In this guide, I’ll show you how to set it up using Docker for a streamlined, privacy-focused smart home. Docker provides an efficient way to run Zigbee2MQTT as a standalone service, offering a lightweight, modular setup – no Home Assistant required.

Table of Contents

• Key IoT Concepts in this Tutorial

• What You’ll Need

• What You’ll Do

• How to Prepare Your Environment

• How to Set Up the Zigbee2MQTT Configuration

• How to Set up Zigbee2MQTT and MQTT Broker in Docker

• Launch the Containers

• Pair Your Zigbee devices

• How to Create an Automation Script

• What’s Next?

Key IoT Concepts in this Tutorial

Here are the key concepts related to the Internet of Things (IoT) and smart homes that you’ll be working with:

• Zigbee is a wireless communication protocol used in smart home devices. It relies on a Zigbee coordinator to communicate with devices like lights, sensors, and switches within a local mesh network. This network allows devices to relay signals to extend coverage and reliability.

• MQTT (Message Queuing Telemetry Transport) is a lightweight messaging protocol for low-bandwidth and high-latency environments. It uses an MQTT broker to manage communication between devices using a publish/subscribe (pub/sub) model, where devices can either send or receive messages based on specific topics.

• Zigbee2MQTT is a bridge application that connects Zigbee devices to an MQTT broker. It translates Zigbee signals into MQTT messages, and vice versa. Zigbee2MQTT supports a wide range of devices from different manufacturers.

What You’ll Need

1. A Zigbee coordinator connected to your network or device. I have an SLZB-06 ($65 USD) connected to my network.

2. A device capable of running Docker, such as a Raspberry Pi or Linux server. I flashed a Raspberry Pi 4 - Model B.

How to Prepare Your Environment

1. SSH into your Pi using the following command in your terminal window, where pi is the username of your Raspberry Pi OS and <RaspberryPi_IP> is the IP address of your Raspberry Pi on your local network.

    ssh pi@<RaspberryPi_IP>
   

2. Install Docker by inputting the following command at the SSH prompt.

    curl -sSL https://get.docker.com | sh
   

3. Give permissions to the current logged in user. You may then need to close the SSH connection, and re-connect, if the permissions hasn’t taken effect.

    sudo usermod -aG docker $USER
   

How to Set Up the Zigbee2MQTT Configuration

1. Create a new project directory, and also a /data directory to store configuration files and data persistently.

    mkdir -p ~/zigbee2mqtt/data
   

2. Create the configuration file.

    touch ~/zigbee2mqtt/data/configuration.yaml
   

3. Open file with your preferred text editor, like using nano as shown below.

    nano ~/zigbee2mqtt/data/configuration.yaml
   

4. Paste the following YAML code into the configuration file from the text editor interface.

    homeassistant: false
    permit_join: false
    mqtt:
      base_topic: zigbee2mqtt
      server: 'mqtt://mqtt:1883'
    serial:
      port: 'tcp://<IP_OF_ZIGBEE_COORDINATOR>:<PORT>'
    frontend:
      port: 8080
   

5. Update the following details within the configuration.yaml file, and save the changes.

   • <MQTT_BROKER_IP>: Your MQTT broker's IP or hostname.

   • port: This value depends on how your Zigbee coordinator is connected:

     • If your Zigbee coordinator is connected to the network, you can configure the port using TCP/IP as shown in the example above, for example tcp://192.168.1.xxx:6638 where the SLZB-06 is located at 192.168.1.xxx on the local network and 6638 is the default port for that Zigbee coordinator.

     • If the Zigbee coordinator is connected to your device, you can find the serial port (such as /dev/ttyUSB0) by running ls /dev/tty* before and after plugging in the adapter to your device.

How to Set up Zigbee2MQTT and MQTT Broker in Docker

1. In the root of your project directory, create a docker-compose.yaml file to set up the Zigbee2MQTT container and Eclipse Mosquitto broker container to handle communication between Zigbee2MQTT and other services.

    services:
      zigbee2mqtt:
        container_name: zigbee2mqtt
        image: koenkk/zigbee2mqtt
        restart: unless-stopped
        volumes:
          - ./data:/app/data
          - /run/udev:/run/udev:ro
        ports:
          # Frontend port
          - 8080:8080
        environment:
          - TZ=American/Los_Angeles
      mqtt:
        image: eclipse-mosquitto:2.0
        restart: unless-stopped
        volumes:
          - "./mosquitto:/mosquitto"
        ports:
          - "1883:1883"
          - "9001:9001"
        command: "mosquitto -c /mosquitto-no-auth.conf"
   

2. Update the TZ environment variable if you are located in a different time zone, and save any changes.

Launch the Containers

1. Run the containers.

    docker compose up -d
   

2. Test the setup by checking the logs to confirm Zigbee2MQTT is running without errors. And look for lines indicating successful connection to the MQTT broker and Zigbee network initialization.

    docker compose logs
   

Pair Your Zigbee devices

1. Once Zigbee2MQTT is running smoothly, you can access the frontend at http://<your-device-IP>:8080 from a web browser to pair and manage your Zigbee devices.

2. Enable pairing by clicking Permit Join (all), and then pair your devices by putting them in pairing mode, for example holding down a reset button.

3. Finish pairing all the Zigbee devices that you wish to use in an automation. In the screenshot below, I have paired an Aqara button and Third Reality smart plug.

   

4. Give your devices a friendly name by using the pencil icon. Make sure to choose a unique name to avoid messaging conflicts in the following steps. For example, if you have 2 smart plugs, you can name them smart-plug-bedroom and smart-plug-office.

MQTT brokers follow a pub/sub messaging pattern which involves the following:

• Subscribing to MQTT topics like zigbee2mqtt/aqara-button to monitor device states like listening for button presses.

• Publishing to MQTT topics like zigbee2mqtt/third-reality/set to send commands to devices like a smart plug to turn on a light.

A topic such as zigbee2mqtt/third-reality/set is broken down into 3 parts:

• zigbee2mqtt refers to the base topic (default for Zigbee2MQTT is zigbee2mqtt).

• third-reality refers to a specific device or group using the friendly name shown in the Zigbee2MQTT frontend.

• set allows you to control the device or group using a JSON message such as {"state": "TOGGLE"}.

1. Input the following command to see the MQTT messages being published to Zigbee2MQTT.

    docker logs -f zigbee2mqtt
   

2. Complete an action on a Zigbee device, for example pushing a button, and make a note of which topics you want to utilize in your automation for the next steps. For example, in the screenshot of the logs below, there is an MQTT topic published called zigbee2mqtt/Aqara when the Aqara button is pressed.

How to Create an Automation Script

To set up an automation, you can use an external system like Home Assistant or Node-RED, or use Zigbee2MQTT’s external converters to respond to MQTT messages from the broker.

You won’t be doing that. Instead, let’s write a JavaScript script to handle this automation, to keep the functionality modular and independent.

1. From the command line prompt of your terminal window, install the NodeSource setup script on your Raspberry Pi.

    curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
   

2. Install Node.js to use as the runtime for your script.

    sudo apt install -y nodejs
   

3. Verify the installation went smoothly by showing the installed version.

    node -v
   

4. Install MQTT.js, the MQTT client library for Node.js.

    npm install mqtt
   

5. Create a file called automation.js to contain the automation script. In this example, you can run the script on the Raspberry Pi. However, the file can be placed anywhere and doesn’t even need to run on the same device as the MQTT broker. As long as the program can connect to the MQTT broker over the local network, it will function correctly.

    touch automation.js
   

6. Open the file with your preferred text editor, like Nano shown here.

    nano automation.js
   

7. Paste the following code into the file.

    const mqtt = require('mqtt');
   
    // MQTT broker connection details
    const MQTT_BROKER = 'mqtt://localhost'; // Replace with your broker's address
    const BUTTON_TOPIC = 'zigbee2mqtt/aqara-button'; // Replace with your button's topic
    const PLUG_TOPIC = 'zigbee2mqtt/third-reality'; // Replace with your plug's topic
   
    // Connect to the MQTT broker
    const client = mqtt.connect(MQTT_BROKER);
   
    // Handle connection events
    client.on('connect', () => {
        console.log('Connected to MQTT broker');
        // Subscribe to the button's topic
        client.subscribe(BUTTON_TOPIC, (err) => {
            if (!err) {
                console.log(`Subscribed to topic: ${BUTTON_TOPIC}`);
            } else {
                console.error(`Failed to subscribe to topic: ${BUTTON_TOPIC}`, err);
            }
        });
    });
   
    // Handle incoming messages
    client.on('message', (topic, message) => {
        if (topic === BUTTON_TOPIC) {
            try {
                const payload = JSON.parse(message.toString());
                console.log('Received message:', payload);
                const desiredAction = payload.action;
   
                // Check for possible actions
                if (desiredAction === 'single') {
                    // Send a message to the plug's topic to toggle the switch
                    client.publish(`${PLUG_TOPIC}/set`, JSON.stringify({"state": "TOGGLE"}));
                    console.log('Toggling the switch')
                } else if (desiredAction === 'double') {
                    // Send a message to the plug's topic to turn off the switch
                    client.publish(`${PLUG_TOPIC}/set`, JSON.stringify({ state: 'OFF' }));
                    console.log('Turning off the switch')
                }
            } catch (err) { 
                console.error('Failed to parse message:', err.message);
            }           
   
        }
    });
   
    // Handle errors
    client.on('error', (err) => {
        console.error('MQTT error:', err);
    });
   

   This script connects to the MQTT broker and subscribes to the button’s topic (zigbee2mqtt/aqara-button). When a message is received, it examines the payload. If the action is a single click (single), the script sends a toggle command ({state: "TOGGLE"}) to the plug’s topic (zigbee2mqtt/third-reality/set), toggling the plug’s state. A double action turns the plug off.

   

   Update the MQTT broker connection and topic details at the top of the script as needed to accommodate your own Zigbee devices, and save your changes.

8. Run the script from the terminal prompt.

    node automation.js
   

9. Test the setup by pressing the button. The script should log the button action and send a command to toggle on the smart plug. Check the MQTT broker logs if the light doesn’t turn on.

10. Optional*:* Once the script is working as expected, there are a few more optional steps to make sure the script restarts during reboots. Install a process manager like PM2 from the command line prompt of the Raspberry Pi.

    sudo npm install -g pm2
    

11. Start the script again.

    pm2 start automation.js
    

12. Your app should now be daemonized, running in the background, and kept alive forever. Generate and configure a startup script to keep PM2 and your processes alive at every server restart.

    pm2 startup
    

13. Copy and paste the command exactly as shown in the terminal output, and run the suggested command.

14. Save the process list so PM2 can restore it after a system reboot.

    pm2 save
    

What’s Next?

Now that you’ve created a custom automation, there are more ways to grow your home automation setup.

• Explore more Zigbee devices: Zigbee2MQTT supports a wide range of devices from various manufacturers.

• Add custom behaviors: Use Zigbee2MQTT’s external converters to define unique functionality for both supported and unsupported devices.

• Scale your setup: This flexible, lightweight setup is good for beginners and power users alike, who don’t want to get locked into proprietary smart home platforms or cloud services.

If you found this tutorial helpful, don’t forget to check out my recommended Home Automation hardware and how-to videos on YouTube for more inspiration!

You can watch the video version of this article here:

We talk about growing up in the European countryside, his early passion for computers, and ultimately his move to San Francisco, where he's founded several tech companies.

Bruno's super excited about embedded systems and custom hardware. He's building home appliances that incorporate open source software and open datasets.

We cover so many topics here. From Star Trek to the European Pirate Party.

I hope these weekly freeCodeCamp podcasts are firing you up about learning more about technology.

Be sure to follow The freeCodeCamp podcast in your favorite podcast app. And share this podcast with a friend. Let's inspire more folks to learn to code and build careers for themselves in tech.

You can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. You can also listen to the podcast below, right in your browser:

A couple interesting links from our discussion:

• "Only Amiga" song from Comdex 1987
• Halt and Catch Fire TV Show trailer

And here are some bonus photos from my time at Bruno's house in NYC:

Bruno at work in his office

A hardware project Bruno had prototyped in his bedroom. (This is the photo that I mentioned during the interview that I had snuck in to snap.)

But that's hardly news to anyone these days. The modern network – best known through its internet iteration – similarly boosted communication, although this time it was the movement of data rather than voice that got a boost.

In the fifty years or so since the birth of the internet, it's been trusted with the movement, storage, and management of more and more of our data.

These changes have brought tremendous opportunities, risks, and pressures. Just getting connected is now a basic necessity. Managing all of our many connected devices and leveraging the ways we authenticate to extend our identities also present challenges. We'll discuss all that here.

