Slide #1.

Intro to Robot Movement Topics: DC motors Servos Line following
More slides like this


Slide #2.

Many ways to move Focus on wheeled movement
More slides like this


Slide #3.

Alternative drive-trains Mecanum wheel Omni wheel • Demos • Mecanum demo • UNCA demo Image credit: http://members.toast.net/joerger/oldarchive.html
More slides like this


Slide #4.

Making wheels move (using servos) Image credit: http://induino.blogspot.com
More slides like this


Slide #5.

Topic 1: DC Motor Image credit: http://en.wikipedia.org • Electromagnetism: A changing magnetic field makes an electric field. A changing electric field makes a magnetic field. • How it works
More slides like this


Slide #6.

Topic 2: Servos Image credit: http://www.engineersgarage.com • Servo motors can also be retrofitted to provide continuous rotation: – Remove mechanical limit (revert back to DC motor shaft). – Remove pot position sensor (no need to know position) and replace it with Not always 2 equal-valued resistors with a combined resistance equivalent to that of necessary the pot. Makes the servo “think” it is in the 90 deg position.
More slides like this


Slide #7.

Servo control Image credit: http://www.engineersgarage.com • An external controller (such as the Arduino) tells the servo where to go with a signal know as pulse proportional modulation (PPM) or pulse code modulation (which is often confused with pulse width modulation, PWM). • PPM uses 1 to 2ms out of a 20ms time period to encode information.
More slides like this


Slide #8.

PPM 20 ms Image credit: http://www.elprocus.com/servo-motor/ • Each pulse is from 1300 to 1700 microsec (μs) in duration • The pulses repeat about 50 times each second---once every 20 millisec
More slides like this


Slide #9.

Continuous rotation servo and speed • The amount of power applied to the motor is proportional to the distance to be traveled. • If the shaft needs to turn a large distance, the motor runs at full speed. • If it needs to turn a small amount, the motor runs at a slower speed.
More slides like this


Slide #10.

Analog vs digital servos Image credit: http://www.sailservo.co.uk/anvdig.html • Advantages: – Higher and more consistent torque throughout the servo travel – Constant holding power when stationary and less deadband – Faster control response - increased acceleration • Disadvantages: – Higher costs
More slides like this


Slide #11.

Parallax Servo Connections Servo Connector: Black – ground Red – power White – signal Image credit: http://www.parallax.com/
More slides like this


Slide #12.

Calibration Program #include Servo myServo; Servo library void setup() { myServo.attach(9); myServo.writeMicroseconds(1500); // Stop } void loop() { } • The parallax servos are modified servos with the potentiometer intact. • The potentiometer (a.k.a., pot) should be adjusted to make the servo think that it is at the 90 degree mark. Do that now.
More slides like this


Slide #13.

In-Class Activity 1 • Read and work activity 6 in Chapter 2 of Parallax’s Robotics with the Board of Education Shield for Arduino. The activity makes reference to the “BOE Shield,” a piece of hardware designed by Parallax to interface with the Arduino. The shield contains a breadboard as well as a few switches and connectors that we don’t have, but not to worry. The Arduino programs and the information about the Parallax servos are correct for our setup. • Complete the assembly of your boe-bot chassis before beginning activity 6. The completed chassis should include both servos, the arduino, and the breadboard. For power, you can leave your robot tethered to the USB cable or use a battery pack.
More slides like this


Slide #14.

Topic 3: Line Following Pololu QTR-8A Reflectance Sensor Array
More slides like this


Slide #15.

Connect to digital pin QTI sensor Connect to power   Connect to ground  Image credit: http://www.parallax.com/ The QTI is a reflective object sensor. There’s an infrared LED behind its clear window and an infrared phototransistor behind its black window. When the infrared light emitted by the LED reflects off a surface and returns to the black window, it strikes the infrared phototransistor’s base, causing it to conduct current. The more infrared incident on the phototransistor’s base, the more current it conducts.
More slides like this


Slide #16.

Using a sensor array Image: http://hirobotblog.blogspot.com/2012/08/algorithms-2-bit-of-maths.html • Control the servos based on the sensor readings • The more sensors the more accurate the control
More slides like this


Slide #17.

Line following with one sensor? Image credit: http://www.inpharmix.com/jps/PID_Controller_For_Lego_Mindstorms_Robots.html • try to follow the edge of the line
More slides like this


Slide #18.

