chenjintao/banban
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
d24c8e186ac3763b49755d01fbb39b54cfbd4a64
banban/ql-application/threadx/interface/wifi/example_wifi_ble_fgm842d_spi.c
T

699 lines
24 KiB
C
Raw Blame History

/*==========================================================================================================
Copyright (c) 2025, Quectel Wireless Solutions Co., Ltd. All rights reserved.
Quectel Wireless Solutions Proprietary and Confidential.
===========================================================================================================*/
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#include "ql_wifi.h"
#include "ql_application.h"
#include "ql_log.h"
#include "ql_rtos.h"
#include "ql_nw.h"
#include "ql_uart.h"
#include "ql_gpio.h"
#include "ql_spi.h"
#include "sockets.h"
#include "ip4_addr.h"
#include "ql_data_call.h"
#include "ql_ping.h"
#include "ql_fs.h"
#include "ql_http_client.h"
#if 0
// EC800MCNLE+FGM842D
#define QL_WIFI_LDO_GPIO GPIO_PIN_NO_27
#define QL_WIFI_CHIP_EN_GPIO GPIO_PIN_NO_31
#define QL_WIFI_SPI_PORT QL_SPI_PORT0
#define QL_WIFI_SPI_CS_GPIO GPIO_PIN_NO_17
#define QL_WIFI_SPI_SLAVE_CTS_GPIO GPIO_PIN_NO_53
#define QL_WIFI_SPI_SLAVE_RDY_GPIO GPIO_PIN_NO_54
#define QL_WIFI_SPI_CLK QL_SPI_CLK_13MHZ
#define QL_WIFI_SPI_MODE QL_SPI_MODE0
#else
// EG800AKCN91LC+FGM842D
#define QL_WIFI_LDO_GPIO GPIO_PIN_NO_84
#define QL_WIFI_CHIP_EN_GPIO GPIO_PIN_NO_85
#define QL_WIFI_SPI_PORT SPI_PORT2
#define QL_WIFI_SPI_CS_GPIO GPIO_PIN_NO_13
#define QL_WIFI_SPI_SLAVE_CTS_GPIO GPIO_PIN_NO_90
#define QL_WIFI_SPI_SLAVE_RDY_GPIO GPIO_PIN_NO_89
#define QL_WIFI_SPI_CLK SPI_CLK_13MHZ
#define QL_WIFI_SPI_MODE SPI_MODE0
#endif
#define QL_WIFI_UART_PORT QL_MAIN_UART_PORT
#define QL_WIFI_DEMO_SOCKET_BUF_SIZE (128)
#define QL_WIFI_STA_MODE_CID 2
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;
static ql_queue_t wifi_msg_queue = NULL;
static ql_task_t wifi_tcp_task = NULL;
typedef struct
{
char ssid[QL_WIFI_SSID_MAX_LEN];
char password[QL_WIFI_PASSWORD_MAX_LEN];
} ql_wifi_app_user_ap_info_s;
#include "ql_wifi_ble.h"
#define QL_WIFI_BLE_COMMAND_DELAY_MS 1000
static ql_queue_t wifi_ble_msg_queue = NULL;
static ql_wifi_ble_send_data_info_s ql_wifi_ble_send_data_info = {0};
typedef enum
{
QL_WIFI_DEMO_BLE_OPEN = 0,
QL_WIFI_DEMO_BLE_CLOSE,
QL_WIFI_DEMO_BLE_WIFI_TRY_OPEN,
QL_WIFI_DEMO_BLE_WIFI_OPEN,
QL_WIFI_DEMO_BLE_DATA_SEND,
QL_WIFI_DEMO_BLE_ADV_RESTART,
} ql_wifi_demo_ble_state_e;
typedef struct
{
ql_wifi_demo_ble_state_e state;
} ql_wifi_demo_ble_msg_s;
static void ql_wifi_demo_ble_send_msg(ql_wifi_demo_ble_state_e state)
{
ql_wifi_demo_ble_msg_s msg =
{
.state = state,
};
if (wifi_ble_msg_queue)
{
ql_rtos_queue_release(wifi_ble_msg_queue, sizeof(ql_wifi_demo_ble_msg_s), (uint8 *)&msg, QL_NO_WAIT);
}
return;
}
static void ql_wifi_hardware_reset(void)
{
ql_gpio_set_level(QL_WIFI_CHIP_EN_GPIO, PIN_LEVEL_HIGH);
ql_rtos_task_sleep_ms(100);
ql_gpio_set_level(QL_WIFI_CHIP_EN_GPIO, PIN_LEVEL_LOW);
}
static void ql_wifi_callback(ql_wifi_ind_t *ctx)
{
ql_wifi_ind_t wifi_ind = {0};
memcpy(&wifi_ind, ctx, sizeof(ql_wifi_ind_t));
if (wifi_msg_queue)
{
ql_rtos_queue_release(wifi_msg_queue, sizeof(ql_wifi_ind_t), (uint8 *)&wifi_ind, QL_NO_WAIT);
}
return;
}
static void ql_wifi_link_info_callback(void *ctx)
{
ql_wifi_link_info_t *info = (ql_wifi_link_info_t *)ctx;
printf("\r\nconne_state:%d, wifi_strength:%d", info->conn_state, info->wifi_strength);
printf("\r\nssid:%s, bssid=%02X:%02X:%02X:%02X:%02X:%02X", info->ssid, \
info->bssid[0], info->bssid[1], info->bssid[2], \
info->bssid[3], info->bssid[4], info->bssid[5]);
printf("\r\naid:%hu, channel:%d, security:%d\r\n", info->aid, info->channel, info->security);
}
static void ql_wifi_scan_callback(void *ctx)
{
ql_wifi_scan_result_s *scan_result = (ql_wifi_scan_result_s *)ctx;
ql_wifi_ap_info_s *ApList = scan_result->ApList;
printf("scan_result->ApNum:%d\n", scan_result->ApNum);
for (int i = 0; i < scan_result->ApNum; i++)
{
printf("ssid:%s,ap_power:%d,bssid=%02X:%02X:%02X:%02X:%02X:%02X,channel=%d,security=%s\n",
ApList->ssid,
ApList->ap_power,
ApList->bssid[0],ApList->bssid[1],ApList->bssid[2],ApList->bssid[3],ApList->bssid[4],ApList->bssid[5],
ApList->channel,
ApList->security);
ApList++;
}
}
void ql_wifi_ldo_ctrl(int val)
{
ql_gpio_init(QL_WIFI_LDO_GPIO, PIN_DIRECTION_OUT, PIN_PULL_DISABLE, PIN_LEVEL_LOW);
ql_gpio_init(QL_WIFI_CHIP_EN_GPIO, PIN_DIRECTION_OUT, PIN_PULL_DISABLE, PIN_LEVEL_LOW);
ql_gpio_set_level(QL_WIFI_LDO_GPIO, val);
ql_rtos_task_sleep_ms(100);
}
static void ql_wifi_tcp_client_thread(void)
{
int ret = 0;
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;
struct sockaddr_in local4, server_ipv4;
ip_addr_t ip = {0};
char ip4_addr_str[16] = {0};
struct ql_data_call_info info = {0};
uint8_t destip[] = {112, 31, 84, 164};
uint16_t destport = 8305;
ip_addr_t int_destip;
IP4_ADDR(&int_destip, destip[0], destip[1], destip[2], destip[3]);
ql_get_data_call_info(QL_WIFI_STA_MODE_CID, 0, &info);
inet_ntop(AF_INET, &info.v4.addr.ip, ip4_addr_str, sizeof(ip4_addr_str));
printf("info.v4.addr.ip: %s\r\n", ip4_addr_str);
inet_aton(ip4_addr_str, &ip);
memset(&local4, 0x00, sizeof(struct sockaddr_in));
local4.sin_family = AF_INET;
local4.sin_port = 2345;
memcpy(&local4.sin_addr, &ip.addr, sizeof(ip_addr_t));
FD_ZERO(&read_fds);
FD_ZERO(&write_fds);
FD_ZERO(&exp_fds);
printf("socket start!\r\n");
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if (socket_fd < 0)
{
printf("*** socket create fail ***\r\n");
goto exit;
}
ret = bind(socket_fd, (struct sockaddr *)&local4, sizeof(struct sockaddr));
if (ret < 0)
{
printf("*** bind fail ***\r\n");
close(socket_fd);
socket_fd = -1;
goto exit;
}
flags |= O_NONBLOCK; // set 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;
printf("\r\n[%s][%d]tcp connected\r\n", __func__, __LINE__);
}
else
{
if (ql_get_soc_errno() != EINPROGRESS) // 115
{
printf("\r\n[%s][%d]tcp connect failed\r\n", __func__, __LINE__);
close(socket_fd);
socket_fd = -1;
goto exit;
}
FD_SET(socket_fd, &write_fds); // write_fds
}
FD_SET(socket_fd, &exp_fds); // exp_fds
printf("\r\n[%s][%d]into while\r\n", __func__, __LINE__);
while (1)
{
fd_changed = select(socket_fd + 1, &read_fds, &write_fds, &exp_fds, NULL); // &tv
printf("\r\n[%s][%d]select\r\n", __func__, __LINE__);
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};
u32_t len = sizeof(value);
getsockopt(socket_fd, SOL_SOCKET, SO_ERROR, &value, &len);
if (value == 0 || value == EISCONN)
{
printf("\r\n[%s][%d]tcp connected\r\n", __func__, __LINE__);
connected = 1;
FD_SET(socket_fd, &read_fds); // read_fds
len = snprintf(con, 128, "tcp connected\r\n");
write(socket_fd, con, len);
}
else
{
printf("\r\n[%s][%d]tcp connect failed\r\n", __func__, __LINE__);
close(socket_fd);
socket_fd = -1;
break;
}
}
else // seldom go here
{
printf("\r\n[%s][%d]1234\r\n", __func__, __LINE__);
memset(send_buf, 0x00, 128);
send_len = snprintf(send_buf, 128, "%d%s%d\r\n", i, "#!&*1234end", i);
write(socket_fd, send_buf, send_len);
i++;
}
} // write_fds
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)
{
printf("\r\n[%s][%d]recv: %s\r\n", __func__, __LINE__, recv_buf);
if(i++ > 1)
goto exit;
memset(send_buf, 0x00, 128);
send_len = snprintf(send_buf, 128, "%d%s%d\r\n", i, "]Quectel[", i);
write(socket_fd, send_buf, send_len);
ql_rtos_task_sleep_s(2);
FD_SET(socket_fd, &read_fds);
}
else if (recv_len == 0)
{
if (closing == false)
{
printf("\r\n[%s][%d]shut down\r\n", __func__, __LINE__);
shutdown(socket_fd, SHUT_WR);
closing = true;
FD_SET(socket_fd, &read_fds);
}
else
{
printf("\r\n[%s][%d]\r\n", __func__, __LINE__);
close(socket_fd);
socket_fd = -1;
break;
}
}
else
{
if (ql_get_soc_errno() == EAGAIN)
{
FD_SET(socket_fd, &read_fds);
}
else
{
printf("\r\n[%s][%d]\r\n", __func__, __LINE__);
close(socket_fd);
socket_fd = -1;
break;
}
}
} // read_fds
else if (FD_ISSET(socket_fd, &exp_fds))
{
FD_CLR(socket_fd, &exp_fds);
printf("\r\n[%s][%d]\r\n", __func__, __LINE__);
close(socket_fd);
socket_fd = -1;
break;
} // exp_fds
} // if (fd_changed > 0)
} // while(1)
printf("\r\n[%s][%d]next to exit\r\n", __func__, __LINE__);
exit:
printf("wifi tcp client end\r\n");
close(socket_fd);
ql_wifi_psm_info wifi_psm_cfg = {0};
wifi_psm_cfg.mode = 2;
wifi_psm_cfg.enable = 1;
wifi_psm_cfg.para = 10;
ret = ql_wifi_app_psm(&wifi_psm_cfg);
printf("\r\n[ql_wifi_app_psm]ret[%d]\r\n", ret);
wifi_tcp_task = NULL;
ql_rtos_task_delete(NULL);
}
static void ql_842d_sta_test(void *argv)
{
int ret = 0;
char *ssid = "Visitor-QuecteK";
char *password = "v@quectel";
ql_wifi_ind_t ql_wifi_status = {0};
char wifi_version[64] = {0};
ql_wifi_config_t wifi_config = {0};
/* Hardware-related configuration*/
wifi_config.port_cfg = QL_WIFI_PORT_SPI_UART;
wifi_config.spi_config.port = QL_WIFI_SPI_PORT;
wifi_config.spi_config.clk = QL_WIFI_SPI_CLK;
wifi_config.spi_config.mode = QL_WIFI_SPI_MODE;
wifi_config.spi_config.cs = QL_WIFI_SPI_CS_GPIO;
wifi_config.spi_config.slave_rdy = QL_WIFI_SPI_SLAVE_RDY_GPIO;
wifi_config.spi_config.slave_cts = QL_WIFI_SPI_SLAVE_CTS_GPIO;
wifi_config.uart_port = QL_WIFI_UART_PORT;
/* Software-related configuration */
wifi_config.mode = QL_WIFI_MODE_STA;
wifi_config.simid = 0;
wifi_config.cid = QL_WIFI_STA_MODE_CID;
wifi_config.auth_type = QL_WIFI_AUTH_TYPE_WPA_WPA2;
memcpy(wifi_config.ssid, ssid, strlen(ssid) + 1);
memcpy(wifi_config.password, password, strlen(password) + 1); // QL_WIFI_AUTH_TYPE_WPA_WPA2
// memset(wifi_config.password, 0, sizeof(wifi_config.password)); // QL_WIFI_AUTH_TYPE_NONE
printf("\r\n[%s][%d]passwd strlen[%d]\r\n", __func__, __LINE__, strlen(wifi_config.password));
// Set log port
ql_log_mask_set(QL_LOG_APP_MASK, QL_LOG_PORT_UART);
printf("ql_wifi_sta_test\n");
/* Create msg queue. */
if (0 != ql_rtos_queue_create(&wifi_msg_queue, sizeof(ql_wifi_ind_t), 10))
{
printf("ql_rtos_queue_create failed");
}
ql_uart_close(QL_WIFI_UART_PORT);
ret = ql_wifi_set_config(&wifi_config);
if (ret == -1)
{
printf("ql_wifi_set_config failed\n");
return;
}
ql_wifi_ldo_ctrl(true);
ql_wifi_hardware_reset();
printf("reset wifi\n");
// wait wifi reset ok
ql_rtos_task_sleep_s(1);
ql_wifi_get_version(wifi_version, sizeof(wifi_version));
printf("wifi version=%s\n", wifi_version);
// Start wifi as station mode
ret = ql_wifi_open(ql_wifi_callback);
printf("ql_wifi_open %d\n", ret);
ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
ql_wifi_demo_ble_send_msg(QL_WIFI_DEMO_BLE_OPEN); // enable ble
while (1)
{
ret = ql_rtos_queue_wait(wifi_msg_queue, (uint8_t *)&ql_wifi_status, sizeof(ql_wifi_ind_t), 5*1000); // 5*1000 QL_WAIT_FOREVER
if (ret != 0)
{
printf("\r\n[%s][%d]queue ret[%d]\r\n", __func__, __LINE__, ret);
ql_wifi_app_sta_link_info(ql_wifi_link_info_callback);
continue;
}
printf("ind_type=%d, wifi status=%d, mac=%s\n", ql_wifi_status.ind_type ,ql_wifi_status.state, ql_wifi_status.mac_str);
switch (ql_wifi_status.state)
{
case QL_WIFI_IND_STATE_CONNECTED:
{
if (wifi_tcp_task == NULL)
{
ret = ql_rtos_task_create(&wifi_tcp_task, 4096, 100, "wifi_tcp", ql_wifi_tcp_client_thread, NULL, 0);
}
break;
}
case QL_WIFI_IND_STATE_DISCONNECT:
default:
{
break;
}
}
}
}
static int ql_wifi_demo_ble_gatt_data_parse(void* in_info,ql_wifi_app_user_ap_info_s *out_info)
{
if(!in_info || !out_info)
{
return -1;
}
uint8_t *ptr = (uint8_t*)in_info;
uint8_t uuid_len = *(uint8_t*)ptr;
printf("wifi ble uuid_len %d",uuid_len);
if(2 != uuid_len && 16 != uuid_len)
{
return -1;
}
ptr += sizeof(uuid_len);
uint8_t uuid[16] = {0};
char uuid_str[32] = {0};
memcpy((void*)uuid,(void*)ptr,uuid_len);
for(uint8_t i = 0; i < uuid_len;i++)
{
sprintf((char*)uuid_str,"%02X",uuid[i]);
}
printf("wifi ble uuid %s",uuid_str);
ptr += uuid_len;
/* Move to data_len */
uint16_t data_len = *(uint16_t*)ptr;
printf("wifi ble data_len %d",data_len);
if(data_len > QL_WIFI_SSID_MAX_LEN + QL_WIFI_PASSWORD_MAX_LEN)
{
return -1;
}
ptr += sizeof(data_len);
printf("wifi ble peek %02x %02x %02x %02x",ptr[0],ptr[1],ptr[2],ptr[3]);
ql_wifi_app_user_ap_info_s ap_info = {0};
uint8_t ssid_len = ptr[0];
uint8_t password_len = ptr[0 + 1 + ssid_len];
printf("wifi ble len %d/%d/%d/%d",data_len,ssid_len,password_len,ssid_len + password_len + 2);
if(data_len != ssid_len + password_len + 2)
{
return -1;
}
memcpy((void*)ap_info.ssid,(void*)(&ptr[1]),ssid_len);
memcpy((void*)ap_info.password,(void*)(&ptr[1 + ssid_len + 1]),password_len);
*out_info = ap_info;
return 0;
}
static void ql_wifi_demo_ble_gatt_data_callback(void* ctx)
{
uint8_t *ptr = (uint8_t*)ctx;
uint8_t uuid_len = *(uint8_t*)ptr;
ptr += sizeof(uuid_len);
ptr += uuid_len;
uint16_t data_len = *(uint16_t*)ptr;
printf("\r\n[%s][%d]data_len[%d]\r\n", __func__, __LINE__,data_len);
ql_wifi_app_user_ap_info_s ap_user_info = {0};
ql_wifi_demo_ble_send_msg(QL_WIFI_DEMO_BLE_DATA_SEND);
// Visitor-Quectel 56697369746f722d5175656374656c
// v@quectel 76407175656374656c
// 0f56697369746f722d5175656374656c0976407175656374656c
if(0 != ql_wifi_demo_ble_gatt_data_parse(ctx,&ap_user_info))
{
printf("\r\n[%s][%d]\r\n", __func__, __LINE__);
return;
}
printf("ssid = [%s], pwd = [%s]", ap_user_info.ssid, ap_user_info.password);
ql_wifi_config_t wifi_config = {0};
/* Software-related config */
wifi_config.mode = QL_WIFI_MODE_STA;
wifi_config.simid = 0;
wifi_config.cid = QL_WIFI_STA_MODE_CID;
wifi_config.auth_type = QL_WIFI_AUTH_TYPE_WPA_WPA2;
memcpy(wifi_config.ssid, ap_user_info.ssid, strlen(ap_user_info.ssid) + 1);
memcpy(wifi_config.password, ap_user_info.password, strlen(ap_user_info.password) + 1);
if ((ql_wifi_set_config(&wifi_config)) == -1)
{
printf("ql_wifi_set_config failed\n");
return;
}
ql_wifi_demo_ble_send_msg(QL_WIFI_DEMO_BLE_WIFI_TRY_OPEN);
return;
}
static void ql_wifi_demo_ble_gatt_link_callback(void* ctx)
{
ql_wifi_ble_msg_e msg = *(ql_wifi_ble_msg_e*)ctx;
switch(msg)
{
case QL_WIFI_BLE_MSG_CONNECTED:
{
printf("wifi ble conn");
break;
}
case QL_WIFI_BLE_MSG_DISCONNECTED:
{
printf("wifi ble disconn");
ql_wifi_demo_ble_send_msg(QL_WIFI_DEMO_BLE_ADV_RESTART);
break;
}
case QL_WIFI_BLE_MSG_MTU_UPDATED:
{
uint16_t mtu = *((uint16_t*)(((ql_wifi_ble_gatt_link_ctx_s*)ctx)->value));
printf("wifi ble mtu updated %d",mtu);
break;
}
default:
{
printf("link unknown msg");
break;
};
}
return;
}
static void ql_wifi_demo_ble_init()
{
int ret = 0;
ql_wifi_ble_service_info_s ble_service = {0};
ble_service.uuid_len = 2;
ble_service.uuid[0] = 0xFF;
ble_service.uuid[1] = 0xF1;
ret = ql_wifi_ble_init(&ble_service);
printf("ql_wifi_ble_init ret = %x",ret);
ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
ql_wifi_ble_service_info_s ble_characteristic = {0};
ble_characteristic.uuid_len = 2;
ble_characteristic.uuid[0] = 0xFF;
ble_characteristic.uuid[1] = 0xF2;
ret = ql_wifi_ble_set_characteristic(&ble_characteristic);
printf("ql_wifi_ble_set_characteristic ret = %x", ret);
/* Update uuid16_data_buf */
if(2 == ble_characteristic.uuid_len)
{
ql_wifi_ble_send_data_info.uuid_len = ble_characteristic.uuid_len;
memcpy((void*)ql_wifi_ble_send_data_info.uuid,(void*)ble_characteristic.uuid,ble_characteristic.uuid_len);
}
ql_wifi_ble_register_gatt_data_cb(ql_wifi_demo_ble_gatt_data_callback);
ql_wifi_ble_register_gatt_link_cb(ql_wifi_demo_ble_gatt_link_callback);
ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
ql_wifi_ble_set_name("quectel_wifi_ble");
ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
ql_wifi_ble_adv_start(NULL);
}
static void ql_wifi_ble_test(void *argv)
{
ql_task_t taskRef =NULL;
u8 wifi_ble_task_priority;
/* Create msg queue. */
if (0 != ql_rtos_queue_create(&wifi_ble_msg_queue, sizeof(ql_wifi_ind_t), 10))
{
printf("ql_rtos_queue_create failed");
}else
{
ql_rtos_task_get_current_ref(&taskRef);
ql_rtos_task_get_priority(taskRef, &wifi_ble_task_priority);
printf("\r\n[%s][%d]priority[%d]\r\n", __func__, __LINE__,wifi_ble_task_priority);
}
int ret = 0;
ql_wifi_demo_ble_msg_s ql_wifi_demo_ble_msg = {0};
ql_wifi_link_info_t info = {0};
while (1)
{
ret = ql_rtos_queue_wait(wifi_ble_msg_queue, (uint8_t *)&ql_wifi_demo_ble_msg, sizeof(ql_wifi_demo_ble_msg_s), QL_WAIT_FOREVER);
switch (ql_wifi_demo_ble_msg.state)
{
case QL_WIFI_DEMO_BLE_OPEN:
{
ql_wifi_demo_ble_init();
ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
break;
}
case QL_WIFI_DEMO_BLE_CLOSE:
{
ql_wifi_ble_adv_stop(NULL);
ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
ql_wifi_ble_deinit(NULL);
break;
}
case QL_WIFI_DEMO_BLE_ADV_RESTART:
{
ql_wifi_ble_adv_start(NULL);;
break;
}
case QL_WIFI_DEMO_BLE_WIFI_OPEN:
{
ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
ret = ql_wifi_open(ql_wifi_callback);
printf("ql_wifi_open %d", ret);
break;
}
case QL_WIFI_DEMO_BLE_WIFI_TRY_OPEN:
{
ql_rtos_task_sleep_ms(QL_WIFI_BLE_COMMAND_DELAY_MS);
ret = ql_wifi_close();
printf("ql_wifi_close %d", ret);
ql_wifi_demo_ble_send_msg(QL_WIFI_DEMO_BLE_WIFI_OPEN);
break;
}
case QL_WIFI_DEMO_BLE_DATA_SEND:
{
/* Data test */
ql_wifi_ble_data_info_s ble_data = {0};
ble_data.data_len = strlen("wifi ble send data");
/* MAX:MTU-3, default: 20 */
uint32_t mtu_3 = 20;
if(ble_data.data_len > mtu_3)
{
printf("wifi ble data overflow");
break;
}
strcpy((char *)ble_data.data, "wifi ble send data");
/* uuid has been set in ql_wifi_demo_ble_init. */
ql_wifi_ble_send_data_info.data_len = ble_data.data_len;
ql_wifi_ble_send_data_info.data = (uint8_t *)ble_data.data;
printf("\r\ndata info:%d/0x%X%X/%d/%s/0x%x\r\n",ql_wifi_ble_send_data_info.uuid_len
,ql_wifi_ble_send_data_info.uuid[0],ql_wifi_ble_send_data_info.uuid[1]
,ql_wifi_ble_send_data_info.data_len
,(char*)ql_wifi_ble_send_data_info.data
, ql_wifi_ble_send_data_info.data);
ql_wifi_ble_sent_gatt_data(&ql_wifi_ble_send_data_info);
break;
}
default:
{
printf("\r\nble_msg[%d] is not define\r\n", ql_wifi_demo_ble_msg.state);
break;
}
}
}
}
// application_init(ql_842d_sta_test, "842d_sta", 10, 100);
// application_init(ql_wifi_ble_test, "wifi_ble", 10, 100);
Reference in New Issue View Git Blame Copy Permalink