Ardu-Bot-Tom – RF Link Controlled Robot Using Arduino • Tech Projects

[box color=”#985D00″ bg=”#FFF8CB” font=”verdana” fontsize=”14 ” radius=”20 ” border=”#985D12″ float=”right” head=”Major Components in Project” headbg=”#FFEB70″ headcolor=”#985D00″]
Ardu-Bot-Tom List of Materials
Controller Parts:

1x – Arduino Uno

1x – 9V Battery

1x – 433Mhz TX Module

1x – SparkFun Joystick

Robot Parts:

1x – Arduino Uno

2x – 9V Battery

1x – 433Mhz RX Module

1x – TB6612FNG Breakout Board

1x – Pololu 3 1/2” x 2” White Breadboard

1x – Pololu Universal Plate Set

1x – Tamiya Twin Motor Gearbox

2x – Pololu Off-Road Tires

Some Zip-Ties

Some Crazy Glue

Common Parts:

2x – Heat-Shrink Wrappers

1x – SparkFun Inventors Kit

1x – Double Sided Tape Roll
[/box]

Introduction

Ardu-Bot-Tom is a fun project created to show you how you can use wireless transmission modules to send commands to your robots, also it touches some specific subjects such as, servo interfacing and programming, joystick value mapping and the calculations required to determine which way the joystick is pushed, using the Serial Monitor to monitor and debug your robot’s sketch and interfacing and programming the Arduino with the TB6612FNG board. The main idea behind Ardu-Bot-Tom is to create a fun robotics platform which movements can be easily controlled and can be built upon to create a more complex robotic system. The robot is very fun to play with as well, you can make two and have a race, or add huge tires and make a monster truck. In other words, the possibilities are endless in what you can do with the Ardu-Bot-Tom platform. In order to achieve get it working, the project is broken down into four major parts described in the index bellow.

Project Index

Part 1: Controller Interfacing

a. Interfacing the Joystick (Command Generation)

b. Interfacing the TX module (Command Transmission)

Part 2: Programming and Testing the Controller

a. Reading, mapping and sending the joystick commands

b. Testing the controller with the serial monitor

Part 3: Robot Interfacing

a. Interfacing the RX module (Command Reception)

b. Interfacing the Servo (Left and Right)

c. Interfacing the TB6612FNG dual motor driver (Forward and Backwards)

Robot Programming And Testing

a. Receiving and realizing the commands

b. Programming the servo movement

c. Programming the motor driver movement

Part 1. Controller Interfacing

1a. Interfacing the Joystick

Since we are using an analog joystick for this application, the physical interface is pretty straight forward. You will connect the pins as follows:

1b. Interfacing the TX Module

The TX module is very simple as well. Connect it to the Arduino as follows:

Part 2: Programming and Testing the Controller

2a. Reading, Mapping and Sending the Joystick Commands

For those that did not know, the analog joystick consists of a momentary pushbutton and two potentiometers. One represents the X axis and the other one represents the Y axis. By connecting each of the potentiometers to two of our analog pins on the Arduino, and reading in the changes produced by the changing resistance on the pin due to any movement, we can calculate what direction the joystick was pushed towards.

The process is as follows:

When the microcontroller starts up, the setup() function is executed first, here we must read and store the two initial “zero” values for each axis.
After the setup() function executes, the Arduino will enter an infinite loop() function where we must constantly poll the updated values of the two axis and compare them to the initial “zero” values.
We must create 4 variables that will store 4 distance values. The first one is how far is the joystick pushed left from the “zero” point, the second how far right, third up and then down.
We then compare all 4 and find the largest, and that will give us what command we must send to the robot.
Finally we do a Serial.write(‘X’) where X is the command character we want to send.

Note: The command characters are F = Forward, B = Backwards, L = Left and R = Right.

The Controllers Sketch

//Define the input pins for the joystick and the variables to keep track of its state
int vertical = A0,horizontal = A1,vVal,hVal,vZero,hZero;
void setup()
{//Here we set up everyting....
  Serial.begin(4800);
  //Set the initial "zero" vertical position value of the joystick
  vZero = map(analogRead(vertical),0,1023,0,255);
  //Set the initial "zero" horizontal position value of the joystick  
  hZero = map(analogRead(horizontal),0,1023,0,255);
}
void loop()
{ //This will happen over and over and over and over again......
  //Read the vertical pot value
  vVal = map(analogRead(vertical),0,1023,0,255);
  //Read the horizontal pot value  
  hVal = map(analogRead(horizontal),0,1023,0,255);
  //Declare variables to store the cardinal distances from the "zero" point
  //and an offset point to activate a direction  
  int FVal = 0,BVal = 0,RVal = 0,LVal = 0,centerOffset = 15;
  //Find the distance from the ("zero" position value +/- the offset value) 
  //for forward and backwards
  //If the joystick is pushed up passed the "zero" point + the offset value         
  if(vVal > (vZero + centerOffset))
  {
    //store the distance up from the "zero" point
    FVal = vVal - vZero;
    //clear any previous distance from the bottom side    
    BVal = 0;
  }
  //If the joystick is pushed down passed the "zero" point - the offset value
  else if(vVal < (vZero - centerOffset))
  {
    //store the distance down from the "zero" point
    BVal = vZero - vVal;
    //clear any previous distance from the top side    
    FVal = 0;
  }
  //Find the distances from the ("zero" position value +/- the offset value) 
  //for left and right
  //If the joystick is pushed left passed the "zero" point + the offset value
  if(hVal > (hZero + centerOffset))
  {
    //store the distance left from the "zero" point
    LVal = hVal - hZero;
    //clear any previous distance from the right side    
    RVal = 0;
  }
  //If the joystick is pushed right passed the "zero" point - the offset value
  else if(hVal < (hZero - centerOffset))
  {
    //store the distance right from the "zero" point
    RVal = hZero - hVal;
    //clear any previous distance from the left side    
    LVal = 0;
  }
  //Find the largest of the four and that's the direction we are going
  //If the joystick is pushed furthest forward 
  if(FVal > BVal && FVal > RVal && FVal > LVal)
  {
    //then send 'F' through usart
    Serial.write('F');
    //Show what happened in the serial monitor    
    Serial.println("Controller: Moving Forward");
  }
  //If the joystick is pushed furthest backwards 
  else if(BVal > FVal && BVal > LVal && BVal > RVal)
  {
    //then send 'B' through usart
    Serial.write('B');
    //Show what happened in the serial monitor    
    Serial.println("Controller: Moving Backwards");
  }
  //If the joystick is pushed furthest left 
  else if(LVal > RVal && LVal > FVal && LVal > BVal)
  {
    //then send 'L' through usart
    Serial.write('L');
    //Show what happened in the serial monitor
    Serial.println("Controller: Moving Left");
  }
  //If the joystick is pushed furthest right 
  else if(RVal > LVal && RVal > FVal && RVal > BVal)
  {
    //then send 'R' through usart
    Serial.write('R');
    //Show what happened in the serial monitor    
    Serial.println("Controller: Moving Right");
  }
  else
  {
    //The character U keeps continuous 0's and 1's on the serial line which
    Serial.write('U');
    //helps with synchronization at the receiver side    
    Serial.println("Controller: Not Moving");
  }
}

Leave a Comment Cancel Reply