【GD32VW553-IOT V2】基于Socket的天气时钟

import requests

import json

def Weather_Data_Write_To_File():

Weather_Data = [None] * 8

dict = Weathet_Data_Get()

print(dict)

print(dict['lives'][0]["weather"])

Weather_Data[0] = dict['lives'][0]['province']

Weather_Data[1] = dict['lives'][0]['city']

Weather_Data[2] = dict['lives'][0]['weather']

Weather_Data[4] = dict['lives'][0]['windpower']

Weather_Data[5] = dict['lives'][0]['temperature_float']

Weather_Data[6] = dict['lives'][0]['humidity_float']

Weather_Data[7] = dict['lives'][0]['reporttime']

if dict['lives'][0]['winddirection'] == '无风向':

Weather_Data[3] = 'No_Wind'

elif dict['lives'][0]['winddirection'] == '东北':

Weather_Data[3] = 'NorthEast'

elif dict['lives'][0]['winddirection'] == '东':

Weather_Data[3] = 'East'

elif dict['lives'][0]['winddirection'] == '东南':

Weather_Data[3] = 'SouthEast'

elif dict['lives'][0]['winddirection'] == '南':

Weather_Data[3] = 'South'

elif dict['lives'][0]['winddirection'] == '西':

Weather_Data[3] = 'West'

elif dict['lives'][0]['winddirection'] == '西北':

Weather_Data[3] = 'NorthWest'

elif dict['lives'][0]['winddirection'] == '北':

Weather_Data[3] = 'North'

else:

Weather_Data[3] = 'Direction_Unknown'

print(Weather_Data)

with open('Weather_Data/Weather_Data.wea','a') as f:

f.write("{}!{}!{}!{}!{}!{}!{}!{}!{}\r\n".format(Weather_Data[0],Weather_Data[1],Weather_Data[2],Weather_Data[3],Weather_Data[4], \

Weather_Data[5],Weather_Data[6],str(Weather_Data[7]).split(' ',1)[0], \

str(Weather_Data[7]).split(' ',1)[1]))

print(Weather_Data[7])

def Weathet_Data_Get():

Weather = requests.get('https://restapi.amap.com/v3/weather/weatherInfo?city=320582&key=<your_Key>')

return Weather.json()

if __name__ == "__main__":

Weather_Data_Write_To_File()

{

"status" :

"1",

"count" :

"1",

"info" :

"OK",

"infocode" :

"10000",

"lives" :

[

"0" :

{

"province" :

"北京",

"city" :

"东城区",

"adcode" :

"110101",

"weather" :

"阴",

"temperature" :

"18",

"winddirection" :

"西南",

"windpower" :

"≤3",

"humidity" :

"65",

"reporttime" :

"2025-09-18 22:33:38",

"temperature_float" :

"18.0",

"humidity_float" :

"65.0"

}

]

}

# Edit this file to introduce tasks to be run by cron.

#

# Each task to run has to be defined through a single line

# indicating with different fields when the task will be run

# and what command to run for the task

#

# To define the time you can provide concrete values for

# minute (m), hour (h), day of month (dom), month (mon),

# and day of week (dow) or use '*' in these fields (for 'any').

#

# Notice that tasks will be started based on the cron's system

# daemon's notion of time and timezones.

#

# Output of the crontab jobs (including errors) is sent through

# email to the user the crontab file belongs to (unless redirected).

#

# For example, you can run a backup of all your user accounts

# at 5 a.m every week with:

# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/

#

# For more information see the manual pages of crontab(5) and cron(8)

#

# m h dom mon dow command

*/30 * * * * /usr/bin/python3 /home/zzk/Socket/Weather.py >> /home/zzk/Socket/Log.lg 2>&1

python脚本的输出在Log.lg文件里保存。



我们的任务是每隔半小时进行数据的获取。



接下来开始进行和单片机交互的Socket服务器的编写：



import socket

import threading

import time

def handle_client(client_socket, client_address):

"""处理客户端连接，接收数据并返回相同数据"""

print(f"新连接: {client_address}")



try:

# 持续接收客户端数据

while True:

# 接收数据，缓冲区大小为1024字节

data = client_socket.recv(1024)



# 如果没有收到数据，说明客户端已断开连接

if not data:

print(f"客户端 {client_address} 断开连接")

