1
0

New Code / Cleanup

This commit is contained in:
Lars H 2017-11-20 12:39:45 +01:00
parent 34ca1c5e01
commit ae96447a6e
5 changed files with 864 additions and 0 deletions

484
Hippie.cpp Normal file
View File

@ -0,0 +1,484 @@
#include "Arduino.h"
#include "Hippie.h"
#include <Oscillator.h>
void Hippie::init(int YL, int YR, int RL, int RR, int Buzzer) {
servo_pins[0] = YL;
servo_pins[1] = YR;
servo_pins[2] = RL;
servo_pins[3] = RR;
attachServos();
isHippieResting=false;
for (int i = 0; i < 4; i++) servo_position[i] = 90;
//Buzzer & noise sensor pins:
pinBuzzer = Buzzer;
pinMode(Buzzer,OUTPUT);
}
///////////////////////////////////////////////////////////////////
//-- ATTACH & DETACH FUNCTIONS ----------------------------------//
///////////////////////////////////////////////////////////////////
void Hippie::attachServos(){
servo[0].attach(servo_pins[0]);
servo[1].attach(servo_pins[1]);
servo[2].attach(servo_pins[2]);
servo[3].attach(servo_pins[3]);
}
void Hippie::detachServos(){
servo[0].detach();
servo[1].detach();
servo[2].detach();
servo[3].detach();
}
///////////////////////////////////////////////////////////////////
//-- BASIC MOTION FUNCTIONS -------------------------------------//
///////////////////////////////////////////////////////////////////
void Hippie::_moveServos(int time, int servo_target[]) {
attachServos();
if(getRestState()==true){
setRestState(false);
}
if(time>10){
for (int i = 0; i < 4; i++) increment[i] = ((servo_target[i]) - servo_position[i]) / (time / 10.0);
final_time = millis() + time;
for (int iteration = 1; millis() < final_time; iteration++) {
partial_time = millis() + 10;
for (int i = 0; i < 4; i++) servo[i].SetPosition(servo_position[i] + (iteration * increment[i]));
while (millis() < partial_time); //pause
}
}
else{
for (int i = 0; i < 4; i++) servo[i].SetPosition(servo_target[i]);
}
for (int i = 0; i < 4; i++) servo_position[i] = servo_target[i];
}
void Hippie::oscillateServos(int A[4], int O[4], int T, double phase_diff[4], float cycle=1){
for (int i=0; i<4; i++) {
servo[i].SetO(O[i]);
servo[i].SetA(A[i]);
servo[i].SetT(T);
servo[i].SetPh(phase_diff[i]);
}
double ref=millis();
for (double x=ref; x<=T*cycle+ref; x=millis()){
for (int i=0; i<4; i++){
servo[i].refresh();
}
}
}
void Hippie::_execute(int A[4], int O[4], int T, double phase_diff[4], float steps = 1.0){
attachServos();
if(getRestState()==true){
setRestState(false);
}
int cycles=(int)steps;
//-- Execute complete cycles
if (cycles >= 1)
for(int i = 0; i < cycles; i++)
oscillateServos(A,O, T, phase_diff);
//-- Execute the final not complete cycle
oscillateServos(A,O, T, phase_diff,(float)steps-cycles);
}
///////////////////////////////////////////////////////////////////
//-- HOME = Hippie at rest position -------------------------------//
///////////////////////////////////////////////////////////////////
void Hippie::home(){
if(isHippieResting==false){ //Go to rest position only if necessary
int homes[4]={90, 90, 90, 90}; //All the servos at rest position
_moveServos(500,homes); //Move the servos in half a second
detachServos();
isHippieResting=true;
}
}
bool Hippie::getRestState(){
return isHippieResting;
}
void Hippie::setRestState(bool state){
isHippieResting = state;
}
///////////////////////////////////////////////////////////////////
//-- PREDETERMINED MOTION SEQUENCES -----------------------------//
///////////////////////////////////////////////////////////////////
//---------------------------------------------------------
//-- Hippie movement: Jump
//-- Parameters:
//-- steps: Number of steps
//-- T: Period
//---------------------------------------------------------
void Hippie::jump(float steps, int T){
int up[]={90,90,150,30};
_moveServos(T,up);
int down[]={90,90,90,90};
_moveServos(T,down);
}
//---------------------------------------------------------
//-- Hippie gait: Walking (forward or backward)
//-- Parameters:
//-- * steps: Number of steps
//-- * T : Period
//-- * Dir: Direction: FORWARD / BACKWARD
//---------------------------------------------------------
void Hippie::walk(float steps, int T, int dir){
//-- Oscillator parameters for walking
//-- Hip sevos are in phase
//-- Feet servos are in phase
//-- Hip and feet are 90 degrees out of phase
//-- -90 : Walk forward
//-- 90 : Walk backward
//-- Feet servos also have the same offset (for tiptoe a little bit)
int A[4]= {30, 30, 20, 20};
int O[4] = {0, 0, 4, -4};
double phase_diff[4] = {0, 0, DEG2RAD(dir * -90), DEG2RAD(dir * -90)};
//-- Let's oscillate the servos!
_execute(A, O, T, phase_diff, steps);
}
//---------------------------------------------------------
//-- Hippie gait: Turning (left or right)
//-- Parameters:
//-- * Steps: Number of steps
//-- * T: Period
//-- * Dir: Direction: LEFT / RIGHT
//---------------------------------------------------------
void Hippie::turn(float steps, int T, int dir){
//-- Same coordination than for walking (see Hippie::walk)
//-- The Amplitudes of the hip's oscillators are not igual
//-- When the right hip servo amplitude is higher, the steps taken by
//-- the right leg are bigger than the left. So, the robot describes an
//-- left arc
int A[4]= {30, 30, 20, 20};
int O[4] = {0, 0, 4, -4};
double phase_diff[4] = {0, 0, DEG2RAD(-90), DEG2RAD(-90)};
if (dir == LEFT) {
A[0] = 30; //-- Left hip servo
A[1] = 10; //-- Right hip servo
}
else {
A[0] = 10;
A[1] = 30;
}
//-- Let's oscillate the servos!
_execute(A, O, T, phase_diff, steps);
}
//---------------------------------------------------------
//-- Hippie gait: Lateral bend
//-- Parameters:
//-- steps: Number of bends
//-- T: Period of one bend
//-- dir: RIGHT=Right bend LEFT=Left bend
//---------------------------------------------------------
void Hippie::bend (int steps, int T, int dir){
//Parameters of all the movements. Default: Left bend
int bend1[4]={90, 90, 62, 35};
int bend2[4]={90, 90, 62, 105};
int homes[4]={90, 90, 90, 90};
//Time of one bend, constrained in order to avoid movements too fast.
//T=max(T, 600);
//Changes in the parameters if right direction is chosen
if(dir==-1)
{
bend1[2]=180-35;
bend1[3]=180-60; //Not 65. Hippie is unbalanced
bend2[2]=180-105;
bend2[3]=180-60;
}
//Time of the bend movement. Fixed parameter to avoid falls
int T2=800;
//Bend movement
for (int i=0;i<steps;i++)
{
_moveServos(T2/2,bend1);
_moveServos(T2/2,bend2);
delay(T*0.8);
_moveServos(500,homes);
}
}
//---------------------------------------------------------
//-- Hippie gait: Shake a leg
//-- Parameters:
//-- steps: Number of shakes
//-- T: Period of one shake
//-- dir: RIGHT=Right leg LEFT=Left leg
//---------------------------------------------------------
void Hippie::shakeLeg (int steps,int T,int dir){
//This variable change the amount of shakes
int numberLegMoves=2;
//Parameters of all the movements. Default: Right leg
int shake_leg1[4]={90, 90, 58, 35};
int shake_leg2[4]={90, 90, 58, 120};
int shake_leg3[4]={90, 90, 58, 60};
int homes[4]={90, 90, 90, 90};
//Changes in the parameters if left leg is chosen
if(dir==-1)
{
shake_leg1[2]=180-35;
shake_leg1[3]=180-58;
shake_leg2[2]=180-120;
shake_leg2[3]=180-58;
shake_leg3[2]=180-60;
shake_leg3[3]=180-58;
}
//Time of the bend movement. Fixed parameter to avoid falls
int T2=1000;
//Time of one shake, constrained in order to avoid movements too fast.
T=T-T2;
T=max(T,200*numberLegMoves);
for (int j=0; j<steps;j++)
{
//Bend movement
_moveServos(T2/2,shake_leg1);
_moveServos(T2/2,shake_leg2);
//Shake movement
for (int i=0;i<numberLegMoves;i++)
{
_moveServos(T/(2*numberLegMoves),shake_leg3);
_moveServos(T/(2*numberLegMoves),shake_leg2);
}
_moveServos(500,homes); //Return to home position
}
delay(T);
}
//---------------------------------------------------------
//-- Hippie movement: up & down
//-- Parameters:
//-- * steps: Number of jumps
//-- * T: Period
//-- * h: Jump height: SMALL / MEDIUM / BIG
//-- (or a number in degrees 0 - 90)
//---------------------------------------------------------
void Hippie::updown(float steps, int T, int h){
//-- Both feet are 180 degrees out of phase
//-- Feet amplitude and offset are the same
//-- Initial phase for the right foot is -90, so that it starts
//-- in one extreme position (not in the middle)
int A[4]= {0, 0, h, h};
int O[4] = {0, 0, h, -h};
double phase_diff[4] = {0, 0, DEG2RAD(-90), DEG2RAD(90)};
//-- Let's oscillate the servos!
_execute(A, O, T, phase_diff, steps);
}
//---------------------------------------------------------
//-- Hippie movement: swinging side to side
//-- Parameters:
//-- steps: Number of steps
//-- T : Period
//-- h : Amount of swing (from 0 to 50 aprox)
//---------------------------------------------------------
void Hippie::swing(float steps, int T, int h){
//-- Both feets are in phase. The offset is half the amplitude
//-- It causes the robot to swing from side to side
int A[4]= {0, 0, h, h};
int O[4] = {0, 0, h/2, -h/2};
double phase_diff[4] = {0, 0, DEG2RAD(0), DEG2RAD(0)};
//-- Let's oscillate the servos!
_execute(A, O, T, phase_diff, steps);
}
//---------------------------------------------------------
//-- Hippie movement: swinging side to side without touching the floor with the heel
//-- Parameters:
//-- steps: Number of steps
//-- T : Period
//-- h : Amount of swing (from 0 to 50 aprox)
//---------------------------------------------------------
void Hippie::tiptoeSwing(float steps, int T, int h){
//-- Both feets are in phase. The offset is not half the amplitude in order to tiptoe
//-- It causes the robot to swing from side to side
int A[4]= {0, 0, h, h};
int O[4] = {0, 0, h, -h};
double phase_diff[4] = {0, 0, 0, 0};
//-- Let's oscillate the servos!
_execute(A, O, T, phase_diff, steps);
}
//---------------------------------------------------------
//-- Hippie gait: Jitter
//-- Parameters:
//-- steps: Number of jitters
//-- T: Period of one jitter
//-- h: height (Values between 5 - 25)
//---------------------------------------------------------
void Hippie::jitter(float steps, int T, int h){
//-- Both feet are 180 degrees out of phase
//-- Feet amplitude and offset are the same
//-- Initial phase for the right foot is -90, so that it starts
//-- in one extreme position (not in the middle)
//-- h is constrained to avoid hit the feets
h=min(25,h);
int A[4]= {h, h, 0, 0};
int O[4] = {0, 0, 0, 0};
double phase_diff[4] = {DEG2RAD(-90), DEG2RAD(90), 0, 0};
//-- Let's oscillate the servos!
_execute(A, O, T, phase_diff, steps);
}
//---------------------------------------------------------
//-- Hippie gait: Ascending & turn (Jitter while up&down)
//-- Parameters:
//-- steps: Number of bends
//-- T: Period of one bend
//-- h: height (Values between 5 - 15)
//---------------------------------------------------------
void Hippie::ascendingTurn(float steps, int T, int h){
//-- Both feet and legs are 180 degrees out of phase
//-- Initial phase for the right foot is -90, so that it starts
//-- in one extreme position (not in the middle)
//-- h is constrained to avoid hit the feets
h=min(13,h);
int A[4]= {h, h, h, h};
int O[4] = {0, 0, h+4, -h+4};
double phase_diff[4] = {DEG2RAD(-90), DEG2RAD(90), DEG2RAD(-90), DEG2RAD(90)};
//-- Let's oscillate the servos!
_execute(A, O, T, phase_diff, steps);
}
//---------------------------------------------------------
//-- Hippie gait: Moonwalker. Hippie moves like Michael Jackson
//-- Parameters:
//-- Steps: Number of steps
//-- T: Period
//-- h: Height. Typical valures between 15 and 40
//-- dir: Direction: LEFT / RIGHT
//---------------------------------------------------------
void Hippie::moonwalker(float steps, int T, int h, int dir){
//-- This motion is similar to that of the caterpillar robots: A travelling
//-- wave moving from one side to another
//-- The two Hippie's feet are equivalent to a minimal configuration. It is known
//-- that 2 servos can move like a worm if they are 120 degrees out of phase
//-- In the example of Hippie, the two feet are mirrored so that we have:
//-- 180 - 120 = 60 degrees. The actual phase difference given to the oscillators
//-- is 60 degrees.
//-- Both amplitudes are equal. The offset is half the amplitud plus a little bit of
//- offset so that the robot tiptoe lightly
int A[4]= {0, 0, h, h};
int O[4] = {0, 0, h/2+2, -h/2 -2};
int phi = -dir * 90;
double phase_diff[4] = {0, 0, DEG2RAD(phi), DEG2RAD(-60 * dir + phi)};
//-- Let's oscillate the servos!
_execute(A, O, T, phase_diff, steps);
}
//----------------------------------------------------------
//-- Hippie gait: Crusaito. A mixture between moonwalker and walk
//-- Parameters:
//-- steps: Number of steps
//-- T: Period
//-- h: height (Values between 20 - 50)
//-- dir: Direction: LEFT / RIGHT
//-----------------------------------------------------------
void Hippie::crusaito(float steps, int T, int h, int dir){
int A[4]= {25, 25, h, h};
int O[4] = {0, 0, h/2+ 4, -h/2 - 4};
double phase_diff[4] = {90, 90, DEG2RAD(0), DEG2RAD(-60 * dir)};
//-- Let's oscillate the servos!
_execute(A, O, T, phase_diff, steps);
}
//---------------------------------------------------------
//-- Hippie gait: Flapping
//-- Parameters:
//-- steps: Number of steps
//-- T: Period
//-- h: height (Values between 10 - 30)
//-- dir: direction: FOREWARD, BACKWARD
//---------------------------------------------------------
void Hippie::flapping(float steps, int T, int h, int dir){
int A[4]= {12, 12, h, h};
int O[4] = {0, 0, h - 10, -h + 10};
double phase_diff[4] = {DEG2RAD(0), DEG2RAD(180), DEG2RAD(-90 * dir), DEG2RAD(90 * dir)};
//-- Let's oscillate the servos!
_execute(A, O, T, phase_diff, steps);
}