This article was taken from the book, Keeping Up: Backgrounders to All the Big Technology Trends You Can't Afford to Ignore. If you'd prefer to watch this chapter as a video, feel free to follow along here:

How We Connect to the Internet

These days, after food and shelter, pretty much the most basic resource of all is internet connectivity. If you can't access the internet, you'll find it difficult to do your banking, educate yourself, book travel arrangements, or even figure out exactly where you are.

It's not for nothing that widespread, reliable, and relatively fast internet access is critical for a region's general economic development.

Even though the internet was originally build as a decentralized, distributed network of resources, you still need to establish some kind of connection to access it.

The best connections are run by network carriers, known as tier 1 networks. Theses networks can reach all other networks through a peering arrangement that doesn't require payment for IP transit. You can think of these networks as the backbone of the internet, and their network infrastructure is its structure.

Examples of companies managing tier 1 networks include AT&T and Verizon in the US, Tata Communications (India), and Deutsche Telekom (Germany). Those carriers will resell bandwidth to smaller internet service providers (ISPs) who, in turn, sell access to end users like you and me.

Broadband Options

Individuals looking for broadband access in their homes or small businesses can usually choose between one of four access models:

• Cable. Since they're already in the business of providing data to millions of homes over existing physical connections, cable TV providers can easily transmit internet over the same wires.
• Digital subscriber line (DSL). A family of technologies that permit digital data across copper telephone lines, DSL can provide a roughly similar level of service as cable, but without the need for an underlying cable subscription. In fact, using a "dry copper" connection, you don't even need a telephone landline account.
• Fibre optics. Due to some arcane technical details (including the laws of physics), transmitting digital signals as infrared light can happen faster and require fewer repeaters than comparable electrical cables. A fibre optics internet connection could typically deliver transfer speeds of 10-40Gbit/s – a thousand times faster than currently standard rates using cable or DSL.
• Satellite. Running new cable through densely populated cities is expensive, but companies can quickly make their money back through the many access contracts they'll sign. But sparsely populated rural regions are much more difficult to service. Partly to fill a rural connectivity gap, a number of companies ambitiously working to launch constellations of thousands of orbiting satellites to provide universal internet coverage. As of this writing, SpaceX is furthest along with its project, having already successfully launched more than 500 satellites as part of the Starlink system.

Besides those dominant technologies, there have been more than a few alternate connectivity solutions attempted. Some are experimental but promising, and others are a bit more speculative.

Google's Balloon Internet (known officially as Loon LLC), is an attempt to float fleets of high-altitude balloons providing a 1 Mbps signal to anyone within range on the ground.

Loon is designed to provide low-end broadband in hard-to-reach regions where reliable service has been difficult or even impossible. As of 2020, the project seems to be in a late experimental stage.

Broadband over power line (BPL) can take advantage of all the electrical grid that connects power authorities with homes and businesses to provide internet data. Ultimately, the technology delivers limited bandwidth because line noise causes significant data signal loss.

Data carrying power lines can also cause interference with high frequency radio communications. In the end, relatively low signal quality and strong competition from other technologies mean that BPL will probably never be widely adopted.

Networks using forms of wireless Internet service provider (WISP) can service homes and offices across larger geographic areas without the need to physically wire every building. Wired connections are installed in an area's center and, where necessary, connected backhauls are installed in elevated areas to strengthen the wireless signals aimed at consumers.

Existing radio towers or other tall structures can be used for the backhaul repeaters, making a WISP system relatively inexpensive to install.

Smaller-scaled wireless network co-ops can be shared locally using a neighborhood internet service provider (NISP) (using rooftop antennas) or a wireless mesh network (where network-connected devices act as peer nodes) to efficiently share a single physical connection.

Those systems are primarily designed to serve us where we live and work. But mobile data access is definitely also a thing. I'm sure you're already familiar with data plans that mobile phone companies can provide alongside their calling and texting services.

Mobile Phone Data Access

Cell connectivity is distributed through geographic areas (known as "cells") from individual radio transmitters spread throughout the cell.

Since the transmitters within each cell will use different radio frequencies than the cells around it, modern wireless technologies permit a seamless, automated "handover" as a user moves between cells.

The technologies used for wireless telephony have changed since the 80s, when what's now known as 1G ("First Generation") cell phones were introduced. To describe the evolution of cell phones in very general terms, we could say that:

• 1G phones carried only voice communications and had a maximum transfer speed of 2.4 Kbps.
• 2G phones could carry Short Message Service (SMS) and Multimedia Messaging Service (MMS) messaging, which could include short videos and images.
• 3G phones had much higher transfer rates (as high as 2 Mbps) than any variant of 2G and was therefore dubbed, "mobile broadband."
• 4G phones could reach speeds as high as 100 Mbps, which permitted HD mobile TV, online gaming, and video conferencing.
• 5G phones – when used on compatible networks – are expected to reach transfer speeds of up to 20 Gbps at a very low latency, permitting fully immersive virtual environments. Should the 5G rollout be successful (and, at the time of writing, this isn't yet clear), the range and limits of new service categories that could be deployed is not yet known.

When it comes to planning a new venture, it's long been the accepted wisdom that there's no replacement for solid market research. Without knowing who your customers will be, where they live, and what they like, how can you properly serve them?

Well, now you can add to that list "how reliable and robust is their internet connectivity," because without digital access, they may never find you or be able to consume your service.

Talking to the Internet of Things

Two recent changes are, more than anything else, responsible for the internet of things (IoT) ecosystem: the availability of cheap, embedded, single-board computers (like the Raspberry Pi) and cheap and always-on internet connectivity.

Those tiny single-boards – often smaller than a credit card – are easy to incorporate into just about anything you're planning to manufacture.

Such devices cost very little – sometimes just a few dollars a piece – and they're generally built to run fully-powered (and free) Linux distributions. And network availability means that the vast streams of data generated by all those on-board cameras, sensors, and other peripherals, can be automatically sent back "home" for processing and analysis.

The Dream of IoT

Here are some ways that IoT applications are already actively changing business and consumer practices:

Inventory control

The very first IoT device was – arguably at least – a Coca-Cola vending machine at Carnegie Mellon University. Back in the early 80s, the machine was modified to digitally report its ongoing inventory.

The simple idea that physical devices can monitor themselves and their surroundings, providing accurate, up-to-the-minute status reports to remote servers, lies at the heart of countless modern industrial solutions.

Modern retail, wholesale, logistics, and manufacturing operations now have constant access to their inventories, allowing them to understand trends and anticipate problems.

Agriculture

Increasingly, modern farming incorporates robotic irrigation, fertilization, planting, and even harvesting technologies.

All those robots running around your property are generating data and, from time to time, getting themselves into trouble.

Moving that data "back" to administration servers is critical for keeping track of what's going on, what might need fixing, and how your actual farm is performing. You can, therefore, expect that each of those devices will be part of someone's IoT.

Military

Communication is key for military operations. But if even weapons, vehicles, and other equipment can communicate autonomously, and if there are servers dedicated to interpreting and acting on that communication, then you're already way ahead of the game.

Sensors connected to each of hundreds of components for, say, a fighter jet, can contribute to giving planners an unprecedented view of what's really going on.

Smart cities

When sensors embedded in buildings, roads, public lighting, smartphones, and electrical systems are combined with data coming from traffic cameras and public departments, the potential for data-driven insights is huge.

Properly understood data can help cities manage their resources, utilities, and even traffic more efficiently, and better maintain their physical infrastructure.

Smart homes

On a far smaller scale than smart cities, home appliances can be connected and monitored and controlled through smartphone apps or remote servers.

Smart home devices already include heating and cooling systems, light bulbs, robotic vacuum cleaners, garage doors, and security systems. Smart home devices can be controlled through phone apps but, in many cases, also through voice controlled devices like Amazon Echo (Alexa).

Conversations about IoT are always just one step away from buzzwordism – where words lose meaning and exaggeration becomes an acceptable lifestyle choice.

Not all IoT stuff is actually IoT. Or, to put it another way, not all IoT is worth talking about. But here's one good way to categorize a particular technology: if, hour after hour, something generates more data than any human being could possibly absorb, then it's probably an IoT device.

Effectively dealing with all that data can be a problem. And that's not the only potential for trouble in IoT land.

The Nightmare of IoT

In the information technology world, as a general rule, the more active network connections you have in your infrastructure, the greater your risk of being successfully attacked.

That's because successful hacker intrusions usually come through badly configured or unpatched devices. The more public-facing devices you're exposing, the greater the chance one of them will have a serious vulnerability.

What kind of vulnerabilities are we talking about? Well, the US government's Common Vulnerabilities and Exposures database contains nearly 140,000 individual entries, each one representing a unique software weakness that could allow unauthorized access to and destruction of an IT system.

There are threats impacting all operating systems (Windows, Linux, macOS), all formats (server, PC, smartphone), and all ages (there are active threats going back to the 1990s). And many hundreds of new entries are added each month.

In that sense, IoT devices are no different than any other kind of computer. But there is one way that they're a whole lot worse. Because you don't normally directly interact with IoT devices on an OS level, and because they're often commodity items that are purchased and deployed by the dozens or thousands, you don't instinctively treat them like computers.

Most of us, as an example, are aware that we should create complex and unique passwords for our laptops and WiFi routers. But your fridge? Just plug it in and it'll be fine! The problem is that many IoT devices – like "smart" fridges – have their own embedded operating systems and, usually, their own network interfaces.

There's a good chance that anyone driving down your quiet residential street can scan for available networks, quickly identify the brand of IoT device you're using, assume that you haven't changed the authentication credentials from their factory defaults, and log in to your private network.

What makes things much worse is that many device manufacturers are still shipping their products with authentication credentials using some variation of admin/admin.

That's a big problem.

Leveraging Federated Identities

All this talk about the dangers presented by authentication and credentials should make you curious about how they can be used to generate some good connectivity stuff.

In a single word, that'd be federation. Identity federation is a technology for linking a single person's identity across multiple network services. Federation is what lets you log in to online gaming or web application sites using, say, your Google account credentials.

The upside of federation is that a single login can be all you'll need as you move between many of the online services you regularly use. That lets you reduce the risk of exposing your password through a vulnerable website.

Of course, it also increases the damage that can come from a serious data breach of the servers used by your federation provider.

Federation can be used to integrate with third party single sign-on (SSO) authentication systems, like Kerberos, the Lightweight Directory Access Protocol (LDAP), and Microsoft's Active Directory (AD). When used with cloud services, SSO systems can securely permit automated as-needed access to private account resources for consumers or processes.

Besides convenience, all this authentication goodness drives opportunities for secure remote collaboration on large, complex projects – itself a fast-growing trend.

YouTube videos of all ten chapters from this book are available here. Lots more tech goodness - in the form of books, courses, and articles - can be had here. And consider taking my AWS, security, and container technology courses here.

Introduction

Are you curious about the IoT (Internet of Things?) Have you always wanted to try to make your own robot, smart mirror, or bird feeder camera? What about building a computer for a fraction of the cost of a commercially available machine?

If you said yes to any of these questions, you might enjoy playing around with a Raspberry Pi.

In this article, I'll explain what a Raspberry Pi is (and what it’s not.) Then I'll show you some things you can use it for, and finally, I'll list all of the current models along with their specs.

What is Raspberry Pi?

A Raspberry Pi is a single board computer (SBC) created in the United Kingdom by the Raspberry Pi Foundation. It's a charity that "works to put the power of computing and digital making into the hands of people all over the world."

The first model of the Raspberry Pi was released in 2012, and as of 2021 there have been five generations of the boards. A microcontroller (more about that later), called the Pico was released in early 2021.

GPIO Pins

Something that sets the Pi apart from your average computer is the set of 40 GPIO (General Purpose Input Output) pins.

GPIO pins are pretty much exactly what they sound like. They are designed to input and output single bits. This means that you can use them to add all sorts of functionality to your Raspberry Pi using switches, buzzers, lights, sensors, and so on.

Raspberry Pi HATs

There are a number of add-on boards that you can attach to the Raspberry Pi using the GPIO pins.

Raspberry Pi HATs (Hardware Attached on Top) are add-on boards designed according to certain specifications. The Raspberry Pi can automatically detect and configure the HATs, making set-up easy.

There is a huge variety of HATs and other add-on boards that you can buy, but here are some notable ones:

• PoE+ HAT – Power over Ethernet HAT
• Sense HAT – Designed for the Astro Pi mission, the Sense HAT includes a gyroscope, an accelerometer, a magnetometer, and sensors for temperature, humidity, and Barometric pressure.
• Pimoroni Explorer HAT Pro – All-purpose board featuring touch pads, crocodile clip pads, and analog inputs
• Adafruit Capacitive Touch HAT – Similar to a Makey Makey, this HAT allows you to use any conductive object to trigger events using Python.

Raspberry Pi Operating Systems

The Raspberry Pi often runs some form of Linux, but there are a ton of operating systems that you can use.

On the official website, you will find a list of operating system images available for download. These include the official Raspberry Pi OS, Debian Buster, and Ubuntu (desktop, core, and server.)

You will also find RetroPie, a specialized gaming platform operating system, and LibreELEC, a lightweight Linux distribution specifically created for use with the open source media player Kodi.

Raspberry Pi VS Arduino

You may have heard of Arduino boards and wondered what the difference is between them and the Raspberry Pi.

The main difference is that Pis (with the exception of the Pico and the RP2040) are full computers with operating systems. You can connect your Pi to a keyboard, mouse, and monitor and use it like you would use a Mac or PC.

The Arduino, on the other hand, is a microcontroller. It cannot function independently as a computer, but is programmed using a computer and then used to control things like cameras, lights, robots, and so on.

As the official Arduino website puts it: “Arduino boards are able to read inputs… and turn it into an output.”

What is the Raspberry Pi Used For?

Search the internet and you will find a huge array of projects created using Raspberry Pis.

Common use cases include home automation, gaming consoles, servers, WiFi extenders, streaming devices, weather stations, and home computers. (Fun fact: much of this article was written on a Raspberry Pi.)

During the Covid-19 pandemic, Raspberry Pi's were even used to control ventilators in some hard-hit areas.

Raspberry Pi Models

All models of Raspberry Pi that are currently in production have 40 GPIO pins.

This list does not include the Raspberry Pi microcontrollers, the Pico and the RP2040.

You can find out where to purchase any of these boards on the Raspberry Pi website.

Conclusion

The Raspberry Pi is an affordable way to explore electronics, hardware, and computer programming. It can be used for a huge variety of projects, from the very silly (like a hamster powered hamster drawing machine) to the very important (like computer labs in developing nations.)

Now that you know the basics, why don't you go out and make something? Whether you hook a Capacitive Touch HAT up to your Raspberry Pi and turn it into a banana piano or install Linux on it and use it to do your homework, I hope you have a great time creating something cool and useful.

Introduction

During the last few years, Internet of Things (IoT) devices have started becoming a more and more important component in our daily lives. Some common applications for IoT devices are:

• Smart Home (eg. smart lamps)
• Wearables (eg. smart-watches)
• Autonomous vehicles
• Smart cities
• Smart Retail

According to Wikipedia, IoT devices are defined as:

"The Internet of things (IoT) is the extension of Internet connectivity into physical devices and everyday objects. Embedded with electronics, Internet connectivity, and other forms of hardware (such as sensors), these devices can communicate and interact with others over the Internet, and they can be remotely monitored and controlled " – Wikipedia [1]

One of the most interesting characteristics of IoT devices is that they are able to produce large amounts of data. This can be particularly used in applications such as Artificial Intelligence and Machine Learning.

Most of IoT devices can produce in fact a great variety of Time Series data which are of huge interest in Artificial Intelligence.

According to a study carried out by Global Data, the IoT market is projected to reach $318bn new worth by 2023 (in constantly rise compared to the previous years).

Figure 1: IoT markets projections [2].

These projections are confirmed by the increased interest of companies such as Google and Microsoft to invest in IoT cloud platforms.

How do IoT devices work?

An IoT system is compromised of four main components:

1. Sensors: enables the devices to collect data from the environment surrounding the device (eg. velocity, GPS coordinates, temperature, etc...).
2. Connectivity: successively the data collected is sent to the cloud (through either WiFi or Bluetooth connection).
3. Data Processing: once the data is received by the cloud infrastructure, it can then be processed (eg. check if the data received adhere to the requirements and if its not alert the user).
4. User Interface: Once the data is processed, the results are then given to the and user.

As a simple workflow example, let's consider a security system in a house.

Our IoT device will check if there are any intruders in our house using a Computer Vision system (Sensors). The video recordings of the house are then sent to the cloud to see if there are any intruders or not (Connectivity). Successively, the data is processed in the cloud (Data Processing) and if some intruders are detected we get alerted (User Interface).

An IoT system could be able to alert us in many different ways (eg. phone call/message or App notification) and in some cases we could be able to control remotely the system itself (eg. lock the house doors).

Figure 2: Main Components of an IoT System [3]

Internet of Things cloud platforms

I will now introduce you to some of the most interesting IoT cloud platforms which can be used for analysing and controlling IoT devices.

Figure 3: IoT Cloud Platforms [4]

Google Cloud Internet of Things

Google Cloud is currently one of the main Cloud solutions provider on the market. Some of the packages offered by Google Cloud for IoT implementations are:

• Cloud IoT Core: is used to set up the device(s) and establish a secure connection between them.
• Cloud Machine Learning Engine: it allows users to create Machine Learning models from the data gathered by the IoT devices in order to increase and monitor performances.
• Cloud Pub/Sub: provides real time analytics of the IoT devices.

Azure Internet of Things

Microsoft Azure is another really important cloud services provider. Azure is able to deliver both pre-customized and fully customizable solutions. In this way, Azure is able to provide solutions for both beginners and experts in IoT. Microsoft Azure enables to easily scale IoT systems to include devices from different manufacturers and also provides analytics and Machine Learning services support.

Amazon Web Services (AWS)

AWS is one of the most popular solution for cloud based services. AWS can enable to perform IoT projects from end to end and making use of the four following packages:

• AWS IoT Core: is the basic package which can be used to set up IoT devices. Using IoT Core we can integrate different devices to communicate each other over a secured connection making possible to exchange data through cloud storage.
• AWS IoT Analytics: is used to process and analyse all the data produced by IoT devices. Once all the data is stored using a semi-structured format (eg. JSON, CSV) it can be then used for Machine Learning purposes (eg. monitor and optimise the interaction between IoT devices).
• AWS IoT Device Defender: is used to construct and personalise the security mechanisms of IoT devices (such as choosing device authentication and data encryption).
• AWS IoT Device Management: enables to easily integrate new IoT devices to an environment and monitor/update their functionalities.

Conclusion

Internet of Things devices are definitely going to play a really important role in future technology advancements. Although there are still the same issues that have to be addressed. In fact, one of the main concerns about IoT devices can be cyber-security.

Because most IoT devices make use of a cloud centre to store their data and to collect useful information from the internet, that makes them vulnerable from Hackers attacks (creating a single point of failure).

In order to resolve this problem, could be either possible to increase the encryption standards (slowing down the transfer of data) or makes use of Artificial Intelligence security powered techniques such as Differential Privacy and Federated Learning.

In case a Hacker would be able to access control of an IoT device (or an entire group) there would be two main risks associated with it:

• The Hacker would be able to access and steal sensitive data of the IoT device users.
• The Hacker could be able to take remote control of the device itself.

In addition to the cloud services provided before, also the following ones can be considered a valid alternative: SAP, Oracle Internet of Things, Cisco IoT Cloud Connect, IBM Watson Internet of Things, etc...

Contacts

If you want to keep updated with my latest articles and projects follow me and subscribe to my mailing list. These are some of my contacts details:

• Linkedin
• Personal Blog
• Personal Website
• Medium Profile
• GitHub
• Kaggle

Cover photo from this article.

Bibliography

[1] Wikipedia, Internet of Things. Accessed at: https://en.wikipedia.org/wiki/Internet_of_things

[2] Global IoT market to reach $318 billion by 2023, says GlobalData. Michelle Froese, Windpower Engineering & Development. Accessed at: https://www.windpowerengineering.com/business-news-projects/global-iot-market-to-reach-318-billion-by-2023-says-globaldata/

[3] Anni Junnila, HOW IOT WORKS – SUMMARY – TRACKINNO BLOG. Accessed at: https://trackinno.com/2018/08/09/how-iot-works-part-4-user-interface/how-iot-works-summary-001/

[4] Overview of the best IOT platforms. Tips for selecting the right cloud solution in 2019. Anna Davydova, Edsson. Accessed at: https://www.edsson.com/en/blog/article?id=iot-platforms

IoT is all about connecting devices, or “things” as you may call them, to the internet and then analyzing data collected from these devices in order to extract an added value. In this article you’ll discover how to benefit from Firebase when working on an IoT project and how it can help you develop IoT prototypes much faster and easier than traditional methods. You will also develop your own IoT project and host it in Firebase.

Before Firebase Realtime Database

Most of my IoT projects require some way of communication between the different endpoints. These endpoints can be anything from devices and services to applications, and eventually data needs to be stored somewhere for further processing and analyzing.

So let’s say you want to build an IoT system where a device will measure temperature and humidity values from sensors and send them to a database service to store them. Then you want to have a web application that will fetch these values and display them in a dashboard. Quite simple, right…?

The easy and lightweight way to go about this is to setup an MQTT broker that will act as a hub and reroute all incoming messages published from the device to all subscribed clients like the web application in this case.

Now the question here is how can the web application display the data? Meaning will it be displaying messages coming from the broker directly or will it be fetching data from a database service?

Let’s say that you want the app to do both things: display data coming from the broker in realtime and fetch data from the database. In this case you can think of 2 ways (actually there are many different ways) to achieve this:

First solution:

Using this architecture the device will first publish its data to the broker then it will send an HTTP request to the database web-service to save the data. For this solution the device needs to implement 2 clients: an MQTT and an HTTP client.

Second solution:

The other way to go about this is that the device will send or publish its data to the broker, then the broker (as expected) will reroute this message to all connected subscribers like the web app. But this time there’s another subscriber connected which represents an API Engine that will accept this data and send it to the database web-service to be stored.

As you may have noticed in this solution, the HTTP client is decoupled from the device and implemented as a backend service. This way you make the device program much lighter. This is an important thing to keep in mind when developing on constrained IoT devices where resources like CPU and memory are limited.

Still, this solution required some additional work in developing the back-end service that will act as a persistence layer.

So is there much easier way of doing this?

Firebase to the rescue

As you may have seen above, things can get quite complex quite easily. For someone like me who wants to get up and running quickly when working on a prototype, that can take some extra time. That’s why, in this part of the article, you’ll see how Firebase can make your life easier and save you a lot of time when developing an IoT prototype.

Firebase offers many cloud services that ranges from authentication, storage, and cloud functions to hosting your web application. In this article you’ll use 2 services: Realtime Database and Hosting.

Let’s start with Firebase Realtime Database. The first thing that comes to mind when reading this service name is: okay so I know what a database is but what does it mean to be realtime here?

Well according to Wikipedia:

A real-time database is a database system which uses real-time processing to handle workloads whose state is constantly changing. This differs from traditional databases containing persistent data, mostly unaffected by time

In the case of Firebase Realtime Database, clients will be connected to the database and will maintain an open bidirectional connection via websockets. Then if any client pushes data to the database it will be triggered and (in this case) inform all connected clients that it has been changed by sending them the newly saved data.

This way of working may remind you of the MQTT broker and how it reacts when it receives a message from a publisher and sends it to all subscribers. The difference this time is the addition of the data persistent part, which is the database. So as you can see here, you don’t need to route messages yourself using other protocols — Firebase Realtime Database will take care of that plus performing its normal database function. Amazing isn’t it?

Returning to the IoT system mentioned earlier, you can now connect the device to the Firebase Realtime Database and make it push data periodically to the database. On the other part of the system you have a web application which will be connected to the same service as the device and will receive new data whenever there is a change in the database.

But what about hosting the web application?

Firebase offers a hosting service that you can use to host your app rather than managing your own web server and dealing with deployment and networking configurations. The good thing is that it is free (yet limited) and pretty easy to use.

Now for the part you all have been waiting for. In this demo you’ll use the example discussed throughout this article and bring it to life.

If you remember, the IoT system is made of 2 endpoints: the first one is the IoT device which is responsible for sending temperature and humidity data to the Firebase Realtime Database. This in turn will communicate with the second endpoint — the web application — that will read the data and display it on a nice dashboard.

I’ll break this project into 3 steps so it becomes easier to follow.

1. Setting up Firebase Realtime Database

There is nothing special about this step. You just need to go to your firebase console and create a new project. After your project is ready, go to the database section and make sure to create a Realtime Database not a cloud Firestore Database. Select start in test mode and proceed as you’ll be using this database only for testing and prototyping and not for production solutions (so you can ignore the red warning). Now the database should be ready for use.

2. Developing the IoT device application

When talking about embedded systems development, you often hear terms like low level programming, assembly, registers, memory management and so on. These terms and concepts are related to the hardware specifics you’re working with and can change from one to another.

That’s why, when prototyping ideas, you don’t have time to dig deep into these specifics and study them in details because you’ll be dealing at the same time with other high level languages and thus other ways of thinking about code. So instead you should have a clear overall idea about the architecture and characteristics of the device and how to use them.

Luckily for you there is a platform that was made specially for prototyping and abstracting all the low level functionalities of hardware. Yes I’m talking about the famous Arduino.

Arduino - Home
_Open-source electronic prototyping platform enabling users to create interactive electronic objects._www.arduino.cc

Note here that when I’m talking about Arduino, I’m referring to the Arduino Framework with its IDE, compilers, and libraries — not the board.

So you will be using Arduino to program the board, but what board you ask? Well, you need a board that is able to interface with sensors and measure physical values like temperature. It should also be able to connect to the internet in order to send this data to the database. Finally, it should be able to be programmed using the Arduino framework.

There are a variety of boards on the market that can achieve these tasks. Some of them are Arduino boards and others are Arduino-compatible boards.

In this demo you will use the famous NodeMCU, an Arduino compatible board. It’s based on the ESP8266 SoC, a chipset produced by the Shanghai-based Chinese manufacturer, Espressif Systems. This board is attractive for developers, as single units can be bought for as little as $3.

Our Gear

Although the Arduino platform offers an IDE for programming and uploading code to boards, it’s not very friendly to developers as it does not provide any intelliSense features or debugging functionalities. That’s why, for most my IoT projects, I use an environment called PlatformIO.

PlatformIO: An open source ecosystem for IoT development
_Cross-platform build system and library manager. Cross-platform IDE and unified debugger. Remote unit testing and…_platformio.org

It’s an open source ecosystem for IoT development, and guess what? It supports the Arduino Framework. So you can use it to write Arduino code, compile it, and upload it to the board. Finally the cool thing about PlatformIO is that it comes as an extension that you can use inside Atom or VScode so you can use it alongside the other functionalities of your IDE (Atom or VScode). I highly recommend watching these 2 YouTube video tutorials to setup and get familiar with the environment.

Enough talk — let’s get started:

Developing Firmware for NodeMCU

kaizoku-619/firebase_nodemcu
_Arduino Firebase Nodemcu client developed sending DHT11 data to Firebase Realtime Database …_github.com

Before diving into developing the firmware, let’s talk about the electronics setup.

If you remember from the example earlier, the IoT device will measure temperature and humidity values from a sensor and send them to the cloud. In this case that means the NodeMCU will read temperature and humidity values from DHT11 sensor module and send them to Firebase. The DHT11 module will be used here because it’s cheap and doesn’t require any additional electronic components to function.

Wiring Diagram

As you can see from the wiring diagram above, DHT11 is connected to the board with 3 wires GND, 3.3V and Data signal in the middle. Connect the data pin to one of the Dx pins on the board and you’re done with wiring.

Now that the wiring is done you can start coding the firmware using PlatformIO.

We’re not writing Go but I like the GIF

But before you dig into writing code directly, let’s stop for a moment and think about what the program should do.

So the first thing the device needs to do is to connect to the internet. To do that it needs to connect to the WiFi access point. Once online, it needs to open a connection with Firebase. After that the device will read temperature and humidity values from the sensor and finally publish the data.

Here is an ordered list of tasks:

(Note that the world task is used here to refer to a functionality of a bloc of code and not a task in realtime OS like FreeRTOS tasks.)

1. Connect to WiFi
2. Open connection with Firebase
3. Read sensor values
3. Publish values to Firebase

Let’s start with the first task:

• Connect to WiFi:

This function begins with printing the SSID (AP name) and setting the NodeMCU into station mode rather than AP mode. Then it keeps loading until it connects to the AP. SSID and PASSWORD are 2 constants defined in another file as you’ll see later.

• Open connection with Firebase:

This function is very straightforward: it takes 2 parameters FIREBASE_HOST and FIREBASE_AUTH. These are also 2 constants defined in another file.

• Read sensor values:

You start by defining 2 constants for the DHT sensor type and pin. After that you create a DHT object by passing these 2 constants to the DHT constructor. Finally you use the object methods readHumidity() and readTemperature() to read humidity and temperature respectively.

• Publish values to Firebase:

Here, the pushInt() method of Firebase class is used to push an integer to Firebase and in case of an error, print it.

And now you’re done with the tasks! All that’s left is to put these tasks together in a clean arduino sketch.

Start by creating a new project in PlatformIO as shown here:

Next you need to install the libraries needed for the project. Note that in this case you will install the libraries locally, meaning they’re only available for this project. This is a best practice if you decided one day to use another version of the library in another project.

Go to the PlatformIO home page → Libraries and search for firebase. FirebaseArduino will show up, so click on it. But don’t click install button, instead click on the … next to install and choose the project to install the library into. Then finally click install. Repeat this process for the DHT library.

Copy this code in the main.cpp file:

Remember the file containing the credentials for the WiFi and Firebase? Go to the include folder and create a new file Creds.h and copy this code to it. Don’t forget to change the code according to your credentials.

And there you go! Upload the firmware to NodeMCU and your device should be able to send data to Firebase Realtime Database.

3. Developing and hosting the web application

kaizoku-619/firebase_iot_web
_Firebase web application client connected to Firebase Realtime database fetching sensor values …_github.com

Now that the IoT device is ready and pushing data to the Realtime Database, you can move to the other endpoint in the system, the web application. It will receive data from Firebase and display it on a dashboard.

You will start by developing the app locally and eventually deploying it.

Start by setting up the project.

Installing Firebase CLI:

The Firebase CLI (command line interface) requires Node.js and npm (the Node Package Manager). Once they are installed you proceed to install the Firebase CLI using npm by running:

npm install -g firebase-tools

You can follow the video to complete the project setup.

Once project setup is done your directory should look something like this:

├── database.rules.json├── firebase.json└── public   ├── 404.html   └── index.html

Start by building the dashboard UI. This will be the index.html file. Open the file and change it to look like this:

This is a simple HTML page designed using Bootstrap Material Design. It consists of 2 Card elements, one for displaying Humidity and the other for displaying Temperature.

As for the Firebase part here, first you import the firebase dependency in the script tag inside the head tag. Finally when the page finishes loading, it calls app.js.

Now that the Dashboard UI is ready you can move on to app.js where you implement the firebase connection and your business logic. In the same directory create a new file called app.js and copy this code:

The script starts by creating a configuration object. The best way is to copy it directly from the firebase project in the firebase console. To do that, navigate to your firebase console and go to the firebase project settings. Then scroll down and click on the <;/> icon as shown here:

I guess the rest of the code is self explanatory with the comments.

Now your app should be ready and you can test it locally with the following command:

firebase serve

Note that on startup the app will fetch the last temperature and humidity values from the database. Great! The app is working locally, but up until now it’s working only inside your localhost and can’t be accessed from the outside world. This means that it’s time to host it on the web using Firebase Hosting.

But before you deploy it there is just one last thing you need to do. Go to the database.rules.json file and change the read and write rules to “true”. This method is not advised for production, as it is not secure, but it’s fine for demonstration purposes here.

With that done you are ready for deployment:

firebase deploy

There you go! If you’ve made it this far, by now you should have a live web application deployed and up and running.

Putting it all together

It’s time to put everything together and test the system. Plug in the NodeMCU to your PC and upload the sketch if you haven’t already:

Open up the web app and the firebase database and watch it change in realtime with the values sent by the device.

Now open up the serial monitor and watch the data pushed from the device to the web app. Note that you can open the console in the browser to watch the received values. Here I use Gtk Serial port terminal with a baud-rate of 115200 bps, but you can use the integrated PlatformIO Serial Monitor or any other tool of your choice.

Troubleshooting

I faced a problem while developing the application on the ESP8266 (and it took me sometime to figure out). Even when everything was configured correctly (WiFi Connection, Firebase Host, Secret Key), the ESP8266 couldn’t connect to Firebase. This was caused by the wrong Fingerprint inside FirebaseHttpClient.h file in the Firebase library. You need to replace it with your own fingerprint. If you installed the library locally using PlatformIO then you can find the file in this path:

your_project_folder/.piolibdeps/FirebaseArduino_ID1259/src/

To generate a fingerprint, go to this website and copy your Firebase host link without the https part and click on Fingerprint Site (mine is:
medium-iot-project.firebaseio.com):

GRC | SSL TLS HTTPS Web Server Certificate Fingerprints
_GRC's HTTPS Web Server Certificate Fingerprint Service_www.grc.com

This will generate a fingerprint for your site, so go ahead and copy it in place of the old kFirebaseFingerprint[] value inside the FirebaseHttpClient.h file. That should fix the problem.

Conclusion

Congratulations if you’ve made it this far!

We’ve only scratched the surface here. The Internet of Things is all about experimenting and exploring, so I encourage you to not stop here and keep learning by making mistakes and finding bugs in your code. But above all don’t forget to have fun along your learning journey.

References

Firebase Realtime Database | Firebase Realtime Database | Firebase
_Store and sync data with our NoSQL cloud database. Data is synced across all clients in realtime, and remains available…_firebase.google.comPlatformIO: An open source ecosystem for IoT development
_Cross-platform build system and library manager. Cross-platform IDE and unified debugger. Remote unit testing and…_platformio.orgArduino - Home
_Open-source electronic prototyping platform enabling users to create interactive electronic objects._www.arduino.ccBootstrap Material Design
_The most popular HTML, CSS, and JS Material Design library in the world._fezvrasta.github.ioesp8266/Arduino
_ESP8266 core for Arduino. Contribute to esp8266/Arduino development by creating an account on GitHub._github.comFirebaseExtended/firebase-arduino
_Arduino samples for Firebase. Contribute to FirebaseExtended/firebase-arduino development by creating an account on…_github.comGRC | SSL TLS HTTPS Web Server Certificate Fingerprints
_GRC's HTTPS Web Server Certificate Fingerprint Service_www.grc.com

In this article, I’ll discuss how I built a Smart Home Automation System with Angular and Node.js on a Raspberry Pi without relying on any external cloud services.

Intro

Over the last few days, I spent some nights designing and developing a home automation system based on JavaScript, with the use of Angular and Node.js. And, like with any other project, the planning involved some deep research on the internet.

It turned out that there are plenty of fish in the sea —plenty of solutions on how to implement a home automation system. Some offer paid services in “the cloud” and others explain how to build your own using a technology called MQTT.

None of the solutions made any sense to me. All options were either expensive, or had inconvenient implementations or even security flaws.

But, before we go any further, let’s explain what MQTT is. MQTT stands for MQ Telemetry Transport. It is a publish/subscribe, extremely simple and lightweight messaging protocol. MQTT is designed for constrained devices and low-bandwidth, high-latency, or unreliable networks.

The design principles are to minimise network bandwidth and device resource requirements whilst attempting to ensure reliability and some degree of assurance of delivery. These principles also turn out to make the protocol ideal for the emerging “machine-to-machine” (M2M) or “Internet of Things” world of connected devices, and for mobile applications where bandwidth and battery power are at a premium.

MQTT Publish/Subscribe Architecture (Image source: HiveMQ.com)

Why wasn’t I convinced about using MQTT, or by any of the solutions I found on the internet? Two reasons:

1. While the MQTT technology seems very convenient for IoT devices, I still thought it was unnecessary. The system which I will be showing in the following tutorial operates in the same medium where the IoT devices live. All benefits that MQTT has for being “fast” and having “low-bandwidth” become irrelevant. Plus there’s all the hassle that is involved in its implementation and all the extra overhead with the additional npm packages that are required for it to work in a JavaScript environment. Instead, I will be using generic JavaScript and Node.js libraries only, nothing more!
2. What about the security part? Well, I’m not a big fan of “the cloud” or cloud computing in general. In some cases it can be very beneficial, but in most cases it’s just unnecessary. Think about it: why would you have a service that is required for controlling your home appliances to be hosted somewhere else in “the cloud” and not in your own network?

_Comic by [Geek and Poke](http://geekandpoke.typepad.com/geekandpoke/2009/11/good-consultants.html" rel="noopener" target="blank" title=")

One might think that “the cloud” provides the ability to access your home appliances from anywhere in the world via the internet.

But think about this: when your home network doesn’t have internet connection, “the cloud” becomes redundant. More importantly, you can still make your home automation system accessible from the internet using port-forwarding even if it’s hosted on your local network.

This is when it “clicked” for me, and I thought about hosting the whole system on a Raspberry Pi and keeping it in my local network.

A Raspberry Pi 3 Model B

The technology

1. Software: The reason why I chose Angular and Node.js is because they’re based on JavaScript and I’m already familiar with it. After all, I wanted to design and develop a progressive web app that communicates with my IoT devices via HTTP — and JavaScript offered all the functionality that I needed.
2. Hardware: The system works with microcontrollers like the Arduino Uno/Mega/Du/MKR1000, Adafruit HUZZAH CC3000, and any other microcontroller with a WiFi connection. I am using the ESP8266 as a base component for my home automation system. It’s a low-cost WiFi microchip with microcontroller capability. It has everything I need and for a cheap price! Lastly, we need to host the system somewhere on our local network — so what’s better than the Raspberry Pi?

This won’t be a coding tutorial where I dive deep into coding, since this project is open-source and I will be publishing everything on GitHub. I will only demonstrate how to implement your own home automation system and will be going through each step. If you’re a developer please fork the repository and get involved in improving it.

The setup

I estimate that it will take about 40 minutes to finish this whole setup plus any time spent online searching for solutions for installation errors.

What is needed?

A Raspberry Pi is required. In my example I’m using a Raspberry Pi 3, but it should work with most versions. The components needed are:

1. Raspberry Pi board
2. MicroSD card (A class 10 with 16 GB or higher is recommended)
3. A USB MicroSD card reader or SD card adapter
4. HDMI monitor and a USB keyboard (only required temporarily for the first boot of the Raspberry Pi)
5. Ethernet cable (not needed for Raspberry Pi 3 as it has built in WiFi)

Installing Raspbian OS on the Raspberry Pi

Raspbian is a free operating system based on Debian Linux, and it is optimized for Raspberry Pi.

I recommend the headless “LITE” version. It has no desktop environment or any graphical user interface, and it’s remotely accessible from a computer or device on the same network via SSH. We’re keeping things simple since this is the only way we are going to access the Raspberry Pi. The LITE version has all the functionality we’re looking for.

1. Download the latest Raspbian image from the official Raspberry Pi website.
2. Flash the Raspbian OS image to the SD card with Etcher or any other OS image burning software of your choice.

Setting up the Raspberry Pi

To get the Raspberry Pi ready to boot we need to:

1. Insert the MicroSD card into the Raspberry Pi
2. Connect the USB keyboard and the HDMI cable
3. Connect the Ethernet cable or if you have a Raspberry Pi 3 and want to use WiFi you should set up the network in the next section

When the Raspberry Pi has finished booting up, log in using username pi and password raspberry

Enabling WiFi and connecting to the network

Skip this step if you chose to connect with an Ethernet cable.

1. Open the “wpa-supplicant” configuration file

$ sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

2. add the following at the bottom of the file while adding your wifi name and password:

network={

   ssid="your_networks_name"   psk="your_networks_password"

}

3. Press Ctrl+X to save the code. Confirm with Y then Enter

4. Reboot the Raspberry Pi with the following command:

$ sudo reboot

Enabling SSH and changing the username and password

Now that the Raspberry Pi is connected to the internet, it’s recommended to change the default password.

1. Open the Raspberry Pi configuration tool and click the second option “Change User Password” and follow the instructions

$ sudo raspi-config

2. Select option 5 “Interfacing Options” then activate SSH

3. Reboot the Raspberry Pi. When it’s up, you have SSH enabled and it’s ready to be accessed remotely from your desktop computer

$ sudo reboot

Configuring remote access to the Raspberry Pi

Now, finally, the part when we install the required software on the Raspberry Pi. This part can be executed directly on the Pi through the terminal using a HDMI monitor and a USB keyboard. For convenience — and since we enable remote SSH connection — we’re going to connect from another desktop environment. This is the best and easiest way to remotely access and control the Pi whenever changes and configurations are needed.

So, basically, this is how you can access the command line interface of a Raspberry Pi remotely from another computer or any device on the same network using SSH. This can be done in two ways:

1. Using the Command Prompt or PowerShell (I’m using Windows on a Desktop computer), replace with your username and IP address

$ ssh username@ipaddress

If you do not know the IP address, type “hostname -I" in the Raspberry Pi command line.

2. The second method is using a client program like PuTTY or any other functioning client SSH software. Here’s an easy guide for using PuTTY.

Installing the required software on the Raspberry Pi

Before installing anything, it’s recommended to update the Raspberry Pi’s operating system and packages. Doing this regularly will keep it up-to-date.

1. Update the system packages list using the following command:

$ sudo apt-get update

2. Upgrade all your installed packages to their latest version:

$ sudo apt-get dist-upgrade

3. Download and install the latest version of Node.js:

// To download$ curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -

// To install$ sudo apt-get install -y nodejs

// Check if the installation was successful:$ node -v

4. Install the Angular CLI globally:

$ npm install -g @angular/cli

5. Install the Git version-control system:

$ sudo apt-get install git

Installing the database (MongoDB)

We need a database for storing the registered users and their credentials. Here are the required steps:

1. Install MongoDB

$ sudo apt-get install mongodb

2. Start the MongoDB process

$ sudo service mongodb start

3. Start the mongo Shell

$ mongo

3. Create a database called “smarthaus”

$ use smarthaus

In MongoDB, default database is test. If you didn’t create any database, then collections will be stored in test database.

Installing Smart Haus

1. Check the current work directory using this command:

$ pwd

/* It will probably print "/home/pi"   where "pi" is the current user directory */

It’s recommended to clone the project’s repository under the pi’s user directory but you can navigate somewhere else if you’re sure.

2. Clone the repository from:

$ git clone https://github.com/ameer157/smarthaus.git

Make sure to navigate inside the directory using:

$ cd smarthaus

Before installing any npm packages using “npm install” please refer to the npm guide to fix permissions to learn how to fix any “EACCESS ”errors you might face during installation. This is very important since it will prevent any npm permission errors, and allows you to install packages globally without using sudo. Using sudo with npm is not recommended and should be avoided.

3. Install all the required packages for the project:

$ npm install

Starting the Node.js server

Before starting the server we need to build the project using the Angular CLI tool. And lastly, we configure the Raspberry Pi so that it runs the server whenever it boots up.

1. Build the project using:

$ ng build --prod

2. Edit the rc.local file using nano:

$ sudo nano /etc/rc.local

3. Add the following on the line before exit 0 then exit and save the file:

su pi -c 'cd /home/pi/smarthaus/backend && sudo node server.js > log.txt &'

The Node.js server is now ready! It will run on every system boot up and save logs in under the same directory in a “log.txt” file.

Let’s run it now and see if it works using this command:

$ sudo node server

The system in now accessible from any device on your network via the Raspberry Pi’s IP address.

Please go ahead and fork this project and get involved in developing the missing parts ?

The end

We got ourselves a working home automation system running safely on a Raspberry Pi in our local network without the use of “the cloud” or somebody else’s server.

Real-time device status synchronization

Adding a new device synchronising data on-demand

My Raspberry Pi sitting next to my Fingbox and router in the living room ?

Rick and Morty providing tech support ??

I hope you enjoyed reading,
Please follow and share for more tech stuff ??

What if you want to self-correct the temperature in your office? Or what if you are curious to understand your office environment using IoT sensors?

If this sounds interesting to you, please read on.

To begin with, we need to set up a temperature reading sensor. We connect it to an Arduino which connects to a RaspberryPi.

The next step is to set up AWS IoT SDK on your Raspberry Pi.

Setup the Thing

1. Create a thing in AWS IoT:

2. Create a single thing to begin with:

3. Create a thing of a particular type. We are using RaspberryPi here (the types are made up by you).

4.Create a certificate for your Thing to communicate with AWS:

5. Download the certificates, a root certificate authority (CA), activate the Thing, and attach the policy.

6. The policy code is here. It may seem a bit permissive, but it is OK for the demo App.

Setup your RaspberryPi

Before you start the setup, please copy all certificates and all root CA files over to the RaspberryPI (scp might help you). You also need to install Node.js if you don’t have it already.

You will also need to install the AWS IoT device SDK.

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install nodejs

openssl x509 -in ./CA-roots/VeriSign-Class\ 3-Public-Primary-Certification-Authority-G5.pem -inform PEM -out root-CA.crt
chmod 775 root-CA.crt

npm install aws-iot-device-sdk

Here is the code that reads the data from the serial port and sends temperature readings using the AWS IoT device SDK. The code is based on the examples from Amazon.

'use strict';

console.log('Running...');

const SerialPort = require('serialport');
const Readline = require('@serialport/parser-readline')

const portName = '/dev/ttyACM0';
const port = new SerialPort(portName, (err) => {
    if (err) {
        return console.log('Error: ', err.message);
    }
});

const deviceModule = require('aws-iot-device-sdk').device;

const parser = port.pipe(new Readline({ delimiter: '\r\n' }));
const rePattern = new RegExp(/C: (.+)F:(.+)/);

parser.on('data', (data) => {
    const arrMatches = data.match(rePattern);

    if(arrMatches && arrMatches.length >= 1) {
        const readingInC = arrMatches[1].trim();
        console.log(readingInC);

        sendDataToTheNube(readingInC);
    }
});

const defaults = {
    protocol: 'mqtts',
    privateKey: './iot/f5b0580f5c-private.pem.key',
    clientCert: './iot/f5b0580f5c-certificate.pem.crt',
    caCert: './iot/root-CA.crt',
    testMode: 1,
    /* milliseconds */
    baseReconnectTimeMs: 4000,
    /* seconds */
    keepAlive: 300,
    /* milliseconds */
    delay: 4000,
    thingName: 'cuttlefish-hub-01',
    clientId: 'nouser' + (Math.floor((Math.random() * 100000) + 1)),
    Debug: false,
    Host: 'a7773lj8lvoid9a.iot.ap-southeast-2.amazonaws.com',
    region: 'ap-southeast-2'
};

function sendDataToTheNube(readingInC) {
    const device = deviceModule({
          keyPath: defaults.privateKey,
          certPath: defaults.clientCert,
          caPath: defaults.caCert,
          clientId: defaults.clientId,
          region: defaults.region,
          baseReconnectTimeMs: defaults.baseReconnectTimeMs,
          keepalive: defaults.keepAlive,
          protocol: defaults.Protocol,
          port: defaults.Port,
          host: defaults.Host,
          debug: defaults.Debug
    });

    device.publish(`temperature/${defaults.thingName}`, JSON.stringify({
        temperature: readingInC
    }));
}

So now what can you do with that data?

You can write a Lambda that enqueues the data for processing. It may look like this:

require("source-map-support").install();

import { Callback, Handler } from "aws-lambda";
import { baseHandler } from "../shared/lambda";
import logger from "../shared/logger";
import {Models} from "../shared/models";
import {QueueWriter} from "./queue-writer";

const handler: Handler = baseHandler((event: any, callback: Callback) => {
    logger.json("Event:", event);

    const writer = new QueueWriter();

    const { temperature, sensorId } = event;

    const reading: Models.Readings.TemperatureReading = {
        temperature,
        sensorId,
    };

    writer.enqueue(reading)
        .then(() => callback())
        .catch(callback);
});

export { handler };

And your serverless.com file may look like this:

functions:
    sensorReadings:
        name: ${self:provider.stage}-${self:service}-sensor-readings
        handler: sensor-readings/index.handler
        description: Gets triggered by AWS IoT
        timeout: 180
        environment:
            READING_QUEUE_NAME: ${self:provider.stage}_${self:custom.productName}_reading
            READING_DL_QUEUE_NAME: ${self:provider.stage}_${self:custom.productName}_reading_dl
        tags:
            service: ${self:service}
        events:
             - iot:
                sql: "SELECT * FROM '#'"

I hope this post has saved you some time setting up your device. Thanks for reading!

It’s the little things that count.

Raspberry Pi 3 Model B+

Many question what the term Internet of Things (IoT) means or what it actually represents. In simple terms, IoT is a term for categorizing anything that can connect to the Internet. This includes your Alexa, HomePod, Android watch, Samsung smart refrigerator and many more. Even if you realize that IoT is a term meant to describe a group of little devices that connect to the Internet that talk to each other, it is still rather unclear how these little devices actually do what they do.

In contrast, everyone knows generally what a Macbook or a computer does and what they are capable of doing. Interestingly, the internals of these IoT devices are very similar to the computers that we use everyday, which includes a processing unit, memory, network and/or bluetooth module and some other sensors.

What many people don’t realize is how easy it is to make your own IoT device using a small computer. In fact, you might wonder if there even exists a readily available, cheap, and powerful small computer. The good news is that it actually exists and it’s really powerful.

Raspberry Pi is EXACTLY That.

Raspberry Pi 3 (raspberrypi.org)

Raspberry Pi is a small computer that fits snugly in your hand. Don’t be fooled by it’s size and just look at the hardware specs for the latest (3+) generation Raspberry Pi.

• 1.4 GHz 64-bit quad-core ARM Cortex-A53, 1GB RAM
• 2.4/5Ghz dual band 802.11ac Wireless LAN, 10/100/1000Mbps Ethernet
• Bluetooth 4.2
• 4 USB ports, Full HDMI port, Combined 3.5mm audio jack and composite video port, 40 GPIO pins
• Micro SD card slot, VideoCore IV 3D graphics core, Camera interface (CSI), Display interface (DSI),

As you can see, this little beast houses a Quad-Core CPU, fast wireless, bluetooth module and enough RAM to do most things you do on your computer. Better yet, this only costs $35, or about a reasonable dinner out (or 3 avocado toasts in SF).

Raspberry Pis have an interesting naming convention. They are categorized by a combination of model name and generation. The model names include A, A+, B, B+, Zero and Compute Module (Compute Module is intended mainly for industrial applications, so we won’t touch on it in this article).

Each model is differentiated by available connectors and the size of the main board. There are various generations built so far, which are largely categorized by numbers from 1 to 3. Each generation is mainly differentiated by the chip performance. The latest and the most powerful version is called Raspberry Pi 3+ Model B+.

As a reference, here are some images that show what parts are available in each of the models.

Raspberry Pi Model Zero

Raspberry Pi 1 Model A (left), Raspberry Pi 1 Model A+ revision 1.1 (right)

Raspberry Pi 1 Model B (left), Raspberry Pi 1,2 Model B+ (middle), Raspberry Pi 3Model B+ (right)

Each model has it’s own tradeoffs. For example, Raspberry Pi Model Zero is the smallest of them all and consumes only 100 mA (0.5W) of power on average. (An average desktop houses a 200~1400W power supply). But, it only houses a single-core CPU, has lower RAM, and lacks a full HDMI port.

However, its smaller size allows it to fit into more spaces, which makes it useful for building devices that are space- and power-constrained. So, having multiple models to choose from increases your options for your project.

What software does it run?

Unfortunately, Raspberry Pi does not run Mac OS X or Windows. Instead, it runs a version of Linux called Raspbian. You can choose to install Raspbian on a micro SD card yourself with NOOBS installer, or purchase a pre-loaded micro SD card like one seen here. Once you plug in the micro SD card with Raspbian installed and turn on the Raspberry Pi, you get the following loading screen:

_Raspbian loading screen. Image from [https://alternativeto.net/software/raspbian/](https://alternativeto.net/software/raspbian/" rel="noopener" target="blank" title=")

As you can see, the desktop looks just like a regular desktop on your large PC. By default, you get a web browser, terminal, image viewer, calculator and many more features.

Raspbian also lets you install tons of software from it’s own open source software repository at no cost. The process of installing a software is also quite simple. You can utilize the apt-get command, a popular Linux command to install software from various repositories, to install any available software.

For example,sudo apt-get install scratch2 will install the popular scratch programming language. Browse around various repositories and StackOverflow, and you will soon realize you can do just about anything with these devices.

What can you ACTUALLY do with this?

Ok, so now you have a small computer that runs a bunch of free software. What can you actually do with it? Well, here’s an easy and fun Python project that I have implemented with a group of middle school students as part of a coding class.

Using a Raspberry Pi compatible temperature/humidity/pressure sensor with LED screen, I taught the concept of randomness using random colors on the LED screen rather than numbers. My students loved how they could visually and physically interact with their own code. You can see the video of the project here:

Using the same device, we also built a calculator, gaming device, weather station and much more. I found them a very useful and cost efficient way to teach introductory programming to young students. I plan to cover the details of my curriculums in an article some other time.

One of my colleagues at Stanford built a customized Raspberry Pi secured espresso machine to protect our precious coffee. The idea is somewhat similar to a Raspberry Pi secured door lock as seen here.

Raspberry Pi secured door lock by HackerHouse

There are many, many articles on using a Raspberry Pi to build fun and useful IoT devices. Here are some list of them I found: Raspberry Pi Security Camera, Raspberry Pi Media Center, Raspberry Pi Code Club.

Wrapping up

I hope this article gives some basic insights on what Raspberry Pis are, how they are built and what they are used for. Also, I hope this article somewhat demystifies what IoT really means.

In essence, IoT is a movement to connect millions of little things using the Internet, and Raspberry Pi is one of the ways to power those little things. I truly believe that the future lies in IoT and I hope everyone try to participate in bringing it a step closer to us.

It’s the little things that count, hundreds of ’em.

— Cliff Shaw.

This is my first article on Medium! Any comment for corrections, improvements and applauses is greatly appreciated!

DeviceHive is an IoT platform which has plenty of different components. The Grafana plugin is one of them. This plugin can gather data from a DeviceHive server and display it with different dashboards using the very popular tool — Grafana. This article explains how to create a Grafana dashboard with DeviceHive. As an example, this uses the ESP8266 chip analog pin to visualise the voltage on it.

Data

To display anything on a dashboard we need data. In terms of a DeviceHive server, data can be provided via ‘commands’ and ‘notifications’. Commands are typically used to deliver any messages to a device which the device should execute while ‘notifications’ are the opposite, devices notify their subscribers about certain events. ‘Commands’ and ‘notifications’ are basically simple JSON messages.

Both of these two entities can be used to plot graphs, display static text, a gauge, table or any other Grafana components. For this article we will generate notifications using special DeviceHive firmware for the ESP8266 chip. This firmware allows the chip to connect directly to a DeviceHive server using its protocol and has plenty of documented commands which can be issued from the server side.

Generating notifications with ESP8266 firmware

The binaries for the DeviceHive firmware are available here. Download the latest version and flash this firmware to your chip. The release archive contains documentation on how to do that, but if you have a ‘nodemcu’-like board you just need to connect the board via a microUSB cable to your computer and run the ‘esp-flasher’ util from the release archive for your operating system and wait until it flashes the board. Having flashed the board, there is a need to configure the chip which Wi-Fi network, DeviceHive server, and credential it should use. There are two ways to do that: using a posix-like terminal with the ‘esp-terminal’ util or wirelessly as described here.

There is a free playground service, which can be used for absolutely free to try a DeviceHive server. After your chip is connected to your server or playground, go to the server admin panel, find your ESP8266 device in the device list and issue the ‘adc/int’ command with the parameters ‘{“0”: 500}’.

This command causes the esp8266 to report every 500ms the voltage on ADC input #0(the only ESP8266 has). After switching to ‘notifications’ there should be screen like:

That is the voltage on the chip’s input pin. And this kind of data is suitable for us to display with Grafana: notifications contain data (parameters in our case), notifications come continuously, and all DeviceHive’s notifications always have a timestamp. Having an analogue sensor connected to this pin it is possible to display this data with Grafana.

Installing the DeviceHive Grafana plugin to Grafana

Grafana can be used as a local service or as a hosted service. To install Grafana locally, please, refer to the “Official documentation. Grafana installation”.

You can find how to install plugins in the “Official documentation. Plugin installation”.

To install DeviceHive datasource via grafana-cli you can use the following command:

$ grafana-cli plugins install devicehive-devicehive-datasource

If you want to install the plugin manually, you should perform the following steps:

Prerequisites, these packages should be installed:

• Grafana >= 4.6
• NodeJs >= 8 (optional)
• NPM >= 5 (optional)
• Grunt (npm install -g grunt) (optional)

Also you should have permissions to copy data to the Plugins folder (you could set it in grafana.ini in Paths->plugins).

1. Clone this repo to the Plugins folder — git clone [https://github.com/devicehive/devicehive-grafana-datasource.git](https://github.com/devicehive/devicehive-grafana-datasource.git;);
2. Next steps are optional (in case if you want to rebuild datasource sources code):
   2.1 Go into folder — cd devicehive-grafana-datasource;
   2.2 Install all packages — npm install;
   2.3 Build plugin — npm run build;
3. Restart Grafana server
4. Open Grafana in browser;
5. Open the side menu by clicking the Grafana icon in the top header;
6. In the side menu click Data Sources;
7. Click the + Add data source in the top header;
8. Select DeviceHive from the Type dropdown;
9. Configure the datasource.

After installation you will be able to see the DeviceHive datasource plugin in the installed plugins list (look at the picture below).

Adding Grafana datasource

To add DeviceHive datasource, you should perform the following steps:

1. Open the side menu by clicking the Grafana icon in the top header;
2. In the side menu click Data Sources;
3. Click the + Add data source in the top header;
4. Select DeviceHive from the Type dropdown;

Look at the picture below:

To configure the DeviceHive datasource you should fill on the following fields:

Server URL (is the path to the DeviceHive WebSocket server. For the playground this is ws://playground.devicehive.com/api/websocket)
Device ID (unique identifier of the DeviceHive device)
Login/Password or AccessToken — credentials to pass authentication

Also, you are able to specify the RefreshToken for auto refreshing the AccessToken

On the picture below you can observe the configuration workflow:

After adding and configuring a DeviceHive datasource, it should exist in the datasource list as in the picture below:

Create new dashboard

To create a new dashboard you should just click on the “New” button in the sidebar panel as shown in the picture below:

In this article we will show examples on the Graph panel, so, click on the Graph button:

After that you will be able to see line chart on your dashboard:

Displaying notifications/commands with Grafana’s graph

Notification and commands are DeviceHive entities:
Command: represents a message dispatched by clients for devices
Notification: represents a message dispatched by devices for clients

By default, a Notification or Command message provides the field named “parameters” in which a user can pass their own data.

At the start of this article we configured the ESP8266 device to send notifications with data that represents the state on analogue pin#0 of the chip. In the picture below you are able to observe how to configure the Grafana graph panel to make it show the data on the line chart:

Displaying annotations on Grafana’s graph

Annotations provide a way to mark points on the graph with rich events. When you hover over an annotation you can get an event description and event tags. The text field can include links to other systems with more detail.
More information about annotations you can find by following this link.

The picture below shows how to configure annotations powered by a DeviceHive datasource.

Advanced graph tuning

After clicking on the “Add converter” button you will be able to select a converter.
A converter is the simple function that transforms a value in some way.

For now, DeviceHive datasources support the following types of converters:

• Scale — multiplies by a given value
• Offset — adds a given value
• Unit converter — converts value between different units of below mentioned measurement types:
• Temperature (‘c’ — Celsius, ‘f’ — Fahrenheit, ‘k’ — Kelvin)
• Length (‘m’ — Meter, ‘mi’ — Mile, ‘yd’ — Yard, ‘ft’ — Feet, ‘in’ — Inch)
• Weight (‘kg’ — Kilogram, ‘lb’ — Pound, ‘oz’ — Ounces)
• Volume (‘l’ — Liter, ‘gal’ — Gallon, ‘pt’ — Pint)

An example of this functionality is shown in the picture below.

Conclusion

Grafana is a perfect tool to visualise data. It is very flexible and provides many different features to make visualisation in a way thay you like. Grafana can use many data sources from a wide range of software solutions and DeviceHive is one of them. The sample which we described in this article is very simple. Using these principles it is possible to create more advanced graphs and we hope it will be helpful for you. Using Grafana and DeviceHive you can build your own IoT visualisation solutions and moreover you can modify both projects as you wish since Grafana and DeviceHive are open source software.

_Written in collaboration with Igor Trambovetskiy, Senior Developer at DeviceHive._

This article discusses the process I used to build the first ever CNC machine controller implementation on pure Python.

Computer numerical control (CNC) machine controllers are typically implemented using the C or C++ programming language. They run on OS-less or real-time operating systems with simple microcontrollers.

In this article, I’ll describe how to build a CNC controller — a 3D printer in particular — using modern ARM boards (Raspberry Pi) with a modern high level language (Python).

Such a modern approach opens a wide range of integration options with other cutting edge technologies, solutions, and infrastructures. This makes the whole project developer-friendly.

About the Project

Modern ARM boards typically use Linux as a reference operating system. This gives us access to the entire Linux infrastructure with all the Linux software packages. We can host a web server on a board, use Bluetooth connectivity, use OpenCV for image recognition, and build a cluster of boards, among other things.

These are well-known tasks that can be implemented on ARM boards, and they can be really useful for custom CNC machines. For example, auto-positioning using compuvision can be very handy for some machines.

Linux is not a real-time operating system. This means we can’t generate pulses with the required timings to control stepper motors directly from the board pins with running software, even as a kernel module. So, how can we use steppers and high-level Linux features? We can use two chips — one microcontroller with a classic CNC implementation, and an ARM board connected to this microcontroller via UART (universal asynchronous receiver-transmitter).

What if there are no suitable firmware features for this microcontroller? What if we need to control additional axes that are not implemented in the microcontroller? Any modifications to the existing C/C++ firmware will require plenty of development time and efforts. Let’s see if we can make it easier and even save money on microcontrollers by simply removing them.

PyCNC

PyCNC is a free open-source high-performance G-code interpreter and CNC/3D-printer controller. It can run on various Linux-powered, ARM-based boards, such as Raspberry Pi, Odroid, Beaglebone, and others. This gives you the flexibility to pick any board and use everything that Linux offers. And you can keep the entire G-code runtime on one board without the need for a separate microcontroller for real-time operation.

Choosing Python as the main programming language significantly reduces the code base compared to C/C++ projects. It also reduces the boilerplate and microcontroller-specific code, and makes the project accessible to a wider audience.

How it works

The project uses DMA (Direct Memory Access) on the chip hardware module. It simply copies the GPIO (General Purpose Input Output) states buffer allocated in RAM to the actual GPIO registers. This copying process is synchronized by the system clock and works completely independently from the CPU cores. Thus, a sequence of pulses for the stepper motor’s axis is generated in memory and then the DMA precisely sends them out.

Let’s dig deeper into the code to understand the basics and how to access hardware modules from Python.

GPIO

A General Purpose Input Output module controls pin states. Each pin can have low or high state. When we program the micro-controller, we usually use SDK (software development kit) defined variables to write to that pin. For example, to enable a high state for pins 1 and 3:

PORTA = (1 << PIN1) | (1 << PIN3)

If you look in the SDK, you will find the declaration of this variable, and it will look similar to:

#define PORTA (*(volatile uint8_t *)(0x12345678))

It’s just a pointer. It doesn’t point to the location in RAM, but to the address of the physical processor. The actual GPIO module is located at this address.

To manage pins, we can write and read data. Raspberry Pi’s ARM processor is not an exception, and it has the same module. To control pins, we can write/read data. We can find the addresses and data structures in the official documentation for processor peripherals.

When we run a process in the user’s runtime, the process starts in the virtual address space. The actual peripheral is accessible directly. But we can still access real physical addresses with _‘/dev/mem’_ device.

Here is some simple code in Python that controls a pin’s state using this approach:

Let’s break it down line by line:

Lines 1–6: headers, imports.

Line 7: open _‘/dev/mem’_ device access to the physical address.

Line 8: we use the mmap system call to map a file (though in our case, this file represents physical memory) into the process’s virtual memory. We specify the length and offset of the map area. For the length, we take the page size. And the offset is 0x3F200000.

The documentation says that the bus address 0x7E200000 contains GPIO registers, and we need to specify the physical address. The documentation says (page 6, paragraph 1.2.3) that the 0x7E000000 bus address is mapped to the 0x20000000 physical address, but this documentation is for Raspberry 1.

Please note that all module bus addresses are the same for Raspberry Pi 1–3, but this map was changed to 0x3F000000 for RPi 2 and 3. So, the address here is 0x3F200000. For Raspberry Pi 1, change it to 0x20200000.

After this, we can write to our process’s virtual memory, but it actually writes to the GPIO module.

Line 9: close the file handle, since we don’t need to store it.

Lines 11–14: we read and write to our map with the 0x08 offset. According to the documentation, it is the GPFSEL2 GPIO Function Select 2 register. And this register controls pin functions.

We set (clear all, then set with the OR operator) 3 bits with the 3rd bit set to 001. This value means that the pin works as an output. There are many pins and possible modes for them. This is why the register for modes is divided into several registers, where each contains the modes for 10 pins.

Lines 16 and 22: set up the ‘Ctrl+C’ interruption handler.

Line 17: infinite loop.

Line 18: set the pin to the high state by writing to the GPSET0 register.

Please note, Raspberry Pi doesn’t have registers like PORTA (AVR microcontrollers) have. We can’t write the whole GPIO state of all pins. There are just set and clear registers which are used to set and clear specified with bitwise mask pins.

Lines 19 and 21: delay

Line 20: set pin to low state with the GPCLR0 register.

Lines 25 and 26: switch pin to default, input state. Close the memory map.

This code should be run with superuser privileges. Name the file ‘gpio.py’ and run it with ‘sudo python gpio.py’. If you have a LED connected to pin 21, it will blink.

DMA

Direct Memory Access is a special module that is designed to copy memory blocks from one area to another. We will copy data from the memory buffer to the GPIO module. First of all, we need a solid area in physical RAM that will be copied.

There are few possible solutions:

1. We can create a simple kernel driver that will allocate, lock, and report to us the address of this memory.
2. In some implementations, virtual memory is allocated and uses ‘/proc/self/pagemap’ to convert the address to the physical one. I wouldn't recommend this approach, especially when we need to allocate big area. Any virtually allocated memory (even locked, see the kernel documentation) can be moved to the physical area.
3. All Raspberry Pi have a ‘/dev/vcio’ device, which is a part of the graphic driver and can allocate physical memory for us. An official example shows how to do it. And we can use it instead of creating our own.

The DMA module itself is just a set of registers that are located somewhere at a physical address. We can control this module via these registers. Basically, there are source, destination, and control registers. Let’s check some simple code that shows how to use the DMA modules to manage the GPIO.

Since additional code is required to allocate physical memory with ‘/dev/vcio’, we will use a file with an existing CMA PhysicalMemory class implementation. We will also use the PhysicalMemory class, which performs the trick with memap from the previous sample.

Let’s break it down line by line:

Lines 1–3: headers, imports.

Lines 5–6: constants with the channel DMA number and GPIO pin that we will use.

Lines 8–15: initialize the specified GPIO pin as an output, and light it up for a half second for visual control. In fact, it’s the same thing we did in the previous example, written in a more pythonic way.

Line 17: allocates 64 bytes in physical memory.

Line 18: creates special structures — control blocks for the DMA module. The following lines break the structure of this block. Each field has a length of 32 bit.

Line 19: transfers information flags. You can find a full description of each flag on page 50 of the official documentation.

Line 20: source address. This address must be a bus address, so we call _get_bus_address()_. The DMA control block must be aligned by 32 bytes, but the size of this block is 24 bytes. So we have 8 bytes, which we use as storage.

Line 21: destination address. In our case, it’s the address of the SET register of the GPIO module.

Line 22: transmission length — 4 bytes.

Line 23: stride. We do not use this feature, set 0.

Line 24: address of the next control block, in our case, next 32 bytes.

Line 25: padding. But since we used this address as a data source, put a bit, which should trigger GPIO.

Line 26: padding.

Lines 28–37: fill in the second DMA control block. The difference is that we write to CLEAR GPIO register and set our first block as a next control block to loop the transmission.

Lines 38–39: write control blocks to physical memory.

Line 41: get the DMA module object with the selected channel.

Lines 42–43: reset the DMA module.

Line 44: specify the address of the first block.

Line 45: run the DMA module.

Lines 49–52: clean up. Stop the DMA module and switch the GPIO pin to the default state.

Let’s connect the oscilloscope to the specified pin and run this application (do not forget about sudo privileges). We will observe ~1.5 MHz square pulses:

DMA challenges

There are several things that you should take into consideration before building a real CNC machine.

First, the size of the DMA buffer can be hundreds of megabytes.

Second, the DMA module is designed for a fast data copying. If several DMA channels are working, we can go beyond the memory bandwidth, and buffer will be copied with delays that can cause jitters in the output pulses. So, it’s better to have some synchronization mechanism.

To overcome this, I created a special design for control blocks:

The oscillogram at the top of the image shows the desired GPIO states. The blocks below represent the DMA control blocks that generate this waveform. “Delay 1” specifies the pulse length, and “Delay 2” is the pause length between pulses. With this approach, the buffer size depends only on the number of pulses.

For example, for a machine with 200mm travel length and 400 pulses per mm, each pulse would take 128 bytes (4 control blocks per 32 bytes), and the total size will be ~9.8MB. We would have more than one axis, but most of the pulses would occur at the same time. And it would be dozens of megabytes, not hundreds.

I solved the second challenge, related to synchronization, by introducing temporary delays through the control blocks. The DMA module has a special feature: it can wait for a special ready signal from the module where it writes data. The most suitable module for us is the PWM (pulse width modulation) module, which will also help us with synchronization.

The PWM module can serialize the data and send it with fixed speed. In this mode, it generates a ready signal for the FIFO (first in, first out) buffer of the PWM module. So, let’s write data to the PWM module and use it only for synchronization.

Basically, we would need to enable a special flag in the perceptual mapping of the transfer information flag, and then run the PWM module with the desired frequency. The implementation is quite long — you can study it yourself.

Instead, let’s create some simple code that can use the existing module to generate precise pulses.

import rpgpio

PIN=21PINMASK = 1 << PINPULSE_LENGTH_US = 1000PULSE_DELAY_US = 1000DELAY_US = 2000 g = rpgpio.GPIO()g.init(PIN, rpgpio.GPIO.MODE_OUTPUT) dma = rpgpio.DMAGPIO()for i in range(1, 6): for i in range(0, i): dma.add_pulse(PINMASK, PULSE_LENGTH_US) dma.add_delay(PULSE_DELAY_US) dma.add_delay(DELAY_US)dma.run(True) raw_input(“Press Enter to stop”)dma.stop()g.init(PIN, rpgpio.GPIO.MODE_INPUT_NOPULL)

The code is pretty simple, and there is no need to break it down. If you run this code and connect an oscilloscope, you will see:

And now we can create real G-code interpreter and control stepper motors. But wait! It is already implemented here. You can use this project, as it’s distributed under the MIT license.

Hardware

The Python project can be adopted for your purposes. But in order to inspire you, I will describe the original hardware implementation of this project — a 3D printer. It basically contains the following components:

1. Raspberry Pi 3
2. RAMPSv1.4 board
3. 4 A4988 or DRV8825 module
4. RepRap Prusa i3 frame with equipment (end-stops, motors, heaters, and sensors)
5. 12V 15A power supply unit
6. LM2596S DC-DC step down converter module
7. MAX4420 chip
8. ADS1115 analog to digital converter module
9. UDMA133 IDE ribbon cable
10. Acrylic glass
11. PCB stands
12. Set of connectors with 2.54mm step

The 40-pin IDE ribbon cable is suitable for the Raspberry Pi 40 pins connector, but the opposite end requires some work. Cut off the existing connector from the opposite end and crimp connectors to the cable wires.

The RAMPSv1.4 board was originally designed for connection to the Arduino Mega connector, so there is no easy way to connect this board to the Raspberry Pi. The following method allows you to simplify the boards connection. You will need to connect less than 40 wires.

PyCNC reference connection

I hope this connection diagram is fairly simple and easily duplicated. It’s better to connect some pins (2nd extruder, servos) for future use, even if they are not currently needed.

You might be wondering — why do we need the MAX4420 chip? The Raspberry Pi pins provide 3.3V for the GPIO outputs, and the pins can provide very small current. It’s not enough to switch the MOSFET (Metal Oxide Semiconductor Field Effect Transistor) gate. In addition, one of the MOSFETs works under the 10A load of a bed heater. As a result, with a direct connection to a Raspberry Pi, this transistor will overheat. Therefore, it is better to connect a special MOSFET driver between the highly loaded MOSFET and Raspberry Pi. It can switch the MOSFET in a an efficient way and reduce its heating.

The ADS1115 is an Analog to Digital Converter (ADC). Since Raspberry Pi doesn’t have an embedded ADC module, I used an external one to measure the temperature from the 100k Ohm thermistors. The RAMPSv1.4 module already has a voltage divider for the thermistors. The LM2596S step down converter must be adjusted to a 5V output, and it is used to power the Raspberry Pi board itself.

Now it can be mounted on the 3D printer frame and the RAMPSv1.4 board should be connected to the equipped frame.

That’s it. The 3D printer is assembled, and you can copy the source code to the Raspberry Pi and run it. sudo ./pycnc will run it in an interactive G-Code shell. sudo ./pycnc filename.gcode will run a G Code file. Check the ready config for Slic3r.

And in this video, you can see how it actually works.

If you found this article useful, please give me some claps so more people see it. Thanks!

_IoT is all about prototyping ideas quickly. To make it possible we developed DeviceHive, an open source IoT/M2M platform. DeviceHive provides a solid foundation and building blocks to create any IoT/M2M solution, bridging the gap between embedded development, cloud platforms, big data & client apps._

This month I built a smart mirror with my dad and daughter. This project spanned across three generations.

The idea started a few years ago with the novelty of a smart mirror. But before I was going invest the time and money to make one, I needed a practical reason to build one. Recently that reason presented itself.

In our kitchen we have a whiteboard where we list out our dinner plans for the week and I wanted to upgrade it. I submitted a presentation idea for the smart mirror at local tech conference. My smart mirror presentation was selected. This accelerated my timeline.

Programming the Smart Mirror with my Daughter

I needed help with the design of the smart mirror frame

since I live in the digital world designing software that lives in the cloud. My dad is a Mechanical Engineer who lives in the physical world designing the planes we fly though the clouds everyday. While talking with my dad one evening, he suggested to create some initial sketches of the mirror.

Initial Design of Smart Mirror

After a few more conversations with my dad and several design revisions, we settled on a simple box design for the frame. My dad knew more about woodworking than I did, and he had a few suggestions for me.

Like using cabinet draw sides for the sides of the frame as they already came with a groove to hold the glass. And using french cleats to secure the mirror to the wall. This also allowed it to be easily removed for transport.

Revised Design of the Smart Mirror

My wife was a huge support in this endeavor. She helped by sorting through dozens of televisions looking for the right price and features. The size had to be large enough for our kitchen, but not too large to make transporting a hassle. Finally she was able to get a television from Best Buy that had everything I was looking for. And the best part was that it was on sale.

The most noticeable part of the smart mirror is the reflective mirror. Most household mirrors are made from glass. But the biggest downside to using glass is that it’s fragile and doesn’t transport well. I chose plastic as it’s lighter, more transparent, and more durable.

It’s nice to talk to experts and I live in Seattle which has a great local plastic supplier. They were excellent and able to help me select the correct plastic. They suggested acrylic and we even tested the mirror film I had acquired on a sample they had. And this was not the first smart mirror they had supplied the plastic for so I knew I was on the right track.

The choice was simple when it came to deciding where to assemble the frame. My dad has a new workshop and all the tools we needed and I have a garage and a single toolbox. Once I had acquired the wood, acrylic, and mirror film, I went over to my dad’s workshop to assemble the frame.

I thought it would take 4–5 hours. But it took around 15 hours to assemble the mirror. That may be due to refining the design as we were making the mirror. It may also be due to me asking a lot of questions, like why glue this instead of screw that. Or it was due to having a good time with my dad. Looking back it was a combination of all the above.

Over three separate days we cut, glued, nailed, and screwed the frame together. It would hold the television, acrylic mirror, and Raspberry Pi.

Several power tools were used including a table saw, chop saw, and nail gun so my daughter didn’t help with that part. But she was able to help with the final assembly when the acrylic mirror was inserted. She was even able to use the power drill to screw in the top during the final assembly.

My Daughter using a Power Drill to Screw in the Top of the Mirror

With all the woodworking completed, my daughter and I started wiring everything together. As pink is her favorite color, it was obvious that the only choice was to 3D print the Raspberry Pi case in pink.

We put the Raspberry Pi into the pink case and attached it to the back of the TV via adhesive Velcro.

By using Velcro, the Raspberry Pi can be disconnected. Thus I can show the size of the computer transforming the mirror into a smart mirror.

3D Printed Pink Raspberry Pi Case

Modern televisions usually include a USB port, and the one my wife found did indeed have one. I tested it out the USB Port on the TV and it was able to supply enough power to the Raspberry Pi. This meant that the TV Power cord was the only cable I needed to plug into the wall outlet.

Then we plugged the USB and HDMI cables into both the Raspberry Pi and TV and we were ready to go.

With the on board WiFi I connected the smart mirror to the internet without any other wires. And when the power is out it will still work as a traditional non-smart mirror.

My Daughter and I Connecting all the Wires on the Back of the Smart Mirror

When you are 4, typing on a keyboard and coding are cool. We’ll see how she feels when she’s 14.

My daughter got to help a lot on the software part of the smart mirror. Since her spelling abilities end with her name, she was able to type that and was very excited when she saw it on the smart mirror.

To get her name to appear, we used HTML. To keep it simple a static HTML page with inline styling via Chrome, fullscreen F11, was all we had to do to get it working. The background needs to be as dark as possible to minimize the light coming though the mirror.

When the screen is off or completely black it appears as a common mirror. The text and graphics need to be as bright as possible to show through, transforming it into a smart mirror. On my mirror I was able to find a film with 5% transparency.

Installing the Acrylic Mirror into the Frame

In reviewing my mirror thus far, I would do a few things different next time. First, I would get a slimmer television. Right now the mirror frame is 4.5 inches deep, which is deep enough that you notice, but not so deep that it’s obtrusive.

Next, I would order acrylic with the mirror film already installed. My dad and I were able to install the film in 20 min, but this resulted in several small bubbles. Most likely due to a few small pieces of dust trapped between the film and acrylic.

Also, I would add a more stylized front. If you take a look at the corners of my smart mirror, you will see all the layers of plywood. This could be hidden with some nice wood to more resemble a picture frame.

Finally, I would add a small gap between the TV and acrylic. Currently, the acrylic is helping to support the TV. This is putting pressure on the acrylic causing it to bend slightly. This results in a slight distortion of the mirror.

Building the Smart Mirror has been a great experience and if you have any questions please reach out.

The next project that my daughter and I are working on is wiring some sensors in the kitchen to track the temperature in the refrigerator and freezer. I’m hoping to get her more involved with this and future projects as she is excited to help and wire the sensors on a breadboard.

I look forward to sharing that story with you once she and I have completed it.

At the fundamental level, a microcontroller is a just tiny computer.

Being a “tiny computer” doesn’t really tell us much, though. So let’s go deeper. Many people associate microcontrollers with Arduino. But it’s important to point out that Arduino is not a microcontroller. Arduino is a complete platform which spans across software and hardware.

Arduino makes devices like the Arduino Uno:

Arduino Uno

The Arduino Uno is not a microcontroller, either. It’s a breakout board based on the Atmel ATmega328P microcontroller.

Here is what the Atmel microcontroller looks like:

If you were to have just the Atmel microcontroller in hand, as a beginner, it wouldn’t be very useful. This is where the breakout board comes in.

The breakout board “breaks out” the pins on the microcontroller into a larger device (like the Arduino Uno). This larger device makes the microcontroller easier to use.

For the Arduino Uno, the breakout board gives you the ability to insert a USB cord, give it power, program the device, and more.

_[Image credit](https://www.hackster.io/hmkim/remote-controlled-8x8-led-matrix-e2b79a?ref=part&ref_id=8233&offset=18" rel="noopener" target="blank" title=")

Without the breakout board, for a beginner, this would be a daunting task. This problem is the very reason that Arduino exists — to make it super easy for you to learn about hardware.

Ah, So it’s like the Raspberry Pi?

Well, not entirely. Both the Arduino and the Raspberry Pi are still computers by definition. But the Raspberry Pi is considered a single-board computer. A single-board computer is a full computer built on a single circuit board.

A Raspberry Pi

Your laptop is also technically a single-board computer — just a powerful one. The Raspberry Pi is a simple version of the same hardware in your laptop. Just as your laptop runs an operating system (Windows, Mac, or Linux), the Raspberry Pi runs a Linux operating system.

Now, back to Microcontrollers. Microcontrollers can’t run an operating system. Microcontrollers also don’t have the same amount of computing power or resources as most single-board computers.

A microcontroller will run just one program repeatedly — not a full operating system. We can see this in Arduino programs because they only need two functions: Setup and loop. Setup will run once and loop will run indefinitely.

Setup and Loop

So, what’s a microcontroller?

A microcontroller is a small computer with low-memory and programmable input/output peripherals.

Inputs/Outputs

As you probably know, everything with a computer eventually starts with binary (0 or 1).

An input means that the microcontroller will read binary. An example input would be a sensor.

An output means that the microcontroller will send binary. An example output would be to control a motor or LED.

Why do we need microcontrollers?

Well, these were “computers” before we arrived at the idea of the computers you know today. Microcontrollers stuck around because some computing tasks are incredibly trivial and require simple logic. For example, flipping a switch or controlling small components — like a LED light — don’t require the same resources we need for day-to-day tasks like sending an email.

We use them today because their low-powered and low memory makes them low-cost. Microcontrollers are part of the reason the Internet of Things is possible and successful today.

How do I get one?

Which microcontroller you’ll want to get depends on which problem you want to solve. If you are doing something simple — turning things on and off, or reading a sensor — pretty much any microcontroller will do.

If you want to play games or have more complex ideas, you’ll need more compute power, so you’ll need to move up to single-board computers, like the Raspberry Pi.

Adafruit and Sparkfun both have TONS of kits and hardware that are all amazing. You can also make use of their tutorials.

Losant also has some cool kits available. You could build your own door sensor — to be notified when a door is left open for too long.

If you don’t have a specific problem you want to solve, just grab some hardware and play around with it.

Here are some things you can buy to get started:

1. A board called the NodeMCU.

Node MCU

The NodeMCU is a board based on the ESP8266 microcontroller. This board is special because it’s cheap and WiFi enabled. It will only run you about $8.79 on Amazon and is even less on Ebay.

Not all microcontrollers are WiFi-enabled. The fact that this one is opens the door to a number of projects you can build with this device. For example, you can collect data and send it to the cloud ☁️.

2. You’ll need some Sensors

Bread Board

You can’t have hardware without sensors. Sensors give you the ability to detect the environment and the world around you. They’re also a great tool for learning.

3. You’ll need a Breadboard & Jumper Wires:

To connect a sensor and the microcontroller together, you’ll have to plug them into the Breadboard and use the Jumper wires to connect them.

Remember: everything is cheaper on eBay and AliExpress. You’ll just have to wait a couple weeks for shipping

What should I build?

Again — and I can’t stress this enough — it’s way easier to start with a project in mind. Now that you understand what a microcontroller is and how to get one, take a different look at the world around you. What can you control? What can you automate? Once you start to answer those questions, you’ll find a project.

While thinking of projects, Hackster is your best friend. Hackster has a ton of ESP8266 projects and some cool Arduino projects:

For example, you can live out a childhood dream.

You can even build robots.

The point is, you just need an idea.

Sometimes programming the real world is more fun than programming virtual ones.

What’s next?

Microcontrollers are only the beginning. You have a world of hardware to explore. Happy Hacking ??

Further reading:

The Absolute Beginner's Guide to Arduino
_Over the Christmas break from work I wanted to learn something new. I've been eyeing up Arduino for some time now, and…_forefront.io

Taron Foxworth is a hardware hacker and the Developer Evangelist at Losant. His goal is to translate technology for people to learn, love, and be inspired.

If you’ve ever wired up a button to an Arduino, you’ve come across this diagram:

At first, this can be confusing. My first thoughts: “Why do I need a resistor? I just want to it to tell me whether the button is being pressed.”

After a lot of reading, there wasn’t a simple explanation.

What’s going on here

Diagram 1

In that button — AKA a switch—the wires are shaped in the form of an “H”. But the middle isn’t connected — or the circuit isn’t connected — until we press the button.

In reality, we want to read from the Arduino a 0 when nothing is connected and a 1 when the button is pressed.

On the Arduino, this is called General Purpose Input Output (GPIO).

So, we can do something like this:

Diagram 2

We connect positive (5v, 3.3V, or VCC) to the left side of the circuit.

Now, when the button is pressed, the GPIO will read a 1, and all is good.

Diagram 3

Well, no. Let’s take a look at Diagram 2 again:

Diagram 2

We wanted a 0 when nothing is connected, but how can you guarantee this? Currently, there is no way to guarantee the GPIO to be 0.

There is also electromagnetic frequencies in the air that could draw your GPIO to 0 or 1. It could even fluctuate between the two! This way, we can’t be positive it’s a 0 (I’m so bad at puns). This is also known as a logical 0.

One way to get a logical 0 is to tie the pin to Ground:

Yay! So, now it’s a guaranteed logical zero. While pushing the button, it’s going to be 1 now. Right?

Well, No.

You just created a short circuit. ?

This is where the resistor comes in. To avoid a short circuit, we need to add resistance to our circuit. The resistor keeps things under control.

Electricity will take the path of least resistance. Your GPIO will now register a 1 when the button is pressed. Like so:

Woo Hoo! Now we’re working with something.

Now let’s look at the opposite: pull-up resistors. It’s the same thing but in reverse. While the button is not pressed, the GPIO will register a 1. When you pressed the button, the GPIO will be 0.

While not pressed, we have the GPIO connected to positive ( VCC ). So, any current that is there will be pulled-up so that the GPIO registers a logical 1.

It’s important to note here that, electricity always wants to go to Ground. So, when we press the button, the current that’s flowing will flow to Ground. Thus, any current that would have been going to the GPIO goes with it, leaving the GPIO at a logical 0.

? The End.

Why did I write this?

I joined Losant in September of 2016 with no hardware experience. Every single hardware starter kit gives you a button with no explanation of this concept. Hopefully, this helps your light bulb go off too. ?

This only scratched the surface. If you want to dig deeper, check out these resources:

Pull-up Resistors - learn.sparkfun.com
_Another thing to point out is that the larger the resistance for the pull-up, the slower the pin is to respond to…_learn.sparkfun.com

I love feedback. So, please let me know if this could be improved. If I totally missed the ball on this, let me know! I would love to make it better for others.