OmniBoard: Skateboard and Hoverboard Hybrid With Bluetooth Control

The OmniBoard is a novel Electric Skateboard-Hoverboard Hybrid controllable through a Bluetooth Smartphone Application. It is able to move with all three degrees of freedom achievable by both boards combined, go forward, spin around its axis, and strafe sideways.

This allows you to move in whichever direction you desire as well as do nifty tricks that you would not otherwise be able to with your typical mode of transportation such as (electric) skateboards, hoverboards, cars, bikes, etc.

My friend and I decided to build the OmniBoard as a fun exercise and challenge, as well as enter to some Instructables contests, namely the wheels challenge. We wanted to make something that has never been done before, is cool, and would be useful. As the public transit system is often unreliable, and city traffic is awful during the morning and afternoon drive to and from work, an alternative mode of transportation such as biking or skateboard are useful. Electric skateboards and bikes are useful for long range commutes, but there are already many consumer and DIY solutions for this topic. So we decided to reinvent the wheel, quite literally, and make a new and fun OmniBoard.

Drive system

• (4) Omni Wheels
• (4) 60 tooth pulley
• (4) 20 tooth pulley
• (4) GT2 Timing Belt (we used 140 tooth)
• (8) 7mm ID, 19mm OD bearing*
• (20) M5 (or similar size) machine screws, roughly 25 mm long*
• (28) Nuts, same size as machine screws*
• (32) No. 2 wood screws, 3/8" long*
• (16) Angle brackets, preferably four holes, must be at least 1/2" from corner to screw hole*
• 1'x2' Plywood sheet*
• Skateboard surface

Electronics:

Drive System

• (4) DC Motors
• (4) Electronic Speed Controllers (ESC)
• Power Distribution Board (PDB)
• 16AWG Silicone wire - Red and Black
• XT90 Connector Parallel Splitter
• XT90 Connector Male with Tail
• (8 Pairs) 4mm Bullet Connector
• (4 Pairs) XT60 Connectors
• (2) LiPo Batteries

Remote Control

• Double-Sided Perf Board*
• LM7805 Voltage Regulator*
• 24AWG Solid Core Wires - Assorted Colour*
• HC-05 Bluetooth Module*
• Arduino Uno v3*
• (32 pin) Dual-Sided Male Pin Headers*
• (12 pin) Single-Sided ale Pin Headers*

Tools:

• Soldering station and Solder
• Wire cutters
• Wire strippers
• Pliers
• Scissors
• Drill bits:1-3/8", 3/4", 1/4"

Equipment:

• 3D Printer
• Laser Cutter
• Band Saw
• Drill Press

*Gotten from the local electronics store or hardware store.

The Omniboard is an electric skateboard and hoverboard in one! It is capable of moving forward and back, side to side, and rotating, all controlled by a joystick on your phone.

The Omniboard is powered by four motors each attached to an omnidirectional wheel. Because the omni wheels are allowed to slide laterally, varying the speed and direction of each motor allows the board to move in any direction the user chooses, as depicted in the image above.

The parts you'll need for assembling the axles are:

• (8) 3D printed bearing spacer
• (4) 3D printed large pulley spacer
• (8) Bearing
• (4) Omni wheel
• (4) Large pulley
• (4) 3x3x80mm keystock

First, you want to put a bearing spacer on the end of the shaft as shown. The spacer is made to be a very tight fit, so I recommend using a vice or mallet to get it on. If it's too loose a fit, shift it a little further up the keystock and attach a collar. You need not worry about a collar for the other end.

Next you slide the omni wheel on followed by a bearing spacer facing the opposite direction. You can slip the bearings on now (it doesn't matter as much of they're not snug) and it should look like the picture. Finally, you can slip the long skinny pulley spacers into the pulleys. At this point, do not tighten the pulley set screws or put them on the keystock. Those come later.

This is where your laser cutter and 3/8" thick plywood comes in handy! The CAD for laser cutting the frame is attached in a .dxf format.

Next you will drill two holes over the little crosses that the laser cutter will leave on the plywood. The slightly smaller cross will be drilled with the 3/4" bit only 1/4" of the way through, while the larger cross will be drilled with the 1-3/8" bit all of the way through. It is very important that you remember for half the pieces to cut the 3/4" holes from one side and the other half from the other side. Next drill a smaller 3/8" hole through the middle of the 3/4" holes, all the way through the layer you didn't cut before.

