Open Source Flipper Zero, Thread, Matter, and Zigbee on ESP32, Arduino go Zephyr, and more!

0:00:00 / -

Watch now on YouTube Watch now

Nox - A House Wandering Robot (ros)

Made by electrouser1021 / Robotics

About the project

Nox is a nice (and time-consuming) robot which uses SLAM (ROS) with a Kinect to navigate in its environment.

Project info

Difficulty: Difficult

Platforms: Adafruit, Arduino, Raspberry Pi, ROS

Estimated time: 4 months

License: GNU General Public License, version 3 or later (GPL3+)

Items used in this project

Hardware components

	Grove IoT Dev Kit Microsoft Azure	x 1
	DC MOTOR click	x 2
	Motor/Stepper/Servo Shield for Arduino	x 1
	Bluno MEGA 2560	x 1
	Raspberry Pi 3 Model B	x 1

Software apps and online services

	Arduino IDE
	ROS Robot Operating System

Hand tools and fabrication machines

Soldering iron (generic)

x 1

Story

Nox is a differential-drive robot built using ROS, Raspberry Pi and Arduino. I started the project as a robot base with basic navigation I could then use for other things, like a vacuum cleaner. However I quickly decided to make it a standalone robot with a proper design, as it's often missing in DIY robots. In its current state the robot can use SLAM (gmapping) to create a map of its surroundings (using the Kinect depth perception to detect wall and obstacles) and localize itself within the map. It can plan a path to a given goal and drive to it avoiding obstacles.

RViz view

Nox is powered by a 11.1v Lithium-Ion battery and driven by two motors. The front panel can be removed to change the battery. A slotted hole and a screw fasten it and allow to put batteries of different lengths. I put a battery alarm with a screen to monitor the level.

The motors are two 12v DC motors (107rpm) from Banggood. They are nice but I actually don't need the robot to go that fast and I would have been okay to trade some of the speed for more accurate encoders.

