Published September 5, 2016 © GPL3+

Getting Started with LoRa

How to get temperature sensor data from a remote Raspberry Pi via Wireless LoRa Protocol.

IntermediateFull instructions provided2 hours100,199

Things used in this project

Hardware components

Raspberry Pi 2 Model B

Lora/GPS_HAT

Story

What is LoRa?

LoRa is a Long-Range radio technology developed by Semtech. Here is a definition from Semtech's LoRa FAQ:

"LoRa (Long Range) is a modulation technique that provides significantly longer range than competing technologies. The modulation is based on spread-spectrum techniques and a variation of chirp spread spectrum (CSS) with integrated forward error correction (FEC). LoRa significantly improves the receiver sensitivity and as with other spread‐spectrum modulation techniques, uses the entire channel bandwidth to broadcast a signal, making it robust to channel noise and insensitive to frequency offsets caused from the use of low cost crystals. LoRa can demodulate signals 19.5dB below the noise floor while most frequency shift keying systems (FSK) need a signal power of 8-10dB above the noise floor to demodulate properly. The LoRa modulation is the physical layer (PHY), which can be utilized with different protocols and in different network architecture – Mesh, Star, point to point, etcetera."

What are the main parameters of LoRa radios?

Throughput and range depend on 3 main LoRa parameters: BW, CR and SF. BW is the physical bandwidth for RF modulation (e.g. 125kHz). Larger signal bandwidth allows for higher effective data rate, thus reducing transmission time at the expense of reduced sensitivity. CR, the coding rate for forward error detection and correction. Such coding incurs a transmission overhead and the lower the coding rate, the higher the coding rate overhead ratio, e.g. with coding_rate=4/(4+CR) the overhead ratio is 1.25 for CR=1 which is the minimum value. Finally SF, the spreading factor, which can be set from 6 to 12. The lower the SF, the higher the data rate transmission but the lower the immunity to interference thus the smaller is the range.

What is the typical range of LoRa radio technology?

Most of tests performed by Semtech and other companies show radio range of about 15-20kms in line-of-sight condition with BW=125kHz and SF=12. The range can be greatly increased if the antennas can be set up higher. Some High Altitude Ballooning experiences have reported range of several hundredths of kms. Under non line-of-sight condition such as in a dense urban area or indoor scenarios, the maximum range is about 2kms.

What is the usual LoRa topology?

With the longer range the usual LoRa topology is a star: end-devices (IoT device) will send data to a gateway which is usually assumed to have Internet connection to be able to push received data to Internet servers. Note that several gateways can be deployed to cover a larger area and it may happen that a message from an end device is received by several gateways. Filtering for duplicated messages can be realized at the Internet server level, or more generally at a layer above the gateway.

What is LoRa/GPS HAT?

The Dragino Lora/GPS HAT is a expansion module for LoRaWan and GPS for use with the Raspberry Pi. This product is intended for those interested in developing LoRaWAN solutions.

The Lora/GPS HAT is based on the SX1276/SX1278 transceiver. The add on L80 GPS (Base on MTK MT3339) is designed for applications that use a GPS connected via the serial ports to the Raspberry Pi such as timing applications or general applications that require GPS information.

Lora/GPS HAT

The transceivers of the Lora/GPS HAT feature the LoRa™ long range modem that provides ultra-long range spread spectrum communication and high interference immunity whilst minimizing current consumption. The Lora/GPD HAT can achieve a sensitivity of over -148dBm using a low cost crystal and bill of materials. The high sensitivity combined with the integrated +20 dBm power amplifier yields industry leading link budget making it optimal for any application requiring range or robustness. LoRa™ also provides significant advantages in both blocking and selectivity over conventional modulation techniques, solving the traditional design compromise between range, interference immunity and energy consumption.

