BLE, RPi 3 & Node.js: Sending Temp Data Guide

Aug 4, 2025 by Viktoria Ivanova 46 views

BLE + Raspberry Pi 3 + Node.js: A Comprehensive Guide to Sending Temperature Measurements

Hey guys! Are you diving into the world of IoT (Internet of Things) and looking to connect your mobile app with a Raspberry Pi 3 using Bluetooth Low Energy (BLE) and Node.js? You've come to the right place! This guide will walk you through the process of building an application where your Raspberry Pi 3 (RPi 3) acts as a BLE peripheral, sending temperature measurements to your Android/iOS app. We'll break down each step, making it super easy to follow, even if you're relatively new to this stuff. Trust me, it's an awesome project that opens up tons of possibilities for home automation, environmental monitoring, and more. By combining the power of Raspberry Pi, the efficiency of BLE, and the flexibility of Node.js, you can create some seriously cool applications. In this article, we'll cover everything from setting up your Raspberry Pi and installing the necessary software to writing the Node.js code for BLE communication and handling temperature data. We'll also touch on the mobile app side, discussing how to connect and receive data from the Pi. So, grab your favorite beverage, and let's get started on this exciting journey! Whether you're a seasoned developer or just starting out, this guide is designed to be accessible and informative. Let's dive in and bring your IoT vision to life!

First things first, let's get your Raspberry Pi 3 ready for action. This involves installing the operating system, enabling Bluetooth, and ensuring all the necessary packages are up to date. This foundational step is critical for the rest of the project, as it ensures your Pi is running smoothly and can handle the BLE communication and Node.js environment we'll be setting up. Think of it as building the foundation for a skyscraper—a solid base ensures everything else can stand tall and strong. So, let's roll up our sleeves and get this done right!

Installing the Operating System

Most likely, you'll want to use Raspberry Pi OS (formerly Raspbian) as your operating system. It's the official OS and has great support for the Pi's hardware. You can download the Raspberry Pi Imager from the official Raspberry Pi website. This tool makes it incredibly easy to flash the OS onto an SD card. Just pop in your SD card, select the OS, and let the Imager do its thing. Once it's done, insert the SD card into your RPi 3 and boot it up. The first boot might take a little while as it configures everything, but once it's up and running, you're ready to move on to the next step. Don't worry if you're not familiar with this process; the Raspberry Pi community is huge, and there are tons of resources and tutorials available online to guide you through it. And if you run into any snags, a quick search will usually get you the answers you need. Remember, every expert was once a beginner, so don't be afraid to ask questions and learn as you go!

Enabling Bluetooth

Next up, we need to make sure Bluetooth is enabled on your RPi 3. By default, it should be enabled, but it's always good to double-check. Open up a terminal window on your Pi and type sudo bluetoothctl. This command launches the Bluetooth command-line tool. From there, type power on to ensure Bluetooth is powered on. If it wasn't already, this will fire up the Bluetooth radio on your Pi. Then, type scan on to start scanning for nearby Bluetooth devices. This is a useful step to verify that your Pi's Bluetooth is working correctly. You should see a list of nearby devices, including your smartphone or other Bluetooth-enabled gadgets. If you don't see anything, double-check your connections and make sure Bluetooth is enabled on any devices you expect to see. Once you've confirmed that Bluetooth is up and running, you're one step closer to establishing that crucial connection between your Pi and your mobile app. Remember, Bluetooth is the backbone of our communication, so it's essential to get this right. With Bluetooth enabled, your Pi is ready to start broadcasting its presence and communicating with other devices!

Updating Packages

Before we dive into the software installation, let's make sure your system is up to date. Run the following commands in the terminal:

sudo apt update
sudo apt upgrade

These commands will update the package lists and upgrade any outdated packages on your system. This step is crucial for ensuring you have the latest versions of all the necessary software and libraries, which can prevent compatibility issues and bugs down the line. Think of it as giving your Pi a fresh coat of paint and a tune-up before a long road trip. It ensures everything runs smoothly and efficiently. Plus, updated packages often include security patches, so you're also keeping your system safe and secure. So, take a few minutes to run these commands, and you'll be setting yourself up for a smoother development experience. With your system fully updated, you can confidently move on to installing the software we need for our BLE project. Remember, a well-maintained system is a happy system, and a happy system makes for a happy developer!

