Oh, my name is Sergey Kassan-Pyre, and I'm going to talk about VIsDR platform, it's WebPayis, it's
DR processing.
So, a little bit about Miso, I started this map with a radio when I was at 9, so I'm interested
in the concept of programming, so I do have the name of the DSP staff and I was in a recent
there was part of FairWaves, I was a creator of original Pixrix, it's DR, as you
know, and now I'm part of WayWavet Labs, we're doing a couple of bunch of videos also
of FairWaves.
So, I'll start to show some of the presentation to keep up time in, but generally we're
real, so let's talk about Acustin, the web is DR projects, so you can logically group
of web projects, one use UI, as web, so it's my idea to open WebEx and the many, much more,
they don't do a processing on the front, mostly do the processing on the web or on HR itself,
and we have another group where there is a complete implementation of processing device
and manipulation, visualization, everything.
Most notably, probably at least I like CyberWavet Labs, it's awesome, there's a lot of features,
but all that project have the same care, so it's my knowledge of design, mostly single project
compiled into web, you use an M script, and some project use, or per show, it's pretty
cool, but they're very long, it's an extension, so it's not really optimized, to extend
or not really have a multi design, so we think what if we can build such a platform, so it's
going to be extensible, no blood, web assembly blocks, so it's going to be, that was
script, a friend day, you can have interaction between the users, you have multiple web,
BDI supports, and it's much more, so we start thinking what we can build and one thing,
we start less complex stuff, because there's already simple stuff available, and
what was left, run it to J, why today, despite it already, not popular solution, but
what it's great is the amount, so it does not use extension, it's the process same, so it's
simple, it's game of related, just a hundred, seventy kilos of project, and J seems structure
is simple, a burst, and a burst, a friend, a frame, and the user given four samples per second,
you get a slight, one mega, mega samples per second, it's okay, even for you, it's
good to it, which we can support a lot of cheap, is the R on the market, and another thing
which is good for 2G, you don't need to program same card, because there's no cell
authentication from phones, so you can use a custom same card, and now plan was,
like, let's do it in the 2 week time to see how it's going, but, it was my
accommodation, you used really complex structure, which is mostly resembles, the
GM standard, there's lots of component, there's lots of interactions, so, only if you
months later we can get something working, so it was only, like, took only four months
to get a simple UC, and a lot of things need to be done, the only that time we run,
use your campaign to get some money to finish our experiments, and we file and
file net, grant foundation for this wall, fortunately we got an all net grant, but
it was, like, a year late, and during that time we tried our best, so what we did, first
we tried a really simple adaptation for 2G in the web, a year reduced, but that way is
possible to reduce, so, no, APs came a delay, and not a progress, just simplest, mesfices,
the end voice calls, even in that configuration, there's a lot of component required,
so we started looking how we can get it, and another issue, there's no, like,
dire QDP, or TCP communication web, have to wrap everything, and it's web
circuits, or, like, modern technologies, but we use web circuits, point.
So, our first approach was just run, osmotherics, and the content and everything
called in the back end, osmotherics is, uh,
components that translate JSM doors into like you samples, pretty simple, but mostly
this being intensive stuff, but you know, it's not a great idea, because you
dp packets were coming up with very short interval, and web circuit in the web browser
was not optimized for this.
It was during, and it just gives power, and it's terribly, for that, I'm pure,
so only we can get, like, osmotherics running for 20 seconds, and then
completely fails.
Another approach, let's do, like, two components, the front, everything in the web,
and that somehow worked, but still a lot of problems remains.
Since, uh, there's a lot of, uh,
since there's a lot of, uh, threads in osmotherics,
it was not properly running, so we had to optimize everything.
First of all, osmotherics use a lot of vector instructions to form JSM
utilization.
Here we did a trick, so we used lookup tables, so we have predefined waveforms.
Actually, to generate JSM's kind of a uniform, you need only, and knowing what was,
like, two or three previous symbols, and knowing that we can form a lookup table.
And that was, and that worked amazingly fast, so it was, like, pure,
maxi pia instruction that worked really well, so we speed up almost,
and by 50% problem was to find that small,
four milliseconds, uh, period between frames.
That was, uh, that we did a trick, so we adopted, uh,
everything to, uh, in processing of two JSM frames.
That was, like, roughly 10 milliseconds per year, but that,
But that time as a computer was okay with JavaScript schedule and web-assembly.
Another thing to optimize was we have a couple of screens, a couple of web workers fighting
with a child and so we write the code to be a single threat in Washington.
And we just call it task sequentially.
So when we get data, we call it BTS Federal, and we call it osmaterics, and it goes for IQ manipulation.
They were really good results, so we finally can make phone to be released, register it on the network,
to get a simple SMS and use it to message.
But to get phone calls, we need more adaptation.
Like classic osmaterics, call stack, use RTP on the backhand or call communications.
And it gave another problem, because RTP, pure UDP, we need to wrap everything,
and each of us call requires each wrapping and adaptable.
But as a computer project already have so called osmax protocol, the design is specifically to run remote.
Based stations that are located over set link that have limited bandwidth, low latency,
and be adopted that protocol over web markets and it worked really well.
In the end, we get only like zero to three frame lost per hour.
That was amazing.
When I started with Harold, the little osmoco project, it's still not impressive for career grade operators.
So I'm going to show you how it looks like.
So we have a divided connect.
We got a notification, so there's device connected, go to our website.
You can actually install on your own, it doesn't matter.
We set a device.
We have to configure it.
GSM, 180 band.
So when the BTS starts, we get some messages,
and you see the data is coming.
So there's an indication that IPU is forming.
So now we took two phones.
There is a screen cast of both phones, both phones,
and we try to connect to a network from both phones.
As we connect, we see a lot of messages going into a BTS log.
The both phones connected to their team, their site, etc.
We turned the osmoco to our number allocation.
So the both phones that dynamic number, one number,
we can make a phone call from another phone.
And every BTS command, everything you can see in the logs of what you are doing.
Every disk and packet is here.
So, and we'll got a phone call.
So we can answer it, unfortunately, there's no sound,
but you got the idea.
Okay.
So what's it like from the old perspectives,
we have a client, which is our browser.
We have intermediate software,
with a back-end that translate websites,
like it's too native as macon protocols.
But the good stuff can really extend it to build a web-based cloud network.
So everyone can run their own BTSs.
We can run multiple BC units.
BC is a control in terms of JSON.
We have multiple controllers,
but geographically distributed to minimize latency between the call.
So, as a community, it's possible to build such a huge worldwide.
Network.
Despite JSM is outdated,
considered outdated nowadays,
and many many sites will look into 4G.
And 5G is still interesting,
in terms of research and education,
where you can build your own network
to do a research and communication,
build distributed network.
And still, it lost for some emergency response technology,
and even looking for people who are lost,
because running a network is open registration.
You can get information that the phone tries to connect to a network,
and based on that information,
you can look where to find the closed people.
And another interesting feature,
we can actually run network on a smartphone.
So it's going to be a network and a network.
Yeah, after getting a success with that application,
we look what we can build in terms of platforms,
how we can unify everything with the one
from that experience,
it build extensible platform.
And so, our platform example,
that we have an application,
that can be very complete in JavaScript,
or useful graph, or in a wild,
vast module.
It finds so-called data streams.
It's where data come from,
that can be from the real hardware through web,
use be, it can be remote,
data through websockets.
You can have local data through the file IPI,
or even cloud services.
We develop,
so you, the dynamic grid with structure,
I'll show it just in a second,
and definitely we should support multi-user
and data access.
So we use the barrier,
standard technology,
and that,
and the design.
So one demo is a FM radio,
pre-test, and that was project,
it already,
but just to get your impression,
how it looks like.
So in the front page,
there's a couple of pre-defined applications,
so we start FM radio,
so, this standard parameters,
so, sure thing,
we'll get a web API connected.
And, all the controls are dynamic.
So, here we can use both frequency,
and modify it from all local,
and it's a long-diffication,
in the full graph.
And, a changing,
that parameters,
you can shoot different stations,
every thing is dynamic,
so, you can use this application,
I can start the point and develop,
and I think else.
And another example is,
if you can use this application,
it's a signal analyzer.
So, we have,
as I mentioned,
so called data structures,
where you can have data,
either like locally,
as here you can shoot a file,
and then analyze it,
or you can connect with a mode,
location,
using cloud file provider.
Or you can even run your old cloud provider,
here's an example.
We're here,
like our own,
very simple file storage cloud.
So, you can upload data,
and the SIGMF is supported
to properly take all the recording.
So, you can see,
we're just can configure what's recording,
if it's,
if it's not tagged correctly,
and it is created from an upload.
Once we are upload,
so you can share the recording
because everyone else,
using the links,
using the link,
and it's pretty convenient.
So, get,
let's get back to our application.
Just in the second.
Yeah,
you can actually download it back,
even then I will,
you want it.
So, here,
we choose our recording,
and you can analyze data
by selecting,
portal,
this recording.
And that record,
at the application,
mostly use liquid,
GSP,
this kind,
is number of,
standard mode view data,
and standard parameters,
for the video later,
like,
the second modulation index,
a threshold,
and once you select it,
you see all beats,
in the decoder stream,
sorry,
that,
it's really,
a lot of fonts.
But,
by a year,
like,
set the wall recording,
you can,
select,
for example,
Bluetooth low energy,
sorry,
I got this recording from my Bluetooth mice,
and you can see,
the wall Bluetooth packet,
decoded here.
They're a bunch of different visualizations,
so you can see power of the signal,
you can see the demodulated signal,
so basically,
I'm the coder,
so you can see all the transitions
from that recording,
you can visualize,
raw beats,
and so forth.
Okay, let's,
skip that,
move to the next video.
Another thing with the platform,
we have,
of course, share device,
where you can run a device
on the one computer,
and share all the data coming from
one computer to another,
through the platform.
For example,
there, we're running one application,
we have,
is your connected to that laptop,
so we started,
and there's a link,
so we can share that link,
with anyone,
whoever you like,
whoever you want,
and anyone with the link,
can actually hear,
and get,
I do data from your,
streaming,
you can actually run
a pretty fine application,
using this link,
and with both some compression,
here you use the low compression,
but we're looking to get more compression,
even streaming,
a few megacenters per second,
might be problematic,
through the web.
So, one another computer with
set stream parameters,
is that link,
and there's,
that's like,
a fan-demodulator on that stream,
so we have one stream,
device,
one location,
and we are in,
another application,
the translation,
if I'm demodilational,
that's single,
sorry,
so you can hear,
that's,
it's working,
and we have a couple of
configuration,
one is,
you can just
trade data stream,
when you want to like an another,
you can actually give access to your device,
and when you change controls,
like frequency,
or bandwidth,
or gain,
that requests go back
to the original recording,
and actually,
changes to that configuration.
Okay, let's stop for this now.
You know,
all the kinds of architectures,
simple,
not not fancy,
let's just,
express,
simple,
file-based,
file storage,
quite your recording,
we use a website,
it's a way we use
school life for storage,
where you can storage,
custom block,
and application configuration,
and you can actually do all the stuff in
not a JS when you can the back,
so you can predefined the location,
and run it in,
completely in the back,
not required,
your interaction.
Another thing,
is,
I mentioned a,
is all platform,
is accessible,
so you cannot write your own application,
or your own blocks,
so you have,
if you don't find any block,
you won't,
specific,
the module,
which,
or single processing,
you can create one.
The interfaces,
pretty simple,
you need to come to the find couple,
function,
it's mostly,
samples,
a good idea,
interface.
And,
when executing multiple blocks,
called the flow graph application,
you can,
just,
draw,
like,
in a,
in a good radio,
just show you,
that,
up,
or have.
Okay,
let's run the demo.
So we create an empty application,
empty project,
here,
nothing,
and we got into edit mode,
so in edit mode,
we can put different blocks.
For example,
here we create,
web use,
be block,
to source data coming from,
from your device,
we can add,
contrast,
control,
the device,
so it's source,
so if you're multiple,
is there connected,
you can,
you'll be able to select,
which is,
there you want,
to get data from,
now,
we can add,
another configuration,
like,
frequency change,
so we have input,
we connect to a frequency parameter,
and we can,
set the cap,
from main,
now we can,
set the cap,
from main,
firing tapes,
a kilo,
and every parameter you,
you,
you peak here,
is saved in your configuration,
so you can share what you experiment with others,
and say,
that application,
in case you need,
it to be used later,
or the application have a JSON like structure.
So we running this application,
it has nothing,
that's doing it with data,
but we can see we get some data coming from WIP USB. So let's do something useful.
At one, scene block, we can see, so we realize streaming. And we can connect with the
applications, so if we can change for example sample rate, so we can get redraw our graph
redraw according to change parameter frequency sample rate. So we add visualization UI and let's see.
So it doesn't sound fancy at the moment, but you get the idea, you put a block and it appears
the dynamic layout. The next stage you can edit a little layout. By default, it's so called
grid layout, which is mostly in a window radio, but big added dynamic layout measures, I'll show
you in a second. So every block you can extend to whatever, and for example, frequency,
we extend frequency, sync, and now it occupies more grid. You can place whatever
troll, like, in a formula application, that way. Okay, let's go to another. So if you didn't find any standard
block on the platform, so you always can add through what some block through compiling
anything, but other can just create custom block in the web. So you don't need to install
update anything. So we just need a block name here. If you add a new, something like a
encryption, and more important, we need to put parameters. So every block requires either input
or output parameter. Sorry. Here we have, I accused them for complex float or complex integer.
We can define multiple types supported for input. And we add output parameter with just float
through to real data. So when we can add special parameter for configuration, for FMD
we add modulation index. We can add as many parameters as we want. It'd be automatically
inserted into your JavaScript environment. So we can add limitation, minimum, maximum
step, if you're doing control and set the default value. So when we're done with definition,
we can add actual code for this element. So in that element here, you see already
template, so you can add some function. In for example, for FMD
later, there is the function. It's pretty simple. I'm sure it gets a derivative from
get the angle. So, yeah. We are not stopping developing the platform. So we are looking
how to add more functionality, definitely we are looking how to add web GPU support,
user programs, execution, web GPU, a plan to add more transport, especially web
transport, that is more optimized for little latency. You can add more blocks. And if there's
any interesting service integration of the looking out, how to add the external service
and other real chosen codes to support like LTO 5G in the browser application. So thank
you for the time and there's a couple projects on CrowdSupply. You can support us
by backing this or you can support participating and you see our development. If you
have any idea, any suggestions for your ideas in our discord channel or for the email.
Thank you.