Diff: main.cpp

Revision:

9:e13e02aa4a2f

Parent:

8:332099ece6e9

Child:

11:9590f3c9d915

--- a/main.cpp	Wed Jul 27 04:37:58 2016 +0000
+++ b/main.cpp	Fri Jul 29 04:00:09 2016 +0000
@@ -52,6 +52,311 @@
     return 0;
 }
 
+/*
+ * Format: 
+ * <        :start flag
+ * 02       :command
+ * xx       :length
+ * xx:      :00: get, 01: set
+ * xx       :index for parameters
+ * ...
+ * ff       :checksum
+ * >        :end flag
+ */
+int configureRadio(uint8_t *payload, uint8_t payload_length, uint8_t *response, uint8_t *response_length)
+{
+    // read settings from radio
+#if USE_MODEM_LORA == 1
+    AlohaTransceiver::LoRaSettings_t *settings = aloha.getSettings();
+#elif USE_MODEM_FSK == 1
+    AlohaTransceiver::FskSettings_t *settings = aloha.getSettings();
+#else
+    #error "Please define a modem in the compiler options."
+#endif
+
+    if (payload_length < 2)
+    {
+        sprintf((char *) response, "Wrong Payload Length\r\n");
+        *response_length = 22;
+        return 1;
+    }
+    
+    // true is set, false is get
+    bool isSet = (bool) payload[0];
+    uint8_t idx = payload[1];
+    
+    switch(idx)
+    {
+        case 0x00: // Power
+        {
+            if (isSet)
+            {
+                int8_t Power = (int8_t) payload[2];
+                settings->Power = Power;
+                
+                return 0;
+            }
+            else
+            {
+                response[0] = (uint8_t) settings->Power;
+                *response_length = 1;
+
+                return 0;
+            }
+        }
+        
+        case 0x01: // Bandwidth
+        {
+            if (isSet)
+            {
+                uint32_t Bandwidth = (payload[5]) | 
+                                     (payload[4] << 8) |
+                                     (payload[3] << 16) | 
+                                     (payload[2] << 24);
+                settings->Bandwidth = Bandwidth;
+                
+                return 0;
+            }
+            else
+            {
+                response[3] = (uint8_t) (settings->Bandwidth);
+                response[2] = (uint8_t) (settings->Bandwidth >> 8);
+                response[1] = (uint8_t) (settings->Bandwidth >> 16);
+                response[0] = (uint8_t) (settings->Bandwidth >> 24);
+                *response_length = 4;
+                
+                return 0;
+            }
+            
+        }
+        
+        case 0x02: // Datarate, AKA Spreading Factor
+        {
+            if (isSet)
+            {
+                uint32_t Datarate = (payload[5]) | 
+                                    (payload[4] << 8) |
+                                    (payload[3] << 16) | 
+                                    (payload[2] << 24);
+                settings->Datarate = Datarate;
+                
+                return 0;
+            }
+            else
+            {
+                response[3] = (uint8_t) (settings->Datarate);
+                response[2] = (uint8_t) (settings->Datarate >> 8);
+                response[1] = (uint8_t) (settings->Datarate >> 16);
+                response[0] = (uint8_t) (settings->Datarate >> 24);
+                *response_length = 4;
+                
+                return 0;
+            }
+        }
+        
+        case 0x03: // Coderate
+        {
+            if (isSet)
+            {
+                uint8_t Coderate = payload[2];
+                settings->Coderate = Coderate;
+                
+                return 0;
+            }
+            else
+            {
+                response[0] = (uint8_t) settings->Coderate;
+                *response_length = 1;
+
+                return 0;
+            }
+        }
+        
+        case 0x04: //Preamble Length
+        {
+            if (isSet) 
+            {
+                uint16_t PreambleLen = payload[3] | (payload[2] << 8);
+                settings->PreambleLen = PreambleLen;
+                return 0;
+            }
+            else
+            {
+                response[1] = (uint8_t) (settings->PreambleLen);
+                response[0] = (uint8_t)(settings->PreambleLen >> 8);
+                *response_length = 2;
+                
+                return 0;
+            }
+        }
+        
+        case 0x05: //Symbol Timeout
+        {
+             if (isSet) 
+             {
+                 uint16_t SymbolTimeout = payload[3] | (payload[2] << 8);
+                 settings->SymbolTimeout = SymbolTimeout;
+                 return 0;
+             }
+             else 
+             {
+                 response[1] = (uint8_t) (settings->SymbolTimeout);
+                 response[0] = (uint8_t) (settings->SymbolTimeout >> 8);
+                 *response_length = 2;
+                 
+                 return 0;
+             }
+        }
+        
+        case 0x06: //FixLen
+        {
+             if (isSet) 
+             {
+                 bool FixLen = payload[2];
+                 settings->FixLen = FixLen;
+                 return 0;
+             }
+             else 
+             {
+                 response[0] = (bool) (settings->SymbolTimeout);
+                 *response_length = 1;
+                 
+                 return 0;
+             }
+        }
+        
+        case 0x07: //PayloadLen
+        {
+             if (isSet)
+             {
+                 uint8_t PayloadLen = payload[2];
+                 settings->PayloadLen = PayloadLen;
+                 return 0;
+             }
+             else 
+             {
+                 response[0] = (uint8_t) (settings->PayloadLen);
+                 
+                 return 0;
+            }
+        }
+        
+        case 0x08: //CrcOn
+        {
+            if (isSet) {
+                bool CrcOn = payload[2];
+                settings->CrcOn = CrcOn;
+                return 0;
+            }
+            else 
+            {
+                response[0] = (bool) (settings->CrcOn);
+                
+                return 0;
+            }
+        }
+        
+        case 0x09: //FreqHopOn
+        {
+             if (isSet) {
+                 bool FreqHopOn = payload[2];
+                 settings->FreqHopOn = FreqHopOn;
+                 return 0;
+            }
+            else 
+            {
+                response[0] = (bool) (settings->FreqHopOn);
+                
+                return 0;
+            }
+        }
+        
+        case 0x0A: //HopPeriod
+        {
+             if (isSet) {
+                 uint8_t HopPeriod = payload[2];
+                 settings->HopPeriod = HopPeriod;
+                 return 0;
+            }
+            else 
+            {
+                response[0] = (uint8_t) (settings->HopPeriod);
+                return 0;
+            }
+        }
+        
+        case 0x0B: //IqInverted
+        {
+             if (isSet) {
+                 bool IqInverted = payload[2];
+                 settings->IqInverted = IqInverted;
+                 return 0;
+            }
+            else 
+            {
+                response[0] = (bool) (settings->IqInverted);
+                return 0;
+            }
+        }
+        
+        case 0x0C: //RxContinuous
+        {
+             if(isSet) 
+             {
+                 bool RxContinuous = payload[2];
+                 settings->RxContinuous = RxContinuous;
+                 return 0;
+            }
+            else 
+            {
+                response[0] = (bool) (settings->RxContinuous);
+                return 0;
+            }
+        }
+        
+        case 0x0D: //TxTimeout
+        {
+             if (isSet) 
+             {
+                 uint32_t TxTimeout = (payload[5]) | 
+                                (payload[4] << 8) |
+                                (payload[3] << 16) | 
+                                (payload[2] << 24);
+                settings->TxTimeout = TxTimeout;
+                return 0;
+            }
+            else 
+            {
+                response[3] = (uint8_t) (settings->TxTimeout);
+                response[2] = (uint8_t) (settings->TxTimeout >> 8);
+                response[1] = (uint8_t) (settings->TxTimeout >> 16);
+                response[0] = (uint8_t) (settings->TxTimeout >> 24);
+                *response_length = 4;
+                
+                return 0;
+            }
+        }
+                 
+        
+        default:
+        {
+            break;
+        }
+        
+        //case 
+    }
+        
+    
+    return 0;
+}
+
+int radioUpdateSettings(uint8_t *payload, uint8_t payload_length, uint8_t *response, uint8_t *response_length)
+{
+    aloha.updateSettings();
+    
+    return 0;
+}
+
 int sendMessage(uint8_t *payload, uint8_t payload_length, uint8_t *response, uint8_t *response_length)
 {
     static uint8_t seqid = 0;
@@ -131,6 +436,8 @@
     // register callback functions for SIP
     SIP.registerCommand(0x00, toggleChecksum);
     SIP.registerCommand(0x01, sendMessage);
+    SIP.registerCommand(0x02, configureRadio);
+    SIP.registerCommand(0x03, radioUpdateSettings);
     
     // register callback functions for aloha transceiver
     aloha.registerType(AlohaFrame::Aloha_Data, AlohaDataEcho);