/**
* \brief Callback to get the Wi-Fi status update.
*
* \param[in] msg_type type of Wi-Fi notification. Possible types are:
* - [M2M_WIFI_RESP_CURRENT_RSSI](@ref M2M_WIFI_RESP_CURRENT_RSSI)
* - [M2M_WIFI_RESP_CON_STATE_CHANGED](@ref M2M_WIFI_RESP_CON_STATE_CHANGED)
* - [M2M_WIFI_RESP_CONNTION_STATE](@ref M2M_WIFI_RESP_CONNTION_STATE)
* - [M2M_WIFI_RESP_SCAN_DONE](@ref M2M_WIFI_RESP_SCAN_DONE)
* - [M2M_WIFI_RESP_SCAN_RESULT](@ref M2M_WIFI_RESP_SCAN_RESULT)
* - [M2M_WIFI_REQ_WPS](@ref M2M_WIFI_REQ_WPS)
* - [M2M_WIFI_RESP_IP_CONFIGURED](@ref M2M_WIFI_RESP_IP_CONFIGURED)
* - [M2M_WIFI_RESP_IP_CONFLICT](@ref M2M_WIFI_RESP_IP_CONFLICT)
* - [M2M_WIFI_RESP_P2P](@ref M2M_WIFI_RESP_P2P)
* - [M2M_WIFI_RESP_AP](@ref M2M_WIFI_RESP_AP)
* - [M2M_WIFI_RESP_CLIENT_INFO](@ref M2M_WIFI_RESP_CLIENT_INFO)
* \param[in] pvMsg A pointer to a buffer containing the notification parameters
* (if any). It should be casted to the correct data type corresponding to the
* notification type. Existing types are:
* - tstrM2mWifiStateChanged
* - tstrM2MWPSInfo
* - tstrM2MP2pResp
* - tstrM2MAPResp
* - tstrM2mScanDone
* - tstrM2mWifiscanResult
*/
static void wifi_callback(uint8_t msg_type, void *msg_data)
{
switch (msg_type) {
case M2M_WIFI_RESP_CON_STATE_CHANGED:
{
tstrM2mWifiStateChanged *msg_wifi_state = (tstrM2mWifiStateChanged *)msg_data;
if (msg_wifi_state->u8CurrState == M2M_WIFI_CONNECTED) {
/* If Wi-Fi is connected. */
printf("Wi-Fi connected\r\n");
m2m_wifi_request_dhcp_client();
} else if (msg_wifi_state->u8CurrState == M2M_WIFI_DISCONNECTED) {
/* If Wi-Fi is disconnected. */
printf("Wi-Fi disconnected\r\n");
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
}
}
break;
case M2M_WIFI_REQ_DHCP_CONF:
{
uint8 *msg_ip_addr = (uint8 *)msg_data;
printf("Wi-Fi IP is %u.%u.%u.%u\r\n",
msg_ip_addr[0], msg_ip_addr[1], msg_ip_addr[2], msg_ip_addr[3]);
/* Send the HTTP request. */
http_client_send_request(&http_client_module_inst, MAIN_HTTP_CLIENT_TEST_URL, MAIN_HTTP_CLIENT_TEST_METHOD, NULL);
}
break;
default:
break;
}
}
/**
* \brief Callback to get the Wi-Fi status update.
*
* \param[in] u8MsgType type of Wi-Fi notification. Possible types are:
* - [M2M_WIFI_RESP_CURRENT_RSSI](@ref M2M_WIFI_RESP_CURRENT_RSSI)
* - [M2M_WIFI_RESP_CON_STATE_CHANGED](@ref M2M_WIFI_RESP_CON_STATE_CHANGED)
* - [M2M_WIFI_RESP_CONNTION_STATE](@ref M2M_WIFI_RESP_CONNTION_STATE)
* - [M2M_WIFI_RESP_SCAN_DONE](@ref M2M_WIFI_RESP_SCAN_DONE)
* - [M2M_WIFI_RESP_SCAN_RESULT](@ref M2M_WIFI_RESP_SCAN_RESULT)
* - [M2M_WIFI_REQ_WPS](@ref M2M_WIFI_REQ_WPS)
* - [M2M_WIFI_RESP_IP_CONFIGURED](@ref M2M_WIFI_RESP_IP_CONFIGURED)
* - [M2M_WIFI_RESP_IP_CONFLICT](@ref M2M_WIFI_RESP_IP_CONFLICT)
* - [M2M_WIFI_RESP_P2P](@ref M2M_WIFI_RESP_P2P)
* - [M2M_WIFI_RESP_AP](@ref M2M_WIFI_RESP_AP)
* - [M2M_WIFI_RESP_CLIENT_INFO](@ref M2M_WIFI_RESP_CLIENT_INFO)
* \param[in] pvMsg A pointer to a buffer containing the notification parameters
* (if any). It should be casted to the correct data type corresponding to the
* notification type. Existing types are:
* - tstrM2mWifiStateChanged
* - tstrM2MWPSInfo
* - tstrM2MP2pResp
* - tstrM2MAPResp
* - tstrM2mScanDone
* - tstrM2mWifiscanResult
*/
static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
switch (u8MsgType) {
case M2M_WIFI_RESP_CON_STATE_CHANGED:
{
tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) {
printf("wifi_cb: M2M_WIFI_RESP_CON_STATE_CHANGED: CONNECTED\r\n");
m2m_wifi_request_dhcp_client();
} else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) {
printf("wifi_cb: M2M_WIFI_RESP_CON_STATE_CHANGED: DISCONNECTED\r\n");
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
}
}
break;
case M2M_WIFI_REQ_DHCP_CONF:
{
uint8_t *pu8IPAddress = (uint8_t *)pvMsg;
wifi_connected = M2M_WIFI_CONNECTED;
printf("wifi_cb: M2M_WIFI_REQ_DHCP_CONF : IP is %u.%u.%u.%u\r\n", pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]);
}
break;
default:
break;
}
}
uint8_t WiFiClass::startConnect(const char *ssid, uint8_t u8SecType, const void *pvAuthInfo)
{
if (!_init) {
init();
}
// Connect to router:
if (_dhcp) {
_localip = 0;
_submask = 0;
_gateway = 0;
}
if (m2m_wifi_connect(ssid, strlen(ssid), u8SecType, pvAuthInfo, M2M_WIFI_CH_ALL) < 0) {
_status = WL_CONNECT_FAILED;
return _status;
}
_status = WL_IDLE_STATUS;
_mode = WL_STA_MODE;
// Wait for connection or timeout:
unsigned long start = millis();
while (!(_status & WL_CONNECTED) &&
!(_status & WL_DISCONNECTED) &&
millis() - start < 60000) {
m2m_wifi_handle_events(NULL);
}
if (!(_status & WL_CONNECTED)) {
_mode = WL_RESET_MODE;
}
memset(_ssid, 0, M2M_MAX_SSID_LEN);
memcpy(_ssid, ssid, strlen(ssid));
return _status;
}
/**
* \brief Callback to get the Wi-Fi status update.
*
* \param[in] u8MsgType type of Wi-Fi notification. Possible types are:
* - [M2M_WIFI_RESP_CON_STATE_CHANGED](@ref M2M_WIFI_RESP_CON_STATE_CHANGED)
* - [M2M_WIFI_REQ_DHCP_CONF](@ref M2M_WIFI_REQ_DHCP_CONF)
* \param[in] pvMsg A pointer to a buffer containing the notification parameters
* (if any). It should be casted to the correct data type corresponding to the
* notification type.
*/
static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
switch (u8MsgType) {
case M2M_WIFI_RESP_CON_STATE_CHANGED:
{
tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) {
m2m_wifi_request_dhcp_client();
} else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) {
printf("Wi-Fi disconnected\r\n");
/* Connect to defined AP. */
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (void *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
}
break;
}
case M2M_WIFI_REQ_DHCP_CONF:
{
uint8_t *pu8IPAddress = (uint8_t *)pvMsg;
printf("Wi-Fi connected\r\n");
printf("Wi-Fi IP is %u.%u.%u.%u\r\n",
pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]);
/* Start OTA Firmware download. */
m2m_ota_start_update((uint8_t *)MAIN_OTA_URL);
break;
}
default:
{
break;
}
}
}
/**
* \brief Callback to get the Wi-Fi status update.
*
* \param[in] msg_type Type of Wi-Fi notification. Possible types are:
* - [M2M_WIFI_RESP_CURRENT_RSSI](@ref M2M_WIFI_RESP_CURRENT_RSSI)
* - [M2M_WIFI_RESP_CON_STATE_CHANGED](@ref M2M_WIFI_RESP_CON_STATE_CHANGED)
* - [M2M_WIFI_RESP_CONNTION_STATE](@ref M2M_WIFI_RESP_CONNTION_STATE)
* - [M2M_WIFI_RESP_SCAN_DONE](@ref M2M_WIFI_RESP_SCAN_DONE)
* - [M2M_WIFI_RESP_SCAN_RESULT](@ref M2M_WIFI_RESP_SCAN_RESULT)
* - [M2M_WIFI_REQ_WPS](@ref M2M_WIFI_REQ_WPS)
* - [M2M_WIFI_RESP_IP_CONFIGURED](@ref M2M_WIFI_RESP_IP_CONFIGURED)
* - [M2M_WIFI_RESP_IP_CONFLICT](@ref M2M_WIFI_RESP_IP_CONFLICT)
* - [M2M_WIFI_RESP_P2P](@ref M2M_WIFI_RESP_P2P)
* - [M2M_WIFI_RESP_AP](@ref M2M_WIFI_RESP_AP)
* - [M2M_WIFI_RESP_CLIENT_INFO](@ref M2M_WIFI_RESP_CLIENT_INFO)
* \param[in] msg_data A pointer to a buffer containing the notification parameters
* (if any). It should be casted to the correct data type corresponding to the
* notification type. Existing types are:
* - tstrM2mWifiStateChanged
* - tstrM2MWPSInfo
* - tstrM2MP2pResp
* - tstrM2MAPResp
* - tstrM2mScanDone
* - tstrM2mWifiscanResult
*/
static void wifi_cb(uint8 msg_type, void *msg_data)
{
switch (msg_type) {
case M2M_WIFI_RESP_CON_STATE_CHANGED:
{
tstrM2mWifiStateChanged *msg_wifi_state = (tstrM2mWifiStateChanged *)msg_data;
if (msg_wifi_state->u8CurrState == M2M_WIFI_CONNECTED) {
/* If Wi-Fi is connected. */
printf("Wi-Fi connected.\r\n");
m2m_wifi_request_dhcp_client();
} else if (msg_wifi_state->u8CurrState == M2M_WIFI_DISCONNECTED) {
/* If Wi-Fi is disconnected. */
printf("Wi-Fi disconnected!\r\n");
wifi_connected = M2M_WIFI_DISCONNECTED;
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
}
}
break;
case M2M_WIFI_REQ_DHCP_CONF:
{
uint8 *pu8IPAddress = (uint8 *)msg_data;
wifi_connected = M2M_WIFI_CONNECTED;
printf("Wi-Fi IP is %u.%u.%u.%u\r\n", pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]);
}
break;
default:
break;
}
}
/**
* \brief Main application function.
*
* Initializing the board and connect to wireless router.
* And event handling the Wi-Fi and SW timer.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
/* Initialize the board. */
system_init();
/* Initialize the UART console. */
configure_console();
/* Initialize the Timer. */
configure_timer();
/* Initialize the HTTP client service. */
configure_http_client();
/* Initialize the BSP. */
nm_bsp_init();
/* Output example information */
printf(STRING_HEADER);
/* Initialize Wi-Fi driver with data and Wi-Fi status callbacks. */
param.pfAppWifiCb = wifi_callback; /* Set Wi-Fi event callback. */
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) { /* Loop forever. */
}
}
/* Initialize Socket module */
socketInit();
registerSocketCallback(socket_event_handler, socket_resolve_handler);
/* Connect to router. */
ret = m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
if (M2M_SUCCESS != ret) {
printf("main: failed to connect access point!\r\n");
while (1) {
}
}
while (1) {
/* Handle pending events from network controller. */
m2m_wifi_handle_events(NULL);
/* Checks the timer timeout. */
sw_timer_task(&swt_module_inst);
}
}
/**
* \brief Main application function.
*
* Application entry point.
*
* \return program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
/* Initialize the board. */
system_init();
/* Initialize the UART console. */
configure_console();
printf(STRING_HEADER);
/* Initialize the BSP. */
nm_bsp_init();
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_cb;
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) {
}
}
/* Initialize Socket module */
socketInit();
registerSocketCallback(socket_cb, resolve_cb);
/* Connect to router. */
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
while (1) {
m2m_wifi_handle_events(NULL);
if (gbConnectedWifi && gbHostIpByName) {
if (gu8SocketStatus == SocketInit) {
if (tcp_client_socket < 0) {
gu8SocketStatus = SocketWaiting;
if (sslConnect() != SOCK_ERR_NO_ERROR) {
gu8SocketStatus = SocketInit;
}
}
}
}
}
return 0;
}
/**
* \brief Callback to get the Wi-Fi status update.
*
* \param[in] u8MsgType type of Wi-Fi notification. Possible types are:
* - [M2M_WIFI_RESP_CURRENT_RSSI](@ref M2M_WIFI_RESP_CURRENT_RSSI)
* - [M2M_WIFI_RESP_CON_STATE_CHANGED](@ref M2M_WIFI_RESP_CON_STATE_CHANGED)
* - [M2M_WIFI_REQ_DHCP_CONF](@ref M2M_WIFI_REQ_DHCP_CONF)
* \param[in] pvMsg A pointer to a buffer containing the notification parameters
* (if any). It should be casted to the correct data type corresponding to the
* notification type.
*/
static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
switch (u8MsgType) {
case M2M_WIFI_RESP_CON_STATE_CHANGED:
{
tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) {
m2m_wifi_request_dhcp_client();
} else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) {
printf("Wi-Fi disconnected\r\n");
/* Connect to defined AP. */
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (void *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
}
break;
}
case M2M_WIFI_REQ_DHCP_CONF:
{
uint8_t *pu8IPAddress = (uint8_t *)pvMsg;
printf("Wi-Fi connected\r\n");
printf("Wi-Fi IP is %u.%u.%u.%u\r\n",
pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]);
/* Request RSSI for the connected AP. */
m2m_wifi_req_curr_rssi();
break;
}
case M2M_WIFI_RESP_CURRENT_RSSI:
{
/* This message type is triggered by "m2m_wifi_req_curr_rssi()" function. */
int8_t *rssi = (int8_t *)pvMsg;
printf("RSSI for the current connected AP (%d)\r\n", (int8_t)(*rssi));
break;
}
default:
{
break;
}
}
}
/**
* \brief Main application function.
*
* Application entry point.
* Initialize system, UART and board specific settings.
* Connect AP using Security mode WEP, WPA
*
* \return program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
/* Initialize the board. */
sysclk_init();
board_init();
/* Initialize the UART console. */
configure_console();
printf(STRING_HEADER);
/* Initialize the BSP. */
nm_bsp_init();
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_cb;
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) {
}
}
/* Case 1. Connect to AP with security type WEP. */
/* m2m_wifi_connect((char *)MAIN_WLAN_DEVICE_NAME, strlen((char *)MAIN_WLAN_DEVICE_NAME), M2M_WIFI_SEC_WEP, &wep64_parameters, M2M_WIFI_CH_ALL); */
/* Case 2. Connect to AP with security type WPA. */
m2m_wifi_connect((char *)MAIN_WLAN_DEVICE_NAME, strlen((char *)MAIN_WLAN_DEVICE_NAME), M2M_WIFI_SEC_WPA_PSK, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
printf("Connecting to %s.\r\n", (char *)MAIN_WLAN_DEVICE_NAME);
/* Infinite loop to handle a event from the WINC1500. */
while (1) {
while (m2m_wifi_handle_events(NULL) != M2M_SUCCESS) {
}
}
return 0;
}
/**
* \brief Main application function.
*
* Application entry point.
*
* \return program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
/* Initialize the board. */
system_init();
/* Initialize the UART console. */
configure_console();
printf(STRING_HEADER);
/* Initialize the BSP. */
nm_bsp_init();
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_cb;
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) {
}
}
/* Connect to defined AP. */
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (void *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
/* Init ota function. */
m2m_ota_init(OtaUpdateCb, OtaNotifCb);
while (1) {
/* Handle pending events from network controller. */
while (m2m_wifi_handle_events(NULL) != M2M_SUCCESS) {
}
}
return 0;
}
/**
* \brief Callback to get the Wi-Fi status update.
*
* \param[in] u8MsgType type of Wi-Fi notification. Possible types are:
* - [M2M_WIFI_RESP_CURRENT_RSSI](@ref M2M_WIFI_RESP_CURRENT_RSSI)
* - [M2M_WIFI_RESP_CON_STATE_CHANGED](@ref M2M_WIFI_RESP_CON_STATE_CHANGED)
* - [M2M_WIFI_RESP_CONNTION_STATE](@ref M2M_WIFI_RESP_CONNTION_STATE)
* - [M2M_WIFI_RESP_SCAN_DONE](@ref M2M_WIFI_RESP_SCAN_DONE)
* - [M2M_WIFI_RESP_SCAN_RESULT](@ref M2M_WIFI_RESP_SCAN_RESULT)
* - [M2M_WIFI_REQ_WPS](@ref M2M_WIFI_REQ_WPS)
* - [M2M_WIFI_RESP_IP_CONFIGURED](@ref M2M_WIFI_RESP_IP_CONFIGURED)
* - [M2M_WIFI_RESP_IP_CONFLICT](@ref M2M_WIFI_RESP_IP_CONFLICT)
* - [M2M_WIFI_RESP_P2P](@ref M2M_WIFI_RESP_P2P)
* - [M2M_WIFI_RESP_AP](@ref M2M_WIFI_RESP_AP)
* - [M2M_WIFI_RESP_CLIENT_INFO](@ref M2M_WIFI_RESP_CLIENT_INFO)
* \param[in] pvMsg A pointer to a buffer containing the notification parameters
* (if any). It should be casted to the correct data type corresponding to the
* notification type. Existing types are:
* - tstrM2mWifiStateChanged
* - tstrM2MWPSInfo
* - tstrM2MP2pResp
* - tstrM2MAPResp
* - tstrM2mScanDone
* - tstrM2mWifiscanResult
*/
static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
switch (u8MsgType) {
case M2M_WIFI_RESP_CON_STATE_CHANGED:
{
tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) {
printf("Wi-Fi connected\r\n");
m2m_wifi_request_dhcp_client();
} else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) {
printf("Wi-Fi disconnected\r\n");
clear_state(WIFI_CONNECTED);
if (is_state_set(DOWNLOADING)) {
f_close(&file_object);
clear_state(DOWNLOADING);
}
if (is_state_set(GET_REQUESTED)) {
clear_state(GET_REQUESTED);
}
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
}
break;
}
case M2M_WIFI_REQ_DHCP_CONF:
{
uint8_t *pu8IPAddress = (uint8_t *)pvMsg;
printf("Wi-Fi IP is %u.%u.%u.%u\r\n", pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]);
add_state(WIFI_CONNECTED);
start_download();
break;
}
default:
break;
}
}
/**
* \brief Callback to get the Wi-Fi status update.
*
* \param[in] u8MsgType Type of Wi-Fi notification.
* \param[in] pvMsg A pointer to a buffer containing the notification parameters.
*
* \return None.
*/
static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
switch (u8MsgType) {
case M2M_WIFI_RESP_CON_STATE_CHANGED:
{
tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) {
printf("wifi_cb: M2M_WIFI_RESP_CON_STATE_CHANGED: CONNECTED\r\n");
m2m_wifi_request_dhcp_client();
} else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) {
printf("wifi_cb: M2M_WIFI_RESP_CON_STATE_CHANGED: DISCONNECTED\r\n");
gbConnectedWifi = false;
gbHostIpByName = false;
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
}
break;
}
case M2M_WIFI_REQ_DHCP_CONF:
{
uint8_t *pu8IPAddress = (uint8_t *)pvMsg;
/* Turn LED0 on to declare that IP address received. */
printf("wifi_cb: M2M_WIFI_REQ_DHCP_CONF: IP is %u.%u.%u.%u\r\n",
pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]);
gbConnectedWifi = true;
/* Obtain the IP Address by network name */
gethostbyname((uint8_t *)MAIN_GMAIL_HOST_NAME);
break;
}
default:
{
break;
}
}
}
/**
* \brief Main application function.
*
* Application entry point.
* Initialize system, UART and board specific settings.
* Connect AP using Security mode WPA/WPA2 enterprise
*
* \return program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
/* Initialize the board. */
system_init();
/* Initialize the UART console. */
configure_console();
printf(STRING_HEADER);
/* Initialize the BSP. */
nm_bsp_init();
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_cb;
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) {
}
}
/* Connect to the enterprise network. */
m2m_wifi_connect((char *)MAIN_WLAN_DEVICE_NAME, sizeof(MAIN_WLAN_DEVICE_NAME), M2M_WIFI_SEC_802_1X, (char *)&gstrCred1x, M2M_WIFI_CH_ALL);
/* Infinite loop to handle a event from the WINC1500. */
while (1) {
while (m2m_wifi_handle_events(NULL) != M2M_SUCCESS) {
}
}
return 0;
}
/**
* \brief Callback to get the Wi-Fi status update.
*
* \param[in] msg_type type of Wi-Fi notification. Possible types are:
* - [M2M_WIFI_RESP_CURRENT_RSSI](@ref M2M_WIFI_RESP_CURRENT_RSSI)
* - [M2M_WIFI_RESP_CON_STATE_CHANGED](@ref M2M_WIFI_RESP_CON_STATE_CHANGED)
* - [M2M_WIFI_RESP_CONNTION_STATE](@ref M2M_WIFI_RESP_CONNTION_STATE)
* - [M2M_WIFI_RESP_SCAN_DONE](@ref M2M_WIFI_RESP_SCAN_DONE)
* - [M2M_WIFI_RESP_SCAN_RESULT](@ref M2M_WIFI_RESP_SCAN_RESULT)
* - [M2M_WIFI_REQ_WPS](@ref M2M_WIFI_REQ_WPS)
* - [M2M_WIFI_RESP_IP_CONFIGURED](@ref M2M_WIFI_RESP_IP_CONFIGURED)
* - [M2M_WIFI_RESP_IP_CONFLICT](@ref M2M_WIFI_RESP_IP_CONFLICT)
* - [M2M_WIFI_RESP_P2P](@ref M2M_WIFI_RESP_P2P)
* - [M2M_WIFI_RESP_AP](@ref M2M_WIFI_RESP_AP)
* - [M2M_WIFI_RESP_CLIENT_INFO](@ref M2M_WIFI_RESP_CLIENT_INFO)
* \param[in] pvMsg A pointer to a buffer containing the notification parameters
* (if any). It should be casted to the correct data type corresponding to the
* notification type. Existing types are:
* - tstrM2mWifiStateChanged
* - tstrM2MWPSInfo
* - tstrM2MP2pResp
* - tstrM2MAPResp
* - tstrM2mScanDone
* - tstrM2mWifiscanResult
*/
static void wifi_callback(uint8 msg_type, void *msg_data)
{
tstrM2mWifiStateChanged *msg_wifi_state;
uint8 *msg_ip_addr;
switch (msg_type) {
case M2M_WIFI_RESP_CON_STATE_CHANGED:
msg_wifi_state = (tstrM2mWifiStateChanged *)msg_data;
if (msg_wifi_state->u8CurrState == M2M_WIFI_CONNECTED) {
/* If Wi-Fi is connected. */
printf("Wi-Fi connected\r\n");
m2m_wifi_request_dhcp_client();
} else if (msg_wifi_state->u8CurrState == M2M_WIFI_DISCONNECTED) {
/* If Wi-Fi is disconnected. */
printf("Wi-Fi disconnected\r\n");
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
/* Disconnect from MQTT broker. */
/* Force close the MQTT connection, because cannot send a disconnect message to the broker when network is broken. */
mqtt_disconnect(&mqtt_inst, 1);
}
break;
case M2M_WIFI_REQ_DHCP_CONF:
msg_ip_addr = (uint8 *)msg_data;
printf("Wi-Fi IP is %u.%u.%u.%u\r\n",
msg_ip_addr[0], msg_ip_addr[1], msg_ip_addr[2], msg_ip_addr[3]);
/* Try to connect to MQTT broker when Wi-Fi was connected. */
mqtt_connect(&mqtt_inst, main_mqtt_broker);
break;
default:
break;
}
}
/**
* \brief Main application function.
*
* Application entry point.
*
* \return program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
init_state();
/* Initialize the board. */
sysclk_init();
board_init();
/* Initialize the UART console. */
configure_console();
printf(STRING_HEADER);
printf("This example may not work as it requires internet connectivity.\r\n");
/* Initialize the Timer. */
configure_timer();
/* Initialize the HTTP client service. */
configure_http_client();
/* Initialize the BSP. */
nm_bsp_init();
/* Initialize SD/MMC storage. */
init_storage();
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_cb;
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) {
}
}
/* Initialize socket module. */
socketInit();
/* Register socket callback function. */
registerSocketCallback(socket_cb, resolve_cb);
/* Connect to router. */
printf("main: Waiting for Wi-Fi connection. AP:%s\r\n", (char *)MAIN_WLAN_SSID);
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
while (!(is_state_set(COMPLETED) || is_state_set(CANCELED))) {
/* Handle pending events from network controller. */
m2m_wifi_handle_events(NULL);
/* Checks the timer timeout. */
sw_timer_task(&swt_module_inst);
}
printf("main: Exit program. Please unplug the card.\r\n");
while (1) {
} /* Loop forever. */
return 0;
}
/**
* \brief Callback to get the Wi-Fi status update.
*
* \param[in] u8MsgType type of Wi-Fi notification. Possible types are:
* - [M2M_WIFI_RESP_CON_STATE_CHANGED](@ref M2M_WIFI_RESP_CON_STATE_CHANGED)
* - [M2M_WIFI_RESP_SCAN_DONE](@ref M2M_WIFI_RESP_SCAN_DONE)
* - [M2M_WIFI_RESP_SCAN_RESULT](@ref M2M_WIFI_RESP_SCAN_RESULT)
* - [M2M_WIFI_REQ_DHCP_CONF](@ref M2M_WIFI_REQ_DHCP_CONF)
* \param[in] pvMsg A pointer to a buffer containing the notification parameters
* (if any). It should be casted to the correct data type corresponding to the
* notification type.
*/
static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
switch (u8MsgType) {
case M2M_WIFI_RESP_SCAN_DONE:
{
tstrM2mScanDone *pstrInfo = (tstrM2mScanDone *)pvMsg;
scan_request_index = 0;
if (pstrInfo->u8NumofCh >= 1) {
m2m_wifi_req_scan_result(scan_request_index);
scan_request_index++;
} else {
m2m_wifi_request_scan(M2M_WIFI_CH_ALL);
}
break;
}
case M2M_WIFI_RESP_SCAN_RESULT:
{
tstrM2mWifiscanResult *pstrScanResult = (tstrM2mWifiscanResult *)pvMsg;
uint16_t demo_ssid_len;
uint16_t scan_ssid_len = strlen((const char *)pstrScanResult->au8SSID);
/* display founded AP. */
printf("[%d] SSID:%s\r\n", scan_request_index, pstrScanResult->au8SSID);
num_founded_ap = m2m_wifi_get_num_ap_found();
if (scan_ssid_len) {
/* check same SSID. */
demo_ssid_len = strlen((const char *)MAIN_WLAN_SSID);
if
(
(demo_ssid_len == scan_ssid_len) &&
(!memcmp(pstrScanResult->au8SSID, (uint8_t *)MAIN_WLAN_SSID, demo_ssid_len))
) {
/* A scan result matches an entry in the preferred AP List.
* Initiate a connection request.
*/
printf("Found %s \r\n", MAIN_WLAN_SSID);
m2m_wifi_connect((char *)MAIN_WLAN_SSID,
sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH,
(void *)MAIN_WLAN_PSK,
M2M_WIFI_CH_ALL);
break;
}
}
if (scan_request_index < num_founded_ap) {
m2m_wifi_req_scan_result(scan_request_index);
scan_request_index++;
} else {
printf("can not find AP %s\r\n", MAIN_WLAN_SSID);
m2m_wifi_request_scan(M2M_WIFI_CH_ALL);
}
break;
}
case M2M_WIFI_RESP_CON_STATE_CHANGED:
{
tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) {
m2m_wifi_request_dhcp_client();
} else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) {
printf("Wi-Fi disconnected\r\n");
/* Request scan. */
m2m_wifi_request_scan(M2M_WIFI_CH_ALL);
}
break;
}
case M2M_WIFI_REQ_DHCP_CONF:
{
uint8_t *pu8IPAddress = (uint8_t *)pvMsg;
printf("Wi-Fi connected\r\n");
printf("Wi-Fi IP is %u.%u.%u.%u\r\n",
pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]);
break;
}
default:
{
break;
}
}
}
/**
* \brief Main application function.
*
* Application entry point.
*
* \return program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
char topic[strlen(MAIN_CHAT_TOPIC) + MAIN_CHAT_USER_NAME_SIZE + 1];
/* Initialize the board. */
system_init();
/* Initialize the UART console. */
configure_console();
/* Output example information */
printf(STRING_HEADER);
/* Initialize the Timer. */
configure_timer();
/* Initialize the MQTT service. */
configure_mqtt();
/* Initialize the BSP. */
nm_bsp_init();
/* Setup user name first */
printf("Enter the user name (Max %d characters)\r\n", MAIN_CHAT_USER_NAME_SIZE);
scanf("%64s", mqtt_user);
printf("User : %s\r\n", mqtt_user);
sprintf(topic, "%s%s", MAIN_CHAT_TOPIC, mqtt_user);
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_callback; /* Set Wi-Fi event callback. */
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) { /* Loop forever. */
}
}
/* Initialize socket interface. */
socketInit();
registerSocketCallback(socket_event_handler, socket_resolve_handler);
/* Connect to router. */
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
while (1) {
/* Handle pending events from network controller. */
m2m_wifi_handle_events(NULL);
/* Try to read user input from USART. */
usart_read_job(&cdc_uart_module, &uart_ch_buffer);
/* Checks the timer timeout. */
sw_timer_task(&swt_module_inst);
/* Checks the USART buffer. */
check_usart_buffer(topic);
}
}
static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
switch (u8MsgType) {
case M2M_WIFI_RESP_CON_STATE_CHANGED:
{
tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) {
//SERIAL_PORT_MONITOR.println("wifi_cb: M2M_WIFI_RESP_CON_STATE_CHANGED: CONNECTED");
if (WiFi._mode == WL_STA_MODE && !WiFi._dhcp) {
WiFi._status = WL_CONNECTED;
// WiFi led ON.
m2m_periph_gpio_set_val(M2M_PERIPH_GPIO15, 0);
}
} else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) {
//SERIAL_PORT_MONITOR.println("wifi_cb: M2M_WIFI_RESP_CON_STATE_CHANGED: DISCONNECTED");
if (WiFi._mode == WL_STA_MODE) {
WiFi._status = WL_DISCONNECTED;
if (WiFi._dhcp) {
WiFi._localip = 0;
WiFi._submask = 0;
WiFi._gateway = 0;
}
}
// WiFi led OFF (rev A then rev B).
m2m_periph_gpio_set_val(M2M_PERIPH_GPIO15, 1);
m2m_periph_gpio_set_val(M2M_PERIPH_GPIO4, 1);
}
}
break;
case M2M_WIFI_REQ_DHCP_CONF:
{
if (WiFi._mode == WL_STA_MODE) {
tstrM2MIPConfig *pstrIPCfg = (tstrM2MIPConfig *)pvMsg;
WiFi._localip = pstrIPCfg->u32StaticIP;
WiFi._submask = pstrIPCfg->u32SubnetMask;
WiFi._gateway = pstrIPCfg->u32Gateway;
WiFi._status = WL_CONNECTED;
// WiFi led ON (rev A then rev B).
m2m_periph_gpio_set_val(M2M_PERIPH_GPIO15, 0);
m2m_periph_gpio_set_val(M2M_PERIPH_GPIO4, 0);
}
/*uint8_t *pu8IPAddress = (uint8_t *)pvMsg;
SERIAL_PORT_MONITOR.print("wifi_cb: M2M_WIFI_REQ_DHCP_CONF: IP is ");
SERIAL_PORT_MONITOR.print(pu8IPAddress[0], 10);
SERIAL_PORT_MONITOR.print(".");
SERIAL_PORT_MONITOR.print(pu8IPAddress[1], 10);
SERIAL_PORT_MONITOR.print(".");
SERIAL_PORT_MONITOR.print(pu8IPAddress[2], 10);
SERIAL_PORT_MONITOR.print(".");
SERIAL_PORT_MONITOR.print(pu8IPAddress[3], 10);
SERIAL_PORT_MONITOR.println("");*/
}
break;
case M2M_WIFI_RESP_CURRENT_RSSI:
{
WiFi._resolve = *((int8_t *)pvMsg);
}
break;
case M2M_WIFI_RESP_PROVISION_INFO:
{
tstrM2MProvisionInfo *pstrProvInfo = (tstrM2MProvisionInfo *)pvMsg;
//SERIAL_PORT_MONITOR.println("wifi_cb: M2M_WIFI_RESP_PROVISION_INFO");
if (pstrProvInfo->u8Status == M2M_SUCCESS) {
memset(WiFi._ssid, 0, M2M_MAX_SSID_LEN);
memcpy(WiFi._ssid, (char *)pstrProvInfo->au8SSID, strlen((char *)pstrProvInfo->au8SSID));
WiFi._mode = WL_STA_MODE;
WiFi._localip = 0;
WiFi._submask = 0;
WiFi._gateway = 0;
m2m_wifi_connect((char *)pstrProvInfo->au8SSID, strlen((char *)pstrProvInfo->au8SSID),
pstrProvInfo->u8SecType, pstrProvInfo->au8Password, M2M_WIFI_CH_ALL);
} else {
WiFi._status = WL_CONNECT_FAILED;
//SERIAL_PORT_MONITOR.println("wifi_cb: Provision failed.\r\n");
}
}
break;
case M2M_WIFI_RESP_SCAN_DONE:
{
tstrM2mScanDone *pstrInfo = (tstrM2mScanDone *)pvMsg;
if (pstrInfo->u8NumofCh >= 1) {
WiFi._status = WL_SCAN_COMPLETED;
}
}
break;
case M2M_WIFI_RESP_SCAN_RESULT:
{
tstrM2mWifiscanResult *pstrScanResult = (tstrM2mWifiscanResult *)pvMsg;
uint16_t scan_ssid_len = strlen((const char *)pstrScanResult->au8SSID);
memset(WiFi._scan_ssid, 0, M2M_MAX_SSID_LEN);
if (scan_ssid_len) {
memcpy(WiFi._scan_ssid, (const char *)pstrScanResult->au8SSID, scan_ssid_len);
}
if (WiFi._bssid) {
memcpy(WiFi._bssid, (const char *)pstrScanResult->au8BSSID, 6);
}
WiFi._resolve = pstrScanResult->s8rssi;
WiFi._scan_auth = pstrScanResult->u8AuthType;
WiFi._status = WL_SCAN_COMPLETED;
}
break;
default:
break;
}
}
/**
* \brief Main application function.
*
* Initialize system, UART console, network then start function of UDP socket.
*
* \return program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
struct sockaddr_in addr;
/* Initialize the board. */
sysclk_init();
board_init();
/* Initialize the UART console. */
configure_console();
printf(STRING_HEADER);
/* Initialize the BSP. */
nm_bsp_init();
/* Initialize socket address structure. */
addr.sin_family = AF_INET;
addr.sin_port = _htons(MAIN_WIFI_M2M_SERVER_PORT);
addr.sin_addr.s_addr = _htonl(MAIN_WIFI_M2M_SERVER_IP);
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_cb;
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) {
}
}
/* Initialize socket module */
socketInit();
registerSocketCallback(socket_cb, NULL);
/* Connect to router. */
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
packetCnt = 0;
while (1) {
if (packetCnt >= MAIN_WIFI_M2M_PACKET_COUNT) {
printf("UDP Server test Complete!\r\n");
close(rx_socket);
rx_socket = -1;
break;
}
m2m_wifi_handle_events(NULL);
if (wifi_connected == M2M_WIFI_CONNECTED) {
/* Create socket for Rx UDP */
if (rx_socket < 0) {
if ((rx_socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
printf("main : failed to create RX UDP Client socket error!\r\n");
continue;
}
/* Socket bind */
bind(rx_socket, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
}
}
}
return 0;
}
/**
* \brief Main application function.
*
* Initialize system, UART console, network then start time client.
*
* \return Program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
struct sockaddr_in addr_in;
/* Initialize the board. */
system_init();
/* Initialize the UART console. */
configure_console();
printf(STRING_HEADER);
/* Initialize the BSP. */
nm_bsp_init();
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_cb;
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) {
}
}
/* Turn LED0 off initially. */
port_pin_set_output_level(LED_0_PIN, true);
/* Initialize Socket module */
socketInit();
/* Register socket handler, resolve handler */
registerSocketCallback(socket_cb, resolve_cb);
/* Connect to router. */
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
while (1) {
/* Handle pending events from network controller. */
m2m_wifi_handle_events(NULL);
if (gbConnectedWifi) {
/*
* Create the socket for the first time.
*/
if (udp_socket < 0) {
udp_socket = socket(AF_INET, SOCK_DGRAM, 0);
if (udp_socket < 0) {
printf("main: UDP Client Socket Creation Failed.\r\n");
continue;
}
/* Initialize default socket address structure. */
addr_in.sin_family = AF_INET;
addr_in.sin_addr.s_addr = _htonl(MAIN_DEFAULT_ADDRESS);
addr_in.sin_port = _htons(MAIN_DEFAULT_PORT);
bind(udp_socket, (struct sockaddr *)&addr_in, sizeof(struct sockaddr_in));
}
}
}
return 0;
}
/**
* \brief Main application function.
*
* Initialize system, UART console, network then start function of SMTP email client.
*
* \return Program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
/* Initialize the board. */
system_init();
/* Initialize the UART console. */
configure_console();
printf(STRING_HEADER);
/* Initialize the BSP. */
nm_bsp_init();
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_cb;
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) {
}
}
/* Initialize Socket module */
socketInit();
registerSocketCallback(socket_cb, resolve_cb);
/* Connect to router. */
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
while (1) {
m2m_wifi_handle_events(NULL);
if (gbConnectedWifi && gbHostIpByName) {
if (gu8SocketStatus == SocketInit) {
if (tcp_client_socket < 0) {
gu8SocketStatus = SocketWaiting;
if (smtpConnect() != SOCK_ERR_NO_ERROR) {
gu8SocketStatus = SocketInit;
}
}
} else if (gu8SocketStatus == SocketConnect) {
gu8SocketStatus = SocketWaiting;
if (smtpStateHandler() != MAIN_EMAIL_ERROR_NONE) {
if (gs8EmailError == MAIN_EMAIL_ERROR_INIT) {
gu8SocketStatus = SocketError;
} else {
close_socket();
break;
}
}
} else if (gu8SocketStatus == SocketComplete) {
printf("main: Email was successfully sent.\r\n");
port_pin_set_output_level(LED_0_PIN, false);
close_socket();
break;
} else if (gu8SocketStatus == SocketError) {
if (gu8RetryCount < MAIN_RETRY_COUNT) {
gu8RetryCount++;
printf("main: Waiting to connect server.(30 seconds)\r\n\r\n");
retry_smtp_server();
} else {
printf("main: Failed retry to server. Press reset your board.\r\n");
gu8RetryCount = 0;
close_socket();
break;
}
}
}
}
return 0;
}
/**
* \brief Main application function.
*
* Application entry point.
* Initialize board and WINC1500 Wi-Fi module.
* Read input data from serial interface and sent it to the remote device.
*
* \return program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
/* Initialize the board. */
system_init();
/* Initialize the UART console. */
configure_console();
printf(STRING_HEADER);
/* Initialize the BSP. */
nm_bsp_init();
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_cb;
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) {
}
}
/* Initialize socket interface. */
socketInit();
registerSocketCallback(socket_cb, NULL);
/* Connect to router. */
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
while (1) {
if (wifi_connected == M2M_WIFI_CONNECTED && tcp_server_socket < 0) {
struct sockaddr_in addr;
/* Create TCP server socket. */
if ((tcp_server_socket = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("Failed to create TCP server socket!\r\n");
continue;
}
/* Initialize socket address structure and bind service. */
addr.sin_family = AF_INET;
addr.sin_port = _htons(MAIN_WIFI_M2M_SERVER_PORT);
addr.sin_addr.s_addr = 0;
bind(tcp_server_socket, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
}
/* Handle pending events from network controller. */
m2m_wifi_handle_events(NULL);
/* Try to read user input from EDBG. */
usart_read_job(&cdc_uart_module, &uart_ch_buffer);
/* Handle user message from EDBG. */
handle_input_message();
}
return 0;
}
