Hello, I'm good afternoon, everyone. I am ASAP.
Currently, I will talk about building wireless media controller with LXI, ESP32 and ATOM3M.
So, Nanas is my own brand for my products.
So, I will introduce myself. Again, I'm ASAP.
I'm based in Tallinn, Estonia. My daily job is as a web developer and also I'm a product engineer.
Designing and manufacturing. You are back in modules and custom media controllers.
So, everything is under the plan of Nanas and this is just so away me.
So, I'm like a chief everything of itself, I'm so jumping from designing, coding, selling, packing, shipping.
So, the problem, why I create this traditional media user value use wired connector.
There is some solution also wireless media solution, but they are using Bluetooth, which is I don't want to use.
Because I want to create a media controller that can integrate with local network, my Wi-Fi local network.
And they are usually popular ecosystem. And also because I'm a web developer.
If I do the Wi-Fi embedded with CNC++, it feels really complex for me.
So, I think my brand cannot catch up with it. And it has to be using manual memory management.
So, it's really difficult to think about concurrency, like, what happened if one knob or a failure or any other things need to do.
So, I think it's really complex in the C++ for me.
And I usually coding web with LXL. So, I'm trying to find, searching the solution is there any possibility to run LXL in my controller like ESP32 and iPhone DMVM.
So, this is the solution that I create, I call it media mesh. It is open source design using ESP32.
And it has to be compatible with EuroRach hardware, meaning at least the power hender is the same.
So, I can put it on the rack of this in. So, that's why I create here using power hender.
But it can also be powered using battery pack like this. And it sends me the data of the Wi-Fi via UDP.
So, what is atom-fem? Actually, this is a subset of RLang-fem design for embedded system. The key feature is it has lightweight process.
And it has also a message passing between the process. And it can interface with GPI or I2C SPI and URT.
And, after this concurrency model, the program is able to write and understand. And this is the most important.
It's support Wi-Fi networking in ESP32, which is, I need it. And it's support with this platform. ESP32, STM32, Raspberry PPCO, UNIX, even wasm.
But, the threat of atom-fem is it has limited-lixer standard library. So, in the firmware itself, sometimes I had to call MLang library directly from a mixer.
And, this is the hardware that I use. C3, the CPU is RS532 bit with 400 kilobit of RAM, Wi-Fi.
And it has quite a decent IO, like 5 ADC and 10GPI, and the cost is really minimal, like 2 euros to 5 euros depends where you bought it.
And, the power option, it's using USB-C, the power header for a 5 volt, or you can use battery portable, like this.
And, this is the architecture of the MIDI mesh, the device. It has, for this POC, I have forlnot and 1-fader.
It's an MIDI via UDP to port for a thousand. And, I also had desktop receiver. It is like a small program running in CLI.
It is also written in LXL. It connects to the virtual MIDI port of the laptop. And, it also, it will listen from port for a thousand.
And, passing the MIDI data to DAO or to send software or to any thing that you wrote the MIDI from your laptop.
And, this is the module architecture. So, basically, there is a main application in the firmware.
And, I create a module like not module, Wi-Fi modules, which module and MIDI generation module, and some configuration.
And, basically, it's just an LXL module.
And, when I say about process based and concurrency, meaning every, every hardware, every thing in this hardware is just an LXL or an Erlang process.
So, basically, we have five independent process here. Like, FVNOP has their own Erlang process. And, FVNOP also same.
And, it, they are passing the message between the process to the main process.
FVNM is it passing. And, the clock itself is like 150 millisecond polling cycles. So, it will always reading the value.
And, this is how the laptop says looks like. When it is looping to reading the value of the potentiometer, it uses recursion.
And, we have pattern matching. So, it has a clean flow, we can follow the poetry really easily.
And, since LXL also immutable, there is no risk condition. And, the good thing is, because the atom VM is subset of Erlang VM.
So, it's process will fails independently. So, let's say, the laptop or the FVNM here fail. It won't make the system go down. It's just one process will fail.
And, this is about Wi-Fi and networking. It's support station mode and AP mode.
But, station mode basically, it will be a client connected to the access point or the device itself will be an access point.
For this demo, I am using this as an access point because I will just want to connect directly to this device.
And, originally, there is a switch to switch the operation between station mode and AP mode. But, I just took it off yesterday because it's too wobbly.
So, I just hugged it into an AP mode. But, actually, in the firmware, to read the station and AP mode, I am using again, it will have a easy to read with, and also, it has a clean state transition between the on and off between the mode.
And, this is the module for midi message generation. Basically, it will mapping the analog data, the raw ADC from potentiometer into a midi data from 0 to 127.
So, if in the future, I want to support midi to 0.0, it will just, I can map it also to midi to 0.0 value.
And, I am using the 10k potentiometer here, and every knob has their own CC mode.
I am hard-coded from CC 75 to CC 79 because it's a general proposed CC number.
And, to give the firmware and deploy it to the hardware, it's only using mixed tasks. So, mixed atom frame install will install the latest image of atom VM.
And, after that, we can use packed beam to compile the code into the firmware and just flash it using mixed flash.
I will demo the hardware after the slide finish, but basically, this is the overview of the demo.
A midi message, connect with the laptop via UDP and in access point mode.
And, I will control cardinal modular scenes, but I don't want to explain what is cardinal because we have talked about cardinal after this.
It will also demonstrate the low latency and how multiple knobs will do, and I will demo it with the device.
And, this is some exploration for the future, because this can be integrated with the Wi-Fi network.
It can be as a work as a distributed midi controller.
Like, imagine the controller not just to control the synthesizer or the software, but it can also control maybe stage lighting,
or maybe an artist can also be do a collaboration with the audience, making music together,
and doing multi-device synchronization, everything is possible here.
So, basically, from the experience building this, why I am using LXL, the pros is concurrency model with real time and also with the nature of hardware.
There's a lot of productivity, and the OTP patterns for reliability, and the challenge here is the smaller ecosystem.
LXL in embedded and atom-VM has smaller ecosystem, and the C++ are even micro-pitan, and need hardware specific niffs if needed.
And the takeaway here is functional programming is actually works on micro-controllers, beam process, naturally, to model embedded systems, atom-VM also brings LXL to IoT or hardware.
And wireless midi enables can be like enables new music applications, and it makes it accessible because I'm using Open hardware and Open software.
So, this is Samarisaurus.
The firmware itself, I host in GitHub, you can just go there, and there is a desktop receiver there, and the license is open source.
So, thank you, and we can do the demo.
So, this is, this one will control the mixer of this patch, where is the engine, oh yeah.
So, I'm starting, let's make something.
So, mix the channel one.
Now, I'm adding some scene.
And this one, for controlling the power of the oscillator.
And it's low latency.
Let's make it more interesting, adding the snails.
Like I said before, it can be like concurrent between the knobs and the fader.
Like I'm controlling this, together.
Let's add some delay.
So, everything is still like working in a real time.
Okay, so it's done.
Okay, but I cannot control the volume.
I will try to make it like, okay, I think this is fine.
Basically, it can control any software scene, but for this one, I'm using a little.
And imagine if we can control the scene together with the audience.
And you can also build some, like, it's modular, modular, maybe controller.
Making it as, let's say, like, a track channel of mixer, something like that, it's everything is possible.
So, yeah, does it talk for me and maybe we have any questions?
Thanks very nice to you.
Can you stop the music?
I will stop it.
Now you'll see why I want to do the music production, and we need something like this.
We have a few questions, I'll start from.
Thanks a lot, it's really nice to see.
I've also played in the past with ESP and doing media over Wi-Fi.
So, I was wondering, because you're using UDP, why you're not using RTP media, right?
Yeah, I'm not using RTP media, but in Atom, we have that I use.
There is no MD and S module yet for us, that's one.
And the second one is, I think, broadcasting is the simplest one here.
And you can disconnect everything.
Yeah, the nice thing with RTP media is that there's already a lot of standardized libraries to,
Yes.
Your laptop already has it built in, so you don't need to run an extra service, your discovery,
built in, etc.
And now, maybe 2.0, it has its own UDP stack, I think, or the limitation.
I think that's what I'll also, but maybe 2.0.
Do we have any other questions?
I'm just wondering of the use of UDP.
What happens if the packet cannot be received by the underside?
Because it's comparing the current value.
That means you can, you know, one value is not sent.
Yeah, it will just last, simply last.
But you can, since usually in the music, you are, you're always tweaking,
It's, and I'm glad that.
Okay.
We end one more question here.
Thank you very much for the presentation.
Regarding the future improvements that you are saying earlier,
I've heard about how five that could help working on multiple devices,
simultaneously over the same network.
I don't know.
If you already heard about it, and maybe talk about using it.
Yeah, I'm thinking about, like, having a multiple device, something like that.
It's possible.
We have one last question, and then we wish you presentation.
Okay.
Thank you.