Interactive Robot Desk Buddy

This cute little robot interacts with not just you, but also the world around it!

Jul 30, 2026

•

1572 views

•

2 respects

•

GPL3+

Robots

Toys

Kids

Devices & Components

40 colored male-male jumper wires

Arduino Uno Rev3

Modulino™ Distance

16x2 LCD display with I²C interface

10k resistors (x4)

160 ohm resistor

100 ohm resistor

Software & Tools

Tinker cad

Project description

Code

Interactive Robot Desk Buddy Code

cpp

1#include <LiquidCrystal.h>
2
3// Pin defs
4const int BUTTON = 7;   // Tickle button
5const int GAME = 3;     // Minigame button
6const int PR = A5;      // Photoresistor
7const int PIEZO = 2;    // Buzzer
8const int FSR_PIN = A0; // Force Sensor
9
10// Distance sensor pins
11const int TRIG_PIN = 5;
12const int ECHO_PIN = 6;
13
14// LCD Pins
15const int RS = 8;
16const int E = 9;
17const int DB4 = 10;
18const int DB5 = 11;
19const int DB6 = 12;
20const int DB7 = 13;
21
22int prValue;
23int buttonState;
24int lastButtonState = LOW;
25int gameState;
26int buttonCount = 0;
27
28// Timing vars
29unsigned long lastSensorCheck = 0;
30const int sensorInterval = 150; // Check sensors every 150 ms
31
32// Melodies
33int laughNotes[] = { 
34  440, 523, 587, 659, 587, 523 
35};
36int laughDurations[] = { 
37  100, 100, 100, 100, 100, 200 
38};
39int laughLength = 6;
40
41int annoyedNotes[] = { 
42  600, 520, 450, 400 
43};
44int annoyedDurations[] = { 
45  180, 200, 230, 320 
46};
47int annoyedLength = 4;
48
49int sleepNotes[] = { 
50  523, 494, 440, 392, 330 
51};
52int sleepDurations[] = { 
53  200, 220, 250, 300, 500 
54};
55int sleepLength = 5;
56
57int singNotes[] = { 
58  659, 784, 523, 587 
59};
60int singDurations[] = { 
61  150, 150, 150, 300 
62};
63int singLength = 4;
64
65int sleepSingNotes[] = { 
66  440, 494, 523, 494, 440, 392, 440, 392 
67};
68int sleepSingDurations[] = { 
69  180, 180, 220, 180, 180, 200, 180, 220 
70};
71int sleepSingLength = 8;
72
73int awakeNotes[] = { 
74  523, 659, 784, 988, 784, 659 
75};
76int awakeDurations[] = { 
77  120, 120, 150, 170, 150, 200 
78};
79int awakeLength = 6;
80
81int startGameNotes[] = { 
82  659, 784, 988, 1319 
83};
84int startGameDurations[] = { 
85  120, 120, 150, 200 
86};
87int startGameLength = 4;
88
89// Game vars
90int obsPos;        
91bool jumping;
92unsigned long jumpTimer = 0;
93unsigned long jumpDuration = 500;
94int score;
95
96LiquidCrystal lcd(RS, E, DB4, DB5, DB6, DB7);
97
98void setup() {
99  Serial.begin(9600);
100  
101  pinMode(BUTTON, INPUT);
102  pinMode(GAME, INPUT);
103  pinMode(PR, INPUT);
104  pinMode(FSR_PIN, INPUT);
105  pinMode(PIEZO, OUTPUT);
106  
107  pinMode(TRIG_PIN, OUTPUT);
108  pinMode(ECHO_PIN, INPUT);
109
110  lcd.begin(16, 2);
111}
112
113void loop() {
114  prValue = analogRead(PR);
115
116  if (prValue < 932) {
117    while (prValue < 932) {
118      sleep();
119    }
120  } else {
121    // Waking up animation
122    playMelody(awakeNotes, awakeDurations, awakeLength);
123    lcd.setCursor(6, 0);
124    lcd.print("- -       ");
125    lcd.setCursor(7, 1);
126    lcd.print("O         ");
127    delay(1000);
128
129    lcd.setCursor(6, 0);
130    lcd.print("^ ^       ");
131    lcd.setCursor(7, 1);
132    lcd.print("-         ");
133    delay(1000);
134
135    resetFace();
136    delay(1000);
137
138    // Main awake loop
139    while (prValue >= 932) {
140      awake();
141    }
142
143    // Faling asleep animation
144    playMelody(sleepNotes, sleepDurations, sleepLength);
145    lcd.setCursor(6, 0);
146    lcd.print("- -       ");
147    lcd.setCursor(6, 1);
148    lcd.print("\\_/       ");
149    delay(1000);
150
151    lcd.setCursor(6, 0);
152    lcd.print("- -       ");
153    lcd.setCursor(6, 1);
154    lcd.print(" O        ");
155    delay(1000);
156
157    lcd.setCursor(6, 0);
158    lcd.print("- -       ");
159    lcd.setCursor(6, 1);
160    lcd.print(" o        ");
161    delay(1000);
162  }
163}
164
165void awake() {
166  buttonState = digitalRead(BUTTON);
167
168  // Tickle button logic
169  if (buttonState == HIGH && lastButtonState == LOW) {
170    buttonCount++; 
171
172    if (buttonCount <= 3) {
173      lcd.setCursor(6, 0);
174      lcd.print("> < HAHA! ");
175      lcd.setCursor(6, 1);
176      lcd.print("\\_/       ");
177      playMelody(laughNotes, laughDurations, laughLength);
178      resetFace();
179    } else {
180      lcd.setCursor(6, 0);
181      lcd.print("> < STOP! ");
182      lcd.setCursor(6, 1);
183      lcd.print(" ^        ");
184      playMelody(annoyedNotes, annoyedDurations, annoyedLength);
185      delay(500);
186      resetFace();
187    }
188  }
189
190  lastButtonState = buttonState;
191
192  // Sensor checking loop (distance & force)
193  if (millis() - lastSensorCheck > sensorInterval) {
194    lastSensorCheck = millis();
195    
196    int forceValue = analogRead(FSR_PIN);
197    long distance = getDistance();
198
199    // Force sensor priority
200    if (forceValue > 600) {
201      // Hard squeeze / squish
202      lcd.setCursor(6, 0);
203      lcd.print("X X  Owie!");
204      lcd.setCursor(6, 1);
205      lcd.print(" o        ");
206      tone(PIEZO, 150, 200); // Low groan tone
207      delay(300);
208      resetFace();
209    } 
210    else if (forceValue > 100) {
211      // Gentle pet / soft touch
212      lcd.setCursor(6, 0);
213      lcd.print("<3 <3  Aw!");
214      lcd.setCursor(6, 1);
215      lcd.print("  u        ");
216      tone(PIEZO, 1046, 150); // Happy chirp
217      delay(300);
218      resetFace();
219    } 
220    // Distance sensor
221    else if (distance > 0 && distance < 60) {
222      // Too close, invading personal space
223      lcd.setCursor(6, 0);
224      lcd.print("O O  Whoa!");
225      lcd.setCursor(6, 1);
226      lcd.print(" o        ");
227      tone(PIEZO, 988, 100);
228    } 
229    else if (distance >= 60 && distance < 80) {
230      // Noticing user getting close
231      lcd.setCursor(6, 0);
232      lcd.print("o o  Hmm? ");
233      lcd.setCursor(6, 1);
234      lcd.print(" -        ");
235    } 
236    else {
237      // Default happy state
238      resetFace();
239    }
240  }
241
242  // Minigame button
243  gameState = digitalRead(GAME);
244  if (gameState == HIGH) {
245    runGame();
246  }
247
248  // Random singing
249  int chance = random(1, 100); 
250  if (chance == 10) {
251    lcd.setCursor(6, 0);
252    lcd.print("^ ^       ");
253    lcd.setCursor(6, 1);
254    lcd.print(" O   LA LA");
255    playMelody(singNotes, singDurations, singLength);
256    resetFace();
257  }
258
259  prValue = analogRead(PR);
260  delay(30); 
261}
262
263// Helper function - read distance (cm)
264long getDistance() {
265  digitalWrite(TRIG_PIN, LOW);
266  delayMicroseconds(2);
267  digitalWrite(TRIG_PIN, HIGH);
268  delayMicroseconds(10);
269  digitalWrite(TRIG_PIN, LOW);
270
271  long duration = pulseIn(ECHO_PIN, HIGH, 25000); 
272  if (duration == 0) return 100; 
273  return duration * 0.034 / 2;
274}
275
276// Helper function - cleanly reset face & wipe all trailing chars
277void resetFace() {
278  lcd.setCursor(6, 0);
279  lcd.print("^ ^       "); 
280  lcd.setCursor(6, 1);
281  lcd.print("\\_/       ");
282}
283
284void sleep() {
285  lcd.setCursor(6, 0);
286  lcd.print("- -       ");
287  lcd.setCursor(0, 1);
288  lcd.print("                "); 
289  lcd.setCursor(7, 1);
290  lcd.print("-    ");
291  delay(1000);
292
293  lcd.setCursor(6, 0);
294  lcd.print("- -       ");
295  lcd.setCursor(7, 1);
296  lcd.print("o zZ ");
297
298  int chance = random(1, 50); 
299  if (chance == 10) {
300    playMelody(sleepSingNotes, sleepSingDurations, sleepSingLength);
301  }
302
303  delay(1000);
304  prValue = analogRead(PR);
305}
306
307void playMelody(int notes[], int durations[], int length) {
308  for (int i = 0; i < length; i++) {
309    tone(PIEZO, notes[i], durations[i]);
310    delay(durations[i] + 20);
311  }
312  noTone(PIEZO);
313}
314
315void runGame() {
316  lcd.clear();
317
318  obsPos = 15;
319  jumping = false;
320  score = 0;
321
322  delay(500);
323  playMelody(startGameNotes, startGameDurations, startGameLength);
324
325  while (true) {
326    lcd.clear();
327
328    if (digitalRead(GAME) == HIGH && !jumping) {
329      jumping = true;
330      jumpTimer = millis();
331    }
332
333    if (jumping && millis() - jumpTimer > jumpDuration) {
334      jumping = false;
335    }
336
337    if (jumping) {
338      lcd.setCursor(2, 0); 
339      lcd.print("O");
340    } else {
341      lcd.setCursor(2, 1);
342      lcd.print("O");
343    }
344
345    if (obsPos >= 0) {
346      lcd.setCursor(obsPos, 1);
347      lcd.print("/\\");
348    }
349
350    if (!jumping && obsPos == 2) {
351      lcd.clear();
352      lcd.setCursor(4, 0);
353      lcd.print("GAME OVER");
354      lcd.setCursor(4, 1);
355      lcd.print("Score: ");
356      lcd.print(score);
357      playMelody(sleepNotes, sleepDurations, sleepLength);
358      delay(2500);
359      
360      lcd.clear(); 
361      resetFace();
362      return;
363    }
364
365    obsPos--;
366
367    if (obsPos < -1) {
368      obsPos = 15;
369      score++;
370    }
371
372    delay(120);
373  }
374}

