This board combines an ESP32 microcontroller with an RA-01 LoRa module. It serves as an alternative to the various LoRa 32 boards already on the market. Designed in a dongle form factor, it allows developers to program it in a plug-and-play manner. This board features onboard header pins, which serve as a versatile interface for connecting and expanding its capabilities. Developers can use these pins to create custom daughterboards that enhance the functionality of the main board. Whether it’s adding sensors, communication modules, or other peripherals, these header pins enable seamless integration and flexibility. This device features an option for attaching a 0.96-inch OLED display and a Neo6m GPS module. Notably, this board supports several open-source projects:

1. Meshtastic: A project that utilizes inexpensive LoRa radios for long-range off-grid communication in areas without reliable cellular service. Whether you’re hiking, skiing, or paragliding, Meshtastic allows mesh members to send and receive text messages and even enables optional GPS-based location features. (Web Flashing tool: https://flasher.meshtastic.org/)
2. TinyGS: Another open-source initiative that extends the capabilities of this board. To configure TinyGS for this board use the below board template. (https://tinygs.com/)
3. LoRa-Based APRS: This project leverages LoRa technology for Automatic Packet Reporting System (APRS) tracking and communication. It’s an excellent fit for this board’s capabilities. (https://github.com/richonguzman/LoRa_APRS_iGate)
4. Single Channel LoRa Gateway: It's related to creating a simple LoRa gateway using this board.(https://github.com/things4u/ESP-1ch-Gateway)
5. Project Voyager: Ongoing open-source project for transmitting files over Lora. (GitHub Repo: https://github.com/aviralverma-8877/Project-Voyager, Web Flashing Tool: https://aviralverma-8877.github.io/Project-Voyager/)

In summary, this board is a powerful tool for experimenting with LoRa-based communication and mesh networking, making it an exciting choice for hobbyists and developers alike!

TinyGS Board Template:

{"name":"[433] esp32 ra01","aADDR":60,"oSDA":21,"oSCL":22,"oRST":-1,"pBut":0,"led":4,"radio":1,"lNSS":18,"lDIO0":26,"lDIO1":33,"lBUSSY":-1,"lRST":23,"lMISO":19,"lMOSI":27,"lSCK":5,"lTCXOV":1.8}

Project Voyager (Source):

This is an ongoing project with one goal in mind, i.e. enabling file transfer via LoRa modulation. One may ask what benefit that we get if we user LoRa over WiFi or Bluetooth. The answer is simple, range with low power. In order to understand how can we achive the file transfer over LoRa, we have to first understand how LoRa works and what are its limitations.

LoRa:

Though LoRa in itself is a very complicated topic, but for this project, we just need to understand that LoRa transmits signal in a bust of electromagnetic wave, which means with each transmission we have limited time and data that we can have in a single transmission. Its not like a FM transmission, where we have a continuous stream of audio transmitting from a ground station. LoRa also provides various configurations that we can configure to achieve higher range, with more accuracy. But the data that we can encode in once transmission is fixed to 256 bytes. Yes you read it correct, 256 bytes. So the question is how can we send files in 256 bytes limitation. One approach that we can use is sending the file in multiple chunks. That is what this project will do.

Approach:

We need an approach to convert a file into chunk or packets and then transmit each packet to the other LoRa node. To make the communication more robust, we will be having CRC checks and option to retry the failed packets. Since we have a ESP32 microcontroller on board, which has only 4MB of SPI flash, and 4MB of SRAM, it is impossible to upload the file first to ESP32 and then perform splitting file into chunks and transmit. So, the client machine, which may be a phone or a PC should be performing the file chunking and sending the each chunk to ESP32 in order to transmit it to near by node via LoRa. To achieve this we can use JavaScript + HTML + CSS, which will be hosted on the ESP32. This script will provide an option for file upload, and when user will select the file, JavaScript itself will spit the file in multiple chunks and feed it to ESP32 via http post requests. This upload process should be synchronized, and the next packet should only be transmitted once the previous packet is confirmed.

Code:

The source of the project is available on GitHub. The project is build in Platform IO and uses Arduino Framework. This project allows user to connect this device to home router via WiFi or use it as it is in AP mode. Most of the code is to provision this connectivity and allow user to configure LoRa module, which is pretty standard, but the main part of the project exists in script.js in file_broadcast() method.

First we ask user to select the file via file input field, and then JavaScript FileReader() webAPI is used to perform the magic. The FileReader() reads the file as dataURL and once the file is loaded then reader.onload is called where the file data can be accessed in FileReader().result. DataURL is basically a long string that we can spit in chunks to transmit and then the receiver will re-combine this string to recreate the file.

In this method we also did some calculations to calculate how many chunks will be transmitted and how much estimated time will be taken to transmit the whole file. Once all the calculations are done then we synchronously call uploadChunk method with individual packet data to send the POST request to ESP32 on http post address /send_raw. If the post request is successful then passed_callback method is called to transmit next packet, or else if it fails then failed_callback is called to retry the same packet.

Once the ESP32 receives the packet via http post request declared here, This method will add the packet to a queue of object that stores the packet data and the request object and that will be processed by a separate method LoRa_sendRaw. LoRa_sendRaw method runs infinitely and as soon as an element appears in the queue it will pop each element from the queue take the packet data and pass it to LoRa_send to performs few more operations such as get the CRC checksum and prepend it to the packet, along with the packet length and packet type (The are 3 types of packet, user message, file chunks and acknowledgements). This meta data will be used by the receiver to validate the packet and send back the acknowledgement. Remember, till this point the ESP has not responded back to the http POST request, which client has sent, LoRa_sendRaw still kept the request on hold till the sender receives the acknowledgement from the receiver.

The receiver will get this packet along with the meta data in onRecieve method, which will read the meta data and packet data and validate it and then push it to a queue. This queue will be processed by manage_recieve_queue method to send it to the receiver's client system via event data. The receiver will receive the packet data in this method which will take the packet append it to the previous packet string and send the acknowledgement back to the transmitter. Transmitter ESP will then send 200 to http post request which was on hold. Once all the packet are received, then receiver client system will recreate the file and allow the user to download it.