DEV Community: Marc Pous

Choosing Pre-Built Docker Images and Custom Containers for NVIDIA Jetson Edge AI Devices

Marc Pous — Wed, 11 Dec 2024 13:13:17 +0000

When planning an edge AI project on NVIDIA Jetson devices, one of the key decisions you will face is whether to use pre-built Docker images or create your own custom containers. This choice significantly impacts your project's security and efficiency.

If you would like to read more about this, go to the balena blogpost.

Pre-Built Docker Images

Pre-built images, such as those found on Docker Hub, offer simplicity and reliability, often including the latest updates and optimizations from their developers. These images are particularly useful for quick development and experimentation, providing all necessary dependencies for NVIDIA frameworks such as TensorFlow or PyTorch.

However, pre-built images can also introduce challenges. They are often generalized for broad use cases, which can result in bloated containers with unnecessary components, increasing their size and bandwidth demands. Additionally, pre-built images may lack specific libraries or configurations required for complex, customized AI applications, making them less suitable for production environments.

Custom Docker Containers

For developers aiming for maximum control and efficiency, creating custom Docker containers is often the better choice. Custom containers allow you to tailor the image to your specific needs, reducing size and improving performance. By building only what you need, you ensure your containers are lean and optimized for the constraints of edge devices, which is especially important for more resource-constrained environments than cloud solutions.

Building your own images also allows seamless integration with CI/CD pipelines, ensuring consistent updates and deployment. While the process requires more effort, including maintaining Dockerfiles and managing dependencies, the resulting containers can be perfectly suited to your project’s requirements. For example, an application leveraging TensorRT or CUDA on NVIDIA Jetson devices can be finely tuned to achieve optimal performance.

Practical Tips for Optimizing Docker Images

Regardless of your approach, there are best practices to optimize your Docker images. Multistage builds, for example, help minimize container size by including only the necessary components in the final image. Leveraging lightweight base images like Alpine for minimal size or Ubuntu for a balance of size and functionality can further streamline your containers. Exploring the construction of official images, using tools like docker history or referencing open Dockerfiles can provide valuable insights when creating custom images.

Learn to streamline Edge AI Deployments

Balena simplifies the complexities of managing Docker containers on edge devices, such as NVIDIA Jetson devices. With balenaCloud and balenaEngine, developers can enjoy features specifically designed for edge AI deployments, such as true container deltas for bandwidth-efficient updates and minimal storage wear-and-tear.

These features are critical for maintaining large fleets of NVIDIA Jetson devices where frequent updates and optimizations are necessary. Some examples of frequent updates and optimizations might be related with AI model optimizations and updates, but also hostOS updates for security.

Balena’s platform also supports seamless management of custom and pre-built containers, enabling developers to transition between the two approaches as their project evolves. For instance, starting with pre-built images for quick prototyping and later moving to custom-built containers for production-grade performance can be achieved without friction, thanks to balena’s robust container runtime and fleet management capabilities.

For NVIDIA Jetson projects, selecting the appropriate base image—whether TensorFlow, Deepstream or PyTorch—ensures compatibility and performance. Combining these practices with balena's features creates an efficient workflow for managing edge AI applications.

For developers ready to explore further, balena’s robust ecosystem provides everything needed to design, deploy and manage containerized applications at scale. Check out the balena's Getting Started resources or reach out in the balena forums to get started with your NVIDIA Jetson edge AI journey today.

Connect Modbus Serial Sensor XY-MD02 to n3uron IIoT platform with balena

Marc Pous — Fri, 21 Apr 2023 16:59:49 +0000

In this blogpost, we are going to showcase how to connect the inexpensive Modbus Serial RTU temperature and humidity sensor, the XY-MD02.

We are going to connect the XY-MD02 to an enterprise Industrial IoT platform running on the edge of floor-plants based on N3uron running on balena.

Hardware needed

Intel NUC i7
USB stick to flash the operating system of the Intel NUC.
USB RS485 converter (for this I used the Greluma ‎‎ZL013LUM)
XY-MD02 Modbus sensor

Software needed

A free balenaCloud account. Remember: your first 10 devices are free and fully-featured.
Software to flash the Intel NUC computer. E.g. balenaEtcher