#include <LiquidCrystal.h>

// Pin defs
const int BUTTON = 7;   // Tickle button
const int GAME = 3;     // Minigame button
const int PR = A5;      // Photoresistor
const int PIEZO = 2;    // Buzzer
const int FSR_PIN = A0; // Force Sensor

// Distance sensor pins
const int TRIG_PIN = 5;
const int ECHO_PIN = 6;

// LCD Pins
const int RS = 8;
const int E = 9;
const int DB4 = 10;
const int DB5 = 11;
const int DB6 = 12;
const int DB7 = 13;

int prValue;
int buttonState;
int lastButtonState = LOW;
int gameState;
int buttonCount = 0;

// Timing vars
unsigned long lastSensorCheck = 0;
const int sensorInterval = 150; // Check sensors every 150 ms

// Melodies
int laughNotes[] = { 
  440, 523, 587, 659, 587, 523 
};
int laughDurations[] = { 
  100, 100, 100, 100, 100, 200 
};
int laughLength = 6;

int annoyedNotes[] = { 
  600, 520, 450, 400 
};
int annoyedDurations[] = { 
  180, 200, 230, 320 
};
int annoyedLength = 4;

int sleepNotes[] = { 
  523, 494, 440, 392, 330 
};
int sleepDurations[] = { 
  200, 220, 250, 300, 500 
};
int sleepLength = 5;

