Category: DIY / Guides

New Features:

• CC Recording – Record and loop CC messages just like notes
• Per-Loop MIDI Channel Assignment – Route recorded notes and CCs to different devices
• MIDI Passthrough
• Loops Now Saved with Presets – if you recorded something cool, you can save it
• See the full list of changes at the bottom of the Loopster GitHub Page

For instructions on installing the new firmware, download the manual above.

I’ve been working on this update for quite a while. First the issue was scope creep – I kept adding in new features that popped into my head. The second issue was testing all of this again. I refactored most of the code (again), which in addition to all of the new features, created bunch of new bugs to squash. I also battled memory issues – CircuitPython is not the most efficient, and the RP2040 does not have much “oomph”. Thankfully, a majority of these problems were solved by just changing the way that scales are generated – creating them all at once made for a very large list of lists which is not very RAM friendly. Now, it only generates them when selected.

If you want to see the entire list of changes, check out the Loopster 2 GitHub page.

For more background, see the original Loopster 2 post here.

The first version of the loopster can be found here. Changes from V1:

• SMD Components – can get it partially assembled at the factory
• RP2040 chip built into board – no more raspberry pi pico needed
• RGB LEDs for buttons for user feedback
• Full sized MIDI In and MIDI Out in addition to USB midi
• Button matrix to use fewer GPIOs
• Unused GPIOs broken out to headers
  • Add your own sliders / buttons
  • Control a strip of neopixels
  • Audio out via PWM
• Slanted case design

New Features:

• Arpeggiator – hold buttons and turn encoder
• Save / Load user presets
  • save scale, starting screen, arp settings, MIDI channel, etc.
• Quantize chords and loops
• MIDI In Sync
  • BPM
  • Start / stop messages
• Record MIDI In to loops / chords
• RGB LEDs for user feedback
  • Recording pad blinks red, etc.

The problems I aimed to solve with V2 were mainly:

Make it easier to produce: I sold 5 units and a handful of kits of V1 and realized that it took me too long to assemble everything. I intend to sell this one as well, and want it to be fairly inexpensive.

Better MIDI features: TRS MIDI is annoying and we all know it. I wanted to be able to plug this directly into a synth without worrying about grabbing the right converter cable (or buying a new one)

Figure Out MIDI In: could have done this with USB MIDI in the last version, but that didn’t sound as useful as DIN MIDI In. I wanted to plug a MIDI keyboard into the Loopster and use it to record some loops and chords.

Better User Interface: I could only do so much with the little screen, and on top of that, it was CPU intensive to update.

Design Process

I don’t feel like going into detail about everything, and you can find better tutorials elsewhere anyway. I’ll focus on specific things that I learned.

Schematic / PCB Design

I don’t have a ton of experience with PCB layout and design – pretty much just the projects you see on this website that involve it. I was nervous about stepping it up so hard by embedding the raspberry pi Pico circuit directly into the board, so I settled on designing just a clone of the RP2040 for practice. But then I thought nah, let’s do it live.

The Raspberry Pi Hardware Design document was super thorough and easy to follow. It uses very common components, all of which JLCPCB had in stock. I had never done anything this close to this complicated and it worked after just a few modifications which have since been fixed on the PCB – keeping track of MIDI pins is hard :/. Either the lesson is that I experienced a miracle, or that you shouldn’t be afraid to try the same, even if you are a beginner like me.

BUTTONS

My main criteria were:

• Satisfying to push (not mushy)
• Relatively quiet (no arcade buttons)