Deploy the Industrial Edge Gateway code

First of all, we are going to deploy the N3uron service along with HiveMQ and MongoDB as an Historian database on balena.

Find here the Github repository of n3uron with balena and click the blue button Deploy with balena. Follow the steps and enjoy the magic of the over-the-air updates with balena.

Open another tab and type the https:// and your local ip address (copy it from the balenaCloud dashboard). That should redirect you to the login page of n3uron in your local machine.

Access to the Modbus Data from N3uron

In my case the XY-MD02 is connected to the machine via USB with a RS-485 to USB converter. If you have a similar configuration follow the next steps.

Go to the Navigation menu, on System and click Config.

Click the Modulesand then click on the tiny blue button next to Models. And click New model.

Add a name such as Modbus. And select the Module Type as a Modbus Client. Click Save.

With this you defined a Connection Layer as a Modbus Client. Now it's time to configure the connection from N3uron to the device and specify the data it's going to collect.

On the second menu, you are going to see the Modbus module you just created but some elements (Logging and API), click on them and click the Save button.

Click on Modbus and a new menu will appear, click on the tiny blue button next to Model and create a New Channel.

In this case the XY-MD02 Modbus device is connected through the /dev/ttyUSB0.

Now go to Tagon the Explorer Menu and we will create the Temperature and Humidity tags to gather the data generated by the Modbus sensor. On of the most tricky thing is that the Modbus address to read the Temperature of the XY-MD02 is 30002 and Humidity is the 30003 and they are Int16. Have this in mind when you fill the gaps.

Afterthat you will be able to see data on the Real Time option.

I hope this will help you to configure a Modbus Serial device on N3uron using a balena gateway.

Feedback

The balena platform is all about reducing friction for fleet owners. As always, let us know if you run into any issues when following this guide or getting the Industrial IoT gateway reference architecture set up in your factory or industry plant floor.

Feel free to add a comment below or contact us on the balena forums.

Connect modbus sensor XY-MD02 to NodeRED with balena

Marc Pous — Tue, 04 Apr 2023 16:49:25 +0000

Modbus is a widely used protocol in the industrial sector for communication between devices, particularly sensors and controllers. A sensor that utilizes Modbus is the XY-MD02 sensor. This sensor measures temperature and humidity and it uses the Modbus RTU protocol. It can measure temperature from -40°C to 80°C with an accuracy of ±0.5°C and humidity from 0% to 100% relative humidity (RH) with an accuracy of ±3% RH according to their technical documentation.

One tool that can be used to integrate the XY-MD02 sensor with other systems is the Industrial edge gateway made with balena running Node-RED, among others services. Node-RED is a no code / low code programming tool that allows users to create and deploy visual applications for IoT devices. It supports various protocols, including Modbus, making it an ideal tool for creating applications that collect data from Modbus controllers and sensors. By using Node-RED along with balena, users can easily access and integrate data from the XY-MD02 sensor into the edge system, making it a valuable tool in the industrial and automation industries.

The XY-MD02 can be easily installed using a standard RS485 connection and it is compatible with most Modbus master devices, such as programmable logic controllers (PLCs) and industrial PCs. In this case, the XY-MD02 will be connected directly using a USB RS485 converter to the Industrial IoT gateway using balena.

Setting up a Modbus gateway using Node-RED and the XY-MD02 sensor is straightforward.

In conclusion, the XY-MD02 sensor is a reliable and accurate sensor that can be integrated into various systems using the Modbus protocol. By using Node-RED as a Modbus gateway, users can easily access and integrate data from the sensor into their system, making it a valuable tool in the industrial and automation industries. With the balena Industrial IoT Edge Gateway easy-to-deploy application, industrial developers can create gateways without needing to write any code, making it accessible to a wide range of users.

Hardware needed

Intel NUC i7
USB stick to flash the operating system of the Intel NUC.
USB RS485 converter (for this I used the Greluma ‎‎ZL013LUM)
XY-MD02 Modbus sensor

Software needed

A free balenaCloud account. Remember: your first 10 devices are free and fully-featured.
Software to flash the Intel NUC computer. E.g. balenaEtcher

