A second CV out for the Raspberry Pi Pico MIDI to CV converter

This entry is part 2 of 2 in the series Raspberry Pi Pico as MIDI to CV converter

In the first part of the series we built a MIDI to CV converter using MicroPython on the Raspberry Pi Pico. Check it out here if you haven’t done so already.

This time we’ll add a second CV output, as well as a distance sensor as a modulation source and a Neopixel ring to visualise its output.

The Set Up

In the above video the Elektron Model:Samples is set up to generate MIDI notes on track 6, which are sent to the MIDI input on the Pico. This generates a gate signal and pitch voltage (on CV1) for the Moog Werkstatt-01.

The distance sensor’s analogue output is visualised by the Neopixel ring as well as sent to CV2, which I have connected to the Werkstatt’s LFO FM input. This allows me to control the speed of the LFO, which is in turn modulating the cutoff frequency of the bassline. Wobble ensues…

Finally, the output of the Werkstatt goes to a Korg Monotron Delay, which is used to further filter the bassline and to add a touch of delay.

The Hardware

Given the multitude of in- and outputs I decided to make a semi-permanent perfboard setup with headers for the Raspberry Pi Pico and the two MCP4725 DACs.

Since space was a bit too tight for an onboard MIDI socket I am using an external daughter board, connected via jumper wires, as are the calibration pot, distance sensor, gate output and Neopixel ring.

I have added a calibration pot to the setup, as the DACs’ output voltages are directly related to VBUS (i.e. the voltage of the USB supply), which is currently used as their reference voltage. In a future revision I may add a voltage regulator to power the project with a more stable 5v.

The two DACs are connected to I2C1 on the Pico and have the addresses 0x62 and 0x63 (by soldering a jumper on one the boards). For now I simply soldered a 3.5mm jack socket to the VOUT and GND pins of each of the DACs. Eventually I may add another header on the perfboard instead.

The eagle-eyed will have spotted that there are headers (and some of the wiring) for two more DAC modules to create a possible 4CV outputs. In order to use these a second I2C bus will be needed (I2C0 on the Pico).


  • Raspberry Pi Pico
  • A 3.3V MIDI interface, such as the one we built in part 1
  • 2x MCP4725 DAC module
  • Sharp GP2Y0A21YK0F infrared distance sensor
  • 100k potentiometer
  • 16 Neopixel ring
  • 3x 3.5mm jack sockets

Circuit Diagram

The Code

The code is written in MicroPython. Its external dependencies are:

I have set up the functions polling the calibration pot and distance sensor ADCs to be called by a timer each, running every 100ms and 50ms respectively. For now these are just arbitrary numbers that seemed to work ok and hopefully leave enough clock cycles for the midi note commands to be tight.

The calibration pot is set up to fine-tune the expected reference voltage, from 4.5V to 5.5V to compensate for slightly different input voltages (for example, my PC’s USB port only delivers around 4.95V, whereas my phone charger outputs 5.1V).

# A second CV out for the Raspberry Pi Pico MIDI to CV converter by @AxWax
# Demo: https://www.youtube.com/watch?v=aGfQHL1jU4I
# This is heavily based on and requires
# the SimpleMIDIDecoder library by @diyelectromusic, which can be found at
# https://diyelectromusic.wordpress.com/2021/06/13/raspberry-pi-pico-midi-channel-router/
# The NeoPixel code requires the pi_pico_neopixel library by Blaž Rolih
# which can be found at https://github.com/blaz-r/pi_pico_neopixel
# Wiring:
# serial midi input: GP13 (UART0 RX)
# neopixels: GP16, GND, 3.3v
# gate output: GP17
# calibration pot: GP26 (A0), GND, 3.3v
# distance sensor: GP27 (A1), 3.3V
# MCP4725 (CV1&2) Pico
# VCC: VBUS (5V)
# SDA: GP2
# SCL: GP3
# VOUT: CV output to synth
import machine
import time
import ustruct
import SimpleMIDIDecoder
from neopixel import Neopixel
# set up Neopixel ring
neopixel_count = 16
neopixel_pin = 16
strip = Neopixel(neopixel_count, 0, neopixel_pin, "GRB")
black = (0, 0, 0)
yellow = (255, 100, 0)
green = (0, 255, 0)
# set up global variables
calibration = 0 # calibration offset for reference voltage
lowest_note = 40 # which MIDI note number corresponds to 0V CV
old_num_pixels = 0 # previous number of neopixels shown
# set up analogue inputs
analog0_value = machine.ADC(26)
analog1_value = machine.ADC(27)
analog2_value = machine.ADC(28)
# set up gate pin
gate = machine.Pin(17, machine.Pin.OUT)
# set up I2C bus 1
i2c = machine.I2C(1, scl=scl, sda=sda, freq=400000)
# initialise serial MIDI ports
uart = machine.UART(0,31250,tx=machine.Pin(12),rx=machine.Pin(13)) # UART0 on pins 12,13
# timer callback functions:
# calibration
def check_calibration_pot(t):
global calibration
calibration = analog0_value.read_u16()
# distance sensor
def check_distance_sensor(t):
distance = analog1_value.read_u16() / 16
#convert to number from 0 – 16
numLEDs = 16 – int(distance / 256)
neopixelDraw(numLEDs, 10)
# set up timers
distance_timer = machine.Timer()
distance_timer.init (period = 50, mode = machine.Timer.PERIODIC, callback = check_distance_sensor)
calibration_timer = machine.Timer()
calibration_timer.init (period = 100, mode = machine.Timer.PERIODIC, callback = check_calibration_pot)
# draw to neopixel ring
def neopixelDraw (num_pixels, bright):
global old_num_pixels
# only redraw if the value has changed
if(num_pixels == old_num_pixels or num_pixels > neopixel_count):
old_num_pixels = num_pixels
# draw the pixels
if (num_pixels == 1):
elif (num_pixels > 1):
strip.set_pixel_line_gradient(0, num_pixels-1, green, yellow)
# DAC function
def writeToDac(value,addr):
buf[0]=(value >> 8) & 0xFF
buf[1]=value & 0xFF
# Calculate the control voltage
def noteToVoltage(note):
reference_voltage = (4.5 + (calibration / 65536)) # from 4.5V to 5.5V
mv = 4096 / reference_voltage / 1000 # value for one mV
semitone = 83.33 * mv # one semitone is 1V/12 = 83.33mV
dacV = int((note-lowest_note)*semitone)
return dacV
# output control voltage for note on CV1
def playNote(note):
dacV = noteToVoltage(note)
return dacV
# MIDI callback routines
def doMidiNoteOn(ch, cmd, note, vel):
dacV = playNote(note)
def doMidiNoteOff(ch, cmd, note, vel):
# initialise MIDI decoder and set up callbacks
md = SimpleMIDIDecoder.SimpleMIDIDecoder()
md.cbNoteOn (doMidiNoteOn)
md.cbNoteOff (doMidiNoteOff)
# the loop
while True:
# Check for MIDI messages
if (uart.any()):

The Future

Things I’d like to try next:

  • Add two more DACs to I2C0 to have 4 CV outputs in total.
  • MIDI CC control for the DACs.
  • Software-based LFO and/or envelope generator.
  • Pitch bend functionality.
Series NavigationRaspberry Pi Pico as MIDI to CV converter >>
  1. Raspberry Pi Pico as MIDI to CV converter
  2. A second CV out for the Raspberry Pi Pico MIDI to CV converter
Site created by AxWax and proudly powered by WordPress