I'm a fan of cyberpunk genre so one of the interests is to craft my own cyberdecks every now and then to help me jack into the net with a proper device.

You don't end up endless social media scrolling with these device - although it does have a handy scroll wheel on the side to navigate your Mastodon feed 🤓

Here are some background and inspiration if you want to build your own.

Ingredients

The deck is constructed of the following parts:

• 3D printed case (design by me 😊) - check it from Printables: Cyberdore 2064
• Small keyboard, Rii 518BT Bluetooth keyboard - Aliexpress 
• Raspberry Pi Zero
• Raspberry Pi Pico to handle both scroll wheel and cassette animation on small OLED display - connected to Zero with USB cable
• 3.5" LCD Display - I used this Waveshare version
• SSD1306 OLED I2C 128X64 as small display
• KY-040 rotary encoder for the wheel
• Battery - I used this battery shield that takes single 18650 battery - Amazon.de
• A couple of small on/off switches and one 5 pin connector that now is only a prop, but the idea is to extend it to be a proper USB compatible port.
• Some parts are glued like the "Cyberdore 2064" panel but mostly fitted together using M2 screws

Rotary wheel

I'm using the same mechanism for the wheel as in my Pikku Dial USB wheel controller. I just created a custom micro-USB to micro-USB mini cable, so I was able to hook it up to Raspberry Pi Zero. Similar cable that I created for the Gamedore 2064 handheld game console.

3D Printed Case

I designed the case with Autodesk Fusion. I wanted to have a deck with a handle so that you can carry it around easily. I also added a place for the small display where to display a cassette animation to give a proper retro futuristic feel to the device.

The keyboard is fitted tightly within the case.

You can download the .stl files from my Printables page: https://www.printables.com/model/945411-cyberdore-2064-cyberdeck

Send Feedback

I'm happy to receive feedback about the device through Mastodon. Link to my account:

Tommi Laukkanen (@tlaukkanen@fosstodon.org)

Attached: 2 images New #cyberdeck build, Cyberdore 2064, is progressing nicely. Design and printed parts 95% ready. Waiting for couple of components from mail to fully hook up the #RaspberryPi Pico to Zero for extra cybernetic controls. :raspberrypi: :commodore:

Fosstodon

I'm a huge fan of Cyberpunk genre and love to design and build weird Cyberdecks. After building the latest deck, Cyberdore 2064 (posting more info on that later), I had a sudden interest in trying to make a gaming handheld to play Commodore 64 games. Main components I used were Raspberry Pi Zero W for running Vice emulator, Raspberry Pi Pico to handle the controls (D-Pad and buttons), 3.5" RPi Display, 18650 battery shield. This is a short story on how to create the device by yourself.

Even though I started my love of computers with Commodore VIC 20, the Commodore 64 was the one that really got me hooked on computers and the reason I ended up in the software development career.

TL;DR

• You can find the 3d printable STL files from Printables - please click the like button there so I receive Prucameter points :) Gamedore 2064 by Tommi L. | Download free STL model | Printables.com
• You can find the Circuitpython source code for controller from GitHub: tlaukkanen/rpi-pico-dpad: Simple game controller with Raspberry Pi Pico (github.com)

Bill of Material

Device is using the following components:

• Raspberry Pi Zero W (I would suggest on using Zero 2 for better performance)
• Raspberry Pi Pico for handling buttons and d-pad
• 3.5" LCD display - Like this from Aliexpress - Quite cheap and looks horrible - and learned later that this is the bottleneck for slow framerates
• 18650 battery shield - Like this from Aliexpress - I unsoldered the USB port from the board so that it fits the case better
• D-Pad component - This one from Aliexpress
• Quiet buttons - 6pce, these from Aliexpress
• Really thin wire for buttons and d-pad so those fit in the case slots
• Red 3mm LED to act as activity indicator in the front panel, you should use some resistor for the LED - I think I used 220 or 1k Ohm for my device.

3D Printable Handheld Shell

I designed the shell case with Fusion 360 and made the components to be printable without support. You should be able to print this with a printer that has a print area of minimum 15 x 10 cm. I used my Prusa MINI+ to print out the parts.

Controls - Hardware

The device uses six buttons and one d-pad for direction controls. The controls are created with Pico which will act as USB HID device when it is connected with USB cable to RPi Zero.

Here are schematics on how the buttons and d-pad can be connected to Pico. I might have used some of the different pins in my setup, so photos don't necessarily match the diagram. You just need to note your pins and configure those accordingly in the Python code later.

Controls - Software

I created the control software using Circuitpython using the adafruit_debouncer, for identifying button presses and adafruit_hid for setting up Pico to act has USB keyboard. Code will interpret button or d-pad clicks to keycodes. You can easily customize those to fit the emulator that you want to use. I used the following as those work quite well with Commodore VICE emulator.

Check out the latest up-to-date code from GitHub:

GitHub - tlaukkanen/rpi-pico-dpad: Simple game controller with Raspberry Pi Pico

Simple game controller with Raspberry Pi Pico. Contribute to tlaukkanen/rpi-pico-dpad development by creating an account on GitHub.

GitHubtlaukkanen

import board
import usb_hid
import digitalio
import adafruit_debouncer
from adafruit_hid.keycode import Keycode
from adafruit_hid.keyboard import Keyboard

# Button mapping
BTN_A = 3
BTN_B = 1
BTN_C = 0
BTN_D = 7
BTN_E = 5
BTN_F = 2
BTN_DOWN = 4
BTN_LEFT = 6
BTN_RIGHT = 8
BTN_UP = 9
BTN_PRESS = 10

