Published March 1, 2016 © CC BY-NC-SA

Dustbunny - A Particle.io Controlled Rover

Dustbunny - A simple Particle.io Web/Wifi controlled rover.

IntermediateFull instructions provided12 hours2,054

Dustbunny - A Particle.io Controlled Rover

Things used in this project

Hardware components

Particle Photon

L9110 H-Bridge

Ultrasonic Sensor - HC-SR04 (Generic)

Used for looks now (not needed for web control. So optional.)

Little Yellow Gear Motor (Right-angle)

Wheel and hub

Make sure they are rubber tires and NOT nylon. The nylons are shiny black and the rubber dull black.

4xAA battery holder

Get one that is 2x2 and holds 4. eBay has them listed.

20mm M2 screws with nuts

Female/Female Jumper Wires

10cm long. You will need at least 10

Velcro

A roll of stick-on Velcro

Breadboard (generic)

See note above about breadboard choice.

Hand tools and fabrication machines

3D Printer (generic)

Hot glue gun (generic)

Double sided tape

Story

All little kids love to pretend that they are something or someone else. As they play out in their little fantasy worlds, they use toys, props and the imagination! The Dustbunny rover is one such prop for your pretend or real games. Built for kids or the kid at heart!

It is a small web controlled rover built around the Particle.io Photon controller board. Dustbunny is a small rover, and only needs modest motors to move around so the little yellow gear motors that are so plentiful in robot web stores or on eBay are used. To drive them, the inexpensive and easy to use L9110 h-bridge has been chosen.

In this article, a 3d printed chassis is used, but any small rover could be used in place of it. Examples of replacement chassis are the Runt rover series or the Dagu Magician.

To start, you will need to get the parts needed to build the robot. See the component list below, but here are details about the items needed:

1x Particle Photon board
1x L9110 h-bridge
2x right-angle 1:48 gear motors (usually yellow)
2x Rubber tire wheels with hubs.
Hot glue gun and glue sticks
Double sided sticky tape (AKA Robot builders duck tape :))
Female to Female jumper wires (10cm in length)
4x 20mm M2 screws with nuts
4 slot AA holder. One that is 2x2 would be the best. A flat one could lay flat on the top though if that's what you have.
Velcro stick on strips
A Small bread board like this.

Note about the wheels - Make sure they are rubber tires and NOT nylon. The nylons are shiny black and the rubber a dull black. The rubber ones have a lot better traction.

Batteries:

You can power the bot with 4x AA rechargeable NiMH or 1x small 7.4v lipo. For mine, I took the AA rechargeable path. You could power it with 4 AA alkalines, but I do not recommend them for long term use. Modern rechargeable batteries are far superior to throw-aways batteries and a lot cheaper in the long run.

3D Printing the Rover

To print the rover you will need to print all the .stl files listed below, with the exception of the rear flair and it's cover. They are optional, but add to the look of the bot. (Note: I did not print a final flair on mine due to printer issues) If you do print it, the batteries will have to be mounted on the top-rear or another place of your choosing. A small 7.4v lipo should fit in the flair box, if you want to go the lipo route instead of 4 AA rechargeables.

All parts should be printed laying flat on the print bed. I printed mine in PLA on an unheated bed using 60% infill, but you probably could get away with 35% or so. The Flair, you can print vertical or horizontal (facing up or down with supports). Shells or outer layer thickness is your choice as well, but I printed them with 1.2mm thick (I think 3 shells) -- Use the settings best for your printer, you know it better than I would!

Dustbunny Printed Parts Assembly

A note on assembling the cover: You may want to use small 3-4mm pieces of double sided sticky tape to hold the parts in-place as you glue them together. This will give you a chance to make sure it's all lined up. A dry run with a tape together may even be a good idea. If you do mess-up, the glue should be able to come off with some work though and not hurt the parts.

Step 1: Glue the two front side braces to the face plate.

Step 2: Glue the top brace to the center-top on the face plate. Have it @ 1cm below the top of the plate.

Step 3: Attach sides to the front braces. The front of the sidewall will be flush against the face plate.

Step 4: Attach two angle braces to the side bottoms with glue.

Step 5: Attach two angle braces to the sides and face plate with glue.

