Getting Started with Blues Wireless and the Notecard - On Demand Webinar
Are you new to wireless IoT? Are you curious about how low-cost cellular can improve your IoT deployments? Do you just want to learn more about Ray Ozzie and this "Blues Wireless" thing? Join us to learn the basics of Blues Wireless and the Notecard!
Webinar Transcript - Getting Started with Blues Wireless and the Notecard
Speaker: Rob Lauer - Director of Developer Relations - Blues Wireless 00:00
Hey everybody. I think we are pretty much ready to roll here. Just so you know what to expect, we will spend about the next 20 to 25 minutes walking through the Blues Wireless ecosystem, what we're about, the problems we're helping to solve with the Notecard, and how we help to solve them. So really quick, introductions: My name is Rob Lauer. I'm Director of Developer Relations here at Blues Wireless. If you're a Twitter person, you can find me there @RobLauer. Far more importantly, with me today is TJ Van Toll. TJ is going to provide a brief demo of setting up a Blues Wireless starter kit with a Notecard and sending your first data to the cloud. Likewise, you can find TJ on Twitter @TJVanToll. I thought it'd be useful to start with our mantra here at Blues Wireless. While I'm not the biggest fan of reading text off of slides for y'all, I'll do this really quickly here: “Complexity kills. It sucks the life out of developers, it makes products difficult to plan, build and test.” This idea of complexity kills really is in our DNA at Blues Wireless, and it is our goal here at Blues to make developers’ lives easier.
I think this can be really easy for a lot of us to relate to when we're adopting new or unfamiliar technologies. We want to solve problems we have, not make our lives more difficult. Hopefully, you will see this thread of simplicity run throughout our time today and hopefully during your journey with the Notecard. In our limited time today, we have a very simple agenda: We're going to do a brief overview of the Notecard and Blues Wireless, and then TJ is going to provide more of a hands-on demo of how the Notecard works. If you have questions, please enter them in that Q&A panel provided to the right of your viewer. After we're done talking, we'll take some time to answer as many questions as we possibly can. Let's just start with this company Blues Wireless. Even the wireless is in our name. People often ask, are we like a cellular service provider? No, we're not. We aren't hocking cell phones at mall kiosks. Rather, we are an IoT company that is focused on making wireless connectivity easier for developers. We are founded and led by former Microsoft Chief Software Architect Ray Ozzie. Ray is well known for starting up Azure, and back in the day, he was a key figure in Lotus Notes. We are really here to provide hardware and services that back up this message of making wireless IoT easier for developers and really more affordable for all.
Assuming that is our core mission, how do we really make that happen? I could distill that down into three main points: One is about security. Our focus is really on securing your data from the moment it's acquired by a sensor or whatever all the way through to landing on your cloud application. All of our hardware solutions are low power out of the box to the tune of about eight micro amps when idle, and this goes for our firmware as well. All the default configurations in our firmware default to low power. Finally, we're also very much a developer-focused company. Our developer experience is one of our top priorities, hence you'll see our really elegant and easy-to-use JSON-based APIs. Let’s start looking at our hardware—zooming in on the Notecard, for instance. The Notecard really is the core of what we provide. It is a low-power system on module measuring a tiny 30 by 35 millimeters. It does have that M.2 edge connector at the bottom for embedding in your project. There are both cellular and Wi-Fi variants of the Notecard. The cellular variation includes the GPS module as well, and the API—the way you interact with the Notecard—is all JSON. Gone really are the days of those archaic AT commands for managing your cellular modem. We also provide SDKs for Python, Go, Arduino, C and C++. Our community has even built SDKs for .NET for some proprietary microcontrollers, and Rust as well. There are Notecard varieties on the cellular side that we're globally using NB-IoT, LTE-M, and Cat-1 standards. Now to make it easier to use your Notecard when you're prototyping, or really even when you're ready to embed in a more permanent solution, we provide products called Notecarriers.
Now these are development boards that allow you to snap in a Notecard and connect it to really virtually any solution you can dream up. Now the Notecard AF, for example, includes a Feather-compatible socket. The A model includes headers that let you hook it up to any microcontroller you need, and both the AF and the A include onboard antennas as well. The B is a small form factor Notecarrier: Note that these images are not to scale, so this one's actually quite tiny. The Notecarrier Pi is a Pi HAT for working with any Raspberry Pi-compatible single-board computer. Finally, Notehub is really the third leg of Blues Wireless: It is a cloud service that receives data as a proxy from Notecard and in turn will securely route it to your cloud app of choice. Within Notehub, you can manage fleets of devices, you can update both host microcontroller and Notecard firmware over the air. Notehub is all about securely transmitting data, both from the Notecard and to your cloud. I mean secure as in data is transferred off the public internet via private VPN tunnels and can optionally be encrypted.
With the Notehub and Notecard, there's also no certificate management or key rotation required. A cool thing about the Notecard is it knows exactly where to go as soon as it is powered on. Again, everything with the Notecard is JSON in and JSON out. As an example, with the API, if you wanted to get your Notecard’s GPS location, you simply call card.location, and it will return the requested location along with some metadata. The rest of our API, I think you'll see, is set up very, very similar to this. To help visualize where the Notecard and Notehub sit in your IoT solution, let me walk you slowly through this diagram. You're going to bring your microcontroller or your single-board computer, like the Pi. You're going to use your sensors and ideally, your programming language as well. You're going to then compose packets of JSON data that we call Notes. Now, these Notes are queued on the Notecard to be sent, and then at a cadence that you specify, they are going to be securely synced with our cloud service Notehub. Now, we don't want your data to live on Notehub—we want you to route that data to your cloud app of choice. Now, that means AWS, Azure, or Google Cloud, or any IoT optimized provider like an Ubidots, Losant, Datacake, or even something that you've stood up on your own some kind of RESTful service. Now, it's important to note that communication with the Notecard is bidirectional, so you can start on your cloud app, and you can send a JSON-based request to Notehub using the API we provide. Notehub will then securely deliver that JSON payload to the Notecard, to one or many Notecards that you specify, and then the Notecard will deliver that back to the host for further control or programming or whatever that you're wanting to set. You can really see in this scenario how you can handle remote control scenarios or updating fleetwide variables all remotely over cellular or Wi-Fi.
Speaker: Rob 08:07
That's my quick seven-minute spiel. What I’d like to do now is send things over to TJ to see some of this in action. TJ, let me make you the presenter.
Speaker: TJ VanToll - Principal Developer Advocate - Blues Wireless
Yeah. While Rob is bringing that up, I'll just remind people that if you do have any questions, again, the GoToWebinar client is a great place to ask those, because we'll try to answer those as we go and then stop for them at the end. For my bit, I want to show you in action how all this works. I like to start by just showing the hardware itself. Rob mentioned it in slides, but I think it's helpful to just see some of them in person. So this is the Notecard. This is a small system on module 30 by 35 millimeters—hopefully you can get a sense just by me holding it how big it is compared to my hand.
This is something that again, can be embedded into pretty much any IoT project through this M.2 edge connector on the side. This is a cellular Notecard. I've got a Wi-Fi Notecard over here—you can see it's the same thing. The two Notecards are really API compatible. The only real difference is just the communication channel. One works over cellular, and one works over Wi-Fi. Now for connecting these boards, we have a series of Notecarriers that are really designed to make it easy for you to just snap in a Notecard real quick and build up your prototypes or even deploy solutions really easily. We have the Notecarrier A series, this is called the AL because of this LiPo battery connector that is on the side; there’s also a JST solar connector in here as well. There are other A-series models that take AA batteries. There was the A series one that has castellated edge connectors—that's available as well.
This one here is the AF, the F being for these Feather-compatible header sockets that appear over there. All of the A-series models also have onboard cellular and GPS antennas. Now the way these things snap in—I think Siri was listening in on me randomly there—but the way these things work is essentially you take the Notecard, and you insert it through this end-to-edge connector. You can see here I've got another A series here, where I've got a Notecard already hooked in. I've got the antennas hooked up, and the Notecarriers also have this micro-USB slot, so I've already got a USB cable plugged in here. The other end of that is going to the laptop—to the computer that I'm using to drive this. You will see why here in a second. I'll switch back over. Let me go ahead and share my screen, and also switch my webcam for a second so that you can see me again as well. There I am, and on my screen, if I go ahead and do this and move some windows open, you'll see dev.blues.io. Once you've ordered some hardware from us, you have a Notecard and Notecarrier, and you've hooked the Notecard into the Notecarrier, this is really the first place that you should go—dev.blues.io. It’s our home for all things Blues, just documentation wise; you'll see there are guides and tutorials here. There's reference documentation, SDK information; it's your go-to hub for all things that we do. The very first thing I'd recommend doing is heading to the Quickstart, into the Notecard Quickstart, which is a step-by-step tutorial that's going to guide you through really everything you need. It even has steps on here to help you set up the hardware itself in terms of what you get, how to mount everything, and how to screw everything in and get everything ready. This guide is also configurable, if I go back to the top here, based off which Notecarrier you get.
In this case, I had that Notecard connected to an AL, so I selected that there, but you could customize this based off the Notecard that you get. Now you can see for the most part, this tutorial looks like any other tutorial you'd find online for any sort of software or hardware that you might be using, with one big interesting thing: this panel that appears on the right-hand side of the screen. One cool thing that you can do on dev.blues is you can actually connect directly to a USB-connected Notecard and Notecarrier. That's actually why I had the micro-USB cord connected to my Notecarrier, because by doing so I can actually connect using the web serial API. This is something that's built into some web browsers, Chrome, Edge, and such have it, where you can connect directly to serial devices. In this case, I can select the Notecard and directly connect to it.
What's cool is if I do this, I can now issue commands and work with my Notecard directly through the web browser. For instance, if I scroll down in this tutorial, because there's a little copy-and-paste friendly block a little bit down here, I can send commands to the Notecard. For example, I can ask for the version. I'll explain the syntax in a second. You'll see I get information back in this case about the firmware versions and various metadata about my Notecard. I want to pause and mention a few things about what just happened here, because I think it's kind of cool. The first thing—Rob mentioned this in the slides, but just to point out again—the APIs for working with the Notecard are all JSON based. In this case, the way I ask the Notecard to do something—I'm asking for the card.version—I send a JSON command saying the request I want is card.version. Notecard accepts that over the web serial API and then passes back the return data as JSON as well. So JSON in, JSON out. All the APIs work that way. We think it's an incredibly cool way to interact with piece of hardware, in this case, the Notecard.
It's pretty cool that you could do that, but I will mention that I'm showing things through the web browser, just because I think it's very cool. It’s also very easy for something like this for a tutorial/demo type of setting, but I also mentioned that everything you see be show today all these commands that I’m showing in the browser, are something that you can also do through the Notecard CLI, which is something that we offer for Windows, for Mac OS, or for Linux. If you want to get in, and you're more comfortable with a terminal command prompt environment, you can automate things based off of that. Also, all of these commands that I'm showing are also available in our SDKs, which we have for Arduino, C, C++, Go, Python, and some others as well.
You can automate, and you can write your scripts around through those SDKs as well. I'll be showing one example of that at the end of this demo, too, but we're keeping things super simple today; we're just going to go with some basic commands. This is how we get the key, the version information from our Notecard, but chances are, you want to do something more interesting with your Notecard than get its version or its metadata. Let's look at how to do something more interesting. The first thing we'll want to do is actually take some sort of data—a lot of IoT projects, you're gathering some sort of data, sensor data, location data, whatever it might be—and sending it to the cloud. To do that with a Notecard, you'll see that the next step in the tutorial is to set up Notehub. Now Notehub is our cloud service. It's sort of a thin cloud service that allows you to easily accept data from the Notecard and pass that along to wherever you want the end destination of your data to be.
I've gotten Notehub, which is notehub.io, up and in this other browser tab. At Notehub, the first thing you'll need to do is create an account. I've already done that to save us a bit of time, and then you’ll create a project. The project is just going to be a logical sort of grouping of our different devices and data that we use. We're just going to create one real quick called Get Started, because that's what we're doing here today. With Notehub, to build this project, I'm going to get this little identifier and call it a product UID. That's basically just a quick ID that I'm going to need. If I go back to my Quickstart, you'll see that the next command that I need to run is one called hub.set. What this command is doing is it's essentially letting me associate the Notecard—that’s the physical hardware sitting on my desk here—and the project in the cloud service in Notehub that I have set up.
This is making this link, once I've linked things up, I can start to do more interesting things like send data and send settings, those sorts of things. Now I ran the hub that said, I also need to run one additional command to make this link and that's hub.sync. What you'll find when you use the Notecard is a lot of our APIs, a lot of our setup, are designed to be low-power friendly by default. I think Rob mentioned in the slides, to the tune of eight micro amps while the thing is idle. We know a lot of you, a lot of the reasons you use something like a cellular Notecard is because you were in an environment where you have to be very careful about the amount of power that you use, and the Notecard was very much designed with that in mind. You don't have to use the Notecard that way. As you'll see, and I'll show the API documentation later, there are different modes you can set your Notecard to, and there are different ways you can work with it.
If you know you're going to have consistent power, you can set the settings to do things like sync far more frequently, but the defaults are very low-power friendly. Just by running the hub.set command, you don't instantly make that connection. The sync is sort of what triggers that communication between Notehub and the Notecard and actually establishes that connection. In this case, because I ran a sync, what I can do is go back to Notehub and refresh. Now I see my device appearing here, so I've now made the link between the Notecard that's sitting here on my desk and Notehub here. I'm ready to just start to do some more interesting things. Before I do, Rob, I want to pause for a second. Do we have any questions that have come in? Have I missed anything? Should I keep going? Where are we at?
Speaker: Rob Lauer
Yeah, one question that we always get is about country coverage with the cellular Notecard. I can address that really quickly. We do have four different Notecard models that are available. One is the NBGL, that is the code on it, and that stands for narrowband global. And this is all in our data sheets on dev.blues, but basically the coverage is 137 countries and counting—
Speaker: TJ VanToll
I keep clicking the wrong link. Sorry. There we go.
Speaker: Rob Lauer
Yeah, there are four different—the NBGL I just mentioned is our global Notecard; the notable exceptions are India and China. If you're in one of those countries, you can still use an external SIM card with any of our Notecarriers as well. Just really quickly the other ones—NBNA is narrowband in North America, WBEX is wideband in EMEA, so that's Europe, Middle East, and Africa. WBNA is wideband in North America. I will say the WBEX also works some places in Latin and Southern America. In terms of the cellular protocols that they connect to, the widebands will connect to Cat-1, the narrowbands to LTE-M and NB-IoT in that order, and there's some fallback on 2G as well. This is, again, all in the data sheets here. If I get anything wrong, just consult the data sheets. And obviously, the Wi-Fi works everywhere. Cool?
Speaker: TJ VanToll
All right. Yeah, good questions, make sure to keep them coming. Otherwise, it's just going to be us rambling for another 15 to 20 minutes, and nobody really needs that. All right, so at this point, we've set up the connection, we've hooked up our hardware, we've taken the Notecard, we ran the hub.set command, and we associated with this Notehub project that we have set up here in the cloud. What's cool is that now that we have the connection made, we can start to do some more interesting things. I mentioned that probably the most common thing you'd want to do at this point is actually start to send some data, whatever sort of data you have, you want that data that you're collecting in some way, shape, or form locally, you want to push that up to the cloud. The easiest way to do that is with the note.add command, because essentially what this request does is lets you send an arbitrary body of data, again, in JSON format, up to Notehub.
Now in a second, we'll look at how to get some actual live sensor readings here, but we'll start with just some hard-coded data just so you can see how the flow works. I'll go ahead and take this command, and I'll send it so we'll run our note.add command. We have to remember again, that by default, just being low power conscious, that command isn't going to go through immediately. Actually, because it's low power friendly, one of the most expensive things you can do from a battery perspective is initiate a cellular connection. The modem eats a decent amount of battery, so it'll queue up those Notes until a sync occurs. We're just going to trigger a sync right away, because we want to see our data right away. If I go back to Notehub and go to this Events section, it is going to show me a list of all the events that have happened with my Notecard. Some of these are internal things that are showing you information about when explicit syncs happen and some configuration as well, but you can also see events for things like note.add when data comes through. You'll see that the hard-coded data that we just sent through for these fake humidity and temperature readings just came through and appeared in Notehub as well. Pretty cool. I want to show—we'll turn that into a dynamic request here in a second, but the other thing I want to show is that communication between the Notecard, the physical hardware, and Notehub, this cloud service, is bidirectional. What I just showed is how you could take data that's on the Notecard and send it up to the cloud. You can also send data configuration in the opposite direction as well. If I go back to my devices list and I go to this device I have here, one thing I can do is I can add a Note from the cloud service. If in Notehub, I want to send a Note file—I'll explain that syntax here in a second—I want to send a Note down, so the key for this—don't worry too much about this—but the convention, this .qi, you kind of have to read it backwards. That .qi means it's an inbound queue, basically it means data is inbound to the Notecard, so the Notecard is the basis for these. So .qi is inbound and .qo is outbound queue; outbound from the Notecard, but you don't really need to worry too much about this. All you need to know is I'm sending some data from Notehub from the cloud down to my device by doing this. I'm going to send this Note. By the way, because this comes up quite a bit too, I'm sending it through the Notehub UI, but there is also an API for Notehub that you can use instead. If you want to automate this into your own system, that's something you can do. You don't have to use the user interface for doing that. But I sent this and I'll skip ahead down to the part that I need to grab from this tutorial.
Once again I need to sync so the Notecard is not just constantly watching for the data that's going to be coming from Notehub; that would use up a lot of battery if it's constantly pinging Notehub looking for new information. I'm going to trigger a sync—I'll give this a second, and then I can run a separate command. In this case, to get Notes that have come in, I run a file.changes request. I’m going to do that, it's going to tell me it has one, and there's a separate command called note.get that I can use to get those values. I can see the data that came through here; it's just going to be those two strings that I hard coded real quickly. This is just a basic demonstration. Hopefully you can get a sense of the sort of things you can accomplish with this. One really common use case is remote control—you have some sort of device that is out in the field, and you want to be able to send commands to it. We, Rob and I, have a co-worker that built a robot that can accept these commands and do things like move its arms and whatnot, so that's the sort of thing you can accomplish. You can use this to change settings and environment variables that are built into the Notecard. Rob recently sent a series of Notecards quite literally around the world to test out some of the tracking capabilities. He was able to actually change the settings, things like how often he was collecting data and whatnot as these things were traveling around the world, which is actually really cool and interesting. There are a lot of cool things you can do. Rob, am I missing anything related to this? I think we should also check to see if any questions have come in at this point as well.
Speaker: Rob Lauer
Yeah, the question alluded to this too. Just to note that everything TJ showed in terms of those explicit hub.sync requests can be automated with different parameters. If you look into the hub.set API, you can set up periodic connections to Notehub based on time limits. You can say, “Connect every 30 minutes, but only connect if there is data to be synced.” Or you can maintain a continuous connection if you're not worried about battery life, and you can immediately sync data from the Notecard to the Notehub. There are all sorts of different parameters to look into depending on your specific scenario.
Speaker: TJ VanToll
Yeah, there's lots of different ways you could approach it. You could also… I'm about to show how to do this in something like a Python script or something that's more realistic. You can either use these configurations to control how often data syncs, or you can do it programmatically. You could have a script that says, “Every X minutes trigger a sync,” or maybe there are some important events, like I detect something and I need to sync the data then because it needs to be available. There are lots of different approaches that you can use for more production situations.
Speaker: Rob Lauer
There's even again, I’m kind of harping on the battery-conscious nature of the firmware, but there's a voltage variable setting as well. Depending on the voltage of your battery, you can sync every 30 minutes if the voltage is high all the way down to maybe once a day if the voltage is getting low. There are all sorts of different parameters that you can use.
Speaker: TJ VanToll
Cool. So, that was it for the Quickstart. Again, even though you saw me sort of do it, I would still recommend that it be the very first thing you do, because there's a lot of value in going through those steps to get your hardware configured, set up Notehub, and just see that data flow back and forth. It's just a nice set of prerequisite steps to see how everything works and feel it for yourself and get everything up and running. Which is cool, but chances are you want to do something more advanced than sending hard coded strings back and forth from the Notecard. For that, I'd recommend as a next step that you check out the guides and tutorials section of the dev.blues documentation. There's lots of stuff here that goes into more detail and could help you with your specific situation. There are things on asset tracking and a bunch of different features of the Notecard. What I'd recommend as step two is to check out both our tutorial on collecting sensor data and our tutorial on routing data, and I'll go through these sequentially. I'm not going to go through all of them. I'm just going to give you a sense of what these are about and then show a quick example that shows them in action a bit. Our sensor tutorial helps you move beyond those hard-coded strings so you can try to build more of a realistic scenario of actually getting some data from a sensor and sending it off to Notehub on some interval. You’ll see that this tutorial is also configurable, so you can work with a number of different languages and technologies. There’s different boards, and you can go through this with different Notecarriers, different languages that you can try to configure this with, and just learn how to do this process based off your own hardware or whatever situation you're building. Now the routing tutorial will help you once you are regularly sending data up to Notehub. It'll help you take that data and move it someplace that you might ultimately want it.
What I mean by that is that you might want to take that data, that event data that's coming through, and move it to something like another cloud, something like an AWS, Azure, Google Cloud, something like that. You might want to take your data and feed it to some sort of IoT platform like Datacake or Ubidots. You might just want to send your data and say, “Every time an event comes in, I want Notehub to invoke some endpoint. I have some custom HTTP server I set up, or I have some other service or whatever it is I’m using, and I just want this endpoint to get invoked,” and we can help you do that as well. Those are the next tutorials I'd recommend going through. What I'm going to do today for this Quickstart environment is just skip ahead and show you what the end state of these tutorials look like so you can get an idea of what you are building.
Speaker: TJ VanToll 31:17
To do that, I'm going to switch monitors because I have a little Python script open here and I'll blow up the font size a little bit. I'm going to go grab it. I've got it sitting down here, and we'll see if the cord I used is long enough. You might have noticed when I showed off all the Notecarriers earlier, I did not show off the Notecarrier Pi. That's because I'm hooked up to a Raspberry Pi here, so I've got the Notecarrier Pi plugged into a Raspberry Pi 4, and I've got a Notecard in there dangling here. I don't know if I've got my angles right, hopefully you can also see the BME280 sensor; it's a really common sensor for gathering temperature, humidity, and weather data. I think by showing the cord, I totally might have just unplugged, so I might have to restart, but I'll do that as I'm going through this source code. What I've got is a little Python script that I've written for the Pi. I'm not going to go through every line of Python code—I don't want to go over every last detail—what I do want to do is show you some things that are going to look super familiar. For example, this hub.set command. As I mentioned earlier, there are different ways that you can send these commands. The easiest way is just to fire them up in a web browser—oh, looks like my Pi is coming back online, which is a good sign—if you prefer not to send through the browser, you can also use our SDKs for doing that as well. I'll fix that in just a second. In this case, I'm formatting up this command in some Python code, and I'm using this card, that transaction is actually from our Note Python API or SDK for Python. This is going to be using the Python SDK and issuing this hub.set command. What I have further down here is a loop that is gathering data from that BME280 sensor, and it's going to print it out. Then here's that exact same note.add command that I ran earlier. But this time, instead of using hard coded data, I'm going to take that actual sensor data and put it into the body of this note.add and do the same card.transaction command to send it up to Notehub.
I'm also passing—I didn't show this earlier— but there is a sync flag that you can send as part of note.add to trigger a Notehub sync, so you don't have to run an explicit hub.sync with each of these you send up, which in a production scenario I wouldn't really use, but for demo purposes, it's really handy. It's just a quick way of syncing and seeing your data. I disconnected from my Pi because I stretched my cord too far, so I'm going to have to fire back up. By the way, if you haven't used it before, the remote, I think it's called Remote Explorer, extension for Visual Studio code is really, really slick. If you need to SSH into anything as part of your work, I highly recommend it; it is really slick. I'm in here. I've got my sensors’ code up on the backup to make sure I'm in the right thing, and then I'm going to go ahead and run it.
Speaker: TJ VanToll 34:24
I’ll run this, and you'll see that further down I'm printing this temperature there—I'm sorry—humidity, pressure, and temperature. I'm spinning it out here. I'm also sending it up to Notehub, this syntax here, this is what the Notecard is actually returning from me running that note.add command. The total is just telling me how many Notes still need to be synced, and the fact that this number is not going up is telling me that it is actually successfully sending data. I have this going to another Notehub project called weather, so I'm going to open that up. Go to my events and you should see… so there's the temperature, humidity and stuff that's coming from my device. Kind of cool, because at this point, we've now got our hardware setup. Now we're using some, in this case Python code, but it could be Arduino code, it could be Go code, it could be whatever, to gather some real data, firing up some note.add commands, and I'm seeing them in Notehub. Now the last piece of the puzzle, you'll remember the last thing I mentioned was going through the routing tutorial, and the routes section of Notehub can help you do this. If you go to create a route, you'll see those same options that appeared in the tutorial of different ways that you can route your data to some of the big clouds and MQTT, or you can send it to just some general HTTP endpoint. Now, in the case of this demo, you'll see that I already have a route setup for Ubidots. Ubidots just being a really simple-to-use IoT platform, it makes it really easy to build visualizations of your data in the cloud. Every event that comes in, if I just go to one of them at random, here, you'll see that Notehub is automatically routing that data to Ubidots. If I open up the Ubidots explorer here in my browser to see the last hour of data, and refresh, you'll see that those events are sort of transitioning over to Ubidots. I can see them in this nice dashboard, where I can see the data coming through, and this updates on the fly. I could leave this running and continue to see new data as well. Really, that's kind of the complete flow. If you think back to when Rob showed the slides of the data and how inbound data flows through the entire project when you use the Notecard, you start by setting up your hardware with the Notecard, you collect your data—whether that's location data, sensor data, or whatever—you use something like a note.add command to send that data up to Notehub. Notehub then takes that data and then routes it wherever you want it to be. In this case, I have a Ubidots dashboard that I want to see it on—and this could be my own platform, this could be wherever I want to use. That would be the journey that I would recommend. Again, I'd say go through the Quickstart. Go to our guides and tutorials, and check out these tutorials as well, because I think that'll help you really get going and understand how to use the Notecard and how to use Notehub. From there, you can look at our guides that are a bit more specialized based on what you are trying to build. I think that's it for the demo section, Rob. Did I miss anything?
Speaker: Rob Lauer
Yeah, that was really good. I think a lot of what TJ showed, and one of the points we're trying to get across, is that you can bring your own bag of parts and accomplish everything that we're doing with the Notecard. We're really trying to simplify things—the Notecard is a system on module, right? It has numerous different components that solve issues like data management, storing that data, queuing that data to the cloud, and securely delivering it to the cloud without any certificate management or key rotation or anything like that. Really, we're trying to provide the most turnkey plug-and-play solution for you.
Speaker: TJ VanToll
Yeah, it's really that we think about the things so you don’t have to. You’re just sending simple JSON commands, you don’t have to worry about what happens if the cellular connection fails… a lot of this data batching, data management is handled completely for you, which is kind of cool.
Speaker: Rob Lauer 38:42
One thing I did want to mention before we finish up here: A big part of our jobs—meaning with TJ and I—at Blues is to create these really fun, silly, and sort of pragmatic tutorials on hackster. We addressed some key scenarios like machine learning, asset tracking, remote monitoring, and you can really see how many use cases you can address with the Notecard here. Check out our projects. A lot of these have full end-to-end tutorials involved at hackster.io/blues-wireless. I did want to mention we have a growing YouTube channel too if you're more of a video learner, you can head to the Blues Wireless YouTube channel to find that as well or just obviously do a search on Google for Blues Wireless and you will find it there as well. Finally, before we jump into some Q&A, there's a few resources I want to make sure you had. Of course, TJ showed this off, but visit dev.blues.io for any technical resources you need. There's even a web-based sneak peek of our API you can browse, and just for attending here, you can grab 15% off any of our starter kits.
We have a Feather microcontroller starter kit and a Raspberry Pi starter kit. You can grab those, it's limited to one starter kit and one purchase, just so you know. Also, we do have a community forum if you have any further questions, you can reach out to TJ or I directly or post your question to the forum at discuss.blues.io. Also, next week, we are hosting a webinar about global asset tracking. This is with our friends at Datacake, and you can register for that at the URL provided here. Now to hit on some questions.
A question came in about microcontroller recommendations. This is a question we get often, and our default answer is usually that you can use any microcontroller. People follow that up with, well, which microcontroller should I use? And, aside from repeating ourselves and saying any microcontroller, we do have our own Feather-compatible microcontroller called the Swan. You can check it out at dev.blues.io. It's really nice, because it's very low power but surprisingly powerful: tons of IO, it’s Feather compatible so it slots right into our Notecarrier AF. Well, that's our recommended one, I guess, if we're going to make a recommendation.
A question came in as well about selecting LTE-M versus Cat-1. Oh, this is a really good question. Part of it's going to depend on location, of course. If you are going to… obviously, if you're only going to be in the US, for instance, I might recommend a Cat-1 Notecard, only because the Notecard is going to connect a little bit more quickly to a Cat-1 protocol. Obviously, the bandwidth there is going to be higher. One thing we did not really mention is that while you may have intuited that the Notecard is a low-bandwidth product by default, there is the capability of performing file transfers. Of course, if you're transferring files with the Notecard, you'd want a more wideband connection that would be available in Cat-1 as well. On the LTE-M, and NB-IoT side of things, if you're just sending text—like strings of sensor data—you'll be fine with those as well. And LTE-M is definitely better than NB-IoT, and the Notecard does try to connect to those in order of their availability.
So, yeah, it's going to depend on your scenario, but there are some pros and cons for each.
Another question came in: Have you tried interfacing with an AI framework like Edge Impulse? Yeah, if you go to our Hackster page, a lot of the ML projects that we’ve put together have used Edge Impulse extensively. I definitely enjoy working with their platform. It's been very, very useful, and very engaging. It's really a simple way to get started with machine learning on embedded systems. Actually, on the Edge Impulse site, there is a tutorial for working with our Swan microcontroller as well. Let's see what other questions we have here.
Are there any limitations to using the Notecard?
Yeah, as mentioned, I like to position it as kind of a high latency, low bandwidth product in general. You know, we're not here for video streaming purposes, this is not a 5G product, right? We're not, in terms of video streaming or massive file transfers, we're probably not the best solution for you. I would say to that… I just blanked on it. One thing I didn't mention—I need to add this to our slides—is that the cellular Notecard does come with 10 years of service and 500 megabytes of data included, and you can top up that data as needed. Again, if you're going to bank on 500 megabytes of data over 10 years, you're probably not going to be sending too many high-resolution images or videos. Did I miss anything, TJ or—
Speaker: TJ VanToll
No, I always like to remind people, because I know some people think of questions after this, or maybe you're watching the recording, discuss.blues.io is a great place to go when you have these sorts of questions. Rob especially—he's very active on there—as are a lot of us at Blues. If you do think of anything else, or like I said, if you're watching this after the fact, just feel free to hop on there and we can help you out.
Speaker: Rob Lauer
Yeah, I think we just answered most of the questions here. If I missed anything, please let me know. Otherwise, I’m going to be aware of your time and, again, thank you very much for attending. Grab that discount code, and again if you have any questions, you know where to find us.
Speaker: TJ VanToll
Cool. See you, everybody.
Speaker: Rob Lauer