Finally, screw the angle brackets to the shorter sides of the rectangular pieces. You have almost everything you need now to assemble the omni wheel trucks.

Now we can finish the truck assembly! You'll need the parts from the last two steps plus:

• (4) Timing belt
• (4) 3D printed small pulley spacer
• (4) Small pulley
• (4) Motor

Slip each plywood side onto the bearings. If the 3/4" holes don't fit easily over the bearings, use a Dremel to sand them a bit wider. Once they fit on, put the pulley over the protruding keystock and tighten the set screws. Screw the rectangular piece into the notch above the omni wheel.

At this point, check that your omni wheel spins freely. If it doesn't, your pulley might be clamping down on the plywood. Raise it a bit further up the keystock.

Next we'll fit the motors in. The 1-3/8" holes are a bit too small, so slowly sand the inner circle with a Dremel until the motor fits snugly inside. Be careful not to force the motor in and deform the housing. Once the motor in in position, slip the belt over the small pulleys, then the small pulleys over their spacers and onto the 3.175mm motor shaft. Tighten the set screws.

For the sake of compactness and symmetry, you'll want to put the pulleys and belts on one side of the truck for two of them and the other side for the other two.

Now we're going to attach the trucks to the skateboard platform. You could make yours from plywood and grip tape; ours was taken from an old skateboard.

First, you'll want to drill 1/4" holes in both sides of the plywood as shown in the picture. In each hole, attach an angle bracket with an M5 screw and double nut it on the inner side to prevent it from coming loose due to vibrations. Measure and drill the holes that allow you to mount the trucks as close to the ends and at as steep a taper angle as possible while staying within the footprint of the platform. Now flip it over and give it a load test!

Solder the 4mm male bullet connectors to a wire which will connect to the motors, then solder this wire onto the motor terminals. For cable organization, each wires are cut to 6cm and stripped from both ends

Tip: It is easier to solder the wires onto the bullet connectors first then solder it to the motor than the other way around.

To solder the bullet connector onto the wire, place it onto an insulated alligator clip of the helping hand (as the heat dissipates quickly from the body of the bullet connector to the metallic, heat conducting helping hand body). Then pool some solder onto the the bullet connector, about half way and while keeping the iron in the connector, dip the wire onto the solder pool, as shown in the video. Then heat shrink the wire and the bullet connector.

Then, place the wire next to the motor terminal and hold it upright using the helping hand. I used the solder roll to hold the motor upside down. Then solder the wire onto the motor terminal. The order and colour of the wires are ambiguous and does not matter, as the ordering can be switched to reverse the rotation, which will be done in the next steps if necessary.

Prior to soldering, cut some heat shrink for each of the wires which will be used to insulate the exposed soldered ends.

Cut of one of the leads to the battery connector, strip it, slip the heat shrink in, and solder it to the XT60 connector with the red connecting to the positive terminal of the XT60 and the black to the negative terminal of the XT60.

Warning: Only cut the ESC wires one at a time, as there is a capacitor that may be charged in between the positive and negative terminals which will short if the scissors or wire cutters cut through both at once.

To solder the wire onto the XT60 connector, use the helping hands to hold the XT60 connector's body. Then, pool some solder to the XT60 terminal about half way and while keeping the soldering iron on the XT60 connector, dip the wire into the liquid solder pool, as shown in the video from the previous step. Once cool, slide the heat shrink down to insulate the exposed end and heat it with the sides of the soldering iron.

Repeat this for the rest of the wires of the battery connectors of the ESCs.

The PDB will take in input from the two Lithium Polymer (LiPo) batteries with a combined voltage and current of 11.1V and 250A, respectively, and distribute it to the four ESCs.

Tip: It is easier to solder the male XT90 connector leads to the PDB pads first, then the 16 AWG wires to the ESCs, followed by the XT60 connectors onto these wires.

Before, soldering the wires, cut the heat shrink to fit each of the wires, so it can be slipped onto the exposed soldered end later to prevent short circuiting.