This board can calculate and predict orbits automatically using the ephemeris data (up to 3 days) stored in internal flash memory, so the HAT can fix position quickly even at indoor signal levels with low power consumption. With AlwaysLocate™ technology, the Lora/GPS HAT can adaptively adjust the on/off time to achieve balance between positioning accuracy and power consumption according to the environmental and motion conditions. The GPS also supports automatic antenna switching function. It can achieve the switching between internal patch antenna and external active antenna. Moreover, it keeps positioning during the switching process.

The ISM/SRD License-Free Frequency Bands

What is the purpose of this project?

In this project we will learn, how sensors in different locations, data will be sent to the server/gateway via LoRa technology. In this example, a node (Sensor data collector) and a server/gateway used for save sensor data. The Node sends temperature to server/gateway. We have used both sides (Node and Server) of the Raspberry Pi.

In this example, Lora/GPS HAT to be attached to the Raspberry Pi according to Table 1:

Table 1: Pinout

You can also use any other LoRa module. This project has also been tested with Adafruit RFM95W LoRa Radio Transceiver Breakout.

1 / 2 • LoRa/GPS HAT

Configuration

Connect the Lora/GPS HAT to Raspberry Pi;

Use raspi-config to ensure that SPI can be used on RPi;

Use sudo apt-get install wiringpi to install the GPIO access library written in C for the BCM2835 used in the Raspberry Pi;

This example tested with Raspberry Pi 1 B, B+, Zero, 2 and 3.

Used operating system : Raspbian Stretch.

Note: This setting is same for the server/gateway and node.

The tutorial consisted of two parts:

1. Preparation Node or Client

2. Preparation Server or Gateway

Part 1 : Preparation Node or Client

1-Wire Digital Temperature Sensor

To measure the temperature, the DS18B20 used. In 1-Wire sensors, all data is sent down one wire, which makes it great for micro controllers such as the Raspberry Pi, as it only requires one GPIO pin for sensing. In addition to this, most 1-Wire sensors will come with a unique serial code (more on this later) which means you can connect multiple units up to one micro controller without them interfering with each other. The DS18B20+ has a similar layout to transistors called the TO-92 package, with three pins: GND, Data (DQ), and 3.3V power line (VDD). You’ll also need some jumper wires, a breadboard and a 4.7kΩ (or 10kΩ) resistor.

DS18B20 Pinout

Add the following lines to /boot/config.txt and reboot the Pi:

dtoverlay=w1-gpio,gpiopin=21

Also requires bcm2835 library to be already installed:

wget http://www.airspayce.com/mikem/bcm2835/bcm2835-1.55.tar.gz
tar zxvf bcm2835-1.55.tar.gz
cd bcm2835-1.55
./configure
make
sudo make check
sudo make install

Get the RadioHead library from following link:

git clone https://github.com/idreamsi/RadioHead
cd RadioHead/examples/raspi/rf95/

Compile and execute the client:

make
sudo ./rf95_client

If everything is correct, you will see the image below.

Client

6 here is the number of every Node. For easier identification we consider a number for each Node.

Part 2 : Preparation Server or Gateway

In the server side, get the RadioHead library again. Compile and execute the server:

git clone https://github.com/idreamsi/RadioHead
cd RadioHead/examples/raspi/rf95/
make
sudo ./rf95_server

If everything is correct, you will see the image below.

Server

Adding post-processing

Our approach is to enable information passing between the gateway program (basically running in a transparent manner) and post-processing operation implemented by end-users in a high-level language such as python. We provide a simple post_processing.py python script to demonstrate how save sensor data in log file or even send to the cloud server such as thingspeak and etc. Note how the server or gateway is launched now:

sudo ./rf95_server | python ./post_processing.py -a filename

The log file can be seen here.

log file

Special thanks to Edwin for help about this project.

Resource

http://www.semtech.com/wireless-rf/lora/LoRa-FAQs.pdf

http://www.dragino.com/products/module/item/106-lora-gps-hat.html

https://github.com/dragino/Lora/

https://github.com/hallard/RadioHead

http://cpham.perso.univ-pau.fr/LORA/RPIgateway.html

