Rename folders as per suggestion from Rajat

ch-09/1-bluetooth-basics/1-bluetooth-bidirectional/code.py

@@ -0,0 +1,16 @@
+import board 
+import busio
+import supervisor
+
+# PICO UART pins? What am i not using?
+uart = busio.UART(board.GP12,board.GP13,baudrate=9600, timeout=0.01)
+
+print("Waiting for bytes on UART...")
+while True:
+    data = uart.read(32)
+    if data is not None:
+        print(data)
+    if supervisor.runtime.serial_bytes_available:
+        value = input().strip()
+        print(f"Received: {value}\r")
+        uart.write(value.encode())

ch-09/1-bluetooth-basics/2-read-control-packets/code.py

@@ -0,0 +1,35 @@
+import board 
+from digitalio import DigitalInOut
+import time
+import busio
+import supervisor
+import adafruit_bluefruit_connect.button_packet, adafruit_bluefruit_connect.quaternion_packet
+
+
+led = DigitalInOut(board.LED)
+led.switch_to_output()
+
+# PICO UART pins? What am i not using?
+uart = busio.UART(board.GP12,board.GP13,baudrate=9600, timeout=0.01)
+
+print("Waiting for bytes on UART...")
+while True:
+    data = uart.read(32)
+    if data is not None:
+      if data[0] == b'!'[0]:
+        print("Looks like a control packet")
+        if data[1] == b'B'[0]:
+          buttons = adafruit_bluefruit_connect.button_packet.ButtonPacket.from_bytes(data)
+          print("Button:", buttons.button, "pressed:", buttons.pressed)
+        elif data[1] == b'Q'[0]:
+          quaternion = adafruit_bluefruit_connect.quaternion_packet.QuaternionPacket.from_bytes(data)
+          print(f"Quaternion: {quaternion.w} + {quaternion.x}i + {quaternion.y}j + {quaternion.z}k")
+        else:
+          print("Data[1]:", data[1])
+      else:
+        print("Data[0]:", data[0])
+        print(data)
+    if supervisor.runtime.serial_bytes_available:
+        value = input().strip()
+        print(f"Received: {value}\r")
+        uart.write(value.encode())

ch-09/1-bluetooth-basics/3-random-walk-graph/code.py

@@ -0,0 +1,36 @@
+import board 
+from digitalio import DigitalInOut
+import time
+import busio
+import supervisor
+import random
+
+led = DigitalInOut(board.LED)
+led.switch_to_output()
+
+# PICO UART pins? What am i not using?
+uart = busio.UART(board.GP12,board.GP13,baudrate=9600, timeout=0.01)
+
+
+def robot_data_source():
+  sensor1 = random.randint(-100, 100)/100
+  sensor2 = random.randint(-100, 100)/100
+  while True:
+      yield sensor1 * 100,sensor2 * 100
+      sensor1 += random.randint(-100, 100)/1000
+      sensor2 += random.randint(-100, 100)/800
+
+data_source = robot_data_source()
+
+print("Waiting for bytes on UART...")
+while True:
+    data = uart.read(32)
+    if data is not None:
+        print(data)
+    # if our monotic time is a multiple of 50
+    time.sleep(0.1)
+    # 0.05 is too fast, 0.1 is about write - so 10 per second.
+    sensor1, sensor2 = next(data_source)
+    sensor_packet = f"{int(sensor1)},{int(sensor2)}\n"
+    print(sensor_packet, end='')
+    uart.write(sensor_packet.encode('utf-8'))

ch-09/1-bluetooth-hello-world/code.py

@@ -0,0 +1,8 @@
+import board 
+import busio
+
+uart = busio.UART(board.GP12, board.GP13, baudrate=9600)
+
+while True:
+    if uart.read(32) is not None:
+        uart.write("Hello, Bluetooth World!\n".encode())

ch-09/2-bluetooth-distance-sensors/code.py

