687 lines
22 KiB
C
687 lines
22 KiB
C
/*============================================================================
|
|
Copyright (c) 2020 Quectel Wireless Solution, Co., Ltd. All Rights Reserved.
|
|
Quectel Wireless Solution Proprietary and Confidential.
|
|
=============================================================================*/
|
|
/*===========================================================================
|
|
|
|
EDIT HISTORY FOR MODULE
|
|
|
|
This section contains comments describing changes made to the module.
|
|
Notice that changes are listed in reverse chronological order.
|
|
|
|
|
|
WHEN WHO WHAT, WHERE, WHY
|
|
---------- ------------ ----------------------------------------------------
|
|
|
|
=============================================================================*/
|
|
|
|
/*===========================================================================
|
|
* include files
|
|
===========================================================================*/
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "ql_api_osi.h"
|
|
#include "ql_log.h"
|
|
|
|
#include "ql_gpio.h"
|
|
|
|
#include "wifi_demo_macro.h"
|
|
|
|
#include "ql_api_datacall.h"
|
|
#include "ql_api_nw.h"
|
|
#include "ql_api_wifi.h"
|
|
|
|
#include "sockets.h"
|
|
#include "lwip/ip_addr.h"
|
|
#include "lwip/ip6_addr.h"
|
|
|
|
#include "lwip/inet.h"
|
|
#include "lwip/tcp.h"
|
|
|
|
#ifdef QL_WIFI_FC41D
|
|
#include "ql_wifi_app.h"
|
|
#endif
|
|
|
|
/*========================================================================
|
|
* Macro Definition
|
|
*========================================================================*/
|
|
|
|
#define QL_WIFI_DEMO_LOG_LEVEL QL_LOG_LEVEL_INFO
|
|
#define QL_WIFI_DEMO_LOG(msg, ...) QL_LOG(QL_WIFI_DEMO_LOG_LEVEL, "phy_demo", msg, ##__VA_ARGS__)
|
|
|
|
#define QL_WIFI_DEMO_MSG_QUEUE_CNT 10
|
|
|
|
#define QL_WIFI_DEMO_DISCONNECT_RETRY_TIME (20 * 1000)
|
|
#define QL_WIFI_DEMO_RETRY_CNT_MAX 3
|
|
|
|
#define QL_WIFI_DEMO_SIM_ID 0
|
|
#define QL_WIFI_DEMO_PROFILE_IDX 1
|
|
#define QL_WIFI_DEMO_SOCKET_BUF_SIZE 128
|
|
|
|
#define QL_WIFI_DEMO_TCP_CLIENTS_CNT 1
|
|
/*========================================================================
|
|
* Enumeration Definition
|
|
*========================================================================*/
|
|
typedef enum
|
|
{
|
|
WIFI_DEMO_RETRY_CONNECT_START = 0,
|
|
WIFI_DEMO_RETRY_CONNECT_END,
|
|
} wifi_demo_retry_state_e;
|
|
|
|
typedef enum
|
|
{
|
|
WIFI_DEMO_EVENT_INIT = 0,
|
|
WIFI_DEMO_EVENT_TRY_CONNECT,
|
|
WIFI_DEMO_EVENT_CONNECTED,
|
|
WIFI_DEMO_EVENT_DISCONNECT,
|
|
WIFI_DEMO_EVENT_APP_TCP_CONNECT,
|
|
WIFI_DEMO_EVENT_APP_TCP_DISCONNECT,
|
|
WIFI_DEMO_EVENT_GET_STATUS,
|
|
} wifi_demo_event_e;
|
|
|
|
/*========================================================================
|
|
* Type Definition
|
|
*=========================================================================*/
|
|
#ifdef QL_WIFI_FC41D
|
|
typedef struct
|
|
{
|
|
int id;
|
|
int fd;
|
|
ql_task_t task;
|
|
uint8_t close_flag;
|
|
} wifi_demo_tcp_client_s;
|
|
#endif
|
|
|
|
typedef struct
|
|
{
|
|
ql_task_t task;
|
|
#ifdef QL_WIFI_FC41D
|
|
uint8_t sim_id;
|
|
int profile_idx;
|
|
ql_wifi_state_e state;
|
|
ql_queue_t msg_queue;
|
|
ql_timer_t retry_timer;
|
|
wifi_demo_retry_state_e retry_state;
|
|
int retry_cnt;
|
|
// tcp client
|
|
wifi_demo_tcp_client_s tcp_client[QL_WIFI_DEMO_TCP_CLIENTS_CNT];
|
|
int tcp_client_cnt;
|
|
#endif
|
|
} wifi_demo_manager_s;
|
|
|
|
typedef struct
|
|
{
|
|
uint32_t id;
|
|
uint32_t param1;
|
|
uint32_t param2;
|
|
uint32_t param3;
|
|
} wifi_demo_event_s;
|
|
/*========================================================================
|
|
* Global Variable
|
|
*========================================================================*/
|
|
wifi_demo_manager_s wifi_demo_manager = {0};
|
|
|
|
#ifdef QL_WIFI_FC41D
|
|
ql_mutex_t wifi_demo_mutex = NULL;
|
|
|
|
static char send_buf[QL_WIFI_DEMO_SOCKET_BUF_SIZE] = {0};
|
|
static int send_len = 0;
|
|
static char recv_buf[QL_WIFI_DEMO_SOCKET_BUF_SIZE] = {0};
|
|
static int recv_len = 0;
|
|
#endif
|
|
|
|
/*========================================================================
|
|
* function Definition
|
|
*========================================================================*/
|
|
#ifdef QL_WIFI_FC41D
|
|
void wifi_demo_send_event(ql_task_t task, uint32_t id, uint32_t param1, uint32_t param2, uint32_t param3)
|
|
{
|
|
wifi_demo_manager_s *manager = &wifi_demo_manager;
|
|
ql_queue_t *msg_queue = NULL;
|
|
if (task == manager->task)
|
|
{
|
|
msg_queue = manager->msg_queue;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
QlOSStatus err = QL_OSI_SUCCESS;
|
|
wifi_demo_event_s event = {.id = id, .param1 = param1, .param2 = param2, .param3 = param3};
|
|
err = ql_rtos_queue_release(msg_queue, sizeof(wifi_demo_event_s), (uint8 *)&event, QL_NO_WAIT);
|
|
if (err)
|
|
{
|
|
QL_WIFI_DEMO_LOG("release failed");
|
|
}
|
|
return;
|
|
}
|
|
|
|
static void wifi_demo_retry_timer_callback(void *ctx)
|
|
{
|
|
wifi_demo_manager_s *manager = &wifi_demo_manager;
|
|
QL_WIFI_DEMO_LOG("timer retry");
|
|
wifi_demo_send_event(manager->task, WIFI_DEMO_EVENT_TRY_CONNECT, 0, 0, 0);
|
|
return;
|
|
}
|
|
|
|
static void wifi_demo_connect_status(void* ctx)
|
|
{
|
|
uint32_t value = *((uint32_t*)ctx);
|
|
wifi_demo_manager_s *manager = &wifi_demo_manager;
|
|
QL_WIFI_DEMO_LOG("wifi connect %d", value);
|
|
wifi_demo_send_event(manager->task, WIFI_DEMO_EVENT_GET_STATUS, value, 0, 0);
|
|
return;
|
|
}
|
|
|
|
void wifi_demo_tcp_client_thread(void *arg)
|
|
{
|
|
wifi_demo_manager_s *manager = &wifi_demo_manager;
|
|
wifi_demo_tcp_client_s *ctx = (wifi_demo_tcp_client_s *)arg;
|
|
ctx->close_flag = 0;
|
|
int ret = 0;
|
|
uint8_t sim_id = manager->sim_id;
|
|
int profile_idx = manager->profile_idx;
|
|
ql_data_call_info_s info = {0};
|
|
// tcp socket
|
|
int i = 0;
|
|
int flags = 0;
|
|
int connected = 0;
|
|
int socket_fd = -1;
|
|
fd_set read_fds;
|
|
fd_set write_fds;
|
|
fd_set exp_fds;
|
|
int fd_changed = 0;
|
|
int closing = false;
|
|
char ip4_addr_str[16] = {0};
|
|
struct sockaddr_in local4, server_ipv4;
|
|
|
|
uint8_t destip[] = {220, 180, 239, 212};
|
|
uint16_t destport = 8305;
|
|
ip4_addr_t int_destip;
|
|
IP4_ADDR(&int_destip, destip[0], destip[1], destip[2], destip[3]);
|
|
|
|
ret = ql_get_data_call_info(sim_id, profile_idx, &info);
|
|
if (ret != QL_DATACALL_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("datacall get err");
|
|
goto exit;
|
|
}
|
|
QL_WIFI_DEMO_LOG("info->profile_idx: %d", info.profile_idx);
|
|
QL_WIFI_DEMO_LOG("info->ip_version: %d", info.ip_version);
|
|
|
|
QL_WIFI_DEMO_LOG("info->v4.state: %d", info.v4.state);
|
|
inet_ntop(AF_INET, &info.v4.addr.ip, ip4_addr_str, sizeof(ip4_addr_str));
|
|
QL_WIFI_DEMO_LOG("info.v4.addr.ip: %s\r\n", ip4_addr_str);
|
|
|
|
inet_ntop(AF_INET, &info.v4.addr.pri_dns, ip4_addr_str, sizeof(ip4_addr_str));
|
|
QL_WIFI_DEMO_LOG("info.v4.addr.pri_dns: %s\r\n", ip4_addr_str);
|
|
|
|
inet_ntop(AF_INET, &info.v4.addr.sec_dns, ip4_addr_str, sizeof(ip4_addr_str));
|
|
QL_WIFI_DEMO_LOG("info.v4.addr.sec_dns: %s\r\n", ip4_addr_str);
|
|
|
|
memset(&local4, 0x00, sizeof(struct sockaddr_in));
|
|
local4.sin_family = AF_INET;
|
|
local4.sin_port = 0;
|
|
inet_aton(ip4addr_ntoa(&info.v4.addr.ip), &local4.sin_addr);
|
|
|
|
FD_ZERO(&read_fds);
|
|
FD_ZERO(&write_fds);
|
|
FD_ZERO(&exp_fds);
|
|
|
|
QL_WIFI_DEMO_LOG("socket start!");
|
|
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
|
|
if(socket_fd < 0)
|
|
{
|
|
goto exit;
|
|
}
|
|
ret = bind(socket_fd,(struct sockaddr *)&local4,sizeof(struct sockaddr));
|
|
if(ret < 0)
|
|
{
|
|
close(socket_fd);
|
|
socket_fd = -1;
|
|
goto exit;
|
|
}
|
|
flags |= O_NONBLOCK;
|
|
fcntl(socket_fd, F_SETFL,flags);
|
|
memset(&server_ipv4, 0x00, sizeof(struct sockaddr_in));
|
|
server_ipv4.sin_family = AF_INET;
|
|
server_ipv4.sin_port = htons(destport);
|
|
memcpy(&(server_ipv4.sin_addr),&int_destip,sizeof(int_destip));
|
|
ret = connect(socket_fd, (struct sockaddr *)&server_ipv4, sizeof(server_ipv4));
|
|
if(ret == 0)
|
|
{
|
|
connected = 1;
|
|
}
|
|
else
|
|
{
|
|
if(lwip_get_error(socket_fd) != EINPROGRESS)
|
|
{
|
|
close(socket_fd);
|
|
socket_fd = -1;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
if (connected == 1)
|
|
{
|
|
QL_WIFI_DEMO_LOG("tcp connected");
|
|
ql_rtos_mutex_try_lock(wifi_demo_mutex);
|
|
ctx->fd = socket_fd;
|
|
ql_rtos_mutex_unlock(wifi_demo_mutex);
|
|
char con[128] = {0};
|
|
int len = 0;
|
|
FD_SET(socket_fd, &read_fds);
|
|
len = snprintf(con, 128, "tcp connected");
|
|
|
|
if (write(socket_fd, con, len) != len)
|
|
{
|
|
FD_SET(socket_fd, &write_fds);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FD_SET(socket_fd, &write_fds);
|
|
}
|
|
FD_SET(socket_fd, &exp_fds);
|
|
while (1)
|
|
{
|
|
fd_changed = select(socket_fd + 1, &read_fds, &write_fds, &exp_fds, NULL);
|
|
if (fd_changed > 0)
|
|
{
|
|
if (FD_ISSET(socket_fd, &write_fds))
|
|
{
|
|
FD_CLR(socket_fd, &write_fds);
|
|
if (connected == 0)
|
|
{
|
|
int value = 0;
|
|
char con[128] = {0};
|
|
int len = sizeof(value);
|
|
getsockopt(socket_fd, SOL_SOCKET, SO_ERROR, &value, &len);
|
|
if (value == 0 || value == EISCONN)
|
|
{
|
|
QL_WIFI_DEMO_LOG("tcp connected");
|
|
ql_rtos_mutex_try_lock(wifi_demo_mutex);
|
|
ctx->fd = socket_fd;
|
|
ql_rtos_mutex_unlock(wifi_demo_mutex);
|
|
connected = 1;
|
|
FD_SET(socket_fd, &read_fds);
|
|
len = snprintf(con, 128, "tcp connected");
|
|
write(socket_fd, con, len);
|
|
}
|
|
else
|
|
{
|
|
QL_WIFI_DEMO_LOG("tcp connect failed");
|
|
close(socket_fd);
|
|
socket_fd = -1;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
memset(send_buf, 0x00, 128);
|
|
send_len = snprintf(send_buf, 128, "%d%s%d\r\n", i, "startAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAend", i);
|
|
write(socket_fd, send_buf, send_len);
|
|
i++;
|
|
}
|
|
}
|
|
else if (FD_ISSET(socket_fd, &read_fds))
|
|
{
|
|
FD_CLR(socket_fd, &read_fds);
|
|
memset(recv_buf, 0x00, 128);
|
|
recv_len = read(socket_fd, recv_buf, 128);
|
|
if (recv_len > 0)
|
|
{
|
|
QL_WIFI_DEMO_LOG("recv: %s", recv_buf);
|
|
memset(send_buf, 0x00, 128);
|
|
send_len = snprintf(send_buf, 128, "%d%s%d\r\n", i, "startAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAend", i);
|
|
write(socket_fd, send_buf, send_len);
|
|
i++;
|
|
FD_SET(socket_fd, &read_fds);
|
|
}
|
|
else if (recv_len == 0)
|
|
{
|
|
if (closing == false)
|
|
{
|
|
QL_WIFI_DEMO_LOG("shut down");
|
|
shutdown(socket_fd, SHUT_WR);
|
|
closing = true;
|
|
FD_SET(socket_fd, &read_fds);
|
|
}
|
|
else
|
|
{
|
|
close(socket_fd);
|
|
socket_fd = -1;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (lwip_get_error(socket_fd) == EAGAIN)
|
|
{
|
|
FD_SET(socket_fd, &read_fds);
|
|
}
|
|
else
|
|
{
|
|
close(socket_fd);
|
|
socket_fd = -1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (FD_ISSET(socket_fd, &exp_fds))
|
|
{
|
|
FD_CLR(socket_fd, &exp_fds);
|
|
close(socket_fd);
|
|
socket_fd = -1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
exit:
|
|
QL_WIFI_DEMO_LOG("wifi tcp client %d end,%p", ctx->id, ctx->task);
|
|
close(socket_fd);
|
|
ql_rtos_mutex_try_lock(wifi_demo_mutex);
|
|
memset(ctx, 0, sizeof(wifi_demo_tcp_client_s));
|
|
ctx->id = -1;
|
|
ctx->fd = -1;
|
|
manager->tcp_client_cnt--;
|
|
ql_rtos_mutex_unlock(wifi_demo_mutex);
|
|
ql_rtos_task_delete(NULL);
|
|
}
|
|
|
|
static int wifi_demo_tcp_client_create()
|
|
{
|
|
wifi_demo_manager_s *manager = &wifi_demo_manager;
|
|
wifi_demo_tcp_client_s *ctx = NULL;
|
|
// User defined.Only support one client here.
|
|
if (manager->tcp_client_cnt >= 1)
|
|
{
|
|
QL_WIFI_DEMO_LOG("only support one client");
|
|
return -1;
|
|
}
|
|
// Find NULL task
|
|
int i = 0;
|
|
for (i = 0; i < QL_WIFI_DEMO_TCP_CLIENTS_CNT; i++)
|
|
{
|
|
ctx = &(manager->tcp_client[i]);
|
|
QL_WIFI_DEMO_LOG("ctx->task %p", ctx->task);
|
|
if (ctx->task == NULL)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= QL_WIFI_DEMO_TCP_CLIENTS_CNT)
|
|
{
|
|
QL_WIFI_DEMO_LOG("client full");
|
|
return -1;
|
|
}
|
|
if (QL_OSI_SUCCESS != ql_rtos_task_create(&(ctx->task), 4 * 1024, APP_PRIORITY_NORMAL, "wifi_tcp_client", wifi_demo_tcp_client_thread, ctx, 5))
|
|
{
|
|
QL_WIFI_DEMO_LOG("task created failed");
|
|
return -1;
|
|
}
|
|
ctx->id = i;
|
|
ctx->fd = -1;
|
|
manager->tcp_client_cnt++;
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
static void wifi_demo_thread(void *arg)
|
|
{
|
|
wifi_demo_manager_s *manager = &wifi_demo_manager;
|
|
#ifdef QL_WIFI_FC41D
|
|
QL_WIFI_DEMO_LOG("wifi demo task start");
|
|
int ret = 0;
|
|
uint8_t sim_id = QL_WIFI_DEMO_SIM_ID;
|
|
int profile_idx = QL_WIFI_DEMO_PROFILE_IDX; // range 1 to 7
|
|
char ssid_str[] = {"enp0s11u"};
|
|
char password_str[] = {"l123654789"};
|
|
|
|
// Initialize client ctx
|
|
manager->tcp_client_cnt = 0;
|
|
for (int i = 0; i < QL_WIFI_DEMO_TCP_CLIENTS_CNT; i++)
|
|
{
|
|
manager->tcp_client[i].id = -1;
|
|
manager->tcp_client[i].fd = -1;
|
|
manager->tcp_client[i].task = NULL;
|
|
}
|
|
|
|
// Create mutex
|
|
ret = ql_rtos_mutex_create(&wifi_demo_mutex);
|
|
if (ret != QL_OSI_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("create mutex ret: %x", ret);
|
|
goto exit;
|
|
}
|
|
// Create timer
|
|
ret = ql_rtos_timer_create(&(manager->retry_timer), NULL, wifi_demo_retry_timer_callback, NULL);
|
|
if (ret != QL_OSI_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("create timer ret: %x", ret);
|
|
goto exit;
|
|
}
|
|
|
|
// Create message queue
|
|
ret = ql_rtos_queue_create(&(manager->msg_queue), sizeof(wifi_demo_event_s), QL_WIFI_DEMO_MSG_QUEUE_CNT);
|
|
if (ret != QL_OSI_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("msg queue ret: %x", ret);
|
|
goto exit;
|
|
}
|
|
|
|
// wifi init
|
|
ret = ql_wifi_app_init(NULL);
|
|
if (ret != QL_WIFI_APP_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("ql_wifi_app_init err %x", ret);
|
|
goto exit;
|
|
}
|
|
QL_WIFI_DEMO_LOG("ql_wifi_app_init done");
|
|
// enable dhcp
|
|
char dhcp = 1;
|
|
ret = ql_wifi_opt_set(QL_WIFI_OPT_DHCP, &dhcp, sizeof(char));
|
|
if (ret != QL_WIFI_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("dhcp set err %x", ret);
|
|
goto exit;
|
|
}
|
|
QL_WIFI_DEMO_LOG("QL_WIFI_OPT_DHCP done");
|
|
// specify wifi cid
|
|
ql_wifi_cid_s ctx =
|
|
{
|
|
.sim_id = sim_id,
|
|
.cid = profile_idx,
|
|
.enable = 1,
|
|
};
|
|
ret = ql_wifi_opt_set(QL_WIFI_OPT_CID, &ctx, sizeof(ql_wifi_cid_s));
|
|
if (ret != QL_WIFI_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("cid set err %x", ret);
|
|
goto exit;
|
|
}
|
|
QL_WIFI_DEMO_LOG("QL_WIFI_OPT_CID done");
|
|
manager->sim_id = sim_id;
|
|
manager->profile_idx = profile_idx;
|
|
|
|
// ssid & password
|
|
ql_wifi_app_user_ap_info_s *ap_user_info = (ql_wifi_app_user_ap_info_s *)calloc(1,sizeof(ql_wifi_app_user_ap_info_s));
|
|
if(!ap_user_info)
|
|
{
|
|
QL_WIFI_DEMO_LOG("calloc faild!");
|
|
goto exit;
|
|
}
|
|
int ssid_len = strlen(ssid_str);
|
|
int password_len = strlen(password_str);
|
|
if(ssid_len >= QL_WIFI_SSID_MAX_LEN || password_len >= QL_WIFI_PASSWORD_MAX_LEN)
|
|
{
|
|
goto exit;
|
|
}
|
|
memcpy(ap_user_info->ssid,ssid_str,ssid_len);
|
|
memcpy(ap_user_info->password,password_str,password_len);
|
|
ret = ql_wifi_app_set_user_ap_info(ap_user_info);
|
|
if(ret != QL_WIFI_APP_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("get ssid/password faild!");
|
|
free(ap_user_info);
|
|
goto exit;
|
|
}
|
|
free(ap_user_info);
|
|
|
|
wifi_demo_send_event(manager->task, WIFI_DEMO_EVENT_INIT, 0, 0, 0);
|
|
while (1)
|
|
{
|
|
wifi_demo_event_s event = {0};
|
|
if (QL_OSI_SUCCESS != ql_rtos_queue_wait(manager->msg_queue, (uint8 *)&event, sizeof(wifi_demo_event_s), QL_WAIT_FOREVER))
|
|
{
|
|
QL_WIFI_DEMO_LOG("queue wait error");
|
|
goto exit;
|
|
}
|
|
QL_WIFI_DEMO_LOG("wifi_demo_thread %x", event.id);
|
|
switch (event.id)
|
|
{
|
|
case WIFI_DEMO_EVENT_INIT: {
|
|
// wifi software reset,better add hardware reset
|
|
ret = ql_wifi_app_reset(NULL);
|
|
if (ret != QL_WIFI_APP_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("reset err %x", ret);
|
|
goto exit;
|
|
}
|
|
ql_rtos_task_sleep_ms(10);
|
|
QL_WIFI_DEMO_LOG("wifi init");
|
|
wifi_demo_send_event(manager->task, WIFI_DEMO_EVENT_TRY_CONNECT, 0, 0, 0);
|
|
break;
|
|
}
|
|
case WIFI_DEMO_EVENT_TRY_CONNECT: {
|
|
manager->retry_cnt++;
|
|
if (manager->retry_cnt >= QL_WIFI_DEMO_RETRY_CNT_MAX)
|
|
{
|
|
manager->retry_cnt = 0;
|
|
wifi_demo_send_event(manager->task, WIFI_DEMO_EVENT_INIT, 0, 0, 0);
|
|
break;
|
|
}
|
|
// start timer
|
|
ret = ql_rtos_timer_start(manager->retry_timer, QL_WIFI_DEMO_DISCONNECT_RETRY_TIME, 0);
|
|
QL_WIFI_DEMO_LOG("timer start %x", ret);
|
|
if (ret != QL_OSI_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("manager->retry_timer start failed");
|
|
wifi_demo_send_event(manager->task, WIFI_DEMO_EVENT_TRY_CONNECT, 0, 0, 0);
|
|
}
|
|
|
|
QL_WIFI_DEMO_LOG("wifi connect start");
|
|
// start to connect wifi
|
|
ret = ql_wifi_app_sta_disable(NULL);
|
|
if (ret != QL_WIFI_APP_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("sta disable err %x", ret);
|
|
goto exit;
|
|
}
|
|
ql_rtos_task_sleep_ms(10);
|
|
ret = ql_wifi_app_sta_enable(wifi_demo_connect_status);
|
|
if (ret != QL_WIFI_APP_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("sta enable err %x", ret);
|
|
goto exit;
|
|
}
|
|
QL_WIFI_DEMO_LOG("ql_wifi_app_sta_enable done");
|
|
// Set retry_state end.When we get disconnect status,
|
|
// we check this state for ignoring to send WIFI_DEMO_EVENT_TRY_CONNECT again.
|
|
manager->retry_state = WIFI_DEMO_RETRY_CONNECT_END;
|
|
break;
|
|
}
|
|
case WIFI_DEMO_EVENT_CONNECTED: {
|
|
ql_data_call_info_s info = {0};
|
|
ret = ql_get_data_call_info(sim_id, profile_idx, &info);
|
|
QL_WIFI_DEMO_LOG("ql_get_data_call_info ret: 0x%x", ret);
|
|
QL_WIFI_DEMO_LOG("info.profile_idx: %d, info.ip_version: %d", info.profile_idx, info.ip_version);
|
|
QL_WIFI_DEMO_LOG("info->v4.state: %d, info.v6.state: %d", info.v4.state, info.v6.state);
|
|
if (info.v4.state)
|
|
{
|
|
QL_WIFI_DEMO_LOG("info.v4.addr.ip: %s", ip4addr_ntoa(&(info.v4.addr.ip)));
|
|
QL_WIFI_DEMO_LOG("info.v4.addr.pri_dns: %s", ip4addr_ntoa(&(info.v4.addr.pri_dns)));
|
|
QL_WIFI_DEMO_LOG("info.v4.addr.sec_dns: %s", ip4addr_ntoa(&(info.v4.addr.sec_dns)));
|
|
}
|
|
wifi_demo_send_event(manager->task, WIFI_DEMO_EVENT_APP_TCP_CONNECT, 0, 0, 0);
|
|
break;
|
|
}
|
|
case WIFI_DEMO_EVENT_APP_TCP_CONNECT: {
|
|
ql_rtos_mutex_try_lock(wifi_demo_mutex);
|
|
wifi_demo_tcp_client_create();
|
|
ql_rtos_mutex_unlock(wifi_demo_mutex);
|
|
break;
|
|
}
|
|
case WIFI_DEMO_EVENT_GET_STATUS: {
|
|
uint32_t value = event.param1;
|
|
if (value == QL_WIFI_STATE_CONNECTED)
|
|
{
|
|
manager->retry_state = WIFI_DEMO_RETRY_CONNECT_END;
|
|
ql_rtos_timer_stop(manager->retry_timer);
|
|
//From others to QL_WIFI_STATE_CONNECTED
|
|
if(manager->state != QL_WIFI_STATE_CONNECTED)
|
|
{
|
|
wifi_demo_send_event(manager->task, WIFI_DEMO_EVENT_CONNECTED, 0, 0, 0);
|
|
}
|
|
}
|
|
else if (value == QL_WIFI_STATE_DISCONNECT)
|
|
{
|
|
if (manager->retry_state == WIFI_DEMO_RETRY_CONNECT_END)
|
|
{
|
|
manager->retry_state = WIFI_DEMO_RETRY_CONNECT_START;
|
|
ql_rtos_timer_stop(manager->retry_timer);
|
|
int ret = 0;
|
|
ret = ql_rtos_timer_start(manager->retry_timer, QL_WIFI_DEMO_DISCONNECT_RETRY_TIME, 0);
|
|
QL_WIFI_DEMO_LOG("timer start %x", ret);
|
|
if (ret != QL_OSI_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("manager->retry_timer start failed");
|
|
wifi_demo_send_event(manager->task, WIFI_DEMO_EVENT_TRY_CONNECT, 0, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
manager->state = value;
|
|
manager->retry_cnt = 0;
|
|
break;
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
exit:
|
|
if (manager->retry_timer)
|
|
{
|
|
ql_rtos_timer_delete(manager->retry_timer);
|
|
}
|
|
if (manager->msg_queue)
|
|
{
|
|
ql_rtos_queue_delete(manager->msg_queue);
|
|
manager->msg_queue = NULL;
|
|
}
|
|
if(wifi_demo_mutex)
|
|
{
|
|
ql_rtos_mutex_delete(wifi_demo_mutex);
|
|
wifi_demo_mutex = NULL;
|
|
}
|
|
#endif
|
|
QL_WIFI_DEMO_LOG("wifi demo task end");
|
|
ql_rtos_task_delete(NULL);
|
|
}
|
|
|
|
void ql_wifi_demo_init(void)
|
|
{
|
|
QlOSStatus err = QL_OSI_SUCCESS;
|
|
wifi_demo_manager_s *manager = &wifi_demo_manager;
|
|
err = ql_rtos_task_create(&(manager->task), 4 * 1024, APP_PRIORITY_NORMAL, "wifi_demo", wifi_demo_thread, NULL, 5);
|
|
if (err != QL_OSI_SUCCESS)
|
|
{
|
|
QL_WIFI_DEMO_LOG("task created failed");
|
|
return;
|
|
}
|
|
}
|