I settled on cherry-style keyswitches that are fairly linear (aka not the super clicky “blue” ones.

DIN MIDI

A lot of folks don’t use USB midi. The old design used mini TRS for a midi out solution, but had no midi in. I knew I wanted to use full sized DIN midi ports, in and out. I have never messed with midi in, but it wasn’t too difficult to figure out. This website is super helpful

I messed up the pins on the first try – it’s super easy to confuse the orientation. Thankfully it wasn’t a critical mistake and using little jumpers helped to fix it. this cheat sheet is the best.

SCREEN / NEOPIXELS

I wanted to add features to the loopster, but needed a better solution for a user interface. Doing more with the SSD1306 OLED screen was a non-starter, as it’s too slow to update can’t have 200ms pauses when sendn MIDI notes. I landed on Neopixels under each key, the select button, and the encoder. Neopixels are great because they only take up one GPIO pin, regardless of length. They are also dirt cheap and there are libraries for using them for everything at this point. I could use multiple colors to emphasize to the user what is going on (button flashing red = recording, etc.).

The neopixels seem to run fine on 3.3 volts – I have always done this without a problem so I wasn’t worried too much.

Hardware lessons

• Be careful about DIN MIDI Pinouts – whether you are looking at the male or female view matters
• Break out unused pins to a header on the side, cause why not
• Always use the “dumbest” pin possible when assigning inputs / peripherals to pins.
  • Try not to use a SPI pin if another digital pin with no special features is available
  • Don’t use analog pins for digital things unless you have to
• Put white silkscreen under LEDs to bounce light up

Software Lessons

• When using Python… use more classes. Even if it seems kinda dumb at the time.
• Use GitHub more. Adding enhancement requests / issues to my own repo was super helpful for documenting and tracking.
• Use a “globals” file or some file that can be imported everywhere to avoid dealing with circular dependencies.
• Resist the urge to optimize – I made bad design choices to save on performance, but who knows if it even would have mattered. Better to ignore until it’s a problem.
• Keep modularization in mind the whole time. I refactored like 3 separate times because things would get unmanageable due to me not considering that some things would need to be used elsewhere in the future.
• AI is kinda nice. I resisted using it for whatever reason, but it does a great job with writing small Python functions and documenting code. Things that you know how to do, but are not interesting and take more time than you’d like.
• The last 10% takes as long as the first 90%. I swear I was almost done months ago… but kept finding small bugs and edge cases, and things that weren’t behaving as I wanted.

I plan to flesh this writeup out later, but for now…

Demo

Links

GitHub

Etsy

I had this nice walnut board lying around, and also had committed to playing a little gig at a series my friends in Fort Collins run called Noise Floor. So why not make the most out of that hard deadline and try to make an instrument out of the board so I can play it at the show? Given how little I know about electric instruments, this came out surprisingly well, and sounds surprisingly good thanks to the stereo contact mics + pre-amp.

Here are the main features:

• Solid walnut body
• Moveable frets
• 2 embedded contact microphones
• DIY single coil pickup
• Hot-swappable pickup system
• Walnut + brass frets w/ 3D printed “legs” that go through the slots
• Spring on the bottom for sustain
• Custom stereo contact mic PCB

And a demo vid if you want to hear some audio samples.

Here are the main features:

• Solid walnut body
• Moveable frets
• 2 embedded contact microphones
• DIY single coil pickup
• Hot-swappable pickup system
• Walnut + brass frets w/ 3D printed “legs” that go through the slots
• Spring on the bottom for sustain
• Custom stereo contact mic PCB

I used 3D printed router jigs for the slots and other cutouts. For my first time trying this in earnest, and it worked pretty well.

In the making

Here is the raw board after surfacing and some sanding.

Here you can see the slots on the back, and how the frets are attached. The black knobs are 3D printed caps superglued onto M3 bolts. These feed up into a captured nut within the 3D printed fret attachment.

The pickup was created by 3D printing the bobbin, sticking some magnetic pins in it, and winding it with a hand drill jig. I ran out of wire so wasn’t able to spool it completely, hence the not great sound. Thankfully I made it modular, so it’s easy to pop out whenever I get inspired to make a new pickup. Harbor freight lever wire connectors do the Job. I used large ones in case I want to experiment with running multiple pickups in parallel, which I think is a thing you can do?

The pickups are mounted on a spring …. for the purposes of tremolo, was the idea. The problem here is that the contact mics pic up every little spring squeak, so it’s not too practical to move the pickup around while playing unless just using the pickup output.

And finally a closeup of one end so you can see the nice walnut grain pattern. I finished it with a hardwax oil – Rubio Monocoat. It has a nice satin finish which I enjoy.

In summary, it’s probably easier to make an electric stringed instrument than you think. If you don’t want to bother with the DIY pickup, just buy one from a used store or online for like 15 bucks. If you don’t want to do that, just grab a piezo disc or 2, solder them to an old aux cable that’s been snipped, and you’re done. So go give it a shot.

I’m of the opinion that faders are better than twist pots, and wanted something compact that I could use to control a bunch of parameters in an Ableton drum rack. I also wanted to solve the “jumping” problem that you have when using a controller with multiple banks – if you change a bank, you don’t know what the real position of the knob should be, and it’s easy to accidentally jump to a wildly different value than you want just by slightly moving the potentiometer. Here are the features that the LumaFader has, some of which help solve this problem.

Demo

Features

• 4 x long-throw faders for precise control
• 4 x mechanical keyswitches for bank management
• 16x RGB LEDs per fader to show the last fader position for that bank
• “Pickup” mode – only send a message when the last value is passed
• USB C for easy connection to your computer / phone / whatever
• Mini TRS Out to directly connect to a synth
• 17 banks = 68 total assignable sliders

Usage

I designed this to use with a drum kit in Ableton. For example, you can map the global sliders to overall kit FX (reverb, volume, filter, etc.). Then, map each bank to an individual sample’s parameters. So holding one button will access 4 parameters of the drum sample, holding another button will access 4 parameters of the snare sample, etc.

• Move slider(s) to send CC messages
• Hold button(s) to access other banks of CCs
• Double click a bank button to lock the bank (otherwise the global bank will be used if no buttons held)
• CC messages are only sent if the slider moves past the last value sent (as displayed on the LEDs next to each slider)
• You can also enable jump mode – send CC messages immediately if the slider is moved

Design

I had already successfully designed a custom PCB based off of the RP2040 – see the Loopster 2.0 – and each time I design a PCB, I try to do something I haven’t done before in order to improve. In this case the new elements were USB C – I’ve only ever used micro USB in the past – and the use of a large number of RGB LEDs (NeoPixels). I’ve used these pixels in the past, but this project uses 69 of them – a good factor of 4 more than the Loopster 2.0 has.

First, I had to add the RP2040 and the associated circuitry. Following the RP2040 hardware design guide  I added the appropriate power regulator, memory chip, crystal, and decoupling caps. The only changes I made from the official design:

1. Swapped the ceramic cap on the power supply with an electrolytic – something that a Redditor suggested. This seems to have eliminated the high pitched buzz you can sometimes hear.
2. Swapped micro USB for USB-C. This ended up being simpler than I expected – just needed a few extra resistors

power regultor and USB C changes

The rest of the circuitry is pretty straightforward – connect the slide pots to the analog pins of the RP2040, connect each button to a digital pin, and then connect the neopixels to one digital pin. These tiny addressable RGB LEDs are great in that they only require ONE digital pin for all of them. Finally, add the TRS MIDI Out circuit, which requires just one more digital pin.

TRS Midi Out Setup

Here is the full schematic

Full Schematic – Main

Full Schematic – LEDs and Pots

Layout

The goal was to make this device compact and portable, so efficient use of space was a priority. I used the middle of the board to house the main circuitry, the left for the buttons, and the right for the 4 large sliders. I decided to break out some additional GPIOs from the RP2040 since I didn’t use them all. I don’t have any plans for these, but perhaps in the future they can be used for something?

PCB Layout

3D Renders

Enclosure

I usually go with a 3D printed enclosure made from PETG, but this time wanted to try the ol’ “PCB Front Panel” trick. I drew up a simple front panel in KiCad and included holes for all of the LEDs, Sliders, and Buttons. I thought they came out great, especially considering how cheap they are to get made. I used some brass standoffs to connect the main board and the front panel.

Assembled device with front panel and diffusers

The tiny LEDs shining through the panel holes were a bit harsh, so I designed little diffuser inserts and printed them out of transparent PETG, which did the trick. Note that the bottom layers are printed in black PETG in an effort to prevent too much bleeding between the pixels.

3D printed LED Diffusers

For the hell of it, I also created a nice Walnut case for one of them. I designed a router template in Fusion 360 and hand routed it out of a solid block of walnut. It was then hand sanded to a high grit and finished with a hardwax oil (Rubio Monocoat)

Walnut Enclosure

Software

I wanted to experiment a bit more with getting PCBs assembled, and also wanted to see how small I could make a lil drumpad. I ended up here.

Features:

• 16 x Drum Pads w/ RGB LEDs (membrane style keys)
• Control up to 51 parameters with sliders (3 global, 48 pad-specific – 3 per)
• CC Mode – Latch buttons to send pad-specific CC messages with sliders
• PETG membrane keyboard and case

the completed Mini MIDI Slider 51

Circuit Design

Basically it’s just a Raspberry Pi Pico, WS2812 LEDs and some mini faders from Digikey. I had the PCB assembled by JLCPCB and they came out great. The WS2812s are dirt cheap, though they do cost a bit extra in setup fees when ordering. I’m planning to use these a lot more now that I know how easy it is to have these made for a reasonable amount of money.

Code: https://github.com/derrickthomin/DJBB-Mini-Midi-Slider-51

Case Design

I wanted the case to bee minimal, durable and 3D-printable. I chose PETG as the material to use for its durability, relatively good heat resistance (shouldn’t warp in a hot car), best of all – its flexibility. The membrane keypad is only 0.5 mm thick in the button areas – just thick enough to hold up, but thin enough to let the pads flex indepently.

Demos

Demo vid here

Buy

Assembly

• Make sure the goofy faces are facing UP (or else the case won’t fit)

• You may need to slightly bend the pot legs inwards to fit into the hole. Just a lil though.

• Switches need at least the center 3 pins soldered. The outer ones are tough due to thermal mass – feel free to skip.
• Place all parts, flip over, and assemble.
  • I usually do the switches first, then add the RCA jacks, then the pot (shortest to longest)

• Screw it into the case

done

Extra headers are for experimenting if that’s ya jam

If you want to stay up to date on when I start selling kits of this, and other things related to this project, sign up for the mailing list here

Background

I created the DJBB Arcade Button MIDI Drumpad as an experiment on how to use a Raspberry Pi Pico microcontroller as a Midi controller.

It worked pretty well but I honestly don’t like the super loud arcade buttons so I never really used it. I wanted an excuse to try designing my first PCB, so I decided to go for a version two of my original design except with these changes:

• Use Cherry style key switches for the buttons (quieter but still feel nice. Also smaller)
• Uses a custom PCB for max compactness and ease of build
• Switch out controls for a function button and encoder
• Software updates and optimization

Features

• 16 Cherry MX style key switches for the pads, with one additional for the function button
• A nice encoder with a button for navigation
• Change midi banks
• Set velocity for each pad via encoder
• encoder mode – experimental way to send notes by twisting encoder
• looper mode – simple but fun and easy to use midi looper with overdub.
• Scale Select – filter down to midi notes in a scale

Demo

Components

1 x DJBB Midi Loopster PCB

1 x Raspberry Pi Pico or Pico W With Headers**djt depends on wifi stuff

1 x SSD1306 OLED Screen

5 x 10k Resistors

1 x 10 Ohm Resistor

1 x 33 Ohm Resistor

17 x Cherry MX Style key switches

1 x Rotary Encoder

1 x 3.5mm Audio Jack

3 x 10nF Capacitors

1 x 3D printed case (optional)

1 x 3D printed screen case (optional)

1 x 4 pin female large headers for screen (optional)

17 x Cherry style key switches (technically optional… but you want em)

BOM in csv format can be found in this GitHub repo (along with the code for this project)

The PCB

Designing my first circuit in KiCad was surprisingly easy. This DigiKey tutorial series was extremely helpful.

Here is the schematic

Device Schematic

Here is the Layout

PCB Layout of DJBB Midi Drumpad

Assembly

PCBs came in looking good. Time to assemble.

all required parts and the PCB

all optional but recommended parts. 3D printed screen case, and overall case.

!! IMPORTANT – MAKE SURE TO DO THIS FIRST !!

First, solder in the two key switches opposite of the Pico on the PCB (the Function key and Pad 1 keys – upper left).

If you do this AFTER you solder in the Pico, you won’t be able to get to the contacts on the back of the board. I fried a Pico trying to jamming a soldering iron up in there to try to solder in the switches…

PCB with 2 switches soldered in on the top left portion of the board. DO THIS FIRST.

Solder in the resistors and capacitors.

PCB with resistors and capacitors soldered to the front

Flip the board over and clip the excess leads.

Clipping off extra leads on the back

If your Pico doesn’t have headers, solder those on now. Solder the 2 remaining resistors, the aux jack, and the Pico to the back of the board.

Back of PCB with resistors, aux jack, and pico soldered

Solder on the encoder – you may need to bend the two mounting tabs on the encoder if they don’t fit in the PCB holes.

Now solder on the switches. I found it helpful to just tape them in place, flip the board, and then solder them all in one shot.

Board with buttons taped in to hold them in place

Board with all components soldered except for the screen

We saved the screen for last simply because it’s the most delicate part. Time to put it on. If you are using the 3D printed spacer / protection case, screw the screen and top on in with M2.5 screws.

Back of screen in its case. The side you see here will be facing the top of the PCB. Note that the long headers attached here are not permanent – these represent the ones soldered into the board in the above step.

Solder in the large 4 pin female header for the screen. This is optional, but without it, once keycaps are added, the screen sits pretty far below the buttons.

Front of board with screen headers soldered in

Here is the whole thing put together with the screen unit assembled. Once you confirm the screen works, put a few drops of CA glue (superglue) where the screen unit meets the PCB to lock it in place. If you ever need to replace the screen, you can simply unscrew the front of the screen unit, remove the screen, and insert a new one into the female headers we soldered to the board.

Complete DJBB Midi Loopster

Here is another view of a different unit. This one does not use the screen assembly setup.

Complete PCB example with no screen case. Screen is soldered directly to the PCB.

Software

The software is written in CircuitPython – Adafruit’s version of MicroPython with some nice ease of use upgrades.

1. Use this guide to configure your Pico
2. Go to this GitHub Repo and download everything in the “src” folder.
3. Drag the contents of the src folder to your Pico in Finder / Explorer (to the root directory)
4. Unplug and then plug in the Pico. The screen should light up.

Troubleshooting

• If the Pico isn’t showing up on your computer, make sure your USB cable isn’t power only. if it isn’t, check your soldering.

Design Decisions

Use a screen.

I kinda didn’t want to because it adds to the cost and is kinda fragile. But I also didn’t want an awful user interface, which I think would happen without a screen (with the level of features I wanted, anyway). To combat the fragility problem, I designed a 3d printed spacer <**djt add link here > that solves a few other problems as well. It has a lip to protect the screen, lifts it off the PCB to get it more in line with the other higher components, and can accept a lid, for transport protection. I also designed the screen to be easily replaceable, just in case it cracks or something.

Use quality parts, where possible.

I basically got good components unless prohibitively expensive. The PCBs are from JLPCB, but honestly they look great and are literally 5x the price to get USA made :(.

The screen was another issue. I wanted to use the little SSD1206 screens from familiarity (and cause they use less pins on the pico), but the ones from Aliexpress are like 8x cheaper than the ones sold by Adafruit, etc. I couldn’t find any other suppliers (but please let me know if you know of one). The Adafruit ones looked to me like the same thing as the Chinese ones, with perhaps some quality control on Adafruit’s part. I decided to order a bunch from Aliexpress and do my own quality control. So far so good.

SO:

Good: encoder, key switches, resistors, capacitors

Eh: screen, PCB

Refresh the screen as little as possible.

I knew from my last go-around that the screen refreshing eats up a LOT of processing power on the Pico and makes the midi output laggy if done too much.

The downside is that I can’t do fun little animations or display real time information (what midi note was just played for example). It only updates part of the screen and only when an important setting change happens (changing the menu, etc.).

Use Cherry-style key switches.

Last time I used arcade buttons but they were loud as heck. These silver Kailua switches are quiet and feel nice, and are quite affordable. Could have skimped and used Aliexpress for these but I really wanted to like the buttons this time.

Change navigation from buttons to encoder.

The old version used little buttons which made menu navigation no fun. The encoder effectively has 3 inputs in one: left, right, or push.

Make a PCB.

I have always wanted to but it was intimidating. KiCad was thankfully very intuitive and I was surprised at how relatively easy it was to pick up.

Make it easy to modify

I wanted to make this open source, so I want it to be easy to interact with. I chose Circuitpython because:

1. It has all the Midi and display libraries I need.
2. It’s still fast enough for MIDI stuff (as compared to C).
3. It’s easy to get to the code on and off the Pico.

Enhancement Ideas

See my list here in GitHub

Change Log

Nov 2023

• Created loopster_settings.json file for easy default config
• Added performance mode congig option
• Added looper feature – twist encoder ccw to remove a random loop note
• Added more scales

I’ve ripped a lot of tapes over the past few years and finally landed on an efficient method of ripping, tracking, and labeling the tapes. It’s super simple but perhaps it will help. The TLDR version is:

• Turn on auto record / auto stop on your field recorder.
• Plug an RCA -> aux cable into the field rec device and press record.
• Put a post-it on the cassette shell / record sleeve. Take note of the side, and the filename on the field recorder.
• Keep doing this until the SD card is full.
• Empty the SD and rename according to your post-its.

Steps

1. Grab your media, post-it notes, field recorder,and aux to RCA cable
2. Go into your field recorder settings and turn on auto rec on and off. Experiment with the dB threshold settings. I set the stop threshold to something really close to the minimum, and the auto start recording threshold set to a bit more than that.
3. At this point you might consider powering your field recorder via a large usb power bank or a brick, if that’s an option. Mine is plugged into a brick and it’s very nice to never think about batteries.
4. Now you can just press play and let it start recording.
5. Slap a post-it note on the cover / case and note a reference to the file name of the recording file, and which tape/side it corresponds with.

filename on zoom h2n

post it note with notes about filenames

1. Repeat until your SD Card is full. With auto record you don’t even need to press record. Just pop out the old and pop in the new and press play.
2. Transfer the files to your computer.
3. Grab your stack of sticky noted media and reference the filenames with the post its to figure out how to name the file. Here’s what mine usually look like.

final filenames in Finder

1. Reformat the SD card
2. Start over and do this forever and ever until you run out of tapes or die
3. Go to the thrift store and get MORE tapes to feed your addiction
4. Check into rehab
5. Relapse. Spend your life’s savings on eBay cassettes.

R.I.P