Andrew Miller
iowfehu;gdbjwHJAOPIHO?L
Fork of
X_NUCLEO_IDW01M1
by 
ST
Revision 1:bd9db471d47d, committed 2016-04-14
- Comitter:
- mridup
- Date:
- Thu Apr 14 06:14:14 2016 +0000
- Parent:
- 0:dc55f40eb04f
- Child:
- 2:bf3b3c6ce3a0
- Commit message:
- increasing reset delay to 200ms due to problem with L4 reset
Changed in this revision
--- a/SPWFInterface.cpp Wed Apr 13 11:34:07 2016 +0000
+++ b/SPWFInterface.cpp Thu Apr 14 06:14:14 2016 +0000
@@ -108,7 +108,7 @@
// SpwfSASocket implementation
int32_t SpwfSAInterface::SpwfSASocket::open(const char *ip, uint16_t port)
{
- uint8_t sock_id = -1;
+ uint8_t sock_id = 99;
//__spwf->setTimeout(SPWF_SEND_TIMEOUT);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf/inc/wifi_const.h Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,131 @@
+/**
+ ******************************************************************************
+ * @file wifi_const.h
+ * @author Central LAB
+ * @version V2.0.0
+ * @date 10-February-2016
+ * @brief Describes the constants and defines in X-CUBE-WIFI1
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
+
+/** @defgroup NUCLEO_WIFI_INTERFACE_Private_Defines
+ * @{
+ */
+
+#define EPOCH_TIME 1453727657//Human time (GMT): Mon, 25 Jan 2016 13:14:17 GMT
+#define EXTI_CONF_TIMER 1900 //millisec
+#define PROCESS_WIFI_TIMER 1
+#define SLEEP_RESUME_PREVENT 2000
+#define RINGBUF_SIZE 2048//1024//3072//2048
+#define MAX_BUFFER_GLOBAL 512
+#define MAX_PREFETCH_BUFFER 20
+#define MAX_WIFI_SCAN_NETWORK 256
+#define RxBufferSize 64
+#define AT_RESP_LEN_OK 6 //\r\nOK\r\n
+#define AT_RESP_LEN_GPIOR 21//GPIO n = 0,in\r\n\r\nOK\r\n
+#define AT_RESP_HELP_TEXT_LEN 512
+#define AT_ATTENTION "AT\r"
+#define AT_WIFI_ENABLE "AT+S.WIFI=%d\r"
+#define AT_GET_CONFIGURATION_VALUE "AT+S.GCFG=%s\r"
+#define AT_SET_CONFIGURATION_VALUE "AT+S.SCFG=%s,%d\r"
+#define AT_SET_CONFIGURATION_ADDRESS "AT+S.SCFG=%s,%s\r"
+//#define AT_GET_SSID "AT&F\r"
+#define AT_SET_SSID "AT+S.SSIDTXT=%s\r"
+#define AT_SET_SEC_KEY "AT+S.SCFG=wifi_wpa_psk_text,%s\r"
+#define AT_RESTORE_DEFAULT_SETTING "AT&F\r"
+#define AT_SAVE_CURRENT_SETTING "AT&W\r"
+#define AT_SET_POWER_STATE "AT+CFUN=%d\r"
+#define AT_HELP_TEXT "AT+S.HELP\r"
+#define AT_RESET_MSG "\r\n+WIND:2:Reset\r\n"
+
+#define UNDEFINE_LENGTH 0xFFFF
+#define AT_WiFi_SCAN "AT+S.SCAN\r"
+#define AT_SOCKET_OPEN "AT+S.SOCKON=%s,%d,%s,ind\r"
+#define AT_SOCKET_WRITE "AT+S.SOCKW=%d,%d\r"
+#define AT_SOCKET_READ "AT+S.SOCKR=%d,%d\r"
+#define AT_SOCKET_CLOSE "AT+S.SOCKC=%d\r"
+#define AT_SERVER_SOCKET_OPEN "AT+S.SOCKD=%d,%s,ind\r" //with indication option
+#define AT_SERVER_SOCKET_CLOSE "AT+S.SOCKD=0\r"
+#define AT_QUERY_PENDING_DATA "AT+S.SOCKQ=%d\r"
+#define AT_DISPLAY_FILE_NAME "AT+S.FSL\r"
+#define AT_DISPLAY_FILE_CONTENT "AT+S.FSP=/%s\r"
+#define AT_CREATE_NEW_HTML_FILE "AT+S.FSC=/%s,%d\r"
+#define AT_APPEND_FILE "AT+S.FSA=/%s,%d\r"
+#define AT_DELETE_FILE "AT+S.FSD=/%s\r"
+#define AT_DOWNLOAD_IMAGE_FILE "AT+S.HTTPDFSUPDATE=%s,/%s,%d\r"
+#define AT_ERASE_FLASH_MEMORY "AT+S.HTTPDFSERASE\r"
+
+#define AT_CMD_TO_DATA_MODE "AT+S.\r"
+#define AT_DATA_TO_CMD_MODE "at+s." /* NOT \r */
+#define AT_HTTPPOST_REQUEST "AT+S.HTTPPOST=%s\r"
+#define AT_HTTPD "AT+S.HTTPD=%d\r"
+#define AT_GET_STATUS_VALUE "AT+S.STS=%s\r"
+
+/************Wi-Fi Config Variables**************/
+
+#define BLINK_LED "blink_led"
+#define LOCALECHO1 "localecho1"
+#define CONSOLE1_HWFC "console1_hwfc"
+#define CONSOLE1_SPEED "console1_speed"
+#define WIFI_PRIV_MODE "wifi_priv_mode"
+#define IP_USE_DHCP_SERVER "ip_use_dhcp"
+#define IP_USE_HTTPD "ip_use_httpd"
+#define WIFI_MODE "wifi_mode"
+#define WIFI_WPA_SECURITY "wifi_wpa_psk_text"
+#define WIFI_CHANNEL_NUMBER "wifi_channelnum"
+#define WIFI_IP_ADDRESS "ip_ipaddr"
+#define WIFI_IP_DEFAULT_GATEWAY "ip_gw"
+#define WIFI_IP_DNS "ip_dns"
+#define WIFI_IP_NETMASK "ip_netmask"
+#define WIFI_IP_HOSTNAME "ip_hostname"
+#define WIFI_IP_APDOMAINNAME "ip_apdomainname"
+#define WIFI_IP_APREDIRECT "ip_apredirect"
+#define WIFI_IP_HTTP_TIMEOUT "ip_http_get_recv_timeout"
+#define WIFI_IP_DHCP_TIMEOUT "ip_dhcp_timeout"
+
+#define WIFI_SLEEP_ENABLED "sleep_enabled"
+#define WIFI_HT_MODE "wifi_ht_mode"
+#define WIFI_OPR_RATE_MASK "wifi_opr_rate_mask"
+#define WIFI_POWERSAVE "wifi_powersave"
+#define WIFI_OPERATIONAL_MODE "wifi_operational_mode"
+#define WIFI_LISTEN_INTERVAL "wifi_listen_interval"
+#define WIFI_BEACON_WAKEUP "wifi_beacon_wakeup"
+#define WIFI_STANDBY_ENABLED "standby_enabled"
+#define WIFI_STANDBY_TIME "standby_time"
+#define WIFI_TX_POWER "wifi_tx_power"
+#define WIFI_IBSS_IP_ADDR "192.168.2.100"
+#define WIFI_IBSS_DEFAULT_GATEWAY "192.168.2.1"
+#define WIFI_IBSS_IP_DNS_ADDR "192.168.2.1"
+#define WIFI_IBSS_IP_MASK "255.255.255.0"
+#define WIFI_IP_USE_DHCP 0
+
+/**
+ * @}
+ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Spwf/inc/wifi_driver.h Thu Apr 14 06:14:14 2016 +0000 @@ -0,0 +1,40 @@ + +#include "wifi_module.h" + +extern volatile Wifi_Status_Var status_flag; + +extern wifi_bool Uartx_Rx_Processing; +extern buffer_td big_buff; +extern wifi_bool resume_receive_data; +extern wifi_bool AT_Cmd_Processing; +extern WiFi_AT_CMD_Response_t WiFi_Module_State; +extern volatile WiFi_WIND_State_TypeDef WiFi_WIND_State; +extern volatile uint8_t wifi_connected; +extern wifi_bool WiFi_Enabled; +extern wifi_bool Standby_Enabled; +extern wifi_bool Deep_Sleep_Enabled; +extern uint8_t WiFi_AT_Cmd_Buff[]; + +extern void callSpwfSADevice_init(void* object); +extern char callSpwfSADevice_getChar(void* object); +extern void callSpwfSADevice_write(void* object, const char * cmd, uint16_t size); +extern void callSpwfSADevice_wakeup(void* object, int wake); +extern void callSpwfSADevice_reset(void* object, int reset); +extern void callSpwfSADevice_rts(void* object, int rts); +extern void callSpwfSADevice_attach(wifi_bool attach); +extern void callSpwfSADevice_debug(void* object, const char * string); +extern void destroySpwfSADevice(void); +extern int callSpwfSADevice_read_rts(void* object); + +extern void Stop_Timer(void); +extern void Start_Timer(void); + +extern void Wifi_TIM_Handler(void); +extern void Wifi_SysTick_Isr(void); + +void *spwf_dev; + +void Wifi_scheduler(void); +void Rx_irq_handler(void); +void Wifi_ticker(void); +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf/inc/wifi_interface.h Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,332 @@
+/**
+ ******************************************************************************
+ * @file wifi_interface.h
+ * @author Central LAB
+ * @version V2.0.0
+ * @date 10-February-2016
+ * @brief Header file for X-CUBE-WIFI1 API
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef __WIFI_INTERFACE_H
+#define __WIFI_INTERFACE_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/* Includes ------------------------------------------------------------------*/
+#include<stdint.h>
+
+ /** @addtogroup MIDDLEWARES
+* @{
+*/
+
+
+/** @addtogroup NUCLEO_WIFI_API
+ * @brief Wi-Fi_interface API
+ * @{
+ */
+
+
+/** @addtogroup NUCLEO_WIFI_API_Private_Macros
+ * @{
+ */
+
+
+ /**
+ * @}
+ */
+
+
+/** @addtogroup NUCLEO_WIFI_API_Private_Variables
+ * @{
+ */
+/* Private variables ---------------------------------------------------------*/
+
+
+/* Exported macro ------------------------------------------------------------*/
+#define _ARG6(_0, _1, _2, _3, _4, _5, _6, ...) _6
+#define NARG6(...) _ARG6(__VA_ARGS__, 6, 5, 4, 3, 2, 1, 0)
+#define _FIVE_OR_SIX_ARGS_5(NAME, a, b, c, d, e) a, b, c, d, e, 1453727657
+#define _FIVE_OR_SIX_ARGS_6(NAME, a, b, c, d, e, f) a, b, c, d, e, f
+#define __FIVE_OR_SIX_ARGS(NAME, N, ...) _FIVE_OR_SIX_ARGS_ ## N (NAME, __VA_ARGS__)
+#define _FIVE_OR_SIX_ARGS(NAME, N, ...) __FIVE_OR_SIX_ARGS(NAME, N, __VA_ARGS__)
+#define FIVE_OR_SIX_ARGS(NAME, ...) NAME(_FIVE_OR_SIX_ARGS(NAME, NARG6(__VA_ARGS__), __VA_ARGS__))
+
+#define wifi_socket_client_security(...) FIVE_OR_SIX_ARGS(wifi_socket_client_security, __VA_ARGS__)
+
+/* Exported constants --------------------------------------------------------*/
+#define GPIO_IN "in"
+#define GPIO_OUT "out"
+
+#define GPIO_Off '0'
+#define GPIO_Rising 'R'
+#define GPIO_Falling 'F'
+#define GPIO_Both 'B'
+
+typedef enum GpioWriteValue
+{
+ GPIO_OFF = 0,
+ GPIO_ON,
+} GpioWriteValue;
+
+typedef enum GpioPin
+{
+ GPIO_PIN0 = 0,
+ GPIO_PIN1,
+ GPIO_PIN2,
+ GPIO_PIN3,
+ GPIO_PIN4,
+ GPIO_PIN5,
+ GPIO_PIN6,
+ GPIO_PIN7,
+ GPIO_PIN8,
+ GPIO_PIN9,
+ GPIO_PIN10,
+ GPIO_PIN11,
+ GPIO_PIN12,
+ GPIO_PIN13,
+ GPIO_PIN14,
+ GPIO_PIN15
+} GpioPin;
+
+typedef enum wifi_bool
+{
+ WIFI_FALSE = 0,
+ WIFI_TRUE = 1,
+ Undefine = 0xFF
+} wifi_bool;
+
+typedef enum WiFi_Priv_Mode
+{
+ None = 0,
+ WEP = 1,
+ WPA_Personal = 2,
+} WiFi_Priv_Mode;
+
+/********** Wi-Fi Error *************/
+typedef enum WiFi_Status_t
+{
+ WiFi_MODULE_SUCCESS = 0,
+ WiFi_TIME_OUT_ERROR = 1,
+ WiFi_MODULE_ERROR,
+ WiFi_HAL_OK,
+ WiFi_NOT_SUPPORTED,
+ WiFi_NOT_READY,
+ WiFi_SCAN_FAILED,
+ WiFi_AT_CMD_BUSY,
+ WiFi_SSID_ERROR,
+ WiFi_SecKey_ERROR,
+ WiFi_CONFIG_ERROR,
+ WiFi_STA_MODE_ERROR,
+ WiFi_AP_MODE_ERROR,
+ WiFi_AT_CMD_RESP_ERROR,
+ WiFi_AT_FILE_LENGTH_ERROR,
+ WiFi_HAL_UART_ERROR,
+ WiFi_IN_LOW_POWER_ERROR,
+ WiFi_HW_FAILURE_ERROR,
+ WiFi_HEAP_TOO_SMALL_WARNING,
+ WiFi_STACK_OVERFLOW_ERROR,
+ WiFi_HARD_FAULT_ERROR,
+ WiFi_MALLOC_FAILED_ERROR,
+ WiFi_INIT_ERROR,
+ WiFi_POWER_SAVE_WARNING,
+ WiFi_SIGNAL_LOW_WARNING,
+ WiFi_JOIN_FAILED,
+ WiFi_SCAN_BLEWUP,
+ WiFi_START_FAILED_ERROR,
+ WiFi_EXCEPTION_ERROR,
+ WiFi_DE_AUTH,
+ WiFi_DISASSOCIATION,
+ WiFi_UNHANDLED_IND_ERROR,
+ WiFi_RX_MGMT,
+ WiFi_RX_DATA,
+ WiFi_RX_UNK
+} WiFi_Status_t;
+
+typedef enum power_mode
+{
+ wifi_active = 0,
+ wifi_reactive = 1,
+ wifi_sleep = 2,
+} power_mode;
+
+typedef enum tx_power_level
+{
+ low = 0,
+ medium = 1,
+ high = 2,
+ max = 3,
+} tx_power_level;
+
+typedef enum dhcp_mode
+{
+ off = 0,
+ on = 1,
+ custom = 2,
+} dhcp_mode;
+
+typedef struct wifi_security
+{
+ wifi_bool wpa;
+ wifi_bool wpa2;
+ wifi_bool wps;
+} wifi_security;
+
+typedef struct wifi_scan
+{
+ uint8_t channel_num;
+ int rssi;
+ char ssid[30];
+ wifi_security sec_type;
+} wifi_scan;
+
+typedef struct wifi_config
+{
+ wifi_bool ht_mode;
+ power_mode power;
+ tx_power_level power_level;
+ dhcp_mode dhcp;
+ char* ip_addr;
+ char* netmask_addr;
+ char* gateway_addr;
+ char* dns_addr;
+ char* host_name;
+ wifi_bool web_server;
+ char* ap_domain_name;
+ char* ap_config_page_name;
+ uint32_t http_timeout;
+ uint32_t dhcp_timeout;
+ uint8_t wifi_region;
+ uint32_t wifi_baud_rate;
+} wifi_config;
+
+/* Exported functions ------------------------------------------------------- */
+
+#ifdef WIFI_USE_VCOM
+void wifi_vcom(void);
+#endif
+
+WiFi_Status_t wifi_init(wifi_config* config);
+WiFi_Status_t wifi_restore(void);
+WiFi_Status_t wifi_enable(wifi_bool enable);
+WiFi_Status_t wifi_disconnect(void);
+WiFi_Status_t wifi_connect(char * ssid, char * sec_key, WiFi_Priv_Mode priv_mode);
+WiFi_Status_t wifi_ap_start(uint8_t * ssid, uint8_t channel_num);
+WiFi_Status_t wifi_adhoc_create(uint8_t * ssid, WiFi_Priv_Mode priv_mode);
+WiFi_Status_t wifi_network_scan(wifi_scan *scan_result, uint16_t max_scan_number);
+void wifi_reset(void);
+
+/******** Wi-Fi Socket Function **********/
+WiFi_Status_t wifi_socket_client_open(uint8_t * hostname, uint32_t port_number, uint8_t * protocol, uint8_t * sock_id);
+WiFi_Status_t wifi_socket_client_write(uint8_t sock_id, uint16_t DataLength,char * pData);
+WiFi_Status_t wifi_socket_client_close(uint8_t sock_close_id);
+WiFi_Status_t wifi_socket_client_security(uint8_t* tls_mode, uint8_t* root_ca_server, uint8_t* client_cert, uint8_t* client_key, uint8_t* client_domain, uint32_t tls_epoch_time);
+
+/********* Wi-Fi Socket Server ********/
+WiFi_Status_t wifi_socket_server_open(uint32_t port_number, uint8_t * protocol);
+WiFi_Status_t wifi_socket_server_write(uint16_t DataLength,char * pData);
+WiFi_Status_t wifi_socket_server_close(void);
+
+/*** FileSystem Request ***********/
+WiFi_Status_t wifi_file_create(char *pFileName,uint16_t alength,char * databuff);
+WiFi_Status_t wifi_file_delete(char * pFileName);
+WiFi_Status_t wifi_file_list(void);
+WiFi_Status_t wifi_file_show(uint8_t * pFileName);
+WiFi_Status_t wifi_file_image_create(uint8_t * pHostName,uint8_t * pFileName, uint32_t port_number);
+WiFi_Status_t wifi_file_erase_external_flash(void);
+
+/*** HTTP File Request ***********/
+WiFi_Status_t wifi_http_get(uint8_t * hostname, uint8_t * path, uint32_t port_number);
+WiFi_Status_t wifi_http_post(uint8_t * url_path);
+
+WiFi_Status_t wifi_fw_update(uint8_t * hostname, uint8_t * filename_path, uint32_t port_number);
+
+/*** Power Configuration **********/
+WiFi_Status_t wifi_standby(uint8_t arg_standby_time);
+WiFi_Status_t wifi_wakeup(wifi_bool enable);
+
+/*** GPIO Configuration **********/
+uint8_t wifi_gpio_init(GpioPin pin, char* dir, char irq);
+uint8_t wifi_gpio_read(GpioPin pin, uint8_t *val, uint8_t *dir);
+uint8_t wifi_gpio_write(GpioPin pin, GpioWriteValue value);
+
+WiFi_Status_t WiFi_Get_IP_Address(uint8_t *ip_addr);
+WiFi_Status_t WiFi_Get_MAC_Address(uint8_t *mac_addr);
+
+void UART_Configuration(uint32_t baud_rate);
+void GPIO_Configuration(void);
+void Timer_Config(void);
+void UART_Msg_Gpio_Init(void);
+void USART_PRINT_MSG_Configuration(uint32_t baud_rate);
+
+/******** Wi-Fi Indication User Callback: For User to implement *********/
+void ind_wifi_warning(WiFi_Status_t warning_code);
+void ind_wifi_error(WiFi_Status_t error_code);
+void ind_wifi_connection_error(WiFi_Status_t status_code);
+void ind_wifi_connected(void);
+void ind_wifi_ap_ready(void);
+void ind_wifi_ap_client_joined(uint8_t * client_mac_address);
+void ind_wifi_ap_client_left(uint8_t * client_mac_address);
+void ind_wifi_on(void);
+void ind_wifi_packet_lost(WiFi_Status_t status_code);
+void ind_wifi_gpio_changed(void);
+void ind_wifi_socket_data_received(uint8_t socket_id, uint8_t * data_ptr, uint32_t message_size, uint32_t chunk_size);
+void ind_wifi_socket_client_remote_server_closed(uint8_t * socketID);
+void ind_wifi_socket_server_data_lost(void);
+void ind_socket_server_client_joined(void);
+void ind_socket_server_client_left(void);
+void ind_wifi_http_data_available(uint8_t * data_ptr,uint32_t message_size);
+void ind_wifi_file_data_available(uint8_t * data_ptr);
+void ind_wifi_resuming(void);
+
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* __WIFI_INTERFACE_H */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf/inc/wifi_module.h Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,379 @@
+ /**
+ ******************************************************************************
+ * @file wifi_module.h
+ * @author Central LAB
+ * @version V2.0.0
+ * @date 10-February-2016
+ * @brief Header file for Wi-Fi module
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef __WIFI_MODULE_H
+#define __WIFI_MODULE_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/* Includes ------------------------------------------------------------------*/
+//#include "stm32_spwf_wifi.h"
+#include "wifi_const.h"
+#include "wifi_interface.h"
+#include "event_buffer.h"
+
+/** @addtogroup MIDDLEWARES
+* @{
+*/
+
+
+/** @addtogroup NUCLEO_WIFI_MODULE
+ * @brief Wi-Fi_driver modules
+ * @{
+ */
+
+
+/** @addtogroup NUCLEO_WIFI_MODULE_Private_Macros
+ * @{
+ */
+
+//#define USART3_INT_MODE
+#define USART3_POLLING_MODE
+ /**
+ * @}
+ */
+
+
+/** @addtogroup NUCLEO_WIFI_MODULE_Private_Variables
+ * @{
+ */
+/* Private variables ---------------------------------------------------------*/
+
+/* Exported macro ------------------------------------------------------------*/
+
+/* Exported constants --------------------------------------------------------*/
+
+typedef struct Wifi_Status_Var
+{
+ wifi_bool Single_Digit_Indication;
+ wifi_bool WiFi_Enabled;
+ wifi_bool http_req_pending;
+ wifi_bool WiFi_Configuration_Done;
+ wifi_bool Timer_Running;
+ wifi_bool resume_receive_data;
+ wifi_bool enable_dequeue;
+ wifi_bool stop_event_dequeue;
+ wifi_bool Standby_Timer_Running;
+ wifi_bool trigger_wakeup_callback;
+ wifi_bool Deep_Sleep_Enabled;
+ wifi_bool Standby_Enabled;
+ wifi_bool Low_Power_Enabled;
+ wifi_bool command_mode;
+ wifi_bool data_mode;
+ wifi_bool Scan_Ongoing;
+ wifi_bool AT_Cmd_Ongoing;
+ wifi_bool AT_Cmd_Processing;
+ wifi_bool Uartx_Rx_Processing;
+ wifi_bool Client_Connected;
+ wifi_bool Client_Disconnected;
+ wifi_bool switch_by_default_to_command_mode;
+ wifi_bool start_sock_read;
+ wifi_bool enable_receive_data_chunk;
+ wifi_bool data_pending_sockD;
+ wifi_bool enable_sock_read;
+ wifi_bool enable_query;
+ wifi_bool Set_AT_Cmd_Response_False;
+ wifi_bool enable_fw_update_read;
+ wifi_bool Q_Contains_Message;
+ wifi_bool Q_Contains_Data;
+ wifi_bool enable_receive_http_response;
+ wifi_bool enable_receive_file_response;
+ wifi_bool enable_receive_wifi_scan_response;
+ wifi_bool prevent_push_OK_event;
+ wifi_bool client_socket_close_ongoing;
+ wifi_bool prevent_push_WIFI_event;
+ wifi_bool sock_read_ongoing;
+ wifi_bool enable_client_socket_write;
+ wifi_bool event_deQ_x_wind64;
+ wifi_bool do_not_reset_push_WIFI_event;
+ wifi_bool message_pending;
+ wifi_bool Pending_SockON_Callback;
+ wifi_bool Pending_SockD_Callback;
+ wifi_bool SockON_Server_Closed_Callback;
+ wifi_bool Client_Socket_Close_Cmd;
+ wifi_bool standby_resume_callback;
+ wifi_bool HTTP_Data_available;
+ wifi_bool FILE_Data_available;
+ wifi_bool AT_Response_Received;
+ wifi_bool Deep_Sleep_Timer;
+ wifi_bool Timeout_Timer;
+ wifi_bool Deep_Sleep_Callback;
+} Wifi_Status_Var;
+
+/******* Wi-Fi Configuration Setting Parameters *****************/
+
+typedef enum WiFi_Mode_TypeDef {
+ WiFi_IDLE_MODE =0,
+ WiFi_STA_MODE,
+ WiFi_IBSS_MODE,
+ WiFi_MiniAP_MODE
+} WiFi_Mode_TypeDef;
+
+
+/********** Wi-Fi Indications*************/
+
+#pragma pack(1)
+typedef struct WiFi_WIND_State_TypeDef
+{
+ wifi_bool ConsoleActive;
+ wifi_bool WiFiPowerON;
+ wifi_bool WiFiReset;
+ wifi_bool WiFiHWFailure;
+ wifi_bool HardFault;
+ wifi_bool StackOverflow;
+ wifi_bool MallocFailed;
+ wifi_bool InitFailure;
+ wifi_bool StartFailed;
+ wifi_bool PS_Mode_Failure;
+ wifi_bool HeapTooSmall;
+ wifi_bool WiFiSignalLOW;
+ wifi_bool WiFiJoin;
+ wifi_bool WiFiScanning;
+ wifi_bool WiFiUp;
+ wifi_bool WiFiAssociation;
+ wifi_bool WiFiStarted_MiniAPMode;
+ wifi_bool WiFiAPClientJoined;
+ wifi_bool WiFiAPClientLeft;
+ wifi_bool WiFiException;
+ wifi_bool WiFiHWStarted;
+ wifi_bool WiFiScanComplete;
+ wifi_bool WiFiPowerDown;
+ wifi_bool WiFiMiniAPMode;
+ wifi_bool WiFiDeauthentication;
+
+ /*Wifi Connection Errors*/
+ wifi_bool WiFiJoinFailed;
+ wifi_bool WiFiScanBlewUp;
+ wifi_bool WiFiScanFailed;
+ wifi_bool WiFiDeAuth;
+ wifi_bool WiFiDisAssociation;
+
+ /*Wifi packet lost INDs*/
+ wifi_bool WiFiUnHandledInd;
+ wifi_bool WiFiRXMgmt;
+ wifi_bool WiFiRXData;
+ wifi_bool WiFiRxUnk;
+ wifi_bool WiFiSockdDataLost;
+
+} WiFi_WIND_State_TypeDef;
+#pragma pack()
+
+typedef enum {
+ Console_Active = 0,
+ Poweron = 1,
+ WiFi_Reset,
+ Watchdog_Running,
+ Heap_Too_Small,
+ WiFi_Hardware_Dead = 5,
+ Watchdog_Terminating,
+ SysTickConfigure,
+ Hard_Fault =8,
+ StackOverflow,
+ MallocFailed,
+ Error,
+ WiFi_PS_Mode_Failure = 12,
+ CopyrightInfo,
+ WiFi_BSS_Regained = 14,
+ WiFi_Signal_LOW = 15,
+ WiFi_Signal_OK = 16,
+ FW_update = 17,
+ Encryption_key_Not_Recognized,
+ WiFi_Join = 19,
+ JOINFAILED = 20,
+ WiFi_Scanning = 21,
+ SCANBLEWUP,
+ SCANFAILED,
+ WiFi_Up = 24,
+ WiFi_Association_Successful = 25,
+ WiFi_Started_MiniAP_Mode = 26,
+ Start_Failed = 27,
+ WiFi__MiniAP_Associated = 28,
+ WiFi_EXCEPTION = 31,
+ WiFi_Hardware_Started = 32,
+ WiFi_BSS_LOST,
+ WiFi_Unhandled_Event,
+ Scan_Complete = 35,
+ WiFi_UNHANDLED_IND,
+ WiFi_UNHANDLED,
+ WiFi_Powered_Down,
+ WiFi_MiniAP_Mode = 39,
+ WiFi_Deauthentication = 40,
+ WiFi_Disassociation,
+ RX_MGMT,
+ RX_DATA,
+ RX_UNK,
+ DOT11_AUTHILLEGAL,
+ Creating_PSK = 46,
+ WPA_Terminated = 49,
+ WPA_Supplicant_Failed,
+ WPA_Handshake_Complete = 51,
+ GPIO_line,
+ Wakeup,
+ Factory_debug,
+ SockON_Data_Pending = 55,
+ Remote_Configuration = 57,
+ SockON_Server_Socket_Closed = 58,
+ In_Command_Mode = 59,
+ In_Data_Mode = 60,
+ Incoming_socket_client = 61,
+ Outgoing_socket_client = 62,
+ SockD_Dropping_Data = 63,
+ SockD_Pending_Data = 64,
+ Low_Power_Mode_Enabled = 66,
+ Going_Into_Standby = 67,
+ Resuming_From_Standby = 68,
+ Going_Into_DeepSleep = 69,
+ Resuming_From_DeepSleep = 70,
+ WiFi_MiniAP_Disassociated = 72,
+ Undefine_Indication = 0xFF
+} WiFi_Indication_t;
+
+typedef enum WiFi_Indication_t WiFi_Indication;
+
+typedef enum WiFi_Power_State_t
+{
+ Active_State,
+ PowerSave_State,
+ Sleep_State=3,
+ StandBy_State=4
+} WiFi_Power_State_t;
+
+typedef enum WiFi_AT_CMD_Response_t {
+ Process_Event =0,
+} WiFi_AT_CMD_Response_t;
+
+#ifdef WIFI_USE_VCOM
+void console_input(void);
+#endif
+
+void PowerUp_WiFi_Module(void);
+void WiFi_Module_Init(void);
+void WiFi_Application(void);
+/******* Wi-Fi AT CMD SET ****************/
+WiFi_Status_t Attention_Cmd(void);
+WiFi_Status_t USART_Transmit_AT_Cmd(uint16_t size);
+WiFi_Status_t USART_Receive_AT_Resp(WiFi_AT_CMD_Response_t);
+WiFi_Status_t Save_Current_Setting(void);
+WiFi_Status_t Restore_Default_Setting(void);
+WiFi_Status_t SET_SSID(char* ssid);
+WiFi_Status_t GET_SSID(void);
+WiFi_Status_t SET_Configuration_Value(char* sVar_name,uint32_t aValue);
+WiFi_Status_t GET_Configuration_Value(char* sVar_name,uint32_t *aValue);
+WiFi_Status_t SET_Configuration_Addr(char* sVar_name,char* addr);
+WiFi_Status_t Display_Help_Text(void);
+WiFi_Status_t SET_Power_State(WiFi_Power_State_t state);
+void Process_Wind_Indication(uint8_t *process_buff_ptr);
+void Process_WiFi_Indication_Cmd(event_s_TypeDef * event_pop_s1);
+//void USART2_SendBuffer(USART_TypeDef* USARTx, uint8_t *pData, uint8_t length);
+WiFi_Status_t Read_WiFi_SSID(char *string);
+void Reset_AT_CMD_Buffer(void);
+WiFi_Status_t Open_Serial_Port(void);
+WiFi_Status_t WaitForResponse(uint16_t alength);
+WiFi_Status_t config_init_value(char* sVar_name,uint8_t aValue);
+WiFi_Status_t config_init_addr(char* sVar_name,char* addr);
+
+char* Delete_Colon(char* );
+WiFi_Status_t Read_WiFi_Mode(char *string);
+WiFi_Status_t Read_WiFi_SecKey(char *string);
+
+WiFi_Status_t Write_WiFi_SSID(char *string);
+WiFi_Status_t Write_WiFi_SecKey(char *string);
+void PrintErrorMsg (void);
+void Print_Msg(char * msgBuff,uint8_t length);
+char *search_buffer(char *pSourceBuff, uint16_t sourceBuffLen, char *pSearchStringBuff, uint16_t seartchStringLen);
+void Error_Handler(void);
+WiFi_Status_t SET_WiFi_SecKey(char* seckey);
+void WiFi_Receive_Indication_Msg(void);
+
+void ResetBuffer(void);
+void Start_Timer(void);
+void Stop_Timer(void);
+void Request_Time_Out(void);
+void Start_DeepSleep_Timer(void);
+void Stop_DeepSleep_Timer(void);
+
+void HTTP_Read_Data(void);
+WiFi_Status_t Socket_Read(uint16_t DataLength);
+void Read_Socket_Data(void);
+void Socket_Pending_Data(void);
+void WiFi_switch_to_command_mode(void);
+void WiFi_switch_to_data_mode(void);
+void WiFi_Configuration(void);
+
+void Receive_Data(void);
+void Process_Buffer(uint8_t * ptr);
+void Process_WiFi(void);
+#if 0
+void configure_to_exti(void);
+#endif
+void Stop_Dequeue(void);
+void Resume_Dequeue(void);
+void wait_for_command_mode(void);
+void Wifi_SysTick_Isr(void);
+void RX_EXTI_Isr(uint16_t GPIO_Pin);
+//void Wifi_TIM_Handler(TIM_HandleTypeDef *htim);
+void Queue_Http_Event(uint8_t * hostname, uint8_t * path, uint32_t port_number,uint8_t * pURL_path);
+void Queue_Client_Write_Event(uint8_t sock_id, uint16_t DataLength, char * pData);
+void Queue_Wifi_FW_Update_Event(uint8_t * hostname, uint8_t * filename_path, uint32_t port_number);
+void Queue_Wifi_File_Event(uint8_t * pHostName, uint8_t * pFileName, uint32_t port_number);
+void Queue_Client_Open_Event(uint8_t * hostname, uint32_t port_number, uint8_t * protocol);
+void Queue_Client_Close_Event(uint8_t sock_id);
+void Wait_For_Sock_Read_To_Complete(void);
+void initialize_status_flags(void);
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+ }
+#endif
+#endif /* __WIFI_MODULE_H */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf/utils/event_buffer.c Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,242 @@
+/**
+ ******************************************************************************
+ * @file event_buffer.c
+ * @author Central LAB
+ * @version V2.0.0
+ * @date 10-February-2016
+ * @brief Implements the Event Buffer management of the Wi-Fi module
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "event_buffer.h"
+#include "wifi_module.h"
+
+/** @addtogroup BSP
+* @{
+*/
+
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT
+ * @brief Wi-Fi_driver modules
+ * @{
+ */
+
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Defines
+ * @{
+ */
+
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Variables
+ * @{
+ */
+extern event_s_TypeDef event_buffer[1024];
+#define ELEMENT_SIZE sizeof(event_s_TypeDef) //1
+
+//extern UART_HandleTypeDef UartMsgHandle;
+//extern char print_msg_buff[512];
+extern event_s_TypeDef element;
+
+/*
+#ifdef USART_PRINT_MSG
+#define printf(arg) sprintf((char*)print_msg_buff,arg); \
+ HAL_UART_Transmit(&UartMsgHandle, (uint8_t*)print_msg_buff, strlen(print_msg_buff), 1000);
+#endif
+*/
+
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Functions
+ * @{
+ */
+
+/**
+ * @brief init
+ * Initialize a circular buffer of type buffer_t
+ * @param None
+ * @retval None
+ */
+void event_init(buffer_e *buffer, int size) {
+ uint32_t element_size;
+ element_size = sizeof(event_s_TypeDef);
+ buffer->size = element_size*size;
+ buffer->start = 0;
+ buffer->count = 0;
+ buffer->end = 0;
+ buffer->element = event_buffer;
+}
+
+/**
+ * @brief full
+ * indicates if the given buffer is full or not
+ * @param None
+ * @retval None
+ */
+int event_full(buffer_e *buffer)
+{
+ int bufsize = buffer->size;
+ if (buffer->count == (bufsize/ELEMENT_SIZE))
+ {
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+/**
+ * @brief empty
+ * indicates if the given buffer is empty or not
+ * @param None
+ * @retval None
+ */
+int event_empty(buffer_e *buffer) {
+ if (buffer->count == 0) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+/**
+ * @brief push_buffer
+ * pushes the data structure onto the circular buffer (queues it)
+ * @param None
+ * @retval None
+ */
+void push_eventbuffer(buffer_e *buffer, event_s_TypeDef data)
+{
+ int bufsize;
+ uint32_t index;
+
+ if (event_full(buffer))
+ {
+ //Buffer overflow and no more space
+ //MPD: No Action taken here; in case of buffer overflow, do we need to overwrite last buffer?
+ //printf("\r\nRing Buffer Full!!\r\n");
+ //printf(data);
+ return;
+ } else
+ {
+ index=buffer->end/ELEMENT_SIZE;
+ buffer->element[index].data_length = data.data_length;
+ buffer->element[index].wind64_pending_packet_no = data.wind64_pending_packet_no;
+ buffer->element[index].enc = data.enc;
+ buffer->element[index].ok_eval = data.ok_eval;
+ buffer->element[index].socket_id = data.socket_id;
+ buffer->element[index].wind = data.wind;
+ buffer->element[index].event = data.event;
+ buffer->element[index].event_pop = data.event_pop;
+ buffer->count++;
+ buffer->end = buffer->end + ELEMENT_SIZE;
+
+ //wrap around if max size is reached
+ bufsize = (buffer->size);
+ if (buffer->end >= bufsize)
+ {
+ buffer->end = 0;
+ }
+ }
+}
+
+/**
+ * @brief pop_buffer_queue
+ * dequeues the circular buffer
+ * @param None
+ * @retval None
+ */
+event_s_TypeDef * pop_eventbuffer_queue(buffer_e *buffer)
+{
+ int bufsize;
+ uint32_t index;
+
+ if (event_empty(buffer))
+ {
+ //printf("\r\Event Buffer Empty!!\r\n");
+ return NULL;
+ }
+ else
+ {
+ /* First in First Out*/
+ index=buffer->start/ELEMENT_SIZE;
+ element.data_length = buffer->element[index].data_length;
+ element.enc = buffer->element[index].enc;
+ element.ok_eval = buffer->element[index].ok_eval;
+ element.socket_id = buffer->element[index].socket_id;
+ element.wind64_pending_packet_no = buffer->element[index].wind64_pending_packet_no;
+ element.wind = buffer->element[index].wind;
+ element.event = buffer->element[index].event;
+ element.event_pop = buffer->element[index].event_pop;
+ buffer->start = buffer->start + ELEMENT_SIZE;
+ buffer->count--;
+
+ bufsize = (buffer->size);
+ if (buffer->start >= bufsize)
+ {
+ buffer->start = 0;
+ }
+ return &element;
+ }
+}
+
+void reset_event(event_s_TypeDef *r_event)
+{
+ r_event->data_length = 0;
+ r_event->enc = WIFI_FALSE;
+ r_event->event = WIFI_NO_EVENT;
+ r_event->ok_eval = WIFI_FALSE;
+ r_event->socket_id = 9; //Socket ID 0-7
+ r_event->wind64_pending_packet_no = 9; //Max pending packets = 4
+ r_event->wind = 99; //any default value
+ r_event->event_pop = WIFI_TRUE;
+}
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+
+/**
+ * @}
+ */
+
+/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf/utils/event_buffer.h Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,157 @@
+ /**
+ ******************************************************************************
+ * @file event_buffer.h
+ * @author Central LAB
+ * @version V2.0.0
+ * @date 10-February-2016
+ * @brief Header File for Event Buffer management of the Wi-Fi module
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
+
+/* Includes ------------------------------------------------------------------*/
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "wifi_module.h"
+#ifndef __EVENT_BUFFER_H
+#define __EVENT_BUFFER_H
+
+/** @addtogroup BSP
+* @{
+*/
+
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT
+ * @brief Wi-Fi_driver modules
+ * @{
+ */
+
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_TypesDefinitions
+ * @{
+ */
+
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Defines
+ * @{
+ */
+
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Macros
+ * @{
+ */
+
+
+
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Variables
+ * @{
+ */
+
+typedef enum
+{
+ WIFI_NO_EVENT,
+ WIFI_WIND_EVENT = 0x0001,
+ WIFI_SOCK_ID_EVENT,
+ WIFI_GCFG_EVENT,
+ WIFI_GPIO_EVENT,
+ WIFI_OK_EVENT,
+ WIFI_ERROR_EVENT,
+ WIFI_STANDBY_CONFIG_EVENT,
+ WIFI_RESUME_CONFIG_EVENT,
+ WIFI_HTTP_EVENT,
+ WIFI_CLIENT_SOCKET_WRITE_EVENT,
+ WIFI_FILE_EVENT,
+ WIFI_CLIENT_SOCKET_OPEN_EVENT,
+ WIFI_CLIENT_SOCKET_CLOSE_EVENT,
+ WIFI_FW_UPDATE_EVENT,
+} event_e;
+
+
+typedef struct
+{
+ uint32_t wind;
+ uint32_t data_length;
+ uint16_t socket_id;
+ uint8_t wind64_pending_packet_no;
+ wifi_bool enc;
+ wifi_bool ok_eval;
+ wifi_bool event_pop;
+ event_e event;
+} event_s_TypeDef;
+
+struct event_buffer {
+ volatile int start; // position of first data from USART
+ volatile int end; // position of last data from USART
+ volatile int size; //Max size in terms of number of data packets (Total Bytes/size of each packet (8 bytes))
+ volatile int count; // number of currently filled data packets (=size if full & =0 if empty)
+
+ /*unsigned main buffer pointer*/
+ event_s_TypeDef *element;
+};
+
+typedef struct event_buffer buffer_e;
+
+void event_init(buffer_e *buffer, int size);
+int event_full(buffer_e *buffer);
+int event_empty(buffer_e *buffer);
+void push_eventbuffer(buffer_e *buffer, event_s_TypeDef data);
+event_s_TypeDef * pop_eventbuffer_queue(buffer_e *buffer);
+void reset_event(event_s_TypeDef *r_event);
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf/utils/ring_buffer.c Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,368 @@
+/**
+ ******************************************************************************
+ * @file ring_buffer.c
+ * @author Central LAB
+ * @version V2.0.0
+ * @date 10-February-2016
+ * @brief Implements the Circular Buffer management of the Wi-Fi module
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "ring_buffer.h"
+#include "wifi_module.h"
+
+/** @addtogroup MIDDLEWARES
+* @{
+*/
+
+
+/** @defgroup NUCLEO_WIFI_UTILS
+ * @brief Wi-Fi buffer utility
+ * @{
+ */
+
+
+/** @defgroup NUCLEO_WIFI_UTILS_Private_Defines
+ * @{
+ */
+
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_UTILS_Private_Variables
+ * @{
+ */
+
+extern uint8_t ring_buffer[RINGBUF_SIZE];
+extern uint8_t pop_buffer[MAX_BUFFER_GLOBAL];
+extern uint8_t prefetch_buffer[20];
+//extern wifi_bool enable_receive_data_chunk;
+extern volatile Wifi_Status_Var status_flag;
+extern uint32_t pop_buffer_size;
+
+#define ELEMENT_SIZE 1
+
+
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_UTILS_Private_Functions
+ * @{
+ */
+
+/**
+ * @brief init
+ * Initialize a circular buffer of type buffer_td
+ * @param None
+ * @retval None
+ */
+void init(buffer_td *buffer, int size)
+{
+ buffer->size = size;
+ buffer->start = 0;
+ buffer->count = 0;
+ buffer->end = 0;
+ buffer->element = ring_buffer;
+}
+
+/**
+ * @brief flush_buffer_queue
+ * flushes the buffer
+ * @param None
+ * @retval None
+ */
+void flush_buffer_queue(buffer_td *buffer)
+{
+ buffer->start = buffer->end;//the tail goes up to the head and buffer becomes empty
+ buffer->count = 0;
+}
+
+/**
+ * @brief is_half_full
+ * checks if the buffer is half full (empty)
+ * @param None
+ * @retval None
+ */
+int is_half_full(buffer_td *buffer)
+{
+ int bufsize = buffer->size;
+ if (buffer->count >= bufsize - 100)
+ {
+ //printf("half full!");
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+/**
+ * @brief is_half_empty
+ * checks if the buffer is less than half
+ * @param None
+ * @retval None
+ */
+int is_half_empty(buffer_td *buffer)
+{
+ //int bufsize = buffer->size;
+ if (buffer->count <= 100)
+ {
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+/**
+ * @brief full
+ * indicates if the given buffer is full or not
+ * @param None
+ * @retval None
+ */
+int full(buffer_td *buffer)
+{
+ int bufsize = buffer->size;
+ if (buffer->count == bufsize)
+ {
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+/**
+ * @brief empty
+ * indicates if the given buffer is empty or not
+ * @param None
+ * @retval None
+ */
+int empty(buffer_td *buffer) {
+ if (buffer->count == 0) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+/**
+ * @brief prefetch_buffer_queue
+ * prefetches the pipeline upto xx bytes
+ * @param None
+ * @retval None
+ */
+uint8_t * prefetch_buffer_queue(buffer_td *buffer)
+{
+ //int i = 0;
+ uint8_t * element;
+ int bufsize;
+
+ memset(prefetch_buffer,0x00,20);
+ element = &prefetch_buffer[0];
+ element[4] = '\0';
+
+ if(!empty(buffer))
+ {
+ bufsize = (buffer->count);
+ if(buffer->count <= 20)
+ memcpy(element, &buffer->element[buffer->start], bufsize);
+ else
+ memcpy(element, &buffer->element[buffer->start], 20);
+ return element;
+ }
+ else return NULL;
+}
+
+/*
+ * @brief push_buffer
+ * pushes a new item onto the circular buffer (queues it)
+ * @param None
+ * @retval None
+ */
+void push_buffer(buffer_td *buffer, uint8_t *data)
+{
+ int bufsize;
+
+ if (full(buffer))
+ {
+ //Buffer overflow and no more space
+ //MPD: No Action taken here; in case of buffer overflow, do we need to overwrite last buffer?
+ //printf("\r\nRing Buffer Full!!\r\n");
+ //printf(data);
+ return;
+ }
+ else
+ {
+ buffer->count++;
+ memcpy(&buffer->element[buffer->end], data, ELEMENT_SIZE);
+ buffer->end = buffer->end + ELEMENT_SIZE;
+
+ //wrap around if max size is reached
+ bufsize = (buffer->size);
+ if (buffer->end >= bufsize)
+ {
+ buffer->end = 0;
+ }
+ }
+}
+
+/**
+ * @brief pop_buffer_queue
+ * dequeues the circular buffer
+ * @param None
+ * @retval None
+ */
+uint8_t * pop_buffer_queue(buffer_td *buffer)
+{
+ uint8_t * element;
+ int bufsize;
+
+ element = &pop_buffer[0];
+ if (empty(buffer))
+ {
+ //printf("\r\nRing Buffer Empty!!\r\n");
+ return NULL;
+ }
+ else
+ {
+ memset(pop_buffer, 0x00 , MAX_BUFFER_GLOBAL);
+ if(status_flag.enable_receive_data_chunk)
+ {
+ int buf_end = buffer->end;
+ // int buf_start = buffer->start;
+ if(buffer->count < 512)
+ {
+ pop_buffer_size = buffer->count;
+ if(buf_end >= buffer->start)
+ {
+ memcpy(element, &buffer->element[buffer->start], pop_buffer_size);
+ }
+ else
+ {
+ int buf_start = buffer->start;
+ memcpy(element, &buffer->element[buffer->start], RINGBUF_SIZE - buf_start);
+ memcpy(element+(RINGBUF_SIZE-buffer->start), &buffer->element[0], buf_end);
+ }
+ buffer->start = buffer->end;
+ buffer->count = 0;
+ }
+ else
+ {
+ if(buf_end >= buffer->start)
+ {
+ memcpy(element, &buffer->element[buffer->start], 511);
+ buffer->start = buffer->start + 511;
+ buffer->count = buf_end - buffer->start;
+ }
+ else
+ {
+ if(buffer->start + 511 < RINGBUF_SIZE)
+ {
+ memcpy(element, &buffer->element[buffer->start], 511);
+ buffer->start = buffer->start + 511;
+ buffer->count = (RINGBUF_SIZE - buffer->start)+ buf_end;
+ }
+ else
+ {
+ int buf_start = buffer->start;
+ memcpy(element, &buffer->element[buffer->start], RINGBUF_SIZE-buf_start);
+ memcpy(element+(RINGBUF_SIZE-buffer->start), &buffer->element[0], buf_start-513); //(buffer->start + 511) - 1024;
+ buffer->start = (buffer->start-513);
+ buffer->count = buf_end - buffer->start;
+ }
+ }
+ pop_buffer_size = 511;
+ }
+ }
+ else
+ {
+ /* First in First Out*/
+ memcpy(element, &buffer->element[buffer->start], ELEMENT_SIZE);
+ buffer->start = buffer->start + ELEMENT_SIZE;
+ buffer->count--;
+ pop_buffer_size = 1;
+ bufsize = (buffer->size);
+ if (buffer->start >= bufsize)
+ {
+ buffer->start = 0;
+ }
+ }
+ return element;
+ }
+}
+
+/**
+ * @brief rewinds_buffer_queue
+ * rewinds the circular buffer
+ * @param None
+ * @retval None
+ */
+void rewind_buffer_queue(buffer_td *buffer , int count)
+{
+ int buf_end = buffer->end;
+ if(buffer->start - count >= 0)
+ {
+ buffer->start = buffer->start - count;
+ if(buf_end > buffer->start) {
+ buffer->count = buf_end - buffer->start;
+ }
+ else {
+ buffer->count = (RINGBUF_SIZE-buffer->start)+buf_end;
+ }
+ }
+ else
+ {
+ buffer->start = RINGBUF_SIZE - (count - buffer->start);
+ buffer->count = (RINGBUF_SIZE - buffer->start)+ buf_end;
+ }
+}
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+
+/**
+ * @}
+ */
+
+/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf/utils/ring_buffer.h Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,130 @@
+ /**
+ ******************************************************************************
+ * @file ring_buffer.h
+ * @author Central LAB
+ * @version V2.0.0
+ * @date 10-February-2016
+ * @brief Header File for Circular Buffer management of the Wi-Fi module
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
+
+/* Includes ------------------------------------------------------------------*/
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifndef __RING_BUFFER_H
+#define __RING_BUFFER_H
+
+/** @addtogroup BSP
+* @{
+*/
+
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT
+ * @brief Wi-Fi_driver modules
+ * @{
+ */
+
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_TypesDefinitions
+ * @{
+ */
+
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Defines
+ * @{
+ */
+
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Macros
+ * @{
+ */
+
+
+
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Variables
+ * @{
+ */
+
+struct buffer {
+ volatile int start; // position of first data from USART
+ volatile int end; // position of last data from USART
+ volatile int size; //Max size in terms of number of data packets (Total Bytes/size of each packet (8 bytes))
+ volatile int count; // number of currently filled data packets (=size if full & =0 if empty)
+
+ /*unsigned main buffer pointer*/
+ uint8_t *element;
+};
+
+typedef struct buffer buffer_td;
+
+void init(buffer_td *buffer, int size);
+void flush_buffer_queue(buffer_td *buffer);
+int is_half_full(buffer_td *buffer);
+int is_half_empty(buffer_td *buffer);
+int full(buffer_td *buffer);
+int empty(buffer_td *buffer);
+void push_buffer(buffer_td *buffer, uint8_t *data);
+uint8_t * pop_buffer_queue(buffer_td *buffer);
+uint8_t * popstack(buffer_td *buffer);
+uint8_t * prefetch_buffer_queue(buffer_td *buffer);
+void rewind_buffer_queue(buffer_td *buffer , int count);
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf/wifi_driver.c Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,187 @@
+/**
+ ******************************************************************************
+ * @file wifi_driver.c
+ * @author Central LAB
+ * @version V2.0.0
+ * @date 01-March-2016
+ * @brief Enable Wi-Fi functionality using AT cmd set
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
+/* Includes ------------------------------------------------------------------*/
+
+#include <stddef.h>
+#include "wifi_module.h"
+#include "ring_buffer.h"
+#include "device.h"
+#include "wait_api.h"
+#include "stdio.h"
+#include "string.h"
+#include "wifi_driver.h"
+
+void Wifi_ticker(void)
+{
+ Wifi_SysTick_Isr();
+}
+
+void Wifi_scheduler(void)
+{
+ Wifi_TIM_Handler();
+}
+
+void Rx_irq_handler(void)
+{
+
+ uint8_t data_byte = (uint8_t)callSpwfSADevice_getChar(spwf_dev);
+
+ status_flag.Uartx_Rx_Processing = WIFI_FALSE;
+
+ Stop_Timer();
+ __disable_irq();
+ push_buffer(&big_buff, &data_byte);
+ __enable_irq();
+ Start_Timer();
+
+ status_flag.Uartx_Rx_Processing = WIFI_TRUE;
+
+ /*if(is_half_full(&big_buff))
+ {
+ status_flag.resume_receive_data = WIFI_TRUE;
+ if(callSpwfSADevice_read_rts(spwf_dev))
+ callSpwfSADevice_rts(spwf_dev, GPIO_PIN_SET);
+ //callSpwfSADevice_attach(0);
+ } else
+ {
+ if(status_flag.AT_Cmd_Processing == WIFI_FALSE)
+ {
+ status_flag.Uartx_Rx_Processing = WIFI_TRUE;
+ }
+ }*/
+}
+
+
+/**
+* @brief wifi_reset
+* Reset WiFi module using PC12 gpio pin
+* @param None
+* @retval None
+*/
+void wifi_reset(void)
+{
+ WiFi_Module_State = Process_Event;
+ WiFi_WIND_State.WiFiHWStarted = WIFI_FALSE;
+ wifi_connected = 0; //reset wifi_connected to get user callback
+ memset((void*)&WiFi_WIND_State,0x00,sizeof(WiFi_WIND_State)); /*reset the WIND State?*/
+
+ /* === RESET PIN - PC12 ===*/
+
+ callSpwfSADevice_reset(spwf_dev, 0);
+ wait_ms(200);
+
+ callSpwfSADevice_reset(spwf_dev, 1);
+ wait_ms(100);
+
+ while(WiFi_WIND_State.WiFiHWStarted != WIFI_TRUE)
+ {
+ //nothing to do
+ __NOP();
+ }
+}
+
+
+/**
+* @brief PowerUp_WiFi_Module
+* Power up Wi-Fi module,SET GPIO PA0 pin
+* @param None
+* @retval None
+*/
+void PowerUp_WiFi_Module(void)
+{
+ /* === SET PIN - PC12 ===*/
+ callSpwfSADevice_reset(spwf_dev, 1);
+ wait_ms(50);
+}
+
+/**
+* @brief Receive_Data
+* Receive data from UART port
+* @param uint8_t number of bytes to be received
+* @retval None
+*/
+void Receive_Data(void)
+{
+ callSpwfSADevice_rts(spwf_dev, 0);
+}
+
+
+/**
+* @brief USART_Transmit_AT_Cmd
+* send AT cmd on UART port of wifi module.
+* @param size size of the AT command
+* @retval WiFi_Status_t : status of AT cmd
+*/
+WiFi_Status_t USART_Transmit_AT_Cmd(uint16_t size)
+{
+ //Check for Hardware Started
+ if(status_flag.WiFi_Enabled == WIFI_FALSE)
+ return WiFi_NOT_READY;
+ //Check for Deep-Sleep or Standby Mode, return error if true
+ if (status_flag.Standby_Enabled == WIFI_TRUE || status_flag.Deep_Sleep_Enabled == WIFI_TRUE)
+ return WiFi_IN_LOW_POWER_ERROR;
+
+ status_flag.AT_Cmd_Processing = WIFI_TRUE;//Stop Any Rx between the TX call
+
+ if (size == 0)
+ {
+ return WiFi_UNHANDLED_IND_ERROR;
+ }
+
+#if defined(USART3_INT_MODE)
+ if(HAL_UART_Transmit_IT(&UartWiFiHandle, (uint8_t *)WiFi_AT_Cmd_Buff, size)!= HAL_OK)
+ {
+ Error_Handler();
+ return WiFi_HAL_UART_ERROR;
+ }
+ while (UartReady != SET);
+ UartReady = RESET;
+
+#elif defined(USART3_POLLING_MODE)
+
+ callSpwfSADevice_write(spwf_dev, (const char *) WiFi_AT_Cmd_Buff, size);
+
+#else
+ #error "Please select USART mode in your application (in wifi_module.h file)"
+#endif
+
+ status_flag.AT_Cmd_Processing = WIFI_FALSE;//Re-enable Rx for UART
+ if(status_flag.Uartx_Rx_Processing == WIFI_FALSE)
+ Receive_Data();//Start receiving Rx from the UART again, if and only if it was stopped in the previous Uartx_Rx_Handler
+ return WiFi_MODULE_SUCCESS;
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf/wifi_interface.c Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,1437 @@
+/**
+ ******************************************************************************
+ * @file wifi_interface.c
+ * @author Central LAB
+ * @version V2.0.0
+ * @date 10-February-2016
+ * @brief User APIs implementation for X-CUBE-WIFI1
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
+
+/* Includes ------------------------------------------------------------------*/
+#include "wifi_module.h"
+//#include "stm32_spwf_wifi.h"
+#include "ring_buffer.h"
+#include "stdio.h"
+#include "string.h"
+#include "gpio_irq_api.h"
+#include "gpio_api.h"
+#include "wait_api.h"
+#include "serial_api.h"
+
+/** @addtogroup MIDDLEWARES
+* @{
+*/
+
+
+/** @defgroup NUCLEO_WIFI_INTERFACE
+ * @brief Wi-Fi User API modules
+ * @{
+ */
+
+
+/** @defgroup NUCLEO_WIFI_INTERFACE_Private_Defines
+ * @{
+ */
+
+
+/**
+ * @}
+ */
+
+/** @addtogroup NUCLEO_WIFI_INTERFACE_Private_Variables
+ * @{
+ */
+/* Private variables ---------------------------------------------------------*/
+
+#if defined (USE_STM32F4XX_NUCLEO) || (USE_STM32L4XX_NUCLEO)
+extern uint8_t WiFi_AT_Cmd_Buff[2048];
+#else
+extern uint8_t WiFi_AT_Cmd_Buff[1024];
+#endif
+
+extern volatile Wifi_Status_Var status_flag;
+
+extern char UserDataBuff[MAX_BUFFER_GLOBAL];
+extern wifi_scan *wifi_scanned_list;//[15];
+extern char print_msg_buff[MAX_BUFFER_GLOBAL];
+extern uint8_t user_scan_number;
+extern uint8_t no_of_open_client_sockets;
+extern wifi_bool open_sockets[8];//Max open sockets allowed is 8. Each array element depicts one socket (true=open, false=closed)
+extern WiFi_AT_CMD_Response_t WiFi_Module_State;
+extern volatile uint8_t wifi_client_connected;
+extern uint8_t gpio_value, gpio_direc;
+extern volatile uint8_t wifi_connected;
+extern uint32_t SockON_Data_Length;
+extern uint8_t Socket_Open_ID, sockon_query_id;
+extern volatile uint32_t WIND64_count;
+extern uint32_t process_buffer_index;
+extern uint32_t epoch_time;
+
+/*SPWFSADevice Class functions and variables*/
+void * spwf_device_class;
+extern void callSpwfSADevice_wakeup(void* object, int wake);
+extern void callSpwfSADevice_debug(void* object, const char * string);
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_INTERFACE_Private_Functions
+ * @{
+ */
+#ifdef USART_PRINT_MSG
+#define printf(arg) {sprintf((char*)print_msg_buff,arg); \
+HAL_UART_Transmit(&UartMsgHandle, (uint8_t*)print_msg_buff, strlen(print_msg_buff), 1000);}
+#endif
+
+/**
+ *Changed/introduced functions for MBED implementation:
+
+- WiFi_Status_t wifi_init(wifi_config* config)
+- WiFi_Status_t wifi_wakeup(wifi_bool wakeup)
+- WiFi_Status_t wifi_socket_server_write(uint16_t DataLength,char * pData)
+- void wifi_reset(void);
+- WiFi_Status_t wifi_enable(wifi_bool enable)
+
+*/
+
+
+/**
+ * @brief wifi_init
+ * User API for wifi init
+ * @param None
+ * @retval None
+ */
+WiFi_Status_t wifi_init(wifi_config* config)
+{
+#ifndef WIFI_USE_VCOM
+ uint8_t tx_level;
+#endif
+
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+#if DEBUG_PRINT
+ printf("\r\n[SPWF]Initializing SPWF01SA1 Interface\r\n");
+#endif
+ //callSpwfSADevice_debug(spwf_device_class, "\r\n[SPWF] Initializing mbed SPWF01SA1 Interface\r\n");
+
+ WiFi_Module_Init();
+
+ //callSpwfSADevice_debug(spwf_device_class, "\r\n[SPWF] Module Init done\r\n");
+
+#ifndef WIFI_USE_VCOM
+
+ wifi_wakeup(WIFI_TRUE);//Prevent from going to sleep during configuration
+
+ /* Soft reset the module */
+ wifi_reset();
+
+ //callSpwfSADevice_debug(spwf_device_class, "\r\n[SPWF] Hardware started\r\n");
+
+ /* Set localecho1 to 0*/
+ status = SET_Configuration_Value(LOCALECHO1, 0);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+
+ /* Restore default setting*/
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_RESTORE_DEFAULT_SETTING);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ /* Switch on HW Flow Control*/
+ status = SET_Configuration_Value(CONSOLE1_HWFC, 1);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+
+ if(config->wifi_baud_rate)
+ {
+ /* Set USART Speed*/
+ status = SET_Configuration_Value(CONSOLE1_SPEED, config->wifi_baud_rate);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ /* Set wifi_mode to idle*/
+ status = SET_Configuration_Value(WIFI_MODE, WiFi_IDLE_MODE);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+
+ switch(config->ht_mode)
+ {
+ case WIFI_FALSE:
+ status = SET_Configuration_Value(WIFI_HT_MODE, 0);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ status = SET_Configuration_Addr(WIFI_OPR_RATE_MASK, "0x00003FCF");
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ break;
+ case WIFI_TRUE:
+ status = SET_Configuration_Value(WIFI_HT_MODE, 1);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ status = SET_Configuration_Addr(WIFI_OPR_RATE_MASK, "0x003FFFCF");
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ break;
+ default:
+ break;
+ }
+
+ switch(config->power)
+ {
+ case wifi_active:
+ status = SET_Configuration_Value(WIFI_POWERSAVE, 0);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ status = SET_Configuration_Value(WIFI_SLEEP_ENABLED, 0);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ break;
+ case wifi_reactive:
+ status = SET_Configuration_Value(WIFI_POWERSAVE, 1);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ status = SET_Configuration_Value(WIFI_OPERATIONAL_MODE, 11);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ status = SET_Configuration_Value(WIFI_BEACON_WAKEUP, 0);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ status = SET_Configuration_Value(WIFI_LISTEN_INTERVAL, 0);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ status = SET_Configuration_Value(WIFI_SLEEP_ENABLED, 0);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ break;
+ case wifi_sleep:
+ status = SET_Configuration_Value(WIFI_POWERSAVE, 1);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ status = SET_Configuration_Value(WIFI_OPERATIONAL_MODE, 12);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ status = SET_Configuration_Value(WIFI_BEACON_WAKEUP, 10);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ status = SET_Configuration_Value(WIFI_LISTEN_INTERVAL, 1);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ status = SET_Configuration_Value(WIFI_SLEEP_ENABLED, 1);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ break;
+ default:
+ break;
+ }
+
+ switch(config->power_level)
+ {
+ case low:
+ case medium:
+ case high:
+ case max:
+ tx_level=config->power_level*6;
+ status = SET_Configuration_Value(WIFI_TX_POWER, tx_level);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ break;
+ default:
+ break;
+ }
+
+ switch(config->dhcp)
+ {
+ case off:
+ case on:
+ case custom:
+ status = SET_Configuration_Value(IP_USE_DHCP_SERVER, config->dhcp);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ break;
+ default:
+ break;
+ }
+
+ /* Set IP address */
+ if(config->ip_addr)
+ {
+ status = SET_Configuration_Addr(WIFI_IP_ADDRESS, config->ip_addr);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+ /* Set netmask address */
+ if(config->netmask_addr)
+ {
+ status = SET_Configuration_Addr(WIFI_IP_NETMASK, config->netmask_addr);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+ /* Set default gateway address */
+ if(config->gateway_addr)
+ {
+ status = SET_Configuration_Addr(WIFI_IP_DEFAULT_GATEWAY, config->gateway_addr);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+ /* Set dns address */
+ if(config->dns_addr)
+ {
+ status = SET_Configuration_Addr(WIFI_IP_DNS, config->dns_addr);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+ /* Set hostname */
+ if(config->host_name)
+ {
+ status = SET_Configuration_Addr(WIFI_IP_HOSTNAME, config->host_name);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ if(config->ap_domain_name)
+ {
+ status = SET_Configuration_Addr(WIFI_IP_APDOMAINNAME, config->ap_domain_name);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ if(config->ap_config_page_name)
+ {
+ status = SET_Configuration_Addr(WIFI_IP_APREDIRECT, config->ap_config_page_name);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ if(config->http_timeout)
+ {
+ status = SET_Configuration_Value(WIFI_IP_HTTP_TIMEOUT, config->http_timeout*1000);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+ if(config->dhcp_timeout)
+ {
+ status = SET_Configuration_Value(WIFI_IP_DHCP_TIMEOUT, config->dhcp_timeout);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+#ifdef MODULE_VERSION_SPWF01Sx_1y
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_HTTPD, config->web_server);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+#endif
+
+ /*AT+S.TLSCERT2=clean,all */
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSCERT2=clean,all\r");
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ /* save current setting in flash */
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SAVE_CURRENT_SETTING);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ if(config->wifi_baud_rate)
+ {
+ UART_Configuration(config->wifi_baud_rate);
+ Receive_Data();//Restart data reception
+ }
+
+ /* Soft reset the module, Do the second reset after setting all parameters and saving in flash */
+ wifi_reset();
+
+ wifi_wakeup(WIFI_FALSE);//De-assert wakeup signal (PC8) to allow sleep if enabled
+#endif //WIFI_USE_VCOM
+
+#if DEBUG_PRINT
+ printf("\r\nEnd of Initialization..\r\n");
+#endif
+ //callSpwfSADevice_debug(spwf_device_class, "\r\n[SPWF] End of mbed Initialization\r\n");
+
+ return status;
+}
+
+
+/**
+* @brief wifi_socket_client_security
+* Set the security certificates and key for secure socket (TLS)
+* @param None
+* @retval WiFi_Status_t : return status
+*/
+WiFi_Status_t wifi_socket_client_security(uint8_t* tls_mode, uint8_t* root_ca_server, uint8_t* client_cert, uint8_t* client_key, uint8_t* client_domain, uint32_t tls_epoch_time)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ /*AT+S.TLSCERT2=clean,all */
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSCERT2=clean,all\r");
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ /* AT+S.SETTIME=<seconds> */
+ Reset_AT_CMD_Buffer();
+ if(tls_epoch_time==0)
+ epoch_time = EPOCH_TIME;
+ else
+ epoch_time = tls_epoch_time;
+
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.SETTIME=%lu\r",(unsigned long)epoch_time);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ /*AT+S.TLSCERT=f_ca,<size><CR><data>*/
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSCERT=f_ca,%d\r%s",strlen((const char *)root_ca_server) - 1, root_ca_server);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ /*AT+S.TLSCERT=f_cert,<size><CR><data>*/
+ if(tls_mode[0]=='m')
+ {
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSCERT=f_cert,%d\r%s",strlen((const char *)client_cert) - 1, client_cert);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ /*AT+S.TLSCERT=f_key,<size><CR><data>*/
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSCERT=f_key,%d\r%s",strlen((const char *)client_key) - 1, client_key);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+ }
+
+ /*AT+S.TLSDOMAIN=f_domain,<server domain>*/
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSDOMAIN=f_domain,%s\r", client_domain);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ if(status != WiFi_MODULE_SUCCESS) return status;
+ }
+
+ return status;
+}
+
+/**
+* @brief wifi_socket_client_open
+* Open a network socket
+* @param Hostname hostname to connect to
+* portnumber portnumber of the Host to connect to
+* protocol tcp or udp protocol
+* sock_id socket id of the opened socket returned to the user
+* @retval WiFi_Status_t : return status of socket open request
+*/
+WiFi_Status_t wifi_socket_client_open(uint8_t * hostname, uint32_t port_number, uint8_t * protocol, uint8_t * sock_id)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ Queue_Client_Open_Event(hostname,port_number,protocol);
+ status = USART_Receive_AT_Resp(Process_Event);
+
+ *sock_id = Socket_Open_ID; //return the socket id to the user
+
+ return status;
+}
+
+/**
+* @brief Open_Serial_Port
+* Open a network socket
+* @param None
+* @retval WiFi_Status_t : Wifi status
+*/
+WiFi_Status_t Open_Serial_Port()
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ /* AT+S.SOCKOS=2<cr> */
+ Reset_AT_CMD_Buffer();
+ //sprintf((char*)WiFi_AT_Cmd_Buff,"\rAT+S.SOCKOS=%d\r",SerialPortNo);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+
+ if(status==WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+ return status;
+}
+
+/**
+* @brief wifi_socket_client_write
+* Write len bytes of data to socket
+* @param sock_id socket ID of the socket to write to
+* DataLength: data length to send
+* pData : pointer of data buffer to be written
+* @retval WiFi_Status_t : return status of socket write request
+*/
+WiFi_Status_t wifi_socket_client_write(uint8_t sock_id, uint16_t DataLength, char * pData)
+{
+ /* AT+S.SOCKW=00,11<cr> */
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ //Check if sock_id is open
+ if(!open_sockets[sock_id])
+ return WiFi_NOT_READY;
+
+ if(DataLength>=1021 || DataLength<=0)
+ return WiFi_NOT_SUPPORTED;
+
+ Queue_Client_Write_Event(sock_id,DataLength,pData);
+ status = USART_Receive_AT_Resp(Process_Event);
+ return status;
+}
+
+/**
+* @brief Socket_Read
+* Return len bytes of data from socket
+* @param DataLength: data length to read
+* @retval WiFi_Status_t : return status of socket read request
+*/
+WiFi_Status_t Socket_Read(uint16_t DataLength)
+{
+ /* AT+S.SOCKR=01,12<cr> */
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ wait_for_command_mode();
+
+ /* AT+S.SOCKON=myserver,1234,t<cr> */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SOCKET_READ,sockon_query_id,DataLength);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ if(status_flag.stop_event_dequeue == WIFI_FALSE)
+ status_flag.stop_event_dequeue = WIFI_TRUE;
+ SockON_Data_Length = DataLength;
+ status_flag.enable_sock_read = WIFI_TRUE;
+ process_buffer_index =5;
+ status_flag.enable_receive_data_chunk = WIFI_TRUE;
+ WiFi_Module_State = Process_Event;
+ status_flag.Set_AT_Cmd_Response_False = WIFI_TRUE;
+ memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);
+ }
+ return status;
+}
+
+/**
+* @brief wifi_socket_client_close
+* The SOCKC command allows to close socket
+* @param sock_close_id the socket ID of the socket which needs to be closed.
+* @retval WiFi_Status_t : return status of socket close request
+*/
+WiFi_Status_t wifi_socket_client_close(uint8_t sock_close_id)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ if(open_sockets[sock_close_id])
+ {
+ Queue_Client_Close_Event(sock_close_id);
+ return status;
+ }
+ else
+ return WiFi_MODULE_ERROR;
+
+}
+
+/**
+* @brief Socket_Pending_Data
+* Query pending data.It will returns the number of bytes of data waiting on socket
+* @param None
+* @retval uint8_t :number of bytes of data waiting on socket
+*/
+void Socket_Pending_Data()
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ /* AT+S.SOCKQ=01<cr> */
+ Reset_AT_CMD_Buffer();
+
+ wait_for_command_mode();
+
+ if(open_sockets[sockon_query_id])
+ {
+ if(status_flag.stop_event_dequeue == WIFI_FALSE)
+ status_flag.stop_event_dequeue = WIFI_TRUE;
+
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_QUERY_PENDING_DATA,sockon_query_id);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status==WiFi_MODULE_SUCCESS)
+ {
+ /* EQ. Set state to Process_Event */
+ WiFi_Module_State = Process_Event;
+ status_flag.Set_AT_Cmd_Response_False = WIFI_TRUE;
+ }
+}
+}
+
+/**
+* @brief wifi_socket_server_open
+* Open a Server socket
+* @param None
+* @retval WiFi_Status_t : return status of server socket request
+*/
+WiFi_Status_t wifi_socket_server_open(uint32_t port_number, uint8_t * protocol)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+Reset_AT_CMD_Buffer();
+
+/* AT+S.SOCKD=portNo,t<cr> */
+sprintf((char*)WiFi_AT_Cmd_Buff,AT_SERVER_SOCKET_OPEN,(int)port_number,protocol);
+status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+if(status == WiFi_MODULE_SUCCESS)
+{
+status = USART_Receive_AT_Resp(Process_Event);
+}
+return status;
+}
+
+/**
+* @brief wifi_socket_server_write
+* Write to a Server socket
+* @param None
+* @retval WiFi_Status_t : return status of server socket request
+*/
+WiFi_Status_t wifi_socket_server_write(uint16_t DataLength,char * pData)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+/*Can only write if there is a client connected*/
+if(!wifi_client_connected)
+{
+return WiFi_NOT_READY;
+}
+ __disable_irq();
+
+status_flag.do_not_reset_push_WIFI_event = WIFI_TRUE;
+status_flag.prevent_push_WIFI_event = WIFI_TRUE;
+__enable_irq();
+
+while(status_flag.sock_read_ongoing || WIND64_count!= 0)//wait till any pending data is read
+{
+ asm("NOP");
+}
+
+wait_for_command_mode();
+
+/*to make sure that by default the mode is not switched to command mode from data mode*/
+status_flag.switch_by_default_to_command_mode = WIFI_FALSE;
+
+/*Switch to Data Mode first*/
+if(!status_flag.data_mode)
+{
+WiFi_switch_to_data_mode();//switch by default
+while(!status_flag.data_mode)
+{
+ //Wait till data_mode is active
+ asm("NOP");
+}
+}
+
+/*Write the data on the uart*/
+/*if(HAL_UART_Transmit(&UartWiFiHandle, (uint8_t *)pData, DataLength,1000)!= HAL_OK)
+{
+Error_Handler();
+return WiFi_HAL_UART_ERROR;
+}*/
+//HAL_Delay(100);//Wait for tx before switching back to command mode
+
+/*Switch back to Command Mode*/
+if(!status_flag.command_mode)
+{
+WiFi_switch_to_command_mode();//switch by default
+while(!status_flag.command_mode)
+{
+ //Wait till command_mode is active
+ asm("NOP");
+}
+}
+
+status_flag.switch_by_default_to_command_mode = WIFI_TRUE; /*back to default behaviour*/
+
+__disable_irq();
+status_flag.prevent_push_WIFI_event = WIFI_FALSE;
+status_flag.do_not_reset_push_WIFI_event = WIFI_FALSE;
+__enable_irq();
+
+return status;
+}
+
+/**
+* @brief Server Socket Close
+* Close a Server socket
+* @param None
+* @retval WiFi_Status_t : return status of server socket request
+*/
+WiFi_Status_t wifi_socket_server_close()
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+Reset_AT_CMD_Buffer();
+
+/* AT+S.SOCKD=portNo,t<cr> */
+sprintf((char*)WiFi_AT_Cmd_Buff,AT_SERVER_SOCKET_CLOSE);
+status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+if(status == WiFi_MODULE_SUCCESS)
+{
+status = USART_Receive_AT_Resp(Process_Event);
+}
+
+return status;
+}
+
+
+/**
+* @brief wait_for_command_mode
+* Waits till we are in command mode
+* @param None
+* @retval None
+*/
+void wait_for_command_mode(void)
+{
+while(!status_flag.command_mode)
+ {
+ //Make sure we are in command mode, ideally we should do this in every User API?
+ asm("NOP");
+ }
+}
+
+
+/**
+* @brief wifi_file_delete
+* Delete a file
+* @param pFileName : File Name to be deleted
+* @retval WiFi_Status_t : return status of delete file request
+*/
+WiFi_Status_t wifi_file_delete(char * pFileName)
+{
+/* AT+S.FSD: delete an existing file */
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+Reset_AT_CMD_Buffer();
+/* AT+S.FSL */
+sprintf((char*)WiFi_AT_Cmd_Buff,AT_DELETE_FILE,pFileName);
+
+status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+if(status == WiFi_MODULE_SUCCESS)
+{
+status = USART_Receive_AT_Resp(Process_Event);
+}
+return status;
+}
+
+/**
+* @brief wifi_file_list
+* List existing filename
+* @param None
+* @retval WiFi_Status_t : return status of AT cmd request
+*/
+
+WiFi_Status_t wifi_file_list()
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+Queue_Wifi_File_Event(NULL,NULL,0);
+status = USART_Receive_AT_Resp(Process_Event);
+return status;
+}
+
+/**
+* @brief wifi_file_show
+* Print the contents of an existing file
+* @param pFileName : pinter of file name
+* @retval WiFi_Status_t : return status of AT cmd request
+*/
+
+WiFi_Status_t wifi_file_show(uint8_t * pFileName)
+{
+if(pFileName==NULL)
+ return WiFi_MODULE_ERROR;
+
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+Queue_Wifi_File_Event(NULL,pFileName,0);
+status = USART_Receive_AT_Resp(Process_Event);
+return status;
+}
+
+/**
+* @brief wifi_file_create
+* Create file for HTTP server
+* @param pFileName : pointer of file name to be created
+* alength : length of file
+* @retval WiFi_Status_t : return status of AT cmd request
+*/
+
+WiFi_Status_t wifi_file_create(char *pFileName, uint16_t alength, char * pUserFileBuff)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+if(alength >1024)
+return WiFi_AT_FILE_LENGTH_ERROR;
+
+Reset_AT_CMD_Buffer();
+
+/* AT+S.FSC=/index.html */
+sprintf((char*)WiFi_AT_Cmd_Buff, AT_CREATE_NEW_HTML_FILE, pFileName, alength);
+
+status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+if(status == WiFi_MODULE_SUCCESS)
+{
+status = USART_Receive_AT_Resp(Process_Event);
+int len = strlen(pUserFileBuff);
+
+if(len >= 1024)
+ return WiFi_AT_FILE_LENGTH_ERROR;
+
+/* AT+S.FSA=/index.html */
+sprintf((char*)WiFi_AT_Cmd_Buff,AT_APPEND_FILE,pFileName,len);
+
+status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+if(status == WiFi_MODULE_SUCCESS)
+{
+ memset(WiFi_AT_Cmd_Buff, 0x00, sizeof WiFi_AT_Cmd_Buff);
+ memcpy((char*)(char*)WiFi_AT_Cmd_Buff, (char*) pUserFileBuff,len);
+ WiFi_AT_Cmd_Buff[len+1]='\r';
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+}
+}
+return status;
+}
+
+/**
+* @brief wifi_http_get
+* Issue an HTTP GET of the given path to the specified host
+* @param None
+* @retval WiFi_Status_t : return status of AT cmd response
+*/
+
+WiFi_Status_t wifi_http_get(uint8_t * hostname, uint8_t * path, uint32_t port_number)
+{
+if(hostname == NULL || path == NULL)
+return WiFi_MODULE_ERROR;
+
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+while(status_flag.sock_read_ongoing || WIND64_count!= 0); //wait till any pending data is read
+{
+ asm("NOP");
+}
+
+// AT+S.HTTPGET=host.example.com,/index.html, port_number<cr>
+//Queue the http-get command
+Queue_Http_Event(hostname, path, port_number,NULL);
+
+//Make the user wait anyway
+status = USART_Receive_AT_Resp(Process_Event);
+
+return status;
+
+}
+
+/**
+* @brief wifi_http_post
+* Issue an HTTP GET of the given path to the specified host
+* @param None
+* @retval WiFi_Status_t : status of Http Post Request
+*/
+
+WiFi_Status_t wifi_http_post(uint8_t * pURL_path)
+{
+if(pURL_path == NULL)
+return WiFi_MODULE_ERROR;
+
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+while(status_flag.sock_read_ongoing || WIND64_count!= 0);//wait till any pending data is read
+{
+ asm("NOP");
+}
+
+// AT+S.HTTPPOST = posttestserver.com,/post.php,name=demo&email=mymail&subject=subj&body=message<cr>
+Queue_Http_Event(NULL,NULL,0,pURL_path);
+
+//Make the user wait anyway
+status = USART_Receive_AT_Resp(Process_Event);
+return status;
+}
+
+/**
+* @brief wifi_file_image_create
+* Downloads an updated file system via a single HTTP GET request to the
+* named host and path.
+* @param None
+* @retval WiFi_Status_t
+*/
+WiFi_Status_t wifi_file_image_create(uint8_t * pHostName, uint8_t * pFileName, uint32_t port_number)
+{
+if(pHostName == NULL || pFileName == NULL || port_number ==0)
+return WiFi_MODULE_ERROR;
+
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+Queue_Wifi_File_Event(pHostName,pFileName,port_number);
+status = USART_Receive_AT_Resp(Process_Event);
+
+/* Soft reset the module */
+SET_Power_State(PowerSave_State);
+return status;
+}
+
+/**
+* @brief wifi_file_erase_external_flash
+* This API allows to erase the content of the external flash
+* @param None
+* @retval WiFi_Status_t
+*/
+WiFi_Status_t wifi_file_erase_external_flash()
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+Reset_AT_CMD_Buffer();
+ResetBuffer();
+
+/* AT+S.HTTPDFSERASE */
+sprintf((char*)WiFi_AT_Cmd_Buff,AT_ERASE_FLASH_MEMORY);
+status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+
+/* Soft reset the module */
+SET_Power_State(PowerSave_State);
+
+return status;
+}
+
+/**
+* @brief wifi_fw_update
+* Issue an HTTP GET of the given path to the specified host and get the firmware updated
+* @param None
+* @retval None
+*/
+WiFi_Status_t wifi_fw_update(uint8_t * hostname, uint8_t * filename_path, uint32_t port_number)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+Queue_Wifi_FW_Update_Event(hostname,filename_path,port_number);
+status = USART_Receive_AT_Resp(Process_Event);
+/* Soft reset the module */
+SET_Power_State(PowerSave_State);
+return status;
+}
+
+/**
+* @brief wifi_network_scan
+* Performs an immediate scan for available network
+* @param None
+* @retval WiFi_Status_t : WiFi status error
+*/
+WiFi_Status_t wifi_network_scan(wifi_scan *scan_result, uint16_t max_scan_number)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+wifi_scanned_list = scan_result;
+if(max_scan_number>MAX_WIFI_SCAN_NETWORK)
+return WiFi_NOT_SUPPORTED;
+user_scan_number = max_scan_number;
+
+if(status_flag.Scan_Ongoing)
+{
+return WiFi_AT_CMD_BUSY;
+}
+
+status_flag.Scan_Ongoing = WIFI_TRUE;
+
+#if 0 //TBD
+if(WiFi_Param.WiFi_Module_State == WiFi_MiniAP_MODE)
+return WiFi_NOT_SUPPORTED;
+#endif
+
+/* AT+S.SCAN: performs an immediate scan for available networks */
+Reset_AT_CMD_Buffer();
+sprintf((char*)WiFi_AT_Cmd_Buff,AT_WiFi_SCAN);
+status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+if(status == WiFi_MODULE_SUCCESS)
+{
+status = USART_Receive_AT_Resp(Process_Event);
+}
+
+/*At this point we have WiFi_Scan_Buffer filled with RSSI and SSID values*/
+return status;
+}
+
+/**
+* @brief Set_MiniAP_Mode
+* Configure Wi-Fi module in AP mode.
+ MiniAP is always configured in open mode (WEP not supported)
+* @param None
+* @retval WiFi_Status_t : status of AT cmd
+*/
+WiFi_Status_t wifi_ap_start(uint8_t * ssid, uint8_t channel_num)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+/* Set the SSID : AT+S.SSIDTXT=<SSID>*/
+//if(ssid)
+ status = SET_SSID((char*)ssid);
+
+
+if(status != WiFi_MODULE_SUCCESS)
+return WiFi_SSID_ERROR;
+
+/* Set the network privacy mode : AT+S.SCFG=wifi_priv_mode,0*/
+status = SET_Configuration_Value(WIFI_PRIV_MODE, None);
+if(status != WiFi_MODULE_SUCCESS)
+return WiFi_CONFIG_ERROR;
+
+/* Set the network mode (1 = STA, 2 = IBSS, 3 = MiniAP) :: AT+S.SCFG=wifi_mode,3*/
+status = SET_Configuration_Value(WIFI_MODE, WiFi_MiniAP_MODE);
+if(status != WiFi_MODULE_SUCCESS)
+return WiFi_CONFIG_ERROR;
+
+/* Set the channel number */
+status = SET_Configuration_Value(WIFI_CHANNEL_NUMBER, channel_num);
+if(status != WiFi_MODULE_SUCCESS)
+return WiFi_CONFIG_ERROR;
+
+/* Save the settings on the flash memory : AT&W*/
+Save_Current_Setting();
+
+status_flag.WiFi_Configuration_Done = WIFI_TRUE;
+WiFi_Module_State = Process_Event;
+
+/* Soft reset the module */
+SET_Power_State(PowerSave_State);
+
+return status;
+}
+
+
+/**
+* @brief SET_WiFi_STA_Mode
+* Configure Wi-Fi module in STA mode
+* @param SSID : SSID name
+* @param sec_key : security key
+* @param priv_mode : network privecy mode
+* @retval WiFi_Status_t : status of AT cmd
+*/
+WiFi_Status_t wifi_connect(char * ssid, char * sec_key, WiFi_Priv_Mode priv_mode)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+if(status_flag.AT_Cmd_Ongoing == WIFI_FALSE)
+status_flag.AT_Cmd_Ongoing = WIFI_TRUE;
+else
+{
+return WiFi_AT_CMD_BUSY;
+}
+
+if(sec_key) {
+status = SET_WiFi_SecKey((char*)sec_key);
+if(status != WiFi_MODULE_SUCCESS)
+ return WiFi_SecKey_ERROR;
+}
+
+/* Set the SSID : AT+S.SSIDTXT=<SSID>*/
+
+ status = SET_SSID((char*)ssid);
+
+if(status != WiFi_MODULE_SUCCESS)
+return WiFi_SSID_ERROR;
+
+/* Set the network privacy mode : AT+S.SCFG=wifi_priv_mode,2*/
+status = SET_Configuration_Value(WIFI_PRIV_MODE, priv_mode);
+if(status != WiFi_MODULE_SUCCESS)
+return WiFi_CONFIG_ERROR;
+
+/* Set the network mode (1 = STA, 2 = IBSS, 3 = MiniAP) :: AT+S.SCFG=wifi_mode,1*/
+status = SET_Configuration_Value(WIFI_MODE, WiFi_STA_MODE);
+if(status != WiFi_MODULE_SUCCESS)
+return WiFi_CONFIG_ERROR;
+
+/* Save the settings on the flash memory : AT&W*/
+Save_Current_Setting();
+
+status_flag.WiFi_Configuration_Done = WIFI_TRUE;
+//WiFi_Module_State = WiFi_Process_Event;
+
+/* Soft reset the module */
+SET_Power_State(PowerSave_State);
+
+status_flag.AT_Cmd_Ongoing = WIFI_FALSE;
+
+return status;
+}
+
+/**
+* @brief SET_WiFi_IBSS_Mode
+* Configure Wi-Fi module in IBSS mode
+* @param SSID : SSID name
+* @param priv_mode : network privecy mode
+* @retval WiFi_Status_t : status of AT cmd
+*/
+WiFi_Status_t wifi_adhoc_create(uint8_t * ssid, WiFi_Priv_Mode priv_mode)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+Attention_Cmd();
+/* Set the SSID : AT+S.SSIDTXT=<SSID>*/
+status = SET_SSID((char*)ssid);
+if(status != WiFi_MODULE_SUCCESS)
+return WiFi_SSID_ERROR;
+
+/* Set the network privacy mode : AT+S.SCFG=wifi_priv_mode,0*/
+status = SET_Configuration_Value(WIFI_PRIV_MODE, priv_mode);
+if(status != WiFi_MODULE_SUCCESS)
+ return WiFi_CONFIG_ERROR;
+
+
+/* Set the network mode (1 = STA, 2 = IBSS, 3 = MiniAP) :: AT+S.SCFG=wifi_mode,2*/
+status = SET_Configuration_Value(WIFI_MODE, WiFi_IBSS_MODE);
+if(status != WiFi_MODULE_SUCCESS)
+ return WiFi_CONFIG_ERROR;
+
+/* Set IP address */
+status = SET_Configuration_Addr(WIFI_IP_ADDRESS, WIFI_IBSS_IP_ADDR);
+if(status != WiFi_MODULE_SUCCESS)
+ return WiFi_CONFIG_ERROR;
+
+/* Set IP default gateway */
+status = SET_Configuration_Addr(WIFI_IP_DEFAULT_GATEWAY, WIFI_IBSS_DEFAULT_GATEWAY);
+if(status != WiFi_MODULE_SUCCESS)
+ return WiFi_CONFIG_ERROR;
+
+
+/* Set IP DNS */
+status = SET_Configuration_Addr(WIFI_IP_DNS, WIFI_IBSS_IP_DNS_ADDR);
+if(status != WiFi_MODULE_SUCCESS)
+ return WiFi_CONFIG_ERROR;
+
+/* Set IP netmask */
+status = SET_Configuration_Addr(WIFI_IP_NETMASK, WIFI_IBSS_IP_MASK);
+if(status != WiFi_MODULE_SUCCESS)
+ return WiFi_CONFIG_ERROR;
+
+/* Turn OFF the DHCP */
+SET_Configuration_Value(IP_USE_DHCP_SERVER, WIFI_IP_USE_DHCP);
+if(status != WiFi_MODULE_SUCCESS)
+ return WiFi_CONFIG_ERROR;
+
+/* Save the settings on the flash memory : AT&W*/
+Save_Current_Setting();
+
+/* Soft reset the module */
+SET_Power_State(PowerSave_State);
+return status;
+}
+
+
+/**
+* @brief wifi_standby
+* Configured WiFi module to enter standby
+* @param arg_standby_time: standby time
+* @retval WiFi_Status_t : status of AT cmd
+*/
+WiFi_Status_t wifi_standby(uint8_t arg_standby_time)
+{
+/*
+For Standby, the presence of Jumpers on JP4 and JP3 has the following behaviour:
+JP3 (middle and bottom): prevents standby and immediately wakes-up module
+JP3 (middle and top): no effect on standby
+JP4 (middle and right): prevents wakeup and standby runs forever
+JP4 (middle and left): no effect on standby
+*/
+
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+/*if(arg_standby_time<2)
+return WiFi_NOT_SUPPORTED;*/
+
+SET_Configuration_Value(WIFI_SLEEP_ENABLED, 0);
+SET_Configuration_Value(WIFI_STANDBY_ENABLED, 1);
+status = SET_Configuration_Value(WIFI_STANDBY_TIME, arg_standby_time);
+
+/* save current setting in flash */
+Save_Current_Setting();
+
+/* AT : send AT command */
+sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_POWER_STATE,1); //cfun=4
+WiFi_Module_State = Process_Event; //make sure the WiFi module is in this state to receive WINDS after wakeup
+status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+
+if(status == WiFi_MODULE_SUCCESS)//if transmit is success, prepare for resume
+{
+/*
+status_flag.AT_Cmd_Processing = WIFI_TRUE;//We do not want the next UART data_byte fetch to be done
+HAL_NVIC_DisableIRQ(USARTx_IRQn);//Disable UART IRQ
+status_flag.Standby_Timer_Running=WIFI_TRUE;
+printf("\r\nGoing into Standby Mode...\r\n");*/
+}
+
+return status;
+
+}
+
+/**
+* @brief wifi_wakeup
+* wakeup the module from sleep by setting the GPIO6 through PC13
+* or allow it to go to sleep
+* Jumper needed on JP4
+* @param wakeup wakeup (WIFI_TRUE) or allow sleep(WIFI_FALSE)
+* @retval WiFi_Status_t : status of function call
+*/
+WiFi_Status_t wifi_wakeup(wifi_bool wakeup)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ if(wakeup)
+ callSpwfSADevice_wakeup(spwf_device_class, 0);
+ else
+ callSpwfSADevice_wakeup(spwf_device_class, 0);
+ wait_ms(100);
+ return status;
+}
+
+
+/**
+* @brief wifi_disconnect
+* disconnect the module from any AP
+* @param None
+* @retval WiFi_Status_t : status of AT cmd
+*/
+WiFi_Status_t wifi_disconnect(void)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+/* Set wifi_mode to idle*/
+status = SET_Configuration_Value(WIFI_MODE, WiFi_IDLE_MODE);
+
+/*If module was connected, reset the status*/
+if(wifi_connected == 1)
+ {
+ wifi_connected = 0;//this will allow the TIM handler to make the callback on connection(WiFiUp)
+ }
+
+/* save current setting in flash */
+Save_Current_Setting();
+
+/* Soft reset the module */
+status = SET_Power_State(PowerSave_State);//CFUN=1
+
+return status;
+}
+
+/**
+* @brief wifi_enable
+* Enable/Disable the Wi-Fi interface
+* @param enable enable Wi-Fi (WIFI_TRUE) disable Wi-Fi (WIFI_FALSE)
+* @retval WiFi_Status_t : status of AT cmd
+*/
+WiFi_Status_t wifi_enable(wifi_bool enable)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+/* Enable or Disable wifi interface*/
+Reset_AT_CMD_Buffer();
+sprintf((char*)WiFi_AT_Cmd_Buff,AT_WIFI_ENABLE, enable);
+
+/*if(HAL_UART_Transmit(&UartWiFiHandle, (uint8_t *)WiFi_AT_Cmd_Buff, strlen((char*)WiFi_AT_Cmd_Buff),1000)!= HAL_OK)
+{
+Error_Handler();
+#if DEBUG_PRINT
+printf("HAL_UART_Transmit Error");
+#endif
+return WiFi_HAL_UART_ERROR;
+} */
+
+status = USART_Receive_AT_Resp(Process_Event);
+
+//wait for power down/hw started
+if(enable)
+while(status_flag.WiFi_Enabled != WIFI_TRUE)
+{
+ asm("NOP");
+}
+else
+while(status_flag.WiFi_Enabled != WIFI_FALSE)
+{
+ asm("NOP");
+}
+
+return status;
+
+}
+
+
+
+/**
+* @brief wifi_restore
+* Restore the Wi-Fi with default values.
+* @param None
+* @retval WiFi_Status_t : status of AT cmd
+*/
+WiFi_Status_t wifi_restore()
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+/* Restore default setting*/
+Restore_Default_Setting();
+
+/* Set wifi_mode to idle*/
+SET_Configuration_Value(WIFI_MODE, WiFi_IDLE_MODE);
+
+/* set the local echo */
+SET_Configuration_Value(LOCALECHO1, 0);
+
+/* save current setting in flash */
+Save_Current_Setting();
+
+/* Soft reset the module */
+status = SET_Power_State(PowerSave_State);//CFUN=1
+
+return status;
+}
+
+/*GPIO Configuration Functions*/
+
+/**
+* @brief wifi_gpio_init
+* Configure a GPIO pin as in or out with IRQ setting
+* @param pin GPIO pin number
+* @param irq configuration of the pin
+* @retval WiFi_Status_t : status of AT cmd
+*/
+uint8_t wifi_gpio_init(GpioPin pin, char* dir, char irq)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+/* AT+S.GPIOC=pin,dir,irq */
+Reset_AT_CMD_Buffer();
+
+memset(WiFi_AT_Cmd_Buff, 0x00, sizeof WiFi_AT_Cmd_Buff);
+
+if(irq!=GPIO_Off)
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.GPIOC=%d,%s,%c\r", pin, dir, irq);
+else
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.GPIOC=%d,%s\r", pin, dir);
+
+status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+
+
+return status;
+
+}
+
+/**
+* @brief wifi_gpio_read
+* Read the configuration of a GPIO pin
+* @param pin GPIO pin number
+* @param val value returned
+* @param dir configuration direction returned
+* @retval WiFi_Status_t : status of AT cmd
+*/
+uint8_t wifi_gpio_read(GpioPin pin, uint8_t *val, uint8_t *dir)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+/* AT+S.GPIOR=pin */
+Reset_AT_CMD_Buffer();
+
+sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.GPIOR=%d\r", pin);
+
+status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+*val = gpio_value;
+*dir = gpio_direc;
+
+return status;
+}
+
+/**
+* @brief wifi_gpio_write
+* Read the value of a GPIO pin
+* @param pin GPIO pin number
+* @param val value to be configured
+* @retval WiFi_Status_t : status of AT cmd
+*/
+uint8_t wifi_gpio_write(GpioPin pin, GpioWriteValue value)
+{
+WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+/* AT+S.GPIOW=pin,value */
+Reset_AT_CMD_Buffer();
+
+sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.GPIOW=%d,%d\r", pin, value);
+
+status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+
+return status;
+}
+
+void UART_Configuration(uint32_t baud_rate)
+{
+}
+
+#ifdef USART_PRINT_MSG
+void USART_PRINT_MSG_Configuration(uint32_t baud_rate)
+{
+}
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+
+/**
+ * @}
+ */
+
+/******************* (C) COPYRIGHT 2015 STMicroelectronics *****END OF FILE****/
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf/wifi_module.c Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,3427 @@
+/**
+ ******************************************************************************
+ * @file wifi_module.c
+ * @author Central LAB
+ * @version V2.0.0
+ * @date 10-February-2016
+ * @brief Enable Wi-Fi functionality using AT cmd set
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
+/* Includes ------------------------------------------------------------------*/
+#include "wifi_module.h"
+//#include "stm32_spwf_wifi.h"
+#include "ring_buffer.h"
+#include "stdio.h"
+#include "string.h"
+#include "event_buffer.h"
+#include "device.h"
+#include "wait_api.h"
+#include <stddef.h>
+
+
+/** @addtogroup MIDDLEWARES
+* @{
+*/
+
+
+/** @defgroup NUCLEO_WIFI_MODULE
+ * @brief Wi-Fi driver modules
+ * @{
+ */
+
+
+/** @defgroup NUCLEO_WIFI_MODULE_Private_Defines
+ * @{
+ */
+
+
+/**
+ * @}
+ */
+
+
+/** @addtogroup NUCLEO_WIFI_MODULE_Private_Variables
+ * @{
+ */
+/* Private variables ---------------------------------------------------------*/
+
+/*All Buffers*/
+//uint8_t WiFi_AT_Cmd_Buff[1024];
+uint8_t process_buffer[MAX_BUFFER_GLOBAL];
+char UserDataBuff[MAX_BUFFER_GLOBAL];
+uint8_t USART_RxBuffer[64];//This buffer is only used in the Init phase (to receive "\r\nOK\r\n")
+char print_msg_buff[MAX_BUFFER_GLOBAL];
+volatile uint8_t ring_buffer[RINGBUF_SIZE];/* Default size for ring buffer */
+
+#ifdef USE_STM32L0XX_NUCLEO
+event_s_TypeDef event_buffer[10];
+#else
+event_s_TypeDef event_buffer[50];
+#endif
+
+volatile uint8_t pop_buffer[MAX_BUFFER_GLOBAL];
+volatile uint8_t prefetch_buffer[20];
+uint8_t uart_byte[1];
+buffer_td big_buff;
+buffer_e event_buff;
+event_s_TypeDef element;
+uint8_t HTTP_Runway_Buff[6];//Used to store the last 6 bytes in between User Callbacks during HTTP tx
+wifi_scan *wifi_scanned_list; //[MAX_WIFI_SCAN_NETWORK];
+
+volatile Wifi_Status_Var status_flag;
+
+uint32_t wind64_DQ_wait = 0;
+uint32_t UserDataBuff_index;
+volatile uint32_t tickcount;
+uint8_t SocketId;
+uint32_t SockON_Data_Len;
+uint32_t Socket_Data_Length =0;
+uint8_t Socket_Open_ID, sockon_query_id,sockon_id_user;
+uint32_t SockON_Data_Length;
+uint8_t enable_pending_data =0;
+
+volatile WiFi_WIND_State_TypeDef WiFi_WIND_State;//describes the current WIND number in processing
+
+uint8_t WiFi_Resp_OK = 0;
+uint32_t number_of_bytes=0;
+uint32_t interim_number_of_bytes=0;
+uint32_t Interim_SockON_Data_Len=0;
+uint32_t bytes_to_be_read = 0;
+uint32_t sock_total_count=0;
+uint32_t sockD_total_count=0;
+uint32_t ip_fragment_count=0;
+uint32_t chunk_size;
+uint32_t message_size;
+uint32_t WIND55_count=0;
+volatile uint32_t WIND64_count=0;
+uint8_t user_scan_number;
+uint32_t pop_queue_length;
+uint32_t pop_buffer_size=0;
+uint32_t process_buffer_index = 5;
+uint32_t epoch_time = 0;
+
+volatile WiFi_AT_CMD_Response_t WiFi_Module_State;
+
+uint8_t *WiFi_Scan_Buffer;
+uint8_t * curr_hostname;
+uint8_t * curr_path;
+uint8_t * curr_pURL;
+uint8_t * curr_protocol;
+uint32_t curr_port_number;
+char * curr_data;
+uint8_t curr_sockID;
+uint8_t * curr_filename;
+uint16_t curr_DataLength;
+uint16_t sock_server_write_datalength;
+char *sock_server_write_pdata;
+
+uint8_t socket_closed_id_callback;
+uint8_t remote_socket_closed_id;
+uint8_t client_socket_close_id;
+volatile uint8_t wifi_ready = WIFI_FALSE;//Set once if wifi is ready for first time
+volatile uint8_t wifi_connected = WIFI_FALSE;//Set once if wifi is connected for first time
+volatile uint8_t wifi_client_connected = 0;//Set once if client is connected
+volatile uint8_t wifi_client_disconnected = 0;//Set once if client is dis-connected
+uint8_t gpio_value, gpio_direc, get_cfg_value[64];
+WiFi_Status_t user_error_code = WiFi_MODULE_SUCCESS;
+
+uint8_t no_of_open_client_sockets = 0;
+wifi_bool open_sockets[8]; //Max open sockets allowed is 8. Each array element depicts one socket (true=open, false=closed)
+uint8_t client_MAC_address[17];//current client MAC address store
+
+uint8_t enable_uart_byte_data_receive=1;
+uint8_t uart_data_receive_ready=1;
+
+WiFi_Status_t AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+uint32_t sleep_count = 0;
+uint32_t standby_time = 0;
+uint8_t scanned_ssids = 0;
+char * prefetch_str;
+
+#if defined (USE_STM32F4XX_NUCLEO) || (USE_STM32L4XX_NUCLEO)
+uint8_t WiFi_AT_Cmd_Buff[2048];
+#else
+uint8_t WiFi_AT_Cmd_Buff[1024];
+#endif
+
+#ifdef USART_PRINT_MSG
+#define printf(arg) {sprintf((char*)print_msg_buff,arg); \
+HAL_UART_Transmit(&UartMsgHandle, (uint8_t*)print_msg_buff, strlen(print_msg_buff), 1000);}
+#endif
+
+void * spwf_dev_;
+
+extern void callSpwfSADevice_debug(void* object, const char * string);
+extern void callSpwfSADevice_attach(wifi_bool attach);
+
+#if defined (__CC_ARM)
+size_t strnlen (const char* s, size_t maxlen);
+
+size_t strnlen (const char* s, size_t maxlen)
+ {
+ size_t len = 0;
+
+ while ((len <= maxlen) && (*s))
+ {
+ s++;
+ len++;
+ }
+
+ return len;
+ }
+#endif
+
+event_s_TypeDef event_s;
+event_s_TypeDef * event_pop_s;
+
+// [DLI]
+#ifdef WIFI_USE_VCOM
+
+uint8_t console_listen_char[1];
+uint8_t console_input_char[1];
+uint8_t console_send_char[1];
+uint8_t console_echo_char[1];
+uint8_t console_send_ready = 0;
+uint8_t console_echo_ready = 1;
+uint8_t console_push_ready = 0;
+
+// Virtual-COM UART
+void console_input() {
+ //HAL_UART_Receive_IT(&UartMsgHandle, (uint8_t *)console_input_char, 1);
+}
+
+void wifi_vcom() {
+
+ uint8_t * temp;
+
+ if (console_push_ready == 1) {
+ push_buffer(&big_buff, uart_byte);
+ console_push_ready = 0;
+ //HAL_UART_Receive_IT(&UartWiFiHandle, (uint8_t *)uart_byte, 1);
+ }
+ if(console_echo_ready == 0) {
+ temp = pop_buffer_queue(&big_buff);
+ if(temp != NULL) {
+ console_echo_ready = 1;
+ //HAL_UART_Transmit_IT(&UartMsgHandle, temp, 1);
+ }
+ }
+}
+
+#endif
+
+/**
+ * @}
+ */
+
+/** @defgroup NUCLEO_WIFI_MODULE_Private_Functions
+ * @{
+ */
+
+/**
+ *Changed/introduced functions for MBED implementation:
+
+- void Wifi_TIM_Handler(void); - new fn
+- void Rx_irq_handler(void); - new fn - in place of HAL_UART_RxCpltCallback
+- Receive_Data(); - modified fn
+- void wifi_reset(void) - modified fn
+- void PowerUp_WiFi_Module(void) - modified fn
+- void RX_EXTI_Isr(uint16_t GPIO_Pin) - removed fn
+- void HAL_UART_TxCpltCallback(UART_HandleTypeDef *UartHandleArg) - removed fn
+- void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandleArg) - removed fn
+- void HAL_UART_ErrorCallback(UART_HandleTypeDef *UartHandle) - removed fn
+- WiFi_Status_t USART_Transmit_AT_Cmd(uint16_t size)- modified fn
+*/
+
+
+
+/**
+ * @brief WiFi_Module_Init
+ * Initialize wifi module
+ * @param None
+ * @retval None
+ */
+void WiFi_Module_Init(void)
+{
+#ifdef WIFI_USE_VCOM
+ console_input();
+#else
+ WiFi_Module_State = Process_Event;
+#endif
+
+ initialize_status_flags();
+ init(&big_buff, RINGBUF_SIZE);//Init the ring buffer
+ wifi_ready = 0; //reset to get user callback on HW started
+ wifi_connected = 0; //reset to get user callback on WiFi UP
+ Receive_Data();
+
+#ifdef USE_STM32L0XX_NUCLEO
+ event_init(&event_buff, 10); //max 15 events can be Q'ed (Event Buffer is of size 15)
+#else
+ event_init(&event_buff, 50); //max 50 events can be Q'ed (Event Buffer is of size 50)
+#endif
+
+#ifndef WIFI_USE_VCOM
+ Start_Timer();
+ memset(open_sockets,0x00, 8); //init the open socket array
+
+#endif
+}
+
+/**
+* @brief initialize_status_flags
+* Default Wifi status values
+* @param None
+* @retval None
+*/
+void initialize_status_flags()
+{
+ status_flag.Single_Digit_Indication = WIFI_FALSE;
+ status_flag.WiFi_Enabled = WIFI_FALSE;
+ status_flag.http_req_pending = WIFI_FALSE;
+ status_flag.WiFi_Configuration_Done = WIFI_FALSE;
+ status_flag.Timer_Running = WIFI_FALSE;
+ status_flag.resume_receive_data = WIFI_FALSE;
+ status_flag.enable_dequeue = WIFI_TRUE;
+ status_flag.stop_event_dequeue = WIFI_FALSE;
+ status_flag.Standby_Timer_Running = WIFI_FALSE;
+ status_flag.trigger_wakeup_callback = WIFI_FALSE;
+ status_flag.Deep_Sleep_Enabled = WIFI_FALSE;
+ status_flag.Standby_Enabled = WIFI_FALSE;
+ status_flag.Low_Power_Enabled = WIFI_FALSE;
+ status_flag.command_mode=WIFI_TRUE;
+ status_flag.data_mode=WIFI_FALSE;
+ status_flag.Scan_Ongoing = WIFI_FALSE;
+ status_flag.AT_Cmd_Ongoing = WIFI_FALSE;
+ status_flag.AT_Cmd_Processing = WIFI_FALSE;
+ status_flag.Uartx_Rx_Processing = WIFI_FALSE;
+ status_flag.Client_Connected = WIFI_FALSE;
+ status_flag.Client_Disconnected = WIFI_FALSE;
+ status_flag.switch_by_default_to_command_mode = WIFI_TRUE;
+ status_flag.start_sock_read = WIFI_FALSE;
+ status_flag.enable_receive_data_chunk = WIFI_FALSE;
+ status_flag.data_pending_sockD=WIFI_FALSE;
+ status_flag.enable_sock_read = WIFI_FALSE;
+ status_flag.enable_query = WIFI_FALSE;
+ status_flag.Set_AT_Cmd_Response_False = WIFI_FALSE;
+ status_flag.enable_fw_update_read = WIFI_FALSE;
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ status_flag.Q_Contains_Data = WIFI_FALSE;
+ status_flag.enable_receive_http_response = WIFI_FALSE;
+ status_flag.enable_receive_file_response = WIFI_FALSE;
+ status_flag.enable_receive_wifi_scan_response = WIFI_FALSE;
+ status_flag.prevent_push_OK_event = WIFI_FALSE;
+ status_flag.client_socket_close_ongoing = WIFI_FALSE;
+ status_flag.prevent_push_WIFI_event = WIFI_FALSE;
+ status_flag.sock_read_ongoing = WIFI_FALSE;
+ status_flag.enable_client_socket_write = WIFI_FALSE;
+ status_flag.event_deQ_x_wind64 = WIFI_FALSE;
+ status_flag.do_not_reset_push_WIFI_event = WIFI_FALSE;
+ status_flag.message_pending = WIFI_FALSE;
+ status_flag.Pending_SockON_Callback = WIFI_FALSE;
+ status_flag.Pending_SockD_Callback = WIFI_FALSE;
+ status_flag.SockON_Server_Closed_Callback = WIFI_FALSE;
+ status_flag.Client_Socket_Close_Cmd = WIFI_FALSE;
+ status_flag.standby_resume_callback = WIFI_FALSE;
+ status_flag.HTTP_Data_available = WIFI_FALSE;
+ status_flag.FILE_Data_available = WIFI_FALSE;
+ status_flag.AT_Response_Received = WIFI_FALSE;
+ status_flag.Deep_Sleep_Timer = WIFI_FALSE;
+ status_flag.Deep_Sleep_Callback = WIFI_FALSE;
+}
+
+
+/**
+* @brief Period elapsed callback in non blocking mode
+* This timer is used for calling back User registered functions with information
+* @param htim : TIM handle
+* @retval None
+*/
+
+void Wifi_TIM_Handler(void)
+{
+ /**********************************************************************
+ * *
+ * Be careful not to make a blocking *
+ * call from this function, see *
+ * example Socket_Read() and Socket_Close() *
+ * *
+ **********************************************************************/
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ if(status_flag.stop_event_dequeue == WIFI_FALSE /*&& !status_flag.enable_receive_data_chunk*/)
+ {
+ __disable_irq();
+ event_pop_s = pop_eventbuffer_queue(&event_buff);
+ __enable_irq();
+
+ if(event_pop_s!=NULL && event_pop_s->event_pop == WIFI_TRUE)
+ {
+ switch(event_pop_s->event)
+ {
+ case WIFI_WIND_EVENT:
+ Process_WiFi_Indication_Cmd(event_pop_s);
+ break;
+
+ case WIFI_OK_EVENT:
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_MODULE_SUCCESS;
+ if(status_flag.Set_AT_Cmd_Response_False == WIFI_TRUE)
+ {
+ status_flag.Set_AT_Cmd_Response_False = WIFI_FALSE;
+ status_flag.AT_Response_Received = WIFI_FALSE;
+ }
+ if(status_flag.enable_client_socket_write) //allows the OK received after socket client write to be processed
+ {
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ status_flag.enable_client_socket_write = WIFI_FALSE;
+ }
+ break;
+
+ case WIFI_SOCK_ID_EVENT:
+ /*check ID and update SocketID array*/
+ no_of_open_client_sockets++;
+
+ if(no_of_open_client_sockets > 8) //Max number of clients is 8
+ {
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_NOT_SUPPORTED;
+ break;
+ }
+
+ open_sockets[event_pop_s->socket_id] = WIFI_TRUE;
+ Socket_Open_ID = event_pop_s->socket_id;
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_MODULE_SUCCESS;
+ break;
+
+ case WIFI_HTTP_EVENT:
+ Reset_AT_CMD_Buffer();
+ memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);//Flush the buffer
+
+ if(curr_pURL) {
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_HTTPPOST_REQUEST,curr_pURL);
+ }
+ else {
+ if(curr_port_number!=0)
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.HTTPGET=%s,%s,%d\r",curr_hostname, curr_path, (int)curr_port_number);
+ else
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.HTTPGET=%s,%s\r",curr_hostname, curr_path);
+ }
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS) {
+ WiFi_Module_State = Process_Event;
+ status_flag.stop_event_dequeue = WIFI_TRUE;
+ status_flag.http_req_pending = WIFI_TRUE;
+ }
+ else {
+ #if DEBUG_PRINT
+ printf("\r\n ERROR IN HTTP \r\n");
+ #endif
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ }
+ break;
+
+ case WIFI_CLIENT_SOCKET_WRITE_EVENT:
+ Reset_AT_CMD_Buffer();
+ /* AT+S.SOCKW=00,11<cr> */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SOCKET_WRITE,curr_sockID,curr_DataLength);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+
+ if(status == WiFi_MODULE_SUCCESS) {
+ Reset_AT_CMD_Buffer();
+ memcpy((char*)(char*)WiFi_AT_Cmd_Buff, (char*)curr_data,curr_DataLength);
+ WiFi_AT_Cmd_Buff[curr_DataLength]='\r';
+
+ status = USART_Transmit_AT_Cmd(curr_DataLength+2);
+ if(status == WiFi_MODULE_SUCCESS) {
+ WiFi_Module_State = Process_Event;
+ }
+ else {
+ #if DEBUG_PRINT
+ printf("\r\n ERROR IN SOCKET\r\n");
+ #endif
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ }
+ }
+ else {
+ #if DEBUG_PRINT
+ printf("\r\n ERROR In Socket\r\n");
+ #endif
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ }
+ break;
+
+ case WIFI_CLIENT_SOCKET_OPEN_EVENT:
+ Reset_AT_CMD_Buffer();
+
+ /* AT+S.SOCKON = myserver,1234,t <cr> */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SOCKET_OPEN,curr_hostname,(int)curr_port_number,curr_protocol);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status != WiFi_MODULE_SUCCESS)
+ {
+ #if DEBUG_PRINT
+ printf("\r\n ERROR During Socket Open \r\n");
+ #endif
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ }
+ break;
+
+ case WIFI_CLIENT_SOCKET_CLOSE_EVENT:
+ Reset_AT_CMD_Buffer();
+
+ /* AT+S.SOCKC=00<cr> */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SOCKET_CLOSE,event_pop_s->socket_id);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ AT_RESPONSE = WiFi_MODULE_SUCCESS;
+ status_flag.prevent_push_OK_event = WIFI_TRUE; //prevent the OK received after socket close command to be Q'ed
+ status_flag.stop_event_dequeue = WIFI_TRUE;
+ remote_socket_closed_id = event_pop_s->socket_id;
+ status_flag.client_socket_close_ongoing = WIFI_TRUE; //used for making changes in the value of open_sockets[sock_id] if no error is returned
+// status_flag.SockON_Server_Closed_Callback = WIFI_TRUE;
+ }
+ else
+ {
+ #if DEBUG_PRINT
+ printf("\r\n ERROR During Socket Close \r\n");
+ #endif
+ }
+ break;
+
+
+ case WIFI_FILE_EVENT:
+ Reset_AT_CMD_Buffer();
+
+ if(curr_filename == NULL)
+ {
+ /* AT+S.FSL */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_DISPLAY_FILE_NAME);
+ }
+ else if(curr_hostname == NULL)
+ {
+ /* AT+S.FSP=/index.html */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_DISPLAY_FILE_CONTENT,curr_filename);
+ }
+ else
+ {
+ /* AT+S.HTTPDFSUPDATE=%s,/outfile.img */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_DOWNLOAD_IMAGE_FILE,curr_hostname,curr_filename,(int)curr_port_number);
+ }
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ WiFi_Module_State = Process_Event;
+ status_flag.enable_receive_http_response = WIFI_TRUE;
+ status_flag.enable_receive_data_chunk = WIFI_TRUE;
+ status_flag.enable_receive_file_response = WIFI_TRUE;
+ }
+ else {
+ #if DEBUG_PRINT
+ printf("\r\n ERROR in FILE \r\n");
+ #endif
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ }
+ break;
+
+ case WIFI_FW_UPDATE_EVENT:
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.FWUPDATE=%s,/%s,%d\r",curr_hostname,curr_filename,(int)curr_port_number);
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ WiFi_Module_State = Process_Event;
+ status_flag.enable_fw_update_read = WIFI_TRUE;
+ status_flag.enable_receive_data_chunk = WIFI_TRUE;
+ }
+ else
+ {
+ #if DEBUG_PRINT
+ printf("\r\n ERROR in Firmware \r\n");
+ #endif
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ }
+ break;
+
+ case WIFI_ERROR_EVENT:
+ #if DEBUG_PRINT
+ printf("\r\n ERROR!\r\n");
+ #endif
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ break;
+
+ case WIFI_GCFG_EVENT:
+ case WIFI_GPIO_EVENT:
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_MODULE_SUCCESS;
+ break;
+
+ case WIFI_STANDBY_CONFIG_EVENT:
+ #if DEBUG_PRINT
+ printf("\r\nGoing into standby..\r\n");
+ #endif
+ WiFi_Module_State = Process_Event;
+ break;
+
+ case WIFI_RESUME_CONFIG_EVENT:
+ #if DEBUG_PRINT
+ printf("\r\nResuming from standby..\r\n");
+ #endif
+ status_flag.AT_Response_Received = WIFI_TRUE;//let main run-on
+ break;
+
+ case WIFI_NO_EVENT:
+ break;
+ }
+ }
+ }
+ /* If data is pending on client socket SOCKON, make read requests*/
+ if(status_flag.start_sock_read == WIFI_TRUE)
+ {
+ //flush_buffer_queue(&big_buff);
+ Socket_Read(Socket_Data_Length);
+ status_flag.start_sock_read = WIFI_FALSE;
+ }
+
+ /* Call Query, after notification for TLS is received */
+ else if(status_flag.enable_query == WIFI_TRUE && status_flag.enable_dequeue == WIFI_TRUE)
+ {
+ //@TBD: Flushing the buffer may be detrimental if we have genuine follow on WIND55?
+ //flush_buffer_queue(&big_buff); //Flush the buffer to remove WIND:55 in pipeline (This maybe a problem)
+ Socket_Pending_Data();
+ status_flag.enable_query = WIFI_FALSE;
+ }
+
+ else if(status_flag.Pending_SockON_Callback==WIFI_TRUE)//for client socket
+ {
+ //Now callback to user with user_data pointer <UserDataBuff>
+ ind_wifi_socket_data_received(sockon_id_user, (uint8_t *)UserDataBuff, message_size, chunk_size);
+ memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);//Flush the buffer
+ Resume_Dequeue();
+ status_flag.Pending_SockON_Callback=WIFI_FALSE;
+ }
+
+ else if(status_flag.Pending_SockD_Callback == WIFI_TRUE)//for server socket
+ {
+ //if(status_flag.command_mode)//if command_mode is achieved then callback else loop in this state
+ {
+ //Now callback to user with user_data pointer <UserDataBuff>
+ ind_wifi_socket_data_received(9, (uint8_t *)UserDataBuff, message_size, chunk_size);
+ memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);//Flush the buffer
+ Resume_Dequeue();
+ status_flag.Pending_SockD_Callback=WIFI_FALSE;
+ }
+ }
+
+ else if(status_flag.Client_Socket_Close_Cmd==WIFI_TRUE)//for client socket
+ {
+ //Close the socket
+ //Change State to AT_Cmd_Response before calling socket_close()
+ WiFi_Module_State = Process_Event;
+ wifi_socket_client_close(client_socket_close_id);
+ status_flag.Client_Socket_Close_Cmd = WIFI_FALSE;
+// status_flag.SockON_Server_Closed_Callback = WIFI_TRUE;
+ }
+
+ else if(status_flag.SockON_Server_Closed_Callback==WIFI_TRUE)//for client socket
+ {
+ //callback the user
+ ind_wifi_socket_client_remote_server_closed(&socket_closed_id_callback);
+ status_flag.SockON_Server_Closed_Callback = WIFI_FALSE;
+ }
+
+ else if(status_flag.HTTP_Data_available == WIFI_TRUE)
+ {
+ ind_wifi_http_data_available((uint8_t *)UserDataBuff,UserDataBuff_index);
+ memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);//Flush the buffer
+// memcpy(&UserDataBuff, &HTTP_Runway_Buff, 6);
+// memset(HTTP_Runway_Buff, 0x00, 6);
+ Resume_Dequeue();
+ status_flag.HTTP_Data_available=WIFI_FALSE;
+ }
+
+ else if (status_flag.FILE_Data_available == WIFI_TRUE)
+ {
+ ind_wifi_file_data_available((uint8_t *) UserDataBuff);
+ memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);//Flush the buffer
+ Resume_Dequeue();
+ status_flag.FILE_Data_available = WIFI_FALSE;
+ }
+ else if(status_flag.Client_Connected == WIFI_TRUE)
+ {
+ ind_socket_server_client_joined();
+ status_flag.Client_Connected = WIFI_FALSE;
+ }
+
+ else if(status_flag.Client_Disconnected == WIFI_TRUE)
+ {
+ ind_socket_server_client_left();
+ status_flag.Client_Disconnected = WIFI_FALSE;
+ }
+
+ //Make callbacks from here to user for pending events
+
+ if(WiFi_WIND_State.WiFiHWStarted==WIFI_TRUE)
+ {
+ if(wifi_ready == 2)//Twice reset for User Callback
+ {
+ wifi_ready++;
+ ind_wifi_on();//Call this once only...This if for wifi_on (instead of console active
+ }
+ }
+
+ if(WiFi_WIND_State.WiFiUp == WIFI_TRUE)
+ {
+ if(wifi_connected == 0)
+ {
+ wifi_connected = 1;
+ ind_wifi_connected();//wifi connected
+ }
+ WiFi_WIND_State.WiFiUp = WIFI_FALSE;
+ }
+
+ else if(WiFi_WIND_State.WiFiStarted_MiniAPMode == WIFI_TRUE)
+ {
+ ind_wifi_ap_ready();
+ WiFi_WIND_State.WiFiStarted_MiniAPMode = WIFI_FALSE;
+ }
+
+ else if(WiFi_WIND_State.WiFiAPClientJoined == WIFI_TRUE)
+ {
+ ind_wifi_ap_client_joined(client_MAC_address);
+ WiFi_WIND_State.WiFiAPClientJoined = WIFI_FALSE;
+ }
+
+ else if(WiFi_WIND_State.WiFiAPClientLeft == WIFI_TRUE)
+ {
+ ind_wifi_ap_client_left(client_MAC_address);
+ WiFi_WIND_State.WiFiAPClientLeft = WIFI_FALSE;
+ }
+
+ else if(status_flag.Deep_Sleep_Callback == WIFI_TRUE)
+ {
+ ind_wifi_resuming();
+ status_flag.Deep_Sleep_Callback = WIFI_FALSE;
+ }
+
+ else if(status_flag.standby_resume_callback == WIFI_TRUE)
+ {
+ ind_wifi_resuming();
+ status_flag.standby_resume_callback = WIFI_FALSE;
+ }
+
+ else if(WiFi_WIND_State.WiFiHWFailure==WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiHWFailure=WIFI_FALSE;
+ ind_wifi_error(WiFi_HW_FAILURE_ERROR);//call with error number
+ }
+
+ else if(WiFi_WIND_State.HardFault==WIFI_TRUE)
+ {
+ WiFi_WIND_State.HardFault=WIFI_FALSE;
+ ind_wifi_error(WiFi_HARD_FAULT_ERROR);//call with error number
+ }
+
+ else if(WiFi_WIND_State.StackOverflow==WIFI_TRUE)
+ {
+ WiFi_WIND_State.StackOverflow=WIFI_FALSE;
+ ind_wifi_error(WiFi_STACK_OVERFLOW_ERROR);//call with error number
+ }
+
+ else if(WiFi_WIND_State.MallocFailed==WIFI_TRUE)
+ {
+ WiFi_WIND_State.MallocFailed=WIFI_FALSE;
+ ind_wifi_error(WiFi_MALLOC_FAILED_ERROR);//call with error number
+ }
+
+ else if(WiFi_WIND_State.InitFailure==WIFI_TRUE)
+ {
+ WiFi_WIND_State.InitFailure=WIFI_FALSE;
+ ind_wifi_error(WiFi_INIT_ERROR);//call with error number
+ }
+
+ else if(WiFi_WIND_State.StartFailed==WIFI_TRUE)
+ {
+ WiFi_WIND_State.StartFailed=WIFI_FALSE;
+ ind_wifi_error(WiFi_START_FAILED_ERROR);//call with error number
+ }
+
+ else if(WiFi_WIND_State.WiFiException==WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiException=WIFI_FALSE;
+ ind_wifi_error(WiFi_EXCEPTION_ERROR);//call with error number
+ }
+
+ else if(WiFi_WIND_State.PS_Mode_Failure==WIFI_TRUE)
+ {
+ WiFi_WIND_State.PS_Mode_Failure=WIFI_FALSE;
+ ind_wifi_warning(WiFi_POWER_SAVE_WARNING);//call with error number
+ }
+
+ else if(WiFi_WIND_State.HeapTooSmall==WIFI_TRUE)
+ {
+ WiFi_WIND_State.HeapTooSmall=WIFI_FALSE;
+ ind_wifi_warning(WiFi_HEAP_TOO_SMALL_WARNING);//call with error number
+ }
+
+ else if(WiFi_WIND_State.WiFiSignalLOW==WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiSignalLOW=WIFI_FALSE;
+ ind_wifi_warning(WiFi_SIGNAL_LOW_WARNING);//call with error number
+ }
+
+ else if(WiFi_WIND_State.WiFiDeauthentication == WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiDeauthentication = WIFI_FALSE;
+ ind_wifi_connection_error(WiFi_DE_AUTH);
+ }
+
+ else if(WiFi_WIND_State.WiFiDisAssociation == WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiDisAssociation = WIFI_FALSE;
+ ind_wifi_connection_error(WiFi_DISASSOCIATION);
+ }
+
+ else if(WiFi_WIND_State.WiFiJoinFailed == WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiJoinFailed = WIFI_FALSE;
+ ind_wifi_connection_error(WiFi_JOIN_FAILED);
+ }
+
+ else if(WiFi_WIND_State.WiFiScanBlewUp == WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiScanBlewUp = WIFI_FALSE;
+ ind_wifi_connection_error(WiFi_SCAN_BLEWUP); //@TBD to check if user made call, so not call callback if true
+ }
+
+ else if(WiFi_WIND_State.WiFiScanFailed == WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiScanFailed = WIFI_FALSE;
+ ind_wifi_connection_error(WiFi_SCAN_FAILED); //@TBD to check if user made call, so not call callback if true
+ }
+
+ else if(WiFi_WIND_State.WiFiUnHandledInd == WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiUnHandledInd = WIFI_FALSE;
+ ind_wifi_packet_lost(WiFi_UNHANDLED_IND_ERROR); //@TBD to check if user made call, so not call callback if true
+ }
+
+ else if(WiFi_WIND_State.WiFiRXMgmt == WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiRXMgmt = WIFI_FALSE;
+ ind_wifi_packet_lost(WiFi_RX_MGMT); //@TBD to check if user made call, so not call callback if true
+ }
+
+ else if(WiFi_WIND_State.WiFiRXData == WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiRXData = WIFI_FALSE;
+ ind_wifi_packet_lost(WiFi_RX_DATA); //@TBD to check if user made call, so not call callback if true
+ }
+
+ else if(WiFi_WIND_State.WiFiRxUnk == WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiRxUnk = WIFI_FALSE;
+ ind_wifi_packet_lost(WiFi_RX_UNK); //@TBD to check if user made call, so not call callback if true
+ }
+
+ else if(WiFi_WIND_State.WiFiSockdDataLost == WIFI_TRUE)
+ {
+ WiFi_WIND_State.WiFiSockdDataLost = WIFI_FALSE;
+ ind_wifi_socket_server_data_lost(); //@TBD to check if user made call, so not call callback if true
+ }
+
+}
+
+
+/**
+* @brief Start_Timer
+* Start Timer
+* @param None
+* @retval None
+*/
+void Start_Timer()
+{
+ //tickcount = WIFI_FALSE;
+ status_flag.Timer_Running = WIFI_TRUE;
+}
+
+/**
+* @brief Stop_Timer
+* Stop Timer request
+* @param None
+* @retval None
+*/
+void Stop_Timer()
+{
+ //tickcount = WIFI_FALSE;
+ status_flag.Timer_Running = WIFI_FALSE;
+ //UartReady = SET;
+}
+
+/**
+* @brief Stop_Dequeue
+* Stop dequeuing data from the ring buffer
+* @param None
+* @retval None
+*/
+void Stop_Dequeue()
+{
+ status_flag.enable_dequeue = WIFI_FALSE;
+}
+
+/**
+* @brief Resume_Dequeue
+* Resume dequeuing data from the ring buffer
+* @param None
+* @retval None
+*/
+void Resume_Dequeue()
+{
+ status_flag.enable_dequeue = WIFI_TRUE;
+}
+
+/**
+* @brief Wifi_SysTick_Isr
+* Function called every SysTick to process buffer
+* @param None
+* @retval None
+*/
+void Wifi_SysTick_Isr()
+{
+ //Check if Data is Paused
+ if((status_flag.Timer_Running) && (status_flag.enable_dequeue==WIFI_TRUE))
+ {
+ Process_WiFi();
+ }
+
+ if(status_flag.Timeout_Timer) tickcount++;
+
+ /*if(status_flag.resume_receive_data == WIFI_TRUE)
+ {
+ if(is_half_empty(&big_buff))
+ {
+ status_flag.resume_receive_data = WIFI_FALSE;
+ //callSpwfSADevice_attach(1);
+ Receive_Data();
+
+ }
+ }*/
+
+
+ if(status_flag.Standby_Timer_Running) // module is in sleep and after expiry RX will be conf as EXTI
+ {
+ if((standby_time++) >= EXTI_CONF_TIMER)
+ {
+ status_flag.Standby_Timer_Running=WIFI_FALSE;
+ standby_time = 0;
+ //configure_to_exti();
+ }
+ }
+
+ /*A Resume WIND:70 has come and triggered this
+ So checking here if after that resume we fall back to sleep (another WIND69) within SLEEP_RESUME_PREVENT time.
+ If yes, we assume it is a false resume and hence do nothing and go back to sleep
+ If no WIND69 (going into sleep) has come, we can assume the resume was genuine and then enable the callback
+ */
+ if((status_flag.Deep_Sleep_Timer) && ( sleep_count++) >= SLEEP_RESUME_PREVENT)
+ {
+ if(status_flag.Deep_Sleep_Enabled == WIFI_TRUE)//which means we have received another WIND69 in the 2 seconds
+ {
+ //do nothing, go back to sleep
+ status_flag.Deep_Sleep_Enabled = WIFI_TRUE;
+ status_flag.Deep_Sleep_Callback = WIFI_FALSE;
+ }
+ else if (status_flag.Deep_Sleep_Enabled == WIFI_FALSE) //which means we have not received any WIND69 during the last 2 seconds
+ {
+ //enable the user callback as it is a genuine WIND70
+ status_flag.Deep_Sleep_Callback = WIFI_TRUE;
+ }
+ Stop_DeepSleep_Timer();
+ }
+}
+
+
+/**
+* @brief USART_Receive_AT_Resp
+* Receive and check AT cmd response
+* @param WiFi_AT_CMD_Response_t : WIFi module next state
+* @retval WiFi_Status_t : Response of AT cmd
+*/
+
+WiFi_Status_t USART_Receive_AT_Resp(WiFi_AT_CMD_Response_t state)
+{
+ WiFi_Module_State = state;
+ tickcount=0;//reset timer
+ status_flag.Timeout_Timer = WIFI_TRUE;
+ while(status_flag.AT_Response_Received != WIFI_TRUE) {
+ if(tickcount >=20000)//20 sec wait
+ {
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ break;
+ }
+ __NOP();
+ }
+ status_flag.Timeout_Timer = WIFI_FALSE;
+ status_flag.AT_Response_Received = WIFI_FALSE;
+ return AT_RESPONSE;
+}
+
+
+/**
+* @brief Process_WiFi
+* Pop a byte from the circular buffer and send the byte for processing
+* This function should be called from main or should be run with a periodic timer
+* @param None
+* @retval None
+*/
+void Process_WiFi(void)
+{
+ uint8_t * temp;//pop buffer temporary
+
+ __disable_irq();
+ temp=pop_buffer_queue(&big_buff); //contents of temp(pop_buffer) will not change till another de-queue is made
+ __enable_irq();
+
+ if(temp!=NULL)
+ {
+ Process_Buffer(temp);
+ }
+
+ if(status_flag.event_deQ_x_wind64)//if de-Q is stopped due to WIND64 wait
+ {
+ wind64_DQ_wait++;//1ms for each count
+ if(wind64_DQ_wait>200)//wait for 50ms for example
+ {
+ wind64_DQ_wait=0;
+ status_flag.event_deQ_x_wind64 = WIFI_FALSE;
+ //re-enable event Q after 200ms
+ status_flag.stop_event_dequeue = WIFI_FALSE;
+ }
+ }
+}
+
+/**
+* @brief Process_Buffer
+* Process and construct a Wind Line buffer
+* @param ptr: pointer to one single byte
+* @retval None
+*/
+
+void Process_Buffer(uint8_t * ptr)
+{
+ static uint32_t Fillptr=0;//count=0;
+ static uint8_t index, chan_value;
+ unsigned char rxdata = 0;
+ int rssi_value = 0;
+ char SocketId_No[2];
+ char databytes_No[4];
+ char * pStr;
+
+ rxdata = *(ptr+0);
+ //printf(&rxdata);//check prints for debug...to be removed or kept in DEBUG statement
+ if(status_flag.enable_receive_data_chunk == WIFI_FALSE)
+ process_buffer[Fillptr++] = rxdata;
+ reset_event(&event_s);
+ switch (WiFi_Module_State)
+ {
+ case Process_Event:
+
+ if((process_buffer[Fillptr-2]==0xD) && (process_buffer[Fillptr-1]==0xA) && !status_flag.enable_receive_http_response && !status_flag.sock_read_ongoing)
+ {
+ if((strstr((const char *)process_buffer,"WIND:")) != NULL)
+ {
+ if((strstr((const char *)process_buffer,"+WIND:67:")) !=NULL)
+ event_s.event = WIFI_STANDBY_CONFIG_EVENT;
+
+ else if ((strstr((const char *)process_buffer,"+WIND:68:"))!= NULL)
+ event_s.event = WIFI_RESUME_CONFIG_EVENT;
+
+ else
+ {
+ //end of msg received. Will not receive any other msg till we process this.
+ //Stop_Timer();
+ //#if defined (USE_STM32L0XX_NUCLEO) || (USE_STM32F4XX_NUCLEO) || (USE_STM32L4XX_NUCLEO)
+ //__disable_irq();
+ //#endif
+ Process_Wind_Indication(&process_buffer[0]);
+ //#if defined (USE_STM32L0XX_NUCLEO) || (USE_STM32F4XX_NUCLEO) || (USE_STM32L4XX_NUCLEO)
+ //__enable_irq();
+ //#endif
+ //Start_Timer();
+ sock_total_count=0;
+ }
+
+ if(!status_flag.prevent_push_WIFI_event)
+ {
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+ reset_event(&event_s);
+ }
+
+ if (!status_flag.do_not_reset_push_WIFI_event) status_flag.prevent_push_WIFI_event = WIFI_FALSE;
+ if(status_flag.enable_sock_read)
+ {
+ status_flag.sock_read_ongoing = WIFI_FALSE;//we finished processing a message and now sock read will commence
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ }
+ Fillptr=0;
+ memset(process_buffer, 0x00, strlen((const char*)process_buffer));
+ }
+
+ else if((strstr((const char *)process_buffer,"\r\nOK\r\n")) != NULL)
+ {
+ /*Now Check to which AT Cmd response this OK belongs to so that correct parsing can be done*/
+
+ // SOCKON ID (Open a client socket)
+ if(((pStr=(strstr((const char *)process_buffer,"ID: "))) != NULL))
+ {
+ SocketId_No[0] = *(pStr + 4) ;
+ SocketId_No[1] = *(pStr + 5) ;
+ SocketId = (((SocketId_No[0] - '0') * 10 ) + (SocketId_No[1] - '0'));
+ event_s.socket_id = SocketId;
+ event_s.event = WIFI_SOCK_ID_EVENT;
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+ reset_event(&event_s);
+ if(status_flag.enable_sock_read)
+ {
+ status_flag.sock_read_ongoing = WIFI_FALSE; //we finished processing a message and now sock read will commence
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ }
+ Fillptr=0;
+ sock_total_count=0;
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ }
+
+ // DATALEN from SOCKQ
+ else if((pStr=(strstr((const char *)process_buffer,"DATALEN: "))) != NULL)
+ {
+ //Find the DataLength and do a socket read
+ databytes_No[0] = *(pStr + 9);
+ databytes_No[1] = *(pStr + 10);
+ databytes_No[2] = *(pStr + 11);
+ databytes_No[3] = *(pStr + 12);
+
+ if( databytes_No[1] == '\r')
+ {
+ SockON_Data_Len = databytes_No[0] - '0';
+ }
+ else if( databytes_No[2] == '\r')
+ {
+ SockON_Data_Len = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
+ }
+ else if( databytes_No[3] == '\r')
+ {
+ SockON_Data_Len = (((databytes_No[0] - '0') * 100 ) + ((databytes_No[1] - '0') * 10 ) + (databytes_No[2] - '0'));
+ }
+ else //it's a 4-digit number
+ {
+ SockON_Data_Len = ((databytes_No[0] - '0') * 1000 ) + ((databytes_No[1] - '0') * 100 ) + ((databytes_No[2] - '0') * 10) + (databytes_No[3] - '0');
+ }
+ Socket_Data_Length = SockON_Data_Len;
+ if(Socket_Data_Length != 0)
+ {
+ status_flag.start_sock_read = WIFI_TRUE;
+ }
+ else if(Socket_Data_Length == 0)
+ {
+ status_flag.stop_event_dequeue = WIFI_FALSE; //continue popping events if nothing to read
+ status_flag.Set_AT_Cmd_Response_False = WIFI_FALSE;
+ }
+ Fillptr = 0;
+ sock_total_count = 0;
+ if(status_flag.enable_sock_read)
+ {
+ status_flag.sock_read_ongoing = WIFI_FALSE; //we finished processing a message and now sock read will commence
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ pop_buffer_size = 0;
+ pop_buffer[0]='\0'; // required as this byte is already used in process_buffer
+ }
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ }
+
+ else if((((strstr((const char *)process_buffer," = "))) != NULL))
+ {
+ // AT command GCFG
+ pStr = (char *) strstr((const char *)process_buffer," = ");
+ event_s.event = WIFI_GCFG_EVENT;
+ memcpy(get_cfg_value, pStr+2, (strlen(pStr)-2));
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+ reset_event(&event_s);
+ if(status_flag.enable_sock_read)
+ {
+ status_flag.sock_read_ongoing = WIFI_FALSE; //we finished processing a message and now sock read will commence
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ }
+ Fillptr=0;
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ }
+
+ else
+ {
+ //This is a standalone OK
+ /*Cases possible
+ - TLSCERT,TLSCERT2, TLSDOMAIN, SETTIME
+ - S.SOCKW, SOCKR, S.SOCKC, S.SOCKD (open a server socket)
+ - File Operations
+ - S.GPIOC and S.GPIOW
+ */
+ //Push a simple OK Event, if this is an OK event required to be pushed to Q
+ if(status_flag.prevent_push_OK_event)
+ {
+ //This OK is not to be handled, hence the pop action on OK completion to be done here
+ //since pop will not happen
+// stop_event_dequeue=WIFI_FALSE;
+
+ if(status_flag.client_socket_close_ongoing)
+ {
+ if(no_of_open_client_sockets > 0)
+ no_of_open_client_sockets--;
+ status_flag.prevent_push_OK_event = WIFI_FALSE;
+ open_sockets[remote_socket_closed_id] = WIFI_FALSE;
+ socket_closed_id_callback = remote_socket_closed_id;
+ status_flag.Set_AT_Cmd_Response_False = WIFI_FALSE;
+ status_flag.client_socket_close_ongoing = WIFI_FALSE;
+ status_flag.SockON_Server_Closed_Callback = WIFI_TRUE;
+ status_flag.stop_event_dequeue=WIFI_FALSE;
+ }
+
+ }
+
+ else
+ {
+ event_s.ok_eval = WIFI_TRUE;
+ event_s.event = WIFI_OK_EVENT;
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+ reset_event(&event_s);
+ }
+ status_flag.prevent_push_OK_event = WIFI_FALSE;
+ memset(process_buffer, 0x00, Fillptr);
+ Fillptr=0;
+ sock_total_count=0;
+ if(status_flag.enable_sock_read)
+ {
+ status_flag.sock_read_ongoing = WIFI_FALSE;//we finished processing a message and now sock read will commence
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ }
+ break;
+ }
+ }
+
+ else if((((strstr((const char *)process_buffer,"ERROR"))) != NULL))
+ {
+ //This is an ERROR
+ //There can be only ONE outstanding AT command and hence this ERROR belongs to that
+ //HTTP -> ERROR: host not found
+ //@TBD: Check all Errors Possible here???
+ if((strstr((const char *)process_buffer,"\r\nERROR: Pending data\r\n")) != NULL) //if Error after sock close command and not 'OK'
+ {
+ printf("\r\nERROR: Socket could not be closed..PENDING DATA\r\n");
+ status_flag.prevent_push_OK_event = WIFI_FALSE; //prevent the OK received after socket close command to be Q'ed
+ status_flag.client_socket_close_ongoing = WIFI_FALSE;
+ status_flag.stop_event_dequeue = WIFI_FALSE;
+ }
+ else
+ {
+ event_s.event = WIFI_ERROR_EVENT;
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+ reset_event(&event_s);
+ if(status_flag.stop_event_dequeue)
+ /*ERROR:Illegal Socket ID*/
+ status_flag.stop_event_dequeue= WIFI_FALSE;//continue popping events if nothing to read
+ }
+ Fillptr=0;
+ sock_total_count=0;
+ if(status_flag.enable_sock_read)
+ {
+ status_flag.sock_read_ongoing = WIFI_FALSE;//we finished processing a message and now sock read will commence
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ }
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ }
+
+ else if((((strstr((const char *)process_buffer,"GPIO "))) != NULL))
+ {
+ // Receive GPIO Read
+ pStr = (char *) strstr((const char *)process_buffer,"= 0,");
+ if(pStr != NULL)
+ {
+ gpio_value = 0;
+ }
+ else
+ gpio_value = 1;
+
+ pStr = (char *) strstr((const char *)process_buffer,"out");
+ if(pStr != NULL)
+ {
+ gpio_direc= 0; //out
+ }
+ else
+ {
+ gpio_direc= 1; //in
+ }
+ //Push GPIO Read Event on Event_Queue
+ event_s.event = WIFI_GPIO_EVENT;
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+ reset_event(&event_s);
+ if(status_flag.enable_sock_read)
+ {
+ status_flag.sock_read_ongoing = WIFI_FALSE; //we finished processing a message and now sock read will commence
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ }
+ Fillptr = 0;
+ memset(process_buffer, 0x00, strlen((const char*)process_buffer));
+ break;
+ }
+
+ else
+ {
+ if(status_flag.enable_sock_read && status_flag.Q_Contains_Message && !status_flag.message_pending)
+ {
+ printf((const char*)&process_buffer[0]);
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ status_flag.Q_Contains_Data = WIFI_TRUE;
+ //status_flag.enable_sock_read = WIFI_FALSE;
+ //status_flag.stop_event_dequeue= WIFI_FALSE;
+ }
+
+ //if in data mode, reset on \r\n
+ if(!status_flag.sock_read_ongoing && status_flag.data_mode)
+ {
+ Fillptr = 0;
+ memset(process_buffer, 0x00, strlen((const char*)process_buffer));
+ }
+ }
+ }
+
+ else if (status_flag.http_req_pending) //HTTP Response Check
+ {
+ if((strstr((const char *)&process_buffer[0],"200 OK\r")) != NULL || (strstr((const char *)&process_buffer[0],"400 Bad Request\r")) != NULL
+ || (strstr((const char *)&process_buffer[0],"401 Unauthorized\r")) != NULL || (strstr((const char *)&process_buffer[0],"403 Forbidden\r")) != NULL
+ || (strstr((const char *)&process_buffer[0],"404 Not Found\r")) != NULL || (strstr((const char *)&process_buffer[0],"408 Request Timeout\r")) != NULL
+ || (strstr((const char *)&process_buffer[0],"500 Internal Server Error\r")) != NULL || (strstr((const char *)&process_buffer[0],"502 Bad Gateway\r")) != NULL
+ || (strstr((const char *)&process_buffer[0],"504 Gateway Timeout\r")) != NULL)
+ {
+ status_flag.enable_receive_http_response = WIFI_TRUE;
+ status_flag.enable_receive_data_chunk = WIFI_TRUE;
+ status_flag.http_req_pending = WIFI_FALSE;
+ pop_buffer[0]='\0';
+ pop_buffer_size=0;
+ process_buffer_index =6;
+ }
+ }
+
+ else if ((process_buffer[Fillptr-1]==0x09) && (process_buffer[Fillptr-2]==':') && (process_buffer[Fillptr-3]=='1'))//<ht> Horizontal Tab for Scan Result?
+ {
+ status_flag.enable_receive_wifi_scan_response = WIFI_TRUE;
+ }
+
+ if(!status_flag.Pending_SockON_Callback && !status_flag.HTTP_Data_available && !status_flag.FILE_Data_available)
+ {
+ //Check Process Buffer for any pending message
+ if(status_flag.enable_receive_data_chunk)
+ {
+ if(!status_flag.Q_Contains_Data && pop_buffer_size)
+ {
+ pop_queue_length = pop_buffer_size;
+ if(Fillptr + pop_queue_length > 511)
+ {
+ uint32_t length = (Fillptr + pop_queue_length) - 511;
+ __disable_irq();
+ rewind_buffer_queue(&big_buff,length);
+ __enable_irq();
+ memset(ptr+(511 - Fillptr), 0x00, length);
+ pop_queue_length = 511 - Fillptr;
+ }
+ memcpy(process_buffer+Fillptr,(char const *)pop_buffer, pop_queue_length);
+ Fillptr = Fillptr + pop_queue_length;
+
+ if(Fillptr > 512)
+ {
+ printf("\r\nFillptr corrupted!!\r\n");
+ }
+
+ if((strstr((const char *)process_buffer,"ERROR: ")) != NULL)
+ {
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ status_flag.message_pending = WIFI_FALSE;
+ }
+ else if(!status_flag.sock_read_ongoing && !status_flag.enable_receive_http_response)
+ {
+ if(process_buffer[0]!='\0')
+ {
+ if(((process_buffer[0]==0xD) && (process_buffer[1]==0xA)) && process_buffer[2] != 0xD)
+ {
+ status_flag.message_pending = WIFI_TRUE;
+ if((pStr = (strstr((const char *)process_buffer+2,"\r\n"))) != NULL)
+ { // process buffer has complete message
+ int wind_length = ((uint8_t *)pStr - (uint8_t *)process_buffer)+2;
+
+ if(strstr((const char *)process_buffer+2,"DATALEN:"))
+ {
+ pStr = strstr((const char *)process_buffer + wind_length,"\r\nOK\r\n"); //find OK, as DATALEN has to be terminated by OK
+ if(pStr!=NULL)
+ {
+ wind_length = ((uint8_t *)pStr-(uint8_t *)process_buffer)+6;
+ }
+ }
+
+ if(Fillptr-wind_length)
+ {
+ __disable_irq();
+ rewind_buffer_queue(&big_buff, Fillptr - wind_length);
+ __enable_irq();
+ memset(process_buffer + wind_length,0x00,Fillptr - wind_length);
+ Fillptr = wind_length;
+ }
+ status_flag.message_pending = WIFI_FALSE;
+ }
+ status_flag.Q_Contains_Message = WIFI_TRUE;
+ }
+ }
+ }
+ }
+ }
+
+ if(!status_flag.Q_Contains_Message && status_flag.enable_sock_read && pop_buffer_size) /*read is enabled*/
+ {
+ status_flag.sock_read_ongoing = WIFI_TRUE;
+ sock_total_count = sock_total_count + pop_queue_length;
+
+ /* Check for "ERROR: Not enough data in buffer " */
+ pStr = (char *) strstr((const char *)&process_buffer,"ERROR: ");
+
+ if (pStr != NULL)
+ {
+ if((process_buffer[Fillptr-2]==0xD) && (process_buffer[Fillptr-1]==0xA))
+ {
+ if((pStr = (char *)strstr((const char *)&process_buffer,"\r\nERROR: Too many sockets\r\n")) !=NULL)
+ {
+ #if DEBUG_PRINT
+ printf("\r\nERROR: TOO MANY SOCKETS \r\n");
+ #endif
+
+ if(*(pStr+27)!='\0')
+ {
+ int len = (uint8_t *)pStr - (uint8_t *)process_buffer;
+ int extra_bytes = Fillptr - (len+27);
+ __disable_irq();
+ rewind_buffer_queue(&big_buff, extra_bytes);
+ __enable_irq();
+ }
+ Fillptr=0;
+ sock_total_count =0;
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ break;
+ }
+ else if((pStr = (char *)strstr((const char *)&process_buffer,"\r\nERROR: Pending data\r\n")) !=NULL)
+ {
+ #if DEBUG_PRINT
+ printf("\r\nERROR: PENDING DATA \r\n");
+ #endif
+
+ if(*(pStr+23)!='\0')
+ {
+ int len = (uint8_t *)pStr - (uint8_t *)process_buffer;
+ int extra_bytes = Fillptr - (len+23);
+ __disable_irq();
+ rewind_buffer_queue(&big_buff, extra_bytes);
+ __enable_irq();
+ }
+ Fillptr=0;
+ sock_total_count =0;
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ break;
+ }
+
+ printf("\rERROR DURING SOCK READ\r\n");
+ sock_total_count=0;
+ SockON_Data_Len=0;
+ SockON_Data_Length=0;
+ status_flag.enable_sock_read = WIFI_FALSE;
+ status_flag.stop_event_dequeue = WIFI_FALSE;
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ status_flag.Q_Contains_Data = WIFI_FALSE;
+ enable_pending_data = 0;
+ status_flag.enable_receive_data_chunk = WIFI_FALSE;
+ WIND64_count=0;
+ process_buffer_index =5;
+ //status_flag.enable_query = TRUE; //do we have more data?
+ Fillptr=0;
+ status_flag.sock_read_ongoing = WIFI_FALSE;
+ if(status_flag.data_pending_sockD)
+ {
+ status_flag.data_pending_sockD=WIFI_FALSE;
+ number_of_bytes=0;
+ status_flag.switch_by_default_to_command_mode=WIFI_TRUE;
+ WiFi_switch_to_command_mode(); //switch by default
+ }
+
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ break;
+ }
+ }
+
+ /*now check if end of msg received*/
+ if(sock_total_count >= SockON_Data_Length)
+ {
+ #if DEBUG_PRINT
+ printf("\nReached SockON_Data_Len \r\n");
+ #endif
+
+ if(sock_total_count > SockON_Data_Length)
+ {
+ int databytes = sock_total_count - SockON_Data_Length;
+ __disable_irq();
+ rewind_buffer_queue(&big_buff, databytes);
+ __enable_irq();
+ memset(process_buffer+(Fillptr - databytes), 0x00, databytes);
+ Fillptr = Fillptr - databytes;
+ }
+ chunk_size = Fillptr;
+ message_size = SockON_Data_Length;
+ memcpy(UserDataBuff, process_buffer, Fillptr);
+ Fillptr = 0;
+ sock_total_count = 0;
+ SockON_Data_Len = 0;
+ status_flag.Q_Contains_Data = WIFI_FALSE;
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ status_flag.enable_receive_data_chunk = WIFI_FALSE;
+ enable_pending_data = 0;
+
+ if(status_flag.data_pending_sockD)
+ {
+// status_flag.data_pending_sockD=WIFI_FALSE;
+ number_of_bytes=0;
+ sockon_id_user = 0;
+ if(WIND64_count>0)
+ WIND64_count--; //decrease the number of pending WIND:64 Events
+ if(WIND64_count==0) {
+ status_flag.switch_by_default_to_command_mode=WIFI_TRUE;
+ WiFi_switch_to_command_mode(); //switch by default
+ }
+ status_flag.enable_query = WIFI_FALSE;
+ }
+ else
+ {
+ status_flag.enable_query = WIFI_TRUE;
+ sockon_id_user = sockon_query_id;
+ /*@TODO: Do not need to prevent OK push in case of server socket*/
+ status_flag.prevent_push_OK_event = WIFI_TRUE; //prevent the qeueuing of the OK after this read operation
+ }
+
+ status_flag.enable_sock_read = WIFI_FALSE;
+ status_flag.sock_read_ongoing = WIFI_FALSE;
+ Stop_Dequeue(); //Stop dequeue till user callback returns
+ status_flag.Pending_SockON_Callback = WIFI_TRUE; //set this to callback to user with User Buffer pointer
+ //do we have more data?
+ if(status_flag.data_pending_sockD)
+ {
+ status_flag.stop_event_dequeue = WIFI_FALSE;
+ status_flag.data_pending_sockD = WIFI_FALSE;
+ }
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ break;
+ }
+
+ if(Fillptr >= MAX_BUFFER_GLOBAL-1)
+ {
+ message_size = SockON_Data_Length;
+ chunk_size = 511;
+ memcpy(UserDataBuff, process_buffer, Fillptr);
+ Fillptr = 0;
+ process_buffer_index = 5;
+ Stop_Dequeue();
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ status_flag.Pending_SockON_Callback = WIFI_TRUE; //set this to callback to user with User Buffer pointer
+ }
+ break;
+ }
+
+ if (status_flag.enable_receive_http_response && pop_buffer_size) // http response enabled
+ {
+ status_flag.sock_read_ongoing = WIFI_TRUE;
+ if((pStr = (strstr((const char *)process_buffer + process_buffer_index - 6,"\r\nOK\r\n"))) != NULL)
+ {
+ #if DEBUG_PRINT
+ printf("\r\nOK\r\n"); //http response completed
+ #endif
+
+ if(*(pStr+7) != '\0')
+ {
+ int len = (uint8_t *)pStr - (uint8_t *)process_buffer;
+ int extra_bytes = Fillptr - (len+6);
+ __disable_irq();
+ rewind_buffer_queue(&big_buff, extra_bytes);
+ __enable_irq();
+
+ memset(process_buffer+len+7, 0x00, extra_bytes);
+ Fillptr = Fillptr - extra_bytes;
+ }
+
+ memcpy(UserDataBuff, process_buffer, Fillptr);
+ UserDataBuff_index = Fillptr;
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ status_flag.enable_receive_data_chunk = WIFI_FALSE;
+ status_flag.enable_receive_http_response = WIFI_FALSE;
+ Stop_Dequeue();
+ AT_RESPONSE = WiFi_MODULE_SUCCESS;
+ status_flag.sock_read_ongoing = WIFI_FALSE;
+ status_flag.Q_Contains_Data = WIFI_FALSE;
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ status_flag.stop_event_dequeue = WIFI_FALSE;
+ process_buffer_index = 6;
+ memset(process_buffer, 0x00, Fillptr);
+ Fillptr=0;
+
+ if(status_flag.enable_receive_file_response)
+ status_flag.FILE_Data_available = WIFI_TRUE;
+ else
+ status_flag.HTTP_Data_available=WIFI_TRUE;
+ }
+
+ else if(((strstr((const char *)process_buffer + process_buffer_index-6,"ERROR"))) != NULL)
+ {
+ #if DEBUG_PRINT
+ printf("\r\nERROR\r\n");
+ #endif
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ status_flag.sock_read_ongoing = WIFI_FALSE;
+ status_flag.enable_receive_data_chunk = WIFI_FALSE;
+ status_flag.Q_Contains_Data = WIFI_FALSE;
+ status_flag.Q_Contains_Message = WIFI_FALSE;
+ Fillptr=0;
+ process_buffer_index=6;
+ status_flag.enable_receive_http_response = WIFI_FALSE;
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+
+ if(status_flag.enable_receive_file_response)
+ status_flag.FILE_Data_available = WIFI_FALSE;
+ else
+ status_flag.HTTP_Data_available=WIFI_FALSE;
+ }
+
+ process_buffer_index = Fillptr;
+ if(Fillptr == MAX_BUFFER_GLOBAL-1 )
+ {
+ memcpy(UserDataBuff, process_buffer, Fillptr);
+ memcpy(&HTTP_Runway_Buff, &UserDataBuff[505], 6);
+ memset(&UserDataBuff[505], 0x00, 6);
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ memcpy(&process_buffer, &HTTP_Runway_Buff, 6);
+ memset(HTTP_Runway_Buff, 0x00, 6);
+ Fillptr = 6;
+ process_buffer_index = 6;
+ UserDataBuff_index = 505;
+ Stop_Dequeue();
+
+ if(status_flag.enable_receive_file_response)
+ status_flag.FILE_Data_available = WIFI_TRUE;
+ else
+ status_flag.HTTP_Data_available=WIFI_TRUE;
+ }
+ break;
+ }
+ }
+ if((!status_flag.Q_Contains_Message) && status_flag.enable_receive_wifi_scan_response)
+ {
+ /*now check if end of msg received*/
+ if((process_buffer[Fillptr-2]==0xD) && (process_buffer[Fillptr-1]==0xA))
+ {
+ if(scanned_ssids < user_scan_number)
+ {
+ pStr = (char *) strstr((const char *)&process_buffer,"CHAN:");
+ if(pStr != NULL)
+ {
+ databytes_No[0] = *(pStr + 6) ;
+ databytes_No[1] = *(pStr + 7) ;
+
+ chan_value = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
+ }
+
+ wifi_scanned_list[scanned_ssids].channel_num = chan_value;
+
+ pStr = (char *) strstr((const char *)&process_buffer,"RSSI:");
+ if(pStr != NULL)
+ {
+ databytes_No[0] = *(pStr + 7) ;
+ databytes_No[1] = *(pStr + 8) ;
+
+ rssi_value = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
+ }
+
+ wifi_scanned_list[scanned_ssids].rssi = -(rssi_value);
+
+ pStr = (char *) strstr((const char *)&process_buffer,"SSID:");
+ if(pStr != NULL)
+ {
+ index = 7;
+ while(*(pStr + index) != 0x27)
+ {
+ wifi_scanned_list[scanned_ssids].ssid[index-7] = *(pStr + index);
+ index++;
+ if(index==35) break; //max ssid lenght is 30 characters
+ }
+ }
+
+ pStr = (char *) strstr((const char *)&process_buffer,"WPA ");
+ if(pStr != NULL)
+ {
+ wifi_scanned_list[scanned_ssids].sec_type.wpa = WIFI_TRUE;
+ } else
+ wifi_scanned_list[scanned_ssids].sec_type.wpa = WIFI_FALSE;
+
+ pStr = (char *) strstr((const char *)&process_buffer,"WPA2 ");
+ if(pStr != NULL)
+ {
+ wifi_scanned_list[scanned_ssids].sec_type.wpa2 = WIFI_TRUE;
+ } else
+ wifi_scanned_list[scanned_ssids].sec_type.wpa2 = WIFI_FALSE;
+
+ pStr = (char *) strstr((const char *)&process_buffer,"WPS ");
+ if(pStr != NULL)
+ {
+ wifi_scanned_list[scanned_ssids].sec_type.wps = WIFI_TRUE;
+ } else
+ wifi_scanned_list[scanned_ssids].sec_type.wps = WIFI_FALSE;
+
+ scanned_ssids++;//increment total_networks
+ //callSpwfSADevice_debug(spwf_dev_,(const char*)scanned_ssids);
+ }
+
+ //end of one line from SCAN result
+ pStr = (char *) strstr((const char *)&process_buffer,"ERROR");
+ if(pStr != NULL)
+ {
+ #if DEBUG_PRINT
+ printf("ERROR Scan Failed");
+ #endif
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ Fillptr=0;
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ status_flag.enable_receive_wifi_scan_response = WIFI_FALSE;
+ status_flag.Scan_Ongoing = WIFI_FALSE; //Enable next scan
+ AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
+ break;
+ }
+
+ #if DEBUG_PRINT
+ printf((const char*)process_buffer);
+ #endif
+
+ callSpwfSADevice_debug(spwf_dev_,(const char*)process_buffer);
+
+ if(((strstr((const char *)process_buffer,"OK\r\n"))) != NULL /*|| scanned_ssids==10*/)/*Max 10 networks supported*/
+ {
+ //print and go for next line
+ //If Any part of scan line contains "OK" this will exit!!
+ #if DEBUG_PRINT
+ printf("\nOK\r\n");
+ #endif
+ status_flag.Scan_Ongoing = WIFI_FALSE; //Enable next scan
+ scanned_ssids=0;
+ Fillptr=0;
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ status_flag.enable_receive_wifi_scan_response = WIFI_FALSE;
+ AT_RESPONSE = WiFi_MODULE_SUCCESS;
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ break;
+ }
+
+ Fillptr=0;
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ }
+
+ if(Fillptr>=MAX_BUFFER_GLOBAL-1)
+ {
+ #if DEBUG_PRINT
+ printf("\rHTTP: process_buffer Max Buffer Size reached\r\n");
+ #endif
+ Fillptr=0;
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ }
+ }
+
+ if((!status_flag.Q_Contains_Message) && status_flag.enable_fw_update_read)
+ {
+ #ifdef DEBUG_PRINT
+ printf("*"); //print * till finish
+ #endif
+
+ pStr = (char *) strstr((const char *)process_buffer,"Complete!");
+
+ if(pStr != NULL)
+ {
+ #ifdef DEBUG_PRINT
+ printf("\r\nUpdate complete\r\n");
+ #endif
+ status_flag.AT_Response_Received = WIFI_TRUE;
+ AT_RESPONSE = WiFi_MODULE_SUCCESS;
+ status_flag.enable_fw_update_read = WIFI_FALSE;
+ Fillptr=0;
+ memset(process_buffer, 0x00, strlen((char const *)process_buffer));
+ }
+ if(Fillptr>=MAX_BUFFER_GLOBAL)
+ {
+ Fillptr=0;
+ memset(process_buffer, 0x00, strlen((char const *)process_buffer));
+ }
+
+ //No change of state till we get "+WIND:17:F/W update complete!"
+ }
+
+ /*else no other case is satisfied at least do the following*/
+ {
+ if(Fillptr>=MAX_BUFFER_GLOBAL-1)
+ {
+ Fillptr=0;
+ memset(process_buffer, 0x00,MAX_BUFFER_GLOBAL-1);
+ }
+ }
+ }
+}
+
+/**
+* @brief Process_Wind_Indication_Cmd
+* Process Wind indication command
+* @param process_buff_ptr: pointer of WiFi indication buffer
+* @retval None
+*/
+
+void Process_Wind_Indication(uint8_t *process_buff_ptr)
+{
+ char * pStr = (char*)process_buff_ptr;
+ char Indication_No[2];
+ char databytes_No[4];
+ #if DEBUG_PRINT
+ printf((const char*)process_buff_ptr);
+ #endif
+ //callSpwfSADevice_debug(spwf_dev_,(const char*)process_buff_ptr);
+
+ char * ptr_offset;
+ int i;
+
+ uint32_t wind55_data_len=0;
+ WiFi_Indication_t Wind_No = Undefine_Indication;
+
+ if(pStr != NULL)
+ {
+ pStr = (char *) strstr((const char *)(pStr),"WIND:");///////
+
+ if(pStr != NULL)
+ {
+ Indication_No[0] = *(pStr + 5) ;
+ Indication_No[1] = *(pStr + 6) ;
+
+ if( Indication_No[1] == ':')
+ {
+ status_flag.Single_Digit_Indication = WIFI_TRUE;
+ /* Convert char to integer */
+ Wind_No = (WiFi_Indication_t)(Indication_No[0] - '0');
+ }
+ else
+ {
+ status_flag.Single_Digit_Indication = WIFI_FALSE;
+ /* Convert char to integer */
+ Wind_No = (WiFi_Indication_t)(((Indication_No[0] - '0') * 10 ) + (Indication_No[1] - '0'));
+ }
+
+ event_s.wind = Wind_No;
+ event_s.event = WIFI_WIND_EVENT;
+
+ switch (Wind_No)
+ {
+ case SockON_Data_Pending: /*WIND:55*/
+
+ /*+WIND:55:Pending Data:%d:%d*/
+ ptr_offset = (char *) strstr((const char *)&process_buffer,"Data:");
+
+ /*Need to find out which socket ID has data pending*/
+ databytes_No[0] = *(ptr_offset + 5);
+
+ SocketId = (databytes_No[0] - '0');//Max number of sockets is 8 (so single digit)
+ event_s.socket_id = SocketId;
+ enable_pending_data = 1;
+
+ /* EQ. Check for ENC string to identify TLS case. Set enable_query */
+ if ( (*(ptr_offset + 7) == 'E') && (*(ptr_offset + 8) == 'N') && (*(ptr_offset + 9) == 'C') )
+ {
+ event_s.enc = WIFI_TRUE;
+ }
+ else
+ {
+ //And find the length of the data
+ databytes_No[0] = *(ptr_offset + 7);
+ databytes_No[1] = *(ptr_offset + 8);
+ databytes_No[2] = *(ptr_offset + 9);
+ databytes_No[3] = *(ptr_offset + 10);
+
+ if( databytes_No[1] == '\r')
+ {
+ wind55_data_len = databytes_No[0] - '0';
+ }
+ else if( databytes_No[2] == '\r')
+ {
+ wind55_data_len = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
+ }
+ else if( databytes_No[3] == '\r') //it's a 3-digit number
+ {
+ wind55_data_len = (((databytes_No[0] - '0') * 100 ) + ((databytes_No[1] - '0') * 10 ) + (databytes_No[2] - '0'));
+ }
+ else //it's a 4-digit number
+ {
+ wind55_data_len = ((databytes_No[0] - '0') * 1000 ) + ((databytes_No[1] - '0') * 100 ) + ((databytes_No[2] - '0') * 10) + (databytes_No[3] - '0');
+ }
+
+ event_s.data_length = wind55_data_len;
+ wind55_data_len = 0;
+ }
+ break;
+
+ case SockON_Server_Socket_Closed:
+ //Find the id of the socket closed
+ //ptr_offset = (char *) strstr((const char *)pStr,"+WIND:58");
+ databytes_No[0] = *(pStr + 22) ;
+ databytes_No[1] = *(pStr + 23) ;
+ if( databytes_No[1] == '\r')
+ {
+ remote_socket_closed_id = databytes_No[0] - '0';
+ }
+ else
+ {
+ remote_socket_closed_id = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
+ }
+ event_s.socket_id = remote_socket_closed_id;
+ break;
+
+ case SockD_Pending_Data:
+ if(status_flag.prevent_push_WIFI_event)
+ {
+ #ifdef DEBUG_PRINT
+ printf(">>IG\r\n");
+ #endif
+ return; ///exit if push is prevented
+ }
+
+ /* @TODO: Do something to delay the de-Q of pending packets so that any further
+ pending WIND64 packets are allowed to arrive and get Q-ed */
+
+ if(status_flag.event_deQ_x_wind64) //which means there is already a previous WIND64
+ {
+ wind64_DQ_wait=0; //reset the timer
+ }
+ else
+ {
+ status_flag.stop_event_dequeue = WIFI_TRUE;//Stop the event de-Q
+ status_flag.event_deQ_x_wind64 = WIFI_TRUE;//Set the flag
+ }
+ //Start Reading data from Client Here.
+ // +WIND:64:Sockd Pending Data:1:130:130
+ ptr_offset = (char *) strstr((const char *)&process_buffer,"Data:");
+
+ //Store the packet number
+ databytes_No[0] = *(ptr_offset + 5) ;
+ event_s.wind64_pending_packet_no = databytes_No[0] - '0';
+
+ //And now find the data length
+ databytes_No[0] = *(ptr_offset + 8) ;//points to number just after 2nd colon
+ databytes_No[1] = *(ptr_offset + 9) ;
+ databytes_No[2] = *(ptr_offset + 10) ;
+ databytes_No[3] = *(ptr_offset + 11) ;
+
+ if( databytes_No[0] == ':')//then it is a 1 digit number
+ {
+ databytes_No[0] = *(ptr_offset + 7) ;
+ databytes_No[1] = *(ptr_offset + 8) ;
+ }
+ else if(databytes_No[1] == ':')//two digit number
+ {
+ databytes_No[0] = *(ptr_offset + 7) ;
+ databytes_No[1] = *(ptr_offset + 8) ;
+ databytes_No[2] = *(ptr_offset + 9) ;
+ //databytes_No[3] = *(ptr_offset + 13) ;
+ }
+ else if(databytes_No[2] == ':')//three digit number
+ {
+ databytes_No[0] = *(ptr_offset + 7) ;
+ databytes_No[1] = *(ptr_offset + 8) ;
+ databytes_No[2] = *(ptr_offset + 9) ;
+ databytes_No[3] = *(ptr_offset + 10) ;
+ }
+ else if(databytes_No[3] == ':')//four digit number
+ {
+ databytes_No[0] = *(ptr_offset + 7) ;
+ databytes_No[1] = *(ptr_offset + 8) ;
+ databytes_No[2] = *(ptr_offset + 9) ;
+ databytes_No[3] = *(ptr_offset + 10) ;
+ }
+
+ if( databytes_No[1] == ':')
+ {
+ interim_number_of_bytes = databytes_No[0] - '0';
+ }
+ else if( databytes_No[2] == ':')
+ {
+ interim_number_of_bytes = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
+ }
+ else if( databytes_No[3] == ':')
+ {
+ interim_number_of_bytes = (((databytes_No[0] - '0') * 100 ) + ((databytes_No[1] - '0') * 10 ) + (databytes_No[2] - '0'));
+ }
+ else //it's a 4-digit number
+ {
+ interim_number_of_bytes = (((databytes_No[0] - '0') * 1000 ) + ((databytes_No[1] - '0') * 100 ) + ((databytes_No[2] - '0') * 10 ) + (databytes_No[3] - '0'));
+ }
+
+ if(WIND64_count >= 1) /*WIND:64 came after pop of previous event and switch to data mode was issued*/
+ /*WIND:64 came before pop of previous event and switch to data mode was issued*/
+ {
+ event_s.data_length = interim_number_of_bytes;// - (730*WIND64_count);
+ WIND64_count++; //Count of the number of queued WIND:64 Events
+ interim_number_of_bytes = 0;
+ break;
+ }
+ else
+ {
+ event_s.data_length = interim_number_of_bytes;
+ WIND64_count++; //Count of the number of queued WIND:64 Events
+ interim_number_of_bytes = 0;
+ }
+ break;
+
+ case In_Command_Mode:
+ status_flag.command_mode= WIFI_TRUE;
+ status_flag.data_mode= WIFI_FALSE;
+ WIND64_count=0; //reset the WIND64 count since the previous data mode would have consumed all data
+ break;
+
+ case In_Data_Mode:
+ status_flag.command_mode = WIFI_FALSE;
+ status_flag.data_mode = WIFI_TRUE;
+
+ if(status_flag.switch_by_default_to_command_mode == WIFI_TRUE)
+ {
+ if(!status_flag.command_mode)
+ {
+ WiFi_switch_to_command_mode();//switch by default
+ }
+ }
+ if(status_flag.data_pending_sockD == WIFI_TRUE)
+ {
+
+ process_buffer_index =5;
+ status_flag.enable_sock_read = WIFI_TRUE;//now data will start coming
+ //Set the data-length to read
+ SockON_Data_Length = number_of_bytes;
+ }
+ break;
+
+ case WiFi__MiniAP_Associated:
+ //Find out which client joined by parsing the WIND //+WIND:28
+ ptr_offset = (char *) strstr((const char *)&process_buffer,"+WIND:28");
+ for(i=17;i<=33;i++)
+ client_MAC_address[i-17] = *(ptr_offset + i) ;
+ WiFi_WIND_State.WiFiAPClientJoined = WIFI_TRUE;
+ break;
+
+ case WiFi_MiniAP_Disassociated:
+ //Find out which client left by parsing the WIND //+WIND:72
+ ptr_offset = (char *) strstr((const char *)&process_buffer,"+WIND:72");
+ for(i=17;i<=33;i++)
+ client_MAC_address[i-17] = *(ptr_offset + i) ;
+ WiFi_WIND_State.WiFiAPClientLeft = WIFI_TRUE;
+ break;
+
+ case Console_Active:
+ case Poweron :
+ case WiFi_Reset:
+ case Watchdog_Running:
+ case Heap_Too_Small:
+ case WiFi_Hardware_Dead:
+ case Watchdog_Terminating:
+ case SysTickConfigure:
+ case Hard_Fault:
+ case StackOverflow:
+ case MallocFailed:
+ case Error:
+ case WiFi_PS_Mode_Failure:
+ case CopyrightInfo:
+ case WiFi_BSS_Regained:
+ case WiFi_Signal_LOW:
+ case WiFi_Signal_OK:
+ case FW_update:
+ case Encryption_key_Not_Recognized:
+ case WiFi_Join:
+ case JOINFAILED:
+ case WiFi_Scanning:
+ case SCANBLEWUP:
+ case SCANFAILED:
+ case WiFi_Up:
+ case WiFi_Association_Successful:
+ case WiFi_Started_MiniAP_Mode:
+ case Start_Failed :
+ case WiFi_EXCEPTION :
+ case WiFi_Hardware_Started :
+ case WiFi_BSS_LOST:
+ case WiFi_Unhandled_Event:
+ case Scan_Complete:
+ case WiFi_UNHANDLED_IND:
+ case WiFi_UNHANDLED:
+ case WiFi_Powered_Down:
+ case WiFi_MiniAP_Mode :
+ case WiFi_Deauthentication:
+ case WiFi_Disassociation:
+ case RX_MGMT:
+ case RX_DATA:
+ case RX_UNK:
+ case DOT11_AUTHILLEGAL:
+ case Creating_PSK:
+ case WPA_Terminated :
+ case WPA_Supplicant_Failed:
+ case WPA_Handshake_Complete:
+ case GPIO_line:
+ case Wakeup:
+ case Factory_debug:
+ case Remote_Configuration:
+ break;
+ default:
+ break;
+ }
+ memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
+ }
+ }
+}
+
+/**
+* @brief Process_Dequeued_Wind_Indication
+* Process Wind Indication after popping from Queue
+* @param event_pop_s1 popped event contents
+* @retval None
+*/
+
+void Process_WiFi_Indication_Cmd(event_s_TypeDef * event_pop_s1)
+{
+ switch(event_pop_s1->wind)
+ {
+ case Console_Active:
+ WiFi_WIND_State.ConsoleActive = WIFI_TRUE;
+ break;
+ case Poweron :
+ WiFi_WIND_State.WiFiPowerON = WIFI_TRUE;
+ break;
+ case WiFi_Reset:
+ WiFi_WIND_State.WiFiReset = WIFI_TRUE;
+ break;
+ case Watchdog_Running:
+ break;
+ case Heap_Too_Small:
+ WiFi_WIND_State.HeapTooSmall=WIFI_TRUE;
+ break;
+ case WiFi_Hardware_Dead:
+ WiFi_WIND_State.WiFiHWFailure = WIFI_TRUE;
+ break;
+ case Watchdog_Terminating:
+ break;
+ case SysTickConfigure:
+ break;
+ case Hard_Fault:
+ WiFi_WIND_State.HardFault = WIFI_TRUE;
+ break;
+ case StackOverflow:
+ WiFi_WIND_State.StackOverflow = WIFI_TRUE;
+ break;
+ case MallocFailed:
+ WiFi_WIND_State.MallocFailed = WIFI_TRUE;
+ break;
+ case Error:
+ WiFi_WIND_State.InitFailure = WIFI_TRUE;
+ break;
+ case WiFi_PS_Mode_Failure:
+ WiFi_WIND_State.PS_Mode_Failure = WIFI_TRUE;
+ break;
+ case CopyrightInfo:
+ break;
+ case WiFi_BSS_Regained:
+ break;
+ case WiFi_Signal_LOW:
+ WiFi_WIND_State.WiFiSignalLOW = WIFI_TRUE;
+ break;
+ case WiFi_Signal_OK :
+ break;
+ case FW_update:
+ break;
+ case Encryption_key_Not_Recognized:
+ break;
+ case WiFi_Join :
+ WiFi_WIND_State.WiFiJoin = WIFI_TRUE;
+ break;
+ case JOINFAILED :
+ WiFi_WIND_State.WiFiJoinFailed = WIFI_TRUE;
+ break;
+ case WiFi_Scanning :
+ WiFi_WIND_State.WiFiScanning = WIFI_TRUE;
+ break;
+ case SCANBLEWUP:
+ WiFi_WIND_State.WiFiScanBlewUp = WIFI_TRUE;
+ break;
+ case SCANFAILED:
+ WiFi_WIND_State.WiFiScanFailed = WIFI_TRUE;
+ break;
+ case WiFi_Up:
+ WiFi_WIND_State.WiFiUp = WIFI_TRUE;
+ break;
+ case WiFi_Association_Successful:
+ WiFi_WIND_State.WiFiAssociation = WIFI_TRUE;
+ break;
+ case WiFi_Started_MiniAP_Mode:
+ WiFi_WIND_State.WiFiStarted_MiniAPMode = WIFI_TRUE;
+ break;
+ case Start_Failed :
+ WiFi_WIND_State.StartFailed = WIFI_TRUE;
+ break;
+ case WiFi_EXCEPTION :
+ WiFi_WIND_State.WiFiException = WIFI_TRUE;
+ break;
+ case WiFi_Hardware_Started :
+ wifi_ready++;
+ status_flag.WiFi_Enabled = WIFI_TRUE;
+ WiFi_WIND_State.WiFiHWStarted = WIFI_TRUE;
+ /*If this is a start-up after standby*/
+ if(status_flag.trigger_wakeup_callback == WIFI_TRUE)
+ {
+ status_flag.trigger_wakeup_callback = WIFI_FALSE;
+ status_flag.Standby_Enabled = WIFI_FALSE;
+ status_flag.standby_resume_callback = WIFI_TRUE;
+ }
+ break;
+ case WiFi_BSS_LOST:
+ break;
+ case WiFi_Unhandled_Event:
+ break;
+ case Scan_Complete:
+ WiFi_WIND_State.WiFiScanComplete = WIFI_TRUE;
+ status_flag.Scan_Ongoing = WIFI_FALSE;
+ break;
+ case WiFi_UNHANDLED_IND:
+ WiFi_WIND_State.WiFiUnHandledInd = WIFI_TRUE;
+ break;
+ case WiFi_UNHANDLED:
+ break;
+ case WiFi_Powered_Down:
+ status_flag.WiFi_Enabled = WIFI_FALSE;
+ //wifi_ready = 0;
+ WiFi_WIND_State.WiFiHWStarted = WIFI_FALSE;
+ WiFi_WIND_State.WiFiPowerDown = WIFI_TRUE;
+ break;
+ case WiFi_MiniAP_Mode :
+ WiFi_WIND_State.WiFiMiniAPMode = WIFI_TRUE;
+ break;
+ case WiFi_Deauthentication:
+ WiFi_WIND_State.WiFiDeauthentication = WIFI_TRUE;
+ break;
+ case WiFi_Disassociation:
+ WiFi_WIND_State.WiFiDisAssociation = WIFI_TRUE;
+ break;
+ case RX_MGMT:
+ WiFi_WIND_State.WiFiRXMgmt = WIFI_TRUE;
+ break;
+ case RX_DATA:
+ WiFi_WIND_State.WiFiRXData = WIFI_TRUE;
+ break;
+ case RX_UNK:
+ WiFi_WIND_State.WiFiRxUnk = WIFI_TRUE;
+ break;
+ case DOT11_AUTHILLEGAL:
+ break;
+ case Creating_PSK:
+ break;
+ case WPA_Terminated :
+ break;
+ case WPA_Supplicant_Failed:
+ break;
+ case WPA_Handshake_Complete:
+ break;
+ case GPIO_line:
+ break;
+ case Wakeup:
+ break;
+ case Factory_debug:
+ break;
+
+ case SockON_Data_Pending:
+
+ /* +WIND:55:Pending Data:%d:%d */
+ if (status_flag.enable_sock_read == WIFI_TRUE)
+ {
+ #if DEBUG_PRINT
+ printf ("\nAlert!\r\n");
+ #endif
+ status_flag.enable_sock_read = WIFI_FALSE;
+ status_flag.enable_receive_data_chunk = WIFI_FALSE;
+ //break;
+ }
+ sockon_query_id = event_pop_s1->socket_id;
+ if(open_sockets[sockon_query_id])
+ {
+ status_flag.enable_query = WIFI_TRUE;
+ status_flag.stop_event_dequeue = WIFI_TRUE;
+ }
+
+ break;
+
+ case SockON_Server_Socket_Closed:
+ client_socket_close_id = event_pop_s1->socket_id;
+ status_flag.Client_Socket_Close_Cmd = WIFI_TRUE;
+ break;
+
+ case SockD_Pending_Data:
+ number_of_bytes = event_pop_s1->data_length;
+ status_flag.data_pending_sockD = WIFI_TRUE;
+ status_flag.stop_event_dequeue = WIFI_TRUE; //Stop any more event de-queue
+ status_flag.enable_receive_data_chunk = WIFI_TRUE; // read data in chunk now from ring buffer
+
+ if(!status_flag.data_mode)
+ {
+ if(event_pop_s1->wind64_pending_packet_no == 1) { //If this is the first WIND64 pending event de-Q'ed
+ status_flag.switch_by_default_to_command_mode = WIFI_FALSE; //we don't want to switch back to command mode after changing to data mode here
+ WiFi_switch_to_data_mode(); //switch by default
+ }
+ }
+ else //already data is coming from previous WIND:64
+ {
+ process_buffer_index =5;
+ status_flag.enable_sock_read = WIFI_TRUE;//n
+ SockON_Data_Length = number_of_bytes;
+ }
+ break;
+
+ case Incoming_socket_client:
+ status_flag.Client_Connected = WIFI_TRUE;
+ wifi_client_connected=1; //Set this so that the callback can be made to the user
+ break;
+
+ case Outgoing_socket_client:
+ status_flag.Client_Disconnected = WIFI_TRUE;
+ wifi_client_disconnected=0;//Set this so that the callback can be made to the user
+ wifi_client_connected = 0;
+ break;
+
+ case SockD_Dropping_Data:
+ WiFi_WIND_State.WiFiSockdDataLost = WIFI_TRUE;
+ break;
+
+ case Low_Power_Mode_Enabled:
+ status_flag.Low_Power_Enabled = WIFI_TRUE;
+ break;
+
+ case Going_Into_Standby:
+ status_flag.Standby_Enabled = WIFI_TRUE;
+ break;
+
+ case Resuming_From_Standby:
+ status_flag.Standby_Enabled = WIFI_FALSE;
+ status_flag.standby_resume_callback = WIFI_TRUE;
+ break;
+ case Going_Into_DeepSleep:
+ status_flag.Deep_Sleep_Enabled = WIFI_TRUE;
+ break;
+ case Resuming_From_DeepSleep:
+ status_flag.Deep_Sleep_Enabled = WIFI_FALSE;
+ Start_DeepSleep_Timer();
+ break;
+ default:
+ break;
+ }
+}
+
+/**
+* @brief Queue_Http_Get_ Event
+* Queue an HTTP-Request Event (GET/POST)
+* @param hostname hostname for HTTP-GET/POST
+* @param path path for HTTP-GET
+* @param port_number port_number for HTTP-GET
+* @param pURL_path full URL for HTTP-POST
+* @retval None
+*/
+
+void Queue_Http_Event(uint8_t * hostname, uint8_t * path, uint32_t port_number, uint8_t * pURL_path)
+{
+ Wait_For_Sock_Read_To_Complete();
+ if(pURL_path == NULL)
+ {
+ curr_hostname = hostname;
+ curr_path = path;
+ curr_port_number = port_number;
+ }
+ else
+ curr_pURL = pURL_path;
+
+ event_s.event = WIFI_HTTP_EVENT;
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+
+ reset_event(&event_s);
+}
+
+/**
+* @brief Queue_Client_Write_Event
+* Queues a Client Socket write event.
+* @param sock_id socket ID to write to
+* @param DataLength length of the data to be written
+* @param pData pointer to data
+* @retval None
+*/
+void Queue_Client_Write_Event(uint8_t sock_id, uint16_t DataLength, char * pData)
+{
+ Wait_For_Sock_Read_To_Complete();
+ curr_DataLength = DataLength;
+ curr_data = pData;
+ curr_sockID = sock_id;
+ status_flag.enable_client_socket_write = WIFI_TRUE;
+
+ event_s.event = WIFI_CLIENT_SOCKET_WRITE_EVENT;
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+
+ reset_event(&event_s);
+}
+
+/**
+* @brief Queue_Wifi_File_Image_Create_Event
+* Queue a File Image Create Event
+* @param pHostName hostname
+* @param pFileName filename within host
+* @param port_number port number to connect to
+* @retval None
+*/
+void Queue_Wifi_File_Event(uint8_t * pHostName, uint8_t * pFileName, uint32_t port_number)
+{
+ Wait_For_Sock_Read_To_Complete();
+ event_s.event = WIFI_FILE_EVENT;
+ curr_filename = pFileName;
+ curr_hostname = pHostName;
+ curr_port_number = port_number;
+
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+
+ reset_event(&event_s);
+}
+
+/**
+* @brief Queue_Wifi_FW_Update_Event
+* Queue a Firmware update Event
+* @param hostname hostname
+* @param filename_path filename and path within host
+* @param port_number port number to connect to
+* @retval None
+*/
+void Queue_Wifi_FW_Update_Event(uint8_t * hostname, uint8_t * filename_path, uint32_t port_number)
+{
+ Wait_For_Sock_Read_To_Complete();
+ event_s.event = WIFI_FW_UPDATE_EVENT;
+ curr_filename = filename_path;
+ curr_hostname = hostname;
+ curr_port_number = port_number;
+
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+
+ reset_event(&event_s);
+}
+
+void Queue_Client_Open_Event(uint8_t * hostname, uint32_t port_number, uint8_t * protocol)
+{
+ Wait_For_Sock_Read_To_Complete();
+ curr_hostname = hostname;
+ curr_port_number = port_number;
+ curr_protocol = protocol;
+
+ event_s.event = WIFI_CLIENT_SOCKET_OPEN_EVENT;
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+
+ reset_event(&event_s);
+}
+
+void Queue_Client_Close_Event(uint8_t sock_id)
+{
+ Wait_For_Sock_Read_To_Complete();
+
+ event_s.event = WIFI_CLIENT_SOCKET_CLOSE_EVENT;
+ event_s.socket_id = sock_id;
+ __disable_irq();
+ push_eventbuffer(&event_buff, event_s);
+ __enable_irq();
+
+ reset_event(&event_s);
+}
+
+/**
+* @brief Wait_For_Sock_Read_To_Complete
+* Wait till sock is over and the OK of read arrives
+* @param None
+* @retval None
+*/
+void Wait_For_Sock_Read_To_Complete(void)
+{
+ //wait if read is ongoing or read OK is yet to arrive
+ while(status_flag.sock_read_ongoing==WIFI_TRUE || status_flag.prevent_push_OK_event==WIFI_TRUE)
+ {
+ asm("NOP");
+ }
+}
+
+/**
+* @brief Reset_AT_CMD_Buffer
+* Clear USART2 Rx buffer and Wi-Fi AT cmd buffer
+* @param None
+* @retval None
+*/
+void Reset_AT_CMD_Buffer()
+{
+ memset(WiFi_AT_Cmd_Buff, 0x00, sizeof WiFi_AT_Cmd_Buff);
+}
+
+#ifdef USE_FULL_ASSERT
+
+/**
+* @brief Reports the name of the source file and the source line number
+* where the assert_param error has occurred.
+* @param file: pointer to the source file name
+* @param line: assert_param error line source number
+* @retval None
+*/
+void assert_failed(uint8_t* file, uint32_t line)
+{
+ /* User can add his own implementation to report the file name and line number,
+ ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
+
+ /* Infinite loop */
+ while (1)
+ {
+ }
+}
+
+#endif
+
+
+/**
+* @brief search_buffer
+* search for substring in a buffer that contains null
+* @param pSourceBuff : pointer of source buffer
+* sourceBuffLen : length of string buffer
+* pSearchStringBuff : pointer of search string buffer
+* seartchStringLen : length of search string buffer
+* @retval pointer of source buffer
+*/
+char *search_buffer(char *pSourceBuff, uint16_t sourceBuffLen, char *pSearchStringBuff, uint16_t seartchStringLen)
+{ /* warning: O(n^2) */
+ int searchlen = sourceBuffLen - seartchStringLen + 1;
+ for ( ; searchlen-- > 0; pSourceBuff++)
+ if (!memcmp(pSourceBuff, pSearchStringBuff, seartchStringLen))
+ return pSourceBuff;
+ return NULL;
+}
+
+/**
+* @brief Delete_Colon
+* delete colon from input buffer
+* @param input : pointer of input buffer
+* @retval return pointer of updated buffer
+*/
+char* Delete_Colon(char* input)
+{
+ int i,j;
+ char *output=input;
+
+ /* Delete Colon */
+ for (i = 0, j = 0; i<strlen(input); i++,j++)
+ {
+#if 0
+ if (input[i]!=':') && (input[i]!='\r')&& (input[i]!='\n')&& (input[i]!='O')&& (input[i]!='K'))
+ output[j]=input[i];
+ else
+ j--;
+#else
+ if ((input[i] ==':') || (input[i]=='\r')|| (input[i]=='\n')|| (input[i]=='O')|| (input[i]=='K'))
+ j--;
+ else
+ output[j]=input[i];
+ }
+ //output[j]=NULL;
+#endif
+ return output;
+}
+
+/**
+* @brief Read_WiFi_SSID
+* Read SSID of WiFi module store in flash
+* @param string : pointer of SSID
+* @retval return status of AT cmd request
+*/
+WiFi_Status_t Read_WiFi_SSID(char *string)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ char * ssid = "wifi_ssid";
+ char * pStr;
+ /* AT+S.GCFG=wifi_ssid read SSID */
+ Reset_AT_CMD_Buffer();
+
+ /* AT : send AT command */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_CONFIGURATION_VALUE,ssid);
+
+ /*
+ Response :
+ # wifi_ssid = 41:6E:53:53:49:44:00:00:00:00:00:00:00:00:00:00:00:00:00:
+ 00:00:00:00:00:00:00:00:00:00:00:00:00<cr><lf>
+ <cr><lf>OK<cr><lf>
+ */
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+
+ /* find a substring (# wifi_ssid = )inside a USART2_RxBuffer that may contain nulls */
+ uint16_t sourceBuffLen = sizeof(get_cfg_value)-1; /* exclude null terminator from length */
+ char searchStringBuff[] = "# wifi_ssid = ";
+ uint16_t stringBuffLen = sizeof(searchStringBuff)-1; /* exclude null terminator from length */
+ char *res = search_buffer((char *)&get_cfg_value, sourceBuffLen, searchStringBuff, stringBuffLen);
+
+ pStr = (char *) (strstr((const char *)res,"= "));
+ if(pStr != NULL)
+ {
+ strcat( string, (pStr + 2));
+ /* Remove colon,\r,\n,OK strings */
+ memcpy(string, Delete_Colon(string) , 32);
+ }
+ return status;
+}
+
+/**
+* @brief Read_WiFi_SecKey
+* Read Security key of WiFi module store in flash
+* @param string : pointer of Security key
+* @retval return status of AT cmd request
+*/
+WiFi_Status_t Read_WiFi_SecKey(char *string)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ char *seckey = "wifi_wpa_psk_text";
+ char *pStr;
+
+ /* AT+S.GCFG=wifi_ssid read SSID */
+ Reset_AT_CMD_Buffer();
+
+ /* AT : send AT command */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_CONFIGURATION_VALUE,seckey);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+
+
+ /* find a substring (wifi_wpa_psk_text = )inside a USART2_RxBuffer that may contain nulls */
+ uint16_t sourceBuffLen = sizeof(get_cfg_value)-1; /* exclude null terminator from length */
+ char searchStringBuff[] = "wifi_wpa_psk_text = ";
+ uint16_t stringBuffLen = sizeof(searchStringBuff)-1; /* exclude null terminator from length */
+ char *res = search_buffer((char *)&get_cfg_value, sourceBuffLen, searchStringBuff, stringBuffLen);
+
+ pStr = (char *) (strstr((const char *)res,"= "));
+ if(pStr != NULL)
+ {
+ strcat( string, (pStr + 2));
+ /* Remove colon,\r,\n,OK strings */
+ memcpy(string, Delete_Colon(string) , 32);
+ }
+
+ return status;
+}
+
+/**
+* @brief Read_WiFi_Mode
+* Read Wi-Fi mode 0: idle,1 =STA,2 =IBSS,3 =MiniAP
+* @param string : return wifi mode type
+* @retval return status of AT cmd request
+*/
+WiFi_Status_t Read_WiFi_Mode(char *string)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ char *mode = "wifi_mode";
+ char *pStr;
+
+ /* AT+S.GCFG=wifi_mode */
+ Reset_AT_CMD_Buffer();
+
+ /* AT : send AT command */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_CONFIGURATION_VALUE,mode);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+
+ pStr = (char *) strstr((const char *)&get_cfg_value,"wifi_mode = ");
+ if(pStr != NULL)
+ {
+ string[0] = *(pStr + 12) ;
+ }
+
+ return status ;
+}
+
+/**
+* @brief Write_WiFi_SSID
+* Store SSID in flash memory of WiFi module
+* @param string : pointer of SSID
+* @retval return status of AT cmd request
+*/
+WiFi_Status_t Write_WiFi_SSID(char *string)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ Reset_AT_CMD_Buffer();
+
+ /* AT+S.SSIDTXT=abcd <ExampleSSID> //set SSID */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_SSID,string);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+
+ /* AT&W :Save the settings on the flash memory */
+ Reset_AT_CMD_Buffer();
+ Save_Current_Setting();
+
+ return status;
+
+}
+
+
+/**
+* @brief Write_WiFi_SecKey
+* Store security key in flash memory of WiFi module
+* @param string : pointer of security key
+* @retval return status of AT cmd request
+*/
+WiFi_Status_t Write_WiFi_SecKey(char *string)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ Reset_AT_CMD_Buffer();
+
+ /* AT+S.SCFG=wifi_wpa_psk_text,helloworld : set password */
+ sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.SCFG=wifi_wpa_psk_text,%s\r",string);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+
+ /* AT&W :Save the settings on the flash memory */
+ Reset_AT_CMD_Buffer();
+ Save_Current_Setting();
+
+ return status;
+}
+
+
+
+/**
+* @brief PrintErrorMsg
+* Print error message on UART terminal
+* @param None
+* @retval None
+*/
+void PrintErrorMsg (void)
+{
+ Print_Msg("error in AT cmd",sizeof("error in AT cmd"));
+}
+
+/**
+ * @brief Print_Msg
+ * Print messages on UART terminal
+ * @param msgBuff : Contains data that need to be print
+ * @param length : leghth of the data
+ * @retval None
+ */
+void Print_Msg(char * msgBuff,uint8_t length)
+{
+
+}
+
+/**
+* @brief Error_Handler
+* This function is executed in case of error occurrence.
+* @param None
+* @retval None
+*/
+void Error_Handler(void)
+{
+ /* Turn LED2 on */
+ //BSP_LED_On(LED2);
+ //The following while(1) is commented as it prevents standby functionality
+ /*while(1)
+ {
+ //Error if LED2 is slowly blinking (1 sec. period)
+ BSP_LED_Toggle(LED2);
+ HAL_Delay(1000);
+ } */
+ Receive_Data();
+}
+
+
+/**
+* @brief Start_DeepSleep_Timer
+* start the deep sleep timer.
+* @param None
+* @retval void
+*/
+void Start_DeepSleep_Timer(void)
+{
+ status_flag.Deep_Sleep_Timer = WIFI_TRUE;
+ sleep_count = 0;
+}
+
+/**
+* @brief Stop_DeepSleep_Timer
+* stop the deep sleep timer.
+* @param None
+* @retval void
+*/
+void Stop_DeepSleep_Timer()
+{
+ status_flag.Deep_Sleep_Timer = WIFI_FALSE;
+ sleep_count = 0;
+}
+
+#if 0
+/**
+* @brief configure_to_exti
+* Configured the USART Rx pin to EXTI pin to capture standby wakeup interrupt
+* @param None
+* @retval None
+*/
+void configure_to_exti()
+{
+ /*configure the pin*/
+
+ HAL_NVIC_DisableIRQ(USARTx_IRQn);//Disable UART IRQ
+
+ /* USART_RX Pin as EXTI IRQ*/
+ GPIO_InitTypeDef GPIO_InitStruct;
+ GPIO_InitStruct.Pin = WiFi_USART_RX_PIN;
+ GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
+ GPIO_InitStruct.Pull = GPIO_NOPULL;
+ GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
+#if defined (USE_STM32L0XX_NUCLEO) || (USE_STM32F4XX_NUCLEO)
+ GPIO_InitStruct.Alternate = 0;
+#endif
+ HAL_GPIO_Init(WiFi_USART_RX_GPIO_PORT, &GPIO_InitStruct);
+
+ /* Configure the NVIC for EXTI */
+ HAL_NVIC_SetPriority(USARTx_EXTI_IRQn, 3, 0);
+ HAL_NVIC_EnableIRQ(USARTx_EXTI_IRQn);
+}
+#endif
+
+/**
+* @brief WiFi_switch_to_command_mode
+* switch to command mode from data mode
+* @param None
+* @retval None
+*/
+void WiFi_switch_to_command_mode(void)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ /* AT+S.*/
+ Reset_AT_CMD_Buffer();
+
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_DATA_TO_CMD_MODE); //Notice the lower case
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ //nothing to do
+ }
+}
+
+
+/**
+* @brief WiFi_switch_to_data_mode
+* switch to data mode from command mode
+* @param None
+* @retval None
+*/
+void WiFi_switch_to_data_mode(void)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ /* AT+S.*/
+ Reset_AT_CMD_Buffer();
+
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_CMD_TO_DATA_MODE); //Notice the upper case
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ //nothing to do
+ }
+
+}
+
+
+/**
+* @brief Attention_Cmd
+* Attention command
+* @param None
+* @retval WiFi_Status_t : status of AT cmd Request
+*/
+WiFi_Status_t Attention_Cmd()
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ Reset_AT_CMD_Buffer();
+
+ /* AT : send AT command */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_ATTENTION);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+ return status;
+}
+
+
+/**
+* @brief SET_Power_State
+* SET power mode of wifi module
+* @param state : power mode of wi-fi module i.e active,sleep,standby,powersave
+* @retval WiFi_Status_t : status of AT cmd Request
+*/
+WiFi_Status_t SET_Power_State(WiFi_Power_State_t state)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+#if DEBUG_PRINT
+ printf("\r\n >>Soft Reset Wi-Fi module\r\n");
+#endif
+
+ Reset_AT_CMD_Buffer();
+
+ /* AT : send AT command */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_POWER_STATE,state);
+// WiFi_Module_State = Process_Event;
+// WiFi_WIND_State.WiFiReset = WIFI_FALSE;
+ WiFi_WIND_State.WiFiHWStarted = WIFI_FALSE;
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status != WiFi_MODULE_SUCCESS)
+ return status;
+ memset((void*)&WiFi_WIND_State,0x00,sizeof(WiFi_WIND_State)); /*reset the WIND State?*/
+ /* AT+CFUN=1 //Soft reset */
+ while(WiFi_WIND_State.WiFiHWStarted != WIFI_TRUE)
+ {
+ asm("NOP");
+ }
+ return status;
+}
+
+
+/**
+* @brief Display_Help_Text
+* this function will print a list of all commands supported with a brief help text for each cmd
+* @param None
+* @retval WiFi_Status_t : status of AT cmd Request
+*/
+WiFi_Status_t Display_Help_Text()
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ Reset_AT_CMD_Buffer();
+
+ /* AT : send AT command */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_HELP_TEXT);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+ return status;
+}
+
+/**
+* @brief WiFi_Get_IP_address
+* Get the ip address
+* @param ip_addr : pointer to ip address
+* @retval status : status of AT cmd request
+*/
+
+WiFi_Status_t WiFi_Get_IP_Address(uint8_t *ip_addr)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ int cfg_value_length, i;
+
+ /* AT : send AT command */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_STATUS_VALUE,"ip_ipaddr");
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ cfg_value_length = strlen((const char*)get_cfg_value);
+
+ //Optimise the following loop??
+ for(i=7; i<=16; i++)//0th index is always ' ' which we ignore
+ if(get_cfg_value[i] == '\r')//find the first '\r'
+ {
+ get_cfg_value[i] = '\0'; //Terminate the string by NULL
+ break;
+ }
+
+ /* copy user pointer to get_cfg_value */
+ memcpy(ip_addr,&get_cfg_value[1],i);//IP address will have max lenght fixed at 16 bytes (null terminated included).
+ memset(get_cfg_value, 0x00,cfg_value_length);
+ }
+ return status;
+}
+
+/**
+* @brief WiFi_Get_MAC_address
+* Get the MAC address
+* @param ip_addr : pointer to MAC address
+* @retval status : status of AT cmd request
+*/
+
+WiFi_Status_t WiFi_Get_MAC_Address(uint8_t *mac_addr)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ int cfg_value_length;
+
+ /* AT : send AT command */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_CONFIGURATION_VALUE,"nv_wifi_macaddr");
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ cfg_value_length = strlen((const char*)get_cfg_value);
+ get_cfg_value[18] = '\0';//Terminate by NULL
+ /* copy user pointer to get_cfg_value */
+ memcpy(mac_addr,&get_cfg_value[1],18);//IP address will have max lenght fixed at 18 bytes.
+ memset(get_cfg_value, 0x00,cfg_value_length);
+ }
+ return status;
+}
+
+/**
+* @brief GET_Configuration_Value
+* Get a wifi configuration value from the module
+* @param sVar_name : Name of the config variable
+* aValue : value of config variable to be returned to user
+* @retval WiFi_Status_t : status of AT cmd Request
+*/
+WiFi_Status_t GET_Configuration_Value(char* sVar_name,uint32_t *aValue)
+{
+ int cfg_value_length;
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ Reset_AT_CMD_Buffer();
+
+ /* AT : send AT command */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_CONFIGURATION_VALUE,sVar_name);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ cfg_value_length = strlen((const char*)get_cfg_value);
+ memcpy(aValue,get_cfg_value,cfg_value_length); //copy user pointer to get_cfg_value
+ memset(get_cfg_value, 0x00,cfg_value_length);
+ }
+ return status;
+}
+
+/**
+* @brief SET_Configuration_Addr
+* Get a wifi configuration address from the module
+* @param sVar_name : Name of the config variable
+* addr : value of config address to be returned to user
+* @retval WiFi_Status_t : status of AT cmd Request
+*/
+WiFi_Status_t SET_Configuration_Addr(char* sVar_name,char* addr)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ Reset_AT_CMD_Buffer();
+
+ /* AT : send AT command */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_CONFIGURATION_ADDRESS,sVar_name,addr);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+ return status;
+}
+
+/**
+* @brief SET_Configuration_Value
+* SET the value of configuration variable
+* @param sVar_name : Name of the config variable
+* aValue : value of config variable
+* @retval WiFi_Status_t : status of AT cmd Request
+*/
+WiFi_Status_t SET_Configuration_Value(char* sVar_name,uint32_t aValue)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ Reset_AT_CMD_Buffer();
+
+ /* AT : send AT command */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_CONFIGURATION_VALUE,sVar_name,(int)aValue);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+ return status;
+}
+
+/**
+* @brief SET_SSID
+* SET SSID in flash memory of Wi-Fi module
+* @param ssid : pointer of SSID
+* @retval WiFi_Status_t : status of AT cmd Request
+*/
+WiFi_Status_t SET_SSID(char* ssid)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ Reset_AT_CMD_Buffer();
+
+ /* AT+S.SSIDTXT=abcd <ExampleSSID> */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_SSID,ssid);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+ return status;
+}
+
+
+/**
+* @brief SET_WiFi_SecKey
+* SET wifi security key
+* @param seckey : pointer of security key
+* @retval WiFi_Status_t : status of AT cmd Request
+*/
+WiFi_Status_t SET_WiFi_SecKey(char* seckey)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ Reset_AT_CMD_Buffer();
+
+ /* AT+S.SCFG=wifi_wpa_psk_text,helloworld : set password */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_SEC_KEY,seckey);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+ return status;
+}
+
+
+/**
+* @brief Restore_Default_Setting
+* Restore the factory default values of the configuration variables
+* and writes them to non volatile storage
+* @param None
+* @retval WiFi_Status_t : status of AT cmd Request
+*/
+WiFi_Status_t Restore_Default_Setting()
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ //Reset_AT_CMD_Buffer();
+
+ /* AT&F: restore default setting */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_RESTORE_DEFAULT_SETTING);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+ return status;
+
+}
+
+/**
+* @brief Save_Current_Setting
+* Store the current RAM-based setting to non-volatile storage
+* @param None
+* @retval WiFi_Status_t : status of AT cmd Request
+*/
+WiFi_Status_t Save_Current_Setting()
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ Reset_AT_CMD_Buffer();
+
+ /* AT&W :Save the settings on the flash memory */
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SAVE_CURRENT_SETTING);
+
+ status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
+ if(status == WiFi_MODULE_SUCCESS)
+ {
+ status = USART_Receive_AT_Resp(Process_Event);
+ }
+ return status;
+}
+
+
+/**
+* @brief ResetBuffer
+* Reset receive data/indication msg buffer
+* @param None
+* @retval None
+*/
+void ResetBuffer()
+{
+
+}
+
+
+/**
+* @brief config_init_value
+* initalize config values before reset
+* @param sVar_name : Name of the config variable
+* aValue : value of config variable
+* @retval None
+*/
+WiFi_Status_t config_init_value(char* sVar_name,uint8_t aValue)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_CONFIGURATION_VALUE,sVar_name,aValue);
+ /*if(HAL_UART_Transmit(&UartWiFiHandle, (uint8_t *)WiFi_AT_Cmd_Buff, strlen((char*)WiFi_AT_Cmd_Buff),1000)!= HAL_OK)
+ {
+ Error_Handler();
+ return WiFi_HAL_UART_ERROR;
+ }*/
+
+ status = WaitForResponse(AT_RESP_LEN_OK);
+ return status;
+}
+
+/**
+* @brief config_init_addr
+* initalize config strings/addresses before reset
+* @param sVar_name : Name of the config variable
+* addr : value of config address to be returned to user
+* @retval None
+*/
+WiFi_Status_t config_init_addr(char* sVar_name,char* addr)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ Reset_AT_CMD_Buffer();
+ sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_CONFIGURATION_ADDRESS,sVar_name,addr);
+ /*if(HAL_UART_Transmit(&UartWiFiHandle, (uint8_t *)WiFi_AT_Cmd_Buff, strlen((char*)WiFi_AT_Cmd_Buff),1000)!= HAL_OK)
+ {
+ Error_Handler();
+ return WiFi_HAL_UART_ERROR;
+ }*/
+
+ status = WaitForResponse(AT_RESP_LEN_OK);
+ return status;
+
+}
+
+
+/**
+* @brief WaitForResponse
+* Wait for OK response
+* @param alength length of the data to be received
+* @retval None
+*/
+WiFi_Status_t WaitForResponse(uint16_t alength)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ if(alength <= RxBufferSize)
+ {
+ /*if(HAL_UART_Receive(&UartWiFiHandle, (uint8_t *)USART_RxBuffer, alength,5000)!= HAL_OK)
+ {
+ Error_Handler();
+ return WiFi_HAL_UART_ERROR;
+ }*/
+
+ if(((strstr((const char *)&USART_RxBuffer,"OK"))) == NULL)
+ {
+ return WiFi_AT_CMD_RESP_ERROR;
+ }
+
+ }
+
+ return status;
+}
+/**** Wi-Fi indication call back *************/
+__weak void ind_wifi_warning(WiFi_Status_t warning_code)
+{
+}
+
+__weak void ind_wifi_error(WiFi_Status_t error_code)
+{
+}
+
+__weak void ind_wifi_connection_error(WiFi_Status_t status_code)
+{
+}
+
+__weak void ind_wifi_connected(void)
+{
+}
+
+__weak void ind_wifi_ap_ready(void)
+{
+}
+
+__weak void ind_wifi_ap_client_joined(uint8_t * client_mac_address)
+{
+}
+
+__weak void ind_wifi_ap_client_left(uint8_t * client_mac_address)
+{
+}
+
+__weak void ind_wifi_on(void)
+{
+}
+
+__weak void ind_wifi_packet_lost(WiFi_Status_t status_code)
+{
+}
+
+__weak void ind_wifi_gpio_changed(void)
+{
+}
+
+__weak void ind_wifi_socket_data_received(uint8_t socket_id, uint8_t * data_ptr, uint32_t message_size, uint32_t chunk_size)
+{
+}
+
+__weak void ind_wifi_socket_client_remote_server_closed(uint8_t * socketID)
+{
+}
+
+__weak void ind_wifi_socket_server_data_lost(void)
+{
+}
+
+__weak void ind_socket_server_client_joined(void)
+{
+}
+
+__weak void ind_socket_server_client_left(void)
+{
+}
+
+__weak void ind_wifi_http_data_available(uint8_t * data_ptr,uint32_t message_size)
+{
+}
+
+__weak void ind_wifi_file_data_available(uint8_t * data_ptr)
+{
+}
+__weak void ind_wifi_resuming(void)
+{
+}
+
+
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+
+/**
+ * @}
+ */
+
+/******************* (C) COPYRIGHT 2015 STMicroelectronics *****END OF FILE****/
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf_API/SpwfSADevice.cpp Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,398 @@
+/* mbed Microcontroller Library
+* Copyright (c) 2006-2013 ARM Limited
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/**
+ ******************************************************************************
+ * @file SpwfSADevice.cpp
+ * @author STMicroelectronics
+ * @brief Implementation of SpwfSADevice class for Wi-Fi mbed
+ ******************************************************************************
+ * @copy
+ *
+ * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+ * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
+ * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
+ * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
+ * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
+ * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ *
+ * <h2><center>© COPYRIGHT 2016 STMicroelectronics</center></h2>
+ ******************************************************************************
+ */
+
+
+#include "SpwfSADevice.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void Rx_irq_handler(void);
+void Wifi_scheduler(void);
+void Wifi_ticker(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+extern void setSpwfSADevice(SpwfSADevice * dev);
+
+SpwfSADevice::SpwfSADevice(PinName tx, PinName rx, PinName rst, PinName wkup, PinName rts):
+ uart_(tx,rx),
+ term_(SERIAL_TX, SERIAL_RX),
+ wakeup_(wkup, PIN_INPUT, PullNone, 0),
+ rst_(rst, PIN_INPUT, PullNone, 1),
+ rts_(rts, PIN_INPUT, PullUp, 0)
+{
+ setSpwfSADevice(this);
+ sync_wait_signal = false;
+}
+
+SpwfSADevice::~SpwfSADevice(void)
+{
+ //de-constructor
+}
+
+int32_t SpwfSADevice::init(void)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ Timer timer;
+
+ timer.start();
+ rst_.output();
+ wakeup_.output();
+ rts_.output();
+
+ term_.baud(9600);
+ term_.format(8, SerialBase::None, 1);
+
+ uart_.baud(115200);
+ uart_.format(8, SerialBase::None, 1);
+ uart_.set_flow_control(SerialBase::RTS, PA_12, NC);//RTSCTS
+ uart_.attach(Rx_irq_handler, SerialBase::RxIrq);
+
+ config.power=wifi_active;
+ config.power_level=high;
+ config.dhcp=on;//use DHCP IP address
+
+ /*Initialize the tickers*/
+ wifi_isr.attach_us(Wifi_ticker, 1000); //decreasing the time period to 1ms may be causing overrun issue with UART?\
+ //UART error not evident but characters are sometimes missing in pipeline(ring_buffer)\
+ //specifically in the +WIND:25:WiFi Association with 'STM' successful WIND (why specifically this?)
+
+ wifi_callback.attach_us(Wifi_scheduler, 2000);//How low can we go?
+
+ sync_wait_signal = false;
+ status = wifi_init(&config);
+ if(status!=WiFi_MODULE_SUCCESS)
+ {
+ return -1;
+ }
+
+ while(!sync_wait_signal)
+ {
+ if (timer.read_ms() > _timeout) {
+ return -1;
+ }
+ __NOP();
+ }
+
+ return 0;
+}
+
+int32_t SpwfSADevice::connect(char * ssid, char * sec_key, WiFi_Priv_Mode priv_mode)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+ Timer timer;
+
+ timer.start();
+ sync_wait_signal = false;
+ status = wifi_connect(ssid, sec_key, priv_mode);
+ if(status!=WiFi_MODULE_SUCCESS)
+ {
+ return -1;
+ }
+
+ while(!sync_wait_signal)
+ {
+ if (timer.read_ms() > _timeout) {
+ return -1;
+ }
+ __NOP();
+ }
+
+ return 0;
+}
+
+int32_t SpwfSADevice::disconnect()
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ status = wifi_disconnect();//will set to Idle Mode
+ if(status!=WiFi_MODULE_SUCCESS)
+ {
+ return -1;
+ }
+
+ return 0;
+}
+
+const char *SpwfSADevice::getIPAddress()
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ status = WiFi_Get_IP_Address((uint8_t *)_ip_buffer);
+
+ if(status!=WiFi_MODULE_SUCCESS)
+ {
+ return NULL;
+ } else
+ return _ip_buffer;
+}
+
+const char *SpwfSADevice::getMACAddress()
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ status = WiFi_Get_MAC_Address((uint8_t *)_mac_buffer);
+
+ if(status!=WiFi_MODULE_SUCCESS)
+ {
+ return NULL;
+ } else
+ return _mac_buffer;
+}
+
+int32_t SpwfSADevice::socket_client_open(uint8_t * hostname, uint32_t port_number, uint8_t * protocol, uint8_t * sock_id)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ //Timeout of synchronous functions?
+ status = wifi_socket_client_open(hostname, port_number, protocol, sock_id);
+ if(status!=WiFi_MODULE_SUCCESS)
+ {
+ *sock_id = 9;//make sure socket id is not set(set to out of bounds of SPWFSA_SOCKET_COUNT range)
+ return -1;
+ }
+
+ return 0;
+}
+
+
+int32_t SpwfSADevice::socket_client_write(uint8_t sock_id, uint16_t DataLength,char * pData)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ status = wifi_socket_client_write(sock_id, DataLength, pData);
+ //map error to enum ns_error_t
+
+ if(status!=WiFi_MODULE_SUCCESS)
+ {
+ return -1;
+ }
+ return 0;
+}
+
+
+int32_t SpwfSADevice::socket_client_recv(uint8_t sock_id, uint16_t RecvLength,char * pData)
+{
+ Timer timer;
+
+ timer.start();
+ bytes_to_read = RecvLength;
+
+ __disable_irq();
+ bytes_read=0;
+ sync_wait_signal = false;
+ recv_buff = (uint8_t*)pData;
+ __enable_irq();
+
+ while(!sync_wait_signal)
+ {
+ if (timer.read_ms() > _timeout) {
+ //debug_print("\r\n SpwfSADevice:: Timeout!\r\n");
+ sync_wait_signal = true;
+ //if(bytes_read==0) return -1;//return error if no bytes are read!
+ return bytes_read;//return amount of data arrived so far
+ //when do we return NS_ERROR_WOULD_BLOCK??
+ }
+ __NOP();
+ }
+
+ return bytes_read;
+
+}
+
+void SpwfSADevice::network_scan(wifi_scan *scan_result, uint16_t max_scan_number)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ status = wifi_network_scan(scan_result, max_scan_number);
+ if(status!=WiFi_MODULE_SUCCESS)
+ {
+ return;
+ }
+}
+
+void SpwfSADevice::http_get(uint8_t * hostname, uint8_t * path, uint32_t port_number)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ status = wifi_http_get((uint8_t *)hostname, (uint8_t *)path, port_number);
+ if(status!=WiFi_MODULE_SUCCESS)
+ {
+ return;
+ }
+}
+
+void SpwfSADevice::http_post(uint8_t * url_path)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ status = wifi_http_post(url_path);
+ if(status!=WiFi_MODULE_SUCCESS)
+ {
+ return;
+ }
+}
+
+void SpwfSADevice::signal_data_receive(uint8_t socket_id, uint8_t * data_ptr, uint32_t message_size, uint32_t chunk_size)
+{
+ char debug_str[10];
+ //Data will be copied or returned to user only if there is a pending request
+ //Copy data to pData
+ if(recv_buff && !sync_wait_signal)
+ {
+ if((bytes_read + message_size)<= bytes_to_read)
+ {
+ memcpy(recv_buff + bytes_read, data_ptr, message_size);//only copy bytes_to_read asked by user//rest of the data is lost!!
+ bytes_read += message_size;
+ }
+ else
+ {
+ uint32_t x_size = (bytes_read + message_size) - bytes_to_read;
+ memcpy(recv_buff + bytes_read, data_ptr, message_size-x_size);
+ bytes_read += (message_size-x_size);
+ }
+
+ if(bytes_read >= bytes_to_read)
+ {
+ __disable_irq();
+ sync_wait_signal = true;
+ __enable_irq();
+ }
+ }
+ else
+ {
+ debug_print("\r\n Socket:: Data Dropped: ");
+ sprintf((char*)debug_str,"%d\r\n",message_size);
+ debug_print(debug_str);
+ __disable_irq();
+ sync_wait_signal = true;
+ __enable_irq();
+ }
+
+}
+
+void SpwfSADevice::signal_synch_wait(WiFi_Status_t code)
+{
+ if(code == WiFi_DISASSOCIATION)
+ {
+ //do nothing
+ }
+ else
+ {
+ __disable_irq();
+ sync_wait_signal = true;
+ __enable_irq();
+ }
+}
+
+int32_t SpwfSADevice::socket_client_close(uint8_t sock_close_id)
+{
+ WiFi_Status_t status = WiFi_MODULE_SUCCESS;
+
+ status = wifi_socket_client_close(sock_close_id);
+ //map error to enum ns_error_t
+ if(status!=WiFi_MODULE_SUCCESS)
+ {
+ return -1;
+ }
+
+ return 0;
+}
+
+
+void SpwfSADevice::spwf_attach_irq(wifi_bool attach)
+{
+ if(attach)
+ {
+ uart_.attach(Rx_irq_handler, SerialBase::RxIrq);
+ }
+ else
+ {
+ uart_.attach(NULL, SerialBase::RxIrq);
+ }
+}
+
+void SpwfSADevice::spwf_send(const char * cmd, uint16_t size)
+{
+ Timer timer;
+ int i;
+ //timer.start();
+
+ //uart_.puts(cmd);//string may contain '\0' character in between hence not used
+
+ for(i=0;i<size;i++)
+ {
+ uart_.putc(cmd[i]);
+ //if (timer.read_ms() > _timeout) {
+ //return -1;
+ //}
+ }
+}
+
+char SpwfSADevice::spwf_get(void)
+{
+ return(uart_.getc());
+}
+
+void SpwfSADevice::spwf_wakeup(int wake)
+{
+ wakeup_.write(wake);
+}
+
+void SpwfSADevice::spwf_reset(int reset)
+{
+ rst_.write(reset);
+}
+
+void SpwfSADevice::spwf_rts(int rts)
+{
+ rts_.write(rts);
+}
+
+int SpwfSADevice::spwf_read_rts()
+{
+ return(rts_.read());
+}
+
+void SpwfSADevice::debug_print(const char * string)
+{
+ term_.puts(string);
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf_API/SpwfSADevice.h Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,115 @@
+/* mbed Microcontroller Library
+* Copyright (c) 2006-2013 ARM Limited
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/**
+ ******************************************************************************
+ * @file SpwfSADevice.h
+ * @author STMicroelectronics
+ * @brief Header File of SpwfSADevice class for Wi-Fi mbed
+ ******************************************************************************
+ * @copy
+ *
+ * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+ * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
+ * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
+ * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
+ * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
+ * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ *
+ * <h2><center>© COPYRIGHT 2016 STMicroelectronics</center></h2>
+ ******************************************************************************
+ */
+
+#ifndef __SPWFSA_DEVICE_H__
+#define __SPWFSA_DEVICE_H__
+
+
+#include "mbed.h"
+#include "RawSerial.h"
+#include "Ticker.h"
+#include "Timer.h"
+#include "wifi_interface.h"
+
+
+/*Class describing the SPWF Device*/
+class SpwfSADevice
+{
+
+public:
+ SpwfSADevice(PinName tx, PinName rx, PinName rst, PinName wkup, PinName rts);
+ ~SpwfSADevice(void);
+
+ int32_t init(void);
+ int32_t connect(char * ssid, char * sec_key, WiFi_Priv_Mode priv_mode);
+ int32_t disconnect(void);
+ const char *getIPAddress();
+ const char *getMACAddress();
+ void network_scan(wifi_scan *scan_result, uint16_t max_scan_number);
+
+ int32_t socket_client_open(uint8_t * hostname, uint32_t port_number, uint8_t * protocol, uint8_t * sock_id);
+ int32_t socket_client_write(uint8_t sock_id, uint16_t DataLength,char * pData);
+ int32_t socket_client_recv(uint8_t sock_id, uint16_t RecvLength,char * pData);
+ int32_t socket_client_close(uint8_t sock_close_id);
+ void socket_client_security(uint8_t* tls_mode, uint8_t* root_ca_server, uint8_t* client_cert, uint8_t* client_key, uint8_t* client_domain, uint32_t tls_epoch_time);
+
+ void socket_server_open(uint32_t port_number, uint8_t * protocol);
+ void socket_server_write(uint16_t DataLength,char * pData);
+ void socket_server_close(void);
+
+ void http_get(uint8_t * hostname, uint8_t * path, uint32_t port_number);
+ void http_post(uint8_t * url_path);
+
+ /*These functions should be pure virtual functions for ppl to derive and implement there own stuff*/
+ char spwf_get(void);
+ void spwf_send(const char * cmd, uint16_t size);
+ void spwf_wakeup(int wake);
+ void spwf_reset(int reset);
+ void spwf_rts(int rts);
+ void spwf_attach_irq(wifi_bool attach);
+ int spwf_read_rts();
+
+ const char *getVersion(void);
+ void waitForEvent(void);
+ void signal_data_receive(uint8_t socket_id, uint8_t * data_ptr, uint32_t message_size, uint32_t chunk_size);
+ void signal_synch_wait(WiFi_Status_t code);
+ bool getIsInitialized(void);
+ void setTimeout(int timeout) {
+ _timeout = timeout;
+ }
+ void debug_print(const char * string);
+
+private:
+ bool isInitialized;
+
+ RawSerial uart_;
+ RawSerial term_;
+ Ticker wifi_isr;
+ Ticker wifi_callback;
+ DigitalInOut wakeup_;
+ DigitalInOut rst_;
+ DigitalInOut rts_;
+ wifi_config config;
+ bool sync_wait_signal;
+ uint16_t bytes_read;
+ uint16_t bytes_to_read;
+ uint8_t * recv_buff;
+ int _timeout;
+
+ char _ip_buffer[16];
+ char _mac_buffer[18];
+};
+
+#endif
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf_API/utils/ItfTranslator.cpp Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,151 @@
+/* mbed Microcontroller Library
+* Copyright (c) 2006-2013 ARM Limited
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/**
+ ******************************************************************************
+ * @file ItfTranslator.cpp
+ * @author STMicroelectronics
+ * @brief Wrapper Functions for access to SPWFSADevice class/vice-versa
+ ******************************************************************************
+ * @copy
+ *
+ * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+ * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
+ * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
+ * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
+ * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
+ * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ *
+ * <h2><center>© COPYRIGHT 2016 STMicroelectronics</center></h2>
+ ******************************************************************************
+ */
+
+#include "SpwfSADevice.h"
+#include "ItfTranslator.h"
+
+SpwfSADevice * device;
+
+void setSpwfSADevice(SpwfSADevice * dev);
+
+void setSpwfSADevice(SpwfSADevice * dev)
+ {
+ device = dev;
+ }
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void callSpwfSADevice_init(void* object)
+ {
+ //static_cast<SpwfSADevice*>(object)->init();
+ device->init();
+ return;
+ }
+
+char callSpwfSADevice_getChar(void* object)
+ {
+ return(device->spwf_get());
+ }
+
+void callSpwfSADevice_write(void* object, const char * cmd, uint16_t size)
+ {
+ device->spwf_send(cmd, size);
+ }
+
+void callSpwfSADevice_wakeup(void* object, int wake)
+{
+ device->spwf_wakeup(wake);
+}
+
+void callSpwfSADevice_reset(void* object, int reset)
+{
+ device->spwf_reset(reset);
+}
+
+void callSpwfSADevice_rts(void* object, int rts)
+{
+ device->spwf_rts(rts);
+}
+
+int callSpwfSADevice_read_rts(void* object)
+{
+ return(device->spwf_read_rts());
+}
+
+void callSpwfSADevice_attach(wifi_bool attach)
+{
+ device->spwf_attach_irq(attach);
+}
+
+void callSpwfSADevice_debug(void* object, const char * string)
+{
+ device->debug_print(string);
+}
+
+void destroySpwfSADevice()
+ {
+
+ }
+
+/*Callbacks implementation*/
+
+void ind_wifi_on()
+{
+ device->signal_synch_wait(WiFi_MODULE_SUCCESS);
+}
+
+void ind_wifi_connected()
+{
+ device->signal_synch_wait(WiFi_MODULE_SUCCESS);
+}
+
+void ind_wifi_connection_error(WiFi_Status_t code)
+{
+ switch(code)
+ {
+ case WiFi_DISASSOCIATION:
+ device->signal_synch_wait(code);
+ break;
+ case WiFi_DE_AUTH:
+ break;
+ default:
+ break;
+ }
+}
+
+void ind_wifi_socket_data_received(uint8_t socket_id, uint8_t * data_ptr, uint32_t message_size, uint32_t chunk_size)
+{
+ device->signal_data_receive(socket_id, data_ptr, message_size, chunk_size);
+}
+
+void ind_wifi_http_data_available(uint8_t * data_ptr, uint32_t message_size)
+{
+ //spwf->debug("\r\nrx>>\r\n");
+ //memcpy(user_buffer, data_ptr, 511);
+}
+
+void ind_wifi_socket_client_remote_server_closed(uint8_t * socket_closed_id)
+{
+ device->signal_synch_wait(WiFi_MODULE_SUCCESS);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Spwf_API/utils/ItfTranslator.h Thu Apr 14 06:14:14 2016 +0000
@@ -0,0 +1,62 @@
+/* mbed Microcontroller Library
+* Copyright (c) 2006-2013 ARM Limited
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/**
+ ******************************************************************************
+ * @file ItfTranslator.h
+ * @author STMicroelectronics
+ * @brief Header file for wrapper Functions for access to SPWFSADevice class/vice-versa
+ ******************************************************************************
+ * @copy
+ *
+ * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+ * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
+ * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
+ * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
+ * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
+ * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ *
+ * <h2><center>© COPYRIGHT 2016 STMicroelectronics</center></h2>
+ ******************************************************************************
+ */
+
+
+#ifndef __INTERMEDIATE_H__
+#define __INTERMEDIATE_H__
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void callSpwfSADevice_init(void* object);
+char callSpwfSADevice_getChar(void* object);
+void callSpwfSADevice_write(void* object, const char * cmd, uint16_t size);
+void callSpwfSADevice_wakeup(void* object, int wake);
+void callSpwfSADevice_reset(void* object, int reset);
+void callSpwfSADevice_rts(void* object, int rts);
+void callSpwfSADevice_attach(wifi_bool attach);
+void callSpwfSADevice_debug(void* object, const char * string);
+void destroySpwfSADevice(void);
+int callSpwfSADevice_read_rts(void* object);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
+
--- a/WIFI_API/SpwfSADevice.cpp Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,398 +0,0 @@
-/* mbed Microcontroller Library
-* Copyright (c) 2006-2013 ARM Limited
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-/**
- ******************************************************************************
- * @file SpwfSADevice.cpp
- * @author STMicroelectronics
- * @brief Implementation of SpwfSADevice class for Wi-Fi mbed
- ******************************************************************************
- * @copy
- *
- * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
- * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
- * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
- * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
- * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
- * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
- *
- * <h2><center>© COPYRIGHT 2016 STMicroelectronics</center></h2>
- ******************************************************************************
- */
-
-
-#include "SpwfSADevice.h"
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void Rx_irq_handler(void);
-void Wifi_scheduler(void);
-void Wifi_ticker(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-extern void setSpwfSADevice(SpwfSADevice * dev);
-
-SpwfSADevice::SpwfSADevice(PinName tx, PinName rx, PinName rst, PinName wkup, PinName rts):
- uart_(tx,rx),
- term_(SERIAL_TX, SERIAL_RX),
- wakeup_(wkup, PIN_INPUT, PullNone, 0),
- rst_(rst, PIN_INPUT, PullUp, 1),
- rts_(rts, PIN_INPUT, PullUp, 0)
-{
- setSpwfSADevice(this);
- sync_wait_signal = false;
-}
-
-SpwfSADevice::~SpwfSADevice(void)
-{
- //de-constructor
-}
-
-int32_t SpwfSADevice::init(void)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- Timer timer;
-
- timer.start();
- rst_.output();
- wakeup_.output();
- rts_.output();
-
- term_.baud(9600);
- term_.format(8, SerialBase::None, 1);
-
- uart_.baud(115200);
- uart_.format(8, SerialBase::None, 1);
- uart_.set_flow_control(SerialBase::RTS, PA_12, NC);//RTSCTS
- uart_.attach(Rx_irq_handler, SerialBase::RxIrq);
-
- config.power=wifi_active;
- config.power_level=high;
- config.dhcp=on;//use DHCP IP address
-
- /*Initialize the tickers*/
- wifi_isr.attach_us(Wifi_ticker, 1000); //decreasing the time period to 1ms may be causing overrun issue with UART?\
- //UART error not evident but characters are sometimes missing in pipeline(ring_buffer)\
- //specifically in the +WIND:25:WiFi Association with 'STM' successful WIND (why specifically this?)
-
- wifi_callback.attach_us(Wifi_scheduler, 2000);//How low can we go?
-
- sync_wait_signal = false;
- status = wifi_init(&config);
- if(status!=WiFi_MODULE_SUCCESS)
- {
- return -1;
- }
-
- while(!sync_wait_signal)
- {
- if (timer.read_ms() > _timeout) {
- return -1;
- }
- __NOP();
- }
-
- return 0;
-}
-
-int32_t SpwfSADevice::connect(char * ssid, char * sec_key, WiFi_Priv_Mode priv_mode)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- Timer timer;
-
- timer.start();
- sync_wait_signal = false;
- status = wifi_connect(ssid, sec_key, priv_mode);
- if(status!=WiFi_MODULE_SUCCESS)
- {
- return -1;
- }
-
- while(!sync_wait_signal)
- {
- if (timer.read_ms() > _timeout) {
- return -1;
- }
- __NOP();
- }
-
- return 0;
-}
-
-int32_t SpwfSADevice::disconnect()
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- status = wifi_disconnect();//will set to Idle Mode
- if(status!=WiFi_MODULE_SUCCESS)
- {
- return -1;
- }
-
- return 0;
-}
-
-const char *SpwfSADevice::getIPAddress()
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- status = WiFi_Get_IP_Address((uint8_t *)_ip_buffer);
-
- if(status!=WiFi_MODULE_SUCCESS)
- {
- return NULL;
- } else
- return _ip_buffer;
-}
-
-const char *SpwfSADevice::getMACAddress()
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- status = WiFi_Get_MAC_Address((uint8_t *)_mac_buffer);
-
- if(status!=WiFi_MODULE_SUCCESS)
- {
- return NULL;
- } else
- return _mac_buffer;
-}
-
-int32_t SpwfSADevice::socket_client_open(uint8_t * hostname, uint32_t port_number, uint8_t * protocol, uint8_t * sock_id)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- //Timeout of synchronous functions?
- status = wifi_socket_client_open(hostname, port_number, protocol, sock_id);
- if(status!=WiFi_MODULE_SUCCESS)
- {
- *sock_id = 9;//make sure socket id is not set(set to out of bounds of SPWFSA_SOCKET_COUNT range)
- return -1;
- }
-
- return 0;
-}
-
-
-int32_t SpwfSADevice::socket_client_write(uint8_t sock_id, uint16_t DataLength,char * pData)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- status = wifi_socket_client_write(sock_id, DataLength, pData);
- //map error to enum ns_error_t
-
- if(status!=WiFi_MODULE_SUCCESS)
- {
- return -1;
- }
- return 0;
-}
-
-
-int32_t SpwfSADevice::socket_client_recv(uint8_t sock_id, uint16_t RecvLength,char * pData)
-{
- Timer timer;
-
- timer.start();
- bytes_to_read = RecvLength;
-
- __disable_irq();
- bytes_read=0;
- sync_wait_signal = false;
- recv_buff = (uint8_t*)pData;
- __enable_irq();
-
- while(!sync_wait_signal)
- {
- if (timer.read_ms() > _timeout) {
- //debug_print("\r\n SpwfSADevice:: Timeout!\r\n");
- sync_wait_signal = true;
- //if(bytes_read==0) return -1;//return error if no bytes are read!
- return bytes_read;//return amount of data arrived so far
- //when do we return NS_ERROR_WOULD_BLOCK??
- }
- __NOP();
- }
-
- return bytes_read;
-
-}
-
-void SpwfSADevice::network_scan(wifi_scan *scan_result, uint16_t max_scan_number)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- status = wifi_network_scan(scan_result, max_scan_number);
- if(status!=WiFi_MODULE_SUCCESS)
- {
- return;
- }
-}
-
-void SpwfSADevice::http_get(uint8_t * hostname, uint8_t * path, uint32_t port_number)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- status = wifi_http_get((uint8_t *)hostname, (uint8_t *)path, port_number);
- if(status!=WiFi_MODULE_SUCCESS)
- {
- return;
- }
-}
-
-void SpwfSADevice::http_post(uint8_t * url_path)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- status = wifi_http_post(url_path);
- if(status!=WiFi_MODULE_SUCCESS)
- {
- return;
- }
-}
-
-void SpwfSADevice::signal_data_receive(uint8_t socket_id, uint8_t * data_ptr, uint32_t message_size, uint32_t chunk_size)
-{
- char debug_str[10];
- //Data will be copied or returned to user only if there is a pending request
- //Copy data to pData
- if(recv_buff && !sync_wait_signal)
- {
- if((bytes_read + message_size)<= bytes_to_read)
- {
- memcpy(recv_buff + bytes_read, data_ptr, message_size);//only copy bytes_to_read asked by user//rest of the data is lost!!
- bytes_read += message_size;
- }
- else
- {
- uint32_t x_size = (bytes_read + message_size) - bytes_to_read;
- memcpy(recv_buff + bytes_read, data_ptr, message_size-x_size);
- bytes_read += (message_size-x_size);
- }
-
- if(bytes_read >= bytes_to_read)
- {
- __disable_irq();
- sync_wait_signal = true;
- __enable_irq();
- }
- }
- else
- {
- debug_print("\r\n Socket:: Data Dropped: ");
- sprintf((char*)debug_str,"%d\r\n",message_size);
- debug_print(debug_str);
- __disable_irq();
- sync_wait_signal = true;
- __enable_irq();
- }
-
-}
-
-void SpwfSADevice::signal_synch_wait(WiFi_Status_t code)
-{
- if(code == WiFi_DISASSOCIATION)
- {
- //do nothing
- }
- else
- {
- __disable_irq();
- sync_wait_signal = true;
- __enable_irq();
- }
-}
-
-int32_t SpwfSADevice::socket_client_close(uint8_t sock_close_id)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- status = wifi_socket_client_close(sock_close_id);
- //map error to enum ns_error_t
- if(status!=WiFi_MODULE_SUCCESS)
- {
- return -1;
- }
-
- return 0;
-}
-
-
-void SpwfSADevice::spwf_attach_irq(wifi_bool attach)
-{
- if(attach)
- {
- uart_.attach(Rx_irq_handler, SerialBase::RxIrq);
- }
- else
- {
- uart_.attach(NULL, SerialBase::RxIrq);
- }
-}
-
-void SpwfSADevice::spwf_send(const char * cmd, uint16_t size)
-{
- Timer timer;
- int i;
- //timer.start();
-
- //uart_.puts(cmd);//string may contain '\0' character in between hence not used
-
- for(i=0;i<size;i++)
- {
- uart_.putc(cmd[i]);
- //if (timer.read_ms() > _timeout) {
- //return -1;
- //}
- }
-}
-
-char SpwfSADevice::spwf_get(void)
-{
- return(uart_.getc());
-}
-
-void SpwfSADevice::spwf_wakeup(int wake)
-{
- wakeup_.write(wake);
-}
-
-void SpwfSADevice::spwf_reset(int reset)
-{
- rst_.write(reset);
-}
-
-void SpwfSADevice::spwf_rts(int rts)
-{
- rts_.write(rts);
-}
-
-int SpwfSADevice::spwf_read_rts()
-{
- return(rts_.read());
-}
-
-void SpwfSADevice::debug_print(const char * string)
-{
- term_.puts(string);
-}
-
--- a/WIFI_API/SpwfSADevice.h Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,115 +0,0 @@
-/* mbed Microcontroller Library
-* Copyright (c) 2006-2013 ARM Limited
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-/**
- ******************************************************************************
- * @file SpwfSADevice.h
- * @author STMicroelectronics
- * @brief Header File of SpwfSADevice class for Wi-Fi mbed
- ******************************************************************************
- * @copy
- *
- * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
- * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
- * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
- * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
- * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
- * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
- *
- * <h2><center>© COPYRIGHT 2016 STMicroelectronics</center></h2>
- ******************************************************************************
- */
-
-#ifndef __SPWFSA_DEVICE_H__
-#define __SPWFSA_DEVICE_H__
-
-
-#include "mbed.h"
-#include "RawSerial.h"
-#include "Ticker.h"
-#include "Timer.h"
-#include "wifi_interface.h"
-
-
-/*Class describing the SPWF Device*/
-class SpwfSADevice
-{
-
-public:
- SpwfSADevice(PinName tx, PinName rx, PinName rst, PinName wkup, PinName rts);
- ~SpwfSADevice(void);
-
- int32_t init(void);
- int32_t connect(char * ssid, char * sec_key, WiFi_Priv_Mode priv_mode);
- int32_t disconnect(void);
- const char *getIPAddress();
- const char *getMACAddress();
- void network_scan(wifi_scan *scan_result, uint16_t max_scan_number);
-
- int32_t socket_client_open(uint8_t * hostname, uint32_t port_number, uint8_t * protocol, uint8_t * sock_id);
- int32_t socket_client_write(uint8_t sock_id, uint16_t DataLength,char * pData);
- int32_t socket_client_recv(uint8_t sock_id, uint16_t RecvLength,char * pData);
- int32_t socket_client_close(uint8_t sock_close_id);
- void socket_client_security(uint8_t* tls_mode, uint8_t* root_ca_server, uint8_t* client_cert, uint8_t* client_key, uint8_t* client_domain, uint32_t tls_epoch_time);
-
- void socket_server_open(uint32_t port_number, uint8_t * protocol);
- void socket_server_write(uint16_t DataLength,char * pData);
- void socket_server_close(void);
-
- void http_get(uint8_t * hostname, uint8_t * path, uint32_t port_number);
- void http_post(uint8_t * url_path);
-
- /*These functions should be pure virtual functions for ppl to derive and implement there own stuff*/
- char spwf_get(void);
- void spwf_send(const char * cmd, uint16_t size);
- void spwf_wakeup(int wake);
- void spwf_reset(int reset);
- void spwf_rts(int rts);
- void spwf_attach_irq(wifi_bool attach);
- int spwf_read_rts();
-
- const char *getVersion(void);
- void waitForEvent(void);
- void signal_data_receive(uint8_t socket_id, uint8_t * data_ptr, uint32_t message_size, uint32_t chunk_size);
- void signal_synch_wait(WiFi_Status_t code);
- bool getIsInitialized(void);
- void setTimeout(int timeout) {
- _timeout = timeout;
- }
- void debug_print(const char * string);
-
-private:
- bool isInitialized;
-
- RawSerial uart_;
- RawSerial term_;
- Ticker wifi_isr;
- Ticker wifi_callback;
- DigitalInOut wakeup_;
- DigitalInOut rst_;
- DigitalInOut rts_;
- wifi_config config;
- bool sync_wait_signal;
- uint16_t bytes_read;
- uint16_t bytes_to_read;
- uint8_t * recv_buff;
- int _timeout;
-
- char _ip_buffer[16];
- char _mac_buffer[18];
-};
-
-#endif
\ No newline at end of file
--- a/intermediate.cpp Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,164 +0,0 @@
-/* mbed Microcontroller Library
-* Copyright (c) 2006-2013 ARM Limited
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-/**
- ******************************************************************************
- * @file intermediate.c
- * @author STMicroelectronics
- * @brief Wrapper Functions for access to SPWFSADevice class/vice-versa
- ******************************************************************************
- * @copy
- *
- * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
- * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
- * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
- * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
- * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
- * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
- *
- * <h2><center>© COPYRIGHT 2016 STMicroelectronics</center></h2>
- ******************************************************************************
- */
-
-#include "SpwfSADevice.h"
-
-SpwfSADevice * device;
-
-void setSpwfSADevice(SpwfSADevice * dev);
-
-void setSpwfSADevice(SpwfSADevice * dev)
- {
- device = dev;
- }
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-
-void callSpwfSADevice_init(void* object);
-char callSpwfSADevice_getChar(void* object);
-void callSpwfSADevice_write(void* object, const char * cmd, uint16_t size);
-void callSpwfSADevice_wakeup(void* object, int wake);
-void callSpwfSADevice_reset(void* object, int reset);
-void callSpwfSADevice_rts(void* object, int rts);
-void callSpwfSADevice_attach(wifi_bool attach);
-void callSpwfSADevice_debug(void* object, const char * string);
-void destroySpwfSADevice(void);
-int callSpwfSADevice_read_rts(void* object);
-
-
-void callSpwfSADevice_init(void* object)
- {
- //static_cast<SpwfSADevice*>(object)->init();
- device->init();
- return;
- }
-
-char callSpwfSADevice_getChar(void* object)
- {
- return(device->spwf_get());
- }
-
-void callSpwfSADevice_write(void* object, const char * cmd, uint16_t size)
- {
- device->spwf_send(cmd, size);
- }
-
-void callSpwfSADevice_wakeup(void* object, int wake)
-{
- device->spwf_wakeup(wake);
-}
-
-void callSpwfSADevice_reset(void* object, int reset)
-{
- device->spwf_reset(reset);
-}
-
-void callSpwfSADevice_rts(void* object, int rts)
-{
- device->spwf_rts(rts);
-}
-
-int callSpwfSADevice_read_rts(void* object)
-{
- return(device->spwf_read_rts());
-}
-
-void callSpwfSADevice_attach(wifi_bool attach)
-{
- device->spwf_attach_irq(attach);
-}
-
-void callSpwfSADevice_debug(void* object, const char * string)
-{
- device->debug_print(string);
-}
-
-void destroySpwfSADevice()
- {
-
- }
-
-/*Callbacks implementation*/
-
-void ind_wifi_on()
-{
- device->signal_synch_wait(WiFi_MODULE_SUCCESS);
-}
-
-void ind_wifi_connected()
-{
- device->signal_synch_wait(WiFi_MODULE_SUCCESS);
-}
-
-void ind_wifi_connection_error(WiFi_Status_t code)
-{
- switch(code)
- {
- case WiFi_DISASSOCIATION:
- device->signal_synch_wait(code);
- break;
- case WiFi_DE_AUTH:
- break;
- default:
- break;
- }
-}
-
-void ind_wifi_socket_data_received(uint8_t socket_id, uint8_t * data_ptr, uint32_t message_size, uint32_t chunk_size)
-{
- device->signal_data_receive(socket_id, data_ptr, message_size, chunk_size);
-}
-
-void ind_wifi_http_data_available(uint8_t * data_ptr, uint32_t message_size)
-{
- //spwf->debug("\r\nrx>>\r\n");
- //memcpy(user_buffer, data_ptr, 511);
-}
-
-void ind_wifi_socket_client_remote_server_closed(uint8_t * socket_closed_id)
-{
- device->signal_synch_wait(WiFi_MODULE_SUCCESS);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-
-
--- a/intermediate.h Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
- // intermediate.h
-
-#ifndef __INTERMEDIATE_H__
-#define __INTERMEDIATE_H__
-
-
- #ifdef __cplusplus
- extern "C" {
- #endif
-
-
-
- #ifdef __cplusplus
- extern }
- #endif
-
-
-#endif
-
--- a/spwf/inc/wifi_const.h Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,131 +0,0 @@
-/**
- ******************************************************************************
- * @file wifi_const.h
- * @author Central LAB
- * @version V2.0.0
- * @date 10-February-2016
- * @brief Describes the constants and defines in X-CUBE-WIFI1
- ******************************************************************************
- * @attention
- *
- * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * 3. Neither the name of STMicroelectronics nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************
- */
-
-/** @defgroup NUCLEO_WIFI_INTERFACE_Private_Defines
- * @{
- */
-
-#define EPOCH_TIME 1453727657//Human time (GMT): Mon, 25 Jan 2016 13:14:17 GMT
-#define EXTI_CONF_TIMER 1900 //millisec
-#define PROCESS_WIFI_TIMER 1
-#define SLEEP_RESUME_PREVENT 2000
-#define RINGBUF_SIZE 2048//1024//3072//2048
-#define MAX_BUFFER_GLOBAL 512
-#define MAX_PREFETCH_BUFFER 20
-#define MAX_WIFI_SCAN_NETWORK 256
-#define RxBufferSize 64
-#define AT_RESP_LEN_OK 6 //\r\nOK\r\n
-#define AT_RESP_LEN_GPIOR 21//GPIO n = 0,in\r\n\r\nOK\r\n
-#define AT_RESP_HELP_TEXT_LEN 512
-#define AT_ATTENTION "AT\r"
-#define AT_WIFI_ENABLE "AT+S.WIFI=%d\r"
-#define AT_GET_CONFIGURATION_VALUE "AT+S.GCFG=%s\r"
-#define AT_SET_CONFIGURATION_VALUE "AT+S.SCFG=%s,%d\r"
-#define AT_SET_CONFIGURATION_ADDRESS "AT+S.SCFG=%s,%s\r"
-//#define AT_GET_SSID "AT&F\r"
-#define AT_SET_SSID "AT+S.SSIDTXT=%s\r"
-#define AT_SET_SEC_KEY "AT+S.SCFG=wifi_wpa_psk_text,%s\r"
-#define AT_RESTORE_DEFAULT_SETTING "AT&F\r"
-#define AT_SAVE_CURRENT_SETTING "AT&W\r"
-#define AT_SET_POWER_STATE "AT+CFUN=%d\r"
-#define AT_HELP_TEXT "AT+S.HELP\r"
-#define AT_RESET_MSG "\r\n+WIND:2:Reset\r\n"
-
-#define UNDEFINE_LENGTH 0xFFFF
-#define AT_WiFi_SCAN "AT+S.SCAN\r"
-#define AT_SOCKET_OPEN "AT+S.SOCKON=%s,%d,%s,ind\r"
-#define AT_SOCKET_WRITE "AT+S.SOCKW=%d,%d\r"
-#define AT_SOCKET_READ "AT+S.SOCKR=%d,%d\r"
-#define AT_SOCKET_CLOSE "AT+S.SOCKC=%d\r"
-#define AT_SERVER_SOCKET_OPEN "AT+S.SOCKD=%d,%s,ind\r" //with indication option
-#define AT_SERVER_SOCKET_CLOSE "AT+S.SOCKD=0\r"
-#define AT_QUERY_PENDING_DATA "AT+S.SOCKQ=%d\r"
-#define AT_DISPLAY_FILE_NAME "AT+S.FSL\r"
-#define AT_DISPLAY_FILE_CONTENT "AT+S.FSP=/%s\r"
-#define AT_CREATE_NEW_HTML_FILE "AT+S.FSC=/%s,%d\r"
-#define AT_APPEND_FILE "AT+S.FSA=/%s,%d\r"
-#define AT_DELETE_FILE "AT+S.FSD=/%s\r"
-#define AT_DOWNLOAD_IMAGE_FILE "AT+S.HTTPDFSUPDATE=%s,/%s,%d\r"
-#define AT_ERASE_FLASH_MEMORY "AT+S.HTTPDFSERASE\r"
-
-#define AT_CMD_TO_DATA_MODE "AT+S.\r"
-#define AT_DATA_TO_CMD_MODE "at+s." /* NOT \r */
-#define AT_HTTPPOST_REQUEST "AT+S.HTTPPOST=%s\r"
-#define AT_HTTPD "AT+S.HTTPD=%d\r"
-#define AT_GET_STATUS_VALUE "AT+S.STS=%s\r"
-
-/************Wi-Fi Config Variables**************/
-
-#define BLINK_LED "blink_led"
-#define LOCALECHO1 "localecho1"
-#define CONSOLE1_HWFC "console1_hwfc"
-#define CONSOLE1_SPEED "console1_speed"
-#define WIFI_PRIV_MODE "wifi_priv_mode"
-#define IP_USE_DHCP_SERVER "ip_use_dhcp"
-#define IP_USE_HTTPD "ip_use_httpd"
-#define WIFI_MODE "wifi_mode"
-#define WIFI_WPA_SECURITY "wifi_wpa_psk_text"
-#define WIFI_CHANNEL_NUMBER "wifi_channelnum"
-#define WIFI_IP_ADDRESS "ip_ipaddr"
-#define WIFI_IP_DEFAULT_GATEWAY "ip_gw"
-#define WIFI_IP_DNS "ip_dns"
-#define WIFI_IP_NETMASK "ip_netmask"
-#define WIFI_IP_HOSTNAME "ip_hostname"
-#define WIFI_IP_APDOMAINNAME "ip_apdomainname"
-#define WIFI_IP_APREDIRECT "ip_apredirect"
-#define WIFI_IP_HTTP_TIMEOUT "ip_http_get_recv_timeout"
-#define WIFI_IP_DHCP_TIMEOUT "ip_dhcp_timeout"
-
-#define WIFI_SLEEP_ENABLED "sleep_enabled"
-#define WIFI_HT_MODE "wifi_ht_mode"
-#define WIFI_OPR_RATE_MASK "wifi_opr_rate_mask"
-#define WIFI_POWERSAVE "wifi_powersave"
-#define WIFI_OPERATIONAL_MODE "wifi_operational_mode"
-#define WIFI_LISTEN_INTERVAL "wifi_listen_interval"
-#define WIFI_BEACON_WAKEUP "wifi_beacon_wakeup"
-#define WIFI_STANDBY_ENABLED "standby_enabled"
-#define WIFI_STANDBY_TIME "standby_time"
-#define WIFI_TX_POWER "wifi_tx_power"
-#define WIFI_IBSS_IP_ADDR "192.168.2.100"
-#define WIFI_IBSS_DEFAULT_GATEWAY "192.168.2.1"
-#define WIFI_IBSS_IP_DNS_ADDR "192.168.2.1"
-#define WIFI_IBSS_IP_MASK "255.255.255.0"
-#define WIFI_IP_USE_DHCP 0
-
-/**
- * @}
- */
--- a/spwf/inc/wifi_driver.h Wed Apr 13 11:34:07 2016 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,40 +0,0 @@ - -#include "wifi_module.h" - -extern volatile Wifi_Status_Var status_flag; - -extern wifi_bool Uartx_Rx_Processing; -extern buffer_td big_buff; -extern wifi_bool resume_receive_data; -extern wifi_bool AT_Cmd_Processing; -extern WiFi_AT_CMD_Response_t WiFi_Module_State; -extern volatile WiFi_WIND_State_TypeDef WiFi_WIND_State; -extern volatile uint8_t wifi_connected; -extern wifi_bool WiFi_Enabled; -extern wifi_bool Standby_Enabled; -extern wifi_bool Deep_Sleep_Enabled; -extern uint8_t WiFi_AT_Cmd_Buff[]; - -extern void callSpwfSADevice_init(void* object); -extern char callSpwfSADevice_getChar(void* object); -extern void callSpwfSADevice_write(void* object, const char * cmd, uint16_t size); -extern void callSpwfSADevice_wakeup(void* object, int wake); -extern void callSpwfSADevice_reset(void* object, int reset); -extern void callSpwfSADevice_rts(void* object, int rts); -extern void callSpwfSADevice_attach(wifi_bool attach); -extern void callSpwfSADevice_debug(void* object, const char * string); -extern void destroySpwfSADevice(void); -extern int callSpwfSADevice_read_rts(void* object); - -extern void Stop_Timer(void); -extern void Start_Timer(void); - -extern void Wifi_TIM_Handler(void); -extern void Wifi_SysTick_Isr(void); - -void *spwf_dev; - -void Wifi_scheduler(void); -void Rx_irq_handler(void); -void Wifi_ticker(void); -
--- a/spwf/inc/wifi_interface.h Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,332 +0,0 @@
-/**
- ******************************************************************************
- * @file wifi_interface.h
- * @author Central LAB
- * @version V2.0.0
- * @date 10-February-2016
- * @brief Header file for X-CUBE-WIFI1 API
- ******************************************************************************
- * @attention
- *
- * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * 3. Neither the name of STMicroelectronics nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************
- */
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __WIFI_INTERFACE_H
-#define __WIFI_INTERFACE_H
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-/* Includes ------------------------------------------------------------------*/
-#include<stdint.h>
-
- /** @addtogroup MIDDLEWARES
-* @{
-*/
-
-
-/** @addtogroup NUCLEO_WIFI_API
- * @brief Wi-Fi_interface API
- * @{
- */
-
-
-/** @addtogroup NUCLEO_WIFI_API_Private_Macros
- * @{
- */
-
-
- /**
- * @}
- */
-
-
-/** @addtogroup NUCLEO_WIFI_API_Private_Variables
- * @{
- */
-/* Private variables ---------------------------------------------------------*/
-
-
-/* Exported macro ------------------------------------------------------------*/
-#define _ARG6(_0, _1, _2, _3, _4, _5, _6, ...) _6
-#define NARG6(...) _ARG6(__VA_ARGS__, 6, 5, 4, 3, 2, 1, 0)
-#define _FIVE_OR_SIX_ARGS_5(NAME, a, b, c, d, e) a, b, c, d, e, 1453727657
-#define _FIVE_OR_SIX_ARGS_6(NAME, a, b, c, d, e, f) a, b, c, d, e, f
-#define __FIVE_OR_SIX_ARGS(NAME, N, ...) _FIVE_OR_SIX_ARGS_ ## N (NAME, __VA_ARGS__)
-#define _FIVE_OR_SIX_ARGS(NAME, N, ...) __FIVE_OR_SIX_ARGS(NAME, N, __VA_ARGS__)
-#define FIVE_OR_SIX_ARGS(NAME, ...) NAME(_FIVE_OR_SIX_ARGS(NAME, NARG6(__VA_ARGS__), __VA_ARGS__))
-
-#define wifi_socket_client_security(...) FIVE_OR_SIX_ARGS(wifi_socket_client_security, __VA_ARGS__)
-
-/* Exported constants --------------------------------------------------------*/
-#define GPIO_IN "in"
-#define GPIO_OUT "out"
-
-#define GPIO_Off '0'
-#define GPIO_Rising 'R'
-#define GPIO_Falling 'F'
-#define GPIO_Both 'B'
-
-typedef enum GpioWriteValue
-{
- GPIO_OFF = 0,
- GPIO_ON,
-} GpioWriteValue;
-
-typedef enum GpioPin
-{
- GPIO_PIN0 = 0,
- GPIO_PIN1,
- GPIO_PIN2,
- GPIO_PIN3,
- GPIO_PIN4,
- GPIO_PIN5,
- GPIO_PIN6,
- GPIO_PIN7,
- GPIO_PIN8,
- GPIO_PIN9,
- GPIO_PIN10,
- GPIO_PIN11,
- GPIO_PIN12,
- GPIO_PIN13,
- GPIO_PIN14,
- GPIO_PIN15
-} GpioPin;
-
-typedef enum wifi_bool
-{
- WIFI_FALSE = 0,
- WIFI_TRUE = 1,
- Undefine = 0xFF
-} wifi_bool;
-
-typedef enum WiFi_Priv_Mode
-{
- None = 0,
- WEP = 1,
- WPA_Personal = 2,
-} WiFi_Priv_Mode;
-
-/********** Wi-Fi Error *************/
-typedef enum WiFi_Status_t
-{
- WiFi_MODULE_SUCCESS = 0,
- WiFi_TIME_OUT_ERROR = 1,
- WiFi_MODULE_ERROR,
- WiFi_HAL_OK,
- WiFi_NOT_SUPPORTED,
- WiFi_NOT_READY,
- WiFi_SCAN_FAILED,
- WiFi_AT_CMD_BUSY,
- WiFi_SSID_ERROR,
- WiFi_SecKey_ERROR,
- WiFi_CONFIG_ERROR,
- WiFi_STA_MODE_ERROR,
- WiFi_AP_MODE_ERROR,
- WiFi_AT_CMD_RESP_ERROR,
- WiFi_AT_FILE_LENGTH_ERROR,
- WiFi_HAL_UART_ERROR,
- WiFi_IN_LOW_POWER_ERROR,
- WiFi_HW_FAILURE_ERROR,
- WiFi_HEAP_TOO_SMALL_WARNING,
- WiFi_STACK_OVERFLOW_ERROR,
- WiFi_HARD_FAULT_ERROR,
- WiFi_MALLOC_FAILED_ERROR,
- WiFi_INIT_ERROR,
- WiFi_POWER_SAVE_WARNING,
- WiFi_SIGNAL_LOW_WARNING,
- WiFi_JOIN_FAILED,
- WiFi_SCAN_BLEWUP,
- WiFi_START_FAILED_ERROR,
- WiFi_EXCEPTION_ERROR,
- WiFi_DE_AUTH,
- WiFi_DISASSOCIATION,
- WiFi_UNHANDLED_IND_ERROR,
- WiFi_RX_MGMT,
- WiFi_RX_DATA,
- WiFi_RX_UNK
-} WiFi_Status_t;
-
-typedef enum power_mode
-{
- wifi_active = 0,
- wifi_reactive = 1,
- wifi_sleep = 2,
-} power_mode;
-
-typedef enum tx_power_level
-{
- low = 0,
- medium = 1,
- high = 2,
- max = 3,
-} tx_power_level;
-
-typedef enum dhcp_mode
-{
- off = 0,
- on = 1,
- custom = 2,
-} dhcp_mode;
-
-typedef struct wifi_security
-{
- wifi_bool wpa;
- wifi_bool wpa2;
- wifi_bool wps;
-} wifi_security;
-
-typedef struct wifi_scan
-{
- uint8_t channel_num;
- int rssi;
- char ssid[30];
- wifi_security sec_type;
-} wifi_scan;
-
-typedef struct wifi_config
-{
- wifi_bool ht_mode;
- power_mode power;
- tx_power_level power_level;
- dhcp_mode dhcp;
- char* ip_addr;
- char* netmask_addr;
- char* gateway_addr;
- char* dns_addr;
- char* host_name;
- wifi_bool web_server;
- char* ap_domain_name;
- char* ap_config_page_name;
- uint32_t http_timeout;
- uint32_t dhcp_timeout;
- uint8_t wifi_region;
- uint32_t wifi_baud_rate;
-} wifi_config;
-
-/* Exported functions ------------------------------------------------------- */
-
-#ifdef WIFI_USE_VCOM
-void wifi_vcom(void);
-#endif
-
-WiFi_Status_t wifi_init(wifi_config* config);
-WiFi_Status_t wifi_restore(void);
-WiFi_Status_t wifi_enable(wifi_bool enable);
-WiFi_Status_t wifi_disconnect(void);
-WiFi_Status_t wifi_connect(char * ssid, char * sec_key, WiFi_Priv_Mode priv_mode);
-WiFi_Status_t wifi_ap_start(uint8_t * ssid, uint8_t channel_num);
-WiFi_Status_t wifi_adhoc_create(uint8_t * ssid, WiFi_Priv_Mode priv_mode);
-WiFi_Status_t wifi_network_scan(wifi_scan *scan_result, uint16_t max_scan_number);
-void wifi_reset(void);
-
-/******** Wi-Fi Socket Function **********/
-WiFi_Status_t wifi_socket_client_open(uint8_t * hostname, uint32_t port_number, uint8_t * protocol, uint8_t * sock_id);
-WiFi_Status_t wifi_socket_client_write(uint8_t sock_id, uint16_t DataLength,char * pData);
-WiFi_Status_t wifi_socket_client_close(uint8_t sock_close_id);
-WiFi_Status_t wifi_socket_client_security(uint8_t* tls_mode, uint8_t* root_ca_server, uint8_t* client_cert, uint8_t* client_key, uint8_t* client_domain, uint32_t tls_epoch_time);
-
-/********* Wi-Fi Socket Server ********/
-WiFi_Status_t wifi_socket_server_open(uint32_t port_number, uint8_t * protocol);
-WiFi_Status_t wifi_socket_server_write(uint16_t DataLength,char * pData);
-WiFi_Status_t wifi_socket_server_close(void);
-
-/*** FileSystem Request ***********/
-WiFi_Status_t wifi_file_create(char *pFileName,uint16_t alength,char * databuff);
-WiFi_Status_t wifi_file_delete(char * pFileName);
-WiFi_Status_t wifi_file_list(void);
-WiFi_Status_t wifi_file_show(uint8_t * pFileName);
-WiFi_Status_t wifi_file_image_create(uint8_t * pHostName,uint8_t * pFileName, uint32_t port_number);
-WiFi_Status_t wifi_file_erase_external_flash(void);
-
-/*** HTTP File Request ***********/
-WiFi_Status_t wifi_http_get(uint8_t * hostname, uint8_t * path, uint32_t port_number);
-WiFi_Status_t wifi_http_post(uint8_t * url_path);
-
-WiFi_Status_t wifi_fw_update(uint8_t * hostname, uint8_t * filename_path, uint32_t port_number);
-
-/*** Power Configuration **********/
-WiFi_Status_t wifi_standby(uint8_t arg_standby_time);
-WiFi_Status_t wifi_wakeup(wifi_bool enable);
-
-/*** GPIO Configuration **********/
-uint8_t wifi_gpio_init(GpioPin pin, char* dir, char irq);
-uint8_t wifi_gpio_read(GpioPin pin, uint8_t *val, uint8_t *dir);
-uint8_t wifi_gpio_write(GpioPin pin, GpioWriteValue value);
-
-WiFi_Status_t WiFi_Get_IP_Address(uint8_t *ip_addr);
-WiFi_Status_t WiFi_Get_MAC_Address(uint8_t *mac_addr);
-
-void UART_Configuration(uint32_t baud_rate);
-void GPIO_Configuration(void);
-void Timer_Config(void);
-void UART_Msg_Gpio_Init(void);
-void USART_PRINT_MSG_Configuration(uint32_t baud_rate);
-
-/******** Wi-Fi Indication User Callback: For User to implement *********/
-void ind_wifi_warning(WiFi_Status_t warning_code);
-void ind_wifi_error(WiFi_Status_t error_code);
-void ind_wifi_connection_error(WiFi_Status_t status_code);
-void ind_wifi_connected(void);
-void ind_wifi_ap_ready(void);
-void ind_wifi_ap_client_joined(uint8_t * client_mac_address);
-void ind_wifi_ap_client_left(uint8_t * client_mac_address);
-void ind_wifi_on(void);
-void ind_wifi_packet_lost(WiFi_Status_t status_code);
-void ind_wifi_gpio_changed(void);
-void ind_wifi_socket_data_received(uint8_t socket_id, uint8_t * data_ptr, uint32_t message_size, uint32_t chunk_size);
-void ind_wifi_socket_client_remote_server_closed(uint8_t * socketID);
-void ind_wifi_socket_server_data_lost(void);
-void ind_socket_server_client_joined(void);
-void ind_socket_server_client_left(void);
-void ind_wifi_http_data_available(uint8_t * data_ptr,uint32_t message_size);
-void ind_wifi_file_data_available(uint8_t * data_ptr);
-void ind_wifi_resuming(void);
-
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
- }
-#endif
-
-#endif /* __WIFI_INTERFACE_H */
--- a/spwf/inc/wifi_module.h Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,379 +0,0 @@
- /**
- ******************************************************************************
- * @file wifi_module.h
- * @author Central LAB
- * @version V2.0.0
- * @date 10-February-2016
- * @brief Header file for Wi-Fi module
- ******************************************************************************
- * @attention
- *
- * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * 3. Neither the name of STMicroelectronics nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************
- */
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __WIFI_MODULE_H
-#define __WIFI_MODULE_H
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-/* Includes ------------------------------------------------------------------*/
-//#include "stm32_spwf_wifi.h"
-#include "wifi_const.h"
-#include "wifi_interface.h"
-#include "event_buffer.h"
-
-/** @addtogroup MIDDLEWARES
-* @{
-*/
-
-
-/** @addtogroup NUCLEO_WIFI_MODULE
- * @brief Wi-Fi_driver modules
- * @{
- */
-
-
-/** @addtogroup NUCLEO_WIFI_MODULE_Private_Macros
- * @{
- */
-
-//#define USART3_INT_MODE
-#define USART3_POLLING_MODE
- /**
- * @}
- */
-
-
-/** @addtogroup NUCLEO_WIFI_MODULE_Private_Variables
- * @{
- */
-/* Private variables ---------------------------------------------------------*/
-
-/* Exported macro ------------------------------------------------------------*/
-
-/* Exported constants --------------------------------------------------------*/
-
-typedef struct Wifi_Status_Var
-{
- wifi_bool Single_Digit_Indication;
- wifi_bool WiFi_Enabled;
- wifi_bool http_req_pending;
- wifi_bool WiFi_Configuration_Done;
- wifi_bool Timer_Running;
- wifi_bool resume_receive_data;
- wifi_bool enable_dequeue;
- wifi_bool stop_event_dequeue;
- wifi_bool Standby_Timer_Running;
- wifi_bool trigger_wakeup_callback;
- wifi_bool Deep_Sleep_Enabled;
- wifi_bool Standby_Enabled;
- wifi_bool Low_Power_Enabled;
- wifi_bool command_mode;
- wifi_bool data_mode;
- wifi_bool Scan_Ongoing;
- wifi_bool AT_Cmd_Ongoing;
- wifi_bool AT_Cmd_Processing;
- wifi_bool Uartx_Rx_Processing;
- wifi_bool Client_Connected;
- wifi_bool Client_Disconnected;
- wifi_bool switch_by_default_to_command_mode;
- wifi_bool start_sock_read;
- wifi_bool enable_receive_data_chunk;
- wifi_bool data_pending_sockD;
- wifi_bool enable_sock_read;
- wifi_bool enable_query;
- wifi_bool Set_AT_Cmd_Response_False;
- wifi_bool enable_fw_update_read;
- wifi_bool Q_Contains_Message;
- wifi_bool Q_Contains_Data;
- wifi_bool enable_receive_http_response;
- wifi_bool enable_receive_file_response;
- wifi_bool enable_receive_wifi_scan_response;
- wifi_bool prevent_push_OK_event;
- wifi_bool client_socket_close_ongoing;
- wifi_bool prevent_push_WIFI_event;
- wifi_bool sock_read_ongoing;
- wifi_bool enable_client_socket_write;
- wifi_bool event_deQ_x_wind64;
- wifi_bool do_not_reset_push_WIFI_event;
- wifi_bool message_pending;
- wifi_bool Pending_SockON_Callback;
- wifi_bool Pending_SockD_Callback;
- wifi_bool SockON_Server_Closed_Callback;
- wifi_bool Client_Socket_Close_Cmd;
- wifi_bool standby_resume_callback;
- wifi_bool HTTP_Data_available;
- wifi_bool FILE_Data_available;
- wifi_bool AT_Response_Received;
- wifi_bool Deep_Sleep_Timer;
- wifi_bool Timeout_Timer;
- wifi_bool Deep_Sleep_Callback;
-} Wifi_Status_Var;
-
-/******* Wi-Fi Configuration Setting Parameters *****************/
-
-typedef enum WiFi_Mode_TypeDef {
- WiFi_IDLE_MODE =0,
- WiFi_STA_MODE,
- WiFi_IBSS_MODE,
- WiFi_MiniAP_MODE
-} WiFi_Mode_TypeDef;
-
-
-/********** Wi-Fi Indications*************/
-
-#pragma pack(1)
-typedef struct WiFi_WIND_State_TypeDef
-{
- wifi_bool ConsoleActive;
- wifi_bool WiFiPowerON;
- wifi_bool WiFiReset;
- wifi_bool WiFiHWFailure;
- wifi_bool HardFault;
- wifi_bool StackOverflow;
- wifi_bool MallocFailed;
- wifi_bool InitFailure;
- wifi_bool StartFailed;
- wifi_bool PS_Mode_Failure;
- wifi_bool HeapTooSmall;
- wifi_bool WiFiSignalLOW;
- wifi_bool WiFiJoin;
- wifi_bool WiFiScanning;
- wifi_bool WiFiUp;
- wifi_bool WiFiAssociation;
- wifi_bool WiFiStarted_MiniAPMode;
- wifi_bool WiFiAPClientJoined;
- wifi_bool WiFiAPClientLeft;
- wifi_bool WiFiException;
- wifi_bool WiFiHWStarted;
- wifi_bool WiFiScanComplete;
- wifi_bool WiFiPowerDown;
- wifi_bool WiFiMiniAPMode;
- wifi_bool WiFiDeauthentication;
-
- /*Wifi Connection Errors*/
- wifi_bool WiFiJoinFailed;
- wifi_bool WiFiScanBlewUp;
- wifi_bool WiFiScanFailed;
- wifi_bool WiFiDeAuth;
- wifi_bool WiFiDisAssociation;
-
- /*Wifi packet lost INDs*/
- wifi_bool WiFiUnHandledInd;
- wifi_bool WiFiRXMgmt;
- wifi_bool WiFiRXData;
- wifi_bool WiFiRxUnk;
- wifi_bool WiFiSockdDataLost;
-
-} WiFi_WIND_State_TypeDef;
-#pragma pack()
-
-typedef enum {
- Console_Active = 0,
- Poweron = 1,
- WiFi_Reset,
- Watchdog_Running,
- Heap_Too_Small,
- WiFi_Hardware_Dead = 5,
- Watchdog_Terminating,
- SysTickConfigure,
- Hard_Fault =8,
- StackOverflow,
- MallocFailed,
- Error,
- WiFi_PS_Mode_Failure = 12,
- CopyrightInfo,
- WiFi_BSS_Regained = 14,
- WiFi_Signal_LOW = 15,
- WiFi_Signal_OK = 16,
- FW_update = 17,
- Encryption_key_Not_Recognized,
- WiFi_Join = 19,
- JOINFAILED = 20,
- WiFi_Scanning = 21,
- SCANBLEWUP,
- SCANFAILED,
- WiFi_Up = 24,
- WiFi_Association_Successful = 25,
- WiFi_Started_MiniAP_Mode = 26,
- Start_Failed = 27,
- WiFi__MiniAP_Associated = 28,
- WiFi_EXCEPTION = 31,
- WiFi_Hardware_Started = 32,
- WiFi_BSS_LOST,
- WiFi_Unhandled_Event,
- Scan_Complete = 35,
- WiFi_UNHANDLED_IND,
- WiFi_UNHANDLED,
- WiFi_Powered_Down,
- WiFi_MiniAP_Mode = 39,
- WiFi_Deauthentication = 40,
- WiFi_Disassociation,
- RX_MGMT,
- RX_DATA,
- RX_UNK,
- DOT11_AUTHILLEGAL,
- Creating_PSK = 46,
- WPA_Terminated = 49,
- WPA_Supplicant_Failed,
- WPA_Handshake_Complete = 51,
- GPIO_line,
- Wakeup,
- Factory_debug,
- SockON_Data_Pending = 55,
- Remote_Configuration = 57,
- SockON_Server_Socket_Closed = 58,
- In_Command_Mode = 59,
- In_Data_Mode = 60,
- Incoming_socket_client = 61,
- Outgoing_socket_client = 62,
- SockD_Dropping_Data = 63,
- SockD_Pending_Data = 64,
- Low_Power_Mode_Enabled = 66,
- Going_Into_Standby = 67,
- Resuming_From_Standby = 68,
- Going_Into_DeepSleep = 69,
- Resuming_From_DeepSleep = 70,
- WiFi_MiniAP_Disassociated = 72,
- Undefine_Indication = 0xFF
-} WiFi_Indication_t;
-
-typedef enum WiFi_Indication_t WiFi_Indication;
-
-typedef enum WiFi_Power_State_t
-{
- Active_State,
- PowerSave_State,
- Sleep_State=3,
- StandBy_State=4
-} WiFi_Power_State_t;
-
-typedef enum WiFi_AT_CMD_Response_t {
- Process_Event =0,
-} WiFi_AT_CMD_Response_t;
-
-#ifdef WIFI_USE_VCOM
-void console_input(void);
-#endif
-
-void PowerUp_WiFi_Module(void);
-void WiFi_Module_Init(void);
-void WiFi_Application(void);
-/******* Wi-Fi AT CMD SET ****************/
-WiFi_Status_t Attention_Cmd(void);
-WiFi_Status_t USART_Transmit_AT_Cmd(uint16_t size);
-WiFi_Status_t USART_Receive_AT_Resp(WiFi_AT_CMD_Response_t);
-WiFi_Status_t Save_Current_Setting(void);
-WiFi_Status_t Restore_Default_Setting(void);
-WiFi_Status_t SET_SSID(char* ssid);
-WiFi_Status_t GET_SSID(void);
-WiFi_Status_t SET_Configuration_Value(char* sVar_name,uint32_t aValue);
-WiFi_Status_t GET_Configuration_Value(char* sVar_name,uint32_t *aValue);
-WiFi_Status_t SET_Configuration_Addr(char* sVar_name,char* addr);
-WiFi_Status_t Display_Help_Text(void);
-WiFi_Status_t SET_Power_State(WiFi_Power_State_t state);
-void Process_Wind_Indication(uint8_t *process_buff_ptr);
-void Process_WiFi_Indication_Cmd(event_s_TypeDef * event_pop_s1);
-//void USART2_SendBuffer(USART_TypeDef* USARTx, uint8_t *pData, uint8_t length);
-WiFi_Status_t Read_WiFi_SSID(char *string);
-void Reset_AT_CMD_Buffer(void);
-WiFi_Status_t Open_Serial_Port(void);
-WiFi_Status_t WaitForResponse(uint16_t alength);
-WiFi_Status_t config_init_value(char* sVar_name,uint8_t aValue);
-WiFi_Status_t config_init_addr(char* sVar_name,char* addr);
-
-char* Delete_Colon(char* );
-WiFi_Status_t Read_WiFi_Mode(char *string);
-WiFi_Status_t Read_WiFi_SecKey(char *string);
-
-WiFi_Status_t Write_WiFi_SSID(char *string);
-WiFi_Status_t Write_WiFi_SecKey(char *string);
-void PrintErrorMsg (void);
-void Print_Msg(char * msgBuff,uint8_t length);
-char *search_buffer(char *pSourceBuff, uint16_t sourceBuffLen, char *pSearchStringBuff, uint16_t seartchStringLen);
-void Error_Handler(void);
-WiFi_Status_t SET_WiFi_SecKey(char* seckey);
-void WiFi_Receive_Indication_Msg(void);
-
-void ResetBuffer(void);
-void Start_Timer(void);
-void Stop_Timer(void);
-void Request_Time_Out(void);
-void Start_DeepSleep_Timer(void);
-void Stop_DeepSleep_Timer(void);
-
-void HTTP_Read_Data(void);
-WiFi_Status_t Socket_Read(uint16_t DataLength);
-void Read_Socket_Data(void);
-void Socket_Pending_Data(void);
-void WiFi_switch_to_command_mode(void);
-void WiFi_switch_to_data_mode(void);
-void WiFi_Configuration(void);
-
-void Receive_Data(void);
-void Process_Buffer(uint8_t * ptr);
-void Process_WiFi(void);
-#if 0
-void configure_to_exti(void);
-#endif
-void Stop_Dequeue(void);
-void Resume_Dequeue(void);
-void wait_for_command_mode(void);
-void Wifi_SysTick_Isr(void);
-void RX_EXTI_Isr(uint16_t GPIO_Pin);
-//void Wifi_TIM_Handler(TIM_HandleTypeDef *htim);
-void Queue_Http_Event(uint8_t * hostname, uint8_t * path, uint32_t port_number,uint8_t * pURL_path);
-void Queue_Client_Write_Event(uint8_t sock_id, uint16_t DataLength, char * pData);
-void Queue_Wifi_FW_Update_Event(uint8_t * hostname, uint8_t * filename_path, uint32_t port_number);
-void Queue_Wifi_File_Event(uint8_t * pHostName, uint8_t * pFileName, uint32_t port_number);
-void Queue_Client_Open_Event(uint8_t * hostname, uint32_t port_number, uint8_t * protocol);
-void Queue_Client_Close_Event(uint8_t sock_id);
-void Wait_For_Sock_Read_To_Complete(void);
-void initialize_status_flags(void);
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
- }
-#endif
-#endif /* __WIFI_MODULE_H */
--- a/spwf/utils/event_buffer.c Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,242 +0,0 @@
-/**
- ******************************************************************************
- * @file event_buffer.c
- * @author Central LAB
- * @version V2.0.0
- * @date 10-February-2016
- * @brief Implements the Event Buffer management of the Wi-Fi module
- ******************************************************************************
- * @attention
- *
- * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * 3. Neither the name of STMicroelectronics nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "event_buffer.h"
-#include "wifi_module.h"
-
-/** @addtogroup BSP
-* @{
-*/
-
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT
- * @brief Wi-Fi_driver modules
- * @{
- */
-
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Defines
- * @{
- */
-
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Variables
- * @{
- */
-extern event_s_TypeDef event_buffer[1024];
-#define ELEMENT_SIZE sizeof(event_s_TypeDef) //1
-
-//extern UART_HandleTypeDef UartMsgHandle;
-//extern char print_msg_buff[512];
-extern event_s_TypeDef element;
-
-/*
-#ifdef USART_PRINT_MSG
-#define printf(arg) sprintf((char*)print_msg_buff,arg); \
- HAL_UART_Transmit(&UartMsgHandle, (uint8_t*)print_msg_buff, strlen(print_msg_buff), 1000);
-#endif
-*/
-
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Functions
- * @{
- */
-
-/**
- * @brief init
- * Initialize a circular buffer of type buffer_t
- * @param None
- * @retval None
- */
-void event_init(buffer_e *buffer, int size) {
- uint32_t element_size;
- element_size = sizeof(event_s_TypeDef);
- buffer->size = element_size*size;
- buffer->start = 0;
- buffer->count = 0;
- buffer->end = 0;
- buffer->element = event_buffer;
-}
-
-/**
- * @brief full
- * indicates if the given buffer is full or not
- * @param None
- * @retval None
- */
-int event_full(buffer_e *buffer)
-{
- int bufsize = buffer->size;
- if (buffer->count == (bufsize/ELEMENT_SIZE))
- {
- return 1;
- }
- else
- {
- return 0;
- }
-}
-
-/**
- * @brief empty
- * indicates if the given buffer is empty or not
- * @param None
- * @retval None
- */
-int event_empty(buffer_e *buffer) {
- if (buffer->count == 0) {
- return 1;
- } else {
- return 0;
- }
-}
-
-/**
- * @brief push_buffer
- * pushes the data structure onto the circular buffer (queues it)
- * @param None
- * @retval None
- */
-void push_eventbuffer(buffer_e *buffer, event_s_TypeDef data)
-{
- int bufsize;
- uint32_t index;
-
- if (event_full(buffer))
- {
- //Buffer overflow and no more space
- //MPD: No Action taken here; in case of buffer overflow, do we need to overwrite last buffer?
- //printf("\r\nRing Buffer Full!!\r\n");
- //printf(data);
- return;
- } else
- {
- index=buffer->end/ELEMENT_SIZE;
- buffer->element[index].data_length = data.data_length;
- buffer->element[index].wind64_pending_packet_no = data.wind64_pending_packet_no;
- buffer->element[index].enc = data.enc;
- buffer->element[index].ok_eval = data.ok_eval;
- buffer->element[index].socket_id = data.socket_id;
- buffer->element[index].wind = data.wind;
- buffer->element[index].event = data.event;
- buffer->element[index].event_pop = data.event_pop;
- buffer->count++;
- buffer->end = buffer->end + ELEMENT_SIZE;
-
- //wrap around if max size is reached
- bufsize = (buffer->size);
- if (buffer->end >= bufsize)
- {
- buffer->end = 0;
- }
- }
-}
-
-/**
- * @brief pop_buffer_queue
- * dequeues the circular buffer
- * @param None
- * @retval None
- */
-event_s_TypeDef * pop_eventbuffer_queue(buffer_e *buffer)
-{
- int bufsize;
- uint32_t index;
-
- if (event_empty(buffer))
- {
- //printf("\r\Event Buffer Empty!!\r\n");
- return NULL;
- }
- else
- {
- /* First in First Out*/
- index=buffer->start/ELEMENT_SIZE;
- element.data_length = buffer->element[index].data_length;
- element.enc = buffer->element[index].enc;
- element.ok_eval = buffer->element[index].ok_eval;
- element.socket_id = buffer->element[index].socket_id;
- element.wind64_pending_packet_no = buffer->element[index].wind64_pending_packet_no;
- element.wind = buffer->element[index].wind;
- element.event = buffer->element[index].event;
- element.event_pop = buffer->element[index].event_pop;
- buffer->start = buffer->start + ELEMENT_SIZE;
- buffer->count--;
-
- bufsize = (buffer->size);
- if (buffer->start >= bufsize)
- {
- buffer->start = 0;
- }
- return &element;
- }
-}
-
-void reset_event(event_s_TypeDef *r_event)
-{
- r_event->data_length = 0;
- r_event->enc = WIFI_FALSE;
- r_event->event = WIFI_NO_EVENT;
- r_event->ok_eval = WIFI_FALSE;
- r_event->socket_id = 9; //Socket ID 0-7
- r_event->wind64_pending_packet_no = 9; //Max pending packets = 4
- r_event->wind = 99; //any default value
- r_event->event_pop = WIFI_TRUE;
-}
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-
-/**
- * @}
- */
-
-/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
--- a/spwf/utils/event_buffer.h Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,157 +0,0 @@
- /**
- ******************************************************************************
- * @file event_buffer.h
- * @author Central LAB
- * @version V2.0.0
- * @date 10-February-2016
- * @brief Header File for Event Buffer management of the Wi-Fi module
- ******************************************************************************
- * @attention
- *
- * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * 3. Neither the name of STMicroelectronics nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************
- */
-
-/* Includes ------------------------------------------------------------------*/
-#include <stdio.h>
-#include <string.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include "wifi_module.h"
-#ifndef __EVENT_BUFFER_H
-#define __EVENT_BUFFER_H
-
-/** @addtogroup BSP
-* @{
-*/
-
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT
- * @brief Wi-Fi_driver modules
- * @{
- */
-
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_TypesDefinitions
- * @{
- */
-
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Defines
- * @{
- */
-
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Macros
- * @{
- */
-
-
-
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Variables
- * @{
- */
-
-typedef enum
-{
- WIFI_NO_EVENT,
- WIFI_WIND_EVENT = 0x0001,
- WIFI_SOCK_ID_EVENT,
- WIFI_GCFG_EVENT,
- WIFI_GPIO_EVENT,
- WIFI_OK_EVENT,
- WIFI_ERROR_EVENT,
- WIFI_STANDBY_CONFIG_EVENT,
- WIFI_RESUME_CONFIG_EVENT,
- WIFI_HTTP_EVENT,
- WIFI_CLIENT_SOCKET_WRITE_EVENT,
- WIFI_FILE_EVENT,
- WIFI_CLIENT_SOCKET_OPEN_EVENT,
- WIFI_CLIENT_SOCKET_CLOSE_EVENT,
- WIFI_FW_UPDATE_EVENT,
-} event_e;
-
-
-typedef struct
-{
- uint32_t wind;
- uint32_t data_length;
- uint16_t socket_id;
- uint8_t wind64_pending_packet_no;
- wifi_bool enc;
- wifi_bool ok_eval;
- wifi_bool event_pop;
- event_e event;
-} event_s_TypeDef;
-
-struct event_buffer {
- volatile int start; // position of first data from USART
- volatile int end; // position of last data from USART
- volatile int size; //Max size in terms of number of data packets (Total Bytes/size of each packet (8 bytes))
- volatile int count; // number of currently filled data packets (=size if full & =0 if empty)
-
- /*unsigned main buffer pointer*/
- event_s_TypeDef *element;
-};
-
-typedef struct event_buffer buffer_e;
-
-void event_init(buffer_e *buffer, int size);
-int event_full(buffer_e *buffer);
-int event_empty(buffer_e *buffer);
-void push_eventbuffer(buffer_e *buffer, event_s_TypeDef data);
-event_s_TypeDef * pop_eventbuffer_queue(buffer_e *buffer);
-void reset_event(event_s_TypeDef *r_event);
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-
-
-#endif
--- a/spwf/utils/ring_buffer.c Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,368 +0,0 @@
-/**
- ******************************************************************************
- * @file ring_buffer.c
- * @author Central LAB
- * @version V2.0.0
- * @date 10-February-2016
- * @brief Implements the Circular Buffer management of the Wi-Fi module
- ******************************************************************************
- * @attention
- *
- * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * 3. Neither the name of STMicroelectronics nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "ring_buffer.h"
-#include "wifi_module.h"
-
-/** @addtogroup MIDDLEWARES
-* @{
-*/
-
-
-/** @defgroup NUCLEO_WIFI_UTILS
- * @brief Wi-Fi buffer utility
- * @{
- */
-
-
-/** @defgroup NUCLEO_WIFI_UTILS_Private_Defines
- * @{
- */
-
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_UTILS_Private_Variables
- * @{
- */
-
-extern uint8_t ring_buffer[RINGBUF_SIZE];
-extern uint8_t pop_buffer[MAX_BUFFER_GLOBAL];
-extern uint8_t prefetch_buffer[20];
-//extern wifi_bool enable_receive_data_chunk;
-extern volatile Wifi_Status_Var status_flag;
-extern uint32_t pop_buffer_size;
-
-#define ELEMENT_SIZE 1
-
-
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_UTILS_Private_Functions
- * @{
- */
-
-/**
- * @brief init
- * Initialize a circular buffer of type buffer_td
- * @param None
- * @retval None
- */
-void init(buffer_td *buffer, int size)
-{
- buffer->size = size;
- buffer->start = 0;
- buffer->count = 0;
- buffer->end = 0;
- buffer->element = ring_buffer;
-}
-
-/**
- * @brief flush_buffer_queue
- * flushes the buffer
- * @param None
- * @retval None
- */
-void flush_buffer_queue(buffer_td *buffer)
-{
- buffer->start = buffer->end;//the tail goes up to the head and buffer becomes empty
- buffer->count = 0;
-}
-
-/**
- * @brief is_half_full
- * checks if the buffer is half full (empty)
- * @param None
- * @retval None
- */
-int is_half_full(buffer_td *buffer)
-{
- int bufsize = buffer->size;
- if (buffer->count >= bufsize - 100)
- {
- //printf("half full!");
- return 1;
- }
- else
- {
- return 0;
- }
-}
-
-/**
- * @brief is_half_empty
- * checks if the buffer is less than half
- * @param None
- * @retval None
- */
-int is_half_empty(buffer_td *buffer)
-{
- //int bufsize = buffer->size;
- if (buffer->count <= 100)
- {
- return 1;
- }
- else
- {
- return 0;
- }
-}
-
-/**
- * @brief full
- * indicates if the given buffer is full or not
- * @param None
- * @retval None
- */
-int full(buffer_td *buffer)
-{
- int bufsize = buffer->size;
- if (buffer->count == bufsize)
- {
- return 1;
- }
- else
- {
- return 0;
- }
-}
-
-/**
- * @brief empty
- * indicates if the given buffer is empty or not
- * @param None
- * @retval None
- */
-int empty(buffer_td *buffer) {
- if (buffer->count == 0) {
- return 1;
- } else {
- return 0;
- }
-}
-
-/**
- * @brief prefetch_buffer_queue
- * prefetches the pipeline upto xx bytes
- * @param None
- * @retval None
- */
-uint8_t * prefetch_buffer_queue(buffer_td *buffer)
-{
- //int i = 0;
- uint8_t * element;
- int bufsize;
-
- memset(prefetch_buffer,0x00,20);
- element = &prefetch_buffer[0];
- element[4] = '\0';
-
- if(!empty(buffer))
- {
- bufsize = (buffer->count);
- if(buffer->count <= 20)
- memcpy(element, &buffer->element[buffer->start], bufsize);
- else
- memcpy(element, &buffer->element[buffer->start], 20);
- return element;
- }
- else return NULL;
-}
-
-/*
- * @brief push_buffer
- * pushes a new item onto the circular buffer (queues it)
- * @param None
- * @retval None
- */
-void push_buffer(buffer_td *buffer, uint8_t *data)
-{
- int bufsize;
-
- if (full(buffer))
- {
- //Buffer overflow and no more space
- //MPD: No Action taken here; in case of buffer overflow, do we need to overwrite last buffer?
- //printf("\r\nRing Buffer Full!!\r\n");
- //printf(data);
- return;
- }
- else
- {
- buffer->count++;
- memcpy(&buffer->element[buffer->end], data, ELEMENT_SIZE);
- buffer->end = buffer->end + ELEMENT_SIZE;
-
- //wrap around if max size is reached
- bufsize = (buffer->size);
- if (buffer->end >= bufsize)
- {
- buffer->end = 0;
- }
- }
-}
-
-/**
- * @brief pop_buffer_queue
- * dequeues the circular buffer
- * @param None
- * @retval None
- */
-uint8_t * pop_buffer_queue(buffer_td *buffer)
-{
- uint8_t * element;
- int bufsize;
-
- element = &pop_buffer[0];
- if (empty(buffer))
- {
- //printf("\r\nRing Buffer Empty!!\r\n");
- return NULL;
- }
- else
- {
- memset(pop_buffer, 0x00 , MAX_BUFFER_GLOBAL);
- if(status_flag.enable_receive_data_chunk)
- {
- int buf_end = buffer->end;
- // int buf_start = buffer->start;
- if(buffer->count < 512)
- {
- pop_buffer_size = buffer->count;
- if(buf_end >= buffer->start)
- {
- memcpy(element, &buffer->element[buffer->start], pop_buffer_size);
- }
- else
- {
- int buf_start = buffer->start;
- memcpy(element, &buffer->element[buffer->start], RINGBUF_SIZE - buf_start);
- memcpy(element+(RINGBUF_SIZE-buffer->start), &buffer->element[0], buf_end);
- }
- buffer->start = buffer->end;
- buffer->count = 0;
- }
- else
- {
- if(buf_end >= buffer->start)
- {
- memcpy(element, &buffer->element[buffer->start], 511);
- buffer->start = buffer->start + 511;
- buffer->count = buf_end - buffer->start;
- }
- else
- {
- if(buffer->start + 511 < RINGBUF_SIZE)
- {
- memcpy(element, &buffer->element[buffer->start], 511);
- buffer->start = buffer->start + 511;
- buffer->count = (RINGBUF_SIZE - buffer->start)+ buf_end;
- }
- else
- {
- int buf_start = buffer->start;
- memcpy(element, &buffer->element[buffer->start], RINGBUF_SIZE-buf_start);
- memcpy(element+(RINGBUF_SIZE-buffer->start), &buffer->element[0], buf_start-513); //(buffer->start + 511) - 1024;
- buffer->start = (buffer->start-513);
- buffer->count = buf_end - buffer->start;
- }
- }
- pop_buffer_size = 511;
- }
- }
- else
- {
- /* First in First Out*/
- memcpy(element, &buffer->element[buffer->start], ELEMENT_SIZE);
- buffer->start = buffer->start + ELEMENT_SIZE;
- buffer->count--;
- pop_buffer_size = 1;
- bufsize = (buffer->size);
- if (buffer->start >= bufsize)
- {
- buffer->start = 0;
- }
- }
- return element;
- }
-}
-
-/**
- * @brief rewinds_buffer_queue
- * rewinds the circular buffer
- * @param None
- * @retval None
- */
-void rewind_buffer_queue(buffer_td *buffer , int count)
-{
- int buf_end = buffer->end;
- if(buffer->start - count >= 0)
- {
- buffer->start = buffer->start - count;
- if(buf_end > buffer->start) {
- buffer->count = buf_end - buffer->start;
- }
- else {
- buffer->count = (RINGBUF_SIZE-buffer->start)+buf_end;
- }
- }
- else
- {
- buffer->start = RINGBUF_SIZE - (count - buffer->start);
- buffer->count = (RINGBUF_SIZE - buffer->start)+ buf_end;
- }
-}
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-
-/**
- * @}
- */
-
-/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
--- a/spwf/utils/ring_buffer.h Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,130 +0,0 @@
- /**
- ******************************************************************************
- * @file ring_buffer.h
- * @author Central LAB
- * @version V2.0.0
- * @date 10-February-2016
- * @brief Header File for Circular Buffer management of the Wi-Fi module
- ******************************************************************************
- * @attention
- *
- * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * 3. Neither the name of STMicroelectronics nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************
- */
-
-/* Includes ------------------------------------------------------------------*/
-#include <stdio.h>
-#include <string.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#ifndef __RING_BUFFER_H
-#define __RING_BUFFER_H
-
-/** @addtogroup BSP
-* @{
-*/
-
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT
- * @brief Wi-Fi_driver modules
- * @{
- */
-
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_TypesDefinitions
- * @{
- */
-
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Defines
- * @{
- */
-
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Macros
- * @{
- */
-
-
-
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_BUFFER_MGMT_Private_Variables
- * @{
- */
-
-struct buffer {
- volatile int start; // position of first data from USART
- volatile int end; // position of last data from USART
- volatile int size; //Max size in terms of number of data packets (Total Bytes/size of each packet (8 bytes))
- volatile int count; // number of currently filled data packets (=size if full & =0 if empty)
-
- /*unsigned main buffer pointer*/
- uint8_t *element;
-};
-
-typedef struct buffer buffer_td;
-
-void init(buffer_td *buffer, int size);
-void flush_buffer_queue(buffer_td *buffer);
-int is_half_full(buffer_td *buffer);
-int is_half_empty(buffer_td *buffer);
-int full(buffer_td *buffer);
-int empty(buffer_td *buffer);
-void push_buffer(buffer_td *buffer, uint8_t *data);
-uint8_t * pop_buffer_queue(buffer_td *buffer);
-uint8_t * popstack(buffer_td *buffer);
-uint8_t * prefetch_buffer_queue(buffer_td *buffer);
-void rewind_buffer_queue(buffer_td *buffer , int count);
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-
-
-#endif
--- a/spwf/wifi_driver.c Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,187 +0,0 @@
-/**
- ******************************************************************************
- * @file wifi_driver.c
- * @author Central LAB
- * @version V2.0.0
- * @date 01-March-2016
- * @brief Enable Wi-Fi functionality using AT cmd set
- ******************************************************************************
- * @attention
- *
- * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * 3. Neither the name of STMicroelectronics nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************
- */
-/* Includes ------------------------------------------------------------------*/
-
-#include <stddef.h>
-#include "wifi_module.h"
-#include "ring_buffer.h"
-#include "device.h"
-#include "wait_api.h"
-#include "stdio.h"
-#include "string.h"
-#include "wifi_driver.h"
-
-void Wifi_ticker(void)
-{
- Wifi_SysTick_Isr();
-}
-
-void Wifi_scheduler(void)
-{
- Wifi_TIM_Handler();
-}
-
-void Rx_irq_handler(void)
-{
-
- uint8_t data_byte = (uint8_t)callSpwfSADevice_getChar(spwf_dev);
-
- status_flag.Uartx_Rx_Processing = WIFI_FALSE;
-
- Stop_Timer();
- __disable_irq();
- push_buffer(&big_buff, &data_byte);
- __enable_irq();
- Start_Timer();
-
- status_flag.Uartx_Rx_Processing = WIFI_TRUE;
-
- /*if(is_half_full(&big_buff))
- {
- status_flag.resume_receive_data = WIFI_TRUE;
- if(callSpwfSADevice_read_rts(spwf_dev))
- callSpwfSADevice_rts(spwf_dev, GPIO_PIN_SET);
- //callSpwfSADevice_attach(0);
- } else
- {
- if(status_flag.AT_Cmd_Processing == WIFI_FALSE)
- {
- status_flag.Uartx_Rx_Processing = WIFI_TRUE;
- }
- }*/
-}
-
-
-/**
-* @brief wifi_reset
-* Reset WiFi module using PC12 gpio pin
-* @param None
-* @retval None
-*/
-void wifi_reset(void)
-{
- WiFi_Module_State = Process_Event;
- WiFi_WIND_State.WiFiHWStarted = WIFI_FALSE;
- wifi_connected = 0; //reset wifi_connected to get user callback
- memset((void*)&WiFi_WIND_State,0x00,sizeof(WiFi_WIND_State)); /*reset the WIND State?*/
-
- /* === RESET PIN - PC12 ===*/
-
- callSpwfSADevice_reset(spwf_dev, 0);
- wait_ms(100);
-
- callSpwfSADevice_reset(spwf_dev, 1);
- wait_ms(100);
-
- while(WiFi_WIND_State.WiFiHWStarted != WIFI_TRUE)
- {
- //nothing to do
- __NOP();
- }
-}
-
-
-/**
-* @brief PowerUp_WiFi_Module
-* Power up Wi-Fi module,SET GPIO PA0 pin
-* @param None
-* @retval None
-*/
-void PowerUp_WiFi_Module(void)
-{
- /* === SET PIN - PC12 ===*/
- callSpwfSADevice_reset(spwf_dev, 1);
- wait_ms(50);
-}
-
-/**
-* @brief Receive_Data
-* Receive data from UART port
-* @param uint8_t number of bytes to be received
-* @retval None
-*/
-void Receive_Data(void)
-{
- callSpwfSADevice_rts(spwf_dev, 0);
-}
-
-
-/**
-* @brief USART_Transmit_AT_Cmd
-* send AT cmd on UART port of wifi module.
-* @param size size of the AT command
-* @retval WiFi_Status_t : status of AT cmd
-*/
-WiFi_Status_t USART_Transmit_AT_Cmd(uint16_t size)
-{
- //Check for Hardware Started
- if(status_flag.WiFi_Enabled == WIFI_FALSE)
- return WiFi_NOT_READY;
- //Check for Deep-Sleep or Standby Mode, return error if true
- if (status_flag.Standby_Enabled == WIFI_TRUE || status_flag.Deep_Sleep_Enabled == WIFI_TRUE)
- return WiFi_IN_LOW_POWER_ERROR;
-
- status_flag.AT_Cmd_Processing = WIFI_TRUE;//Stop Any Rx between the TX call
-
- if (size == 0)
- {
- return WiFi_UNHANDLED_IND_ERROR;
- }
-
-#if defined(USART3_INT_MODE)
- if(HAL_UART_Transmit_IT(&UartWiFiHandle, (uint8_t *)WiFi_AT_Cmd_Buff, size)!= HAL_OK)
- {
- Error_Handler();
- return WiFi_HAL_UART_ERROR;
- }
- while (UartReady != SET);
- UartReady = RESET;
-
-#elif defined(USART3_POLLING_MODE)
-
- callSpwfSADevice_write(spwf_dev, (const char *) WiFi_AT_Cmd_Buff, size);
-
-#else
- #error "Please select USART mode in your application (in wifi_module.h file)"
-#endif
-
- status_flag.AT_Cmd_Processing = WIFI_FALSE;//Re-enable Rx for UART
- if(status_flag.Uartx_Rx_Processing == WIFI_FALSE)
- Receive_Data();//Start receiving Rx from the UART again, if and only if it was stopped in the previous Uartx_Rx_Handler
- return WiFi_MODULE_SUCCESS;
-}
-
--- a/spwf/wifi_interface.c Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1437 +0,0 @@
-/**
- ******************************************************************************
- * @file wifi_interface.c
- * @author Central LAB
- * @version V2.0.0
- * @date 10-February-2016
- * @brief User APIs implementation for X-CUBE-WIFI1
- ******************************************************************************
- * @attention
- *
- * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * 3. Neither the name of STMicroelectronics nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************
- */
-
-/* Includes ------------------------------------------------------------------*/
-#include "wifi_module.h"
-//#include "stm32_spwf_wifi.h"
-#include "ring_buffer.h"
-#include "stdio.h"
-#include "string.h"
-#include "gpio_irq_api.h"
-#include "gpio_api.h"
-#include "wait_api.h"
-#include "serial_api.h"
-
-/** @addtogroup MIDDLEWARES
-* @{
-*/
-
-
-/** @defgroup NUCLEO_WIFI_INTERFACE
- * @brief Wi-Fi User API modules
- * @{
- */
-
-
-/** @defgroup NUCLEO_WIFI_INTERFACE_Private_Defines
- * @{
- */
-
-
-/**
- * @}
- */
-
-/** @addtogroup NUCLEO_WIFI_INTERFACE_Private_Variables
- * @{
- */
-/* Private variables ---------------------------------------------------------*/
-
-#if defined (USE_STM32F4XX_NUCLEO) || (USE_STM32L4XX_NUCLEO)
-extern uint8_t WiFi_AT_Cmd_Buff[2048];
-#else
-extern uint8_t WiFi_AT_Cmd_Buff[1024];
-#endif
-
-extern volatile Wifi_Status_Var status_flag;
-
-extern char UserDataBuff[MAX_BUFFER_GLOBAL];
-extern wifi_scan *wifi_scanned_list;//[15];
-extern char print_msg_buff[MAX_BUFFER_GLOBAL];
-extern uint8_t user_scan_number;
-extern uint8_t no_of_open_client_sockets;
-extern wifi_bool open_sockets[8];//Max open sockets allowed is 8. Each array element depicts one socket (true=open, false=closed)
-extern WiFi_AT_CMD_Response_t WiFi_Module_State;
-extern volatile uint8_t wifi_client_connected;
-extern uint8_t gpio_value, gpio_direc;
-extern volatile uint8_t wifi_connected;
-extern uint32_t SockON_Data_Length;
-extern uint8_t Socket_Open_ID, sockon_query_id;
-extern volatile uint32_t WIND64_count;
-extern uint32_t process_buffer_index;
-extern uint32_t epoch_time;
-
-/*SPWFSADevice Class functions and variables*/
-void * spwf_device_class;
-extern void callSpwfSADevice_wakeup(void* object, int wake);
-extern void callSpwfSADevice_debug(void* object, const char * string);
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_INTERFACE_Private_Functions
- * @{
- */
-#ifdef USART_PRINT_MSG
-#define printf(arg) {sprintf((char*)print_msg_buff,arg); \
-HAL_UART_Transmit(&UartMsgHandle, (uint8_t*)print_msg_buff, strlen(print_msg_buff), 1000);}
-#endif
-
-/**
- *Changed/introduced functions for MBED implementation:
-
-- WiFi_Status_t wifi_init(wifi_config* config)
-- WiFi_Status_t wifi_wakeup(wifi_bool wakeup)
-- WiFi_Status_t wifi_socket_server_write(uint16_t DataLength,char * pData)
-- void wifi_reset(void);
-- WiFi_Status_t wifi_enable(wifi_bool enable)
-
-*/
-
-
-/**
- * @brief wifi_init
- * User API for wifi init
- * @param None
- * @retval None
- */
-WiFi_Status_t wifi_init(wifi_config* config)
-{
-#ifndef WIFI_USE_VCOM
- uint8_t tx_level;
-#endif
-
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-#if DEBUG_PRINT
- printf("\r\n[SPWF]Initializing SPWF01SA1 Interface\r\n");
-#endif
- //callSpwfSADevice_debug(spwf_device_class, "\r\n[SPWF] Initializing mbed SPWF01SA1 Interface\r\n");
-
- WiFi_Module_Init();
-
- //callSpwfSADevice_debug(spwf_device_class, "\r\n[SPWF] Module Init done\r\n");
-
-#ifndef WIFI_USE_VCOM
-
- wifi_wakeup(WIFI_TRUE);//Prevent from going to sleep during configuration
-
- /* Soft reset the module */
- wifi_reset();
-
- //callSpwfSADevice_debug(spwf_device_class, "\r\n[SPWF] Hardware started\r\n");
-
- /* Set localecho1 to 0*/
- status = SET_Configuration_Value(LOCALECHO1, 0);
- if(status != WiFi_MODULE_SUCCESS) return status;
-
- /* Restore default setting*/
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_RESTORE_DEFAULT_SETTING);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- /* Switch on HW Flow Control*/
- status = SET_Configuration_Value(CONSOLE1_HWFC, 1);
- if(status != WiFi_MODULE_SUCCESS) return status;
-
- if(config->wifi_baud_rate)
- {
- /* Set USART Speed*/
- status = SET_Configuration_Value(CONSOLE1_SPEED, config->wifi_baud_rate);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- /* Set wifi_mode to idle*/
- status = SET_Configuration_Value(WIFI_MODE, WiFi_IDLE_MODE);
- if(status != WiFi_MODULE_SUCCESS) return status;
-
- switch(config->ht_mode)
- {
- case WIFI_FALSE:
- status = SET_Configuration_Value(WIFI_HT_MODE, 0);
- if(status != WiFi_MODULE_SUCCESS) return status;
- status = SET_Configuration_Addr(WIFI_OPR_RATE_MASK, "0x00003FCF");
- if(status != WiFi_MODULE_SUCCESS) return status;
- break;
- case WIFI_TRUE:
- status = SET_Configuration_Value(WIFI_HT_MODE, 1);
- if(status != WiFi_MODULE_SUCCESS) return status;
- status = SET_Configuration_Addr(WIFI_OPR_RATE_MASK, "0x003FFFCF");
- if(status != WiFi_MODULE_SUCCESS) return status;
- break;
- default:
- break;
- }
-
- switch(config->power)
- {
- case wifi_active:
- status = SET_Configuration_Value(WIFI_POWERSAVE, 0);
- if(status != WiFi_MODULE_SUCCESS) return status;
- status = SET_Configuration_Value(WIFI_SLEEP_ENABLED, 0);
- if(status != WiFi_MODULE_SUCCESS) return status;
- break;
- case wifi_reactive:
- status = SET_Configuration_Value(WIFI_POWERSAVE, 1);
- if(status != WiFi_MODULE_SUCCESS) return status;
- status = SET_Configuration_Value(WIFI_OPERATIONAL_MODE, 11);
- if(status != WiFi_MODULE_SUCCESS) return status;
- status = SET_Configuration_Value(WIFI_BEACON_WAKEUP, 0);
- if(status != WiFi_MODULE_SUCCESS) return status;
- status = SET_Configuration_Value(WIFI_LISTEN_INTERVAL, 0);
- if(status != WiFi_MODULE_SUCCESS) return status;
- status = SET_Configuration_Value(WIFI_SLEEP_ENABLED, 0);
- if(status != WiFi_MODULE_SUCCESS) return status;
- break;
- case wifi_sleep:
- status = SET_Configuration_Value(WIFI_POWERSAVE, 1);
- if(status != WiFi_MODULE_SUCCESS) return status;
- status = SET_Configuration_Value(WIFI_OPERATIONAL_MODE, 12);
- if(status != WiFi_MODULE_SUCCESS) return status;
- status = SET_Configuration_Value(WIFI_BEACON_WAKEUP, 10);
- if(status != WiFi_MODULE_SUCCESS) return status;
- status = SET_Configuration_Value(WIFI_LISTEN_INTERVAL, 1);
- if(status != WiFi_MODULE_SUCCESS) return status;
- status = SET_Configuration_Value(WIFI_SLEEP_ENABLED, 1);
- if(status != WiFi_MODULE_SUCCESS) return status;
- break;
- default:
- break;
- }
-
- switch(config->power_level)
- {
- case low:
- case medium:
- case high:
- case max:
- tx_level=config->power_level*6;
- status = SET_Configuration_Value(WIFI_TX_POWER, tx_level);
- if(status != WiFi_MODULE_SUCCESS) return status;
- break;
- default:
- break;
- }
-
- switch(config->dhcp)
- {
- case off:
- case on:
- case custom:
- status = SET_Configuration_Value(IP_USE_DHCP_SERVER, config->dhcp);
- if(status != WiFi_MODULE_SUCCESS) return status;
- break;
- default:
- break;
- }
-
- /* Set IP address */
- if(config->ip_addr)
- {
- status = SET_Configuration_Addr(WIFI_IP_ADDRESS, config->ip_addr);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
- /* Set netmask address */
- if(config->netmask_addr)
- {
- status = SET_Configuration_Addr(WIFI_IP_NETMASK, config->netmask_addr);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
- /* Set default gateway address */
- if(config->gateway_addr)
- {
- status = SET_Configuration_Addr(WIFI_IP_DEFAULT_GATEWAY, config->gateway_addr);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
- /* Set dns address */
- if(config->dns_addr)
- {
- status = SET_Configuration_Addr(WIFI_IP_DNS, config->dns_addr);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
- /* Set hostname */
- if(config->host_name)
- {
- status = SET_Configuration_Addr(WIFI_IP_HOSTNAME, config->host_name);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- if(config->ap_domain_name)
- {
- status = SET_Configuration_Addr(WIFI_IP_APDOMAINNAME, config->ap_domain_name);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- if(config->ap_config_page_name)
- {
- status = SET_Configuration_Addr(WIFI_IP_APREDIRECT, config->ap_config_page_name);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- if(config->http_timeout)
- {
- status = SET_Configuration_Value(WIFI_IP_HTTP_TIMEOUT, config->http_timeout*1000);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
- if(config->dhcp_timeout)
- {
- status = SET_Configuration_Value(WIFI_IP_DHCP_TIMEOUT, config->dhcp_timeout);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
-#ifdef MODULE_VERSION_SPWF01Sx_1y
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_HTTPD, config->web_server);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-#endif
-
- /*AT+S.TLSCERT2=clean,all */
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSCERT2=clean,all\r");
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- /* save current setting in flash */
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SAVE_CURRENT_SETTING);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- if(config->wifi_baud_rate)
- {
- UART_Configuration(config->wifi_baud_rate);
- Receive_Data();//Restart data reception
- }
-
- /* Soft reset the module, Do the second reset after setting all parameters and saving in flash */
- wifi_reset();
-
- wifi_wakeup(WIFI_FALSE);//De-assert wakeup signal (PC8) to allow sleep if enabled
-#endif //WIFI_USE_VCOM
-
-#if DEBUG_PRINT
- printf("\r\nEnd of Initialization..\r\n");
-#endif
- //callSpwfSADevice_debug(spwf_device_class, "\r\n[SPWF] End of mbed Initialization\r\n");
-
- return status;
-}
-
-
-/**
-* @brief wifi_socket_client_security
-* Set the security certificates and key for secure socket (TLS)
-* @param None
-* @retval WiFi_Status_t : return status
-*/
-WiFi_Status_t wifi_socket_client_security(uint8_t* tls_mode, uint8_t* root_ca_server, uint8_t* client_cert, uint8_t* client_key, uint8_t* client_domain, uint32_t tls_epoch_time)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- /*AT+S.TLSCERT2=clean,all */
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSCERT2=clean,all\r");
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- /* AT+S.SETTIME=<seconds> */
- Reset_AT_CMD_Buffer();
- if(tls_epoch_time==0)
- epoch_time = EPOCH_TIME;
- else
- epoch_time = tls_epoch_time;
-
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.SETTIME=%lu\r",(unsigned long)epoch_time);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- /*AT+S.TLSCERT=f_ca,<size><CR><data>*/
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSCERT=f_ca,%d\r%s",strlen((const char *)root_ca_server) - 1, root_ca_server);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- /*AT+S.TLSCERT=f_cert,<size><CR><data>*/
- if(tls_mode[0]=='m')
- {
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSCERT=f_cert,%d\r%s",strlen((const char *)client_cert) - 1, client_cert);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- /*AT+S.TLSCERT=f_key,<size><CR><data>*/
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSCERT=f_key,%d\r%s",strlen((const char *)client_key) - 1, client_key);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
- }
-
- /*AT+S.TLSDOMAIN=f_domain,<server domain>*/
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.TLSDOMAIN=f_domain,%s\r", client_domain);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- if(status != WiFi_MODULE_SUCCESS) return status;
- }
-
- return status;
-}
-
-/**
-* @brief wifi_socket_client_open
-* Open a network socket
-* @param Hostname hostname to connect to
-* portnumber portnumber of the Host to connect to
-* protocol tcp or udp protocol
-* sock_id socket id of the opened socket returned to the user
-* @retval WiFi_Status_t : return status of socket open request
-*/
-WiFi_Status_t wifi_socket_client_open(uint8_t * hostname, uint32_t port_number, uint8_t * protocol, uint8_t * sock_id)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- Queue_Client_Open_Event(hostname,port_number,protocol);
- status = USART_Receive_AT_Resp(Process_Event);
-
- *sock_id = Socket_Open_ID; //return the socket id to the user
-
- return status;
-}
-
-/**
-* @brief Open_Serial_Port
-* Open a network socket
-* @param None
-* @retval WiFi_Status_t : Wifi status
-*/
-WiFi_Status_t Open_Serial_Port()
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- /* AT+S.SOCKOS=2<cr> */
- Reset_AT_CMD_Buffer();
- //sprintf((char*)WiFi_AT_Cmd_Buff,"\rAT+S.SOCKOS=%d\r",SerialPortNo);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-
- if(status==WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
- return status;
-}
-
-/**
-* @brief wifi_socket_client_write
-* Write len bytes of data to socket
-* @param sock_id socket ID of the socket to write to
-* DataLength: data length to send
-* pData : pointer of data buffer to be written
-* @retval WiFi_Status_t : return status of socket write request
-*/
-WiFi_Status_t wifi_socket_client_write(uint8_t sock_id, uint16_t DataLength, char * pData)
-{
- /* AT+S.SOCKW=00,11<cr> */
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- //Check if sock_id is open
- if(!open_sockets[sock_id])
- return WiFi_NOT_READY;
-
- if(DataLength>=1021 || DataLength<=0)
- return WiFi_NOT_SUPPORTED;
-
- Queue_Client_Write_Event(sock_id,DataLength,pData);
- status = USART_Receive_AT_Resp(Process_Event);
- return status;
-}
-
-/**
-* @brief Socket_Read
-* Return len bytes of data from socket
-* @param DataLength: data length to read
-* @retval WiFi_Status_t : return status of socket read request
-*/
-WiFi_Status_t Socket_Read(uint16_t DataLength)
-{
- /* AT+S.SOCKR=01,12<cr> */
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- wait_for_command_mode();
-
- /* AT+S.SOCKON=myserver,1234,t<cr> */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SOCKET_READ,sockon_query_id,DataLength);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- if(status_flag.stop_event_dequeue == WIFI_FALSE)
- status_flag.stop_event_dequeue = WIFI_TRUE;
- SockON_Data_Length = DataLength;
- status_flag.enable_sock_read = WIFI_TRUE;
- process_buffer_index =5;
- status_flag.enable_receive_data_chunk = WIFI_TRUE;
- WiFi_Module_State = Process_Event;
- status_flag.Set_AT_Cmd_Response_False = WIFI_TRUE;
- memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);
- }
- return status;
-}
-
-/**
-* @brief wifi_socket_client_close
-* The SOCKC command allows to close socket
-* @param sock_close_id the socket ID of the socket which needs to be closed.
-* @retval WiFi_Status_t : return status of socket close request
-*/
-WiFi_Status_t wifi_socket_client_close(uint8_t sock_close_id)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- if(open_sockets[sock_close_id])
- {
- Queue_Client_Close_Event(sock_close_id);
- return status;
- }
- else
- return WiFi_MODULE_ERROR;
-
-}
-
-/**
-* @brief Socket_Pending_Data
-* Query pending data.It will returns the number of bytes of data waiting on socket
-* @param None
-* @retval uint8_t :number of bytes of data waiting on socket
-*/
-void Socket_Pending_Data()
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- /* AT+S.SOCKQ=01<cr> */
- Reset_AT_CMD_Buffer();
-
- wait_for_command_mode();
-
- if(open_sockets[sockon_query_id])
- {
- if(status_flag.stop_event_dequeue == WIFI_FALSE)
- status_flag.stop_event_dequeue = WIFI_TRUE;
-
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_QUERY_PENDING_DATA,sockon_query_id);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status==WiFi_MODULE_SUCCESS)
- {
- /* EQ. Set state to Process_Event */
- WiFi_Module_State = Process_Event;
- status_flag.Set_AT_Cmd_Response_False = WIFI_TRUE;
- }
-}
-}
-
-/**
-* @brief wifi_socket_server_open
-* Open a Server socket
-* @param None
-* @retval WiFi_Status_t : return status of server socket request
-*/
-WiFi_Status_t wifi_socket_server_open(uint32_t port_number, uint8_t * protocol)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-Reset_AT_CMD_Buffer();
-
-/* AT+S.SOCKD=portNo,t<cr> */
-sprintf((char*)WiFi_AT_Cmd_Buff,AT_SERVER_SOCKET_OPEN,(int)port_number,protocol);
-status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-if(status == WiFi_MODULE_SUCCESS)
-{
-status = USART_Receive_AT_Resp(Process_Event);
-}
-return status;
-}
-
-/**
-* @brief wifi_socket_server_write
-* Write to a Server socket
-* @param None
-* @retval WiFi_Status_t : return status of server socket request
-*/
-WiFi_Status_t wifi_socket_server_write(uint16_t DataLength,char * pData)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-/*Can only write if there is a client connected*/
-if(!wifi_client_connected)
-{
-return WiFi_NOT_READY;
-}
- __disable_irq();
-
-status_flag.do_not_reset_push_WIFI_event = WIFI_TRUE;
-status_flag.prevent_push_WIFI_event = WIFI_TRUE;
-__enable_irq();
-
-while(status_flag.sock_read_ongoing || WIND64_count!= 0)//wait till any pending data is read
-{
- asm("NOP");
-}
-
-wait_for_command_mode();
-
-/*to make sure that by default the mode is not switched to command mode from data mode*/
-status_flag.switch_by_default_to_command_mode = WIFI_FALSE;
-
-/*Switch to Data Mode first*/
-if(!status_flag.data_mode)
-{
-WiFi_switch_to_data_mode();//switch by default
-while(!status_flag.data_mode)
-{
- //Wait till data_mode is active
- asm("NOP");
-}
-}
-
-/*Write the data on the uart*/
-/*if(HAL_UART_Transmit(&UartWiFiHandle, (uint8_t *)pData, DataLength,1000)!= HAL_OK)
-{
-Error_Handler();
-return WiFi_HAL_UART_ERROR;
-}*/
-//HAL_Delay(100);//Wait for tx before switching back to command mode
-
-/*Switch back to Command Mode*/
-if(!status_flag.command_mode)
-{
-WiFi_switch_to_command_mode();//switch by default
-while(!status_flag.command_mode)
-{
- //Wait till command_mode is active
- asm("NOP");
-}
-}
-
-status_flag.switch_by_default_to_command_mode = WIFI_TRUE; /*back to default behaviour*/
-
-__disable_irq();
-status_flag.prevent_push_WIFI_event = WIFI_FALSE;
-status_flag.do_not_reset_push_WIFI_event = WIFI_FALSE;
-__enable_irq();
-
-return status;
-}
-
-/**
-* @brief Server Socket Close
-* Close a Server socket
-* @param None
-* @retval WiFi_Status_t : return status of server socket request
-*/
-WiFi_Status_t wifi_socket_server_close()
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-Reset_AT_CMD_Buffer();
-
-/* AT+S.SOCKD=portNo,t<cr> */
-sprintf((char*)WiFi_AT_Cmd_Buff,AT_SERVER_SOCKET_CLOSE);
-status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-if(status == WiFi_MODULE_SUCCESS)
-{
-status = USART_Receive_AT_Resp(Process_Event);
-}
-
-return status;
-}
-
-
-/**
-* @brief wait_for_command_mode
-* Waits till we are in command mode
-* @param None
-* @retval None
-*/
-void wait_for_command_mode(void)
-{
-while(!status_flag.command_mode)
- {
- //Make sure we are in command mode, ideally we should do this in every User API?
- asm("NOP");
- }
-}
-
-
-/**
-* @brief wifi_file_delete
-* Delete a file
-* @param pFileName : File Name to be deleted
-* @retval WiFi_Status_t : return status of delete file request
-*/
-WiFi_Status_t wifi_file_delete(char * pFileName)
-{
-/* AT+S.FSD: delete an existing file */
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-Reset_AT_CMD_Buffer();
-/* AT+S.FSL */
-sprintf((char*)WiFi_AT_Cmd_Buff,AT_DELETE_FILE,pFileName);
-
-status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-if(status == WiFi_MODULE_SUCCESS)
-{
-status = USART_Receive_AT_Resp(Process_Event);
-}
-return status;
-}
-
-/**
-* @brief wifi_file_list
-* List existing filename
-* @param None
-* @retval WiFi_Status_t : return status of AT cmd request
-*/
-
-WiFi_Status_t wifi_file_list()
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-Queue_Wifi_File_Event(NULL,NULL,0);
-status = USART_Receive_AT_Resp(Process_Event);
-return status;
-}
-
-/**
-* @brief wifi_file_show
-* Print the contents of an existing file
-* @param pFileName : pinter of file name
-* @retval WiFi_Status_t : return status of AT cmd request
-*/
-
-WiFi_Status_t wifi_file_show(uint8_t * pFileName)
-{
-if(pFileName==NULL)
- return WiFi_MODULE_ERROR;
-
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-Queue_Wifi_File_Event(NULL,pFileName,0);
-status = USART_Receive_AT_Resp(Process_Event);
-return status;
-}
-
-/**
-* @brief wifi_file_create
-* Create file for HTTP server
-* @param pFileName : pointer of file name to be created
-* alength : length of file
-* @retval WiFi_Status_t : return status of AT cmd request
-*/
-
-WiFi_Status_t wifi_file_create(char *pFileName, uint16_t alength, char * pUserFileBuff)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-if(alength >1024)
-return WiFi_AT_FILE_LENGTH_ERROR;
-
-Reset_AT_CMD_Buffer();
-
-/* AT+S.FSC=/index.html */
-sprintf((char*)WiFi_AT_Cmd_Buff, AT_CREATE_NEW_HTML_FILE, pFileName, alength);
-
-status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-if(status == WiFi_MODULE_SUCCESS)
-{
-status = USART_Receive_AT_Resp(Process_Event);
-int len = strlen(pUserFileBuff);
-
-if(len >= 1024)
- return WiFi_AT_FILE_LENGTH_ERROR;
-
-/* AT+S.FSA=/index.html */
-sprintf((char*)WiFi_AT_Cmd_Buff,AT_APPEND_FILE,pFileName,len);
-
-status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-if(status == WiFi_MODULE_SUCCESS)
-{
- memset(WiFi_AT_Cmd_Buff, 0x00, sizeof WiFi_AT_Cmd_Buff);
- memcpy((char*)(char*)WiFi_AT_Cmd_Buff, (char*) pUserFileBuff,len);
- WiFi_AT_Cmd_Buff[len+1]='\r';
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
-}
-}
-return status;
-}
-
-/**
-* @brief wifi_http_get
-* Issue an HTTP GET of the given path to the specified host
-* @param None
-* @retval WiFi_Status_t : return status of AT cmd response
-*/
-
-WiFi_Status_t wifi_http_get(uint8_t * hostname, uint8_t * path, uint32_t port_number)
-{
-if(hostname == NULL || path == NULL)
-return WiFi_MODULE_ERROR;
-
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-while(status_flag.sock_read_ongoing || WIND64_count!= 0); //wait till any pending data is read
-{
- asm("NOP");
-}
-
-// AT+S.HTTPGET=host.example.com,/index.html, port_number<cr>
-//Queue the http-get command
-Queue_Http_Event(hostname, path, port_number,NULL);
-
-//Make the user wait anyway
-status = USART_Receive_AT_Resp(Process_Event);
-
-return status;
-
-}
-
-/**
-* @brief wifi_http_post
-* Issue an HTTP GET of the given path to the specified host
-* @param None
-* @retval WiFi_Status_t : status of Http Post Request
-*/
-
-WiFi_Status_t wifi_http_post(uint8_t * pURL_path)
-{
-if(pURL_path == NULL)
-return WiFi_MODULE_ERROR;
-
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-while(status_flag.sock_read_ongoing || WIND64_count!= 0);//wait till any pending data is read
-{
- asm("NOP");
-}
-
-// AT+S.HTTPPOST = posttestserver.com,/post.php,name=demo&email=mymail&subject=subj&body=message<cr>
-Queue_Http_Event(NULL,NULL,0,pURL_path);
-
-//Make the user wait anyway
-status = USART_Receive_AT_Resp(Process_Event);
-return status;
-}
-
-/**
-* @brief wifi_file_image_create
-* Downloads an updated file system via a single HTTP GET request to the
-* named host and path.
-* @param None
-* @retval WiFi_Status_t
-*/
-WiFi_Status_t wifi_file_image_create(uint8_t * pHostName, uint8_t * pFileName, uint32_t port_number)
-{
-if(pHostName == NULL || pFileName == NULL || port_number ==0)
-return WiFi_MODULE_ERROR;
-
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-Queue_Wifi_File_Event(pHostName,pFileName,port_number);
-status = USART_Receive_AT_Resp(Process_Event);
-
-/* Soft reset the module */
-SET_Power_State(PowerSave_State);
-return status;
-}
-
-/**
-* @brief wifi_file_erase_external_flash
-* This API allows to erase the content of the external flash
-* @param None
-* @retval WiFi_Status_t
-*/
-WiFi_Status_t wifi_file_erase_external_flash()
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-Reset_AT_CMD_Buffer();
-ResetBuffer();
-
-/* AT+S.HTTPDFSERASE */
-sprintf((char*)WiFi_AT_Cmd_Buff,AT_ERASE_FLASH_MEMORY);
-status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-
-/* Soft reset the module */
-SET_Power_State(PowerSave_State);
-
-return status;
-}
-
-/**
-* @brief wifi_fw_update
-* Issue an HTTP GET of the given path to the specified host and get the firmware updated
-* @param None
-* @retval None
-*/
-WiFi_Status_t wifi_fw_update(uint8_t * hostname, uint8_t * filename_path, uint32_t port_number)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-Queue_Wifi_FW_Update_Event(hostname,filename_path,port_number);
-status = USART_Receive_AT_Resp(Process_Event);
-/* Soft reset the module */
-SET_Power_State(PowerSave_State);
-return status;
-}
-
-/**
-* @brief wifi_network_scan
-* Performs an immediate scan for available network
-* @param None
-* @retval WiFi_Status_t : WiFi status error
-*/
-WiFi_Status_t wifi_network_scan(wifi_scan *scan_result, uint16_t max_scan_number)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-wifi_scanned_list = scan_result;
-if(max_scan_number>MAX_WIFI_SCAN_NETWORK)
-return WiFi_NOT_SUPPORTED;
-user_scan_number = max_scan_number;
-
-if(status_flag.Scan_Ongoing)
-{
-return WiFi_AT_CMD_BUSY;
-}
-
-status_flag.Scan_Ongoing = WIFI_TRUE;
-
-#if 0 //TBD
-if(WiFi_Param.WiFi_Module_State == WiFi_MiniAP_MODE)
-return WiFi_NOT_SUPPORTED;
-#endif
-
-/* AT+S.SCAN: performs an immediate scan for available networks */
-Reset_AT_CMD_Buffer();
-sprintf((char*)WiFi_AT_Cmd_Buff,AT_WiFi_SCAN);
-status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-if(status == WiFi_MODULE_SUCCESS)
-{
-status = USART_Receive_AT_Resp(Process_Event);
-}
-
-/*At this point we have WiFi_Scan_Buffer filled with RSSI and SSID values*/
-return status;
-}
-
-/**
-* @brief Set_MiniAP_Mode
-* Configure Wi-Fi module in AP mode.
- MiniAP is always configured in open mode (WEP not supported)
-* @param None
-* @retval WiFi_Status_t : status of AT cmd
-*/
-WiFi_Status_t wifi_ap_start(uint8_t * ssid, uint8_t channel_num)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-/* Set the SSID : AT+S.SSIDTXT=<SSID>*/
-//if(ssid)
- status = SET_SSID((char*)ssid);
-
-
-if(status != WiFi_MODULE_SUCCESS)
-return WiFi_SSID_ERROR;
-
-/* Set the network privacy mode : AT+S.SCFG=wifi_priv_mode,0*/
-status = SET_Configuration_Value(WIFI_PRIV_MODE, None);
-if(status != WiFi_MODULE_SUCCESS)
-return WiFi_CONFIG_ERROR;
-
-/* Set the network mode (1 = STA, 2 = IBSS, 3 = MiniAP) :: AT+S.SCFG=wifi_mode,3*/
-status = SET_Configuration_Value(WIFI_MODE, WiFi_MiniAP_MODE);
-if(status != WiFi_MODULE_SUCCESS)
-return WiFi_CONFIG_ERROR;
-
-/* Set the channel number */
-status = SET_Configuration_Value(WIFI_CHANNEL_NUMBER, channel_num);
-if(status != WiFi_MODULE_SUCCESS)
-return WiFi_CONFIG_ERROR;
-
-/* Save the settings on the flash memory : AT&W*/
-Save_Current_Setting();
-
-status_flag.WiFi_Configuration_Done = WIFI_TRUE;
-WiFi_Module_State = Process_Event;
-
-/* Soft reset the module */
-SET_Power_State(PowerSave_State);
-
-return status;
-}
-
-
-/**
-* @brief SET_WiFi_STA_Mode
-* Configure Wi-Fi module in STA mode
-* @param SSID : SSID name
-* @param sec_key : security key
-* @param priv_mode : network privecy mode
-* @retval WiFi_Status_t : status of AT cmd
-*/
-WiFi_Status_t wifi_connect(char * ssid, char * sec_key, WiFi_Priv_Mode priv_mode)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-if(status_flag.AT_Cmd_Ongoing == WIFI_FALSE)
-status_flag.AT_Cmd_Ongoing = WIFI_TRUE;
-else
-{
-return WiFi_AT_CMD_BUSY;
-}
-
-if(sec_key) {
-status = SET_WiFi_SecKey((char*)sec_key);
-if(status != WiFi_MODULE_SUCCESS)
- return WiFi_SecKey_ERROR;
-}
-
-/* Set the SSID : AT+S.SSIDTXT=<SSID>*/
-
- status = SET_SSID((char*)ssid);
-
-if(status != WiFi_MODULE_SUCCESS)
-return WiFi_SSID_ERROR;
-
-/* Set the network privacy mode : AT+S.SCFG=wifi_priv_mode,2*/
-status = SET_Configuration_Value(WIFI_PRIV_MODE, priv_mode);
-if(status != WiFi_MODULE_SUCCESS)
-return WiFi_CONFIG_ERROR;
-
-/* Set the network mode (1 = STA, 2 = IBSS, 3 = MiniAP) :: AT+S.SCFG=wifi_mode,1*/
-status = SET_Configuration_Value(WIFI_MODE, WiFi_STA_MODE);
-if(status != WiFi_MODULE_SUCCESS)
-return WiFi_CONFIG_ERROR;
-
-/* Save the settings on the flash memory : AT&W*/
-Save_Current_Setting();
-
-status_flag.WiFi_Configuration_Done = WIFI_TRUE;
-//WiFi_Module_State = WiFi_Process_Event;
-
-/* Soft reset the module */
-SET_Power_State(PowerSave_State);
-
-status_flag.AT_Cmd_Ongoing = WIFI_FALSE;
-
-return status;
-}
-
-/**
-* @brief SET_WiFi_IBSS_Mode
-* Configure Wi-Fi module in IBSS mode
-* @param SSID : SSID name
-* @param priv_mode : network privecy mode
-* @retval WiFi_Status_t : status of AT cmd
-*/
-WiFi_Status_t wifi_adhoc_create(uint8_t * ssid, WiFi_Priv_Mode priv_mode)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-Attention_Cmd();
-/* Set the SSID : AT+S.SSIDTXT=<SSID>*/
-status = SET_SSID((char*)ssid);
-if(status != WiFi_MODULE_SUCCESS)
-return WiFi_SSID_ERROR;
-
-/* Set the network privacy mode : AT+S.SCFG=wifi_priv_mode,0*/
-status = SET_Configuration_Value(WIFI_PRIV_MODE, priv_mode);
-if(status != WiFi_MODULE_SUCCESS)
- return WiFi_CONFIG_ERROR;
-
-
-/* Set the network mode (1 = STA, 2 = IBSS, 3 = MiniAP) :: AT+S.SCFG=wifi_mode,2*/
-status = SET_Configuration_Value(WIFI_MODE, WiFi_IBSS_MODE);
-if(status != WiFi_MODULE_SUCCESS)
- return WiFi_CONFIG_ERROR;
-
-/* Set IP address */
-status = SET_Configuration_Addr(WIFI_IP_ADDRESS, WIFI_IBSS_IP_ADDR);
-if(status != WiFi_MODULE_SUCCESS)
- return WiFi_CONFIG_ERROR;
-
-/* Set IP default gateway */
-status = SET_Configuration_Addr(WIFI_IP_DEFAULT_GATEWAY, WIFI_IBSS_DEFAULT_GATEWAY);
-if(status != WiFi_MODULE_SUCCESS)
- return WiFi_CONFIG_ERROR;
-
-
-/* Set IP DNS */
-status = SET_Configuration_Addr(WIFI_IP_DNS, WIFI_IBSS_IP_DNS_ADDR);
-if(status != WiFi_MODULE_SUCCESS)
- return WiFi_CONFIG_ERROR;
-
-/* Set IP netmask */
-status = SET_Configuration_Addr(WIFI_IP_NETMASK, WIFI_IBSS_IP_MASK);
-if(status != WiFi_MODULE_SUCCESS)
- return WiFi_CONFIG_ERROR;
-
-/* Turn OFF the DHCP */
-SET_Configuration_Value(IP_USE_DHCP_SERVER, WIFI_IP_USE_DHCP);
-if(status != WiFi_MODULE_SUCCESS)
- return WiFi_CONFIG_ERROR;
-
-/* Save the settings on the flash memory : AT&W*/
-Save_Current_Setting();
-
-/* Soft reset the module */
-SET_Power_State(PowerSave_State);
-return status;
-}
-
-
-/**
-* @brief wifi_standby
-* Configured WiFi module to enter standby
-* @param arg_standby_time: standby time
-* @retval WiFi_Status_t : status of AT cmd
-*/
-WiFi_Status_t wifi_standby(uint8_t arg_standby_time)
-{
-/*
-For Standby, the presence of Jumpers on JP4 and JP3 has the following behaviour:
-JP3 (middle and bottom): prevents standby and immediately wakes-up module
-JP3 (middle and top): no effect on standby
-JP4 (middle and right): prevents wakeup and standby runs forever
-JP4 (middle and left): no effect on standby
-*/
-
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-/*if(arg_standby_time<2)
-return WiFi_NOT_SUPPORTED;*/
-
-SET_Configuration_Value(WIFI_SLEEP_ENABLED, 0);
-SET_Configuration_Value(WIFI_STANDBY_ENABLED, 1);
-status = SET_Configuration_Value(WIFI_STANDBY_TIME, arg_standby_time);
-
-/* save current setting in flash */
-Save_Current_Setting();
-
-/* AT : send AT command */
-sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_POWER_STATE,1); //cfun=4
-WiFi_Module_State = Process_Event; //make sure the WiFi module is in this state to receive WINDS after wakeup
-status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-
-if(status == WiFi_MODULE_SUCCESS)//if transmit is success, prepare for resume
-{
-/*
-status_flag.AT_Cmd_Processing = WIFI_TRUE;//We do not want the next UART data_byte fetch to be done
-HAL_NVIC_DisableIRQ(USARTx_IRQn);//Disable UART IRQ
-status_flag.Standby_Timer_Running=WIFI_TRUE;
-printf("\r\nGoing into Standby Mode...\r\n");*/
-}
-
-return status;
-
-}
-
-/**
-* @brief wifi_wakeup
-* wakeup the module from sleep by setting the GPIO6 through PC13
-* or allow it to go to sleep
-* Jumper needed on JP4
-* @param wakeup wakeup (WIFI_TRUE) or allow sleep(WIFI_FALSE)
-* @retval WiFi_Status_t : status of function call
-*/
-WiFi_Status_t wifi_wakeup(wifi_bool wakeup)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- if(wakeup)
- callSpwfSADevice_wakeup(spwf_device_class, 1);
- else
- callSpwfSADevice_wakeup(spwf_device_class, 0);
- wait_ms(100);
- return status;
-}
-
-
-/**
-* @brief wifi_disconnect
-* disconnect the module from any AP
-* @param None
-* @retval WiFi_Status_t : status of AT cmd
-*/
-WiFi_Status_t wifi_disconnect(void)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-/* Set wifi_mode to idle*/
-status = SET_Configuration_Value(WIFI_MODE, WiFi_IDLE_MODE);
-
-/*If module was connected, reset the status*/
-if(wifi_connected == 1)
- {
- wifi_connected = 0;//this will allow the TIM handler to make the callback on connection(WiFiUp)
- }
-
-/* save current setting in flash */
-Save_Current_Setting();
-
-/* Soft reset the module */
-status = SET_Power_State(PowerSave_State);//CFUN=1
-
-return status;
-}
-
-/**
-* @brief wifi_enable
-* Enable/Disable the Wi-Fi interface
-* @param enable enable Wi-Fi (WIFI_TRUE) disable Wi-Fi (WIFI_FALSE)
-* @retval WiFi_Status_t : status of AT cmd
-*/
-WiFi_Status_t wifi_enable(wifi_bool enable)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-/* Enable or Disable wifi interface*/
-Reset_AT_CMD_Buffer();
-sprintf((char*)WiFi_AT_Cmd_Buff,AT_WIFI_ENABLE, enable);
-
-/*if(HAL_UART_Transmit(&UartWiFiHandle, (uint8_t *)WiFi_AT_Cmd_Buff, strlen((char*)WiFi_AT_Cmd_Buff),1000)!= HAL_OK)
-{
-Error_Handler();
-#if DEBUG_PRINT
-printf("HAL_UART_Transmit Error");
-#endif
-return WiFi_HAL_UART_ERROR;
-} */
-
-status = USART_Receive_AT_Resp(Process_Event);
-
-//wait for power down/hw started
-if(enable)
-while(status_flag.WiFi_Enabled != WIFI_TRUE)
-{
- asm("NOP");
-}
-else
-while(status_flag.WiFi_Enabled != WIFI_FALSE)
-{
- asm("NOP");
-}
-
-return status;
-
-}
-
-
-
-/**
-* @brief wifi_restore
-* Restore the Wi-Fi with default values.
-* @param None
-* @retval WiFi_Status_t : status of AT cmd
-*/
-WiFi_Status_t wifi_restore()
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-/* Restore default setting*/
-Restore_Default_Setting();
-
-/* Set wifi_mode to idle*/
-SET_Configuration_Value(WIFI_MODE, WiFi_IDLE_MODE);
-
-/* set the local echo */
-SET_Configuration_Value(LOCALECHO1, 0);
-
-/* save current setting in flash */
-Save_Current_Setting();
-
-/* Soft reset the module */
-status = SET_Power_State(PowerSave_State);//CFUN=1
-
-return status;
-}
-
-/*GPIO Configuration Functions*/
-
-/**
-* @brief wifi_gpio_init
-* Configure a GPIO pin as in or out with IRQ setting
-* @param pin GPIO pin number
-* @param irq configuration of the pin
-* @retval WiFi_Status_t : status of AT cmd
-*/
-uint8_t wifi_gpio_init(GpioPin pin, char* dir, char irq)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-/* AT+S.GPIOC=pin,dir,irq */
-Reset_AT_CMD_Buffer();
-
-memset(WiFi_AT_Cmd_Buff, 0x00, sizeof WiFi_AT_Cmd_Buff);
-
-if(irq!=GPIO_Off)
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.GPIOC=%d,%s,%c\r", pin, dir, irq);
-else
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.GPIOC=%d,%s\r", pin, dir);
-
-status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
-
-
-return status;
-
-}
-
-/**
-* @brief wifi_gpio_read
-* Read the configuration of a GPIO pin
-* @param pin GPIO pin number
-* @param val value returned
-* @param dir configuration direction returned
-* @retval WiFi_Status_t : status of AT cmd
-*/
-uint8_t wifi_gpio_read(GpioPin pin, uint8_t *val, uint8_t *dir)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-/* AT+S.GPIOR=pin */
-Reset_AT_CMD_Buffer();
-
-sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.GPIOR=%d\r", pin);
-
-status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
-*val = gpio_value;
-*dir = gpio_direc;
-
-return status;
-}
-
-/**
-* @brief wifi_gpio_write
-* Read the value of a GPIO pin
-* @param pin GPIO pin number
-* @param val value to be configured
-* @retval WiFi_Status_t : status of AT cmd
-*/
-uint8_t wifi_gpio_write(GpioPin pin, GpioWriteValue value)
-{
-WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-/* AT+S.GPIOW=pin,value */
-Reset_AT_CMD_Buffer();
-
-sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.GPIOW=%d,%d\r", pin, value);
-
-status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
-
-return status;
-}
-
-void UART_Configuration(uint32_t baud_rate)
-{
-}
-
-#ifdef USART_PRINT_MSG
-void USART_PRINT_MSG_Configuration(uint32_t baud_rate)
-{
-}
-#endif
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-
-/**
- * @}
- */
-
-/******************* (C) COPYRIGHT 2015 STMicroelectronics *****END OF FILE****/
-
-
--- a/spwf/wifi_module.c Wed Apr 13 11:34:07 2016 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3427 +0,0 @@
-/**
- ******************************************************************************
- * @file wifi_module.c
- * @author Central LAB
- * @version V2.0.0
- * @date 10-February-2016
- * @brief Enable Wi-Fi functionality using AT cmd set
- ******************************************************************************
- * @attention
- *
- * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * 3. Neither the name of STMicroelectronics nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************
- */
-/* Includes ------------------------------------------------------------------*/
-#include "wifi_module.h"
-//#include "stm32_spwf_wifi.h"
-#include "ring_buffer.h"
-#include "stdio.h"
-#include "string.h"
-#include "event_buffer.h"
-#include "device.h"
-#include "wait_api.h"
-#include <stddef.h>
-
-
-/** @addtogroup MIDDLEWARES
-* @{
-*/
-
-
-/** @defgroup NUCLEO_WIFI_MODULE
- * @brief Wi-Fi driver modules
- * @{
- */
-
-
-/** @defgroup NUCLEO_WIFI_MODULE_Private_Defines
- * @{
- */
-
-
-/**
- * @}
- */
-
-
-/** @addtogroup NUCLEO_WIFI_MODULE_Private_Variables
- * @{
- */
-/* Private variables ---------------------------------------------------------*/
-
-/*All Buffers*/
-//uint8_t WiFi_AT_Cmd_Buff[1024];
-uint8_t process_buffer[MAX_BUFFER_GLOBAL];
-char UserDataBuff[MAX_BUFFER_GLOBAL];
-uint8_t USART_RxBuffer[64];//This buffer is only used in the Init phase (to receive "\r\nOK\r\n")
-char print_msg_buff[MAX_BUFFER_GLOBAL];
-volatile uint8_t ring_buffer[RINGBUF_SIZE];/* Default size for ring buffer */
-
-#ifdef USE_STM32L0XX_NUCLEO
-event_s_TypeDef event_buffer[10];
-#else
-event_s_TypeDef event_buffer[50];
-#endif
-
-volatile uint8_t pop_buffer[MAX_BUFFER_GLOBAL];
-volatile uint8_t prefetch_buffer[20];
-uint8_t uart_byte[1];
-buffer_td big_buff;
-buffer_e event_buff;
-event_s_TypeDef element;
-uint8_t HTTP_Runway_Buff[6];//Used to store the last 6 bytes in between User Callbacks during HTTP tx
-wifi_scan *wifi_scanned_list; //[MAX_WIFI_SCAN_NETWORK];
-
-volatile Wifi_Status_Var status_flag;
-
-uint32_t wind64_DQ_wait = 0;
-uint32_t UserDataBuff_index;
-volatile uint32_t tickcount;
-uint8_t SocketId;
-uint32_t SockON_Data_Len;
-uint32_t Socket_Data_Length =0;
-uint8_t Socket_Open_ID, sockon_query_id,sockon_id_user;
-uint32_t SockON_Data_Length;
-uint8_t enable_pending_data =0;
-
-volatile WiFi_WIND_State_TypeDef WiFi_WIND_State;//describes the current WIND number in processing
-
-uint8_t WiFi_Resp_OK = 0;
-uint32_t number_of_bytes=0;
-uint32_t interim_number_of_bytes=0;
-uint32_t Interim_SockON_Data_Len=0;
-uint32_t bytes_to_be_read = 0;
-uint32_t sock_total_count=0;
-uint32_t sockD_total_count=0;
-uint32_t ip_fragment_count=0;
-uint32_t chunk_size;
-uint32_t message_size;
-uint32_t WIND55_count=0;
-volatile uint32_t WIND64_count=0;
-uint8_t user_scan_number;
-uint32_t pop_queue_length;
-uint32_t pop_buffer_size=0;
-uint32_t process_buffer_index = 5;
-uint32_t epoch_time = 0;
-
-volatile WiFi_AT_CMD_Response_t WiFi_Module_State;
-
-uint8_t *WiFi_Scan_Buffer;
-uint8_t * curr_hostname;
-uint8_t * curr_path;
-uint8_t * curr_pURL;
-uint8_t * curr_protocol;
-uint32_t curr_port_number;
-char * curr_data;
-uint8_t curr_sockID;
-uint8_t * curr_filename;
-uint16_t curr_DataLength;
-uint16_t sock_server_write_datalength;
-char *sock_server_write_pdata;
-
-uint8_t socket_closed_id_callback;
-uint8_t remote_socket_closed_id;
-uint8_t client_socket_close_id;
-volatile uint8_t wifi_ready = WIFI_FALSE;//Set once if wifi is ready for first time
-volatile uint8_t wifi_connected = WIFI_FALSE;//Set once if wifi is connected for first time
-volatile uint8_t wifi_client_connected = 0;//Set once if client is connected
-volatile uint8_t wifi_client_disconnected = 0;//Set once if client is dis-connected
-uint8_t gpio_value, gpio_direc, get_cfg_value[64];
-WiFi_Status_t user_error_code = WiFi_MODULE_SUCCESS;
-
-uint8_t no_of_open_client_sockets = 0;
-wifi_bool open_sockets[8]; //Max open sockets allowed is 8. Each array element depicts one socket (true=open, false=closed)
-uint8_t client_MAC_address[17];//current client MAC address store
-
-uint8_t enable_uart_byte_data_receive=1;
-uint8_t uart_data_receive_ready=1;
-
-WiFi_Status_t AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
-uint32_t sleep_count = 0;
-uint32_t standby_time = 0;
-uint8_t scanned_ssids = 0;
-char * prefetch_str;
-
-#if defined (USE_STM32F4XX_NUCLEO) || (USE_STM32L4XX_NUCLEO)
-uint8_t WiFi_AT_Cmd_Buff[2048];
-#else
-uint8_t WiFi_AT_Cmd_Buff[1024];
-#endif
-
-#ifdef USART_PRINT_MSG
-#define printf(arg) {sprintf((char*)print_msg_buff,arg); \
-HAL_UART_Transmit(&UartMsgHandle, (uint8_t*)print_msg_buff, strlen(print_msg_buff), 1000);}
-#endif
-
-void * spwf_dev_;
-
-extern void callSpwfSADevice_debug(void* object, const char * string);
-extern void callSpwfSADevice_attach(wifi_bool attach);
-
-#if defined (__CC_ARM)
-size_t strnlen (const char* s, size_t maxlen);
-
-size_t strnlen (const char* s, size_t maxlen)
- {
- size_t len = 0;
-
- while ((len <= maxlen) && (*s))
- {
- s++;
- len++;
- }
-
- return len;
- }
-#endif
-
-event_s_TypeDef event_s;
-event_s_TypeDef * event_pop_s;
-
-// [DLI]
-#ifdef WIFI_USE_VCOM
-
-uint8_t console_listen_char[1];
-uint8_t console_input_char[1];
-uint8_t console_send_char[1];
-uint8_t console_echo_char[1];
-uint8_t console_send_ready = 0;
-uint8_t console_echo_ready = 1;
-uint8_t console_push_ready = 0;
-
-// Virtual-COM UART
-void console_input() {
- //HAL_UART_Receive_IT(&UartMsgHandle, (uint8_t *)console_input_char, 1);
-}
-
-void wifi_vcom() {
-
- uint8_t * temp;
-
- if (console_push_ready == 1) {
- push_buffer(&big_buff, uart_byte);
- console_push_ready = 0;
- //HAL_UART_Receive_IT(&UartWiFiHandle, (uint8_t *)uart_byte, 1);
- }
- if(console_echo_ready == 0) {
- temp = pop_buffer_queue(&big_buff);
- if(temp != NULL) {
- console_echo_ready = 1;
- //HAL_UART_Transmit_IT(&UartMsgHandle, temp, 1);
- }
- }
-}
-
-#endif
-
-/**
- * @}
- */
-
-/** @defgroup NUCLEO_WIFI_MODULE_Private_Functions
- * @{
- */
-
-/**
- *Changed/introduced functions for MBED implementation:
-
-- void Wifi_TIM_Handler(void); - new fn
-- void Rx_irq_handler(void); - new fn - in place of HAL_UART_RxCpltCallback
-- Receive_Data(); - modified fn
-- void wifi_reset(void) - modified fn
-- void PowerUp_WiFi_Module(void) - modified fn
-- void RX_EXTI_Isr(uint16_t GPIO_Pin) - removed fn
-- void HAL_UART_TxCpltCallback(UART_HandleTypeDef *UartHandleArg) - removed fn
-- void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandleArg) - removed fn
-- void HAL_UART_ErrorCallback(UART_HandleTypeDef *UartHandle) - removed fn
-- WiFi_Status_t USART_Transmit_AT_Cmd(uint16_t size)- modified fn
-*/
-
-
-
-/**
- * @brief WiFi_Module_Init
- * Initialize wifi module
- * @param None
- * @retval None
- */
-void WiFi_Module_Init(void)
-{
-#ifdef WIFI_USE_VCOM
- console_input();
-#else
- WiFi_Module_State = Process_Event;
-#endif
-
- initialize_status_flags();
- init(&big_buff, RINGBUF_SIZE);//Init the ring buffer
- wifi_ready = 0; //reset to get user callback on HW started
- wifi_connected = 0; //reset to get user callback on WiFi UP
- Receive_Data();
-
-#ifdef USE_STM32L0XX_NUCLEO
- event_init(&event_buff, 10); //max 15 events can be Q'ed (Event Buffer is of size 15)
-#else
- event_init(&event_buff, 50); //max 50 events can be Q'ed (Event Buffer is of size 50)
-#endif
-
-#ifndef WIFI_USE_VCOM
- Start_Timer();
- memset(open_sockets,0x00, 8); //init the open socket array
-
-#endif
-}
-
-/**
-* @brief initialize_status_flags
-* Default Wifi status values
-* @param None
-* @retval None
-*/
-void initialize_status_flags()
-{
- status_flag.Single_Digit_Indication = WIFI_FALSE;
- status_flag.WiFi_Enabled = WIFI_FALSE;
- status_flag.http_req_pending = WIFI_FALSE;
- status_flag.WiFi_Configuration_Done = WIFI_FALSE;
- status_flag.Timer_Running = WIFI_FALSE;
- status_flag.resume_receive_data = WIFI_FALSE;
- status_flag.enable_dequeue = WIFI_TRUE;
- status_flag.stop_event_dequeue = WIFI_FALSE;
- status_flag.Standby_Timer_Running = WIFI_FALSE;
- status_flag.trigger_wakeup_callback = WIFI_FALSE;
- status_flag.Deep_Sleep_Enabled = WIFI_FALSE;
- status_flag.Standby_Enabled = WIFI_FALSE;
- status_flag.Low_Power_Enabled = WIFI_FALSE;
- status_flag.command_mode=WIFI_TRUE;
- status_flag.data_mode=WIFI_FALSE;
- status_flag.Scan_Ongoing = WIFI_FALSE;
- status_flag.AT_Cmd_Ongoing = WIFI_FALSE;
- status_flag.AT_Cmd_Processing = WIFI_FALSE;
- status_flag.Uartx_Rx_Processing = WIFI_FALSE;
- status_flag.Client_Connected = WIFI_FALSE;
- status_flag.Client_Disconnected = WIFI_FALSE;
- status_flag.switch_by_default_to_command_mode = WIFI_TRUE;
- status_flag.start_sock_read = WIFI_FALSE;
- status_flag.enable_receive_data_chunk = WIFI_FALSE;
- status_flag.data_pending_sockD=WIFI_FALSE;
- status_flag.enable_sock_read = WIFI_FALSE;
- status_flag.enable_query = WIFI_FALSE;
- status_flag.Set_AT_Cmd_Response_False = WIFI_FALSE;
- status_flag.enable_fw_update_read = WIFI_FALSE;
- status_flag.Q_Contains_Message = WIFI_FALSE;
- status_flag.Q_Contains_Data = WIFI_FALSE;
- status_flag.enable_receive_http_response = WIFI_FALSE;
- status_flag.enable_receive_file_response = WIFI_FALSE;
- status_flag.enable_receive_wifi_scan_response = WIFI_FALSE;
- status_flag.prevent_push_OK_event = WIFI_FALSE;
- status_flag.client_socket_close_ongoing = WIFI_FALSE;
- status_flag.prevent_push_WIFI_event = WIFI_FALSE;
- status_flag.sock_read_ongoing = WIFI_FALSE;
- status_flag.enable_client_socket_write = WIFI_FALSE;
- status_flag.event_deQ_x_wind64 = WIFI_FALSE;
- status_flag.do_not_reset_push_WIFI_event = WIFI_FALSE;
- status_flag.message_pending = WIFI_FALSE;
- status_flag.Pending_SockON_Callback = WIFI_FALSE;
- status_flag.Pending_SockD_Callback = WIFI_FALSE;
- status_flag.SockON_Server_Closed_Callback = WIFI_FALSE;
- status_flag.Client_Socket_Close_Cmd = WIFI_FALSE;
- status_flag.standby_resume_callback = WIFI_FALSE;
- status_flag.HTTP_Data_available = WIFI_FALSE;
- status_flag.FILE_Data_available = WIFI_FALSE;
- status_flag.AT_Response_Received = WIFI_FALSE;
- status_flag.Deep_Sleep_Timer = WIFI_FALSE;
- status_flag.Deep_Sleep_Callback = WIFI_FALSE;
-}
-
-
-/**
-* @brief Period elapsed callback in non blocking mode
-* This timer is used for calling back User registered functions with information
-* @param htim : TIM handle
-* @retval None
-*/
-
-void Wifi_TIM_Handler(void)
-{
- /**********************************************************************
- * *
- * Be careful not to make a blocking *
- * call from this function, see *
- * example Socket_Read() and Socket_Close() *
- * *
- **********************************************************************/
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- if(status_flag.stop_event_dequeue == WIFI_FALSE /*&& !status_flag.enable_receive_data_chunk*/)
- {
- __disable_irq();
- event_pop_s = pop_eventbuffer_queue(&event_buff);
- __enable_irq();
-
- if(event_pop_s!=NULL && event_pop_s->event_pop == WIFI_TRUE)
- {
- switch(event_pop_s->event)
- {
- case WIFI_WIND_EVENT:
- Process_WiFi_Indication_Cmd(event_pop_s);
- break;
-
- case WIFI_OK_EVENT:
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_MODULE_SUCCESS;
- if(status_flag.Set_AT_Cmd_Response_False == WIFI_TRUE)
- {
- status_flag.Set_AT_Cmd_Response_False = WIFI_FALSE;
- status_flag.AT_Response_Received = WIFI_FALSE;
- }
- if(status_flag.enable_client_socket_write) //allows the OK received after socket client write to be processed
- {
- status_flag.AT_Response_Received = WIFI_TRUE;
- status_flag.enable_client_socket_write = WIFI_FALSE;
- }
- break;
-
- case WIFI_SOCK_ID_EVENT:
- /*check ID and update SocketID array*/
- no_of_open_client_sockets++;
-
- if(no_of_open_client_sockets > 8) //Max number of clients is 8
- {
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_NOT_SUPPORTED;
- break;
- }
-
- open_sockets[event_pop_s->socket_id] = WIFI_TRUE;
- Socket_Open_ID = event_pop_s->socket_id;
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_MODULE_SUCCESS;
- break;
-
- case WIFI_HTTP_EVENT:
- Reset_AT_CMD_Buffer();
- memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);//Flush the buffer
-
- if(curr_pURL) {
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_HTTPPOST_REQUEST,curr_pURL);
- }
- else {
- if(curr_port_number!=0)
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.HTTPGET=%s,%s,%d\r",curr_hostname, curr_path, (int)curr_port_number);
- else
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.HTTPGET=%s,%s\r",curr_hostname, curr_path);
- }
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS) {
- WiFi_Module_State = Process_Event;
- status_flag.stop_event_dequeue = WIFI_TRUE;
- status_flag.http_req_pending = WIFI_TRUE;
- }
- else {
- #if DEBUG_PRINT
- printf("\r\n ERROR IN HTTP \r\n");
- #endif
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- status_flag.AT_Response_Received = WIFI_TRUE;
- }
- break;
-
- case WIFI_CLIENT_SOCKET_WRITE_EVENT:
- Reset_AT_CMD_Buffer();
- /* AT+S.SOCKW=00,11<cr> */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SOCKET_WRITE,curr_sockID,curr_DataLength);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-
- if(status == WiFi_MODULE_SUCCESS) {
- Reset_AT_CMD_Buffer();
- memcpy((char*)(char*)WiFi_AT_Cmd_Buff, (char*)curr_data,curr_DataLength);
- WiFi_AT_Cmd_Buff[curr_DataLength]='\r';
-
- status = USART_Transmit_AT_Cmd(curr_DataLength+2);
- if(status == WiFi_MODULE_SUCCESS) {
- WiFi_Module_State = Process_Event;
- }
- else {
- #if DEBUG_PRINT
- printf("\r\n ERROR IN SOCKET\r\n");
- #endif
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- }
- }
- else {
- #if DEBUG_PRINT
- printf("\r\n ERROR In Socket\r\n");
- #endif
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- }
- break;
-
- case WIFI_CLIENT_SOCKET_OPEN_EVENT:
- Reset_AT_CMD_Buffer();
-
- /* AT+S.SOCKON = myserver,1234,t <cr> */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SOCKET_OPEN,curr_hostname,(int)curr_port_number,curr_protocol);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status != WiFi_MODULE_SUCCESS)
- {
- #if DEBUG_PRINT
- printf("\r\n ERROR During Socket Open \r\n");
- #endif
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- }
- break;
-
- case WIFI_CLIENT_SOCKET_CLOSE_EVENT:
- Reset_AT_CMD_Buffer();
-
- /* AT+S.SOCKC=00<cr> */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SOCKET_CLOSE,event_pop_s->socket_id);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- AT_RESPONSE = WiFi_MODULE_SUCCESS;
- status_flag.prevent_push_OK_event = WIFI_TRUE; //prevent the OK received after socket close command to be Q'ed
- status_flag.stop_event_dequeue = WIFI_TRUE;
- remote_socket_closed_id = event_pop_s->socket_id;
- status_flag.client_socket_close_ongoing = WIFI_TRUE; //used for making changes in the value of open_sockets[sock_id] if no error is returned
-// status_flag.SockON_Server_Closed_Callback = WIFI_TRUE;
- }
- else
- {
- #if DEBUG_PRINT
- printf("\r\n ERROR During Socket Close \r\n");
- #endif
- }
- break;
-
-
- case WIFI_FILE_EVENT:
- Reset_AT_CMD_Buffer();
-
- if(curr_filename == NULL)
- {
- /* AT+S.FSL */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_DISPLAY_FILE_NAME);
- }
- else if(curr_hostname == NULL)
- {
- /* AT+S.FSP=/index.html */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_DISPLAY_FILE_CONTENT,curr_filename);
- }
- else
- {
- /* AT+S.HTTPDFSUPDATE=%s,/outfile.img */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_DOWNLOAD_IMAGE_FILE,curr_hostname,curr_filename,(int)curr_port_number);
- }
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- WiFi_Module_State = Process_Event;
- status_flag.enable_receive_http_response = WIFI_TRUE;
- status_flag.enable_receive_data_chunk = WIFI_TRUE;
- status_flag.enable_receive_file_response = WIFI_TRUE;
- }
- else {
- #if DEBUG_PRINT
- printf("\r\n ERROR in FILE \r\n");
- #endif
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- }
- break;
-
- case WIFI_FW_UPDATE_EVENT:
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.FWUPDATE=%s,/%s,%d\r",curr_hostname,curr_filename,(int)curr_port_number);
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- WiFi_Module_State = Process_Event;
- status_flag.enable_fw_update_read = WIFI_TRUE;
- status_flag.enable_receive_data_chunk = WIFI_TRUE;
- }
- else
- {
- #if DEBUG_PRINT
- printf("\r\n ERROR in Firmware \r\n");
- #endif
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- }
- break;
-
- case WIFI_ERROR_EVENT:
- #if DEBUG_PRINT
- printf("\r\n ERROR!\r\n");
- #endif
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- break;
-
- case WIFI_GCFG_EVENT:
- case WIFI_GPIO_EVENT:
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_MODULE_SUCCESS;
- break;
-
- case WIFI_STANDBY_CONFIG_EVENT:
- #if DEBUG_PRINT
- printf("\r\nGoing into standby..\r\n");
- #endif
- WiFi_Module_State = Process_Event;
- break;
-
- case WIFI_RESUME_CONFIG_EVENT:
- #if DEBUG_PRINT
- printf("\r\nResuming from standby..\r\n");
- #endif
- status_flag.AT_Response_Received = WIFI_TRUE;//let main run-on
- break;
-
- case WIFI_NO_EVENT:
- break;
- }
- }
- }
- /* If data is pending on client socket SOCKON, make read requests*/
- if(status_flag.start_sock_read == WIFI_TRUE)
- {
- //flush_buffer_queue(&big_buff);
- Socket_Read(Socket_Data_Length);
- status_flag.start_sock_read = WIFI_FALSE;
- }
-
- /* Call Query, after notification for TLS is received */
- else if(status_flag.enable_query == WIFI_TRUE && status_flag.enable_dequeue == WIFI_TRUE)
- {
- //@TBD: Flushing the buffer may be detrimental if we have genuine follow on WIND55?
- //flush_buffer_queue(&big_buff); //Flush the buffer to remove WIND:55 in pipeline (This maybe a problem)
- Socket_Pending_Data();
- status_flag.enable_query = WIFI_FALSE;
- }
-
- else if(status_flag.Pending_SockON_Callback==WIFI_TRUE)//for client socket
- {
- //Now callback to user with user_data pointer <UserDataBuff>
- ind_wifi_socket_data_received(sockon_id_user, (uint8_t *)UserDataBuff, message_size, chunk_size);
- memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);//Flush the buffer
- Resume_Dequeue();
- status_flag.Pending_SockON_Callback=WIFI_FALSE;
- }
-
- else if(status_flag.Pending_SockD_Callback == WIFI_TRUE)//for server socket
- {
- //if(status_flag.command_mode)//if command_mode is achieved then callback else loop in this state
- {
- //Now callback to user with user_data pointer <UserDataBuff>
- ind_wifi_socket_data_received(9, (uint8_t *)UserDataBuff, message_size, chunk_size);
- memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);//Flush the buffer
- Resume_Dequeue();
- status_flag.Pending_SockD_Callback=WIFI_FALSE;
- }
- }
-
- else if(status_flag.Client_Socket_Close_Cmd==WIFI_TRUE)//for client socket
- {
- //Close the socket
- //Change State to AT_Cmd_Response before calling socket_close()
- WiFi_Module_State = Process_Event;
- wifi_socket_client_close(client_socket_close_id);
- status_flag.Client_Socket_Close_Cmd = WIFI_FALSE;
-// status_flag.SockON_Server_Closed_Callback = WIFI_TRUE;
- }
-
- else if(status_flag.SockON_Server_Closed_Callback==WIFI_TRUE)//for client socket
- {
- //callback the user
- ind_wifi_socket_client_remote_server_closed(&socket_closed_id_callback);
- status_flag.SockON_Server_Closed_Callback = WIFI_FALSE;
- }
-
- else if(status_flag.HTTP_Data_available == WIFI_TRUE)
- {
- ind_wifi_http_data_available((uint8_t *)UserDataBuff,UserDataBuff_index);
- memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);//Flush the buffer
-// memcpy(&UserDataBuff, &HTTP_Runway_Buff, 6);
-// memset(HTTP_Runway_Buff, 0x00, 6);
- Resume_Dequeue();
- status_flag.HTTP_Data_available=WIFI_FALSE;
- }
-
- else if (status_flag.FILE_Data_available == WIFI_TRUE)
- {
- ind_wifi_file_data_available((uint8_t *) UserDataBuff);
- memset(UserDataBuff, 0x00, MAX_BUFFER_GLOBAL);//Flush the buffer
- Resume_Dequeue();
- status_flag.FILE_Data_available = WIFI_FALSE;
- }
- else if(status_flag.Client_Connected == WIFI_TRUE)
- {
- ind_socket_server_client_joined();
- status_flag.Client_Connected = WIFI_FALSE;
- }
-
- else if(status_flag.Client_Disconnected == WIFI_TRUE)
- {
- ind_socket_server_client_left();
- status_flag.Client_Disconnected = WIFI_FALSE;
- }
-
- //Make callbacks from here to user for pending events
-
- if(WiFi_WIND_State.WiFiHWStarted==WIFI_TRUE)
- {
- if(wifi_ready == 2)//Twice reset for User Callback
- {
- wifi_ready++;
- ind_wifi_on();//Call this once only...This if for wifi_on (instead of console active
- }
- }
-
- if(WiFi_WIND_State.WiFiUp == WIFI_TRUE)
- {
- if(wifi_connected == 0)
- {
- wifi_connected = 1;
- ind_wifi_connected();//wifi connected
- }
- WiFi_WIND_State.WiFiUp = WIFI_FALSE;
- }
-
- else if(WiFi_WIND_State.WiFiStarted_MiniAPMode == WIFI_TRUE)
- {
- ind_wifi_ap_ready();
- WiFi_WIND_State.WiFiStarted_MiniAPMode = WIFI_FALSE;
- }
-
- else if(WiFi_WIND_State.WiFiAPClientJoined == WIFI_TRUE)
- {
- ind_wifi_ap_client_joined(client_MAC_address);
- WiFi_WIND_State.WiFiAPClientJoined = WIFI_FALSE;
- }
-
- else if(WiFi_WIND_State.WiFiAPClientLeft == WIFI_TRUE)
- {
- ind_wifi_ap_client_left(client_MAC_address);
- WiFi_WIND_State.WiFiAPClientLeft = WIFI_FALSE;
- }
-
- else if(status_flag.Deep_Sleep_Callback == WIFI_TRUE)
- {
- ind_wifi_resuming();
- status_flag.Deep_Sleep_Callback = WIFI_FALSE;
- }
-
- else if(status_flag.standby_resume_callback == WIFI_TRUE)
- {
- ind_wifi_resuming();
- status_flag.standby_resume_callback = WIFI_FALSE;
- }
-
- else if(WiFi_WIND_State.WiFiHWFailure==WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiHWFailure=WIFI_FALSE;
- ind_wifi_error(WiFi_HW_FAILURE_ERROR);//call with error number
- }
-
- else if(WiFi_WIND_State.HardFault==WIFI_TRUE)
- {
- WiFi_WIND_State.HardFault=WIFI_FALSE;
- ind_wifi_error(WiFi_HARD_FAULT_ERROR);//call with error number
- }
-
- else if(WiFi_WIND_State.StackOverflow==WIFI_TRUE)
- {
- WiFi_WIND_State.StackOverflow=WIFI_FALSE;
- ind_wifi_error(WiFi_STACK_OVERFLOW_ERROR);//call with error number
- }
-
- else if(WiFi_WIND_State.MallocFailed==WIFI_TRUE)
- {
- WiFi_WIND_State.MallocFailed=WIFI_FALSE;
- ind_wifi_error(WiFi_MALLOC_FAILED_ERROR);//call with error number
- }
-
- else if(WiFi_WIND_State.InitFailure==WIFI_TRUE)
- {
- WiFi_WIND_State.InitFailure=WIFI_FALSE;
- ind_wifi_error(WiFi_INIT_ERROR);//call with error number
- }
-
- else if(WiFi_WIND_State.StartFailed==WIFI_TRUE)
- {
- WiFi_WIND_State.StartFailed=WIFI_FALSE;
- ind_wifi_error(WiFi_START_FAILED_ERROR);//call with error number
- }
-
- else if(WiFi_WIND_State.WiFiException==WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiException=WIFI_FALSE;
- ind_wifi_error(WiFi_EXCEPTION_ERROR);//call with error number
- }
-
- else if(WiFi_WIND_State.PS_Mode_Failure==WIFI_TRUE)
- {
- WiFi_WIND_State.PS_Mode_Failure=WIFI_FALSE;
- ind_wifi_warning(WiFi_POWER_SAVE_WARNING);//call with error number
- }
-
- else if(WiFi_WIND_State.HeapTooSmall==WIFI_TRUE)
- {
- WiFi_WIND_State.HeapTooSmall=WIFI_FALSE;
- ind_wifi_warning(WiFi_HEAP_TOO_SMALL_WARNING);//call with error number
- }
-
- else if(WiFi_WIND_State.WiFiSignalLOW==WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiSignalLOW=WIFI_FALSE;
- ind_wifi_warning(WiFi_SIGNAL_LOW_WARNING);//call with error number
- }
-
- else if(WiFi_WIND_State.WiFiDeauthentication == WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiDeauthentication = WIFI_FALSE;
- ind_wifi_connection_error(WiFi_DE_AUTH);
- }
-
- else if(WiFi_WIND_State.WiFiDisAssociation == WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiDisAssociation = WIFI_FALSE;
- ind_wifi_connection_error(WiFi_DISASSOCIATION);
- }
-
- else if(WiFi_WIND_State.WiFiJoinFailed == WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiJoinFailed = WIFI_FALSE;
- ind_wifi_connection_error(WiFi_JOIN_FAILED);
- }
-
- else if(WiFi_WIND_State.WiFiScanBlewUp == WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiScanBlewUp = WIFI_FALSE;
- ind_wifi_connection_error(WiFi_SCAN_BLEWUP); //@TBD to check if user made call, so not call callback if true
- }
-
- else if(WiFi_WIND_State.WiFiScanFailed == WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiScanFailed = WIFI_FALSE;
- ind_wifi_connection_error(WiFi_SCAN_FAILED); //@TBD to check if user made call, so not call callback if true
- }
-
- else if(WiFi_WIND_State.WiFiUnHandledInd == WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiUnHandledInd = WIFI_FALSE;
- ind_wifi_packet_lost(WiFi_UNHANDLED_IND_ERROR); //@TBD to check if user made call, so not call callback if true
- }
-
- else if(WiFi_WIND_State.WiFiRXMgmt == WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiRXMgmt = WIFI_FALSE;
- ind_wifi_packet_lost(WiFi_RX_MGMT); //@TBD to check if user made call, so not call callback if true
- }
-
- else if(WiFi_WIND_State.WiFiRXData == WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiRXData = WIFI_FALSE;
- ind_wifi_packet_lost(WiFi_RX_DATA); //@TBD to check if user made call, so not call callback if true
- }
-
- else if(WiFi_WIND_State.WiFiRxUnk == WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiRxUnk = WIFI_FALSE;
- ind_wifi_packet_lost(WiFi_RX_UNK); //@TBD to check if user made call, so not call callback if true
- }
-
- else if(WiFi_WIND_State.WiFiSockdDataLost == WIFI_TRUE)
- {
- WiFi_WIND_State.WiFiSockdDataLost = WIFI_FALSE;
- ind_wifi_socket_server_data_lost(); //@TBD to check if user made call, so not call callback if true
- }
-
-}
-
-
-/**
-* @brief Start_Timer
-* Start Timer
-* @param None
-* @retval None
-*/
-void Start_Timer()
-{
- //tickcount = WIFI_FALSE;
- status_flag.Timer_Running = WIFI_TRUE;
-}
-
-/**
-* @brief Stop_Timer
-* Stop Timer request
-* @param None
-* @retval None
-*/
-void Stop_Timer()
-{
- //tickcount = WIFI_FALSE;
- status_flag.Timer_Running = WIFI_FALSE;
- //UartReady = SET;
-}
-
-/**
-* @brief Stop_Dequeue
-* Stop dequeuing data from the ring buffer
-* @param None
-* @retval None
-*/
-void Stop_Dequeue()
-{
- status_flag.enable_dequeue = WIFI_FALSE;
-}
-
-/**
-* @brief Resume_Dequeue
-* Resume dequeuing data from the ring buffer
-* @param None
-* @retval None
-*/
-void Resume_Dequeue()
-{
- status_flag.enable_dequeue = WIFI_TRUE;
-}
-
-/**
-* @brief Wifi_SysTick_Isr
-* Function called every SysTick to process buffer
-* @param None
-* @retval None
-*/
-void Wifi_SysTick_Isr()
-{
- //Check if Data is Paused
- if((status_flag.Timer_Running) && (status_flag.enable_dequeue==WIFI_TRUE))
- {
- Process_WiFi();
- }
-
- if(status_flag.Timeout_Timer) tickcount++;
-
- /*if(status_flag.resume_receive_data == WIFI_TRUE)
- {
- if(is_half_empty(&big_buff))
- {
- status_flag.resume_receive_data = WIFI_FALSE;
- //callSpwfSADevice_attach(1);
- Receive_Data();
-
- }
- }*/
-
-
- if(status_flag.Standby_Timer_Running) // module is in sleep and after expiry RX will be conf as EXTI
- {
- if((standby_time++) >= EXTI_CONF_TIMER)
- {
- status_flag.Standby_Timer_Running=WIFI_FALSE;
- standby_time = 0;
- //configure_to_exti();
- }
- }
-
- /*A Resume WIND:70 has come and triggered this
- So checking here if after that resume we fall back to sleep (another WIND69) within SLEEP_RESUME_PREVENT time.
- If yes, we assume it is a false resume and hence do nothing and go back to sleep
- If no WIND69 (going into sleep) has come, we can assume the resume was genuine and then enable the callback
- */
- if((status_flag.Deep_Sleep_Timer) && ( sleep_count++) >= SLEEP_RESUME_PREVENT)
- {
- if(status_flag.Deep_Sleep_Enabled == WIFI_TRUE)//which means we have received another WIND69 in the 2 seconds
- {
- //do nothing, go back to sleep
- status_flag.Deep_Sleep_Enabled = WIFI_TRUE;
- status_flag.Deep_Sleep_Callback = WIFI_FALSE;
- }
- else if (status_flag.Deep_Sleep_Enabled == WIFI_FALSE) //which means we have not received any WIND69 during the last 2 seconds
- {
- //enable the user callback as it is a genuine WIND70
- status_flag.Deep_Sleep_Callback = WIFI_TRUE;
- }
- Stop_DeepSleep_Timer();
- }
-}
-
-
-/**
-* @brief USART_Receive_AT_Resp
-* Receive and check AT cmd response
-* @param WiFi_AT_CMD_Response_t : WIFi module next state
-* @retval WiFi_Status_t : Response of AT cmd
-*/
-
-WiFi_Status_t USART_Receive_AT_Resp(WiFi_AT_CMD_Response_t state)
-{
- WiFi_Module_State = state;
- tickcount=0;//reset timer
- status_flag.Timeout_Timer = WIFI_TRUE;
- while(status_flag.AT_Response_Received != WIFI_TRUE) {
- if(tickcount >=20000)//20 sec wait
- {
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- break;
- }
- __NOP();
- }
- status_flag.Timeout_Timer = WIFI_FALSE;
- status_flag.AT_Response_Received = WIFI_FALSE;
- return AT_RESPONSE;
-}
-
-
-/**
-* @brief Process_WiFi
-* Pop a byte from the circular buffer and send the byte for processing
-* This function should be called from main or should be run with a periodic timer
-* @param None
-* @retval None
-*/
-void Process_WiFi(void)
-{
- uint8_t * temp;//pop buffer temporary
-
- __disable_irq();
- temp=pop_buffer_queue(&big_buff); //contents of temp(pop_buffer) will not change till another de-queue is made
- __enable_irq();
-
- if(temp!=NULL)
- {
- Process_Buffer(temp);
- }
-
- if(status_flag.event_deQ_x_wind64)//if de-Q is stopped due to WIND64 wait
- {
- wind64_DQ_wait++;//1ms for each count
- if(wind64_DQ_wait>200)//wait for 50ms for example
- {
- wind64_DQ_wait=0;
- status_flag.event_deQ_x_wind64 = WIFI_FALSE;
- //re-enable event Q after 200ms
- status_flag.stop_event_dequeue = WIFI_FALSE;
- }
- }
-}
-
-/**
-* @brief Process_Buffer
-* Process and construct a Wind Line buffer
-* @param ptr: pointer to one single byte
-* @retval None
-*/
-
-void Process_Buffer(uint8_t * ptr)
-{
- static uint32_t Fillptr=0;//count=0;
- static uint8_t index, chan_value;
- unsigned char rxdata = 0;
- int rssi_value = 0;
- char SocketId_No[2];
- char databytes_No[4];
- char * pStr;
-
- rxdata = *(ptr+0);
- //printf(&rxdata);//check prints for debug...to be removed or kept in DEBUG statement
- if(status_flag.enable_receive_data_chunk == WIFI_FALSE)
- process_buffer[Fillptr++] = rxdata;
- reset_event(&event_s);
- switch (WiFi_Module_State)
- {
- case Process_Event:
-
- if((process_buffer[Fillptr-2]==0xD) && (process_buffer[Fillptr-1]==0xA) && !status_flag.enable_receive_http_response && !status_flag.sock_read_ongoing)
- {
- if((strstr((const char *)process_buffer,"WIND:")) != NULL)
- {
- if((strstr((const char *)process_buffer,"+WIND:67:")) !=NULL)
- event_s.event = WIFI_STANDBY_CONFIG_EVENT;
-
- else if ((strstr((const char *)process_buffer,"+WIND:68:"))!= NULL)
- event_s.event = WIFI_RESUME_CONFIG_EVENT;
-
- else
- {
- //end of msg received. Will not receive any other msg till we process this.
- //Stop_Timer();
- //#if defined (USE_STM32L0XX_NUCLEO) || (USE_STM32F4XX_NUCLEO) || (USE_STM32L4XX_NUCLEO)
- //__disable_irq();
- //#endif
- Process_Wind_Indication(&process_buffer[0]);
- //#if defined (USE_STM32L0XX_NUCLEO) || (USE_STM32F4XX_NUCLEO) || (USE_STM32L4XX_NUCLEO)
- //__enable_irq();
- //#endif
- //Start_Timer();
- sock_total_count=0;
- }
-
- if(!status_flag.prevent_push_WIFI_event)
- {
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
- reset_event(&event_s);
- }
-
- if (!status_flag.do_not_reset_push_WIFI_event) status_flag.prevent_push_WIFI_event = WIFI_FALSE;
- if(status_flag.enable_sock_read)
- {
- status_flag.sock_read_ongoing = WIFI_FALSE;//we finished processing a message and now sock read will commence
- status_flag.Q_Contains_Message = WIFI_FALSE;
- }
- Fillptr=0;
- memset(process_buffer, 0x00, strlen((const char*)process_buffer));
- }
-
- else if((strstr((const char *)process_buffer,"\r\nOK\r\n")) != NULL)
- {
- /*Now Check to which AT Cmd response this OK belongs to so that correct parsing can be done*/
-
- // SOCKON ID (Open a client socket)
- if(((pStr=(strstr((const char *)process_buffer,"ID: "))) != NULL))
- {
- SocketId_No[0] = *(pStr + 4) ;
- SocketId_No[1] = *(pStr + 5) ;
- SocketId = (((SocketId_No[0] - '0') * 10 ) + (SocketId_No[1] - '0'));
- event_s.socket_id = SocketId;
- event_s.event = WIFI_SOCK_ID_EVENT;
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
- reset_event(&event_s);
- if(status_flag.enable_sock_read)
- {
- status_flag.sock_read_ongoing = WIFI_FALSE; //we finished processing a message and now sock read will commence
- status_flag.Q_Contains_Message = WIFI_FALSE;
- }
- Fillptr=0;
- sock_total_count=0;
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- }
-
- // DATALEN from SOCKQ
- else if((pStr=(strstr((const char *)process_buffer,"DATALEN: "))) != NULL)
- {
- //Find the DataLength and do a socket read
- databytes_No[0] = *(pStr + 9);
- databytes_No[1] = *(pStr + 10);
- databytes_No[2] = *(pStr + 11);
- databytes_No[3] = *(pStr + 12);
-
- if( databytes_No[1] == '\r')
- {
- SockON_Data_Len = databytes_No[0] - '0';
- }
- else if( databytes_No[2] == '\r')
- {
- SockON_Data_Len = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
- }
- else if( databytes_No[3] == '\r')
- {
- SockON_Data_Len = (((databytes_No[0] - '0') * 100 ) + ((databytes_No[1] - '0') * 10 ) + (databytes_No[2] - '0'));
- }
- else //it's a 4-digit number
- {
- SockON_Data_Len = ((databytes_No[0] - '0') * 1000 ) + ((databytes_No[1] - '0') * 100 ) + ((databytes_No[2] - '0') * 10) + (databytes_No[3] - '0');
- }
- Socket_Data_Length = SockON_Data_Len;
- if(Socket_Data_Length != 0)
- {
- status_flag.start_sock_read = WIFI_TRUE;
- }
- else if(Socket_Data_Length == 0)
- {
- status_flag.stop_event_dequeue = WIFI_FALSE; //continue popping events if nothing to read
- status_flag.Set_AT_Cmd_Response_False = WIFI_FALSE;
- }
- Fillptr = 0;
- sock_total_count = 0;
- if(status_flag.enable_sock_read)
- {
- status_flag.sock_read_ongoing = WIFI_FALSE; //we finished processing a message and now sock read will commence
- status_flag.Q_Contains_Message = WIFI_FALSE;
- pop_buffer_size = 0;
- pop_buffer[0]='\0'; // required as this byte is already used in process_buffer
- }
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- }
-
- else if((((strstr((const char *)process_buffer," = "))) != NULL))
- {
- // AT command GCFG
- pStr = (char *) strstr((const char *)process_buffer," = ");
- event_s.event = WIFI_GCFG_EVENT;
- memcpy(get_cfg_value, pStr+2, (strlen(pStr)-2));
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
- reset_event(&event_s);
- if(status_flag.enable_sock_read)
- {
- status_flag.sock_read_ongoing = WIFI_FALSE; //we finished processing a message and now sock read will commence
- status_flag.Q_Contains_Message = WIFI_FALSE;
- }
- Fillptr=0;
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- }
-
- else
- {
- //This is a standalone OK
- /*Cases possible
- - TLSCERT,TLSCERT2, TLSDOMAIN, SETTIME
- - S.SOCKW, SOCKR, S.SOCKC, S.SOCKD (open a server socket)
- - File Operations
- - S.GPIOC and S.GPIOW
- */
- //Push a simple OK Event, if this is an OK event required to be pushed to Q
- if(status_flag.prevent_push_OK_event)
- {
- //This OK is not to be handled, hence the pop action on OK completion to be done here
- //since pop will not happen
-// stop_event_dequeue=WIFI_FALSE;
-
- if(status_flag.client_socket_close_ongoing)
- {
- if(no_of_open_client_sockets > 0)
- no_of_open_client_sockets--;
- status_flag.prevent_push_OK_event = WIFI_FALSE;
- open_sockets[remote_socket_closed_id] = WIFI_FALSE;
- socket_closed_id_callback = remote_socket_closed_id;
- status_flag.Set_AT_Cmd_Response_False = WIFI_FALSE;
- status_flag.client_socket_close_ongoing = WIFI_FALSE;
- status_flag.SockON_Server_Closed_Callback = WIFI_TRUE;
- status_flag.stop_event_dequeue=WIFI_FALSE;
- }
-
- }
-
- else
- {
- event_s.ok_eval = WIFI_TRUE;
- event_s.event = WIFI_OK_EVENT;
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
- reset_event(&event_s);
- }
- status_flag.prevent_push_OK_event = WIFI_FALSE;
- memset(process_buffer, 0x00, Fillptr);
- Fillptr=0;
- sock_total_count=0;
- if(status_flag.enable_sock_read)
- {
- status_flag.sock_read_ongoing = WIFI_FALSE;//we finished processing a message and now sock read will commence
- status_flag.Q_Contains_Message = WIFI_FALSE;
- }
- break;
- }
- }
-
- else if((((strstr((const char *)process_buffer,"ERROR"))) != NULL))
- {
- //This is an ERROR
- //There can be only ONE outstanding AT command and hence this ERROR belongs to that
- //HTTP -> ERROR: host not found
- //@TBD: Check all Errors Possible here???
- if((strstr((const char *)process_buffer,"\r\nERROR: Pending data\r\n")) != NULL) //if Error after sock close command and not 'OK'
- {
- printf("\r\nERROR: Socket could not be closed..PENDING DATA\r\n");
- status_flag.prevent_push_OK_event = WIFI_FALSE; //prevent the OK received after socket close command to be Q'ed
- status_flag.client_socket_close_ongoing = WIFI_FALSE;
- status_flag.stop_event_dequeue = WIFI_FALSE;
- }
- else
- {
- event_s.event = WIFI_ERROR_EVENT;
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
- reset_event(&event_s);
- if(status_flag.stop_event_dequeue)
- /*ERROR:Illegal Socket ID*/
- status_flag.stop_event_dequeue= WIFI_FALSE;//continue popping events if nothing to read
- }
- Fillptr=0;
- sock_total_count=0;
- if(status_flag.enable_sock_read)
- {
- status_flag.sock_read_ongoing = WIFI_FALSE;//we finished processing a message and now sock read will commence
- status_flag.Q_Contains_Message = WIFI_FALSE;
- }
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- }
-
- else if((((strstr((const char *)process_buffer,"GPIO "))) != NULL))
- {
- // Receive GPIO Read
- pStr = (char *) strstr((const char *)process_buffer,"= 0,");
- if(pStr != NULL)
- {
- gpio_value = 0;
- }
- else
- gpio_value = 1;
-
- pStr = (char *) strstr((const char *)process_buffer,"out");
- if(pStr != NULL)
- {
- gpio_direc= 0; //out
- }
- else
- {
- gpio_direc= 1; //in
- }
- //Push GPIO Read Event on Event_Queue
- event_s.event = WIFI_GPIO_EVENT;
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
- reset_event(&event_s);
- if(status_flag.enable_sock_read)
- {
- status_flag.sock_read_ongoing = WIFI_FALSE; //we finished processing a message and now sock read will commence
- status_flag.Q_Contains_Message = WIFI_FALSE;
- }
- Fillptr = 0;
- memset(process_buffer, 0x00, strlen((const char*)process_buffer));
- break;
- }
-
- else
- {
- if(status_flag.enable_sock_read && status_flag.Q_Contains_Message && !status_flag.message_pending)
- {
- printf((const char*)&process_buffer[0]);
- status_flag.Q_Contains_Message = WIFI_FALSE;
- status_flag.Q_Contains_Data = WIFI_TRUE;
- //status_flag.enable_sock_read = WIFI_FALSE;
- //status_flag.stop_event_dequeue= WIFI_FALSE;
- }
-
- //if in data mode, reset on \r\n
- if(!status_flag.sock_read_ongoing && status_flag.data_mode)
- {
- Fillptr = 0;
- memset(process_buffer, 0x00, strlen((const char*)process_buffer));
- }
- }
- }
-
- else if (status_flag.http_req_pending) //HTTP Response Check
- {
- if((strstr((const char *)&process_buffer[0],"200 OK\r")) != NULL || (strstr((const char *)&process_buffer[0],"400 Bad Request\r")) != NULL
- || (strstr((const char *)&process_buffer[0],"401 Unauthorized\r")) != NULL || (strstr((const char *)&process_buffer[0],"403 Forbidden\r")) != NULL
- || (strstr((const char *)&process_buffer[0],"404 Not Found\r")) != NULL || (strstr((const char *)&process_buffer[0],"408 Request Timeout\r")) != NULL
- || (strstr((const char *)&process_buffer[0],"500 Internal Server Error\r")) != NULL || (strstr((const char *)&process_buffer[0],"502 Bad Gateway\r")) != NULL
- || (strstr((const char *)&process_buffer[0],"504 Gateway Timeout\r")) != NULL)
- {
- status_flag.enable_receive_http_response = WIFI_TRUE;
- status_flag.enable_receive_data_chunk = WIFI_TRUE;
- status_flag.http_req_pending = WIFI_FALSE;
- pop_buffer[0]='\0';
- pop_buffer_size=0;
- process_buffer_index =6;
- }
- }
-
- else if ((process_buffer[Fillptr-1]==0x09) && (process_buffer[Fillptr-2]==':') && (process_buffer[Fillptr-3]=='1'))//<ht> Horizontal Tab for Scan Result?
- {
- status_flag.enable_receive_wifi_scan_response = WIFI_TRUE;
- }
-
- if(!status_flag.Pending_SockON_Callback && !status_flag.HTTP_Data_available && !status_flag.FILE_Data_available)
- {
- //Check Process Buffer for any pending message
- if(status_flag.enable_receive_data_chunk)
- {
- if(!status_flag.Q_Contains_Data && pop_buffer_size)
- {
- pop_queue_length = pop_buffer_size;
- if(Fillptr + pop_queue_length > 511)
- {
- uint32_t length = (Fillptr + pop_queue_length) - 511;
- __disable_irq();
- rewind_buffer_queue(&big_buff,length);
- __enable_irq();
- memset(ptr+(511 - Fillptr), 0x00, length);
- pop_queue_length = 511 - Fillptr;
- }
- memcpy(process_buffer+Fillptr,(char const *)pop_buffer, pop_queue_length);
- Fillptr = Fillptr + pop_queue_length;
-
- if(Fillptr > 512)
- {
- printf("\r\nFillptr corrupted!!\r\n");
- }
-
- if((strstr((const char *)process_buffer,"ERROR: ")) != NULL)
- {
- status_flag.Q_Contains_Message = WIFI_FALSE;
- status_flag.message_pending = WIFI_FALSE;
- }
- else if(!status_flag.sock_read_ongoing && !status_flag.enable_receive_http_response)
- {
- if(process_buffer[0]!='\0')
- {
- if(((process_buffer[0]==0xD) && (process_buffer[1]==0xA)) && process_buffer[2] != 0xD)
- {
- status_flag.message_pending = WIFI_TRUE;
- if((pStr = (strstr((const char *)process_buffer+2,"\r\n"))) != NULL)
- { // process buffer has complete message
- int wind_length = ((uint8_t *)pStr - (uint8_t *)process_buffer)+2;
-
- if(strstr((const char *)process_buffer+2,"DATALEN:"))
- {
- pStr = strstr((const char *)process_buffer + wind_length,"\r\nOK\r\n"); //find OK, as DATALEN has to be terminated by OK
- if(pStr!=NULL)
- {
- wind_length = ((uint8_t *)pStr-(uint8_t *)process_buffer)+6;
- }
- }
-
- if(Fillptr-wind_length)
- {
- __disable_irq();
- rewind_buffer_queue(&big_buff, Fillptr - wind_length);
- __enable_irq();
- memset(process_buffer + wind_length,0x00,Fillptr - wind_length);
- Fillptr = wind_length;
- }
- status_flag.message_pending = WIFI_FALSE;
- }
- status_flag.Q_Contains_Message = WIFI_TRUE;
- }
- }
- }
- }
- }
-
- if(!status_flag.Q_Contains_Message && status_flag.enable_sock_read && pop_buffer_size) /*read is enabled*/
- {
- status_flag.sock_read_ongoing = WIFI_TRUE;
- sock_total_count = sock_total_count + pop_queue_length;
-
- /* Check for "ERROR: Not enough data in buffer " */
- pStr = (char *) strstr((const char *)&process_buffer,"ERROR: ");
-
- if (pStr != NULL)
- {
- if((process_buffer[Fillptr-2]==0xD) && (process_buffer[Fillptr-1]==0xA))
- {
- if((pStr = (char *)strstr((const char *)&process_buffer,"\r\nERROR: Too many sockets\r\n")) !=NULL)
- {
- #if DEBUG_PRINT
- printf("\r\nERROR: TOO MANY SOCKETS \r\n");
- #endif
-
- if(*(pStr+27)!='\0')
- {
- int len = (uint8_t *)pStr - (uint8_t *)process_buffer;
- int extra_bytes = Fillptr - (len+27);
- __disable_irq();
- rewind_buffer_queue(&big_buff, extra_bytes);
- __enable_irq();
- }
- Fillptr=0;
- sock_total_count =0;
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- break;
- }
- else if((pStr = (char *)strstr((const char *)&process_buffer,"\r\nERROR: Pending data\r\n")) !=NULL)
- {
- #if DEBUG_PRINT
- printf("\r\nERROR: PENDING DATA \r\n");
- #endif
-
- if(*(pStr+23)!='\0')
- {
- int len = (uint8_t *)pStr - (uint8_t *)process_buffer;
- int extra_bytes = Fillptr - (len+23);
- __disable_irq();
- rewind_buffer_queue(&big_buff, extra_bytes);
- __enable_irq();
- }
- Fillptr=0;
- sock_total_count =0;
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- break;
- }
-
- printf("\rERROR DURING SOCK READ\r\n");
- sock_total_count=0;
- SockON_Data_Len=0;
- SockON_Data_Length=0;
- status_flag.enable_sock_read = WIFI_FALSE;
- status_flag.stop_event_dequeue = WIFI_FALSE;
- status_flag.Q_Contains_Message = WIFI_FALSE;
- status_flag.Q_Contains_Data = WIFI_FALSE;
- enable_pending_data = 0;
- status_flag.enable_receive_data_chunk = WIFI_FALSE;
- WIND64_count=0;
- process_buffer_index =5;
- //status_flag.enable_query = TRUE; //do we have more data?
- Fillptr=0;
- status_flag.sock_read_ongoing = WIFI_FALSE;
- if(status_flag.data_pending_sockD)
- {
- status_flag.data_pending_sockD=WIFI_FALSE;
- number_of_bytes=0;
- status_flag.switch_by_default_to_command_mode=WIFI_TRUE;
- WiFi_switch_to_command_mode(); //switch by default
- }
-
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- break;
- }
- }
-
- /*now check if end of msg received*/
- if(sock_total_count >= SockON_Data_Length)
- {
- #if DEBUG_PRINT
- printf("\nReached SockON_Data_Len \r\n");
- #endif
-
- if(sock_total_count > SockON_Data_Length)
- {
- int databytes = sock_total_count - SockON_Data_Length;
- __disable_irq();
- rewind_buffer_queue(&big_buff, databytes);
- __enable_irq();
- memset(process_buffer+(Fillptr - databytes), 0x00, databytes);
- Fillptr = Fillptr - databytes;
- }
- chunk_size = Fillptr;
- message_size = SockON_Data_Length;
- memcpy(UserDataBuff, process_buffer, Fillptr);
- Fillptr = 0;
- sock_total_count = 0;
- SockON_Data_Len = 0;
- status_flag.Q_Contains_Data = WIFI_FALSE;
- status_flag.Q_Contains_Message = WIFI_FALSE;
- status_flag.enable_receive_data_chunk = WIFI_FALSE;
- enable_pending_data = 0;
-
- if(status_flag.data_pending_sockD)
- {
-// status_flag.data_pending_sockD=WIFI_FALSE;
- number_of_bytes=0;
- sockon_id_user = 0;
- if(WIND64_count>0)
- WIND64_count--; //decrease the number of pending WIND:64 Events
- if(WIND64_count==0) {
- status_flag.switch_by_default_to_command_mode=WIFI_TRUE;
- WiFi_switch_to_command_mode(); //switch by default
- }
- status_flag.enable_query = WIFI_FALSE;
- }
- else
- {
- status_flag.enable_query = WIFI_TRUE;
- sockon_id_user = sockon_query_id;
- /*@TODO: Do not need to prevent OK push in case of server socket*/
- status_flag.prevent_push_OK_event = WIFI_TRUE; //prevent the qeueuing of the OK after this read operation
- }
-
- status_flag.enable_sock_read = WIFI_FALSE;
- status_flag.sock_read_ongoing = WIFI_FALSE;
- Stop_Dequeue(); //Stop dequeue till user callback returns
- status_flag.Pending_SockON_Callback = WIFI_TRUE; //set this to callback to user with User Buffer pointer
- //do we have more data?
- if(status_flag.data_pending_sockD)
- {
- status_flag.stop_event_dequeue = WIFI_FALSE;
- status_flag.data_pending_sockD = WIFI_FALSE;
- }
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- break;
- }
-
- if(Fillptr >= MAX_BUFFER_GLOBAL-1)
- {
- message_size = SockON_Data_Length;
- chunk_size = 511;
- memcpy(UserDataBuff, process_buffer, Fillptr);
- Fillptr = 0;
- process_buffer_index = 5;
- Stop_Dequeue();
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- status_flag.Pending_SockON_Callback = WIFI_TRUE; //set this to callback to user with User Buffer pointer
- }
- break;
- }
-
- if (status_flag.enable_receive_http_response && pop_buffer_size) // http response enabled
- {
- status_flag.sock_read_ongoing = WIFI_TRUE;
- if((pStr = (strstr((const char *)process_buffer + process_buffer_index - 6,"\r\nOK\r\n"))) != NULL)
- {
- #if DEBUG_PRINT
- printf("\r\nOK\r\n"); //http response completed
- #endif
-
- if(*(pStr+7) != '\0')
- {
- int len = (uint8_t *)pStr - (uint8_t *)process_buffer;
- int extra_bytes = Fillptr - (len+6);
- __disable_irq();
- rewind_buffer_queue(&big_buff, extra_bytes);
- __enable_irq();
-
- memset(process_buffer+len+7, 0x00, extra_bytes);
- Fillptr = Fillptr - extra_bytes;
- }
-
- memcpy(UserDataBuff, process_buffer, Fillptr);
- UserDataBuff_index = Fillptr;
- status_flag.AT_Response_Received = WIFI_TRUE;
- status_flag.enable_receive_data_chunk = WIFI_FALSE;
- status_flag.enable_receive_http_response = WIFI_FALSE;
- Stop_Dequeue();
- AT_RESPONSE = WiFi_MODULE_SUCCESS;
- status_flag.sock_read_ongoing = WIFI_FALSE;
- status_flag.Q_Contains_Data = WIFI_FALSE;
- status_flag.Q_Contains_Message = WIFI_FALSE;
- status_flag.stop_event_dequeue = WIFI_FALSE;
- process_buffer_index = 6;
- memset(process_buffer, 0x00, Fillptr);
- Fillptr=0;
-
- if(status_flag.enable_receive_file_response)
- status_flag.FILE_Data_available = WIFI_TRUE;
- else
- status_flag.HTTP_Data_available=WIFI_TRUE;
- }
-
- else if(((strstr((const char *)process_buffer + process_buffer_index-6,"ERROR"))) != NULL)
- {
- #if DEBUG_PRINT
- printf("\r\nERROR\r\n");
- #endif
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- status_flag.sock_read_ongoing = WIFI_FALSE;
- status_flag.enable_receive_data_chunk = WIFI_FALSE;
- status_flag.Q_Contains_Data = WIFI_FALSE;
- status_flag.Q_Contains_Message = WIFI_FALSE;
- Fillptr=0;
- process_buffer_index=6;
- status_flag.enable_receive_http_response = WIFI_FALSE;
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
-
- if(status_flag.enable_receive_file_response)
- status_flag.FILE_Data_available = WIFI_FALSE;
- else
- status_flag.HTTP_Data_available=WIFI_FALSE;
- }
-
- process_buffer_index = Fillptr;
- if(Fillptr == MAX_BUFFER_GLOBAL-1 )
- {
- memcpy(UserDataBuff, process_buffer, Fillptr);
- memcpy(&HTTP_Runway_Buff, &UserDataBuff[505], 6);
- memset(&UserDataBuff[505], 0x00, 6);
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- memcpy(&process_buffer, &HTTP_Runway_Buff, 6);
- memset(HTTP_Runway_Buff, 0x00, 6);
- Fillptr = 6;
- process_buffer_index = 6;
- UserDataBuff_index = 505;
- Stop_Dequeue();
-
- if(status_flag.enable_receive_file_response)
- status_flag.FILE_Data_available = WIFI_TRUE;
- else
- status_flag.HTTP_Data_available=WIFI_TRUE;
- }
- break;
- }
- }
- if((!status_flag.Q_Contains_Message) && status_flag.enable_receive_wifi_scan_response)
- {
- /*now check if end of msg received*/
- if((process_buffer[Fillptr-2]==0xD) && (process_buffer[Fillptr-1]==0xA))
- {
- if(scanned_ssids < user_scan_number)
- {
- pStr = (char *) strstr((const char *)&process_buffer,"CHAN:");
- if(pStr != NULL)
- {
- databytes_No[0] = *(pStr + 6) ;
- databytes_No[1] = *(pStr + 7) ;
-
- chan_value = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
- }
-
- wifi_scanned_list[scanned_ssids].channel_num = chan_value;
-
- pStr = (char *) strstr((const char *)&process_buffer,"RSSI:");
- if(pStr != NULL)
- {
- databytes_No[0] = *(pStr + 7) ;
- databytes_No[1] = *(pStr + 8) ;
-
- rssi_value = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
- }
-
- wifi_scanned_list[scanned_ssids].rssi = -(rssi_value);
-
- pStr = (char *) strstr((const char *)&process_buffer,"SSID:");
- if(pStr != NULL)
- {
- index = 7;
- while(*(pStr + index) != 0x27)
- {
- wifi_scanned_list[scanned_ssids].ssid[index-7] = *(pStr + index);
- index++;
- if(index==35) break; //max ssid lenght is 30 characters
- }
- }
-
- pStr = (char *) strstr((const char *)&process_buffer,"WPA ");
- if(pStr != NULL)
- {
- wifi_scanned_list[scanned_ssids].sec_type.wpa = WIFI_TRUE;
- } else
- wifi_scanned_list[scanned_ssids].sec_type.wpa = WIFI_FALSE;
-
- pStr = (char *) strstr((const char *)&process_buffer,"WPA2 ");
- if(pStr != NULL)
- {
- wifi_scanned_list[scanned_ssids].sec_type.wpa2 = WIFI_TRUE;
- } else
- wifi_scanned_list[scanned_ssids].sec_type.wpa2 = WIFI_FALSE;
-
- pStr = (char *) strstr((const char *)&process_buffer,"WPS ");
- if(pStr != NULL)
- {
- wifi_scanned_list[scanned_ssids].sec_type.wps = WIFI_TRUE;
- } else
- wifi_scanned_list[scanned_ssids].sec_type.wps = WIFI_FALSE;
-
- scanned_ssids++;//increment total_networks
- //callSpwfSADevice_debug(spwf_dev_,(const char*)scanned_ssids);
- }
-
- //end of one line from SCAN result
- pStr = (char *) strstr((const char *)&process_buffer,"ERROR");
- if(pStr != NULL)
- {
- #if DEBUG_PRINT
- printf("ERROR Scan Failed");
- #endif
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- Fillptr=0;
- status_flag.AT_Response_Received = WIFI_TRUE;
- status_flag.enable_receive_wifi_scan_response = WIFI_FALSE;
- status_flag.Scan_Ongoing = WIFI_FALSE; //Enable next scan
- AT_RESPONSE = WiFi_AT_CMD_RESP_ERROR;
- break;
- }
-
- #if DEBUG_PRINT
- printf((const char*)process_buffer);
- #endif
-
- callSpwfSADevice_debug(spwf_dev_,(const char*)process_buffer);
-
- if(((strstr((const char *)process_buffer,"OK\r\n"))) != NULL /*|| scanned_ssids==10*/)/*Max 10 networks supported*/
- {
- //print and go for next line
- //If Any part of scan line contains "OK" this will exit!!
- #if DEBUG_PRINT
- printf("\nOK\r\n");
- #endif
- status_flag.Scan_Ongoing = WIFI_FALSE; //Enable next scan
- scanned_ssids=0;
- Fillptr=0;
- status_flag.AT_Response_Received = WIFI_TRUE;
- status_flag.enable_receive_wifi_scan_response = WIFI_FALSE;
- AT_RESPONSE = WiFi_MODULE_SUCCESS;
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- break;
- }
-
- Fillptr=0;
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- }
-
- if(Fillptr>=MAX_BUFFER_GLOBAL-1)
- {
- #if DEBUG_PRINT
- printf("\rHTTP: process_buffer Max Buffer Size reached\r\n");
- #endif
- Fillptr=0;
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- }
- }
-
- if((!status_flag.Q_Contains_Message) && status_flag.enable_fw_update_read)
- {
- #ifdef DEBUG_PRINT
- printf("*"); //print * till finish
- #endif
-
- pStr = (char *) strstr((const char *)process_buffer,"Complete!");
-
- if(pStr != NULL)
- {
- #ifdef DEBUG_PRINT
- printf("\r\nUpdate complete\r\n");
- #endif
- status_flag.AT_Response_Received = WIFI_TRUE;
- AT_RESPONSE = WiFi_MODULE_SUCCESS;
- status_flag.enable_fw_update_read = WIFI_FALSE;
- Fillptr=0;
- memset(process_buffer, 0x00, strlen((char const *)process_buffer));
- }
- if(Fillptr>=MAX_BUFFER_GLOBAL)
- {
- Fillptr=0;
- memset(process_buffer, 0x00, strlen((char const *)process_buffer));
- }
-
- //No change of state till we get "+WIND:17:F/W update complete!"
- }
-
- /*else no other case is satisfied at least do the following*/
- {
- if(Fillptr>=MAX_BUFFER_GLOBAL-1)
- {
- Fillptr=0;
- memset(process_buffer, 0x00,MAX_BUFFER_GLOBAL-1);
- }
- }
- }
-}
-
-/**
-* @brief Process_Wind_Indication_Cmd
-* Process Wind indication command
-* @param process_buff_ptr: pointer of WiFi indication buffer
-* @retval None
-*/
-
-void Process_Wind_Indication(uint8_t *process_buff_ptr)
-{
- char * pStr = (char*)process_buff_ptr;
- char Indication_No[2];
- char databytes_No[4];
- #if DEBUG_PRINT
- printf((const char*)process_buff_ptr);
- #endif
- //callSpwfSADevice_debug(spwf_dev_,(const char*)process_buff_ptr);
-
- char * ptr_offset;
- int i;
-
- uint32_t wind55_data_len=0;
- WiFi_Indication_t Wind_No = Undefine_Indication;
-
- if(pStr != NULL)
- {
- pStr = (char *) strstr((const char *)(pStr),"WIND:");///////
-
- if(pStr != NULL)
- {
- Indication_No[0] = *(pStr + 5) ;
- Indication_No[1] = *(pStr + 6) ;
-
- if( Indication_No[1] == ':')
- {
- status_flag.Single_Digit_Indication = WIFI_TRUE;
- /* Convert char to integer */
- Wind_No = (WiFi_Indication_t)(Indication_No[0] - '0');
- }
- else
- {
- status_flag.Single_Digit_Indication = WIFI_FALSE;
- /* Convert char to integer */
- Wind_No = (WiFi_Indication_t)(((Indication_No[0] - '0') * 10 ) + (Indication_No[1] - '0'));
- }
-
- event_s.wind = Wind_No;
- event_s.event = WIFI_WIND_EVENT;
-
- switch (Wind_No)
- {
- case SockON_Data_Pending: /*WIND:55*/
-
- /*+WIND:55:Pending Data:%d:%d*/
- ptr_offset = (char *) strstr((const char *)&process_buffer,"Data:");
-
- /*Need to find out which socket ID has data pending*/
- databytes_No[0] = *(ptr_offset + 5);
-
- SocketId = (databytes_No[0] - '0');//Max number of sockets is 8 (so single digit)
- event_s.socket_id = SocketId;
- enable_pending_data = 1;
-
- /* EQ. Check for ENC string to identify TLS case. Set enable_query */
- if ( (*(ptr_offset + 7) == 'E') && (*(ptr_offset + 8) == 'N') && (*(ptr_offset + 9) == 'C') )
- {
- event_s.enc = WIFI_TRUE;
- }
- else
- {
- //And find the length of the data
- databytes_No[0] = *(ptr_offset + 7);
- databytes_No[1] = *(ptr_offset + 8);
- databytes_No[2] = *(ptr_offset + 9);
- databytes_No[3] = *(ptr_offset + 10);
-
- if( databytes_No[1] == '\r')
- {
- wind55_data_len = databytes_No[0] - '0';
- }
- else if( databytes_No[2] == '\r')
- {
- wind55_data_len = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
- }
- else if( databytes_No[3] == '\r') //it's a 3-digit number
- {
- wind55_data_len = (((databytes_No[0] - '0') * 100 ) + ((databytes_No[1] - '0') * 10 ) + (databytes_No[2] - '0'));
- }
- else //it's a 4-digit number
- {
- wind55_data_len = ((databytes_No[0] - '0') * 1000 ) + ((databytes_No[1] - '0') * 100 ) + ((databytes_No[2] - '0') * 10) + (databytes_No[3] - '0');
- }
-
- event_s.data_length = wind55_data_len;
- wind55_data_len = 0;
- }
- break;
-
- case SockON_Server_Socket_Closed:
- //Find the id of the socket closed
- //ptr_offset = (char *) strstr((const char *)pStr,"+WIND:58");
- databytes_No[0] = *(pStr + 22) ;
- databytes_No[1] = *(pStr + 23) ;
- if( databytes_No[1] == '\r')
- {
- remote_socket_closed_id = databytes_No[0] - '0';
- }
- else
- {
- remote_socket_closed_id = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
- }
- event_s.socket_id = remote_socket_closed_id;
- break;
-
- case SockD_Pending_Data:
- if(status_flag.prevent_push_WIFI_event)
- {
- #ifdef DEBUG_PRINT
- printf(">>IG\r\n");
- #endif
- return; ///exit if push is prevented
- }
-
- /* @TODO: Do something to delay the de-Q of pending packets so that any further
- pending WIND64 packets are allowed to arrive and get Q-ed */
-
- if(status_flag.event_deQ_x_wind64) //which means there is already a previous WIND64
- {
- wind64_DQ_wait=0; //reset the timer
- }
- else
- {
- status_flag.stop_event_dequeue = WIFI_TRUE;//Stop the event de-Q
- status_flag.event_deQ_x_wind64 = WIFI_TRUE;//Set the flag
- }
- //Start Reading data from Client Here.
- // +WIND:64:Sockd Pending Data:1:130:130
- ptr_offset = (char *) strstr((const char *)&process_buffer,"Data:");
-
- //Store the packet number
- databytes_No[0] = *(ptr_offset + 5) ;
- event_s.wind64_pending_packet_no = databytes_No[0] - '0';
-
- //And now find the data length
- databytes_No[0] = *(ptr_offset + 8) ;//points to number just after 2nd colon
- databytes_No[1] = *(ptr_offset + 9) ;
- databytes_No[2] = *(ptr_offset + 10) ;
- databytes_No[3] = *(ptr_offset + 11) ;
-
- if( databytes_No[0] == ':')//then it is a 1 digit number
- {
- databytes_No[0] = *(ptr_offset + 7) ;
- databytes_No[1] = *(ptr_offset + 8) ;
- }
- else if(databytes_No[1] == ':')//two digit number
- {
- databytes_No[0] = *(ptr_offset + 7) ;
- databytes_No[1] = *(ptr_offset + 8) ;
- databytes_No[2] = *(ptr_offset + 9) ;
- //databytes_No[3] = *(ptr_offset + 13) ;
- }
- else if(databytes_No[2] == ':')//three digit number
- {
- databytes_No[0] = *(ptr_offset + 7) ;
- databytes_No[1] = *(ptr_offset + 8) ;
- databytes_No[2] = *(ptr_offset + 9) ;
- databytes_No[3] = *(ptr_offset + 10) ;
- }
- else if(databytes_No[3] == ':')//four digit number
- {
- databytes_No[0] = *(ptr_offset + 7) ;
- databytes_No[1] = *(ptr_offset + 8) ;
- databytes_No[2] = *(ptr_offset + 9) ;
- databytes_No[3] = *(ptr_offset + 10) ;
- }
-
- if( databytes_No[1] == ':')
- {
- interim_number_of_bytes = databytes_No[0] - '0';
- }
- else if( databytes_No[2] == ':')
- {
- interim_number_of_bytes = (((databytes_No[0] - '0') * 10 ) + (databytes_No[1] - '0'));
- }
- else if( databytes_No[3] == ':')
- {
- interim_number_of_bytes = (((databytes_No[0] - '0') * 100 ) + ((databytes_No[1] - '0') * 10 ) + (databytes_No[2] - '0'));
- }
- else //it's a 4-digit number
- {
- interim_number_of_bytes = (((databytes_No[0] - '0') * 1000 ) + ((databytes_No[1] - '0') * 100 ) + ((databytes_No[2] - '0') * 10 ) + (databytes_No[3] - '0'));
- }
-
- if(WIND64_count >= 1) /*WIND:64 came after pop of previous event and switch to data mode was issued*/
- /*WIND:64 came before pop of previous event and switch to data mode was issued*/
- {
- event_s.data_length = interim_number_of_bytes;// - (730*WIND64_count);
- WIND64_count++; //Count of the number of queued WIND:64 Events
- interim_number_of_bytes = 0;
- break;
- }
- else
- {
- event_s.data_length = interim_number_of_bytes;
- WIND64_count++; //Count of the number of queued WIND:64 Events
- interim_number_of_bytes = 0;
- }
- break;
-
- case In_Command_Mode:
- status_flag.command_mode= WIFI_TRUE;
- status_flag.data_mode= WIFI_FALSE;
- WIND64_count=0; //reset the WIND64 count since the previous data mode would have consumed all data
- break;
-
- case In_Data_Mode:
- status_flag.command_mode = WIFI_FALSE;
- status_flag.data_mode = WIFI_TRUE;
-
- if(status_flag.switch_by_default_to_command_mode == WIFI_TRUE)
- {
- if(!status_flag.command_mode)
- {
- WiFi_switch_to_command_mode();//switch by default
- }
- }
- if(status_flag.data_pending_sockD == WIFI_TRUE)
- {
-
- process_buffer_index =5;
- status_flag.enable_sock_read = WIFI_TRUE;//now data will start coming
- //Set the data-length to read
- SockON_Data_Length = number_of_bytes;
- }
- break;
-
- case WiFi__MiniAP_Associated:
- //Find out which client joined by parsing the WIND //+WIND:28
- ptr_offset = (char *) strstr((const char *)&process_buffer,"+WIND:28");
- for(i=17;i<=33;i++)
- client_MAC_address[i-17] = *(ptr_offset + i) ;
- WiFi_WIND_State.WiFiAPClientJoined = WIFI_TRUE;
- break;
-
- case WiFi_MiniAP_Disassociated:
- //Find out which client left by parsing the WIND //+WIND:72
- ptr_offset = (char *) strstr((const char *)&process_buffer,"+WIND:72");
- for(i=17;i<=33;i++)
- client_MAC_address[i-17] = *(ptr_offset + i) ;
- WiFi_WIND_State.WiFiAPClientLeft = WIFI_TRUE;
- break;
-
- case Console_Active:
- case Poweron :
- case WiFi_Reset:
- case Watchdog_Running:
- case Heap_Too_Small:
- case WiFi_Hardware_Dead:
- case Watchdog_Terminating:
- case SysTickConfigure:
- case Hard_Fault:
- case StackOverflow:
- case MallocFailed:
- case Error:
- case WiFi_PS_Mode_Failure:
- case CopyrightInfo:
- case WiFi_BSS_Regained:
- case WiFi_Signal_LOW:
- case WiFi_Signal_OK:
- case FW_update:
- case Encryption_key_Not_Recognized:
- case WiFi_Join:
- case JOINFAILED:
- case WiFi_Scanning:
- case SCANBLEWUP:
- case SCANFAILED:
- case WiFi_Up:
- case WiFi_Association_Successful:
- case WiFi_Started_MiniAP_Mode:
- case Start_Failed :
- case WiFi_EXCEPTION :
- case WiFi_Hardware_Started :
- case WiFi_BSS_LOST:
- case WiFi_Unhandled_Event:
- case Scan_Complete:
- case WiFi_UNHANDLED_IND:
- case WiFi_UNHANDLED:
- case WiFi_Powered_Down:
- case WiFi_MiniAP_Mode :
- case WiFi_Deauthentication:
- case WiFi_Disassociation:
- case RX_MGMT:
- case RX_DATA:
- case RX_UNK:
- case DOT11_AUTHILLEGAL:
- case Creating_PSK:
- case WPA_Terminated :
- case WPA_Supplicant_Failed:
- case WPA_Handshake_Complete:
- case GPIO_line:
- case Wakeup:
- case Factory_debug:
- case Remote_Configuration:
- break;
- default:
- break;
- }
- memset(process_buffer, 0x00, MAX_BUFFER_GLOBAL);
- }
- }
-}
-
-/**
-* @brief Process_Dequeued_Wind_Indication
-* Process Wind Indication after popping from Queue
-* @param event_pop_s1 popped event contents
-* @retval None
-*/
-
-void Process_WiFi_Indication_Cmd(event_s_TypeDef * event_pop_s1)
-{
- switch(event_pop_s1->wind)
- {
- case Console_Active:
- WiFi_WIND_State.ConsoleActive = WIFI_TRUE;
- break;
- case Poweron :
- WiFi_WIND_State.WiFiPowerON = WIFI_TRUE;
- break;
- case WiFi_Reset:
- WiFi_WIND_State.WiFiReset = WIFI_TRUE;
- break;
- case Watchdog_Running:
- break;
- case Heap_Too_Small:
- WiFi_WIND_State.HeapTooSmall=WIFI_TRUE;
- break;
- case WiFi_Hardware_Dead:
- WiFi_WIND_State.WiFiHWFailure = WIFI_TRUE;
- break;
- case Watchdog_Terminating:
- break;
- case SysTickConfigure:
- break;
- case Hard_Fault:
- WiFi_WIND_State.HardFault = WIFI_TRUE;
- break;
- case StackOverflow:
- WiFi_WIND_State.StackOverflow = WIFI_TRUE;
- break;
- case MallocFailed:
- WiFi_WIND_State.MallocFailed = WIFI_TRUE;
- break;
- case Error:
- WiFi_WIND_State.InitFailure = WIFI_TRUE;
- break;
- case WiFi_PS_Mode_Failure:
- WiFi_WIND_State.PS_Mode_Failure = WIFI_TRUE;
- break;
- case CopyrightInfo:
- break;
- case WiFi_BSS_Regained:
- break;
- case WiFi_Signal_LOW:
- WiFi_WIND_State.WiFiSignalLOW = WIFI_TRUE;
- break;
- case WiFi_Signal_OK :
- break;
- case FW_update:
- break;
- case Encryption_key_Not_Recognized:
- break;
- case WiFi_Join :
- WiFi_WIND_State.WiFiJoin = WIFI_TRUE;
- break;
- case JOINFAILED :
- WiFi_WIND_State.WiFiJoinFailed = WIFI_TRUE;
- break;
- case WiFi_Scanning :
- WiFi_WIND_State.WiFiScanning = WIFI_TRUE;
- break;
- case SCANBLEWUP:
- WiFi_WIND_State.WiFiScanBlewUp = WIFI_TRUE;
- break;
- case SCANFAILED:
- WiFi_WIND_State.WiFiScanFailed = WIFI_TRUE;
- break;
- case WiFi_Up:
- WiFi_WIND_State.WiFiUp = WIFI_TRUE;
- break;
- case WiFi_Association_Successful:
- WiFi_WIND_State.WiFiAssociation = WIFI_TRUE;
- break;
- case WiFi_Started_MiniAP_Mode:
- WiFi_WIND_State.WiFiStarted_MiniAPMode = WIFI_TRUE;
- break;
- case Start_Failed :
- WiFi_WIND_State.StartFailed = WIFI_TRUE;
- break;
- case WiFi_EXCEPTION :
- WiFi_WIND_State.WiFiException = WIFI_TRUE;
- break;
- case WiFi_Hardware_Started :
- wifi_ready++;
- status_flag.WiFi_Enabled = WIFI_TRUE;
- WiFi_WIND_State.WiFiHWStarted = WIFI_TRUE;
- /*If this is a start-up after standby*/
- if(status_flag.trigger_wakeup_callback == WIFI_TRUE)
- {
- status_flag.trigger_wakeup_callback = WIFI_FALSE;
- status_flag.Standby_Enabled = WIFI_FALSE;
- status_flag.standby_resume_callback = WIFI_TRUE;
- }
- break;
- case WiFi_BSS_LOST:
- break;
- case WiFi_Unhandled_Event:
- break;
- case Scan_Complete:
- WiFi_WIND_State.WiFiScanComplete = WIFI_TRUE;
- status_flag.Scan_Ongoing = WIFI_FALSE;
- break;
- case WiFi_UNHANDLED_IND:
- WiFi_WIND_State.WiFiUnHandledInd = WIFI_TRUE;
- break;
- case WiFi_UNHANDLED:
- break;
- case WiFi_Powered_Down:
- status_flag.WiFi_Enabled = WIFI_FALSE;
- //wifi_ready = 0;
- WiFi_WIND_State.WiFiHWStarted = WIFI_FALSE;
- WiFi_WIND_State.WiFiPowerDown = WIFI_TRUE;
- break;
- case WiFi_MiniAP_Mode :
- WiFi_WIND_State.WiFiMiniAPMode = WIFI_TRUE;
- break;
- case WiFi_Deauthentication:
- WiFi_WIND_State.WiFiDeauthentication = WIFI_TRUE;
- break;
- case WiFi_Disassociation:
- WiFi_WIND_State.WiFiDisAssociation = WIFI_TRUE;
- break;
- case RX_MGMT:
- WiFi_WIND_State.WiFiRXMgmt = WIFI_TRUE;
- break;
- case RX_DATA:
- WiFi_WIND_State.WiFiRXData = WIFI_TRUE;
- break;
- case RX_UNK:
- WiFi_WIND_State.WiFiRxUnk = WIFI_TRUE;
- break;
- case DOT11_AUTHILLEGAL:
- break;
- case Creating_PSK:
- break;
- case WPA_Terminated :
- break;
- case WPA_Supplicant_Failed:
- break;
- case WPA_Handshake_Complete:
- break;
- case GPIO_line:
- break;
- case Wakeup:
- break;
- case Factory_debug:
- break;
-
- case SockON_Data_Pending:
-
- /* +WIND:55:Pending Data:%d:%d */
- if (status_flag.enable_sock_read == WIFI_TRUE)
- {
- #if DEBUG_PRINT
- printf ("\nAlert!\r\n");
- #endif
- status_flag.enable_sock_read = WIFI_FALSE;
- status_flag.enable_receive_data_chunk = WIFI_FALSE;
- //break;
- }
- sockon_query_id = event_pop_s1->socket_id;
- if(open_sockets[sockon_query_id])
- {
- status_flag.enable_query = WIFI_TRUE;
- status_flag.stop_event_dequeue = WIFI_TRUE;
- }
-
- break;
-
- case SockON_Server_Socket_Closed:
- client_socket_close_id = event_pop_s1->socket_id;
- status_flag.Client_Socket_Close_Cmd = WIFI_TRUE;
- break;
-
- case SockD_Pending_Data:
- number_of_bytes = event_pop_s1->data_length;
- status_flag.data_pending_sockD = WIFI_TRUE;
- status_flag.stop_event_dequeue = WIFI_TRUE; //Stop any more event de-queue
- status_flag.enable_receive_data_chunk = WIFI_TRUE; // read data in chunk now from ring buffer
-
- if(!status_flag.data_mode)
- {
- if(event_pop_s1->wind64_pending_packet_no == 1) { //If this is the first WIND64 pending event de-Q'ed
- status_flag.switch_by_default_to_command_mode = WIFI_FALSE; //we don't want to switch back to command mode after changing to data mode here
- WiFi_switch_to_data_mode(); //switch by default
- }
- }
- else //already data is coming from previous WIND:64
- {
- process_buffer_index =5;
- status_flag.enable_sock_read = WIFI_TRUE;//n
- SockON_Data_Length = number_of_bytes;
- }
- break;
-
- case Incoming_socket_client:
- status_flag.Client_Connected = WIFI_TRUE;
- wifi_client_connected=1; //Set this so that the callback can be made to the user
- break;
-
- case Outgoing_socket_client:
- status_flag.Client_Disconnected = WIFI_TRUE;
- wifi_client_disconnected=0;//Set this so that the callback can be made to the user
- wifi_client_connected = 0;
- break;
-
- case SockD_Dropping_Data:
- WiFi_WIND_State.WiFiSockdDataLost = WIFI_TRUE;
- break;
-
- case Low_Power_Mode_Enabled:
- status_flag.Low_Power_Enabled = WIFI_TRUE;
- break;
-
- case Going_Into_Standby:
- status_flag.Standby_Enabled = WIFI_TRUE;
- break;
-
- case Resuming_From_Standby:
- status_flag.Standby_Enabled = WIFI_FALSE;
- status_flag.standby_resume_callback = WIFI_TRUE;
- break;
- case Going_Into_DeepSleep:
- status_flag.Deep_Sleep_Enabled = WIFI_TRUE;
- break;
- case Resuming_From_DeepSleep:
- status_flag.Deep_Sleep_Enabled = WIFI_FALSE;
- Start_DeepSleep_Timer();
- break;
- default:
- break;
- }
-}
-
-/**
-* @brief Queue_Http_Get_ Event
-* Queue an HTTP-Request Event (GET/POST)
-* @param hostname hostname for HTTP-GET/POST
-* @param path path for HTTP-GET
-* @param port_number port_number for HTTP-GET
-* @param pURL_path full URL for HTTP-POST
-* @retval None
-*/
-
-void Queue_Http_Event(uint8_t * hostname, uint8_t * path, uint32_t port_number, uint8_t * pURL_path)
-{
- Wait_For_Sock_Read_To_Complete();
- if(pURL_path == NULL)
- {
- curr_hostname = hostname;
- curr_path = path;
- curr_port_number = port_number;
- }
- else
- curr_pURL = pURL_path;
-
- event_s.event = WIFI_HTTP_EVENT;
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
-
- reset_event(&event_s);
-}
-
-/**
-* @brief Queue_Client_Write_Event
-* Queues a Client Socket write event.
-* @param sock_id socket ID to write to
-* @param DataLength length of the data to be written
-* @param pData pointer to data
-* @retval None
-*/
-void Queue_Client_Write_Event(uint8_t sock_id, uint16_t DataLength, char * pData)
-{
- Wait_For_Sock_Read_To_Complete();
- curr_DataLength = DataLength;
- curr_data = pData;
- curr_sockID = sock_id;
- status_flag.enable_client_socket_write = WIFI_TRUE;
-
- event_s.event = WIFI_CLIENT_SOCKET_WRITE_EVENT;
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
-
- reset_event(&event_s);
-}
-
-/**
-* @brief Queue_Wifi_File_Image_Create_Event
-* Queue a File Image Create Event
-* @param pHostName hostname
-* @param pFileName filename within host
-* @param port_number port number to connect to
-* @retval None
-*/
-void Queue_Wifi_File_Event(uint8_t * pHostName, uint8_t * pFileName, uint32_t port_number)
-{
- Wait_For_Sock_Read_To_Complete();
- event_s.event = WIFI_FILE_EVENT;
- curr_filename = pFileName;
- curr_hostname = pHostName;
- curr_port_number = port_number;
-
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
-
- reset_event(&event_s);
-}
-
-/**
-* @brief Queue_Wifi_FW_Update_Event
-* Queue a Firmware update Event
-* @param hostname hostname
-* @param filename_path filename and path within host
-* @param port_number port number to connect to
-* @retval None
-*/
-void Queue_Wifi_FW_Update_Event(uint8_t * hostname, uint8_t * filename_path, uint32_t port_number)
-{
- Wait_For_Sock_Read_To_Complete();
- event_s.event = WIFI_FW_UPDATE_EVENT;
- curr_filename = filename_path;
- curr_hostname = hostname;
- curr_port_number = port_number;
-
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
-
- reset_event(&event_s);
-}
-
-void Queue_Client_Open_Event(uint8_t * hostname, uint32_t port_number, uint8_t * protocol)
-{
- Wait_For_Sock_Read_To_Complete();
- curr_hostname = hostname;
- curr_port_number = port_number;
- curr_protocol = protocol;
-
- event_s.event = WIFI_CLIENT_SOCKET_OPEN_EVENT;
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
-
- reset_event(&event_s);
-}
-
-void Queue_Client_Close_Event(uint8_t sock_id)
-{
- Wait_For_Sock_Read_To_Complete();
-
- event_s.event = WIFI_CLIENT_SOCKET_CLOSE_EVENT;
- event_s.socket_id = sock_id;
- __disable_irq();
- push_eventbuffer(&event_buff, event_s);
- __enable_irq();
-
- reset_event(&event_s);
-}
-
-/**
-* @brief Wait_For_Sock_Read_To_Complete
-* Wait till sock is over and the OK of read arrives
-* @param None
-* @retval None
-*/
-void Wait_For_Sock_Read_To_Complete(void)
-{
- //wait if read is ongoing or read OK is yet to arrive
- while(status_flag.sock_read_ongoing==WIFI_TRUE || status_flag.prevent_push_OK_event==WIFI_TRUE)
- {
- asm("NOP");
- }
-}
-
-/**
-* @brief Reset_AT_CMD_Buffer
-* Clear USART2 Rx buffer and Wi-Fi AT cmd buffer
-* @param None
-* @retval None
-*/
-void Reset_AT_CMD_Buffer()
-{
- memset(WiFi_AT_Cmd_Buff, 0x00, sizeof WiFi_AT_Cmd_Buff);
-}
-
-#ifdef USE_FULL_ASSERT
-
-/**
-* @brief Reports the name of the source file and the source line number
-* where the assert_param error has occurred.
-* @param file: pointer to the source file name
-* @param line: assert_param error line source number
-* @retval None
-*/
-void assert_failed(uint8_t* file, uint32_t line)
-{
- /* User can add his own implementation to report the file name and line number,
- ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
-
- /* Infinite loop */
- while (1)
- {
- }
-}
-
-#endif
-
-
-/**
-* @brief search_buffer
-* search for substring in a buffer that contains null
-* @param pSourceBuff : pointer of source buffer
-* sourceBuffLen : length of string buffer
-* pSearchStringBuff : pointer of search string buffer
-* seartchStringLen : length of search string buffer
-* @retval pointer of source buffer
-*/
-char *search_buffer(char *pSourceBuff, uint16_t sourceBuffLen, char *pSearchStringBuff, uint16_t seartchStringLen)
-{ /* warning: O(n^2) */
- int searchlen = sourceBuffLen - seartchStringLen + 1;
- for ( ; searchlen-- > 0; pSourceBuff++)
- if (!memcmp(pSourceBuff, pSearchStringBuff, seartchStringLen))
- return pSourceBuff;
- return NULL;
-}
-
-/**
-* @brief Delete_Colon
-* delete colon from input buffer
-* @param input : pointer of input buffer
-* @retval return pointer of updated buffer
-*/
-char* Delete_Colon(char* input)
-{
- int i,j;
- char *output=input;
-
- /* Delete Colon */
- for (i = 0, j = 0; i<strlen(input); i++,j++)
- {
-#if 0
- if (input[i]!=':') && (input[i]!='\r')&& (input[i]!='\n')&& (input[i]!='O')&& (input[i]!='K'))
- output[j]=input[i];
- else
- j--;
-#else
- if ((input[i] ==':') || (input[i]=='\r')|| (input[i]=='\n')|| (input[i]=='O')|| (input[i]=='K'))
- j--;
- else
- output[j]=input[i];
- }
- //output[j]=NULL;
-#endif
- return output;
-}
-
-/**
-* @brief Read_WiFi_SSID
-* Read SSID of WiFi module store in flash
-* @param string : pointer of SSID
-* @retval return status of AT cmd request
-*/
-WiFi_Status_t Read_WiFi_SSID(char *string)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- char * ssid = "wifi_ssid";
- char * pStr;
- /* AT+S.GCFG=wifi_ssid read SSID */
- Reset_AT_CMD_Buffer();
-
- /* AT : send AT command */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_CONFIGURATION_VALUE,ssid);
-
- /*
- Response :
- # wifi_ssid = 41:6E:53:53:49:44:00:00:00:00:00:00:00:00:00:00:00:00:00:
- 00:00:00:00:00:00:00:00:00:00:00:00:00<cr><lf>
- <cr><lf>OK<cr><lf>
- */
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
-
- /* find a substring (# wifi_ssid = )inside a USART2_RxBuffer that may contain nulls */
- uint16_t sourceBuffLen = sizeof(get_cfg_value)-1; /* exclude null terminator from length */
- char searchStringBuff[] = "# wifi_ssid = ";
- uint16_t stringBuffLen = sizeof(searchStringBuff)-1; /* exclude null terminator from length */
- char *res = search_buffer((char *)&get_cfg_value, sourceBuffLen, searchStringBuff, stringBuffLen);
-
- pStr = (char *) (strstr((const char *)res,"= "));
- if(pStr != NULL)
- {
- strcat( string, (pStr + 2));
- /* Remove colon,\r,\n,OK strings */
- memcpy(string, Delete_Colon(string) , 32);
- }
- return status;
-}
-
-/**
-* @brief Read_WiFi_SecKey
-* Read Security key of WiFi module store in flash
-* @param string : pointer of Security key
-* @retval return status of AT cmd request
-*/
-WiFi_Status_t Read_WiFi_SecKey(char *string)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- char *seckey = "wifi_wpa_psk_text";
- char *pStr;
-
- /* AT+S.GCFG=wifi_ssid read SSID */
- Reset_AT_CMD_Buffer();
-
- /* AT : send AT command */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_CONFIGURATION_VALUE,seckey);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
-
-
- /* find a substring (wifi_wpa_psk_text = )inside a USART2_RxBuffer that may contain nulls */
- uint16_t sourceBuffLen = sizeof(get_cfg_value)-1; /* exclude null terminator from length */
- char searchStringBuff[] = "wifi_wpa_psk_text = ";
- uint16_t stringBuffLen = sizeof(searchStringBuff)-1; /* exclude null terminator from length */
- char *res = search_buffer((char *)&get_cfg_value, sourceBuffLen, searchStringBuff, stringBuffLen);
-
- pStr = (char *) (strstr((const char *)res,"= "));
- if(pStr != NULL)
- {
- strcat( string, (pStr + 2));
- /* Remove colon,\r,\n,OK strings */
- memcpy(string, Delete_Colon(string) , 32);
- }
-
- return status;
-}
-
-/**
-* @brief Read_WiFi_Mode
-* Read Wi-Fi mode 0: idle,1 =STA,2 =IBSS,3 =MiniAP
-* @param string : return wifi mode type
-* @retval return status of AT cmd request
-*/
-WiFi_Status_t Read_WiFi_Mode(char *string)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- char *mode = "wifi_mode";
- char *pStr;
-
- /* AT+S.GCFG=wifi_mode */
- Reset_AT_CMD_Buffer();
-
- /* AT : send AT command */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_CONFIGURATION_VALUE,mode);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
-
- pStr = (char *) strstr((const char *)&get_cfg_value,"wifi_mode = ");
- if(pStr != NULL)
- {
- string[0] = *(pStr + 12) ;
- }
-
- return status ;
-}
-
-/**
-* @brief Write_WiFi_SSID
-* Store SSID in flash memory of WiFi module
-* @param string : pointer of SSID
-* @retval return status of AT cmd request
-*/
-WiFi_Status_t Write_WiFi_SSID(char *string)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- Reset_AT_CMD_Buffer();
-
- /* AT+S.SSIDTXT=abcd <ExampleSSID> //set SSID */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_SSID,string);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
-
- /* AT&W :Save the settings on the flash memory */
- Reset_AT_CMD_Buffer();
- Save_Current_Setting();
-
- return status;
-
-}
-
-
-/**
-* @brief Write_WiFi_SecKey
-* Store security key in flash memory of WiFi module
-* @param string : pointer of security key
-* @retval return status of AT cmd request
-*/
-WiFi_Status_t Write_WiFi_SecKey(char *string)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- Reset_AT_CMD_Buffer();
-
- /* AT+S.SCFG=wifi_wpa_psk_text,helloworld : set password */
- sprintf((char*)WiFi_AT_Cmd_Buff,"AT+S.SCFG=wifi_wpa_psk_text,%s\r",string);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
-
- /* AT&W :Save the settings on the flash memory */
- Reset_AT_CMD_Buffer();
- Save_Current_Setting();
-
- return status;
-}
-
-
-
-/**
-* @brief PrintErrorMsg
-* Print error message on UART terminal
-* @param None
-* @retval None
-*/
-void PrintErrorMsg (void)
-{
- Print_Msg("error in AT cmd",sizeof("error in AT cmd"));
-}
-
-/**
- * @brief Print_Msg
- * Print messages on UART terminal
- * @param msgBuff : Contains data that need to be print
- * @param length : leghth of the data
- * @retval None
- */
-void Print_Msg(char * msgBuff,uint8_t length)
-{
-
-}
-
-/**
-* @brief Error_Handler
-* This function is executed in case of error occurrence.
-* @param None
-* @retval None
-*/
-void Error_Handler(void)
-{
- /* Turn LED2 on */
- //BSP_LED_On(LED2);
- //The following while(1) is commented as it prevents standby functionality
- /*while(1)
- {
- //Error if LED2 is slowly blinking (1 sec. period)
- BSP_LED_Toggle(LED2);
- HAL_Delay(1000);
- } */
- Receive_Data();
-}
-
-
-/**
-* @brief Start_DeepSleep_Timer
-* start the deep sleep timer.
-* @param None
-* @retval void
-*/
-void Start_DeepSleep_Timer(void)
-{
- status_flag.Deep_Sleep_Timer = WIFI_TRUE;
- sleep_count = 0;
-}
-
-/**
-* @brief Stop_DeepSleep_Timer
-* stop the deep sleep timer.
-* @param None
-* @retval void
-*/
-void Stop_DeepSleep_Timer()
-{
- status_flag.Deep_Sleep_Timer = WIFI_FALSE;
- sleep_count = 0;
-}
-
-#if 0
-/**
-* @brief configure_to_exti
-* Configured the USART Rx pin to EXTI pin to capture standby wakeup interrupt
-* @param None
-* @retval None
-*/
-void configure_to_exti()
-{
- /*configure the pin*/
-
- HAL_NVIC_DisableIRQ(USARTx_IRQn);//Disable UART IRQ
-
- /* USART_RX Pin as EXTI IRQ*/
- GPIO_InitTypeDef GPIO_InitStruct;
- GPIO_InitStruct.Pin = WiFi_USART_RX_PIN;
- GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
- GPIO_InitStruct.Pull = GPIO_NOPULL;
- GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
-#if defined (USE_STM32L0XX_NUCLEO) || (USE_STM32F4XX_NUCLEO)
- GPIO_InitStruct.Alternate = 0;
-#endif
- HAL_GPIO_Init(WiFi_USART_RX_GPIO_PORT, &GPIO_InitStruct);
-
- /* Configure the NVIC for EXTI */
- HAL_NVIC_SetPriority(USARTx_EXTI_IRQn, 3, 0);
- HAL_NVIC_EnableIRQ(USARTx_EXTI_IRQn);
-}
-#endif
-
-/**
-* @brief WiFi_switch_to_command_mode
-* switch to command mode from data mode
-* @param None
-* @retval None
-*/
-void WiFi_switch_to_command_mode(void)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- /* AT+S.*/
- Reset_AT_CMD_Buffer();
-
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_DATA_TO_CMD_MODE); //Notice the lower case
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- //nothing to do
- }
-}
-
-
-/**
-* @brief WiFi_switch_to_data_mode
-* switch to data mode from command mode
-* @param None
-* @retval None
-*/
-void WiFi_switch_to_data_mode(void)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- /* AT+S.*/
- Reset_AT_CMD_Buffer();
-
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_CMD_TO_DATA_MODE); //Notice the upper case
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-
- if(status == WiFi_MODULE_SUCCESS)
- {
- //nothing to do
- }
-
-}
-
-
-/**
-* @brief Attention_Cmd
-* Attention command
-* @param None
-* @retval WiFi_Status_t : status of AT cmd Request
-*/
-WiFi_Status_t Attention_Cmd()
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- Reset_AT_CMD_Buffer();
-
- /* AT : send AT command */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_ATTENTION);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
- return status;
-}
-
-
-/**
-* @brief SET_Power_State
-* SET power mode of wifi module
-* @param state : power mode of wi-fi module i.e active,sleep,standby,powersave
-* @retval WiFi_Status_t : status of AT cmd Request
-*/
-WiFi_Status_t SET_Power_State(WiFi_Power_State_t state)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
-#if DEBUG_PRINT
- printf("\r\n >>Soft Reset Wi-Fi module\r\n");
-#endif
-
- Reset_AT_CMD_Buffer();
-
- /* AT : send AT command */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_POWER_STATE,state);
-// WiFi_Module_State = Process_Event;
-// WiFi_WIND_State.WiFiReset = WIFI_FALSE;
- WiFi_WIND_State.WiFiHWStarted = WIFI_FALSE;
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status != WiFi_MODULE_SUCCESS)
- return status;
- memset((void*)&WiFi_WIND_State,0x00,sizeof(WiFi_WIND_State)); /*reset the WIND State?*/
- /* AT+CFUN=1 //Soft reset */
- while(WiFi_WIND_State.WiFiHWStarted != WIFI_TRUE)
- {
- asm("NOP");
- }
- return status;
-}
-
-
-/**
-* @brief Display_Help_Text
-* this function will print a list of all commands supported with a brief help text for each cmd
-* @param None
-* @retval WiFi_Status_t : status of AT cmd Request
-*/
-WiFi_Status_t Display_Help_Text()
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- Reset_AT_CMD_Buffer();
-
- /* AT : send AT command */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_HELP_TEXT);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
- return status;
-}
-
-/**
-* @brief WiFi_Get_IP_address
-* Get the ip address
-* @param ip_addr : pointer to ip address
-* @retval status : status of AT cmd request
-*/
-
-WiFi_Status_t WiFi_Get_IP_Address(uint8_t *ip_addr)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- int cfg_value_length, i;
-
- /* AT : send AT command */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_STATUS_VALUE,"ip_ipaddr");
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- cfg_value_length = strlen((const char*)get_cfg_value);
-
- //Optimise the following loop??
- for(i=7; i<=16; i++)//0th index is always ' ' which we ignore
- if(get_cfg_value[i] == '\r')//find the first '\r'
- {
- get_cfg_value[i] = '\0'; //Terminate the string by NULL
- break;
- }
-
- /* copy user pointer to get_cfg_value */
- memcpy(ip_addr,&get_cfg_value[1],i);//IP address will have max lenght fixed at 16 bytes (null terminated included).
- memset(get_cfg_value, 0x00,cfg_value_length);
- }
- return status;
-}
-
-/**
-* @brief WiFi_Get_MAC_address
-* Get the MAC address
-* @param ip_addr : pointer to MAC address
-* @retval status : status of AT cmd request
-*/
-
-WiFi_Status_t WiFi_Get_MAC_Address(uint8_t *mac_addr)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- int cfg_value_length;
-
- /* AT : send AT command */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_CONFIGURATION_VALUE,"nv_wifi_macaddr");
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- cfg_value_length = strlen((const char*)get_cfg_value);
- get_cfg_value[18] = '\0';//Terminate by NULL
- /* copy user pointer to get_cfg_value */
- memcpy(mac_addr,&get_cfg_value[1],18);//IP address will have max lenght fixed at 18 bytes.
- memset(get_cfg_value, 0x00,cfg_value_length);
- }
- return status;
-}
-
-/**
-* @brief GET_Configuration_Value
-* Get a wifi configuration value from the module
-* @param sVar_name : Name of the config variable
-* aValue : value of config variable to be returned to user
-* @retval WiFi_Status_t : status of AT cmd Request
-*/
-WiFi_Status_t GET_Configuration_Value(char* sVar_name,uint32_t *aValue)
-{
- int cfg_value_length;
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- Reset_AT_CMD_Buffer();
-
- /* AT : send AT command */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_GET_CONFIGURATION_VALUE,sVar_name);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- cfg_value_length = strlen((const char*)get_cfg_value);
- memcpy(aValue,get_cfg_value,cfg_value_length); //copy user pointer to get_cfg_value
- memset(get_cfg_value, 0x00,cfg_value_length);
- }
- return status;
-}
-
-/**
-* @brief SET_Configuration_Addr
-* Get a wifi configuration address from the module
-* @param sVar_name : Name of the config variable
-* addr : value of config address to be returned to user
-* @retval WiFi_Status_t : status of AT cmd Request
-*/
-WiFi_Status_t SET_Configuration_Addr(char* sVar_name,char* addr)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- Reset_AT_CMD_Buffer();
-
- /* AT : send AT command */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_CONFIGURATION_ADDRESS,sVar_name,addr);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
- return status;
-}
-
-/**
-* @brief SET_Configuration_Value
-* SET the value of configuration variable
-* @param sVar_name : Name of the config variable
-* aValue : value of config variable
-* @retval WiFi_Status_t : status of AT cmd Request
-*/
-WiFi_Status_t SET_Configuration_Value(char* sVar_name,uint32_t aValue)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- Reset_AT_CMD_Buffer();
-
- /* AT : send AT command */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_CONFIGURATION_VALUE,sVar_name,(int)aValue);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
- return status;
-}
-
-/**
-* @brief SET_SSID
-* SET SSID in flash memory of Wi-Fi module
-* @param ssid : pointer of SSID
-* @retval WiFi_Status_t : status of AT cmd Request
-*/
-WiFi_Status_t SET_SSID(char* ssid)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- Reset_AT_CMD_Buffer();
-
- /* AT+S.SSIDTXT=abcd <ExampleSSID> */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_SSID,ssid);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
- return status;
-}
-
-
-/**
-* @brief SET_WiFi_SecKey
-* SET wifi security key
-* @param seckey : pointer of security key
-* @retval WiFi_Status_t : status of AT cmd Request
-*/
-WiFi_Status_t SET_WiFi_SecKey(char* seckey)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- Reset_AT_CMD_Buffer();
-
- /* AT+S.SCFG=wifi_wpa_psk_text,helloworld : set password */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_SEC_KEY,seckey);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
- return status;
-}
-
-
-/**
-* @brief Restore_Default_Setting
-* Restore the factory default values of the configuration variables
-* and writes them to non volatile storage
-* @param None
-* @retval WiFi_Status_t : status of AT cmd Request
-*/
-WiFi_Status_t Restore_Default_Setting()
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- //Reset_AT_CMD_Buffer();
-
- /* AT&F: restore default setting */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_RESTORE_DEFAULT_SETTING);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
-
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
- return status;
-
-}
-
-/**
-* @brief Save_Current_Setting
-* Store the current RAM-based setting to non-volatile storage
-* @param None
-* @retval WiFi_Status_t : status of AT cmd Request
-*/
-WiFi_Status_t Save_Current_Setting()
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- Reset_AT_CMD_Buffer();
-
- /* AT&W :Save the settings on the flash memory */
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SAVE_CURRENT_SETTING);
-
- status = USART_Transmit_AT_Cmd(strlen((char*)WiFi_AT_Cmd_Buff));
- if(status == WiFi_MODULE_SUCCESS)
- {
- status = USART_Receive_AT_Resp(Process_Event);
- }
- return status;
-}
-
-
-/**
-* @brief ResetBuffer
-* Reset receive data/indication msg buffer
-* @param None
-* @retval None
-*/
-void ResetBuffer()
-{
-
-}
-
-
-/**
-* @brief config_init_value
-* initalize config values before reset
-* @param sVar_name : Name of the config variable
-* aValue : value of config variable
-* @retval None
-*/
-WiFi_Status_t config_init_value(char* sVar_name,uint8_t aValue)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_CONFIGURATION_VALUE,sVar_name,aValue);
- /*if(HAL_UART_Transmit(&UartWiFiHandle, (uint8_t *)WiFi_AT_Cmd_Buff, strlen((char*)WiFi_AT_Cmd_Buff),1000)!= HAL_OK)
- {
- Error_Handler();
- return WiFi_HAL_UART_ERROR;
- }*/
-
- status = WaitForResponse(AT_RESP_LEN_OK);
- return status;
-}
-
-/**
-* @brief config_init_addr
-* initalize config strings/addresses before reset
-* @param sVar_name : Name of the config variable
-* addr : value of config address to be returned to user
-* @retval None
-*/
-WiFi_Status_t config_init_addr(char* sVar_name,char* addr)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
- Reset_AT_CMD_Buffer();
- sprintf((char*)WiFi_AT_Cmd_Buff,AT_SET_CONFIGURATION_ADDRESS,sVar_name,addr);
- /*if(HAL_UART_Transmit(&UartWiFiHandle, (uint8_t *)WiFi_AT_Cmd_Buff, strlen((char*)WiFi_AT_Cmd_Buff),1000)!= HAL_OK)
- {
- Error_Handler();
- return WiFi_HAL_UART_ERROR;
- }*/
-
- status = WaitForResponse(AT_RESP_LEN_OK);
- return status;
-
-}
-
-
-/**
-* @brief WaitForResponse
-* Wait for OK response
-* @param alength length of the data to be received
-* @retval None
-*/
-WiFi_Status_t WaitForResponse(uint16_t alength)
-{
- WiFi_Status_t status = WiFi_MODULE_SUCCESS;
-
- if(alength <= RxBufferSize)
- {
- /*if(HAL_UART_Receive(&UartWiFiHandle, (uint8_t *)USART_RxBuffer, alength,5000)!= HAL_OK)
- {
- Error_Handler();
- return WiFi_HAL_UART_ERROR;
- }*/
-
- if(((strstr((const char *)&USART_RxBuffer,"OK"))) == NULL)
- {
- return WiFi_AT_CMD_RESP_ERROR;
- }
-
- }
-
- return status;
-}
-/**** Wi-Fi indication call back *************/
-__weak void ind_wifi_warning(WiFi_Status_t warning_code)
-{
-}
-
-__weak void ind_wifi_error(WiFi_Status_t error_code)
-{
-}
-
-__weak void ind_wifi_connection_error(WiFi_Status_t status_code)
-{
-}
-
-__weak void ind_wifi_connected(void)
-{
-}
-
-__weak void ind_wifi_ap_ready(void)
-{
-}
-
-__weak void ind_wifi_ap_client_joined(uint8_t * client_mac_address)
-{
-}
-
-__weak void ind_wifi_ap_client_left(uint8_t * client_mac_address)
-{
-}
-
-__weak void ind_wifi_on(void)
-{
-}
-
-__weak void ind_wifi_packet_lost(WiFi_Status_t status_code)
-{
-}
-
-__weak void ind_wifi_gpio_changed(void)
-{
-}
-
-__weak void ind_wifi_socket_data_received(uint8_t socket_id, uint8_t * data_ptr, uint32_t message_size, uint32_t chunk_size)
-{
-}
-
-__weak void ind_wifi_socket_client_remote_server_closed(uint8_t * socketID)
-{
-}
-
-__weak void ind_wifi_socket_server_data_lost(void)
-{
-}
-
-__weak void ind_socket_server_client_joined(void)
-{
-}
-
-__weak void ind_socket_server_client_left(void)
-{
-}
-
-__weak void ind_wifi_http_data_available(uint8_t * data_ptr,uint32_t message_size)
-{
-}
-
-__weak void ind_wifi_file_data_available(uint8_t * data_ptr)
-{
-}
-__weak void ind_wifi_resuming(void)
-{
-}
-
-
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-
-/**
- * @}
- */
-
-/******************* (C) COPYRIGHT 2015 STMicroelectronics *****END OF FILE****/
-