@@ -0,0 +1,20 @@
+import board 
+import time
+import busio
+import robot
+
+uart = busio.UART(board.GP12, board.GP13, baudrate=9600)
+
+robot.left_distance.distance_mode = 1
+robot.left_distance.start_ranging()
+robot.right_distance.distance_mode = 1
+robot.right_distance.start_ranging()
+
+while True:
+    if robot.left_distance.data_ready and robot.right_distance.data_ready:
+        sensor1 = robot.left_distance.distance
+        sensor2 = robot.right_distance.distance
+        uart.write(f"{sensor1},{sensor2}\n".encode())
+        robot.left_distance.clear_interrupt()
+        robot.right_distance.clear_interrupt()
+    time.sleep(0.05)

ch-09/2-bluetooth-distance-sensors/pio_encoder.py

@@ -0,0 +1,77 @@
+import rp2pio
+import adafruit_pioasm
+import array
+
+program = """
+; use the osr for count
+; input pins c1 c2
+
+    set y, 0            ; clear y
+    mov osr, y          ; and clear osr
+read:
+    ; x will be the old value
+    ; y the new values
+    mov x, y            ; store old Y in x
+    in null, 32         ; Clear ISR - using y
+    in pins, 2          ; read two pins into y
+    mov y, isr
+    jmp x!=y, different ; Jump if its different
+    jmp read            ; otherwise loop back to read
+
+different:
+    ; x has old value, y has new.
+    ; extract the upper bit of X.
+    in x, 31             ; get bit 31 - old p1 (remember which direction it came in)
+    in null, 31         ; keep only 1 bit
+    mov x, isr          ; put this back in x
+    jmp !x, c1_old_zero
+
+c1_old_not_zero:
+    jmp pin, count_up
+    jmp count_down
+
+c1_old_zero:
+    jmp pin, count_down
+    ; fall through
+count_up:
+    ; for a clockwise move - we'll add 1 by inverting
+    mov x, ~ osr        ; store inverted OSR on x
+    jmp x--, fake       ; use jump to take off 1
+fake:
+    mov x, ~ x          ; invert back
+    jmp send
+count_down:
+    ; for a clockwise move, just take one off
+    mov x, osr          ; store osr in x
+    jmp x--, send       ; dec and send
+send:
+    ; send x.
+    mov isr, x          ; send it
+    push noblock        ; put ISR into input FIFO
+    mov osr, x          ; put X back in OSR
+    jmp read            ; loop back
+"""
+
+assembled = adafruit_pioasm.assemble(program)
+
+
+class QuadratureEncoder:
+    def __init__(self, first_pin, second_pin, reversed=False):
+        """Encoder with 2 pins. Must use sequential pins on the board"""
+        self.sm = rp2pio.StateMachine(
+            assembled,
+            frequency=0,
+            first_in_pin=first_pin,
+            jmp_pin=second_pin,
+            in_pin_count=2,
+        )
+        self.reversed = reversed
+        self._buffer = array.array("i", [0])
+
+    def read(self):
+        while self.sm.in_waiting:
+            self.sm.readinto(self._buffer)
+        if self.reversed:
+            return -self._buffer[0]
+        else:
+            return self._buffer[0]

ch-09/2-bluetooth-distance-sensors/robot.py

@@ -0,0 +1,52 @@
+import board
+import pwmio
+import pio_encoder
+import busio
+import adafruit_vl53l1x
+
+
+motor_A1 = pwmio.PWMOut(board.GP17)
+motor_A2 = pwmio.PWMOut(board.GP16)
+motor_B1 = pwmio.PWMOut(board.GP18)
+motor_B2 = pwmio.PWMOut(board.GP19)
+
+right_motor = motor_A1, motor_A2
+left_motor = motor_B1, motor_B2
+
+right_encoder = pio_encoder.QuadratureEncoder(board.GP20, board.GP21, reversed=True)
+left_encoder = pio_encoder.QuadratureEncoder(board.GP26, board.GP27)
+
+i2c0 = busio.I2C(sda=board.GP0, scl=board.GP1)
+i2c1 = busio.I2C(sda=board.GP2, scl=board.GP3)
+
+left_distance = adafruit_vl53l1x.VL53L1X(i2c0)
+right_distance = adafruit_vl53l1x.VL53L1X(i2c1)
+
+
+def stop():
+    motor_A1.duty_cycle = 0
+    motor_A2.duty_cycle = 0
+    motor_B1.duty_cycle = 0
+    motor_B2.duty_cycle = 0
+
+
+def set_speed(motor, speed):
+    # Swap motor pins if we reverse the speed
+    if speed < 0:
+        direction = motor[1], motor[0]
+        speed = -speed
+    else:
+        direction = motor
+    speed = min(speed, 1)  # limit to 1.0
+    max_speed = 2 ** 16 - 1
+
+    direction[0].duty_cycle = int(max_speed * speed)
+    direction[1].duty_cycle = 0
+
+
+def set_left(speed):
+    set_speed(left_motor, speed)
+
+
+def set_right(speed):
+    set_speed(right_motor, speed)

