So, last 10 seconds to leave the room, if no, you're staying towards the end of the
lighting talks.
One, two, three, four, five, six, seven, eight, nine, ten.
And we are starting the next lighting talk by Leon.
Thank you very much for joining.
It's not the end of the world.
It's just a lighting talk about, oh, is it?
That's working?
Kind of.
Is it working?
Yeah.
All right.
It's a little bit broken.
So, it's not the end of the world.
It's just a lighting talk about Wayland, Weston, the Yocto project, and RDP.
So, Wayland is a display protocol.
It was started like 15 years ago with the idea to replace X11, and it's slowly getting
there.
How many of you are using Wayland on your desktop computers or trying to use it?
All right.
Pretty much all of us, all right.
We're trying, right?
I'm not a Wayland, neither a Western developer, but I'm a user.
Actually, I'm a contributor to the Yocto project and open embedded.
So here I'm sharing ups and downs of the integration of RDP.
So Western is just one of the compositors for Wayland.
There are so many different compositors.
Probably Western is not the best one of them, actually, but for embedded systems, it's actually
sometimes pretty useful because it's small and simple.
And there are options how to share your screen when you're running Wayland and Western.
And there is this protocol, which is RDP, which stands for Remote Desktop Protocol.
It's an alternative to VNC.
Basically, you are doing remote screen sharing with it.
There are some ups and downs, like it's proprietary protocol.
The ups is that it's actually a semantic protocol.
So you are sharing the fonts, the controls, all that kind of stuff with RDP.
And the good thing about RDP is that you actually have an implementation for it in Western,
the reference compositor of Wayland.
So keep in mind that if you come into a situation where you're working on an embedded device,
you have Wayland, you're using Western, and one moment you want to share screen for one
reason or another, you can use RDP as an alternative of VNC.
So you might have heard about the Yocto project.
If you attended some of the other talks earlier today, they're quite famous because they make
really good Hooties that you can order online.
But the Yocto project is not just about hooties and t-shirts.
It's a collaborative project of the Linux Foundation for building a custom embedded Linux distribution
that is using the open embedded build framework and a tool for building images called BitBake.
The Yocto project comes with a reference Linux distribution, which is called Pocky.
So basically this is a way how you can get started relatively easy with some images that
are out there, and you can pretty much build them out of the box if you have the right
BSP for the hardware that you're touching.
So I said relatively easy, but I have to say that the truth is the Yocto project has a
steep learning curve.
It has an amazing flexibility, but it takes some time to learn it.
And it has releases twice per year, and nowadays there is a long term support release.
So here's an example for the releases.
This is the release that is going to be released in April.
And we have Kirkstone, which is an LTS release.
And we have Dunfa, which is also a long term release.
It was released almost three years ago, and it will be supported for a year more.
So keep in mind that, especially in the terms of the things that we're talking here about
Wayland and Weston and the BSPs, there are different versions of Wayland and Weston depending
on your BSP, but also on the Yocto release that you are using.
So you might end up in this situation where a feature is missing from Weston because you
are using an older version of Weston, and you are using this older version of Weston
because you are using an older release of Yocto.
So my personal recommendation is that if you are not sure, and if you can make a choice,
go for the latest and greatest long term support release.
But of course, that's not always true, it depends.
So here is a simple example how to do a BBA pen file.
This is basically extending the existing recipe for Weston so that we can build the
module for screen sharing with RDP.
Out of the box, it's not built, so we have to go one step further and make this configuration.
It's just a build configuration to make sure that in core image Weston, which is a small
image containing Wayland and Weston, we can have this module and we can enable, after that,
screen sharing over RDP.
And the RDP implementation in Wayland is based on free RDP, so we have to add it as a dependency.
So after we have this, at runtime, we need to do a little bit of more configuration.
Well, actually, we have to do them unless we haven't done them as part of the automation
of the recipes with Yocto and Open embedded.
But this is just a simple example of how to generate appropriate keys.
After that, to configure the Weston init file, this is the master configuration file
of Weston with various configurations depending on your system.
So there, you have to enable in the screen sharing section the command to be launched
when you do screen sharing.
But when this is done, remember to launch Weston or restart it just to make sure that
the right configuration is loaded.
But after that, there is one more thing you need to do.
You need to press control out plus S. That's pretty cool if you have a keyboard.
But some embedded devices don't have keyboards, right?
So hold on, hold on, I've told you it's ups and downs, so sometimes they're downs.
You are versions of Weston actually have this option to put in Weston init, which allows
you to do automatic start up of the screen sharing with Weston.
And this has been added to Weston version nine.
And I believe this feature was added by Marek who had a talk here earlier about you boot.
So you probably know him.
So thank you very much for doing this because this is a really useful feature if you are
working on an embedded device that doesn't have a keyboard.
And once you're ready with this, from another computer in the same network, you can launch
a client that supports RDP and you can connect remotely to your embedded device.
Here are a couple of examples depending whether you're using Wayland and based on your response
to my question at the beginning of the session, it looks like a lot of you are using Weston.
So here you go, you just replace the IP and if everything is okay, you'll be able to connect
to your embedded device remotely.
And if you're still using X11, you're still in the game.
So here is a very simple demonstration.
And what we see here is a screenshot from my computer.
My computer is, I'm kind of a lazy Linux user, so it's just Ubuntu FTS support.
So we have Ubuntu with Wayland and GNOME, which we see on the back.
And here in this screen, we are seeing core image Weston running on Raspberry Pi 4 with
the configurations that you have seen in the previous slides.
All right.
So that's all.
That's pretty much how it works.
RDP has some ups and downs.
I guess the major conclusion from this lightning talk is that if you come into a situation
where you need to do screen sharing on embedded device that is running Wayland and Weston,
as an alternative to VNC, you have RDP as an option.
And use the Yocto project and open embedded, it's pretty cool and it's pretty much everywhere
nowadays.
Thank you very much for the attention.
I think we're just on time.