break

Receive_Data = data.decode('utf-8')

print(f"从 {client_address} 收到数据: {Receive_Data}")

# 将收到的数据原样返回给客户端

if Receive_Data == "Get_Time":

Time = time.strftime("%Y:%m:%d:%H:%M:%S",time.localtime())

client_socket.sendall(Time.encode('ascii'))

print(f"传回数据：{Time}")

elif Receive_Data == "Get_Weather":

client_socket.sendall(Weather_Data_Get().encode('ascii'))

print(f"传回数据：{Weather_Data_Get()}")

else:

client_socket.sendall("Mesange_Error".encode('ascii'))

print(f"回传数据：{'Mesange_Error'}")

except Exception as e:

print(f"处理客户端 {client_address} 时出错: {e}")



finally:

# 关闭客户端连接

client_socket.close()

def Weather_Data_Get():

with open("/home/zzk/Socket/Weather_Data/Weather_Data.wea","r",encoding="utf-8") as Fw:

Wea_Str = Fw.readlines()

Wea_List = Wea_Str[-1].split('!',8)

Wea_List[2] = Weather_Condition_Deal(Wea_List[2])

Wea_List[0] = 'Jiangsu'

Wea_List[1] = 'ZhangjiaGang'

if Wea_List[4] == '≤3':

Wea_List[4] = '<3'

Deal_Str = (f"{Wea_List[0]}_{Wea_List[1]}_{Wea_List[2]}_{Wea_List[3]}_{Wea_List[4]}_{Wea_List[5]}_"

f"{Wea_List[6]}_{Wea_List[7]}_{Wea_List[8].strip()}")

print(f"Log:{Deal_Str}")

return Deal_Str



def start_server(host='127.0.0.1', port=1234): # 修改为 0.0.0.0

"""启动服务器并监听连接"""

# 创建TCP socket

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)



# 允许端口重用，避免程序重启时出现"地址已在使用"错误

server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)



try:

# 绑定到指定的IP和端口

server_socket.bind((host, port))

print(f"服务器已绑定到 {host}:{port}")



# 开始监听，最大连接数为5

server_socket.listen(5)

print(f"服务器开始监听，等待连接...")



while True:

# 接受客户端连接

client_socket, client_address = server_socket.accept()



# 创建线程处理客户端请求，实现多客户端同时连接

client_thread = threading.Thread(

target=handle_client,

args=(client_socket, client_address)

)

client_thread.start()



except Exception as e:

print(f"服务器出错: {e}")



finally:

# 关闭服务器socket

server_socket.close()

print("服务器已关闭")

def Weather_Condition_Deal(Condition : str):

weather_translation = {

"晴": "Sunny",

"少云": "Partly Cloudy",

"晴间多云": "Sun & Clouds",

"多云": "Cloudy",

"阴": "Overcast",

"有风": "Windy",

"平静": "Calm",

"微风": "Light Breeze",

"和风": "Mod Breeze",

"清风": "Fresh Breeze",

"强风/劲风": "Strong Wind",

"疾风": "Near Gale",

"大风": "Gale",

"烈风": "Strong Gale",

"风暴": "Storm",

"狂爆风": "Violent Storm",

"飓风": "Hurricane",

"热带风暴": "Trop Storm",

"霾": "Haze",

"中度霾": "Mod Haze",

"重度霾": "Heavy Haze",

"严重霾": "Severe Haze",

"阵雨": "Showers",

"雷阵雨": "Thunder Showers",

"雷阵雨并伴有冰雹": "T-Storm w/Hail",

"小雨": "Light Rain",

"中雨": "Mod Rain",

"大雨": "Heavy Rain",

"暴雨": "Torrential Rain",

"大暴雨": "Heavy Downpour",

"特大暴雨": "Extreme Rain",

"强阵雨": "Heavy Showers",

"强雷阵雨": "Heavy T-Storm",

"极端降雨": "Extreme Rainfall",

"毛毛雨/细雨": "Drizzle",

"雨": "Rain",

"小雨-中雨": "Light-Mod Rain",

"中雨-大雨": "Mod-Heavy Rain",

"大雨-暴雨": "Heavy-Torrential",

"暴雨-大暴雨": "Torrential-Heavy",

"大暴雨-特大暴雨": "Heavy-Extreme",

"雨雪天气": "Rain & Snow",

"雨夹雪": "Sleet",

"阵雨夹雪": "Showers w/Snow",

"冻雨": "Freezing Rain",

"雪": "Snow",

"阵雪": "Snow Showers",

"小雪": "Light Snow",

"中雪": "Mod Snow",

"大雪": "Heavy Snow",

"暴雪": "Blizzard",

"小雪-中雪": "Light-Mod Snow",

"中雪-大雪": "Mod-Heavy Snow",

"大雪-暴雪": "Heavy Snow-Bliz",

"浮尘": "Dust",

"扬沙": "Blowing Sand",

"沙尘暴": "Sandstorm",

"强沙尘暴": "Severe Sandstorm",

"龙卷风": "Tornado",

"雾": "Fog",

"浓雾": "Dense Fog",

"强浓雾": "Heavy Fog",

"轻雾": "Mist",

"大雾": "Thick Fog",

"特强浓雾": "Extreme Fog",

"热": "Hot",

"冷": "Cold",

"未知": "Unknown"

}

