Seed Spreading Robot

You will need:

(x1) Lynxmotion Tri-Track Chassis Kit
(x1) Earthway EV-M-Spred Seed Hopper (or similar)
(x1) Arduino Uno
(x1) Arduino Motor Shield
(x1) Parallax Ping Rangefinder Sensor
(x1) 1/4 Scale Servo
(x1) Lynxmotion 12v battery
(x1) Vex battery charger
(x1) DC power plug
(x3) Multipurpose PCB
(x1) 7805 voltage regulator
(x1) Heat sink
(x1) Thermal transfer paste
(x1) 10 uF capacitor
(x4) 0.1uF capacitor
(x1) 1K resistor
(x20) Header pins
(x1) ATS177 hall effect sensor
(x2) 1/8" rare earth magnet
(x4) 1-1/4" aluminum spacers
(x4) 1-1/2" x 6-32 nuts and bolts
(x1) 12" x 24" x 1/8" acrylic
(x1) 6" x 6" x 1/4" plywood
(x12) 1/4" nylon spacers
(x12) 1" x 6-32 nuts and bolts
(x4) 1-1/2" x 4-40 nuts and bolts
(x8) 1/4" nylon spacers
(x6) pens
(x6) 1/4 x 6" nuts and bolts
(x4) 1-1/4" aluminum spacers
(x4) 2" x 6-32 nuts and bolts
(x1) Assorted zip ties
(x1) Assorted shrink tube
(x1) Krazy Glue (gel)
(x1) Thread lock
(x1) 24" x 24" cardboard sheet

You will also need to download and cut out the following files:

SensorHolder.eps -- cut out of 1/8" acrylic and etch away the black square 1/16" down
HopperDrillBracket.eps -- cut out of cardboard
TopBracket.eps -- cut out of 1/8" acrylic
ServoBracket.eps -- cut out of 1/8" acrylic
ServoConnector.eps -- cut out of 1/4" plywood
BottomDrillBracket.eps -- cut out of cardboard
PingBracket.eps -- cut out of 1/8" acrylic

(Note that some of the links on this page are affiliate links. This does not change the cost of the item for you. I reinvest whatever proceeds I receive into making new projects. If you would like any suggestions for alternative suppliers, please let me know.)

Assemble the treads by lining them up side-by-side, inserting a clear tube between the aligned rings, and pressing in the plastic pins until they snap in place.

You should be left with two long strips. Set aside the hardware necessary for closing the loops for later.

/*

 Hall Effect Example Code
 
 * Connect a 1K resistor from 5V to pin 2.
 * Connect a 0.1uF capacitor between pin 2 and ground.
 * Connect the hall effect output pin to pin 2.
 * Connect power and ground from the Arduino to the appropriate hall effect sensor pins.
 
 
 This example code is in the public domain.
 
 */

int sensorPin1 = 2;  // sensor on pin 2
int sensorState1;    // variable for reading the sensor


void setup() {

  //set pin 2 as an input
  pinMode(sensorPin1, INPUT);        

  //begin communication to the serial monitor
  Serial.begin(9600);

}

void loop(){
 
  // read the sensor pin
  sensorState1 = digitalRead(sensorPin1);


  // check if the sensor is activated.
  // if it is, the sensor goes LOW:
  if (buttonState1 == LOW) {    
    // print to the serial monitor:   
    Serial.println("magnet present");
  }

}

/*

Seed Spreading Robot Example Code

For more information visit:
https://www.instructables.com/id/Seed-Spreading-Robot/

This code is in the public domain.
    
 
 */

int motorRotateCounter = 0;   // counter for the number of motor rotations
int hallState = 0;         // current state of hall effect sensor
int lastHallState = 0;     // previous state of the hall effect sensor

  // establish variables for duration of the ping,
  // and the distance result in inches and centimeters: 
  long duration, inches, cm;
 


// servo2 is connected to Arduino pin10
#define servo2control OCR1B    

//servo constants -- trim as needed
#define servo2null 2980

//////////

const int pingPin = 7;

//////////

int StoredMotorData = 0;

//change this number to change the amount of left / right rotation - in milliseconds
int LeftRotation = 900;
int RightRotation = 1000;


//how soon the robot will brake from obstacles - in inches
int wallDistance = 15;

//the tightness of stripes across the lawn
int nextRow = 1000;