Step 6: Attach two angle braces to the side top flush to the edge with glue.

Step 7: Attach two angle braces to the side rear flush to the edge with glue.

Step 8: Attach the backplate to the rear angle with glue.

Step 9: Attach one angle brace to the top of the backplate, flush to the top with glue.

Step 10: Attach the top plate to the two top angle braces on the sides with glue.

Step 11: Attach the two top angle braces to top plate with glue.

Step 12: Attach two rear angle braces to the back and sides with glue.

Painting (optional):

Note: Follow any and all instructions on your paint and primer containers!!

You can optionally paint the bot cover and chassis if you like. I suggest doing this before placing the motors and other components on the bot. You will need a primer that can be applied to plastic. Prime both cover and or chassis (let dry) and then paint them with your choice of color(s). Make it your own!

Motors, Chassis and Cover Mounts

After you have the cover assembled, solder wires to your motors and place them on the chassis with the 4 M2 screws and nuts.

Now carefully cut velcro strips for the left and right side bottom angle braces on the cover bottom. The strips should be no wider than the braces. After cutting, take one velcro side and stick it to the chassis on the left and right side where the cover will site. It may be easier to that the cut top and bottom strips and stick one side to the cover brace and then unpeel the other side of the strip and place the cover into proper alignment on the chassis, leaving the second strip on the chassis. Do this for both the left and right sides.

Place all the components as pictured with double sided tape onto the chassis:

Keep the components close in the center of the chassis.

Wiring it Up

Photon D0 -> L9110 A-IA
Photon D1 -> L9110 B-IA
Photon D2 -> L9110 A-IB
Photon D3 -> L9110 B-IB
L9110 Vcc to Vcc row on little bread board
Photon Vcc to Vcc row on little bread board
Photon GND to GND row on little bread board
L9110 GND to GND row on little bread board
Battery pack GND (Neg) to GND row on little bread board
Battery pack Vcc (Pos) Vcc row on little bread board

Loading the Code

You will need to familiarize yourself with setting up and loading code to the Particle.io boards. If you do not have a board or an account, head over to the Particle.io site to get going. You can go here for general development and device info.

Once you have your device setup and are ready to load the code, download the dustbunny code from github. Clone or download the zip and navigate to or note the the directory you unpacked or cloned to. Go to the Particle.io Build site and log in to start.

Click on the "Create new app" button and call the app "dustbunny" -- Now click on "Libraries" icon (A ribbon bookmark) and find the libary "L9110Driver" and add it to your app. Next, load the file "dustbunny.ino" from inside your local dustbunny directory (on your computer hard drive), into a text editor. Select all the text and copy it, then paste it to the dustbunny.ino in your web IDE project. Do the same for the "dustbunny.h" file.

After you have the project setup and all the code loaded, find the "Device" icon (a gun scope target) and select the device you want to flash to. Then click on the "Flash" icon (a lightning bolt) to compile and load the code to your device.

Once you have the code loaded, you are ready for a test.

Testing and Using

Navigate to the dustbunny directory on your computer and open up the file "dustbunnylocal.html" in your favorite text editor. Find the section that has:

var deviceID    = "<YOUR DEVICE ID>";
var accessToken = "<YOUR ACCESS TOKEN>";

Change the "deviceID" line to equal your devices id (see the Build page devices)
Change the "accessToken" line to your access token (see the Build page settings)

Save the file. Now load it into a Web browser (you can probably just double click the file) and once loaded you will see:

Dustbunny control page.

From this page you can use the mouse or keyboard to drive the rover. You can control the speed, direction and distance traveled from this interface.

Note: To use the keyboard to drive the rover, there has to be no button selected on the page. If there is, just click on a blank area of the page.

The keys used to control the bot are:

w - forward
z - reverse/backward
a - long left turn
s - long right turn
q - short left turn
e - short right turn
h - halt/stop robot

If all went well, you can send commands to the robot! If not, open up the javascript console in the browser (Shift + Ctrl + I on Chrome), if there are any errors, correct them and try again.

Once you can talk to your device from the browser, click on the "Forward" button and see if the bot responds in kind. If not, reverse the wires on one motor and try again. Then do the same for the "Left" and "Right" directions.

