File content as of revision 3:85fc843a9d7d:

#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" 

//#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);

/***************************************************************************
 * 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


bool get_data_flag = false;         // used for data tramission frequency


//Timer setup
Ticker timer_1;                     // timer for data tramission frequency


void onTimerInterrupt(){
    get_data_flag = true;
}

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];
//        uint8_t prev_MAX77650_from_slave[size_of_MAX77650];
        uint8_t prev_raw_temp_from_slave[size_of_MAX30208];
//        bool chrg_status = false;; //True = ON False = OFF    
    #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];
        uint8_t 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];
        uint8_t 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[size_of_MAX30208] = {10, 13, 15, 17, 19};
    curr_raw_temp_to_master[0] = 99;
    curr_raw_temp_to_master[1] = 99;
//    curr_raw_temp_to_master[2] = 15;
//    curr_raw_temp_to_master[3] = 17;
//    curr_raw_temp_to_master[4] = 19;
//    curr_raw_light_to_master[size_of_MAX44009] = {25, 26, 27, 28, 29};
    curr_raw_light_to_master[0] = 25;
    curr_raw_light_to_master[1] = 26;
//    curr_raw_light_to_master[2] = 27;
//    curr_raw_light_to_master[3] = 28;
//    curr_raw_light_to_master[4] = 29;
//    curr_raw_AO32_to_master[size_of_MAX20361] = {99, 100, 101, 102, 103};
    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_AO32_to_master[4] = 103;
//    curr_raw_other_to_master[size_of_other] = {20, 30, 40, 50, 60, 70, 80};
//    curr_raw_other_to_master[0] = 20;
//    curr_raw_other_to_master[1] = 30;
//    curr_raw_other_to_master[2] = 40;
//    curr_raw_other_to_master[3] = 50;
//    curr_raw_other_to_master[4] = 60;
//    curr_raw_other_to_master[5] = 70;
//    curr_raw_other_to_master[6] = 80;
    
    
     #endif
    
    /***************************************************************************
     * Loop Counter
     **************************************************************************/
    int loopCnt = 0;
    
    #if SLAVE == 1
    //************* init ticker timer callbacks  ****************
    timer_1.attach(&onTimerInterrupt, 3);        //LED3 toggles every 3 seconds
    
    //************* OT07 Variables  ****************
//    char data[5];   
    char rawtempdata[2];          
    char OT07_i2c_add = 0xA0;
