ecki/Robotics-at-Home-with-Raspberry-Pi-Pico
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bluetooth examples for chapter 9

Browse Source
This commit is contained in:
Danny Staple 2022-06-22 22:30:37 +01:00
parent 115e9e03ef
commit f3d8c7a0d6
24 changed files with 169 additions and 530 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
ch-9/1-bluetooth-basics/1-hello-world/code.py Normal file
View File

@ -0,0 +1,21 @@
import board
from digitalio import DigitalInOut
import time
import busio
import supervisor
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:
print(data)
if supervisor.runtime.serial_bytes_available:
value = input().strip()
print(f"Received: {value}\r")
uart.write(value.encode())

35
ch-9/1-bluetooth-basics/2-read-control-packets/code.py Normal file
View File

@ -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())

36
ch-9/1-bluetooth-basics/3-random-walk-graph/code.py Normal file
View File

@ -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'))

32
ch-9/1-wifi-basics/connect_and_fetch.py
View File

@ -1,32 +0,0 @@
import board
import busio
from digitalio import DigitalInOut
from adafruit_esp32spi import adafruit_esp32spi
from adafruit_esp32spi import adafruit_esp32spi_wifimanager
try:
from secrets import secrets
except ImportError:
print("WiFi secrets are kept in secrets.py, please add them there!")
raise
esp32_cs = DigitalInOut(board.GP10)
esp32_ready = DigitalInOut(board.GP9)
esp32_reset = DigitalInOut(board.GP8)
spi = busio.SPI(board.GP14, MOSI=board.GP11, MISO=board.GP12)
esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset)
status_led = DigitalInOut(board.LED)
status_led.switch_to_output()
wifi = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager(esp, secrets)
status_led.value = 1
print("Connected. Making connection")
try:
response = wifi.get("https://api.ipify.org")
print(response.text)
except:
status_led.value = 0
wifi.reset()
raise

27
ch-9/1-wifi-basics/version_and_scan.py
View File

@ -1,27 +0,0 @@
import board
import busio
from digitalio import DigitalInOut
from adafruit_esp32spi import adafruit_esp32spi
import time
print("ESP32 SPI hardware test")
esp32_cs = DigitalInOut(board.GP10)
esp32_ready = DigitalInOut(board.GP9)
esp32_reset = DigitalInOut(board.GP8)
spi = busio.SPI(board.GP14, board.GP11, board.GP12)
esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset)
if esp.status == adafruit_esp32spi.WL_IDLE_STATUS:
print("ESP32 found and in idle mode")
print("Firmware vers.", esp.firmware_version)
print("MAC addr:", [hex(i) for i in esp.MAC_address])
# esp.start_scan_networks()
# time.sleep(5)
for ap in esp.scan_networks():
print("\t%s\t\tRSSI: %d" % (str(ap["ssid"], "utf-8"), ap["rssi"]))
print("Done!")

4
ch-9/2-hello-world/hello.html
View File

@ -1,4 +0,0 @@
<!DOCTYPE html>
<meta charset="utf-8">
<h1>Hello</h1>
<p>World</p>

33
ch-9/2-hello-world/hello_from_file.py
View File

@ -1,33 +0,0 @@
import robot_wifi
from adafruit_esp32spi import adafruit_esp32spi_wsgiserver
from adafruit_wsgi.wsgi_app import WSGIApp
app = WSGIApp()
@app.route("/")
def index(request):
with open("hello.html") as fd:
hello_html = fd.read()
return 200, [("Content-Type", "text/html")], hello_html
print("Setting up wifi.")
wifi, esp = robot_wifi.connect_to_wifi()
server = adafruit_esp32spi_wsgiserver.WSGIServer(80, application=app)
adafruit_esp32spi_wsgiserver.set_interface(esp)
print("Starting server")
server.start()
ip_int = ".".join(str(int(n)) for n in esp.ip_address)
print(f"IP Address is {ip_int}")
while True:
try:
server.update_poll()
# background task
except:
print("Shutting down wifi on failure. resetting ESP")
wifi.reset()
raise