ch-09/3-bluetooth-print-incoming/code.py

@@ -0,0 +1,9 @@
+import board 
+import busio
+
+uart = busio.UART(board.GP12,board.GP13,baudrate=9600, timeout=0.01)
+
+print("Waiting for bytes on UART...")
+while True:
+    if uart.in_waiting:
+        print(uart.read(32))

ch-09/4-bluetooth-teleop/code.py

@@ -0,0 +1,35 @@
+import board 
+import time
+import busio
+from adafruit_bluefruit_connect.button_packet import ButtonPacket
+import robot
+
+
+uart = busio.UART(board.GP12,board.GP13,baudrate=9600, timeout=0.01)
+
+stop_at = 0
+speed = 0.8
+
+print("Waiting for control signals...")
+while True:
+  if uart.in_waiting:
+    packet = ButtonPacket.from_stream(uart)
+    if packet:
+      if not packet.pressed:
+          robot.stop()
+      elif packet.button == ButtonPacket.UP:
+        robot.set_left(speed)
+        robot.set_right(speed)
+      elif packet.button == ButtonPacket.DOWN:
+        robot.set_left(-speed)
+        robot.set_right(-speed)
+      elif packet.button == ButtonPacket.LEFT:
+        robot.set_left(-speed)
+        robot.set_right(speed)
+      elif packet.button == ButtonPacket.RIGHT:
+        robot.set_left(speed)
+        robot.set_right(-speed)
+      stop_at = time.time() + 3
+
+  if time.time() > stop_at:
+    robot.stop()

ch-09/4-bluetooth-teleop/pio_encoder.py

@@ -0,0 +1,77 @@
+import rp2pio
+import adafruit_pioasm
+import array
+
+program = """
+; use the osr for count
+; input pins c1 c2
+
+    set y, 0            ; clear y
+    mov osr, y          ; and clear osr
+read:
+    ; x will be the old value
+    ; y the new values
+    mov x, y            ; store old Y in x
+    in null, 32         ; Clear ISR - using y
+    in pins, 2          ; read two pins into y
+    mov y, isr
+    jmp x!=y, different ; Jump if its different
+    jmp read            ; otherwise loop back to read
+
+different:
+    ; x has old value, y has new.
+    ; extract the upper bit of X.
+    in x, 31             ; get bit 31 - old p1 (remember which direction it came in)
+    in null, 31         ; keep only 1 bit
+    mov x, isr          ; put this back in x
+    jmp !x, c1_old_zero
+
+c1_old_not_zero:
+    jmp pin, count_up
+    jmp count_down
+
+c1_old_zero:
+    jmp pin, count_down
+    ; fall through
+count_up:
+    ; for a clockwise move - we'll add 1 by inverting
+    mov x, ~ osr        ; store inverted OSR on x
+    jmp x--, fake       ; use jump to take off 1
+fake:
+    mov x, ~ x          ; invert back
+    jmp send
+count_down:
+    ; for a clockwise move, just take one off
+    mov x, osr          ; store osr in x
+    jmp x--, send       ; dec and send
+send:
+    ; send x.
+    mov isr, x          ; send it
+    push noblock        ; put ISR into input FIFO
+    mov osr, x          ; put X back in OSR
+    jmp read            ; loop back
+"""
+
+assembled = adafruit_pioasm.assemble(program)
+
+
+class QuadratureEncoder:
+    def __init__(self, first_pin, second_pin, reversed=False):
+        """Encoder with 2 pins. Must use sequential pins on the board"""
+        self.sm = rp2pio.StateMachine(
+            assembled,
+            frequency=0,
+            first_in_pin=first_pin,
+            jmp_pin=second_pin,
+            in_pin_count=2,
+        )
+        self.reversed = reversed
+        self._buffer = array.array("i", [0])
+
+    def read(self):
+        while self.sm.in_waiting:
+            self.sm.readinto(self._buffer)
+        if self.reversed:
+            return -self._buffer[0]
+        else:
+            return self._buffer[0]