90
Hippie.h Normal file
View File

@ -0,0 +1,90 @@
#ifndef Hippie_h
#define Hippie_h
#include <ESP32_Servo.h>
#include <Oscillator.h>
#include "Hippie_mouths.h"
#include "Hippie_sounds.h"
#include "Hippie_gestures.h"
//-- Constants
#define FORWARD 1
#define BACKWARD -1
#define LEFT 1
#define RIGHT -1
#define SMALL 5
#define MEDIUM 15
#define BIG 30
#define PIN_Buzzer 10
#define PIN_Trigger 8
#define PIN_Echo 9
#define PIN_NoiseSensor A6
class Hippie
{
public:
//-- Hippie initialization
void init(int YL, int YR, int RL, int RR, int Buzzer=PIN_Buzzer);
//-- Attach & detach functions
void attachServos();
void detachServos();
//-- Predetermined Motion Functions
void _moveServos(int time, int servo_target[]);
void oscillateServos(int A[4], int O[4], int T, double phase_diff[4], float cycle);
//-- HOME = Hippie at rest position
void home();
bool getRestState();
void setRestState(bool state);
//-- Predetermined Motion Functions
void jump(float steps=1, int T = 2000);
void walk(float steps=4, int T=1000, int dir = FORWARD);
void turn(float steps=4, int T=2000, int dir = LEFT);
void bend (int steps=1, int T=1400, int dir=LEFT);
void shakeLeg (int steps=1, int T = 2000, int dir=RIGHT);
void updown(float steps=1, int T=1000, int h = 20);
void swing(float steps=1, int T=1000, int h=20);
void tiptoeSwing(float steps=1, int T=900, int h=20);
void jitter(float steps=1, int T=500, int h=20);
void ascendingTurn(float steps=1, int T=900, int h=20);
void moonwalker(float steps=1, int T=900, int h=20, int dir=LEFT);
void crusaito(float steps=1, int T=900, int h=20, int dir=FORWARD);
void flapping(float steps=1, int T=1000, int h=20, int dir=FORWARD);
private:
Oscillator servo[4];
int servo_pins[4];
int servo_trim[4];
int servo_position[4];
int pinBuzzer;
unsigned long final_time;
unsigned long partial_time;
float increment[4];
bool isHippieResting;
void _execute(int A[4], int O[4], int T, double phase_diff[4], float steps);
};
#endif

