Become a leader in the IoT community!
New DevHeads get a 320-point leaderboard boost when joining the DevHeads IoT Integration Community. In addition to learning and advising, active community leaders are rewarded with community recognition and free tech stuff. Start your Legendary Collaboration now!
In essence – yes.
You still have a million scripts, they are just packaged nicely and called The Yocto Project!
Aha that’s insane that embedded linux is that huge, that the build tool is a project, as opposed to being shipped with a project.
Embedded Linux is that huge. A typical distribution contains thousands of files – but then a Linux system is meant to be for more heavyweight tasks.
If I wanted ‘small’ then I would go hand-rolled or just use something like zephyr.
I think so. It is just scale that differs.
well you want a good build tool rather than a small one
what is the scale difference would you say, I’m still looking at things very `baremetal`
I mean scale in terms of features, entirely based off, what each of them offers – yocto would be just more complex.
For example, I think it would take a lot to have layering in zephyr but is it even needed.
And look at the learning curve on yocto.
I know this has been explained before, but can you explain `layering` to a layman?
_Layering_ is simply having groups of related build instructions bundled in a ‘layer’. You can then stack those layers on top of each other, e.g:
You can then build up your final system by adding in layers that contain the useful stuff you need (and therefore also don’t include the layers of non-useful stuff you don’t need)
This allows for complex systems to be almost pieced together in a way that is manageable.
The scale is not clear cut.
For ‘simple things’ where for example you are ‘just’ reading sensor data and then either acting upon it to control something or pass that data upstream, a full blown Linux type system would probably be an overkill.
While I don’t know RTOS’s that well, but for more complex systems, where you may want to have task isolation (in Linux every task is isolated from each other, so that an issue in user-space with one task should not affect any other tasks) or if you just need more computational power, then Linux makes it easier, as the OS handles a lot of it for you.
The other things would be familiarity with the system (I’m always going to be biased towards Linux, as I ‘think’ in Linux and can see the solution faster in Linux) or if an essential library is only available for one particular OS.
When you are building your bike each layer is a like a specific group of things that serve a distinct purpose (grouping things into a function), so a layer could be the engine or custom seats. All the layers stack up and you have your bike. Building from layering allows you to build (and easily modify) your bike. Swapping the engine would be as simple as replacing or modifying the engine layer. This modular system gives you flexibility to create what you need while making it easy to modify without complexity.
so in this kind of world you don’t need to rebuild layers that have not changed. I.e my OS and Drivers havent changed but my application has changed so just use a cache for the former 2 and re build my application.
Almost like releases in elixir, but that’s a bundle as opposed to a build system.
In a Yocto Project – the caching actually happens at the recipe level. It is more like a `make` system – it only rebuilds the package if the _recipe_ has changed.
Miiiing, what in the world is a recipe. Is this like a list of dependecies and their versions?
A Recipe is the instructions in a Yocto Project for the how tos:
– How to download the source
– How to configure the source
– How to compile the code
– How to install the resulting files into the final image
The collection of files that actually end up in the final image are then a `package`.
Man I’m sorry this is becoming russian dolls. Is a package an executable then. Is this what a .deb is?
It is russian dolls!
A `.deb` (or `.rpm` or `.ipk`)package is an installable collection of executables. The recipe in Yocto is the thing that builds that package.
For a `.deb` or `.ipk` it is literally a tar file containing the files to be installed along with some pre and post installation scripts.
I have more questions, I will read first and maybe bring them. Thank you both for this awesome TIL
CONTRIBUTE TO THIS THREAD