 Hi, and welcome back to another episode of Visual Studio Toolbox. I'm back with my guest, Suze Hinton. Hi, Suze, welcome to the show again. Hey, thanks for having me back. Yeah. So we're here, we're doing a series on Windows IOT Core Development, and Suze is back to do episode two out of that series. And what are we going to talk about today? Yeah. So today, we're actually going to run our very first Windows IOT Core UWP app, which is really exciting. And the app that we're going to run, it blinks an LED and an LED is just like a little light that you can plug into your breadboard. And because a lot of IOT projects don't necessarily have like a visual screen or any kind of graphics, we like to consider the blinky LED to be like the Hello World of like an electronics project. So normally you're printing to a console or something like that, but in electronics, the blinking light means, okay, everything seems to be working. Awesome. And in the previous episode, this is episode two out of our series, we talked about some of the fundamentals, right? Right. We said, what's a breadboard? How does the hardware server all work together? What programming language can you use? How do you build for it? So we did a lot of the conversational pieces, so people should go watch that episode of day one, but here we're actually going to jump into Visual Studio, right? This is the first time and from this episode forward, it's all about running Visual Studio and doing something with the devices. So it's exciting. Yeah. We're going to sort of prove that there's no smoke and mirrors, it really is just normal Visual Studio development. Yeah. Awesome. All right. Well, let's jump right into it then. Cool. Let's go ahead. So I have the Microsoft Windows IOT Core Samples repository, up and this is on GitHub and you can clone this down to get started with it. We have a lot of samples to start with. We are going to just start with the blinky one. So when you have a look at the documentation, it helps you, there are really friendly links on how to get started and things like that, and actually how to use the samples themselves. Awesome. So people watching this can then go ahead, we'll put a link in the show, they can download this exact sample specifically and then look at other samples. Totally. So in the samples directory, there's the whole list there, and we're just going to be using like hello blinky. So that's what we'll be using today. Then we just need to read the code, find out in the read me where to plug in the LED and things like that, and then we're all good to go. Okay. Awesome. There's also great documentation right behind this platform. So where can people go for that? Yeah. So you can go to docs.microsoft.com, which is where all of our docs live, and we have an entire section on Windows IOT Core and getting started with it, and we have a lot of really cool sections including tutorials and things like that. So usually I recommend that people click on the get started link and that explains exactly what it is, gives a little more detail than we gave in the last episode, and also gives you a list of devices that are compatible and things like that, which is really cool. So definitely check that out just to familiarize yourself with the process of getting up and running because we are skipping a few of those steps today. Okay. Awesome. Yeah. And we did talk about like device compatibility being important in the last episode. Totally. It's definitely folks should like, check that episode out if they've never done this before, and they would make it start making it real. Okay. Awesome. So let's jump into the sample then. Go to Visual Studio and why don't you introduce to us what we're doing here, what we're looking at. Right. So I'm just opening the main page, dot.xaml, and we have the actual class with code as you can see here. It doesn't really look particularly different from a regular UWP app. In our solution, we have our package app manifest and our app.xaml and everything that you would normally see. We also have our xaml file itself, which shows that we're setting up a UI as well. Yeah. Awesome. Simple little UI there. It's just xaml like you would expect it. And the only thing different for like regular people that have experience with WPF or UWP or anything else, xaml-based like platform-wise, is that we're targeting ARM on top, right? That's the one kind of thing that stands out. Everything else look like regular code, but the build target, the platform we're targeting. Yeah. So when you have a look here at Debug, this is where you'll see that normally you wouldn't see that, but that's what we set everything up to be. And we have templates in Visual Studio, which gets you started with like an app from scratch, if you'd prefer not to use a sample, and it should set all of that stuff up for you too. Okay. Awesome. And now you also have next to the wrong button says remote machine, right? Because you actually need to debug against a remote device. That's one of the things I learned and talked about in the previous episode, like there's no emulator. You've got to like either have an ARM device. I mean, maybe that could work in the future. We are getting like ARM devices for Windows now, but let's assume you're like me. All your devices are not ARM. Your Raspberry Pi, in this case, our device would be ARM and that's our target. That's why you need to run this code to debug it on the remote machine, right? So how does that even work? How does it connect to the Pi device? Yeah. So there are several ways to connect to your device. And usually the most straightforward way that I recommend at the beginning is to use Ethernet because then you've got just a direct connection from your development laptop or your development desktop to the actual Raspberry Pi itself. You can actually access it as long as both computers are on the same network, though. So you don't necessarily have to be directly tethered, but usually I recommend that just so that it's really easy for discoverability and things like that. And what it does is it'll build your app and then it actually just copies that package over and it tells Windows to start running that app on the Raspberry Pi itself. So it's literally like a one-click deployment. Run, deploy, debug scenario, right? The thing that people expect on Windows as well, right? Or back like on Windows Phone Development or any other kind of remote device tether development. That's pretty cool. And it knows which device to target based on the IP address of the device, right? That's what it's using internally. Or I guess you can use hostname as well. I like IP addresses. I think that simplifies my life. The other thing that I found useful is that when I got my Pi home, the first moment like frustration I had was I actually didn't have any adapter to direct tether it. Like you're using an adapter, right? Right. Now with the laptop. Talk about that device because I didn't have that. And if you don't have that, then you need something else. And we'll talk about the regular way I did it, but how did you get it to work here? Yeah, so normally when I'm debugging this from home, I have like this Pi hooked into my router. And so then I can access it just through the local network. So if it's plugged in to a router over a regular ethernet, it will just work because that's your home local network, your debug machine against network as well. Totally. And then you have this as the alternative mobile setup. Yeah, so this is a direct tethering. So I have a really fancy laptop and it's a little too thin to have like an entire ethernet port. Too thin, yeah. And so the way that I got around that was I bought like a USB to ethernet adapter. And that works really, really well. And so I just bought mine off Amazon and it was plug and play. And so I found that that's been the easiest way for me to do it when I'm out and about and debugging things even though I get strange looks when I'm trying to do this at the airport. Yeah, lots of boards. Yeah, so I tend to try and be discreet and have that all in my backpack, but then I can have this nice cable here and still be developing, which is really convenient. So what's your technique? Yeah, I mean, so my technique, that was to get a router because I didn't have a router. I mean, I literally like I live in an apartment where they gave me wiring in the walls about to the internet, so that was easy. Wow. Yeah, fancy, right? Like I didn't have a router. I used to have a router always in my life except the last couple of years when I exactly started this phone. So I went to Best Buy, bought a router and like you said, that just works great because they gave me a local network to attach to. And the Raspberry Pi can connect to wireless. Like you could connect it to your wireless, that does work but that's a next level of complexity. I actually like the physical connection for the beginning and then you can configure it to work off a hotspot or whatever but this is the first easiest way to go. Yeah, totally. And once you're actually done debugging and things you don't need to be tethered like this anymore, right? So you would actually like package up an actual release. You can then deploy it to the device and then the device has really nice abstractions through like a portal that you can access to just set up what is the startup app. And then that means that every time you turn on your Pi instead of starting up the default app which we've been working with it'll just start your own UWP app. So it's really, really nice once you actually do become untethered. Awesome. Let's talk about a couple of those apps maybe within plan originally to talk about them but I think it's important, like I remember again my getting started that I realized that there's this whole suite of apps that you can get from us from Microsoft that lets you first of all you can get the device working. So you buy a micro SD card, right? You need to plug it into some laptop that's running this piece of software. Maybe you can start that dashboard manager and show people what the piece of software looks like. Yes. And then that piece of software lets you just configure Windows on the card. So you can actually, you can configure the preview version of Windows or the main one for Windows IAT Core. And then you pull that card out, you plug it into your Pi and your Pi boots up magically. So that's kind of the two-step process but I didn't realize that if like again I started from scratch I was like how do I get this micro SD card to have Windows on it? Do I X copy it? Do I, no there's an app. We ship an app for you, right? Yeah, it's so, so easy because I know with like general Raspberry Pi stuff you can buy SD cards with software preloaded on it and so it would be ridiculous if we asked people to have to go through all that trouble. So I was really pleasantly surprised by just clicking one button with my SD card plugged in and then it just deployed the exact copy of Windows that I needed and then you turn the Pi on and it works. So I can definitely show you that dashboard. Cool, so let's take a look at it now. So if I bring up the IoT dashboard which is the app that we just mentioned, I can already see that my Raspberry Pi is plugged in. This is the IP address so that I know how to connect that to Visual Studio for debugging and deployment, which is really cool. Now I like to call my stuff like with a prefix of noop or noop because my name on the internet is noopcat so that's why mine's called nooppi. So you can name it whatever you want and then it shows you the IP address on the exact OS version. So it gives you some rich information as long as it can also show you like is your Pi being detected on the local network direct tover or local home internet and this is the same app that we would also use to set up the new device, right? There's like a tab here, you click on it and it's just magical and then what I found out, we don't have to show this in detail here but like what I found out if you sign in in the bottom left, if you're a window insiders you start seeing insider builds. It's the same thing if you click that blue link sign in as windows insider. So by having your identity you can get internal builds but I mean I started and I still use actually the RTM build. I don't skip ahead, I'm not that advanced but this thing will download it, install it, give it a name, give it a password and then you just pull the card out, plug it into your Pi. Exactly. And if the hardware is compatible with that OS version, it works. Yeah, it's really awesome and so that's literally as easy as it is. You fill out the details, you download and install. It'll tell you when you're done and then you just eject the SD card from your computer, plug it into the Pi and then you'll see the windows icon show up on a little screen if you have it plugged in, which blew my mind. You know, I'm not used to seeing that on like a hardware device. Yeah, yeah, it's really cool and the fact that you have a screen attached over a regular HDMI, that's all you needed, right? So in fact, you could hook this up to a big screen. I mean, I've done that, right? Like it's just HDMI, it's just windows. Totally. In a big way. And then you have some advanced hardware with touch and stuff you can add later but the beginning you could start with like, like you can scavenge at home. Like that's why I took my HDMI spare monitor and I plugged it into the Pi. That was my first getting it to work. Then I bought a fancy screen. Like you don't have to buy a lot of stuff to get started. Just the board and some spare equipment a lot of us have. Yeah, I feel like everyone has that old monitor lying around that like it's too small or it's like not nice anymore because you bought a new fancy one and I find that that's like awesome for use with the Pi for sure. Yeah, and you can plug in a keyboard and a mouse into the Pi and then you can control the app that you just built and deployed. So that's what I did at home. And I actually wound up not having a keyboard that I could plug in. So I did that I had to buy a keyboard but then I remembered I had a Bluetooth keyboard and I found that that works with the device. So you can use Bluetooth mouse, Bluetooth keyboard, regular USB mouse and keyboard. It's Windows. It's kind of magical. That's the one thing that I think takes this for Microsoft developers kind of to the next level of ease. It's so true. Yeah, a lot of the drivers that you would kind of be expecting to be on like regular Windows are there because it's really just an optimized version of Windows 10, which is great. Yeah, that's awesome. All right, so let's go back to Visual Studio and maybe take a look on kind of how do you start? How do you like run code against the device? How does the configuration for the IP address look? That sort of thing. It'd be interesting to show people. Yeah, absolutely. So you do have to do a little bit of work to kind of set up this remote machine and it should be in your regular debug settings. And so if you go in, you should see this thing right here that says Blinky Properties. And so I'm going to go back into that. It works the same if you right-click on your project in the right hand. Oh, shortcuts. Solution is where it goes right in. So it's under the debug tab. I feel like you're like the power user of Visual Studio and so many years back from the days before it was called Visual Studio. So yes, I have an advantage. Awesome. So you can see there are a lot of different options. You don't necessarily need to have to worry about all of them. The most important part here is in the start options in the middle here. So you can see the target device needs to be set to remote machine. The remote machine itself, the IP address is definitely like the best way to go about this. And you can grab that IP address directly from the IoT dashboard that we showed earlier as well. It makes it easier. And also on the pie itself, you can also see the IP address if you have a screen attached. Yeah, and that's really nice. So there is a default app that starts on the pie that gives you extra additional information about that. So that should be all that you need to get up and running. And a lot of the time, this stuff is already part of the template. So usually you only need to fill in the remote machine details and then you're good to go. What else can we talk about? All right, so what we showed actually like hitting a break point. I think that's always been a great part. So we have it set to ARM so we know it's gonna build to the right platform. We already configured the IP address. So we did that. It wasn't much else you probably had to do that kind of is the default as long as the device can be seen. So now we just hit F5, right? Yeah, this is scary. But yeah, so- It's always scary, F5 is always scary. Yeah, so we set a break point pretty early on in the app and I'm happy to explain how the code works later on but it should hit this point and it should do that remotely. So you normally would be expecting that it's coming from the emulator or from your actual desktop but you're actually gonna start seeing details that are specific to the Pi including all of the monitoring and things like that. So if I hit F5 now, we should actually start seeing that building. Right, so it's very standard stuff. Windows developers will be familiar with it, right? You've got your outputs showing the build happening. It's gonna do the deployment. I think you showed me a tip earlier. It's actually gonna show you the path and there of where on the Pi it's deploying it to. I learned something new, that was cool. It's very cool. So this is normal, right? This is what you would normally see. Totally normal. You got your diagnostics, your outputs, your locals, everything you would expect as a C-sharp developer. Yeah, and so this is actually showing you all of these metrics and the diagnostics are actually for the Pi. So it's not for your laptop and then if you look in the output, it's actually showing, this is not my laptop's path at all. And so this is the default user account on the Pi where it's actually deploying the app and running blinky.exe, which is really, really cool. Yeah, that's awesome. And so basically you're running the app, so let's run the app, let's see what it actually looks like on the device. Yeah, so we started running it and it did actually halt at this break point right here. And so this looks as it normally would, which is really cool. And so let's say like the GPIO, which is our general purpose input output. This absolutely needs to be started up for us to even be able to like start manipulating things on the breadboard, right? Because that's what our devices are plugged into. And so I can just regularly roll over my variables just to make sure that they did actually instantiate probably, which is really, really cool. And then we can just keep continuing so that the app keeps running and you'll see again that the diagnostics then can continue. Yeah. And the apps actually started up. So let's go over and see what is actually happening on the screen and what's happening on the breadboard. So this app is called Blinky, which sort of gives away what it should be doing. Yeah, I'll zoom into the hardware here on the screen. Yeah, so if we take a look over here at the hardware, we have our screen, which has a very, very attractive, it has a very attractive app running. I know that if I was friends with a designer, I would actually be able to do a better job with this. No, this is the sample. I mean, we're showing people what they're gonna see. Right, and so that red and white sort of cycling circle there is just an indicator that it is telling the LED to turn on and off. And so that's just a visual reproduction of the 500 millisecond rate that we're doing that at. And then if we come over and have a look at the breadboard, we do have some pretty bright lights here, but you should be able to see that there's a tiny little blue light and it is turning off and on. And it's actually doing that in sync with our UI as well, which is kind of reflecting that too. That's awesome. And so that's all the app does. It starts up the GPIO so that it can then start toggling that LED and that's how Hello World. Awesome. So how does it, like the breadboard has a bunch of places you can plug stuff into, right? So people might buy a kit that has a blinking light and it has some transistors and some wires and they might follow the instructions we lay out, right, to plug it all in. But then when you're looking at a code, how do you relate the code knowing where you've plugged something in and you've sent the command? Maybe you can jump into that C-sharp and show people. Yeah, that's a really, really good question. And just to put the breadboard up in probably a slightly more accessible manner too before we begin, we do tend to create these diagrams with our samples that show you how to plug everything in. And so this here is the actual circuit that we're using. My computer wants to start up, yeah. And so this is a good wiring diagram because it shows you exactly where you need to plug what. The wire colors don't actually matter at all but it is helpful to have the right resistor, for example, here. And you have columns and rows identified by letters and numbers, right? So people can, like I've missed that because it's gray and it's a little bit weak and it's on the physical board, it's on this diagram but that's how you know where they're telling you to plug it in. So it's not like a mystery and again, once you learn about more about how hardware works, this will be less demystifying. But when you're first starting, this is terrifying. You're like, why do I plug it in? Why do I plug in both the little wires and plug them in? Yes, this shows you exactly the X-parts. So follow it 100% and you'll be good to go. Exactly, yeah. So once you get comfortable, you'll be like, well, I don't want to put the LED on the left side of the breadboard, I want to put it on the right. And so you'll get more confident with understanding how it works and everything. But we try and make it super easy by giving you just a very visual way of being able to follow that. Very reproducible. Yes. Where did you get the hardware for this? Like the breadboard and the Raspberry Pi doesn't come with it by default, right? You have to buy some of this stuff. Some of them are kits and... Yeah, that's right. So I got mine as part of this kit here. So this is the Microsoft IoT Pack for Raspberry Pi 3. It is a collaboration that we have with Adafruit. Adafruit is one of my favorite companies in the world. And they're also New York based. So I'm from New York. A little advice, yes. Yeah, I want to support local business. There you go. And so we've done some really, really cool Azure IoT collaborations with Adafruit and this is probably one of my favorite packs. So this is the Microsoft IoT Pack for Raspberry Pi. You can actually choose to have the Raspberry Pi come with it. But if you already have a Raspberry Pi lying around and you've just shamefully never done anything with it and this feels like your time to do so, you can also just buy the pack alone. It does come with some really cool devices and bits and pieces that you can plug in, including one of the sensors that we're going to be using in this series. Awesome. And that comes with the breadboard and everything that you need to get started with. So you don't need to hunt down anything. If you're comfortable buying an entire pack, then this is definitely the way to go. Okay, awesome. Yeah, that I think denistrifies some of it. So let's go take a look at the code and see how does the code know what to do? How does the code know which part of that board to actually interact with? Totally, totally. So I'm actually just going to stop this program just so that we're not distracted by everything or the diagnostics. So we have just our normal class where we're defining a lot of the variables that we're going to be using. And you'll see that there's a curious one here which is an integer and the constant is called ledpin. So does that give you any clues as to what you think it'll be? I think it does, yeah. I think that's how we know where it's plugged in, right? Where are we going to send the command? Exactly. And so we see this integer five and that's our clue. If we weren't following that nice breadboard picture, if let's say someone just gave you a random app and you had no instructions, these are the kind of clues that you need to look for when it comes to hardware as to where you might need to plug that into. Can we show on the board how we correlate that number five to the actual board five? Yes, absolutely. If maybe the camera can zoom in back to the board, we can show people what that looks like because to me, this was very mysterious. Let's bring it up to the full screen because this is hard to see a little bit and how do you know it's five on here? Yeah, so normally you don't have to use this particular breakout that I'm using here. You can plug stuff directly into the Raspberry Pi's GPIO which sounds like that was the way that you've been doing things. And when we say GPIO, we mean the pins on the Pi that are currently blocked by the fact that we plugged the big cable in. So that's the GPIO cable. To me, none of this was obvious when I was trying to say, what's a GPIO cable? What's a GPIO port? Oh, my Pi has a GPIO thing. Yes, that's what it is. And we're just enabling the breadboard to be its extension now by giving it more pluggable things. And we have this number five, so how does that correlate? Yep, totally. So the row, there's like a double row of pins going along the side of the Raspberry Pi. And then if you use this breakout, which sometimes is called a cobbler, because Pi, cobbler, get it? Sure. It's really cool. This just allows me to work directly on the breadboard and I don't have to keep crossing back between the Pi and the breadboard. But every single one of the GPIO pins on the Raspberry Pi has been broken out and labeled on this breakout board here. And so you can see there should be a bunch of numbers that are running all along each one so that you can easily just look for the number five and that's where we need to plug it in. And so it's very small for you to see here, but I do have the red wire plugged in. And because remember these copper lines kind of go vertical, I can just pop one in at one of the locations that is right across from pin five where it's labeled. And that's really all there is to it. That's how you plug it in. And how do you know to plug in the other wire you have there? The black wire, which is the ground, I believe. That's something I've learned. Again, I know nothing about electronics. Like literally, I'm very new. So I'm like, why do we need a ground cable? And how do we know which one of these to plug it in? And tell me if I'm wrong or right. But I remember I think reading that certain pins are designated as ground and that's just why that's the one that works. It's multiple of them. And the diagram you had before shows you which one you can use, but you can use any ground for the black and the red has to go to match the number in the constant in the app. Totally, yeah. So it's really good to explain this. So there are, there does tend to be like multiple grounds on a lot of boards such as the Raspberry Pi or the Arduino. And that's mostly just for convenience, especially if you don't have a breadboard, you can kind of have multiple devices plugged into ground because it is kind of like the common default for every device to use. And so by plugging things into grounds, we're actually giving, we're closing the circuit to actually give the electricity like a path to run across. So if we sent power to this LED and we didn't have a ground, then nothing would actually move because there's no motivation for our circuit to actually like start being powered. And so that's why we always need a ground and you can think about pin five as like a remote controllable power source, if that makes sense. And so you could either say that pin is sending, the pin five is sending power or you can say it's not sending power and that's what completes or doesn't complete that circuit. Right, and then from the wires you have set up there, you sort of translate that five into a different spot which matches where the light is and that's how the light turns on. And you match it for the light in the right places. So that's kind of like it's all black magic until you realize that the wire on the breadboard from one place to another connects that five and ground to where the light is. And therefore the light could have been somewhere else like you said, right? There's this, once you get more advanced, you can move the light around and stuff. But like if you follow this configuration, it will work, it will get the light on, you'll get the basics and then this code will actually run. And if you connect it to six instead of five, you can just change that constant and that's fine. And you can change where the ground is connected as long as that's a ground location. You can't kind of ground to power. I've heard people even breaking some of their devices and stuff so. It's really scary. So you have to be careful. Like I tell people, new people to Windows IoT, the one thing to remember is you are getting to the level of power, not to overuse the word power, power, everything's power. The power of power, but the power of power is it can break stuff. Absolutely. If like stuff in the right place, double check that. Make sure before you send power to it, in other words, like if your pie is unplugged and your board is connected, your breadboard into the pie, it doesn't have magical power source of any kind. So it's kind of safe. You can move things around. Once you plug that pie in, you can break something. Totally. Make sure you're plugging correctly. Yeah, and I'm really cautious. Like I get worried that I'm just kind of like accidentally touch a wire to a contact accidentally cause I drop it on the pie or something. So I tend to always unplug stuff when I'm moving things around on the breadboard. Like it takes like two seconds to plug it back in again, but I really like what you said about double checking everything like the measure twice cut once kind of thing. I feel like that does actually give you a lot of safety in electronics and the LED even, it has a ground wire and it has a like a power wire. And so if you get them marked around the wrong way, it doesn't, in this case, it doesn't matter too much, but you'll find that your circuit won't actually work because it's not in the right orientation. Got it. So ask me how I know that you can burn something out. Oh yeah. Cause I bring something out. I just, I just plugged stuff in the wrong places and I plug power and that thing stopped working forever. But did you feel like less afraid after that? Cause you're like, okay, I messed it up. That's out of the way now. That's kind of how I felt, but also kind of stupid. That's okay. That's okay. That's what we're here. We're trying to help folks not to make the mistakes. And if you do these things around that expensive. Right. You go maybe it's a little more than your wallet depending on situations, but like, it's not so bad. I've heard people of burning their boards out. I've heard people doing all sorts of stuff. So I think probably the one thing it's kind of safe-ish. Yeah, it's not a legal statement is your computer. I don't think you can break your computer necessarily. You're plugging over your front end stuff like that. But from the board out, it's, you've got to know what you're doing. So just be careful. Maybe we can end by looking at the code itself. So we know where to send it. And we have this Mac magical class for now. People don't have to get the full understanding of it. The GPIO pin and value, all of that is part of this like, that black wires magic into the board and into the spot. Yes. That's good enough. So there's a class that we provide as a Windows IoT platform. And then how do we tell it to shred blinking? Yeah, so we can just use windows.devices.gpio. It's ridiculously easy to just include that and start using it. And so we need to define the actual pin int that it's going to be on. We create a pin. And then we can also create a pin value to be able to actually set it. So that's sort of how we turn it on and off. And the easiest thing for us to do is to just set up a timer so that every 500 milliseconds that actually runs that handler that we attach to it. And so after initializing our GPIO, which just means that we're opening our pin at pin five. And then we set the pin value to be high. And high means we're sending power to it. Low means we're not sending power to it. So it's a very binary thing. So it's pretty easy to get your head around. And then every time we actually want to start writing that value to the pin, that's where we can use our pin API and pin.write. Okay, so pin.write writes the value. And the value is that high value. And the pin has been open to five. So it already knows where to send that high value to. And then you have that one more command set drive mode. What is set drive mode? Yeah, so that's a really good point. So when we talk about the abbreviation GPIO, it's general purpose input output, right? So most of the pins can be either an input or an output. So you can either read to it or read from it or you can write to it. And so in this case, we're saying we want pin five that we're setting up. We want this pin to actually be an output. So we are actually writing a value to it or sending power to it. So with this magical combination, it just is going to survive. It just works, yeah. And working with these pins tends to be kind of like the basic foundation to learn. And from there, you can kind of move up to like communication protocols and things like that. Awesome. And so our handler, which is our timer tick is what takes care of doing the actual blinking itself. And so this conditional will seem super familiar to you. We're checking to see if the current pin value is already set to high. If it is, then we want to set it low, right? So if the light is on, we want to turn it off. And so we then create a new pin value and write directly to that pin five. And then we fill the little kind of circle, the LED indicator on our UI with red. And then if it's actually like already off, then we want to turn it on and then we want to kind of update the UI accordingly as well. So that's pretty straightforward to get your head around. And you can start messing with the values and messing with the timer interval and making it blink really fast or really slow. And that's sort of how you can sort of start getting to know some of these APIs. Okay, awesome. Do we want to show anything else in this episode? I think that was it. I think the best thing is that you can remotely debug this. So if your GPIO doesn't start up, for example, you can just like kind of actually walk through and maybe see why that's happening. You don't get that with most hardware. Like remote debugging is such a treat to have. And so I just encourage people to set breakpoints and actually step through and actually watch how things are being set up when the app starts running. Okay, well, awesome, Suze. Well, thank you so much for being on and showing us this next step of complexity people to get through. And folks, we hope you enjoyed this episode. We'll have more of these episodes in the series on Windows IoT development. And Suze, thank you so much for being in Visual Studio Toolbox. Hope to see you again. Yeah, thanks for having me. Let's have even more fun next time. Definitely. All right, folks. Thank you very much. See you next time. Bye-bye.