Final, Final, Microbit RC

Following on from the last post about the remote control microbit powered bitbot, I think I mentioned all the way along that the car source code and functionality I would like to include is constantly butting up against the program size restriction that the microbit can accomodate. If you create too big a program, then after the flashing process finishes you will see a “memory allocation” error scrolling across the screen.

After a bit of searching I found this post useful. It turns out that classes, code comments, long functions and long variable names all contribute to larger program sizes.

One of the selling points for the code as I had always organized this project was the easy understandability of the classes for motor, led etc. It looked like I was going to have to abandon some of those and replace some variables if I wanted to continue to add functionality to the project.

Handset

The handset code didn’t change very much because that has always been small enough (about 100 lines) and all I needed was to add a couple of extra commands to send to the car.

Commands

I remapped the A and B buttons to the headlights and horn commands respectively and moved the not very often used fast and slow commands to the edge connectors. Hitting the A button cycles the cars lights through on, off and auto settings, where auto means to use the microbit’s light sensor to decide if it needs to turn on the headlights. Hitting the B button sounds a quick double toot on the horn to let people know you are coming. I also added a horn sound when the car starts reversing as a nod to safety and realism.

Watchdog

I also noticed during testing that if I pulled the plug on the handset, the car stopped receiving messages but could continue to drive the motors, perhaps with disasterous results. I decided that a cut off would be useful if the two halves ever lost contact with each other. As well as the normal movement commands I added a watchdog ‘hi’ to send out to the car approximately every 5 seconds even when no control commands are being sent.


from microbit import *
import radio

def wait_for_contact():
    hello = 'hi'
    waiting = True

    while waiting:
        display.set_pixel(2, 2, 9)
        sleep(100)
        radio.send(hello)

        msg = radio.receive()

        if msg and msg == hello:
            waiting = False
        else:
            display.set_pixel(2, 2, 0)
            sleep(100)

def show_contact_made():
    for i in range(5):
        display.show(Image.HEART_SMALL)
        sleep(500)
        display.show(Image.HEART)
        sleep(500)

fwd_rev_tilt = 250
steering_tilt = 250

forward_command = 'F'
stop_command = 'S'
left_command = 'L'
right_command = 'R'
reverse_command = 'B'
fast_command = 'Z'
slow_command = 'W'
lights_command = 'I'
horn_command = 'P'
watchdog_command = 'hi'

display.scroll("bitBot RC handset")

radio.on()

wait_for_contact()
show_contact_made()

last_cmd = ''
watchdog_counter = 0

while True:

    cmd = ''

    if button_a.was_pressed():
        cmd = lights_command
    elif button_b.was_pressed():
        cmd = horn_command
    elif pin0.is_touched():
        cmd = slow_command
    elif pin2.is_touched():
        cmd = fast_command
    else:
        forward_back = accelerometer.get_y()
        side_to_side = accelerometer.get_x()

        if abs(forward_back) >= abs(side_to_side):
            # priority to fwd reverse
            if forward_back < -fwd_rev_tilt:
                display.show(Image.ARROW_N)
                cmd = forward_command
            elif forward_back > fwd_rev_tilt:
                display.show(Image.ARROW_S)
                cmd = reverse_command
        else:
            if side_to_side > steering_tilt:
                display.show(Image.ARROW_E)
                cmd = right_command
            elif side_to_side < -steering_tilt:
                display.show(Image.ARROW_W)
                cmd = left_command

    if cmd == '':
        display.show(Image.SQUARE_SMALL)
        cmd = stop_command

    if cmd != '' and cmd != last_cmd:
        radio.send(cmd)
        last_cmd = cmd

    # try to keep in constant contact
    # even if nothing has changed so
    # we don't run away
    watchdog_counter += 1

    # send every 5 seconds or so
    if watchdog_counter >= 20:
        radio.send(watchdog_command)
        watchdog_counter = 0

    sleep(250)

Car

On to the car. After flattening out the functions from their original classes, I needed to some renaming to make their use more obvious and to organize them into a more coherent structure. First motor commands, then lights, then overall “car” commands. Notice the number of string and number literals I had to use to get the code shoehorned into the microbit.

Lights

The last version had an auto headlight feature using the light detector but this time I added a manual on and off override as well as adjusting the intensity of all the lights.

Horn

As mentioned above, the bitbot piezo horn is put to use to warn everyone when reversing and for tooting when the driver hits the B button on the handset. Just like a real car!

Watchdog

The final feature was implementing a more sophisticated run loop. The outer loop still runs forever but I added an inner loop to wait for initial contact, then run as long as the handset was in communication with the car. Either by sending a movement command or by the special ‘hi’ command. We increment the watchdog count every time through the loop and reset the count when we get another message over the radio. If we go too long without contact, we drop out of the inner while loop, stop the motors and wait for contact to be established again at the top of the outer loop.