//    TempResponse T;
    
    //************* MAX44009 Variables  ****************
    char rawluxdata[2];          
    char MAX44009_i2c_add = 0x96;      // 0b1001 011x
    
    //************* AO32 Variables  ****************
    char rawOCVdata[2];                 // only needs 1
    char rawCntdata[2];
    char AO32_i2c_add = 0x2A;      // 0b0010 101x
    
    #endif
    
    while (1) {
        
    // Application details:
    //1. Set a fixed timer.
    //2. Data sent from Master to Slave.
    //3. Display data and repeat from 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);
        
        //fill raw temp data into the array
        curr_raw_temp_to_master[0] = rawtempdata[0];
        curr_raw_temp_to_master[1] = rawtempdata[1];      
            
       // for (int i = 0; i < 3; i++) {
//            convert_temperature(&i2cBus0, i2c_add);  //send OW convert selected device
//            wait_ms(CONVERT_T_DELAY);  //wait 20 ms for convert temperature to complete 
//            T = get_temperature(&i2cBus0, i2c_add);
//            pc.printf("OT07  temperature[%.3f]  status[%d]\r\n", T.tempC, T.status);
//        }
        
        /***************************************************************************
        * 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) + 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[%f]  status[%d] status[%d]\r\n", lux, lux_error1, lux_error2);
        
        //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 = int(rawOCVdata[0]) / 100;
        pc.printf("AO32  OCV[%.2f]  status[%d]\r\n", voltage, ocv_error);  
        
        //calculate harvesting counts from data
        int countHi = int(rawCntdata[0] << 8); // might cause trouble, * 256 instead?
        int countLo = int(rawCntdata[1]);
        int harvest_counts = countHi + countLo;
        pc.printf("AO32  HarvesterCnt[%d]  status[%d]\r\n", harvest_counts, cnt_error); 
        
        //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
        
        /***************************************************************************
        * 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);
        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);

    /***************************************************************************
    * 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("%d \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; 
//    pc.printf("OT07  temperature[%.3f]  status[%d]\r\n", Temp, error);
    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("%d \r\n", curr_raw_light_from_slave[i]);
//    }
            
    //        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("%d \r\n", curr_raw_AO32_from_slave[i]);
//    }
            
    //        memcpy(curr_raw_other_from_slave,  &BufferRx[rx_idx_other],  size_of_other);
    //pc.printf("Print Other data\r\n");
//    for(int i = 0; i < sizeof(curr_raw_other_from_slave); i++){
//        pc.printf("%d \r\n", curr_raw_other_from_slave[i]);
//    }
    
    // print loop counter
    pc.printf("Loop Counter Master: %d \r\n", loopCnt);
    loopCnt = loopCnt + 1;
    
//    wait(3);
    
    #endif
        
    ///***************************************************************************
//     * Fill Payload Buffer With Data From Main Program Buffers for next LoRa Transmition
//     **************************************************************************/
//    #if   MASTER == 1 // Master Device
//        memcpy(&BufferTx[tx_idx_signature], PingMsg,           size_signature);
//        memcpy(&BufferTx[tx_idx_dum],       curr_dum_to_slave, size_of_dum);
//    #elif SLAVE == 1 // Slave Device
//        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);
//    #endif
//    
//    /***************************************************************************
//     * In case of OnRxTimeout
//     **************************************************************************/
//    #if   MASTER == 1 // Master Device, these are values when LoRa communication did not happen
//        ID_of_slave[0] = 10; // 
//        ID_of_slave[1] = 11; // 
//        ID_of_slave[2] = 12; // 
//        ID_of_slave[3] = 13; // 
//        ID_of_slave[4] = 14; // 
//        ID_of_slave[5] = 15; // 
//        ID_of_slave[6] = 16; // 
//        ID_of_slave[7] = 17; // 
//    
//    #elif SLAVE == 1 // 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;       
//    
//    #endif
//
//
//    /***************************************************************************
//     * Lora Communications
//     **************************************************************************/
//    #if   MASTER == 1 // Master Device
//        SX1276GateWayReceive();
//    
//    #elif SLAVE == 1 // Slave Device
//        SX1276SensorSend(); 
//        int sendTime = TimeOnAirSend();
//        pc.printf("Tx Time on Air: %d \r\n", sendTime);
//    #endif  
//    
////    SX1276PingPong();           // what changes here?
//    
//    
//    /***************************************************************************
//     * Fill Main Program Buffers With Data From Received Payload Buffer
//     **************************************************************************/
//    /* The master and slave devices will have different requirements for offloading payload */
//    #if   MASTER == 1 // Master Device
//        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);
//    #elif SLAVE == 1 // Slave Device
//        memcpy(ID_of_master,              &BufferRx[rx_idx_signature], size_signature);
//        memcpy(curr_dum_from_master,      &BufferRx[rx_idx_dum],       size_of_dum);
//    #endif    
//        
//       
//    /***************************************************************************
//     * Print Out Data Received
//     **************************************************************************/       
//    #if   MASTER == 1 // Master Device
//    
////        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("%d \r\n", curr_raw_temp_from_slave[i]); 
//            }
//            
////        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("%d \r\n", curr_raw_light_from_slave[i]);
//            }
//            
////        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("%d \r\n", curr_raw_AO32_from_slave[i]);
//            }
//            
////        memcpy(curr_raw_other_from_slave,  &BufferRx[rx_idx_other],  size_of_other);
//        pc.printf("Print Other data\r\n");
//        for(int i = 0; i < sizeof(curr_raw_other_from_slave); i++){
//            pc.printf("%d \r\n", curr_raw_other_from_slave[i]);
//            }
//    
//    // print loop counter
//    pc.printf("Loop Counter Master: %d \r\n", loopCnt);
//    loopCnt = loopCnt + 1;
//            
//    #elif SLAVE == 1 // Slave Device
////        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;
//    #endif    
           
    // add delay to slow down
    //    wait(1);
        
        
//        }  //end of get_data_flag
    
    } // end of while(1) loop
        
}  // end of main()