a jumperless (solderless) breadboard

Public Chat
Similar projects worth following
Using a bunch of analog crosspoint switches wired together into one bigger switch, Jumperless makes real, fully analog hardware connections between any points on the board or the Arduino Nano header at the top via serial, instead of needing to use jumper wires.

Jumperless also has a ton of voltage/current sensing so the RGB LEDs underneath each row can show a ton of information about what's going on with your circuit. It has 2 buffered DACs (0-5V and ±8V), 4 buffered 12-bit ADCs (3 are 0-5V and 1 for ±8V), 2 INA219 current/voltage sensor ICs, and 5 GPIO that can be routed to anywhere on the breadboard or the Nano header.

Use it to probe the pins on an unknown IC, or for some automated fuzzing, or to read/write EEPROM chips, or to help guide you through converting a schematic to a real circuit, or do whatever the hell you want with it.


The connections are real and fully analog (-8V to +8V, up to around 1 MHz before signal quality starts to degrade) instead of cheating with some measure-then-simulate setup, although you can do that too if you want to simulate a memristor or to send jumpers over the internet.

Currently, the best way to make connections is using Wokwi while running the Jumperless Wokwi Bridge app on your computer. It's a Python script and command line interface that automatically pulls any changes you make to your Wokwi project and sends them to the Jumperless.

Here's a video of me connecting an OLED display to an Arduino

It also passes through all the serial communications to and from the Jumperless so you can use the text-based menus to do things like running the wave generators, measuring current/voltage, and looking debug output on the Jumperless directly at the same time.

Pretty soon there will be an Arduino Library where you can make connections and measure stuff with an API that will look something like jumperless.connect(row1, row2); or jumperless.measureVoltage(row); that can either be run on the Arduino Nano (sending commands via UART to the RP2040) or the Jumperless itself.

Hopefully this will allow people to write cool stuff for the Jumperless to do that I haven't even thought of and wouldn't be possible on a regular breadboard.

Also there will be a Python Module that does the same stuff as above, which can either be run in an onboard MicroPython interpreter or on a computer.

Here's another video of me using the Jumperless to figure out the pinout of an LED matrix. I'm actually not faking it in this video, I couldn't find a datasheet.

Firmware and stuff

The Jumperless is controlled by an RP2040 and can be programmed exactly like a Raspberry Pi Pico. I spend every waking second of my life working on the firmware so there will be frequent updates. There are prebuilt UF2 files on Github under Releases, so whenever there's an update, just hold the USB BOOT button while plugging it into your computer (with the included pink glittery USB Mini cable,) then drag that UF2 file into the drive that pops up and you're good to go.

The whole thing is open source so you can also edit/fix the firmware however you like (and please submit a pull request on Github to share your fixes)

DACs and Revisions

Currently, the ones available are Revision 2, the only major difference between Rev 2 and the soon-to-be-available Rev 3 are the Digital Analog Converters. If you're an audio person that might want to use this thing as a eurorack module or something involving generating audio, I recommend you wait for Rev 3 to be available in a couple weeks. Here's why:

Revision 2 uses 2 MCP4728 12-bit I2C DACs, which work great for setting voltages to be used as an adjustable power supply, but I2C isn't fast enough to send clean waveforms above ~100Hz.

Revision 3 DAC
This is the DAC (on Rev 3) and current sensor circuits

Revision 3 now uses a single MCP4822 2 channel SPI DAC, which is fast enough to make waveforms well above 400KHz. So you could feasibly use the onboard DAC as a Max8 or plugData output, and route the audio output to the breadboard and mess with it in hardware and even send it back in as an input. The software to do that hasn't been written yet but with the upcoming Python Module and Arduino API, it shouldn't be too difficult pull off.

Both of these revisions have their DACs buffered through an LM272D High Power (1A) op amp. Obviously 1 amp would blow this thing up, the power supplies couldn't handle it, and it would go way over the current limit for the crosspoint switches. But the outputs of the buffered analog voltages are broken out to pads in the top corner, so you could drive a smallish speaker directly form that if you wanted to.

The +-8V DAC output is hardwired to one of the 2 INA219 current/voltage sensors so you can always see how much current is being drawn. The other INA219 is...

Read more »

Adobe Portable Document Format - 13.80 MB - 08/24/2023 at 00:08


JPEG Image - 1.41 MB - 07/26/2023 at 20:27


JPEG Image - 1.15 MB - 07/26/2023 at 20:27


JPEG Image - 1.01 MB - 07/26/2023 at 20:27


JPEG Image - 549.06 kB - 07/26/2023 at 20:27


