/** * @brief Start provisioning * * Used to start Limited Access Point * * @param AP ssid * @param AP WiFi channel * @param AP Host IP (string) * @param AP Host subnet mask (string) * @param AP Host name * * @return True if successful */ bool GS_API_StartProvisioning(char* provSsid, char* provChannel, char* ip, char* subnetMask, char* hostName) { GS_Api_SetResponseTimeoutHandle(TIMEOUT_RESPONSE_INTERVAL_HIGH); // Disable DHCP if (!gs_api_handle_cmd_resp(AtLibGs_DHCPSet(0))) return false; // Set Static IP if (!gs_api_handle_cmd_resp( AtLibGs_IPSet((int8_t*) ip, (int8_t*) subnetMask, (int8_t*) ip))) return false; // Enable DHCP Server if (!gs_api_handle_cmd_resp(AtLibGs_SetDHCPServerMode(1))) return false; // Enable Limited AP if (!gs_api_handle_cmd_resp(AtLibGs_Mode(2))) return false; // Set SSID and Channel if (!gs_api_handle_cmd_resp( AtLibGs_Assoc((int8_t*) provSsid, (int8_t*) "", (int8_t*) provChannel))) return false; /* Reset the receive buffer */ AtLib_FlushRxBuffer(); GS_Api_SetResponseTimeoutHandle(TIMEOUT_RESPONSE_INTERVAL_LOW); return true; }
/** * @brief Join WiFi netwrk * * @param Network Configuration struct * * @return True if successfully joined */ bool GS_API_JoinWiFiNetwork(HOST_APP_NETWORK_CONFIG_T* apiNetCfg){ bool joined = false; unsigned int response_timeout_temp; response_timeout_temp = GS_Api_GetResponseTimeoutHandle(); GS_Api_SetResponseTimeoutHandle(TIMEOUT_RESPONSE_INTERVAL_HIGH); AtLib_FlushIncomingMessage(); // Associate if(gs_api_handle_cmd_resp(AtLibGs_Assoc((int8_t *) apiNetCfg->ssid,(int8_t*)"", (int8_t *) apiNetCfg->channel))) { if (gs_api_handle_cmd_resp(AtLibGs_DHCPSet(1))) { char ip[16]; if (AtLib_ParseWlanConnIp((uint8_t *) ip) == true) joined = true; } // Clear all data handler functions memset(cidDataHandlers, 0, sizeof(cidDataHandlers)); } GS_Api_SetResponseTimeoutHandle(response_timeout_temp); return joined; }
/** * @brief Set up keep alive socket options for desired socket * * @param Connection id * @param Keep alive in seconds * * @return True if successful */ bool GS_Api_SetUpSocket_TcpKeepAlive(uint8_t cid, uint32_t keepalive){ if (!gs_api_handle_cmd_resp(AtLib_SetSocketOptions(cid, ATLIB_SOCKET_OPTION_TYPE_SOCK, ATLIB_SOCKET_OPTION_PARAM_SO_KEEPALIVE, 1))) return false; if (!gs_api_handle_cmd_resp(AtLib_SetSocketOptions(cid, ATLIB_SOCKET_OPTION_TYPE_TCP, ATLIB_SOCKET_OPTION_PARAM_TCP_KEEPALIVE_COUNT, 1))) return false; return gs_api_handle_cmd_resp(AtLib_SetSocketOptions(cid, ATLIB_SOCKET_OPTION_TYPE_TCP, ATLIB_SOCKET_OPTION_PARAM_TCP_KEEPALIVE, keepalive)); }
/** * @brief Create Tcp Server Connection * * @param Host port (string) * @param Function pointer to data handler function * * @return Connection id */ uint8_t GS_API_CreateTcpServerConnection(char* port, GS_API_DataHandler cidDataHandler){ uint8_t cidStr[] = " "; uint16_t cid = GS_API_INVALID_CID; unsigned int response_timeout_temp; response_timeout_temp = GS_Api_GetResponseTimeoutHandle(); GS_Api_SetResponseTimeoutHandle(TIMEOUT_RESPONSE_INTERVAL_HIGH); if(!gs_api_handle_cmd_resp(AtLibGs_TcpServer_Start((int8_t*)port))) { GS_Api_SetResponseTimeoutHandle(response_timeout_temp); return cid; } if(AtLib_ParseTcpServerStartResponse(cidStr)){ // need to convert from ASCII to numeric cid = gs_api_parseCidStr(cidStr); if(cid != GS_API_INVALID_CID){ cidDataHandlers[cid] = cidDataHandler; } } GS_Api_SetResponseTimeoutHandle(response_timeout_temp); return cid; }
/** * @brief Returns system time from GS module * * Calls AT+GETTIME=? command and parses response. * * @param Return time string. Time will be in milliseconds since epoch * * @return True if successful */ bool GS_Api_GetSystemTime(char* timeStr){ if (gs_api_handle_cmd_resp(AtLib_GetTime())) if (AtLib_ParseSystemTime(timeStr) == 1) { return true; } return false; }
/** * @brief Open SSL secured connection * * Calls AT+SSLOPEN=<cid>,<cert name> command, and parses standard response. * Open SSL secured connection on desired tcp socket * * @param Connection id * @param Certificate name * * @return True if successful */ bool GS_API_OpenSSLconnection(uint8_t cid, uint8_t* cert_name){ unsigned int response_timeout_temp; bool result; response_timeout_temp = GS_Api_GetResponseTimeoutHandle(); GS_Api_SetResponseTimeoutHandle(TIMEOUT_RESPONSE_INTERVAL_HIGH); result = gs_api_handle_cmd_resp(AtLib_SSLOpen(cid, (char*) cert_name)); GS_Api_SetResponseTimeoutHandle(response_timeout_temp); return result; }
uint8_t GS_API_CreateUdpClientConnection(char* serverIp, char* serverPort, char* localPort, GS_API_DataHandler cidDataHandler){ uint8_t cidStr[] = " "; uint16_t cid = GS_API_INVALID_CID; if(!gs_api_handle_cmd_resp(AtLibGs_UdpClientStart((int8_t*) serverIp, (int8_t*) serverPort, (int8_t*) localPort))) return cid; if(AtLib_ParseUdpServerStartResponse(cidStr)){ // need to convert from ASCII to numeric cid = gs_api_parseCidStr(cidStr); if(cid != GS_API_INVALID_CID){ cidDataHandlers[cid] = cidDataHandler; } } return cid; }
uint8_t GS_API_CreateTcpServerConnection(char* port, GS_API_DataHandler cidDataHandler){ uint8_t cidStr[] = " "; uint16_t cid = GS_API_INVALID_CID; if(!gs_api_handle_cmd_resp(AtLibGs_TcpServer_Start((int8_t*)port))) { return cid; } if(AtLib_ParseTcpServerStartResponse(cidStr)){ // need to convert from ASCII to numeric cid = gs_api_parseCidStr(cidStr); if(cid != GS_API_INVALID_CID){ cidDataHandlers[cid] = cidDataHandler; } } return cid; }
/** * @brief Open http client connection * * Calls AT+HTTPOPEN=<host >[, <Port Number>, <SSL Flag>, <certificate name>,<proxy>,<Connection Timeout>,<client certificate name>,<client key name>] * command in order to open http client connection. * Parses for OK response from GS module and returns connection id. * * @param Host ip string * @param Host port * @param Function pointer to data handler * * @return Connection id */ uint8_t GS_Api_HttpClientOpen(char* host, int hostPort, GS_API_DataHandler cidDataHandler){ uint8_t cid = GS_API_INVALID_CID; unsigned int response_timeout_temp; response_timeout_temp = GS_Api_GetResponseTimeoutHandle(); GS_Api_SetResponseTimeoutHandle(TIMEOUT_RESPONSE_INTERVAL_HIGH); if (!gs_api_handle_cmd_resp(AtLibGs_HTTPOpen(host, hostPort, &cid))) { GS_Api_SetResponseTimeoutHandle(response_timeout_temp); return GS_API_INVALID_CID; } if (GS_Api_IsCidValid(cid)) cidDataHandlers[cid] = cidDataHandler; GS_Api_SetResponseTimeoutHandle(response_timeout_temp); return cid; }
uint8_t GS_API_CreateTcpClientConnection(char* serverIp, char* serverPort, GS_API_DataHandler cidDataHandler){ uint8_t cidStr[] = " "; uint16_t cid = GS_API_INVALID_CID; if(!gs_api_handle_cmd_resp(AtLibGs_TcpClientStart((int8_t*) serverIp, (int8_t*) serverPort))) { printf("ERROR: WIFI TCP CLIENT SETUP ERROR.\n"); return cid; } if(AtLib_ParseTcpServerStartResponse(cidStr)){ // need to convert from ASCII to numeric cid = gs_api_parseCidStr(cidStr); if(cid != GS_API_INVALID_CID){ cidDataHandlers[cid] = cidDataHandler; } } return cid; }
void GS_API_StartProvisioning(char* provSsid, char* provChannel, char* username, char* password, char* ip, char* subnetMask, char* hostName) { // Disable DHCP if (!gs_api_handle_cmd_resp(AtLibGs_DHCPSet(0))) return; // Set Static IP if (!gs_api_handle_cmd_resp( AtLibGs_IPSet((int8_t*) ip, (int8_t*) subnetMask, (int8_t*) ip))) return; // Enable Limited AP if (!gs_api_handle_cmd_resp(AtLibGs_Mode(2))) return; // Set SSID and Channel if (!gs_api_handle_cmd_resp( AtLibGs_Assoc((int8_t*) provSsid, (int8_t*) "", (int8_t*) provChannel))) return; // Enable DHCP Server gs_api_handle_cmd_resp(AtLibGs_SetDHCPServerMode(1)); // Enable DNS Server //if (!gs_api_handle_cmd_resp(AtLibGs_SetDNSServerMode(1, hostName))) // return; if (!gs_api_handle_cmd_resp(AtLibGs_BData (1))) return; // Enable Provisioning //if (!gs_api_handle_cmd_resp(AtLibGs_StartProv(username, password))) // return; //GS_API_Printf("Prov Up SSID:%s", provSsid); //GS_API_Printf("%s/gsclient.html", ip); /* Reset the receive buffer */ AtLib_FlushRxBuffer(); }
bool GS_API_IsAssociated(void){ if (!gs_api_handle_cmd_resp(AtLibGs_WlanConnStat())) return false; return AtLib_ParseWlanConnStat(); }
void GS_API_StopProvisioning(void){ // Web client can't be shut off, so just reset the device gs_api_handle_cmd_resp(AtLibGs_Reset()); }
bool GS_Api_EnableSoftFlowControl(char mode){ return (gs_api_handle_cmd_resp(AtLib_EnableSoftFlowControl((uint32_t) mode))); }
/** * @brief Set Gpio output pins on GS module (drive led) * * Calls AT+DGPIO=<GPIO-NO>,<SET/RESET(0/1) command and parses standard response * * @param GPIO number * @param GPIO state * * @return True if successful */ static bool GS_Api_GpioSetState( ATLIB_GPIO_PIN_E gpio, ATLIB_GPIO_STATE_E state ){ return (gs_api_handle_cmd_resp(AtLib_SetGPIO(gpio, state))); }
/** * @brief Close http client connection * * Calls AT+HTTPCLOSE=<CID> command, and parses standard response. * Will close http connection with desired cid. * * @param Connection id * * @return True if successful */ bool GS_Api_HttpCloseConn(uint8_t cid){ return (gs_api_handle_cmd_resp(AtLib_HTTPClose(cid))); }
/** * @brief Load certificate into GS module * * Calls AT+TCERTADD=<Name>,<Format>,<Size>,<Location><CR><ESC>W<data of size above> command, * and parses standard response. * Load desired certificate with desired name into GS module * * @param Desired cert name * @param Certificate size * @param Certificate array * * @return True if successful */ bool GS_API_LoadCertificate(uint8_t* cert_name, uint32_t cert_size, uint8_t* cacert){ return gs_api_handle_cmd_resp(AtLib_AddSSLCertificate((char *) cert_name, 0 /*binary*/, cert_size, 1 /*RAM*/, (char *) cacert)); }
/** * @brief Http config function * * Calls AT+HTTPCONF=<Param>,<Value> command and parses standard response * * @param Http parameter type * @param Parameter string * * @return True if successful */ bool GS_Api_HttpClientConfig(int parm, char* val){ return (gs_api_handle_cmd_resp(AtLib_HTTPConf(parm, val))); }
/** * @brief Set up WiFi network * * initialize and set up WiFi parameters for desired WiFi network * * @param Network Configuration struct * * @return True if successful */ bool GS_API_SetupWifiNetwork(HOST_APP_NETWORK_CONFIG_T* apiNetCfg) { bool set = false; uint8_t security = atoi(apiNetCfg->security); // Set all the configuration options // Check for DHCP Enabled if (atoi(apiNetCfg->dhcpEnabled)) { if (!gs_api_handle_cmd_resp(AtLibGs_DHCPSet(1))) { return set; } } else { if (!gs_api_handle_cmd_resp(AtLibGs_DHCPSet(0))) return set; if (!gs_api_handle_cmd_resp( AtLibGs_IPSet((int8_t *) apiNetCfg->staticIp, (int8_t *) apiNetCfg->subnetMask, (int8_t *) apiNetCfg->gatewayIp))) return set; } // Check security switch (security) { case 0: // Set all // Don't check these since some might not be valid anyway if (!gs_api_handle_cmd_resp( AtLibGs_SetPassPhrase((int8_t *) apiNetCfg->passphrase))) return set; if (!gs_api_handle_cmd_resp(AtLibGs_SetAuthMode(0))) return set; break; case 1: // Set none break; case 2: // Set WEP if (!gs_api_handle_cmd_resp( AtLibGs_SetWepKey(atoi(apiNetCfg->wepId), apiNetCfg->wepKey))) return set; if (!gs_api_handle_cmd_resp(AtLibGs_SetAuthMode(0))) return set; break; case 4: case 8: case 16: case 32: case 64: // Set WPA if (!gs_api_handle_cmd_resp(AtLibGs_SetPassPhrase((int8_t *) apiNetCfg->passphrase))) return set; break; default: // nothing break; } // Set the security mode if(!gs_api_handle_cmd_resp(AtLibGs_SetSecurity(security))) return set; // Set adhoc or infrastructure if(!gs_api_handle_cmd_resp(AtLibGs_Mode(atoi(apiNetCfg->connType)))) return set; return set; }
/** * @brief Set up max retries socket options for desired socket * * @param Connection id * @param Max retries in seconds * * @return True if successful */ bool GS_Api_SetUpSocket_MaxRT(uint8_t cid, uint32_t max_rt){ return gs_api_handle_cmd_resp(AtLib_SetSocketOptions(cid, ATLIB_SOCKET_OPTION_TYPE_TCP, ATLIB_SOCKET_OPTION_PARAM_TCP_MAXRT, max_rt)); }
/** * @brief Get cid info * * Calls AT+CID=? command * Send get cid info command. * Does not parse result. * * @return True if successful */ bool GS_Api_GetCidInfo(){ return gs_api_handle_cmd_resp(AtLib_GetCIDInfo()); }
/** * @brief Remove certificate from GS module * * Calls AT+TCERTDEL=<certificate name> command, and parses standard response. * removes certificate from GS module memory * * @param Desired cert name * * @return True if successful */ bool GS_API_RemoveCertificate(uint8_t* cert_name){ return gs_api_handle_cmd_resp(AtLib_DeleteSSLCertificate((char *) cert_name)); }
/** * @brief Checks WiFi network status * * Calls AT+WSTATUS command and parses standard response. * After this call, AtLib_ParseSSIDResponse or AtLib_ParseNodeIpAddress * should be called to parse node ip or target ssid * * @return True if successful */ bool GS_API_WlanStatus(){ return (gs_api_handle_cmd_resp(AtLibGs_WlanConnStatShort())); }
/** * @brief Close SSL secured connection * * Calls AT+SSLCLOSE=<cid> command, and parses standard response. * Close SSL secured connection on desired tcp socket * * @param Connection id * * @return True if successful */ bool GS_API_CloseSSLconnection(uint8_t cid){ return gs_api_handle_cmd_resp(AtLib_SSLClose(cid)); }
/** * @brief Get memory trace info * * Calls AT+MEMTRACE command * Send get memory trace info command. * Does not parse result. * * @return True if successful */ bool GS_Api_getMemoryInfo(){ return gs_api_handle_cmd_resp(AtLib_GetMemoryInfo()); }
bool GS_API_JoinNetwork() { bool joined = false; uint8_t security = atoi(apiNetworkConfig.security); // Set all the configuration options // Check for DHCP Enabled if (atoi(apiNetworkConfig.dhcpEnabled)) { if (!gs_api_handle_cmd_resp(AtLibGs_DHCPSet(1))) return joined; } else { if (!gs_api_handle_cmd_resp(AtLibGs_DHCPSet(0))) return joined; if (!gs_api_handle_cmd_resp( AtLibGs_IPSet((int8_t*)apiNetworkConfig.staticIp, (int8_t*)apiNetworkConfig.subnetMask, (int8_t*)apiNetworkConfig.gatewayIp))) return joined; } // Check security switch (security) { case 0: // Set all // Don't check these since some might not be valid anyway AtLibGs_SetPassPhrase((int8_t*)apiNetworkConfig.passphrase); AtLibGs_SetWepKey(atoi(apiNetworkConfig.wepId), apiNetworkConfig.wepKey); AtLibGs_SetAuthMode(0); break; case 1: // Set none break; case 2: // Set WEP if (!gs_api_handle_cmd_resp( AtLibGs_SetWepKey(atoi(apiNetworkConfig.wepId), apiNetworkConfig.wepKey))) return joined; if (!gs_api_handle_cmd_resp(AtLibGs_SetAuthMode(0))) return joined; break; case 4: case 8: case 16: case 32: case 64: // Set WPA if (!gs_api_handle_cmd_resp(AtLibGs_SetPassPhrase((int8_t*)apiNetworkConfig.passphrase))) return joined; break; default: // nothing break; } // Set the security mode if(!gs_api_handle_cmd_resp(AtLibGs_SetSecurity(security))) return joined; // Set adhoc or infrastructure if(!gs_api_handle_cmd_resp(AtLibGs_Mode(atoi(apiNetworkConfig.connType)))) return joined; // Associate if(gs_api_handle_cmd_resp(AtLibGs_Assoc((int8_t*)apiNetworkConfig.ssid,(int8_t*)"", (int8_t*)apiNetworkConfig.channel))){ joined = true; // Clear all data handler functions memset(cidDataHandlers, 0, sizeof(cidDataHandlers)); } return joined; }
/** * @brief Set time into GS module * * Calls AT+SETTIME=[<dd/mm/yyyy>,<HH:MM:SS>],[ System time in milliseconds since epoch(1970)] * command, and parses standard response. * * @param Desired time string in format * "dd/mm/yyyy,HH:MM:SS" or * ",xxxxxxxxxxxxx" * * @return True if successful */ bool GS_API_SetTime(uint8_t* time){ return gs_api_handle_cmd_resp(AtLibGs_SetTime((int8_t *) time)); }