Diff: main.cpp

Revision:

28:0ed92c590607

Parent:

27:6b549f838f0a

Child:

29:f7a0e49b826b

--- a/main.cpp	Fri Jul 20 21:29:53 2018 +0000
+++ b/main.cpp	Mon Jul 23 23:39:35 2018 +0000
@@ -28,7 +28,7 @@
 
 DigitalOut myled(LED);
 
-//Serial pc(USBTX, USBRX);
+Serial pc(USBTX, USBRX);
 
 
 #if   defined(TARGET_MAX32630FTHR) // Master Device: MAX32630FTHR BLE-to-LoRa Gateway
@@ -46,10 +46,6 @@
     GridEye gridEye(i2cGridEye);
 #endif
 
-
-/***************************************************************************
- * main()
- **************************************************************************/
 int main() 
 {
     /*
@@ -69,96 +65,7 @@
     #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
         dprintf("MAX32620FTHR: Slave");
     #endif
-
-/***************************************************************************
- * Lora Communication Buffers
- **************************************************************************/
-    /* Create Buffers to store both incoming and outgoing LoRa communications */
-    uint8_t BufferTx[BufferSizeTx];
-    uint8_t BufferRx[BufferSizeRx];
     
-/***************************************************************************
- * BLE Data Buffers
- **************************************************************************/
-    #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
-        uint8_t curr_ble_data_to_slave[size_of_ble];
-    #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
-        uint8_t curr_ble_data_from_master[size_of_ble];
-        uint8_t prev_ble_data_from_master[size_of_ble];
-    #endif
-/***************************************************************************
- * Grid Eye Sensor Data Buffers
- **************************************************************************/
-    #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
-        char curr_raw_frame_data_from_slave[size_of_grid_eye];
-        char prev_raw_frame_data_from_slave[size_of_grid_eye];
-        int16_t conv_frame_data_from_slave[64];
-    #elif defined(TARGET_MAX32620FTHR) // Client Device: LoRa Controlled Robot
-        char curr_raw_frame_data_to_master[size_of_grid_eye];
-        char prev_raw_frame_data_to_master[size_of_grid_eye];
-        int16_t conv_frame_data_to_master[64];
-    #endif
-/***************************************************************************
- * GPS Data Buffers
- **************************************************************************/
-    #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
-        uint8_t curr_gps_data_from_slave[size_of_gps];
-        uint8_t prev_gps_data_from_slave[size_of_gps];
-    #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
-        uint8_t curr_gps_data_to_master[size_of_gps];
-    #endif
-/***************************************************************************
- * MAX17055 Data Buffers
- **************************************************************************/
-    #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
-        uint8_t curr_MAX17055_from_slave[size_of_MAX17055];
-        uint8_t prev_MAX17055_from_slave[size_of_MAX17055];
-    #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
-        uint8_t curr_MAX17055_to_master[size_of_MAX17055];
-    #endif
-    
-/***************************************************************************
- * MAX77650 Data Buffers
- **************************************************************************/
-    #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
-        uint8_t curr_MAX77650_from_slave[size_of_MAX77650];
-        uint8_t prev_MAX77650_from_slave[size_of_MAX77650];
-    #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
-        uint8_t curr_MAX77650_to_master[size_of_MAX77650];
-    #endif
-/***************************************************************************
- * Store Aliases to the buffers created here in main porgram
- **************************************************************************/
-#if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
-createAliasesForGlobalBufs(BufferTx,
-                           BufferRx, 
-                           curr_ble_data_to_slave,
-                           curr_raw_frame_data_from_slave,
-                           curr_gps_data_from_slave,
-                           curr_MAX17055_from_slave,
-                           curr_MAX77650_from_slave
-                           );
-#elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
-createAliasesForGlobalBufs(BufferTx, 
-                           BufferRx, 
-                           curr_ble_data_from_master,
-                           curr_raw_frame_data_to_master, 
-                           curr_gps_data_to_master,
-                           curr_MAX17055_to_master,
-                           curr_MAX77650_to_master
-                           );
-#endif
-/***************************************************************************
- * Continue with Finishing Setup by Calling other functions
- **************************************************************************/
-    
-    
-    /* Pass in pointers to the two buffers for LoRa communication to the sx1276 
-    `* Setup so that the LoRa communications know where data needs to be both
-     * stored to in a case of Receiving or where to find data in case of a 
-     * Transmistion occuring.
-     */
-    SX1276PingPongSetup(BufferTx, BufferRx);
     
     /***************************************************************************
      * Grid Eye Sensor: Non-Buffer Program Variables
@@ -168,26 +75,84 @@
     #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
         // none yet
         int frame_idx = 0;
-        char local_curr_raw_frame_data_to_master[size_of_grid_eye];
-        char local_prev_raw_frame_data_to_master[size_of_grid_eye];
-        int16_t local_conv_frame_data_to_master[64];
     #endif
     
     
+    /***************************************************************************
+     * Combined Payload Buffers for LoRa Communications
+     **************************************************************************/
+    uint8_t BufferTx[BufferSizeTx];
+    uint8_t BufferRx[BufferSizeRx];
+    
+    /***************************************************************************
+     * BLE Data Buffers
+     **************************************************************************/
+    #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
+        uint8_t curr_ble_to_slave[size_of_ble];
+    #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
+        uint8_t curr_ble_from_master[size_of_ble];
+        uint8_t prev_ble_from_master[size_of_ble];
+    #endif
+    
+    /***************************************************************************
+     * Grid Eye Sensor Data Buffers
+     **************************************************************************/
+    #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
+        char curr_raw_frame_from_slave[size_of_grid_eye];
+        char prev_raw_frame_from_slave[size_of_grid_eye];
+        int16_t conv_frame_from_slave[64];
+    #elif defined(TARGET_MAX32620FTHR) // Client Device: LoRa Controlled Robot
+        char curr_raw_frame_to_master[size_of_grid_eye];
+        char prev_raw_frame_to_master[size_of_grid_eye];
+        int16_t conv_frame_to_master[64];
+    #endif
+    
+    /***************************************************************************
+     * GPS Data Buffers
+     **************************************************************************/
+    #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
+        uint8_t curr_gps_from_slave[size_of_gps];
+        uint8_t prev_gps_from_slave[size_of_gps];
+    #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
+        uint8_t curr_gps_to_master[size_of_gps];
+    #endif
+    
+    /***************************************************************************
+     * MAX17055 Data Buffers
+     **************************************************************************/
+    #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
+        uint8_t curr_MAX17055_from_slave[size_of_MAX17055];
+        uint8_t prev_MAX17055_from_slave[size_of_MAX17055];
+    #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
+        uint8_t curr_MAX17055_to_master[size_of_MAX17055];
+    #endif
+    
+    /***************************************************************************
+     * MAX77650 Data Buffers
+     **************************************************************************/
+    #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
+        uint8_t curr_MAX77650_from_slave[size_of_MAX77650];
+        uint8_t prev_MAX77650_from_slave[size_of_MAX77650];
+    #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
+        uint8_t curr_MAX77650_to_master[size_of_MAX77650];
+    #endif
+    
+    /***************************************************************************
+     * Finish Setting up LoRa Radios: This passes in pointers to Buffers to send
+     **************************************************************************/
+    SX1276PingPongSetup(BufferTx, BufferRx);
+    
     while(1) 
-    {
+    {        
         /***************************************************************************
          * Grid Eye Sensor 
          **************************************************************************/
         #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
-            /*
-            //Check to see if the contents of the previous scan are the same. If they are different then continue with converting
-            if( memcmp(prev_raw_frame_data_from_slave, curr_raw_frame_data_from_slave, sizeof(curr_raw_frame_data_from_slave)) != 0 )
+            // Check to see if the contents of the previous scan are the same. If they are different then continue with converting
+            if( memcmp(prev_raw_frame_from_slave, curr_raw_frame_from_slave, sizeof(curr_raw_frame_from_slave)) != 0 )
             {
                 // Convert raw data sent from slave to a 16 bit integer array by calling this
-                convRaw8x8Data2Point25degC(curr_raw_frame_data_from_slave, conv_frame_data_from_slave);
-                
-                wait_ms(10);
+                convRaw8x8Data2Point25degC(curr_raw_frame_from_slave, conv_frame_from_slave);
                 
                 // Next Print off the Converted data
                 pc.printf("\r\nFrame %d data: \r\n", frame_idx);
@@ -196,7 +161,7 @@
                 for (int y = 0; y < 8; y++) {
                     for (int x = 0; x < 8; x++) {
                         idx = y*8 + x;
-                        pixel_data = conv_frame_data_from_slave[idx]/4.0;
+                        pixel_data = ((float)conv_frame_from_slave[idx])/4.0;
                         pc.printf("%.2f  \t", pixel_data);
                     }
                     pc.printf("\r\n\r\n");
@@ -206,26 +171,24 @@
                 // Increment frame counter
                 frame_idx = frame_idx +1;
             }
-            */
+            
             /* Next copy in data received from current data into buffer used for
              * comparison next time the memcmp above is called. This prevents the 
              * program from converting the same raw data aquired by the grid eye
              * sensor on the slave device to the floating point array with the 
              * 0.25 degrees celsius precision level when there is not new data. 
              */
-            //memcpy(prev_raw_frame_data_from_slave, curr_raw_frame_data_from_slave, sizeof(curr_raw_frame_data_from_slave));
+            memcpy(prev_raw_frame_from_slave, curr_raw_frame_from_slave, sizeof(curr_raw_frame_from_slave));
             
         #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
             // Aquire raw data about 8x8 frame from the grid eye sensor in this function call 
-            gridEye.getRaw8x8FrameData(local_curr_raw_frame_data_to_master);
-            wait_ms( 10 );  
-/*            
-            if ( memcmp(prev_raw_frame_data_to_master, curr_raw_frame_data_to_master, sizeof(curr_raw_frame_data_to_master)) != 0 )
-            {
+            gridEye.getRaw8x8FrameData(curr_raw_frame_to_master);
+            wait_ms( 10 );
+            /*
+            //if ( memcmp(prev_raw_frame_to_master, curr_raw_frame_to_master, sizeof(curr_raw_frame_to_master)) != 0 )
+            //{
                 // Convert raw data sent from slave to a 16 bit integer array by calling this
-                convRaw8x8Data2Point25degC(local_curr_raw_frame_data_to_master, local_conv_frame_data_to_master);
-                
-                wait_ms(10);
+                convRaw8x8Data2Point25degC(curr_raw_frame_to_master, conv_frame_to_master);
                 
                 // Next Print off the Converted data
                 pc.printf("\r\nFrame %d data: \r\n", frame_idx);
@@ -234,7 +197,7 @@
                 for (int y = 0; y < 8; y++) {
                     for (int x = 0; x < 8; x++) {
                         idx = y*8 + x;
-                        pixel_data = local_conv_frame_data_to_master[idx]/4.0;
+                        pixel_data = conv_frame_to_master[idx]/4.0;
                         pc.printf("%.2f  \t", pixel_data);
                     }
                     pc.printf("\r\n\r\n");
@@ -243,19 +206,46 @@
                 
                 // Increment frame counter
                 frame_idx = frame_idx +1;
-            }
-*/          
-            
-            memcpy(curr_raw_frame_data_to_master, local_curr_raw_frame_data_to_master, sizeof(curr_raw_frame_data_to_master));
-            memcpy(local_prev_raw_frame_data_to_master, local_curr_raw_frame_data_to_master, sizeof(local_curr_raw_frame_data_to_master));
+            //}
+            */
+            memcpy(prev_raw_frame_to_master, curr_raw_frame_to_master, sizeof(curr_raw_frame_to_master));
         #endif
-
+        
+        
         /***************************************************************************
-        * Lora Communications
-        **************************************************************************/
-
+         * Fill Payload Buffer With Data From Sensors for LoRa Transmition
+         **************************************************************************/
+        #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
+            memcpy(&BufferTx[tx_idx_signature], PingMsg,           size_signature);
+            memcpy(&BufferTx[tx_idx_ble],       curr_ble_to_slave, size_of_ble);
+        #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
+            memcpy(&BufferTx[tx_idx_signature], PongMsg,                  size_signature);
+            memcpy(&BufferTx[tx_idx_grid_eye],  curr_raw_frame_to_master, size_of_grid_eye);
+            memcpy(&BufferTx[tx_idx_gps],       curr_gps_to_master,       size_of_gps);
+            memcpy(&BufferTx[tx_idx_MAX17055],  curr_MAX17055_to_master,  size_of_MAX17055);
+            memcpy(&BufferTx[tx_idx_MAX77650],  curr_MAX77650_to_master,  size_of_MAX77650);
+        #endif
+        
+        
+        
+        /***************************************************************************
+         * Lora Communications
+         **************************************************************************/
         wait_ms( 10 );  
         SX1276PingPong();
+        
+        /***************************************************************************
+         * Fill Global Buffers With Data From Received Payload Buffer
+         **************************************************************************/
+        /* The master and slave devices will have different requirements for offloading payload */
+        #if   defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
+            memcpy(curr_raw_frame_from_slave, &BufferRx[rx_idx_grid_eye], size_of_grid_eye);
+            memcpy(curr_gps_from_slave,       &BufferRx[rx_idx_gps],      size_of_gps);
+            memcpy(curr_MAX17055_from_slave,  &BufferRx[rx_idx_MAX17055], size_of_MAX17055);
+            memcpy(curr_MAX77650_from_slave,  &BufferRx[rx_idx_MAX77650], size_of_MAX77650);
+        #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
+            memcpy(curr_ble_from_master,      &BufferRx[rx_idx_ble],      size_of_ble);
+        #endif
     
         
         
@@ -264,6 +254,3 @@
     }
     
 }
-
-
-