10. Output Devices

Goals

Group assignment:

[x] measure the power consumption of an output device

Individual assignment:

[x] add an output device to a microcontroller board you’ve designed, and program it to do something

Tools Used

Blender - Free and opensource 3D software that can be used for anything from sculpting to animation and much more.
Thonny
ChatGPT
CircuitPython
Xiao-Fab

TLDR; Nice images

Group Project

For our group project we tested the power consumption of an LED vs a servo motor using a USB tester.

Full documentation can be found here.

Summary

The power draw was much lower on the LED as expected, though it was interesting to see the power consumption, or more specifically the current draw of the servo motor change as we put it under load.

Individual Project

1. Macro Pad Inputs -> Software Outputs

For this weeks assignment I worked on using my Xiao-Fab from a couple of weeks ago to develop some of the logic for my final project.

My project is a CAD specific input device so my focus was to have inputs from the device generate outputs to my laptop as well as a small OLED display.

1.0 Switching platform

After doing some research, I found that the CircuitPython HID library provides a simple way to send keyboard and mouse events to the host computer.

To date I have been using MicroPython but the switch seemed straightforward and made sense for the project to switch to CircuitPython.

As in other weeks I used thonny to set up the board and install CircuitPython.

I downloaded the full bundle of CircuitPython libraries from CircuitPython Library Bundle.

1.1 Basics again

Circuit Python Main Documentation

Circuit Python HID Library Documentation

One of the differences I have found between MicroPython and CircuitPython is the naming convention for pins on the board.

Thankfully, the documentation guides you through using the REPL to print out the list of pin names. This can then be referenced with the boards pinout diagram.

As CircuitPython was a bit of a chance I recreated some of the basic programs I had used earlier, such as print hello world on a button press.

Adafruit provides fantastic documentation on their libraries and resources on their site.

Here is a full list of the codes that are used to send keystrokes to the machine.

1.2 Putting it together

import board  # Import board module to access pin names
import digitalio  # Import digitalio to work with digital inputs/outputs
import time  # Import time module to handle delays
import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode

# Set up the button on pin D7
button = digitalio.DigitalInOut(board.D7)  # Define button on pin D7
button.direction = digitalio.Direction.INPUT  # Set as an input (reading data)
button.pull = digitalio.Pull.UP  # Enable internal pull-up resistor (default HIGH)

# Variable to track previous button state
previous_state = button.value  # Start by storing the initial button state

keyboard = Keyboard(usb_hid.devices)

toggle = 0 # Var to toggle the state of the button.

while True:
    if toggle == 4: # When the toggle reaches 4, reset it to 0
        toggle = 0

    current_state = button.value  # Read the current button state


    # Detect when the button is pressed (goes from HIGH to LOW)
    if previous_state and not current_state:  # Was HIGH, now LOW = Pressed
        if toggle == 0:
            print("Blender Front")
            keyboard.send(Keycode.KEYPAD_ONE)  # Sends the Numbad one key - in Blender this is the front view
        elif toggle == 1:
            print("Blender Side")
            keyboard.send(Keycode.KEYPAD_THREE)  # Sends the Numbad three key - in Blender this is the side view
        elif toggle == 2:
            print("Blender Top")
            keyboard.send(Keycode.KEYPAD_SEVEN)  # Sends the Numbad seven key - in Blender this is the top view
        else:
            print("Blender Camera")  # Print message once
            keyboard.send(Keycode.KEYPAD_ZERO)  # Sends the Numbad zero key - in Blender this is the camera view
        toggle = toggle + 1 # After each press, increment the toggle

    # Update previous state for the next loop iteration
    previous_state = current_state

    time.sleep(0.01)  # Small delay to avoid CPU overload

The above was my first major success in bringing in some of the functionality that I wanted to implement.

The code above toggles between the different views in Blender on a button press.

1.3 Do the twist

For the next part of my functionality I wanted to experiment with using a potentiometer to control orbiting of the Blender.

My first iteration of the code used the mouse as the primary input for orbiting the camera.

This had unintended consequences though as the mouse pointer would move across the screen while it was working and this was not the desired behaviour.

import board  # Import board module to access pin names
import analogio# Import analogio to work with analog inputs/outputs
import time  # Import time module to handle delays
import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode

from adafruit_hid.mouse import Mouse

keyboard = Keyboard(usb_hid.devices)

pot = analogio.AnalogIn(board.D0)

center = 65535/2 # The center of the pot
neutral_zone = 10000 # Area on pot where there is no input

while True:
    pot_value_x = pot.value
    deviation = pot_value_x - center

    if abs(deviation) > neutral_zone: #abs is removing negitave values

        if deviation > 0:
            #keyboard.press(Keycode.KEYPAD_SIX)
            keyboard.press(Keycode.KEYPAD_EIGHT)
            print(pot_value_x)
        else:
            #keyboard.press(Keycode.KEYPAD_FOUR)
            keyboard.press(Keycode.KEYPAD_TWO)
            print(pot_value_x)
    else:
        keyboard.release_all()
    time.sleep(0.05)

The second iteration of the code instead used the numpad keys to orbit the camera, this felt much cleaner to use but also has a jerky, low resolution quality to the movement.