return weather_translation[Condition]

if __name__ == "__main__":

# 启动服务器，默认使用1234端口

# 如需更改端口，可以修改port参数，如start_server(port=9999)

start_server(host = '0.0.0.0')

import socket





def start_client():

# 创建TCP/IP套接字

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)



# 服务器地址和端口

server_address = ("127.0.0.1", 1234)

print(f"连接到服务器 {server_address[0]}:{server_address[1]}")



try:

# 连接到服务器

client_socket.connect(server_address)



# 发送数据

message = "Get_Weather"

print(f"发送消息: {message}")

client_socket.sendall(message.encode('utf-8'))



# 接收服务器响应

data = client_socket.recv(1024)

print(f"收到服务器响应: {data.decode('ascii')}")

# 发送数据

message = "Get_Time"

print(f"发送消息: {message}")

client_socket.sendall(message.encode('utf-8'))



# 接收服务器响应

data = client_socket.recv(1024)

print(f"收到服务器响应: {data.decode('ascii')}")



finally:

# 关闭套接字

client_socket.close()

print("客户端已关闭连接")





if __name__ == "__main__":

start_client()

/*

* My_Wifi_Connect.h

*

* Created on: 2025年9月10日

* Author: 19651

*/



#ifndef MY_WIFI_CONNECT_H_

#define MY_WIFI_CONNECT_H_

void wifi_connect_ap(void * para);

void wifi_start_ap(void *para);

void LED_Blink(void *para);

void wifi_start_ap_1(void *para);

void Socket_Test(void);

void Get_Data_Manage(void* Para);

void Socket_Deal(void *Para);

void OLED_Show(void *Para);

void OLED_Control(void *Para);

void Get_Data_Deal(void);

typedef enum{

OLED_Clock,

OLED_Weather_Condition,

OLED_Weather_Tem_Hyd,

}OLED_WEATHER;

typedef enum{

Wifi_Socket_Get_Error,

Wifi_Socket_Server_Error,

Wifi_Socket_Normal





}Wifi_Data_condition;

typedef enum{

Socket_Get_Time,

Socket_Get_Weather

}Which_Data_To_GET;

typedef enum{

OLED_Wifi_Connect,

OLED_Wifi_Disconnect



}Wifi_Connect_STATUS;

typedef struct{

char Provience[10];

char Location[15];

char Weather_Condition[21];

char Hyd[5];

char TEM[5];

char Update_Date[11];

char Update_Tim[11];

char Wind_Direction[11];

char Wind_Intensity[2];

}WEATHER_DATA;

#endif /* MY_WIFI_CONNECT_H_ */





/*

* My_Wifi_Connect.c

*

* Created on: 2025年9月10日

* Author: 19651

*/

#include "wifi_management.h"

#include "My_Wifi_Connect.h"

#include <stdint.h>

#include "gd32vw55x_gpio.h"

#include "My_Wifi_Connect.h"

#include "stdbool.h"

#include "OLED.h"

#include "wrapper_os.h"

#include "sockets.h"

#include "string.h"

void* WIFI_Connect_Status = NULL;

OLED_WEATHER OLED_Weather = OLED_Weather_Tem_Hyd;