ch-09/4-bluetooth-teleop/robot.py

@@ -0,0 +1,52 @@
+import board
+import pwmio
+import pio_encoder
+import busio
+import adafruit_vl53l1x
+
+
+motor_A1 = pwmio.PWMOut(board.GP17)
+motor_A2 = pwmio.PWMOut(board.GP16)
+motor_B1 = pwmio.PWMOut(board.GP18)
+motor_B2 = pwmio.PWMOut(board.GP19)
+
+right_motor = motor_A1, motor_A2
+left_motor = motor_B1, motor_B2
+
+right_encoder = pio_encoder.QuadratureEncoder(board.GP20, board.GP21, reversed=True)
+left_encoder = pio_encoder.QuadratureEncoder(board.GP26, board.GP27)
+
+i2c0 = busio.I2C(sda=board.GP0, scl=board.GP1)
+i2c1 = busio.I2C(sda=board.GP2, scl=board.GP3)
+
+left_distance = adafruit_vl53l1x.VL53L1X(i2c0)
+right_distance = adafruit_vl53l1x.VL53L1X(i2c1)
+
+
+def stop():
+    motor_A1.duty_cycle = 0
+    motor_A2.duty_cycle = 0
+    motor_B1.duty_cycle = 0
+    motor_B2.duty_cycle = 0
+
+
+def set_speed(motor, speed):
+    # Swap motor pins if we reverse the speed
+    if speed < 0:
+        direction = motor[1], motor[0]
+        speed = -speed
+    else:
+        direction = motor
+    speed = min(speed, 1)  # limit to 1.0
+    max_speed = 2 ** 16 - 1
+
+    direction[0].duty_cycle = int(max_speed * speed)
+    direction[1].duty_cycle = 0
+
+
+def set_left(speed):
+    set_speed(left_motor, speed)
+
+
+def set_right(speed):
+    set_speed(right_motor, speed)

ch-09/5-bluetooth-accelerometer-drive/code.py

@@ -0,0 +1,28 @@
+import board 
+import time
+import busio
+from adafruit_bluefruit_connect.accelerometer_packet import AccelerometerPacket
+import robot
+
+
+uart = busio.UART(board.GP12,board.GP13,baudrate=9600, timeout=0.01)
+
+stop_at = 0
+speed = 0.8
+
+print("Waiting for accelerometer signals...")
+while True:
+  if uart.in_waiting:
+    packet = AccelerometerPacket.from_stream(uart)
+    speed = packet.z * 0.1
+    turning = packet.y * 0.1
+    if abs(speed) > 0.3 or abs(turning) > 0.1:
+      print("speed:", speed, "turning:", turning)
+      robot.set_left(speed + turning)
+      robot.set_right(speed - turning)
+    else:
+      robot.stop()
+    stop_at = time.time() + 1
+
+  if time.time() > stop_at:
+    robot.stop()

ch-09/5-bluetooth-accelerometer-drive/pio_encoder.py