70
Hippie_gestures.h Normal file
View File

@ -0,0 +1,70 @@
#ifndef Zowi_gestures_h
#define Zowi_gestures_h
//***********************************************************************************
//*********************************GESTURE DEFINES***********************************
//***********************************************************************************
#define ZowiHappy 0
#define ZowiSuperHappy 1
#define ZowiSad 2
#define ZowiSleeping 3
#define ZowiFart 4
#define ZowiConfused 5
#define ZowiLove 6
#define ZowiAngry 7
#define ZowiFretful 8
#define ZowiMagic 9
#define ZowiWave 10
#define ZowiVictory 11
#define ZowiFail 12
//*** MOUTH ANIMATIONS***
#define littleUuh 0
#define dreamMouth 1
#define adivinawi 2
#define wave 3
// unsigned long int littleUuh_code[]={
// 0b00000000000000001100001100000000,
// 0b00000000000000000110000110000000,
// 0b00000000000000000011000011000000,
// 0b00000000000000000110000110000000,
// 0b00000000000000001100001100000000,
// 0b00000000000000011000011000000000,
// 0b00000000000000110000110000000000,
// 0b00000000000000011000011000000000
// };
// unsigned long int dreamMouth_code[]={
// 0b00000000000000000000110000110000,
// 0b00000000000000010000101000010000,
// 0b00000000011000100100100100011000,
// 0b00000000000000010000101000010000
// };
// unsigned long int adivinawi_code[]={
// 0b00100001000000000000000000100001,
// 0b00010010100001000000100001010010,
// 0b00001100010010100001010010001100,
// 0b00000000001100010010001100000000,
// 0b00000000000000001100000000000000,
// 0b00000000000000000000000000000000
// };
// unsigned long int wave_code[]={
// 0b00001100010010100001000000000000,
// 0b00000110001001010000100000000000,
// 0b00000011000100001000010000100000,
// 0b00000001000010000100001000110000,
// 0b00000000000001000010100100011000,
// 0b00000000000000100001010010001100,
// 0b00000000100000010000001001000110,
// 0b00100000010000001000000100000011,
// 0b00110000001000000100000010000001,
// 0b00011000100100000010000001000000
// };
#endif