void setup() {
  pinMode(5, INPUT);  //hall effect
  pinMode(10,OUTPUT); //servo PWM pin
 
 
  TCCR1B = 0b00011010;        // Fast PWM, top in ICR1, /8 prescale (.5 uSec)
  TCCR1A = 0b00100010;        //clear on compare match, fast PWM
                      // to use pin 9 as normal input or output, use  TCCR1A = 0b00100010
                      // to use pin 10 as normal input or output, use  TCCR1A = 0b10000010
  ICR1 =  39999;            // 40,000 clocks @ .5 uS = 20mS
  servo2control = servo2null;       // controls chip pin 16  ARDUINO pin 10
 
 
  //Setup Channel A
  pinMode(12, OUTPUT); //Initiates Motor Channel A pin
  pinMode(9, OUTPUT); //Initiates Brake Channel A pin

  //Setup Channel B
  pinMode(13, OUTPUT); //Initiates Motor Channel A pin
  pinMode(8, OUTPUT);  //Initiates Brake Channel A pin
 
  //wait 5 seconds before going
  delay(5000);
 
  //set inches above one foot
  inches = 24;
 
  Serial.begin(9600);
}




void loop() {
 // disengageBrake(); 
  //drive forward
  forward();
 
  //Start the seed spreader servo
  servo2control = 2000; 
  delay(10);
 
  checkForRotation();
 
  PingRead();
 
  //PING sensor test
  //Serial.println(inches);

  if(inches < wallDistance) {
   
    //stop driving
    engageBrake();
   
    //stop the seed spreader
    servo2control = servo2null;
   
    //wait two seconds
    delay(2000);
   
    //check the distance again.
    //this is to account for things moving in front of it briefly
    //and false readings
    PingRead();
   
      //if there is still something in front of it, it is probably the fence
      if(inches < wallDistance) {
       
        //let's record how many rotations the motor made to get across the lawn
        StoredMotorData = motorRotateCounter;
       
        //and then we reset the motor rotation counter
        motorRotateCounter = 0;
       
       
        //enable the motor to move
        disengageBrake();
       
        //let us turn right
        right();
       
        //this delay determines the amount of rotation.
        //from tests on hardwood floors 1 second (1000 microseconds) is roughly 90 degrees.
        //will probably need to be tweeked for lawn. Change rotation value above
        //to set rotation delay for the entire code.
        delay(RightRotation);
       
        //stop driving
        engageBrake();
       
        //
        // DRIVE FORWARD A LITTLE HERE
        //
        delay(100);
        disengageBrake();
        forward();      
        delay(nextRow);
        engageBrake();       
       
       
        //
        // CHECK DISTANCE - IF WALL WITHIN DISTANCE --> THEN STOP!!!!!
        //
       
        if(inches < wallDistance) {
           
            //wait two seconds
            delay(2000);
           
            //check the distance again.
            //this is to account for things moving in front of it briefly
            //and false readings
            PingRead();
           
            //if there is still something in front of it, it is probably the fence
            if(inches < wallDistance) {
             
              while(1) { };
            }
        }   
          
        //
        // right again
        //
        delay(500);
        disengageBrake();
        right();      
        delay(RightRotation);
        engageBrake();
       
       
        //
        // DRIVE FORWARD MOTORROTATIONS
        // ENGAGE SERVO
        //
        servo2control = 2000;     
        disengageBrake();
        while((StoredMotorData + 5) > motorRotateCounter){
          forward();
          delay(50);
          checkForRotation();
        }
       
        motorRotateCounter = 0;
        StoredMotorData = 0;
        engageBrake();
        servo2control = servo2null;
       
        //
        // TURN LEFT
        //
       
        delay(500);
        disengageBrake();       
        left();
        delay(LeftRotation);
        engageBrake();       
       
        //
        // DRIVE FORWARD A LITTLE HERE
        //
        delay(100);
        disengageBrake();
        forward();      
        delay(nextRow);
        engageBrake();       
       
       
        //
        // CHECK DISTANCE - IF WALL WITHIN DISTANCE --> THEN STOP!!!!!
        //
       
        if(inches < wallDistance) {
           
            //wait two seconds
            delay(2000);
           
            //check the distance again.
            //this is to account for things moving in front of it briefly
            //and false readings
            PingRead();
           
            //if there is still something in front of it, it is probably the fence
            if(inches < wallDistance) {
             
              while(1) { };
            }
        }   
          
        //
        // left again
        //
        delay(500);
        disengageBrake();
        left();      
        delay(LeftRotation);
        engageBrake();
       
       
       


       
        //wait two seconds before driving back
        delay(2000);
      }
    }
  }



void checkForRotation() {
    // read the hall effect input pin:
  hallState = digitalRead(5);

  // compare the hall effect state to its previous state
  if (hallState != lastHallState) {
    // if the state has changed, increment the counter
    if (hallState == HIGH) {
      // if the current state is HIGH then the sensor
      // wend from off to on:
      motorRotateCounter++;
      Serial.print("number of half rotations pushes:  ");
      Serial.println(motorRotateCounter);
    }
  }
  // save the current state as the last state,
  //for next time through the loop
  lastHallState = hallState;
}