Code

#Original code by: https://github.com/CongducPham/LowCostLoRaGw/
#Edited by: Ramin Sangesari

import sys
import os
import datetime
import getopt

#gateway id/addr, just for giving a different name to various log files
_gwaddr=1

def main(argv):
	try:
		opts, args = getopt.getopt(argv,'a:',['addr'])
	except getopt.GetoptError:
		print 'logParseGateway -a'
		sys.exit(2)
	
	for opt, arg in opts:		
		if opt in ("-a", "--addr"):
			global _gwaddr
			_gwaddr = arg
			print "will use _"+str(_gwaddr)+" for post-processing log file"			

		
if __name__ == "__main__":
	main(sys.argv[1:])
	

_parselog_filename = str(_gwaddr)+".log"
the_line=sys.stdin.readline()

try:
	while the_line:
		f=open(os.path.expanduser(_parselog_filename),"a")	
		now = datetime.datetime.now()
		f.write(now.isoformat()+'> ')
		f.write(the_line)
		f.close()
		sys.stdout.write(the_line)
		the_line=sys.stdin.readline()

except KeyboardInterrupt:
   sys.stdout.flush()
   pass

// rf95_client.cpp
//
// Example program showing how to use RH_RF95 on Raspberry Pi
// Uses the bcm2835 library to access the GPIO pins to drive the RFM95 module
// Requires bcm2835 library to be already installed:
// http://www.airspayce.com/mikem/bcm2835/
// Use the Makefile in this directory:
// cd example/raspi/rf95
// make
// sudo ./rf95_client
//
// Contributed by Charles-Henri Hallard based on sample RH_NRF24 by Mike Poublon
// Edited by: Ramin Sangesari
// https://www.hackster.io/idreams/


#include <bcm2835.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

#include <RH_RF69.h>
#include <RH_RF95.h>

#include <stdlib.h>
#include <fcntl.h>
#include <dirent.h>
#include <string.h>
#include <time.h>
#include <math.h>


// define hardware used change to fit your need
// Uncomment the board you have, if not listed 
// uncommment custom board and set wiring tin custom section

// LoRasPi board 
// see https://github.com/hallard/LoRasPI
//#define BOARD_DRAGINO_PIHAT

// Adafruit RFM95W LoRa Radio Transceiver Breakout
// see https://www.adafruit.com/product/3072
#define BOARD_ADAFRUIT_RFM95W

// iC880A and LinkLab Lora Gateway Shield (if RF module plugged into)
// see https://github.com/ch2i/iC880A-Raspberry-PI
//#define BOARD_IC880A_PLATE

// Raspberri PI Lora Gateway for multiple modules 
// see https://github.com/hallard/RPI-Lora-Gateway
//#define BOARD_PI_LORA_GATEWAY

// Dragino Raspberry PI hat
// see https://github.com/dragino/Lora
//#define BOARD_DRAGINO_PIHAT

// Now we include RasPi_Boards.h so this will expose defined 
// constants with CS/IRQ/RESET/on board LED pins definition
#include "../RasPiBoards.h"

// Our RFM95 Configuration 
#define RF_FREQUENCY  868.00
//#define RF_GATEWAY_ID 1 
#define RF_NODE_ID    10

uint8_t RF_GATEWAY_ID = 1;

// Create an instance of a driver
RH_RF95 rf95(RF_CS_PIN, RF_IRQ_PIN);
//RH_RF95 rf95(RF_CS_PIN);

//Flag for Ctrl-C
volatile sig_atomic_t force_exit = false;

void Data_create(float *val, uint8_t data[]){
    uint8_t *sends;
    sends = (uint8_t *) val;
    memcpy(data, sends, sizeof(float));
}


void sig_handler(int sig)
{
  printf("\n%s Break received, exiting!\n", __BASEFILE__);
  force_exit=true;
}