87
Hippie_mouths.h Normal file
View File

@ -0,0 +1,87 @@
#ifndef Zowi_mouths_h
#define Zowi_mouths_h
//***********************************************************************************
//*********************************MOUTHS DEFINES************************************
//***********************************************************************************
#define zero_code 0b00001100010010010010010010001100
#define one_code 0b00000100001100000100000100001110
#define two_code 0b00001100010010000100001000011110
#define three_code 0b00001100010010000100010010001100
#define four_code 0b00010010010010011110000010000010
#define five_code 0b00011110010000011100000010011100
#define six_code 0b00000100001000011100010010001100
#define seven_code 0b00011110000010000100001000010000
#define eight_code 0b00001100010010001100010010001100
#define nine_code 0b00001100010010001110000010001110
#define smile_code 0b00000000100001010010001100000000
#define happyOpen_code 0b00000000111111010010001100000000
#define happyClosed_code 0b00000000111111011110000000000000
#define heart_code 0b00010010101101100001010010001100
#define bigSurprise_code 0b00001100010010100001010010001100
#define smallSurprise_code 0b00000000000000001100001100000000
#define tongueOut_code 0b00111111001001001001000110000000
#define vamp1_code 0b00111111101101101101010010000000
#define vamp2_code 0b00111111101101010010000000000000
#define lineMouth_code 0b00000000000000111111000000000000
#define confused_code 0b00000000001000010101100010000000
#define diagonal_code 0b00100000010000001000000100000010
#define sad_code 0b00000000001100010010100001000000
#define sadOpen_code 0b00000000001100010010111111000000
#define sadClosed_code 0b00000000001100011110110011000000
#define okMouth_code 0b00000001000010010100001000000000
#define xMouth_code 0b00100001010010001100010010100001
#define interrogation_code 0b00001100010010000100000100000100
#define thunder_code 0b00000100001000011100001000010000
#define culito_code 0b00000000100001101101010010000000
#define angry_code 0b00000000011110100001100001000000
//Mouths sorted by numbers, and after, by happy to sad mouths
#define zero 0
#define one 1
#define two 2
#define three 3
#define four 4
#define five 5
#define six 6
#define seven 7
#define eight 8
#define nine 9
#define smile 10
#define happyOpen 11
#define happyClosed 12
#define heart 13
#define bigSurprise 14
#define smallSurprise 15
#define tongueOut 16
#define vamp1 17
#define vamp2 18
#define lineMouth 19
#define confused 20
#define diagonal 21
#define sad 22
#define sadOpen 23
#define sadClosed 24
#define okMouth 25
#define xMouth 26
#define interrogation 27
#define thunder 28
#define culito 29
#define angry 30
#endif