int singNotes[] = { 
  659, 784, 523, 587 
};
int singDurations[] = { 
  150, 150, 150, 300 
};
int singLength = 4;

int sleepSingNotes[] = { 
  440, 494, 523, 494, 440, 392, 440, 392 
};
int sleepSingDurations[] = { 
  180, 180, 220, 180, 180, 200, 180, 220 
};
int sleepSingLength = 8;

int awakeNotes[] = { 
  523, 659, 784, 988, 784, 659 
};
int awakeDurations[] = { 
  120, 120, 150, 170, 150, 200 
};
int awakeLength = 6;

int startGameNotes[] = { 
  659, 784, 988, 1319 
};
int startGameDurations[] = { 
  120, 120, 150, 200 
};
int startGameLength = 4;

// Game vars
int obsPos;        
bool jumping;
unsigned long jumpTimer = 0;
unsigned long jumpDuration = 500;
int score;

LiquidCrystal lcd(RS, E, DB4, DB5, DB6, DB7);

void setup() {
  Serial.begin(9600);
  
  pinMode(BUTTON, INPUT);
  pinMode(GAME, INPUT);
  pinMode(PR, INPUT);
  pinMode(FSR_PIN, INPUT);
  pinMode(PIEZO, OUTPUT);
  
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);

  lcd.begin(16, 2);
}