31
ch-9/2-hello-world/hello_server.py
View File

@ -1,31 +0,0 @@
import robot_wifi
from adafruit_esp32spi import adafruit_esp32spi_wsgiserver
from adafruit_wsgi.wsgi_app import WSGIApp
app = WSGIApp()
@app.route("/")
def index(request):
return 200, [], "Hello world!"
print("Setting up wifi.")
wifi, esp = robot_wifi.connect_to_wifi()
server = adafruit_esp32spi_wsgiserver.WSGIServer(80, application=app)
adafruit_esp32spi_wsgiserver.set_interface(esp)
print("Starting server")
server.start()
ip_int = ".".join(str(int(n)) for n in esp.ip_address)
print(f"IP Address is {ip_int}")
while True:
try:
server.update_poll()
# background task
except:
print("Shutting down wifi on failure. resetting ESP")
wifi.reset()
raise

25
ch-9/2-hello-world/robot_wifi.py
View File

@ -1,25 +0,0 @@
import board
import busio
from digitalio import DigitalInOut
from adafruit_esp32spi import adafruit_esp32spi
from adafruit_esp32spi import adafruit_esp32spi_wifimanager
try:
from secrets import secrets
except ImportError:
print("WiFi secrets are kept in secrets.py, please add them there!")
raise
def connect_to_wifi():
esp32_cs = DigitalInOut(board.GP10)
esp32_ready = DigitalInOut(board.GP9)
esp32_reset = DigitalInOut(board.GP8)
spi = busio.SPI(board.GP14, MOSI=board.GP11, MISO=board.GP12)
esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset)
esp.reset()
wifi = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager(esp, secrets)
wifi.connect()
return wifi, esp

14
ch-9/3-0-counting-server/counting.html
View File

@ -1,14 +0,0 @@
<!DOCTYPE html>
<h1>Counting test</h1>
<p>Counter: <span id="counter"> </span></p>
<script type="module">
import * as d3_module from "https://cdn.jsdelivr.net/npm/d3@7";
var count_output = d3.select("span#counter");
setInterval(function() {
d3.json("count").then(function(data) {
count_output.text(data)
});
}, 300);
</script>

23
ch-9/3-0-counting-server/counting.py
View File

@ -1,23 +0,0 @@
import json
import robot_wifi
from adafruit_wsgi.wsgi_app import WSGIApp
app = WSGIApp()
counter = iter(range(int(1e6)))
@app.route("/")
def index(request):
with open("counting.html") as fd:
hello_html = fd.read()
return 200, [("Content-Type", "text/html")], hello_html
@app.route("/count")
def get_count(request):
value = next(counter)
print(f"Counter value is {value}")
return 200, [("Content-Type", "application/json")], [json.dumps(value)]
robot_wifi.start_wifi_server(app)

63
ch-9/3-0-counting-server/robot_wifi.py
View File

