Hi, it's Ed again. Welcome to the arm profile booting and initialization topic. As usual, we've got some learning objectives for you. The first one is to develop startup initialization code. We'll show you how [inaudible] cortex micro-controller software interface can make that easier for you. The next thing is to write memory description files. These are files that pass to a link at all and they allow you to describe the devices' memories that you're working with and determine where different parts of your application will end up on the device in terms of their location at load time and also run-time. Thirdly, we've got an objective on how to choose and use the C library appropriately. That might be something that you're not deciding to make use of. You might be trying to avoid the C library, but at the same time, you might want to make use of some of the function, and let's see. We'll discuss the different options there and how to re-implement and retarget certain library functionality. Then finally, the main goal of this topic is to get you to the point where you can create an executable image that's suitable for booting on your device. When you're working on any embedded software development, the idea is that you'll want to go from this point here where maybe you're working at your desk may be a PC or laptop. Perhaps you have a simulator running on your computer that's simulating the arm processor that you're working with. Milliohm device that you want to work with. Or perhaps you're connecting to some development board and probably building an application, downloading an application to simulate to a development board into the memory on that system and then maybe running a simulation, seeing what happens, maybe gathering some trace information to test your software on early stages of the project. But eventually, you'll want to move over to the real device perhaps that is being manufactured at the end of the day. Maybe there's some software that's going to end up in a payment machine or a drone or something. To get from this situation over here where we're working in our test environment to the full production environment, on the right-hand side, there are lots of things that you need to be able to achieve in order to get there. In the process of moving from that development environment to a standalone embedded application, a few things to consider are the application startup code, the memory map of the target system that you're working with, and how the C library is used by the application, wherever it's used at all, and what doesn't have to be used. Throughout this presentation, we're going to be looking at those three things in particular, and showing you how the default behavior works. Then we'll move on to looking at how to move away from the default behavior. We look at the agenda. As just mentioned, we've got a section covering how compilation tools like arm compiler or GCC might behave by default. We've also then got sections looking specifically at how to write your own startup initialization code and move away from the default startup initialization code that might be achieved by a compiler tool. In particular, we're going to focus on CMSIS score and how that can provide you with some default templates to work with to get you started. We'll also discuss how that works from different users' perspectives. You might be someone who's developing software for a device already exists. But you might also be a silicon vendor who's designing a device, and needs to create one of these little startup initialization files from scratch. We'll cover that. We'll also cover some post-startup initialization topics that you might need to consider. Once we've looked at the basic initialization code that's required, we'll then move on to show how to describe the memory map of the device and what peripherals and memories exist on that device using a memory description file, something called a scatter file and ARM compiler or familiar with GCC, you might have come across linker scripts. When looking at the memory map of the device will consider how to set up memory regions for other important parts of the software that we're developing. Things like placing a stack and heap, making sure our software has areas of memory dedicated for those special parts of the software is for a static and dynamic memory allocation. We'll also look at some further memory map considerations. Just briefly touch on things like the NPU and show you a few extra tricks or things that you might need to be aware of in order to make sure that you can build your image and target it correctly at the memory in the system you're working with. Then, at the end of the presentation, we will look at retargeting the C library behavior to work for your system. That will depend very much on what functions you want to make use of in the C library. If you want to make use of the C library, so it might be that it's very bare metal application that doesn't require any library functions from the C library, you might just be providing all of the functions themselves. We'll look at that in some detail and cover something called semi-hosting, which is an interesting topic. We'll show how to avoid semi-hosting and also how to work with it. Finally, we will hopefully be in a position where we can build an image that's ready for booting, so we'll show you how to do that using tools from L4 of dumping GCC, and how to ensure that image contains things like debugging information so you can debug the image easily.