It looks like Pure Data is open source but what about the Organelle software itself? Is the source available?
No, I mean the software that operates the Organelle hardware like the keyboard, knobs, buttons, and sound generation hardware. I realize that the OS itself is open source.
That’s all pd and scripts for linux check the “mother.pd” file when you run it
Cool. Seems like an interesting device. I don’t have one yet but I’m certainly tempted.
There is some really fun stuff going on for organelle thats for sure.
Everything from FM to Spectral
Are there any people here who are extending the Organelle software with C or C++ or is everything being done with Pure Data?
And another probably silly question but why doesn’t the Organelle have 25 keys? It seems kind of odd to leave out the high C key. Most two-octave keyboards have 25 keys.
LADSPA is DSP code written in C/C++ and loaded into Pd with the plugin~ external
Is there a non-graphical music language for the Organelle?
ok, so pure data is what I would call the ‘patchers interface’ into organelle…
but given your talking about C++/open source, I’m guessing your more a developer, so perhaps want the ‘less simplified view’
to understand the software layer, we first need to talk about hardware layers
pots, encoders ,keyboard switches and lcd are all connected to an MCU (STM32F0? , need to check that).
this MCU is then connected to a SOC (solid run , see other threads) via a serial link.
so the MCU encodes/decodes serial messages to communicate with the hardware and the SOC.
this software is open source, Organelle_Controller, but you would need to open the organelle to re-program it… this is no issues, since its very generic, so is not needed.
the SOC, has the Arm CPU, codec, usb etc… and runs an appropriate arch linux build for the SOC.
also on start up its runs the ‘mother host’ (aka Organelle_UI) written in C++,
its listens for OSC messages about the LCD, and coverts these, and sends then via serial line to the MCU. it also listens on the serial lines for msgs re pots/keys etc, and broadcasts these via OSC.
mother hosts, also provides the ‘user menu’ the users sees, and so also launches pure data when the user selects a patch.
on the pure data side, as Patrick said, there is a mother.pd patch loaded alongside the user patch which converts to/from OSC messages to pure data ‘send/recieve’
(for audio , the SOC provides a standard audio interface which is interfaced directly via alsa)
phews… so back to the original question.
yes, all the software above is open source, and available on the C&G GitHub repo.
which is great, because it means Ive been able to contribute to development of the ‘mother host’
as I mentioned, you could reprogram the MCU, but really there is nothing to be gained there, and other users would not be able to do it.
you could entirely replace the ‘mother host’ with your own dedicated process, written in C++, or whatever. which would talk to the MCU (and so hardware) via the serial line.
the mother host, can launch arbitrary scripts, which could of course include applications written in C++, so again no pure data involved.
has anyone done it, not to my knowledge… but I think that’s as much to do with ‘target audience’ as anything else.
Personally, I’ve got a lot of plans/projects , one does include native synths/fx native that don’t use pure data (so I can avoid the PD overhead) … but its one of many projects Ive got underway, so might be a little while yet before it sees the light of day.
I think organelle is a great platform… I think it excels, when things are written specifically for it… which can be optimised for its hardware. (rather than ports of things designed for PCs - which will tend to be a compromise)
some might read the above and think, all seems simple enough, they could implement this on a rPI, and they would be right , theoretically, if they have the skill set .
but are also missing some key elements
- its quite a bit of work, to actually create the above, and make it work seamlessly together
- a common form factor (# encoders, lcd) etc, whilst provides limits, it also provides a target platform, so patchers can target this… i.e. we can share patches
without this commonality, everyone has to write their own ‘instrument’, which is exactly what you see on the rPI… a few hackers build great things, but not something a community can be built around.
sorry, that went probably a bit off-topic.
I’m an enthusiastic developer in this area, I also build things with Axoloti, Bela and rPI (each has its pros/cons)
so was really intrigued with Organelle, and even though I could build a similar system (on any of the aforementioned platforms) - I’m ever more certain, Organelle is ‘more than a sum of its parts’… which I guess is why when I describe its part, I feel the need to express how great the ‘sum’ is
you could build supercollider for it… or any of the others that run on the linux
(look for something that runs on a PI, to guage if there is enough processing power etc)
not sure of the answer for that, C&G would need to say.
my guess would be either due to physical space, or perhaps due to the number of GPIO on the MCU.
I guess things will be muxed, but still there’s a limit of gpio on the mcu, and also more mux = more circuitry/complexity … id need to check the organelle_controller code to see how its arranged.
Wow! Thanks for all of the detailed information. I’ll check out the C&G GitHub repository.
Is there a hardware block diagram for the Organelle? It sounds like there is an ARM MCU running Linux as well as another processor (also an ARM?) that acts as the “sound card” and that the communications between the two use a serial connection. Is that correct? Is there a block diagram available?
not as far as I’m aware… it should be noted, that whilst the software is open source, the hardware is not.
… so what Ive worked out, has either been kindly supplied by C&G or by looking at Linux OS and the code.
once you get an Organelle , you will be able to quickly probe the OS, to see whats going on.
an MCU don’t (usually) run operating systems, they are embedded control units, so just native code to poll IO etc.
Linux runs on the SOC (system on a chip) , which also has the codec.
This is a pretty common configuration for this kind of solution - DIYers often uses arduino/teensy connected to PIs etc for similar reasons.
(a few reasons for mcu, e.g. jitter, analog gpio)
Whats your interest in all of this?
I’m an embedded programmer who is also interested in music. I like the all-in-one nature of the Organelle although I guess making a MIDI synthesis box with a RaspberryPi plus an add-on board would be okay as well. Even if I eventually want to go that route, it seems like starting with the Organelle would be easier than diving into hardware and device driver design right off the bat. While there are a number of music-related projects I’m interested in, one that I might start with is writing an emulator for the old Triadex Muse. I realize it is a pretty simplistic approach to algorithmic composition but it’s kind of a classic piece of hardware that I will probably never be able to add to my collection so an emulation might be as close as I get. The programability and open source nature of the Organelle is the main thing that attracts me to it. Are all of Critter&Guitari products open source? I seem to remember they had a solder kit ages ago that is no longer available. I’d love to find one of those.
Linux runs on the SOC (system on a chip) , which also has the codec.
Any idea what SOC is in use? I assume it has “sound card” hardware that is supported by ALSA.
not meaning to mess up tech talk but for the keys of course you can just set an octave doubler/divider to span the traditional 88
Yes, I realize that. You can also connect an external keyboard. As I said in my original post, it isn’t a deal breaker. I just thought it was odd.
To get back to the internals part of this thread, does anyone have a description of the Organelle internals? What kind of SOC? What kind of MCU? What kind of sound hardware?
As the hardware design is not open source, I think you should direct these to C&G directly.
( they have little impact on the programming or use of organelle).
Well, I had this idea that I wanted to create a non-graphical language for programming the Organelle but now that I’ve looked at Pure Data a bit I think it I will just try working with that for the time being maybe adding a few new features rather than trying to move in a totally different direction. I’m still interested in learning more about what is inside the Organelle. Has anyone ever disassembled one? Any pictures of the internals?