Robot Eyes. DAY 3 Let's Make a Robot

Transcription

1 DAY 3 Let's Make a Robot Objective: Students will learn to use an SR04 Sonar component to measure distance. The Students will then build their robot, establish programming to control the motors and then integrate the Sonar components and finalize their robots program. Robot Eyes A robot needs some way to detect the world around it, otherwise it is just a car. The SR04 Sonar unit consists of a speaker and a microphone, when the Trig (trigger) pin is set to HIGH it emits an Serial.begin(9600); pinmode(10, OUTPUT); pinmode(a0, INPUT); Serial.println(GetDistance()); delay(20); unsigned long GetDistance(){ unsigned long duration; digitalwrite(10, HIGH); delay(10); digitalwrite(10, LOW); duration = pulsein(a0, HIGH); duration = (duration / 2) / 29.1; return duration; ultrasonic click from the speaker. If there is anything nearby for the click to bounce off the sound will return and be detected by the microphone. The Sonar unit will then send a pulse through the Echo pin indicating the time between sending and receiving the sound. eg. a 30ms pulse of 5V will be sent if the sound took 30ms to bounce back. To interpret the message from the Echo pin we will use the pulsein(pinnumber) function, this function causes the Arduino to delay until the given pin goes high and then low again, returning the duration of this high-low pulse. The pulsein value is divided by two to account for the sounds return trip and divided by 29.1 based on the average speed of sound at sea level. A long is a variable type that can store larger numbers than int, and unsigned long can only store positive numbers.

2 Libraries This is a great and simple way to get a distance using the SR04 Sonar component however pulsein can be very slow as it forces the Arduino to delay while waiting for input, if there is no obstacle to report pulsein() will continue to wait for a signal that is not coming, adding a second Sonar unit to our robot would make this delay even greater. There are a few good ways around this issue that are outside the scope of this course, so instead we will make use of a programming library designed for exactly what we want, to make the reading of an SR04 Sonar component more efficient. The NewPing library can be downloaded from Tutorials and examples of use can also be found at that page. Download the NewPing library and copy it to the Libraries folder in your Arduino save folder (usually in Documents). Library files are added to the Arduino IDE on startup, so if you are running Arduino you should save and close what you are doing and restart the IDE. A library is a collection of programming tools that have been pre-made. Rather than inventing our own functions to make use of the SR04 we can include the NewPing library and make use of excellent functions that have been designed and tested already. #include <NewPing.h> int trigpin = 10; int echopin = A0; int maxdistance = 200; NewPing sonar(trigpin, echopin, maxdistance); Serial.begin(9600); int distance = sonar.ping() / US_ROUNDTRIP_CM); Serial.println(distance); delay(50);

3 The first line tells the code to include the NewPing library in our code, it is exactly as if we copy and pasted all the NewPing code to the end of our program, we can call any function for the library at any time. After we have defined our trigger and echo pins as well as the maximum distance we want to detect (larger than 200cm becomes inaccurate with the SR04) we can create the new NewPing variable, the NewPing variable represents our sonar device. We create a NewPing variable called sonar and tell it which pins and max distance we are using, that is all the setup we need to do, NewPing will set the pin modes for us. Now we just have to use sonar.ping() and NewPing will run some fancy code to get the distance from the SR04 Sonar component, we divide it by US_ROUNDTRIP_CM which is variable that represents (29/2) used to convert the raw value into a centimeter value. To extend our code to work with two (or more) Sonar components we just need to plug them into our Arduino and add a new NewPing object to our code. #include <NewPing.h> int trigpinl = 10; int echopinl = A0; int trigpinr = 16; int echopinr = A1; int maxdistance = 200; NewPing sonarl(trigpinl, echopinl, maxdistance); NewPing sonarr(trigpinr, echopinr, maxdistance); Serial.begin(9600); int distancel = sonarl.ping() / US_ROUNDTRIP_CM); int distancer = sonarr.ping() / US_ROUNDTRIP_CM); Serial.print("Left: "); Serial.print(distanceL); Serial.print(" Right:"); Serial.println(distanceR); delay(50); So this time we had two trigger pins, one for left and one for right, the same with echo pins. We made two NewPing objects, one called sonarl and one called sonarr.

