[00:00.000 --> 00:08.080]  Well, one of the slides I'll quickly introduce him.
[00:08.080 --> 00:12.000]  I have a lot of things to say about him, but he's already learning late.
[00:12.000 --> 00:17.360]  But I've never seen such dedication to even five seconds before he came on stage debugging
[00:17.360 --> 00:19.300]  his code.
[00:19.300 --> 00:21.000]  I've never seen such dedication for a talk.
[00:21.000 --> 00:23.800]  I think this is true conference-driven development.
[00:23.800 --> 00:32.400]  Thank you, Ron.
[00:32.400 --> 00:41.600]  At Fostam 2021, we learned to go without wires, and we discovered Go Bluetooth, a new package
[00:41.600 --> 00:45.280]  that let you use Go to connect with Bluetooth.
[00:45.280 --> 00:50.600]  Not just on microcontrollers, but on Windows, yes, I said Windows here at Fostam, I'm very
[00:50.600 --> 00:51.600]  brave.
[00:51.600 --> 00:55.520]  Windows on macOS and on Linux.
[00:55.520 --> 01:04.400]  Then at Fostam 2022, we learned to go further without wires, and we discovered the mysteries
[01:04.400 --> 01:08.480]  of Wi-Fi and the Internet.
[01:08.480 --> 01:16.520]  Now at Fostam 2023, we will go even further without wires.
[01:16.520 --> 01:19.320]  This time, we go long.
[01:19.320 --> 01:24.600]  I am Ron Evans, dead program, I am technologist for hire, aren't we all these days, of the
[01:24.600 --> 01:29.040]  hybrid group on micro consultancy here on planet Earth, where we're all technologists
[01:29.040 --> 01:30.280]  for hire.
[01:30.280 --> 01:36.040]  So we do a lot of open source work, usually for little or no renumeration, and TinyGo
[01:36.040 --> 01:40.760]  is the result of the amazing collaborations of a huge community of people all over the
[01:40.760 --> 01:42.440]  world.
[01:42.440 --> 01:46.040]  So this is about going further without wires.
[01:46.040 --> 01:51.160]  So what we're actually talking about here is low powered wide area networking, or LP
[01:51.160 --> 01:52.160]  WAN.
[01:52.160 --> 01:55.320]  So we talked about personal area networking two years ago, local area networking, and
[01:55.320 --> 01:58.520]  now we're going for wide area networking.
[01:58.520 --> 02:01.240]  And of course, we're talking about Laura.
[02:01.240 --> 02:03.600]  So and Laura WAN.
[02:03.600 --> 02:06.120]  So what is Laura?
[02:06.120 --> 02:07.440]  That's a very good question.
[02:07.440 --> 02:11.200]  Maybe we should ask who is Laura or why is Laura, but let's start with what is Laura.
[02:11.200 --> 02:15.200]  So Laura is, of course, long range radio.
[02:15.200 --> 02:22.320]  It is a semi proprietary but freely licensed protocol that was created in order to do long
[02:22.320 --> 02:26.440]  range wireless communication of digital data.
[02:26.440 --> 02:29.560]  And yes, I had to ask why is Laura.
[02:29.560 --> 02:33.840]  Well long range, of course, I mean you knew that from the name, right?
[02:33.840 --> 02:40.760]  Ultra low power, not just low power, but ultra low power, and license free spectrum.
[02:40.760 --> 02:45.160]  That means you do not need to go to any governmental entities and ask permissions.
[02:45.160 --> 02:48.080]  But that does not mean free for all.
[02:48.080 --> 02:53.680]  That just means we must share the commons gently because these airwaves are in fact the property
[02:53.680 --> 02:56.040]  of all human beings.
[02:56.040 --> 03:00.800]  So Laura is the physical layer protocol.
[03:00.800 --> 03:06.360]  And what we mean by that is it's actually like tells us when the radio signal comes whether
[03:06.360 --> 03:07.760]  it's a one or a zero.
[03:07.760 --> 03:12.720]  So a question, what do these three things have in common?
[03:12.720 --> 03:22.040]  A bat, a dolphin, and screen star of the 20th century, Hevy Lamar.
[03:22.040 --> 03:23.360]  I know you're probably wondering.
[03:23.360 --> 03:25.880]  The answer is, of course, chirp spread spectrum.
[03:25.880 --> 03:27.000]  You have that, right?
[03:27.000 --> 03:32.440]  So Hevy Lamar, in addition to being an actress, probably many people know, was an inventor
[03:32.440 --> 03:37.720]  of what is now known as frequency hopping, which was a technology that was used to avoid
[03:38.520 --> 03:41.360]  jamming and detection during World War II.
[03:41.360 --> 03:44.240]  And we use this today for the lower protocol.
[03:44.240 --> 03:47.720]  So to kind of get you an idea, there's an up-chirp and a down-chirp.
[03:47.720 --> 03:54.600]  So I will now imitate the up-chirp, and the down-chirp, and imagine that in a cute little
[03:54.600 --> 03:55.960]  dolphin voice.
[03:55.960 --> 04:02.240]  So by being able to parse and modulate these signals, it's able to actually send across
[04:02.240 --> 04:04.400]  long distances using very low power.
[04:04.400 --> 04:06.360]  So how do you use Laura?
[04:06.680 --> 04:08.160]  Chips, of course.
[04:08.160 --> 04:08.480]  Thank you.
[04:08.480 --> 04:08.880]  Good night.
[04:08.880 --> 04:10.560]  No.
[04:10.560 --> 04:12.400]  Chips mostly from Semtech.
[04:12.400 --> 04:17.880]  So Semtech is a company that are the creators of the lower protocol, and they make most
[04:17.880 --> 04:19.640]  of the chips, and they license them out.
[04:19.640 --> 04:25.840]  The two that are the most common are the SX126X series and the SX127 series.
[04:25.840 --> 04:29.400]  And so what we're going to do is we're going to see you have a microcontroller, some type
[04:29.400 --> 04:33.080]  of device, and we're going to connect through the serial peripheral interface, which is
[04:33.080 --> 04:39.240]  a low-level serial interface, to the actual Laura chipset, and then with the antenna talk
[04:39.240 --> 04:40.960]  out to someplace far, far away.
[04:40.960 --> 04:43.720]  So this is where TinyGo comes in, right?
[04:43.720 --> 04:46.000]  You knew that when we saw a microcontroller.
[04:46.000 --> 04:50.200]  So the Go compiler for small places, if you haven't checked it out, you could program
[04:50.200 --> 04:51.840]  Arduino's with Go.
[04:51.840 --> 04:53.360]  You'll see in a minute.
[04:53.360 --> 04:58.440]  So let's start with the whole old world of things, which of course is a blinky LED.
[04:58.440 --> 05:03.920]  And we're going to start with a Raspberry Pi Pico, which, oh, I forgot to start my video.
[05:03.920 --> 05:04.920]  Let's see here.
[05:04.920 --> 05:09.280]  Because you need some actually to see what's going on, or it's not quite as exciting.
[05:09.280 --> 05:12.280]  Now let's see here.
[05:12.280 --> 05:18.680]  Yes, I use all Linux tools, don't we all?
[05:18.680 --> 05:21.280]  Let's see if the camera will come up.
[05:21.280 --> 05:24.160]  Oh, wrong camera.
[05:24.160 --> 05:26.960]  It looks like, well, I think that is it.
[05:26.960 --> 05:28.680]  I forgot to take the lens cap off.
[05:28.680 --> 05:29.680]  That helps.
[05:29.680 --> 05:35.320]  No, I am not a professional photographer by trade.
[05:35.320 --> 05:37.440]  And of course, if we make that bigger, it's a lot easier to see.
[05:37.440 --> 05:39.560]  And we can even bring it into a little bit of focus.
[05:39.560 --> 05:40.560]  All right.
[05:40.560 --> 05:47.640]  So this is a Raspberry Pi Pico RP2040, which is a microcontroller made by Raspberry Pi.
[05:47.640 --> 05:52.760]  And as we were seeing a minute ago, it's got a dual-core ARM Cortex N0, which is a very,
[05:53.040 --> 05:58.520]  very low-powered, not very powerful ARM Cortex microcontroller, a 32-bit.
[05:58.520 --> 06:02.680]  Runs at 133 megahertz and 2 megabytes of flash.
[06:02.680 --> 06:06.080]  So let's just take a quick look at some code, just so you get an idea of what it is that
[06:06.080 --> 06:09.080]  we're looking at.
[06:09.080 --> 06:13.080]  And the whole world of things is a very simple program.
[06:13.080 --> 06:15.080]  You can see this good.
[06:15.080 --> 06:16.080]  All right.
[06:16.080 --> 06:17.800]  So it's just a Go program, right?
[06:17.800 --> 06:21.480]  But it's run through the tiny Go compiler, and it compiles to the code that can actually
[06:21.480 --> 06:23.320]  run on the microcontroller.
[06:23.320 --> 06:28.520]  So we'll import the machine package, which is a special package tiny Go uses to communicate
[06:28.520 --> 06:33.880]  with the hardware directly, then the time package, same time package, and our function
[06:33.880 --> 06:36.040]  main, you've seen this before.
[06:36.040 --> 06:40.840]  So first we're going to say LED colon equals machine LED, which is like the built-in LED
[06:40.840 --> 06:42.480]  that's on a lot of boards.
[06:42.480 --> 06:46.600]  We'll configure that as an output, meaning we're going to send a signal to it to turn
[06:46.600 --> 06:47.800]  it on.
[06:47.800 --> 06:53.120]  And then forever we're going to turn it low, meaning off.
[06:53.120 --> 06:58.560]  We're going to wait for 500 milliseconds, half a second, turn it on, and then wait for
[06:58.560 --> 07:00.120]  another 500 milliseconds.
[07:00.120 --> 07:01.400]  All right.
[07:01.400 --> 07:05.280]  So let's go and let's see this actually work.
[07:05.280 --> 07:11.000]  So if we go back to my presser, costume, there we go.
[07:11.000 --> 07:17.120]  And if we make blinky, I really like make.
[07:17.120 --> 07:23.040]  So we'll then compile that code, flash it on there, and you can see that it's a 7K program.
[07:23.040 --> 07:25.040]  Can you see that?
[07:25.040 --> 07:26.040]  Yeah.
[07:26.040 --> 07:30.000]  It's really small, both the type and the program.
[07:30.000 --> 07:39.440]  And then if we go and we take a look, if we, oh, I forgot to plug it in.
[07:39.440 --> 07:42.080]  I was a little rushed for time, I'll admit.
[07:42.080 --> 07:43.080]  Naturally it failed the flash.
[07:43.080 --> 07:44.800]  That would have been frightening if it had.
[07:44.800 --> 07:47.960]  There is no wireless in there yet.
[07:47.960 --> 07:51.360]  It's very inexpensive, meaning there's no wireless built on board.
[07:51.360 --> 07:52.360]  All right.
[07:52.360 --> 07:53.360]  So now it's flashed.
[07:53.360 --> 07:59.560]  And if we take a look, we can see an LED is turning on and off.
[07:59.560 --> 08:00.560]  Yes.
[08:00.560 --> 08:01.560]  All right.
[08:01.560 --> 08:07.080]  We're off to a good start.
[08:07.080 --> 08:11.240]  I tempted the demo gods quite a lot today.
[08:11.240 --> 08:15.560]  So now we're going to use the TinyGo drivers package, which is a package that is a sister
[08:15.560 --> 08:21.120]  package to the TinyGo compiler, which contains support for all different kinds of sensors,
[08:21.120 --> 08:28.720]  of displays, and other interesting things like, for example, our Lora wireless adapters.
[08:28.720 --> 08:33.880]  So our first demo is going to be showing Lora, just the low level protocol, transmitting
[08:33.880 --> 08:34.880]  and receiving.
[08:34.880 --> 08:39.560]  And we're going to use the same Raspberry Pi Pico, but we're going to add to it an RF
[08:39.560 --> 08:42.000]  solutions lambda 62.
[08:42.000 --> 08:47.680]  So if we can actually take a look at that here, if we go to the video, we'll take away
[08:47.680 --> 08:54.080]  that one, and we'll put in this one, different Raspberry Pi, and it's wired up to one of
[08:54.080 --> 08:56.320]  those chips that I showed you before.
[08:56.320 --> 08:58.080]  This, by the way, is the antenna.
[08:58.080 --> 08:59.080]  This little wire.
[08:59.080 --> 09:02.760]  Do I tell you that in the, I think I do.
[09:02.760 --> 09:03.760]  Yes.
[09:03.760 --> 09:09.560]  So we're going to take SX1262 with an 868 megahertz radio, is what you need in order
[09:09.560 --> 09:14.480]  to be legal and broadcast here in the European region, and it's got a wire antenna, which
[09:14.480 --> 09:17.800]  is literally just a short piece of wire.
[09:17.800 --> 09:27.400]  And so if we take a quick look at the code of our SX126X, so we can see it's not that
[09:27.400 --> 09:28.400]  much longer.
[09:29.400 --> 09:34.280]  It's got a package main, our machine package, time, and now we bring in the drivers for
[09:34.280 --> 09:40.720]  Lora, which is the actual communication for Lora, and then for the chip itself.
[09:40.720 --> 09:44.960]  And what we're going to do here in our main is we'll start by sleeping, and then we'll
[09:44.960 --> 09:51.520]  set up the Lora interface, and then we'll try to receive data, transmit some data, and
[09:51.520 --> 09:52.520]  then sleep.
[09:52.520 --> 09:57.080]  So setting up the Lora interface is really just about configuring the SPI interface,
[09:58.080 --> 10:05.080]  creating the driver that we need in the TinyGo drivers package, attaching a radio controller,
[10:05.080 --> 10:10.080]  which because these chips have so many different variations that we need to be able to do,
[10:10.080 --> 10:15.160]  so we can tell it which wires are going to be turning it on and off, and then make sure
[10:15.160 --> 10:19.960]  we actually have the device detected, configure it appropriately.
[10:19.960 --> 10:26.440]  So here we've got our 868.1 megahertz frequency, the bandwidth that we're using, et cetera,
[10:26.440 --> 10:30.720]  and then once we've got that configured, if you recall, we have our setup, then we'll
[10:30.720 --> 10:31.720]  receive data.
[10:31.720 --> 10:39.080]  So to receive, it's just a matter of saying LoraRadio.rx, and then how long we should
[10:39.080 --> 10:43.520]  wait, and if we don't receive any data, time out and return.
[10:43.520 --> 10:49.920]  And then transmit is almost exactly the same thing, that's going to be transmitting this
[10:49.920 --> 10:56.300]  message here, which is from RP2040 saying hello, TinyGo, and then it's going to use
[10:56.300 --> 10:57.300]  LoraRadio.tx.
[10:57.300 --> 11:00.700]  All right, let's see if it actually works.
[11:00.700 --> 11:06.500]  The demo gods are just waiting, waiting for their chance.
[11:06.500 --> 11:16.380]  All right, so let's actually plug it in this time, since we are professionals, and let's
[11:16.380 --> 11:24.220]  run make, which will now flash that code, and that one is a whole 15K.
[11:25.220 --> 11:27.740]  Yeah, you have to add something to go wireless.
[11:27.740 --> 11:31.860]  All right, and we're actually using one of the capabilities we added into TinyGo two
[11:31.860 --> 11:36.300]  releases ago, which is it's got a built-in serial monitor, so we can see it's trying
[11:36.300 --> 11:44.300]  to receive LoraData, and for 10 seconds, there's no one sending, apparently, and then it will
[11:44.300 --> 11:48.260]  try to, after that, it'll try to send.
[11:48.300 --> 12:01.300]  So because there's no one sending, wait, what, who is that, that's my next demo.
[12:01.300 --> 12:05.140]  All right, the yo badge.
[12:05.140 --> 12:09.780]  You may have seen several of us are wearing these go badges.
[12:09.780 --> 12:16.380]  So the go badge is a, it started out like, oh wow, it's upside down.
[12:16.380 --> 12:23.780]  It started out life as an ate a fruit pie badge, but we helped it transition to its final
[12:23.780 --> 12:29.620]  form, a go badge, and it's much happier now, I can tell you.
[12:29.620 --> 12:34.500]  I mean, just look at its display, not to mention that we've got such cute stickers.
[12:34.500 --> 12:39.540]  So we're actually running a different TinyGo program on there, which is called yo badge.
[12:39.540 --> 12:45.980]  So yo badge is using the ate a fruit pie badge, I told you about that a little bit, and it's
[12:45.980 --> 12:52.780]  using this ate a fruit low rough feather wing, which is a little daughter board, but can
[12:52.780 --> 12:59.140]  be added to some of these, and I soldered it on here, and it's got a UFL antenna, which
[12:59.140 --> 13:04.260]  is one of those little antennas that clip on, that way you can wear it as a badge, because
[13:04.260 --> 13:07.140]  I mean, it is in fact a badge.
[13:07.140 --> 13:13.780]  And then, naturally, I need to reboot it.
[13:14.780 --> 13:23.660]  Okay, so you can see the cool yo logo, and then because the other program is still running,
[13:23.660 --> 13:24.660]  right?
[13:24.660 --> 13:29.700]  Remember, it's plugged in, the Raspberry Pi is still plugged in, so we could say yo to
[13:29.700 --> 13:35.940]  it, and within like 10 seconds or so, it should say something back.
[13:35.940 --> 13:40.660]  Let's see, let's see if it's still here.
[13:40.660 --> 13:44.020]  Oh, yep, that was it.
[13:44.020 --> 13:47.780]  The machines are talking to us, and we're talking back.
[13:47.780 --> 13:52.020]  I feel so warm.
[13:52.020 --> 13:54.820]  I really like machines, if you haven't noticed that.
[13:54.820 --> 14:02.180]  All right, so now let's talk about low rawan, because this was all just peer to peer, which
[14:02.180 --> 14:07.260]  actually before I do that, just real quick before I do that, so we brought a few of these
[14:07.260 --> 14:12.500]  go badges that I give away here today to some very special lucky individuals, we'll do that
[14:12.500 --> 14:13.700]  this afternoon.
[14:13.700 --> 14:17.740]  So if you go on Mastodon or any of those other social media things that you're still using,
[14:17.740 --> 14:23.140]  and you send out some really great messages about how awesome TinyGo is, and how cool
[14:23.140 --> 14:27.540]  Fostem is, and how you really would like to be one of the kids with a programmable badge
[14:27.540 --> 14:33.460]  with wireless, then we'll arbitrarily decide who gets these badges.
[14:33.460 --> 14:34.460]  Maybe random.
[14:34.460 --> 14:36.460]  I don't have time to write me more software.
[14:37.460 --> 14:40.180]  So we don't have that much time left.
[14:40.180 --> 14:45.260]  So low rawan, now you're getting, we're going to go really wide.
[14:45.260 --> 14:51.060]  So the first low ran specification was actually created in January 2015, so we're not cutting
[14:51.060 --> 14:56.380]  edge here, my friends, we're just catching up on what the cool kids have been doing since
[14:56.380 --> 14:58.180]  back when they were kids.
[14:58.180 --> 15:03.140]  So this is the lan part of the talk, which means the cloud.
[15:03.140 --> 15:06.140]  Take a refreshing breath.
[15:06.980 --> 15:09.020]  So that means routable packets.
[15:09.020 --> 15:13.140]  If you want to go between internet works, generally we use media access control addresses
[15:13.140 --> 15:14.500]  or MAC addresses.
[15:14.500 --> 15:18.100]  You've seen these and wondered, that's so ugly.
[15:18.100 --> 15:24.100]  But we need this because with lower wan, our architecture is a bit more complex.
[15:24.100 --> 15:30.540]  We have our end devices, as you saw, like the badge, and they talk to a lower gateway.
[15:30.540 --> 15:35.180]  And the gateway is what I was trying to get working before, but I had to do a router reset
[15:35.220 --> 15:38.100]  and I didn't have time to finish, I apologize.
[15:38.100 --> 15:41.860]  They didn't give me an ethernet cable, they were worried about what I would do with it.
[15:41.860 --> 15:44.860]  I don't know why.
[15:44.860 --> 15:49.340]  Anyway, the gateway then has a backhaul to the internets.
[15:49.340 --> 15:53.660]  And that's where the lower ran protocol has three components that are very important.
[15:53.660 --> 15:59.380]  The join server, the network server, and then the application server.
[15:59.380 --> 16:03.540]  So by the way, lower wan is already running on go.
[16:03.620 --> 16:07.900]  It's always in all the good places and it's already lower wan.
[16:07.900 --> 16:08.900]  What do I mean?
[16:08.900 --> 16:12.540]  Well, you may have heard of a company called the things network.
[16:12.540 --> 16:18.220]  Very, very cool company, real pioneers in the space, and they have a complete stack
[16:18.220 --> 16:22.620]  for a lower wan server back end that's all written entirely in go.
[16:22.620 --> 16:25.620]  Come on, give it up for them.
[16:25.620 --> 16:30.100]  Not to make an awesome free public service.
[16:30.100 --> 16:34.260]  And then chirp stack, a little bit more recent entry, they're actually doing amazing stuff
[16:34.260 --> 16:40.220]  with similarly entirely in go back end stack for lower wan and they have a lot of cool
[16:40.220 --> 16:42.180]  tools and libraries that we're using.
[16:42.180 --> 16:45.180]  So give it up for them.
[16:45.180 --> 16:48.820]  But we're talking about devices here.
[16:48.820 --> 16:53.020]  I mean, they've really got go on the back end, like we don't need to reinvent that wheel,
[16:53.020 --> 16:54.020]  they're doing amazing work.
[16:54.020 --> 16:57.060]  No, we're talking about the actual end devices here.
[16:57.060 --> 17:00.340]  And the most important part starts with device activation.
[17:00.340 --> 17:04.260]  So device activation is like when you buy a phone and it turns on, you don't have to
[17:04.260 --> 17:08.700]  keep like logging into your phone, maybe you should be, but let's skip over that.
[17:08.700 --> 17:09.700]  That's another talk.
[17:09.700 --> 17:14.380]  So it connects, it's activated, you go to your cellular provider and now you just start
[17:14.380 --> 17:15.380]  making calls.
[17:15.380 --> 17:20.100]  Well, this is the same model, the same pattern that we use with lower wan.
[17:20.100 --> 17:21.380]  And there's two kinds of activation.
[17:21.380 --> 17:27.340]  One is activation by personalization, which means pre-saved keys on the device itself.
[17:27.340 --> 17:31.620]  We're running out of power, 4%.
[17:31.620 --> 17:33.300]  The question is, what do I unplug?
[17:33.300 --> 17:35.500]  It's like, it's a tough decision.
[17:35.500 --> 17:39.740]  Oh, well, and also I don't have my adapter with me, so.
[17:39.740 --> 17:42.020]  You only have five minutes, so go.
[17:42.020 --> 17:43.020]  Oh, perfect.
[17:43.020 --> 17:49.580]  And then over the air activation, which means that you just connect to some server somewhere
[17:49.580 --> 17:55.180]  and you get your keys down from the cloud, and then you save those, and then you can
[17:55.180 --> 17:57.060]  use those.
[17:57.060 --> 18:00.340]  And then you use those for uplink and downlink, and one thing to remember, and that's really
[18:00.340 --> 18:05.900]  important, is that with uplink and downlink and lower wan, there is really only uplink.
[18:05.900 --> 18:09.180]  You uplink and then you maybe get a chance to download some data.
[18:09.180 --> 18:13.780]  So this is the reason why it's so low power, it mostly talks and doesn't really listen,
[18:13.780 --> 18:18.420]  which is the opposite of the app I showed you before, which is just a peer-to-peer thing.
[18:18.420 --> 18:23.180]  Also we have lower gateways, that's what this awesome antenna here is.
[18:23.180 --> 18:28.820]  It's a micro tick knot that I couldn't get rebooted in time with a Yagi antenna, and
[18:28.820 --> 18:31.420]  these are, this is a very powerful antenna.
[18:31.420 --> 18:34.220]  And you'll see what this is all about tomorrow.
[18:34.220 --> 18:36.060]  What do I mean?
[18:36.060 --> 18:40.540]  What I mean is tiny global, a Pico high altitude balloon.
[18:41.060 --> 18:50.980]  So if you go to tinyglobo.com, and we'll see if we have internet, yes, it will redirect
[18:50.980 --> 18:55.260]  you to this page, which is showing you when it's turned on the actual current location,
[18:55.260 --> 18:59.220]  altitude and stats of the high altitude balloon.
[18:59.220 --> 19:05.940]  This balloon we will be launching tomorrow, here at FOSDEM, uh oh, I think it may have
[19:05.940 --> 19:07.980]  fallen asleep, nope.
[19:07.980 --> 19:13.420]  Well noon, central European time, weather permitting, of course, and that's the end
[19:13.420 --> 19:15.420]  of the talk.
[19:26.220 --> 19:31.420]  As the best ending ever, we still have some time for questions, weirdly enough.
[19:31.420 --> 19:32.420]  Thank you, battery.
[19:32.420 --> 19:33.580]  How did that happen?
[19:33.580 --> 19:34.740]  I have no idea.
[19:34.740 --> 19:36.860]  Any questions for Ron?
[19:37.860 --> 19:39.860]  I'm sure you've got a lot of questions.
[19:44.860 --> 19:46.860]  Apparently no questions.
[19:46.860 --> 19:48.860]  Sorry, sorry, sorry.
[19:50.860 --> 19:51.860]  Hi.
[19:51.860 --> 19:58.220]  Have you ever managed to compile the whole Raspberry Pico SDK in C, and then import it
[19:58.220 --> 20:00.220]  successfully in tinyglo?
[20:00.220 --> 20:03.020]  I'm sorry, could you repeat the first part of the question?
[20:03.020 --> 20:09.340]  Have you ever managed to successfully compile the whole SDK for Raspberry Pi Pico, and then
[20:09.340 --> 20:12.100]  successfully import it in tinyglo?
[20:12.100 --> 20:14.580]  Because a year ago it didn't work.
[20:14.580 --> 20:20.980]  Well, so the question is, can we import the Raspberry Pi CSDK and then compile it into
[20:20.980 --> 20:21.980]  tinyglo?
[20:21.980 --> 20:27.500]  The answer is, I'm not really sure, um, I believe you, actually I think you can, but
[20:27.500 --> 20:30.580]  that's not something we're really trying to do, you're probably interested in the Wi-Fi
[20:30.580 --> 20:31.580]  support.
[20:31.580 --> 20:36.060]  And then it's important, you know, watchdog, for example.
[20:36.060 --> 20:39.340]  Most things are probably better implemented in tinyglo itself.
[20:39.340 --> 20:41.340]  There is no watchdog in tinyglo.
[20:41.340 --> 20:43.260]  There is no compile goal.
[20:43.260 --> 20:55.660]  There is a branch with a watchdog WDT experimental branch for, check that out, but yes, watchdog,
[20:55.660 --> 21:01.140]  low power, and bringing in C, those are all things that are part of the tinyglo continuum.
[21:02.140 --> 21:08.460]  So, 12 noon tomorrow, look for us outside somewhere, you'll know us by this antenna,
[21:08.460 --> 21:14.540]  look for this antenna, and some people wearing glowing helmets with actual balloons that are
[21:14.540 --> 21:20.220]  back in my hotel room, and by the way, all the parts are of Chinese origin, but it was
[21:20.220 --> 21:25.220]  made by these American hands, thank you.
[21:25.220 --> 21:28.220]  Thank you very much, and please do not tell the government about tomorrow.
[21:28.220 --> 21:30.300]  I'm sorry I don't have any cards.