Hug Avoider 4 - micropython, Eggbot and speech

The last of the posts on the Hug avoider and the 4Tronix's Eggbit

4Tronix's Eggbit (in fact I bought three of them https://shop.4tronix.co.uk/collections/bbc-micro-bit/products/eggbit-three-pack-special  :-) recently) is a cute add-on for the microbit. In three previous posts I looked at eggbit using microcode to  produce a hug avoider - warns when people at too close.

• -https://robotsandphysicalcomputing.blogspot.com/2021/12/hug-avoider-2-4tronix-eggbit.html
• - 4tronix Eggbit - cute and wearable - hug avoider

• Hug Avoider 3 - experiments with Python and 4Tronix Eggbit

In this post using the buttons and adding (via Microbit V2 with its speaker) simple speech

1. Buttons

Pins for the buttons

• pin8 - Green button
• pin12 - Red button
• pin14 - Yellow button
• pin`6 - Blue button

    if pin12.read_digital()==1:

        #Red Button

        blank_it()

    if pin8.read_digital()==1:

        #Green button

        startingMessage()

    if pin14.read_digital()==1:

        #Yellow button

        rainbow()

    if pin16.read_digital()==1:

        #Blue botton

        display.show(Image.ASLEEP)

2. Speech

The basis on the code is take from https://microbit-micropython.readthedocs.io/en/latest/tutorials/speech.html

    mess1 = [

    "This is the hug avoide",

    "please keep back",

]

# Take from https://microbit-micropython.readthedocs.io/en/latest/tutorials/speech.html

    for line in mess1:

        speech.say(line, speed=120, pitch=100, throat=100, mouth=200)

        sleep(500

The speech is difficult to hear but is fun and there are possibly ways to improve this starting with the information on  https://microbit-micropython.readthedocs.io/en/latest/tutorials/speech.html

3. Overall

from microbit import *

from machine import time_pulse_us

import neopixel, speech

sonar =pin15

sonar.write_digital(0)

fireled=neopixel.NeoPixel(pin13,9)

def rainbow():

    fireled[0] = (255, 0, 40)

    fireled[1]=  (255,165,0)

    #block=yellow

    fireled[2] = (255,255,0)

    #block=green

    fireled[3] = (0,255,0)

    #block=blue

    fireled [4] = (0,0,255)

    # block=indigo

    fireled[5] = (75,0,130)

    # block=violet

    fireled[6] = (138,43,178)

    #block=purple

    fireled[7] = (255,0,255)

    fireled.show()

def blank_it():

    for j in range(8):

        fireled[j] = (63, 0, 0)

    fireled.show()

def howfar():

    sonar.write_digital(1)

    sonar.write_digital(0)

    timeus=time_pulse_us(sonar,1)

    echo=timeus/1000000

    dist=(echo/2)*34300

    sleep(100)

    return dist

def startingMessage():

    mess1 = [

    "This is the hug avoide",

    "please keep back",

]

# Take from https://microbit-micropython.readthedocs.io/en/latest/tutorials/speech.html

    for line in mess1:

        speech.say(line, speed=120, pitch=100, throat=100, mouth=200)

        sleep(500)

def buttonplay():

    if pin12.read_digital()==1:

        #Red Button

        blank_it()

    if pin8.read_digital()==1:

        #Green button

        startingMessage()

    if pin14.read_digital()==1:

        #Yellow button

        rainbow()

    if pin16.read_digital()==1:

        #Blue botton

        display.show(Image.ASLEEP)

  

while True:

    buttonplay()

    dist=howfar()

    if dist>30:

        pin2.write_digital(1)

        pin0.write_digital(0)

        display.show(Image.HAPPY)

    else:

        pin2.write_digital(1)

        pin0.write_digital(1)

        blank_it()

        speech.say("back away please", speed=120, pitch=100, throat=100, mouth=200)

        display.show(Image.ANGRY)

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

Dancing Kitronik's Game Zap - reacts to music

You will glad to hear this is only a short post.  

In an earlier post, Build a Disco Cube:bit that reacts to music; the vibrations of music, makes the cube sitting on a speaker with the volume pushed to 11 (just to test it of course) react to the music. The accelerometers values in the micro:bit, in the three axis, are feedback to change the neopixels colour. Simple but good fun.

With some very minor (and I do mean minor) changes it works on the Kitronik's Game Zap - eight pixels are altered at a time instead of five but apart from that nothing more. The code in python is shown below:

from microbit import *

import neopixel, random

np = neopixel.NeoPixel(pin0, 64)

while True:

    for pxl in range (3,64, 8):

        rd=int(abs(accelerometer.get_x())/20)

        gr=int(abs(accelerometer.get_y())/20)

        bl=int(abs(accelerometer.get_z())/20)

        np[pxl] = (rd, gr, 0)

        np[pxl+1] = (rd, gr, 0)

        np[pxl-1] = (rd, gr, 0)

        np[pxl+2] = (rd, gr, 0)

        np[pxl+3] = (0, gr, rd)

        np[pxl-2] = (0, gr, rd)

        np[pxl-3] = (rd, 0, 0)

        np[pxl+4] = (0, gr,0)

        np.show()

I was impressed with a few tweaks it worked! Please feel to share and copy, if this useful to you please share in the comments.

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

Speech with EduBlocks on BBC microbit

The microbit is a great piece of kit, not least of which because of the range of programming languages and tools that can be used with it - officially JavaScript and Python and but there is also a range of third-party ones. A useful place to look for what languages/tools  are available is http://microbit.org/code-alternative-editors/; listing both official and third-party tools (there was a few I wasn't aware of ). One I was aware and meaning to play with, is the brilliant Edublocks by Josh Lowe (@all_about_code) or more  specifically in this post Edublocks for BBC Micro:bit (https://microbit.edublocks.org/).



Edublocks for the microbit (and Edublocks in general) allows graphical blocks of code, in a similar way to languages such as Scratch, to be dragged and dropped into places. That in itself would be great, but the really useful thing here is though, whilst doing it you are actually producing a Python program (technically in the microbit case micropython)- a good way (as others have said before e.g https://www.electromaker.io/blog/article/coding-the-bbc-microbit-with-edublocks ) of bridging the gap between block based programming tand text-based programming language (ie. Python). Added to this is the support for Python on the microbit and the things like speech, access the pins and neopixels you have a really useful and fun tool. 

Talk is cheap (sort of!)
The project shown here is getting the microbit to 'talk' using speech. I have attached a microbit to Pimoroni's noise bit for convenience (https://shop.pimoroni.com/products/noise-bit)  but equally, alligator wires and headphones could be used (https://www.microbit.co.uk/blocks/lessons/hack-your-headphones/activity ). The routine below allows when button A on the microbit is pressed the Microbit (through a speaker) to say Hello, B say Good bye and when both pressed Now what ? Simple but fun.

The equivalent Python code

They are essentially the same.


Here is a video of it in action:






Thoughts.

As you might have gathered I think this Edublocks for the microbit is a fantastic tool. I am planning my new experiments with it now- coming soon to this blog. Edublocks for the microbit is not all Edublocks can do, the project itself can be found at https://edublocks.org/ is well worth a look. For playing with the microbit for the first time with Python I would recommend Edublocks for the microbit  https://microbit.edublocks.org/


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

Radio controlled microbit Robot Unicorn

In a previous post a robot unicorn was built from a kit (Do it Kits https://doitkits.com/product/robot-unicorn/) and controlled to do a fixed sequence of actions. In this post a similar thing will be done, but this time the actions are not fixed within the robot itself, but in response to messages sent from another microbit via the radio module.

Sending

Sends out messages via the microbit's radio module, e.g. fwd for forward or tr for turn right; as well the name of the actions scrolls across the microbit.


On the Unicorn

Revieves messages via the microbits radio module, e.g. bwd for backward or tl for turn left; then carries out the action for 500ms. The time was selected to give the system enough time to finish the action before the next message is expected.




All the code available at Turner, S., 2017. Robo_unicorn_python. Available at: <Robo_unicorn_python> https://doi.org/10.6084/m9.figshare.5729583.v7

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

Micro:bit Robot Arm

In this post, I am discussing using a recently bought  CBIS BBC micro:bit RobotArm, but play with it using Python (or rather micropython).

Set Up
Not a lot to set up really. The base and the arm are separate and are attached with four screws (so you will need a screwdriver). 

The most difficult bit is the wiring the arm to the circuit/breakout board on the base, but instructions are available through CBiS Resource portal http://portal.cbis.education/teacher/hardware. You will need a log-in for this. Also on that site, there is an example Microsoft Blocks code which includes some instructions on inserting the microbit as well - the micro:bit goes in buttons side facing upwards.


Code
Taking the values from the instruction sheet for setting it - the micro:bit key bit - the following pins were selected.
Base                     Pins 0 and 1
Shoulder               Pins 8 and 12
Elbow                   Pins 2 and 13
Wrist                    Pins 14 and 15
Gripper                 Pins 16 and 11 - this is the only one I haven't got working yet.

So to test it out, a simple bit of code to drive each motor in both directions was produced and is shown below.



This is good fun to play with. The use of the micro:bit is a good idea because it's ease of use to plug-in and play with.

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

kitronik :Move mini buggy (Python control of LEDs)

In two previous posts I looked at control the :Move buggy using JavaScript Blocks or Python. In this post we are going to look at controlling the LEDs using Python (or more accurately micropython).

Pin 0 controls the LEDs, they are based on5  NeoPixel compatible, RGB, addressable LEDs; so the Neopixel protocols (and library for Neopixels) can be used. 

Code First five colours of the rainbow. The array lig holds the RGB settings for the rainbow colours (more details on the RGB colours can be found at Lorraine Underwood's Halloween Cloud project). In the code below, the five LEDs have a different colour allocated to them.

from microbit import *
import neopixel

np = neopixel.NeoPixel(pin0, 5)
lig=[[255,0,0],[255,127,0],[255,255,0],[0,255,0],[0,0,255],[75,0,136],[139,0,255]]
while True:
    np[0] = lig[0]
    np[1] = lig[1]
    np[2] = lig[2]
    np[3] = lig[3]
    np[4] = lig[4]

    np.show()


Code to cycle through the rainbow
from microbit import *
import neopixel

np = neopixel.NeoPixel(pin0, 5)
lig=[[255,0,0],[255,127,0],[255,255,0],[0,255,0],[0,0,255],[75,0,136],[139,0,255]]
count1=1
count0=0
count2=2
count3=3
count4=4
while True:
        np[0] = lig[count0]
        if count0>=6:
            count0=0;
        else:
            count0=count0+1
        np[1] = lig[count1]
        if count1>=6:
            count1=0;
        else:
            count1=count1+1
        np[2] = lig[count2]
        if count2>=6:
            count2=0;
        else:
            count2=count2+1
        np[3] = lig[count3]
        if count3>=6:
            count3=0;
        else:
            count3=count3+1
        np[4] = lig[count4]
        if count4>=6:
            count4=0;
        else:
            count4=count4+1
        np.show()

        sleep(500)


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

kitronik :Move buggy (Python controlled servos)

In a previous post I looked at controlling the Kitronik :Move buggy using Javascript based blocks. In this short post I will show controlling the servos of the micro:bit based :Move buggy with Python.

Control is via pin1(left motor) and pin2 (right motor) and the motors have to be driven in opposite directions to move forward or backwards. The direction of the motors is controlled by the analogue value written to the pins; pinX.write_analog(180) - anticlockwise or pinX.write_analog(1) - clockwise (pinX.write_analog(0) - stops the motor). Setting the analog_period seems to work at 20ms; this was found by experiment, discussed in a previous post.

So the initial code below sets up the moves for forward, backward, turn left, turn right all controlled with a move for so many milliseconds.

Code 
from microbit import *

pin1.set_analog_period(20)
pin2.set_analog_period(20)

def forward(N):
    pin1.write_analog(180)
    pin2.write_analog(1)
    sleep(N)
    
def backward(N):
    pin1.write_analog(1)
    pin2.write_analog(180)
    sleep(N)

def turnLeft(N):
    pin1.write_analog(1)
    pin2.write_analog(1)
    sleep(N)

def turnRight(N):
    pin1.write_analog(180)
    pin2.write_analog(180)
    sleep(N)

while True:
    forward(1500)
    backward(1500)
    turnLeft(1500)
    turnRight(1500)   

I would recommend running the :Move buggy on a surface that isn't smooth, I found the wheels slipping on a smooth surface. This is a really nice little robot to play with.

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

CBiS Education Micro:Bit based Robot Car

At PiWars 2017 (1st-2nd April 2017), thanks to the generosity of CBiS Education, I now have one of their BBC micro:bit RobotCar^™ . It is a sturdy bit of kit, encased in an aluminum chassis with a clear acrylic screen - it feels substantial when you pick it up. 

It is based around fours motors, control by a Micro:Bit, via L298N based motor controller/shield. Batteries power, 8 AAs, the motors and a Lithium powerbank to power the Micro:Bit - all included. 

More information about the technical details and example software can be found on their site https://www.cbis.education/robotic-car-kit# including further details on the L298N based motor controller/shield, which I found useful for programming it. 

I have experimented briefly with programming it in Python (micropython), getting it to it move forward, backward; to the right and left, using the Mu editor. 

The code is shown below for those who want to try it:

from microbit import *


def forward(n):
    pin13.write_digital(1)
    pin16.write_digital(1)
    sleep(n)
    
def backward(n):
    pin14.write_digital(1)
    pin15.write_digital(1)
    sleep(n)

def stopit(n):
    pin13.write_digital(0)
    pin14.write_digital(0)
    pin15.write_digital(0)
    pin16.write_digital(0)
    sleep(n)

def spinLeft(n):
    pin13.write_digital(1)
    pin15.write_digital(1)
    sleep(n)

def spinRight(n):
    pin14.write_digital(1)
    pin16.write_digital(1)
    sleep(n)


while True:
    forward(500)
    stopit(1000)
    backward(500)
    stopit(1000)
    spinRight(1000)
    stopit(1000)
    spinLeft(1000)
    stopit(1000)


This thing is quick. I like the feel of it, you pick it up and it doesn't feel like it is going to fall apart; because it comes all assembled - including batteries, it is ready to go. I look forward to trying some more ideas on it.

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

4Tronix Bit:Bot - now there is a good idea.

When I first heard of this robot, my first thought was what a great idea; a robot with neopixels (I know I should be saying 'smart RGB LEDs' but neopixels is so much more snappier) controlled via a micro:bit.

A good starting point for learning more about this robot, is the details on the 4Tronix site/blog, which includes build guidance and programming instructions for micropython and PXT. Though for the micropython code you might need to change pinX.digital_write() to pinX.write_digital() where X is the pin number.

My play code was to randomly select which neopixels to light up, I didn't include code to turn them off so multiple ones can be on. The robot is driven forwards, waits, backward, waits, turns to the right and then the left; and then repeats. 

Code:
from microbit import *
import neopixel, random

np = neopixel.NeoPixel(pin13, 12)

def forward(n):
    pin0.write_digital(1)
    pin8.write_digital(0) 
    pin1.write_digital(1)
    pin12.write_digital(0)
    sleep(n*1000)
    
def halt(n):
    pin0.write_digital(0)
    pin8.write_digital(0)
    pin1.write_digital(0)
    pin12.write_digital(0)
    sleep(n*1000)
    
def backward(n):
    pin0.write_digital(0)
    pin8.write_digital(1) 
    pin1.write_digital(0)
    pin12.write_digital(1)
    sleep(n*1000)

def right_turn(n):
    pin0.write_digital(1)
    pin8.write_digital(0) 
    pin1.write_digital(0)
    pin12.write_digital(1)
    sleep(n*1000)

def left_turn(n):
    pin0.write_digital(0)
    pin8.write_digital(1) 
    pin1.write_digital(1)
    pin12.write_digital(0)
    sleep(n*1000)

while True:
    pxl=random.randint(1,11)
    rd=random.randint(1,32)
    gr=random.randint(1,32)
    bl=random.randint(1,32)
    t1=random.randint(10,100)
    np[pxl] = (rd, gr, bl)
    np.show()
    forward(1)
    halt(1)
    backward(1)
    halt(1)
    right_turn(1)

    left_turn(1)

The video below shows it in action, the code is simple but this is a lovely robot to program especially if the mu editor is used.




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

Simple (and temporary) Halloween Hack

This really is a simple one. A Glowbug (or a NeoPixel) with the data in, Ground and 5v connected pushed into the neck of the balloon, then inflated the balloon. The neck of the balloon and wires are twisted tightly and insulating tape used to provide a bit of a seal.

The data in wire is connected to Pin 0 of a Micro:Bit and the other two wires are attached to the corresponding connections of the Micro:Bit. The code below randomly selects the colours and the length of the delay before changing colour.

from microbit import *
import neopixel, random

np = neopixel.NeoPixel(pin0, 1)

while True:
    rd=random.randint(1,254)
    gr=random.randint(1,254)
    bl=random.randint(1,254)
    t1=random.randint(200,2000)
    np[0] = (rd, gr, bl)
    np.show()
    sleep(t1)

The problem is a slow leak means it only stays inflated for a short while.


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

Dancing pixels

In previous post I played with using the combination of the Proto-Pic Micro:pixel and Micro:Bit to react, using the accelerometer, to music through a computer speakers. The vibrations from the music shake the Micro:Bit enough to give measurable changes in three axis, and these values are used to change the pixels colour.



The latest version of this uses most of pixels.

Coded in micropython using the Mu editor.

from microbit import *
import neopixel, random

np = neopixel.NeoPixel(pin0, 32)

while True:
    for pxl in range (2,32, 5):
        rd=int(abs(accelerometer.get_x())/20)
        gr=int(abs(accelerometer.get_y())/20)
        bl=int(abs(accelerometer.get_z())/20)
        np[pxl] = (rd, gr, 0)
        np[pxl-1] = (rd, gr, 0)
        np[pxl+1] = (0, gr, rd)
        np[pxl-2] = (rd, 0, 0)
        np[pxl+2] = (0, gr,0)
        np.show()

Video of it action, using royalty-free music Electro Deluxe by My Free Mickey feat. Gurdonark. http://dig.ccmixter.org/files/myfreemickey/48180





As one of the reviewers on Proto-Pic site states, the box the Micro:pixel comes in does make a good diffuser.

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

Microbit + Micro:pixel reacting to music

This post discusses a simple way to get the Micropixel-Micro:Bit combination to change the Neopixels based on the music. Using the accelerometer on the Micro:Bit to provide x,y,z values to provide colour values for the neopixels; the micropixel sits over the speaker and vibrations are picked up. 

Simple but it roughly works (see the video at the end of the post).


Code
from microbit import *
import neopixel, random

# Setup the Neopixel strip on pin0 with a length of 2 pixels
np = neopixel.NeoPixel(pin0, 32)

while True:
    pxl=11
    rd=int(abs(accelerometer.get_x())/20)
    gr=int(abs(accelerometer.get_y())/20)
    bl=int(abs(accelerometer.get_z())/20)
    t1=10
    np[pxl] = (0, 0, bl)
    np[pxl-1] = (rd, gr, 0)
    np[pxl+1] = (0, gr, rd)
    np[pxl-2] = (rd, 0, 0)
    np[pxl+2] = (0, gr,0)
    np.show()
    sleep(t1)
    np[pxl] = (0, 0, 0)
    np[pxl+1] = (0, 0, 0)
    np[pxl-1] = (0, 0, 0)
    np[pxl+2] = (0, 0, 0)
    np[pxl-2] = (0, 0, 0)


Video of it action using Revolve by cinematrix available under Creative Commons Licence (http://ccmixter.org/files/hisboyelroy/430 ).





Always obey the safety advice provided by Micro:bit https://microbit0.blob.core.windows.net/pub/jedfednb/Parent-and-Teacher-micro-bit-safety-guide.pdf 



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

Disco micro:pixel

In a previous post Proto-Pic board, Microbit and Micropython I played with the Proto-Pic micro:pixel 4x8 NeoPixel board. 

This post is just a short description of a quick play with making it flashing blocks of different colours across the board. The routine produces five random numbers (three to define the colours, one for which pixel is selected and the last for the delay each iteration). The idea of being - a pixel is selected, but so are the ones either side of it, each one has a different combination of the colour values, but only two of the pixels are turned off after the delay.

from microbit import *
import neopixel, random

# Setup the Neopixel strip on pin0 with a length of 2 pixels
np = neopixel.NeoPixel(pin0, 32)

while True:
    pxl=random.randint(1,30)
    rd=random.randint(1,32)
    gr=random.randint(1,32)
    bl=random.randint(1,32)
    t1=random.randint(10,100)
    np[pxl] = (rd, gr, bl)
    np[pxl-1] = (gr, bl, rd)
    np[pxl+1] = (bl, rd, gr)
    np.show()
    sleep(t1)
    np[pxl] = (0, 0, 0)
    np[pxl+1] = (0, 0, 0)

The video below shows the routine in action. There is no connection between the pixels and the music on the video - but making the connection between music and the pixels would be an interesting project.




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

micro:pixel board, micro:bit and micropython

A new (or to me at least)  addition to devices you can attach a Micro:Bit to, is the Proto-Pic micro:pixel 4x8 NeoPixel board; essentially a board with 4 x8 grid of NeoPixels that you plug the Micro:Bit into. Following the advice of the website the  values of RGB are all set to 32 or below to avoid pulling too much power. Pin0 is used to write to. You will need to use the Mu editor for this.

Two tests were tried

Example 1: To get the pixels to appear to light up from the last to the first one.

from microbit import *
import neopixel

np = neopixel.NeoPixel(pin0, 32)

while True:
    for x in range(0, 32):
        for y in range(0, (32-x)):
            np[y] = (y, 32-y, 1)
            if (y>0):
                np[y-1]=(0,0,0)
            np.show()
            sleep(30)




Example 2: To randomly select a pixel and its colour.

from microbit import *
import neopixel, random

np = neopixel.NeoPixel(pin0, 32)

while True:
    pxl=random.randint(0,31)
    rd=random.randint(1,32)
    gr=random.randint(1,32)
    bl=random.randint(1,32)
    np[pxl] = (rd, gr, bl)
    np.show()
    sleep(500)
    np[pxl] = (0, 0, 0)




This is a good, fun board to play with; relatively easy to use.





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