Deploy the Industrial IoT Gateway

Deploying this application is as simple as clicking the Deploy with balena button to create a fleet on balenaCloud. Find the repository of the application here.

You can follow all the instructions to deploy the Industrial iot edge gateway from this step-by-step tutorial.

Run the XY-MD02 Modbus sensor on NodeRED

First of all, it’s important that the sensor is already connected to a USB port of your Intel NUC once you power up the device.

At this moment, go to NodeRED on the port 80 of your local ip address and use balena and balena as username and passwords.

Once there, you should be able to see the Modbus nodes. Select the Modbus Reader node and a Debug node.

To configure the Modbus Reader node, double click on it. Select the FC FC 4: Read Input Registers for this case on Address 1 and Quantity 2. I selected a Poll Rate every 2 seconds (feel free to change the poll rate).

Click on the Server edit button to Add new modbus-client.

Select Type as Serial. The Serial Port is /dev/ttyUSB0. The Serial type is RTU-BUFFERED and the Baud rate is 9600.

Update the Modbus read client node and click Deploy. You should see the Modbus Reader node connected and active.

Parse the data

To parse the data coming from the XY-MD02 modbus sensor we will add a function that will get the data coming from the array resulting from reading the modbus data, and we will divide by 10 the number.

The temperature is in celsius degrees and the humidity is in %. This is just an example to encode the temperature and humidity.

Troubleshooting

In case this is not existing go to balenaCloud, open the terminal on HostOS and type ls /dev/ttyUSB* and check what you see as a result.

If you don’t see any ttyUSB0 or anything else as a result, you might have a problem with the USB connection. Feel free to write to us on the balena forums to learn more about your case.

Feedback

Feel free to add a comment below or contact us on our forums.

NVIDIA Jetson AGX Orin is now compatible with balena

Marc Pous — Thu, 09 Feb 2023 13:15:27 +0000

Balena is excited to announce our official support for the NVIDIA Jetson AGX Orin

Balena is excited to announce our official support for the NVIDIA Jetson AGX Orin. Users of balenaOS can now leverage the incredible power of the Jetson AGX Orin for their edge applications. With 2048 CUDA cores, this new device shines in applications ranging from energy-efficient autonomous machines to manufacturing, logistics and retail among others.

Balena has solved the hard problems of device deployment, management and updating so you can concentrate on your applications. Now those applications can be even more powerful when they’re running on an AGX Orin powered by balenaOS.

What is the NVIDIA Jetson AGX Orin

The NVIDIA Jetson AGX Orin(TM) is the newest member of the NVIDIA Jetson devices.

Currently the NVIDIA Jetson AGX Orin runs up to 275 TOPS of AI performance with a configurable power range of 15W and 60W. That means 8 times more performance than the NVIDIA Jetson Xavier in the same form factor.

The Orin has been built with the new NVIDIA Ampere architecture with 2048 cores and 64 Tensor Cores as a GPU with a maximum of 1Ghz of GPU frequency. And as a CPU it uses a 12-core Arm Cortex A78AE 64bit. It also brings a 64GB eMMC memory and 32GB of DRAM.

A customer using the NVIDIA Jetson AGX Orin with balena

Microscopes and processing acquired images to make scientific discoveries and engineering decisions are an integral part of state of the art laboratories. Theia Scientific applies IoT solutions to problematic scientific image processing and analysis workflows in the energy, materials, and life sciences fields of Research and Development (R&D).

Many laboratories have more than one microscope and more than one type of microscope. This quantity and variety are useful for conducting a broad spectrum of experiments and capturing a wide range of images that need to be analyzed. Institutions and facilities with multiple microscopes often refer to them as “fleets”. Similarly, a collection of IoT devices is called a “fleet”. Hence, balenaCloud is one element used with the Theiascope™ platform for fleet management.

Theia Scientific with the help of Volkov Lab’s uses balenaCloud to remotely allow updates, control, and support of Theiascopes™ deployed in any laboratory worldwide.

