diff options
Diffstat (limited to 'libraries/Robot_Control/examples')
27 files changed, 2173 insertions, 0 deletions
diff --git a/libraries/Robot_Control/examples/explore/R01_Logo/R01_Logo.ino b/libraries/Robot_Control/examples/explore/R01_Logo/R01_Logo.ino new file mode 100644 index 0000000..794479e --- /dev/null +++ b/libraries/Robot_Control/examples/explore/R01_Logo/R01_Logo.ino @@ -0,0 +1,134 @@ +/* Robot Logo + + This sketch demonstrates basic movement of the Robot. + When the sketch starts, press the on-board buttons to tell + the robot how to move. Pressing the middle button will + save the pattern, and the robot will follow accordingly. + You can record up to 20 commands. The robot will move for + one second per command. + + This example uses images on an SD card. It looks for + files named "lg0.bmp" and "lg1.bmp" and draws them on the + screen. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> // include the robot library + +int commands[20]; // array for storing commands + +void setup() { + // initialize the Robot, SD card, and display + Robot.begin(); + Robot.beginTFT(); + Robot.beginSD(); + + // draw "lg0.bmp" and "lg1.bmp" on the screen + Robot.displayLogos(); +} + +void loop() { + + Robot.drawBMP("intro.bmp", 0, 0); //display background image + + iniCommands(); // remove commands from the array + addCommands(); // add commands to the array + + delay(1000); // wait for a second + + executeCommands(); // follow orders + + Robot.stroke(0,0,0); + Robot.text("Done!", 5, 103); // write some text to the display + delay(1500); // wait for a moment +} + +// empty the commands array +void iniCommands() { + for(int i=0; i<20; i++) + commands[i]=-1; +} + +// add commands to the array +void addCommands() { + Robot.stroke(0,0,0); + // display text on the screen + Robot.text("1. Press buttons to\n add commands.\n\n 2. Middle to finish.", 5, 5); + + // read the buttons' state + for(int i=0; i<20;) { //max 20 commands + int key = Robot.keyboardRead(); + if(key == BUTTON_MIDDLE) { //finish input + break; + }else if(key == BUTTON_NONE) { //if no button is pressed + continue; + } + commands[i] = key; // save the button to the array + PrintCommandI(i, 46); // print the command on the screen + delay(100); + i++; + } +} + +// run through the array and move the robot +void executeCommands() { + // print status to the screen + Robot.text("Excuting...",5,70); + + // read through the array and move accordingly + for(int i=0; i<20; i++) { + switch(commands[i]) { + case BUTTON_LEFT: + Robot.turn(-90); + break; + case BUTTON_RIGHT: + Robot.turn(90); + break; + case BUTTON_UP: + Robot.motorsWrite(255, 255); + break; + case BUTTON_DOWN: + Robot.motorsWrite(-255, -255); + break; + case BUTTON_NONE: + return; + } + // print the current command to the screen + Robot.stroke(255,0,0); + PrintCommandI(i, 86); + delay(1000); + + // stop moving for a second + Robot.motorsStop(); + delay(1000); + } +} + +// convert the button press to a single character +char keyToChar(int key) { + switch(key) { + case BUTTON_LEFT: + return '<'; + case BUTTON_RIGHT: + return '>'; + case BUTTON_UP: + return '^'; + case BUTTON_DOWN: + return 'v'; + } +} + +// display a command +void PrintCommandI(int i, int originY) { + Robot.text(keyToChar(commands[i]), i%14*8+5, i/14*10+originY); +} + diff --git a/libraries/Robot_Control/examples/explore/R02_Line_Follow/R02_Line_Follow.ino b/libraries/Robot_Control/examples/explore/R02_Line_Follow/R02_Line_Follow.ino new file mode 100644 index 0000000..58de253 --- /dev/null +++ b/libraries/Robot_Control/examples/explore/R02_Line_Follow/R02_Line_Follow.ino @@ -0,0 +1,73 @@ +/* Robot Line Follow + + This sketch demonstrates the line following capabilities + of the Arduino Robot. On the floor, place some black + electrical tape along the path you wish the robot to follow. + To indicate a stopping point, place another piece of tape + perpendicular to the path. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> // include the robot library + +long timerOrigin; // used for counting elapsed time + +void setup() { + // initialize the Robot, SD card, display, and speaker + Robot.begin(); + Robot.beginTFT(); + Robot.beginSD(); + Robot.beginSpeaker(); + + // show the logots on the TFT screen + Robot.displayLogos(); + + Robot.drawBMP("lf.bmp", 0, 0); // display background image + + Robot.playFile("chase.sqm"); // play a song from the SD card + + // add the instructions + Robot.text("Line Following\n\n place the robot on\n the track and \n see it run", 5, 5); + Robot.text("Press the middle\n button to start...", 5, 61); + Robot.waitContinue(); + + // These are some general values that work for line following + // uncomment one or the other to see the different behaviors of the robot + // Robot.lineFollowConfig(11, 5, 50, 10); + Robot.lineFollowConfig(14, 9, 50, 10); + + //set the motor board into line-follow mode + Robot.setMode(MODE_LINE_FOLLOW); + + // start + Robot.fill(255, 255, 255); + Robot.stroke(255, 255, 255); + Robot.rect(0, 0, 128, 80); // erase the previous text + Robot.stroke(0, 0, 0); + Robot.text("Start", 5, 5); + + Robot.stroke(0, 0, 0); // choose color for the text + Robot.text("Time passed:", 5, 21); // write some text to the screen + + timerOrigin=millis(); // keep track of the elapsed time + + while(!Robot.isActionDone()) { //wait for the finish signal + Robot.debugPrint(millis()-timerOrigin, 5, 29); // show how much time has passed + } + + Robot.stroke(0, 0, 0); + Robot.text("Done!", 5, 45); +} +void loop() { + //nothing here, the program only runs once. Reset the robot + //to do it again! +} diff --git a/libraries/Robot_Control/examples/explore/R03_Disco_Bot/R03_Disco_Bot.ino b/libraries/Robot_Control/examples/explore/R03_Disco_Bot/R03_Disco_Bot.ino new file mode 100644 index 0000000..3574b01 --- /dev/null +++ b/libraries/Robot_Control/examples/explore/R03_Disco_Bot/R03_Disco_Bot.ino @@ -0,0 +1,179 @@ +/* Disco Bot + + This sketch shows you how to use the melody playing + feature of the robot, with some really cool 8-bit music. + Music will play when the robot is turned on, and it + will show you some dance moves. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> // include the robot library + +/* Dancing steps: + S: stop + L: turn left + R: turn right + F: go forward + B: go backwards + + The number after each command determines how long + each step lasts. Each number is 1/2 second long. + + The "\0" indicates end of string +*/ +char danceScript[] = "S4L1R1S2F1B1S1\0"; + +int currentScript = 0; // what step are we at + +int currentSong = 0; // keep track of the current song +static const int SONGS_COUNT = 3; // number of songs + +// an array to hold the songs +char musics[][11] = { + "melody.sqm", + "menu.sqm", + "chase.sqm", +}; + +// variables for non-blocking delay +long waitFrom; +long waitTime = 0; + +void setup() { + // initialize the Robot, SD card, display, and speaker + Robot.begin(); + Robot.beginSpeaker(); + Robot.beginSD(); + Robot.beginTFT(); + + // draw "lg0.bmp" and "lg1.bmp" on the screen + Robot.displayLogos(); + + // Print instructions to the screen + Robot.text("1. Use left and\n right key to switch\n song", 5, 5); + Robot.text("2. Put robot on the\n ground to dance", 5, 33); + + // wait for a few soconds + delay(3000); + + setInterface(); // display the current song + play(0); //play the first song in the array + + resetWait(); //Initialize non-blocking delay +} + +void loop() { + // read the butttons on the robot + int key = Robot.keyboardRead(); + + // Right/left buttons play next/previous song + switch(key) { + case BUTTON_UP: + case BUTTON_LEFT: + play(-1); //play previous song + break; + case BUTTON_DOWN: + case BUTTON_RIGHT: + play(1); //play next song + break; + } + + // dance! + runScript(); +} + +// Dancing function +void runScript() { + if(!waiting()) { // if the previous instructions have finished + // get the next 2 commands (direction and duration) + parseCommand(danceScript[currentScript], danceScript[currentScript+1]); + currentScript += 2; + if(danceScript[currentScript] == '\0') // at the end of the array + currentScript = 0; // start again at the beginning + } +} + +// instead of delay, use this timer +boolean waiting() { + if(millis()-waitFrom >= waitTime) + return false; + else + return true; +} + +// how long to wait +void wait(long t) { + resetWait(); + waitTime = t; +} + +// reset the timer +void resetWait() { + waitFrom = millis(); +} + +// read the direction and dirstion of the steps +void parseCommand(char dir, char duration) { + //convert the scripts to action + switch(dir) { + case 'L': + Robot.motorsWrite(-255, 255); + break; + case 'R': + Robot.motorsWrite(255, -255); + break; + case 'F': + Robot.motorsWrite(255, 255); + break; + case 'B': + Robot.motorsWrite(-255, -255); + break; + case 'S': + Robot.motorsStop(); + break; + } + //You can change "500" to change the pace of dancing + wait(500*(duration-'0')); +} + +// display the song +void setInterface() { + Robot.clearScreen(); + Robot.stroke(0, 0, 0); + Robot.text(musics[0], 0, 0); +} + +// display the next song +void select(int seq, boolean onOff) { + if(onOff){//select + Robot.stroke(0, 0, 0); + Robot.text(musics[seq], 0, 0); + }else{//deselect + Robot.stroke(255, 255, 255); + Robot.text(musics[seq], 0, 0); + } +} + +// play the slected song +void play(int seq) { + select(currentSong, false); + if(currentSong <= 0 && seq == -1) { //previous of 1st song? + currentSong = SONGS_COUNT-1; //go to last song + } else if(currentSong >= SONGS_COUNT-1 && seq == 1) { //next of last? + currentSong = 0; //go to 1st song + } else { + currentSong += seq; //next song + } + Robot.stopPlayFile(); + Robot.playFile(musics[currentSong]); + select(currentSong, true); //display the current song +} diff --git a/libraries/Robot_Control/examples/explore/R04_Compass/R04_Compass.ino b/libraries/Robot_Control/examples/explore/R04_Compass/R04_Compass.ino new file mode 100644 index 0000000..a7a7315 --- /dev/null +++ b/libraries/Robot_Control/examples/explore/R04_Compass/R04_Compass.ino @@ -0,0 +1,70 @@ +/* Robot Compass + + The robot has an on-board compass module, with + which it can tell the direction the robot is + facing. This sketch will make sure the robot + goes towards a certain direction. + + Beware, magnets will interfere with the compass + readings. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +// include the robot library +#include <ArduinoRobot.h> + +int speedLeft; +int speedRight; +int compassValue; +int direc = 180; //Direction the robot is heading + +void setup() { + // initialize the modules + Robot.begin(); + Robot.beginTFT(); + Robot.beginSD(); + Robot.displayLogos(); +} + +void loop() { + // read the compass orientation + compassValue = Robot.compassRead(); + + // how many degrees are we off + int diff = compassValue-direc; + + // modify degress + if(diff > 180) + diff = -360+diff; + else if(diff < -180) + diff = 360+diff; + + // Make the robot turn to its proper orientation + diff = map(diff, -180, 180, -255, 255); + + if(diff > 0) { + // keep the right wheel spinning, + // change the speed of the left wheel + speedLeft = 255-diff; + speedRight = 255; + } else { + // keep the right left spinning, + // change the speed of the left wheel + speedLeft = 255; + speedRight = 255+diff; + } + // write out to the motors + Robot.motorsWrite(speedLeft, speedRight); + + // draw the orientation on the screen + Robot.drawCompass(compassValue); +} diff --git a/libraries/Robot_Control/examples/explore/R05_Inputs/R05_Inputs.ino b/libraries/Robot_Control/examples/explore/R05_Inputs/R05_Inputs.ino new file mode 100644 index 0000000..1359f8d --- /dev/null +++ b/libraries/Robot_Control/examples/explore/R05_Inputs/R05_Inputs.ino @@ -0,0 +1,166 @@ +/* Robot Inputs + + This sketch shows you how to use the on-board + potentiometer and buttons as inputs. + + Turning the potentiometer draws a clock-shaped + circle. The up and down buttons change the pitch, + while the left and right buttons change the tempo. + The middle button resets tempo and pitch. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +// default tempo and pitch of the music +int tempo = 60; +int pitch = 1000; + +void setup() { + // initialize the Robot, SD card, speaker, and display + Robot.begin(); + Robot.beginTFT(); + Robot.beginSpeaker(); + Robot.beginSD(); + + // draw "lg0.bmp" and "lg1.bmp" on the screen + Robot.displayLogos(); + + // play a sound file + Robot.playFile("Melody.sqm"); +} + +void loop() { + // check the value of the buttons + keyDown(Robot.keyboardRead()); + + // check the value of the pot + drawKnob(Robot.knobRead()); +} + +// Draw the basic interface +void renderUI() { + //fill the buttons blank + Robot.fill(255, 255, 255); + Robot.rect(53, 58, 13, 13); // left + Robot.rect(93, 58, 13, 13); // right + Robot.rect(73, 38, 13, 13); // up + Robot.circle(79, 64, 6); // middle + Robot.rect(73, 78, 13, 13); // down + Robot.circle(26, 116, 18); // knob + + //draw the vertical bargraph + int fullPart=map(pitch, 200, 2000, 0, 58); //length of filled bargraph + Robot.fill(255, 255, 255); + Robot.rect(21, 30, 13, 58-fullPart); + Robot.fill(0, 0, 255); + Robot.rect(21, 88-fullPart, 13, fullPart); //58-fullPart+30 + + //draw the horizontal bargraph + fullPart = map(tempo, 20, 100, 0, 58); // length of filled bargraph + Robot.fill(255, 190, 0); + Robot.rect(53, 110, fullPart, 13); + Robot.fill(255, 255, 255); + Robot.rect(53+fullPart, 110, 58-fullPart, 13); +} + +void keyDown(int keyCode) { + // use a static int so it is persistent over time + static int oldKey; + switch(keyCode) { + case BUTTON_LEFT: + //left button pressed, reduces tempo + tempo -= 5; + if(tempo < 20) tempo = 20; //lowest tempo 20 + Robot.fill(255,190,0); + + Robot.rect(53, 58, 13, 13); + break; + case BUTTON_RIGHT: + //right button pressed, increases tempo + tempo += 5; + if(tempo > 100) tempo = 100; //highest tempo 100 + Robot.fill(255,190,0); + Robot.rect(93, 58, 13, 13); + break; + case BUTTON_UP: + //up button pressed, increases pitch + pitch += 120; + if(pitch > 2000) pitch = 2000; + Robot.fill(0, 0, 255); + + Robot.rect(73, 38, 13, 13); + break; + case BUTTON_DOWN: + //down button pressed, reduces pitch + pitch -= 120; + if(pitch < 200){ + pitch = 200; + } + Robot.fill(0, 0, 255); + + Robot.rect(73, 78, 13, 13); + break; + case BUTTON_MIDDLE: + //middle button pressed, resets tempo and pitch + tempo = 60; + pitch = 1000; + Robot.fill(160,160,160); + + Robot.circle(79, 64, 6); + break; + case BUTTON_NONE: + //Only when the keys are released(thus BUTTON_NONE is + //encountered the first time), the interface will be + //re-drawn. + if(oldKey != BUTTON_NONE){ + renderUI(); + } + break; + } + if(oldKey != keyCode) { + // change the song's tempo + Robot.tempoWrite(tempo); + // change the song's pitch + Robot.tuneWrite(float(pitch/1000.0)); + } + oldKey = keyCode; +} + +void drawKnob(int val) { + static int x = 0, y = 0, val_old = 0; + // radian number, -3.14 to 3.14 + float ang = map(val, 0, 1023, -PI*1000, PI*1000) / 1000.0; + + // erase the old line + if (val_old != val) { + Robot.stroke(255, 255, 255); + Robot.line(26, 116, x, y); + } + + // the following lines avoid a glitch in the TFT library + // that seems to appear when drawing a vertical line + if (val < 1011 && val > 265 || val < 253) { + //a bit math for drawing the hand inside the clock + x = 16*sin(ang)+26; + y = 16*cos(ang)+116; + } + if (val > 265 && val < 253) { + x = 10; y = 116; + } + if (val >= 1011) { + x = 27; y = 100; + } + Robot.stroke(0, 0, 0); + Robot.line(26, 116, x, y); + val_old = val; +} diff --git a/libraries/Robot_Control/examples/explore/R06_Wheel_Calibration/R06_Wheel_Calibration.ino b/libraries/Robot_Control/examples/explore/R06_Wheel_Calibration/R06_Wheel_Calibration.ino new file mode 100644 index 0000000..c571b3a --- /dev/null +++ b/libraries/Robot_Control/examples/explore/R06_Wheel_Calibration/R06_Wheel_Calibration.ino @@ -0,0 +1,103 @@ +/* 6 Wheel Calibration + + Use this sketch to calibrate the wheels in your robot. + Your robot should drive as straight as possible when + putting both motors at the same speed. + + Run the software and follow the on-screen instructions. + Use the trimmer on the motor board to make sure the + robot is working at its best! + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> // inport the robot librsry +// import the utility library +// a description of its funtionality is below +#include <utility/RobotTextManager.h> + +// arrays to hold the text for instructions +char script1[] ="Wheel Calibration"; +char script2[] ="1. Put Robot on a\n flat surface"; +char script3[] ="2. Adjust speed with the knob on top"; +char script4[] ="3. If robot goes\n straight, it's done"; +char script5[] ="4. Use screwdriver\n on the bottom trim"; +char script6[] ="- Robot turns left,\n screw it clockwise;"; +char script7[] ="- Turns right, screw it ct-colockwise;"; +char script8[] ="5. Repeat 4 until\n going straight"; + +int speedRobot; //robot speed +int calibrationValue; //value for calibrate difference between wheels + +void setup(){ + //necessary initialization sequence + Robot.begin(); + Robot.beginTFT(); + Robot.beginSD(); + + // left and top margin for displaying text + // see below for a description of this + textManager.setMargin(5,5); + // write all instructions at once + writeAllscript(); + +} +void loop(){ + //Control the robot's speed with knob on top + int speedRobot=map(Robot.knobRead(),0,1023,-255,255); + Robot.motorsWrite(speedRobot,speedRobot); + + //read value of the pot on motor baord,to clibrate the wheels + int calibrationValue=map(Robot.trimRead(),0,1023,-30,30); + // print the values to the screen + Robot.debugPrint(calibrationValue,110,145); + delay(40); + +} + +void writeAllscript(){ + //prints 8 scripts one after another + textManager.writeText(0,0,script1); + textManager.writeText(1,0,script2); + textManager.writeText(3,0,script3); + textManager.writeText(5,0,script4); + textManager.writeText(7,0,script5); + textManager.writeText(9,0,script6); + textManager.writeText(11,0,script7); + textManager.writeText(13,0,script8); +} + +/** +textManager mostly contains helper functions for +R06_Wheel_Calibration and R01_Hello_User. + + textManager.setMargin(margin_left, margin_top): + Configure the left and top margin for text + display. The margins will be used by + textManager.writeText(). + Parameters: + margin_left, margin_top: int, the margin values + from the top and left side of the screen. + Returns: + none + + textManager.writeText(line,column,text): + Display text on the specific line and column. + It's different from Robot.text() which + uses pixels for positioning the text. + Parameters: + line:int, which line is the text displayed. Each line + is 10px high. + column:int, which column is the text displayed. Each + column is 8px wide. + text:a char array(string) of the text to be displayed. + Returns: + none +*/ diff --git a/libraries/Robot_Control/examples/explore/R07_Runaway_Robot/R07_Runaway_Robot.ino b/libraries/Robot_Control/examples/explore/R07_Runaway_Robot/R07_Runaway_Robot.ino new file mode 100644 index 0000000..9832d29 --- /dev/null +++ b/libraries/Robot_Control/examples/explore/R07_Runaway_Robot/R07_Runaway_Robot.ino @@ -0,0 +1,78 @@ +/* Runaway Robot + + Play tag with your robot! With an ultrasonic + distance sensor, it's capable of detecting and avoiding + obstacles, never bumping into walls again! + + You'll need to attach an untrasonic range finder to TK1. + + Circuit: + * Arduino Robot + * US range finder like Maxbotix EZ10, with analog output + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +// include the robot library +#include <ArduinoRobot.h> + +int sensorPin = TK1; // pin is used by the sensor + +void setup() { + // initialize the Robot, SD card, and display + Serial.begin(9600); + Robot.begin(); + Robot.beginTFT(); + Robot.beginSD(); + Robot.displayLogos(); + + // draw a face on the LCD screen + setFace(true); +} + +void loop() { + // If the robot is blocked, turn until free + while(getDistance() < 40) { // If an obstacle is less than 20cm away + setFace(false); //shows an unhappy face + Robot.motorsStop(); // stop the motors + delay(1000); // wait for a moment + Robot.turn(90); // turn to the right and try again + setFace(true); // happy face + } + // if there are no objects in the way, keep moving + Robot.motorsWrite(255, 255); + delay(100); +} + +// return the distance in cm +float getDistance() { + // read the value from the sensor + int sensorValue = Robot.analogRead(sensorPin); + //Convert the sensor input to cm. + float distance_cm = sensorValue*1.27; + return distance_cm; +} + +// make a happy or sad face +void setFace(boolean onOff) { + if(onOff) { + // if true show a happy face + Robot.background(0, 0, 255); + Robot.setCursor(44, 60); + Robot.stroke(0, 255, 0); + Robot.setTextSize(4); + Robot.print(":)"); + }else{ + // if false show an upset face + Robot.background(255, 0, 0); + Robot.setCursor(44, 60); + Robot.stroke(0, 255, 0); + Robot.setTextSize(4); + Robot.print("X("); + } +} diff --git a/libraries/Robot_Control/examples/explore/R08_Remote_Control/R08_Remote_Control.ino b/libraries/Robot_Control/examples/explore/R08_Remote_Control/R08_Remote_Control.ino new file mode 100644 index 0000000..fda21cb --- /dev/null +++ b/libraries/Robot_Control/examples/explore/R08_Remote_Control/R08_Remote_Control.ino @@ -0,0 +1,123 @@ +/* 08 Remote Control + + ******************* + *** + ***This example code is in an experimental state. + ***You are welcome to try this with your robot, + ***and no harm will come to it. We will provide a + ***detailed description of an updated version of this + ***in a future update + *** + *** For this example to work you need: + *** + *** - download and install the IR-Remote library by Ken Shirriff + *** to be found at https://github.com/shirriff/Arduino-IRremote + *** - get a Sony remote control + *** + *** This example will be updated soon, come back to the Robot + *** page on the Arduino server for updates!! + *** + ******************* + + If you connect a IR receiver to the robot, + you can control it like you control a TV set. + Using a Sony compatiable remote control, + map some buttons to different actions. + You can make the robot move around without + even touching it! + + Circuit: + * Arduino Robot + * Connect the IRreceiver to TDK2 + * Sony compatible remote control + + based on the IRremote library + by Ken Shirriff + http://arcfn.com + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +// include the necessary libraries +#include <IRremote.h> +#include <ArduinoRobot.h> + +// Define a few commands from your remote control +#define IR_CODE_FORWARD 0x2C9B +#define IR_CODE_BACKWARDS 0x6C9B +#define IR_CODE_TURN_LEFT 0xD4B8F +#define IR_CODE_TURN_RIGHT 0x34B8F + +int RECV_PIN = TKD2; // the pin the IR receiver is connected to +IRrecv irrecv(RECV_PIN); // an instance of the IR receiver object +decode_results results; // container for received IR codes + +void setup() { + // initialize the Robot, SD card, display, and speaker + Robot.begin(); + Robot.beginTFT(); + Robot.beginSD(); + + // print some text to the screen + Robot.stroke(0, 0, 0); + Robot.text("Remote Control code:", 5, 5); + Robot.text("Command:", 5, 26); + irrecv.enableIRIn(); // Start the receiver +} + +void loop() { + // if there is an IR command, process it + if (irrecv.decode(&results)) { + processResult(); + irrecv.resume(); // resume receiver + } +} + +void processResult() { + unsigned long res = results.value; + // print the value to the screen + Robot.debugPrint(res, 5, 15); + + if(res == IR_CODE_FORWARD || res == IR_CODE_BACKWARDS || res == IR_CODE_TURN_LEFT || res == IR_CODE_TURN_RIGHT) { + Robot.fill(255, 255, 255); + Robot.stroke(255, 255, 255); + + Robot.rect(5, 36, 55, 10); + } + switch(results.value){ + case IR_CODE_FORWARD: + Robot.stroke(0, 0, 0); + Robot.text("Forward", 5, 36); + Robot.motorsWrite(255, 255); + delay(300); + Robot.motorsStop(); + break; + case IR_CODE_BACKWARDS: + Robot.stroke(0, 0, 0); + Robot.text("Backwards", 5, 36); + Robot.motorsWrite(-255, -255); + delay(300); + Robot.motorsStop(); + break; + case IR_CODE_TURN_LEFT: + Robot.stroke(0, 0, 0); + Robot.text("Left", 5, 36); + Robot.motorsWrite(-255, 255); + delay(100); + Robot.motorsStop(); + break; + case IR_CODE_TURN_RIGHT: + Robot.stroke(0, 0, 0); + Robot.text("Right", 5, 36); + Robot.motorsWrite(255, -255); + delay(100); + Robot.motorsStop(); + break; + } +} + diff --git a/libraries/Robot_Control/examples/explore/R09_Picture_Browser/R09_Picture_Browser.ino b/libraries/Robot_Control/examples/explore/R09_Picture_Browser/R09_Picture_Browser.ino new file mode 100644 index 0000000..a43348c --- /dev/null +++ b/libraries/Robot_Control/examples/explore/R09_Picture_Browser/R09_Picture_Browser.ino @@ -0,0 +1,159 @@ +/* Picture Browser + + You can make your own gallery/picture show with the + Robot. Put some pictures on the SD card, start the + sketch, they will diplay on the screen. + + Use the left/right buttons to navigate through the + previous and next images. + + Press up or down to enter a mode where you change + the pictures by rotating the robot. + + You can add your own pictures onto the SD card, and + view them in the Robot's gallery! + + Pictures must be uncompressed BMP, 24-bit color depth, + 160 pixels wide, and 128 pixels tall. + + They should be named as "picN.bmp". Replace 'N' with a + number between 0 and 9. + + The current code only supports 10 pictures. How would you + improve it to handle more? + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> // include the robot library + +const int NUM_PICS = 4; //Total number of pictures in Gallery + +// name the modes +const int CONTROL_MODE_KEY = 0; +const int CONTROL_MODE_COMPASS = 1; + +char buffer[] = "pic1.bmp"; // current file name +int i = 1; // Current gallery sequence counter +int mode = 0; // Current mode + +// text to display on screen +char modeNames[][9] = { "keyboard", "tilt " }; + +void setup() { + // initialize the Robot, SD card, display, and speaker + Robot.beginSD(); + Robot.beginTFT(); + Robot.begin(); + + // draw "lg0.bmp" and "lg1.bmp" on the screen + Robot.displayLogos(); + + // draw init3.bmp from the SD card on the screen + Robot.drawBMP("init3.bmp", 0, 0); + + // display instructions + Robot.stroke(0, 0, 0); + Robot.text("The gallery\n\n has 2 modes, in\n keyboard mode, L/R\n key for switching\n pictures, U/D key\n for changing modes", 5, 5); + delay(6000); + Robot.clearScreen(); + Robot.drawBMP("pb.bmp", 0, 0); + Robot.text("In tilt mode,\n quickly tilt the\n robot to switch\n pictures", 5, 5); + delay(4000); +} + +void loop() { + buffer[3] = '0'+i;// change filename of the img to be displayed + Robot.drawBMP(buffer, 0, 0); // draw the file on the screen + // change control modes + switch(mode) { + case CONTROL_MODE_COMPASS: + compassControl(3); + break; + case CONTROL_MODE_KEY: + keyboardControl(); + break; + } + delay(200); +} + +void keyboardControl() { + //Use buttons to control the gallery + while(true) { + int keyPressed = Robot.keyboardRead(); // read the button values + switch(keyPressed) { + case BUTTON_LEFT: // display previous picture + if(--i < 1) i = NUM_PICS; + return; + case BUTTON_MIDDLE: // do nothing + case BUTTON_RIGHT: // display next picture + if(++i > NUM_PICS) i = 1; + return; + case BUTTON_UP: // change mode + changeMode(-1); + return; + case BUTTON_DOWN: // change mode + changeMode(1); + return; + } + } +} + +// if controlling by the compass +void compassControl(int change) { + // Rotate the robot to change the pictures + while(true) { + // read the value of the compass + int oldV = Robot.compassRead(); + + //get the change of angle + int diff = Robot.compassRead()-oldV; + if(diff > 180) diff -= 360; + else if(diff < -180) diff += 360; + + if(abs(diff) > change) { + if(++i > NUM_PICS) i = 1; + return; + } + + // chage modes, if buttons are pressed + int keyPressed = Robot.keyboardRead(); + switch(keyPressed) { + case BUTTON_UP: + changeMode(-1); + return; + case BUTTON_DOWN: + changeMode(1); + return; + } + delay(10); + } +} + +// Change the control mode and display it on the LCD +void changeMode(int changeDir) { + // alternate modes + mode += changeDir; + if(mode < 0) { + mode = 1; + } else if(mode > 1) + mode=0; + + // display the mode on screen + Robot.fill(255, 255, 255); + Robot.stroke(255, 255, 255); + Robot.rect(0, 0, 128, 12); + Robot.stroke(0, 0, 0); + Robot.text("Control:", 2, 2); + Robot.text(modeNames[mode], 52, 2); + delay(1000); +} + diff --git a/libraries/Robot_Control/examples/explore/R10_Rescue/R10_Rescue.ino b/libraries/Robot_Control/examples/explore/R10_Rescue/R10_Rescue.ino new file mode 100644 index 0000000..48044db --- /dev/null +++ b/libraries/Robot_Control/examples/explore/R10_Rescue/R10_Rescue.ino @@ -0,0 +1,124 @@ +/* Robot Rescue + + In this example, the robot enters the line following mode and + plays some music until it reaches its target. Once it finds the + target, it pushes it out of the track. It then returns to the + track and looks for a second target. + + You can make the robot push as many objects as you want to, just + add more to calls to the rescue function or even move that code + into the loop. + + Circuit: + * Arduino Robot + * some objects for the robot to push + * a line-following circuit + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> // include the robot library + +void setup(){ + // initialize the Robot, SD card, display, and speaker + Robot.begin(); + Robot.beginTFT(); + Robot.beginSD(); + Robot.beginSpeaker(); + + // draw "lg0.bmp" and "lg1.bmp" on the screen + Robot.displayLogos(); + + // display the line following instructional image from the SD card + Robot.drawBMP("lf.bmp", 0, 0); + + // play the chase music file + Robot.playFile("chase.sqm"); + + // add the instructions + Robot.text("Rescue\n\n place the robot on\n the rescue track\n pushing the\n obstacles away", 5, 5); + Robot.text("Press the middle\n button to start...", 5, 61); + Robot.waitContinue(); + + // start + Robot.fill(255, 255, 255); + Robot.stroke(255, 255, 255); + Robot.rect(0, 0, 128, 80); // erase the previous text + Robot.stroke(0, 0, 0); + Robot.text("Start", 5, 5); + + // use this to calibrate the line following algorithm + // uncomment one or the other to see the different behaviors of the robot + // Robot.lineFollowConfig(11, 5, 50, 10); + Robot.lineFollowConfig(14, 9, 50, 10); + + // run the rescue sequence + rescueSequence(); + Robot.text("Found obstacle", 5, 12); + // find the track again + goToNext(); + Robot.text("Found track", 5, 19); + // run the rescue sequence a second time + rescueSequence(); + Robot.text("Found obstacle", 5, 26); + + // here you could go on ... + + // write status on the screen + Robot.stroke(0, 0, 0); + Robot.text("Done!", 5, 25); +} + +void loop(){ + //nothing here, the program only runs once. +} + +// run the sequence +void rescueSequence(){ + //set the motor board into line-follow mode + Robot.setMode(MODE_LINE_FOLLOW); + + while(!Robot.isActionDone()){ // wait until it is no longer following the line + } + delay(1000); + + // do the rescue operation + doRescue(); + delay(1000); +} + +void doRescue(){ + // Reached the endline, engage the target + Robot.motorsWrite(200,200); + delay(250); + Robot.motorsStop(); + delay(1000); + + // Turn the robot + Robot.turn(90); + Robot.motorsStop(); + delay(1000); + + // Move forward + Robot.motorsWrite(200,200); + delay(500); + Robot.motorsStop(); + delay(1000); + + // move backwards, leave the target + Robot.motorsWrite(-200,-200); + delay(500); + Robot.motorsStop(); +} + +void goToNext(){ + // Turn the robot + Robot.turn(-90); + Robot.motorsStop(); + delay(1000); +} diff --git a/libraries/Robot_Control/examples/explore/R11_Hello_User/R11_Hello_User.ino b/libraries/Robot_Control/examples/explore/R11_Hello_User/R11_Hello_User.ino new file mode 100644 index 0000000..90fbfff --- /dev/null +++ b/libraries/Robot_Control/examples/explore/R11_Hello_User/R11_Hello_User.ino @@ -0,0 +1,181 @@ +/* Hello User + + Hello User! This sketch is the first thing you see + when starting this robot. It gives you a warm welcome, + showing you some of the really amazing abilities of + the robot, and make itself really personal to you. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> // include the robot library +// include the utility function for ths sketch +// see the details below +#include <utility/RobotTextManager.h> + +char buffer[20];//for storing user name + +void setup(){ + //necessary initialization sequence + Robot.begin(); + Robot.beginTFT(); + Robot.beginSpeaker(32000); + Robot.beginSD(); + + // show the logos from the SD card + Robot.displayLogos(); + + // play the music file + Robot.playFile("menu.sqm"); + + // clear the screen + Robot.clearScreen(); + + // From now on, display different slides of + // text/pictures in sequence. The so-called + // scripts are strings of text stored in the + // robot's memory + + // these functions are explained below + + //Script 6 + textManager.writeScript(5, 4, 0); + textManager.writeScript(9, 10, 0); + Robot.waitContinue(); + delay(500); + Robot.clearScreen(); + + //Script 7 + textManager.writeScript(6, 4, 0); + textManager.writeScript(9, 10, 0); + Robot.waitContinue(); + delay(500); + Robot.clearScreen(); + + //Script 8 + // this function enables sound and images at once + textManager.showPicture("init2.bmp", 0, 0); + + textManager.writeScript(7, 2, 0); + textManager.writeScript(9, 7, 0); + Robot.waitContinue(); + delay(500); + Robot.clearScreen(); + + //Script 9 + textManager.showPicture("init3.bmp", 0, 0); + textManager.writeScript(8, 2, 0); + textManager.writeScript(9, 7, 0); + Robot.waitContinue(); + delay(500); + Robot.clearScreen(); + + //Script 11 + textManager.writeScript(10, 4, 0); + textManager.writeScript(9, 10, 0); + Robot.waitContinue(); + delay(500); + Robot.clearScreen(); + + //Input screen + textManager.writeScript(0, 1, 1); + textManager.input(3, 1, USERNAME); + + textManager.writeScript(1, 5, 1); + textManager.input(7, 1, ROBOTNAME); + + delay(1000); + Robot.clearScreen(); + + //last screen + textManager.showPicture("init4.bmp", 0, 0); + textManager.writeText(1, 2, "Hello"); + Robot.userNameRead(buffer); + textManager.writeText(3, 2, buffer); + + textManager.writeScript(4,10,0); + + Robot.waitContinue(BUTTON_LEFT); + Robot.waitContinue(BUTTON_RIGHT); + textManager.showPicture("kt1.bmp", 0, 0); +} + +void loop(){ + // do nothing here +} + + +/** +textManager mostly contains helper functions for +R06_Wheel_Calibration and R01_Hello_User. + +The ones used in this example: + textManager.setMargin(margin_left, margin_top): + Configure the left and top margin for text + display. The margins will be used for + textManager.writeText(). + Parameters: + margin_left, margin_top: the margin values + from the top and left side of the screen. + Returns: + none + + textManager.writeScript(script_number,line,column): + Display a script of Hello User example. + Parameters: + script_number: an int value representing the + script to be displayed. + line, column: in which line,column is the script + displayed. Same as writeText(). + Returns: + none + + textManager.input(line,column,codename): + Print an input indicator(">") in the line and column, + dispaly and receive input from a virtual keyboard, + and save the value into EEPROM represented by codename + Parameters: + line,column: int values represents where the input + starts. Same as wirteText(). + codename: either USERNAME,ROBOTNAME,CITYNAME or + COUNTRYNAME. You can call Robot.userNameRead(), + robotNameRead(),cityNameRead() or countryNameRead() + to access the values later. + Returns: + none; + + textManager.writeText(line,column,text): + Display text on the specific line and column. + It's different from Robot.text() as the later + uses pixels for positioning the text. + Parameters: + line:in which line is the text displayed. Each line + is 10px high. + column:in which column is the text displayed. Each + column is 8px wide. + text:a char array(string) of the text to be displayed. + Returns: + none + + textManager.showPicture(filename, x, y): + It has the same functionality as Robot.drawPicture(), + while fixing the conflict between drawPicture() and + sound playing. Using Robot.drawPicture(), it'll have + glitches when playing sound at the same time. Using + showPicture(), it'll stop sound when displaying + picture, so preventing the problem. + Parameters: + filename:string, name of the bmp file in sd + x,y: int values, position of the picture + Returns: + none + +*/ diff --git a/libraries/Robot_Control/examples/learn/AllIOPorts/AllIOPorts.ino b/libraries/Robot_Control/examples/learn/AllIOPorts/AllIOPorts.ino new file mode 100644 index 0000000..3520214 --- /dev/null +++ b/libraries/Robot_Control/examples/learn/AllIOPorts/AllIOPorts.ino @@ -0,0 +1,149 @@ +/* + All IO Ports + + This example goes through all the IO ports on your robot and + reads/writes from/to them. Uncomment the different lines inside + the loop to test the different possibilities. + + The TK inputs on the Control Board are multiplexed and therefore + it is not recommended to use them as outputs. The TKD pins on the + Control Board as well as the TK pins on the Motor Board go directly + to the microcontroller and therefore can be used both as inputs + and outputs. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +// use arrays to store the names of the pins to be read +uint8_t arr[] = { TK0, TK1, TK2, TK3, TK4, TK5, TK6, TK7 }; +uint8_t arr2[] = { TKD0, TKD1, TKD2, TKD3, TKD4, TKD5 }; +uint8_t arr3[] = { B_TK1, B_TK2, B_TK3, B_TK4 }; + +void setup(){ + // initialize the robot + Robot.begin(); + + // open the serial port to send the information of what you are reading + Serial.begin(9600); +} + +void loop(){ + // read all the TK inputs at the Motor Board as analog + analogReadB_TKs(); + + // read all the TK inputs at the Motor Board as digital + //digitalReadB_TKs(); + + // read all the TK inputs at the Control Board as analog + //analogReadTKs(); + + // read all the TK inputs at the Control Board as digital + //digitalReadTKs(); + + // read all the TKD inputs at the Control Board as analog + //analogReadTKDs(); + + // read all the TKD inputs at the Control Board as digital + //digitalReadTKDs(); + + // write all the TK outputs at the Motor Board as digital + //digitalWriteB_TKs(); + + // write all the TKD outputs at the Control Board as digital + //digitalWriteTKDs(); + delay(5); +} + +// read all TK inputs on the Control Board as analog inputs +void analogReadTKs() { + for(int i=0;i<8;i++) { + Serial.print(Robot.analogRead(arr[i])); + Serial.print(","); + } + Serial.println(""); +} + +// read all TK inputs on the Control Board as digital inputs +void digitalReadTKs() { + for(int i=0;i<8;i++) { + Serial.print(Robot.digitalRead(arr[i])); + Serial.print(","); + } + Serial.println(""); +} + +// read all TKD inputs on the Control Board as analog inputs +void analogReadTKDs() { + for(int i=0; i<6; i++) { + Serial.print(Robot.analogRead(arr2[i])); + Serial.print(","); + } + Serial.println(""); +} + +// read all TKD inputs on the Control Board as digital inputs +void digitalReadTKDs() { + for(int i=0; i<6; i++) { + Serial.print(Robot.digitalRead(arr2[i])); + Serial.print(","); + } + Serial.println(""); +} + +// write all TKD outputs on the Control Board as digital outputs +void digitalWriteTKDs() { + // turn all the pins on + for(int i=0; i<6; i++) { + Robot.digitalWrite(arr2[i], HIGH); + } + delay(500); + + // turn all the pins off + for(int i=0; i<6; i++){ + Robot.digitalWrite(arr2[i], LOW); + } + delay(500); +} + +// write all TK outputs on the Motor Board as digital outputs +void digitalWriteB_TKs() { + // turn all the pins on + for(int i=0; i<4; i++) { + Robot.digitalWrite(arr3[i], HIGH); + } + delay(500); + + // turn all the pins off + for(int i=0; i<4; i++) { + Robot.digitalWrite(arr3[i], LOW); + } + delay(500); +} + +// read all TK inputs on the Motor Board as analog inputs +void analogReadB_TKs() { + for(int i=0; i<4; i++) { + Serial.print(Robot.analogRead(arr3[i])); + Serial.print(","); + } + Serial.println(""); +} + +// read all TKD inputs on the Motor Board as digital inputs +void digitalReadB_TKs() { + for(int i=0; i<4; i++) { + Serial.print(Robot.digitalRead(arr3[i])); + Serial.print(","); + } + Serial.println(""); +} diff --git a/libraries/Robot_Control/examples/learn/Beep/Beep.ino b/libraries/Robot_Control/examples/learn/Beep/Beep.ino new file mode 100644 index 0000000..1a78673 --- /dev/null +++ b/libraries/Robot_Control/examples/learn/Beep/Beep.ino @@ -0,0 +1,39 @@ +/* + Beep + + Test different pre-configured beeps on + the robot's speaker. + + Possible beeps are: + - BEEP_SIMPLE + - BEEP_DOUBLE + - BEEP_LONG + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +void setup() { + // initialize the robot + Robot.begin(); + + // initialize the sound speaker + Robot.beginSpeaker(); +} +void loop() { + Robot.beep(BEEP_SIMPLE); + delay(1000); + Robot.beep(BEEP_DOUBLE); + delay(1000); + Robot.beep(BEEP_LONG); + delay(1000); +} diff --git a/libraries/Robot_Control/examples/learn/CleanEEPROM/CleanEEPROM.ino b/libraries/Robot_Control/examples/learn/CleanEEPROM/CleanEEPROM.ino new file mode 100644 index 0000000..ae14bdd --- /dev/null +++ b/libraries/Robot_Control/examples/learn/CleanEEPROM/CleanEEPROM.ino @@ -0,0 +1,41 @@ +/* + Clean EEPROM + + This example erases the user information stored on the + external EEPROM memory chip on your robot. + + BEWARE, this will erase the following information: + - your name + - your robots name given by you + - your city and country if you configured them via software + + EEPROMs shouldn't be rewritten too often, therefore the + code runs only during setup and not inside loop. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +void setup(){ + // initialize the robot + Robot.begin(); + + // write empty strings for the different fields + Robot.userNameWrite(""); + Robot.robotNameWrite(""); + Robot.cityNameWrite(""); + Robot.countryNameWrite(""); +} + +void loop(){ + // do nothing +} diff --git a/libraries/Robot_Control/examples/learn/Compass/Compass.ino b/libraries/Robot_Control/examples/learn/Compass/Compass.ino new file mode 100644 index 0000000..4170ab7 --- /dev/null +++ b/libraries/Robot_Control/examples/learn/Compass/Compass.ino @@ -0,0 +1,41 @@ +/* + Compass + + Try the compass both on the robot's TFT + and through the serial port. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +void setup() { + // initialize the robot + Robot.begin(); + + // initialize the robot's screen + Robot.beginTFT(); + + // initialize the serial port + Serial.begin(9600); +} + +void loop() { + // read the compass + int compass = Robot.compassRead(); + + // print out the sensor's value + Serial.println(compass); + + // show the value on the robot's screen + Robot.drawCompass(compass); +} + diff --git a/libraries/Robot_Control/examples/learn/IRArray/IRArray.ino b/libraries/Robot_Control/examples/learn/IRArray/IRArray.ino new file mode 100644 index 0000000..36b4acf --- /dev/null +++ b/libraries/Robot_Control/examples/learn/IRArray/IRArray.ino @@ -0,0 +1,44 @@ +/* + IR array + + Read the analog value of the IR sensors at the + bottom of the robot. The also-called line following + sensors are a series of pairs of IR sender/receiver + used to detect how dark it is underneath the robot. + + The information coming from the sensor array is stored + into the Robot.IRarray[] and updated using the Robot.updateIR() + method. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +void setup(){ + // initialize the robot + Robot.begin(); + + // initialize the serial port + Serial.begin(9600); +} + +void loop(){ + // store the sensor information into the array + Robot.updateIR(); + + // iterate the array and print the data to the Serial port + for(int i=0; i<5; i++){ + Serial.print(Robot.IRarray[i]); + Serial.print(" "); + } + Serial.println(""); +} diff --git a/libraries/Robot_Control/examples/learn/LCDDebugPrint/LCDDebugPrint.ino b/libraries/Robot_Control/examples/learn/LCDDebugPrint/LCDDebugPrint.ino new file mode 100644 index 0000000..0078b77 --- /dev/null +++ b/libraries/Robot_Control/examples/learn/LCDDebugPrint/LCDDebugPrint.ino @@ -0,0 +1,37 @@ +/* + LCD Debug Print + + Use the Robot's library function debugPrint() to + quickly send a sensor reading to the robot's creen. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +int value; + +void setup() { + // initialize the robot + Robot.begin(); + + // initialize the screen + Robot.beginTFT(); +} +void loop(){ + // read a value + value = analogRead(A4); + + // send the value to the screen + Robot.debugPrint(value); + + delay(40); +} diff --git a/libraries/Robot_Control/examples/learn/LCDPrint/LCDPrint.ino b/libraries/Robot_Control/examples/learn/LCDPrint/LCDPrint.ino new file mode 100644 index 0000000..d34168c --- /dev/null +++ b/libraries/Robot_Control/examples/learn/LCDPrint/LCDPrint.ino @@ -0,0 +1,44 @@ +/* + LCD Print + + Print the reading from a sensor to the screen. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +int value; + +void setup() { + // initialize the robot + Robot.begin(); + + // initialize the robot's screen + Robot.beginLCD(); +} + +void loop() { + // read a analog port + value=Robot.analogRead(TK4); + + // write the sensor value on the screen + Robot.fill(0, 255, 0); + Robot.textSize(1); + Robot.text(value, 0, 0); + + delay(500); + + // erase the previous text on the screen + Robot.fill(255, 255, 255); + Robot.textSize(1); + Robot.text(value, 0, 0); +} diff --git a/libraries/Robot_Control/examples/learn/LCDWriteText/LCDWriteText.ino b/libraries/Robot_Control/examples/learn/LCDWriteText/LCDWriteText.ino new file mode 100644 index 0000000..e34a7d2 --- /dev/null +++ b/libraries/Robot_Control/examples/learn/LCDWriteText/LCDWriteText.ino @@ -0,0 +1,41 @@ +/* + LCD Write Text + + Use the Robot's library function text() to + print out text to the robot's screen. Take + into account that you need to erase the + information before continuing writing. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +void setup() { + // initialize the robot + Robot.begin(); + + // initialize the screen + Robot.beginTFT(); +} +void loop() { + Robot.stroke(0, 0, 0); // choose the color black + Robot.text("Hello World", 0, 0); // print the text + delay(2000); + Robot.stroke(255, 255, 255); // choose the color white + Robot.text("Hello World", 0, 0); // writing text in the same color as the BG erases the text! + + Robot.stroke(0, 0, 0); // choose the color black + Robot.text("I am a robot", 0, 0); // print the text + delay(3000); + Robot.stroke(255, 255, 255); // choose the color black + Robot.text("I am a robot", 0, 0); // print the text +} diff --git a/libraries/Robot_Control/examples/learn/LineFollowWithPause/LineFollowWithPause.ino b/libraries/Robot_Control/examples/learn/LineFollowWithPause/LineFollowWithPause.ino new file mode 100644 index 0000000..a3d3fc0 --- /dev/null +++ b/libraries/Robot_Control/examples/learn/LineFollowWithPause/LineFollowWithPause.ino @@ -0,0 +1,49 @@ +/* + Line Following with Pause + + As the robot has two processors, one to command the motors and one to + take care of the screen and user input, it is possible to write + programs that put one part of the robot to do something and get the + other half to control it. + + This example shows how the Control Board assigns the Motor one to + follow a line, but asks it to stop every 3 seconds. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +void setup() { + // initialize the robot + Robot.begin(); + + // initialize the screen + Robot.beginTFT(); + + // get some time to place the robot on the ground + delay(3000); + + // set the robot in line following mode + Robot.setMode(MODE_LINE_FOLLOW); +} + +void loop() { + // tell the robot to take a break and stop + Robot.pauseMode(true); + Robot.debugPrint('p'); + delay(3000); + + // tell the robot to move on + Robot.pauseMode(false); + Robot.debugPrint('>'); + delay(3000); +} diff --git a/libraries/Robot_Control/examples/learn/Melody/Melody.ino b/libraries/Robot_Control/examples/learn/Melody/Melody.ino new file mode 100644 index 0000000..6c049a7 --- /dev/null +++ b/libraries/Robot_Control/examples/learn/Melody/Melody.ino @@ -0,0 +1,62 @@ +/* + Melody + + Plays a melody stored in a string. + + The notes and durations are encoded as follows: + + NOTES: + c play "C" + C play "#C" + d play "D" + D play "#D" + e play "E" + f play "F" + F play "#F" + g play "G" + G play "#G" + a play "A" + A play "#A" + b play "B" + - silence + + DURATIONS: + 1 Set as full note + 2 Set as half note + 4 Set as quarter note + 8 Set as eigth note + + SPECIAL NOTATION: + . Make the previous note 3/4 the length + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + + This code uses the Squawk sound library designed by STG. For + more information about it check: http://github.com/stg/squawk + */ + +#include <ArduinoRobot.h> + +void setup() { + // initialize the robot + Robot.begin(); + + // initialize the sound library + Robot.beginSpeaker(); +} + +void loop() { + // array containing the melody + char aTinyMelody[] = "8eF-FFga4b.a.g.F.8beee-d2e.1-"; + + // play the melody + Robot.playMelody(aTinyMelody); +} diff --git a/libraries/Robot_Control/examples/learn/MotorTest/MotorTest.ino b/libraries/Robot_Control/examples/learn/MotorTest/MotorTest.ino new file mode 100644 index 0000000..baaaf06 --- /dev/null +++ b/libraries/Robot_Control/examples/learn/MotorTest/MotorTest.ino @@ -0,0 +1,41 @@ +/* + Motor Test + + Just see if the robot can move and turn. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +void setup() { + // initialize the robot + Robot.begin(); +} + +void loop() { + Robot.motorsWrite(255,255); // move forward + delay(2000); + Robot.motorsStop(); // fast stop + delay(1000); + Robot.motorsWrite(-255,-255); // backward + delay(1000); + Robot.motorsWrite(0,0); // slow stop + delay(1000); + Robot.motorsWrite(-255,255); // turn left + delay(2000); + Robot.motorsStop(); // fast stop + delay(1000); + Robot.motorsWrite(255,-255); // turn right + delay(2000); + Robot.motorsStop(); // fast stop + delay(1000); +} diff --git a/libraries/Robot_Control/examples/learn/SpeedByPotentiometer/SpeedByPotentiometer.ino b/libraries/Robot_Control/examples/learn/SpeedByPotentiometer/SpeedByPotentiometer.ino new file mode 100644 index 0000000..e97f48d --- /dev/null +++ b/libraries/Robot_Control/examples/learn/SpeedByPotentiometer/SpeedByPotentiometer.ino @@ -0,0 +1,39 @@ +/* + Speed by Potentiometer + + Control the robot's speed using the on-board + potentiometer. The speed will be printed on + the TFT screen. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +void setup() { + // initialize the robot + Robot.begin(); + + // initialize the screen + Robot.beginTFT(); +} + +void loop() { + // read the value of the potentiometer + int val=map(Robot.knobRead(), 0, 1023, -255, 255); + + // print the value to the TFT screen + Robot.debugPrint(val); + + // set the same speed on both of the robot's wheels + Robot.motorsWrite(val,val); + delay(10); +} diff --git a/libraries/Robot_Control/examples/learn/TurnTest/TurnTest.ino b/libraries/Robot_Control/examples/learn/TurnTest/TurnTest.ino new file mode 100644 index 0000000..543c06c --- /dev/null +++ b/libraries/Robot_Control/examples/learn/TurnTest/TurnTest.ino @@ -0,0 +1,32 @@ +/* + Turn Test + + Check if the robot turns a certain amount of degrees. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +void setup() { + // initialize the robot + Robot.begin(); +} + +void loop(){ + Robot.turn(50); //turn 50 degrees to the right + Robot.motorsStop(); + delay(1000); + + Robot.turn(-100); //turn 100 degrees to the left + Robot.motorsStop(); + delay(1000); +} diff --git a/libraries/Robot_Control/examples/learn/TurnTest/TurnTest.ino.orig b/libraries/Robot_Control/examples/learn/TurnTest/TurnTest.ino.orig new file mode 100644 index 0000000..4e3624f --- /dev/null +++ b/libraries/Robot_Control/examples/learn/TurnTest/TurnTest.ino.orig @@ -0,0 +1,37 @@ +/* + Turn Test + + Check if the robot turns a certain amount of degrees. + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +void setup() { + // initialize the robot + Robot.begin(); +} + +<<<<<<< HEAD +void loop() { + Robot.turn(50); //turn 50 degrees to the right +======= +void loop(){ + Robot.turn(50);//turn 50 degrees to the right + Robot.motorsStop(); +>>>>>>> f062f704463222e83390b4a954e211f0f7e6e66f + delay(1000); + + Robot.turn(-100);//turn 100 degrees to the left + Robot.motorsStop(); + delay(1000); +} diff --git a/libraries/Robot_Control/examples/learn/keyboardTest/keyboardTest.ino b/libraries/Robot_Control/examples/learn/keyboardTest/keyboardTest.ino new file mode 100644 index 0000000..5bbc0e5 --- /dev/null +++ b/libraries/Robot_Control/examples/learn/keyboardTest/keyboardTest.ino @@ -0,0 +1,38 @@ +/* + Keyboard Test + + Check how the robot's keyboard works. This example + sends the data about the key pressed through the + serial port. + + All the buttons on the Control Board are tied up to a + single analog input pin, in this way it is possible to multiplex a + whole series of buttons on one single pin. + + It is possible to recalibrate the thresholds of the buttons using + the Robot.keyboardCalibrate() function, that takes a 5 ints long + array as parameter + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +void setup() { + // initialize the serial port + Serial.begin(9600); +} + +void loop() { + // print out the keyboard readings + Serial.println(Robot.keyboardRead()); + delay(100); +} diff --git a/libraries/Robot_Control/examples/learn/keyboardTest/keyboardTest.ino.orig b/libraries/Robot_Control/examples/learn/keyboardTest/keyboardTest.ino.orig new file mode 100644 index 0000000..6ee6c05 --- /dev/null +++ b/libraries/Robot_Control/examples/learn/keyboardTest/keyboardTest.ino.orig @@ -0,0 +1,49 @@ +/* + Keyboard Test + + Check how the robot's keyboard works. This example + sends the data about the key pressed through the + serial port. + + All the buttons on the Control Board are tied up to a + single analog input pin, in this way it is possible to multiplex a + whole series of buttons on one single pin. + + It is possible to recalibrate the thresholds of the buttons using + the Robot.keyboardCalibrate() function, that takes a 5 ints long + array as parameter + + Circuit: + * Arduino Robot + + created 1 May 2013 + by X. Yang + modified 12 May 2013 + by D. Cuartielles + + This example is in the public domain + */ + +#include <ArduinoRobot.h> + +<<<<<<< HEAD +// it is possible to use an array to calibrate +//int vals[] = { 0, 133, 305, 481, 724 }; + +void setup() { + // initialize the serial port + Serial.begin(9600); + + // calibrate the keyboard + //Robot.keyboardCalibrate(vals);//For the new robot only. +======= +void setup(){ + Serial.begin(9600); +>>>>>>> f062f704463222e83390b4a954e211f0f7e6e66f +} + +void loop() { + // print out the keyboard readings + Serial.println(Robot.keyboardRead()); + delay(100); +} |