 Hello, my name is Jessica Zhang. I work for Intel Open Source Technology Center and mainly focus on the YAKTO ADT. So basically is what Cam has been referring as SDK. We call it application development tool case and the Eclipse plug-in. And I also been actively involved in the user experience tools like Hub and there's a Web Hub. So I know this is the last session. There's a Luckily, there's a with cams talks and also especially there's a usage model and the flows basically cover lots of the up front, the contacts and the knowledge base that people need to know. So I'm going to talk about this. The talk is going to build up some concept level of what is the application development tool case and what's the usage flow and rows. So this part should be very easy for people to understand now with this mentioning of prior sessions. And then I'm going to talk about the YAKTO projects Eclipse plug-in. And so how it can be used as an IDE, as an environment for both the application developer and system developers. And also with this IDE, we know this YAKTO projects is really not just about the build system. It's really an umbrella projects and underneath it contains lots of tools. So within this Eclipse plug-in, you can interact with all these YAKTO projects tools. And all of this, I've created this as Tom did for the kernel, a self-guided hands-on lab. So it's posted on the YAKTO projects website. By following that, each lab session basically gives you the first-hand experience and playing with the YAKTO projects, the ADT Eclipse plug-in and also the tools like a hub and the YAKTO BSP. I'm probably going to just to speed up and also focus a little bit about the last item is the ADT and Eclipse for cross-compile kernel modules. This is something that's recently has been live topics on the mailing list. And since a usage model, a new model, there's some people that are interested in and they are developing their load-book kernel modules by using the kernel source, they're using, trying to use ADT and also the cross-development environment, not on the targets. So I'm going to just walk through how basically was the required steps and how you do that. So you've seen this and basically with the system development, you produce a cross-2 chain, which is the SDK. And also there's two key components for application development, one is the cross-2 chain and the other is the SysRoot. So basically the SysRoot is your target root FS that's extracted. So that gives you exactly the same contents as your targets, that allows the application developer to develop their application against. There are many three ways to set up your ADT, there's a cross-development environment. So basically that's why I talk about ADT setup. I mean, that's the two-chain and the SysRoot. So one way is the SDK target. So this is basically when you do this bit big, there's a meta-two-chain or meta-two-chain GMAE or SDK. And also the latest, the new one-three feature is create the two-chain target image by doing this bit big, your image name dash populate SDK. So with this target, it basically contains both your two-chain and a SysRoot, and especially if you generate this using the matching you, there's a target image that SysRoot contents is exactly what you have on your targets. And the other one is the ADT installer. So with the ADT installer, it requires, first of all, it depends on the package format is IPK. And it requires you have needs to set up a pre populate the repo based on your built outputs. But what it does is give you the ultimate flexibility to allow you to map in your two-chain and your SysRoot setup. So in this way, with the SDK target, basically you have a two-chain and your SysRoot is towards one target. With this ADT installer, it's using a configuration file, allows you to set up your SysRoot. Maybe that's kind of using different RoodFS, this image RoodFS, or different for different architectures, that's the two chains. And the third way is, let's say there's a person, there's both a system and application. So the top two is mainly for a true application developer, which doesn't need to interact with BitBag, or doesn't need to interact with any metadata. So basically, he or she is just behind it over by a system developer, either a table or this configuration file, and install against a repo. And for this, there's a person, maybe there's both needs to interact with both the metadata, and also needs to develop the application for the final image or targets, then there's a way that you can generate the two chains in your metadata environment, is by doing this BitBag ID support. So all of these three models, the details, is explained in the ADT user manual. For 1.3, there's improvements for ADT. 1, as Cam has mentioned, this allows you to generate the image matching SDK. The other one is now the two chains is not as a fixed location. Now the two chains, basically, can be installed at a user-specific location. So this is mainly just a graphical flow. You use the Yachto metadata to do the customization. You do run a pocket build. This mainly focuses into the system developers. There's an area of the main. And the output of that is the package repository, and also the image for your targets, and also the ADT. And the target's image and ADT can be used by the application developer to further develop applications that go under, that go on top of the final targets. So that's the fundamental of how you set up with the Yachto projects, how you set up ADT, what is your cross-development environment. And the Yachto project's Eclipse plugin is mainly for developers who wants to use and within IDE environment can interact with all sorts of things, Yachto projects offerings. So that's the main motivation of the Yachto projects Eclipse plugin. And it is built on top of the extensions of this widely adopted existing Eclipse upstream plugins like CDT, Linux tools, and RC and PCF. And it's integrated the ADT, there's a cross-development into the CDT, so then it's seamlessly integrated and allows you to use the ADT cross environment to do your application. And also this is using the RSE, the OHSH and TCF for this remote interaction. So mainly there's people, developers who are looking for using an IDE, they not only want to just build their application, they want to allow them, without leaving the IDE, allows them to this remote debugging, deploying, and playing interacts with the remote target. Yes? It's been a bit of a lot of acronyms in there that I don't have a technology. OK, sorry. So the CDT is mainly the CDT means there's a CC++ development toolkit. So that's the environment for you to writing CC++ code in Eclipse. It's just like Vero Studio. Otherwise Eclipse can develop for Java code. And so this is the Linux tools project. So it has the auto tools. So Eclipse is more like a framework. And everything is called a plugin. So it has lots of subprojects. So you basically, based on what you want, you just add, keeps installing this in these frameworks or the foundation, what are the plugins you want. And each plugin, so these are the main Eclipse subprojects, all these kind of like standard plugins. Those people, mainly for the embedded developers, they are interacts with. So Yachto projects and also the Eclipse, how the Eclipse framework works is like a big platform. So you add what you want. And on top of what you want, you also can extend what you want. So the Yachto projects Eclipse plugin is, so these CDT and Linux tools provide you those remote tracing tool support, auto tool support, all those kind of things. And RSE stands for the Remote System Explorer. So that's mainly for you using different protocols, remotely interacts with the file system, the files, and do the terminals, the shells. And TCF is another framework for the remote interaction. So that's for target communication frameworks. That's then for what TCF is. And so the Yachto projects is either there's a build on top of it, or extend existing upstream plugins, so add the features. And also this integrated was the Yachto projects. There's an add-ons to it, to them. So am I to, is it, people get a basic idea? So the Yachto projects Eclipse plugin when you work with the Yachto projects, there's system developers and application developers. So the IDE, it can be used for application developers. If the IDE is used for the application developers, mainly they're using the ADT crowd setups to build their applications. And then after they build their applications, they do this remote debugging and remote deployment. And then that's just typically that's how you do the CU works. So first thing first you need to do is you need to configure the IDE to use your Yachto projects. There's a crowd setup. So this is one of the main. And this is maps to this. So standalone pre-built tool chain, that refers to this, you set up your ADT either where there's a pre-built SDK turbo using the ADT installer. And the build system derived tool chain, that's the one that you have the metadata I mentioned where the big, big metadata support. So the tool chain is embedded in the metadata. So that's basically three ways you can set up your ADT and it's all reflects here. It depends on how you set up your ADT. And then you need to configure your Eclipse IDE accordingly so for it to pick up the right sets of tools and SysRule to build your application against. And the target options. So you can choose either using the QEMU as your target or use your external hardware. So if you choose QEMU, then it needs to provide what is the kernel file and what is the. So if you choose the QEMU, the Yachto projects, the feature is you provide the kernel file and it's using the SysRule. As we mentioned, the SysRule is what your target root FS extracted, flattened out as your SysRule. So those two is enough to boot up your QEMU. And that's a good way to say if you don't have you real this hardware ready, you can boot up the Qemulator to simulate your true hardware. Yes. You mean that's a then that's basically that you're saying that you just fall into the forebacks so that you develop application and run just on your native run. Then yeah, that's what I'm saying. You don't need this because where my things go? Is there somewhere? Sorry. This one here. Oh, no. No, oh, jeez. Uh-oh. Where's my step go? Now I don't know where it is. So can I open this? It's PowerPoint. You don't want PowerPoint? No, no, no. I'll open my file. Where's PDF here? Where'd the? There it is. Oh, man. OK. So after you configure your IDE to use the ADT, then as I said, we introduce a whole set of Yachto projects, projects templates. So that's quickly that's helped you to start building you this application projects using Yachto ADT. And this is the screencast. So once you have the projects and you do the configure, remember you have the IDE-wise of the ADT configuration. So by default, you newly, because you're choosing one of the Yachto projects, this ADT template, and it inherits your IDE-wise set-ups. And then hopefully you can see the CROSS2 chains and all those things. And the sysroute, the libraries, the headers, it's going to be used to build your application. And the other thing is by default, inherit your IDE-wise, but it allows you to change your specific projects. Let's say you first develop against this x86, and later on you want to the project moves to this arm. And you can just change you this specific project settings for different settings, the CROSS development needs. And this part is mainly the CDT allows you. So that's the UQME instance you build up. And it can be a remote hardware, true hardware as well. And this is the CDT session that is bring up on your development host. So that's basically summarized for the main flow. You compile, deploy, and debug. That's for application developer perspective. And this is we also support for the system development needs. So for system developer, mainly, they need to interact with the metadata. To support that, we introduce a new project types called BitBit Commander Projects type. And also, here, if you install our plugin, you can, by default, that's project type is available for you when you do the new projects. So you create a BitBit Commander project. And it also gives you a wizard allows you to either bring in your already get cloned from the command line, the metadata, or it's going to clone one for you and bring in the direct review in this tree view. The nice thing is, with this metadata editor, and you see the syntax is highlighted, so it's much easier for you to rate a recipe files and to edit files. And also, with the variables, too bad I don't have the setup. It has the power, the capability. So if you go to a variable there, and then it's going to prompt you what is the variable the value is. Yeah, that's for the system developer. And then, within IDE, it allows you to interact with other very useful tools and powerful tools of Yachto projects. One is with this BitBit Commander project, and you go to the projects, and there's a manual option called launch hub. So that's going to launch the hub using this. You just modify it, edit it, the metadata, and allows you to build customization and all those things. The other tool is Yachto BSP. So we have created a plugin for the Yachto BSP tools that Tom mentioned. So Yachto BSP tool is a very, kind of like, works through you, there's a step by step, allows you to create a standard BSP layer, and then allows you to further customize your kernels and all those things. And with this Eclipse plugin for the Yachto BSP tools, it's really there's a wizard like the steps for you. So it's much more simplified things. So this is the screencast of the Yachto BSP tool. So it's very simple. So after you tell what your metadata is, and all this dropdown layer is going to be by interacts with the Yachto BSP populate for you, and you just kind of make your selection and go there. And this is after you have the metadata, you click on launch hop, and this is the main hop view and from there, you can just do your build customization. So all of this, it doesn't matter. I've created these self-guided lives. So basically by following this live, you get a play around and see all of this. There's an application developer, a system developer. There are five lab sessions fully covered there. So now I'm going to talk a little bit about using the ADTN Eclipse for cross-compound kernel module. So this is using cross-2 chains and sysroot by the Yachto projects. And this requires you sysroot the kernel mesh targets and must contain the kernel depth. So by default, our sysroot or image doesn't contain the kernel development sources. There's two ways you can achieve this. One is that by default, we have this core image that is SDK. So that's mainly the development vehicle image for people. So by default, it contains this kernel depth. Or you can have your own image. And in the local.com files, add image install append kernel depth. So in that way, that image, the root FS contains the kernel depth. And when you flatten it out as your sysroot, you should have your kernel development package there. And then after you extend it, that's your sysroot. So go under your sysroot directories. That's a user source kernel. And you need to do this following two commands. What it does is when you build a kernel module, it requires a whole bunch of the scripts and the tools. With that, because we don't distribute, and those tools build out, requires you host. Depends on your host, wherever your host. So there's no way we can distribute that into the images. So that's the thing you have to build yourself. And then after you have done all of that, then if you decide to develop in the Eclipse IDE, so you just go basically, all of this is the standard way. New projects, make sure it's a make file projects and choose the empty projects. So in the new projects, here's an example that you create two files, or if you already have existing files, there's a way you can just import the files into the empty projects. So this is my sample, the hello kernel, the module. So it's nothing fancy, it's just kind of create what is in it. It's print one message, one exit. It's there's a print out different message. So this is the make file. And the make file, basically, you need to specify the arcs. And this arcs maps when you do this, remember, that's when you build you the kernel tools. That arc needs to match this arc. It's whatever your target arcs. And you need to specify the cross-compile. And also, the other part is your kernel directory is. And with this, it's going to pick up the correct components you want to use for cross-compile. And the other thing is if you decide to do this, so there are two ways, after you have this make file and there's the kernel, there's the module, there's the C file. If you do it from the command line, with the ADT, it has an environment setup file. So always, if you want to do from the command line, you need to source this environment setup file before you do this run across compile. Because that's going to set up your cross environment, the paths, everything. So it's going to change your paths to point to look for the correct cross-compiler link or all those things. And so from the command line, you need to source that environment setup file. So the environment setup file is followed by dash and what is the target arcs? Let's say there's an environment setup, i586, something if you want your target is an x86 space machine. And you do the echo paths. So if you want to do it in the eclipse IDE, there's one extra thing you need to set up. In your project files, then you need to right-click on it or you just go to the projects property menu and there's a build environment. So you need to add a path variable and the value should match to what the path setup in this environment setup file. So basically, you need to tell the build where to find your cross tools, to change all those steps. Then after you have all this set, if you do the build projects, your kernel module will be cross-built. And then you can use the RSE. It's very simple. That's too bad I don't have that machine. I can do a live demo in the eclipse. It's so simple. If from a command line, then you probably have to SSH into your targets and then let's copy over and then do those kind of things. With RSE, you just create a new connection to your remote that's the target. And then it allows you just, you have a local that's a file and you have the remote that's a file system. You just drag and drop copy over and also it's bring up a long to remote terminal just add your fingertips and you can type whatever command. So to test out, you newly create the kernel module. So it's really the ones you have all this setup is very similar to me. So that's basically what I have. Any questions?