button_pins = [
    digitalio.DigitalInOut(board.GP3),
    digitalio.DigitalInOut(board.GP4),
    digitalio.DigitalInOut(board.GP5),
    digitalio.DigitalInOut(board.GP6),
    digitalio.DigitalInOut(board.GP7),
    digitalio.DigitalInOut(board.GP8),
    digitalio.DigitalInOut(board.GP9),
    digitalio.DigitalInOut(board.GP10),
    digitalio.DigitalInOut(board.GP11),
    digitalio.DigitalInOut(board.GP12),
    digitalio.DigitalInOut(board.GP13)
]

buttons = [None] * 11
for i in range(0, 11):
    button_pins[i].direction = digitalio.Direction.INPUT
    button_pins[i].pull = digitalio.Pull.DOWN
    buttons[i] = adafruit_debouncer.Debouncer(button_pins[i])

keyboard = Keyboard(usb_hid.devices)

def get_key(button):
    if button == BTN_A:
        key = Keycode.F12
    elif button == BTN_B:
        key = Keycode.F1
    elif button == BTN_C:
        key = Keycode.ENTER
    elif button == BTN_D:
        key = Keycode.ONE
    elif button == BTN_E:
        key = Keycode.A
    elif button == BTN_F:
        key = Keycode.SPACEBAR
    elif button == BTN_DOWN:
        key = Keycode.DOWN_ARROW
    elif button == BTN_LEFT:
        key = Keycode.LEFT_ARROW
    elif button == BTN_RIGHT:
        key = Keycode.RIGHT_ARROW
    elif button == BTN_UP:
        key = Keycode.UP_ARROW
    elif button == BTN_PRESS:
        key = Keycode.X
    else:
        key = Keycode.ESCAPE
    return key

while True:
    for i in range(0, 11):
        buttons[i].update()
        if buttons[i].rose:
            key = get_key(i)
            keyboard.press(key)
        if buttons[i].fell:
            key = get_key(i)
            keyboard.release(key)

Emulators

There are multiple emulators to choose from for the RPi Zero. One of the easiest might be RetroPie as you can get full SD card image for that from the official Raspberry image generator. After that you just need to install the drivers for the 3.5" display.

For better performance it's also good to check optimization tutorials on how to enable and use the FBCP-iLi9341 driver with the 3.5" display as that will boost up the FPS significantly:

• RetroPie 3.5 inch SPI display HIGH FPS (FBCP - iLi9341) (youtube.com)
• juj/fbcp-ili9341: A blazing fast display driver for SPI-based LCD displays for Raspberry Pi A, B, 2, 3, 4 and Zero (github.com)

After everything is setup, you are ready to go and enjoy those golden games from the 80s with the gaming device that we never had back in the day :'-)

Add your comments on my Mastodon post:

Tommi Laukkanen (@tlaukkanen@fosstodon.org)

Attached: 1 image Released STL files and code for #RaspberryPi Pico for my Gamedore 2064 console as a Christmas gift to my #Maker friends 🎅 Merry Christmas to you all and I hope you get plenty of PLA in your Christmas socks to continue #3dPrinting in 2024! I also published a YouTube video of the…

Fosstodon

As soon I installed solar panels on top of my house, I was interested in seeing more information about the panel power output as well as current electricity price (spot price) of the current hour. Even though I'm not yet that keen to optimize my daily actions but still knowing these numbers may eventually guide me to use household devices when sun is shining, and electricity price is low. I also might be tempted to turn off devices when electricity price is high so that produced energy would be sold back to the grid for high price.

So, the problem was how to build a device that is always on and able to show real-time data from internet services and would look nice so it could be placed in a visible place in the house.

I chose Raspberry Pico W as the microcontroller as that has WLAN for internet connectivity, can be programmed easily with MicroPython and it's easy to hook it up with TM1637 driven 4-digit display. I chose the small display just because I happened to have few of those in my drawers - another reason is that it fits nicely in the same case that I have used for Pikku Dial and Pikku Macropad.

TL;DR: GitHub link for code and Printables.com link for STL files

Bill of Material

Required components to build Picoclock:

• Raspberry Pico W
• 4-digit LED display with TM1637 driver (used these from Amazon.de)
• 3D printed case
• 42mm lens (used something like this from Aliexpress)

Schematics

As Pico can be powered with USB cable then the only wires needed are for display. TM1637 only requires four wires: VCC, Ground, Data, Clock.

3D Printed Case

The base layer of the case is the same as in my Pikku controllers, Pikku Dial and Pikku Macropad. It fits the RPi Pico nicely and can different configurations on top of it. I designed a holder for 4-digit display and added a front panel with a slot for a glass lens to give it a retro futuristic look. I used 42mm lens from this Aliexpress seller. I used M2 screws to screw in the display component on the second layer. The display cover and top layer should snap fit to the case so glue is not necessary. I did glue up the gray U-shaped second layer component to the base for firm fit.

Python Code

You can check the full source code from GitHub. Remember to rename config_example.py to config.py and replace the placeholder values with your wifi credentials. You can also get yourself a OpenWeatherMap.org API key from that site.

tlaukkanen/picoclock

Small Raspberry Pico powered desktop or wall display - tlaukkanen/picoclock

GitHubtlaukkanen

HTTP client module (Micropython should have built-in client nowadays)

GitHub - balloob/micropython-http-client: MicroPython HTTP Client

MicroPython HTTP Client. Contribute to balloob/micropython-http-client development by creating an account on GitHub.

GitHubballoob

For TM1637 display I used this module:

GitHub - mcauser/micropython-tm1637: MicroPython driver for TM1637 quad 7-segment LED modules

MicroPython driver for TM1637 quad 7-segment LED modules - GitHub - mcauser/micropython-tm1637: MicroPython driver for TM1637 quad 7-segment LED modules

GitHubmcauser

Make it your own

Customize the code as you please and share what you make it to display! Join the conversation at Mastodon:

Tommi Laukkanen (@tlaukkanen@fosstodon.org)

Attached: 1 image Released source code and STL files for my Picoclock smart clock display. Easily customizable (aka MicroPython 🤓) to show relevant information to you. https://www.codeof.me/picoclock-smart-desktop-wall-clock-display/

Fosstodon

Created another Eurorack modular synth module after the Emergency Bass Drop Module. This is a passive attenuator/fader that can attenuate the given signal. It's still easy to build as it doesn't require current from the Eurorack bus and only uses couple of components. Attenuator circuit is created using a 10k slider pot along with single 1k resistor.

Bill of material

Only couple of components are needed:

• 10k slider pot, similar as these in Amazon.de
• 1k resistor
• 3d printed panels
• 2 x 3.5mm mono sockets, similar as these in Aliexpress

3D Printable Parts

Designed a simple panel and slider decoration with Fusion 360. I used the existing Human Skull Cut model by TAB and just resized it and added a hole for slider knob.

You can download the STL files from Printables:
Eurorack Skull Attenuator/Fader Module by Tommi L. | Download free STL model | Printables.com

Circuit

Circuit follows a simple passive mixer setup. In fact, it would be nice to create a skull themed passive mixer with the same design :)

Final Module

Some images of the final module. Maybe some video of actual usage later :)

Join the discussion in Mastodon. Any ideas what to build next?

Tommi Laukkanen (@tlaukkanen@fosstodon.org)

Attached: 3 images Forgive me father for I have synth again! This time designed and built a skull attenuator #ModularSynth module for #Eurorack - Great for attenuating those darker voltages 😈 🎶 https://www.codeof.me/modular-attenuator-for-darker-techno/

Fosstodon

This is a simple passive switch modular synth module for Eurorack. Emergency push button is used as a switch component. Can be used for both ways by routing trigger signal either to A or B output or other way around by switching from trigger signal A to trigger signal B.

Bill of Material

Requires only few parts:

• Emergency stop switch, e.g. this from Amazon.de ~13€
• 3.5mm jack socket (3 pce), e.g. this from Amazon.de ~9€/5 pce. There are cheaper sets in Aliexpress etc. ...and also mono socket would be better for Eurorack but I had these spare stereo ones available so used them.
• Wires
• 3D printed panel and button

Circuit

It's just a switch 🙃

Panels

Had couple of designs for the front panel. Settled on this one that tries to visualize the audio waves rushing from the button to the audio jacks.

You can download the 3D printable STL files from Printables.com:
Emergency Bass Drop Module for Eurorack by Tommi L. | Download free STL model | Printables.com

Join the conversation at Mastodon. Any simple ideas to build next?

Tommi Laukkanen (@tlaukkanen@fosstodon.org)

Attached: 2 images Made Emergency Bass Drop #Eurorack #ModularSynth module. Panel and button designed in #Fusion360. Front panel & button spray painted after #3dPrinting. Used passive emergency push button as switch. This will drop the bass in style :mastodance: 😺 🎶

Fosstodon

Designed a small USB dial controller to fit together with its predecessor, the Pikku Macropad. The Dial also uses Raspberry Pi Pico and is even simpler under the hood as the only component in addition to Pico is KY-040 rotary encoder. The rotary encoder includes a switch action in addition to rotary function so pushing it will switch between different modes that you can easily customize in Python code.

The modes I have there currently are:

1. Volume
2. Scroll (mouse-wheel up/down)
3. Arrow keys up/down (like moving a cursor up/down or scroll in smaller steps)
4. Fidget mode (does nothing, a stress toy 😀)

TL;DR: Check the GitHub repository for code: github.com/tlaukkanen/pikku-macropad. 3D printable .stl models are also available via Printables.com

Bill of Material

Components needed to build your own dial controller:

• Raspberry Pi Pico
• KY-040 rotary encoder (I used these from Amazon.de)
• 3D printed case

Hardware - 3D Printed Case

I designed the case to be simple and easy to print. It consists of four layers where the base houses the Raspberry Pico (same as in macropad), the second layer holds the rotary encoder in place on top of Pico. The third layer is the top panel enclosure and the last one is the actual dial knob that is connected to rotary encoder.

You can print parts with assorted colors to have different looks depending how you want it to look and to differentiate or make it use similar colors as your macropad.

I used some super glue to put the second layer in place with the rotary encoder. It shouldn't need it necessarily as there are only applied forces downwards when rotary is pressed.

Have Fun with Dial Knobs

You can quite easily design your own rotary knobs and try to find the one that suits you the best. I found the dial knobs with small "slot" for a finger to be nice.

Improvement Ideas for the Case

There are couple of ideas that could improve the usability a bit: weight and smaller rotary ratio, meaning that it could have gearing so that rotary encoder would rotate faster with smaller movement. Now it's over 10° angle for each step. Something like 2:1 - 4:1 gear ration in between the dial and encoder could feel better.

The case is quite light so rotating the dial can easily rotate the case too. Some weight could be added by adding some metal pieces to the empty slots in the case.

Schematics and Soldering

The wiring is simple as you only have the Pico and rotary encoder. Wire the power from Pico's VSYS to + in KY-040. GND ground to GND ground of KY-040.

Depends on your code wire the GPIO pins in the following way (or choose your own):

• GPIO PIN 20 to SW (Switch)
• GPIO PIN 19 to DT
• GPIO PIN 18 to CLK

Code

I flashed the Raspberry Pi Pico with the latest CircuitPython firmware by following this "Getting started with CircuitPython" tutorial from Adafruit. For code I used CircuitPython libraries:

• adafruit-circuitpython-hid for keyboard and mouse communication

Here's the full code for the macropad. Code can also be found from GitHub, here.

