Revision 7:c0872971aef4, committed 2020-10-16

Comitter:

walterluu

Date:

Fri Oct 16 06:50:42 2020 +0000

Parent:

6:51f492ca61a2

Commit message:

MAX20361 Demo with LoRa Module on LP0 mode

Changed in this revision

--- a/SX1276GenericPingPong/GenericPingPong2.cpp	Wed Oct 14 00:19:02 2020 +0000
+++ b/SX1276GenericPingPong/GenericPingPong2.cpp	Fri Oct 16 06:50:42 2020 +0000
@@ -19,13 +19,13 @@
 #ifdef FEATURE_LORA				// in main.cpp
 
 /* Set this flag to '1' to display debug messages on the console */
-#define DEBUG_MESSAGE   0
+#define DEBUG_MESSAGE   1
 
 /* Set this flag to '1' to use the LoRa modulation or to '0' to use FSK modulation */
 #define USE_MODEM_LORA  1
 #define USE_MODEM_FSK   !USE_MODEM_LORA
 #define RF_FREQUENCY            RF_FREQUENCY_915_0  // Hz
-#define TX_OUTPUT_POWER         14                  // 14 dBm
+#define TX_OUTPUT_POWER         1                  // 14 dBm
 
 #if USE_MODEM_LORA == 1
 
@@ -33,8 +33,11 @@
 #define LORA_SPREADING_FACTOR   LORA_SF7
 #define LORA_CODINGRATE         LORA_ERROR_CODING_RATE_4_5
 
-#define LORA_PREAMBLE_LENGTH    8       // Same for Tx and Rx
-#define LORA_SYMBOL_TIMEOUT     5       // Symbols
+//#define LORA_PREAMBLE_LENGTH    8       // Same for Tx and Rx, default
+#define LORA_PREAMBLE_LENGTH    5
+//#define LORA_SYMBOL_TIMEOUT     5       // Symbols
+#define LORA_SYMBOL_TIMEOUT     4       // Symbols
+
 #define LORA_FIX_LENGTH_PAYLOAD_ON  false
 #define LORA_FHSS_ENABLED       false  
 #define LORA_NB_SYMB_HOP        4     
@@ -56,9 +59,11 @@
 #endif 
 
 
-//#define RX_TIMEOUT_VALUE    3500	// in ms, default
-#define RX_TIMEOUT_VALUE    333	// testing
-//#define RX_TIMEOUT_VALUE    333	// in ms
+#if MASTER == 1
+	#define RX_TIMEOUT_VALUE    3500	// in ms, default
+#elif SLAVE == 1
+	#define RX_TIMEOUT_VALUE    333	// in ms
+#endif
 
 //#define BUFFER_SIZE       32        // Define the payload size here
 //#define BUFFER_SIZE         64        // Define the payload size here
@@ -246,11 +251,67 @@
     if (DEBUG_MESSAGE)
         ad->printf("Starting Ping-Pong loop\r\n"); 
 
-        
-    Radio->Rx( RX_TIMEOUT_VALUE );
+#if MASTER == 1        
+    Radio->Rx( RX_TIMEOUT_VALUE );	// initate Rx State for Master
+#endif
+    
 return 0; //added by Walter due to "Control reaches end of non-void function"
 }
 
+
+bool SX1276MasterCheckForNewData(void)
+{
+    bool new_data_available = false;
+    switch( State )
+    {
+    case RX:
+        if( BufferSizeRx > 0 )
+        {
+            new_data_available = true;
+            wait_ms( 10 ); //do we need this?
+            if (DEBUG_MESSAGE)
+                ad->printf( "State=RX\r\n" );
+        }
+        Radio->Rx( RX_TIMEOUT_VALUE );  
+        State = LOWPOWER;
+        break;
+    case RX_TIMEOUT:
+        wait_ms( 10 ); 
+        if (DEBUG_MESSAGE)
+                ad->printf( "State=RX_TIMEOUT\r\n" );     
+        Radio->Rx( RX_TIMEOUT_VALUE );    
+        State = LOWPOWER;
+        break;
+    case RX_ERROR:
+        // We have received a Packet with a CRC error, send reply as if packet was correct
+        wait_ms( 10 );  
+        if (DEBUG_MESSAGE)
+                ad->printf( "State=RX_ERROR\r\n" );
+        Radio->Rx( RX_TIMEOUT_VALUE );
+        State = LOWPOWER;
+        break;
+    case TX_TIMEOUT:
+        if (DEBUG_MESSAGE)
+                ad->printf( "State=TX_TIMEOUT\r\n" );
+        State = LOWPOWER;
+        break;
+    case LOWPOWER:
+        sleep();
+        break;
+    default:
+        sleep(); // TODO, should this be removed?
+        break;
+    }   
+    return new_data_available; 
+}
+
+void SX1276SlaveSendData(void)
+{
+    //wait_ms( 10 );  
+    Radio->Send( BufferTx, BufferSizeTx );
+    sleep();
+}
+
 /****************************************************************************************************************************************
  * 
  ****************************************************************************************************************************************/