About the design, the main constrain was to have something that integrates well with the Kinect, as I was building the robot around it. I was inspired by the triangular look of a lot of modern style objects (and a lot by Deus Ex I have to admit). I really wanted to have a nice and professional looking robot as it's something that's often missing in DIY robots (but don't worry the wiring is as messy as it should be). Spending a few weeks on the CAD model to tweak everything was necessary.

3D rendering

The lights on the side are recycled from a New Year's Eve glowing stick I got for free and serve to indicate the robot states. When the Arduino is not connected to the ROS master (indicating that the robot program has not started yet) the lights blink three times in a row very quickly. When driving, the lights have a more "breathing"-looking blink and the blinking speed depends on the robot speed.

Not connect blinking

Idle blinking

Structure

As stated above, the robot is a differential drive one, so the motor are placed on the same axis. The base is made of wood with two caster wheels for support. I initially planned on using one caster wheel to avoid the hyperstatic thing but couldn't find a good-sized one. The rest of the structure is made mainly of wood and metal brackets, easy to find in any DIY retail store. On the rear part of the robot plates can be stacked to put the electronic boards on.

The carter is made of black plastic plate, cut and glued by hand (will definitely use 3D printing next time).

Hardware

On the inside the main controller is a Raspberry Pi 3B running Ubuntu and ROS. The Raspberry can be accessed from a outside computer through WiFi and ssh to give order to the robot. The ROS program carries out odometry calculation, navigation planning, and mapping using the Kinect. The Raspberry Pi sends the velocity command to an Arduino which controls the two motors with a PID through an Adafruit Motor Shield. It reads the value of the encoder, calculate the speed of each motor and send back the value to the Raspberry for odometry calculation. Arduino and Raspberry Pi are connected by USB and the Arduino program acts as a ROS node (look for rosserial for more info).

I used different types of Arduino before settling down for the good one. At first I used the basic Arduino Uno but I didn't have enough interrupt pins to read the encoder values with (the best method to do so with Arduino). The speed and accuracy were limited as I had to resort to other programing tricks to make it work. I tried using an Arduino Leonardo but the limiting factor was memory and I had to finally switch to an Arduino Mega 2560. A blessing in disguise as I have plenty of memory and pins left to add new functions now.

Kinect 360 was part of the project from the start, as I wanted to do SLAM (Simultaneous Localization And Mapping) but without spending a ton of money on a lidar. A kinect is basically a 25€ 3D-camera (of course don't expect the same accuracy as an Hokuyo) and, in addition to the depth scanning needed for SLAM, can be also used for computer vision, has an accelerometer and a microphone array. All of which being handy for the following steps of the project.

Two DC converters are used to convert the voltage. The motor are running directly with the battery voltage (more or less 11.1v). The command part (including Raspberry Pi, Arduino and encoders) is running on 5V converted from the battery. The Kinect needs a 12v stabilized voltage and a converter provides it from the battery too.

Software

On the software part, I used ROS Kinetic. The only node I really wrote is the "nox_controller" which, as his name doesn't really imply, is used to compute the odometry from the Arduino >On Differential Drive Robot Odometry with Application to Path Planning" (I actually did my own formulas but they are the same, anyway the paper is worth a read). Covariance matrices are given in the odometry but not currently used (however it will become useful if I'm integrating a IMU to the odometry).

In the Arduino the motor control is done through PWM. A PID is supposed to manage each motor speed but as the PWM/motor speed ratio is very linear I got good result with a direct command of the speed and desactivated the PID for now. Don't worry though correct PID implementation and calibration is on its way.

Mapping and Path Planning

The algorithm used for SLAM is gmapping. A nice implementation already exists on ROS and I used it. I plan to try RGB-D SLAM in the near future.

Concerning the path planning, I tried different local planners available on ROS and settled with DWA local planner, as it gives the best result for differential drive robots. I still have a lot of tweaking to do as Nox can sometimes got stuck getting to close to a door or some obstacles. Moreover after some time navigating and especially if the robot is changing rooms, the map starts to get messy and the robot got lost. I mainly blame the quality of the kinect (also the shaking of it) and the odometry for that. Fusing the odometry from the encoder with an IMU could be a next step in solving this issue.

In order to get the best odometry as I could, I did some calibration. I basically drove the robot in a straight line, measured the distance from the starting point manually and compared it with the odometry distance. With the difference between the two I computed a scale to correct the odometry measure. I did the same thing for the rotation by rotating the robot on its own and comparing the odometry with the reality. You can check ROS navigation tuning guide and the paper it's partially based one here for more information.

Next steps in the project:

Totally independent on-board navigation (currently still relies for some part on an outside computer) with random goal spawning or exploring behavior.

Fusing the odometry with an IMU (ROS proposes nice implementations of Kalman filters) to improve the accuracy

Use OpenCV to add some computer vision features

Implement voice recognition (I was thinking about using HARK-ROS but if anyone as a suggestion, I'm open to it)

I would like to thank and give credit to the following:

Sungjik's project which was the biggest inspiration to make my own robot

"ROS Navigation Tuning Guide" by Kaiyu Zheng

"How to connect Kinect to Raspberry Pi 2 or 3 with ROS" Youtube video by Robotics Weekends

"Communication between Raspberry Pi and PC (ROS)" by mktk1117

"On Differential Drive Robot Odometry with Application to Path Planning" by Evangelos Papadopoulos and Michael Misailidis

Turtlebot programs

Prof. Shuro Nakajima from Wakayama University where I got the occasion to learn by working on the PMV (Personal Mobility Vehicle) project (check it it's awesome)

Everyone in the ROS community that got the same problems as me and the ones who answered them

Schematics, diagrams and documents

Nox general schematic

CAD, enclosures and custom parts

Nox CAD model (Solidworks)

Soliworks CAD model of Nox

Go to download

Code

Arduino motor controller

The Adafruit library has been modified to allow braking the motor. Check here for more information: https://forums.adafruit.com/viewtopic.php?t=60084

#include <Adafruit_MotorShield.h>
#include <Wire.h>
#include <PID_v1.h>
#include <ros.h>
#include <std_msgs/String.h>
#include <geometry_msgs/Vector3Stamped.h>
#include <geometry_msgs/Twist.h>
#include <ros/time.h>
 
//initializing all the variables
#define LOOPTIME                      100     //Looptime in millisecond
const byte noCommLoopMax = 10;                //number of main loops the robot will execute without communication before stopping
unsigned int noCommLoops = 0;                 //main loop without communication counter

char log_msg[50];
char result[8];
double speed_cmd_left2 = 0;      

const int PIN_ENCOD_A_MOTOR_LEFT = 2;               //A channel for encoder of left motor                    
const int PIN_ENCOD_B_MOTOR_LEFT = 4;               //B channel for encoder of left motor

const int PIN_ENCOD_A_MOTOR_RIGHT = 3;              //A channel for encoder of right motor         
const int PIN_ENCOD_B_MOTOR_RIGHT = 5;              //B channel for encoder of right motor 

const int PIN_SIDE_LIGHT_LED = 46;                  //Side light blinking led pin

unsigned long lastMilli = 0;
const double radius = 0.04;                   //Wheel radius, in m
const double wheelbase = 0.187;               //Wheelbase, in m

double speed_req = 0;                         //Desired linear speed for the robot, in m/s
double angular_speed_req = 0;                 //Desired angular speed for the robot, in rad/s

double speed_req_left = 0;                    //Desired speed for left wheel in m/s
double speed_act_left = 0;                    //Actual speed for left wheel in m/s
double speed_cmd_left = 0;                    //Command speed for left wheel in m/s 

double speed_req_right = 0;                   //Desired speed for right wheel in m/s
double speed_act_right = 0;                   //Actual speed for right wheel in m/s
double speed_cmd_right = 0;                   //Command speed for right wheel in m/s 
                        
const double max_speed = 0.4;                 //Max speed in m/s

int PWM_leftMotor = 0;                     //PWM command for left motor
int PWM_rightMotor = 0;                    //PWM command for right motor 
                                                      
// PID Parameters
const double PID_left_param[] = { 0, 0, 0.1 }; //Respectively Kp, Ki and Kd for left motor PID
const double PID_right_param[] = { 0, 0, 0.1 }; //Respectively Kp, Ki and Kd for right motor PID

volatile float pos_left = 0;       //Left motor encoder position
volatile float pos_right = 0;      //Right motor encoder position

PID PID_leftMotor(&speed_act_left, &speed_cmd_left, &speed_req_left, PID_left_param[0], PID_left_param[1], PID_left_param[2], DIRECT);          //Setting up the PID for left motor
PID PID_rightMotor(&speed_act_right, &speed_cmd_right, &speed_req_right, PID_right_param[0], PID_right_param[1], PID_right_param[2], DIRECT);   //Setting up the PID for right motor

Adafruit_MotorShield AFMS = Adafruit_MotorShield();  // Create the motor shield object with the default I2C address
Adafruit_DCMotor *leftMotor = AFMS.getMotor(1);      //Create left motor object
Adafruit_DCMotor *rightMotor = AFMS.getMotor(2);     //Create right motor object
  
ros::NodeHandle nh;

//function that will be called when receiving command from host
void handle_cmd (const geometry_msgs::Twist& cmd_vel) {
  noCommLoops = 0;                                                  //Reset the counter for number of main loops without communication
  
  speed_req = cmd_vel.linear.x;                                     //Extract the commanded linear speed from the message

  angular_speed_req = cmd_vel.angular.z;                            //Extract the commanded angular speed from the message
  
  speed_req_left = speed_req - angular_speed_req*(wheelbase/2);     //Calculate the required speed for the left motor to comply with commanded linear and angular speeds
  speed_req_right = speed_req + angular_speed_req*(wheelbase/2);    //Calculate the required speed for the right motor to comply with commanded linear and angular speeds
}

ros::Subscriber<geometry_msgs::Twist> cmd_vel("cmd_vel", handle_cmd);   //create a subscriber to ROS topic for velocity commands (will execute "handle_cmd" function when receiving data)
geometry_msgs::Vector3Stamped speed_msg;                                //create a "speed_msg" ROS message
ros::Publisher speed_pub("speed", &speed_msg);                          //create a publisher to ROS topic "speed" using the "speed_msg" type

const int lightIncNumber = 30;                                                                                                                                       //Number of lightIncrements for side light blinking
int lightInc = 0;                                                                                                                                                    //Init increment for side light blinking
int lightValue [lightIncNumber]= { 10, 40, 80, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 160, 80, 40, 10, 0, 0, 0, 0, 0, 0, 0, 0 }; //side light increment values
int lightValueNoComm [25]= { 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; //side light increment values
int lightT = 0; //init light period

//__________________________________________________________________________

void setup() {

  
  pinMode(PIN_SIDE_LIGHT_LED, OUTPUT);      //set pin for side light leds as output
  analogWrite(PIN_SIDE_LIGHT_LED, 255);     //light up side lights
  
  nh.initNode();                            //init ROS node
  nh.getHardware()->setBaud(57600);         //set baud for ROS serial communication
  nh.subscribe(cmd_vel);                    //suscribe to ROS topic for velocity commands
  nh.advertise(speed_pub);                  //prepare to publish speed in ROS topic
 
  AFMS.begin();
  
  //setting motor speeds to zero
  leftMotor->setSpeed(0);
  leftMotor->run(BRAKE);
  rightMotor->setSpeed(0);
  rightMotor->run(BRAKE);
 
  //setting PID parameters
  PID_leftMotor.SetSampleTime(95);
  PID_rightMotor.SetSampleTime(95);
  PID_leftMotor.SetOutputLimits(-max_speed, max_speed);
  PID_rightMotor.SetOutputLimits(-max_speed, max_speed);
  PID_leftMotor.SetMode(AUTOMATIC);
  PID_rightMotor.SetMode(AUTOMATIC);
    
  // Define the rotary encoder for left motor
  pinMode(PIN_ENCOD_A_MOTOR_LEFT, INPUT); 
  pinMode(PIN_ENCOD_B_MOTOR_LEFT, INPUT); 
  digitalWrite(PIN_ENCOD_A_MOTOR_LEFT, HIGH);                // turn on pullup resistor
  digitalWrite(PIN_ENCOD_B_MOTOR_LEFT, HIGH);
  attachInterrupt(0, encoderLeftMotor, RISING);

  // Define the rotary encoder for right motor
  pinMode(PIN_ENCOD_A_MOTOR_RIGHT, INPUT); 
  pinMode(PIN_ENCOD_B_MOTOR_RIGHT, INPUT); 
  digitalWrite(PIN_ENCOD_A_MOTOR_RIGHT, HIGH);                // turn on pullup resistor
  digitalWrite(PIN_ENCOD_B_MOTOR_RIGHT, HIGH);
  attachInterrupt(1, encoderRightMotor, RISING);
}

//_________________________________________________________________________

void loop() {
  nh.spinOnce();
  if((millis()-lastMilli) >= LOOPTIME)   
  {                                                                           // enter timed loop
    lastMilli = millis();
    
    if (!nh.connected()){
      analogWrite(PIN_SIDE_LIGHT_LED, lightValueNoComm[lightInc]);
      lightInc=lightInc+1;
      if (lightInc >= 25){
        lightInc=0;
      }
    }
    else{
      analogWrite(PIN_SIDE_LIGHT_LED, lightValue [lightInc]);
      lightT = 3000 - ((2625/max_speed)*((abs(speed_req_left)+abs(speed_req_right))/2));
      lightInc=lightInc+(30/(lightT/LOOPTIME));
      if (lightInc >= lightIncNumber){
        lightInc=0;
      }
    }
    
    
    if (abs(pos_left) < 5){                                                   //Avoid taking in account small disturbances
      speed_act_left = 0;
    }
    else {
      speed_act_left=((pos_left/990)*2*PI)*(1000/LOOPTIME)*radius;           // calculate speed of left wheel
    }
    
    if (abs(pos_right) < 5){                                                  //Avoid taking in account small disturbances
      speed_act_right = 0;
    }
    else {
    speed_act_right=((pos_right/990)*2*PI)*(1000/LOOPTIME)*radius;          // calculate speed of right wheel
    }
    
    pos_left = 0;
    pos_right = 0;

    speed_cmd_left = constrain(speed_cmd_left, -max_speed, max_speed);
    PID_leftMotor.Compute();                                                 // compute PWM value for left motor
    PWM_leftMotor = constrain(((speed_req_left+sgn(speed_req_left)*0.0882)/0.00235) + (speed_cmd_left/0.00235), -255, 255); //
    
    if (noCommLoops >= noCommLoopMax) {                   //Stopping if too much time without command
      leftMotor->setSpeed(0);
      leftMotor->run(BRAKE);
    }
    else if (speed_req_left == 0){                        //Stopping
      leftMotor->setSpeed(0);
      leftMotor->run(BRAKE);
    }
    else if (PWM_leftMotor > 0){                          //Going forward
      leftMotor->setSpeed(abs(PWM_leftMotor));
      leftMotor->run(BACKWARD);
    }
    else {                                               //Going backward
      leftMotor->setSpeed(abs(PWM_leftMotor));
      leftMotor->run(FORWARD);
    }
    
    speed_cmd_right = constrain(speed_cmd_right, -max_speed, max_speed);    
    PID_rightMotor.Compute();                                                 // compute PWM value for right motor
    PWM_rightMotor = constrain(((speed_req_right+sgn(speed_req_right)*0.0882)/0.00235) + (speed_cmd_right/0.00235), -255, 255); // 

    if (noCommLoops >= noCommLoopMax) {                   //Stopping if too much time without command
      rightMotor->setSpeed(0);
      rightMotor->run(BRAKE);
    }
    else if (speed_req_right == 0){                       //Stopping
      rightMotor->setSpeed(0);
      rightMotor->run(BRAKE);
    }
    else if (PWM_rightMotor > 0){                         //Going forward
      rightMotor->setSpeed(abs(PWM_rightMotor));
      rightMotor->run(FORWARD);
    }
    else {                                                //Going backward
      rightMotor->setSpeed(abs(PWM_rightMotor));
      rightMotor->run(BACKWARD);
    }

    if((millis()-lastMilli) >= LOOPTIME){         //write an error if execution time of the loop in longer than the specified looptime
      Serial.println(" TOO LONG ");
    }

    noCommLoops++;
    if (noCommLoops == 65535){
      noCommLoops = noCommLoopMax;
    }
    
    publishSpeed(LOOPTIME);   //Publish odometry on ROS topic
  }
 }

//Publish function for odometry, uses a vector type message to send the data (message type is not meant for that but that's easier than creating a specific message type)
void publishSpeed(double time) {
  speed_msg.header.stamp = nh.now();      //timestamp for odometry data
  speed_msg.vector.x = speed_act_left;    //left wheel speed (in m/s)
  speed_msg.vector.y = speed_act_right;   //right wheel speed (in m/s)
  speed_msg.vector.z = time/1000;         //looptime, should be the same as specified in LOOPTIME (in s)
  speed_pub.publish(&speed_msg);
  nh.spinOnce();
  nh.loginfo("Publishing odometry");
}

//Left motor encoder counter
void encoderLeftMotor() {
  if (digitalRead(PIN_ENCOD_A_MOTOR_LEFT) == digitalRead(PIN_ENCOD_B_MOTOR_LEFT)) pos_left++;
  else pos_left--;
}

//Right motor encoder counter
void encoderRightMotor() {
  if (digitalRead(PIN_ENCOD_A_MOTOR_RIGHT) == digitalRead(PIN_ENCOD_B_MOTOR_RIGHT)) pos_right--;
  else pos_right++;
}

template <typename T> int sgn(T val) {
    return (T(0) < val) - (val < T(0));
}

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast

Nox - A House Wandering Robot (ros)

About the project

Project info