 Wow thanks for showing up here. I like to present you a project. It came out after doing many one-off projects, so in a way it's like an attempt to make the ultimate framework. But first let's have a look at what people in DIY audio are doing. When you look around here and people do audio they make analog circuits or they modify existing circuits called circuit bending like you have to speak and spell they modify it and two different things or they make MIDI controllers as an extension of their laptop to have a new way to control it. That's our really nice one. We did MIDI controller yesterday around here and then there is people doing sound with 8-bit microcontrollers I mean like going like sort of hybrid topology making like digital pulses from software and using the pulses as sound and then there is real embedded digital single processing that means you're not dealing with just pulses but accurate measurements and time domain processing in a digital world that could create just any waveform not limited to square waves or chiptunes. There's very few digital single processing in DIY happening because it needs quite a setup. This is what digital single processing is about so you have sound inputs you convert it from analog from a continuous waveform to digital numbers at certain at the regular time intervals and then you have a processor which runs some sort of software can be controlled from MIDI or from the front panel with knobs and dials and at some point it can go back to analog sound. A computer can do this actually very well. There's lots of software around open source close source for every taste and it's sort of crowded in this field so there's software synthesizer that emulates old analog machines or new things that were impossible to recreate to create with analog machines. It's very crowded. Apparently if you go to a music instrument store there's still a lot of dedicated hardware. People like to play a dedicated instrument because it's plug-and-play you just turn it on and it always works. It's not designed for office work and it will not show you email notifications. It's really quite distracting if you do a jam session with friends and you work with laptops often something that sort of pops up or you updated something and you start like testing things rather than playing. So I designed some hardware. That is exactly this analog to digital converter and digital to analog and a processor. So you see like stereo input stereo output, headphone jack, a USB port for computer connection, a slot for SD card and MIDI inputs, MIDI outputs. It's like it's very similar as what is inside the things you can buy in a music instrument store because if you would take these things apart you will see that the inside is sort of similar. It just makes a lot of products differentiated by the shape, the number of knobs and the color of the plastic and the firmware running on it. And I didn't do the knobs and the plastic. So there's front side connectors and then on the back end there is like general purpose inputs and outputs that allow you to connect almost anything. A bit similar like Arduino. It's really not limited to knobs and dials. You can also do servo motors or accelerometers or lights and series, whatever you can think of. It's more like circuit bending as a goal than as an afterthought or as a not. So to get this thing talking we need to develop some digital single processing firmware that breaks apart sort of in an audio input-output driver, a MIDI input-output driver, other input outputs for front panel knobs and dials. And then you make any combination of digital single processing algorithms like oscillators, filters, envelopes and then you have to map the parameters to control it somehow and some bookkeeping to load new presets or things. It's not the first time that open source embedded ESP solutions have been developed. But they didn't really reach critical mass. I think programming DSP can be sort of complex. There is not mathematics involved. For example you have to make trade-offs between execution speed and quality. For instance the standard CMAT library is for sort of limited use. It's made for mathematical precision and sometimes you really want to go much faster than that. It's not because you could edit or add DSP algorithms to firmware that someone will do so. Now I'm going to make a little switch to what's out there in software, in pure software without going to hardware. There is several data flow oriented programming languages. The open source, the main open source one is pure data. So there's a program where you select objects, you put them on the screen, you configure them and you put wires between inputs and outputs and this turns into a program. You document as a program, so it's a sort of programming language. There's a commercial friend called Max and they have a similar syntax and grammar. The nice thing about graphical programming is that you don't need to, you can't make errors against syntax or grammar because you choose your objects. You don't have to really type code. You can only make errors against logic. The punishment of making an error is much smaller. You don't get a compiler saying like I don't understand that. It will just do something and it's up to you to make it to the right thing. So with this low punishment of experiments it's very accessible to artists and musicians. So around both languages there is quite a field of, quite a community of artists developing all sort of things. It's a graphical programming language. It's not, I wouldn't say it's a complete graphic, it's not a complete programming language. I wouldn't implement a quick sort in any of these by patching things around. That really gets awkward. But single processing is really about regular data, regular intervals and then the execution part of the code is really boring. It's really linear. Both environments depend on objects already are loaded as dynamic loaded libraries. So at runtime it needs to dispatch function calls from to DLLs. Which implies a huge overhead if an object just needs to add to inputs together. So the processor needs to make an indirect jump, save the context, add and then restore the context. While this probably could have been one instruction in optimal code. So let's try to make editing firmware similarly as easy as possible. So I wanted to make a graphical dataflow programming environment for firmware that does not expose command line tools, does not expose C++ code unless you would want to and ease in the compile, upload and run cycle. So that was the first version of the sort of the architecture. So on your computer you would run a program, the axlotypatcher. This one has like a library of objects you could put on the screen, wire them up and now the software would generate code, compile it and upload it. And then this is the axlotycore, that's the board. Yeah, we have the camera at the wrong place. Could someone put the camera over here? So after uploading you have the axlotycore program to the right firmware, you can do sound IO, MIDI IO and turn on purpose IO and after flashing you just turn it on and you can play. I'll give a little demo of that, just so it is the patcher environment. So this is an empty document and I double click I get the object library. I have like a linear catalog, an alphabetic catalog of objects. We also have like a hierarchy of categories which makes it easier to search. You can also start typing a name until like find the best match. So I start with, as an example, with saututwafe. This selects saututwafe oscillator, saututwafe is like a linear ramp, periodically repeated. So let's have a look at the anatomy of this object. It has like an input on the left. The blue color is a data type. This means it's from modulation, control voltage. Like it's for slow changes, not suitable for audio quality, but good enough for changes over time. And then there is a red data type, an output on the right. Both have indication plus minus means that they're like bipolar. And then there's a dial where you can adjust the frequency. I tried to make it as user-friendly as possible. So at the zero position it would give a certain value in hertz. Musicians want to read the name of the note. That's one click away and you also get the factor compared to the middle value. So if I would put the dial on at 12, I can just type 12, you see that the ratio is times two. So 12 semitones in music corresponds with a double frequency. And at the same time you can also wonder if with seven semitones corresponds with almost one and a half, which almost directly shows how harmony works in music. So to listen to the oscillator, I have to add... I take a volume control just to be safe with the sound system. I have a multiply object here, multiply with a constant. So this is a dial to adjust the constant. But I created a blue object, I mean blue input, blue output. But similar like you have function overloading in C++, this object will upgrade to a red one. Because it sees, oh, you give me red input and there is a red implementation of this object as well. And then I can wire that to the output what you out, stir you dial it up. So the first version was this, you press a button and it will generate C++ code and it would be uploaded to the target. And if everything works, can you turn the volume up a bit? Oh, I unplugged something. Turn it down first, please, the external input. Okay, so here you see that you already get a working system. I'm actually jumping in my presentation. Because version one was just you make a chart with your program and it would run that. Version two was about making the changes interactive. So after generating C++ code, compiling it doing the upload, make it also instrumented that you can change parameters on the fly. So that you don't need to go to recompile and re-upload cycle for just adjusting a number. And it also goes the other way around. So you see two level meters here that will also read back from the code and show you the actual volume level. So no critical audio computation is going on on my laptop. It's the firmware that is compiled and uploaded that is talking with the user interface after it's running. Okay, we have a little loss later and I can turn this very easily into a music keyboard. If I take a keyboard object and the keyboard object has an output for the note that's being played and there's a gate output that will indicate when a key is pressed or not. It's very similar in reasoning as old, well they still made analog synthesizers, analog model synthesizers. You have like machines where you have like, it's a bit similar to this but every every object is like a circuit and you interconnect them with patch cables. To grow up to a playable thing I have to modify the volume depending on the gate. The yellow cable type is a bullion on or off but that also can convert into a blue one. That doesn't need to be a substitution object that has a yellow input because there's a conversion rule from yellow to blue. So I turn that on and I take a virtual keyboard. Oh volume is still at zero. So we have a playable system. I thought five objects would be a better minimum to get a playable system. But it can grow quite a bit. Let's go into, I'll take a little organ patch, organ, organ, organ. Just like a sort of, one of the problems if you want to play music you don't want to be limited to one key because well some instruments do for some instruments it's reasonable but for an organ it's not reasonable. But if you want to express that in a patch it's sort of awkward. If you would have to wire up 12 or 16 different oscillators and parts for if you want to play different keys. So I made a way to use one document as an object into another one. So actually this object comes from this patch. This document has like magic objects. It's called an outlet object that represents an output on the generated object that corresponds with it. Also here there's a little, the red output and inside it just uses a keyboard object like I showed in the beginning. So that's the child patch. And then on top I asked, now give me 12 voices of that and just arrange it. But I also wanted to show that inside this object some parameters have like an attribute. It's called parameter on parent. So the parameters with this flag set there are promoted to the object corresponding with the inside object. So that's 12 voices of a certain architecture to play one organ pipe or something. So this is just a matter of combining elements and adding objects to the library up to currently I think there's over 400 objects serving different purposes. And it seems to be that's like the critical minimum, critical minimum sort of being reached that you can start doing stuff without having to write another object for a certain purpose. Let me show you something that if you're used to Arduino or things that might give it a different look. What I did on this setup is wire a potentiometer to analog input. So it's just a regular voltage divider. So yeah, like this. So it takes power supply, ground and fits that into the potentiometer and gets back the analog input. So instead of an Arduino people learn to write like a function call called analog read. In my environment is called GPIO in slash analog. And I select the channel where it is connected to. And in Arduino people learn how to print numbers to a console and read the numbers that fly over there. Here I can have a little chart plotter or a dial or or a numerical readout. No, it's already in the dial. I don't need that. So I turn it up. You see it's instrumented. You don't have to watch the flying numbers. You can just fly the oscilloscope on screen. So I think that's more, that's quite a bit more learnable than writing the same thing in C and getting a terminal with numbers flying by. In the same world you can also do PWM to drive a stepper motor or dim LEDs or to SPI or I2C. As a final demo I take a bit of, well I'm not really, I'm not really a musician, although I sometimes enjoy playing something. So on top there is like a little, this is a metronome, a square wave generated at one at five hertz. That means 240 bpm and it's divided in steps. So it's not really 240 bpm. And then like a counter that counts to 16. If the counter does a carry, it does not count. That will count to four. When that does a carry, also something else will happen. And then there are steps and patterns and oscillators and generators and stuff. But at all I would like to make a modification to this document, otherwise it's so boring. I take this GPIO in analog objects and I have like this little two-channel mixer to recombine influences. Quickly, no I just skip the analog inputs just for the time and I press live. And so there is like a drum machine and an hi-hat and a bass line. These are no samples, no samples involved, it's just all algorithms. That means you have a lot of flexibility. It's a very nice demo. I'm afraid we don't have time for questions and answers right now, but if you're interested in Johannes' work then just come up to him right after the talk and maybe find a place to meet somewhere. So please give him a round of applause.