Building your own custom Linux distribution for embedded devices
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 96 | |
| Author | ||
| License | CC Attribution - NonCommercial - ShareAlike 3.0 Unported: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal and non-commercial purpose as long as the work is attributed to the author in the manner specified by the author or licensor and the work or content is shared also in adapted form only under the conditions of this | |
| Identifiers | 10.5446/51704 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
NDC Oslo 201652 / 96
2
7
8
9
12
14
19
20
26
28
31
33
38
40
43
45
48
50
51
61
63
65
76
79
80
83
87
88
90
93
94
96
00:00
Key (cryptography)19 (number)DialectProduct (business)Distribution (mathematics)Wireless LANTelecommunicationFacebookSoftware developerConnected spaceFront and back endsInternet service providerVideo gameTelematikLimit (category theory)High availabilityArithmetic meanLink (knot theory)Dot productElectric generatorComputer animation
02:10
Energy conversion efficiencyCellular automatonComputer hardwareTowerProduct (business)CASE <Informatik>TelecommunicationSpeech synthesisComplex (psychology)Nichtlineares GleichungssystemChannel capacitySoftwareSmartphoneInterface (computing)Arithmetic meanConfiguration spaceMultiplication signComputer animation
03:35
MereologyCartesian coordinate systemBootingPhysical systemProduct (business)Presentation of a groupFile systemData storage deviceChainProcess (computing)Semiconductor memoryDistribution (mathematics)Limit (category theory)Film editingJSONComputer animation
04:10
Kernel (computing)MultilaterationDistribution (mathematics)Open sourceWeightRepository (publishing)1 (number)Presentation of a groupDifferent (Kate Ryan album)Integrated development environmentBuildingLimit (category theory)Goodness of fitProcess (computing)Term (mathematics)Uniform boundedness principleComputer animation
06:45
Distribution (mathematics)Integrated development environmentIntegrated development environmentOpen setDifferent (Kate Ryan album)Multiplication signOpen sourceEmulatorComputer architectureCompilation albumPressureComputer animation
07:29
Term (mathematics)IntelDistribution (mathematics)PressureView (database)Distribution (mathematics)Point (geometry)Rapid PrototypingProcess (computing)Different (Kate Ryan album)Task (computing)BuildingIntegrated development environmentConfiguration spaceMultiplicationComputer architectureOrder (biology)Compilation albumBitPresentation of a groupComputer animationJSON
09:32
EmulationDemo (music)Scripting languageMeta elementSkeleton (computer programming)Computer hardwareOpen sourceCache (computing)Virtual machineTask (computing)Queue (abstract data type)DemosceneParameter (computer programming)Kernel (computing)Computer-generated imageryInterface (computing)PasswordRootPower (physics)Scheduling (computing)Default (computer science)Read-only memoryHash functionDevice driverGeneric programmingSCSIBlock (periodic table)Revision controlProcess capability indexCore dumpoutputBit rateLimit (category theory)Data bufferVideo game consoleBootingSoftware developerExt functorTotal S.A.Computer networkLoginMessage passingMaxima and minimaMultiplication signStandard deviationDefault (computer science)Medical imagingSoftwareEmulatorInformationOpen sourceIntegrated development environmentGroup actionPhysical systemComputer hardwareConfiguration spaceDistribution (mathematics)BitBuildingSoftware testingVirtual machinePOKEScripting languageIterationGoodness of fitMultiplicationCore dumpComputer animation
12:23
Revision controlSource codeCompilerTask (computing)Configuration spaceRun time (program lifecycle phase)InformationImage resolutionSource codeBranch (computer science)Physical systemLatent heatDistribution (mathematics)SoftwareOrder (biology)Cartesian coordinate systemCodeType theoryComputer fileLibrary (computing)Configuration spaceTask (computing)Multiplication signRevision controlOpen sourceSystem callMereologyFlagElectronic mailing listHoaxCASE <Informatik>MetadataSession Initiation ProtocolKernel (computing)Repository (publishing)BuildingComputer animation
15:59
LogicCartesian coordinate systemDistribution (mathematics)Product (business)Connected spaceMedical imagingInformationSocial classLogicComputer hardwareKernel (computing)WhiteboardComputer animation
17:34
Open setPrice indexMIDIBranch (computer science)MultilaterationMathematicsMultiplication signDistribution (mathematics)MereologyComputer animation
18:37
Computer-generated imageryDemo (music)Distribution (mathematics)MereologyComputer animation
19:09
Network topologyDefault (computer science)Patch (Unix)Directory serviceComputer fileComputer virusInclusion mapMeta elementComputer-generated imageryCore dumpRevision controlLarge eddy simulationData conversionCache (computing)Error messageTask (computing)Image resolutionQueue (abstract data type)DemosceneRootKernel (computing)File formatRead-only memoryPower (physics)outputBlock (periodic table)Device driverGeneric programmingSCSIInterrupt <Informatik>Process capability indexLink (knot theory)Hash functionScheduling (computing)Data bufferVideo game consoleBootingTotal S.A.Demo (music)Software developerLimit (category theory)Bit rateInterface (computing)Computer networkLoginComputer programmingMedical imagingSpacetimePoint (geometry)Configuration spacePhysical systemMereologyInformation technology consultingInstallation artMessage passingDistribution (mathematics)Limit (category theory)Game controllerRight angleSoftwareDemo (music)Default (computer science)Revision controlPatch (Unix)Figurate numberComputer fileMultiplication signPower (physics)Maxima and minimaRoutingGraph coloringInformationSpeech synthesisQuicksortBuildingFreewareIntegrated development environmentMultilaterationGreatest elementSource codeOnline helpRootCore dumpText editorEmulatorComputer animation
27:21
Cache (computing)State of matterShared memoryComputer-generated imageryBinary space partitioningWhiteboardInformationMedical imagingDefault (computer science)MiniDiscState of matterMultiplication signWhiteboardComputer configurationCore dumpCache (computing)Distribution (mathematics)INTEGRALSet (mathematics)Computer hardwareShared memoryFile systemRobotServer (computing)Run time (program lifecycle phase)Product (business)Physical systemOrder (biology)Point (geometry)Machine visionSpacetimeIntegrated development environmentView (database)Adventure gameNP-hardIntServGroup actionDampingMathematicsComputer animationJSON
31:18
System programmingPhysical systemTape drivePower (physics)CodeMeta elementComputer hardwareScripting languageComputer-generated imageryCore dumpSkeleton (computer programming)Open sourceRevision controlData conversionError messageMessage passingVector potentialVirtual machineLocal ringIntegrated development environmentCache (computing)Task (computing)Image resolutionComputer fileDemosceneConfiguration spaceRootStatisticsCore dumpMedical imagingIntegrated development environmentConfiguration spaceMereologyMoment (mathematics)BuildingOpen sourceVirtual machineSpring (hydrology)Computer configurationPhysical systemSoftware testingFreewareComputer hardwareArchaeological field surveyInstallation artGroup actionSoftwareMaxima and minimaScripting languageMultiplication signPiDefault (computer science)RootDirectory serviceFile systemPlastikkarteServer (computing)BootingComputer animation
36:33
Demo (music)Embedded systemSystem programmingDistribution (mathematics)Computer hardwareSurfaceMereologyBuildingRepository (publishing)Kernel (computing)Data managementWordPresentation of a groupReading (process)CASE <Informatik>Computer animation
37:55
Lipschitz-StetigkeitComputer animation
39:09
Limit (category theory)WaveDampingReading (process)Level (video gaming)Distribution (mathematics)Different (Kate Ryan album)
Transcript: English(auto-generated)
00:04
Okay, so let's start. Hello, everyone. My name is Oscar. I work for a great little Swedish consulting company called Swede. On my current assignment, I work as a back-end developer and team leader for wireless car, a world-leading telematics provider
00:21
for vehicles. But before that, I worked as an embedded developer at Ericsson, and I worked on this. Does anyone actually recognize it? Do you have anyone here who's worked within telecom? Ah, 1%. Great. So this is a brand-new product. It is the MiniLink 6352. It's a next-generation,
00:49
high-performance, all-outdoor microwave solution. And it's brand-new. I believe that they started selling it for about a month ago or so. And believe it or not, this actually runs Linux.
01:03
And it runs a custom Linux distribution built by us, and using the same techniques that we'll demonstrate here today. What's more interesting with it is where it's installed. Up here. Now, sadly, this picture doesn't feature the MiniLink 6352, but you get the
01:24
general idea. But once it's installed up there, you don't want to take it down again. So it's really important that it works. Modern life requires stable connectivity. We do our banking, our cars are connected, and much more. Kids, they need their Snapchats
01:44
and their Instagrams, and old people have their Facebook. And telecom companies know this, and they demand high availability. Still, it's a really competitive industry. And there's a fierce competition to quickly reach the market. So in a sense, we need
02:05
quality, and we need speed, and we need it more than ever before. So what we're seeing is that embedded is changing, and it's changing much like the rest of the industry.
02:23
We're seeing much more powerful hardware. Basically, what you had on your desktop 10 years ago is now up in the cell tower, and it's smaller. It's more energy-efficient. And that's a lot of hardware to make use of. We're also seeing more and more software requirements. The products are getting smarter and smarter. More features,
02:46
easier to configure, and so on. Even products that traditionally didn't have any intelligence are now getting smarter also. I now have a smart car, I have a smart phone, I have a smart watch. I mean, the only thing in that equation that isn't smart is like me.
03:05
So we're seeing an increasing complexity in building these products. And also, at the same time, we need to make use of that hardware that is provided. So in the case of telecom equipment, customers are requiring more traffic capacity at a lower cost, while still demanding that it
03:27
always works. And it has a nice interface so that you can just click and configure it. So one thing that is important to remember when we're speaking about embedded is that
03:43
an embedded product is more than just Linux. It requires, for example, a bootloader to actually load the kernel into memory. We need a file system so we can actually store things like applications. We need a tool chain to develop it and much more. So Linux is actually only
04:04
one part of the whole embedded system and the process. So the goal of this presentation is to get you up and running and building your own Linux distribution, much like we built our
04:21
Linux distribution for the 6352. And I really tried to streamline this presentation and cut away as much as possible so that there's not that much to confuse you. So if you feel that I skipped or left out something, please feel free to ask any questions. It would actually feel good
04:42
if you asked more questions. So any questions is more than welcome. So one thing that I've always felt is when I go to these big conferences, I'm like really inspired when I go to these presentations. But then I go to like eight presentations a day and I'm really inspired with all of them. And then when I get home, I'm really tired
05:02
and then really nothing happens. So I decided that for this talk that I would also provide a GitHub repository with instructions, everything that I will show today, so that you can go home and you can repeat basically what you saw here today. So you don't
05:22
really have to remember exactly what I typed. You can just try to remember the big arc, the big picture, and hopefully the details will be in the repository later. So this is a quite ambitious task, this building a Linux distribution. I mean,
05:43
the scope is quite ambitious. We have like one hour, and I've already been talking for like six minutes. So how are we going to manage to build a Linux distribution? We're going to use something called the Yocto project, or the Yocto project is an umbrella
06:03
umbrella project for many different open source projects. But looking at it as a whole, I think that this is one of the absolutely coolest open source projects in the world. And there are many cool ones available. There's like the Linux kernel. We have Postgres.
06:21
I believe that .NET is open source now. We have Git and much more. But I still think that this is one that really deserves a place at the top. And I hope that during this presentation, I will be able to convince you why that is. And by the end of it, you also think that this
06:41
is a really cool project. So one thing to remember is that Yocto is not a Linux distribution. It's just to help you build one. And it does so by providing a complete embedded development environment. Basically everything you need. It will provide
07:04
you with tools such as emulators, debuggers, compilers, support for different architectures, and it builds on experience and best practice. In a sense, you will be standing on the shoulders of giants instead of reinventing the wheel. And it's open source, and it has a lot of industry
07:27
backing. So you might recognize some of these companies. And these are different-sized companies that provide their time, money, and effort into the Yocto project. So I hope that when
07:42
you see these companies that you feel somewhat of a peer pressure to get started. So how are we going to start building this distribution? Well, we're going to use something called Pocky, which is a project within Yocto. And it is a reference distribution. And so it
08:02
provides us with a base that we can start on. And from a rapid prototyping point of view, this is absolutely excellent. So we're going to start with just building it as it is. And then later, we will start to customize it, efficiently making it our own. And in order to build it, we're going to use another tool within the Yocto project called BitBake.
08:26
And it is described as a task executioner. And that really doesn't say so much, but I will describe later why that is, and it will be a little logical. And but you can think of it as make, but somewhat more flexible. I believe it is
08:46
created and inspired by Portage from GAN to Linux, if you are familiar with that. And it will help us with a lot of things. For example, cross-compilation. And cross-compilation is a huge pain otherwise. If you're building on one architecture and targeting another one,
09:06
the configuration can be a little bit messy. And if you're building for multiple different targets, then that can really be a pain point for you. But BitBake will actually solve that without any problem. So it will be really simple for us to change target,
09:24
as we will during this presentation. So let's get started. So there we go. So the first thing we need to do is that we will initialize the build environment.
09:52
So this script that we just ran, the source or open embedded initialized build environment, creates a default environment with default configurations that we can use.
10:04
And this means that we also have we got access to some tools. For example, BitBake. So now we can use BitBake to build a standard default image that comes with Poke. So we'll build core image minimal. So the first time that you run this, this can literally take hours for you.
10:30
Now I've built it, so it will be much quicker for me. But you can expect it to go on for hours. So we'll see some configuration information here. For example, here, we can see the machine
10:44
that we're targeting is Qemu. And it went successfully, so let's start it. Yeah, and I
11:01
can type. So there we go. So you might think that this is somewhat cheating. We said that we would build a Linux distribution for Raspberry Pi, but we're starting it on an emulator. And the reason why is actually multiple I have actually multiple reasons for this. One is that
11:23
this is a really good tool for fast iterations. We don't need to go via hardware. We can do a quick test on the emulator. The second reason is that if you're developing hardware and software side by side, many times you don't know if it's a problem with the hardware or the software.
11:42
And you kind of need to get started with the software anyway. So using emulators is a one way to actually get started with software when not having stable hardware. And third, and lastly, is that it's really simple to change targets. So this is for demonstration purpose. So we can see now. We can log in. Thank you. And it's a running Linux system.
12:10
So we have actually built a whole distribution and we're running it in an emulator. That simple. It's powered off. So let's forget the whole Linux distribution thing for a while and just
12:36
think what if I want to run Netcat on an embedded device? So how do I go from the idea
12:42
I want to run Netcat to actually having it on an embedded device? Well, there are certain tasks that we need to perform in order to do so. And these things are described in something called a recipe. Now, before I mentioned make, and so we can continue
13:04
with just comparing to make, where make has its make files to configure its build. Bitbake has its recipes and configuration files. So a recipe describes how to build a certain package. And note that this can be literally any package. It could be the kernel.
13:24
It could be a library that you need such as ncursors or in this case it could be Netcat. So this is applicable for basically all types of software. And it will answer things like, for example, what version do we want? Is it a specific version that we want? Where is the source
13:44
code? Is it in a git repository somewhere? Is it subversion somewhere? Is there some sip that we need to download? Do we need a specific commit or a specific branch? These are things that we really need to know to get the source. It also solves things like dependencies. And this is also
14:04
amazingly good. So Bitbake will solve things like compile time dependencies. If you need a library to compile this, it will make sure that that library is built before so that it is available. It will also solve things like runtime dependencies. If it needs a library
14:23
when running, it will make sure that that is provided also. And it describes also things like how is it built? Does it use make? Does it use cmake? Or does it use some other build system? It describes things like flags that it might need or anything, any other configuration. So
14:44
a recipe, one note is that a recipe is also often referred to as metadata in the documentation. And so metadata is what we call configuration files that will control all the recipes.
15:01
It describes recipes and also classes. So these are things that Bitbake used us in order to actually perform builds. So everything there is called metadata. Because it's data about data. So once we have all this information about how to build a certain package, we can now
15:24
start actually building it. And these are some examples of tasks that Bitbake will perform. And hence, this is why we call it the task executioner. Because it will do things like we need to fetch the source code. We need to unpack it. We need to configure it. And we
15:44
need to compile it. And so on. So this is why we call it task executioner. Because it will execute these tasks. So we now describe that, okay, one application can be a recipe. So what do we do with a Linux distribution that has thousands of applications on it? Do we just have
16:07
thousands of recipes lying around? And of course, no, we don't. So we organize them in something called layers. And a layer is a logical collection of recipes. For example,
16:21
we can have connectivity tools in a layer. We can have it for a certain product. And a layer will contain things like images to build. It will contain board support packages, which allow us to run on a certain hardware. It will contain classes, which is information, general information about how to build recipes. For example, if we want to build
16:43
the kernel, it would be unnecessary if all the recipes for the kernel would define all the information. So we can inherit it from one class. And we can get that general behavior by using classes. So for example, at Ericsson, we had our own layer. And this layer contained
17:06
basically support for all our hardware. It contained our special images that we used and the recipes that we needed. Which meant that we could upgrade the distribution that we used without changing this layer. So we were in that sense forward compatible. And it actually
17:24
really worked very well. So but one thing that you want to remember is before you actually create a layer or recipe, you should check the open embedded portal for them. As we can see here, this is the portal. And I've searched here for raspberry.
17:43
And what we can see here, the top one is the Raspberry Pi. And that will provide us with support actually for the Raspberry Pi later. And the second one is an example distribution layer for Raspberry Pi. So I did not know of it when I created this talk.
18:01
I could have probably saved a lot of time and effort by just stealing that. So learn from my mistakes and check the portal first before doing anything yourself. And most commonly, if you're using a common tool, there's probably already a recipe for it. So take a look. And if it doesn't really fit you, there are ways to alter these recipes
18:27
called appends. So you can just make small changes to them while still using them. So it's a really, really powerful tool. So now when we talked about layers and recipes, let's go on and do the next demonstration.
18:45
So in this part, we're going to we have already built a Linux distribution. We have customized it. So in this step, we are going to create a layer. We're going to create a recipe. And then we're going to actually execute this and see that we have this recipe running so that we can use it.
19:23
So the first thing that we're going to do is that we're going to use the Octolayer. And we're going to create a layer called Squeed after my consulting company. We're going to say that it has priority 10, because I happen to know that the Raspberry Pi layer has priority 9. So we want to be just slightly over.
19:42
We are the most important, of course. We want an example recipe. And we're going to call it HelloSqueed. And we're happy with that. So as you can see here, by naming convention, it calls our new layer for MitaSqueed. And that is just a convention.
20:02
So it will add Mita before it. And if we check our new layer, we'll see things as we have layer configuration. So that is some general configuration for this layer. We will have some copyright information. Read me here. We will have the auto-generated recipe.
20:24
Here is what we call the package name, the version. And here we have the source. Hello world and example patch. It will apply on that source code before building it. So we will start by just customizing the hello world, just so that we see
20:44
that we have changed it. That it's our software that's running on the emulator later. So we'll go for it. Example. So here we go.
21:05
So hello NDC Oslo. So now we have a recipe. But we don't have an image that actually contains this recipe.
21:21
So our next step will be to actually create an image. And we will also add this recipe to that image. So first we're going to add a folder for it.
21:55
So there we go. So the first thing that we want to say is that this recipe will build upon the core image minimal target that we used before.
22:04
So the first thing we will say is that we require the full path to it. If you see any misspelling here, please help me. Because this is the part which is the most problematic. To actually spell it. Core image minimal.
22:25
Once we've done that, we can say that we also want to install. There we go. Image install. Yeah. And that's it.
22:41
So this is what we need. We just say we require this image to exist. And we want to also add this recipe to it. And that's all we need. So now we can go back to our build folder. So what we'll see here. So let's check the build configuration for this environment.
23:06
So if we check the configuration folder, we'll see that there's a file called bblayers. And this configures which layers that we have available to us. So if you take a look at it, we'll see right now.
23:22
But there are three layers available. It is v3. Meta, yokto, and yokto-bsp. So these are three default layers that we get by default. But we need to add our own. So we will have to add it.
23:42
So let's see here. There we go. And now we have added our own layer here.
24:01
So now we have access to the recipe and we have the image. Now you can do this edit also just by just opening it in one text editor. But commonly it's better to use tools to get it right. So now let's build our own image.
24:28
So when you do this, you will notice that this is much faster the second time. And that is because it doesn't have to rebuild everything. Notice that our layer appears here at the bottom.
24:41
So we have four layers and Swedish is one of them. And this will take a little time. It is now building the root file system. But it will be over shortly.
25:01
Any questions so long? No, it actually uses absolute paths.
25:23
And there is a configuration file that will actually save the exact path where it's created. So just moving it will not work. But it actually generates this. So it will generate paths for wherever it is. So I'm not configuring absolute paths in that sense.
25:47
The paths were absolute if you check the conf. So these were really absolute. So let's run the emulator again.
26:01
And we're going to see that now we actually have this package installed.
26:29
Yeah, taking some time. Of course, it's a demo. There we go. And there we go. So this is somewhat maybe a silly example. I mean, it's just a hello world program.
26:43
But in principle, this could have been anything. It could have been some radio device-controlled software. It could have flashed the LEDs. Or in our case, it's just a hello world. The important part is that we have actually built the Linux distribution. And we have customized it. And we're actually installing software on it.
27:03
And also, extra cool is that we're actually doing it on an emulator right now. And this is basically trivial. So it's very easy to get started. And it's really easy to do these things. So it's a really powerful tool.
27:29
So as I mentioned, you will notice that when you run this second step, that it will be much, much faster than the first one.
27:41
And the reason for this is due to caching. Now, from a technological point of view, caching has its advantages and disadvantages. The advantage is that if you always build it from scratch, it will never be stale. The information will always be current. Still, it takes a lot of time.
28:00
It will literally take hours. So in order to save time, using cache is really efficient. And it costs some disk space, but it's really efficient. Now, Bitfake shares this information by something called the shared state cache.
28:23
And this can be shared between different build environments. It can also be shared between users. So, for example, you could have a build bot that just populates this shared cache. And then having the users use this cache.
28:40
We, for example, used this for integration servers and managed to cut down the runtime from four to five minutes to five by just using caching so we didn't need to rebuild everything. So one thing that has been mentioned multiple times now is images.
29:01
So what is an image? So an image is a compressed file system. And it is bootable on the target device. Now, before, we built them through QEMU. But we're going to build one soon for Raspberry Pi. And what's interesting with these images is that it's really easy to customize them.
29:24
For example, in the examples before, we have used something called Core Image Minimal, which is a default image. But there are lots of other images that we could have used. And it would have worked equally as well. And there are many ways to customize these images.
29:42
You can customize and enable features for certain hardware, for your distro, for an image. So there are really many flexible options here. This means that you can have, for example, a certain set of images for debugging purpose
30:00
with more tools, with more logging enabled on them. And you can have a more secured one for production that you actually send to the customer. So it's a really, really flexible system. So now that we've actually built a Linux distribution, we have customized it. It's time to actually get it, build something that can run on hardware.
30:24
But in order to do so, we're going to need support for our board. And to get that, we need something called a board support package. And so we're going to now get a board support package. We're going to add it and create an image that actually uses this board support package.
30:44
So one thing to remember here is that we want to run it on the Raspberry Pi. But basically, this could be any hardware that you have a board support package for. If you build your own hardware, you could make your own board support package and get this distribution running on it. So it's very, very flexible.
31:03
You can have different targets and just change what board you want to run on.
31:31
So I have already cloned the meet the Raspberry Pi project. So I already have it here. So if we see here.
31:43
So if you check it out, meet the Raspberry Pi. It comes with three default images. The RPI basic image, the RPI hardware up, and the test image. So now, just like we did when we extended core image minimal,
32:04
we will now make our own image and we will use it to extend the Raspberry Pi basic image. And in the same way, we will install our own software on it and build an image containing that. So what we're going to do is we're going to go into our own layer again.
32:28
Core images. And we're going to use RPI. And we're going to, in the same way, we're going to require this core.
32:58
So did I get the spelling?
33:00
Require this core images RPI basic. Yeah. And we're going to do the same thing. Image installed. So now that we're building for another target, we're going to initialize a new build environment.
33:22
So we're going to do the same thing again. We're going to source. We'll initialize build environment script. We're going to just call build. And as we can see here, if we check out, we only have three layers. So the first thing we're going to do is we're going to have to add our two layers again.
33:53
So we're adding the meet the Raspberry Pi layer now. Getting hardware support. And we're adding our own squid.
34:06
There we go. And now we're ready to run. So the first thing is that we will specify a machine here. I will show you how to set this configuration in just a moment.
34:20
But for flexibility options, we're just setting it when we're building now. RPI. Squid. Send it here.
34:41
Misconfigure this. Yeah, sure. Raspberry Pi. So spelling important. So we're going to see now that the machine configuration has changed.
35:03
As we see here in the top. But now, let's go up. Here we go. But we are now targeting the Raspberry Pi. So we're basically building for different target with no configuration required.
35:22
We are, the reason it says Ubuntu here is because the build server I use is Ubuntu. This comes up as a question sometimes. And the distro name is Pocky. Because we haven't really set it. So now we're actually building a root file system for the Raspberry Pi.
35:43
And this image will be bootable. If you use it, you can write it to an SD card. Or you can boot it from remote. It will work excellently. So let's see here. And since, there we go.
36:04
So since it's taking a little time, I will just wait for it. It doesn't really give us anything. So and these images are then available for you. In deploy. This and for machine Raspberry Pi.
36:21
So in the temp directory deploy images. There will be, here we have the completed image. And this image is bootable. That's actually how easy it is.
36:41
So what we've seen today is that we've built a distribution. We've customized it. And we've added hardware support. We've discussed some recipes. We had discussed layers. And so on. Here is the GitHub repository that I have full instructions for.
37:01
Please feel free to use it to spread it. If you want to use that hackathon, just feel free to use it in any way you like. Just spread the word. And so we have really just scratched the surface here of what Yocto can do. There are many more fantastic aspects of it.
37:21
It can do package management. You can use it to build, for example, SDKs. You can use it to build kernel recipes. There are lots and lots of things to discover. And I hope that you'll have really fun doing so. If you like a book, I got this book last week.
37:42
And I'm really sad that I just got it last week. Because the parts I read have been really, really good. So I think that I can really recommend this book. I think that this presentation would surely be better if I got it earlier. So I hope that by now that you got some feeling that maybe,
38:01
even if you don't think that Yocto is the coolest project in the world, you at least think that it will be really interesting to try it. Now, if you have any questions, I'm glad to take them. Or if you want to discuss it afterwards, please feel free to come and ask me afterwards. So thank you very much.
38:26
Yeah, thank you. I haven't seen that. But, I mean, it's not...
38:41
Do they run Linux? Oh, then it shouldn't be impossible. I haven't seen it, but I'm sure that it's there on the way. Then it's not impossible. I don't know, but it might be on its way.
39:14
So you're asking what distribution it will look like? I don't believe it will look like any distribution.
39:21
It's basically its own. I mean, we are building our own Linux distribution, so it's not based on Red Hat or Ubuntu or anything like that. So, I mean, if you want to make your own custom Linux distribution, there are different ways of going. You can do the Linux from scratch approach,
39:43
where you just take exactly what you need and you put it together, or you can, like, customize an existing distribution. And this is somewhere in the middle here, where we have recipes to define on a higher level what we want to add to it. So I don't think it draws from any distribution in that way.
40:02
It's its own. Thank you. Do we have anything else? Yeah. Yes.
40:20
So the question was, if we build with the package manager, do we have to host it themselves? I'm not aware of there being any global package. Yeah, I'm sure you could probably pull in the packages from other distributions. But I'm not, I won't swear by it.
40:41
I think that you might have to host them yourself, and there are tools to actually do it. But I'm sure if you can actually pull someone else's. Thank you. Do we have any more? Well, thank you very much for coming.