Read more here about how Theia Scientific is currently using the newest NVIDIA Jetson AGX Orin on their fleet of microscopes. Theia Scientific and Volkov Labs, improved the Jetson AGX Orin inference speeds up to 30FPS. The Jetson AGX Orin running YOLOv5 tripled the Frames-per-Second (FPS) compared with the latest Jetson AGX Xavier.

Jetson AGX Orin balena resources

Our Getting Started with Jetson on balena Guide See examples of loading CUDA and OpenCV on various Jetson devices running balenaOS, including the AGX Orin. Learn about the variety of Jetson devices supported by balenaOS as well as an introduction to running Jetson devices in containers on balena OS.
OpenDataCam - an open source tool to quantify the world by tracking moving objects using live video analysis. It is optimized for NVIDIA Jetson boards and is now supported on the Jetson AGX Orin.
Jetson Examples - A Github repository with examples of X11 and Gstreamer packages installed on Jetson devices including the AGX Orin. You can use these examples as the basis for your own projects!
Jetson Flash - A tool for flashing balenaOS onto Jetson devices. It runs on Ubuntu or from inside a Docker container.

See our official partners page , read the documentation or try a project today and let us know what you think on Twitter, Linkedin and our Forums. For more information about the NVIDIA Jetson AGX Orin and to see more examples of their platform in action, visit the NVIDIA Orin modules website.

Backup and restore the gateway key from your Helium Hotspot

Marc Pous — Sat, 26 Feb 2022 01:06:53 +0000

If you have a Helium Hotspot it's very important to backup the gateway_key of your hotspot. If you loose this key and something happen to your SD card or secure element, you will not be able to use this hotspot anymore. In conclusion, backup your key, store it in a safe place and you will be able to restore it in the future in case it's needed.

This tutorial it's compatible with DIY Helium Hotspots and Data-Only Hotspots managed with balena.

DIY Helium Hotspots

Backup your swarm key

Open an SSH session to the "host-os"
Type this command and keep note of the (YOUR INSTANCE)_miner-data information: ls /var/lib/docker/volumes
Type this command to get a link to download the swarm key (note to replace the YOUR INSTANCE part with the container number that you got from the previous command) curl -F "file=@/var/lib/docker/volumes/(YOUR INSTANCE)_miner-data/_data/miner/swarm_key" https://file.io
Use the outputted file.io link to securely download your swarm key. The file is deleted once downloaded.

Restore your swarm key on your new hotspot

Open an SSH session to the "host-os"
Type this command and keep note of the (YOUR INSTANCE)_miner-data information: ls /var/lib/docker/volumes
Navigate to where the swarm_key is stored cd /var/lib/docker/volumes/(YOUR INSTANCE)_miner-data/_data/miner/
Remove the original swarm_key file rm swarm_key
Upload your swarm_key that you wish to restore onto file.io and do curl -LJO [FILE.IO UPLOAD LINK]
Reboot miner and you will see it restored successfully.

Helium Data-Only Hotspot

To build the Helium Data-Only Hotspot using a Raspberry Pi and balena follow these intructions

Backup your gateway_key.bin file

Open an SSH session to the "host-os" on balenaCloud Terminal.
Type this command and keep note of the (YOUR INSTANCE)_miner-storage: ls /var/lib/docker/volumes
Type this command to get a link to download the gateway key (note to replace the YOUR INSTANCE part with the container number that you got from the previous command) curl -F "file=@/var/lib/docker/volumes/(YOUR INSTANCE)_miner-storage/_data#/gateway_key.bin" https://file.io
Use the outputted file.io link to securely download your swarm key. The link only works one time.

Restore your gateway_key.bin file on your new hotspot

Open an SSH session to the "host-os" on balenaCloud Terminal.
Type this command and keep note of the (YOUR INSTANCE)_miner-storage information: ls /var/lib/docker/volumes
Navigate to where the swarm_key is stored cd /var/lib/docker/volumes/(YOUR INSTANCE)_miner-storage/_data#/
Remove the original gateway_key.bin file rm gateway_key.bin
Upload your gateway_key.bin that you wish to restore onto file.io and do curl -LJO [FILE.IO UPLOAD LINK]
Reboot miner and you will see it restored and working :)

Acknowledgements

Thank you for the inspiration made by bottxrnife and Mithun. Also give the credits to olieman.eth for the picture of the blogpost.