After that you are all ready to play with your little Dustbunny!

Moving forward with the Project

The "dustbunnylocal.html" is only for local use as it states in the file. You do not want to place this file on a web server for in-the-wild internet consumption!!! Your device ID and Access Token are included and could (will be) seen by anyone who loads the page up. If you want to use the bot remotely from the internet, have a look at the Python code included. There is a flask project for you to start with and it uses the same page look and feel as the "dustbunnylocal.html" version does. You will have to open up a port to get to the flask server or other www server you may setup to get at the bot. I will leave that to you! I only include the code as a starter. You could of course write your own in another language or system like nodejs or even make it autonomous. Again, make it your own!

Chassis and Cover Pics

1 / 4 • Cover all together and primed and painted.

The boards mounted on the chassis:

1 / 6 • Little bread-board for connecting power and grounds.

The rover ready for action!

1 / 2 • Classic over-the-head selfie!

Runt-Rover Dustbunny!

Components mounted using a NON-PRINTED chassis.

Schematics

Code

// This #include statement was automatically added by the Particle IDE.
#include "L9110Driver/L9110Driver.h"

// Various time delays used for driving autonomously
#define TURNDELAY 475
#define BACKUPDELAY 400
#define MAXFORWARDSPEED 225

int rovMotors (String command);
int rovSpeed (String speed_in);

// Globals
L9110_Motor motor_l (D0, D2);
L9110_Motor motor_r (D1, D3);
static bool avoid_it = false;
static int speed = 200;

/* This function is called once at start up ----------------------------------*/
void setup ( )
{
    //Setup the Tinker application here

    //Register the rover functions
    Particle.function ("motors", rovMotors);
    Particle.function ("speed", rovSpeed);

	  rovMotors ("0,0"); // Make sure the motors are off at startup
}

/* This function loops forever --------------------------------------------*/
void loop ( )
{

}

int rovMotors (String command)
{
	//convert ascii to integer
	int mcmd = command.charAt(0) - '0';
	//Sanity check to see if the direction numbers are within limits
	if (mcmd < 0 || mcmd > 5)
	    return -1;

    if (mcmd == 0) // Stop
    {
       	motor_l.run (BRAKE);
        motor_r.run (BRAKE);
    } 
    
    else if (mcmd == 1) // Forward
    {
       	motor_l.run (FORWARD | RELEASE);
        motor_r.run (FORWARD | RELEASE);
    }
    
    else if (mcmd == 2) // Backward
    {
       	motor_l.run (BACKWARD | RELEASE);
        motor_r.run (BACKWARD | RELEASE);
    }
    
    else if (mcmd == 3) // Left turn
    {
       	motor_l.run (BACKWARD | RELEASE);
        motor_r.run (FORWARD | RELEASE);
    }

    else if (mcmd == 4) // Right turn
    {
       	motor_l.run (FORWARD | RELEASE);
        motor_r.run (BACKWARD | RELEASE);
    }

    if (mcmd != 0)
    {
        String value = command.substring(2);
        motor_l.setSpeed (speed);
        motor_r.setSpeed (speed);
        int delay_time = value.toInt();
        if (delay_time != 0) 
        {
           delay (delay_time);
           motor_l.run (BRAKE);
           motor_r.run (BRAKE);
        }
    }

    return (0);
}

int rovSpeed (String speed_in)
{
    speed = speed_in.toInt ( );

//        motor_l.run (BRAKE);
//        motor_r.run (BRAKE);

    return (0);
}

<!--
   Photon based rover driver page
   Written by Scott Beasley - 2016
   Free to use or modify. Enjoy!
   SEE BELOW FOR USAGE WARNING.
-->
<html>
  <script src="http://ajax.googleapis.com/ajax/libs/jquery/2.1.4/jquery.min.js"
          type="text/javascript" charset="utf-8">
  </script>
