Robotics — day 5

from time import ticks_ms
from time import ticks_add

import machine


uart = machine.UART(
    0,
    baudrate=115200,
    timeout=10,
    timeout_char=100,
    )

machine_id = machine.unique_id().hex()

# TODO: defer after boot to allow time for network to be live
uart.write(f"{machine_id}: start\n")


def send(message):
    uart.write(message + "\n")


def receive(wait=False, timeout=10):
    start_time = ticks_ms()
    end_time = ticks_add(start_time, timeout*1000)

    while True:
        rawline = uart.readline()

        # have something
        if rawline is not None:
            # convert from bytes to string
            try:
                line = rawline.decode()
            except:
                #oops, ignore
                return None
            # done!
            return line.strip()  # remove start/end newline or spaces
        # Nothing.  What to do next?
        # Try again to get a line if wait==True and no timeout yet
        elif wait and (ticks_ms() < end_time):
            continue  # repeat the loop from the top
        # either we don't want to wait, or
        # we've timed out
        else:
            return None  # same as returned from .readline()

# Built-in modules
from time import sleep

# MicroPython-specific modules
import machine
from machine import Pin


# Custom local modules
import comms


# Setup the onboard LED
onboard_led = Pin(25, Pin.OUT)


while True:
    line = comms.receive()
    
    if line:
        # do something with the line
        print(f"Received: {line}")
        comms.send(f"ACK {line}")
        
        if line == "led-on":
            onboard_led.on()
        
        elif line == "led-off":
            onboard_led.off()
        
        else:
            print("Unknown command.")
    
    #sleep(0.1)
    

# Built-in modules
from time import sleep

# MicroPython-specific modules
import machine
from machine import Pin


# Custom local modules
import comms
import motors

# Setup the onboard LED
onboard_led = Pin(25, Pin.OUT)


def handle_go(line):
    # split into parts:
    #   go-direction-howlong  (milliseconds)

    # wrap in a try/except block to catch common errors
    # so we don't crash the robot's software
    try:
        go, direction, howlong = line.split("-")
        howlong = int(howlong)
    except:
        msg = "go: Parse error."
        print(msg)
        comms.send(msg)
        return
    
    print(f"go: {direction} for {howlong}")
    
    # do the action
    if direction == "forward":
        motors.forward()
    
    elif direction == "back":
        motors.back()
        
    elif direction == "left":
        motors.left()
        
    elif direction == "right":
        motors.right()
    
    else:
        msg = f"go: Unknown direction: {direction}."
        print(msg)
        comms.send(msg)
        return None
    
    # for the duration
    # this blocks other code
    # TODO: change to async style
    sleep(howlong / 1000)
    motors.stop()
    return True



###########################################
#
# the main thing
#
while True:
    # (try to) get a command
    line = comms.receive()
    
    # nothing?  then quit here and try again
    if line is None:
        continue


    # we have a line!  now do something with it!
    print(f"Received: {line}")
    comms.send(f"ACK {line}")
    
    if line == "led-on":
        onboard_led.on()
    
    elif line == "led-off":
        onboard_led.off()

    # a different way.
    # sub-commands
    elif line.startswith("go-"):
        handle_go(line)
        
    else:
        # send the same message to two different places
        msg = "bot: Unknown command."
        print(msg)
        comms.send(msg)