If you have other methods to backup and restore gateway keys, feel free to share them on the comments.

Watch the birds on your backyard with a Raspberry Pi, Edge Impulse and balena

Marc Pous — Mon, 14 Feb 2022 13:44:27 +0000

I love birds, but to be honest with you I don't have any clue about birds.

My parents installed an Amazon camera in their backyard and we started to get video streams of birds going to a bird feeder, that was awesome. However I couldn't tell my children what type of bird was on the camera. Then at the childrens' school we installed a nest for birds with sensors but we couldn't get any image when a bird was detected. And by serendipity, the balena Ambassador Mithun Das was working on a Bird Watcher project.

In this post I would like to share how you can build a Bird Watcher at home. Once you have it you will be able to watch birds eating on your bird feeder. Plus detect with a Machine Learning model running on Edge Impulse the type of the bird. Everything runs on a Raspberry Pi using balena and a camera.

Some of the goals of building a Bird Watcher are related to learning about birds around us plus experimenting with different materials to build the bird feeder. But lately as well to introduce IoT and AI to children. Cameras are not just cameras that take pictures anymore.

Requirements

Hardware

Raspberry Pi 3/4 or balenaFin
SD card in case of the RPi 3/4
Power supply and (optionally) ethernet cable
Pi Camera or USB Camera

Software

A balenaCloud account (sign up here)
An Edge Impulse account (sign up here)
balenaEtcher
Install Telegram on your mobile device

Deploy the fleet

One-click deploy using Balena Deploy

Running this project is as simple as deploying it to a balenaCloud application. You can do it in just one click by using the button below:

Follow instructions, click Add a Device and flash an SD card with that OS image dowloaded from balenaCloud. Enjoy the magic 🌟Over-The-Air🌟!

Join the balenaHub fleet

Keep it even more simple and join the BirdWatcher fleet on balenaHub.

Train your machine learning model to detect birds

First thing needed is to have your own Birds Machine Learning model made with Edge Impulse.

My recommendation is to start with Mithun’s ML model here. Clone it on your Edge Impulse free account.

If you prefer to start from scratch. Just create an Edge Impulse project and choose Images. Then select that you would like to Classify multiple objects (object detection). With this you will be able to detect the location of multiple objects in an image. For example, to detect many birds eating at the bird feeder together. Have in mind that the object detection is more compute intensive than image classification method, and it’s only available for Linux-based devices like the Raspberry Pi or Jetson Nano. Remember, on this project we are going to use the Raspberry Pi running on balena.

Data acquisition

Now it’s time to create the Training Data and the Test Data, acquiring data from the sensors. In our case, our sensor will be a camera. My recommendation is to upload pictures from birds that you know that live in your region.

In the future the best will be to train your model with pictures from the Bird Watcher device with your background, and label them on Edge Impulse.

Remember to add the correct labels to all the birds. From my experience to get a good Machine Learning model from pictures you will need dozens of pictures for each type of bird, so be patient.

Impulse Design

Next step is to create the Impulse. An impulse takes raw data (a picture in our case) and uses signal processing to extract features and then uses a learning block to classify the new data. Once the impulse is saved it’s time to check the raw data of the sample and Generate features.

When you click “Generate features” you will see the feature explorer diagram with all the samples represented on a X-Y-Z axis. This will enable you to see if the samples from the model are properly separated on the system and that means that the ML model will properly detect the birds.

Finally it’s time to click Object detection and train your Neural Network (MobileNetV2). Once you have fine-tined the training settings (number of training cycles, learning rate and validation set size), click Start Training. As a training output you will get the last training performance with a precision score and more information about the model generated.

Deploy with balena

Now you are ready to deploy your device with balena. Go to the BirdWatcher Github repository and click Deploy with balena.

If you don’t have a balenaCloud account, create a free account (you will be able to connect up to 10 devices for free) and create a fleet. The BirdWatcher project will deploy the latest release of the source code on your fleet.

Click Add a new device, configure the balenaOS (add WiFi credentials) and download it or flash directly the SD card of your Raspberry Pi using balenaEtcher.

