j2zj8y2vpjb5jkrahohc.png

Zebra Robot

Ada's first robot

Ada loves wall-e, and whilst repeatedly watching the film asked if we could make a wall-e robot. I’d never made anything that complicated so I looked online to see what others had done.

 

There are lots of cardboard wall-e robots and some plastic and metal ones (https://sennaswalle.blogspot.com/ ). To an inexperienced person like me it all looked too complicated. 

 

While researching Ada had seen other styles of robot made out of cardboard and she liked them as much as wall-e. These robots seemed easier to build out of cardboard boxes. 

 

We’d seen from our research that some wall-e robots could move around and so I thought we could make our robot do this (https://youtu.be/6VqS8c_eC0U). It didn’t seem unrealistic as I had started to remember my school A-level lessons in “Design & Technology” from the 1990’s.

 

Some research on the internet and some previous discussions with my friend Steve Holmes about his use of programmable microprocessors in art galleries and installations , he told me about Ardiuno as the go to product for “makers”. 

 

A bit of googling I found a robot chassis with an Arduino clone, motor shield and other bits-and-bobs that look related and all for £12.58 from eBay. So on 25th October 2018 I placed my order in China and awaited the delivery (https://www.youtube.com/watch?v=eKcKdMb_nkQ and https://www.youtube.com/watch?v=autM98m5fwY)

 

I had backed a Kickstarter project in 2016 called Bolt IoT (https://www.boltiot.com/) , I had planned to monitor the water level in our garden , but I just couldn’t get it to work with the sensor I had bought.  So I knew I had connectivity through the Bolt board , so this seemed like a good way to get the project working.

 

8th November and the chassis arrived and Ada and I spent an hour assembling the board , she’s only three and loves getting involved. The chassis was cracked so I super glued the battery holder and motors on to keep it rigid.

 

I wrote a Postman script (https://www.getpostman.com/) to send commands to the Bolt board and using supplied H-Bridge motor driver supplied (took some time to read the manuals) and I could control a wheel forwards and backwards (https://youtu.be/DOWgpgBM1eU

 

I built a small HTML5 page to send commands to the Bolt IOT cloud

https://github.com/targetarchitecture/zebra-robot/blob/master/Bolt%20IOT%20HTML5%20controller.htm


 

9th November - I discovered the W3C Gamepad API (https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API/Using_the_Gamepad_API and https://hacks.mozilla.org/2013/12/the-gamepad-api/) which allows xbox controllers plugged into my laptop to drive an HTML5 website. 

 

I wrote some basic code to test this (https://github.com/targetarchitecture/zebra-robot/blob/master/First%20Gamepad%20API%20HTML%20page.html

 

This leads to an architecture as follows:

 




 

10th November - The chassis could drive around for a few minutes and then it would stop (https://youtu.be/oaiXitDjybw). Control was using the xbox 360 controllers triggers - do it was driven like a tank. After a bit of Googling I discovered that the Bolt IoT platform was throttling the requests to one every three seconds and anymore than that and the account usage is suspended for six hours , this was not ideal as the Xbox controller was sending hundreds of commands a second. 

 

 

 

11th November - So I looked for something which could act as a web-server to receive the commands locally from the HTML5 page. I bought a Raspberry Pi 3, and after a bit of research I discovered Node-RED (https://nodered.org/) - a graphical interface for controlling things. This led to the following architecture where everything is received and controlled locally on the chassis:

 

 

The code that was running on the Pi is here.

 

https://github.com/targetarchitecture/zebra-robot/blob/master/Node-RED%20and%20Gamepad%20API.html


 

12th November - First test drive! (https://youtu.be/YKVmp-HMKFw

 

13th November - I had revelation....I had built something that worked but had too many dependencies and at was a relatively high cost. I realised that the destruction of the robot was inevitable and at around £50 per build and could get costly.

.

I knew that the robot chassis kit had an Ardunio clone in it and I started to think about using it instead of the Bolt and remove the laptop completely from the design.

 

14th November - I few hours later , I had a servo and a motor controller using a mouse (https://youtu.be/ge6qSBylkrc) . So with Node-RED on the laptop sending USB commands to the Arduino with Standard Firmata installed. This then controlled the H-Bridge and a servo.

 

Another realisation , was that I couldn't have the robot dependant on the laptop, and so I did some more research to find a “USB Host Shield” as the Arduino is only a USB Client and so cannot accept peripherals plugged into it.

 

16th November - USB Host Shield arrived, and I wrote code to use the USB xbox receiver when plugged into the shield. My code is based on the example sketch Xbox Wireless Receiver library  developed by Kristian Lauszus (http://blog.tkjelectronics.dk/2012/12/xbox-360-receiver-added-to-the-usb-host-library/) . 

 

The code can be found here https://github.com/targetarchitecture/zebra-robot/blob/master/First%20Xbox360%20wireless%20reciever%20on%20Arduino.ino 

 

17th November -  Chassis reassembled with battery and arduino. The neighbours children came around to have a drive.

 

 

Ada and I started to build the robot head using a small box and foil, Ada choose the robot eye colour and helped glue the foil on to the head. Ada glued in the LEDs in place. I soldered the servo and LEDs together with (what I now know as dupont cables). I then wrote the code to control the eyes and make the head look left and right.

I built a “kill switch” scenario that turns everything off if you press the “xbox” button on the controller.

https://youtu.be/0RjWz8xK-Hw

 

19th November - Ada decorated the robots head with ears , a smile and lots of pipe cleaners antenna.

 

 

Ada also decorated the kitchen roll arms with “washi” tape.

 

 

 

 

 

20th November - Robot was assembled with more glue and arms attached with Split Pins Butterfly Clip

 

21st November - Initial testing decapitated the robot as the servos move so fast, lock-to-lock in less than one second. This seems a common problem and I had to write code to slow down the servo , this is based on the “blink without delay” example.

 

22nd November - Robot now moves head slowly. I also bought a box of quality street sweets for my work colleagues. https://youtu.be/ZGvjm90Zj_M

 

23rd November - It’s Friday night and Ada decorated the robots front with playdoh lids, coffee jar lids and spares from Cbeebies Arts magazine.

 

 

24th November - Trip to B&Q to get plastic primer paint (note from the future - this didn’t work and the paint peeled). The quality street box is glued and ready for painting.

 

Ada had a little drive to check out the handling

 

https://youtu.be/Gof_GoMDWxA


 

27th November - Borrowed a glue gun and attached the quality street box to the chassis. Attached servos and strain relief to the cables. A lot of mess in the kitchen! Changed the H-Bridge from L298N (https://cdn.instructables.com/FRJ/7W76/HZDYE1YD/FRJ7W76HZDYE1YD.LARGE.jpg?auto=webp) to L9110S (https://robu.in/wp-content/uploads/2018/05/datasheet-l9110.pdf). These have a lot less pins and I was starting to run out of PWM pins on the Arduino. 

 

I found some sample code at https://www.bananarobotics.com/shop/How-to-use-the-HG7881-(L9110)-Dual-Channel-Motor-Driver-Module

 

 

 

 

 

 

 

28th November - People had commented that the robot needed the arms to move. The arduino Uno doesn’t have enough PWM (https://www.arduino.cc/en/Tutorial/PWM)  pins as the USB host shield uses two of them for signalling and not for PWM. So I had to move the Shield Select (SS) and interrupt (INT) pins on the USB host shield. There’s not enough a lot of information on the internet about this with comments around boards being broken or “it’s just not possible”. I found a good site (https://www.circuitsathome.com/mcu/arduino/usb-shield/troubleshooting-arduino-usb-host-shield/). Tried for the first time do this - I hate soldering small things.

 

29th November - Shield pin shift doesn’t look too bad and I had to make a code change in the USB.h header file wirth the library copied locally to the project to only make this change for this project. This is the first time I’ve programmed in C++ and there’s a lot to remember since University computing days.

 

I found a USB host board quality control script and uploaded to the Ardiuno https://github.com/targetarchitecture/zebra-robot/blob/master/USB%20Host%20Shield%202.0%20board%20quality%20control%20routine.ino 


 

 

 

 

So after three days of research , I now have two additional PWM pins on the Arduino for the arm servos and the USB host shield is working after a lot of errors - until I made the USB library change, so SS = GPIO 8 and INT = GPIO 7. The USB host shield board was very cheap and needed the 3.3v and 5v pins connecting in order to provide power for USB connected device and the onboard electronics. Without these the board wasn’t actually powered on and so wasn’t responding to the library causing some wonderfully cryptic messages, when trying to upload the board test script.

 


 

I created a separate copy of the USB host shield library and modified the UsbCore.h file to change the pins for this project only.

 

/* shield pins. First parameter - SS pin, second parameter - INT pin */

#ifdef BOARD_BLACK_WIDDOW

typedef MAX3421e<P6, P3> MAX3421E; // Black Widow

#elif defined(CORE_TEENSY) && (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__))

#if EXT_RAM

typedef MAX3421e<P20, P7> MAX3421E; // Teensy++ 2.0 with XMEM2

#else

typedef MAX3421e<P9, P8> MAX3421E; // Teensy++ 1.0 and 2.0

#endif

#elif defined(BOARD_MEGA_ADK)

typedef MAX3421e<P53, P54> MAX3421E; // Arduino Mega ADK

#elif defined(ARDUINO_AVR_BALANDUINO)

typedef MAX3421e<P20, P19> MAX3421E; // Balanduino

#elif defined(__ARDUINO_X86__) && PLATFORM_ID == 0x06

typedef MAX3421e<P3, P2> MAX3421E; // The Intel Galileo supports much faster read and write speed at pin 2 and 3

#elif defined(ESP8266)

typedef MAX3421e<P15, P5> MAX3421E; // ESP8266 boards

#elif defined(ESP32)

typedef MAX3421e<P5, P17> MAX3421E; // ESP32 boards

#else

//typedef MAX3421e<P10, P9> MAX3421E; //Original before JJ altered

typedef MAX3421e<P8, P7> MAX3421E; // Official Arduinos (UNO, Duemilanove, Mega, 2560, Leonardo, Due etc.), Intel Edison, Intel Galileo 2 or Teensy 2.0 and 3.x

#endif

 

The ardunio code can be found at https://github.com/targetarchitecture/zebra-robot/blob/master/Modified%20USB%20Host%20Library%20for%20Xbox360.ino



 

30th November  - Ada painted the base of the robot.

 

 

I glued the servo arms to lollipop sticks ready for attachment.

 

 

The arms are now working, and the washi taped kitchen roll arms are going to be attached with rubber bands to allow some rough play.

https://www.youtube.com/watch?v=pknRAYQU_Rk 


 

2nd December  - glued the H-bridge onto the chassis. At such low costs I’m not bothered about sacrificing small value components to the glue gun.

Glued the arduino to the top of the battery case. The arduino is now topped with a cheap sensor shield (it also came with the original eBay robot chassis kit). 

 

 

Due to the USB host shield cables being rerouted I could attach the 3 servos  and the 2 motor controls all on the 5 PWM pins.As I had used all of the GPIO digital pins  I had to use the analog pins to drive the eye LEDs using analogWrite.

 

 

 

Added a power socket to allow battery pack with a switch to be externalised. Power from two 18650 3.7v batteries to generate 7.4v. Power is split to the H-bridge and the arduino.

 

 

 

Added strain relief to arm servos, cables routed out of the bottom of the shoe box, who cut out of the lid of quality street tin. I had concerns about the adhesive of the glue so I used tie wraps. 

 

 

 

 

 

 

As usual full assembly takes place on the kitchen counter! You can see the three boards stacked together with the Arduino , USB Host controller, Sensor power distribution board

 

 

First test drive takes place and robot falls flat on its face as it’s top heavy and the acceleration and deceleration is too fast.

 

https://youtu.be/UX-ZvZ7LlEw

 

https://youtu.be/zIQpEGaBLOI

 

4th December 

 

A Quick trip to Monk Bar models for some advice and they recommend another local shop that supplies modelling clay.

 

 

 

Ada helped pack out the robot base with 1Kg of clay to hopefully stop it toppling over.

 

 

 

Ada’s first test drive!

 

Almost immediately problems arise! With the robot spinning around and the microsoft usb receiver disconnecting. I have ordered a USb OTG cable to be able to see the debug details from the serial print statements in the code to diagnose.

 

5 December

 

Thinking it might be Xbox 360 controller I  ordered on eBay a PS2 wireless controller and found some wiring diagrams and code - the “Super amazing PS2 controller Arduino Library v1.8” by Bill Porter (http://www.billporter.info/?p=240). 

 

 

 

14 December

 

After wandering around the living room with my mobile phone using a serial monitor, it looked like the USB receiver would stop working, I put this down to battery power and had a change in plan, from xbox360 USB to an “playstation” RF receiver. This should draw less power, I also started to realise that power management with all of the sensor shield hat was not ideal.

 

The PS2 wireless controller code can be found here https://github.com/targetarchitecture/zebra-robot/blob/master/First%20attempt%20with%20PS2%20wireless%20controller.ino 

 

 

 

So it is goodbye to all of these things below!

 

 

15 December

 

I had also purchased a DIY More “DM Strong Mini UNO R3 Board ATmega328 ATmega16U2 Microcontroller Module Micro USB Compatible for Arduino”

https://www.diymore.cc/products/dm-strong-ch340g-nano-v3-0-16mhz-micro-usb-development-board-atmega328p-microcontroller-module-for-arduino?_pos=10&_sid=ee3cf83f5&_ss=r

 

 

It is the same as an Arduino NANO but has the pins pre-wired up for servo dupont cables, this should lead to a simpler cabling layout, and less power draw than the full sized arduino. I’m learning fast that smaller boards use less power.

 

So with some code from the internet , I wired up a servo and the receiver to the new DIYmore NANO. All went well and I proceeded to wire up the servos and motor controllers as well. As the RF receiver used a lot less pins this meant there was plenty of space on the board.

 

 

 

 

The RF receiver only needs 3.3 volts and the DIYmore board conveniently outputs this so I used dupont wires (orange and blue) to power it.

 

 

16 December

 

Another test drive after a code rewrite to use the RF commands and not the USB Xbox360 commands.

 

https://youtu.be/UX-ZvZ7LlEw

 

 

 

20 December 

 

After more coding Ada get another test drive

 

https://youtu.be/XlWAv2X69ag


 

 

 

https://youtu.be/h4OwzzEmJHA

 

This code can be found here https://github.com/targetarchitecture/zebra-robot/blob/master/Complete%20Code.ino 

 

It was all going well so it seemed as the robot worked...most of the time! Ada held a name my robot competition during her birthday party and then decided on the name “Zebra”. 

 

Zebra worked well, but occasionally would just stop working and start spinning around - just like earlier in the build. Again I put this down to power. By the end of February I had learnt an important lesson that having seperate battery packs for motor load and processing load is sensible as motor load will drain batteries first and control via the processor won’t be lost. 

 

I made space for two internal battery holders and wired up the NANO and the motor board input voltage separately. I also learnt about using a shared negative - after a great discussion with one of my electrical engineer friends - the shared negative is broken via a switch on the outside replacing the power jack I had previously fitted.

 

 





 

YouTube channel @ https://www.youtube.com/channel/UCYGqsl0rZpNkdK8ZrOUIPjQ 

Ada loves Wall-e

   Zebra

       Arduino IDE

       Diymore version

       Html5 on laptop

       IoT with small board

C++ for the first time

       Xbox 360 controller

       Servos

       LEDs

       Resistors

       Batteries lipo

       Robot chassis

       Cardboard

  Single motor controller board

      Had to make the single wheel at the front due to its bad steering

Top heavy - research to find modelling clay

Servos too fast and had to slow them down

       Upgrade to have two battery packs one for circuit and servos one for motors

Creative Commons "Attribution-Share Alike"  Target Architecture