Sunday, 25 September 2016

UFO talks to Robot - part two

In part one of this series of posts, the project to get Consumable Robotics UFO and Dimm robot was started but focussed on the UFO kit. The goal being for some action on Dimm to trigger a series of messages being passed between the two of them.

In this post, the focus moves to Dimm and the setting up the actions leading to the messaging.

Stage 1 Build
Using the Micro:bits port 0 (as part of the Dimm robot) for the input from the light sensor, which is included in the kit (Red lead going to 3v and the black lead going to GND). Just to note the less light there is the higher the value on the sensor.




Stage 2 Code
Micropython programmed through the Mu editor (see below)

If light levels are high then :
      scroll a message saying "calling UFO" 
      send the code "dimm" via bluetooth.
otherwise: 
      scroll a message saying "I can't see"
If it recieves "ufo" via bluetooth :
      display "Hello, UFO called me"

Micropython code
import radio
from microbit import pin0, pin1, display, sleep

radio.on()

while True:
   incoming = radio.receive()
   if incoming == 'ufo':  
      display.scroll("Hello, UFO called me", 75)
   if pin0.read_analog()<175:
        display.scroll("calling UFO")
        radio.send("dimm")
   else:
        display.scroll("I can't see")

Stage 3 Testing

Video below shows it in action including what happens when the light (in this case a torch) shines on the sensor connected to Dimm; a message is sent and picked up by the UFO kit (LEDs flash and the message saying "DIMM calling" scrolls  across the UFO LED array - see UFO talks to robot - part one for more details). A message is sent back from the UFO kit and on Dimm's LED array the message "Hello, UFO called me").
If the light levels are too low then the message "I can't see" scrolls across Dimm's LED array.






As an aside, the Dimm robot still reminds me, a little, of a colourful, friendly, Ood from Dr Who with all the leads hanging out of the 'mouth' - think that is geeky I know.




All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with. Twitter @scottturneruon

UFO talks to Robot - part one

In previous posts (UFO has Landed and DIMM the OOD),  I started playing with the CBiSEducation's UFO consumable robots. Still using the Micro:Bit, in this two part post series, I am going to be playing with using Micropython to send messages between the two kits.






Stage 1 Wiring and Set up-UFO
Pins 0 and 1 are outputs to the LEDs
The black leads on the UFO go to GND.

Micropython, using the Micro:Bit's built in radio module (Bluetooth), is used to communication between the two kits.



Stage 2 Code -UFO
The code is set to flash the UFO's LEDs and then scroll a message "DIMM Calling" when it receives a message "dimm" via Bluetooth. 

Basic overview is
- Turn on the radio module - radio.on()
- If the message is received then turn the LEDs on and off and scrolls "DIMM calling" across the LED array.
- send a message via bluetooth "ufo" to whoever is listening (in the end the robot DIMM hopefully). The code is shown below. 

import radio
from microbit import pin0, pin1, display, sleep

def pulseLed1(duration):
   pin1.write_digital(0)
   pin0.write_digital(1)
   sleep(duration)
   
def pulseLed2(duration):
   pin1.write_digital(1)
   pin0.write_digital(0)
   sleep(duration)
   
def stopIt():
   pin0.write_digital(0)
   pin1.write_digital(0)

radio.on()

while True:
   incoming = radio.receive()
   stopIt()
   if incoming == 'dimm':   
      pulseLed1(1000)
      pulseLed2(1000)
      stopIt()
      radio.send("ufo")
      display.scroll("DIMM calling")