This is an area I will return to in later weeks to improve.

The final version of this code involved a bit of help from ChatGPT to figure out. (log in files.)

Basically the camera orbits in the x axis, and when the button is pressed it toggles the rotation to the y axis.

1.4 Some direction

As this is output week I thought it would be fitting to give the device a way of communicating to the user the state of the toggle button.

I found a small OLED display module in our lab that probably came from a kit.

I found some boiler plate code that could be used to confirm if the device communicated over I2C, and it was successful returning an address..

One of the nicest things about CircuitPython is how easy adding the libraries is, they are just copy and pasted into a lib folder on the device.

I brought in libraries related to the display.

/adafruit_display_shapes
/adafruit_display_text
adafruit_displayio_ssd1306.mpy

I found a simple hello world example for the display.

And it came to life!

2. Making a new board

So I wanted to make a new board so that I could test the display without having to use a breadboard.

To do this I needed to make a new component in my fusion 360 library for 4 solder pads in a row.

This was under File -> New Electronics Library

In order to make a new component I needed to first make a symbol, then a footprint (you would normally make a package at this point with the 3D File but I chose not too)

Then in my schematic I could connect the pads to the display using the net tool.

Board was routed in the PCB tab. Note that I increased the trace width to 0.8mm with a gap of 0.6 as I had issues in past board and space was not an issue on this one.

The board are exported as .png files by hiding the layers and exporting the board using the command line export image.

In the menu I chose monochrome and a DPI of 1000.

The file I have noticed tend to include some unwanted information like text and crosshairs, these were cleaned up in GIMP.

Cleaned up traces.

This is the same process for the outline cut of the board.

And the holes I used gimp to remove all the areas around the traces using the paint bucket tool.

The finished 3D of the board.

Everything was programmed in mods using:

0.4mm tip, 60deg v-bit
0.8mm endmill for outline and holes.

3. Bringing all the pieces together

The .rml file was sent using v-panel to the SRM-20.

And we have success!

This was my first board that I placed the pads incorrectly on.

And the soldered final board.

And this is the board in action using the view toggle program from above with the current view state being displayed on the screen.

import board  # Import board module to access pin names
import digitalio  # Import digitalio to work with digital inputs/outputs
import time  # Import time module to handle delays
import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode

import displayio
import terminalio
from adafruit_display_text import label
from adafruit_displayio_ssd1306 import SSD1306
import i2cdisplaybus

# Set up the button on pin D7
button = digitalio.DigitalInOut(board.D7)  # Define button on pin D7
button.direction = digitalio.Direction.INPUT  # Set as an input (reading data)
button.pull = digitalio.Pull.UP  # Enable internal pull-up resistor (default HIGH)

# Variable to track previous button state
previous_state = button.value  # Start by storing the initial button state

keyboard = Keyboard(usb_hid.devices)

toggle = 0 # Var to toggle the state of the button.

# Screen Stuff

# Release any previously used displays
displayio.release_displays()

# Set up I2C and display
i2c = board.I2C()  # Uses GP17 (SCL) and GP16 (SDA) by default
display_bus = i2cdisplaybus.I2CDisplayBus(i2c, device_address=0x3C)
display = SSD1306(display_bus, width=128, height=64)

display.rotation = 180

# Create text label
text_area = label.Label(terminalio.FONT, text="Hello World", color=0xFFFFFF, x=30, y=30)

# Show it on the screen
group = displayio.Group()
group.append(text_area)
display.root_group = group  # New method in CircuitPython 9.x

while True:
    if toggle == 4: # When the toggle reaches 4, reset it to 0
        toggle = 0

    current_state = button.value  # Read the current button state

    # Detect when the button is pressed (goes from HIGH to LOW)
    if previous_state and not current_state:  # Was HIGH, now LOW = Pressed
        if toggle == 0:
            print("Blender Front")
            text_area.text = "Blender Front"
            keyboard.send(Keycode.KEYPAD_ONE)  # Sends the NumPad one key - in Blender this is the front view
        elif toggle == 1:
            print("Blender Side")
            text_area.text = "Blender Side"
            keyboard.send(Keycode.KEYPAD_THREE)  # Sends the NumPad three key - in Blender this is the side view
        elif toggle == 2:
            print("Blender Top")
            text_area.text = "Blender Top"
            keyboard.send(Keycode.KEYPAD_SEVEN)  # Sends the NumPad seven key - in Blender this is the top view
        else:
            print("Blender Camera")  # Print message once
            text_area.text = "Blender Camera"
            keyboard.send(Keycode.KEYPAD_ZERO)  # Sends the NumPad zero key - in Blender this is the camera view

        toggle = toggle + 1 # After each press, increment the toggle
        display.root_group = group  # Refresh display



    # Update previous state for the next loop iteration
    previous_state = current_state

    time.sleep(0.01)  # Small delay to avoid CPU overload

In Summary

This week felt like big progress toward my final project.

I am happy with the switch to CircuitPython as it feels like it is a good fit for my project.

Things I would do differently next time

The implementation of the orbit using the keyboard strokes still needs some refinement.

It feels jumpy and low resolution and for my project I had envisioned using the device to make very precise movements.

See below link to files created this week:

Week 10 Files