So, I know everyone, so I'm Everest, my course I need a 5-0-0.
I work with the Pito-SDR from maybe 6 years now, just curious how many people on Pito-SDR
here.
Okay, right.
Okay, so this presentation is the presentation about what could be an autonomous SDR, which is based
on the same architecture of Pito-SDR.
So just to get back to the basics, generally you use an SDR, like a peripheral.
You can plug it through USB, network, PCA Express, and all the processing is generally done
on the PC, and so you need to install software, depending on your operating system,
on your PC.
So for example, here is a SDR++ client.
The idea here is to have something which is more autonomous, which made that it's not just
an SDR, which is a 9-Q, like with the senior gateway, but try to get it like just a one-machine,
which is something which has to do some job, but you don't want to interact all the time,
and the main process is done on the SDR itself.
So if you want to interact with this, you just have to get a diagnostic viewer, which
means generally a web browser, which works on every platform, even on the telephone.
So that's here the idea.
So my plan here to demonstrate it is first, what is the pre-to-SDR limits, mainly on the
other side, what the clones are now.
We can find a lot of Chinese clones now, so I try to review that, and after that what is
a firmware, and what is the physical firmware, and it's been after that for autonomous platform,
within mind zero install on the PC, what could be the future, and hopefully have some
question about that.
So as many know what is pre-to-SDR, there is a lot of characteristics, which are not
very easy to over limit.
The first is that the QSP flash, so what contains firmware is only 32MB, so on this flash,
which is on your pre-to-SDR, you need to have the bitstream of the FPGA, the Linux, and
application on that.
So it's quite a little to have all that.
On the link between the PC, because right now we are using the SDR, like a peripheral, so we
need a link between the PC and the P2SDR, and we are limited to USP2 right now, and
getting over three or four megabytes without drop is not always very easy with this USP2.
There is several reasons, it could be a protocol, which is IO, well.
So this is a problem.
If you want to use it as an autonomous platform, then you want to add extra software
in it, because you know that on the P2SDR, you have, of course, the ADC 1973, which is the
analog digital converter and digital analog converter.
You have the FPGA, which is zinc-710, which mainly transfer, well, transfer, the signal from
the analog device to the USB, and on the zinc, there is a little arm in it.
So this processor, which is nearly not used, actually, is like a P Raspberry P2, so not
very powerful, but enough to run some software on it.
The FPGA is only 710, so with the firmware from ADC, it is nearly full.
We can clean some blocks of FPGA, for example, the decimator, an interpreter, or DDS, which
is by default, but we are quite full on the P2SDR itself.
Now what are these clones?
So this is a clone, okay.
It costs about 150 years right now.
It has a GBB internet, so not a GBB internet, two USB, and an SD card.
You can have also a USB debug, which is very useful when you don't know what your
P2SDR is doing.
There is a lot of clone like that, and from many manufacturers.
The many issues with this Chinese clone is we don't know exactly who is the creator of
this clone, which means that if you want to report some bugs, or hardware modification, it's
very complicated to reach a contact on that.
So it's less documented, but cheaper right now compared to an original P2SDR, which is
around 250, I think, right now.
This is from NTSDR, which is one of a clone, where we know exactly the source, and you
see that it's quite comparable to the P2SDR, but you have a bigger FPGM, and you have, okay,
all the RX-12, you have also some clock here, which is deepened, you have a GPIOE
either, which could be very useful.
The clock, okay, this is a clock from, and we spoke about it, a lot of the clock, if you
want to have GPIO synchronization, then you can input a PPS, or 10MF input, that's for the
NTSDR, and the clock is quite good, because you can even input a 40MF clock, or you can use
the FPGM, which control the VCTCXO of your NTSDR, okay, that's a good thing, but on all the
clones, there are some missing parts, which mean that if you want to input 40MF instead
of the standard oscillator, which is on the board, you need to desoldier this and sort
of this, this is very small, so for us, a matter, this CMS is not very easy to use, so
be careful about the external clock, okay, so now we need a firmware in order to, that's
these clones works, at each time the manufacturer could bring you a firmware, but generally
not well maintained, so I decided to support a lot of boards, which have in common that they
have the same architecture, the same FPGM, or smaller bigger, and the same AD, 93 converter, so the
build, the firmware, which is containing first the bootloader, so the U-boot, you have the FPGM inside,
and you have the Linux and the rootFS, okay, so ADI, I was providing a firmware builder, which
is build on build root, but not completely, with some make file, external make file, so I decided
to be 100% build root, so it's very easy to just get build root and make a deaf config and
it's okay, it's based on Linux 6.1, and you have rootFS, so all the application above Linux,
are common above all the bolts, the FPGA is custom FPGA, based on the Maya Zia from Daniel, and with
this firmware, you can write a system file from SD card, which boot from the SD card, or for
the flash, and well, as it's simple to build, we can build it on a GitHub directly, you can build
it yourself, even on Windows with WSL, and it's just open to 22.00 database, and as soon as you
have build your firmware, you just need to add CP it on the right, the USB card, and it's okay,
and the FPGA is side, so there is a new 50 process, so all that is custom FPGA, doesn't consume
anything on the CPU, on the RBCPU of the tutorial Zia, so you have FFT done by Maya Zia, I had
some transformation from complex IQ, normally it's complex IQ size bits, 16 bits, and here
we can choose from 12 to 8 bits, because the native ADC is only 12 bits, so you can have more
bandwidth, well it's it's consuming less bandwidth if you use for example 8 bits, that is
this decimation, so we Daniel just explained what the fear, and the fear from Remes,
just very efficient, and so this decimation going to IO, so it means that even on a classical
application, south-party application, you can get the result of the decimation, and this
is very useful, if for example you want to see the old spectrum, but just want to isolate
only one sub band, you can use this, and without getting all the bandwidth through USB or
it done it, I also had some overclocking based on experiment from other guys in firmware, and
it's quite well, it works quite good, because we can have had to 45 mega-sumble over a gigabits
with this kind of overclocking, so it could be very useful also, I don't know about the
temperature of the FPGA, but well, that's an option, Tesoucai is also handling LVDS, which means
that instead of running CMOS, we can have more bandwidth from the ADC to the FPGA, and
there is the two reception, two transmission supported, the Linux kernel, so it's not directly
Linux, but there is first the U-boot, which is on the SD, and for now we get the root FS so
all the application on the run, so it's the same as before on the previous SDR, and the
device tree is done by board, which means that the Linux is common, and you just have to
describe UDS and build your firmware with that, I had some USB drivers, because generally
if you have a PUTOS DR, you want to make USB to return it, then you can just plug it on USB
and it works, I had them through GPS, audio, and even Wi-Fi, and I extend the frequency,
so generally, ADC, 963 is 3, 350 to 6 GHz, and here I can go down to 47 MHz, so on the root FS,
which means all the application, there is a WTFL server, a possible SWIP, so the SWIP is here,
which means that we have normally max 61 MHz of bandwidth, and with the SWIP, we fast
lock on 8 bands, because the register is only for 8, so it's 60 MHz by 8, so we have here
4 and 80 MHz spectrum, and for the transmission, I just add a PTT on GPIO, which is quite
huge, useful for amateur when they use amplifier, so the third party are already using some
features, and here are some examples on that, the Tezuka community is quite huge now,
there is around 10,000 downloads, a lot of issues, and some contributors, and thanks for that,
there is some manufacturers, and some samples to test on it, maybe a little demo,
I don't know if, yeah, so here you have SDR++ running at, well, all the band,
on the FM, so 80, 28 MHz, and so we can listen to the modulation here on the FM band,
and at the same time we can see it on the web browser, this is a very, well, classical use,
and for the sweep here, we have from 500 to 8, so we have 40, 480 MHz of band, and so here we can see
some GSM, and the firmware is quite good, because we can have to have 5 KHz of Fremorites, so the next one,
for Spectrum, okay, so right now it's just a no more firmware, and now we want to be autonomous,
so instead of having the root FS on the run, we put it on the SD, and that's extend a lot, the application of the Puto, well,
it's not the Puto, because there is no SD on the Puto, but on the clone.
This is a TZUK extension, which means that the Linux kernel is the same as TZUK, and the ZUK in Europe is just a root FS, so just the application of that.
It's deviant to 12-based, so instead of having very little size, we and only build root, then we have deviant to deviant based, so with all the package you want.
It's persistent, which means that it's more easy to make some application on that, the process is just scripts to install several application, which it's used with KMU,
and I have some pretty easy tool, like VNC access with web, so it's no VNC, and the print cell package.
So for example, you can compile on target, wow, it's not always possible, because there is a big project,
but if you want just to compile some very little projects, just you don't need to cross-compile, and you have all the tools on the clone itself, which means that you have GCC, you have already Python 3 installed.
You have new radio, an example from Johnny Shell, from the book, and several other application on that.
And you can see that there is a radio already. The radio is just, it's just odd, and it's integrate just a few hours ago.
And there is remote as they are, so this is a sample of web application, which can be demodulated.
Okay, this is what is, sorry. So this is a web application, okay, and this is done on the, on the tutorial, just on the arm, and you have some new radio script,
running on the print of itself. So the problem is that if I use the original project, there is some very high process.
The first one is the spectrum, not the highest, but we need to compute the FFT from the IQ, and the main is the decimation.
Which means that the arm, the little arm on the print of is not very sippy, well, it's just a little pi-do, pi-do, and so this machine here is around 1 and 20.
So you go from 2.5 or 2.5 mega sample, and you decimate by 120.
So instead of that, we use just 20 here to reduce it. Why? Because we use the SPGA to decimation to make the NCO, so the frequency tuning, and we get the spectrum instead of that.
So all is done on the SPGA, and with that, we can then run it. I can show you some, what, so this is a web interface, okay,
and I connect to my printer. The password is analogs. So this is a new radio working on the printer itself, okay, and then here it's getting the FFT from the FPGA.
We have, for example, Octave, if you want to, well, the idea is to have a match as application on the SDI itself, and you don't have to install it on your PC.
And I don't know, yeah, you can have, so J predict, for example, if you are interesting in satellite, and want to use the Doppler to receive it from the radio.
I know that there is also a GR satellite inside. Here I use, it's a little different from Maya. I just add some overlay, well, it's a proof of concept, just to try to add some features on it.
And this is remote SDR. So with this, maybe we will hear it, I don't know if there is audio.
So all this, on the web interface, you can receive it, and you can make else or some transmission. So some, sorry.
Some, some guys use it to, to transmit on a Q100, okay, because you have a complete receiver here, which works alone.
So you can, you can put your clone on, well, just near your antenna, and then just have a little asymmetry cable, and you have,
you're a transmitter. So the installation is very easy. If you don't want to install all, to yourself, just go to the GitHub of the Conego pair, write it on SD card, because it's a ISO.
So use a Barney Ultra, for example, and then you will have on the boot, civil folder, and one folder is for one border.
So just get the file, which is under this folder, and go to the boot. So there is a readme on that, but I just do that.
And so it could handle several boards with these techniques. Okay, the limits, the limits for this autonomous, is that, well, it's not really agnostic, which means that we, we need to know how the FPGA is working,
and so it's not a classical SDR. Some process could not be done on the arm, and even on the FPGA, well, it could be done, but it's complicated.
For example, if you want to, to a process, a white band with a wham or something like that, if it's not done on the FPGA, then you can do this on your arm, and then you need to get all the bands for you PC.
So, and if you prefer to compute all the IQ of a GPU, then it's not, it's not the target of this project.
Okay, Adi, 96X has already have some limits, especially with the synchronization, and Jean-Michel has just explained us what, what the problem.
We'll see that there is some I-O CPU usage. So, the I-O is the protocol from I-D-I, to go from the, the P2SDR to the PC, and it is a very, very high CPU usage for that.
It's based on RPC, and even you have a lot of bandwidth network, the limitation is the CPU. That's why we try to overclock it.
The solution could be maybe, to have direct, direct implementation from the FPGA, going to the G-Dabbit.
So, what is the future? Maybe having this kind of thing, which is autonomous, which process all the DSP in FPGA, and then use a lighter DSP on the web browser.
So, this could be done with cyber ether. So, if we can get Websook at some of the future SDR, then it could be easily managed by browser with JavaScript, etc.
So, try to have a more FPGA module. I begin to, to refactor the FPGA one, which is where you can add or remove some components.
You are on big FPGA, and you can have more interpolation, you can have, and you can choose the components. So, this is the next one.
This is now with the GPL, and GPL is quite good for the latest clones, because you can use them for discussion with the FPGA, or try to synchronize several balls.
Well, there is, you can, you can extend it to SPI, or I2C if you want to add a lead or a band filter, for example.
Maybe put this to red pizzeria, and for all the people who have a Pluto, but not a clone. What about this project? Well, if I add the possibility to plug a USB on your Pluto, then you will have the same.
So, thank you very much for Daniel, and for the source of the FPGA and the contribution, thanks for the community.
And so, I hope that you enjoyed.