Introduce the flashed SD card into the Raspberry Pi and power it up. You should be able to see your device on your fleet getting online and all the BirdWatcher services getting released.

Open your birdwatcher.local website

Once you see the device online and ready on balenaCloud. Check that your laptop / mobile device is connected to the same WiFi as your Bird Watcher. Type into your browser http://birdwatcher.local.

On the local UI, you will be able to see the stream from the camera on the BirdWatcher.

Watched birds

Click on Snaps to see all the "watched" birds plus Birds detected that are unknown as we are using the camera of the Raspberry Pi as a motion sensor.

From Snaps you will be able to send pictures to Edge Impulse to retrain the ML model. The picture sent to Edge Impulse is going to be a picture without any square on it.

Settings

Go to Settings and start defining your settings as your Edge Impulse keys.

On the other hand, enable the motion flag if you want to watch the unknown birds, record the images to feed your Edge Impulse ML model to retrain it. Add Y to the ENABLE_MOTION variable.

Finally, if you would like to send the pictures and results from the ML model over Telegram, turn on the telegram notifications. Set the ENABLE_TG to Y and add the keys of your Telegram bot.

Print your Bird Feeder

Download STL files from here bird_watcher_3D_print.zip

Attributions

Thank you to Mithun Das for developing this amazing application and Edge Impulse to provide support on the balena Linux integration.

Deploy a Data Only Helium Hotspot with balena, Raspberry Pi and RAK LoRa concentrator

Marc Pous — Fri, 24 Sep 2021 09:20:29 +0000

Find here a step-by-step tutorial to build, deploy and manage a Helium data-only Hotspot using balena. Note that this is a balena version based on the Nebra helium light hotspot.

Disclaimer

This Helium Hotspot is going to transfer LoRa data to Helium OUIs BUT it's not going to perform proof-of-coverage or anything else to retrieve tokens.
Read more information about the milestones and what's possible to get here

Requirements

Hardware

Raspberry Pi 0/2/3/4 or balenaFin
SD card in case of the RPi 0/2/3/4
Power supply and (optionally) ethernet cable
LoRa concentrator (SX1302 SPI based) (e.g. RAK2287)

Software

A balenaCloud account (sign up here)
balenaEtcher

Deploy the fleet

One-click deploy using Balena Deploy

Running this project is as simple as deploying it to a balenaCloud application. You can do it in just one click by using the button below:

Follow instructions, click Add a Device and flash an SD card with that OS image dowloaded from balenaCloud. Enjoy the magic 🌟Over-The-Air🌟!

Device Variables

Once the device is online and the services packet-forwarder and gatewayrs are downloaded and installed go to Device Variables:

VARIANT: This is used to define your hardware. During the test is being used a Raspberry Pi 4 with RAK2287 LoRa concentrator and the VARIANT is defined DIY-RAK2287. You can find here the list of hardware compatible.
REGION_OVERRIDE: This is used to define your LoRa region (e.g. EU868). You can find here the list of LoRa regions compatible.

At that moment the hotspot should be running showing some errors on connecting to the Blockchain on the balenaCloud Logs.

Run the Helium Hotspot

To check that everything is running properly, go to the Terminal and select the gatewayrs service, then introduce.

helium_gateway key info

And you will get something like this:

{
  "address": <hotspot address>,
  "name": <hotspot name>
}

Join the Helium blockchain with your data-only hotspot

To join the Helium blockchain, at the moment (summer 2021) you only can use the Helium CLI. The Helium app is still not compatible with the data-only hotspots. Install the Helium CLI wallet and follow these steps:

Create a Helium wallet

Install the Helium wallet CLI or use the wallet key from your mobile application. In case that you need to create a wallet from scratch, just type and follow the instructions.

helium-wallet create basic

Then to see YOUR_WALLET of the Helium wallet type:

helium-wallet info

Add the hotspot from balenaCloud

Go to your device on balenaCloud and type on the HostOS terminal (before change YOUR_WALLET by your public Helium wallet ID):

root@d83bf778fc69:/etc/helium_gateway# helium_gateway add --owner YOUR_WALLET --payer YOUR_WALLET
{
  "address": "YOUR_ADDRESS",
  "fee": 65000,
  "mode": "dataonly",
  "owner": "YOUR_WALLET",
  "payer": "YOUR_WALLET",
  "staking fee": 1000000,
  "txn": "YOUR_TXN"
}