import board
import digitalio
import rotaryio
import time
import usb_hid
import adafruit_hid.keyboard as keyboard
import adafruit_hid.mouse as mouse
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
from adafruit_hid.keycode import Keycode
from adafruit_hid.consumer_control import ConsumerControl
from adafruit_hid.consumer_control_code import ConsumerControlCode

# Define pins
DT_PIN = board.GP19
CLK_PIN = board.GP18
SW_PIN = board.GP20

BTN_DOWN = 1
BTN_UP = 0

button = digitalio.DigitalInOut(SW_PIN)
button.direction = digitalio.Direction.INPUT
button.pull = digitalio.Pull.DOWN
last_button_state = BTN_UP
last_position = None

# Define initial mode
mode = "VOL"

# Define keyboard layout
pikku_keyboard = keyboard.Keyboard(usb_hid.devices)
layout = KeyboardLayoutUS(pikku_keyboard)
cc = ConsumerControl(usb_hid.devices)
pikku_mouse = mouse.Mouse(usb_hid.devices)

# Define rotary encoder callback function
def change_mode():
    global mode
    if mode == "VOL":
        mode = "SCROLL"
    elif mode == "SCROLL":
        mode = "CURSOR"
    elif mode == "CURSOR":
        mode = "FIDGET"
    else:
        mode = "VOL"
    time.sleep(0.1)

# Define rotary encoder reading function
def read_encoder(encoder):
    global last_position
    position = encoder.position
    if last_position == None or position == last_position:
        last_position = position
        return 0
    delta = last_position - position
    last_position = position
    return delta

# Create rotary encoder object
encoder = rotaryio.IncrementalEncoder(DT_PIN, CLK_PIN)

# Define main loop
while True:
    # Read rotary encoder
    encoder_delta = read_encoder(encoder)
    if encoder_delta != 0:
        print("delta: " + str(encoder_delta))

    # Adjust volume, scroll or cursor based on mode
    if mode == "VOL":
        if encoder_delta > 0:
            cc.send(ConsumerControlCode.VOLUME_INCREMENT)
        elif encoder_delta < 0:
            cc.send(ConsumerControlCode.VOLUME_DECREMENT)
    elif mode == "SCROLL":
        if encoder_delta > 0:
            pikku_mouse.move(wheel=-1)
        elif encoder_delta < 0:
            pikku_mouse.move(wheel=1)
    elif mode == "CURSOR":
        if encoder_delta > 0:
            pikku_keyboard.send(Keycode.DOWN_ARROW)
        elif encoder_delta < 0:
            pikku_keyboard.send(Keycode.UP_ARROW)
    else:
        # Fidget mode - do nothing
        if encoder_delta > 0:
            print("right")
        elif encoder_delta < 0:
            print("left")

    # Check if rotary encoder switch is pressed
    if button.value is False and last_button_state == BTN_UP:
        change_mode()
        print("new mode: " + mode) 
        last_button_state = BTN_DOWN
        time.sleep(0.1)
    else:
        last_button_state = BTN_UP

    # Delay to avoid debounce
    time.sleep(0.02)

Have fun on building your own! Remember to post your make on Printables :)

Join the discussion in Mastodon:

Tommi Laukkanen (@tlaukkanen@fosstodon.org)

Attached: 2 images Released code and model files for this small multimode dial controller, “Pikku Dial”. It goes well together with its sibling, Pikku Macropad 🥰#RaspberryPi #3dPrinting #CircuitPython https://www.codeof.me/pikku-dial-multi-mode-dial-controller/

Fosstodon

I designed and built a small Raspberry Pi Pico powered macropad. Code is written with Python and it is easy to customize with your own macros. You can start with current code as a basis and add your own macros there. I added functionality so that the first key changes the mode - current modes include VS Code, MS Teams, Git and more could be easily added.

TL;DR: Check the GitHub repository for code: github.com/tlaukkanen/pikku-macropad. 3D printable .stl models are also available via Printables.com

Bill of Material

Components needed to build your own macropad:

• Raspberry Pi Pico
• MX key switches and keycaps (6 pcs), I used these from Pi Hut
• Display Module SSD1306 I2C 128x32 LCD OLED Screen
• 3D printed case

Schematics

The wiring is quite simple: SSD1306 is connected via I2C pins (GP4=SDA and GP5=SCL) and buttons are connected to 3.3V voltage and other pins from switch is connected to individual GP6,7,8,10,11,12 pins.

Hardware - 3D Printed Case and Soldering

I designed the case to be simple and easy to print. It consists of three layers where the base houses the Raspberry Pico, the middle piece holds the key switches in place and the small top part fits the display inside.

You can print parts with assorted colors to have different looks.

Soldering should be done when key switches are in place as the wiring wouldn't allow you to fit switches into the middle layer part afterwards.

Code

I flashed the Raspberry Pi Pico with the latest CircuitPython firmware by following this "Getting started with CircuitPython" tutorial from Adafruit. For code I used CircuitPython libraries:

• adafruit-circuitpython-hid for keyboard communication
• adafruit-circuitpython-ssd1306 for controlling display
• Downloaded font5x8.bin file from adafruit-circuitpython-framebuf and uploaded to root of Pico. This is used by SSD1306 module for displaying text with ssd1306_display.text("some text", x, y)

Here's the full code for the macropad. Code can also be found from GitHub, here.

import board
import busio
import time
import usb_hid
import digitalio
import adafruit_ssd1306
from adafruit_hid.keycode import Keycode
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS

# Button mapping
BTN1_PIN = board.GP6
BTN2_PIN = board.GP8
BTN3_PIN = board.GP11
BTN4_PIN = board.GP7
BTN5_PIN = board.GP10
BTN6_PIN = board.GP12