@ -1,63 +0,0 @@
import board
import busio
from digitalio import DigitalInOut
from adafruit_esp32spi import adafruit_esp32spi
from adafruit_esp32spi import adafruit_esp32spi_wifimanager
from adafruit_esp32spi import adafruit_esp32spi_wsgiserver
try:
from secrets import secrets
except ImportError:
print("WiFi secrets are kept in secrets.py, please add them there!")
raise
def connect_to_wifi():
esp32_cs = DigitalInOut(board.GP10)
esp32_ready = DigitalInOut(board.GP9)
esp32_reset = DigitalInOut(board.GP8)
status_led = DigitalInOut(board.LED)
status_led.switch_to_output()
print("Starting spi bus...")
spi = busio.SPI(board.GP14, MOSI=board.GP11, MISO=board.GP12)
print("Creating ESP SPI control...")
esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset)
# print("Resetting...")
print("Firmware vers.", esp.firmware_version)
print("MAC addr:", [hex(i) for i in esp.MAC_address])
# esp.reset()
print("Starting Wifi Manager...")
wifi = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager(esp, secrets)
print("Connecting...")
wifi.connect()
status_led.value = 1
return wifi, esp
def start_wifi_server(app, background_task=None):
print("Setting up wifi.")
wifi, esp = connect_to_wifi()
server = adafruit_esp32spi_wsgiserver.WSGIServer(80, application=app)
adafruit_esp32spi_wsgiserver.set_interface(esp)
print("Starting server")
server.start()
ip_int = ".".join(str(int(n)) for n in esp.ip_address)
print(f"IP Address is {ip_int}")
while True:
try:
server.update_poll()
# background task
if background_task:
background_task()
except ConnectionError:
print("Connection error detected. Carrying on")
except:
print("Shutting down wifi on failure. resetting ESP")
wifi.reset()
raise

29
ch-9/3-bluetooth-distance-sensors/code.py Normal file
View File

@ -0,0 +1,29 @@
import board
import time
import busio
import robot
uart = busio.UART(board.GP12,board.GP13,baudrate=9600, timeout=0.01)
print("Initialising sensors")
robot.left_distance.distance_mode = 1
robot.left_distance.start_ranging()
robot.right_distance.distance_mode = 1
robot.right_distance.start_ranging()
print("Sending via UART...")
while True:
if robot.left_distance.data_ready and robot.right_distance.data_ready:
sensor1 = robot.left_distance.distance
sensor2 = robot.right_distance.distance
try:
sensor_packet = f"{sensor1},{sensor2},10,15,49.23,-3\n"
print(sensor_packet, end='')
uart.write(sensor_packet.encode('utf-8'))
finally:
robot.left_distance.clear_interrupt()
robot.right_distance.clear_interrupt()
time.sleep(0.05)
# installinig the bluetooth update ovre the air makes it work better with
# floating point, 6 channels, negatives all confirmed.

0
ch-9/3-sensors/pio_encoder.py → ch-9/3-bluetooth-distance-sensors/pio_encoder.py
View File

0
ch-9/3-sensors/robot.py → ch-9/3-bluetooth-distance-sensors/robot.py
View File

25
ch-9/3-sensors/robot_wifi.py
View File

@ -1,25 +0,0 @@
import board
import busio
from digitalio import DigitalInOut
from adafruit_esp32spi import adafruit_esp32spi
from adafruit_esp32spi import adafruit_esp32spi_wifimanager
try:
from secrets import secrets
except ImportError:
print("WiFi secrets are kept in secrets.py, please add them there!")
raise
def connect_to_wifi():
esp32_cs = DigitalInOut(board.GP10)
esp32_ready = DigitalInOut(board.GP9)
esp32_reset = DigitalInOut(board.GP8)
spi = busio.SPI(board.GP14, MOSI=board.GP11, MISO=board.GP12)
esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset)
esp.reset()
wifi = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager(esp, secrets)
wifi.connect()
return wifi, esp

19
ch-9/3-sensors/sensor.html
View File

@ -1,19 +0,0 @@
<!DOCTYPE html>
<svg id="graph" height="200" width="450"></svg>
<script src="https://d3js.org/d3.v5.js"></script>
<script>
var svg = d3.select("svg#graph");
svg.append("text")
.attr("id", "left_dist")
.attr("x", 0)
.attr("y", 20)
.text("--");
setInterval(function() {
d3.json("sensors").then(function(data) {
d3.select("#left_dist").text(data['left_distance'])
});
}, 300);
</script>

57
ch-9/3-sensors/sensor_remote.py
View File