/////////////////////????////
//  drive motor functions  //
/////////////////////////////


void engageBrake() {
  digitalWrite(8, HIGH);  //Engage the Brake for Channel A
  digitalWrite(9, HIGH);  //Engage the Brake for Channel B
}

void disengageBrake() {
  digitalWrite(8, LOW);  //Engage the Brake for Channel A
  digitalWrite(9, LOW);  //Engage the Brake for Channel B
}


void forward() {
 
  //Motor A forward @ full speed
  digitalWrite(12, LOW); //Establishes forward direction of Channel A
  digitalWrite(9, LOW);   //Disengage the Brake for Channel A
  analogWrite(3, 255);   //Spins the motor on Channel A at full speed

  //Motor B backward @ half speed
  digitalWrite(13, HIGH);  //Establishes backward direction of Channel B
  digitalWrite(8, LOW);   //Disengage the Brake for Channel B
  analogWrite(11, 255);    //Spins the motor on Channel B at half speed
 
}

void backward() {
 
  //Motor A forward @ full speed
  digitalWrite(12, HIGH); //Establishes forward direction of Channel A
  digitalWrite(9, LOW);   //Disengage the Brake for Channel A
  analogWrite(3, 255);   //Spins the motor on Channel A at full speed

  //Motor B backward @ half speed
  digitalWrite(13, LOW);  //Establishes backward direction of Channel B
  digitalWrite(8, LOW);   //Disengage the Brake for Channel B
  analogWrite(11, 255);    //Spins the motor on Channel B at half speed
 
}

void left() {
 
  //Motor A forward @ full speed
  digitalWrite(12, HIGH); //Establishes forward direction of Channel A
  digitalWrite(9, LOW);   //Disengage the Brake for Channel A
  analogWrite(3, 255);   //Spins the motor on Channel A at full speed

  //Motor B backward @ half speed
  digitalWrite(13, HIGH);  //Establishes backward direction of Channel B
  digitalWrite(8, LOW);   //Disengage the Brake for Channel B
  analogWrite(11, 255);    //Spins the motor on Channel B at half speed
 
}

void right() {
 
  //Motor A forward @ full speed
  digitalWrite(12, LOW); //Establishes forward direction of Channel A
  digitalWrite(9, LOW);   //Disengage the Brake for Channel A
  analogWrite(3, 255);   //Spins the motor on Channel A at full speed

  //Motor B backward @ half speed
  digitalWrite(13, LOW);  //Establishes backward direction of Channel B
  digitalWrite(8, LOW);   //Disengage the Brake for Channel B
  analogWrite(11, 255);    //Spins the motor on Channel B at half speed
 
}

/////////////////////////////////
//  distance sensor functions  //
/////////////////////////////////

void PingRead() {


  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);

  // The same pin is used to read the signal from the PING))): a HIGH
  // pulse whose duration is the time (in microseconds) from the sending
  // of the ping to the reception of its echo off of an object.
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);

  // convert the time into a distance
  inches = microsecondsToInches(duration);
 
  delay(100);
 
}

//for PING second to inch conversion

long microsecondsToInches(long microseconds)
{
  // According to Parallax's datasheet for the PING))), there are
  // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
  // second).  This gives the distance travelled by the ping, outbound
  // and return, so we divide by 2 to get the distance of the obstacle.
  // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
  return microseconds / 74 / 2;
}

Assuming your lawn is square and has an L-shaped fence (or U-shaped fence... or you are a total weirdo and it is completely fenced in...), place the robot such that it is pointing in a straight line towards the end segment of the L, and will be turning right to move to the side wall. If this description makes little sense, check out the diagram.

Basically, the way that this is working is that it engages the seed spreader, travels towards the far fence, and counts the number of motor rotations it takes to get there. Once it is within a few inches of the wall, it turns right and travels about a foot and a half (disengaging the seed spreader). It then turns right again and travels back across the lawn (engaging the seed spreader). However, since there is no longer a wall to sense, the robot counts the number of motor rotations and travels back the same distance it traveled towards the wall. When it gets back to this side, it turns left, travels about a foot and a half (disengaging the seed spreader), turns left again (engaging the seed spreader), and then repeats the routine. The routine is repeated until it turns to the side and encounters the side wall within a foot's distance (or so).

In theory, the robot should perfectly cover the lawn with grass seed. In reality, it will draw probably draw a weird modernist zig zag pattern.

One major thing which still needs tweaking is that inserting grass seed makes the bot top heavy and forces the rangefinder sensor to point slightly downwards. As the robot bounces along the lawn, it sometimes senses the ground and stops short of the wall. I think this can be solved by angling the sensor upwards and adding some debouncing to the code.

This is still a work in progress and I welcome anyone who thinks that they can develop better solutions to this problem to take a stab at it.