Humanize those drum computers!
© 2024–2025 Harm Lammers
The situation was that I owned an electronic drum kit and a bunch of drum computers. My dream was to play those drum computers from my drum kit, so I went searching for a way to do just that. It turned out that I couldn’t find any software or hardware solution that would give easy-to-use experience with the flexibility to change the mapping as you change a program on a drum module.
That was April 2024, when Cybo-Drummer was born: I decided to develop my own solution. The first prototype on a breadboard took a couple of months build and showed that it could work, but I had a lot to learn: programming in MicroPython, designing PCBs, (re)writing display drivers and a lot more. Also, when Cybo-Drummer started to take shape, it turned out to be a much more complex project than I had anticipated…
In November 2024 the second prototype was finally ready and I decided to publish it as an open source project. I received several enthausiast responses of people liking the idea, but no one else tried building their own Cybo-Drummer as far as I can tell – that is no surprise, because the project was still very rough around the edges, with its ad hoc hardware design, no case, a sluggy graphic user interface and an overly complex workflow.
Now, in June 2025 it’s time to launch the third prototype. This time everything as been redesigned: new hardware (now based on the more powerful Raspberry Pi Pico 2) in a 3D printed case, an almost completely redesigned user interface (now with icons and a font specially designed for Cybo-Drummer!) and a simplified, yet improved workflow, making it much more intuitive to use, yet virtually as powerful as the previous prototype. It also introduces some neat new features, like velocity layers and tools to easily assign note series to toms and scales/modes and chords to multipad triggers.
With the thrid prototype Cybo-Drummer has reached a state where it does what it has to do. There are still a few things to be done before reaching version 1.0 (but all things that could be solved with firmware updates). MIDI learn, for example still needs to be refined, better tested and documented. A big inprovement still to come is adding USB MIDI support. Before version 1.23 (released on 31 May 2024) MicroPython didn’t support MIDI over USB and even now no one figured out yet how (in MicroPython) to set up the USB MIDI descriptors, such that multiple MIDI ports (over the same USB connection) show up with different port names in the host (see the MicroPython GitHub discussion – if you know how this works, your input is appreciated!)
Are you an experienced drummer with a fascination for synthesized drum sounds? (I’ve only started my drumming journey in April 2023 and too much of my time has gone into developing Cybo-Drummer instead of practizing…) I’d love to hear how you experience using Cybo-Drummer. Does it work for you? What would you change? What features are you missing?
Note
Please use the issues tab to report bug and other issues, or the discussion tab to discuss anything else.
Of course I’m open for collaboration. Just let me know how you think you can contribute!
Cybo-Drummer is a MIDI router/mapper with 6 input ports and 6 output ports, specially designed for mapping drum triggers (electronic drum kits’ modules or brains) to drum computers. Since there is no standard for the MIDI messages sent by drum kits, nor the messages received by drum computers, Cybo-Drummer offers a flexible way of mapping the one to the other.
Cybo-Drummer operates at two distinct levels, each running on its own processor core, as shown by the dashed line in the diagram below:
Diagram showing Cybo-Drummer’s inner workings. The icons in the corners of the green and orange shapes refer to the respective pages in Cybo-Drummer’s graphic user interface.
The top level (with the green and orange shapes in the diagram above) manages all definitions, user interaction (buttons and knobs) and the graphic user interface. Some of these definitions are global and the same for all programs (green shapes and arrows), while other definitions (orange shapes and arrows) change when selecting one of the up to 2,600 programs (26 banks of 100 programs).
The bottom level (with the purple shapes and arrows in the diagram above) does its work hidden to the user. Here sits the actual router that routes MIDI data from input ports to output ports – transformed if neccessary. It is optimized to do as little as possible, to minimize latency.
No interaction takes place between the top and the bottom layer, except if a program is changed or a set-up definition is modified – this resets the router, rebuilding each route based on the definitions from the top layer.
- Real-time (low latency) mapping of up to 6 MIDI input devices (drum kits, drum triggers, multipad devices, etc.) to up to 6 MIDI output devices (drum computers, samplers, synthesizers, etc.)
- Combine multiple input devices in a single setup
- Define up to 2,600 programs (26 banks of 100 programs) to easily swich between different output devices and voices
- Combine multiple output devices in one program
- Layer multiple voices from the same or different output devices, including advanced layering techniques based on velocity layers and transition curves
- Set trigger dependency to cc value (a common way for drum modules/brains to distinguish between open and closed hihat)
- Adjust velocity dynamics (threshold, curve, minimum velocity, maximum velocity)
- Adjust how to send note off (off, pulse, fixed delay or a toggle on/off effect)
- Send program change and/or bank select commands to output devices on program change
- Quickly set up toms to the same output device/voice, but with different notes, based on intervals or chords
- Quickly assign notes to the pads of a multipad trigger to different notes, based on scales/modes or to chords (or a combination of both)
- Basic MIDI monitor
- 6 MIDI input ports (5-pin DIN)
- 6 MIDI output ports (5-pin DIN)
- 2.2 inch colour display (220×176 pixels)
- 2 knobs (rotary encoders) and 3 buttons to interact with Cybo-Drummer’s graphic user interface
- Power over micro USB or 5V DC power supply
- Option to mount onto drum rack using a standard mounting plate with screw holes spaced 70×100mm (as often used for drum modules/brains and multipads)
For indept documentation on Cybo-Drummer, see the following files:
Note
Cybo-Drummer Terminology
Since there is no universal terminology used by all manufacturers of electronic drum equipment and drum computers, or that describes all possible combinations of equipment that could be used, a choice had to be made to use the following terminology for Cybo-Drummer:
| Input device | A drum kit, drum triggers, multipad device, keyboard or other device which exists of multiple triggers and outputs MIDI data |
| Trigger | A drum pad, trigger or similar element of an electronic drum kit or other type of input device; a trigger has one or more zones/layers |
| Zone/layer | A zone or a layer of a trigger which sends a specific MIDI note |
| Multipad device | A specific type of input device which combines typically between 4 and 12 pads (triggers) into a single device, which can be used as a compact, table-top or stand mounted drumkit, or used as extension of a regular drum kit; sometimes also called ‘electronic drum pads’, ‘electronic percussion controller’ or ‘sample pads‘ (if it is sample based) or similar |
| Output device | A drum computer, sampler, synthesizer or other device which responds to MIDI data |
| Voice | A specific sound of an output device which responds to a specific MIDI channel and/or note(s) |
A MIDI router/mapper is a time-sensitive application, so why not using the programming language which leads to the fastest possible code (on a Raspberry Pi that would be C++)? Well… I do am aware that MicroPython is much slower, but I decided to use it anyway, because besides solving my challenge to connect my electronic drum kit to my drum computers, I had a second goal: finally learning how to use Python. You see, I’ve used several programming languages over time (starting with BASIC when I was a child, then Turbo Pascal as a teenager in the 90s, later a bit or C/C++ at university, some JavaScript, a lot of VBA and more recently some Arduino code). But never before I found the time to learn Python, while profesionally I’m managing a small product development and innovaiton team, with analysts/developers who are using Python as their go-to language – so I decided it was time to finally master that language as well. This project was a great learning journey!
I spent a lot of time optimizing the code (for speed and memory usage) and it turns out MicroPython on a Raspberry Pi Pico is fast enough after all. Keep in mind MIDI is a 40+ year old protocol, so it is pretty slow by today’s standards – enough time between two MIDI bytes to run a bit of Python code.
To keep latency to a minimum the second core is dedicated to MIDI handling, while the primary core takes care of the graphic user interface and button and rotary encoder input. In that way the second core runs a light loop doing only time-sensitive MIDI routing, while the primary core does all the heavy stuff.
Copyright © 2024–2025 Harm Lammers
This project is free hardware/software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
This project is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
See LICENSE for the full license text.
The fonts used for the logo and the front panel are Soviet Regular and Soviet X-Expanded, © 2003 Dan Zadorozny – Iconian Fonts, published with the following copyright statement:
This font may be freely distributed and is free for all non-commercial uses. This font is e-mailware; that is, if you like it, please e-mail the author at: