Team Walter
MAX20361 System Demo with Low Power 2 mode
Dependencies: SX1276GenericLib USBDevice
Fork of
NonPingPong_PICO_LoRa
by 
Walter Luu
Diff: main.cpp
- Revision:
- 7:62c868478eef
- Parent:
- 6:51f492ca61a2
--- a/main.cpp Wed Oct 14 00:19:02 2020 +0000
+++ b/main.cpp Tue Oct 20 00:00:20 2020 +0000
@@ -1,6 +1,8 @@
#include "mbed.h"
+#include "lp.h"
+
// Board pins related
#include "PinMap.h"
@@ -25,11 +27,6 @@
// 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
@@ -38,15 +35,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
**************************************************************************/
@@ -84,99 +72,52 @@
/* 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
+
+ sleep(); // put slave in sleep mode
+
#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
-
/***************************************************************************
* 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
/***************************************************************************
@@ -188,31 +129,6 @@
// 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;
@@ -236,7 +152,7 @@
char MAX44009_i2c_add = 0x94; // 0b1001 010x
//************* AO32 Variables ****************
- char rawOCVdata[2]; // only needs 1
+ char rawOCVdata[1]; // only needs 1
char rawCntdata[2];
char AO32_i2c_add = 0x2A; // 0b0010 101x
@@ -267,7 +183,11 @@
while (1) {
- #if SLAVE == 1
+ #if SLAVE == 1 // only send sensor data
+
+ // Slave sleeps before interrupt calls
+ sleep();
+
if(get_data_flag) {
//reset the flag
@@ -281,17 +201,7 @@
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 +212,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
@@ -363,169 +243,64 @@
/***************************************************************************
* 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
- **************************************************************************/
- // 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);
+// SX1276PingPong();
+ SX1276SlaveSendData();
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);
+ #if MASTER == 1 // only Receive Sensor Data
/***************************************************************************
* 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
**************************************************************************/
- 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);
/***************************************************************************
* 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);
+ int luxResult = (int) calc_lux(curr_raw_light_from_slave);
-
- // 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];
+ char OCVrawHex[1];
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];
+ CntrawHex[0] = curr_raw_AO32_from_slave[1];
+ CntrawHex[1] = curr_raw_AO32_from_slave[2];
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
+ sleep(); // going back to sleep mode
+
} // end of while(1) loop
} // end of main()
\ No newline at end of file