void loop() {
  prValue = analogRead(PR);

  if (prValue < 932) {
    while (prValue < 932) {
      sleep();
    }
  } else {
    // Waking up animation
    playMelody(awakeNotes, awakeDurations, awakeLength);
    lcd.setCursor(6, 0);
    lcd.print("- -       ");
    lcd.setCursor(7, 1);
    lcd.print("O         ");
    delay(1000);

    lcd.setCursor(6, 0);
    lcd.print("^ ^       ");
    lcd.setCursor(7, 1);
    lcd.print("-         ");
    delay(1000);

    resetFace();
    delay(1000);

    // Main awake loop
    while (prValue >= 932) {
      awake();
    }

    // Faling asleep animation
    playMelody(sleepNotes, sleepDurations, sleepLength);
    lcd.setCursor(6, 0);
    lcd.print("- -       ");
    lcd.setCursor(6, 1);
    lcd.print("\\_/       ");
    delay(1000);

    lcd.setCursor(6, 0);
    lcd.print("- -       ");
    lcd.setCursor(6, 1);
    lcd.print(" O        ");
    delay(1000);

    lcd.setCursor(6, 0);
    lcd.print("- -       ");
    lcd.setCursor(6, 1);
    lcd.print(" o        ");
    delay(1000);
  }
}