4 The only other new thing we did was have multiple Serial.print commands, in the Arduino IDE you can't add multiple variables to a single println command, so we used Serial.print() which sends text via Serial just like println but doesn't add a carriage return (next line), so each print command is added onto the previous with no carriage return (next line) until the final Serial.println(distanceR). You should now have two sonar devices working at the same time, do some experiments with different surfaces and distances to see how they react. The response can get a bit erratic at very long and very short distances so it may be necessary to write a function to clean up the signal, perhaps any response above 200 should return a value of 200 and a response of less than 2cm can default to 0cm. It's Robot Time! Now that we know how to operate our robots eyes and it's motors, it's time to build the robot. Each motor should be attached to an aluminium mounting block with 2 long screws with nuts, the mounting block is then attached with two medium screws to the underside of the perspex chassis. Note that the axles should be towards the front (the curved side). The rear castor wheel should have each of the four brass spacers fixed with a flat bottomed screw and then attached to the perspex chassis with a short round headed screw. HINT: After building the robot chassis some time should be spent discussing what the layout of the

5 breadboards, battery pack, sonar units etc should be. When it is decided the student should spend some time trying to draw out a rough wiring schematic. If the class is small this can be done together using Fritzing to make a more readable diagram. Now we need to combine our motor code and our Sonar code into one script and upload it to our robot. We can create a simple bit of code in our loop() function that tests the left and right distances and instructs the motors to go straight unless an object gets too close on either side.

6 #include <NewPing.h> // Motor Pins int lmon = 7; int lm0 = 8; int lm1 = 9; int rmon = 14; int rm0 = 16; int rm1 = 10; // Sonar Pins int ltrig = 2; int lecho = A0; int rtrig = 3; int recho = A1; int maxdistance = 200; // Sonar sensor objects NewPing sonarl(ltrig, lecho, maxdistance); NewPing sonarr(rtrig, recho, maxdistance); // Holds the values returned by the left and right sensors int ldist = 200; int rdist = 200; Serial.begin(9600); // Serial link for debugging sonar // Set motor pins to OUTPUT pinmode(lmon, OUTPUT); pinmode(lm0, OUTPUT); pinmode(lm1, OUTPUT); pinmode(rmon, OUTPUT); pinmode(rm0, OUTPUT); pinmode(rm1, OUTPUT); // Set left and right motors enabled digitalwrite(lmon, HIGH); digitalwrite(rmon, HIGH); UpdateSonar(); if (ldist < 20){ Move(1,-1); else if (rdist < 20){ Move(-1,1); else { Move(1,1); delay(50);

7 void UpdateSonar(){ ldist = sonarl.ping() / US_ROUNDTRIP_CM; rdist = sonarr.ping() / US_ROUNDTRIP_CM; void Move(int left, int right){ LMotor(left); RMotor(right); void LMotor(int dir){ if (dir == 1){ digitalwrite(lm0, HIGH); digitalwrite(lm1, LOW); else if (dir == -1){ digitalwrite(lm0, LOW); digitalwrite(lm1, HIGH); else { digitalwrite(lm0, LOW); digitalwrite(lm1, LOW); void RMotor(int dir){ if (dir == 1){ digitalwrite(rm0, HIGH); digitalwrite(rm1, LOW); else if (dir == -1){ digitalwrite(rm0, LOW); digitalwrite(rm1, HIGH); else { digitalwrite(rm0, LOW); digitalwrite(rm1, LOW); The above code should give a fully functioning robot that will drive forward until it meets a wall. If the robot is hitting walls consider adjusting the direction of the sonar units or increasing the distance at which the robot will turn away from a wall.