To solder the wires onto the PDB pads, I found it easiest to use the helping hands to hold the wires upright (especially the large XT90 cable) and place it on top of the PDB resting on the table. Then solder the wire around the PDB pad. Then, slide the heat shrink down and heat it to insulate the circuitry.

Repeat this for at the rest of the ESC wires.

To solder the XT60, follow the previous step on how the ESC battery terminal was replaced with XT60s.

Connect the motor wires to the bullet connector terminals of the ESC. Then, plug in the white signal pin from the ESC to pin 9 and the black ground pin to the GND pin on the Arduino. Dual lock strips was used to secure all the ESCs and wires to the board.

To check if the rotation of the motors are correct (spinning towards the front), by run the sample code on the Arduino below.

#include <Servo.h>

Servo motor;
byte clockwiseSpeed = 110;
unsigned long interval = 1500;
int motorPin = 9;

void setup()
{
    Serial.begin(9600);
    motor.attach(motorPin);
    Serial.println("Beginning test");
}

void loop()
{
    motor.write(clockwiseSpeed);
    Serial.println("Stop Motor From Spinning");
    delay(interval);
}

The order of wires connected from the ESC to the motor determine the rotation of the motor. If the motor spin is counterclockwise, then keep note of the motor and change the boolean in the controller code on step "Programming the Omniboard Controller". If it is spinning clockwise towards the front, then the rotation is correct. Do this for each of the four motors. If the motor is not spinning, double check all your connectors if there are any cold solder resulting in a loose connection.

By default, the brushed ESCs are at practice mode. This is indicated by the blinking LED light. In order to programmatically control a motor to the reverse direction, climbing mode is needed.

To access this mode, connect the ESC to the Arduino by plugging in the white signal pin from the ESC to pin 9 and the black ground pin to the GND pin on the Arduino. Then upload and run the following program to the Arduino board:

#include <Servo.h>

Servo motor;
byte stopSpeed = 90;
unsigned long interval = 1500;
int motorPin = 9;

void setup()
{
    Serial.begin(9600);
    motor.attach(motorPin);
    Serial.println("Beginning test");
}

void loop()
{
    motor.write(stopSpeed);
    Serial.println("Stop Motor From Spinning");
    delay(interval);
}

Turn on the ESC, then press and hold the programming button for two seconds. The LED indicator will now be steady as opposed to flashing, which means the mode has been successfully changed to climbing mode.

The HC-05 Bluetooth module allows the Arduino to connect with a phone to allow wireless control of the skateboard through an App. As I have found issues certain faulty the Bluetooth module interfaces, it would be better to test it out first before soldering the final circuitry,

We will be using 4 of the 6 pins on the Bluetooth module. These are: Tx (Transmit), Rx (Receive), 5V, and GND (Ground). Connect the Tx and Rx pins from the HC-05 Bluetooth module to pins 10 and 11 on the Arduino, respectively. Then, connect the 5V pin and GND pins to the pins with the label the same on the Arduino.

On the Blynk App, add the bluetooth and button widgets, as shown in the images above. Then, assign digital pin D13, which is connected to the built-in LED on the Arduino Uno, to the button.

Upload and run the following code to the Arduino with the bluetooth module plugged in and open serial monitor to see if the bluetooth module has connected. Then toggle the On/Off button and observe the built-in LED on the Arduino change.

#define BLYNK_PRINT Serial<br>

#include <BlynkSimpleSerialBLE.h>
#include <SoftwareSerial.h>

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "Your Authentication Token";

SoftwareSerial SerialBLE(10, 11); // RX, TX

BLYNK_WRITE(V1)
{
  int pinValue = param.asInt(); // assigning incoming value from pin V1 to a variable
}

void setup()
{
  Serial.begin(9600);	// debug console
  SerialBLE.begin(9600); 
  Blynk.begin(SerialBLE, auth);
  Serial.println("Waiting for connections...");
}

void loop()
{
  Blynk.run();
}

In order to clean up the circuitry and loose jumper wires from the prototype, we will be soldering an Arduino shield that connects to each of the ESCs and Bluetooth module, as well as a power supply to the Arduino.

Solder the following schematic above onto a double-sided perf board.

