Updated console site

Console/source/builds/handheld.md

@@ -13,7 +13,7 @@ This build recipe will help you create an RNode that is suitable for mobile and
 ### Table of Contents
 
 1. [Preparation](#prep)
-2. [Supported Board](#devboard)
+2. [Supported Boards](#devboard)
 3. [Materials](#materials)
 4. [Print Parts](#parts)
 5. [Install Tools](#tools)
@@ -48,13 +48,12 @@ You will also need to demount the OLED display from the small acrylic riser on t
 
 In addition to the board, you will need a few other components to build this RNode.
 
-- A suitable antenna. Most boards purchased online include a passable antenna, but you may want to upgrade it to a better one.
-- 6 pieces of M2x6mm screws for assembling the case. Can be bought in most hardware stores or from online vendors.
-- An optional NeoPixel RGB LED for displaying status, and TX/RX activity. If you do not want to add this, it can simply be omitted.
+- A suitable **antenna**. Most boards purchased online include a passable antenna, but you may want to upgrade it to a better one.
+- 6 pieces of **M2x6mm screws** for assembling the case. Can be bought in most hardware stores or from online vendors.
+- An optional **NeoPixel RGB LED** for displaying status, and TX/RX activity. If you do not want to add this, it can simply be omitted.
     - The easiest way is to use the PCB-mounted NeoPixel "mini-buttons" manufactured by [adafruit.com](https://www.adafruit.com/product/1612). These fit exactly into the slot in the mounting position in the 3D-printed case, and are easy to connect cables to.
-- An optional lithium-polymer battery.
-  - This RNode supports 3.7v, single-cell LiPo batteries
-  - 1.25mm JST connector
+- An optional **lithium-polymer battery**.
+    - This RNode supports **3.7v**, **single-cell** LiPo batteries with a **1.25mm JST connector**
     - The standard case can fit up to a 700mAh LP602248 battery
         - Maximum battery dimensions for this case is 50mm x 25mm x 6mm
     - There is a larger bottom casing available that fits 1100mAh batteries
@@ -62,9 +61,9 @@ In addition to the board, you will need a few other components to build this RNo
 
 ### <a name="parts"></a>Step 4: 3D Print Parts
 
-To complete the build of this RNode, you will need to 3D-print the parts for the casing. Download, extract and slice the STL files from the [parts package]({ASSET_PATH}3d/Handheld_RNode_Parts.7z) in your preffered software.
+To complete the build of this RNode, you will need to 3D-print the parts for the casing. Download, extract and slice the STL files from the [parts package]({ASSET_PATH}3d/Handheld_RNode_Parts.7z) in your preferred software.
 
-- Two of the parts should are LED light-guides, and should be printed in a semi-translucent material:
+- Two of the parts are LED light-guides, and should be printed in a semi-translucent material:
     - The `LED_Window.stl` file is a light-guide for the NeoPixel LED, mounted in the circular cutout at the top of the device.
     - The `LED_Guide.stl` file is a light-guide for the power and charging LEDs, mounted in the rectangular grove at the bottom of the device.
 - The rest of the parts can be printed in any material, but for durability and heat-resistance, PETG is recommended.
@@ -97,7 +96,7 @@ rnodeconf --autoinstall
 3. You will now be asked what device this is, select the option **A Specific Kind of RNode**.
 4. The installer will ask you what model your device is. Select the **Handheld RNode v2.x** option that matches the frequency band of your device.
 5. The installer will display a summary of your choices. If you are satisfied, confirm your selection.
-6. The installer will now automaticall install and configure the firmware and prepare the device for use.
+6. The installer will now automatically install and configure the firmware and prepare the device for use.
 
 > **Please Note!** If you are connected to the Internet while installing, the autoinstaller will automatically download any needed firmware files to a local cache before installing.
 
@@ -106,16 +105,16 @@ rnodeconf --autoinstall
 If you need to extract the firmware from an existing RNode, run the following command:
 
 ```
-rnodeconf --extract-firmware /dev/ttyUSB0
+rnodeconf --extract
 ```
 
-Remember to replace `/dev/ttyUSB0` with the port the RNode is actually connected to. If `rnodeconf` finds a working RNode on the specified port, it will extract and save the firmware from the device for later use. You can then run the auto-installer with the `--no-check` and `--fw-version`options to use the locally extracted file:
+If `rnodeconf` finds a working RNode, it will extract and save the firmware from the device for later use. You can then run the auto-installer with the `--use-extracted` option to use the locally extracted file:
 
 ```
-rnodeconf --autoinstall --no-check --fw-version 1.55
+rnodeconf --autoinstall --use-extracted
 ```
 
-Make sure to replace the version number with the one that actually matches the extracted firmware.
+This also works for updating the firmware on existing RNodes, so you can extract a newer firmware from one RNode, and deploy it onto other RNodes using the same method. Just use the `--update` option instead of `--autoinstall`.
 
 ### <a name="assembly"></a>Step 7: Assembly
 

Console/source/contact.md

@@ -1,6 +1,8 @@
 [title]: <> (Contact)
 # Contact Me
 
+**Hello!** I am the creator of the RNode ecosystem.
+
 If you have any general questions or comments about any of the projects I maintain, I encourage you to post it in one of the following places:
 
 - The [discussion forum](https://github.com/markqvist/Reticulum/discussions) on GitHub

Console/source/guides/install_firmware.md

@@ -14,7 +14,7 @@ With the firmware installed, you can use your newly created RNode as:
 - A Linux network interface using the [tncattach program]({ASSET_PATH}pkg/tncattach.zip)
 - A LoRa-based TNC for almost any amateur radio packet application
 
-So let's get started! You will need either a **LilyGO T-Beam v1.1**, a **LilyGO LoRa32 v2.0**, a **LilyGO LoRa32 v2.1** or a **Heltec LoRa32 v2** device. More supported devices are added regularly, so it might be useful to check the latest [list of supported devices](https://unsigned.io/rnode_firmware/#supported-hardware) as well.
+So let's get started! You will need either a **LilyGO T-Beam v1.1**, a **LilyGO LoRa32 v2.0**, a **LilyGO LoRa32 v2.1** or a **Heltec LoRa32 v2** device. More supported devices are added regularly, so it might be useful to check the latest [list of supported devices]({ASSET_PATH}supported.html) as well.
 
 It is currently recommended to use one of the following devices: A **LilyGO LoRa32 v2.1** (also known as **TTGO T3 v1.6.1**) or a **LilyGO T-Beam v1.1**.
 
@@ -29,20 +29,14 @@ Some devices come with transceiver chips that are currently unsupported by the R
 
 ## Preparations
 
-To get started, you will need to download at least version 2.1.0 of the [RNode Configuration Utility]({ASSET_PATH}m/using.html#the-rnodeconf-utility). The easiest way by far is to simply install it with `pip`, if you already have that installed on your system (if not, go install `python` and `python-pip` now, it will come in handy later).
+To get started, you will need to install at least version 2.1.0 of the [RNode Configuration Utility]({ASSET_PATH}m/using.html#the-rnodeconf-utility). 
 
-The `rnodeconf` program is part of the `rns` package. To install it, open up a terminal and type:
-
-```
-pip install rns
-```
-
-After a few seconds, you should have `rnodeconf` installed and ready to go. If this is the very first time you install something with `pip`, you might need to close your terminal and open it again (or in some cases even reboot your computer), for the `rnodeconf` command to become available.
-
-We are now ready to start installing the firmware. To install the RNode firmware on your devices, run the RNode autoinstaller using this command:
+The `rnodeconf` program is included in the `rns` package. Please read [these instructions]({ASSET_PATH}s_rns.html) for more information on how to install it from this repository, or from the Internet. If installation goes well, you can now move on to the next step.
 
 ## Install The Firmware
 
+We are now ready to start installing the firmware. To install the RNode Firmware on your devices, run the RNode autoinstaller using this command:
+
 ```txt
 rnodeconf --autoinstall
 ```
@@ -51,6 +45,24 @@ The installer will now ask you to insert the device you want to set up, scan for
 
 If the install goes well, you will be greated with a success message telling you that your device is now ready.
 
+> **Please Note!** If you are connected to the Internet while installing, the autoinstaller will automatically download any needed firmware files to a local cache before installing.
+
+> If you do not have an active Internet connection while installing, you can extract and use the firmware from this device instead. This will **only** work if you are building the same type of RNode as the device you are extracting from, as the firmware has to match the targeted board and hardware configuration.
+
+If you need to extract the firmware from an existing RNode, run the following command:
+
+```
+rnodeconf --extract
+```
+
+If `rnodeconf` finds a working RNode, it will extract and save the firmware from the device for later use. You can then run the auto-installer with the `--use-extracted` option to use the locally extracted file:
+
+```
+rnodeconf --autoinstall --use-extracted
+```
+
+This also works for updating the firmware on existing RNodes, so you can extract a newer firmware from one RNode, and deploy it onto other RNodes using the same method. Just use the `--update` option instead of `--autoinstall`.
+
 ## Verify Installation
 To confirm everything is OK, you can query the device info with:
 
@@ -86,8 +98,20 @@ If you want to use it with [Reticulum]({ASSET_PATH}s_rns.html), [Nomad Network](
 
 If you want to use it with legacy amateur radio applications that work with KISS TNCs, you should [set it up in TNC mode]({ASSET_PATH}guides/tnc_mode.html).
 
+## External RGB LED
+If you are using a **LilyGO LoRa32 v2.1** device, you can connect an external **NeoPixel RGB LED** for device status using the following setup:
+
+- Connect the NeoPixel **V+** pin to the **3.3v** pin on the board.
+- Connect the NeoPixel **GND** pin to the **GND** pin on the board.
+- Connect the NeoPixel **DATA** pin to **IO Pin 12** on the board.
+
+For the firmware to activate the NeoPixel LED, you must also make specific choices in the autoinstaller guide:
+
+- When asked what type of device you have, select **A specific kind of RNode**.
+- When asked what model the device is, select the **Handheld v2.x RNode** that matches the frequency of your board.
+
 ## External Display & LEDs
-If you are using a **T-Beam** device, you can connect an external **SSD1306** OLED display using the following setup:
+If you are using a **LilyGO T-Beam** device, you can connect an external **SSD1306 OLED** display using the following setup:
 
 - The **SSD1306**-based display must be set to use **I2C** and address `0x3D`
 - Connect display **GND** to T-Beam **GND**

Console/source/guides/loracomms.md

@@ -18,11 +18,11 @@ In later parts of this series, we will expand the system to provide these oppert
 
 To accomplish this, we will be building a small and simple system based on freely available and Open Source software. To realise our system we will need the following components:
 
-- A networking system that can function reliably and efficiently even without any functional Internet infrastructure available. This will be provided by [Reticulum](https://reticulum.network).
-- Software that Alice and Bob can interact with on their computers and mobile devices to actually communicate with each other. This will be provided by the programs [Nomad Network](https://unsigned.io/nomadnet) and [Sideband](https://unsigned.io/sideband).
-- Radio hardware that Reticulum can use to cover the 7 kilometer distance between Bobs apartment and Alices house. This will be provided by installing the [RNode Firmware](https://unsigned.io/rnode_firmware) on a couple of small LoRa radio modules that can be purchased cheaply off Amazon or similar online vendors.
+- A networking system that can function reliably and efficiently even without any functional Internet infrastructure available. This will be provided by [Reticulum]({ASSET_PATH}r/index.html).
+- Software that Alice and Bob can interact with on their computers and mobile devices to actually communicate with each other. This will be provided by the programs [Nomad Network]({ASSET_PATH}s_nn.html) and [Sideband]({ASSET_PATH}s_sideband.html).
+- Radio hardware that Reticulum can use to cover the 7 kilometer distance between Bobs apartment and Alices house. This will be provided by installing the [RNode Firmware]({ASSET_PATH}guides/install_firmware.html) on a couple of small LoRa radio modules that can be purchased cheaply off Amazon or similar online vendors.
 
-As you might have already guessed, the "magic glue" that acutally makes this entire system possible is [Reticulum](https://reticulum.network/).
+As you might have already guessed, the "magic glue" that acutally makes this entire system possible is [Reticulum]({ASSET_PATH}r/index.html).
 
 Reticulum is a complete networking stack that was designed to handle challenging situations and requirements like this. Reticulum is an incredibly flexible networking platform, that can use almost anything as a carrier for digital information transfer, and it can automatically form secure mesh networks with very minimal resources, infrastructure and setup.
 
@@ -33,11 +33,11 @@ The user-facing software that Alice and Bob will be installing already includes
 Let's get started.
 
 # LoRa Radio Setup
-The first step is to get the LoRa radios prepared and installed. I have written in more length and details about these subjects in other posts on this site ([Installing RNode Firmware on Supported Devices](https://unsigned.io/installing-rnode-firmware-on-supported-devices/) and [How To Make Your Own RNodes](https://unsigned.io/how-to-make-your-own-rnodes/)), so this article will just quickly guide you through the basics required to get up and running. For much more information, read the above articles.
+The first step is to get the LoRa radios prepared and installed. I have written in more length and details about these subjects in other posts on this site ([Installing RNode Firmware on Supported Devices]({ASSET_PATH}guides/install_firmware.html) and [How To Make Your Own RNodes]({ASSET_PATH}guides/make_rnodes.html), so this article will just quickly guide you through the basics required to get up and running. For much more information, read the above articles.
 
 First of all, Alice and Bob need to get a compatible piece of radio hardware to use. Had they been living closer to each other, they might have just been able to use WiFi, but they need to cover a distance of more than 7 kilometers, so they decide to go with a couple of LoRa radios.
 
-They take a look at the RNode Firmware [Supported Devices List](https://unsigned.io/rnode_firmware/#supported-hardware) , and decide to go with a couple of LilyGO T-Beam devices. They could have also used others, and they don't need to choose the same device, as long as they are within the same frequency range, all compatible devices work with Reticulum and can communicate with each other, as soon as the RNode Firmware has been installed on them.
+They take a look at the RNode Firmware [Supported Devices List]({ASSET_PATH}supported.html), and decide to go with a couple of LilyGO T-Beam devices. They could have also used others, and they don't need to choose the same device, as long as they are within the same frequency range, all compatible devices work with Reticulum and can communicate with each other, as soon as the RNode Firmware has been installed on them.
 
 ![]({ASSET_PATH}images/lora_rnodes.webp)
 
@@ -47,7 +47,7 @@ Once the devices arrive, it is time to get the firmware installed. For this they
 pip install rnodeconf
 ```
 
-The above command installs the program they need to flash the LoRa radios with the right firmware. If for some reason Python3 had not already been installed on Alices computer, she would have had to install it first with the command `sudo apt install python3 python3-pip`.
+The above command installs the program they need to flash the LoRa radios with the right firmware. If for some reason Python3 had not already been installed on Alices computer, she would have had to install it first with the command `sudo apt install python python-pip`.
 
 Now that the firmware installer is ready, it is time to actually get the firmware on to the devices. Alice launches the installer with the following command:
 
@@ -78,7 +78,7 @@ All required directories and configuration files will now be created, and the cl
 
 Confirming that everything is installed and working, it is time to add the LoRa radio as an interface that Reticulum can use. To do this, she opens up the Reticulum configuration file (located at `˜/.reticulum/config`) in a text editor.
 
-By referring to the [RNode LoRa Interface](https://markqvist.github.io/Reticulum/manual/interfaces.html#rnode-lora-interface) section of the [Reticulum Manual](https://markqvist.github.io/Reticulum/manual/), she can just copy-and-paste in a new configuration section for the interface, and edit the radio parameters to her requirements. She ends up with a configuration file that looks like this in it's entirity:
+By referring to the [RNode LoRa Interface]({ASSET_PATH}m/interfaces.html#rnode-lora-interface) section of the [Reticulum Manual]({ASSET_PATH}m), she can just copy-and-paste in a new configuration section for the interface, and edit the radio parameters to her requirements. She ends up with a configuration file that looks like this in it's entirity:
 
 ```
 [reticulum]
@@ -114,7 +114,7 @@ By referring to the [RNode LoRa Interface](https://markqvist.github.io/Reticulum
 Alice can now start the Nomad Network client again, and this time around it will initialise and use the LoRa radio installed in her attic. Having completed Alices part of the setup, lets move on to Bobs apartment.
 
 # Installation at Bobs Apartment
-Bob likes his messaging to happen on a handy device like a phone, so he decides to go with the [Sideband](https://unsigned.io/sideband) app instead of Nomad Network. He goes to the [download page](https://github.com/markqvist/Sideband/releases/latest) and installs the APK on his Android phone. He now needs a way to connect to the LoRa radio already running at Alices house to establish communication.
+Bob likes his messaging to happen on a handy device like a phone, so he decides to go with the [Sideband]({ASSET_PATH}s_sideband.html) app instead of Nomad Network. He goes to the [download page](https://github.com/markqvist/Sideband/releases/latest) and installs the APK on his Android phone. He now needs a way to connect to the LoRa radio already running at Alices house to establish communication.
 
 Since he doesn't want to walk around with the LoRa radio constantly dangling by a USB cable from his phone, he decides to set up a Reticulum gateway in his apartment using a Raspberry Pi he had lying around. The RNode LoRa radio will connect via USB to the Raspberry Pi, and the Raspberry Pi will be connected to the WiFi network in his apartment.
 
@@ -204,7 +204,7 @@ To allow other devices on his network to route through his new Reticulum gateway
 Everything is ready, and when Bob launches the Sideband appplication on his phone, Alice and him will now be able to communicate securely and independently of any other infrastructure.
 
 # Communication
-Both the [Nomad Network](https://unsigned.io/nomadnet) program and the [Sideband](https://unsigned.io/sideband) application use a cryptographic message delivery system named [LXMF](https://unsigned.io/lxmf), that in turn uses Reticulum for encryption and privacy guarantees. Both Nomad Network and Sideband are *LXMF clients*.
+Both the [Nomad Network]({ASSET_PATH}s_nn.html) program and the [Sideband]({ASSET_PATH}s_sidband.html) application use a cryptographic message delivery system named [LXMF]({ASSET_PATH}s_lxmf.html), that in turn uses Reticulum for encryption and privacy guarantees. Both Nomad Network and Sideband are *LXMF clients*.
 
 Much like many different e-mail clients exist, so can many different LXMF clients, and they can all communicate with each other, which is why Alice and Bob can message each other even though they prefer to use very different kinds of user-facing software.
 
@@ -234,4 +234,4 @@ And on Alices computer running Nomad Network, it looks like this:
 
 Although pretty useful, what we have explored here does not even begin to scratch the surface of what is possible with Reticulum and associated software. I hope you will find yourself inspired to explore and read deeper into the documentation and available software.
 
-In the next parts of this series, we will explore how to add more features to the system, such as offline message delivery, expanding the system to allow communication for a larger number of people, bridging isolated networks over both the Internet and the Invisible Internet (I2P), using Reticulum over Packet Radio, and using LoRa interfaces diretcly on Android devices.
+To learn more, take a look at the [Learn]({ASSET_PATH}learn.html) section.

Console/source/guides/make_rnodes.md

@@ -73,6 +73,24 @@ rnodeconf --autoinstall
 
 The installer will now ask you to insert the device you want to set up, scan for connected serial ports, and ask you a number of questions regarding the device. When it has the information it needs, it will install the correct firmware and configure the necessary parameters in the device EEPROM for it to function properly.
 
+> **Please Note!** If you are connected to the Internet while installing, the autoinstaller will automatically download any needed firmware files to a local cache before installing.
+
+> If you do not have an active Internet connection while installing, you can extract and use the firmware from this device instead. This will **only** work if you are building the same type of RNode as the device you are extracting from, as the firmware has to match the targeted board and hardware configuration.
+
+If you need to extract the firmware from an existing RNode, run the following command:
+
+```
+rnodeconf --extract
+```
+
+If `rnodeconf` finds a working RNode, it will extract and save the firmware from the device for later use. You can then run the auto-installer with the `--use-extracted` option to use the locally extracted file:
+
+```
+rnodeconf --autoinstall --use-extracted
+```
+
+This also works for updating the firmware on existing RNodes, so you can extract a newer firmware from one RNode, and deploy it onto other RNodes using the same method. Just use the `--update` option instead of `--autoinstall`.
+
 If the install goes well, you will be greated with a success message telling you that your device is now ready. To confirm everything is OK, you can query the device info with:
 
 ```txt

Console/source/guides/tnc_mode.md

@@ -1,9 +1,9 @@
 [date]: <> (2023-01-07)
-[title]: <> (Using RNodes With Amateur Radio Software)
+[title]: <> (Using an RNode With Amateur Radio Software)
 [image]: <> (images/g4p.webp)
 [excerpt]: <> (If you want to use an RNode with amateur radio applications, like APRS or a packet radio BBS, you will need to put the device into TNC Mode. In this mode, an RNode will behave exactly like a KISS-compatible TNC, which will make it usable with any amateur radio software.)
 <div class="article_date">{DATE}</div>
-# Using RNodes With Amateur Radio Software
+# Using an RNode With Amateur Radio Software
 
 If you want to use an RNode with amateur radio applications, like APRS or a packet radio BBS, you will need to put the device into *TNC Mode*. In this mode, an RNode will behave exactly like a KISS-compatible TNC, which will make it usable with any amateur radio software that can talk to a KISS TNC over a serial port.
 

Console/source/index.md

@@ -23,6 +23,6 @@ This repository also contains tools, software and information necessary to boots
 <a href="./learn.html"><button type="button" id="task-rns">Learn More</button></a>
 <a href="./m/networks.html"><button type="button" id="task-rns">Build A Network</button></a>
 <a href="./help.html"><button type="button" id="task-rns">Get Help</button></a>
-<a href="https://unsigned.io/shop"><button type="button" id="task-rns">Buy RNodes</button></a>
+<a href="https://unsigned.io/shop"><button type="button" id="task-rns">Buy an RNode</button></a>
 <a href="./contribute.html"><button type="button" id="task-rns">Contribute</button></a>
 </center>

Console/source/learn.md

@@ -1,11 +1,13 @@
 [title]: <> (Learn More)
 ## Learn More
-This RNode contains a selection of tutorials and guides on setting up communications, creating RNodes, building networks and using Reticulum. You can find additional information in the following sections:
+This RNode contains a selection of tutorials and guides on setting up communications, creating RNodes, building networks and using Reticulum. You can learn more by:
 
-- The [Questions & Answers](qa.html) section
-- The [Reticulum Manual](m/index.html) stored on this RNode
-- A copy of the [Reticulum Website](r/index.html) stored on this RNode
-- The [unsigned.io](https://unsigned.io/) website
+- Reading the [What is an RNode?](rnode.html) page
+- Checking the [Questions & Answers](qa.html) section
+- Reading the [Reticulum Manual](m/index.html) stored on this RNode
+- Browsing a copy of the [Reticulum Website]({ASSET_PATH}r/index.html) stored on this RNode
+- Visiting the [unsigned.io](https://unsigned.io/) website
+- You can also find **unisgned.io** on Nomad Network, at `ec58b0e430cd9628907383954feea068`
 
 ## Guides
 

Console/source/rnode.md

@@ -0,0 +1,11 @@
+[title]: <> (What is an RNode?)
+## What is an RNode?
+An RNode is an open, free and unrestricted digital radio transceiver. It enables anyone to send and receive any kind of data over both short and very long distances. RNodes can be used with many different kinds of programs and systems, but they are especially well suited for use with Reticulum.
+
+RNode is not a product, and not any one specific device in particular. It is a system that is easy to replicate across space and time, that produces highly functional communications tools, which respects user autonomy and empowers individuals and communities to protect their sovereignty and privacy.
+
+The RNode system is primarily software, which *transforms* available hardware devices into functional, physical RNodes, which can then be used to solve a wide range of communications tasks. Such RNodes can be modified and build to suit the specific time, locale and environment they need to exist in.
+
+If you notice the presence of a circularity in the naming of the system as a whole, and the physical devices, it is no coincidence. Every RNode contains the seeds necessary to reproduce the system, and create more RNodes, and even to bootstrap entire communications networks, completely independently of existing infrastructure, or the lack thereof.
+
+The production of one particular RNode device is not an end, but the potential starting point of a new branch of devices on the tree of the RNode system as a whole. This tree fits into the larger biome of Free & Open Communications Systems, which I hope that you - by using communications tools like RNode - will help grow and prosper.

Console/source/supported.md

@@ -0,0 +1,17 @@
+[title]: <> (Supported Hardware)
+## Supported Boards & Devices
+The RNode Firmware supports the following boards:
+
+- Handheld v2.x RNodes from [unsigned.io](https://unsigned.io/shop/product/handheld-rnode)
+- Original v1.x RNodes from [unsigned.io](https://unsigned.io/shop/product/rnode)
+- LilyGO T-Beam v1.1 devices
+- LilyGO LoRa32 v2.0 devices
+- LilyGO LoRa32 v2.1 devices
+- Heltec LoRa32 v2 devices
+- Homebrew RNodes based on ATmega1284p boards
+- Homebrew RNodes based on ATmega2560 boards
+- Homebrew RNodes based on Adafruit Feather ESP32 boards
+- Homebrew RNodes based on generic ESP32 boards
+
+## Supported Transceiver Modules
+The RNode Firmware supports all transceiver modules based on **Semtech SX1276** or **Semtech SX1278** chips, that have an **SPI interface** and expose the **DIO_0** interrupt pin from the chip.