@@ -558,4 +619,6 @@
 }
 
 
+
+
 #endif

--- a/SX1276GenericPingPong/GenericPingPong2.h	Wed Oct 14 00:19:02 2020 +0000
+++ b/SX1276GenericPingPong/GenericPingPong2.h	Fri Oct 16 06:50:42 2020 +0000
@@ -110,4 +110,8 @@
  */
 int numOfRxTimeouts();
 
+bool SX1276MasterCheckForNewData(void);
+
+void SX1276SlaveSendData(void);
+
 #endif // __MAIN_H__
\ No newline at end of file

--- a/main.cpp	Wed Oct 14 00:19:02 2020 +0000
+++ b/main.cpp	Fri Oct 16 06:50:42 2020 +0000
@@ -25,10 +25,14 @@
 // AO19 related
 #include "AO19_lib.h"
 
-//#if defined(TARGET_MAX32630FTHR) // using the RFM95 board
-//    #include "max32630fthr.h"
-//    MAX32630FTHR pegasus(MAX32630FTHR::VIO_3V3);
-//#endif
+// Low Power Mode
+#include "lp.h"
+#include "mxc_config.h"
+#include "lp.h"
+#include "rtc.h"
+//#include "board.h"      // Cannot find source?
+#define LP1_WakeTime    3 //seconds
+#define LP0_WakeTime    3 //seconds
 
 // Virtual COM related
 #include "USBSerial.h"      // for virtual COM
@@ -38,15 +42,6 @@
 // Virtual serial port over USB TODO NEW VID PID NEEDED!!
 USBSerial pc(0x0B6A, 0x0042, 0x0001, false);
 
-///***************************************************************************
-// * Virtual COM Instantiation
-// **************************************************************************/
-//#include "USBSerial.h"  // for virtual COM
-//#define BS          8       // ASCII Back Space
-//#define CR          13      // ASCII Carriage Return
-//// Virtual serial port over USB TODO NEW VID PID NEEDED!!
-//USBSerial pc(0x0B6A, 0x0042, 0x0001, false);
-
 /***************************************************************************
  * LEDs Instantiation
  **************************************************************************/
@@ -76,27 +71,105 @@
     print_data_flag = true;
 }
 
+// *****************************************************************************
+void RTC_Setup()
+{
+    rtc_cfg_t RTCconfig;
+
+    RTCconfig.compareCount[0] = LP0_WakeTime;//3 second timer          
+//    RTCconfig.compareCount[1] = LP1_WakeTime;      //3 second timer
+    RTCconfig.prescaler = RTC_PRESCALE_DIV_2_12; //1Hz clock
+    RTCconfig.prescalerMask = RTC_PRESCALE_DIV_2_12;//used for prescaler compare
+    RTCconfig.snoozeCount = 0;
+    RTCconfig.snoozeMode = RTC_SNOOZE_DISABLE;
+
+    RTC_Init(&RTCconfig);
+
+    RTC_Start();
+}
+
+//void Wakeup_LP1() {
+//    
+//        /***************************************************************************
+//        * Temperature Sensor Data Measurement
+//        **************************************************************************/
+//        // obtain register hex values
+//        convert_temperature(&i2cBus0, OT07_i2c_add);  //send OW convert selected device
+//        wait_ms(CONVERT_T_DELAY);  //wait 20 ms for convert temperature to complete
+//        int temp_error = OT07_read_register(&i2cBus0, OT07_i2c_add, OT07_FIFO_DATA, rawtempdata, 2); 
+//        double tempFinal = calc_temperature(rawtempdata);
+//        
+//        //fill raw temp data into the array
+//        curr_raw_temp_to_master[0] = rawtempdata[0];
+//        curr_raw_temp_to_master[1] = rawtempdata[1];      
+//        
+//        /***************************************************************************
+//        * Light Intensity Sensor Data Measurement
+//        **************************************************************************/
+//        // obtain register hex values
+//        int lux_error = MAX44009_read_lux_register(&i2cBus0, MAX44009_i2c_add, MAX44009_LUX_HI, rawluxdata);
+//        int luxFinal = (int) (calc_lux(rawluxdata));
+//        
+//        //fill raw lux data into the array
+//        curr_raw_light_to_master[0] = rawluxdata[0];
+//        curr_raw_light_to_master[1] = rawluxdata[1];
+//        
+//        /***************************************************************************
+//        * Solar Harvester Data Measurement
+//        **************************************************************************/
+//        
+//        int ocv_error = AO32_read_register(&i2cBus0, AO32_i2c_add, AO32_VOC, rawOCVdata);
+//        int cnt_error = AO32_read_register(&i2cBus0, AO32_i2c_add, AO32_HARV_H, rawCntdata, 2); // burst read 2 bytes
+//        
+//        //calculate open circuit voltage from data
+//        double OCVFinal = calc_OCV(rawOCVdata);
+//        
+//        //calculate harvesting counts from data
+//        int countFinal = calc_Harvest(rawCntdata);
+//        
+//        //fill raw AO32 data into the array
+//        curr_raw_AO32_to_master[0] = rawOCVdata[0];         // Fill OCV hex first
+//        curr_raw_AO32_to_master[1] = rawCntdata[0];         // Fill Harvesting count high byte
+//        curr_raw_AO32_to_master[2] = rawCntdata[1];         // Fill Harvesting count low byte
+//        
+//        // print out sensor data
+//         pc.printf("SENSOR: [%.3f] [%d] [%.2f] [%d] [0]\r\n", tempFinal, luxFinal, OCVFinal, countFinal);
+//        
+//        /***************************************************************************
+//        * Fill Payload Buffer With Data From Main Program Buffers for next LoRa Transmition
+//        **************************************************************************/
+//        memcpy(&BufferTx[tx_idx_signature], PongMsg,                  size_signature);
+//        memcpy(&BufferTx[tx_idx_MAX30208],  curr_raw_temp_to_master, size_of_MAX30208);
+//        memcpy(&BufferTx[tx_idx_MAX44009],  curr_raw_light_to_master, size_of_MAX44009);
+//        memcpy(&BufferTx[tx_idx_MAX20361],  curr_raw_AO32_to_master,  size_of_MAX20361);
+//
+//        /***************************************************************************
+//        * LoRa Communication: Send Sensor Data
+//        **************************************************************************/
+//        SX1276SlaveSendData();    
+//}
+
 int main() {
 
 /***************************************************************************
-
- 
  
     /* Setup begins here: */
     #if   MASTER == 1 // Master Device
-//        pc.printf("MAX32625PICO: MASTER DEVICE\r\n");
-//        wait(1);
+        rLED = LED_ON;      // red LED on
+        myled = LED_OFF;
+        bLED = LED_OFF;
     #elif SLAVE == 1 // Slave Device
-//        pc.printf("MAX32625PICO: SLAVE DEVICE\r\n");
-//        wait(1);
+        rLED = LED_OFF;
+        myled = LED_OFF;
+        bLED = LED_ON;      // blue LED on
+        
+        //configure RTC and start for slave
+        RTC_Setup();
+        
+//        sleep();            // put slave in sleep mode LP2
+        
     #endif
     
-    /* Introduction text: */
-//    pc.printf("Welcome to the SX1276GenericLib\r\n");
-//    wait(5);
-//    pc.printf("Starting a simple LoRa PingPong\r\n");
-//    wait(5);
-    
      /***************************************************************************
      * Combined Payload Buffers for LoRa Communications
      **************************************************************************/
@@ -113,27 +186,12 @@
     #endif
     
     /***************************************************************************
-     * Dummy Data Buffers
-     **************************************************************************/
-    #if MASTER == 1  // Master Device
-//        uint8_t curr_dum_to_slave[size_of_dum];
-    #elif SLAVE == 1 // Slave Device
-//        uint8_t curr_dum_from_master[size_of_dum];
-//        uint8_t prev_dum_from_master[size_of_dum];
-    #endif
-    
-    /***************************************************************************
      * MAX30208 Data Buffers
      **************************************************************************/
     #if   MASTER == 1 // Master Device
-//        uint8_t curr_MAX77650_from_slave[size_of_MAX77650];
-//        uint8_t curr_raw_temp_from_slave[size_of_MAX30208];
         char curr_raw_temp_from_slave[size_of_MAX30208];   // to match data type
-//        uint8_t prev_MAX77650_from_slave[size_of_MAX77650];
         char prev_raw_temp_from_slave[size_of_MAX30208];  
     #elif SLAVE == 1 // Slave Device
-//        uint8_t curr_MAX77650_to_master[size_of_MAX77650];
-//        bool chrg_status = false; //True = ON False = OFF
         uint8_t curr_raw_temp_to_master[size_of_MAX30208];
     #endif
     
@@ -142,41 +200,20 @@
      * MAX44009 Data Buffers
      **************************************************************************/
     #if   MASTER == 1 // Master Device
-//        uint8_t curr_raw_light_from_slave[size_of_MAX44009];
         char curr_raw_light_from_slave[size_of_MAX44009];    // to match data type
         char prev_raw_light_from_slave[size_of_MAX44009];
-    //    static int16_t conv_frame_data_from_slave[64];
     #elif SLAVE == 1 // Slave Device
         uint8_t curr_raw_light_to_master[size_of_MAX44009];
-    //    static char prev_raw_light_data_to_master[size_of_MAX44009];
-    //    static int16_t conv_frame_data_to_master[64];
     #endif
     
     /***************************************************************************
      * MAX20361 Data Buffers
      **************************************************************************/
     #if   MASTER == 1 // Master Device
-//        uint8_t curr_raw_AO32_from_slave[size_of_MAX20361];
         char curr_raw_AO32_from_slave[size_of_MAX20361];            // to match data type
         char prev_raw_AO32_from_slave[size_of_MAX20361];
-    //    static int16_t conv_frame_data_from_slave[64];
     #elif SLAVE == 1 // Slave Device
         uint8_t curr_raw_AO32_to_master[size_of_MAX20361];
-    //    static char prev_raw_AO32_data_to_master[size_of_MAX20361];
-    //    static int16_t conv_frame_data_to_master[64];
-    #endif
-    
-    /***************************************************************************
-     * Other Data Buffers
-     **************************************************************************/
-    #if   MASTER == 1 // Master Device
-//        uint8_t curr_raw_other_from_slave[size_of_other];
-//        uint8_t prev_raw_other_from_slave[size_of_other];
-    //    static int16_t conv_frame_data_from_slave[64];
-    #elif SLAVE == 1 // Slave Device
-//        uint8_t curr_raw_other_to_master[size_of_other];
-    //    static char prev_raw_other_data_to_master[size_of_other];
-    //    static int16_t conv_frame_data_to_master[64];
     #endif
     
     /***************************************************************************
@@ -184,32 +221,24 @@
      **************************************************************************/
     SX1276PingPongSetup(BufferTx, BufferRx, &pc);
     
-//    Pointer Tutorials
+//    Pointer Tutorial
 //    https://www.tutorialspoint.com/cprogramming/c_pointers.htm
     
     /***************************************************************************
      * Create Dummy Data For Master and Slave
      **************************************************************************/
-//    Array Tutorials    
-//    http://www.cplusplus.com/doc/tutorial/arrays/
-    #if MASTER == 1
-//    curr_dum_to_slave[0] = {33, 34};
-//    curr_dum_to_slave[0] = 33;
-//    curr_dum_to_slave[1] = 34;
-    #endif
     
     #if SLAVE == 1
-
-    curr_raw_temp_to_master[0] = 99;
-    curr_raw_temp_to_master[1] = 99;
-
-    curr_raw_light_to_master[0] = 25;
-    curr_raw_light_to_master[1] = 26;
-
-    curr_raw_AO32_to_master[0] = 99;
-    curr_raw_AO32_to_master[1] = 100;
-    curr_raw_AO32_to_master[2] = 101;
-    curr_raw_AO32_to_master[3] = 102;    
+//    curr_raw_temp_to_master[0] = 99;
+//    curr_raw_temp_to_master[1] = 99;
+//
+//    curr_raw_light_to_master[0] = 25;
+//    curr_raw_light_to_master[1] = 26;
+//
+//    curr_raw_AO32_to_master[0] = 99;
+//    curr_raw_AO32_to_master[1] = 0;
+//    curr_raw_AO32_to_master[2] = 101;
+//    curr_raw_AO32_to_master[3] = 102;    
      #endif
     
     /***************************************************************************
@@ -220,12 +249,11 @@
     #if MASTER == 1
      //************* init ticker timer callbacks  ****************
     timer_M.attach(&onGatewayInterrupt, 3);        //Gateway data print out frequency
-    
     #endif
     
     #if SLAVE == 1
     //************* init ticker timer callbacks  ****************
-    timer_1.attach(&onTimerInterrupt, 3);        //Sensor data transmission frequency
+    timer_1.attach(&onTimerInterrupt, 10);        //Sensor data transmission frequency
     
     //************* OT07 Variables  **************** 
     char rawtempdata[2];          
@@ -246,13 +274,6 @@
     char AO19_BB_CFG[2];              // store result of AO19's register 0x01 BBstCfg0
     int AO19_read = AO19_read_register(&i2cBus0, AO19_i2c_add, AO19_BB_CFG0, AO19_BB_CFG);
     
-//    if (AO19_read) {
-//        pc.printf("AO19 Initial Read fail!\r\n");
-//    }
-//    else {
-//        pc.printf("AO19 Initial Read success!\r\n");
-//    } 
-    
     int AO19_en = AO19_write_register(&i2cBus0, AO19_i2c_add, AO19_BB_CFG0, AO19_BB_CFG[0]|0x80);
     
    // if (AO19_en) {
@@ -263,35 +284,18 @@
 //    } 
     
     
-    #endif
     
-    while (1) {
-    
-    #if SLAVE == 1
-    if(get_data_flag) {
+    // LP0 Wake Up call
+    if(LP_IsLP0WakeUp()){
         
-        //reset the flag
-        get_data_flag = false;
-//        pc.printf("Timer interval reached!\r\n");
-        
-        /***************************************************************************
+     /***************************************************************************
         * Temperature Sensor Data Measurement
         **************************************************************************/
         // obtain register hex values
         convert_temperature(&i2cBus0, OT07_i2c_add);  //send OW convert selected device
         wait_ms(CONVERT_T_DELAY);  //wait 20 ms for convert temperature to complete
         int temp_error = OT07_read_register(&i2cBus0, OT07_i2c_add, OT07_FIFO_DATA, rawtempdata, 2); 
-//        pc.printf("OT07 add[%02X] data[%02X] data[%02X]\r\n", OT07_FIFO_DATA, rawtempdata[0], rawtempdata[1]);  
-            
-        //calculate temperature from data     
-//        int count = (int)(rawtempdata[0]*256 + rawtempdata[1]);
-//        if (count >= 32768)count = count - 65536;     // 2s comp
-//        double Temp = (double)count*0.005; 
-//        pc.printf("OT07  temperature[%.3f]  status[%d]\r\n", Temp, temp_error);
         double tempFinal = calc_temperature(rawtempdata);
-//        pc.printf("OT07  Final temperature[%.3f] \r\n", tempFinal);
-//        pc.printf("\r\n");
-        
         
         //fill raw temp data into the array
         curr_raw_temp_to_master[0] = rawtempdata[0];
@@ -302,55 +306,25 @@
         **************************************************************************/
         // obtain register hex values
         int lux_error = MAX44009_read_lux_register(&i2cBus0, MAX44009_i2c_add, MAX44009_LUX_HI, rawluxdata);
-//        int lux_error1 = MAX44009_read_register(&i2cBus0, MAX44009_i2c_add, MAX44009_LUX_HI, &rawluxdata[0]);
-//        int lux_error2 = MAX44009_read_register(&i2cBus0, MAX44009_i2c_add, MAX44009_LUX_LO, &rawluxdata[1]);
-//        pc.printf("MAX44009 hi_add[%02X] hi_data[%02X] lo_add[%02X] lo_data[%02X]\r\n", MAX44009_LUX_HI, rawluxdata[0], MAX44009_LUX_LO, rawluxdata[1]);
-        
-        //calculate temperature from data  
-//        int exponent = int(rawluxdata[0] >> 4);
-//        int mantissa = (int)((rawluxdata[0] << 4) & 0xF0) + (int)(rawluxdata[1]);
-//        double lux = 0.045 * mantissa * pow((double) 2, exponent);
-//        pc.printf("MAX44009  exponent[%d]  mantissa[%d]\r\n", exponent, mantissa);
-//        pc.printf("MAX44009  lux[%.2f]  status[%d] status[%d]\r\n", lux, lux_error1, lux_error2);
-//        pc.printf("MAX44009  lux[%.2f]  status[%d]\r\n", lux, lux_error);
         int luxFinal = (int) (calc_lux(rawluxdata));
-//        pc.printf("MAX44009  Final Lux[%.2f] \r\n", luxFinal);
-//        pc.printf("\r\n");
         
         //fill raw lux data into the array
         curr_raw_light_to_master[0] = rawluxdata[0];
         curr_raw_light_to_master[1] = rawluxdata[1];
         
-        
         /***************************************************************************
         * Solar Harvester Data Measurement
         **************************************************************************/
-        // obtain register hex values
-//        char AO32ID[2];
-//        int id_error = AO32_read_register(&i2cBus0, AO32_i2c_add, AO32_DEVICE_ID, AO32ID);  // testing
-//        pc.printf("AO32 add[%02X] data[%02X]\r\n", AO32_DEVICE_ID, AO32ID[0]);              // should be 0x00: 0x11
         
         int ocv_error = AO32_read_register(&i2cBus0, AO32_i2c_add, AO32_VOC, rawOCVdata);
-//        pc.printf("AO32 add[%02X] data[%02X]\r\n", AO32_VOC, rawOCVdata[0]);
         int cnt_error = AO32_read_register(&i2cBus0, AO32_i2c_add, AO32_HARV_H, rawCntdata, 2); // burst read 2 bytes
-//        pc.printf("AO32 hi_add[%02X] hi_data[%02X] lo_add[%02X] lo_data[%02X]\r\n", AO32_HARV_H, rawCntdata[0], AO32_HARV_L, rawCntdata[1]);
         
         //calculate open circuit voltage from data
-        double voltage = (double)(rawOCVdata[0]) / 100;
-//        pc.printf("AO32  OCV[%.2f]  status[%d]\r\n", voltage, ocv_error);  
+//        double voltage = (double)(rawOCVdata[0]) / 100;
         double OCVFinal = calc_OCV(rawOCVdata);
-//        pc.printf("AO32  Final OCV[%.2f]  \r\n", OCVFinal);
-//        pc.printf("\r\n");
         
         //calculate harvesting counts from data
-//        int countHi = int(rawCntdata[0]) * 256;
-//        int countLo = int(rawCntdata[1]);
-//        int harvest_counts = countHi + countLo;
-//        pc.printf("AO32  HarvesterCnt[%d]  status[%d]\r\n", harvest_counts, cnt_error); 
         int countFinal = calc_Harvest(rawCntdata);
-//        pc.printf("AO32 Final HarvesterCnt[%d]\r\n",  countFinal);
-//        pc.printf("\r\n");
-        
         
         //fill raw AO32 data into the array
         curr_raw_AO32_to_master[0] = rawOCVdata[0];         // Fill OCV hex first
@@ -367,75 +341,61 @@
         memcpy(&BufferTx[tx_idx_MAX30208],  curr_raw_temp_to_master, size_of_MAX30208);
         memcpy(&BufferTx[tx_idx_MAX44009],  curr_raw_light_to_master, size_of_MAX44009);
         memcpy(&BufferTx[tx_idx_MAX20361],  curr_raw_AO32_to_master,  size_of_MAX20361);
-//        memcpy(&BufferTx[tx_idx_other],  curr_raw_other_to_master,  size_of_other);
-        
-        /***************************************************************************
-        * In case of OnRxTimeout
-        **************************************************************************/
-        // Slave Device, these are values when LoRa communication did not happen
-       // ID_of_master[0] = 'N'; // 0x4E or 78
-//        ID_of_master[1] = 'A'; // 0x41 or 65
-//        ID_of_master[2] = 'C'; // 0x43 or 67
-//        ID_of_master[3] = 'K'; // 0x4B or 75
-//        ID_of_master[4] = 'M'; // 0x4D or 77
-//        ID_of_master[5] = 'A'; // 0x41 or 65
-//        ID_of_master[6] = 'S'; // 0x53 or 83
-//        ID_of_master[7] = '!'; // 0x21 or 33
-//        
-//        curr_dum_from_master[0] = 39;
-//        curr_dum_from_master[1] = 40;       
-        
+
         /***************************************************************************
         * LoRa Communication: Send Sensor Data
         **************************************************************************/
-//        SX1276SensorSend();
-        SX1276PingPong(); 
-//        int sendTime = TimeOnAirSend();
-//        pc.printf("Tx Time on Air: %d \r\n", sendTime);
-        
-        /***************************************************************************
-        * Fill Main Program Buffers With Data From Received Payload Buffer
-        **************************************************************************/
-        // Slave Device
-//        memcpy(ID_of_master,              &BufferRx[rx_idx_signature], size_signature);
-//        memcpy(curr_dum_from_master,      &BufferRx[rx_idx_dum],       size_of_dum);
+        SX1276SlaveSendData();   
         
-         /***************************************************************************
-        * Slave Device: Print out Master Data
-        **************************************************************************/
-        //        memcpy(ID_of_master,              &BufferRx[rx_idx_signature], size_signature);
-//        pc.printf("Print ID_of_master\r\n");
-//        for(int i = 0; i < sizeof(ID_of_master); i++){
-//            pc.printf("%d \r\n", ID_of_master[i]);
-//        }
-            
-        //        memcpy(curr_dum_from_master,      &BufferRx[rx_idx_dum],       size_of_dum);
-//        pc.printf("Print Dum From Master\r\n");
-//        for(int i = 0; i < sizeof(curr_dum_from_master); i++){
-//            pc.printf("%d \r\n", curr_dum_from_master[i]);
-//        }
-            
-        // print loop counter
-//        pc.printf("Loop Counter Slave: %d \r\n", loopCnt);
-        loopCnt = loopCnt + 1;
-    } // end of transmission frequency for slave
-    #endif    
+    }
+    
+    
+    
+    #endif
+    
+    while (1) {
+    
+    #if SLAVE == 1
     
     
-    #if MASTER == 1
+        /***************************************************************************
+        * LP0 Experiment
+        **************************************************************************/
+        //Clear existing wake-up config
+        LP_ClearWakeUpConfig();
+
+        //Clear any event flags
+        LP_ClearWakeUpFlags();
+
+        //configure wake-up on RTC compare 0
+        LP_ConfigRTCWakeUp(1, 0, 0, 0);
+
+
+        //set RTC compare 0 value
+        uint32_t cmp = RTC_GetCount() + LP0_WakeTime;
+        RTC_SetCompare(0,cmp);
+        RTC_ClearFlags(MXC_F_RTC_FLAGS_COMP0);
+
+        //interrupts are disabled in LP_EnterLP0
+        LP_EnterLP0();
+
+        //firmware will reset on wake-up
+    
+    #endif                  // end define for Slave    
+    
+    
+    #if MASTER == 1         // only Receive Sensor Data
     /***************************************************************************
      * Fill Payload Buffer With Data From Main Program Buffers for next LoRa Transmition
      **************************************************************************/
-    memcpy(&BufferTx[tx_idx_signature], PingMsg,           size_signature);
-//    memcpy(&BufferTx[tx_idx_dum],       curr_dum_to_slave, size_of_dum);
+    memcpy(&BufferTx[tx_idx_signature], PingMsg,           size_signature);         // no need
     
      /***************************************************************************
      * LoRa Communication: Gateway Receive Sensor Data
      **************************************************************************/
-//    SX1276GateWayReceive(333);
-    SX1276PingPong();
-//    int sendTime = TimeOnAirSend();
-//    pc.printf("Tx Time on Air: %d \r\n", sendTime);
+//    SX1276PingPong();
+    if(SX1276MasterCheckForNewData())
+    {
     
     /***************************************************************************
      * Fill Main Program Buffers With Data From Received Payload Buffer
@@ -444,46 +404,13 @@
     memcpy(curr_raw_temp_from_slave, &BufferRx[rx_idx_MAX30208],  size_of_MAX30208);
     memcpy(curr_raw_light_from_slave, &BufferRx[rx_idx_MAX44009], size_of_MAX44009);
     memcpy(curr_raw_AO32_from_slave,  &BufferRx[rx_idx_MAX20361],  size_of_MAX20361);
-//    memcpy(curr_raw_other_from_slave,  &BufferRx[rx_idx_other],  size_of_other);
 
     /***************************************************************************
     * Master Device: Print out Slave Data
     **************************************************************************/
     
-    //        memcpy(ID_of_slave,               &BufferRx[rx_idx_signature], size_signature);
-    //pc.printf("Print ID_of_slave\r\n");
-//    for(int i = 0; i < sizeof(ID_of_slave); i++){
-//        pc.printf("%d \r\n", ID_of_slave[i]); 
-//    }
-    
-    //        memcpy(curr_raw_temp_from_slave, &BufferRx[rx_idx_MAX30208],  size_of_MAX30208);
-//    pc.printf("Print MAX30208 data\r\n");
-//    for(int i = 0; i < sizeof(curr_raw_temp_from_slave); i++){
-//        pc.printf("[%02X]\r\n", curr_raw_temp_from_slave[i]); 
-//    } 
-    
-//    int count = curr_raw_temp_from_slave[0] * 256 +  curr_raw_temp_from_slave[1];
-//    if (count >= 32768)count = count - 65536;     // 2s comp
-//    double tempResult = count * 0.005; 
-    
     double tempResult = calc_temperature(curr_raw_temp_from_slave);
-//    pc.printf("MSG: [%.3f] [] [] [] []\r\n", tempResult);
-    
-            
-    //        memcpy(curr_raw_light_from_slave, &BufferRx[rx_idx_MAX44009], size_of_MAX44009);
-//     pc.printf("Print MAX44009 data\r\n");
-//    for(int i = 0; i < sizeof(curr_raw_light_from_slave); i++){
-//        pc.printf("[%02X] \r\n", curr_raw_light_from_slave[i]);
-//    }
-    
     int luxResult = (int) calc_lux(curr_raw_light_from_slave);
-//    pc.printf("MSG: [%.3f] [%.2f] [] [] []\r\n", tempResult, luxResult);
-            
-    //        memcpy(curr_raw_AO32_from_slave,  &BufferRx[rx_idx_MAX20361],  size_of_MAX20361);
-//    pc.printf("Print MAX20361 data\r\n");
-//    for(int i = 0; i < sizeof(curr_raw_AO32_from_slave); i++){
-//        pc.printf("[%02X] \r\n", curr_raw_AO32_from_slave[i]);
-//    }
     
     char OCVrawHex[2];
     OCVrawHex[0] = curr_raw_AO32_from_slave[0];
@@ -494,37 +421,18 @@
     
     double OCVResult = calc_OCV(OCVrawHex);
     int CntResult = calc_Harvest(CntrawHex);
-    
-    
-    // only print out new results
-//    int tempNew = memcmp(prev_raw_temp_from_slave, curr_raw_temp_from_slave, sizeof(size_of_MAX30208)); 
-//    int luxNew = memcmp(prev_raw_light_from_slave, curr_raw_light_from_slave, sizeof(size_of_MAX44009)); 
-//    int AO32New = memcmp(prev_raw_AO32_from_slave, curr_raw_AO32_from_slave, sizeof(size_of_MAX20361)); 
-    
-//    if (tempNew != 0 || luxNew != 0 || AO32New != 0) {
-    
-//        pc.printf("MSG: [%.3f] [%d] [%.2f] [%d] [0]\r\n", tempResult, luxResult, OCVResult, CntResult);
-    
-//    }
+        
+    //reset the flag
+    print_data_flag = false;        // no need
+    pc.printf("MSG: [%.3f] [%d] [%.2f] [%d] [0]\r\n", tempResult, luxResult, OCVResult, CntResult);
     
-    if(print_data_flag) {
-        
-        //reset the flag
-        print_data_flag = false;
-        pc.printf("MSG: [%.3f] [%d] [%.2f] [%d] [0]\r\n", tempResult, luxResult, OCVResult, CntResult);
-    
-    }
-    
-    // copy the current recceived data into previous data
-//    memcpy(prev_raw_temp_from_slave, curr_raw_temp_from_slave, sizeof(size_of_MAX30208));
-//    memcpy(prev_raw_light_from_slave, c/urr_raw_light_from_slave, sizeof(size_of_MAX44009));         
-//    memcpy(prev_raw_AO32_from_slave, curr_raw_AO32_from_slave, sizeof(size_of_MAX20361)); 
-    
-    // print loop counter
-//    pc.printf("Loop Counter Master: %d \r\n", loopCnt);
+    }   // end of SX1276MasterCheckForNewData
+
     loopCnt = loopCnt + 1;
     
-    #endif
+    #endif            // end define for Master
+        
+//    sleep();        // going back to sleep mode    
         
     } // end of while(1) loop
         

