├── Arduino nano pinout.xlsx ├── drivers └── CH341SER(1).ZIP ├── libraries ├── IRLib-master.zip ├── NewPing_v1.7.zip └── NewPing │ ├── NewPing.h │ ├── keywords.txt │ └── NewPing.cpp ├── Arduino nano pinout - Feuille 1.pdf ├── MindLab robotic holiday course.docx ├── README.md ├── Test3_remote ├── code.txt └── Test3_remote.ino ├── Test2_ultrasound ├── blocklyduino.xml └── Test2_ultrasound.ino ├── Test1_motor ├── blocklyduino.xml └── Test1_motor.ino ├── Test3a_remote_detect └── Test3a_remote_detect.ino └── Test4_all └── Test4_all.ino /Arduino nano pinout.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/drachezoil/Mindlab-robot/HEAD/Arduino nano pinout.xlsx -------------------------------------------------------------------------------- /drivers/CH341SER(1).ZIP: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/drachezoil/Mindlab-robot/HEAD/drivers/CH341SER(1).ZIP -------------------------------------------------------------------------------- /libraries/IRLib-master.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/drachezoil/Mindlab-robot/HEAD/libraries/IRLib-master.zip -------------------------------------------------------------------------------- /libraries/NewPing_v1.7.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/drachezoil/Mindlab-robot/HEAD/libraries/NewPing_v1.7.zip -------------------------------------------------------------------------------- /libraries/NewPing/NewPing.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/drachezoil/Mindlab-robot/HEAD/libraries/NewPing/NewPing.h -------------------------------------------------------------------------------- /Arduino nano pinout - Feuille 1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/drachezoil/Mindlab-robot/HEAD/Arduino nano pinout - Feuille 1.pdf -------------------------------------------------------------------------------- /MindLab robotic holiday course.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/drachezoil/Mindlab-robot/HEAD/MindLab robotic holiday course.docx -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Mindlab-robot 2 | Arduino nano with 2 motor, ultrasound, buzer, remote, led,... 3 | 4 | CAD files 5 | https://www.tinkercad.com/users/57R4FTxF3Sq-zoilo-abad 6 | 7 | thingiverse project 8 | http://www.thingiverse.com/thing:1582398 9 | -------------------------------------------------------------------------------- /Test3_remote/code.txt: -------------------------------------------------------------------------------- 1 | UP FF629D 2 | DOWN FFA857 3 | RIGHT FFC23D 4 | LEFT FF22DD 5 | OK FF02FD 6 | 1 FF6897 7 | 2 FF9867 8 | 3 FFB04F 9 | 4 FF30CF 10 | 5 FF18E7 11 | 6 FF7A85 12 | 7 FF10EF 13 | 8 FF38C7 14 | 9 FF5AA5 15 | 0 FF4AB5 16 | * FF42BD 17 | # FF52AD -------------------------------------------------------------------------------- /libraries/NewPing/keywords.txt: -------------------------------------------------------------------------------- 1 | ################################### 2 | # Syntax Coloring Map For NewPing 3 | ################################### 4 | 5 | ################################### 6 | # Datatypes (KEYWORD1) 7 | ################################### 8 | 9 | NewPing KEYWORD1 10 | 11 | ################################### 12 | # Methods and Functions (KEYWORD2) 13 | ################################### 14 | 15 | ping KEYWORD2 16 | ping_in KEYWORD2 17 | ping_cm KEYWORD2 18 | ping_median KEYWORD2 19 | ping_timer KEYWORD2 20 | check_timer KEYWORD2 21 | timer_us KEYWORD2 22 | timer_ms KEYWORD2 23 | timer_stop KEYWORD2 24 | convert_in KEYWORD2 25 | convert_cm KEYWORD2 26 | 27 | ################################### 28 | # Constants (LITERAL1) 29 | ################################### 30 | -------------------------------------------------------------------------------- /Test2_ultrasound/blocklyduino.xml: -------------------------------------------------------------------------------- 1 | DistanceMinimumint4LTE9cmDistanceMinimumstop1000backward1000right1000forward 2 | -------------------------------------------------------------------------------- /Test1_motor/blocklyduino.xml: -------------------------------------------------------------------------------- 1 | firstint1EQfirst1first01000forward1000right1000left1000backward1000stop 2 | -------------------------------------------------------------------------------- /Test1_motor/Test1_motor.ino: -------------------------------------------------------------------------------- 1 | #define led1Pin 11 // LEDs 2 | #define led2Pin 12 // LEDs 3 | #define ECHO_PIN 7 // Arduino pin tied to echo pin on ping sensor. 4 | #define TRIGGER_PIN 8 // Arduino pin tied to trigger pin on ping sensor. 5 | #define buzzerPin 3 // Buzzer 6 | #define remotePin 4 // Ir reciever 7 | #define MOTOR_A_B 9 // Motor A pin 1, A-IB, DIR 8 | #define MOTOR_A_A 5 // Motor A pin 2, A-IA, PWM 9 | #define MOTOR_B_B 10 // Motor B pin 1, B-IB, DIR 10 | #define MOTOR_B_A 6 // Motor B pin 2, B-IA, PWM 11 | 12 | // the actual values for "fast" and "slow" depend on the motor 13 | #define PWM_SLOW 100 // arbitrary slow speed PWM duty cycle 14 | #define PWM_FAST 150 // arbitrary fast speed PWM duty cycle 15 | #define DIR_DELAY 1000 // brief delay for abrupt motor changes 16 | 17 | int first; 18 | 19 | 20 | void setup() 21 | { 22 | first = 1; 23 | Serial.begin(9600); 24 | pinMode(led1Pin,OUTPUT); // Led output 25 | pinMode(led2Pin,OUTPUT); // Led output 26 | pinMode( MOTOR_A_A, OUTPUT ); 27 | pinMode( MOTOR_A_B, OUTPUT ); 28 | pinMode( MOTOR_B_A, OUTPUT ); 29 | pinMode( MOTOR_B_B, OUTPUT ); 30 | stop(); 31 | digitalWrite(led1Pin, HIGH); 32 | digitalWrite(led2Pin, HIGH); 33 | delay(500); 34 | digitalWrite(led1Pin, LOW); 35 | digitalWrite(led2Pin, LOW); 36 | } 37 | 38 | 39 | void loop() 40 | { 41 | /*if (first == 1) { 42 | first = 0; 43 | delay(1000); 44 | forward(); 45 | delay(1000); 46 | right(); 47 | delay(1000); 48 | left(); 49 | delay(1000); 50 | backward(); 51 | delay(1000); 52 | stop(); 53 | }*/ 54 | for(int i = 0; i<250 ; i=i+10){ 55 | forward(i); 56 | Serial.print("speed: "); 57 | Serial.println(i); 58 | delay(1000); 59 | 60 | } 61 | } 62 | 63 | void forward(int speed) 64 | { 65 | digitalWrite(MOTOR_A_A,LOW); 66 | digitalWrite(MOTOR_B_A,LOW); 67 | analogWrite(MOTOR_A_B,speed); 68 | analogWrite(MOTOR_B_B,speed); 69 | digitalWrite(led1Pin, HIGH); 70 | digitalWrite(led2Pin, HIGH); 71 | } 72 | 73 | void right(int speed) 74 | { 75 | analogWrite(MOTOR_A_A,speed); 76 | digitalWrite(MOTOR_B_A,LOW); 77 | digitalWrite(MOTOR_A_B,LOW); 78 | analogWrite(MOTOR_B_B,speed); 79 | digitalWrite(led1Pin, HIGH); 80 | digitalWrite(led2Pin, LOW); 81 | } 82 | 83 | void left(int speed) 84 | { 85 | digitalWrite(MOTOR_A_A,LOW); 86 | analogWrite(MOTOR_B_A,speed); 87 | analogWrite(MOTOR_A_B,speed); 88 | digitalWrite(MOTOR_B_B,LOW); 89 | digitalWrite(led2Pin, HIGH); 90 | digitalWrite(led1Pin, LOW); 91 | } 92 | 93 | void backward(int speed) 94 | { 95 | analogWrite(MOTOR_A_A,speed); 96 | analogWrite(MOTOR_B_A,speed); 97 | digitalWrite(MOTOR_A_B,LOW); 98 | digitalWrite(MOTOR_B_B,LOW); 99 | digitalWrite(led1Pin, LOW); 100 | digitalWrite(led2Pin, LOW); 101 | } 102 | 103 | void stop() 104 | { 105 | digitalWrite(MOTOR_A_A,LOW); 106 | digitalWrite(MOTOR_B_A,LOW); 107 | digitalWrite(MOTOR_A_B,LOW); 108 | digitalWrite(MOTOR_B_B,LOW); 109 | digitalWrite(led1Pin, LOW); 110 | digitalWrite(led2Pin, LOW); 111 | } 112 | -------------------------------------------------------------------------------- /Test3a_remote_detect/Test3a_remote_detect.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define led1Pin 11 // LEDs 4 | #define led2Pin 12 // LEDs 5 | #define ECHO_PIN 7 // Arduino pin tied to echo pin on ping sensor. 6 | #define TRIGGER_PIN 8 // Arduino pin tied to trigger pin on ping sensor. 7 | #define buzzerPin 3 // Buzzer 8 | #define remotePin 4 // Ir reciever 9 | #define MOTOR_A_B 9 // Motor A pin 1, A-IB, DIR 10 | #define MOTOR_A_A 5 // Motor A pin 2, A-IA, PWM 11 | #define MOTOR_B_B 10 // Motor B pin 1, B-IB, DIR 12 | #define MOTOR_B_A 6 // Motor B pin 2, B-IA, PWM 13 | 14 | #define UP FF629D 15 | #define DOWN FFA857 16 | #define RIGHT FFC23D 17 | #define LEFT FF22DD 18 | #define OK FF02FD 19 | #define 1 FF6897 20 | #define 2 FF9867 21 | #define 3 FFB04F 22 | #define 4 FF30CF 23 | #define 5 FF18E7 24 | #define 6 FF7A85 25 | #define 7 FF10EF 26 | #define 8 FF38C7 27 | #define 9 FF5AA5 28 | #define 0 FF4AB5 29 | #define STAR FF42BD 30 | #define HASH FF52AD 31 | 32 | // the actual values for "fast" and "slow" depend on the motor 33 | #define PWM_SLOW 80 // arbitrary slow speed PWM duty cycle 34 | #define PWM_FAST 150 // arbitrary fast speed PWM duty cycle 35 | 36 | //Create a receiver object to listen on pin 11 37 | IRrecv My_Receiver(remotePin); 38 | 39 | //Create a decoder object 40 | IRdecode My_Decoder; 41 | 42 | void setup() 43 | { 44 | Serial.begin(9600); 45 | My_Receiver.enableIRIn(); // Start the receiver 46 | pinMode(led1Pin,OUTPUT); // Led output 47 | pinMode(led2Pin,OUTPUT); // Led output 48 | pinMode( MOTOR_A_A, OUTPUT ); 49 | pinMode( MOTOR_A_B, OUTPUT ); 50 | pinMode( MOTOR_B_A, OUTPUT ); 51 | pinMode( MOTOR_B_B, OUTPUT ); 52 | stop(); 53 | digitalWrite(led1Pin, HIGH); 54 | digitalWrite(led2Pin, HIGH); 55 | delay(500); 56 | digitalWrite(led1Pin, LOW); 57 | digitalWrite(led2Pin, LOW); 58 | } 59 | 60 | void loop() 61 | { 62 | //Continuously look for results. When you have them pass them to the decoder 63 | if (My_Receiver.GetResults(&My_Decoder)) { 64 | My_Decoder.decode(); //Decode the data 65 | My_Decoder.DumpResults(); //Show the results on serial monitor 66 | My_Receiver.resume(); //Restart the receiver 67 | } 68 | } 69 | 70 | void forward(int speed) 71 | { 72 | digitalWrite(MOTOR_A_A,LOW); 73 | digitalWrite(MOTOR_B_A,LOW); 74 | analogWrite(MOTOR_A_B,speed); 75 | analogWrite(MOTOR_B_B,speed); 76 | digitalWrite(led1Pin, HIGH); 77 | digitalWrite(led2Pin, HIGH); 78 | } 79 | 80 | void right(int speed) 81 | { 82 | analogWrite(MOTOR_A_A,speed); 83 | digitalWrite(MOTOR_B_A,LOW); 84 | digitalWrite(MOTOR_A_B,LOW); 85 | analogWrite(MOTOR_B_B,speed); 86 | digitalWrite(led1Pin, HIGH); 87 | digitalWrite(led2Pin, LOW); 88 | } 89 | 90 | void left(int speed) 91 | { 92 | digitalWrite(MOTOR_A_A,LOW); 93 | analogWrite(MOTOR_B_A,speed); 94 | analogWrite(MOTOR_A_B,speed); 95 | digitalWrite(MOTOR_B_B,LOW); 96 | digitalWrite(led2Pin, HIGH); 97 | digitalWrite(led1Pin, LOW); 98 | } 99 | 100 | void backward(int speed) 101 | { 102 | analogWrite(MOTOR_A_A,speed); 103 | analogWrite(MOTOR_B_A,speed); 104 | digitalWrite(MOTOR_A_B,LOW); 105 | digitalWrite(MOTOR_B_B,LOW); 106 | digitalWrite(led1Pin, LOW); 107 | digitalWrite(led2Pin, LOW); 108 | } 109 | 110 | void stop() 111 | { 112 | digitalWrite(MOTOR_A_A,LOW); 113 | digitalWrite(MOTOR_B_A,LOW); 114 | digitalWrite(MOTOR_A_B,LOW); 115 | digitalWrite(MOTOR_B_B,LOW); 116 | digitalWrite(led1Pin, LOW); 117 | digitalWrite(led2Pin, LOW); 118 | } 119 | -------------------------------------------------------------------------------- /Test3_remote/Test3_remote.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define led1Pin 11 // LEDs 4 | #define led2Pin 12 // LEDs 5 | #define ECHO_PIN 7 // Arduino pin tied to echo pin on ping sensor. 6 | #define TRIGGER_PIN 8 // Arduino pin tied to trigger pin on ping sensor. 7 | #define buzzerPin 3 // Buzzer 8 | #define remotePin 4 // Ir reciever 9 | #define MOTOR_A_B 9 // Motor A pin 1, A-IB, DIR 10 | #define MOTOR_A_A 5 // Motor A pin 2, A-IA, PWM 11 | #define MOTOR_B_B 10 // Motor B pin 1, B-IB, DIR 12 | #define MOTOR_B_A 6 // Motor B pin 2, B-IA, PWM 13 | 14 | #define UP 0xFF629D 15 | #define DOWN 0xFFA857 16 | #define RIGHT 0xFFC23D 17 | #define LEFT 0xFF22DD 18 | #define OK 0xFF02FD 19 | #define NUM_1 0xFF6897 20 | #define NUM_2 0xFF9867 21 | #define NUM_3 0xFFB04F 22 | #define NUM_4 0xFF30CF 23 | #define NUM_5 0xFF18E7 24 | #define NUM_6 0xFF7A85 25 | #define NUM_7 0xFF10EF 26 | #define NUM_8 0xFF38C7 27 | #define NUM_9 0xFF5AA5 28 | #define NUM_0 0xFF4AB5 29 | #define STAR 0xFF42BD 30 | #define HASH 0xFF52AD 31 | 32 | // the actual values for "fast" and "slow" depend on the motor 33 | #define PWM_SLOW 80 // arbitrary slow speed PWM duty cycle 34 | #define PWM_FAST 150 // arbitrary fast speed PWM duty cycle 35 | 36 | //Create a receiver object to listen on pin 11 37 | IRrecv My_Receiver(remotePin); 38 | 39 | //Create a decoder object 40 | IRdecode My_Decoder; 41 | 42 | void setup() 43 | { 44 | Serial.begin(9600); 45 | My_Receiver.enableIRIn(); // Start the receiver 46 | pinMode(led1Pin,OUTPUT); // Led output 47 | pinMode(led2Pin,OUTPUT); // Led output 48 | pinMode( MOTOR_A_A, OUTPUT ); 49 | pinMode( MOTOR_A_B, OUTPUT ); 50 | pinMode( MOTOR_B_A, OUTPUT ); 51 | pinMode( MOTOR_B_B, OUTPUT ); 52 | stop(); 53 | digitalWrite(led1Pin, HIGH); 54 | digitalWrite(led2Pin, HIGH); 55 | delay(500); 56 | digitalWrite(led1Pin, LOW); 57 | digitalWrite(led2Pin, LOW); 58 | } 59 | 60 | void loop() 61 | { 62 | if (My_Receiver.GetResults(&My_Decoder)) { 63 | My_Decoder.decode(); //Decode the data 64 | switch(My_Decoder.value) { 65 | case UP: 66 | forward(PWM_SLOW); 67 | break; 68 | case DOWN: 69 | backward(PWM_SLOW); 70 | break; 71 | case RIGHT: 72 | right(PWM_SLOW); 73 | break; 74 | case LEFT: 75 | left(PWM_SLOW); 76 | break; 77 | case OK: 78 | stop(); 79 | break; 80 | } 81 | My_Receiver.resume(); //Restart the receiver 82 | } 83 | } 84 | 85 | void forward(int speed) 86 | { 87 | digitalWrite(MOTOR_A_A,LOW); 88 | digitalWrite(MOTOR_B_A,LOW); 89 | analogWrite(MOTOR_A_B,speed); 90 | analogWrite(MOTOR_B_B,speed); 91 | digitalWrite(led1Pin, HIGH); 92 | digitalWrite(led2Pin, HIGH); 93 | } 94 | 95 | void right(int speed) 96 | { 97 | analogWrite(MOTOR_A_A,speed); 98 | digitalWrite(MOTOR_B_A,LOW); 99 | digitalWrite(MOTOR_A_B,LOW); 100 | analogWrite(MOTOR_B_B,speed); 101 | digitalWrite(led1Pin, HIGH); 102 | digitalWrite(led2Pin, LOW); 103 | } 104 | 105 | void left(int speed) 106 | { 107 | digitalWrite(MOTOR_A_A,LOW); 108 | analogWrite(MOTOR_B_A,speed); 109 | analogWrite(MOTOR_A_B,speed); 110 | digitalWrite(MOTOR_B_B,LOW); 111 | digitalWrite(led2Pin, HIGH); 112 | digitalWrite(led1Pin, LOW); 113 | } 114 | 115 | void backward(int speed) 116 | { 117 | analogWrite(MOTOR_A_A,speed); 118 | analogWrite(MOTOR_B_A,speed); 119 | digitalWrite(MOTOR_A_B,LOW); 120 | digitalWrite(MOTOR_B_B,LOW); 121 | digitalWrite(led1Pin, LOW); 122 | digitalWrite(led2Pin, LOW); 123 | } 124 | 125 | void stop() 126 | { 127 | digitalWrite(MOTOR_A_A,LOW); 128 | digitalWrite(MOTOR_B_A,LOW); 129 | digitalWrite(MOTOR_A_B,LOW); 130 | digitalWrite(MOTOR_B_B,LOW); 131 | digitalWrite(led1Pin, LOW); 132 | digitalWrite(led2Pin, LOW); 133 | } 134 | -------------------------------------------------------------------------------- /Test2_ultrasound/Test2_ultrasound.ino: -------------------------------------------------------------------------------- 1 | /* 2 | * Robot program 3 | * done : 4 | * - led 5 | * - ultrasound 6 | * - buzzer 7 | * todo : 8 | * - motor (test to do) 9 | * - remote 10 | * 11 | */ 12 | #include // Ultrasound library 13 | 14 | #define led1Pin 11 // LEDs 15 | #define led2Pin 12 // LEDs 16 | #define ECHO_PIN 7 // Arduino pin tied to echo pin on ping sensor. 17 | #define TRIGGER_PIN 8 // Arduino pin tied to trigger pin on ping sensor. 18 | #define buzzerPin 3 // Buzzer 19 | #define remotePin 4 // Ir reciever 20 | #define MOTOR_A_B 9 // Motor A pin 1, A-IB, DIR 21 | #define MOTOR_A_A 5 // Motor A pin 2, A-IA, PWM 22 | #define MOTOR_B_B 10 // Motor B pin 1, B-IB, DIR 23 | #define MOTOR_B_A 6 // Motor B pin 2, B-IA, PWM 24 | 25 | // the actual values for "fast" and "slow" depend on the motor 26 | #define PWM_SLOW 80 // arbitrary slow speed PWM duty cycle 27 | #define PWM_FAST 150 // arbitrary fast speed PWM duty cycle 28 | #define DIR_DELAY 1000 // brief delay for abrupt motor changes 29 | 30 | // ultrasound 31 | #define MAX_DISTANCE 100 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm. 32 | NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance. 33 | int sonarDistance = 0; // Distance of the object 34 | 35 | int DistanceMinimum; 36 | 37 | void setup() 38 | { 39 | DistanceMinimum = 4; 40 | Serial.begin(9600); 41 | pinMode(led1Pin,OUTPUT); // Led output 42 | pinMode(led2Pin,OUTPUT); // Led output 43 | pinMode( MOTOR_A_A, OUTPUT ); 44 | pinMode( MOTOR_A_B, OUTPUT ); 45 | pinMode( MOTOR_B_A, OUTPUT ); 46 | pinMode( MOTOR_B_B, OUTPUT ); 47 | stop(); 48 | digitalWrite(led1Pin, HIGH); 49 | digitalWrite(led2Pin, HIGH); 50 | delay(500); 51 | digitalWrite(led1Pin, LOW); 52 | digitalWrite(led2Pin, LOW); 53 | } 54 | 55 | 56 | void loop() 57 | { 58 | // Check ultrasound 59 | int sonarDistanceTemp = sonar.ping_cm(); 60 | if ( sonarDistanceTemp==0) sonarDistance = MAX_DISTANCE; // Send ping, get distance in cm 61 | else sonarDistance = sonarDistanceTemp; 62 | 63 | Serial.print("Ping: "); 64 | Serial.print(sonarDistance); 65 | Serial.println("cm"); 66 | 67 | if (sonarDistance<10) { 68 | stop(); 69 | delay(100); 70 | backward(PWM_SLOW); 71 | delay(500); 72 | stop(); 73 | delay(100); 74 | right(PWM_SLOW); 75 | delay(500); 76 | stop(); 77 | delay(100); 78 | } else { 79 | forward(PWM_SLOW); 80 | } 81 | } 82 | 83 | void forward(int speed) 84 | { 85 | digitalWrite(MOTOR_A_A,LOW); 86 | digitalWrite(MOTOR_B_A,LOW); 87 | analogWrite(MOTOR_A_B,speed); 88 | analogWrite(MOTOR_B_B,speed); 89 | digitalWrite(led1Pin, HIGH); 90 | digitalWrite(led2Pin, HIGH); 91 | } 92 | 93 | void right(int speed) 94 | { 95 | analogWrite(MOTOR_A_A,speed); 96 | digitalWrite(MOTOR_B_A,LOW); 97 | digitalWrite(MOTOR_A_B,LOW); 98 | analogWrite(MOTOR_B_B,speed); 99 | digitalWrite(led1Pin, HIGH); 100 | digitalWrite(led2Pin, LOW); 101 | } 102 | 103 | void left(int speed) 104 | { 105 | digitalWrite(MOTOR_A_A,LOW); 106 | analogWrite(MOTOR_B_A,speed); 107 | analogWrite(MOTOR_A_B,speed); 108 | digitalWrite(MOTOR_B_B,LOW); 109 | digitalWrite(led2Pin, HIGH); 110 | digitalWrite(led1Pin, LOW); 111 | } 112 | 113 | void backward(int speed) 114 | { 115 | analogWrite(MOTOR_A_A,speed); 116 | analogWrite(MOTOR_B_A,speed); 117 | digitalWrite(MOTOR_A_B,LOW); 118 | digitalWrite(MOTOR_B_B,LOW); 119 | digitalWrite(led1Pin, LOW); 120 | digitalWrite(led2Pin, LOW); 121 | } 122 | 123 | void stop() 124 | { 125 | digitalWrite(MOTOR_A_A,LOW); 126 | digitalWrite(MOTOR_B_A,LOW); 127 | digitalWrite(MOTOR_A_B,LOW); 128 | digitalWrite(MOTOR_B_B,LOW); 129 | digitalWrite(led1Pin, LOW); 130 | digitalWrite(led2Pin, LOW); 131 | } 132 | -------------------------------------------------------------------------------- /Test4_all/Test4_all.ino: -------------------------------------------------------------------------------- 1 | /* 2 | * Robot program 3 | * done : 4 | * - led 5 | * - ultrasound 6 | * - //buzzer 7 | * - motor (test to do) 8 | * - remote 9 | * 10 | */ 11 | #include 12 | #include // Ultrasound library 13 | 14 | #define led1Pin 11 // LEDs 15 | #define led2Pin 12 // LEDs 16 | #define ECHO_PIN 7 // Arduino pin tied to echo pin on ping sensor. 17 | #define TRIGGER_PIN 8 // Arduino pin tied to trigger pin on ping sensor. 18 | #define buzzerPin 3 // Buzzer 19 | #define remotePin 4 // Ir reciever 20 | #define MOTOR_A_B 9 // Motor A pin 1, A-IB, DIR 21 | #define MOTOR_A_A 5 // Motor A pin 2, A-IA, PWM 22 | #define MOTOR_B_B 10 // Motor B pin 1, B-IB, DIR 23 | #define MOTOR_B_A 6 // Motor B pin 2, B-IA, PWM 24 | 25 | #define UP 0xFF629D 26 | #define DOWN 0xFFA857 27 | #define RIGHT 0xFFC23D 28 | #define LEFT 0xFF22DD 29 | #define OK 0xFF02FD 30 | #define NUM_1 0xFF6897 31 | #define NUM_2 0xFF9867 32 | #define NUM_3 0xFFB04F 33 | #define NUM_4 0xFF30CF 34 | #define NUM_5 0xFF18E7 35 | #define NUM_6 0xFF7A85 36 | #define NUM_7 0xFF10EF 37 | #define NUM_8 0xFF38C7 38 | #define NUM_9 0xFF5AA5 39 | #define NUM_0 0xFF4AB5 40 | #define STAR 0xFF42BD 41 | #define HASH 0xFF52AD 42 | 43 | // the actual values for "fast" and "slow" depend on the motor 44 | #define PWM_SLOW 80 // arbitrary slow speed PWM duty cycle 45 | #define PWM_FAST 150 // arbitrary fast speed PWM duty cycle 46 | 47 | //Create a receiver object to listen on pin 11 48 | IRrecv My_Receiver(remotePin); 49 | //Create a decoder object 50 | IRdecode My_Decoder; 51 | 52 | // ultrasound 53 | #define MAX_DISTANCE 100 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm. 54 | NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance. 55 | int sonarDistance = 0; // Distance of the object 56 | 57 | int DistanceMinimum; 58 | 59 | void setup() 60 | { 61 | DistanceMinimum = 4; 62 | Serial.begin(9600); 63 | My_Receiver.enableIRIn(); // Start the receiver 64 | pinMode(led1Pin,OUTPUT); // Led output 65 | pinMode(led2Pin,OUTPUT); // Led output 66 | pinMode( MOTOR_A_A, OUTPUT ); 67 | pinMode( MOTOR_A_B, OUTPUT ); 68 | pinMode( MOTOR_B_A, OUTPUT ); 69 | pinMode( MOTOR_B_B, OUTPUT ); 70 | stop(); 71 | digitalWrite(led1Pin, HIGH); 72 | digitalWrite(led2Pin, HIGH); 73 | delay(500); 74 | digitalWrite(led1Pin, LOW); 75 | digitalWrite(led2Pin, LOW); 76 | } 77 | 78 | void loop() 79 | { 80 | // Check ultrasound 81 | int sonarDistanceTemp = sonar.ping_cm(); 82 | if ( sonarDistanceTemp==0) sonarDistance = MAX_DISTANCE; // Send ping, get distance in cm 83 | else sonarDistance = sonarDistanceTemp; 84 | 85 | Serial.print("Ping: "); 86 | Serial.print(sonarDistance); 87 | Serial.println("cm"); 88 | 89 | if (sonarDistance<10) { 90 | stop(); 91 | delay(100); 92 | backward(PWM_SLOW); 93 | delay(500); 94 | stop(); 95 | delay(100); 96 | right(PWM_SLOW); 97 | delay(500); 98 | stop(); 99 | delay(100); 100 | } 101 | 102 | if (My_Receiver.GetResults(&My_Decoder)) { 103 | My_Decoder.decode(); //Decode the data 104 | switch(My_Decoder.value) { 105 | case UP: 106 | forward(PWM_SLOW); 107 | break; 108 | case DOWN: 109 | backward(PWM_SLOW); 110 | break; 111 | case RIGHT: 112 | right(PWM_SLOW); 113 | break; 114 | case LEFT: 115 | left(PWM_SLOW); 116 | break; 117 | case OK: 118 | stop(); 119 | break; 120 | } 121 | My_Receiver.resume(); //Restart the receiver 122 | } 123 | 124 | } 125 | 126 | void forward(int speed) 127 | { 128 | digitalWrite(MOTOR_A_A,LOW); 129 | digitalWrite(MOTOR_B_A,LOW); 130 | analogWrite(MOTOR_A_B,speed); 131 | analogWrite(MOTOR_B_B,speed); 132 | digitalWrite(led1Pin, HIGH); 133 | digitalWrite(led2Pin, HIGH); 134 | } 135 | 136 | void right(int speed) 137 | { 138 | analogWrite(MOTOR_A_A,speed); 139 | digitalWrite(MOTOR_B_A,LOW); 140 | digitalWrite(MOTOR_A_B,LOW); 141 | analogWrite(MOTOR_B_B,speed); 142 | digitalWrite(led1Pin, HIGH); 143 | digitalWrite(led2Pin, LOW); 144 | } 145 | 146 | void left(int speed) 147 | { 148 | digitalWrite(MOTOR_A_A,LOW); 149 | analogWrite(MOTOR_B_A,speed); 150 | analogWrite(MOTOR_A_B,speed); 151 | digitalWrite(MOTOR_B_B,LOW); 152 | digitalWrite(led2Pin, HIGH); 153 | digitalWrite(led1Pin, LOW); 154 | } 155 | 156 | void backward(int speed) 157 | { 158 | analogWrite(MOTOR_A_A,speed); 159 | analogWrite(MOTOR_B_A,speed); 160 | digitalWrite(MOTOR_A_B,LOW); 161 | digitalWrite(MOTOR_B_B,LOW); 162 | digitalWrite(led1Pin, LOW); 163 | digitalWrite(led2Pin, LOW); 164 | } 165 | 166 | void stop() 167 | { 168 | digitalWrite(MOTOR_A_A,LOW); 169 | digitalWrite(MOTOR_B_A,LOW); 170 | digitalWrite(MOTOR_A_B,LOW); 171 | digitalWrite(MOTOR_B_B,LOW); 172 | digitalWrite(led1Pin, LOW); 173 | digitalWrite(led2Pin, LOW); 174 | } 175 | -------------------------------------------------------------------------------- /libraries/NewPing/NewPing.cpp: -------------------------------------------------------------------------------- 1 | // --------------------------------------------------------------------------- 2 | // Created by Tim Eckel - teckel@leethost.com 3 | // Copyright 2015 License: GNU GPL v3 http://www.gnu.org/licenses/gpl.html 4 | // 5 | // See "NewPing.h" for purpose, syntax, version history, links, and more. 6 | // --------------------------------------------------------------------------- 7 | 8 | #include "NewPing.h" 9 | 10 | 11 | // --------------------------------------------------------------------------- 12 | // NewPing constructor 13 | // --------------------------------------------------------------------------- 14 | 15 | NewPing::NewPing(uint8_t trigger_pin, uint8_t echo_pin, unsigned int max_cm_distance) { 16 | _triggerBit = digitalPinToBitMask(trigger_pin); // Get the port register bitmask for the trigger pin. 17 | _echoBit = digitalPinToBitMask(echo_pin); // Get the port register bitmask for the echo pin. 18 | 19 | _triggerOutput = portOutputRegister(digitalPinToPort(trigger_pin)); // Get the output port register for the trigger pin. 20 | _echoInput = portInputRegister(digitalPinToPort(echo_pin)); // Get the input port register for the echo pin. 21 | 22 | _triggerMode = (uint8_t *) portModeRegister(digitalPinToPort(trigger_pin)); // Get the port mode register for the trigger pin. 23 | 24 | #if ROUNDING_ENABLED == false 25 | _maxEchoTime = min(max_cm_distance + 1, (unsigned int) MAX_SENSOR_DISTANCE + 1) * US_ROUNDTRIP_CM; // Calculate the maximum distance in uS (no rounding). 26 | #else 27 | _maxEchoTime = min(max_cm_distance, (unsigned int) MAX_SENSOR_DISTANCE) * US_ROUNDTRIP_CM + (US_ROUNDTRIP_CM / 2); // Calculate the maximum distance in uS. 28 | #endif 29 | 30 | #if defined (__arm__) && defined (TEENSYDUINO) 31 | pinMode(echo_pin, INPUT); // Set echo pin to input (on Teensy 3.x (ARM), pins default to disabled, at least one pinMode() is needed for GPIO mode). 32 | pinMode(trigger_pin, OUTPUT); // Set trigger pin to output (on Teensy 3.x (ARM), pins default to disabled, at least one pinMode() is needed for GPIO mode). 33 | #endif 34 | 35 | #if defined (ARDUINO_AVR_YUN) 36 | pinMode(echo_pin, INPUT); // Set echo pin to input on the Arduino Yun, not sure why it doesn't default this way. 37 | #endif 38 | 39 | #if ONE_PIN_ENABLED != true 40 | *_triggerMode |= _triggerBit; // Set trigger pin to output. 41 | #endif 42 | } 43 | 44 | 45 | // --------------------------------------------------------------------------- 46 | // Standard ping methods 47 | // --------------------------------------------------------------------------- 48 | 49 | unsigned int NewPing::ping() { 50 | if (!ping_trigger()) return NO_ECHO; // Trigger a ping, if it returns false, return NO_ECHO to the calling function. 51 | 52 | #if URM37_ENABLED == true 53 | while (!(*_echoInput & _echoBit)) // Wait for the ping echo. 54 | if (micros() > _max_time) return NO_ECHO; // Stop the loop and return NO_ECHO (false) if we're beyond the set maximum distance. 55 | #else 56 | while (*_echoInput & _echoBit) // Wait for the ping echo. 57 | if (micros() > _max_time) return NO_ECHO; // Stop the loop and return NO_ECHO (false) if we're beyond the set maximum distance. 58 | #endif 59 | 60 | return (micros() - (_max_time - _maxEchoTime) - PING_OVERHEAD); // Calculate ping time, include overhead. 61 | } 62 | 63 | 64 | unsigned long NewPing::ping_cm() { 65 | unsigned long echoTime = NewPing::ping(); // Calls the ping method and returns with the ping echo distance in uS. 66 | #if ROUNDING_ENABLED == false 67 | return (echoTime / US_ROUNDTRIP_CM); // Call the ping method and returns the distance in centimeters (no rounding). 68 | #else 69 | return NewPingConvert(echoTime, US_ROUNDTRIP_CM); // Convert uS to centimeters. 70 | #endif 71 | } 72 | 73 | 74 | unsigned long NewPing::ping_in() { 75 | unsigned long echoTime = NewPing::ping(); // Calls the ping method and returns with the ping echo distance in uS. 76 | #if ROUNDING_ENABLED == false 77 | return (echoTime / US_ROUNDTRIP_IN); // Call the ping method and returns the distance in inches (no rounding). 78 | #else 79 | return NewPingConvert(echoTime, US_ROUNDTRIP_IN); // Convert uS to inches. 80 | #endif 81 | } 82 | 83 | 84 | unsigned long NewPing::ping_median(uint8_t it) { 85 | unsigned int uS[it], last; 86 | uint8_t j, i = 0; 87 | unsigned long t; 88 | uS[0] = NO_ECHO; 89 | 90 | while (i < it) { 91 | t = micros(); // Start ping timestamp. 92 | last = ping(); // Send ping. 93 | 94 | if (last != NO_ECHO) { // Ping in range, include as part of median. 95 | if (i > 0) { // Don't start sort till second ping. 96 | for (j = i; j > 0 && uS[j - 1] < last; j--) // Insertion sort loop. 97 | uS[j] = uS[j - 1]; // Shift ping array to correct position for sort insertion. 98 | } else j = 0; // First ping is sort starting point. 99 | uS[j] = last; // Add last ping to array in sorted position. 100 | i++; // Move to next ping. 101 | } else it--; // Ping out of range, skip and don't include as part of median. 102 | 103 | if (i < it && micros() - t < PING_MEDIAN_DELAY) 104 | delay((PING_MEDIAN_DELAY + t - micros()) / 1000); // Millisecond delay between pings. 105 | 106 | } 107 | return (uS[it >> 1]); // Return the ping distance median. 108 | } 109 | 110 | 111 | // --------------------------------------------------------------------------- 112 | // Standard and timer interrupt ping method support function (not called directly) 113 | // --------------------------------------------------------------------------- 114 | 115 | boolean NewPing::ping_trigger() { 116 | #if ONE_PIN_ENABLED == true 117 | *_triggerMode |= _triggerBit; // Set trigger pin to output. 118 | #endif 119 | 120 | *_triggerOutput &= ~_triggerBit; // Set the trigger pin low, should already be low, but this will make sure it is. 121 | delayMicroseconds(4); // Wait for pin to go low. 122 | *_triggerOutput |= _triggerBit; // Set trigger pin high, this tells the sensor to send out a ping. 123 | delayMicroseconds(10); // Wait long enough for the sensor to realize the trigger pin is high. Sensor specs say to wait 10uS. 124 | *_triggerOutput &= ~_triggerBit; // Set trigger pin back to low. 125 | 126 | #if ONE_PIN_ENABLED == true 127 | *_triggerMode &= ~_triggerBit; // Set trigger pin to input (when using one Arduino pin this is technically setting the echo pin to input as both are tied to the same Arduino pin). 128 | #endif 129 | 130 | #if URM37_ENABLED == true 131 | if (!(*_echoInput & _echoBit)) return false; // Previous ping hasn't finished, abort. 132 | _max_time = micros() + _maxEchoTime + MAX_SENSOR_DELAY; // Maximum time we'll wait for ping to start (most sensors are <450uS, the SRF06 can take up to 34,300uS!) 133 | while (*_echoInput & _echoBit) // Wait for ping to start. 134 | if (micros() > _max_time) return false; // Took too long to start, abort. 135 | #else 136 | if (*_echoInput & _echoBit) return false; // Previous ping hasn't finished, abort. 137 | _max_time = micros() + _maxEchoTime + MAX_SENSOR_DELAY; // Maximum time we'll wait for ping to start (most sensors are <450uS, the SRF06 can take up to 34,300uS!) 138 | while (!(*_echoInput & _echoBit)) // Wait for ping to start. 139 | if (micros() > _max_time) return false; // Took too long to start, abort. 140 | #endif 141 | 142 | _max_time = micros() + _maxEchoTime; // Ping started, set the time-out. 143 | return true; // Ping started successfully. 144 | } 145 | 146 | 147 | #if TIMER_ENABLED == true 148 | 149 | // --------------------------------------------------------------------------- 150 | // Timer interrupt ping methods (won't work with Teensy 3.0, ATmega8/128 and all ATtiny microcontrollers) 151 | // --------------------------------------------------------------------------- 152 | 153 | void NewPing::ping_timer(void (*userFunc)(void)) { 154 | if (!ping_trigger()) return; // Trigger a ping, if it returns false, return without starting the echo timer. 155 | timer_us(ECHO_TIMER_FREQ, userFunc); // Set ping echo timer check every ECHO_TIMER_FREQ uS. 156 | } 157 | 158 | 159 | boolean NewPing::check_timer() { 160 | if (micros() > _max_time) { // Outside the time-out limit. 161 | timer_stop(); // Disable timer interrupt 162 | return false; // Cancel ping timer. 163 | } 164 | 165 | #if URM37_ENABLED == false 166 | if (!(*_echoInput & _echoBit)) { // Ping echo received. 167 | #else 168 | if (*_echoInput & _echoBit) { // Ping echo received. 169 | #endif 170 | timer_stop(); // Disable timer interrupt 171 | ping_result = (micros() - (_max_time - _maxEchoTime) - PING_TIMER_OVERHEAD); // Calculate ping time including overhead. 172 | return true; // Return ping echo true. 173 | } 174 | 175 | return false; // Return false because there's no ping echo yet. 176 | } 177 | 178 | 179 | // --------------------------------------------------------------------------- 180 | // Timer2/Timer4 interrupt methods (can be used for non-ultrasonic needs) 181 | // --------------------------------------------------------------------------- 182 | 183 | // Variables used for timer functions 184 | void (*intFunc)(); 185 | void (*intFunc2)(); 186 | unsigned long _ms_cnt_reset; 187 | volatile unsigned long _ms_cnt; 188 | #if defined(__arm__) && defined(TEENSYDUINO) 189 | IntervalTimer itimer; 190 | #endif 191 | 192 | 193 | void NewPing::timer_us(unsigned int frequency, void (*userFunc)(void)) { 194 | intFunc = userFunc; // User's function to call when there's a timer event. 195 | timer_setup(); // Configure the timer interrupt. 196 | 197 | #if defined (__AVR_ATmega32U4__) // Use Timer4 for ATmega32U4 (Teensy/Leonardo). 198 | OCR4C = min((frequency>>2) - 1, 255); // Every count is 4uS, so divide by 4 (bitwise shift right 2) subtract one, then make sure we don't go over 255 limit. 199 | TIMSK4 = (1<>2) - 1, 255); // Every count is 4uS, so divide by 4 (bitwise shift right 2) subtract one, then make sure we don't go over 255 limit. 204 | TIMSK2 |= (1<