View all 21 files

  • 12 × CH446Q 8x16 Analog Crosspoint Switch
  • 1 × RP2040 Microcontroller
  • 2 × INA219 Power Management ICs / Power Supply Support
  • 1 × MCP4822 Data Converters / Digital to Analog Converters (DACs)
  • 2 × LM324 Amplifier and Linear ICs / Operational Amplifiers

View all 33 components

  • Doom and Some Other Less-Trivial Demos

    Kevin Santo Cappuccioa day ago 0 comments

    A lot of these shots will be cut into the Hackaday Prize entry video, but I'm gonna post them here anyway so I don't feel like I've wasted time making these if I decide some of them don't fit.

    Doom Over a Jumperless

    Doom is the most click-baity demo you can do. And I support it (even though I suck at actually playing Doom)

    Someone on Twitter asked if the crosspoint switches would interfere with fast data signals. The answer is no, they won't, they're rated to 50MHz at 3dB rolloff. The physical breadboard will have a much larger effect at those frequencies, so if it works on a regular breadboard, it should work on a Jumperless (wrt frequency, current and voltage have their own limits). 

    This is the awesome project doom-nano which is stripped down enough to run on an ATMEGA328P at ~15 fps. Note that the enemies don't die when I shoot them, that hasn't been implemented yet.

    The nerd-sniper who got me actually was asking about SPI displays, I didn't have a Arduino Nano ESP32 at the time, but I will today (thanks Amazon). So expect a demo of real doom running on a color display soon. 

    16x2 LCD

    And my video light Fuck mask gets its time in the spotlight.

    Making this one revealed a bug in the routing code here it wasn't checking the other end of the "bounces" in certain arrangements. So yeah, 2 days of debugging for a 22 second video, that's approaching Kubrick's shooting-to-runtime ratio.

    Some 7400-Series Logic Stuff

    Here I threw together a random logic circuit with the chips I had laying around, and used a 555 as the clock source. Near the end, I take out the 555 and use the Jumperless's DAC making a square wave as the clock. Which might be useful if you're building just part of something and you don't want to screw around with the clock source.

    There's a simple text-based wave generator menu that I'm using to control the frequency and stuff. It looks like this.

    On the Wokwi project I had a potentiometer connected to the blue clock line, that's what tells the Jumperless that I want a DAC connected there.

    This is the same circuit again:

    Magic Flames Released

    This is the silly intro shot, same circuit as above (and part of it is redundant).

    Obviously, circuits don't blow up like that when you cut one wire. So let's look behind the curtain and see what I did 

    It's cigarette filter wrapped in NiChrome wire and submersed in a foil tray filled with vape juice hidden behind the breadboard then hooked up to a big 12V lead-acid battery when I wanted it to go off. I'm actually just cutting the 5V power in the video.

    This is what it looked like afterwards 


    I also tried just cutting 2 jumpers connected to the leads of the lead-acid battery, but the sparks weren't dramatic enough and too quick to be shot on video. 

    Another attempt was made by emptying out the powder from a bullet and igniting it, but modern smokeless powder is, well, smokeless. Like really surprisingly so. I even mixed it with sugar and Ammonium Dichromate but it never really looked right. So vape juice it was!

    Crosspoint Superzoom

    This is just to give people a but of an understanding of what's going on inside a crosspoint switch. Not really a demo, but it was made so people understand that the Jumpeless isn't reading and simulating your signals, just passing them through an analog CMOS switch.

    If you want to play with that crosspoint demo in Falstad, here's the link to that circuit.

    And the transistor-level analog CMOS switch is here.

    Rail Selector Switch

    This is a fun little shot of the supply rails being switched in stop motion. 

    Anyway, I think that's all the video I have for now. But stay tuned for the Hackaday Prize entry video where I cut all this together and talk at you.

  • Getting Started Using Your Jumperless

    Kevin Santo Cappuccio09/06/2023 at 17:26 0 comments

    Cool, so you have this super sexy object now. How do turn it into an actual prototyping tool? The answer is software.

    After you've unboxed (and maybe assembled) your Jumperless, we're going to need a way to talk to it. 

    Now, the Jumperless is very open and will accept netlists from any program with some basic formatting, if you hate Wokwi and want to use something else, this project log should give you an idea of what format it accepts over serial so you can write your own Bridge to any software you like. But for now, I'm focusing on Wokwi because I think it's better to have solid support for one workflow than shitty support for a bunch.

    First, we need to download the App and latest firmware here.

    Updating The Firmware

    I ship these with the latest firmware installed, so if you just received your Jumperless in the mail, you can skip the firmware update. But I usually push minor fixes to that firmware.uf2 file every few days, so it's probably worth doing anyway.

    On your Jumperless, there will be a little button on the opposite side of the USB port. This is the USB Boot button and works exactly the same as a Raspberry Pi Pico.  

    1. Hold the USB Boot button and plug the Jumperless into your computer. 

    2. A drive should pop up called RPI-RP2. Drag the firmware.uf2 file into it and it should reset and you're done!

    Installing the App

    I'm showing this on a fresh install of macOS, but Windows should be roughly the same.

    1. On the releases page, download (or the .exe for windows) and firmware.uf2

    2. It should automatically unzip in your downloads folder. Note that this won't run correctly from anywhere but your Applications folder, so drag it there.

    3. Click it to try to run it. Unless you've set your security setting to allow apps from anywhere, it's going to complain.

    4. Click Cancel and go to  Settings > Privacy and Security > scroll down and click Open Anyway

    5. It's going to complain again and just click Open

    Hot tip: run 

    sudo spctl --master-disable

    in Terminal to give you another checkbox for Anywhere under Settings > Privacy and Security > Allow Apps From. And you won't have to go through this again for other shoddy software.

    6. If everything goes well, you should now be presented with a Terminal window like this

    Note that on MacOS, it should just autodetect and connect to the Jumperless if it's plugged in when you start the app, if not, just plug it in and type 'r' to rescan the ports until it finds it. 

    Okay, now the app is set up, what do we paste into there to connect to our Wokwi project?

    Getting Wokwi Set Up

    You'll need a stable link to your Wokwi project, and it will only make one when you're signed in and have saved your project to "My Projects". After that the links are saved in a text file in the JumperlessWokwiBridge app and you'll be able to select projects you've used before from a list.

    1. Go to Screenshot 2023-09-05 at 2.53.39 PM
    2. Click Sign Up/Sign In and enter your email (or use Google or Github) Screenshot 2023-09-05 at 2.54.14 PM
    3. Click the link they email you to sign in Screenshot 2023-09-05 at 2.54.36 PM
      Screenshot 2023-09-05 at 2.54.57 PM
    4. Click Go To Your Projects, then New Project > Arduino Nano Screenshot 2023-09-05 at 2.55.08 PM
      Screenshot 2023-09-05 at 2.55.13 PM
      Screenshot 2023-09-05 at 2.55.20 PM
    5. Click Save and give your project a name Screenshot 2023-09-05 at 2.55.38 PM
      Screenshot 2023-09-05 at 2.55.47 PM (note that the URL has now changed to a unique link)
    6. Click blue “+” (top center) to Add New Part and scroll down to Half Breadboard and click it Screenshot 2023-09-05 at 3.10.47 PM
      Screenshot 2023-09-05 at 3.11.02 PM  It will put it somewhere random, so click somewhere that’s not a hole to drag it. Screenshot 2023-09-05 at 3.11.07 PM
    7. Open the JumperlessWokwiBridge App and resize the windows so you can see both Screenshot 2023-09-05 at 2.56.14 PM
      Screenshot 2023-09-05 at 2.58.03 PM(on mac it will autodetect the port if it’s plugged in, on windows you’ll need to select the COM port here first, if the Jumperless wasn’t connected when you opened the app, press ‘r’ the Enter to rescan the ports)
    8. Copy the URL of the Wokwi project you just made Screenshot 2023-09-05 at 2.58.12 PM
    9. Paste that URL into the Bridge App window and press Enter Screenshot 2023-09-05 at 2.58.29 PM
      Screenshot 2023-09-05 at 2.58.34 PM
    10. Name the project and hit Enter (it will save the link so next time you’ll only need to choose it from...
    Read more »

  • Ṭ̴̯̿̂h̶̫̏̀ę̵̙̒ ̷̩̉C̴̖̞̀͝ọ̵̬̎̔ḓ̵̓e̸̥̞̓̓ part 4 - Picking Colors and Putting Them On Your Retinas

    Kevin Santo Cappuccio09/04/2023 at 18:00 1 comment

    Table of Contents  (bolded ones are in this project log)

    • General terms - the names I've decided to call things
    • What's being stored - how the overall state is stored
    • Pathfinding - how we find valid paths for each connection
    • Controlling the switches - how we send that data to the CH446Qs
    • LEDs - how we choose unique colors for each net
    • The Wokwi bridge app - how we scrape the Wokwi page for updates

    If you're wondering why you feel a strange sexual attraction to this board, I can give you a hint...

    I didn't want to do the LEDs at first because it seemed a bit out-of-scope. But after using the prototype board without them, I found that it involved a lot of counting rows to find where you're connecting things. And that gets pretty tedious. 

    Around the same time, I had ended my month-long search for anyone who sells just the metal spring clips from a breadboard and resigned to having custom spring clips made by Shenzhen Fulimei Technology Co. LTD. 

    Hot tip for makers that want a bunch of some thing custom made using a non-so-common process: put your drawings and requirements up on, you'll get a ton of quotes within days and just pick your favorite. 

    I'm glad I did, because using this thing is sooo much smoother now, you really only have to look at the board for the first connection and then everything else can just be counted as an offset from there. Also, the new versions of the breadboard shell have every 5th embossed number raised (which is actually super weird on breadboards because they count from 1, so there's 3 holes between 1 and 5, and 4 holes between the rest, enjoy being bothered by that forever) which makes it even easier to locate where you're connecting stuff.

    How the colors are chosen

    It would be really cool if the colors would correspond to the colors in the Wokwi diagram, but there's a couple of problems with that.


    All the wires default to green, and having to select a unique color for each wire is kind of a pain in the current version of Wokwi. I know they'll eventually work on something to change this, but their voting system of which features they should work on next shows it's a fairly low priority.

    The other issue is this:

    Currently, they only support 15 HTML colors. So having only 15 different possible nets with unique colors (fewer, because black, grey, and brown wouldn't really show up on RGBs)

    So we're just gonna pick our own colors.

    The special nets have hard-coded colors, they are as follows:

      rgbColor specialNetColors[8] = {      
      {00, 00, 00},
       {0x00, 0xFF, 0x30},    //GND     - Green 
       {0xFF, 0x41, 0x14},    //5V     - Red leaning towards orange {0xFF, 0x10, 0x40},    //3.3v    - Red leaning towards purple 
       {0xeF, 0x78, 0x7a},    //DAC 0-5V- Pinkish White  (changes brightness and hue based on output magnitude) 
       {0xeF, 0x40, 0x7f},    //DAC +-8V- Purplish White (changes brightness based on output magnitude, hue for positive or negative) 
       {0xFF, 0xff, 0xff},    //Current Sense+ - Yellow 
       {0xff, 0xFF, 0xff}};   //Current Sense- - Blue 
       rgbColor railColors[4] = { 
        {0xFF, 0x32, 0x30},    //GND - Green 
        {0x00, 0xFF, 0x30},    //5V - Red 
        {0xFF, 0x32, 0x30},    //GND - Green 
        {0x00, 0xFF, 0x30}};   //5V - Red

    Here's what those look like:

    Note the bottom rail is 3.3V, top rail is 5V. pot1-sig is DAC 0, pot2-sig is DAC1.

    The colors are saved at full brightness and scaled down to the default brightness or the brightness you set in the menu when they're displayed.

    For the other nets, here's the general algorithm:

    • Get the number of unique nets and divide that by 255 (that's the full color wheel in the NeoPixel Library) to get a color distance
    • Check if the hue at (color distance * 1) is the too close to any of the special nets
      • If it is, add 1 to the number of unique nets and calculate a new color distance, then try again with an offset (color distance/2)
    • If not, set that hue for the net and check the next net at (color distance * 2) etc...

    Here's how...

    Read more »

  • Ṭ̴̯̿̂h̶̫̏̀ę̵̙̒ ̷̩̉C̴̖̞̀͝ọ̵̬̎̔ḓ̵̓e̸̥̞̓̓ part 3 - Driving the CH446Qs

    Kevin Santo Cappuccio08/30/2023 at 03:14 0 comments

    Table of Contents  (bolded ones are in this project log)

    • General terms - the names I've decided to call things
    • What's being stored - how the overall state is stored
    • File Parsing - how we fill in those arrays
    • Pathfinding - how we find valid paths for each connection
    • Controlling the crosspoint switches - how we send that data to the CH446Qs
    • LEDs - how we choose unique colors for each net
    • The Wokwi bridge app - how we scrape the Wokwi page for updates

    Controlling the Crosspoint Switches

    What crosspoint switches crave

    Okay, so now we have all our paths filled out with what chips need to have which X and Y inputs connected to make the magic happen.

    The CH446Qs are basically clones of the MT8816, except for one important difference, they accept serial addressing. The datasheet is kinda vague about how, but it turns out it's just a kinda weird version of SPI. 

    Basically, all the chips see the same data signal, and whichever one sees a pulse on the STB when the last bit comes in will connect or disconnect the selected X and Y inputs. The state of the DAT line when the Strobe comes in determines whether it's connecting or disconnecting. That stretched out clock line shows that it doesn't care about real time, which comes in handy.

    PIO State Machine

    So I have to do something that's kinda like SPI but not quite, this looks like a job for the RP2040 PIO State Machines.

    Even knowing assembly, the learning curve for writing a PIO program is steep. The documentation is really hit-or-miss, the examples are uncommented and written like they're playing code golf, insanely terse. Like these people do realize you can name variables after what they do, right? And these are the Official examples in the datasheet. Anyway after a few days of staring at what looks like gibberish, it starts to click.

    I copied the SPI.pio example and edited it from there. Let me try to explain some of the things I learned to hopefully make it easier for you to write a PIO program in the future. 

    I'm just compiling this with the online pioasm compiler and then pasting the compiled code into spi.pio.h

    Here's where we are:

    ;this is basically spi but it sets a system IRQ on the last bit to allow the chip select pulse to happen
    .program spi_ch446_multi_cs
    .side_set 1
        out pins, 1        side 0x0 [2]
        nop                side 0x1 [2]
        jmp x-- bitloop    side 0x1
        out pins, 1        side 0x1
        mov x, y           side 0x1
        irq  0             side 0x1
        wait 0 irq 0 rel   side 0x1
        jmp !osre bitloop  side 0x0
    public entry_point:                 ; Must set X,Y to n-2 before starting!
        pull ifempty       side 0x0 [1] ; Block with CSn high (minimum 2 cycles)
        nop                side 0x0 [1]; CSn front porch

    What wasn't explained well is what the hell a sideset pin is. Basically you do your normal-ish assembly code on the left, and then each operation also affects the sideset pin on the right. It's kind of a hack to allow you to control 2 pins in a single clock cycle. In this case, the sideset pin is attached to the CLK, and pins, 1 is DAT.

    So, whats going on is that in the regular code, I'm sending a byte to the sm register with this line

    pio_sm_put(pio, sm, chAddress);

    (the last bit of chAddress is set to 1 or 0 depending if I want to connect or disconnect)

    and that pull ifempty will pull in a byte to the working register and send it out one bit at a time while toggling the clock. When it's out of data to send, it triggers a system interrupt request that can be seen outside of the PIO state machine and I deal with it in an ISR in CH446Q.cpp

    At this point, here's where we are in the timing diagram:

    Now we need to select the correct CS line to make the right chip make the connection

    void isrFromPio(void)
      switch (chipSelect)
      case CHIP_A:
        digitalWriteFast(CS_A, HIGH);
      case CHIP_B:
        digitalWriteFast(CS_B, HIGH);
      case CHIP_C:
        digitalWriteFast(CS_C, HIGH);
      case CHIP_D:
    Read more »

  • Ṭ̴̯̿̂h̶̫̏̀ę̵̙̒ ̷̩̉C̴̖̞̀͝ọ̵̬̎̔ḓ̵̓e̸̥̞̓̓ part 2 - Pathfinding

    Kevin Santo Cappuccio08/25/2023 at 01:37 0 comments

    Table of Contents  (bolded ones are in this project log)

    • General terms - the names I've decided to call things
    • What's being stored - how the overall state is stored
    • File Parsing - how we fill in those arrays
    • Pathfinding - how we find valid paths for each connection
    • Controlling the crosspoint switches - how we send that data to the CH446Qs
    • LEDs - how we choose unique colors for each net
    • The Wokwi bridge app - how we scrape the Wokwi page for updates


    This is the really tricky part. I probably wrote all this code about 4 times, trashed it and started over from scratch with only the lessons learned from the last attempt. Earlier versions would add connections one at a time, but you'd end up in weird states because it has no knowledge of what other paths it needs to make room for. So the final version here clears the connections from the last update, takes in all the connections to be made, and finds paths for the whole board every time you add a new wire. All the old connections usually follow the same paths as last time unless they need to be nudged over to make room for some other path, and the actual connection won't be interrupted at all.

    Untitled Here's the schematic of just the crosspoints, the Nano header, and the breadboard.

    If you look closely, you'll see that there generally 2 connections (I'm calling these 2 connections Lanes between each breadboard chip, except for the chip that is across from it on the breadboard. And every breadboard chip has one connection to each of the special function chips. The pins on the Nano header has a connection to 2 special function chips (interleaved to make it easier to connect continuous pairs of pins to the breadboard).

    Here's the high level outline of what NetsToChipConnections.cpp is doing

    • Sorts all the paths by Net This sort of sets priority, lower net numbers (so all the special function nets) will be picked first and are more likely to have direct connections chosen
    • For each path, find the start and end chips
      • If there are multiple candidates (Nano header pins will have 2) store both
      • If both start and end chips have candidates in common, choose that chip (this would make it a bounce)
      • Assign node and path types (BB to BB, NANO to BB, BB to SF, etc...)
      • Sort a list of chips from least to most crowded (by how many connections that chip has used)
      • Resolve the candidate chips by going down the sorted list of chips and picking the less crowded chip
      • Search for a direct path between those 2 chips
        • If there isn't one, swap to the other candidate chips and search again
        • If one of the nodes is a special function with multiple options swap the nodes with their equivalents and search again
        • If there still isn't a direct path, set the altPathNeeded flag and move on At this point, any paths that have a simple direct connection should be done, now we need to deal with the ones that don't
    • Resolve alt paths, if the altPathNeeded flag is set
      • Search through all the other chips until you find one that has a direct connection to both the start and end chips
        • If one chip is connected to the X inputs and the other the Y inputs, set that connection on chip[2] and x[2] y[2]
        • If they're both on X or both on Y, set the sameChip flag and the x[3] or y[3] as -2 to denote that that connection is a bounce and it doesn't matter which pin is chosen, as long as it's available
    • Resolve uncommitted hops, anything set as -2 gets a random unconnected pin assigned to it at the very end so it doesn't take up connection space

    There's a lot more subtlety to this but if I go into any more detail you might as well just read the code itself. It will all be in the file NetsToChipConnections.cpp, and if you're running it on a Jumperless or just an RP2040, you can set the Chip Connections and Chip Connections Alt debug flags and it will show you everything it's doing in a somewhat nicely formatted way. There are comments in the code but there are a lot of nested array things that can get pretty confusing, if...

    Read more »

  • Ṭ̴̯̿̂h̶̫̏̀ę̵̙̒ ̷̩̉C̴̖̞̀͝ọ̵̬̎̔ḓ̵̓e̸̥̞̓̓

    Kevin Santo Cappuccio08/18/2023 at 18:11 0 comments

    I'm going to do a high-level explanation of what the code in the Jumperless is actually doing. There's a lot going on and it's in a bunch of separate files so I think it will be helpful for people who what to understand or improve upon it.

    Table of Contents  (bolded ones are in this project log)

    • General terms - the names I've decided to call things
    • What's being stored - how the overall state is stored
    • File Parsing - how we fill in those arrays
    • Pathfinding - how we find valid paths for each connection
    • Controlling the crosspoint switches - how we send that data to the CH446Qs
    • LEDs - how we choose unique colors for each net
    • The Wokwi bridge app - how we scrape the Wokwi page for updates

    This is going to be really long and so I'll be filling out parts as I finish them in no particular order.

    General terms

    I've made up terms for things here that may or may not be the formal definition, so I should probably let you know what I chose.

    Breadboard Chips - This refers to the 8 CH446Q crosspoint switches (labeled A-H) that have their Y pins connected to the breadboard. This excludes Chip L which actually has it's X pins connected to the 4 corners of the board (rows 1, 30, 31 (b1), 60 (b30))

    Special Function Chips - This refers to the 4 crosspoints (labeled I-L) that connect to everything else; the Nano header, power supplies, DACs, GPIO from the RP2040, etc...


    Nodes - Also used synonymously with Row especially when it's on the breadboard or Nano Header. And end point to a bridge

    Bridges - Just 2 nodes that should be connected

    Nets - Groups of nodes and bridges that should all be electrically connected to each other

    Bounce - Sometimes there won't be an available path directly from one node to another, so in this case it will pick another chip with a free path to the start and end chips and "bounce" through it.

    Paths - Similar to a bridge, except that it contains data for how that bridge is connected. So it will have which chips and which X and X pins are needed to make the connection


    You'll see a lot of these, they're all in JumperlessDefinesRP2040.h. But the point of this whole this is so you don't have to dig through the code, so I'll put the abridged version here:

    #define CHIP_A 0
    #define CHIP_L 11
    #define t1  1
    #define t30 30
    #define b1  31
    #define b30 60
    #define NANO_D0  70 //these are completely arbitrary
    #define NANO_A7  93
    #define GND  100 #define SUPPLY_3V3  103
    #define SUPPLY_5V  105
    #define DAC0_5V  106 #define DAC1_8V  107
    #define CURRENT_SENSE_PLUS  108
    #define CURRENT_SENSE_MINUS  109
    #define ADC0_5V 110
    #define ADC1_5V 111
    #define ADC2_5V 112
    #define ADC3_8V 113
    #define EMPTY_NET 127

    What's being stored

    There are a few big arrays of structs that store the overall state of everything. Here are the main ones:


    This stores the actual hardware layout of each of the 12 crosspoint switches, like what is physically connected where and whether that path is being used. In the code it's and array called ch[12] and it's in MatrixStateRP2040.h

    //the struct
    struct chipStatus{
    int chipNumber;
    char chipChar;
    int8_t xStatus[16]; //store the bb row or nano conn this is eventually connected to so they can be stacked if conns are redundant
    int8_t yStatus[8];  //store the row/nano it's connected to
    const int8_t xMap[16];
    const int8_t yMap[8];
    //the array of those structs
    struct chipStatus ch[12] = {  {0,'A',  {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}, // x status  {-1,-1,-1,-1,-1,-1,-1,-1}, //y status  {CHIP_I, CHIP_J, CHIP_B, CHIP_B, CHIP_C, CHIP_C, CHIP_D, CHIP_D, CHIP_E, CHIP_K, CHIP_F, CHIP_F, CHIP_G, CHIP_G, CHIP_H, CHIP_H},//X MAP constant  {CHIP_L,  t2,t3, t4, t5, t6, t7, t8}},  // Y MAP constant
    ... {10,'K', {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}, // x status {-1,-1,-1,-1,-1,-1,-1,-1}, //y status {NANO_A0, NANO_A1, NANO_A2, NANO_A3, NANO_D2, NANO_D3, NANO_D4, NANO_D5,...
    Read more »

  • Boxes within shirts within boxes

    Kevin Santo Cappuccio07/26/2023 at 20:58 9 comments

    Edit - this is me from the future. The new boxes got here and this is what they look like in real life:


    It turns out the cardboard from Ponoko is a pain to fold. I have to cut it halfway through, peel off half the thickness, coat the entire thing in clear paint, then bend it while it's still sort of wet for it to keep it's shape.

    I'll put up photos of that whole process soon. But in the future I'll probably use a better material for this.

    I did order a Matte cutter to help with this, but it isn't here yet so I came up with a super ghetto solution that works surprisingly well. 

    Super gluing a craft knife blade to 3D printed cube I had laying around. I taped a piece of the cardboard to the bottom before gluing to set the depth. I can just drag it along a ruler and it cuts to the right depth. Probably should have thought of this before spending $40 on effectively the same thing.

    Okay now back to the past....

    So this is me kind of procrastinating, but I've designed an inner case to keep the Jumperless nice and cozy inside it's box. I figured instead of using disposable packing materials, I'd have some shirts made and use them instead of bubble wrap.

    But having the Jumperless just loose in that shirt looks kinda ghetto to me.

    So I needed a smaller box to actually keep it safe wrapped up in that shirt that still leaves room for the other stuff. So this full foam cutout wasn't gonna cut it. 

    Originally it was just going to be 2 squares of cardboard with foam around it, but when I was ordering the cardboard and foam cutouts from Ponoko, I noticed they really only charge by the area of material, the actual cuts only seem to affect the cost by a few percent.

    I also kinda felt like this logo wasn't getting enough love.

    So I designed this box which should also serve as a storage case for people who like to keep their things in boxes.

    The cool thing is how it (hopefully) stays shut. This oval at the top should slot into the cutout at the bottom, and there should be enough friction and foldiness to keep it closed. 

    We'll see. 

    I should do a writeup on my failed attempts to use my 3018 cheapy CNC machine to hot wire cut foam. But now that Ponoko will cut foam for you, I decided to leave that to the pros.

    Anyway, here's a simulated experience of opening a Jumperless now

    **Angelic noises**

View all 7 project logs

  • 1
    If you get a Jumperless Kit (or order your own boards with SMD parts assembled)

    The assembly is pretty easy, it's all through hole stuff.

    Here's a montage of all the steps to give an overview of what you'll be doing

    If you've gone through the trouble of ordering your own boards and everything, I'd be happy to send you a free set of spring clips, which is the only part with a huge minimum order quantity and having them made was a whole thing.

    Your kit will come in ~7 parts:

    • Main board (all the SMD stuff assembled) 
    • LED “wishbone” board (the LEDs around the header that shine through the board) 
    • 2 x 15 pin female headers
    • Plastic breadboard shell
    • 80 x breadboard spring clips
    • 1 x LT1054 in 8 pin DIP
    • 4 x Sticky-backed rubber feet

    I also include some:

    • sandpaper
    • masking tape
    • ~4 feet of solder.

    The reason I'm including solder is that when you're just starting out with electronics you think soldering is hard. It isn't, you've just been using crappy solder and no one told you how big of a difference it makes. So I include ~4 feet of Kester Sn63Pb37 0.8mm Type 44 solder, also known as, "the good shit."

    The only things you'll need to provide yourself won't be consumed in the process, you can have them back when you're done:

    • A soldering iron
    • an Arduino Nano (or something with the same footprint to keep the headers aligned while soldering)
    • 80 pins worth of .1" male headers. You need these to stick in the breadboard while soldering to make sure all the clips stay perfectly straight, if you don't have enough, just stick anything (DIP chips, Arduino Nanos, whatever) into all the holes and that should work fine.
    • some Isopropyl alcohol or flux remover spray (okay I guess this does get used up)

    If you're the kind of person like me who wants to constantly test your board while you assemble it, you can load this LEDtesterFirmware.uf2 (just click Download Raw File) onto your Jumperless (scroll to the bottom for a guide on that). This firmware will just constantly run LEDbounce(); so you can make sure all the LEDs are working. It will look like this:

    Let's begin!

    - Carefully snap of the edge rails from the LED wishbone board. Put the V-cut on the edge of a table and slowly bend it until it breaks off. 

    - Use the 300 grit sandpaper lightly on the tops of the LEDs on the main board to diffuse the light a bit, you don't need to do this on the reverse-mounted "wishbone" board. You can use masking tape so you don't accidentally sand the board for aesthetic reasons (but there are very few traces on the top layer and you shouldn't be sanding hard enough to break a trace.)

    When you're finished the LEDs should look like this (before is on the left)

    - Put the spring clips into the breadboard shell first and make sure they're all pushed all the way in. Then gently put that onto the main PCB, it may take some careful wiggling to coax all the tabs on the spring clips to go into their holes. If you can't get it seated, take it off and check that they're all straight and in a nice row. If some are giving you trouble, bend it back or swap it out (I have included extras.)

    - Stick pin headers into every row of the breadboard and leave them in for soldering. Put them in one hole from the center hole. This makes sure that all the clips are perfectly aligned.

    - Solder all the clips, it works best to use a large soldering iron tip and start from the middle on each row. The breadboard will expand slightly as it gets warm so I try to account for that by making sure it expands evenly from the center. 

    - Be careful not to short any of the pins on the CH446Qs, if you do, use some desoldering braid to get it off. It's a good idea to double check this because it can cause some really confusing behavior (ask me how I know, it was actually the exact board you see here because I was trying to solder without getting my head in the shot).

    - Place the LT1054 into the footprint between the headers, on the front side of the board. Pin 1 is the bottom left (the square pad) so the notch on the chip should be towards the big yellow capacitors.

    - Stick an Arduino Nano in the top headers while you solder them so they stay straight, before doing anything with the wishbone LED board. And wiggle it around to find the nicest looking position (the holes are slightly bigger than the pins so you can wiggle it ~0.5mm) if you're a total perfectionist like me. Then solder it in.

    - You'll want to clean off the flux before you put on the wishbone board so there isn't any flux between the LEDs and the PCB. I like to shatter it all by dragging pokey tweezers over it, brush it off, and then use alcohol swabs or MG Chemicals Super Wash spray (this stuff is an absolute game changer, I recommend getting a can)

    - For the wishbone board, solder the 2 inner ground pins directly to the backside of the female header pins that are sticking through. Make sure the LEDs lay flat to the main board.

    - Stick the 3 other header pins through the wishbone board just far enough that they're flush on the top of the main board. If you stick the short side of the header pin up to the plastic, it turns out that is the perfect length. Tape the headers down so they don't fall out when you flip the board. Solder from the front of the main board first so it's just a flat spot of solder. Now cut the header pins flush before soldering. None of this is strictly necessary, but it leaves the board looking really nice instead of having soldered-then-cut poky headers.

    - Clean off all the flux like you did above.

    - Peel and stick the rubber feet, 2 on the bottom, 1 by the GPIO headers, and 1 just under the logo on the back. If it's a bit wobbly, a small amount of heat will soften the one giving you issues, then press it onto a flat surface until the wobbliness is gone.

    - You can load the firmware by plugging it in with the USB Boot button held and dragging the .uf2 file from here into the drive that pops up as RPI-RP2

    And your Jumperless should be good to go!

View all instructions

Enjoy this project?



anfractuosity wrote 08/25/2023 at 19:44 point

Such a cool idea :) I'd not heard of those analogue switches before either

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates