Index

1. Pictures and videos
2. Wiring diagram
3. Components list
4. Breadboard
5. Code description
6. Code

Pictures and videos

 

Wiring diagram

Components list

Item:	Quantity:
LED red 3 mm round	6
LED yellow 3 mm round	2
LED white 5 mm white - 26000 mcd	7
Resistor 100 Ohm	4
Resistor 27 Ohm	1
Transistor	1
Micro Motor 2000 rpm	1
Servo 9G	1
ON/OFF-Switch	1
Micro Switch	1
Arduino Nano	1
Breadboard	1
Wire AWG 26 / 0,15 mm2 - different colors	10 m
DuPont connectors	25
Shrink tube	20 cm
USB breakout board	1
USB power bank	1

Breadboard

 

Code description

P.O.S.T. - Power On Self Test for three seconds: 

• On-/Off-switch is on, button is open:
• Servo goes to zero degrees (Transportation mode). 
• Seven white LEDs: switched on
• Two yellow LEDs: switched on
• Six red LEDs: switched on
• Motor: switched on
• Servo: switched on
• 7-Segment-display: testing all LEDs

Mode 1 - Tunnel Scene:

• On-/Off-switch is on, button is open:
• Seven white LEDs: switched off
• two yellow LEDs: switched off
• six red LEDs: switched on, two LEDS parallel from bottom to top, revolving 
• Motor: switched off, dome is not spinning
• Servo: switched on, ears are moving
• 7-Segment-display: random values between 0.00 GeV and 0.99 GeV

See here: https://youtu.be/Ojn4SwfjnVk?t=635

Mode 2 - Statue of Liberty (deleted scene):

• On-/Off-switch is on, button is pressed once (state machine) and open:
• Seven white LEDs: switched on
• two yellow LEDs: switched on
• six red LEDs: switched on, two LEDS parallel from bottom to top, but faster than in paragraph 1
• Motor: switched on, dome is moving
• Servo: switched on, ears are moving
• 7-Segment-display: random values between 1.00 GeV and 1.99 GeV

See here: https://youtu.be/Ojn4SwfjnVk?t=348

 If the button is pressed a second time (Modulo 2) it switches back to the state it was before.

 Mode 3 - First avenue:

• On-/Off-switch is on, button is pressed and stays closed:
• Seven white LEDs: switched on
• Two yellow LEDs: switched on
• Six red LEDs: switched on, two LEDS parallel from bottom to top, but faster than in paragraph 1
• Motor: switched on, dome is moving
• Servo: switched on, goes into an exact angle (ears “listening”).
• 7-Segment-display: 2.50 GeV

See here: https://youtu.be/Ojn4SwfjnVk?t=628

When the button is released it switches to the state it was before.

Code

#include <VarSpeedServo.h>
//#include <SoftwareSerial.h>

// LEDS
const int PIN_LED_RED_TOP = 2;
const int PIN_LED_RED_MIDDLE = 3;
const int PIN_LED_RED_BOTTOM = 4;
const int PIN_LED_YELLOW1 = 6;
const int PIN_LED_YELLOW2 = 6;
const int PIN_LED_WHITE = 6;

// MOVEMENT
const int PIN_MOTOR_BOWL = 6;
const int PIN_SERVO_EARS = 10;
VarSpeedServo servo_ears;

// BUTTON
const int PIN_BUTTON = 5;

int button_val = 0;
int button_val_save = 0;
bool button_pressed = false;
bool button_pressed_entprellt = false;
unsigned long button_millis_delay = 1000;
unsigned long button_millis_save = millis();
bool button_recently_switched = false;

// MODE
bool mode_ears = true;

// EARS
const int EAR_MOVE_SPEED = 100;
const int EAR_POS_CLOSED = 90;
const int EAR_POS_OPEN = 0;
const int EAR_POS_WAIT = 70;
bool ear_is_closed = true;

int ear_light_pos = 0;

// EARS TIME
unsigned long millis_current = 0;
unsigned long ear_pos_millis_delay = 500;
unsigned long ear_pos_millis_save = millis();
unsigned long ear_light_millis_save = millis();
unsigned long ear_light_millis_delay_slow = 300;
unsigned long ear_light_millis_delay_fast = 50;
unsigned long ear_light_millis_delay = ear_light_millis_delay_slow;

 

// 7-SEGMENT-DISPLAY
// Used Analog IO: A4, A5
const int DISPLAY_DI = A4;
const int DISPLAY_CLK = A5;
const long DISPLAY_DELAY = 1100;
const long DISPLAY_DELAY_SNAKE = 100;
unsigned long display_millis_save = millis(); //Display LastUpdated Variable
// unsigned long millis_current = 0; //Current Time
//Display Digits Conversion Table
const byte DEC_DIGITS[] = {0b11111100, 0b01100000, 0b11011010, 0b11110010, 0b01100110, 0b10110110, 0b10111110, 0b11100000, 0b11111110, 0b11110110};
const byte DEC_DIGITS_PERIOD[] = {0b11111101, 0b01100001, 0b11011011, 0b11110011, 0b01100111, 0b10110111, 0b10111111, 0b11100001, 0b11111111, 0b11110111};
const byte DEC_SNAKE[] = {0b10000000, 0b10000000, 0b10000000, 0b01000000, 0b00100000, 0b00010000, 0b00010000, 0b00010000, 0b00001000, 0b00000100 };
const int SNAKE_POS[] = {0, 1, 2, 2, 2, 2, 1, 0, 0, 0};

