Example #1
0
/**
   @brief Writes the current network configuration to non-volatile storage
   @private
*/
void gs_api_writeNetworkConfig(void) {
     // Try to save the network information
     //if (!GS_HAL_store_data(NETWORK_SAVE_ADDRESS, (void*) &apiNetworkConfig,
     //                       sizeof(apiNetworkConfig))) {
          GS_API_Printf("Network save failed");
     //}
}
Example #2
0
/**
   @brief AtCmdLib calls this function for all incoming data

   @param cid Incoming data connection ID
   @param rxData Incoming data value
*/
void App_ProcessIncomingData(uint8_t cid, uint8_t rxData) {
     // Check for and call handler for incoming CID and Data
     if(cid < CID_COUNT && cidDataHandlers[cid])
          cidDataHandlers[cid](cid, rxData);
     else
          GS_API_Printf("RX Data with no handler for cid %d\r\n", cid);
}
Example #3
0
void GS_API_CheckForData(void){
     uint8_t rxData;

     /* Read one byte at a time - Use non-blocking call */
     while (GS_HAL_recv(&rxData, 1, 0)) {
          /* Process the received data */
          switch(AtLib_ReceiveDataProcess(rxData)){
          case HOST_APP_MSG_ID_TCP_SERVER_CLIENT_CONNECTION:
          {
               uint8_t cidServerStr[] = " ";
               uint8_t cidClientStr[] = " ";
               uint8_t cidServer = GS_API_INVALID_CID;
               uint8_t cidClient = GS_API_INVALID_CID;

               if(AtLib_ParseTcpServerClientConnection((char *)cidServerStr, (char *)cidClientStr, tcpServerClientIp, tcpServerClientPort)){
                    cidServer = gs_api_parseCidStr(cidServerStr);
                    cidClient = gs_api_parseCidStr(cidClientStr);
                    gs_api_setCidDataHandler(cidClient, gs_api_getCidDataHandler(cidServer));
               }
               GS_API_Printf("TCP Server Client Connection %d, %d, %s, %s\r\n", cidServer, cidClient, tcpServerClientIp, tcpServerClientPort);
          }
          break;

          case HOST_APP_MSG_ID_RESPONSE_TIMEOUT:
          case HOST_APP_MSG_ID_NONE:
               // Do nothing
               break;

          default:
               break;
          }
     }
}
Example #4
0
/**
   @brief Checks for a OK response to a command
   @private
   @param msg Message returned by command sent to Gainspan module
   @return true if command response was OK, false if not
*/
static bool gs_api_handle_cmd_resp(HOST_APP_MSG_ID_E msg) {

     if (msg != HOST_APP_MSG_ID_OK) {
          GS_API_Printf("CMD ERR %d", msg);
          return false;
     } else {
          return true;
     }

}
Example #5
0
/**
@brief Parses command sent to TCP server

This method will act upon the command sent to the TCP server, and send a response to the
client that made the request to notify if the command was recognized or not.

@private
*/
static void gs_example_tcp_handle_command(void){
  switch(commandToHandle){
  case TCP_NO_CMD:
    // Nothing to do
    break;
    
  case START_TCP_CLIENT:
    // Acknowledge command and start TCP client
    GS_API_SendTcpData(commandCID, TCP_COMMAND_ACK_STR, (sizeof(TCP_COMMAND_ACK_STR) - 1));
    gs_example_start_tcp_client(value1, value2);
    break;
    
  case STOP_TCP_CLIENT:
    // Acknowledge command and stop TCP client
    GS_API_SendTcpData(commandCID, TCP_COMMAND_ACK_STR, (sizeof(TCP_COMMAND_ACK_STR) - 1));
    GS_API_CloseConnection(tcpClientCID);
    tcpClientCID = GS_API_INVALID_CID;
    break;
    
  case TCP_FIRMWARE_UPGRADE:
    // Acknowledge command and attempt firmware update
    GS_API_SendTcpData(commandCID, TCP_COMMAND_ACK_STR, (sizeof(TCP_COMMAND_ACK_STR) - 1));
    if(GS_API_UpdateFirmware((char*)value1, (char*)value2, (char*)value3, (char*)value4, (char*)value5)){
      GS_API_Printf("Firmware Updated");
      GS_Example_stop_tcp_task();
      firmwareUpdated = true;
    } else {
      GS_API_Printf("Firmware Update Failed");
      firmwareUpdated = true;
    }
    break;
    
  default:
    // Unknown command, send not ok and print the unrecognized command
    GS_API_Printf((char*)line);
    GS_API_SendTcpData(commandCID, TCP_COMMAND_NAK_STR, (sizeof(TCP_COMMAND_NAK_STR) - 1));
    break;
  }
  
  // Clear the command so we don't act on it again
  commandToHandle = TCP_NO_CMD;
}
Example #6
0
/**
@brief Starts a TCP client to connect to the specified server

Tries to connect using TCP to the IP and port passed in.
@private
@param serverIp IP of TCP server to connect to
@param serverPort port of TCP server to connect to
*/
static void gs_example_start_tcp_client(uint8_t* serverIp, uint8_t* serverPort){
  
  // Check to see if we are already connected
  if(tcpClientCID != GS_API_INVALID_CID){
    GS_API_Printf("TCP Client Already Started");
    return;
  }
  
  // We're not connected, so lets create a TCP client connection
  tcpClientCID = GS_API_CreateTcpClientConnection((char*)serverIp, (char*)serverPort, gs_example_handle_tcp_client_data);
  
  // Now lets send data for the first time
  gs_example_send_tcp_client_data();
}
Example #7
0
/** Public Method Implmentation **/
void GS_Example_start_tcp_task(void){
  // Reset all variables 
  memset(tcpServerClientCids, GS_API_INVALID_CID, sizeof(tcpServerClientCids));
  tcpServerCID = GS_API_INVALID_CID;
  commandToHandle = TCP_NO_CMD;
  commandCID = GS_API_INVALID_CID;
  firmwareUpdated = false;
  
  
  // Create the TCP Server connection
  tcpServerCID = GS_API_CreateTcpServerConnection(TCP_SERVER_PORT, gs_example_handle_tcp_server_data);
  if(tcpServerCID != GS_API_INVALID_CID){
    GS_API_Printf("TCP PORT: %s", TCP_SERVER_PORT);
  }
}
Example #8
0
/**
   @brief Reads the network configuration from non-volatile storage
   @private
*/
void gs_api_readNetworkConfig(void) {
     // Try to read the saved network information
    // if (!GS_HAL_read_data(NETWORK_SAVE_ADDRESS, (void*) &apiNetworkConfig,
    //                       sizeof(apiNetworkConfig))) {
          GS_API_Printf("No Saved Network");
          // Set default data here
          memcpy(apiNetworkConfig.ssid, DEFAULT_SSID, sizeof(DEFAULT_SSID));
          memcpy(apiNetworkConfig.channel, DEFAULT_CHANNEL,
                 sizeof(DEFAULT_CHANNEL));
          memcpy(apiNetworkConfig.dhcpEnabled, DEFAULT_DHCP_ENABLE,
                 sizeof(DEFAULT_DHCP_ENABLE));
          memcpy(apiNetworkConfig.security, DEFAULT_SECURITY,
                 sizeof(DEFAULT_SECURITY));
     //}
}
Example #9
0
/**
@brief Sends periodic temperature using TCP client connection
@private
*/
static void gs_example_send_tcp_client_data(){
  static uint8_t temperatureStr[] = TCP_CLIENT_DATA_STR;
  // Check for a valid connection and timer interval
  if(tcpClientCID != GS_API_INVALID_CID && MSTimerDelta(tcpClientSentTime) > TCP_CLIENT_SEND_INTERVAL ){
    // Format string with temperature
    sprintf((char*)temperatureStr, TCP_CLIENT_DATA_STR, GS_Example_GetTemperature());
    // Try to send the temperature string
    if(!GS_API_SendTcpData(tcpClientCID, temperatureStr, sizeof(TCP_CLIENT_DATA_STR) - 1)){
      // Sending failed, disable this connection ID
      tcpClientCID = GS_API_INVALID_CID;
      GS_API_Printf("Send TCP Data failed");
    }
    // Reset sending interval
    tcpClientSentTime = MSTimerGet();
  }
  
}
Example #10
0
void GS_API_PrintNetworkInfo(void){
     GS_API_Printf("Network Info");
     GS_API_Printf("SSID: %s", apiNetworkConfig.ssid);
     GS_API_Printf("Channel: %s", apiNetworkConfig.channel);
}
Example #11
0
bool GS_API_PollProvisioningResponse(void){
     if(AtLib_ResponseHandleNoBlock() != HOST_APP_MSG_ID_NONE){
          // Get the provisioning data
          HOST_APP_NETWORK_CONFIG_T networkConfig;
          memset(&networkConfig, 0, sizeof(networkConfig));

          if (AtLib_ParseProvisionResponse(&networkConfig)) {
               // Print the Provisioning Network Options
               GS_API_Printf(networkConfig.ssid);
               GS_API_Printf(networkConfig.channel);
               GS_API_Printf(networkConfig.mode);
               GS_API_Printf(networkConfig.security);
               GS_API_Printf(networkConfig.dhcpEnabled);
               GS_API_Printf(networkConfig.passphrase);
               GS_API_Printf(networkConfig.wepKey);
               GS_API_Printf(networkConfig.wepId);
               GS_API_Printf(networkConfig.connType);
               GS_API_Printf(networkConfig.staticIp);
               GS_API_Printf(networkConfig.subnetMask);
               GS_API_Printf(networkConfig.gatewayIp);
               GS_API_Printf(networkConfig.autoDnsEnabled);
               GS_API_Printf(networkConfig.primaryDns);
               GS_API_Printf(networkConfig.secondaryDns);

               // Save the network configuration to non volatile storage 
               memcpy(&apiNetworkConfig, &networkConfig, sizeof(apiNetworkConfig));
               //gs_api_writeNetworkConfig();

               return true;
          }
     }
     return false;
}