buttons = [
    digitalio.DigitalInOut(BTN1_PIN),
    digitalio.DigitalInOut(BTN2_PIN),
    digitalio.DigitalInOut(BTN3_PIN),
    digitalio.DigitalInOut(BTN4_PIN),
    digitalio.DigitalInOut(BTN5_PIN),
    digitalio.DigitalInOut(BTN6_PIN)
]
for i in range(0,6):
    buttons[i].direction = digitalio.Direction.INPUT
    buttons[i].pull = digitalio.Pull.DOWN

# OLED display setup
WIDTH = 128
HEIGHT = 32

# I2C pins
SCL = 5
SDA = 4

BTN_DOWN = 1
BTN_UP = 0

lastState = BTN_UP
modes = [
    ['Teams',           # Mode name
     'Search',          # Key 2 function
     'Goto',            # Key 3 function
     'Toggle mute',     # Key 4 function 
     'Toggle camera',   # Key 5 function
     'Hangup'           # Key 6 function
    ],
    ['VS Code',         # Mode name
     'Explorer',        # Key 2 function
     'Problems',        # Key 3 function
     'Search',          # Key 4 function
     'Debug',           # Key 5 function
     'Output'           # Key 6 function
    ],
    ['Git',             # Mode name
     'Branch..',        # Key 2 function
     'Checkout main',   # Key 3 function
     'Status',          # Key 4 function
     'Push',            # Key 5 function
     'Pull org main'    # Key 6 function
    ]

]

keyboard = Keyboard(usb_hid.devices)
layout = KeyboardLayoutUS(keyboard)
MODE_TEAMS = 0
MODE_VSCODE = 1
MODE_GIT = 2
COUNT_OF_MODES = 3
currentMode = MODE_GIT

# Initialize I2C
i2c = busio.I2C(scl=board.GP5, sda=board.GP4)
display = adafruit_ssd1306.SSD1306_I2C(WIDTH, HEIGHT, i2c)

def handle_mode_press(mode, key):
    if(mode == MODE_TEAMS):
        if key == 1:
            keyboard.send(Keycode.LEFT_CONTROL, Keycode.E)
        if key == 2:
            keyboard.send(Keycode.LEFT_CONTROL, Keycode.G)
        if key == 3:
            keyboard.send(Keycode.LEFT_CONTROL, Keycode.SHIFT, Keycode.M)
        if key == 4:
            keyboard.send(Keycode.LEFT_CONTROL, Keycode.SHIFT, Keycode.O)
        if key == 5:
            keyboard.send(Keycode.LEFT_CONTROL, Keycode.SHIFT, Keycode.B)
    if(mode == MODE_VSCODE):
        if key == 1:
            keyboard.send(Keycode.LEFT_CONTROL, Keycode.SHIFT, Keycode.E)
        if key == 2:
            keyboard.send(Keycode.LEFT_CONTROL, Keycode.SHIFT, Keycode.M)
        if key == 3:
            keyboard.send(Keycode.LEFT_CONTROL, Keycode.SHIFT, Keycode.F)
        if key == 4:
            keyboard.send(Keycode.F5)
        if key == 5:
            keyboard.send(Keycode.LEFT_CONTROL, Keycode.SHIFT, Keycode.U)
    if(mode == MODE_GIT):
        if key == 1:
            layout.write('git branch -b ')
        if key == 2:
            layout.write('git checkout main\n')
        if key == 3:
            layout.write('git status\n')
        if key == 4:
            layout.write('git push\n')
        if key == 5:
            layout.write('git pull origin main\n')

def draw_screen(text, x, y):
    global currentMode
    global modes
    display.fill(0)
    display.text(text, x, y, 1)
    display.text("Mode: " + modes[currentMode][0], 24, 12, 1)
    display.text("Pikku v1.0", 24, 24, 1)
    display.show()

def buttonPress(last):
    global currentMode
    tempLast = last
    text = ""
    nextState = last

    # Check key 1 mode change
    if (tempLast == BTN_UP) and (buttons[0].value):
        nextState = BTN_DOWN
        currentMode += 1
        if(currentMode>COUNT_OF_MODES-1):
            currentMode = 0
        draw_screen("", 1, 1)

    # Check keys 2-6 press
    for btn in range(1, 6):
        if (tempLast == BTN_UP) and (buttons[btn].value):
            nextState = BTN_DOWN
            text = modes[currentMode][btn]
            draw_screen(text, 1, 1)
            # Type the text as key presses
            handle_mode_press(currentMode, btn)
            time.st pull origleep(0.256)

    # Key up
    if  (tempLast == BTN_DOWN and
        not buttons[0].value and
        not buttons[1].value and
        not buttons[2].value and
        not buttons[3].value and
        not buttons[4].value and
        not buttons[5].value):
        nextState = BTN_UP
        draw_screen("", 1, 1)
    return nextState

draw_screen("", 1, 1)
while True:
    lastState = buttonPress(lastState)

Have fun building your own! Remember to post your make on Printables :)

Join the discussion with Mastodon:

Tommi Laukkanen (@tlaukkanen@fosstodon.org)

Attached: 1 image Designed and built a small macropad, Pikku. Powered by #RaspberryPi Pico and #CircuitPython. I made the code and STL available for #3dPrinting https://www.codeof.me/pikku-raspberry-pi-pico-powered-macropad/

Fosstodon

As a fan of cyberpunk and sci-fi I've always wanted to have a cyberdeck of my own. Finally designed and built one - I call it Cyberdore.

Ingredients

I wanted my cyberdeck to be portable but still run full Linux. Also wanted to have some sci-fi feel to it but keep it a bit retro. Here are components that I used:

• Raspberry Pi (I used 3 Model B+ first but ended up using Zero W for lower energy consumption)
• Battery - I used this battery shield that takes single 18650 battery Amazon.de
• 3.5" LCD Display - I used this Waveshare version
• Rii X1 mini wireless keyboard - this in Amazon.de
• 3D printed case - see next chapter

That was the mandatory part to get functional minicomputer. I did want to have some sci-fi cyberpunk props there too, so I designed a small screen on the side to display retro cassette mimicking animation. For this I used:

• Raspberry Pi Pico
• Small 1.5" OLED display with 128x128 resolution, I used this from Waveshare
• 40mm flatback magnifying glass, something like this in Aliexpress
• Red LED for power indicator

I also added a wi-fi antenna as a prop. I did mean to enhance the wi-fi range with it first but eventually didn't add external wi-fi card for this purpose.

Total cost for the components depends highly where you are. Many might have Raspberry Pi already but depending on the model (and your country) getting it from the store can cost anything between 10€ to 90€ due to component shortage. I'd guess the total average cost for materials is around 100-150€.

Cyberdeck case

I started the design based on keyboard dimensions and I was able to embed the keyboard quite well in the front with minimal noticeable gaps. I added main 3.5" and circular lens glass displays on top of the keyboard. I also wanted to have a retro feel to the case and gave it the grille and power led on top as a tribute to Commodore computers that got me started in computing in 80s (Vic 20 & C64 FTW!)

The case is made of layers which are held together by four M2 screws that go through all the layers. The back panel has a snap fit design so it can be removed without screws when you need to have access to Raspberry Pi.

Printables

Checkout my Printables page for .stl files if you'd like to build or mod your own version: Cyberdore - RPi powered Cyberdeck by Tommi L. | Download free STL model | Printables.com

Starting the year 2023 with productivity in mind. I've always been fan of different techniques to gain better focus for tasks at hand. Pomodoro technique is interesting and I've always liked physical productivity gear over software apps.

Therefore, I took as a task to design and build Picomoro - a small pomodoro timer powered by Raspberry Pi Pico. Designed as cubelike case with Fusion 360 and printed with Prusa Mini. Here are the steps if you'd also like to build one or use it as a basis for something more exciting, like smart clock etc.

TL;DR Checkout source code at GitHub, 3D printable case at Printables.com

Pomodoro Technique

Wikipedia describes Pomodoro technique like this:

The original technique has six steps:

1. Decide on the task to be done.
2. Set the pomodoro timer (typically for 25 minutes).
3. Work on the task.
4. End work when the timer rings and take a short break (typically 5–10 minutes).
5. If you have finished fewer than three pomodoros, go back to Step 2 and repeat until you go through all three pomodoros.
6. After three pomodoros are done, take the fourth pomodoro and then take a long break (typically 20 to 30 minutes). Once the long break is finished, return to step 2.

For the purposes of the technique, a pomodoro is an interval of work time.

Functional Requirements

I started the design with my additional technical requirements. Timer should have:

• Display for displaying minutes and seconds
• Button or dial to change the initial time and start the timer
• Buzzer to notify that time is up
• Timer can be powered by USB cable

Bill of Material

From the requirements I ended up with the following components. Mostly built with components that I had laying around:

• Raspberry Pi Pico - small and powerful microcontroller that can be programmed with many languages, including Micropython
• SMA420564 - Four Digit Seven Segment LED Display 0.56"
• Mini on/off rocker switch (this in Amazon.de or this could be the same in Aliexpress)
• 4 x 220 Ohm resistors
• KY-006 Piezoelectric buzzer
• KY-040 Rotary Encoder
• 3 AA batteries
• on/off switch

Schematic

Here's a schematic on how I connected the components together. Instead of 5V battery I used three normal AA batteries in series (~ 4.5V). As stated here, Pico can be safely powered with voltage between 1.8V and 5.5V. I added 220 Ohm resistors for the display to limit the current for digit displays. It seems to work without those but didn't like to test if it breaks something eventually when running for a long time.

Case

It was fun to design this. I wanted it to have retro feel and look like a bedside clock. Case design should still have enough space to fit everything inside without special arrangements with the circuitry.

So, I produced this cubelike shape but with a twist so that the bottom is cut in a way that display rotates a bit upwards for easier reading.

Retrospect: a better placement for rotary dial could have been on the top as one of the functionalities is to press the dial and it now needs to be held from the other side if you press the dial - otherwise it would slide on the desk as it's so light.

3D printing the case

Printed the case parts from two different PLAs. The display cover with matte black PLA and dial, case and back cover with beige PLA that reminds me of good old Commodore 64 and Amiga case colors.

Final tests before closing the enclosure.

Code

I wrote the actual logic for Raspberry Pi Pico with Micropython. Basic logic is that timer counts down and displays the remaining time. The rotary encoder can control the initial time which defaults to Pomodoro's 25 minutes but can be adjusted by turning the knob either clockwise (increase minutes) or counterclockwise (decrease minutes). When the knob is pressed the timer starts.

Buzzer is used for notifying user that knob controls are acknowledged. The buzzer will also beep when the timer runs to zero.

Full code is only a bit under 250 lines of code:

import time
import micropython
import uasyncio as asyncio
from machine import Pin, PWM