@@ -0,0 +1,77 @@
+import rp2pio
+import adafruit_pioasm
+import array
+
+program = """
+; use the osr for count
+; input pins c1 c2
+
+    set y, 0            ; clear y
+    mov osr, y          ; and clear osr
+read:
+    ; x will be the old value
+    ; y the new values
+    mov x, y            ; store old Y in x
+    in null, 32         ; Clear ISR - using y
+    in pins, 2          ; read two pins into y
+    mov y, isr
+    jmp x!=y, different ; Jump if its different
+    jmp read            ; otherwise loop back to read
+
+different:
+    ; x has old value, y has new.
+    ; extract the upper bit of X.
+    in x, 31             ; get bit 31 - old p1 (remember which direction it came in)
+    in null, 31         ; keep only 1 bit
+    mov x, isr          ; put this back in x
+    jmp !x, c1_old_zero
+
+c1_old_not_zero:
+    jmp pin, count_up
+    jmp count_down
+
+c1_old_zero:
+    jmp pin, count_down
+    ; fall through
+count_up:
+    ; for a clockwise move - we'll add 1 by inverting
+    mov x, ~ osr        ; store inverted OSR on x
+    jmp x--, fake       ; use jump to take off 1
+fake:
+    mov x, ~ x          ; invert back
+    jmp send
+count_down:
+    ; for a clockwise move, just take one off
+    mov x, osr          ; store osr in x
+    jmp x--, send       ; dec and send
+send:
+    ; send x.
+    mov isr, x          ; send it
+    push noblock        ; put ISR into input FIFO
+    mov osr, x          ; put X back in OSR
+    jmp read            ; loop back
+"""
+
+assembled = adafruit_pioasm.assemble(program)
+
+
+class QuadratureEncoder:
+    def __init__(self, first_pin, second_pin, reversed=False):
+        """Encoder with 2 pins. Must use sequential pins on the board"""
+        self.sm = rp2pio.StateMachine(
+            assembled,
+            frequency=0,
+            first_in_pin=first_pin,
+            jmp_pin=second_pin,
+            in_pin_count=2,
+        )
+        self.reversed = reversed
+        self._buffer = array.array("i", [0])
+
+    def read(self):
+        while self.sm.in_waiting:
+            self.sm.readinto(self._buffer)
+        if self.reversed:
+            return -self._buffer[0]
+        else:
+            return self._buffer[0]

ch-09/5-bluetooth-accelerometer-drive/robot.py

@@ -0,0 +1,52 @@
+import board
+import pwmio
+import pio_encoder
+import busio
+import adafruit_vl53l1x
+
+
+motor_A1 = pwmio.PWMOut(board.GP17)
+motor_A2 = pwmio.PWMOut(board.GP16)
+motor_B1 = pwmio.PWMOut(board.GP18)
+motor_B2 = pwmio.PWMOut(board.GP19)
+
+right_motor = motor_A1, motor_A2
+left_motor = motor_B1, motor_B2
+
+right_encoder = pio_encoder.QuadratureEncoder(board.GP20, board.GP21, reversed=True)
+left_encoder = pio_encoder.QuadratureEncoder(board.GP26, board.GP27)
+
+i2c0 = busio.I2C(sda=board.GP0, scl=board.GP1)
+i2c1 = busio.I2C(sda=board.GP2, scl=board.GP3)
+
+left_distance = adafruit_vl53l1x.VL53L1X(i2c0)
+right_distance = adafruit_vl53l1x.VL53L1X(i2c1)
+
+
+def stop():
+    motor_A1.duty_cycle = 0
+    motor_A2.duty_cycle = 0
+    motor_B1.duty_cycle = 0
+    motor_B2.duty_cycle = 0
+
+
+def set_speed(motor, speed):
+    # Swap motor pins if we reverse the speed
+    if speed < 0:
+        direction = motor[1], motor[0]
+        speed = -speed
+    else:
+        direction = motor
+    speed = min(speed, 1)  # limit to 1.0
+    max_speed = 2 ** 16 - 1
+
+    direction[0].duty_cycle = int(max_speed * speed)
+    direction[1].duty_cycle = 0
+
+
+def set_left(speed):
+    set_speed(left_motor, speed)
+
+
+def set_right(speed):
+    set_speed(right_motor, speed)