@ -1,57 +0,0 @@
import json
from adafruit_esp32spi import adafruit_esp32spi_wsgiserver
from adafruit_wsgi.wsgi_app import WSGIApp
import robot_wifi
import robot
app = WSGIApp()
@app.route("/")
def index(request):
with open("sensor.html") as fd:
hello_html = fd.read()
return 200, [("Content-Type", "text/html")], [hello_html]
@app.route("/sensors")
def sensors(request):
sensor_data = {
"left_distance": robot.left_distance.distance,
}
robot.left_distance.clear_interrupt()
return 200, [("Content-Type", "application/json")], [json.dumps(sensor_data)]
print("Setting up wifi.")
wifi, esp = robot_wifi.connect_to_wifi()
server = adafruit_esp32spi_wsgiserver.WSGIServer(80, application=app)
adafruit_esp32spi_wsgiserver.set_interface(esp)
print("Initialising sensors")
robot.left_distance.distance_mode = 1
robot.left_distance.start_ranging()
print("Starting server")
server.start()
ip_int = ".".join(str(int(n)) for n in esp.ip_address)
print(f"IP Address is {ip_int}")
while True:
try:
try:
server.update_poll()
except RuntimeError as e:
print(f"Server poll error: {type(e)}, {e}")
# background task
except:
print("Shutting down wifi on failure. resetting ESP")
wifi.reset()
raise
# Reader exercise
# add the right distance to the distance sensor remote. Consider where to position the meter for this, how to return both sensors in
# the sensors call. Don't forget to clear the interrupt to get new readings.

45
ch-9/4-bluetooth-teleop/code.py Normal file
View File

@ -0,0 +1,45 @@
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)
class RobotControl:
stop_at = 0
speed = 0.8
timeout = 3
def send_control(self, packet):
if packet.button == ButtonPacket.UP:
robot.set_left(self.speed)
robot.set_right(self.speed)
elif packet.button == ButtonPacket.DOWN:
robot.set_left(-self.speed)
robot.set_right(-self.speed)
elif packet.button == ButtonPacket.LEFT:
robot.set_left(-self.speed)
robot.set_right(self.speed)
elif packet.button == ButtonPacket.RIGHT:
robot.set_left(self.speed)
robot.set_right(-self.speed)
self.stop_at = time.time() + self.timeout
control = RobotControl()
print("Waiting for control signals...")
while True:
data = uart.read(32)
if data is not None and data.startswith(b'!B'):
packet = ButtonPacket.from_bytes(data)
print("Button:", packet.button, "pressed:", packet.pressed)
if packet.pressed:
control.send_control(packet)
else:
robot.stop()
if control.stop_at < time.time():
robot.stop()

0
ch-9/4-teleop/pio_encoder.py → ch-9/4-bluetooth-teleop/pio_encoder.py
View File

15
ch-9/4-teleop/robot.py → ch-9/4-bluetooth-teleop/robot.py
View File

@ -1,9 +1,6 @@
import board
import pwmio
import pio_encoder
import busio
import adafruit_vl53l1x
motor_A1 = pwmio.PWMOut(board.GP17)
motor_A2 = pwmio.PWMOut(board.GP16)
@ -16,12 +13,6 @@ 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
@ -30,7 +21,7 @@ def stop():
motor_B2.duty_cycle = 0
def set_speed(motor, speed):
def set_speed(motor: tuple, speed: float):
# Swap motor pins if we reverse the speed
if speed < 0:
direction = motor[1], motor[0]
@ -44,9 +35,9 @@ def set_speed(motor, speed):
direction[1].duty_cycle = 0
def set_left(speed):
def set_left(speed: float):
set_speed(left_motor, speed)
def set_right(speed):
def set_right(speed: float):
set_speed(right_motor, speed)

25
ch-9/4-teleop/robot_wifi.py
View File

