George White stonehippo

LSM6DSV16X CircuitPython Driver

Notes on writing a CircuitPython driver for the LSM6DSV16X IMU.

First steps

For starts, I went to the Adafruit CircuitPython driver for LSM6DS-class chips. It covers several models with similar setups, so it seemed liked a good place to start.

Once I figured out that the Sparkfun dev board that I'm using was set up for the alternate I2C address (0x6b instead of 0x6a) and that I needed to use the chip ID specific to the LSM6DSV16X (0x70), I was able to connect with the LSM6DS library, using a new implemenation file (which really only setup the new CHIP_ID):

ESP8266 and Micropython Tools

I use Micropython sometimes. It's a great port of Python to microcontrollers, and the basis of CircuitPython. Unlike CircuitPython, MicroPython doesn't typically provide a mounted drive via native USB, which means that you need some tooling to best interact with the board. For example, I am using MP on some ESP8266 dev boards, because CP support there isn't great (no UF2 bootloader, no native USB).

esptool.py - Needed for flashing the board
mpremote - a handy toolkit for working with MP boards, including console access, package management, and file management
ampy - a handy tool for copying files to and from a MicroPython board. This is somewhat redundant if you use mpremote

Using the CircuitPython native USB for serial data

I was trying to get some CP code to talk to Processing over a serial port interface. Of course, the CP REPL is normally available on whatever serial port the board mounts by default. This is a little complicated, because although you can use something like print from the REPL (or code.py) to print a value to the console, sys.stdin and sys.stdout are text-based streams, which may not be what you want. And you'll get REPL noise to boot. Not ideal.

This is where usb_cdc comes in. It's a handy library for managing the USB CDC (serial) on most CircuitPython boards. First, usb_cdc can be used to control how many serial ports CP will provide at startup. You can modify boot.py to make this work:

import usb_cdc

usb_cdc.enable(console=True, data=False)

Hallowing M4: Enable `audioio` & `touchio`

The Adafruit Hallowing M4 is a feature-filled development board, including four capacitve touch "teeth" at the bottom of it's skull-shaped circuit board.

CircuitPython has a nifty module for working cap touch pins, touchio. However, the Hallowing M4 uses an Atmel SAMD51, which doesn't handle cap touch in hardware (unlike the SAMD21 in the Hallowing M0). If you try to use the cap touch pins without some additional setup, you'll get an error.

import board
import touchio

SparkFun moto:bit driver for BBC micro:bit micropython

The SparkFun moto:bit is a motor controller carrier for the BBC micro:bit. This board is also available as part of the SparkFun micro:bot kit.

SparkFun provides a MakeCode extension for using this board, but no driver for working with the board using micro:bit-flavored micropython. Given the spiffy new micro:bit Python Editor, it would nice to be able to program this motor controller in micropython. This class makes that easy to do.

The code has been moved to a new repo: https://github.com/stonehippo/sparkfun_motobit_microbit_python.

Usage

A tiny dice roller in modern Python

I have been reading Fluent Python, and I can tell that it's going to help me be a better Python coder right away.

A while ago, I started a Javascript library for rolling common dice types, which I intended to use for various games. While reading Fluent Python, I realized that I could write the same logic in a much more compact form, thanks to listcomps, generator functions, and unpacking. In fact, the core implementation takes only four lines of code:

sides = [4, 6, 8, 10, 12, 20]
d4, d6, d8, d10, d12, d20 = [range(1, count + 1) for count in sides]

	import board
	import time
	import adafruit_bme680
	import adafruit_veml7700
	import neopixel
	from adafruit_led_animation.animation.rainbow import Rainbow
	from adafruit_led_animation.color import RED
	from ulab import numpy as np

	i2c = board.I2C()

	"""
	Simple CircuitPython control of an RGB strip via Mosfetti or plain MOSFETS.

	Copyright (c) 2023 George White <[email protected]>

	Written for the Adafruit Metro M0, but will work with any board with
	4 PWM-capable pins.
	"""
	import board
	from pwmio import PWMOut

	cd ~/circuitpython

	git pull
	git submodule sync
	git submodule update --init

	cd $OLDPWD

	// define pins for the RGB LED
	byte led_red_pin = 3;
	byte led_green_pin = 5;
	byte led_blue_pin = 6;

	int piezo_pin = A0;
	int piezo_threshold = 250; // This may have to be tuned for your piezo

	int wait = 10000; // the time before the last night and the cycle resets
	int debounce = 200; // the number of milliseconds we'll wait to reject bad input