Code (missing two functions) #include // Include servo library Servo servoLeft; Servo servoRight; // Declare left and right servo objects //Parameters int target = 210; // target sensor reading int maxSpeed = 100; // control forward speed void setup() { // initialization method Serial.begin(9600); servoLeft.attach(12); // Attach left signal to pin 13 servoRight.attach(3); // Attach right signal to pin 12 } void loop() { // main loop auto-repeats int light = (int) rcTime(9); // Read QTI sensor float error = light - target; // Difference between target ¤t reading int speedLeft, speedRight; // Declare speed variables if (error > 0.0) { // over only black? speedLeft = -maxSpeed; // Slow down left wheel speedRight = maxSpeed; // Full speed right wheel } else { // over only white? speedRight = -maxSpeed; // Slow down right wheel speedLeft = maxSpeed; // Full speed left wheel } maneuver(speedLeft, speedRight, 20); // Set wheel speeds }
More slides like this


Slide #19.

rcTime() function // rcTime function measures decay at pin long rcTime(int pin) { pinMode(pin, OUTPUT); digitalWrite(pin, HIGH); delay(5); pinMode(pin, INPUT); digitalWrite(pin, LOW); long time = micros(); while(digitalRead(pin)); time = micros() - time; return time; } // Charge capacitor // ..by setting pin ouput-high // ..for 5 ms // Set pin to input // ..with no pullup // Mark the time // Wait for voltage < threshold // Calculate decay time // Returns decay time
More slides like this


Slide #20.

maneuver() function // maneuver function void maneuver(int speedLeft, int speedRight, int msTime) { servoLeft.writeMicroseconds(1500 + speedLeft); // Set left servo speed servoRight.writeMicroseconds(1500 - speedRight); // Set right servo speed if(msTime==-1) { // if msTime = -1 servoLeft.detach(); servoRight.detach(); } delay(msTime); } // Stop servo signals // Delay for msTime
More slides like this


Slide #21.

Proportional line following Image credit: http://www.inpharmix.com/jps/PID_Controller_For_Lego_Mindstorms_Robots.html • • • • In proportional line following the turn varies smoothly between two limits If the light sensor reading indicates close to the line then do a small turn If far from the line then do a big turn Proportional means there is a linear relationship between the sensor reading and robot movement
More slides like this


Slide #22.

Code: loop() only float kp = 0.5; void loop() { int light = (int)rcTime(9); float error = light - target; int speedLeft, speedRight; if (error > 0.0) { speedLeft = int(maxSpeed - (error * kp)); speedLeft = constrain(speedLeft, -maxSpeed, maxSpeed); speedRight = maxSpeed; } else { speedRight = int(maxSpeed + (error * kp)); speedRight = constrain(speedRight, -maxSpeed, maxSpeed); speedLeft = maxSpeed; } maneuver(speedLeft, speedRight, 20); } // main loop auto-repeats // Declare speed variables // on black only ? // proportion adjust // scale left wheel speed // Full speed right wheel // on white only ? // proportion adjust // scale right wheel speed // Full speed left wheel // Set wheel speeds
More slides like this


Slide #23.

PID control • KP, KI, and KD are tunable constants (i.e., weights) • (KP e) proportional to the current error—the basis of the previous algorithm • (KI ∫e) —the integral is the running sum of the error – integral = integral + error*(dT) • (KD de/dt) —the derivative is the change in the error between two consecutive sensor readings – derivative = ((the current error) - (the previous error)) /(dT) • movement = Kp*(error) + Ki*(integral) + Kd*(derivative)
More slides like this


Slide #24.

Code: part of loop() void loop() { // Main loop auto-repeats int light = (int)rcTime(9); // read sensor float error = light - target; // proportional term int delta = error - prevError; // derivative term integral = integral + error; // integral term prevError = error; float correction = (integralMemory * integral * ki) + (error * kp) + (delta * kd); int speedLeft, speedRight; // Declare speed variables if (correction > 0.0) { // over black only? speedLeft = int(maxSpeed - correction); speedLeft = constrain(speedLeft, -maxSpeed, maxSpeed); speedRight = maxSpeed; } else { // over white only? speedRight = int(maxSpeed + correction); speedRight = constrain(speedRight, -maxSpeed, maxSpeed); speedLeft = maxSpeed; } … Link to the full program
More slides like this


Slide #25.

Two sensors? OR • place them on either side of the line Image credit: http://kile.stravaganza.org/project/lego-robot-line-follower
More slides like this


Slide #26.

Two sensor proportional line following Image credit: http://www.inpharmix.com/jps/PID_Controller_For_Lego_Mindstorms_Robots.html • Control based on the difference between the sensors readings: • Negate left sensor reading • Sum the right and left sensor readings • Move based on the difference Image credit: http://www.seattlerobotics.org/encoder/200011/Line%20Following.htm
More slides like this


Slide #27.

In-Class Activity 2 • Create a two-sensor line-following robot and compete in the in-class competition. • Members of the winning team will each receive 5 extra credit pts.
More slides like this