@ -1,25 +0,0 @@
import board
import busio
from digitalio import DigitalInOut
from adafruit_esp32spi import adafruit_esp32spi
from adafruit_esp32spi import adafruit_esp32spi_wifimanager
try:
from secrets import secrets
except ImportError:
print("WiFi secrets are kept in secrets.py, please add them there!")
raise
def connect_to_wifi():
esp32_cs = DigitalInOut(board.GP10)
esp32_ready = DigitalInOut(board.GP9)
esp32_reset = DigitalInOut(board.GP8)
spi = busio.SPI(board.GP14, MOSI=board.GP11, MISO=board.GP12)
esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset)
esp.reset()
wifi = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager(esp, secrets)
wifi.connect()
return wifi, esp

61
ch-9/4-teleop/teleop.html
View File

@ -1,61 +0,0 @@
<!DOCTYPE html>
<meta charset="utf-8">
<svg id="graph" height="200" width="450"></svg>
<script src="https://d3js.org/d3.v5.js"></script>
<script>
var svg = d3.select("svg#graph").append("circle")
.attr("id", "button")
.attr("cx", 100)
.attr("cy", 100)
.attr("r", 50)
.attr("fill", "green");
var circle = d3.select("#button");
function circle_to_relative(point) {
return [
(point[0] - circle.attr("cx")) / circle.attr("r"),
(point[1] - circle.attr("cy")) / circle.attr("r")
]
}
var last_position = [0, 0];
var new_position = false;
function move_robot() {
if (new_position === true) {
d3.json("/control", {
method:"POST",
body: JSON.stringify(last_position),
headers: {
"Content-type": "application/json; charset=UTF-8"
}
}).finally(function() {
setTimeout(move_robot, 10) // continue the lop 50 ms after a response, even a non-positive one.
});
new_position = false;
}
else {
setTimeout(move_robot, 10); // continue the loop if there's nothing to send
}
}
function stop() {
last_position = [0, 0];
new_position = true;
}
setTimeout(move_robot, 50); // start the control loop
circle.on("pointermove", function() {
if(d3.event.buttons == 1) {
last_position = circle_to_relative(d3.mouse(this));
new_position = true;
}
})
.on("mouseup", stop)
.on("mouseout", stop);
</script>

79
ch-9/4-teleop/teleop.py
View File

@ -1,79 +0,0 @@
import json
import time
from digitalio import DigitalInOut
import board
from adafruit_esp32spi import adafruit_esp32spi_wsgiserver
from adafruit_wsgi.wsgi_app import WSGIApp
import robot_wifi
import robot
app = WSGIApp()
class State:
stop_at = 0
state = State()
@app.route("/")
def index(request):
with open("teleop.html") as fd:
hello_html = fd.read()
return 200, [("Content-Type", "text/html")], [hello_html]
@app.route("/control", methods=["POST"])
def control(request):
movement = json.load(request.body)
print(f"Received movement: {movement}")
robot.set_left(-movement[1] + movement[0])
robot.set_right(-movement[1] - movement[0])
state.stop_at = time.time() + 1
return 200, [("Content-Type", "application/json")], ["true"]
print("Setting up wifi.")
status_led = DigitalInOut(board.LED)
status_led.switch_to_output()
status_led.value = False
wifi, esp = robot_wifi.connect_to_wifi()
server = adafruit_esp32spi_wsgiserver.WSGIServer(80, application=app)
adafruit_esp32spi_wsgiserver.set_interface(esp)
print("Starting server")
server.start()
ip_int = ".".join(str(int(n)) for n in esp.ip_address)
status_led.value = True
print(f"IP Address is {ip_int}")
while True:
try:
status_led.value = False
server.update_poll()
status_led.value = True
# background task
if state.stop_at < time.time():
robot.stop()
except RuntimeError as e:
print(f"Server poll error: {type(e)}, {e}")
robot.stop()
print(f"Resetting ESP...")
wifi.reset()
print("Reset complete.")
except:
print("Shutting down wifi on failure. resetting ESP")
robot.stop()
wifi.reset()
raise
# Reader exercise
# Can you combine the sensors and the control app? Can you think about how to control it using the sensors for feedback.