I first sized and plugged in the Dual-Sided Male Pin Headers onto the Arduino female headers then soldered it to the top side of the perf board for both side. Once they were soldered, I removed it from the Arduino board to solder the bottom portion of the board. Then, I soldered the ESC Single-Sided Male Pin Headers in 4 sets of 3 onto the bottom side of the perf board. After which, I placed the HC-05 Bluetooth module upright and soldered the connectors onto the bottom side of the perf board as well.

Since the Bluetooth module requires a 5V voltage input and the PDB is only regulated to 12V, I used a LM7805 to step down the current to limit the current draw from the Arduino. This same 5V supply is also connected to the 5V pin of the Arduino such that the Arduino can be powered through the shield as opposed to an additional barrel jack adaptor.

The pins of the LM7805 was soldered to the bottom side of the perf board with the voltage regulator component sitting atop the perf board as shown in the image above. I soldered all the power connections to each of the components and ESC pin headers and HC-05 Bluetooth module as described in the schematic. The 12V output of the PDB was then soldered to the VCC input (left most) pin and ground pin (middle) of the LM7805 voltage regulator. Lastly, each of the ESC signal pin headers and HC-05 Bluetooth module Tx and Rx pins to the Arduino digital pins through the Dual-Sided Male Pin Headers as shown in the schematic.

The Omniboard will be controlled over Bluetooth using any smartphone via the Blynk App. Blynk is an Android and iOS app that allows one to use modules and widgets that can interface with several microcontrollers with Bluetooth or wireless capabilities or Bluetooth / wireless modules, like the HC-05.

1. Install Blynk onto your phone.

2. Create an account and login

3. Create a new project and name it. I named mine "Omniboard controller", select Arduino Uno as the microcontroller, and select Bluetooth as the interface type.

4. Drag and drop the following widgets on screen: Bluetooth, Map, 2 Buttons, and Joystick

The button will be used to toggle Hoverboard mode vs Skateboard mode. Hoverboard mode allows for precise control of spin and strafe while holding a cruise velocity. While, skateboard mode gives precise control of forward velocity and spin. The joystick will control the skateboard with two degrees of freedom which are interchanged by the toggle button. The map will display your current location as well as waypoints for other places to go to. The bluetooth allows the interface to connect with a Bluetooth module.

Joystick Settings:

• Select "Merge" for the output type and assign it to Virtual pin V1.

Buttons Setting:

• Name the first button "Hover Mode" and the second button "Cruise Control."
• Assign the output of the first button to Virtual pin V2 and change the Mode to "Switch."
• Assign the output of the second button to Virtual pin V3 and change the Mode to "Switch."
• Rename the toggle names of the first buttons as "Hover" and "Skate" and retain "ON" and "OFF."

Map Settings:

• Assign the input to be V4.

Bluetooth Settings:

Select the Bluetooth widget on the Blynk app and connect with your module. The default password for the Bluetooth module is '1234'

The dynamics of the Omniboard was programmed based on the dynamics algorithm derived from the "How it Works" section. Each of the 3 degrees of freedom, forwards, strafe, and spin are calculated independently and are superimposed on each other to result in full range of motion control of the Omniboard. The control of each motors are linearly proportional to the movement of the joystick. Upload and run the following code to the Arduino.

#define BLYNK_PRINT Serial<br>

#include <BlynkSimpleSerialBLE.h>
#include <SoftwareSerial.h>

#include <Servo.h>
Servo motorFR;
Servo motorFL; 
Servo motorBR;
Servo motorBL;

bool motorFRrev = true;
bool motorFLrev = true;
bool motorBRrev = true;
bool motorBLrev = true;

float motorFRang = 330.0*PI/180.0;
float motorFLang = 30.0*PI/180.0;
float motorBRang = 210.0*PI/180.0;
float motorBLang = 150.0*PI/180.0;

float motorFRspeedT;
float motorFLspeedT;
float motorBRspeedT;
float motorBLspeedT;

float motorFRspeedR;
float motorFLspeedR;
float motorBRspeedR;
float motorBLspeedR;

float maxAccel = 10;

byte forwardSpeed = 110;
byte backSpeed = 70;
byte stopSpeed = 90;  // change to experimenally deternmied number

int cruiseControl;
int yawMode;

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "8523d5e902804a8690e61caba69446a2";

