Good morning people, welcome!
So we are officially starting the embedded Devroom 2025.
So this year there is a small change, so my main co-host is this year World Minor, giving
the warm welcome.
So the previous co-host is still with us, he is still in the community, but he is now leading
the Android Devroom, so I encourage you to visit that Devroom as well.
My name is Chris, I work for a company named NET, who manufactures the video conferencing
equipment.
Yeah, my name is Walt Miner, I work for automotive grade Linux and the Linux Foundation as
the community manager there.
So we hope that you have a great time, although this year we have a small room with no
windows, but that means that the density of knowledge is going to be higher.
Test test?
Okay, yeah.
So good morning, my name is Manolis from the US Space Foundation, first time on the embedded
track, I was mainly in Walt with radio stuff, but this year we jumped to the embedded.
Today I will present you the Saturn's Combs, which is this board, it's a kit that
will come in case in board that is suitable for kit missions.
So how many of you are familiar with the Saturn's?
Okay, keep people here.
So in the nutshell, Saturn's is perhaps the biggest project of free space foundation,
it's a network of ground stations that follow a modular setup based on software-ifying
radio, their purpose is to receive and demodulate and decode satellite signals, and then
post the telemetry data to our cloud infrastructures to for visualizing and getting them.
The entire stock is open hardware and open source, and the telemetry results are also
published with open licenses.
So right now, we cover mainly the VHSF and UHSF bands, we have a few stations for railbunt
and as a bunch, and we are responding to our next one too.
So having that experience from the ground stations, that we have around 400, if I recall correctly
around the world, we wanted to expand to the space segment.
So together with these are, which go found, we go found the project Saturn's comes,
which is a receiver with two dedicated interface, one for the UHSF and one for the S-bunt.
It based on the S-DM headed to H7, a microcontroller and has also a Zinc FPGA for doing DSP.
So we use the FPGA as a compressor, let's say.
It's suitable for low-weth orbit Gibbs atomizations up to 600 kilometers, and the entire stock
is open source and upper hardware.
Right from the design phase of the project, everything is open and you can go and check
the development process, the decision making, why it's just that part of the fire, not the
other and all that stuff.
Everything is there and you can go and follow the story, let's say.
One unique feature of this transmitter that we provide seamless integration with Saturn's,
so if you get this transceiver on your satellite, you have the guarantee that you can use
any of the Saturn stations to get your data.
So this is the transceiver of the bottom side, the top side as it starts right now on the
latest version, 0.3.2.
And we are very, very proud that we, for the development of this project, only open source
tools were used.
So for the, for the hardware design we use a kick-up, for the similar simulations we use
a Cooks, ZFRTOS, for the main MCU, we try to also use a latex for the FPGA staff.
We haven't done yet with great success, but we are going to, we are planning to do this.
So regarding the added capabilities, we mainly, as I said before, we cover the huge FNS
bond, mainly the commercial bonds, but upon request, we can tune the system and provide
also the amateur radio bonds.
At the x power it's quite high, in terms of, of the needs of cube set missions and it has
a great resolution of 1 dB.
One thing that is that we are very proud of, I know that you don't understand, maybe so
if you don't understand, but we have put a lot of effort to minimize the noise, the noise
figure of the system, which currently stands for 1.4 dB, which is super impressive.
So just to have an idea, this is the UHF, the UHF front end, on the bottom side you can
say the transmission path, which is actually very simple with a power amplifier and an analog
amplifier to cut off and kind of want the missions.
And on the upper side, it's the receiving path, which is much more complicated, because
we implement on board a hardware mechanism for automatic gain control.
So this is the H1 path, quite similar approach with the UHF, but with the MNS, the
difference, because the transceiver module that we use, the transceiver IC that we use,
doesn't support the commercial asment bugs.
We have an RF mixer that down converts or up converts the frequency to the target one that
so we can receive the singles.
Of course, actually communication board, it provides some interfaces for the satellite to connect
with other subsystems on board.
So we have two can, one SPI, one I square c, three yards, one equivalent, that goes
to the zinc FPGA, two antenna deployment mechanisms, and all these are available through
the PC 104 connector, the big one connector, that is quite standard in the Kibserti
industry right now.
So the board itself has already flown in space, so we, we've flown in, we fly in this with
Ariane 6, with a maiden flight of Ariane 6, back in July, on board the Kirium 1 satellite.
Unfortunately, things didn't go well, it didn't go so well, and for many days, we didn't receive anything
from the satellite, and then we have some good friends, Cisbasa and Tamoyan, that actually
have access to this small antenna, 25 mm this, and we pointed this to the satellite, and eventually
this doesn't, it doesn't, it doesn't, it's not so visible, but eventually we find out that
the, the board was active and it was transmitting, so after doing some analysis and getting
scratches from a telemetry, we identified that they would of course was that the antennas didn't
deploy, so yeah, it was a successful failure, let's say.
So our next big issue is the phasma, which is right now perhaps the biggest ongoing project
free space, phasma is a two, two, three YouTube satellite, so we will launch two satellites,
one of the other, to do spectrum monitoring from from orbit, okay, so to identify the spectrum
occupancy from orbit, so we will use two satellites, on its satellite, one for the on board
computer and communication subsystem, and one to do the actual spectrum monitoring, so this
mission is correct to be launched on this October, so yeah, the interesting stuff right now,
so what about the software, so we have decided, because we need, we envision that this board
will be available for other teams to to use it and as, as the communication subsystem, so we,
we, we, we said that we, we should implement it, implement it as, as abstract as possible,
so we use zefiartos as our main artist for the firmware, but someone else will perhaps like to
to implement it on freeartos or whatever arthos slikes, so for this reason we completely
are structured, the hardware control from the main logic of the firmware, so we implement the
lip settings comes, which sees an abstract class that controls the hardware components, interacts
with a hardware and they have the value sensor at the board has, and with this interface, someone
can implement the logic of a satellite without having to re-implement everything for scraps,
so to do that, we decided to use C++ and more specifically the 17 version of the standard,
and designed the the lip settings comes as an abstract class using which pure virtual methods,
so with this way, if someone was to implement it, the logic on different arthos, for example,
it is has to implement only the pure virtual methods that are provided by the platform,
which actually corresponds to hardware specific stuff, so for example, this example of the GPIO,
there is a pure virtual method called enable or get, so this has between only this method
should be implemented by the user, and this of course, many mice, the effort of integration
or whatever, so I thought about zf, and a good question will be, why is zf, okay, so
it is more than sexy, we all know that, it has a huge community,
it uses C-make, which someone may like, someone not, but C-make makes things much more easier, and modular,
and at least for me, it uses device-free, and I know please don't suit me, device-free,
about a device-free, but I have few slides later on, so we can discuss.
Why not Linux? Good question, but at that point, we were not sure that the STM-87 could cope with this.
Only DSP stuff, this is our second processing stuff, again on zinc hustling, but because the zinc,
if you enable the zinc, it consumes at least a what of power, you don't want to have it continuously running,
so you enable the zinc at the specific time, you want, okay, so regarding the zf,
we use a lot of modular stuff, so even if you don't fly a satellite, you can still use this project,
as an example, to take some code snippets, let's say, from one of the available modules,
that we use, as you say, the majority of the difficulty, like modules like the LFS,
the executive place, with MCBoot are there, so go get some ideas.
So, with the guy in the advisory, yeah, so there is a book, advisory for dummies,
I'm just kidding, there isn't. So, yeah, advisory, it's a pain in the ass, okay, you all know that,
but for our case, it was a game changer, because we could, you know, every mission of this
gives a mission, it's a bit different, it requires different IO, requires different interfaces,
so we didn't want to pollute the code base with a different, with different branches,
mission x, mission y, mission blah, blah, so we decided to use extensively the advisory,
in order to support all these different configurations, and we are quite proud, because right now,
we, doesn't, yeah, we support right now 34, if I call correctly, different hardware configurations,
with zero code modification, you just use the overlay that we provide, the orange combination
of overlays, and you have it. So, yeah, advisory for us was super, super, super nice.
Okay, hand, the other point, I mentioned about C++, and some argue, okay, C++, I'm a bit
skeptical, you should, to my opinion, you should, so C++ provides better code organizations
through polymer fees, of course, it can provide much safer abstraction layers, oppose to the
weak or function pointers, so if you, if you forget to implement a weak function, you will not
get any kind of compiler error, okay, you'll know that. On contrary, on pure virtual methods,
if you don't provide the implementation of pure virtual method, you will get a directly
a compilation error, okay, so at compile time, you know that you have done something wrong,
and another very interesting idiom is the right resource allocation is also in the
realization, which you can do very nice stuff in order to gracefully clean up whatever, whatever
steps of your code, or your program, if something occurs, so for example, if an error occurs and
an exception of race, for example, if you have implemented correctly the right and do the proper
stuff in the constructor, you are sure that everything will go well, so very, very nice example,
it's a critical section, so if you enter the critical section, you have to disable the interrupts,
and when you leave it, you have to enable it. If you, if you go with the if the nulls away,
it is very, very easy to forget to enable the interrupts, but with the right idiom, it's not an issue.
Another interesting point is that you can minimize the use of pointers, so we have tried a lot
in Saturn's conflict, we have a few pointers still, but the majority of the code uses references,
and this is another option, another compile time check, if you don't initialize the reference,
you get a compile lesson here, templates, of course, we all hate them, but we all like them,
and another nice feature of the recent standards is the concept expression, so you can do a lot
of stuff with concept expression and do compile time checks or compile time code execution with
context expression, so this another interesting feature of the language itself, and the last one
to note this, exceptions, so how many of you use the exceptions from your projects on a bad
device is one, two, three, okay, so let's talk about the challenges, which is plus plus, so
a big challenge is that the standard to play the language, standard to play the area for
plus plus, is use dynamic memory, so the majority of the components of the STL gives dynamic memory
location, for space, this is a no-go period, okay, another thing of the language is the
artistic Y, random type, random type information, which is actually dynamic cast or type ID,
if you are familiar with C++, so this we can live with this without this, so you can disable
by providing to the compiler the appropriate option, and because it produces very advanced
fitness, but for exceptions we know that the also produce larger fitness, but not so large,
for our case, because we are on the space domain, we can afford, I'll say, a more expensive
micro-controller with larger plus, so for our case at least this was not an issue,
okay, we talk about dynamic memory location with STL, so why to use C++, if I know that
the majority of the containers of the STL use dynamic memory are the case, so a solution could
be not use STL or write C++, but of course this defeats the purpose of using C++,
and very clever guy, he comes in and says he will implement a hip manager,
no, yes, of course not, okay, we have the issue of fragmentation, but we have ETL CPP,
how many of you know the ETL, those were used the exceptions, okay, so ETL is a fantastic
and provides the ETL, provides the STL with fixed memory model, okay, the memory,
the memory requirements of each container, it's it's not combined, so I strongly suggest
go check the library and use it on your projects, and now we come back to the discussion about
exceptions, so unfortunately in the keeps at the main, we don't have, we don't, we are not so
lucky as these guys in 1984 that went out there and serviced satellite, we will ignore it,
so the software itself should be able to identify and kind of errors at a cure, at runtime,
recover program and also log them, so this is super critical for satellite software,
and as I said we use exceptions, and we have a unified, we have a unified
error handling and logging system that logs any kind of exception plus errors at a cure at
runtime and logs in different 40 different buckets, SWO, we have a ring buffer, we can store them
also on the on board the precision storage and on the bugs backup SRAM, so our exceptions have
four different five different civic levels and based on the civic level of the exception
we take different actions, so for example, I square C is a well known buggy
communication protocol, while in space because it's a very successful with noise,
so we know that I square C transactions may fail, so we assign to such an exception
a low security level, while on the radio staff that is super critical for us, we assign a higher
level, so depending on where the exception occurs, this is called snippet to the exception
for exception handling, based on this weight of the exception, we have different strategies to mitigate
them, one strategy could be just to solve it, the other one could be this catastrophic exception,
I should reboot this at light, the subsystem itself, okay, and then you will argue that hey,
I know that exceptions are bad because they not only produce larger films, but also they are slow,
correct, good, exceptions are slow when the cure only, and I have some code snippets
that proves that, so we should think that exception is something rare to cure, we are not the
other developers, okay, so in our case we should design the software like the exception occurs rare,
and if occurs, okay, yeah, I'm willing to pay the price of the slower execution of the exception,
because I know that occurs one percent of the time, more or less, even less, so exceptions provide
so many goodies that is very hard to to to to meet them, so if you have to take something from
this presentation, please use exceptions, okay, so that's all from my side, you can find us on
matrix, you can find whatever we discussed here on our GitLab repositories, and we have also a
booth, so if you want to talk more about exceptions or whatever, please comment, give us a visit, okay,
thank you.
Thank you for a great talk, unfortunately we don't have a time for questions, but you can
catch the speaker, maybe in the corridor.