Now that your RPi 3 is set up, let's install Node.js and the necessary packages to handle BLE communication. Node.js is a powerful runtime environment that allows you to run JavaScript on the server-side, making it perfect for our project. We'll also need a few specific Node.js packages that will help us interact with the Bluetooth hardware and handle the data transmission. This is where the magic really starts to happen, as we bring together the software components that will enable our temperature-sensing application. So, let's dive into the installation process and get our Pi ready to speak the language of BLE!

Installing Node.js

Node.js isn't typically installed by default on Raspberry Pi OS, so we'll need to add it. The easiest way to do this is by using the NodeSource repository. Open your terminal and run the following commands:

curl -sL https://deb.nodesource.com/setup_16.x | sudo -E bash -
sudo apt-get install -y nodejs

These commands first add the NodeSource repository to your system's package sources, and then install Node.js. It's like adding a new toolbox to your workshop, filled with all the tools you need to build amazing things. Once the installation is complete, you can verify it by running node -v and npm -v in the terminal. These commands will display the versions of Node.js and npm (Node Package Manager) installed on your system. If you see version numbers, congratulations! You've successfully installed Node.js. If not, double-check the commands and make sure you're connected to the internet. With Node.js up and running, you're ready to start building your BLE application. This powerful environment will allow you to write the code that controls your Raspberry Pi's Bluetooth functionality and sends those valuable temperature measurements. So, let's keep the momentum going and move on to installing the specific packages we need for our project.

Installing Noble.js

For BLE communication, we'll use the noble package, a popular Node.js library for interacting with Bluetooth Low Energy devices. To install it, run:

sudo apt-get install bluetooth bluez libbluetooth-dev libudev-dev
sudo npm install noble --unsafe-perm

The first command installs the necessary Bluetooth development libraries. These libraries are essential for noble to communicate with the Bluetooth hardware on your Raspberry Pi. Think of them as the gears and cogs that make the Bluetooth engine run smoothly. The second command installs the noble package itself. The --unsafe-perm flag is required because noble needs to access system resources, and this flag tells npm to bypass permission checks during installation. Don't worry, it's a common practice when working with hardware-related packages. Once the installation is complete, you'll have the noble library at your fingertips, ready to help you create your BLE application. This package provides a clean and intuitive API for scanning, connecting, and communicating with BLE devices. It's like having a universal remote for the Bluetooth world, allowing you to control and interact with a wide range of devices. With noble installed, you're well-equipped to handle the BLE side of your project. So, let's keep moving forward and start thinking about the code that will bring your temperature-sensing application to life!

Alright, the fun part! Let's write the Node.js code that will make your RPi 3 act as a BLE peripheral and send those temperature readings. This involves creating a script that initializes the BLE stack, advertises the Raspberry Pi as a connectable device, and handles the transmission of data. This is where we'll translate our ideas into action, turning the Pi into a temperature-broadcasting powerhouse. So, fire up your favorite text editor, and let's get coding!

Setting Up the BLE Peripheral

Create a new JavaScript file, for example, ble_temperature.js. At the beginning of the file, require the noble library and create a new instance:

const noble = require('@abandonware/noble');

noble.on('stateChange', function(state) {
  if (state === 'poweredOn') {
    noble.startAdvertising('temperature_sensor', ['1234']);
  } else {
    noble.stopAdvertising();
  }
});

This code snippet does a few important things. First, it imports the noble library, which provides the functions we need to interact with BLE. Then, it sets up an event listener for the stateChange event. This event is triggered whenever the Bluetooth adapter's state changes (e.g., when it's powered on or off). Inside the event listener, we check if the state is poweredOn. If it is, we start advertising our Raspberry Pi as a BLE peripheral named temperature_sensor. The ['1234'] is a list of service UUIDs that our peripheral supports. UUIDs are unique identifiers that define the services and characteristics of a BLE device. We'll define these later, but for now, just think of them as labels that help other devices understand what our Pi can do. If the Bluetooth adapter is not powered on, we stop advertising. This ensures that our Pi only broadcasts its presence when Bluetooth is active. This initial setup is crucial for making your Pi discoverable to other devices. It's like putting up a sign that says, "Hey, I'm here and ready to connect!" With this code in place, your Pi will start broadcasting its presence, waiting for a connection from your mobile app. So, let's keep building on this foundation and add the functionality to actually send temperature data.

Adding a Service and Characteristic

Now, let's add a service and a characteristic to our BLE peripheral. A service is a collection of characteristics that perform a specific function, and a characteristic is a single data point within a service. In our case, we'll create a service for temperature sensing and a characteristic for the temperature value itself.

const bleno = require('@abandonware/bleno');

function TemperatureService() {
  bleno.PrimaryService.call(this, {
    uuid: '1234',
    characteristics: [
      new bleno.Characteristic({
        uuid: 'abcd',
        properties: ['read', 'notify'],
        onReadRequest: function(offset, callback) {
          // Simulate temperature reading
          const temperature = 25 + Math.random() * 5;
          const data = Buffer.alloc(4);
          data.writeFloatLE(temperature, 0);
          console.log('Temperature sent: ' + temperature);
          callback(this.RESULT_SUCCESS, data);
        },
        onSubscribe: function(maxValueSize, updateValueCallback) {
          console.log('Client subscribed');
          this._updateValueCallback = updateValueCallback;
        }
      })
    ]
  });
}

util.inherits(TemperatureService, bleno.PrimaryService);

This code defines a TemperatureService class that extends bleno.PrimaryService. We assign a UUID of '1234' to our service, which matches the UUID we used when starting advertising. Inside the service, we define a single characteristic with a UUID of 'abcd'. This characteristic has two properties: read and notify. The read property allows clients to request the current temperature value, and the notify property allows the peripheral to send updates to subscribed clients. The onReadRequest function is called when a client requests the temperature. We simulate a temperature reading using 25 + Math.random() * 5, which generates a random temperature between 25 and 30 degrees Celsius. We then create a Buffer to store the temperature value and write the float value into it. Finally, we call the callback function with the result and the data. The onSubscribe function is called when a client subscribes to the characteristic. We store the updateValueCallback function, which we'll use later to send temperature updates. This code snippet is the heart of our temperature-sensing application. It defines the structure of our BLE service and characteristic, and it handles the crucial task of providing temperature data to connected clients. With this in place, your Raspberry Pi is ready to start sharing its (simulated) temperature readings with the world. So, let's keep going and add the final touches to make our application complete!

Advertising the Service

To make our service available, we need to advertise it. Add the following code to the stateChange event listener in your ble_temperature.js file:

noble.on('stateChange', function(state) {
  if (state === 'poweredOn') {
    bleno.on('stateChange', function(state) {
      if (state === 'poweredOn') {
        bleno.startAdvertising('temperature_sensor', ['1234']);
        bleno.setServices([new TemperatureService()]);
      } else {
        bleno.stopAdvertising();
      }
    });

    bleno.on('advertisingStart', function(err) {
      if (!err) {
        console.log('Advertising...');
      }
    });

    noble.startAdvertising('temperature_sensor', ['1234']);
  } else {
    noble.stopAdvertising();
  }
});

This code adds a new event listener for bleno.on('stateChange'). Inside this listener, we start advertising our peripheral with the name temperature_sensor and the service UUID 1234. We also set the services for our peripheral, which includes our TemperatureService. The bleno.on('advertisingStart') event listener is called when advertising starts successfully. We simply log a message to the console to let us know that advertising is running. This code snippet ensures that our Raspberry Pi is not only discoverable but also advertises the specific services it offers. It's like adding a detailed listing to a directory, so potential clients know exactly what your Pi can do. With this in place, your Pi is ready to broadcast its temperature-sensing capabilities to the world. So, let's take a moment to appreciate the progress we've made. We've set up our Raspberry Pi, installed the necessary software, and written the code to create a BLE peripheral that advertises a temperature-sensing service. Now, it's time to move on to the final steps, which involve running our code and connecting to it from a mobile app.

