Merge branch 'master' of https://git.unsigned.io/markqvist/RNode_Firmware

Console/build.py

@@ -4,6 +4,7 @@ import sys
 import shutil
 
 packages = {
+    # "rnspure": "rnspure-0.4.6-py3-none-any.whl",
     "rns": "rns-0.4.6-py3-none-any.whl",
     "nomadnet": "nomadnet-0.3.1-py3-none-any.whl",
     "lxmf": "lxmf-0.2.8-py3-none-any.whl",
@@ -149,7 +150,7 @@ def generate_html(f, root_path):
         print("Found topic: "+str(topic)+", rt "+str(rt))
         md = md.replace(rt, tl)
 
-    menu_html = markdown.markdown(menu_md.replace("{CONTENT_PATH}", root_path), extensions=["markdown.extensions.fenced_code"]).replace("<p></p>", "")
+    menu_html = markdown.markdown(menu_md.replace("{CONTENT_PATH}", root_path), extensions=["markdown.extensions.fenced_code", "sane_lists"]).replace("<p></p>", "")
     page_html = markdown.markdown(md, extensions=["markdown.extensions.fenced_code"]).replace("{ASSET_PATH}", root_path)
     page_html = page_html.replace("{LXMF_ADDRESS}", LXMF_ADDRESS)
     for pkg_name in packages:
@@ -355,4 +356,4 @@ if not "--no-gz" in sys.argv:
     gz_all()
 
 if not "--no-remap" in sys.argv:
-    remap_names()
+    remap_names()

Console/source/builds/ap.md

@@ -0,0 +1,7 @@
+[date]: <> (2023-01-12)
+[title]: <> (Outdoor AP RNode)
+[image]: <> (gfx/ph.png)
+[excerpt]: <> (An outdoor-mountable RNode suitable for Access Point or network backbone operation. Also supports high-capacity batteries and solar charging.)
+<div class="article_date">{DATE}</div>
+## Outdoor AP RNode
+This build recipe will be released soon. Please [support the project]({ASSET_PATH}contribute.html) to help realise it!

Console/source/builds/handheld.md

@@ -0,0 +1,54 @@
+[date]: <> (2023-01-14)
+[title]: <> (Handheld RNode)
+[image]: <> (gfx/rnode_iso.png)
+[excerpt]: <> (This RNode is suitable for mobile and handheld operation, and offers both wireless and wired connectivity to host devices. A good all-round unit. It is also suitable for permanent installation indoors.)
+<div class="article_date">{DATE}</div>
+## Handheld RNode Recipe
+This build recipe will help you create an RNode that is suitable for mobile and handheld operation, and offers both wireless and wired connectivity to host devices. It is also useful for permanent installation indoors, or even outdoors, as long as it is protected from water ingress and direct sunlight.
+
+**Table of Contents**
+
+1. [Preparation](#prep)
+2. [Supported Board](#devboard)
+3. [Materials](#materials)
+4. [Print Parts](#parts)
+5. [Install Tools](#tools)
+6. [Firmware Setup](#firmware)
+7. [Assembly](#assembly)
+
+
+### <a name="prep"></a>Step 1: Preparation
+To complete this build recipe, you will need access to the following items:
+
+- A computer with a functional operating system, such as Linux, BSD or macOS
+- One of the [supported development boards](#devboard) for this recipe
+- A suitable USB cable for connecting the development board to your computer
+- A 3D printer and the necessary amount of material for printing the [device parts](#parts)
+- 6 pieces of M2x6mm screws to assemble the case
+- A suitable [antenna](#antenna)
+- An optional [battery](#battery)
+
+### <a name="devboard"></a>Step 2: Supported Development Boards
+
+Lorem
+
+### <a name="materials"></a>Step 3: Materials
+
+Lorem
+
+### <a name="parts"></a>Step 4: 3D Print Parts
+
+Lorem
+
+### <a name="tools"></a>Step 5: Install Tools
+
+Lorem
+
+### <a name="firmware"></a>Step 6: Firmware Setup
+
+Lorem
+
+### <a name="assembly"></a>Step 7: Assembly
+
+Lorem
+

Console/source/guides/install_firmware.md

@@ -0,0 +1,99 @@
+[date]: <> (2022-01-25)
+[title]: <> (Installing RNode Firmware on Supported Devices)
+[image]: <> (images/a801c7a0-b75b-48c5-8ce7-8cb07012fc96-400x275.jpg)
+[excerpt]: <> (If you have a T-Beam or LoRa32 device handy, it is very easy to get it set up for all the things that the RNode firmware allows you to do.)
+<div class="article_date">{DATE}</div>
+# Installing RNode Firmware on Supported Devices
+
+Do you have one of the devices available that the RNode Firmware supports? In that case, it is very easy to turn it into a working RNode by using the `rnodeconf` autoinstaller.
+
+With the firmware installed, you can use your newly created RNode as:
+
+- A [LoRa interface for Reticulum](https://markqvist.github.io/Reticulum/manual/interfaces.html#rnode-lora-interface)
+- A LoRa packet sniffer with [LoRaMon](https://unsigned.io/loramon/)
+- A Linux network interface using the [tncattach program](https://unsigned.io/tncattach/)
+- 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.
+
+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**.
+
+![Compatible LoRa devices]({ASSET_PATH}images/a801c7a0-b75b-48c5-8ce7-8cb07012fc96-1024x768.jpg)
+*Some of the device types compatible with this installation guide*
+
+## Device Variations
+
+Some devices come with transceiver chips that are currently unsupported by the RNode Firmware. Currently devices with an **SX1276** or **SX1278** chip are supported. Support for **SX1262**, **SX1268** and **SX1280** is being added. Please support the development with [donations]({ASSET_PATH}donate.html), if you would like to see these chips supported.
+
+> **Beware!** Some devices, like the T-Beam, use SiLabs USB chips. These may need [additional drivers](https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers) to work well on macOS and Windows. Linux usually has up-to-date drivers pre-installed. The SiLabs driver may also experience conflicts with earlier, pre-installed versions of the driver, causing a *resource busy* error, which can be fixed by [removing the old driver](https://community.platformio.org/t/mac-usb-port-detected-but-won-t-upload/20663/2).
+
+## Preparations
+
+To get started, you will need to download at least version 2.1.0 of the [RNode Configuration Utility](https://unsigned.io/rnodeconf). 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).
+
+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:
+
+## Install The Firmware
+
+```txt
+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.
+
+If the install goes well, you will be greated with a success message telling you that your device is now ready.
+
+## Verify Installation
+To confirm everything is OK, you can query the device info with:
+
+```txt
+rnodeconf --info /dev/ttyUSB0
+```
+
+Remember to replace `/dev/ttyUSB0` with the actual port the installer used in the previous step. You should now see `rnodeconf` connect to your device and show something like this:
+
+```txt
+[20:11:22] Opening serial port /dev/ttyUSB0...
+[20:11:25] Device connected
+[20:11:25] Current firmware version: 1.26
+[20:11:25] Reading EEPROM...
+[20:11:25] EEPROM checksum correct
+[20:11:25] Device signature validated
+[20:11:25]
+[20:11:25] Device info:
+[20:11:25]   Product            : LilyGO LoRa32 v2.0 850 - 950 MHz (b0:b8:36)
+[20:11:25]   Device signature   : Validated - Local signature
+[20:11:25]   Firmware version   : 1.26
+[20:11:25]   Hardware revision  : 1
+[20:11:25]   Serial number      : 00:00:00:02
+[20:11:25]   Frequency range    : 850.0 MHz - 950.0 MHz
+[20:11:25]   Max TX power       : 17 dBm
+[20:11:25]   Manufactured       : 2022-01-27 20:10:32
+[20:11:25]   Device mode        : Normal (host-controlled)
+```
+
+On the hardware side, you should see the status LED flashing briefly approximately every 2 seconds. If all of the above checks out, congratulations! Your RNode is now ready to use. If your device has a display, it should also come alive and show you various information related to the device state.
+
+If you want to use it with [Reticulum](https://reticulum.network), [Nomad Network](https://unsigned.io/nomadnet), [LoRaMon](https://unsigned.io/loramon), or other such applications, leave it in the default `Normal (host-controlled)` mode.
+
+If you want to use it with legacy amateur radio applications that work with KISS TNCs, you should [set it up in TNC mode](https://unsigned.io/using-an-rnode-with-amateur-radio-software/).
+
+## External Display & LEDs
+If you are using a **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**
+- Connect display **Vin** to suitable power-supplying pin on the T-Beam
+- Connect display **RST** to T-Beam **Pin 13**
+- Connect display **I2C CLK** to T-Beam **SCL** / **Pin 22**
+- Connect display **I2C DATA** to T-Beam **SDA** / **Pin 21**
+
+On **T-Beam** devices, you can also connect external RX/TX LEDs to **Pin 2** and **Pin 4**.

Console/source/guides/make_rnodes.md

@@ -0,0 +1,113 @@
+[date]: <> (2022-01-26)
+[title]: <> (How To Make Your Own RNodes)
+[image]: <> (images/e4261dcb-49e5-4cd3-856e-c44fb7522b32-400x275.jpg)
+[excerpt]: <> (This article will outline the general process, and provide the information you need, for building your own RNode from a few basic modules. The RNode will be functionally identical to a commercially purchased board.)
+<div class="article_date">{DATE}</div>
+# How To Make Your Own RNodes
+
+This article will outline the general process, and provide the information you need, for building your own RNode from a few basic modules. The RNode will be functionally identical to a purchased device.
+
+Once you have learned the put together a custom RNode with your own choice of components, you can use these skills to create your own RNode designs from scratch, using either a custom-designed PCB, or simply by mounting your choice of modules in a enclosure or case.
+
+If you haven't already, you migh also want to check out how to [install the RNode firmware directly on pre-made LoRa development boards](https://unsigned.io/installing-rnode-firmware-on-supported-devices/).
+
+![A Homemade RNode]({ASSET_PATH}images/e4261dcb-49e5-4cd3-856e-c44fb7522b32-1024x768.jpg)
+*A homemade RNode, based on an ESP32 board and a transceiver module, ready for use*
+
+Since there is not *one right way* to cut this pie, this article will probably not give the *exact* steps for the combination of components you choose, but will instead attempt to provide you with the information you need to build RNodes from a wide variety of microcontroller boards and LoRa modules. Generally speaking, you will need three things to construct a working RNode:
+
+- A supported microcontroller board
+- A supported transceiver module
+- A way to mount and connect the two
+
+## Preparing the Hardware
+
+Currently, the RNode firmware supports a variety of different microcontrollers, and more are being added regurlarly. That means that there is a *lot* of boards to choose from. You can probably use most boards that are based on either the **ATmega1284P**, **ATmega2560** or **ESP32** microcontrollers. Regarding microcontroller boards there is a few key points to take note of:
+
+- You will need to connect the transceiver module over the SPI bus. This means that the board should have SPI pins for exposed for you to connect to. UART-only modules will **not** work.
+- Logic voltage levels must match the transceiver module you are using, or you will have to add a voltage level converter in between the two devices, that is fast enough for the clock of the SPI bus (usually 8 or 10MHz). I recommend using a microcontroller and transceiver module with matching logic levels. Most will be 3.3 volts.
+- Apart from the SPI pins for *clock*, *chip select*, *MOSI* and *MISO*, you will also need an output pin for a *reset* line to the transceiver module, and one **interrupt-capable** input pin for the interrupt signal from the transceiver module. Almost all boards should have plenty of IO available for this, but you might as well make sure before ordering anything.
+- You need to choose a board that can provide enough power on it's internal regulators to power the transceiver module while it is transmitting. This can draw quite a bit of power, and some boards only have very small 3.3v regulators, which will not cut it while driving the transmitter at full tilt.
+
+Regarding the LoRa transceiver module, there is going to be an almost overwhelming amount of options to choose from. To narrow it down, here are the essential characteristics to look for:
+
+- The RNode firmware needs a module based on the **Semtech SX1276** or **Semtech SX1278** LoRa transceiver IC. These come in several different variants, for all frequency bands from about 150 MHz to about 1100 MHz.
+- Support for **SX1262**, **SX1268** and **SX1280**-based modules is coming soon, but until that is released, only **SX1276** and **SX1278** modules will work.
+- The module *must* expose the direct SPI bus to the transceiver chip. UART based modules that add their own communications layer will not work.
+- The module must also expose the *reset* line of the chip, and provide the **DIO0** interrupt signal *from* the chip.
+- As mentioned above, the module must be logic-level compatible with the microcontroller you are using, unless you want to add a level-shifter. Resistor divider arrays will most likely not work here, due to the bus speeds required.
+
+Keeping those things in mind, you should be able to select a suitable combination of microcontroller board and transceiver module.
+
+## Assembling the RNode
+
+Ok, having gone through the endless combinations and selected a board and a module, you are actually almost done. Connecting the devices together is pretty simple, and should only take a few minutes. I recommend that you place both devices in a solderless breadboard initially, to make sure everything is working as expected. Once you have a working setup, you can make it more durable and permanent by soldering it to a prototyping board, and connecting permanent lines between the devices.
+
+In the photo above I used an Adafruit Feather ESP32 board and a ModTronix inAir4 module. That will result in an RNode suitable for the 420 MHz to 520 MHz range. To complete the device I did the following:
+
+1. Connect the GND pin of the microcontroller board to the GND rail of the breadboard.
+2. Connect the GND pin of the transceiver module to the GND rail of the breadboard.
+3. Connect the 3.3 volt output line of the microcontroller board to the V_IN pin of the transceiver module.
+4. Connect the *chip select* pin of the microcontroller board to the *chip select* pin of the transceiver module.
+5. Connect the *SPI clock* pin of the microcontroller board to the *SPI clock* pin of the transceiver module.
+6. Connect the *MOSI* pin of microcontroller board to the *MOSI* pin of the transceiver module.
+7. Connect the *MISO* pin of the microcontroller board to the *MISO* pin of the transceiver module.
+8. Connect the *transceiver reset* pin of the microcontroller board to the *reset* pin of the transceiver module.
+9. Connect the *DIO0* pin of the transceiver module to the *DIO0 interrupt pin* of the microcontroller board.
+10. You can optionally connect transmit and receiver LEDs to the corresponding pins of the microcontroller board.
+
+The pin layouts of your transceiver module and microcontroller board will vary, but you can look up the correct pin assignments for your processor type and board layout in the [Config.h](https://github.com/markqvist/RNode_Firmware/blob/master/Config.h) file of the [RNode Firmware](https://unsigned.io/rnode_firmware).
+
+## Loading the Firmware
+Once the hardware is assembled, you are ready to load the firmware onto the board and configure the configuration parameters in the boards EEPROM. Luckily, this process is completely automated by the [RNode Configuration Utility](https://markqvist.github.io/Reticulum/manual/using.html#the-rnodeconf-utility). To prepare for loading the firmware, make sure that `python` and `pip` is installed on your system, then install the `rns` package (which includes the `rnodeconf` program) by issuing the command:
+
+
+```txt
+pip install rns
+```
+
+If installation goes well, you can now move on to the next step.
+
+> *Take Care*: A LoRa transceiver module **must** be connected to the board for the firmware to start and accept commands. If the firmware does not verify that the correct transceiver is available on the SPI bus, execution is stopped, and the board will not accept commands. If you find the board unresponsive after installing the firmware, or EEPROM configuration fails, double-check your transceiver module wiring!
+
+Having double-checked that everything is connected correctly, it is time to power up the board and install the firmware. Run the `rnodeconf` autoinstaller by executing the command:
+
+```txt
+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.
+
+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
+rnodeconf --info /dev/ttyUSB0
+```
+
+Remember to replace `/dev/ttyUSB0` with the actual port the installer used in the previous step. You should now see `rnodeconf` connect to your device and show something like this:
+
+```txt
+[2022-01-27 20:11:22] Opening serial port /dev/ttyUSB0...
+[2022-01-27 20:11:25] Device connected
+[2022-01-27 20:11:25] Current firmware version: 1.26
+[2022-01-27 20:11:25] Reading EEPROM...
+[2022-01-27 20:11:25] EEPROM checksum correct
+[2022-01-27 20:11:25] Device signature validated
+[2022-01-27 20:11:25]
+[2022-01-27 20:11:25] Device info:
+[2022-01-27 20:11:25]   Product            : LilyGO LoRa32 v2.0 850 - 950 MHz (b0:b8:36)
+[2022-01-27 20:11:25]   Device signature   : Validated - Local signature
+[2022-01-27 20:11:25]   Firmware version   : 1.26
+[2022-01-27 20:11:25]   Hardware revision  : 1
+[2022-01-27 20:11:25]   Serial number      : 00:00:00:02
+[2022-01-27 20:11:25]   Frequency range    : 850.0 MHz - 950.0 MHz
+[2022-01-27 20:11:25]   Max TX power       : 17 dBm
+[2022-01-27 20:11:25]   Manufactured       : 2022-01-27 20:10:32
+[2022-01-27 20:11:25]   Device mode        : Normal (host-controlled)
+```
+
+On the hardware side, you should see the status LED flashing briefly approximately every 2 seconds. If all of the above checks out, congratulations! Your RNode is now ready to use.
+
+If you want to use it with [Reticulum]({ASSET_PATH}s_rns.html), [Nomad Network]({ASSET_PATH}s_nn.html), [LoRaMon](https://unsigned.io/loramon), or other such applications, leave it in the default `Normal (host-controlled)` mode.
+
+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).

Console/source/guides/tnc_mode.md

@@ -0,0 +1,28 @@
+[date]: <> (2020-05-03)
+[title]: <> (Using RNodes With Amateur Radio Software)
+[image]: <> (images/xastir2-e1643321757361-400x275.jpg)
+[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
+
+If you want to use an [RNode](https://unsigned.io/rnode/) with amateur radio applications, like [APRS](https://unsigned.io/aprs-over-lora-with-rnode/) 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.
+
+Whether you RNode is [bought from my shop](https://unsigned.io/shop/product/rnode/), [made from a compatible LoRa board](https://unsigned.io/installing-rnode-firmware-on-supported-devices/) or [built by yourself](https://unsigned.io/how-to-make-your-own-rnodes/), you can use the [RNode Configuration Utility](https://unsigned.io/rnodeconf) to change settings on your device, including putting it into TNC mode.
+
+The easiest way to install `rnodeconf` on your system is by installing the `rns` package using `pip`. You probably already have `python` and `pip` installed if you use a relatively recent version of Linux or macOS. If not, go and install Python 3 now. When that is done, you can simply install `rnodeconf` by opening up a terminal and typing:
+
+```
+pip install rns
+```
+
+After a few seconds, the program should be installed and ready to use. If this is the very first time you are installing something with `pip`, you might need to close your terminal and open it again, or in some cases restart your computer, before the `rnodeconf` command becomes available.
+
+With the `rnodeconf` program installed, you can put your RNode into TNC mode simply by entering the command:
+
+```
+rnodeconf -T /dev/ttyUSB0
+```
+
+Remember to replace `/dev/ttyUSB0` with the actual port your RNode is connected to. The program will now ask you for the channel configuration parameters, like frequency, bandwidth, transmission power and so on. It is also possible to specify all the parameters at once on the command line, see the `rnodeconf --help` for information on how to do this.
+
+That's all there is to it! Your RNode is now configured in TNC mode, and ready for use with amateur radio applications.

Console/source/recipes.md

@@ -0,0 +1,5 @@
+[title]: <> (RNode Recipes)
+## RNode Build Recipes
+This section contains a library of build recipes for various types of RNodes, along with accessories and useful extras. All the recipes contain necessary plans, instructions and 3D-printable files for completing the build.
+
+{TOPIC:builds}

Console/source/replicate.md

@@ -1,3 +1,24 @@
 [title]: <> (Replicate)
 ## Create RNodes
-This section contains the tools and guides necessary to create more RNodes.
+This section contains the tools and guides necessary to create more RNodes. Creating any number of RNodes is **completely free and unrestricted** for all personal, non-commercial and humanitarian purposes. If doing so provides value to you or your community, you are encouraged to [contribute](./contribute.html) whatever you find to be reasonable.
+
+In addition, you are very much **encouraged** to create RNodes for sale or commercial purposes, and doing so requires buying a copy of the RNode Firmware for each unit produced for commercial purposes. Please read the [selling RNodes]({ASSET_PATH}sell_rnodes.html) section for more details.
+
+### Getting Started
+To create your own RNodes, there are generally three distinct paths you can take:
+
+- The first, and easiest option, is to [create a basic RNode]({ASSET_PATH}guides/install_firmware.html) from one of the supported development boards. This option allows you to simply acquire a board from any online or local vendor that sells them, and then use the `rnodeconf` program to automatically turn it into an RNode. Such an RNode will be functionally equivalent to the other options, but might lack some niceties.
+- The second option is to use one of the [RNode Build Recipes]({ASSET_PATH}recipes.html) included here. These recipes contain all the resources needed to build a specific type of RNode, such as a handheld device, or an outdoor-mountable, solar-powered access point.
+- The third option is to [create your own RNode design]({ASSET_PATH}guides/make_rnodes.html) from scratch. This offers unlimited flexibility, but is a bit more involved.
+
+If you already have some experience with 3D-printing and electronics projects, the recommended path is to pick a [build recipe]({ASSET_PATH}recipes.html) for the RNode type you want. That way, you will get a neat and portable unit that's ready for real-world use.
+
+If you are just getting started, it might be nice to get a working "proof-of-concept" with minimal effort first, though. In such a case, [creating a basic RNode]({ASSET_PATH}guides/install_firmware.html) is a good starting point.
+<br/><br/>
+<center>
+<h3>Choose a path to get started</h3>
+<br/>
+<a href="{ASSET_PATH}guides/install_firmware.html"><button type="button" id="task-rns">Basic Build</button></a>
+<a href="{ASSET_PATH}recipes.html"><button type="button" id="task-rns">Build Recipes</button></a>
+<a href="{ASSET_PATH}guides/make_rnodes.html"><button type="button" id="task-rns">New Design</button></a>
+</center>

Console/source/s_lxmf.md

@@ -10,15 +10,14 @@ Installing this LXMF library allows other programs on your system, like Nomad Ne
 
 If you do not have access to the Internet, or would prefer to install LXMF directly from this RNode, you can use the following instructions.
 
+- If you do not have an Internet connection while installing make sure to install the [Reticulum](./s_rns.html) package first
 - Download the [{PKG_BASE_lxmf}]({ASSET_PATH}{PKG_lxmf}) package from this RNode and unzip it
 - Install it with the command `pip install ./{PKG_NAME_lxmf}`
 - Verify the installed Reticulum version by running `lxmd --version`
 
-If you do not have an Internet connection while installing make sure to install the [Reticulum](./s_rns.html) package first.
-
 **Online Installation**
 
 If you are connected to the Internet, you can try to install the latest version of LXMF via the `pip` package manager.
 
 - Install Nomad Network by running the command `pip install lxmf`
-- Verify the installed Reticulum version by running `lxmd --version`
+- Verify the installed Reticulum version by running `lxmd --version`

Console/source/s_nn.md

@@ -14,15 +14,14 @@ Nomad Network does not need any connections to the public internet to work. In f
 
 If you do not have access to the Internet, or would prefer to install Nomad Network directly from this RNode, you can use the following instructions.
 
+- If you do not have an Internet connection while installing make sure to install the [Reticulum](./s_rns.html) and [LXMF](./s_lxmf.html) packages first
 - Download the [{PKG_BASE_nomadnet}]({ASSET_PATH}{PKG_nomadnet}) package from this RNode and unzip it
 - Install it with the command `pip install ./{PKG_NAME_nomadnet}`
 - Verify the installed Reticulum version by running `nomadnet --version`
 
-If you do not have an Internet connection while installing make sure to install the [Reticulum](./s_rns.html) and [LXMF](./s_lxmf.html) packages first.
-
 ### Online Installation
 
 If you are connected to the Internet, you can try to install the latest version of Nomad Network via the `pip` package manager.
 
 - Install Nomad Network by running the command `pip install nomadnet`
-- Verify the installed Reticulum version by running `nomadnet --version`
+- Verify the installed Reticulum version by running `nomadnet --version`

Console/source/s_rns.md

@@ -1,9 +1,11 @@
 [title]: <> (Reticulum)
 ## Reticulum
-The cryptographic networking stack for building resilient networks anywhere. This packages requires you have `python` and `pip` installed on your computer. This should come as standard on most operating systems released since 2020.
+The cryptographic networking stack for building resilient networks anywhere. The vision of Reticulum is to allow anyone to operate their own sovereign communication networks, and to make it cheap and easy to cover vast areas with a myriad of independent, interconnectable and autonomous networks. Reticulum is Unstoppable Networks for The People.
 
 <p align="center"><img width="30%" src="{ASSET_PATH}m/_static/rns_logo_512.png"></p>
 
+This packages requires you have `python` and `pip` installed on your computer. This should come as standard on most operating systems released since 2020.
+
 ### Local Installation
 If you do not have access to the Internet, or would prefer to install Reticulum directly from this RNode, you can use the following instructions.
 
@@ -18,4 +20,14 @@ If you are connected to the Internet, you can try to install the latest version
 - Verify the installed Reticulum version by running `rnstatus --version`
 
 ### Dependencies
-If the installation has problems resolving dependencies, you can try to install the `python-cryptography`, `python-netifaces` and `python-pyserial` packages from your systems package manager, if they are locally available. If this is not possible, you please read the [Getting Started section of the Reticulum Manual]({ASSET_PATH}m/gettingstartedfast.html) for more detailed information. Specifically the [Pure-Python Reticulum]({ASSET_PATH}m/gettingstartedfast.html#pure-python-reticulum) section may be of use.
+If the installation has problems resolving dependencies, first try installing the `python-cryptography`, `python-netifaces` and `python-pyserial` packages from your systems package manager.
+
+If this fails, or is simply not possible in your situation, you can make the installation of Reticulum ignore the resolution of dependencies using the command:
+
+`pip install --no-dependencies ./{PKG_NAME_rns}`
+
+This will allow you to install Reticulum on systems, or in circumstances, where one or more dependencies cannot be resolved. This will most likely mean that some functionality will not be available, which may be a worthwhile tradeoff in some situations.
+
+If you use this method of installation, it is essential to read the [Pure-Python Reticulum]({ASSET_PATH}m/gettingstartedfast.html#pure-python-reticulum) section of the Reticulum Manual, and to understand the potential security implications of this installation method.
+
+For more detailed information, please read the entire [Getting Started section of the Reticulum Manual]({ASSET_PATH}m/gettingstartedfast.html).