133
Hippie_sounds.h Normal file
View File

@ -0,0 +1,133 @@
#ifndef Zowi_sounds_h
#define Zowi_sounds_h
//***********************************************************************************
//*********************************SOUNDS DEFINES************************************
//***********************************************************************************
// Reference: This list was adapted from the table located here:
// http://www.phy.mtu.edu/~suits/notefreqs.html
#define note_C0 16.35 //C0
#define note_Db0 17.32 //C#0/Db0
#define note_D0 18.35 //D0
#define note_Eb0 19.45 //D#0/Eb0
#define note_E0 20.6 //E0
#define note_F0 21.83 //F0
#define note_Gb0 23.12 //F#0/Gb0
#define note_G0 24.5 //G0
#define note_Ab0 25.96 //G#0/Ab0
#define note_A0 27.5 //A0
#define note_Bb0 29.14 //A#0/Bb0
#define note_B0 30.87 //B0
#define note_C1 32.7 //C1
#define note_Db1 34.65 //C#1/Db1
#define note_D1 36.71 //D1
#define note_Eb1 38.89 //D#1/Eb1
#define note_E1 41.2 //E1
#define note_F1 43.65 //F1
#define note_Gb1 46.25 //F#1/Gb1
#define note_G1 49 //G1
#define note_Ab1 51.91 //G#1/Ab1
#define note_A1 55 //A1
#define note_Bb1 58.27 //A#1/Bb1
#define note_B1 61.74 //B1
#define note_C2 65.41 //C2 (Middle C)
#define note_Db2 69.3 //C#2/Db2
#define note_D2 73.42 //D2
#define note_Eb2 77.78 //D#2/Eb2
#define note_E2 82.41 //E2
#define note_F2 87.31 //F2
#define note_Gb2 92.5 //F#2/Gb2
#define note_G2 98 //G2
#define note_Ab2 103.83 //G#2/Ab2
#define note_A2 110 //A2
#define note_Bb2 116.54 //A#2/Bb2
#define note_B2 123.47 //B2
#define note_C3 130.81 //C3
#define note_Db3 138.59 //C#3/Db3
#define note_D3 146.83 //D3
#define note_Eb3 155.56 //D#3/Eb3
#define note_E3 164.81 //E3
#define note_F3 174.61 //F3
#define note_Gb3 185 //F#3/Gb3
#define note_G3 196 //G3
#define note_Ab3 207.65 //G#3/Ab3
#define note_A3 220 //A3
#define note_Bb3 233.08 //A#3/Bb3
#define note_B3 246.94 //B3
#define note_C4 261.63 //C4
#define note_Db4 277.18 //C#4/Db4
#define note_D4 293.66 //D4
#define note_Eb4 311.13 //D#4/Eb4
#define note_E4 329.63 //E4
#define note_F4 349.23 //F4
#define note_Gb4 369.99 //F#4/Gb4
#define note_G4 392 //G4
#define note_Ab4 415.3 //G#4/Ab4
#define note_A4 440 //A4
#define note_Bb4 466.16 //A#4/Bb4
#define note_B4 493.88 //B4
#define note_C5 523.25 //C5
#define note_Db5 554.37 //C#5/Db5
#define note_D5 587.33 //D5
#define note_Eb5 622.25 //D#5/Eb5
#define note_E5 659.26 //E5
#define note_F5 698.46 //F5
#define note_Gb5 739.99 //F#5/Gb5
#define note_G5 783.99 //G5
#define note_Ab5 830.61 //G#5/Ab5
#define note_A5 880 //A5
#define note_Bb5 932.33 //A#5/Bb5
#define note_B5 987.77 //B5
#define note_C6 1046.5 //C6
#define note_Db6 1108.73 //C#6/Db6
#define note_D6 1174.66 //D6
#define note_Eb6 1244.51 //D#6/Eb6
#define note_E6 1318.51 //E6
#define note_F6 1396.91 //F6
#define note_Gb6 1479.98 //F#6/Gb6
#define note_G6 1567.98 //G6
#define note_Ab6 1661.22 //G#6/Ab6
#define note_A6 1760 //A6
#define note_Bb6 1864.66 //A#6/Bb6
#define note_B6 1975.53 //B6
#define note_C7 2093 //C7
#define note_Db7 2217.46 //C#7/Db7
#define note_D7 2349.32 //D7
#define note_Eb7 2489.02 //D#7/Eb7
#define note_E7 2637.02 //E7
#define note_F7 2793.83 //F7
#define note_Gb7 2959.96 //F#7/Gb7
#define note_G7 3135.96 //G7
#define note_Ab7 3322.44 //G#7/Ab7
#define note_A7 3520 //A7
#define note_Bb7 3729.31 //A#7/Bb7
#define note_B7 3951.07 //B7
#define note_C8 4186.01 //C8
#define note_Db8 4434.92 //C#8/Db8
#define note_D8 4698.64 //D8
#define note_Eb8 4978.03 //D#8/Eb8
#define S_connection 0
#define S_disconnection 1
#define S_buttonPushed 2
#define S_mode1 3
#define S_mode2 4
#define S_mode3 5
#define S_surprise 6
#define S_OhOoh 7
#define S_OhOoh2 8
#define S_cuddly 9
#define S_sleeping 10
#define S_happy 11
#define S_superHappy 12
#define S_happy_short 13
#define S_sad 14
#define S_confused 15
#define S_fart1 16
#define S_fart2 17
#define S_fart3 18
#endif