//Main Function
//int main (int argc, const char* argv[] )
//{
int main(int argc, char **argv)
{
    if( argc == 2 )
        RF_GATEWAY_ID = atoi(argv[1]);	
	
  static unsigned long last_millis;
  static unsigned long led_blink = 0;
  
  signal(SIGINT, sig_handler);
  printf( "%s\n", __BASEFILE__);

  if (!bcm2835_init()) {
    fprintf( stderr, "%s bcm2835_init() Failed\n\n", __BASEFILE__ );
    return 1;
  }
  
  printf( "RF95 CS=GPIO%d", RF_CS_PIN);

#ifdef RF_LED_PIN
  pinMode(RF_LED_PIN, OUTPUT);
  digitalWrite(RF_LED_PIN, HIGH );
#endif

#ifdef RF_IRQ_PIN
  printf( ", IRQ=GPIO%d", RF_IRQ_PIN );
  // IRQ Pin input/pull down 
  pinMode(RF_IRQ_PIN, INPUT);
  bcm2835_gpio_set_pud(RF_IRQ_PIN, BCM2835_GPIO_PUD_DOWN);
#endif
  
#ifdef RF_RST_PIN
  printf( ", RST=GPIO%d", RF_RST_PIN );
  // Pulse a reset on module
  pinMode(RF_RST_PIN, OUTPUT);
  digitalWrite(RF_RST_PIN, LOW );
  bcm2835_delay(150);
  digitalWrite(RF_RST_PIN, HIGH );
  bcm2835_delay(100);
#endif

#ifdef RF_LED_PIN
  printf( ", LED=GPIO%d", RF_LED_PIN );
  digitalWrite(RF_LED_PIN, LOW );
#endif

  if (!rf95.init()) {
    fprintf( stderr, "\nRF95 module init failed, Please verify wiring/module\n" );
  } else {
    printf( "\nRF95 module seen OK!\r\n");

#ifdef RF_IRQ_PIN
    // Since we may check IRQ line with bcm_2835 Rising edge detection
    // In case radio already have a packet, IRQ is high and will never
    // go to low so never fire again 
    // Except if we clear IRQ flags and discard one if any by checking
    rf95.available();

    // Now we can enable Rising edge detection
    bcm2835_gpio_ren(RF_IRQ_PIN);
#endif

    // Defaults after init are 434.0MHz, 13dBm, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on

    // The default transmitter power is 13dBm, using PA_BOOST.
    // If you are using RFM95/96/97/98 modules which uses the PA_BOOST transmitter pin, then 
    // you can set transmitter powers from 5 to 23 dBm:
    //rf95.setTxPower(23, false); 
    // If you are using Modtronix inAir4 or inAir9,or any other module which uses the
    // transmitter RFO pins and not the PA_BOOST pins
    // then you can configure the power transmitter power for -1 to 14 dBm and with useRFO true. 
    // Failure to do that will result in extremely low transmit powers.
    //rf95.setTxPower(14, true);

    rf95.setTxPower(14, false); 

    // You can optionally require this module to wait until Channel Activity
    // Detection shows no activity on the channel before transmitting by setting
    // the CAD timeout to non-zero:
    //rf95.setCADTimeout(10000);

    // Adjust Frequency
    rf95.setFrequency( RF_FREQUENCY );

    // This is our Node ID
    rf95.setThisAddress(RF_NODE_ID);
    rf95.setHeaderFrom(RF_NODE_ID);
    
    // Where we're sending packet
    rf95.setHeaderTo(RF_GATEWAY_ID);  

    printf("RF95 node #%d init OK @ %3.2fMHz\n", RF_NODE_ID, RF_FREQUENCY );

    last_millis = millis();

    //Begin the main body of code
    while (!force_exit) {

      //printf( "millis()=%ld last=%ld diff=%ld\n", millis() , last_millis,  millis() - last_millis );

      // Send every 5 seconds
      if ( millis() - last_millis > 5000 ) {
        last_millis = millis();

#ifdef RF_LED_PIN
        led_blink = millis();
        digitalWrite(RF_LED_PIN, HIGH);
#endif
    ///////////////////////////////////////////////////
	// DS18b20 Temperature sensor
	///////////////////////////////////////////////////
		
	char path[50] = "/sys/bus/w1/devices/";
	char rom[20];
	char buf[100];
	DIR *dirp;
	struct dirent *direntp;
	int fd =-1;
	char *temp;
	float value;
	// These tow lines mount the device:
	system("sudo modprobe w1-gpio");
	system("sudo modprobe w1-therm");
	// Check if /sys/bus/w1/devices/ exists.
	if((dirp = opendir(path)) == NULL)
	{
		printf("opendir error\n");
		return 1;
	}
	// Reads the directories or files in the current directory.
	while((direntp = readdir(dirp)) != NULL)
	{
		// If 28-00000 is the substring of d_name,
		// then copy d_name to rom and print rom.  
		if(strstr(direntp->d_name,"28-00000"))
		{
			strcpy(rom,direntp->d_name);
			//printf(" rom: %s\n",rom);
		}
	}
	closedir(dirp);
	// Append the String rom and "/w1_slave" to path
	// path becomes to "/sys/bus/w1/devices/28-00000xxxx/w1_slave"
	strcat(path,rom);
	strcat(path,"/w1_slave");
	// Open the file in the path.
	if((fd = open(path,O_RDONLY)) < 0)
	{
		printf("open error\n");
		return 1;
	}
	// Read the file
	if(read(fd,buf,sizeof(buf)) < 0)
	{
		printf("read error\n");
		return 1;
	}
	// Returns the first index of 't'.
	temp = strchr(buf,'t');
		
	// Read the string following "t=".
	sscanf(temp,"t=%s",temp);
			
	// atof: changes string to float.
	value = atof(temp)/1000;
	char c[50]; //size of the number
	//sprintf(c, "%.2f C", value);
	sprintf(c, "%.2f", value);
		
	//printf("Temperature: %s\n", c);
			
    ///////////////////////////////////////////////////
	// DS18b20 Temperature sensor
	///////////////////////////////////////////////////
		
	
    // Send Temperature data to rf95_server
    //uint8_t data[] = "Hi Hackster !";
	uint8_t * data = (uint8_t *)c;
	uint8_t len = sizeof(data);
    printf("Sending %02d bytes to node #%d => ", len, RF_GATEWAY_ID );
    printbuffer(data, len);
    printf("\n" );
    rf95.send(data, len);
    rf95.waitPacketSent();
        
    }

#ifdef RF_LED_PIN
      // Led blink timer expiration ?
      if (led_blink && millis()-led_blink>200) {
        led_blink = 0;
        digitalWrite(RF_LED_PIN, LOW);
      }
#endif
      
      // Let OS doing other tasks
      // Since we do nothing until each 5 sec
      bcm2835_delay(100);
    }
  }

#ifdef RF_LED_PIN
  digitalWrite(RF_LED_PIN, LOW );
#endif
  printf( "\n%s Ending\n", __BASEFILE__ );
  bcm2835_close();
  return 0;
}