<head>
<title>Dustbunny Local Control page</title>
<script type="text/javascript">
document.onkeypress = keypressed;
document.onload = initBot;
// WARNING!!!!! DO NOT RUN IN THE DMZ!
// This script should only be run locally on your computer due to the device
// and access token being used to talk to the robot. Again, this is only for
// local use!
var deviceID    = "ADD YOUR ID";
var accessToken = "ADD YOUR TOKEN";
// !!!!!WARNING END
var last_action = "";
var start_dt = new Date ( );
var last_mills = start_dt.getTime ( );
var run_time = "750"
var turn_tm = 166
var auto_state = false

function sentBotCommand (action) {
   var run_dt = new Date ( );
   var mills = run_dt.getTime ( );
   // If a dup, ignore if newer than 500ms
   if (action == last_action && (mills - last_mills) <= 500)
      return;

  console.log ("Action = " + action)
   last_mills = mills;
   last_action = action;
   if (action == 'stop') {
      motors ("0", "0")
      run_time = "750"
   }
   else if (action == 'forward')
      motors ("1", run_time)
   else if (action == 'backward')
      motors ("2", run_time)
   else if (action == 'left')
      motors ("3", 500 - (turn_tm / 2))
   else if (action == 'right')
      motors ("4", 500 - (turn_tm / 2))
   else if (action == 'ltforward')
      motors ("3", 250 - (turn_tm / 2))
   else if (action == 'rtforward')
      motors ("4", 250 - (turn_tm / 2))
   else if (action == 'speed_low') {
      setSpeed ("150")
      turn_tm = 83
   }
   else if (action == 'speed_mid') {
      setSpeed ("200")
      turn_tm = 166
   }
   else if (action == 'speed_hi') {
      setSpeed ("255")
      turn_tm = 332
   }
   else if (action == 'short_time') {
      run_time = "300"
   }
   else if (action == 'mid_run') {
      run_time = "750"
   }
   else if (action == 'continuous') {
      run_time = "0"
   }
   else if (action == 'auto_off') {
      setAuto ("off")
      motors ("0", "0");
   }
   else if (action == 'auto_on') {
      setAuto ("on")
      motors ("1", "0");
   }
}
function keypressed (event) {
   var keyCd = ('charCode' in event) ? event.charCode : event.keyCode;
   if (keyCd == 113 || keyCd == 81)  // q
      sentBotCommand ('ltforward')
   if (keyCd == 119 || keyCd == 87)  // w
      sentBotCommand ('forward')
   if (keyCd == 122 || keyCd == 90)  // z
      sentBotCommand ('backward')
   if (keyCd == 101 || keyCd == 69)  // e
      sentBotCommand ('rtforward')
   if (keyCd == 97 || keyCd == 65)   // a
      sentBotCommand ('left')
   if (keyCd == 104 || keyCd == 72)  // h
      sentBotCommand ('stop')
   if (keyCd == 115 || keyCd == 83)  // s
      sentBotCommand ('right')
}
function initBot (event) {
   setSpeed ("200");
   motors ("0", "0");
}
function motors (direction, run_time) {
   var requestURL = "https://api.spark.io/v1/devices/" + deviceID + "/motors";
   $.post( requestURL, { params: direction+","+run_time, access_token: accessToken });
}
function setSpeed (speed) {
   var requestURL = "https://api.spark.io/v1/devices/" + deviceID + "/speed";
   $.post( requestURL, { params: speed, access_token: accessToken });
}
</script>
</head>
<center>
   Dustbunny Local Control page
   <br><br>
   <Font face="Arial">
   <table name="Table" border="0" cellpadding="6">
      <tr>
         <td align="center">
            <input type="radio" name="run_time" value="42" id="short_time"
            onclick="sentBotCommand ('short_time');">Short run
         </td>
         <td align="center">
            <input type="radio" name="run_time" value="84" id="mid_run"
            onclick="sentBotCommand ('mid_run');" checked>Med run
         </td>
         <td align="center">
            <input type="radio" name="run_time" value="126" id="continuous"
            onclick="sentBotCommand ('continuous');">Continuous
         </td>
      </tr>
      <tr>
         <td align="center">
            Left-Forward
            <br>
            <input type="hidden" name="ltforward" value="0" id="ltforward" />
            <input type="image" src="images/arrow_up_left.png"
            id="imgLtforward" onclick="sentBotCommand ('ltforward');"/>
         </td>
         <td align="center">
            Forward
            <br>
            <input type="hidden" name="forward" value="0" id="forward" />
            <input type="image" src="images/forward.png" id="imgforward"
            onclick="sentBotCommand ('forward');"/>
         </td>
         <td align="center">
            Right-Forward
            <br>
            <input type="hidden" name="rtforward" value="0" id="rtforward" />
            <input type="image" src="images/arrow_up_right.png"
            id="imgRtforward" onclick="sentBotCommand ('rtforward');"/>
         </td>
      </tr>
      <tr>
         <td align="center">
            Left
            <br>
            <input type="hidden" name="left" value="0" id="left" />
            <input type="image" src="images/left.png" id="imgleft"
            onclick="sentBotCommand ('left');"/>
         </td>
         <td align="center">
            Stop
            <br>
            <input type="hidden" name="stop" value="0" id="stop" />
            <input type="image" src="images/stop.png" width="50" id="imgstop"
            onclick="sentBotCommand ('stop');"/>
         </td>
         <td align="center">
            Right
            <br>
            <input type="hidden" name="right" value="0" id="right" />
            <input type="image" src="images/right.png" id="imgright"
            onclick="sentBotCommand ('right');"/>
         </td>
      </tr>
      <tr>
         <td align="center">
            Left-Backward
            <br>
            <input type="hidden" name="ltforward" value="0" id="ltforward" />
            <input type="image" src="images/arrow_down_left.png"
            id="imgltback" onclick="sentBotCommand ('ltforward');"/>
         </td>
         <td align="center">
            Backward
            <br>
            <input type="hidden" name="backward" value="0" id="backward" />
            <input type="image" src="images/backward.png" id="imgbackward"
            onclick="sentBotCommand ('backward');"/>
         </td>
         <td align="center">
            Right-Backward
            <br>
            <input type="hidden" name="rtforward" value="0" id="rtforward" />
            <input type="image" src="images/arrow_down_right.png"
            id="imgrtback" onclick="sentBotCommand ('rtforward');"/>
         </td>
      </tr>
      <tr>
         <td align="center">
            <input type="radio" name="speed" value="42" id="speed_low"
            onclick="sentBotCommand ('speed_low');">Low speed
         </td>
         <td align="center">
            <input type="radio" name="speed" value="84" id="speed_mid"
            onclick="sentBotCommand ('speed_mid');" checked>Mid speed
         </td>
         <td align="center">
            <input type="radio" name="speed" value="126" id="speed_hi"
            onclick="sentBotCommand ('speed_hi');">High speed
         </td>
      </tr>
   </table>
   </font>