Wifi_Data_condition Wifi_Data_Condition = Wifi_Socket_Normal;

Which_Data_To_GET Which_Data_To_Get = Socket_Get_Weather;

//Which_Data_To_GET Which_Data_To_Get = Socket_Get_Time;

Wifi_Connect_STATUS Wifi_Connect_Status = OLED_Wifi_Disconnect;

WEATHER_DATA Weather_Data ;

extern rtc_parameter_struct RTC_Init;

static bool Oled_Status_Chnaged = false;

void wifi_connect_ap(void * para)

{

while(1)

{

int status = 0;

char *ssid = "你的wifi账号";

char *password = "你的Wifi密码";

status = wifi_management_connect(ssid, password, true);

if (status != 0) {

}

printf("Wifi_connect_Task\r\n");

sys_task_notify(WIFI_Connect_Status,false);

printf("Wifi_connect_Weak_Up\r\n");

sys_task_delete(NULL);



}

}

void LED_Blink(void *para)

{

for(;;)

{

gpio_bit_set(GPIOA,GPIO_PIN_3);

sys_ms_sleep(500);

gpio_bit_reset(GPIOA,GPIO_PIN_3);

sys_ms_sleep(500);

}



}

void *Socket_Para = NULL;

void Socket_Deal(void *Para)

{

int vif_idx = WIFI_VIF_INDEX_DEFAULT;

bool Wifi_Status;

static bool Socket_Creat = true;

for(;;)

{



Wifi_Status = wifi_vif_is_sta_connected(vif_idx);



if(Wifi_Status)

{

Wifi_Connect_Status = OLED_Wifi_Connect;

if(Socket_Creat)

{

Socket_Para = sys_task_create(NULL, (const uint8_t *)"Socket_Manager", NULL, 512, 0, 0, OS_TASK_PRIORITY(3), Get_Data_Manage, NULL);

Socket_Creat = false;

}

sys_ms_sleep(500);



}

else

{

Wifi_Connect_Status = OLED_Wifi_Disconnect;

//Socket_Creat = true;

sys_task_create(NULL, (const uint8_t *)"Wifi_Connect2", NULL, 256, 0, 0, OS_TASK_PRIORITY(0), wifi_connect_ap, NULL);

sys_task_wait_notification(-1);



}

sys_ms_sleep(200);





}



}

char Buffer1[90];

void Socket_Test(void)

