new/external/rkwifibt-app/test/rk_wifi_test.c

388 lines
8.3 KiB
C
Raw Normal View History

2025-05-10 21:58:58 +08:00
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <sys/prctl.h>
#include <sys/time.h>
#include <stdbool.h>
#include "Rk_wifi.h"
#include "Rk_softap.h"
struct wifi_info {
int ssid_len;
char ssid[512];
int psk_len;
char psk[512];
};
static void printf_system_time()
{
struct timeval tv;
gettimeofday(&tv, NULL);
printf("--- time: %lld ms ---\n", tv.tv_sec * 1000 + tv.tv_usec/1000 + tv.tv_usec%1000);
}
static void ping_test()
{
char line[2048];
while(1) {
sleep(1);
#if 0
if (RK_wifi_ping("www.baidu.com")) {
printf("ping ok\n");
printf_system_time();
rk_wifi_getConnectionInfo(NULL);
break;
}
//#else
memset(line, 0, sizeof(line));
RK_shell_exec("ping www.baidu.com -c 1", line, sizeof(line));
//RK_shell_exec("ping 8.8.8.8 -c 1", line, sizeof(line));
//usleep(100000);
printf("line: %s\n", line);
if (strstr(line, "PING www.baidu.com") && strstr(line, "bytes from")) {
//if (strstr(line, "PING 8.8.8.8") && strstr(line, "bytes from")) {
printf("ping ok\n");
printf_system_time();
rk_wifi_getConnectionInfo(NULL);
break;
}
#endif
usleep(100000);
}
}
static void printf_connect_info(RK_WIFI_INFO_Connection_s *info)
{
if(!info)
return;
printf(" id: %d\n", info->id);
printf(" bssid: %s\n", info->bssid);
printf(" ssid: %s\n", info->ssid);
printf(" freq: %d\n", info->freq);
printf(" mode: %s\n", info->mode);
printf(" wpa_state: %s\n", info->wpa_state);
printf(" ip_address: %s\n", info->ip_address);
printf(" mac_address: %s\n", info->mac_address);
}
/*****************************************************************
* wifi config *
*****************************************************************/
static volatile bool rkwifi_gonff = false;
static RK_WIFI_RUNNING_State_e wifi_state = 0;
static int rk_wifi_state_callback(RK_WIFI_RUNNING_State_e state, RK_WIFI_INFO_Connection_s *info)
{
printf("%s state: %d\n", __func__, state);
printf_connect_info(info);
wifi_state = state;
if (state == RK_WIFI_State_CONNECTED) {
printf("RK_WIFI_State_CONNECTED\n");
//ping_test();
//RK_wifi_get_connected_ap_rssi();
} else if (state == RK_WIFI_State_CONNECTFAILED) {
printf("RK_WIFI_State_CONNECTFAILED\n");
} else if (state == RK_WIFI_State_CONNECTFAILED_WRONG_KEY) {
printf("RK_WIFI_State_CONNECTFAILED_WRONG_KEY\n");
} else if (state == RK_WIFI_State_OPEN) {
rkwifi_gonff = true;
printf("RK_WIFI_State_OPEN\n");
} else if (state == RK_WIFI_State_OFF) {
rkwifi_gonff = false;
printf("RK_WIFI_State_OFF\n");
} else if (state == RK_WIFI_State_DISCONNECTED) {
printf("RK_WIFI_State_DISCONNECTED\n");
} else if (state == RK_WIFI_State_SCAN_RESULTS) {
char *scan_r;
printf("RK_WIFI_State_SCAN_RESULTS\n");
scan_r = RK_wifi_scan_r();
//printf("%s\n", scan_r);
free(scan_r);
}
return 0;
}
static void *rk_wifi_config_thread(void *arg)
{
struct wifi_info *info;
printf("rk_config_wifi_thread\n");
prctl(PR_SET_NAME,"rk_config_wifi_thread");
wifi_state = 0;
info = (struct wifi_info *) arg;
RK_wifi_register_callback(rk_wifi_state_callback);
RK_wifi_connect(info->ssid, info->psk);
printf("Exit wifi config thread\n");
return NULL;
}
/*****************************************************************
* airkiss wifi config test *
*****************************************************************/
void rk_wifi_airkiss_start(void *data)
{
int err = 0;
struct wifi_info info;
pthread_t tid = 0;
memset(&info, 0, sizeof(struct wifi_info));
printf("===== %s =====\n", __func__);
//if(RK_wifi_airkiss_start(info.ssid, info.psk) < 0)
// return;
wifi_state = 0;
err = pthread_create(&tid, NULL, rk_wifi_config_thread, &info);
if (err) {
printf("Error - pthread_create() return code: %d\n", err);
return;
}
while (!wifi_state)
sleep(1);
}
void rk_wifi_airkiss_stop(void *data)
{
//RK_wifi_airkiss_stop();
}
/*****************************************************************
* softap wifi config test *
*****************************************************************/
static int rk_wifi_softap_state_callback(RK_SOFTAP_STATE state, const char* data)
{
switch (state) {
case RK_SOFTAP_STATE_CONNECTTING:
printf("RK_SOFTAP_STATE_CONNECTTING\n");
break;
case RK_SOFTAP_STATE_DISCONNECT:
printf("RK_SOFTAP_STATE_DISCONNECT\n");
break;
case RK_SOFTAP_STATE_FAIL:
printf("RK_SOFTAP_STATE_FAIL\n");
break;
case RK_SOFTAP_STATE_SUCCESS:
printf("RK_SOFTAP_STATE_SUCCESS\n");
break;
default:
break;
}
return 0;
}
void rk_wifi_softap_start(void *data)
{
printf("%s enter\n", __func__);
RK_softap_register_callback(rk_wifi_softap_state_callback);
if (0 != RK_softap_start("Rockchip-SoftAp", RK_SOFTAP_TCP_SERVER)) {
return;
}
}
void rk_wifi_softap_stop(void *data)
{
RK_softap_stop();
}
void _rk_wifi_open(void *data)
{
RK_wifi_register_callback(rk_wifi_state_callback);
if (RK_wifi_enable(1) < 0)
printf("RK_wifi_enable 1 fail!\n");
}
void rk_wifi_close(void *data)
{
if (RK_wifi_enable(0) < 0)
printf("RK_wifi_enable 0 fail!\n");
}
static int wifi_cnt = 0;
void *wifi_test_onff_thread(void *arg)
{
while (1) {
//open
RK_wifi_register_callback(rk_wifi_state_callback);
if (RK_wifi_enable(1) < 0)
printf("RK_wifi_enable 1 fail!\n");
while (rkwifi_gonff == false) {
sleep(1);
printf("%s: RKWIFI TURNING ON ...\n", __func__);
}
//scan
RK_wifi_scan();
sleep(1);
//close
printf("%s: RKWIFI DEINIT\n", __func__);
if (RK_wifi_enable(0) < 0)
printf("RK_wifi_enable 0 fail!\n");
while (rkwifi_gonff == true) {
sleep(1);
printf("%s: RKWIFI TURNING OFF ...\n", __func__);
}
printf("%s: RKWIFI TURN ONOFF CNT: [%d] \n", __func__, wifi_cnt++);
}
}
static pthread_t rkwifi_init_thread = 0;
void rk_wifi_openoff_test(char *data)
{
printf("%s: ", __func__);
if (rkwifi_init_thread) {
printf("rkwifi_init_thread already exist\n");
return;
}
if (pthread_create(&rkwifi_init_thread, NULL, wifi_test_onff_thread, NULL)) {
printf("Createrkwifi_init_thread failed\n");
return;
}
}
void rk_wifi_open(char *data)
{
printf("%s: ", __func__);
RK_wifi_register_callback(rk_wifi_state_callback);
if (RK_wifi_enable(1) < 0)
printf("RK_wifi_enable 1 fail!\n");
}
//9 input fish1:rk12345678
void rk_wifi_connect(void *data)
{
char *ssid = NULL, *psk = NULL;
if(data == NULL) {
printf("%s: invalid input\n", __func__);
return;
}
ssid = strtok(data, ":");
if(ssid)
psk = strtok(NULL, ":");
if (RK_wifi_connect(ssid, psk) < 0)
printf("RK_wifi_connect1 fail!\n");
}
void rk_wifi_connect1(void *data)
{
char *ssid = NULL, *psk = NULL;
if (RK_wifi_connect1("1a~!@#%^*()=+]['\\\\\\\":\\/?.>,<", "12345678", WPA, 1) < 0)
printf("RK_wifi_connect1 fail!\n");
return;
if(data == NULL) {
printf("%s: invalid input\n", __func__);
return;
}
ssid = strtok(data, ":");
if(ssid)
psk = strtok(NULL, ":");
if (RK_wifi_connect(ssid, psk) < 0)
printf("RK_wifi_connect1 fail!\n");
}
void rk_wifi_ping(void *data)
{
if (!RK_wifi_ping("www.baidu.com"))
printf("RK_wifi_ping fail!\n");
}
void rk_wifi_scan(void *data)
{
if (RK_wifi_scan() < 0)
printf("RK_wifi_scan fail!\n");
}
void rk_wifi_getSavedInfo(void *data)
{
RK_WIFI_SAVED_INFO_s *wsi;
int ap_cnt = 0;
RK_wifi_getSavedInfo(&wsi, &ap_cnt);
if (ap_cnt <= 0) {
printf("not found saved ap!\n");
return;
}
for (int i = 0; i < ap_cnt; i++) {
printf("id: %d, name: %s, bssid: %s, state: %s\n",
wsi[i].id,
wsi[i].ssid,
wsi[i].bssid,
wsi[i].state);
}
if (wsi != NULL)
free(wsi);
}
void rk_wifi_getConnectionInfo(void *data)
{
RK_WIFI_INFO_Connection_s info;
if(!RK_wifi_running_getConnectionInfo(&info))
printf_connect_info(&info);
}
void rk_wifi_connect_with_ssid(void *data)
{
if(data == NULL) {
printf("%s: ssid is null\n", __func__);
return;
}
if (RK_wifi_connect_with_ssid(data) < 0)
printf("RK_wifi_connect_with_ssid fail!\n");
}
void rk_wifi_cancel(void *data)
{
if (RK_wifi_cancel() < 0)
printf("RK_wifi_cancel fail!\n");
}
void rk_wifi_forget_with_ssid(void *data)
{
if(data == NULL) {
printf("%s: ssid is null\n", __func__);
return;
}
if (RK_wifi_forget_with_ssid(data) < 0) {
printf("rk_wifi_forget_with_ssid fail!\n");
}
}
void rk_wifi_disconnect(void *data)
{
RK_wifi_disconnect_network();
}