Remember that to confirm all the commands you will need to add --commit at the end of the command.

Then go to your computer where you installed the Helium wallet CLI software. Copy your txn from the previous JSON response and type:

MacBookPro-Marc-Pous-2827:helium-wallet-v1.6.6-x86-64-macos marcpous$ ./helium-wallet hotspots add YOUR_TXN --commit
Password: [hidden]
+-------------+-----------------------------------------------------+
| Key         | Value                                               |
+-------------+-----------------------------------------------------+
| Address     | YOUR_ADDRESS                                        |
+-------------+-----------------------------------------------------+
| Payer       | YOUR_WALLET                                         |
+-------------+-----------------------------------------------------+
| Fee         | 65000                                               |
+-------------+-----------------------------------------------------+
| Staking fee | 1000000                                             |
+-------------+-----------------------------------------------------+
| Hash        | YOUR_HASH                                           |
+-------------+-----------------------------------------------------+

You will need to have some Data Credits to be able to do this operation (1065000 DCs).

Finally you will need to assert the location of the data-only Helium hotspot. Cpy your

MacBookPro-Marc-Pous-2827:helium-wallet-v1.6.6-x86-64-macos marcpous$ ./helium-wallet hotspots assert --gateway YOUR_ADDRESS --lat=YOUR_LAT --lon=YOUR_LON --mode dataonly --commit
Password: [hidden]
+------------------+-----------------------------------------------------+
| Key              | Value                                               |
+------------------+-----------------------------------------------------+
| Address          | YOUR_ADDRESS                                        |
+------------------+-----------------------------------------------------+
| Location         | LOCATION_HASH                                       |
+------------------+-----------------------------------------------------+
| Payer            | YOUR_WALLET                                         |
+------------------+-----------------------------------------------------+
| Nonce            | 1                                                   |
+------------------+-----------------------------------------------------+
| Fee (DC)         | 55000                                               |
+------------------+-----------------------------------------------------+
| Staking Fee (DC) | 500000                                              |
+------------------+-----------------------------------------------------+
| Gain (dBi)       | 1.2                                                 |
+------------------+-----------------------------------------------------+
| Elevation        | 0                                                   |
+------------------+-----------------------------------------------------+
| Hash             | YOUR_HASH                                           |
+------------------+-----------------------------------------------------+

And now that should have worked.

Backup your gateway_key.bin file

DISCLAIMER: It's very important that at this point you backup the gateway_key of your hotspot. If you loose this key, you will not be able to use this hotspot anymore.

Follow this instructions to backup your gateway_key.bin file of your hotspot.

Open an SSH session to the "host-os" on balenaCloud Terminal.
Type this command and keep note of the (YOUR INSTANCE)_miner-storage: ls /var/lib/docker/volumes
Type this command to get a link to download the gateway key (note to replace the YOUR INSTANCE part with the container number that you got from the previous command) curl -F "file=@/var/lib/docker/volumes/(YOUR INSTANCE)_miner-storage/_data#/gateway_key.bin" https://file.io
Use the outputted file.io link to securely download your swarm key. The link only works one time.

Restore your gateway_key.bin file on your new file

Follow this instructions to restore your gateway_key.bin key into your new hotspot.

Open an SSH session to the "host-os" on balenaCloud Terminal.
Type this command and keep note of the (YOUR INSTANCE)_miner-storage information: ls /var/lib/docker/volumes
Navigate to where the swarm_key is stored cd /var/lib/docker/volumes/(YOUR INSTANCE)_miner-storage/_data#/
Remove the original gateway_key.bin file rm gateway_key.bin
Upload your gateway_key.bin that you wish to restore onto file.io and do curl -LJO [FILE.IO UPLOAD LINK]
Reboot miner and you will see it restored and working :)

Attributions

Thank you to Nebra for developing and balenifying the Helium Hotspot, Helium developers community, Travis and Joseph from balena to work on the dbus + conman issues.

Run your LoRaWAN gateway with your own The Things Stack network server on a Raspberry Pi and balena

