Getting started with TI-RTOS

OK, so here's the agenda for this workshop. We start off with Chapter 0. That's the chapter that we're in, introducing the workshop, introducing the agenda, and embedded advantage and so forth.

So what's up with Chapters 1 through 4? Well, after we get done with the out-of-box experience in this chapter, we're going to go in and start installing the tools. So we're going to talk about Code Composer Studio. We're going to talk about the software development kit that they have for the SimpleLink processors, and then we're going to go through looking at that tools and software, getting a chance to learn about Code Composer Studio, and to dissect the software-- the SDK that comes with it.

Or whatever other tools come with the target.

Oh, yeah, all the tools that come with it. Then in Chapter 3, we're actually going to start looking at the GPIO drivers, and getting a chance to play with them. Basically, we're going to be blinking an LED in that chapter. But we're going to learn a little bit about GPIO and the drivers. So if you've never heard of GPIO before, we'll talk about that there.

And then finally, in Chapter 4, we're going to be looking at using drivers and interrupts. So how can we use that GPIO driver to interrupt the system, and also try to have-- we're going to have a timer interrupt the system. And if you think about operating systems-- we're talking about RTOSes-- one of the fundamental parts of scheduling or of having events going on in the system is hardware interrupts. And so we're getting our toes wet here, a little bit, with the hardware interrupts and looking at how drivers help us with that. And then stepping into Chapter 5, Eric, what are we doing with the green part of this?

OK, so Chapter 5 is really conceptually what is an RTOS? So if you go from a traditional embedded system topology where you have a while loop in main and you've got hardware interrupts interrupting that while loop, you've got basically two levels of priorities. What are the common problems with that?

What are the limitations of using a system like that, and how do we walk across the bridge of saying, hm, if we need to schedule threads this way or that way, we probably need a couple other levels of priority between those two? What are the benefits of that?

We even define the word "thread" in that chapter, don't we?

We do, actually. So that's more of a conceptual thing to-- when we talk about threads, when we talk about hardware interrupts, software interrupts, tasks and idle, what does that all mean? What are the priorities, and how do you create this stuff under the hood? It's really a conceptual part of what is the RTOS? What are all the terms? And so forth.

Chapter 6-- then we go, OK, now that you know some of the conceptual pieces, how do we actually create those objects in a real application and start using them? So how do you configure the BIOS services? How do you use something called idle, which is a very low-priority thread? And we're going to, again, blink an LED inside an idle function running at that low priority level.

So we're going to walk before we run, but that's really the mechanics of how do we configure a BIOS system and do something very simple? Then we start taking steps toward medium or advanced-- more advanced complexity-- RTOS application. How do you use tasks? What are tasks? What are the benefits of using tasks? How do you create them? How do tasks potentially talk to one another?

Then in chapter 8 is TI-RTOS instrumentation. If you want visibility, how do you actually instrument your code on the target side and then be able to actually see that, observe the responses to see the results of that instrumentation through a graphical tool called the RTOS Analyzer?

Chapter 9, we talk about semaphores. We use some of the code that we did in the first couple chapters-- driver code-- to post a semaphore to unblock a task, that then continues to do its processing, which is actually blinking an LED. Then in chapter 10 we talk about clocks.

This can be a very confusing topic, Scott, as we've taught this topic for many, many years. Lots of different processors. Lots of different timers. What are their uses? How do you set them up?

What are the defaults? Can I change the defaults? And what is the actual BIOS heartbeat, or tick rate, for the system? So we're going to be able to set that up, configure it, use it to trigger periodic functions, and then we're going to talk about some other timer-related topics.

So we actually introduce the timer in Chapter 4 and use it as a way to just generate hardware interrupts using the driver. But we get to learn-- I guess we leverage all that through all these BIOS services that have time-based features. It can really extend the times.

It's really important to understand what hardware-- what hardware timers-- actually exist in your system, because BIOS is going to use them by default-- or manually, based upon what the user sets up-- to do different things in the operating system. So both the knowledge of the target, as well as how BIOS uses those are both very important.

Chapter 11 is using mailboxes. So this is basic, fundamental communication from one task to another. How do we send information from one thread to another? Lastly-- last part of the fundamentals workshop-- is using events.

It will be quite an event, Scott, when we talk about-- you like puns. That was a terrible one. I need to work on my delivery, actually. Events are basically ways to signal different threads that part a happened, part b happened, and part c happened, and you can actually unblock a task based upon a logical combination of those things happening in the system. Quite cool.

So we'll eventually get--

Eventually, yeah. That was better than mine. Way to go, Scott. And then the bonus chapters.

Yeah, so what we talked about earlier with the bonus chapters-- we've got a whole bunch of them already in mind. And so as Eric said, as we get this out the door, start to look for additional chapters being added to the workshop.

And make sure you take advantage of those.