With the Node.js code in place, you're almost there! Now, we'll run the script on your Raspberry Pi and then explore how you can connect to it from a mobile app. This is where we see all our hard work come to fruition, as we witness the communication between the Pi and the mobile app. So, let's power up our Pi, fire up the app, and watch the magic happen!

Running the Node.js Script

To run your ble_temperature.js script, navigate to the directory where you saved the file in your terminal and run:

sudo node ble_temperature.js

You'll need to use sudo because noble requires root privileges to access the Bluetooth hardware. If everything is set up correctly, you should see the "Advertising..." message in the console. This indicates that your Raspberry Pi is now advertising itself as a BLE peripheral. If you encounter any errors, double-check your code for typos and make sure all the necessary packages are installed. The error messages in the console can be a great help in troubleshooting, so pay close attention to them. Running your Node.js script is like starting the engine of your temperature-sensing machine. It brings your code to life and allows your Pi to interact with the outside world. With the script running smoothly, you're ready to connect to it from your mobile app and start receiving those valuable temperature readings. So, let's move on to the final piece of the puzzle and explore how to make that connection!

Connecting with a Mobile App

To connect to your RPi 3 from a mobile app, you'll need a BLE scanner app. There are many free apps available on both the App Store (iOS) and the Google Play Store (Android). Some popular choices include nRF Connect, LightBlue, and BLE Scanner. Install one of these apps on your mobile device. Once installed, open the app and start scanning for Bluetooth devices. You should see your device listed as temperature_sensor. Select it to connect. After connecting, you'll see the services and characteristics advertised by the device. Look for the service with the UUID '1234' and the characteristic with the UUID 'abcd'. You can then subscribe to the characteristic to receive notifications whenever the temperature value changes. The specific steps for connecting and subscribing may vary slightly depending on the app you're using, but the general process is the same. These mobile apps act as a window into the BLE world, allowing you to discover and interact with devices like your Raspberry Pi. They provide a user-friendly interface for connecting, exploring services, and reading data. With a mobile app connected to your Pi, you can finally see the fruits of your labor. The temperature readings will be displayed on your screen, bringing your IoT project to life. So, take a moment to celebrate this milestone. You've successfully built a BLE temperature sensor using a Raspberry Pi and Node.js! But the journey doesn't end here. There's always more to learn and explore in the exciting world of IoT.

Even with the best guides, you might run into some bumps along the road. Let's cover some common issues and how to troubleshoot them:

Problem: noble fails to install.
- Solution: Make sure you have the Bluetooth development libraries installed (sudo apt-get install bluetooth bluez libbluetooth-dev libudev-dev) and try installing noble with the --unsafe-perm flag (sudo npm install noble --unsafe-perm).
Problem: The RPi 3 is not advertising.
- Solution: Double-check that Bluetooth is enabled (sudo bluetoothctl -> power on). Also, ensure your Node.js script is running with sudo.
Problem: Mobile app cannot connect to the RPi 3.
- Solution: Make sure your mobile device has Bluetooth enabled and is within range of the RPi 3. Also, verify that the service and characteristic UUIDs in your code match those you're searching for in the app.

So, there you have it! You've successfully built a BLE temperature sensor using a Raspberry Pi 3 and Node.js. This is a fantastic project that demonstrates the power of IoT and the ease with which you can connect devices and collect data. But this is just the beginning! You can expand this project in countless ways. You could connect a real temperature sensor to your Pi, store the data in a database, or build a web dashboard to visualize the readings. The possibilities are endless! I hope this guide has been helpful and has inspired you to explore the exciting world of IoT. Remember, the key to success is to keep learning, keep experimenting, and never be afraid to ask questions. The IoT community is full of passionate and knowledgeable people who are always willing to help. So, go forth and build amazing things! And most importantly, have fun along the way. The journey of creating something new is just as rewarding as the final product. So, embrace the challenges, celebrate the successes, and keep pushing the boundaries of what's possible. Happy coding, guys! And who knows, maybe your next project will change the world!