Marc Pous — Fri, 27 Aug 2021 14:57:01 +0000

Running this project you can have all the LoRaWAN stack (Basics Station gateway + The Things Stack network server) running together on a single Raspberry Pi, LoRa concentrator and balena. Using containers on balena means that it can run alongside with other services such as the balena LoRaWAN BasicsTM Station gateway and others.

What is LoRa and LoRaWAN

I love the concept of the Low-Power Wide Area Networks (LPWAN). LPWAN enable to set up tiny sensors running with batteries far away from the base stations and still send data during a lot of time.

LoRa is a radio modulation meant for Long Range communication using very little power to send data.

LoRaWAN is a Media Acces Layer (MAC) protocol. A software layer that defines how devices use LoRa to transmit and receive messages on a network.

LoRaWAN (LoRa Wide Area Network) is an example of LPWAN. Using LoRa (Long Range) radio-frequencies, you can send tiny packages of data over long distances (even miles away depending on the topology) with simple battery-powered devices. The radio packets are captured by gateways which relay over the Internet the LoRa packages to network servers.
The Things Stack is an example of a LoRaWAN network server. The Things Stack (previously The Things Network) is being run on the The Things Industries clusters that are distributed worldwide.

Why is this Running on a Raspberry Pi instead of a cloud?

If you want to manage your own data without sharing it with any cloud provider, the data collected can’t leave your country, or other similar requirements, then the solution is to deploy The Things Stack LoRaWAN Network Server using balena on a Raspberry Pi.

If you are a professional that needs to build your ad-hoc LoRaWAN private network for tests or others, this is a great and unexpensive solution. And if you are a community or company who need a tiny private LoRaWAN network server, this could be just enough.

Some people says that a Raspberry Pi is to small for this type of job, but it has been running for weeks with good performance with tiny amount of LoRa nodes. Needs to be tested on a bigger environment. Feel free to bring your feedback here.

Hardware and Software required

Raspberry Pi 3 or 4 (or similar Compute Module carrier boards).
SD card
Power supply
LoRa concentrator (SX1301 or SX1302) (e.g. RAK 2245, RAK 2287 among others)
balenaCloud account
balena Etcher to flash the SD card.

Deploy the Basics Station gateway with The Things Stack network server

To deploy the Basics(TM) Station gateway service along TTS local network server on your Raspberry Pi, click the Deploy with balena here or go to the Github repo to click the Deploy with balena button to automatically deploy the application on balenaCloud.

Clicking the deploy button will create a fleet with all the necessary code to deploy your The Things Stack plus basicstation service.

It’s time to connect your LoRa concentrator compatible with your Raspberry Pi or balena Fin (SX1301, or SX1302 and SX1303 such as RAK2245 or RAK 2287), to run the LoRaWAN gateway running alongside with The Things Stack network server.

Remember to add or modify the variable MODEL depending on the LoRa concentrator model you have (SX1301, SX1302 or SX1303). By default is set to SX1301.

You should see something similar on balenaCloud as below:

You will notice that the services will reboot a few times, this is normal behaviour to set up all the services properly.

Register the gateway at your private The Things Stack

Copy your local IP address and paste it into the browser with https. Accept the self-signed certificate that the device has generated automatically for your local IP address. Alternatevaly feel free to use the public URL generated by balenaCloud.

Login using the credentials User ID admin and the password changeme. Feel free to change your Password after you log in.

Click Register a gateway and then Add new Gateway. Copy the EUI that the basicstation service introduces as a TAG of on the balenaCloud dashboard. Paste it as the EUI of the gateway when registering.

Now the gateway is registered and it's time to generate an API Key. Go to Add API Key, then select Link as a Gateway to a Gateway Server for traffic exchange, i.e. write uplink and red downlink. Click the button Create API key. Remember to copy the key.

Paste the key on the balenaCloud Device Variables of the device on balenaCloud as TC_KEY.

The gateway registered will be online on your private The Things Stack network server and able to receive data from your LoRa nodes.

This project involves a lot of services running together. If there is any issue not reported here, feel free to report it at the balena forums.

And remember that this project is open source, feel free to contribute to improve it.