 Hi everyone, thanks for joining me today. My name is Bill Lamey. I'm one of the co-founders of Express Logic and also a program manager now with Microsoft on the Azure RTOS product. It's great to be here today. I have a brief overview of Azure RTOS in conjunction with ST and I guess let's just get started. I guess the first thing to talk about in terms of Azure RTOS is what Azure RTOS means. Azure RTOS is the umbrella name for the runtime products, including the popular ThreadX kernel from Express Logic, also including the middleware, FileX, GUIX, NetX, NetX Duo, and USBX, virtually all of the X's are covered. Anyway, the Azure RTOS name is now the new Microsoft branded name for that collection of runtime products. So just at the very high level, it's the same quality and breadth of service that was there with the Express Logic products before, but just under a new brand name Azure RTOS. What is an RTOS? We'll go quickly over this because this audience is pretty savvy with what an RTOS is, but at the highest level, an RTOS is used to allocate processor time. So the application doesn't have to do it in a big while loop or some other mechanism. When you think of an RTOS, generally you want to think small and fast, something that has a dedicated purpose and something that requires real-time deterministic processing. In most cases, the RTOS is used on a processor that has less than 512 kB of memory, maybe less than 200 megahertz, doesn't require an MMU. That said, there's plenty of applications with Azure RTOS that deviate from that. So there's a ThreadX SMP, for instance, is a full SMP version of ThreadX, and that's run on really high-end processors like a Cortex A53, for instance, that might be quad-core, gigabit processing speed, megabytes of memory. In those particular cases, Azure RTOS is used for the deterministic processing rather than the small footprint. All of that said, typically you'll find Azure RTOS and MCU small constrained devices more than the high-end parts. What do embedded developers want in an RTOS? This varies greatly between different embedded developers. Generally, it's allocating processor time, meeting real-time requirements, fitting into small memory areas, dividing up the application into pieces instead of having everything in one big while loop, and then also the middleware. Having access to file system, network stack, GUI, USB, all of these things are typically what embedded developers want in an RTOS or a runtime solution. According to the 2019 UBM Embedded Developers Survey, these are the top 19 reasons developers chose an RTOS. I circled, circled. I put a red square around all of the real-time or processing requirements, so we have real-time capability, context switch time, scheduling efficiency. Those are more speed-oriented or overhead-oriented. Then the green boxes is memory footprint. Then finally, there's a box on safety. Azure RTOS specializes on industrial functional safety certification. I put the blue box around safety certification. But if you really look at all of these categories in terms of what embedded developers are looking for in an RTOS, really Azure RTOS meets most of them. If not all of them or is best of class in most of them if not all of them. Just to give the audience an idea of what embedded developers have actually said they wanted in RTOS in a survey, the most recent survey I think. As for Azure RTOS, the things to think about with Azure RTOS always small, fast, and safe. On the size side, if you just use the basic scheduling and ThreadX, maybe two threads just relinquishing control between each of them, you're looking at a 2K byte instruction area footprint for Azure RTOS. On the speed side, Azure RTOS typically offers API calls in less than a microsecond and context switching in less than a microsecond. Then on the safety side, there's nothing better than 23 years of field proven usage of an RTOS and Azure RTOS or ThreadX has been in the field since 1997. We also have a bunch of functional safety certification. We have taken Azure RTOS ThreadX, FileX, GUIX, NetX Duo, and USBX through SILV4, ASIL-D, Medical Class C certification. That means that these products and components are suitable for use in functional safety certification, whether that's automotive, industrial, medical, or anything that needs that level of certification. In addition to the core principles of small, fast, and safe, Azure RTOS is a comprehensive, easy to use solution as well. We have all of these middleware components, in addition to the kernel. Then we also have support for most of the popular embedded architectures and development tools. That combined with the fact that we've created all of these products in-house, we haven't purchased them or accumulated them from other sources. They all have the same look and feel, the documentation looks the same. It's really a totally comprehensive solution. Then lately, since our acquisition, which was about a year and a half ago, since we became part of Microsoft, we focused more on the IoT connectivity, making sure that a device using Azure RTOS can connect to Azure IoT the easiest way possible, and also using the least amount of resources. These general areas are the high-level value of Azure RTOS. Whereas Azure RTOS being used today, well, lots of places. According to VDC research, as of 2017, Azure RTOS was used in 6.2 billion devices worldwide. Most of the devices or a huge chunk of them are in mobile phones, not the core operating system in the mobile phone, obviously, but in peripheral chips around the core operating system. Cellular modem, Wi-Fi, Bluetooth, GPS, any of the peripheral chips that surround and provide function for the central processor on a typical phone, would be Azure RTOS candidates. But we scale all the way down from small Cortex-M devices and wearables, through medical devices, through home security, home automation, through printers. HP is one of our big customers. Even in some space probes, the Mars Reconnaissance Orbiter uses Azure RTOS ThreadX in its camera system. We were also in the deep impact of space probes in the camera systems there, too. So virtually everything from really high-deploy devices to deployments of two or three in the space situation. A little drill down in terms of where the 6.2 billion deployments come from, you can see that mobile phones is a huge chunk of that, roughly 3.4 billion. We believe that over time, and especially with the license arrangement with ST, where end customers from using ST parts have a free production license to use Azure RTOS, all the components in their designs, we believe that all the other numbers will start evening out a little bit more. Traditionally, we've been kind of heavy on parts that were super intensive and required the very best RTOS there was out there, customers willing to pay money for it other than the free solutions. So now with the Azure RTOS being free, effectively, it's certainly in the context of customers using ST parts, we believe that these numbers were gonna even out a little bit more. And I should mention too that the 6.2 billion number is as of 2017. The run rate for that, the number of deployments per year, extrapolating out to like 2020 today would put that over 7 billion easily. We need to go back and get that refreshed, obviously. Azure RTOS system components. So Azure RTOS, as I mentioned earlier, is the umbrella name for all of the former ExpressLogic components, the runtime components and also host components. And that includes the kernel ThreadX, the FatFileSystemFileX, the USBX stack, which provides a host and device USB support, and then NetX and NetX Duo, our TCP IP stacks, and then GUIX and GUIX Studio and Tracex. GUIX Studio and Tracex are host tools used to help developers using the runtime tools. GUIX Studio is a graphics design tool that runs on the host, where you can do most of your UI design, and then when you're ready to go, you press a button and that'll generate some C codes that can be imported into an embedded project where the GUIX 2D graphics runtime engine is running. And that way you can do most of your heavy work in terms of your UI design on Windows, system and not have to do the nitty gritty programming actually on the device side. Tracex is a graphical event viewer for real-time events that happen on a ThreadX based system. So you would enable tracing on ThreadX and then enable it and then once you're ready at either a crash or a breakpoint, whenever you wanted to look at what has happened in the system, you would export the trace buffer up to a host and then you could graphically view that kind of like a logic analyzer, but system events in terms of the RTOS on Windows. And that will show you all context switches, all API calls, when threads are resumed, when threads suspend, basically everything that's happening in the system is represented graphically. Tracex is always interesting to me because every time I look at a trace buffer, I see something I didn't expect. Playing computer in my head versus reality is always kind of a fun checksum to have. So I'll go through a brief overview of each of the Azure RTOS components, starting with ThreadX. As I mentioned before, the minimal footprint for ThreadX is 2K bytes and we're looking at sub-microsecond processing through the API set, SILV4, ASLD, Medical Class C, Functional Safety Certification. And then ThreadX has some advanced features that aren't found in other RTOSs. These include preemption threshold, which is kind of like a two-priority system where threads have a priority when they're scheduled and they have another priority once they're scheduled. And you can use this to reduce context switches. There's even academic research that shows how you can use preemption threshold to guarantee a schedulability within a set of threads. Anyway, it's kind of a neat little technology that is unique to ThreadX. We also have event chaining. Everything that you, all the products, including ThreadX, have auto-scaling. And auto-scaling is basically the idea that only what the application uses comes into the final image. So if you don't use, for instance, in ThreadX, if you don't use event flags, they don't appear. If you don't use byte memory pools, they don't appear. But if you use counting semaphores, they automatically are brought into the image at link time. We also have an add-on component to ThreadX called ThreadX Modules. And ThreadX Modules allow the application to build a separately linked and located piece of application code that contains one or more threads. And that application code, that module, is created in a position-independent code and position-independent data format. So it can be basically loaded anywhere in the address space and executed. And the nice thing about that too is that for parts that have an MPU or MMU, we can put a memory protection around that module code. So it's a way of kind of getting a lightweight process inside of what is a traditional RTOS kernel. And then finally, a consistent APIs, extensive out-of-box examples. There's lots of developers that have already used ThreadX out in the marketplace. So that's a quick overview of ThreadX. Moving along to FileX. FileX is our FAT12, FAT16, FAT32, and XFAT file system. The minimal footprint for FileX is around nine K bytes. And it too has the functional safety certification like ThreadX. On the advanced feature set, FileX has an optional fault tolerant mode where we will journal file system activities. And then if there's a power loss or interruption of any sort on the next boot, we can figure out whether to either discard what was going on or complete what was going on and basically keep the file system intact. So there's no ability to corrupt the file system on a power loss or reset or some other system event where things don't complete in the file system. We have extensive performance advantages in FileX. We have a bunch of different caches for FAT entry tables, logical sectors, even directory entries. So depending on how much memory you have, you can get a lot more performance out of the file system. We have the ability to do a pre-allocation of clusters. And we also have an add-on component to FileX called LevelX, which is a flashware leveling technology. And that operates on NOR and NAND flash parts. And again, FileX auto-scales. So only what you use of the file system comes into the image. And again, it's all written from the ground up by our engineering team. So it has the same API, same documentation layout. And then there's a good amount of out-of-box examples. GUI-X is our 2D graphics runtime engine. And it has a companion part on the Windows side where you can do your Windows design using a Windows application and it generates code that runs on the target. Basically about 13K bytes for a minimal system running on the target. It's all pure C, no C++. So it's a pure C GUI package, even though the concept of widgets and everything is very object-oriented like, it's still written in C. Again, it's a CIL-4, ACIL-D Medical Class C certified and has extensive widget sets. And it scales automatically like ThreadX and the other products. And again, consistent API because it's all written from the ground up by our engineering team. Oh, I should also mention that GUI-X does have the Chromart integration as well. So it's integrated with the accelerators from ST. NetX Duo is in terms of the cloud side of things is a very important piece of our equation because it's indeed the TCPIP stack along with the security protocols like TLS and MQTT that gets you the base cloud connectivity. In terms of size, for a minimal cloud connectivity, NetX Duo comes in around 50K bytes. And that is, that's using ThreadX, NetX Duo, the TLS stack and MQTT. And with that, you can make a direct connection to Azure IoT Hub. And that's about as bare bones as you can get. And we think that's the best of class in the industry in terms of getting a small device to connect to the cloud. In terms of performance, NetX Duo is a zero copy implementation so we can get near wire speed and at the same time using minimal CPU usage. And again, NetX Duo is still for ASL-D Medical Class C Functional Safety Certified. We've also taken the TLS stack and the software crypto library through security certification, EAL-4 Plus and FIPS 140-2. And just you can see on the block diagram that there's lots and lots of components with NetX Duo, things that you don't normally see in a typical embedded RTOS TCP IP stack like maybe MDNS, DNSSD, PTP and so on. So it's a really rich set of components, also a rich set of cloud connectivity components and security components. IPsec is another thing that you don't generally see in a lot of embedded TCP IP stacks. This is just a diagram showing the cloud connectivity pieces. You'll see Azure RTOS ThreadX and basically the TCP IP stack with IPv4 and IPv6 support, TLS, MQTT. That gives you the base connectivity to like Azure IoT Hub but if you want easier connectivity we also have integration with the embedded CSDK and with that you get all sorts of other things including the integration with Azure Security Center which is now called Azure Defender. And then there's also plug and play support and all the neat things that you find, all the neat services on the cloud side but we make them easier through the embedded CSDK on the device side. And all that's integrated and has APIs that are similar to other Azure RTOS APIs. Azure RTOS USBX is our USB host and device stack. You'll see a fairly small footprint, lots and lots of class supports, one of the richest class supports of USB stacks available. It's going through the SILV4-ACLD Medical Class C certification today. And again, it's like all the other products in terms of consistent API, extensive out-of-box examples and device host controller integration. I mentioned this a little bit before in the NetX Duo section and then earlier before in terms of the presentation. After acquisition, the former ExpressLogic team now a Microsoft team has put a lot of work into making the IoT connectivity that much easier from the device perspective. And the key component in that is Azure IoT embedded SDK. And that's where all of the magic happens in terms of integrating with Azure Defender, plug and play support and just making things easier with a nice set of APIs that look like Azure RTOS APIs. And all of this is done with a kind of a minimal footprint mindset as well. The new embedded SDK, for instance, is something that ranges from five to 10 K bytes in general in terms of instruction size. So it's not a bulky big thing for embedded devices any longer. And so now you can really leverage the ease of use to Azure IoT without suffering a huge memory penalty. I mentioned Azure Defender. This integration is really encapsulated inside of the embedded SDK, but Azure Defender leverages the security capabilities of Azure. So we can, so just as an example, when it's enabled by the device manufacturer through the SDK, we can send telemetry information to the cloud that has like IP addresses, for instance. And then Azure Defender can analyze those against Blacklist and see if, for instance, there's something that the device is connecting to that isn't a good idea. And then it'll alert the appropriate folks on the cloud side to let people know that there's a potential security problem. So all of this integration is easy to use and basically just requires an enable API on the embedded SDK side. So we're real super excited about the relationship with ST. Prior to Acquisition Express Logic was a premier partner to ST and certainly now with Microsoft, we're strengthening that relationship, many, many fold over. We already have support for most of the core architectures on the STMCU and MPU family. We also support many of the IDEs, the, you know, anything from STM32Q by DE to IR to Kyle. And then we also are doing all sorts of integration on the cloud side of things. You can find some of this sample applications on GitHub today. We'll be sharing that link a little bit later in this presentation, but there's sample applications for ST. We're also working with the ST engineering team, you know, continuously on a project to basically get all of this inside of the ST delivery mechanism. So in addition to what we have on GitHub today for free access, all of Azure RTOS and all of the integration will be available directly inside the tools themselves. So it'll be all ready to go pre-integrated, ready to run. So there will be virtually no effort, you know, in terms of putting together any kind of Azure RTOS application. And then of course, as I mentioned earlier, you know, we, ST has basically purchased a license. So all ST customers on the STM32 MCUs and MPUs will have a free license to use Azure RTOS. So it's kind of like the best of all worlds, all pre-integrated, you know, down the road. And then freely licensed. So there's no possible obstacles in terms of using Azure RTOS and ST parts. And you get to leverage all of the commercial grade Azure RTOS components and certification that we've had for many, many years. And this is the Azure RTOS GitHub page. I mentioned briefly the samples repo. That's where you can go to find pre-made turnkey zip file samples for Azure RTOS. And then you can also see all the other components. The full source code is there on GitHub. GitHub is applications or developers are able to take what's on GitHub today. They're able to develop with it freely, explore freely. It's all full source code. All of our products are there. And then in addition, you know, as we go further with ST, all of this will be actually incorporated inside the ST tools. So you won't have to, you know, pick it up from GitHub or, you know, have two sources for, you know, for getting Azure RTOS. So with that, you know, we think that this combined solution with ST is gonna basically really speed up time to market for our mutual customers and then leverage the benefits of Azure RTOS. The reliable performance, the small footprint and all of this will, you know, basically reduce risk too. There's no, you're not gonna be developing with an RTOS only to find out at the end of the project that it's too slow. So now you're gonna have ability to get industrial grade Azure RTOS, certified Azure RTOS and field proven Azure RTOS into the designs, you know, right away without any worry, without any risk. And then of course, for Azure embedded designs start migrating to the IoT, which they naturally will. You'll have the easiest path to Azure IoT with Azure RTOS. Here's a slide with some resources. Azure RTOS on the Microsoft website is at azure.com slash RTOS and GitHub, the GitHub repose, you can either search for Azure RTOS on GitHub or just go to github.com slash Azure RTOS and you can find all the documentation on the web as well. I think I'm probably getting close to my time budget. So I wanna thank you for sharing your time with me today. Hopefully that was helpful and there'll be more deep dives coming for Azure RTOS. Thank you very much.