To use the radio module you will need to switch to the mu editor (http://codewith.mu/).




Stage 3 Testing it
To test it, a second Micro:bit was used to send test signals (the code for this is shown below). When button A is pressed on the second Micro:Bit a message 'dimm' is sent followed by sending 'not'.

import radio
from microbit import button_a, button_b, sleep

radio.on()

while True:
   if button_a.is_pressed():
       radio.send('dimm')
       radio.send('not')
       
   if button_b.is_pressed():
       radio.send('ufo')
       radio.send('not')


The UFO does cycle through the sequence LEDs flash and the message scrolls. The slight bug is in repeats it several times before it stops; possibly a buffering issue somewhere.




Stage 4 
In the next post (http://bit.ly/2d3zlh0), I will be building the Robot DIMM part of the system - sending and receiving message and detecting light levels in micropython.







All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with. Twitter @scottturneruon

Saturday, 24 September 2016

Crumblebot - explorer bot?

In an earlier post I played with 4Tronix's CrumbleBot to make an edge follower robot (http://robotsandphysicalcomputing.blogspot.co.uk/2015/07/edge-following-crumblebot.html). I wanted to play a little more, so I looked at making it 'explore' a room a bit and recently 4Tronix's have released an add-on panning ultrasonic sensor for the CrumbleBot - how can I resist?



What is a CrumbleBot
The CrumbleBot (http://4tronix.co.uk/store/index.php?rt=product/product&product_id=493) is based around the Redfern Electronic's Crumble Controller (http://redfernelectronics.co.uk/crumble/) and Crumble software (http://redfernelectronics.co.uk/crumble-software/); providing an intuitive graphical interface (similar to Scratch) to control two motors and four inputs/outputs. The CrumbleBot comes with a number sensors including  line-detecting sensors and Light-Dependent Resistors for light detection and you use crocodile clips to connect the sensors to the inputs/outputs. In essence, this is nice little framework for simple robotics and quite forgiving; the commands are kept to a minimum and loading the program to the bot is just one action. One suggestion, is to make sure you order the Crumble Controller at the same time as CrumbleBot, it is easy to forget if you haven't already got a crumble controller already.

Building the 'Bot' is relatively simple and 4Tronix have provided some easy to follow instructions on-line (http://4tronix.co.uk/crumble/CrumbleBot.pdf) that are almost foolproof (I manage to build it!).


Panning sensor

This is an add-on piece (http://4tronix.co.uk/store/index.php?rt=product/product&keyword=crumblebot&category_id=0&product_id=556), at the time of writing this costing around £12 (with VAT), which adds a ultrasonic sensor that pans and is controlled using Crumble. The instructions for setting this up are available at http://4tronix.co.uk/blog/?p=1353 you need to read from about half way down the page, they are detailed and please don't do what I did and skim through them, missing out an important action. 


'Explorerbot' 
The Crumblebot is built, the Panning ultrasonic sensor is connected - in my case IO port A for the servo to pan the sensor and IO port D for the input from the sensor - time to program it. The instructions in the set-up http://4tronix.co.uk/blog/?p=1353 include a useful little starting routine to read the sensor and 'zero' the sensor's position.

So my exploring routine is based around 


  • panning the sensor by +/-20 degrees of the sensor facing forward.
  • if an object is 5cm or less from the sensor; reverse the Crumblebot and make a slight turn; otherwise move forward.
The code is shown below:

The video shows the 'Explorerbot' in action.




Conclusion
It is good fun; this is a relatively simple problem but still fun. The Crumble language is Scratch-like and simple to set up and use. Crumble as a system I have, so far, found quite forgiving and this is useful - less fear of making a mistake.The panning sensor gives this already cute robot an even cuter look. Please feel free to add the discussion using the comment section.





All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with. Twitter @scottturneruon

Saturday, 17 September 2016

Python Junkbot - PyCon UK 2016

Poster presented at PyCon UK 2016, 17th September 2016.



Pyconuk16 junkbots from Scott Turner

DOI: 10.13140/RG.2.2.28682.67520

For more details on the three builds:






All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with. Twitter @scottturneruon

Sunday, 11 September 2016

Do it yourself: Remote Controlled Micro:Bit Junkbot

In an earlier post, I showed how you could build a Micro:Bit controlled Junkbot. In this post I want to show a modification to it, to use one Micro:Bit to control the junkbot controlled by another Micro:Bit. A nice feature of the Micro:Bit using micropython, is it can send and receive simple messages via radio - so here is my take on it.

The first problem is the Python editor available on https://www.microbit.co.uk/ does not seem to work with the radio API. One solution to this is to change to the mu editor.


Two pieces of code are needed.

Sending Code for the 'remote' control:
Essentially it is set up to send two messages, via the built-in radio module, spinl or spinr depending on which button is pressed.

import radio
from microbit import button_a, button_b

radio.on()

while True:
   if button_a.is_pressed():
       radio.send('spinl')
   if button_b.is_pressed():

       radio.send('spinr')

Junkbot Code
This takes an adapted form of the previous Junkbot code to work by; on receiving spinl or spinr via the radio link; spin the motor clockwise or anticlockwise.
import radio
from microbit import pin8, pin12, sleep

def leftTurn(duration):
   pin8.write_digital(0)
   pin12.write_digital(1)
   sleep(duration)
   
def rightTurn(duration):
   pin8.write_digital(1)
   pin12.write_digital(0)
   sleep(duration)
   
def stopIt():
   pin8.write_digital(0)
   pin12.write_digital(0)

radio.on()
while True:
   incoming = radio.receive()
   if incoming == 'spinl':
        leftTurn(500)
        stopIt()
   if incoming == 'spinr':
        rightTurn(500)
        stopIt()








All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with.

How to do it yourself: Microbit Junkbot


What is a Junkbot?
For this project, it is a moving ‘bot’ made from waste materials, combined with an electric motor and a programmable device (in this case a Micro:Bit) to control (or try) it. An example is shown below. More details on junkbots can be found at http://junkbots.blogspot.co.uk/


Stage 1 - The start of a Junkbot
This stage is relatively simple. Tape some pens or straws to a drinks can.




Stage 2 - Physical arrangement of Microbit and motor control board

The control part is this via a Micro:bit (http://www.bbc.co.uk/programmes/articles/4hVG2Br1W1LKCmw8nSm9WnQ/the-bbc-micro-bit). Kitronik produce a motor driver board, and provide quite a bit of support for it, for the Micro:Bit (the latest version of the board can be found at https://www.kitronik.co.uk/5620-motor-driver-board-for-the-bbc-microbit-v2.html ). A 6v battery pack is connected (see on the left of the image) and wires going to a motor are attached to the first block on the front left (marked as motor A).



The overall arrangement is show below, including a broken propellor as an unbalanced load to make the motor vibrate - the propellor was to hand but if you can secure something a clothes peg this could be used.


Stage 3 - Built Junkbot
Now we just need to put them together by taping (or fixing somehow) the motor to the junkbot built in stage 1. A further possibility is to attach the Micro:Bit, motor driver board and battery pack to the junkbots; but this adds weight.








Stage 4 Code
 Using Micropython via the online editor https://www.microbit.co.uk to program the board and therefore the junkbot. 
An example piece of code is shown below:

from microbit import *

def startIt():
   pin8.write_digital(1)
   pin12.write_digital(0)
   pin0.write_digital(1)
   pin16.write_digital(0)    

def leftTurn(duration):
   pin8.write_digital(0)
   pin12.write_digital(1)
   sleep(duration)
   
def stopIt():
   pin8.write_digital(1)
   pin12.write_digital(1)
   sleep(2000)

while True:
   startIt()
   
   if button_a.is_pressed():
       leftTurn(100)
   
   if button_b.is_pressed():
       stopIt()

Unplug the Micro:bit from the motor driver board and download the code to the microbit. Unplug the download cable and plug the Micro:Bit back into the motorboard, with the battery pack attached there is enough power for the Micro:Bit and the motor - don't plug in any other power including the programming cable when it is in the motor driver board.


Stage 5 In action



Suggested Resource List
  • Small Electric Motor
  • Kitronik Motor Board
  • Battery Pack
  • BBC Micro:bit
  • Pens
  • Junk (Can or Bottle)
  • Wires
  • Tape
  • Scissors
  • Broken Propeller or un-balanced load
  • Screw Driver


Related Links






All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with.

Wednesday, 7 September 2016

DIMM 'the OOD' Cardboard Robot

CBiS Education generously sent me two of their new range of robotics development kits - BinaryBots  (https://www.binarybots.co.uk/makers.aspx), these are a range of cardboard based kits (so far a robot and a UFO) with electronic components for example LEDs; sensors and buzzers,  depending on the kits. What makes the kits interesting though is they are designed to be controlled by either by a BBC Micro:bit or a CodeBug.In an earlier post,  I played with the UFO one (http://robotsandphysicalcomputing.blogspot.co.uk/2016/08/ufo-detects-light.html), now I have had a chance to play the DIMM the robot.

With the wires hanging out of the mouth and its humanoid shape it reminds we a bit of the OOD from Doctor Who (https://en.wikipedia.org/wiki/Ood) but a lot more unthreatening.




How to build it video from @cbiseducation is shown below.




So I built a Light detection system with the light sensor that came with the kit and added a microbit. The idea was
- to play one sound when the light level is low as well display an 'L' on the Microbit;
- to play another sound when the light level is higher and display an 'H' on the Microbit.

The code used is shown below. It is built around the forever loop, the light sensor is connected to Pin 1 and the speaker on Pin 0 (ground and Vcc connected as appropriate see the robot below). when the sensor value is greater than 175 then the low light level is detected otherwise the higher light is detected.


The video below shows this enjoyable kit in action - the sound level is a bit low in the video.





All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with.

Friday, 2 September 2016

Matthew takes control of robot research project

Taken from: http://www.northampton.ac.uk/news/matthew-takes-control-of-robot-research-project/




Matthew Hole
A sixth-form student has spent the summer at the University of Northampton investigating the possibility of controlling DIY robots with a computer half the size of a credit card.
Matthew Hole, who attends Wrenn Academy in Wellingborough, has been awarded a Nuffield Research Placement – a scheme which offers sixth formers the chance to work on university research projects during the summer.
During his time at the University, Matthew used a BBC micro:bit computer  to control a junkbot – a robot made from junk, such as a drinks can, powered by a kit.
Junkbots have previously been controlled by a Raspberry Pi computer, but the University’s Associate Professor in Computing and Immersive Technologies, Dr Scott Turner, saw the potential to harness the micro:bit.
“The micro:bit has been given away free to every Year 7 pupil in the UK, so it made sense to investigate how well it could control a junkbot.
“Matthew worked incredibly hard on the research project, overcoming several problems, and was successful in harnessing the micro:bit to control a junkbot.
“He used his experience to produce an action pack, which will be available for schools to refer to so that pupils can learn how to control a junkbot with the micro:bit – so Matthew’s research has the potential to benefit thousands of young people across the UK and beyond.”
Matthew said: “The project has definitely helped me to develop my problem solving skills: I’ve learnt how to break projects down into small pieces and work on them methodically, which has been really useful,” said Matthew, who has received a bursary to carry out his work.
“To be able to work on an action pack that will be available for schools to use is also a fantastic thing to have on my CV.”

To learn more about the junkbots project contact: scott.turner@northampton.ac.uk or go to http://robotsandphysicalcomputing.blogspot.co.uk/2016/08/creating-microbit-junkbot-for-use-in.html





All opinions in this blog are the Author's and should not in any way be seen as reflecting the views of any organisation the Author has any association with.

Gesture controlled python robot unicorn (or is it a rhino)

In the previous two post I built and played with a robot unicorn from  Do it Kits https://doitkits.com/product/robot-unicorn/ . In the first...