--- a/main.h	Wed Oct 14 00:19:02 2020 +0000
+++ b/main.h	Fri Oct 16 06:50:42 2020 +0000
@@ -8,49 +8,49 @@
 #define FEATURE_LORA
 
 
-#ifdef FEATURE_LORA             // in main.cpp
+//#ifdef FEATURE_LORA             // in main.cpp
 
 /* Set this flag to '1' to display debug messages on the console */
-#define DEBUG_MESSAGE   1
+//#define DEBUG_MESSAGE   1
 
 /* Set this flag to '1' to use the LoRa modulation or to '0' to use FSK modulation */
-#define USE_MODEM_LORA  1
-#define USE_MODEM_FSK   !USE_MODEM_LORA
-#define RF_FREQUENCY            RF_FREQUENCY_915_0  // Hz
-#define TX_OUTPUT_POWER         14                  // 14 dBm
+//#define USE_MODEM_LORA  1
+//#define USE_MODEM_FSK   !USE_MODEM_LORA
+//#define RF_FREQUENCY            RF_FREQUENCY_915_0  // Hz
+//#define TX_OUTPUT_POWER         14                  // 14 dBm
 
-#if USE_MODEM_LORA == 1
+//#if USE_MODEM_LORA == 1
 
-#define LORA_BANDWIDTH          125000  // LoRa default, details in SX1276::BandwidthMap
-#define LORA_SPREADING_FACTOR   LORA_SF7
-#define LORA_CODINGRATE         LORA_ERROR_CODING_RATE_4_5
+//#define LORA_BANDWIDTH          125000  // LoRa default, details in SX1276::BandwidthMap
+//#define LORA_SPREADING_FACTOR   LORA_SF7
+//#define LORA_CODINGRATE         LORA_ERROR_CODING_RATE_4_5
 