{

struct sockaddr_in server_addr;

int fd;

const char *send_data;

if(Which_Data_To_Get == Socket_Get_Time)

{

send_data = "Get_Time";

}

else

{

send_data = "Get_Weather";

}

int send_len = strlen(send_data);

int recv_len;



// 初始化服务器地址

memset(&server_addr, 0, sizeof(server_addr));

server_addr.sin_family = AF_INET;

server_addr.sin_port = htons(你的服务器端口);

server_addr.sin_addr.s_addr = inet_addr("你的服务器ipv4地址");

memset(Buffer1, 0, sizeof(Buffer1)); // 使用sizeof更安全



// 1. 创建TCP socket

fd = socket(AF_INET, SOCK_STREAM, 0);

if (fd < 0)

{

sys_ms_sleep(5000);

return;

}



// 2. 连接服务器

if (connect(fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)

{

close(fd);

sys_ms_sleep(5000);

return;

}



printf("Connect_Success Send Data...\r\n");



// 3. 发送数据并检查结果

if (send(fd, send_data, send_len, 0) != send_len)

{

printf("Send_Error\r\n");

close(fd);

sys_ms_sleep(5000);

return;

}



// 4. 接收数据 - 调整缓冲区大小，正确处理非阻塞模式

recv_len = recv(fd, Buffer1, 90, 0);

if (recv_len < 0)

{

Wifi_Data_Condition = Wifi_Socket_Get_Error;

}

else if (recv_len == 0)

{

Wifi_Data_Condition = Wifi_Socket_Server_Error;

}



// 5. 显示数据（缩小临界区范围）

printf("Receive:%s\r\n",Buffer1);

Get_Data_Deal();

// 6. 关闭连接

close(fd);



}



void Get_Data_Manage(void* Para)

{

for(;;)

{

if(Which_Data_To_Get == Socket_Get_Time)

{

Which_Data_To_Get = Socket_Get_Weather;

Socket_Test();

printf("Get_Time_Task\r\n");

sys_ms_sleep(60000);



}

else

{

Which_Data_To_Get = Socket_Get_Time;

Socket_Test();

printf("Get_Weather_Task\r\n");

sys_ms_sleep(2000);

}

}

}



void Get_Data_Deal(void)

{

if(Which_Data_To_Get == Socket_Get_Time)

{

sys_enter_critical();

RTC_Init.year = (strtol (strtok(Buffer1,":"),NULL,16)) & 0xff;

RTC_Init.month = strtol (strtok(NULL,":"),NULL,16);

RTC_Init.date = strtol (strtok(NULL,":"),NULL,16);

RTC_Init.hour = strtol (strtok(NULL,":"),NULL,16);

RTC_Init.minute = strtol (strtok(NULL,":"),NULL,16);

RTC_Init.second = strtol (strtok(NULL,":"),NULL,16);

printf("%x,%x,%x\r\n",RTC_Init.month,RTC_Init.minute,RTC_Init.second);

rtc_init_mode_enter();

rtc_init(&RTC_Init);

rtc_init_mode_exit();

sys_exit_critical();

}

else

{

char *p = strtok(Buffer1,"_");

strcpy(Weather_Data.Provience,p);

p = strtok(NULL,"_");

strcpy(Weather_Data.Location,p);

p = strtok(NULL,"_");

strcpy(Weather_Data.Weather_Condition,p);

p = strtok(NULL,"_");

strcpy(Weather_Data.Wind_Direction,p);

p = strtok(NULL,"_");

strcpy(Weather_Data.Wind_Intensity,p);

p = strtok(NULL,"_");

strcpy(Weather_Data.TEM,p);

p = strtok(NULL,"_");

strcpy(Weather_Data.Hyd,p);

p = strtok(NULL,"_");

strcpy(Weather_Data.Update_Date,p);

p = strtok(NULL,"_");

strcpy(Weather_Data.Update_Tim,p);

}



}



char Buffer[20];

rtc_parameter_struct Rtc_Oled;

void OLED_Show(void *Para)

{

for(;;)

{

sys_enter_critical();

if(Oled_Status_Chnaged)

{

OLED_Clear();

Oled_Status_Chnaged = false;

}

if(OLED_Weather == OLED_Clock)

{



sprintf(Buffer," Current_Time ");

OLED_ShowString(1, 1, Buffer);

printf("OLED_Task1\r\n");

rtc_current_time_get(&Rtc_Oled);

sprintf(Buffer," 20%02x:%02x:%02x ",Rtc_Oled.year,Rtc_Oled.month,Rtc_Oled.date);

OLED_ShowString(2, 1, Buffer);

sprintf(Buffer," %02x:%02x:%02x ",Rtc_Oled.hour,Rtc_Oled.minute,Rtc_Oled.second);

OLED_ShowString(3, 1, Buffer);

if(Wifi_Connect_Status ==OLED_Wifi_Disconnect)

{

OLED_ShowString(4, 1, " Wifi_Disconnect");

}

else if(Wifi_Connect_Status == OLED_Wifi_Connect)

{

OLED_ShowString(4, 1, " Wifi_Connect ");

}

}

else if(OLED_Weather == OLED_Weather_Condition)

{



sprintf(Buffer,"Pro:%s",Weather_Data.Provience);

OLED_ShowString(1,1,Buffer);

sprintf(Buffer,"Loc:%s",Weather_Data.Location);

OLED_ShowString(2,1,Buffer);

sprintf(Buffer,"Weather: %02x:%02x",RTC_Init.hour,RTC_Init.minute);

OLED_ShowString(3,1,Buffer);

sprintf(Buffer,"%s",Weather_Data.Weather_Condition);

OLED_ShowString(4,1,Buffer);

}

else if(OLED_Weather == OLED_Weather_Tem_Hyd)

{



sprintf(Buffer,"Tem:%sHyd:%s",Weather_Data.TEM,Weather_Data.Hyd);

OLED_ShowString(1,1,Buffer);

sprintf(Buffer,"%s %s",Weather_Data.Wind_Direction,Weather_Data.Wind_Intensity);

OLED_ShowString(2,1,Buffer);

sprintf(Buffer,"Up_Dt:%s",Weather_Data.Update_Date);

OLED_ShowString(3,1,Buffer);

sprintf(Buffer,"Up_Tim:%s",Weather_Data.Update_Tim);

OLED_ShowString(4,1,Buffer);

}

sys_exit_critical();

sys_ms_sleep(1000);

}

}

void OLED_Control(void *Para)

{

for(;;)

{

if(OLED_Weather == OLED_Clock)

{

OLED_Weather = OLED_Weather_Condition;



}

else if(OLED_Weather == OLED_Weather_Condition)

{

OLED_Weather = OLED_Weather_Tem_Hyd;



}

else if(OLED_Weather == OLED_Weather_Tem_Hyd)

{

OLED_Weather = OLED_Clock;



}

Oled_Status_Chnaged = true;

sys_ms_sleep(5500);



}

}















main.c:







/*!

\file main.c

\brief Main loop of GD32VW55x SDK.



\version 2023-07-20, V1.0.0, firmware for GD32VW55x

*/



/*

Copyright (c) 2023, GigaDevice Semiconductor Inc.



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 the copyright holder 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 <stdint.h>

#include "wifi_export.h"

#include "gd32vw55x_platform.h"

#include "uart.h"

#include "ble_init.h"

#include "gd32vw55x.h"

#include "wrapper_os.h"

#include "cmd_shell.h"

#include "atcmd.h"

#include "util.h"

#include "wlan_config.h"

#include "wifi_init.h"

#include "user_setting.h"

#include "version.h"

#include "_build_date.h"

#ifdef CONFIG_FATFS_SUPPORT

#include "fatfs.h"

#endif

#include "ble_app_config.h"

#include "app_cmd.h"

#ifdef CONFIG_AZURE_IOT_SUPPORT

#include "azure_entry.h"

#endif

#include "My_Wifi_Connect.h"

#include "OLED.h"

#include <string.h>

#include "W25Q64.h"

uint8_t Data[256];

uint8_t Read[256];

rtc_parameter_struct RTC_Init = {0} ;

void LED_BSP_Init(void);

/*!

\brief Init applications.

This function is called to initialize all the applications.

\param[in] none.

\param[out] none.

\retval none.

*/

static void application_init(void)

{

#if defined CONFIG_BASECMD || defined CONFIG_RF_TEST_SUPPORT || defined CONFIG_BLE_DTM_SUPPORT

if (cmd_shell_init()) {

dbg_print(ERR, "cmd shell init failed\r\n");

}

#endif

#ifdef CONFIG_ATCMD

if (atcmd_init()) {

dbg_print(ERR, "atcmd init failed\r\n");

}

#endif

util_init();



user_setting_init();



#ifdef CFG_BLE_SUPPORT

#ifdef CONFIG_BLE_ALWAYS_ENABLE

ble_init(true);

#else

ble_init(false);

#endif // CONFIG_BLE_DEFAULT_INIT

#endif // CFG_BLE_SUPPORT



#ifdef CFG_WLAN_SUPPORT

if (wifi_init()) {

dbg_print(ERR, "wifi init failed\r\n");

}

#endif

#ifdef CONFIG_FATFS_SUPPORT

fatfs_mk_mount(NULL);

#endif

#ifdef CFG_MATTER

MatterInit();

#endif



#ifdef CONFIG_AZURE_F527_DEMO_SUPPORT

azure_task_start();

#endif

}



#ifdef PLATFORM_OS_RTTHREAD

/*!

\brief Start task.

This function is called to initialize all the applications in thread context.

\param[in] param parameter passed to the task

\param[out] none

\retval none.

*/

static void start_task(void *param)

{

(void)param;



application_init();



sys_task_delete(NULL);

}

#endif



/*!

\brief Main entry point.

This function is called right after the booting process has completed.

\param[in] none

\param[out] none

\retval none.

*/

void OLED_Init_Config(void *para);

void OLED_Show(void *Para);

void Random_Data_Get(uint8_t Num);

void W25q64_Test(void *Para);

void W25Q64_Config(void);

void Task_Delete(void *Para);

void RTC_BSP_Init(void);

void* W25Q64_Task = NULL;

extern void* WIFI_Connect_Status;

int main(void)

{



sys_os_init();

platform_init();



dbg_print(NOTICE, "SDK Version: %s\n", WIFI_GIT_REVISION);

dbg_print(NOTICE, "Build date: %s\n", SDK_BUILD_DATE);

#ifdef PLATFORM_OS_RTTHREAD

if (sys_task_create_dynamic((const uint8_t *)"start_task",

START_TASK_STACK_SIZE, OS_TASK_PRIORITY(START_TASK_PRIO), start_task, NULL) == NULL) {

dbg_print(ERR, "Create start task failed\r\n");

}

#else

application_init();

#endif

LED_BSP_Init();

RTC_BSP_Init();

W25Q64_Config();

sys_task_create(NULL, (const uint8_t *)"oled_init", NULL, 1024, 0, 0, OS_TASK_PRIORITY(5), OLED_Init_Config, NULL);

sys_task_create(NULL, (const uint8_t *)"LED_Blink", NULL, 256, 0, 0, OS_TASK_PRIORITY(1), LED_Blink, NULL);

sys_task_create(NULL, (const uint8_t *)"oled_control", NULL, 256, 0, 0, OS_TASK_PRIORITY(4), OLED_Control, NULL);

sys_task_create(NULL, (const uint8_t *)"Oled_Show", NULL, 512, 0, 0, OS_TASK_PRIORITY(4), OLED_Show, NULL);

WIFI_Connect_Status = sys_task_create(NULL, (const uint8_t *)"Wifi_Status", NULL, 256, 0, 0, OS_TASK_PRIORITY(0), Socket_Deal, NULL);



sys_os_start();

}

void OLED_Init_Config(void *para)

{

for(;;)

{

sys_enter_critical();

OLED_Init();

sys_exit_critical();

sys_ms_sleep(100);

sys_task_delete(NULL);

}



}



void W25Q64_Config(void)

{

W25Q64_Init();

}

void Random_Data_Get(uint8_t Num)

{

int i=0;

int32_t Get;

for(i=0; i < Num ; i++)

{

Get = sys_random_bytes_get(Data+i,2);

if(Get != 0)

{

printf("Random_Data_Generate_Error!\r\n");

return;

}

}

}

void Buffer_Data_Print(uint8_t *BUffer)

{

for(int i=0;i < 256 / 8;i++)

{

{

printf("%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\r\n",BUffer[0+i*8],BUffer[1+i*8],BUffer[2+i*8],\

BUffer[3+i*8],BUffer[4+i*8],BUffer[5+i*8],BUffer[6+i*8],BUffer[7+i*8]);



}



}

printf("-----------\r\n");

}



void RTC_BSP_Init(void)

{

uint32_t prescaler_a = 0, prescaler_s = 0;

rcu_periph_clock_enable(RCU_PMU);

pmu_backup_write_enable();

rcu_osci_on(RCU_IRC32K);

rcu_osci_stab_wait(RCU_IRC32K);

rcu_rtc_clock_config(RCU_RTCSRC_IRC32K);

prescaler_s = 0x13F;

prescaler_a = 0x63;

rcu_periph_clock_enable(RCU_RTC);

rtc_register_sync_wait();

RTC_Init.year = 0x00;

RTC_Init.month = 0;

RTC_Init.date = 0;

RTC_Init.month = 0;

RTC_Init.minute = 0;

RTC_Init.second = 0;

RTC_Init.factor_asyn = prescaler_a;

RTC_Init.factor_syn = prescaler_s;

rtc_init(&RTC_Init);

}

void W25q64_Test(void *Para)

{

for(;;)

{

sys_enter_critical();

//Random_Data_Get(256);

memset(Data, 0x55,256);

Buffer_Data_Print(Data);

//W25Q64_SectorErase(0);

//W25Q64_PageProgram(0,Data,256);

W25Q64_ReadData(0,Read,256);

Buffer_Data_Print(Read);

sys_exit_critical();

sys_ms_sleep(1000);

}

}



void LED_BSP_Init(void)

{

rcu_periph_clock_enable(RCU_GPIOB);

gpio_mode_set(GPIOB,GPIO_MODE_OUTPUT,GPIO_PUPD_NONE,GPIO_PIN_2);

gpio_output_options_set(GPIOB,GPIO_OTYPE_PP,GPIO_OSPEED_MAX,GPIO_PIN_2);