top of page

Leveraging Behaviors to Create Applications

​

Project:

The arduino-based robot specifically designed to detect and trace lines on a surface. Using sensors, it can autonomously navigate by staying on its path. This technology is commonly used in automation and educational robotics projects..

​

Parts and Materials:

1. Arduino Board: 
   - A microcontroller, like Arduino Uno or Arduino Mega, to act as the brain of the robot.

2. Motors and Wheels:
   - Depending on the size and weight of your robot, you'll need DC motors to drive the robot.
   - Wheels attached to the motors.

3. Motor Driver:
   - To interface and control the DC motors with the Arduino. For example, the L293D or L298N motor driver.

4. Compass Module: 
   - A digital compass like HMC5883L or another similar module to determine the robot's heading.

5. IR Sensors: 
   - For floor marking detection. Depending on your design, you might need more than one.

6. Breadboard and Jumper Wires:
   - For connecting components.

7. Power Source:
   - Batteries to power the Arduino and motors. Depending on the motors you use, you might need a separate power source for them.

8. Chassis:
   - A frame or platform where you mount all the components. You can buy a ready-made one or create one using materials like acrylic or wood.

9. Wheels:
   - To make the robot move. The type and size will depend on the chassis and the motors.

10. Casters/Ball Casters:
   - Useful for providing a third/fourth point of contact with the ground, especially for three-wheeled or differential drive robots.

11. Mounting Hardware:
   - Screws, nuts, bolts, etc., to fix the motors to the chassis and other mounting needs.

12. Optional Components:
   - Encoders: If you need precise control or feedback on the motor's rotation.
   - Ultrasonic or IR distance sensors: If you want to add obstacle avoidance capabilities.
   - LEDs: To indicate robot status or for visual appeal.
   - Push buttons or switches: For user input or turning the robot on/off.


In the realm of robotics, the concept of reusable behaviors has emerged as a fundamental asset. By implementing these behaviors, one can construct innovative applications with remarkable ease and efficiency.

Imagine a scenario: you're managing a restaurant and wish to incorporate technology to enhance the dining experience. What if a robot could seamlessly transfer dishes from the kitchen straight to the dining area? While a complex task would involve direct delivery to individual tables, for the sake of this guide, we'll keep things straightforward. We'll design a robot that ferries food to a central point in the dining space, from where the wait-staff can then serve it to the customers.

At first glance, this task might appear elementary. The robot just needs to shuffle between two fixed spots - one for the kitchen staff to place dishes and another in the dining area as a drop-off point. However, such simplistic navigation isn't as straightforward as it might seem.

A naïve approach might involve programming the robot to move in a straight line between the two designated areas. But this method is fraught with challenges. Even minor deviations in the robot's movements - stemming from factors like wheel size discrepancies or speed differences - can cumulatively lead to significant errors over multiple trips.

Unraveling the Complexity

For illustrative purposes, consider being blindfolded and asked to walk in a straight line, turn around after a set number of steps, and return to the starting point. While a single iteration might be relatively accurate, repeating this process would likely result in a gradual deviation from the intended path.

How could one address this challenge? A human might rely on tactile feedback, like feeling for markers on the ground or using guide rails. Similarly, robots can utilize sensors to help them navigate and correct their course.

Incorporating Sensory Data

Robots equipped with sensors can actively monitor and adjust their route. For instance, an electronic compass could maintain the robot's direction, while cameras could identify floor markings or distinguish color-coded signals in the environment. By leveraging these sensors, the robot can recalibrate its movements, ensuring accuracy and minimizing errors.

Such sensory systems aren't merely adopted from existing robot models. When designing a robot for a specific purpose, it's crucial to explore various sensor options to ascertain which combination will most effectively aid the robot in accomplishing its objectives.

Case in Point

Revisiting our restaurant example, the key lies in integrating the right sensors and programming behaviors to ensure the robot can efficiently transport food from the kitchen to the dining area. Through careful planning and exploration, robotics can indeed revolutionize everyday experiences.

​

Below is a basic sketch for an Arduino-based robot that uses a compass module (like the HMC5883L) for direction and simple IR sensors for floor markings detection:

​

Code:

 

#include <Wire.h>  // For I2C communication with the compass module