// rf95_server.cpp
//
// Example program showing how to use RH_RF95 on Raspberry Pi
// Uses the bcm2835 library to access the GPIO pins to drive the RFM95 module
// Requires bcm2835 library to be already installed
// http://www.airspayce.com/mikem/bcm2835/
// Use the Makefile in this directory:
// cd example/raspi/rf95
// make
// sudo ./rf95_server
//
// Contributed by Charles-Henri Hallard based on sample RH_NRF24 by Mike Poublon
// Edited by: Ramin Sangesari
// https://www.hackster.io/idreams/

#include <bcm2835.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

#include <RH_RF69.h>
#include <RH_RF95.h>

// define hardware used change to fit your need
// Uncomment the board you have, if not listed 
// uncommment custom board and set wiring tin custom section


// LoRasPi board 
// see https://github.com/hallard/LoRasPI
//#define BOARD_LORASPI

// Adafruit RFM95W LoRa Radio Transceiver Breakout
// see https://www.adafruit.com/product/3072
#define BOARD_ADAFRUIT_RFM95W

// iC880A and LinkLab Lora Gateway Shield (if RF module plugged into)
// see https://github.com/ch2i/iC880A-Raspberry-PI
//#define BOARD_IC880A_PLATE

// Raspberri PI Lora Gateway for multiple modules 
// see https://github.com/hallard/RPI-Lora-Gateway
//#define BOARD_PI_LORA_GATEWAY