from microbit import *
import radio
import neopixel

# Motors - speed and direction
left_motor = [pin0, pin8]
right_motor = [pin1, pin12]

# Motor Functions
def pulse_width_modulate(motor, speed, direction):
    if 1023 >= speed >= 0:
        motor[0].write_analog(speed)
        motor[1].write_digital(direction)

def motor_forward(motor, percent):
    pulse_width_modulate(motor, percent * 10.23, 0)

def motor_reverse(motor, percent):
    pulse_width_modulate(motor, 1023-(percent * 10.23), 1)

def motor_stop(motor):
    pulse_width_modulate(motor, 0, 0)

# LED Functions
neopixels = neopixel.NeoPixel(pin13, 12)

def set_leds(pixels, colour):
    for i in pixels:
        neopixels[i] = colour
    neopixels.show()

# Colours 
black = (0, 0, 0)
white = (75, 75, 75) # full intensity is REALLY bright
red = (75, 0, 0)
amber = (75, 40, 0)

def mainbeam_lights(off=False):
    set_leds([5, 11], black if off else white)

def reverse_lights(off=False):
    set_leds([0, 6], black if off else white)

def brake_lights(off=False):
    set_leds([0, 6], black if off else red)

def left_blinker(off=False):
    set_leds([3, 4], black if off else amber)

def right_blinker(off=False):
    set_leds([9, 10], black if off else amber)

# High level commands
direction = 'S'
speed = 50
headlights = 'auto'

def go_faster():
    global speed
    speed = min(speed + 20, 100)

def go_slower():
    global speed
    speed = max(speed - 20, 0)

def go_forward():
    global direction
    direction = 'F'
    motor_forward(left_motor, speed)
    motor_forward(right_motor, speed)

def reverse():
    global direction
    direction = 'B'
    sound_horn()
    motor_reverse(left_motor, speed)
    motor_reverse(right_motor, speed)
    
def steer_left():
    global direction
    direction = 'L'
    motor_forward(left_motor, speed / 2)
    motor_forward(right_motor, speed)

def steer_right():
    global direction
    direction = 'R'
    motor_forward(left_motor, speed)
    motor_forward(right_motor, speed / 2)

def stop():
    global direction
    direction = 'S'
    motor_stop(left_motor)
    motor_stop(right_motor)

def cycle_lights():
    global headlights
    if headlights == 'auto':
        headlights = 'off'
    elif headlights == 'off':
        headlights = 'on'
    else:
        headlights = 'auto'

def update_headlights():
    main_beams = True if headlights == 'on' else False

    if headlights == 'auto':
        main_beams = False if display.read_light_level() >= 75 else True

    if main_beams:
        mainbeam_lights()
    else:
        mainbeam_lights(off=True)
    
def update_blinkers():
    left_blinker(off=direction != 'L')
    right_blinker(off=direction != 'R')

def update_rear_lights():
    if direction == 'S':
        brake_lights()
    elif direction == 'F' or direction == 'L' or direction == 'R':
        brake_lights(off=True)
        reverse_lights(off=True)
    elif direction == 'B':
        reverse_lights()
    
def update_lights():
    update_headlights()
    update_blinkers()
    update_rear_lights()

def sound_horn():
    for i in range(2):
        pin14.write_digital(1)
        sleep(100)
        pin14.write_digital(0)
        sleep(200)
        
def wait_for_contact():
    display.clear()
    waiting = True

    while waiting:
        display.set_pixel(2, 2, 9)
        sleep(100)
        msg = radio.receive()

        if msg and msg == 'hi':
            radio.send(msg)
            waiting = False
        else:
            display.set_pixel(2, 2, 0)
            sleep(100)

def show_contact_made():
    for i in range(5):
        display.show(Image.HEART_SMALL)
        sleep(500)
        display.show(Image.HEART)
        sleep(500)

    display.clear()
    
display.scroll("bitBot RC")
radio.on()

while True:
    wait_for_contact()
    show_contact_made()

    watchdog_counter = 0

    while watchdog_counter < 100:
        watchdog_counter += 1
        update_lights()
        sleep(100)

        msg = radio.receive()

        if msg:
            watchdog_counter = 0
            
            if msg == 'S':
                stop()
            elif msg == 'F':
                go_forward()
            elif msg == 'B':
                reverse()
            elif msg == 'L':
                steer_left()
            elif msg == 'R':
                steer_right()
            elif msg == 'W':
                go_slower()
            elif msg == 'Z':
                go_faster()
            elif msg == 'I':
                cycle_lights()
            elif msg == 'P':
                sound_horn()

    stop()
    display.show(Image.SKULL)
    sleep(2000)
    

I had anticipated the code for the car to be much longer in the non-class version but it turned out to be about 200 lines so well within manageable limits for future maintenance. Now that I have promised myself I am done with features, that shouldn’t be a concern :)