class Rotary:
  
  ROT_CW = 1
  ROT_CCW = 2
  SW_PRESS = 4
  SW_RELEASE = 8
  
  def __init__(self,dt,clk,sw):
    self.dt_pin = Pin(dt, Pin.IN, Pin.PULL_DOWN)
    self.clk_pin = Pin(clk, Pin.IN, Pin.PULL_DOWN)
    self.sw_pin = Pin(sw, Pin.IN, Pin.PULL_DOWN)
    self.last_status = (self.dt_pin.value() << 1) | self.clk_pin.value()
    self.dt_pin.irq(handler=self.rotary_change, trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING )
    self.clk_pin.irq(handler=self.rotary_change, trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING )
    self.sw_pin.irq(handler=self.switch_detect, trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING )
    self.handlers = []
    self.last_button_status = self.sw_pin.value()
      
  def rotary_change(self, pin):
    new_status = (self.dt_pin.value() << 1) | self.clk_pin.value()
    if new_status == self.last_status:
      return
    transition = (self.last_status << 2) | new_status
    if transition == 0b1110:
      micropython.schedule(self.call_handlers, Rotary.ROT_CW)
    elif transition == 0b1101:
      micropython.schedule(self.call_handlers, Rotary.ROT_CCW)
    self.last_status = new_status
      
  def switch_detect(self,pin):
    if self.last_button_status == self.sw_pin.value():
      return
    self.last_button_status = self.sw_pin.value()
    if self.sw_pin.value():
      micropython.schedule(self.call_handlers, Rotary.SW_RELEASE)
    else:
      micropython.schedule(self.call_handlers, Rotary.SW_PRESS)
          
  def add_handler(self, handler):
    self.handlers.append(handler)
  
  def call_handlers(self, type):
    for handler in self.handlers:
        handler(type)

buzzer = PWM(Pin(22))
async def beep():
  buzzer.freq(600)
  buzzer.duty_u16(200)
  await asyncio.sleep(0.2)
  buzzer.deinit()

async def upBeep():
  buzzer.freq(800)
  buzzer.duty_u16(100)
  await asyncio.sleep(0.1)
  buzzer.deinit()

async def downBeep():
  buzzer.freq(500)
  buzzer.duty_u16(100)
  await asyncio.sleep(0.1)
  buzzer.deinit()

async def buzz():
  buzzer.freq(400)
  buzzer.duty_u16(200)
  await asyncio.sleep(0.1)
  buzzer.freq(800)
  buzzer.duty_u16(400)
  await asyncio.sleep(0.2)
  buzzer.freq(600)
  buzzer.duty_u16(200)
  await asyncio.sleep(0.1)
  buzzer.deinit()

DT_PIN = 27
CLK_PIN = 28
SW_PIN = 26

rotary = Rotary(DT_PIN, CLK_PIN, SW_PIN)
rotaryValue = 0
# Default countdown time 25 minutes in seconds
countdown = 25 * 60
isActive = False

def rotary_changed(change):
  global rotaryValue
  global countdown
  global isActive
  if change == Rotary.ROT_CW:
    asyncio.run(upBeep())
    countdown += 60
    # round countdown to nearest minute
    countdown = countdown - (countdown % 60)
    isActive = False
    rotaryValue += 1
    print("Rotary CW", rotaryValue)
  elif change == Rotary.ROT_CCW:
    asyncio.run(downBeep())
    if(countdown>60):
      countdown -= 60
    # round countdown to nearest minute
    countdown = countdown - (countdown % 60)
    isActive = False

    rotaryValue -= 1
    print("Rotary CCW", rotaryValue)
  elif change == Rotary.SW_PRESS:
    if(countdown<=0):
      countdown = 25 * 60
    else:    
      isActive = True
    asyncio.run(beep())
  elif change == Rotary.SW_RELEASE:
    print("Switch released")

rotary.add_handler(rotary_changed)

# SMA420564 pinout mapping to GPIO pins
pin = [
  # Top row
  Pin(4, Pin.OUT), # GP4 through 220 Ohm resistor
  Pin(5, Pin.OUT), # GP5
  Pin(6, Pin.OUT), # GP6
  Pin(7, Pin.OUT), # GP7 through 220 Ohm resistor
  Pin(8, Pin.OUT), # GP8 through 220 Ohm resistor
  Pin(9, Pin.OUT), # GP9
  
  # Bottom row
  Pin(16, Pin.OUT), # GP16
  Pin(17, Pin.OUT), # GP17
  Pin(18, Pin.OUT), # GP18
  Pin(19, Pin.OUT), # GP19
  Pin(20, Pin.OUT), # GP20
  Pin(21, Pin.OUT)  # GP21 through 220 Ohm resistor
]

buzz()
time.sleep(1)
beep()

def getGND(place):
  p = 0
  if place == 1:
    p = 0
  elif place == 2:
    p = 3
  elif place == 3:
    p = 4
  elif place == 4:
    p = 11
  else:
    return None
  return p

pin1digits = [0, 2, 3, 5, 6, 7, 8, 9]
pin2digits = [0, 4, 5, 6, 8, 9]
pin5digits = [0, 1, 2, 3, 4, 7, 8, 9]
pin6digits = [0, 2, 6, 8]
pin7digits = [0, 2, 3, 5, 6, 8]
pin9digits = [0, 1, 3, 4, 5, 6, 7, 8, 9]
pin10digits = [2, 3, 4, 5, 6, 8, 9]

# Draw two lines when timer is idle
def displayIdle():
  pin[3].off()
  pin[4].off()
  pin[10].on()

def display(digit,place):
  gnd = getGND(place)
  pin[gnd].off()
  if digit in pin1digits:
    pin[1].on()
  if digit in pin2digits:
    pin[2].on()
  if digit in pin5digits:
    pin[5].on()
  if digit in pin6digits:
    pin[6].on()
  if digit in pin7digits:
    pin[7].on()
  if digit in pin9digits:
    pin[9].on()
  if digit in pin10digits:
    pin[10].on()
  time.sleep(0.002)
  pin[1].off()
  pin[2].off()
  pin[5].off()
  pin[6].off()
  pin[7].off()
  pin[9].off()
  pin[10].off()  
  pin[gnd].on()

def cleanup():
  for i in [1,2,5,6,7,9,10]:
    pin[i].off()

