Arduino Tracked Rover Robot Control With Gesture

About the project

We use The Tactigon Skin (T-Skin) to control our tracked rover by moving our hand!The rover robot is Arduino base robot with BLE

Project info

Difficulty: Moderate

Platforms: Arduino

Estimated time: 2 hours

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

Items used in this project

Hardware components

	Grove - Mini Track Ball	x 1
	3D Gesture Sensor (Mini) For Arduino	x 1
	Arduino Uno Rev 3 You can use Arduino UNO and Bluetooth or The Tactigon ONE BOARD (with BLE and MCU inside)	x 1
	Bluetooth 4.0 Low Energy-BLE Shield v2.1	x 1

Software apps and online services

Arduino IDE

Story

Hello, There!

Our old friend, CINGO, is now controlled with T-Skin device! T-Skin provides an ergonomic, lightweight smart case for The Tactigon ONE, so we updated the sketch in CINGO's Controller to handle the four buttons integrated in T-Skin. The Buttons now turn on and off movements communication, so if we want to stop the rover while drinking, we can!

CINGO can now be used with hand movements, and by pressing a key, you stop data transmission and have hands free to create awesome routes to go with your nice tracked rover!

ARDUINO ROVER SKETCH

The Tactigon can be connected and talk to a serial motor control board. In this article we’ll look at how to control the rover using a second Tactigon as controller in alternative to Arduino UNO board, using pitch and roll to compute tracks’ speeds (called wheels speeds from now on), as shown in the video above.Tutorial – How to control motor with The Tactigon – Part II – Sketch)and Tutorial – How to control motor with The Tactigon – Part I – Hardware

ARDUINO ROVER SKETCH

Robots usually require a lot of sensors, radio communication, calculating capacity and possibly low power consumption, to control position, next movements and reduce weight. Visit our website (thetactigon.com)PART LIST-- Arduino UNO board or in alternative TACTIGON ONE-- Bluetooth Low Energy (if you use Arduino UNO)-- motor control

THE TACTIGON ONE

The Tactigon is an interesting alternative in robot development. Maker can get advantages from its integrated Bluetooth Low Energy radio, sensors and GPIO to control other robot’s peripherals as ultrasonic distance or IR obstacle detection sensors. Sketch can be longer as Flash memory is larger than typical development board, and with more RAM too. Arduino IDE Compatibility with The Tactigon is ensured by downloadable Core.As we saw in the articles in our website (

Code

T-Skin

Controller code

/**************************************************/
/* CINGO Controller for T-Skin use only.          */
/* Won't work on The Tactigon One board           */
/* as it's missing button to start communication. */
/* MAC Address updated to work with last receiver */
/* https://thetactigon.com  info@thetactigon.com  */
/**************************************************/

#include <tactigon_led.h>
#include <tactigon_IMU.h>
#include <tactigon_BLE.h>
#include <tactigon_IO.h>

extern int ButtonPressed;   

T_Led rLed, bLed, gLed;

T_QUAT qMeter;
T_QData qData;

T_BLE bleManager;
UUID targetUUID;
uint8_t targetMAC[6] = {0xbe, 0xa5, 0x7f, 0x31, 0x77, 0x59};
T_BLE_Characteristic accChar, gyroChar, magChar, qChar;

//GPIO
T_GPP gpp1;
T_GPP gpp2;
T_GPP gpp3;
T_GPP gpp4;

boolean transmission = false;
int debounceTime = 300;
int lastTransmissionSwitch, lastGPIO1Switch, lastGPIO2Switch, lastGPIO3Switch = 0;

int ticks, ticksLed, stp, cnt, printCnt, ledCnt;
float roll, pitch, yaw;


//////////////////////////////////////////////////////////////////////////////////////////
void setup() {
  // put your setup code here, to run once:
  ticks = 0;
  ticksLed = 0;
  stp = 0;
  cnt = 0;
  ledCnt = 0;

  //init leds
  rLed.init(T_Led::RED);
  gLed.init(T_Led::GREEN);
  bLed.init(T_Led::BLUE);
  rLed.off();
  gLed.off();
  bLed.off();

  //init BLE
  bleManager.setName("Tacti");
  bleManager.InitRole(TACTIGON_BLE_CENTRAL);                  //BLE role: CENTRAL
  targetUUID.set("c1c0760d-503d-4920-b000-101e7306b001");     //target characteristic
  bleManager.setTarget(targetMAC, targetUUID);                //target: mac device and its char UUID

  gpp1.init(T_GPP::GPP1, T_GPP::GPP_IN);
  gpp2.init(T_GPP::GPP2, T_GPP::GPP_IN);
  gpp3.init(T_GPP::GPP3, T_GPP::GPP_IN);
  gpp4.init(T_GPP::GPP4, T_GPP::GPP_IN);
}




//////////////////////////////////////////////////////////////////////////////////////////
void loop() {


  char buffData[2];


  int deltaWheel, speedWheel;
  int pitchThreshold, rollThreshold, th1, th2;

  //base engine @ 50Hz (20msec)
  if (GetCurrentMilli() >= (ticks + (1000 / 50))) {
    ticks = GetCurrentMilli();
    //debounce on GPP4 (activate /deactivate transmission)
    if (!gpp4.read()) {
      if (GetCurrentMilli() >= lastTransmissionSwitch + debounceTime) {
        transmission = !transmission;
        lastTransmissionSwitch = GetCurrentMilli();
      }
    }
    if (transmission) {
      //get quaternions and Euler angles
      qData = qMeter.getQs();

      //Euler angles: rad/sec --> degrees/sec
      roll = qData.roll * 360 / 6.28;
      pitch = qData.pitch * 360 / 6.28;
      yaw = qData.yaw * 360 / 6.28;

      //forward/backword
      rollThreshold = 10;
      th1 = 90 + rollThreshold;
      th2 = 90 - rollThreshold;
      roll = fabs(roll);

      //compute speed wheel and delta speed wheel depending on Euler angles
      //left/right
      pitchThreshold = 10;
      if (pitch < -pitchThreshold || pitch > pitchThreshold) {
        if (pitch < -pitchThreshold) {
          if (roll < th1 && roll > th2) {
            //spin
            deltaWheel = - (fabs(pitch) - pitchThreshold) * 10;
            rLed.on();
            bLed.on();
            gLed.on();
          } else {
            deltaWheel = - (fabs(pitch) - pitchThreshold) * 3;
          }
        }
        else {
          if (roll < th1 && roll > th2) {
            //spin
            deltaWheel = + (fabs(pitch) - pitchThreshold) * 10;
            rLed.on();
            bLed.on();
            gLed.on();
          } else {
            deltaWheel = + (fabs(pitch) - pitchThreshold) * 3;
          }
        }
      }
      else {
        deltaWheel = 0;
      }

      //forward/backward
      if (roll > th1) {
        speedWheel = ((roll - th1) * 3);
      }
      else if (roll < th2) {
        speedWheel = ((roll - th2) * 3);
      }
      else {
        speedWheel = 0;
      }


      //convert speedWheel and deltaWheel in command byte for motor control board
      int sxC, dxC;
      uint8_t sx, dx;
      sxC = (speedWheel - (-deltaWheel / 4)) + 64;
      dxC = (speedWheel + (-deltaWheel / 4)) + 192;

      if (sxC > 127) {
        sxC = 127;
      } else if (sxC < 1) {
        sxC = 1;
      }
      if (dxC < 128) {
        dxC = 128;
      } else if ( dxC > 255) {
        dxC = 255;
      }
      sx = sxC;
      dx = dxC;

      //fill buffData to write in BLE characteristic
      buffData[0] = sx;
      buffData[1] = dx;
      Serial.print("SX: ");
      Serial.println(sx);
      Serial.print("DX: ");
      Serial.println(dx);
      //if connected and attached to peripheral characteristic write in it
      if (bleManager.getStatus() == 3) {

        //signal that connection is on
        bLed.on();
        rLed.off();
        ledCnt++;
        if (ledCnt > 100) {
          ledCnt = 0;
          rLed.off();
          bLed.off();
          gLed.off();
        }
        //write in BLE characteristic (@ 10Hz in order to not stress control motor board)
        cnt++;
        if (cnt > 5) {
          bleManager.writeToPeripheral((unsigned char *)buffData, 2);
          cnt = 0;
          rLed.on();
        }

      }
    }        else {
      buffData[0] = 0x00;
      buffData[1] = 0x00;
      //debounce on GPP1 (rotate)
      if (!gpp2.read()) {
        if (GetCurrentMilli() >= lastTransmissionSwitch + debounceTime) {
          buffData[0] = 0x01;
          buffData[1] = 0xFF;
          lastGPIO1Switch = GetCurrentMilli();
        }
      }
      //debounce on GPP2 (rotate)
      if (!gpp1.read()) {
        if (GetCurrentMilli() >= lastTransmissionSwitch + debounceTime) {
          buffData[0] = 0x7F;
          buffData[1] = 0x80;
          lastGPIO2Switch = GetCurrentMilli();
        }
      }
      //debounce on GPP3 (stop)
      if (!gpp3.read()) {
        if (GetCurrentMilli() >= lastTransmissionSwitch + debounceTime) {
          buffData[0] = 0x00;
          buffData[1] = 0x00;
          lastGPIO3Switch = GetCurrentMilli();

        }
      }
      bleManager.writeToPeripheral((unsigned char *)buffData, 2);
    }

  }


}

CINGO

Receiver code

#include <tactigon_led.h>
#include <tactigon_BLE.h>
#include <tactigon_UserSerial.h>


//RGB LEDs
T_Led rLed, bLed, gLed;

//BLE Manager, BLE Characteristic and its UUID
T_BLE bleManager;
T_BLE_Characteristic cmdChar;
UUID uuid;

//UART
T_UserSerial tSerial;

//Used for LEDs cycle
int  ticksLed, stp;

/*----------------------------------------------------------------------*/
void cbBLEcharWritten(uint8_t *pData, uint8_t dataLen)
{
  blinkLEDs();
  cingoSpeed((char*)pData, dataLen);
}

/*----------------------------------------------------------------------*/
void blinkLEDs() {
  //Blinks LEDs, turned off by next state in loop()
  rLed.on();
  gLed.on();
  bLed.on();
}

/*----------------------------------------------------------------------*/
void cingoSpeed(char *spd, uint8_t len) {
  tSerial.write(spd, len);
}



/*----------------------------------------------------------------------*/
void setup() {

  char charProg;

  ticksLed = 0;
  stp = 0;

  rLed.init(T_Led::RED);
  gLed.init(T_Led::GREEN);
  bLed.init(T_Led::BLUE);

  rLed.off();
  gLed.off();
  bLed.off();

  //init role
  bleManager.InitRole(TACTIGON_BLE_PERIPHERAL);
  //bleManager.setName("CINGO");
  
  uuid.set("c1c0760d-503d-4920-b000-101e7306b001");     //command characteristic UUID
  cmdChar = bleManager.addNewChar(uuid, 18, 1);         //create characteristic
  charProg = cmdChar.setWcb(cbBLEcharWritten);          //setup a callback on characteristic write event

  //init user serial
  tSerial.init(T_UserSerial::B_9600, T_UserSerial::T_SERIAL1);
}



/*----------------------------------------------------------------------*/
void loop() {

  //Cycle on rgb leds
  if (GetCurrentMilli() >= (ticksLed + (3000 / 1))) {

    ticksLed = GetCurrentMilli();

    if (stp == 0) {
      rLed.on();
      gLed.off();
      bLed.off();
    }
    else if (stp == 1) {
      rLed.off();
      gLed.off();
      bLed.on();
    }
    else if (stp == 2) {
      rLed.off();
      gLed.on();
      bLed.off();
    }
    stp = (stp + 1) % 3;
  }

}

Credits

The Tactigon

The Tactigon is a brand of Next Industries Milano. Next Industries is a born of a passion to develop devices and sensors fit for Iot Technology. Our team is made of incredible experts in movement detection for big structural monitoring systems, software development and wearable device.

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

Arduino Tracked Rover Robot Control With Gesture

About the project

Project info