-#define LORA_PREAMBLE_LENGTH    8       // Same for Tx and Rx
-#define LORA_SYMBOL_TIMEOUT     5       // Symbols
-#define LORA_FIX_LENGTH_PAYLOAD_ON  false
-#define LORA_FHSS_ENABLED       false  
-#define LORA_NB_SYMB_HOP        4     
-#define LORA_IQ_INVERSION_ON    false
-#define LORA_CRC_ENABLED        true
+//#define LORA_PREAMBLE_LENGTH    8       // Same for Tx and Rx
+//#define LORA_SYMBOL_TIMEOUT     5       // Symbols
+//#define LORA_FIX_LENGTH_PAYLOAD_ON  false
+//#define LORA_FHSS_ENABLED       false  
+//#define LORA_NB_SYMB_HOP        4     
+//#define LORA_IQ_INVERSION_ON    false
+//#define LORA_CRC_ENABLED        true
     
-#elif USE_MODEM_FSK == 1
+//#elif USE_MODEM_FSK == 1
 
-#define FSK_FDEV                25000     // Hz
-#define FSK_DATARATE            19200     // bps
-#define FSK_BANDWIDTH           50000     // Hz
-#define FSK_AFC_BANDWIDTH       83333     // Hz
-#define FSK_PREAMBLE_LENGTH     5         // Same for Tx and Rx
-#define FSK_FIX_LENGTH_PAYLOAD_ON   false
-#define FSK_CRC_ENABLED         true
+//#define FSK_FDEV                25000     // Hz
+//#define FSK_DATARATE            19200     // bps
+//#define FSK_BANDWIDTH           50000     // Hz
+//#define FSK_AFC_BANDWIDTH       83333     // Hz
+//#define FSK_PREAMBLE_LENGTH     5         // Same for Tx and Rx
+//#define FSK_FIX_LENGTH_PAYLOAD_ON   false
+//#define FSK_CRC_ENABLED         true
     
-#else
-    #error "Please define a modem in the compiler options."
-#endif 
+//#else
+//    #error "Please define a modem in the compiler options."
+//#endif 
 
 
-#define RX_TIMEOUT_VALUE    3500    // in ms
+//#define RX_TIMEOUT_VALUE    3500    // in ms
 
-#endif
+//#endif
 
 /*
  *  Global variables declarations