Semi-modular hardware patch bay?

#1

Is it possible to wire up a semi-modular patch bay like many of Bastl Instruments' synths have?

Is this something that the GPIO ports can do, or would extra components be required? There's just something really fun about plugging stuff together physically rather than turning knobs on a controller.

Making axoloti an hardware patchable synth?
#2

I guess it would be possible, but you would need to ensure there is some protection on your pins, general rule of thumb is to not connect and disconnect connections from your GPIO's in order to avoid damaging them. And you would need to setup your patch with all possibilities so the connection can be read. You could probably set it up as though making the connection is switching it on, and maybe set it up in reverse, where the pin is always high until the connection is made sending it low, and switching on the action.
:thinking:

#3

It should be possible but you have to be aware that the number of in's and outs on the card is restricted. So you'd be quickly using up connections that you might also want to use for pots and such. The only solution to avoid those getting in the way would then be to edit everyhting else via the screen or use a MIDI controller feeding CC info into the program.

Another complication might be that you need to harmonize the signals. The Axoloti does after all not create voltages as such but produces these on the basis of calculated data (I suppose by putting the necesarry numbers into a DAC (Digital to Analog Convertor). Then these signals would have to be matched in a way that fits the typical Axoloti voltages. "All I/O is 3.3 V signaling" the website description of the core for instance states.

So I agree that it should be possible but do not expect straight out of the box interfacing with analog hardware. Furhtermore Axoloti only seems to have more then enough of everything when one is working with low processor power eating software objects. Everything else is often still doable but seldomly boundless.

To find out how to make it do things even the developers might not yet have thought about is howeverr part of the atraction.

#4

Patching in the Axoloti is static and cannot be changed at runtime.

In a few words:
With the graphical interface, on the PC or Mac, you connect modules, then the patch is compiled, all the connexions and modules are transformed into code with optimisations. This assembly code is uploaded to the Axoloti.
In the Axoloti, a "patch" is an actual program.

A software solution is to use multiplexers in the patch that could be changed live, much like routing switches found in the Arp Odyssey,

It is not necessary to have actual signals flowing in your hardware connections, what is essential is to detect the hardware connections in order to replicate them in software.

We can imagine a hardware interface that consist of connectors and wires.
With some scanning method it will be possible to detect what is connected to what.
The list of connections can control the software multiplexers in order to get the patch work conform to the hardware connections.

But well, i think that doing something similar to the Arp Odyssey routing switch can be a good start (not too complicated and can be a nice "proof of concept").

The routing switches are below the sliders, they allow to change the source corresponding to the slider, on the odyssey those are two position switches (the concept can be extended to more positions).

#5

With all the restrictions you have read already. still you can do a little bit.. For instance, in your "modular patch" having lfo's gates and triggers as outputs and having some inputs like additional filter modulation, extra note trigger, advance step in a sequencer, modulate pitch, modulate FM, etc.. Though, of course, most work it's done in Soft. Also, you should protect the inputs (and maybe outputs too )by adding some resistors, just in case..

#6

Dear Smasho,

This confuses me.

What I understood until now is that switching to live mode means that one sends the software to the Axoloti but that all th eknobs in the main screen can then still be controlled by either screen input , amnalog input or MIDI input. Of MIDI I am sure and Mathew Tyass's video tutorial seems to indicate that anlog input is also possible.

What you write however seems to imply is that one cannot tweak the software on the screen in the Live mode and at the same time do the same for assigned parameters via the analog and digital inputs on the card!

If that is right it would be a major bummer because that would automatically card-input-wise, lead to an OR situation in stead of an EITHER / OR situation, basically only leaving the possibility of combining the Live mode with a MIDI controller.

Is that right?

The rest what you say is basically what I already tried to describe. Axoloti wil not use the actual analog signals but interpret them by measuring them and convert them to the right binary code.

The in/output sheet seems to indicate only the PAS and PA4 board connections can be used as analog outs, thus at best leading to a bit of a lobsided situation of 13 analog inputs against only 2 outputs. Making the use of a hardware patchfield for the Axoloti itself rather unpractical indeed.

Well let's say it would indeed be rather akward to do external patching since everything can already be done wihtin the software. Which sort of brings me back to the conclusion that one can better use the analog inputs for other things.

But if one insists patching could still play a part, for instance by patching signals from an external modular system into the Axoloti, assuming the right voltages are fed in of course.

#7

The knobs, yes, they can be modified real time.

the interconnexions between the objects no.

#8

Interconnections could be done, but would be rather complicated within the patching environment given that it is not realy required.
For example, interconnections could be re-routed via mux / demux situation where plugging a connection into a certain GPIO pin would tell the mux / demux which value to apply and in turn re-route the interconection to your desired destination. But you would still need to find away to ensure both connections are correctly paired, More to consider. One may seem simple enough, but how would you apply many of them.

But it is it worth it to go to so much effort for the look of patching between options, if it is alot easier and uses less resources to just hit a switch of some sorts, maybe not. But this is the beauty of the Axo, we don't do it because its easy, we do it because we want to.
:grin:

#9

That's why I mentioned scanning.

In the scan process only one (digital) output is active at a time. And its interconnexions can be evaluated.

In fact, i imagine a process similar to a keyboard scan (including anti ghosting diodes).

#10

OK, then the rest still applies. Since a patchfield can provide similar input info as a set of knobs a patchfield should still be posisble within the confines I sketched. For an anlog inoput it will not make a difference if the incoming voltage is generated by changing a voltage via a variable resistor or via some other (external) means,as long as (one can not repeat it often enough) the voltage specs are kept in mind.

#11

I got to thinking that their might actually be quite a simple solution that does not take up too much resources, and a patch bay type scenario is just one of many that could easily be adapted. I am not Synth guy, so please bare with me.
The way I see it, just like in an object, we want to go from somewhere to somewhere, in this setup, you could go A to B, A to B to C, but not B to A, C to A or C to B.
In this example, lets focus on A to B.

In the Axo patch,
- B is a monopole dial connected to a midi CC value.
- A is a Midi Internal send object where the CC value is connected a value read from an analogue input pin.

In the hardware,
- Build an output port for B with Resistor / 3.3V / GND setup to create a unique analogue value sent out of port B, single wire only required.
- Build an input port for A connected to an analogue pin so the unique analogue value read will set the CC value on the midi internal send object to the same CC value set on the monopole dial that you want the values to go to.

The above describes a simple approach that could easily be expanded in a patch without too much impact on resources, not only that, it should work fine in live mode, might be a bit twitchy when connecting depending on the plugs you use, but I think what I like about it is, it could easily be extended to other styles without patch cords etc.. and it could easily be implemented between several Axo boards as well.

I am sure that are many ways the idea could be fine tuned, but there it is.
I hope I have explained it well enough to get the idea across.
:grin:

#12

Further thinking.. :thinking:
It could be setup in reverse.
Setup A to B,
- A Contains the specific CC value, sent via "Internal midi send", and output hardware.
- B instead has "Internal midi receive" and input hardware.
In this setup, it would mimic the Axo path setup in the patch, also allowing multiple outputs.
So if you had an LFO, you could send the same CC data to several inputs.
:grin:

#13

At this point, we should make some schematics...

#14

I wouldn't normally offer a schematic without knowing it works, as my skills in this area are limited.
So anyway, here is at least something that my show the direction I am going in.
Even though I have separated outputs in inputs, parts or portions of can be swapped when patched in objects, just as long as 2 outputs are not connected to each other.

Capture.PNG944x657 24 KB

#15

I understand better, it is much simpler that what i described.

On the inputs, you can guess which input is connected simply with its value.

I think you should add pull up resistors on the inputs so that +3v3 means "nothing connected".

#16

I don't think it would make much of a difference, I tried this setup n the Axo once before, the resistor ladder was connected to switches. I tried it because I was hoping it might filter out a spike that happened when the button was pressed, a falling edge trigger instead of the rising edge, but didn't work, but the spike never exceeded 3.3v on the analogue pin. To solve it, I had to apply a delay that would wait for the spike to disappear before reading the pin. I don't think it would be an issue if using patch cables.

#17

So each analog input will be reading a constant value based on how far down the "output" ladder it's patched to? Sounds like a good idea honestly. I feel like it's a bit inefficient though, even though we have 15 analog inputs. There must be a way to fit more in there while also leaving room for pots.

#18

There are a few ways to increase the analogue inputs.
You will find this post interesting reading.


And there are few more floating around to read.
But I would test a small version just in case I have missed anything, and to iron out the tweeks etc..
I think what has realy made this idea cool, is the internal midi that can be patched in so easily.

#19

First problem I haven't considered is linking an audio line.
The patch does it perfectly with the red s-rate link, but I highly doubt there is any value sending audio data down an internal midi line.

So what is the alternative,
I have thought of replacing the internal midi objects with a custom object.
Inputs from the pins to read the analogue value.
Inputs for signal origin.
Outputs that link to signal destination.
The difference in this object, the analogue value read would link the signal destination to the signal origin.
Example..
Analogue read A, B, C, D
Origin input iA, iB, iC, iD
Destination output o1, o2, o3, o4

  • If value at B = 3, Destination output o3 will be connected to Origin input iB.
    And so on etc..

And different objects could be created to encompass S-rate, K-rate and bool where needed.

:thinking:

#20

The other advantage an object like this would offer, if you swapped out the analogue read pins for midi input values, you could control this with an external midi controller.

So who makes midi controllers that look like patch bays ?.. I don't know, my knowledge of synths is very limited, only what I have learnt on this forum.. :stuck_out_tongue_winking_eye:

I guess you could make it yourself. Just like any other diy midi controller with different hardware. By applying the analogue read concept in this post, should be pretty straight forward.

Why am I so fascinated with this idea... because it replaces the need for a display of sorts to know what's connected etc.. all the cable will tell you what is connected to what.
:sunglasses: