Revision 7:c92ed2d6e344, committed 2020-10-16

Comitter:

walterluu

Date:

Fri Oct 16 06:48:08 2020 +0000

Parent:

6:51f492ca61a2

Commit message:

MAX32625PICO 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:48:08 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:48:08 2020 +0000
@@ -110,4 +110,8 @@
  */
 int numOfRxTimeouts();
 
+bool SX1276MasterCheckForNewData(void);
+
+void SX1276SlaveSendData(void);
+
 #endif // __MAIN_H__
\ No newline at end of file

--- a/global_buffers.h	Wed Oct 14 00:19:02 2020 +0000
+++ b/global_buffers.h	Fri Oct 16 06:48:08 2020 +0000
@@ -28,12 +28,12 @@
 /***************************************************************************
  * MASTER Device
  **************************************************************************/\
-//#define MASTER 1
+#define MASTER 1
 
 /***************************************************************************
  * SLAVE Device
  **************************************************************************/\
-#define SLAVE 1
+//#define SLAVE 1
 
 
 /***************************************************************************

--- a/main.cpp	Wed Oct 14 00:19:02 2020 +0000
+++ b/main.cpp	Fri Oct 16 06:48:08 2020 +0000
@@ -1,531 +1,87 @@
-
 #include "mbed.h"
 
-// Board pins related
-#include "PinMap.h"
-
-// LORA related
-#include "global_buffers.h"
-#include "GenericPingPong2.h"
-#define FEATURE_LORA
-#include "sx1276-mbed-hal.h"
-
-#include "main.h"
-
-// OT07 related
-#include "OT07_lib.h"      
-#define CONVERT_T_DELAY 30 
-
-// MAX44009 related
-#include "MAX44009_lib.h"    
-
-// AO32 related
-#include "AO32_lib.h" 
-
-// AO19 related
-#include "AO19_lib.h"
-
-//#if defined(TARGET_MAX32630FTHR) // using the RFM95 board
-//    #include "max32630fthr.h"
-//    MAX32630FTHR pegasus(MAX32630FTHR::VIO_3V3);
-//#endif
-
-// Virtual COM related
-#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);
-
-///***************************************************************************
-// * 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);
+// Low Power Mode
+#include "lp.h"
+#include "mxc_config.h"
+#include "lp.h"
+#include "rtc.h"
+//#define LP1_WakeTime    3 //seconds
+#define LP0_WakeTime    3 //seconds
 
 /***************************************************************************
  * LEDs Instantiation
  **************************************************************************/
-DigitalOut myled(LED2);          // LED = LED2 green
-DigitalOut rLED(LED1);          // red LED
-DigitalOut bLED(LED3);          // blue LED
-//DigitalOut *led3;
-
-/***************************************************************************
- * I2C Bus Instantiation
- **************************************************************************/
-I2C i2cBus0(P1_6, P1_7);            // I2C of MAX32625PICO
+//DigitalOut gLED(LED2);          // green LED
+//DigitalOut rLED(LED1);          // red LED
+//DigitalOut bLED(LED3);          // blue LED
 
 
-bool get_data_flag = false;         // used for data tramission frequency on the SENSOR side
-bool print_data_flag = false;       // used for data display on the GATEWAY side
-
-//Timer setup
-Ticker timer_1;                     // timer for data tramission frequency on the SENSOR side
-Ticker timer_M;                     // timer for data print out on the GATEWAY side
+// *****************************************************************************
+void RTC_Setup()
+{
+    rtc_cfg_t RTCconfig;
 
-void onTimerInterrupt(){
-    get_data_flag = true;
-}
+    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;
 
-void onGatewayInterrupt(){
-    print_data_flag = true;
+    RTC_Init(&RTCconfig);
+
+    RTC_Start();
 }
 
 int main() {
-
-/***************************************************************************
-
  
- 
-    /* Setup begins here: */
-    #if   MASTER == 1 // Master Device
-//        pc.printf("MAX32625PICO: MASTER DEVICE\r\n");
-//        wait(1);
-    #elif SLAVE == 1 // Slave Device
-//        pc.printf("MAX32625PICO: SLAVE DEVICE\r\n");
-//        wait(1);
-    #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
-     **************************************************************************/
-    uint8_t BufferTx[BufferSizeTx];             // more info in global_buffers.h
-    uint8_t BufferRx[BufferSizeRx];             // more info in global_buffers.h
-    
-    /***************************************************************************
-     * Identification Buffers
-     **************************************************************************/
-    #if   MASTER == 1 // Master Device
-        uint8_t ID_of_slave[size_signature]; 
-    #elif SLAVE == 1 // Slave Device
-        uint8_t ID_of_master[size_signature];
-    #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
+    // Set all LEDs off
+//    gLED = LED_OFF;
+//    rLED = LED_OFF;
+//    bLED = LED_OFF;
     
     
-    /***************************************************************************
-     * 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
-    
-    /***************************************************************************
-     * Finish Setting up LoRa Radios: This passes in pointers to Buffers to send
-     **************************************************************************/
-    SX1276PingPongSetup(BufferTx, BufferRx, &pc);
-    
-//    Pointer Tutorials
-//    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;    
-     #endif
-    
-    /***************************************************************************
-     * Loop Counter
-     **************************************************************************/
-    int loopCnt = 0;
-    
-    #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
-    
-    //************* OT07 Variables  **************** 
-    char rawtempdata[2];          
-    char OT07_i2c_add = 0xA0;
-    
-    //************* MAX44009 Variables  ****************
-    char rawluxdata[2];          
-    char MAX44009_i2c_add = 0x94;      // 0b1001 010x
-    
-    //************* AO32 Variables  ****************
-    char rawOCVdata[2];                 // only needs 1
-    char rawCntdata[2];
-    char AO32_i2c_add = 0x2A;      // 0b0010 101x
-    
-     //************* AO19 Settings  ****************
-    // Enable AO19
-    char AO19_i2c_add = 0xD0;      // 
-    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) {
-//        pc.printf("AO19 Enabled fail!\r\n");
-//    }
-//    else {
-//        pc.printf("AO19 Enabledsuccess!\r\n");
-//    } 
+     // LP0 Wake Up call
+    if(LP_IsLP0WakeUp()){
+        wait(1);
+    }  
     
     
-    #endif
-    
+    //configure RTC and start
+    RTC_Setup();
+
     while (1) {
-    
-    #if SLAVE == 1
-    if(get_data_flag) {
-        
-        //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];
-        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 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 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
-        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
+        // Set all LEDs off
+//        gLED = LED_OFF;
+//        rLED = LED_OFF;
+//        bLED = LED_OFF;
         
-        // 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);
-//        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);
-        
-         /***************************************************************************
-        * Slave Device: Print out Master Data
+        * LP0 Experiment
         **************************************************************************/
-        //        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    
-    
-    
-    #if MASTER == 1
-    /***************************************************************************
-     * 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);
-    
-     /***************************************************************************
-     * LoRa Communication: Gateway Receive Sensor Data
-     **************************************************************************/
-//    SX1276GateWayReceive(333);
-    SX1276PingPong();
-//    int sendTime = TimeOnAirSend();
-//    pc.printf("Tx Time on Air: %d \r\n", sendTime);
-    
-    /***************************************************************************
-     * Fill Main Program Buffers With Data From Received Payload Buffer
-     **************************************************************************/
-    memcpy(ID_of_slave,               &BufferRx[rx_idx_signature], size_signature);
-    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);
+        //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);
+
 
-    /***************************************************************************
-    * 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];
-    OCVrawHex[1] = curr_raw_AO32_from_slave[1];
-    char CntrawHex[2];
-    CntrawHex[0] = curr_raw_AO32_from_slave[2];
-    CntrawHex[1] = curr_raw_AO32_from_slave[3];
-    
-    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);
-    
-//    }
-    
-    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);
-    loopCnt = loopCnt + 1;
-    
-    #endif
-        
+        //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
+
     } // end of while(1) loop
         
 }  // end of main()
\ No newline at end of file

--- a/main.h	Wed Oct 14 00:19:02 2020 +0000
+++ b/main.h	Fri Oct 16 06:48:08 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