</center>
</html>

#!/usr/bin/env python

#   Photon based rover driver Web app
#   Written by Scott Beasley - 2016
#   Free to use or modify. Enjoy!

from flask import Flask, render_template # request
import time
import requests
import meinheld

DEVICE_ID = '<YOUR DEV ID>'
ACCESS_TOKEN = '<YOUR ACCESS TOKEN>'

API_URL = 'https://api.spark.io/v1/devices'
DEVICE_URL = API_URL+'/'+DEVICE_ID

# Speed and drive control variables
last_direction = -1
speed_offset = 84
turn_tm = 166
run_time = 750

application = Flask (__name__, static_url_path = "", static_folder = "images")

@application.route("/")
def index ( ):
   return render_template ('index.html', name=None)

@application.route ("/forward")
def forward ( ):
   global run_time

   print "Forward"
   motors ("1", run_time)

   # sleep one second
   time.sleep (1)
   return "ok" # keep flask happy with a return.

@application.route ("/backward")
def backward ( ):
   global run_time

   print "Backward"
   motors ("2", run_time)

   # sleep one second
   time.sleep (1)
   return "ok"

@application.route ("/left")
def left ( ):
   global speed_offset, last_direction, turn_tm

   print "Left"
   motors ("3", 500 - (turn_tm / 2))

   # sleep one second
   time.sleep (1)
   return "ok"

@application.route ("/right")
def right ( ):
   global speed_offset, last_direction, turn_tm

   print "Right"
   motors ("4", 500 - (turn_tm / 2))

   # sleep one second
   time.sleep (1)
   return "ok"

@application.route ("/ltforward")
def ltforward ( ):
   global speed_offset, last_direction, turn_tm

   print "Left 45deg turn"
   motors ("3", 250 - (turn_tm / 2))

   # sleep one second

   time.sleep (1)
   return "ok"

@application.route ("/rtforward")
def rtforward ( ):
   global speed_offset, last_direction, turn_tm

   print "Right 45deg turn"
   motors ("4", 250 - (turn_tm / 2))

   # sleep one second
   time.sleep (1)
   return "ok"

@application.route ("/stop")
def stop ( ):
   print "Stop"
   motors ("0", "0")

   # sleep one second
   time.sleep (1)
   return "ok"

@application.route ("/speed_low")
def speed_low ( ):
   global speed_offset, last_direction, turn_tm

   speed_offset = 42
   turn_tm = 83

   setspeed (150)
   # sleep 1 second
   time.sleep (01)
   return "ok"

@application.route ("/speed_mid")
def speed_mid ( ):
   global speed_offset, last_direction, turn_tm

   speed_offset = 84
   turn_tm = 166

   setspeed (195)
   # sleep 1 second
   time.sleep (1)
   return "ok"

@application.route ("/speed_hi")
def speed_hi ( ):
   global speed_offset, last_direction, turn_tm

   speed_offset = 126
   turn_tm = 332

   setspeed (250)
   # sleep 1 second
   time.sleep (1)
   return "ok"

@application.route ("/continuous")
def continuous ( ):
   global run_time

   print "Continuous run"
   run_time = 0

   # sleep 1 second
   time.sleep (1)
   return "ok"

@application.route ("/mid_run")
def mid_run ( ):
   global run_time

   print "Mid run"
   run_time = 750

   # sleep 1 second
   time.sleep (1)
   return "ok"

@application.route ("/short_time")
def short_time ( ):
   global run_time

   print "Short run"
   run_time = 300

   # sleep 1 second
   time.sleep (1)
   return "ok"

def motors (direction, run_time):
    r = requests.post(DEVICE_URL+'/motors',
        data={'access_token':ACCESS_TOKEN, 'args':direction+','+str(run_time)})
    ret_json = r.json ( )
    return_val = ret_json['return_value']
    return int(return_val)

def setspeed (speed):
    r = requests.post(DEVICE_URL+'/motors',
        data={'access_token':ACCESS_TOKEN, 'args':'5,'+str(speed)})
    ret_json = r.json ( )
    return_val = ret_json['return_value']
    return int(return_val)

def digitalWrite (pin, state):
    r = requests.post(DEVICE_URL+'/digitalwrite',
        data={'access_token':ACCESS_TOKEN, 'args':pin+','+state})
    ret_json = r.json ( )
    return_val = ret_json['return_value']
    return int(return_val)

def digitalRead (pin):
    r = requests.post(DEVICE_URL+'/digitalread',
        data={'access_token':ACCESS_TOKEN, 'args':pin})
    ret_json = r.json ( )
    return_val = ret_json['return_value']
    return int(return_val)

if __name__ == "__main__" :
   #application.run (host='0.0.0.0', port=8080, debug=False)
   #application.run (host='0.0.0.0')
   meinheld.listen(("0.0.0.0"))
   meinheld.run(app)

Credits

Scott Beasley

9 projects • 61 followers

Well odd

Embed the widget on your own site

Dustbunny - A Particle.io Controlled Rover

Dustbunny - A Particle.io Controlled Rover

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

3D Printing the Rover

Dustbunny Printed Parts Assembly

Motors, Chassis and Cover Mounts

Wiring it Up

Loading the Code

Testing and Using

Moving forward with the Project

Chassis and Cover Pics

Custom parts and enclosures

Face

Top

Back

Left

Right

Chassis

Castor leg

Castor glide

Flair back lid

Optional castor leg

Optional castor glide

Dustbunny Example

Support braces

Photon mount

Stl files home

Schematics

dustbunny.fzz

Flair back

dustbunny_bb.png

Code

Photon driver code

Rover html/js driver page for local network use

Python/Flask driver code for WEB driving the bot.

L9110 driver code for Particle boards

Dustbunny rover code

Credits

Scott Beasley

Comments

Related channels and tags