int snake_counter = 0;
unsigned long startup_time_save = millis();

const bool DISPLAY_STARTUP_CUSTOM_MESSAGE = false;
const byte DISPALY_STARTUP_CUSTOM_MESSAGE_POSITON_1 = 0b10011100;
const byte DISPALY_STARTUP_CUSTOM_MESSAGE_POSITON_2 = 0b00000000;
const byte DISPALY_STARTUP_CUSTOM_MESSAGE_POSITON_3 = 0b00011100;

// 1. 0b10000000 top
// 2. 0b01000000 top right
// 3. 0b00100000 bottom right
// 4. 0b00010000 bottom
// 5. 0b00001000 bottom left
// 6. 0b00000100 top left
// 7. 0b00000010 middle
// 8. 0b00000001 decimal point

unsigned int display_position_1 = 0;
unsigned int display_position_2 = 0;
unsigned int display_position_3 = 0;

////////////////////////////
// IMPORTANT: START DELAY
const long START_DELAY = 3000;
////////////////////////////

////////////////////////////
// IMPORTANT: LOOP DELAY
const long LOOP_DELAY = 50;
////////////////////////////

// SWITCH MODE
void get_mode() {
button_val = digitalRead(PIN_BUTTON);
if (button_val == LOW) {
if (button_pressed_entprellt == false) {
mode_ears = !mode_ears;
button_millis_save = millis_current;
button_pressed_entprellt = true;
}
if ((unsigned long)(millis_current - button_millis_save) >=
button_millis_delay) {
button_millis_save = millis_current;
button_pressed = true;
}
} else {
button_pressed = false;
button_pressed_entprellt = false;
}

if (button_val != button_val_save) {
button_recently_switched = true;
}

// SPEED UP IF ALERTING
if (!mode_ears || button_pressed) {
ear_light_millis_delay = ear_light_millis_delay_fast;
} else {
ear_light_millis_delay = ear_light_millis_delay_slow;
}
button_val_save = button_val;
}

// SET EARS LIGHT
void ears_light() {
ear_light_pos++;
switch (ear_light_pos) {
case 1:
digitalWrite(PIN_LED_RED_BOTTOM, HIGH);
digitalWrite(PIN_LED_RED_MIDDLE, LOW);
digitalWrite(PIN_LED_RED_TOP, LOW);
break;
case 2:
digitalWrite(PIN_LED_RED_BOTTOM, LOW);
digitalWrite(PIN_LED_RED_MIDDLE, HIGH);
digitalWrite(PIN_LED_RED_TOP, LOW);
break;
case 3:
digitalWrite(PIN_LED_RED_BOTTOM, LOW);
digitalWrite(PIN_LED_RED_MIDDLE, LOW);
digitalWrite(PIN_LED_RED_TOP, HIGH);
ear_light_pos = 0;

break;
}
}

// SET EARS POS (CLOSED WHEN NOT EAR MODE)
void ears_pos() {
if (!button_pressed) {
if (ear_is_closed) {
if (!servo_ears.isMoving()) {
servo_ears.write(EAR_POS_OPEN, EAR_MOVE_SPEED);
ear_is_closed = false;
}
} else if (!servo_ears.isMoving()) {
servo_ears.write(EAR_POS_CLOSED, EAR_MOVE_SPEED);
ear_is_closed = true;
}
} else {
// ALWAYS OPEN EARS WHEN EARS NOT MOVING
if (!servo_ears.isMoving()) {
servo_ears.write(EAR_POS_WAIT, EAR_MOVE_SPEED);
ear_is_closed = true;
}
}
}

// ALERT MODE
void alert_mode() {
if (!mode_ears || button_pressed) {
digitalWrite(PIN_MOTOR_BOWL, HIGH);
digitalWrite(PIN_LED_WHITE, HIGH);
} else {
digitalWrite(PIN_MOTOR_BOWL, LOW);
digitalWrite(PIN_LED_WHITE, LOW);
}
}

void startup_display() {
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 00000001); //A 1 to start the display.

if (DISPLAY_STARTUP_CUSTOM_MESSAGE) {
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, DISPALY_STARTUP_CUSTOM_MESSAGE_POSITON_1);
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, DISPALY_STARTUP_CUSTOM_MESSAGE_POSITON_2);
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, DISPALY_STARTUP_CUSTOM_MESSAGE_POSITON_3);
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 11000000); //Bit 25 & 26 Enable (Power LED's) Only, Pin 4 & 5
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 00000000); //Don't need a whole byte, but this clocks in the last bits needed to get the display to auto latch (33, 34, 35) and 5 extra zeroes.
} else if ((unsigned long)(millis_current - display_millis_save) >= DISPLAY_DELAY_SNAKE) {
display_millis_save = millis_current; //Update Timer
switch (SNAKE_POS[snake_counter]) {
case 0:
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, DEC_SNAKE[snake_counter]);
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 0b00000000); // EMPTY
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 0b00000000); // EMPTY
break;
case 1:
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 0b00000000); // EMPTY
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, DEC_SNAKE[snake_counter]);
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 0b00000000); // EMPTY
break;
case 2:
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 0b00000000); // EMPTY
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 0b00000000); // EMPTY
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, DEC_SNAKE[snake_counter]);
break;
}
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 11000000); //Bit 25 & 26 Enable (Power LED's) Only, Pin 4 & 5
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 00000000); //Don't need a whole byte, but this clocks in the last bits needed to get the display to auto latch (33, 34, 35) and 5 extra zeroes.
snake_counter = snake_counter + 1;
snake_counter = snake_counter % 10;
}
}

 

void run_display() {
if ((unsigned long)(millis_current - display_millis_save) >= DISPLAY_DELAY) {
display_millis_save = millis_current; //Update Timer

if (button_pressed_entprellt) {
display_position_1 = 2; //Update Digit 1 Random Number
display_position_2 = 5; //Digit 2
display_position_3 = 0; //Digit 3
} else if (mode_ears) {
display_position_1 = 0; //Update Digit 1 Random Number
display_position_2 = random(0, 9); //Digit 2
display_position_3 = random(0, 9); //Digit 3
} else {
display_position_1 = 1; //Update Digit 1 Random Number
display_position_2 = random(0, 9); //Digit 2
display_position_3 = random(0, 9); //Digit 3
}

shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 00000001); //A 1 to start the display.

shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, DEC_DIGITS_PERIOD[display_position_1]); //Shift out random digit 1 with a period trailing.
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, DEC_DIGITS[display_position_2]); //Shift out random digit 2 .
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, DEC_DIGITS[display_position_3]); //Shift out random digit 3.

shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 11000000); //Bit 25 & 26 Enable (Power LED's) Only, Pin 4 & 5
shiftOut(DISPLAY_DI, DISPLAY_CLK, MSBFIRST, 00000000); //Don't need a whole byte, but this clocks in the last bits needed to get the display to auto latch (33, 34, 35) and 5 extra zeroes.
}
}

// SETUP
void setup() {
// 7-SEGMENT-DISPLAY
pinMode(DISPLAY_DI, OUTPUT);
pinMode(DISPLAY_CLK, OUTPUT);
digitalWrite(DISPLAY_DI, LOW);
digitalWrite(DISPLAY_CLK, HIGH);

// LIGHT
pinMode(PIN_LED_RED_TOP, OUTPUT);
pinMode(PIN_LED_RED_MIDDLE, OUTPUT);
pinMode(PIN_LED_RED_BOTTOM, OUTPUT);
pinMode(PIN_LED_YELLOW1, OUTPUT);
pinMode(PIN_LED_YELLOW2, OUTPUT);
pinMode(PIN_LED_WHITE, OUTPUT);

pinMode(PIN_BUTTON, INPUT);
digitalWrite(PIN_BUTTON, HIGH);

servo_ears.attach(PIN_SERVO_EARS);
servo_ears.write(EAR_POS_CLOSED, EAR_MOVE_SPEED);

// START POWER ON SELFTEST LIGHTS
// DISABLE IF NEEDED
digitalWrite(PIN_LED_RED_TOP, HIGH);
digitalWrite(PIN_LED_RED_MIDDLE, HIGH);
digitalWrite(PIN_LED_RED_BOTTOM, HIGH);
digitalWrite(PIN_LED_YELLOW1, HIGH);
digitalWrite(PIN_LED_YELLOW2, HIGH);
digitalWrite(PIN_LED_WHITE, HIGH);
// END POWER ON SELFTEST LIGHTS

// START POWER ON SELFTEST DISPLAY
// DO NOT DISABLE LOOP!
while ((unsigned long)(millis_current - startup_time_save) <= START_DELAY) {
millis_current = millis();

// ONLY DISABLE THIS LINE FOR DISABLING POWER ON SELFTEST DISPLAY
startup_display();

delay(DISPLAY_DELAY_SNAKE);
delay(1);
}
// END POWER ON SELFTEST DISPLAY
}

// RUN
void loop() {
millis_current = millis();

// Get Mode
get_mode();

// Ear lights
if ((unsigned long)(millis_current - ear_light_millis_save) >=
ear_light_millis_delay) {
ear_light_millis_save = millis_current;
ears_light();
}

// Ear movement
if ((unsigned long)(millis_current - ear_pos_millis_save) >=
ear_pos_millis_delay) {
ear_pos_millis_save = millis_current;
ears_pos();
}

alert_mode();
//sound();

run_display();

delay(LOOP_DELAY);
}