def cleanupDigitPins():
    pin[0].on()
    pin[3].on()
    pin[4].on()
    pin[11].on()

cleanupDigitPins()

while True:
  minutes = countdown // 60
  seconds = countdown % 60

  # format minutes and seconds to 4 digits with leading zeros, 
  # for example 8 minutes and 5 seconds will be 0805
  displayString = "{:02d}{:02d}".format(minutes, seconds)

  # display the time with digits
  # flicker the display 125 times per second to make it more visible
  if(countdown>0):
    for flicker in range(1,125):
        for displayIndex in range(1, 5):
          digit = int(displayString[displayIndex - 1])
          display(digit, displayIndex)
    if(isActive):
      countdown -= 1
  else:
    displayIdle()

  if(countdown == 0):
    buzz()
    time.sleep(1)
    countdown = -1

I used Thonny IDE to upload the code to Pico. Remember to name your file to main.py as then it will be automatically started even when Pico is not connected to computer or just powered with battery.

Finished

Now it sits on my desk and can be activated easily for Pomodoro tasks :)

TL;DR: Coded a small Azure DevOps Task extension that can be used to publish comments on Pull Requests. See and install extension from Marketplace or browse the open-source code from GitHub azure-devops-pr-comment-extension.

Task itself is easy to use in your pipeline yaml script:

- task: PullRequestComment@1
  inputs:
    comment: |
      This is **sample** _text_ 🎉
      [This is link](https://microsoft.com)
      Build ID is $(Build.BuildId)
      | Table |
      |---|
      | Cell |

The example shows that you can use multiline Markdown formatting as well as all variables that you may have available in the pipeline. When task executes, it will show up as a comment like this in your pull request comments:

How to create Azure DevOps extensions?

It's easy to create new extensions as Microsoft provides npx tooling to create baseline for your extension. Extension consists of main three parts:

1. Extension manifest file (vss-extension.json)
2. Discovery assets (screenshots, markdown), things you see in Marketplace
3. Static files, like in this case build task Typescript code

Following tutorials show this quite well so I don't duplicate them here:

• Extensions overview - Azure DevOps | Microsoft Learn
• Add a build or release task in an extension - Azure DevOps | Microsoft Learn
• Custom build/release task reference - Azure DevOps | Microsoft Learn

How to add comment on PR in your extension with TypeScript?

So how to utilize and interact with Azure DevOps objects? Microsoft provides a couple of handy modules that make it easy to interact with the Azure DevOps API and especially Git API for Pull Request commenting. So, install these to your task script:

• npm install azure-pipelines-task-lib
• npm install azure-devops-node-api

After this the comment thread can be created with the following task code:

import tl = require('azure-pipelines-task-lib/task')
import azdev = require('azure-devops-node-api')
import { CommentThreadStatus, CommentType } from 'azure-devops-node-api/interfaces/GitInterfaces'

async function run() {
  try{
    const comment: string | undefined = tl.getInput('comment', true)
    if(comment == '' || comment == undefined) {
      console.log(`Empty comment given - skipping PR comment`)
      return
    }
    const pullRequestId = parseInt(tl.getVariable('System.PullRequest.PullRequestId') ?? '-1')
    if(pullRequestId < 0 ) {
      console.log(`No pull request id - skipping PR comment`)
      return
    }
    
    // This is especially nice for task extensions as you
    // don't need to pass access tokens as parameters but you can get
    // the access token to az api with just the following:
    const accessToken = tl.getEndpointAuthorizationParameter('SystemVssConnection', 'AccessToken', false) ?? ''
    const authHandler = azdev.getPersonalAccessTokenHandler(accessToken) ?? ''
    
    // All the system/build variables can be accessed in similar
    // way as you access those from pipelines
    const collectionUri = tl.getVariable('System.CollectionUri') ?? ''
    const repositoryId = tl.getVariable('Build.Repository.ID') ?? ''
    const connection = new azdev.WebApi(collectionUri, authHandler)
    const gitApi = await connection.getGitApi()
    
    // Thread and comment schema wasn't explained well anywhere
    // but this minimalistic version was constructed from various
    // Stackoverflow posts
    const thread : any = {
      comments: [{
        commentType: CommentType.Text,
        content: comment,
      }],
      lastUpdatedDate: new Date(),
      publishedDate: new Date(),
      status: CommentThreadStatus.Closed,
    }
    const t = await gitApi.createThread(thread, repositoryId, pullRequestId)
    
    // Console logging shows up nicely on the actual build log
    console.log(`Comment added on pull request: ${comment}`)
  }
  catch (err:any) {
    tl.setResult(tl.TaskResult.Failed, err.message)
  }
}

run()

Designed and built a futuristic looking camera case for Raspberry Pi Zero. The original idea was to have a camera to monitor my 3D builds and create timelapse shots of various things.

Bill of Material

The bill of material for the components is the following:

• 3D printed case
• Raspberry Pi Zero
• Waveshare Li-ion Battery hat
• Camera Module with cable compatible with RPi Zero
• Two push buttons, I used these from Amazon.de
• 1.5" OLED display or similar
• Round 8x1 mm magnets for back cover, I used these from Amazon.de

3D Printed Case

3D case modeling was done with Fusion 360 and the final design has six different components.

I published the model's .STL files Creative Commons license and those can be downloaded from Printables.com, here.

The Code

There are many good tutorials on how to use Python for taking pictures when pressing button. The possibilities on what you do with your picture files after that are endless - apply AI magic to them or just post them directly to your Telegram etc. Couple of tutorials to get you started:

• python-picamera-setup/worksheet.md at master · raspberrypilearning/python-picamera-setup (github.com)
• Building a Raspberry Pi 3 prototype camera that takes a picture at the press of a button (techcoil.com)