// Define pins
const int MOTOR_LEFT_PIN = 2;
const int MOTOR_RIGHT_PIN = 3;
const int IR_SENSOR_PIN = A0;  // Assuming analog IR sensor

// Compass readings
int16_t x, y, z;  // X, Y, Z axis values

void setup() {
  pinMode(MOTOR_LEFT_PIN, OUTPUT);
  pinMode(MOTOR_RIGHT_PIN, OUTPUT);

  // Start Serial for debugging and communication with compass
  Serial.begin(9600);

  // Initialize compass (HMC5883L example)
  Wire.begin();
  Wire.beginTransmission(0x1E);  // Compass address
  Wire.write(0x02);  // Mode register
  Wire.write(0x00);  // Continuous measurement mode
  Wire.endTransmission();
}

void loop() {
  // Read compass
  Wire.beginTransmission(0x1E);
  Wire.write(0x03);  // Data register
  Wire.endTransmission();
  Wire.requestFrom(0x1E, 6);
  if (Wire.available() == 6) {
    x = Wire.read() << 8 | Wire.read();
    z = Wire.read() << 8 | Wire.read();
    y = Wire.read() << 8 | Wire.read();
  }

  // Check if robot is facing North (adjust as necessary)
  if (x > SOME_VALUE) { // Replace SOME_VALUE with a suitable threshold
    moveForward();
  } else {
    correctDirection();
  }

  // Check for floor markings with IR sensor
  int irValue = analogRead(IR_SENSOR_PIN);
  if (irValue > ANOTHER_VALUE) { // Replace ANOTHER_VALUE with a threshold indicating a marking
    stopRobot();
    delay(5000);  // Pause for 5 seconds, for example
    moveForward();
  }
}

void moveForward() {
  digitalWrite(MOTOR_LEFT_PIN, HIGH);
  digitalWrite(MOTOR_RIGHT_PIN, HIGH);
}

void stopRobot() {
  digitalWrite(MOTOR_LEFT_PIN, LOW);
  digitalWrite(MOTOR_RIGHT_PIN, LOW);
}

void correctDirection() {
  // Implement logic to correct robot's direction based on compass readings.
  // This might involve turning the robot left or right until it faces North.
}

​

Explanation:

​

Libraries and Global Variables:

 #include <Wire.h>  // For I2C communication with the compass module

This includes the Wire library, which is used for I2C communication, needed to interface with devices such as the compass module in this code.

// Define pins
const int MOTOR_LEFT_PIN = 2;
const int MOTOR_RIGHT_PIN = 3;
const int IR_SENSOR_PIN = A0;  // Assuming analog IR sensor
Here, you're defining pins for the left and right motors and an IR sensor, which presumably detects floor markings.

// Compass readings
int16_t x, y, z;  // X, Y, Z axis values
These variables store the compass readings from the X, Y, and Z axes.

Setup Function:

void setup() {...}

The setup() function initializes the necessary settings before the main loop starts:

  • The motor pins are set to OUTPUT mode since they control the motors.

  • The serial communication is started at 9600 baud rate, likely for debugging purposes.

  • The compass (in this case, assumed to be the HMC5883L model) is initialized for continuous measurement mode.

Main Loop:

void loop() {...}

This is the main execution loop where the program logic happens:

  1. Reading Compass Data:

    • The compass's data registers are accessed to fetch X, Y, and Z values. These readings are then stored in x, y, and z respectively.

  2. Directional Control:

    • Based on the x value (or the North-South magnetic field component), the robot checks its direction. If the robot is facing North (as denoted by the placeholder SOME_VALUE), it moves forward. Otherwise, it will attempt to correct its direction.

  3. Floor Marking Detection:

    • An analog reading from the IR sensor checks for floor markings. If a floor marking is detected (determined by the placeholder ANOTHER_VALUE), the robot stops, waits for 5 seconds, and then continues moving forward.

Auxiliary Functions:

  • moveForward(): Turns on both motors to move the robot forward.

  • stopRobot(): Turns off both motors, causing the robot to stop.

  • correctDirection(): This function is a placeholder to correct the robot's direction based on compass readings. The actual implementation logic isn't provided, but this is where you'd add code to make the robot turn left or right until it's facing the correct direction (e.g., North).

 

The code represents a simple robot navigation system where the robot tries to move in a particular direction (like North) and stops when it detects certain floor markings.

​

bottom of page