void awake() {
  buttonState = digitalRead(BUTTON);

  // Tickle button logic
  if (buttonState == HIGH && lastButtonState == LOW) {
    buttonCount++; 

    if (buttonCount <= 3) {
      lcd.setCursor(6, 0);
      lcd.print("> < HAHA! ");
      lcd.setCursor(6, 1);
      lcd.print("\\_/       ");
      playMelody(laughNotes, laughDurations, laughLength);
      resetFace();
    } else {
      lcd.setCursor(6, 0);
      lcd.print("> < STOP! ");
      lcd.setCursor(6, 1);
      lcd.print(" ^        ");
      playMelody(annoyedNotes, annoyedDurations, annoyedLength);
      delay(500);
      resetFace();
    }
  }

  lastButtonState = buttonState;

  // Sensor checking loop (distance & force)
  if (millis() - lastSensorCheck > sensorInterval) {
    lastSensorCheck = millis();
    
    int forceValue = analogRead(FSR_PIN);
    long distance = getDistance();

    // Force sensor priority
    if (forceValue > 600) {
      // Hard squeeze / squish
      lcd.setCursor(6, 0);
      lcd.print("X X  Owie!");
      lcd.setCursor(6, 1);
      lcd.print(" o        ");
      tone(PIEZO, 150, 200); // Low groan tone
      delay(300);
      resetFace();
    } 
    else if (forceValue > 100) {
      // Gentle pet / soft touch
      lcd.setCursor(6, 0);
      lcd.print("<3 <3  Aw!");
      lcd.setCursor(6, 1);
      lcd.print("  u        ");
      tone(PIEZO, 1046, 150); // Happy chirp
      delay(300);
      resetFace();
    } 
    // Distance sensor
    else if (distance > 0 && distance < 60) {
      // Too close, invading personal space
      lcd.setCursor(6, 0);
      lcd.print("O O  Whoa!");
      lcd.setCursor(6, 1);
      lcd.print(" o        ");
      tone(PIEZO, 988, 100);
    } 
    else if (distance >= 60 && distance < 80) {
      // Noticing user getting close
      lcd.setCursor(6, 0);
      lcd.print("o o  Hmm? ");
      lcd.setCursor(6, 1);
      lcd.print(" -        ");
    } 
    else {
      // Default happy state
      resetFace();
    }
  }

  // Minigame button
  gameState = digitalRead(GAME);
  if (gameState == HIGH) {
    runGame();
  }

  // Random singing
  int chance = random(1, 100); 
  if (chance == 10) {
    lcd.setCursor(6, 0);
    lcd.print("^ ^       ");
    lcd.setCursor(6, 1);
    lcd.print(" O   LA LA");
    playMelody(singNotes, singDurations, singLength);
    resetFace();
  }

  prValue = analogRead(PR);
  delay(30); 
}

// Helper function - read distance (cm)
long getDistance() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  long duration = pulseIn(ECHO_PIN, HIGH, 25000); 
  if (duration == 0) return 100; 
  return duration * 0.034 / 2;
}

// Helper function - cleanly reset face & wipe all trailing chars
void resetFace() {
  lcd.setCursor(6, 0);
  lcd.print("^ ^       "); 
  lcd.setCursor(6, 1);
  lcd.print("\\_/       ");
}

void sleep() {
  lcd.setCursor(6, 0);
  lcd.print("- -       ");
  lcd.setCursor(0, 1);
  lcd.print("                "); 
  lcd.setCursor(7, 1);
  lcd.print("-    ");
  delay(1000);

  lcd.setCursor(6, 0);
  lcd.print("- -       ");
  lcd.setCursor(7, 1);
  lcd.print("o zZ ");

  int chance = random(1, 50); 
  if (chance == 10) {
    playMelody(sleepSingNotes, sleepSingDurations, sleepSingLength);
  }

  delay(1000);
  prValue = analogRead(PR);
}

void playMelody(int notes[], int durations[], int length) {
  for (int i = 0; i < length; i++) {
    tone(PIEZO, notes[i], durations[i]);
    delay(durations[i] + 20);
  }
  noTone(PIEZO);
}

void runGame() {
  lcd.clear();

  obsPos = 15;
  jumping = false;
  score = 0;

  delay(500);
  playMelody(startGameNotes, startGameDurations, startGameLength);

  while (true) {
    lcd.clear();

    if (digitalRead(GAME) == HIGH && !jumping) {
      jumping = true;
      jumpTimer = millis();
    }

    if (jumping && millis() - jumpTimer > jumpDuration) {
      jumping = false;
    }

    if (jumping) {
      lcd.setCursor(2, 0); 
      lcd.print("O");
    } else {
      lcd.setCursor(2, 1);
      lcd.print("O");
    }

    if (obsPos >= 0) {
      lcd.setCursor(obsPos, 1);
      lcd.print("/\\");
    }

    if (!jumping && obsPos == 2) {
      lcd.clear();
      lcd.setCursor(4, 0);
      lcd.print("GAME OVER");
      lcd.setCursor(4, 1);
      lcd.print("Score: ");
      lcd.print(score);
      playMelody(sleepNotes, sleepDurations, sleepLength);
      delay(2500);
      
      lcd.clear(); 
      resetFace();
      return;
    }

    obsPos--;

    if (obsPos < -1) {
      obsPos = 15;
      score++;
    }

    delay(120);
  }
}

Comments

Only logged in users can leave comments

efrice

0 Followers

•

0 Projects

Intro