Internet of Things Primer
This article is for you if you’ve heard of the Internet of Things but you don’t really know what’s behind that term. I’ll introduce you to the key components of a typical Internet of Things system from a technical point of view. I assume only that you know some of the applications (autonomous cars, smart cities, NOT typically a smart fridge) but you don't know how they work inside. This article will give you a high level (architectural) overview of such a system.
When people talk about "the Internet of Things", those Things are all types of computers that don't look like a computer.
That's the first part: the Things that make up the Internet of Things just have a computer inside them. That doesn't mean those Things look like computers.
Compare it to cars. Most cars look like this:
Wow, I hear you say. Look at the diversity! There's a pick-up near the next lamp post, a few SUVs. Some look expensive or sporty. You calling this similar?
They are all quite similar if you compare it to this:
Or if you compare it to this:
I hear you exclaim: surely, those are not cars?
In the same way, we think that computers look like this:
However, I worked on computers that looked like this:
A more fancy computer that I worked on, took this selfie:
At the inside of such machines, you will usually find a computer system like this:
The computer shown here is a plug-in card for another computer. This computer by itself cannot connect to a screen, a keyboard or a mouse. But, in some ways, it's a lot more powerful. It's what we call a DSP. It's a computer made for Digital Signal Processing. This type of computer has thousands of applications, including:
- Everything audio or video: your CD player, iPod, DVD/BlueRay and smartphone all have DSPs inside.
- Cars: your car is full of these DSPs, to control ABS, the airbags, anti-skidding and just about everything smart
- Just about every machine you can imagine.
Recap: computers are the first building block for the Internet of Things. The "Things" all have computers inside them. But they look like the Thing, not like a computer.
Just to recap and to add one more pretty picture, here are a few more computers:
We strip a computer of its standard set of peripherals, like its mouse. But your computer can't really do much without connections to the outside world. So we add back what we need: a camera, a gyroscope, links to other systems on board or elsewhere, … As a result, we get a computer that is purpose-built. That computer is then embedded into another machine. We thus call the computer an embedded system. As a matter of fact, embedded systems is the ancient name for Internet of Things.
That's the second part: our embedded computer uses sensors and other components to interact with the outside world.
We can embed computers in just about everything. Aside from the spacecraft and sorting machine above, I have worked on systems that were deployed in buoys for seismic research, in radars and in sonars, amongst others.
Fortunately, life is much easier now than it was when I started in embedded systems. Hardware is much more powerful now. Twenty years ago, I worked as a software developer for a company where we made an operating system and drivers for those DSP processors. Nowadays, in many cases you can just run Linux. For example, take the Raspberry Pi. It's a little computer that looks like this:
See, it's already pre-stripped! You have some connections, though. At the bottom, you can see an HDMI port. Just hook up a computer screen, then attach keyboard and mouse to the USB ports on the right. Voilà, you've got a running Linux computer! Best of all, it costs only €40.
The fun really starts when you program it to do things that also work without screen-keyboard-mouse. Here's what it looks like when you hook up a temperature sensor and a small display:
While screen and keyboard are helpful when you're developing the system, you can just leave them off for deployment. For example, the system we've developed at my company Geckomatics looks like this:
This is a camera that our customers use to map their outdoor infrastructure. They mount the camera on a car (in the wide sense of the word), then drive around and back in the office, process the information.
Recap: sensors are the second building block of the Internet of Things. Our embedded computers will capture data with the sensors that we selected for our application.
Next thing we need to do is make sure we can use our data. For example, we might want to:
- Process the data, e.g. stripping out spurious results, simplifying the data, storing it in a database, …
- Present the data visually, e.g. showing maps, graphs, …
- Interpret the data, e.g. recognise patterns, objects in video, … This can sometimes be done with A.I.
- Combine the data with or compare it to other data, e.g. to find the differences, to enrich your data with more information.
That's the third part: we need to process or present our data to use it.
For example, this example from the data processing company Luciad presents data gathered in the field on a map:
There are several possibilities at this stage. For example, you can have a post-processing stage with a dashboard. In other cases, the presentation of the data can happen on the system itself. Or you can have a combination: an electric car presents part of the data to the driver, but another part is sent to the manufacturer for monitoring.
Now that we have our embedded system and usually our processing backoffice, we need a way to connect them together. Your embedded systems need to relay their data to the backoffice to get it processed.
There are many ways to send sensor data to other systems. For example, there's the LoRa network that is designed for Internet of Things sensor data. It's low power, so perfect for battery-operated devices. However, it's also low bandwidth: you can't send too much over it at once. For us at Geckomatics, that's no use because we collect hundreds of megabytes per minute. We use a combination of a local server for backups and nightly backups to the backoffice.
Recap: using the data is the third building block of Internet of Things. You need a connection from your embedded computer to the outside world. Once you get the data out, you can process or present it.
That's a short architectural overview of embedded systems. You have an embedded system in the field. It's a computer with sensors and other equipment to get the job done. It sends its data to a backoffice for processing and to present it in a form that we, humans, understand.
Of course, just like the variety of shapes of the computers, the architecture also comes in many forms and shapes. Sometimes, the backoffice is the main focus. It can be extended to control the embedded computers, to reprogram them from a distance, and much more. But in other cases, the embedded computer is almost completely standalone, like with a GPS system or a smartphone.
So that's the conclusion. Even though we've just described a typical architecture for an Internet of Things system, there are many other possibilities. Because embedded systems are always purpose-built, there are no rules. Just make what you need. It's that freedom that makes them so interesting!
If you liked this article, hit the clap button & dleave a comment. I'm planning to add a getting started guide based on the Raspberry Pi. Let me know if you like the idea!