SoftwareSerial SerialBLE(10, 11); // RX, TX

BLYNK_WRITE(V2) {cruiseControl = param.asInt();}
BLYNK_WRITE(V3) {yawMode = param.asInt();}
WidgetMap myMap(V4);

BLYNK_WRITE(V1)
{
  int x = param[0].asInt();
  int y = param[1].asInt();

  if (!cruiseControl) calcTranslation(x, y);
  if (yawMode)        calcRotation(x, y);
  else
  {
    motorFRspeedR = 0;
    motorFLspeedR = 0;
    motorBRspeedR = 0;
    motorBLspeedR = 0;
  }
  
  writeToMotors();
}

void setup()
{
  motorFR.attach(9);
  motorFL.attach(6);
  motorBR.attach(5);
  motorBL.attach(3);
  delay(1500); // wait for motors to initialize
  // Debug console
  Serial.begin(9600);

  SerialBLE.begin(9600);
  Blynk.begin(SerialBLE, auth);

  Serial.println("Waiting for connections...");

  // If you want to remove all points:
  //myMap.clear();

  int index = 1;
  float lat = 43.653172;
  float lon = -79.384042;
  myMap.location(index, lat, lon, "value");
}

void loop()
{
  Blynk.run();
}

void calcTranslation(int joyX, int joyY)
{
   float normX = (joyX - 127.0)/128.0;
   float normY = (joyY - 127.0)/128.0;
   
   motorFRspeedT = (normY*cos(motorFRang) + normX*sin(motorFRang))*(1 - 2*motorFRrev);
   motorFLspeedT = (normY*cos(motorFLang) + normX*sin(motorFLang))*(1 - 2*motorFLrev);
   motorBRspeedT = (normY*cos(motorBRang) + normX*sin(motorBRang))*(1 - 2*motorBRrev);
   motorBLspeedT = (normY*cos(motorBLang) + normX*sin(motorBLang))*(1 - 2*motorBLrev);
}

void calcRotation(int joyX, int joyY)
{
   float normX = (joyX - 127.0)/128.0;
   float normY = (joyY - 127.0)/128.0;
   
   motorFRspeedR = joyX*(1 - 2*motorFRrev);
   motorFLspeedR = -joyX*(1 - 2*motorFLrev);
   motorBRspeedR = -joyX*(1 - 2*motorBRrev);
   motorBLspeedR = joyX*(1 - 2*motorBLrev);
}

void writeToMotors()
{
   float motorFRspeed = motorFRspeedT + motorFRspeedR;
   float motorFLspeed = motorFLspeedT + motorFLspeedR;
   float motorBRspeed = motorBRspeedT + motorBRspeedR;
   float motorBLspeed = motorBLspeedT + motorBLspeedR;

   long motorFRmapped = map((long) (100*motorFRspeed), -100, 100, backSpeed, forwardSpeed);
   long motorFLmapped = map((long) (100*motorFLspeed), -100, 100, backSpeed, forwardSpeed);
   long motorBRmapped = map((long) (100*motorBRspeed), -100, 100, backSpeed, forwardSpeed);
   long motorBLmapped = map((long) (100*motorBLspeed), -100, 100, backSpeed, forwardSpeed);
   
   motorFR.write(motorFRmapped);
   motorFL.write(motorFLmapped);
   motorBR.write(motorBRmapped);
   motorBL.write(motorBLmapped);
}

In order to keep all the wires and parts from dangling out of the bottom, 3D print the housing attached, then screw it onto the skateboard using M5 screws.

The inspiration for the top deck design are PCB circuitry and patterns. To do this, first the bottom of the skateboard is covered my wrapping painter's tape around it. Then the whole top deck is coated with white paint. Once dry, it's masked with the negative of the circuit pattern, then repainted with a black coat. Then, peel of the maskings from the top layer carefully and voila, a cool-looking skateboard.

I encourage you to personalize the design for your own Omniboard and exercise your creative freedom.

Plug in the batteries to the XT90 Splitter in parallel, then plug it in to the PDB. Connect the ESC's to the ESC pin headers on the custom-made Arduino Shield, then turn on the ESCs.

Launch your Blynk app and connect to the Arduino via Bluetooth. Control your skateboard with the joy stick.

Enjoy and Have fun!