// Dragino Raspberry PI hat
// see https://github.com/dragino/Lora
//#define BOARD_DRAGINO_PIHAT

// Now we include RasPi_Boards.h so this will expose defined 
// constants with CS/IRQ/RESET/on board LED pins definition
#include "../RasPiBoards.h"

// Our RFM95 Configuration 
#define RF_FREQUENCY  868.00
#define RF_NODE_ID    1

// Create an instance of a driver
RH_RF95 rf95(RF_CS_PIN, RF_IRQ_PIN);
//RH_RF95 rf95(RF_CS_PIN);

//Flag for Ctrl-C
volatile sig_atomic_t force_exit = false;

void sig_handler(int sig)
{
  printf("\n%s Break received, exiting!\n", __BASEFILE__);
  force_exit=true;
}

//Main Function
int main (int argc, const char* argv[] )
{
  unsigned long led_blink = 0;
  
  signal(SIGINT, sig_handler);
  //printf( "%s\n", __BASEFILE__);

  if (!bcm2835_init()) {
    fprintf( stderr, "%s bcm2835_init() Failed\n\n", __BASEFILE__ );
    return 1;
  }
  
  //printf( "RF95 CS=GPIO%d", RF_CS_PIN);

#ifdef RF_LED_PIN
  pinMode(RF_LED_PIN, OUTPUT);
  digitalWrite(RF_LED_PIN, HIGH );
#endif

#ifdef RF_IRQ_PIN
  //printf( ", IRQ=GPIO%d", RF_IRQ_PIN );
  // IRQ Pin input/pull down
  pinMode(RF_IRQ_PIN, INPUT);
  bcm2835_gpio_set_pud(RF_IRQ_PIN, BCM2835_GPIO_PUD_DOWN);
  // Now we can enable Rising edge detection
  bcm2835_gpio_ren(RF_IRQ_PIN);
#endif
  
#ifdef RF_RST_PIN
  //printf( ", RST=GPIO%d", RF_RST_PIN );
  // Pulse a reset on module
  pinMode(RF_RST_PIN, OUTPUT);
  digitalWrite(RF_RST_PIN, LOW );
  bcm2835_delay(150);
  digitalWrite(RF_RST_PIN, HIGH );
  bcm2835_delay(100);
#endif

#ifdef RF_LED_PIN
  //printf( ", LED=GPIO%d", RF_LED_PIN );
  digitalWrite(RF_LED_PIN, LOW );
#endif

  if (!rf95.init()) {
    fprintf( stderr, "\nRF95 module init failed, Please verify wiring/module\n" );
  } else {
    // Defaults after init are 434.0MHz, 13dBm, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on

    // The default transmitter power is 13dBm, using PA_BOOST.
    // If you are using RFM95/96/97/98 modules which uses the PA_BOOST transmitter pin, then 
    // you can set transmitter powers from 5 to 23 dBm:
    //  driver.setTxPower(23, false);
    // If you are using Modtronix inAir4 or inAir9,or any other module which uses the
    // transmitter RFO pins and not the PA_BOOST pins
    // then you can configure the power transmitter power for -1 to 14 dBm and with useRFO true. 
    // Failure to do that will result in extremely low transmit powers.
    // rf95.setTxPower(14, true);


    // RF95 Modules don't have RFO pin connected, so just use PA_BOOST
    // check your country max power useable, in EU it's +14dB
    rf95.setTxPower(14, false);

    // You can optionally require this module to wait until Channel Activity
    // Detection shows no activity on the channel before transmitting by setting
    // the CAD timeout to non-zero:
    //rf95.setCADTimeout(10000);

    // Adjust Frequency
    rf95.setFrequency(RF_FREQUENCY);
    
    // If we need to send something
    rf95.setThisAddress(RF_NODE_ID);
    rf95.setHeaderFrom(RF_NODE_ID);
    
    // Be sure to grab all node packet 
    // we're sniffing to display, it's a demo
    rf95.setPromiscuous(true);

    // We're ready to listen for incoming message
    rf95.setModeRx();

    //printf( " OK NodeID=%d @ %3.2fMHz\n", RF_NODE_ID, RF_FREQUENCY );
    //printf( "Listening packet...\n" );

    //Begin the main body of code
    while (!force_exit) {
      
#ifdef RF_IRQ_PIN
      // We have a IRQ pin ,pool it instead reading
      // Modules IRQ registers from SPI in each loop
      
      // Rising edge fired ?
      if (bcm2835_gpio_eds(RF_IRQ_PIN)) {
        // Now clear the eds flag by setting it to 1
        bcm2835_gpio_set_eds(RF_IRQ_PIN);
        //printf("Packet Received, Rising event detect for pin GPIO%d\n", RF_IRQ_PIN);
#endif

        if (rf95.available()) { 
#ifdef RF_LED_PIN
          led_blink = millis();
          digitalWrite(RF_LED_PIN, HIGH);
#endif
          // Should be a message for us now
          uint8_t buf[RH_RF95_MAX_MESSAGE_LEN];
          uint8_t len  = sizeof(buf);
          uint8_t from = rf95.headerFrom();
          uint8_t to   = rf95.headerTo();
          uint8_t id   = rf95.headerId();
          uint8_t flags= rf95.headerFlags();;
          int8_t rssi  = rf95.lastRssi();
          
          if (rf95.recv(buf, &len)) {
            printf("From: [#%d] => Temperature: ", to);
            //printf("Packet[%02d] #%d => #%d %ddB: ", len, from, to, rssi);
            printbuffer(buf, len);
            printf(" °C");
          } else {
            Serial.print("receive failed");
          }
          printf("\n");
        }
        
#ifdef RF_IRQ_PIN
      }
#endif
      
#ifdef RF_LED_PIN
      // Led blink timer expiration ?
      if (led_blink && millis()-led_blink>200) {
        led_blink = 0;
        digitalWrite(RF_LED_PIN, LOW);
      }
#endif
      // Let OS doing other tasks
      // For timed critical appliation you can reduce or delete
      // this delay, but this will charge CPU usage, take care and monitor
      bcm2835_delay(5);
    }
  }

#ifdef RF_LED_PIN
  digitalWrite(RF_LED_PIN, LOW );
#endif
  printf( "\n%s Ending\n", __BASEFILE__ );
  bcm2835_close();
  return 0;
}

Credits

Ramin Sangesari

24 projects • 319 followers

Programmer and IoT Developer

Getting Started with LoRa

Things used in this project

Hardware components

Story

What is LoRa?

What is the purpose of this project?

Configuration

Part 1 : Preparation Node or Client

Part 2 : Preparation Server or Gateway

Adding post-processing

Resource

Schematics

Lora/GPS HAT

Code

post_processing.py

rf95_client.c

rf95_server.c

Credits

Ramin Sangesari

Comments

Embed the widget on your own site

Getting Started with LoRa

Getting Started with LoRa

Things used in this project

Hardware components

Story

What is LoRa?

What is the purpose of this project?

Configuration

Part 1 : Preparation Node or Client

Part 2 : Preparation Server or Gateway

Adding post-processing

Resource

Schematics

Lora/GPS HAT

Code

post_processing.py

rf95_client.c

rf95_server.c

Credits

Ramin Sangesari

Comments

Related channels and tags