SXDT-Embedded
/
JT-DT-YD4N02B_4G_RTT_MRS
mirror of https://gitee.com/SXDT-Embedded/JT-DT-YD4N02B_4G_RTT_MRS.git
6
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

优化了连接方式

This commit is contained in:
小马_666 2024-12-31 17:48:22 +08:00
parent 44bc96b250
commit fdcbda42b7
9 changed files with 214 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.template
View File

@ -4,8 +4,8 @@ Series=CH32V307
RTOS=NoneOS RTOS=NoneOS
MCU=CH32V307RVT6 MCU=CH32V307RVT6
Link=WCH-Link Link=WCH-Link
PeripheralVersion==========1.4 PeripheralVersion============1.4
Description==========ROM(byte): 256K, SRAM(byte): 64K, CHIP PINS: 64, GPIO PORTS: 51.\nWCH CH32V3 series of mainstream MCUs covers the needs of a large variety of applications in the industrial,medical and consumer markets. High performance with first-class peripherals and low-power,low-voltage operation is paired with a high level of integration at accessible prices with a simple architecture and easy-to-use tools. Description============ROM(byte): 256K, SRAM(byte): 64K, CHIP PINS: 64, GPIO PORTS: 51.\nWCH CH32V3 series of mainstream MCUs covers the needs of a large variety of applications in the industrial,medical and consumer markets. High performance with first-class peripherals and low-power,low-voltage operation is paired with a high level of integration at accessible prices with a simple architecture and easy-to-use tools.
Mcu Type=CH32V30x Mcu Type=CH32V30x
Address=0x08000000 Address=0x08000000
Target Path=obj\JT-DT-YD4N02A_RTT_MRS-4G.hex Target Path=obj\JT-DT-YD4N02A_RTT_MRS-4G.hex

20
applications/main.c
View File

@ -2,7 +2,7 @@
* @Author: mbw * @Author: mbw
* @Date: 2024-10-23 17:14:16 * @Date: 2024-10-23 17:14:16
* @LastEditors: mbw && 1600520629@qq.com * @LastEditors: mbw && 1600520629@qq.com
* @LastEditTime: 2024-12-30 10:50:46 * @LastEditTime: 2024-12-31 14:10:16
* @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\applications\main.c * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\applications\main.c
* @Descrt_thread_ * @Descrt_thread_
* *
@ -91,8 +91,8 @@ void Send_Laser_Alarm_Event(AlarmEvent event_type)
if (is_event_initialized == RT_TRUE) if (is_event_initialized == RT_TRUE)
{ {
LOG_I("Send_Laser_Alarm_Event = %d", SysControl.status);
rt_event_send(&alarm_event, Get_Sys_Event_Flag(event_type)); rt_event_send(&alarm_event, Get_Sys_Event_Flag(event_type));
LOG_D("Send_Laser_Alarm_Event = %d", SysControl.status);
} }
else else
{ {
@ -183,7 +183,6 @@ int main(void)
rt_err_t result = RT_EINVAL; rt_err_t result = RT_EINVAL;
rt_uint32_t received_event; rt_uint32_t received_event;
rt_kprintf("JT-DT-YD4N02A Software version: %02X", (uint8_t)Flash_Get_SysCfg(kSwVerId));
BSP_ADC_Init(); BSP_ADC_Init();
BSP_VIN_Detection_Init(); BSP_VIN_Detection_Init();
@ -394,7 +393,7 @@ int main(void)
else if (received_event & Get_Sys_Event_Flag(kPowerDownEvent)) // 掉电 else if (received_event & Get_Sys_Event_Flag(kPowerDownEvent)) // 掉电
{ {
LOG_D("掉电模式"); LOG_D("掉电模式");
H308_PWR_OFF;
SysControl.last_status = SysControl.status; SysControl.last_status = SysControl.status;
SysControl.status = kPowerDownEvent; SysControl.status = kPowerDownEvent;
@ -405,9 +404,8 @@ int main(void)
#if (IOT_MODULE_SWITCH == 1) #if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kPowerDownEvent); Nt26k_Send_Event(kNt26kPowerDownEvent);
#endif #endif
LOG_D("Enter AnalogWatchdog Interrupt"); // 等待30s,要是还没断电就重启
// 等待180s,要是还没断电就重启 for (uint8_t i = 0; i < 20; i++)
for (uint8_t i = 0; i < 30; i++)
{ {
rt_thread_mdelay(1000); rt_thread_mdelay(1000);
LOG_D(" %d s", i); LOG_D(" %d s", i);
@ -439,7 +437,7 @@ int main(void)
{ {
Flash_Write_Record(kRecordSensoEndOfLife); Flash_Write_Record(kRecordSensoEndOfLife);
} }
BEEP_END_OF_LIFE; // BEEP_END_OF_LIFE;
LED_Y_END_OF_LIFE; LED_Y_END_OF_LIFE;
} }
} }
@ -480,4 +478,10 @@ static void SYS_Set_RtcProductTime(int argc, char **argv)
} }
MSH_CMD_EXPORT(SYS_Set_RtcProductTime, "SYS_Set_RtcProductTime"); MSH_CMD_EXPORT(SYS_Set_RtcProductTime, "SYS_Set_RtcProductTime");
static void SYS_SW_Version(void)
{
rt_kprintf("JT-DT-YD4N02A Software version: V%02X\r\n", (uint8_t)Flash_Get_SysCfg(kSwVerId));
}
MSH_CMD_EXPORT(SYS_SW_Version, "软件版本");
#endif #endif

21
applications/user_sys.c
View File

@ -30,6 +30,8 @@
#include "bsp_rng.h" #include "bsp_rng.h"
#include "at_device_nt26k.h" #include "at_device_nt26k.h"
#define K 3 * 1000
volatile rt_uint16_t work_duration = 1; // 工作时长 volatile rt_uint16_t work_duration = 1; // 工作时长
volatile rt_uint8_t device_life_check = 0; volatile rt_uint8_t device_life_check = 0;
volatile rt_uint8_t device_state_flag = 0; // 设备失效标志 volatile rt_uint8_t device_state_flag = 0; // 设备失效标志
@ -225,6 +227,25 @@ int Convert_To_Hex(const struct flash_sever_info *sever_info, uint8_t *hex_array
return RT_EOK; return RT_EOK;
} }
//利用IMEI号进行错峰延时计算
rt_uint32_t IMEI_Delay(void)
{
char imei_str[16];
char randon_char[8] = {0};
rt_uint32_t imei_delay = 0;
unsigned int random_number = 0;
Get_Nb_Imei(imei_str, FLASH_NB_IMEI_LEN);
// 提取 IMEI 的最后 5 位作为种子
rt_strncpy(randon_char, &imei_str[0] + FLASH_NB_IMEI_LEN - 5, 5);
random_number = atoi(randon_char);
imei_delay = (random_number + Get_RandomNumber()) % (K);
// rt_kprintf("IMEI_Delay:%d\r\n", imei_delay);
return (rt_uint32_t)imei_delay;
}
int BSP_SYS_Init(void) int BSP_SYS_Init(void)
{ {
BSP_Flash_Init(); BSP_Flash_Init();

62
applications/user_sys.h
View File

@ -14,12 +14,17 @@
#include "rtdef.h" #include "rtdef.h"
#include "bsp_flash.h" #include "bsp_flash.h"
#define SYS_PREHEAT_TIME_S (10U)
#define SYS_MUTE_TIME_S (uint8_t)(10 * 3)
#define SYS_PREHEAT_TIME_S (10U) #define MAX_EXPIRATION_DAYS (uint16_t)(365 * 10 + 30 * 3)
#define SYS_MUTE_TIME_S (uint8_t)(10 * 3)
#define MAX_EXPIRATION_DAYS (uint16_t)(365 * 10 + 30 * 3)
#define SYS_HW_VERSION 0X10
#define SYS_SW_VERSION 0X13
#define SYS_IOT_UPLOAD_CYCLE_MIN (0X3C00) // 高位在前，低位在后
#define SYS_ALARM_VALVE 0X0A
#define SYS_IOT_URL "8.130.117.149"
#define SYS_IOT_PORT "7137"
typedef enum typedef enum
{ {
kPowerOnEvent, kPowerOnEvent,
@ -37,60 +42,57 @@ typedef enum
kMaxEventcnt, kMaxEventcnt,
} AlarmEvent; } AlarmEvent;
// 定义开关状态枚举类型 // 定义开关状态枚举类型
typedef enum typedef enum
{ {
kStatusOff = 0, // 关闭状态 kStatusOff = 0, // 关闭状态
kStatusOn // 打开状态 kStatusOn // 打开状态
} TeStatus; } TeStatus;
// 定义系统标志位结构体 // 定义系统标志位结构体
typedef struct typedef struct
{ {
TeStatus valve_status; // 阀门状态 TeStatus valve_status; // 阀门状态
TeStatus relay_status; // 继电器状态 TeStatus relay_status; // 继电器状态
} TsDeviceStatus; } TsDeviceStatus;
// 定义系统状态枚举类型 // 定义系统状态枚举类型
typedef enum typedef enum
{ {
kSysToBeCalibStatus = 0, // 系统待校准状态 kSysToBeCalibStatus = 0, // 系统待校准状态
kSysGasCalibStatus, // 气体校准状态 kSysGasCalibStatus, // 气体校准状态
KSysTestStatus, // 测试状态 KSysTestStatus, // 测试状态
kSysSelfCheckingStatus, // 自检状态 kSysSelfCheckingStatus, // 自检状态
kSysPowerUpStatus, // 上电状态 kSysPowerUpStatus, // 上电状态
kSysPowerDownStatus, // 下电状态 kSysPowerDownStatus, // 下电状态
kSysStartupPreheatingStatus, // 启动预热状态 kSysStartupPreheatingStatus, // 启动预热状态
kSysRuningStatus, // 运行中状态 kSysRuningStatus, // 运行中状态
kSysAlarmStatus, // 报警状态 kSysAlarmStatus, // 报警状态
kSysMuteStatus, // 消音状态 kSysMuteStatus, // 消音状态
kSysFaultStatus, // 故障状态 kSysFaultStatus, // 故障状态
kSysSensorEndOfLifeStatus, // 传感器寿命结束状态 kSysSensorEndOfLifeStatus, // 传感器寿命结束状态
kSysRestoreFactoryStatus, // 恢复出厂设置状态 kSysRestoreFactoryStatus, // 恢复出厂设置状态
}TeSysStatus; } TeSysStatus;
// 定义系统控制结构体 // 定义系统控制结构体
typedef struct typedef struct
{ {
AlarmEvent status; // 当前状态 AlarmEvent status; // 当前状态
AlarmEvent last_status; // 上一次状态 AlarmEvent last_status; // 上一次状态
} TsSysControl; } TsSysControl;
extern volatile rt_uint16_t work_duration;//工作天数 extern volatile rt_uint16_t work_duration; // 工作天数
extern volatile rt_uint8_t device_state_flag; extern volatile rt_uint8_t device_state_flag;
extern struct rt_event alarm_event; extern struct rt_event alarm_event;
extern TsSysControl SysControl; extern TsSysControl SysControl;
void Send_Laser_Alarm_Event(AlarmEvent event); void Send_Laser_Alarm_Event(AlarmEvent event);
unsigned short crc1021(const char *data, unsigned int length); unsigned short crc1021(const char *data, unsigned int length);
void HexStrToBytes(const char *hexString, unsigned char *byteArray, size_t byteCount); void HexStrToBytes(const char *hexString, unsigned char *byteArray, size_t byteCount);
void String2Hex(char *hex_arry, char *str); void String2Hex(char *hex_arry, char *str);
@ -99,7 +101,5 @@ int Extract_Value(const char *str, const char *key);
int _Self_Check_Mode(void); int _Self_Check_Mode(void);
int Convert_To_Hex(const struct flash_sever_info *sever_info, uint8_t *hex_array); int Convert_To_Hex(const struct flash_sever_info *sever_info, uint8_t *hex_array);
int BSP_SYS_Init(void); int BSP_SYS_Init(void);
rt_uint32_t IMEI_Delay(void);
#endif //!__USER_SYS_H__ #endif //!__USER_SYS_H__

2
bsp/inc/at_device_nt26k.h
View File

@ -60,7 +60,7 @@ struct at_device_nt26k
int pwr_en_pin; int pwr_en_pin;
int rst_pin; int rst_pin;
int wkp_pin; int pwr_key_pin;
size_t recv_line_num; size_t recv_line_num;
struct at_device device; struct at_device device;

4
bsp/inc/bsp_nt26k.h
View File

@ -13,8 +13,7 @@
#define NT26K_PWR_EN_PIN GET_PIN(B, 3) #define NT26K_PWR_EN_PIN GET_PIN(B, 3)
#define NT26K_RST_PIN GET_PIN(A, 11) #define NT26K_RST_PIN GET_PIN(A, 11)
#define NT26K_WKP_PIN GET_PIN(C, 7) #define NT26K_PWR_KEY_PIN GET_PIN(C, 7)
#define NT26K_SAMPLE_DEIVCE_NAME "nt26k" #define NT26K_SAMPLE_DEIVCE_NAME "nt26k"
@ -203,6 +202,7 @@ struct Nt26k_Ops
extern struct Nt26k_Ops nt26k_ops; extern struct Nt26k_Ops nt26k_ops;
extern rt_sem_t nt26k_recv_sem; extern rt_sem_t nt26k_recv_sem;
extern rt_sem_t nt26k_disconnect_sem;
extern rt_uint8_t nt26k_conncet_tcp_flag; extern rt_uint8_t nt26k_conncet_tcp_flag;
extern rt_uint8_t power_on_send_flag; extern rt_uint8_t power_on_send_flag;
int nt26k_device_register(void); int nt26k_device_register(void);

256
bsp/src/at_device_nt26k.c
View File

@ -2,7 +2,7 @@
* @Author : stark1898y 1658608470@qq.com * @Author : stark1898y 1658608470@qq.com
* @Date : 2024-09-04 13:33:49 * @Date : 2024-09-04 13:33:49
* @LastEditors: mbw && 1600520629@qq.com * @LastEditors: mbw && 1600520629@qq.com
* @LastEditTime: 2024-12-30 17:19:08 * @LastEditTime: 2024-12-31 14:13:51
* @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\src\at_device_nt26k.c * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\src\at_device_nt26k.c
* @Description : * @Description :
* *
@ -46,7 +46,7 @@
#define NT26K_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 2) #define NT26K_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 2)
char data_buf[AT_CLIENT_RECV_BUFF_LEN] = {0}; char data_buf[AT_CLIENT_RECV_BUFF_LEN] = {0};
rt_uint8_t recv_byte_buf[AT_CLIENT_RECV_BUFF_LEN] = {0};
nt26k_sys_info nt26k = {0}; nt26k_sys_info nt26k = {0};
struct rt_completion nt26k_init_complate; struct rt_completion nt26k_init_complate;
@ -54,7 +54,6 @@ volatile rt_uint8_t socket_id = 0;
rt_err_t Nt26k_Reset(struct at_device *device) rt_err_t Nt26k_Reset(struct at_device *device)
{ {
// at_client_send("AT+NRB\r\n", rt_strlen("AT+NRB\r\n"));
LOG_I("NT26K Reset"); LOG_I("NT26K Reset");
rt_pin_mode(NT26K_RST_PIN, PIN_MODE_OUTPUT); rt_pin_mode(NT26K_RST_PIN, PIN_MODE_OUTPUT);
rt_pin_write(NT26K_RST_PIN, PIN_LOW); rt_pin_write(NT26K_RST_PIN, PIN_LOW);
@ -157,56 +156,16 @@ static int nt26k_sleep(struct at_device *device)
static int nt26k_wakeup(struct at_device *device) static int nt26k_wakeup(struct at_device *device)
{ {
at_response_t resp = RT_NULL;
struct at_device_nt26k *nt26k = RT_NULL; struct at_device_nt26k *nt26k = RT_NULL;
nt26k = (struct at_device_nt26k *)device->user_data; nt26k = (struct at_device_nt26k *)device->user_data;
if (!nt26k->power_status) // power off if (nt26k->pwr_key_pin != -1)
{ {
LOG_E("the power is off and the wake-up cannot be performed"); rt_pin_write(nt26k->pwr_key_pin, PIN_LOW);
return (-RT_ERROR);
}
if (!nt26k->sleep_status) // no sleep status
{
return (RT_EOK);
}
resp = at_create_resp(64, 0, rt_tick_from_millisecond(300));
if (resp == RT_NULL)
{
LOG_D("no memory for resp create.");
at_delete_resp(resp);
return (-RT_ERROR);
}
if (nt26k->wkp_pin != -1)
{
rt_pin_write(nt26k->wkp_pin, PIN_LOW);
rt_thread_mdelay(100); rt_thread_mdelay(100);
rt_pin_write(nt26k->wkp_pin, PIN_HIGH); rt_pin_write(nt26k->pwr_key_pin, PIN_HIGH);
rt_thread_mdelay(100); nt26k->sleep_status = RT_TRUE;
rt_pin_write(nt26k->wkp_pin, PIN_LOW);
} }
/* disable sleep mode */
if (at_obj_exec_cmd(device->client, resp, "AT+ECPMUCFG=1,0") != RT_EOK)
{
LOG_D("wake up fail. \"AT+ECPMUCFG=1,0\" execute fail.");
at_delete_resp(resp);
return (-RT_ERROR);
}
/* disable PSM mode */
if (at_obj_exec_cmd(device->client, resp, "AT+CPSMS=0") != RT_EOK)
{
LOG_D("wake up fail.\"AT+CPSMS=0\" execute fail.");
at_delete_resp(resp);
return (-RT_ERROR);
}
nt26k->sleep_status = RT_FALSE;
at_delete_resp(resp);
return (RT_EOK); return (RT_EOK);
} }
@ -216,6 +175,7 @@ static void urc_tcp_recv(struct at_client *client, const char *data, rt_size_t s
rt_uint16_t crc16 = 0; rt_uint16_t crc16 = 0;
rt_uint16_t rec_crc16 = 0; rt_uint16_t rec_crc16 = 0;
char crc16_buf[6] = {0}; char crc16_buf[6] = {0};
rt_uint8_t recv_byte_buf[AT_CLIENT_RECV_BUFF_LEN] = {0};
rt_memset(data_buf, 0, sizeof(data_buf)); rt_memset(data_buf, 0, sizeof(data_buf));
@ -239,8 +199,10 @@ static void urc_tcp_recv(struct at_client *client, const char *data, rt_size_t s
{ {
rt_memset(nt26k_ops.recv, 0, sizeof(struct Nt26kRecvData)); // 清空结构体 rt_memset(nt26k_ops.recv, 0, sizeof(struct Nt26kRecvData)); // 清空结构体
rt_memcpy(nt26k_ops.recv, recv_byte_buf, sizeof(struct Nt26kRecvData)); rt_memcpy(nt26k_ops.recv, recv_byte_buf, sizeof(struct Nt26kRecvData));
rt_sem_release(nt26k_recv_sem); if (nt26k_ops.recv->recv_data.event_type != INSTRUCTION_HEART_BEAT)//加这个的原因就是如果有指令下发，会出现两个信号量，指令会执行两次，所以排除心跳包才释放信号量
rt_memset(recv_byte_buf, 0, sizeof(recv_byte_buf)); {
rt_sem_release(nt26k_recv_sem);
}
} }
else else
{ {
@ -248,24 +210,27 @@ static void urc_tcp_recv(struct at_client *client, const char *data, rt_size_t s
} }
} }
} }
rt_memset(recv_byte_buf, 0, sizeof(recv_byte_buf));
} }
static void urc_device_reset(struct at_client *client, const char *data, rt_size_t size) static void urc_device_reset(struct at_client *client, const char *data, rt_size_t size)
{ {
LOG_D("device reset"); LOG_D("device reset");
nt26k_conncet_tcp_flag = 0; nt26k_conncet_tcp_flag = 0;
rt_sem_release(nt26k_disconnect_sem);
} }
static void urc_tcp_disconnect(struct at_client *client, const char *data, rt_size_t size) static void urc_tcp_disconnect(struct at_client *client, const char *data, rt_size_t size)
{ {
size_t err_code = 0, id; size_t id;
if (sscanf(data, "+NSOCLI:%d,%d", &id, &err_code) == 2) if (sscanf(data, "+QIURC: \"closed\",%d", &id) == 1)
{ {
if ((id == socket_id) && (err_code == 107)) // 107错误一般是服务器没加这个IMEI if (id == socket_id)
{ {
LOG_W("socket %d disconnect, error code: %d", id, err_code); LOG_W("socket %d disconnect", id);
nt26k_conncet_tcp_flag = 0; nt26k_conncet_tcp_flag = 0;
rt_sem_release(nt26k_disconnect_sem);
} }
} }
} }
@ -274,7 +239,7 @@ static const struct at_urc urc_table[] = {
{"+QIURC: \"recv\"", "\r\n", urc_tcp_recv}, {"+QIURC: \"recv\"", "\r\n", urc_tcp_recv},
{"boot.rom", "\r\n", urc_device_reset}, // 这个是软件复位时， {"boot.rom", "\r\n", urc_device_reset}, // 这个是软件复位时，
{"Lierda", "\r\n", urc_device_reset}, // 这个时硬件复位时回复 {"Lierda", "\r\n", urc_device_reset}, // 这个时硬件复位时回复
{"+NSOCLI:", "\r\n", urc_tcp_disconnect}, // 这个时硬件复位时回复 {"+QIURC: \"closed\"", "\r\n", urc_tcp_disconnect}, // tcp连接断开
}; };
void show_resp_info(at_response_t resp) void show_resp_info(at_response_t resp)
{ {
@ -311,48 +276,12 @@ int at_device_nt26k_disconnect_tcp(struct at_device *device)
return -RT_ERROR; return -RT_ERROR;
} }
nt26k_conncet_tcp_flag = 0; nt26k_conncet_tcp_flag = 0;
rt_sem_release(nt26k_disconnect_sem);
at_delete_resp(resp); at_delete_resp(resp);
} }
return RT_EOK; return RT_EOK;
} }
#if 0
int at_device_nt26k_socket_creat(struct at_device *device)
{
at_response_t resp = at_create_resp(AT_CLIENT_RECV_BUFF_LEN, 4, AT_DEFAULT_TIMEOUT);
rt_uint8_t retry = (rt_uint8_t)Flash_Get_SysCfg(kNbRetryId);
if (resp == RT_NULL)
{
LOG_E("No memory for response structure!");
at_delete_resp(resp);
return -RT_ENOMEM;
}
while (retry--)
{
if (at_obj_exec_cmd(device->client, resp, TCP_SOCKET_CREAT) == RT_EOK)
{
if (at_resp_parse_line_args_by_kw(resp, "+SKTCREATE:", "+SKTCREATE:%d", &socket_id) > 0)
{
if (socket_id >= 0)
{
LOG_I("nt26k create tcp socket success. socket id: %d", socket_id);
at_delete_resp(resp);
return RT_EOK;
}
}
else
{
at_device_nt26k_disconnect_tcp(device);//这里失败的原因有两种，一种是没有ID返回，一种是返回比较慢，导致错误出现
LOG_E("nt26k create tcp socket failed. retry %d", retry);
}
}
rt_thread_mdelay(5000);
}
at_delete_resp(resp);
return RT_ERROR;
}
#endif
static int at_device_nt26k_connect_tcp(struct at_device *device) static int at_device_nt26k_connect_tcp(struct at_device *device)
{ {
int err_code = 0; int err_code = 0;
@ -360,7 +289,7 @@ static int at_device_nt26k_connect_tcp(struct at_device *device)
return RT_EOK; return RT_EOK;
ASSERT(device); ASSERT(device);
rt_uint8_t retry = (rt_uint8_t)Flash_Get_SysCfg(kNbRetryId); rt_uint8_t retry = (rt_uint8_t)Flash_Get_SysCfg(kNbRetryId);
at_response_t resp = at_create_resp(64, 0, AT_DEFAULT_TIMEOUT); at_response_t resp = at_create_resp(64, 4, AT_DEFAULT_TIMEOUT);
if (resp == RT_NULL) if (resp == RT_NULL)
{ {
LOG_E("No memory for response structure!"); LOG_E("No memory for response structure!");
@ -373,13 +302,11 @@ static int at_device_nt26k_connect_tcp(struct at_device *device)
at_delete_resp(resp); at_delete_resp(resp);
return RT_ERROR; return RT_ERROR;
} }
at_delete_resp(resp);
resp = at_create_resp(32, 4, AT_DEFAULT_TIMEOUT);
for (size_t i = 0; i < retry; i++) for (size_t i = 0; i < retry; i++)
{ {
if (at_obj_exec_cmd(device->client, resp, TCP_CONNECT_CMD, sever_info.server_url, sever_info.server_port) == RT_EOK) if (at_obj_exec_cmd(device->client, resp, TCP_CONNECT_CMD, sever_info.server_url, sever_info.server_port) == RT_EOK)
{ {
if (at_resp_parse_line_args_by_kw(resp, "+QIOPEN:", "+QIOPEN:%d,%d", socket_id, err_code) > 0) if (at_resp_parse_line_args_by_kw(resp, "+QIOPEN:", "+QIOPEN:%d,%d", &socket_id, &err_code) > 0)
{ {
if (err_code == 0) if (err_code == 0)
{ {
@ -390,18 +317,14 @@ static int at_device_nt26k_connect_tcp(struct at_device *device)
} }
else else
{ {
at_device_nt26k_disconnect_tcp(device);
LOG_E("nt26k connect to tcp server failed. error code: %d",err_code); LOG_E("nt26k connect to tcp server failed. error code: %d",err_code);
} }
} }
else
{
nt26k_conncet_tcp_flag = 0;
LOG_E("nt26k connect to tcp server failed.");
}
} }
rt_thread_mdelay(5000); rt_thread_mdelay(5000);
} }
at_device_nt26k_disconnect_tcp(device);
rt_sem_release(nt26k_disconnect_sem);
at_delete_resp(resp); at_delete_resp(resp);
return RT_ERROR; return RT_ERROR;
} }
@ -410,7 +333,6 @@ int at_send_data(struct at_device *device, const char *data, rt_size_t size)
{ {
#define NT26K_SEND_RESP_TIME (3000) #define NT26K_SEND_RESP_TIME (3000)
const char *line_buffer = RT_NULL; const char *line_buffer = RT_NULL;
int len = 0;
rt_uint8_t retry = 0; rt_uint8_t retry = 0;
at_response_t resp = at_create_resp(AT_CLIENT_RECV_BUFF_LEN / 4, 2, NT26K_SEND_RESP_TIME); at_response_t resp = at_create_resp(AT_CLIENT_RECV_BUFF_LEN / 4, 2, NT26K_SEND_RESP_TIME);
rt_uint8_t max_retry_count = (rt_uint8_t)Flash_Get_SysCfg(kNbRetryId); rt_uint8_t max_retry_count = (rt_uint8_t)Flash_Get_SysCfg(kNbRetryId);
@ -423,7 +345,7 @@ int at_send_data(struct at_device *device, const char *data, rt_size_t size)
while (retry < max_retry_count) while (retry < max_retry_count)
{ {
rt_thread_mdelay(Get_RandomNumber());//获取一个随机延时 rt_thread_mdelay(IMEI_Delay());//获取一个随机延时
if (at_obj_exec_cmd(device->client, resp, TCP_SEND_DATA, socket_id, data) == RT_EOK) if (at_obj_exec_cmd(device->client, resp, TCP_SEND_DATA, socket_id, data) == RT_EOK)
{ {
if ((line_buffer = at_resp_get_line(resp, 2)) != RT_NULL) if ((line_buffer = at_resp_get_line(resp, 2)) != RT_NULL)
@ -444,7 +366,7 @@ int at_send_data(struct at_device *device, const char *data, rt_size_t size)
return -RT_ERROR; return -RT_ERROR;
} }
static int nt26k_check_link_status(struct at_device *device) int nt26k_check_link_status(struct at_device *device)
{ {
at_response_t resp = RT_NULL; at_response_t resp = RT_NULL;
struct at_device_nt26k *nt26k = RT_NULL; struct at_device_nt26k *nt26k = RT_NULL;
@ -458,14 +380,14 @@ static int nt26k_check_link_status(struct at_device *device)
} }
if (nt26k->sleep_status) // is sleep status if (nt26k->sleep_status) // is sleep status
{ {
if (nt26k->wkp_pin != -1) if (nt26k->pwr_key_pin != -1)
{ {
rt_pin_write(nt26k->wkp_pin, PIN_LOW); rt_pin_write(nt26k->pwr_key_pin, PIN_LOW);
rt_thread_mdelay(100); rt_thread_mdelay(100);
rt_pin_write(nt26k->wkp_pin, PIN_HIGH); rt_pin_write(nt26k->pwr_key_pin, PIN_HIGH);
rt_thread_mdelay(100); rt_thread_mdelay(100);
rt_pin_write(nt26k->wkp_pin, PIN_LOW); rt_pin_write(nt26k->pwr_key_pin, PIN_LOW);
} }
} }
@ -505,7 +427,7 @@ static int nt26k_check_link_status(struct at_device *device)
/* ============================= nt26k network interface operations ============================= */ /* ============================= nt26k network interface operations ============================= */
/* set nt26k network interface device status and address information */ /* set nt26k network interface device status and address information */
static int nt26k_netdev_set_info(struct netdev *netdev) int nt26k_netdev_set_info(struct netdev *netdev)
{ {
#define NT26K_INFO_RESP_SIZE 128 #define NT26K_INFO_RESP_SIZE 128
#define NT26K_INFO_RESP_TIMO rt_tick_from_millisecond(1000) #define NT26K_INFO_RESP_TIMO rt_tick_from_millisecond(1000)
@ -617,7 +539,7 @@ static void nt26k_check_link_status_entry(void *parameter)
} }
} }
static int nt26k_netdev_check_link_status(struct netdev *netdev) int nt26k_netdev_check_link_status(struct netdev *netdev)
{ {
#define NT26K_LINK_THREAD_TICK 20 #define NT26K_LINK_THREAD_TICK 20
#define NT26K_LINK_THREAD_STACK_SIZE (1024 + 512) #define NT26K_LINK_THREAD_STACK_SIZE (1024 + 512)
@ -947,6 +869,18 @@ static void nt26k_init_thread_entry(void *parameter)
result = -RT_ERROR; result = -RT_ERROR;
goto __exit; goto __exit;
} }
/*设置保活信息*/
if ( at_obj_exec_cmd(device->client, resp, "AT+QICFG=\"tcp/keepalive\",1,1800,100,3") != RT_EOK)
{
result = -RT_ERROR;
goto __exit;
}
/*设置保活信息*/
if ( at_obj_exec_cmd(device->client, resp, "AT+QICFG=\"passiveclosed\",1") != RT_EOK)
{
result = -RT_ERROR;
goto __exit;
}
/* get module version */ /* get module version */
if (at_obj_exec_cmd(device->client, resp, "AT+CGMR") != RT_EOK) if (at_obj_exec_cmd(device->client, resp, "AT+CGMR") != RT_EOK)
{ {
@ -984,13 +918,12 @@ static void nt26k_init_thread_entry(void *parameter)
/* check SIM card */ /* check SIM card */
for (i = 0; i < CPIN_RETRY; i++) for (i = 0; i < CPIN_RETRY; i++)
{ {
if (at_obj_exec_cmd(device->client, resp, "AT+CPIN?") == RT_EOK) if (at_obj_exec_cmd(device->client, resp, "AT+CPIN?") == RT_EOK)
{ {
if (at_resp_get_line_by_kw(resp, "READY") != RT_NULL) if (at_resp_get_line_by_kw(resp, "+CPIN: READY") != RT_NULL)
break; break;
} }
rt_thread_mdelay(1000); rt_thread_mdelay(2000);
} }
if (i == CPIN_RETRY) if (i == CPIN_RETRY)
{ {
@ -1002,7 +935,7 @@ static void nt26k_init_thread_entry(void *parameter)
for (i = 0; i < CSQ_RETRY; i++) for (i = 0; i < CSQ_RETRY; i++)
{ {
if (at_obj_exec_cmd(device->client, resp, "AT+CREG=3") == RT_EOK) if (at_obj_exec_cmd(device->client, resp, "AT+CREG=2") == RT_EOK)
{ {
if (at_resp_get_line_by_kw(resp, "OK") > 0) if (at_resp_get_line_by_kw(resp, "OK") > 0)
{ {
@ -1026,12 +959,12 @@ static void nt26k_init_thread_entry(void *parameter)
char iccid[NT26K_ICCID_LEN] = {0}; char iccid[NT26K_ICCID_LEN] = {0};
/* send "AT+ECICCID" commond to get device iccid */ /* send "AT+ECICCID" commond to get device iccid */
if (at_obj_exec_cmd(device->client, resp, "AT+ECICCID") != RT_EOK) if (at_obj_exec_cmd(device->client, resp, "AT+QCCID") != RT_EOK)
{ {
result = -RT_ERROR; result = -RT_ERROR;
goto __exit; goto __exit;
} }
if (at_resp_parse_line_args_by_kw(resp, "+ECICCID:", "+ECICCID:%s", iccid) <= 0) if (at_resp_parse_line_args_by_kw(resp, "+QCCID:", "+QCCID:%s", iccid) <= 0)
{ {
LOG_E("%s device prase \"AT+ECICCID\" cmd error.", device->name); LOG_E("%s device prase \"AT+ECICCID\" cmd error.", device->name);
result = -RT_ERROR; result = -RT_ERROR;
@ -1273,52 +1206,52 @@ rt_err_t Nt26k_Get_Signal_Info(struct at_device *device)
LOG_E("%s device signal data failed", device->name); LOG_E("%s device signal data failed", device->name);
result = -RT_ERROR; result = -RT_ERROR;
} }
/* get signal snr, pci */ // /* get signal snr, pci */
for (int i = 0; i < RETRY; i++) // for (int i = 0; i < RETRY; i++)
{ // {
if (at_obj_exec_cmd(device->client, resp, "AT+NUESTATS") == RT_EOK) // if (at_obj_exec_cmd(device->client, resp, "AT+NUESTATS") == RT_EOK)
{ // {
const char *key1 = "SNR:"; // const char *key1 = "SNR:";
const char *key2 = "PCI:"; // const char *key2 = "PCI:";
int pci = 0, snr = 0; // int pci = 0, snr = 0;
// show_resp_info(resp); // // show_resp_info(resp);
// 获取第 2 行的响应 // // 获取第 2 行的响应
const char *line = at_resp_get_line(resp, 2); // const char *line = at_resp_get_line(resp, 2);
if (line != NULL) // if (line != NULL)
{ // {
snr = Extract_Value(line, key1); // snr = Extract_Value(line, key1);
pci = Extract_Value(line, key2); // pci = Extract_Value(line, key2);
if (snr != 0 && pci != 0) // if (snr != 0 && pci != 0)
{ // {
nt26k.pci = pci; // nt26k.pci = pci;
nt26k.snr = snr; // nt26k.snr = snr;
LOG_D("pci:%d,snr:%d", nt26k.pci, nt26k.snr); // LOG_D("pci:%d,snr:%d", nt26k.pci, nt26k.snr);
break; // break;
} // }
else // else
{ // {
LOG_D("Extracted values are invalid: SNR=%d, PCI=%d", snr, pci); // LOG_D("Extracted values are invalid: SNR=%d, PCI=%d", snr, pci);
} // }
} // }
else // else
{ // {
LOG_D("Failed to get line 2 from response"); // LOG_D("Failed to get line 2 from response");
} // }
} // }
else // else
{ // {
LOG_D("Failed to execute AT command"); // LOG_D("Failed to execute AT command");
} // }
rt_thread_mdelay(2000); // rt_thread_mdelay(2000);
} // }
if (i == RETRY) // if (i == RETRY)
{ // {
LOG_E("%s device signal data failed", device->name); // LOG_E("%s device signal data failed", device->name);
result = -RT_ERROR; // result = -RT_ERROR;
} // }
at_delete_resp(resp); at_delete_resp(resp);
return result; return result;
@ -1376,9 +1309,10 @@ static int nt26k_init(struct at_device *device)
{ {
rt_pin_mode(nt26k->rst_pin, PIN_MODE_OUTPUT); rt_pin_mode(nt26k->rst_pin, PIN_MODE_OUTPUT);
} }
if (nt26k->wkp_pin != -1) if (nt26k->pwr_key_pin != -1)
{ {
rt_pin_mode(nt26k->wkp_pin, PIN_MODE_OUTPUT); rt_pin_mode(nt26k->pwr_key_pin, PIN_MODE_OUTPUT);
device->class->device_ops->control(device, AT_DEVICE_CTRL_WAKEUP, RT_NULL);
} }
/* initialize nt26k device network */ /* initialize nt26k device network */
return nt26k_netdev_set_up(device->netdev); return nt26k_netdev_set_up(device->netdev);

14
bsp/src/bsp_flash.c
View File

@ -80,21 +80,19 @@ const rt_uint32_t hr_sys_cfg_info_len[kCnt] = {
static rt_base_t interrupt_value; static rt_base_t interrupt_value;
/*默认的系统配置*/ /*默认的系统配置*/
rt_uint8_t sys_hw_ver = 0x10; rt_uint8_t sys_hw_ver = SYS_HW_VERSION;
rt_uint8_t sys_sw_ver = 0x12; rt_uint8_t sys_sw_ver = SYS_SW_VERSION;
rt_uint8_t sys_nb_retry = 0x03; // 重试次数3次 rt_uint8_t sys_nb_retry = 0x03; // 重试次数3次
rt_uint16_t sys_nb_upload_cycle = 0x3C00; // 60分钟一次 ,低位在前，高为在后，为了和服务器下发时保持一致，有利于读取 rt_uint16_t sys_nb_upload_cycle = SYS_IOT_UPLOAD_CYCLE_MIN; // 60分钟一次 ,低位在前，高为在后，为了和服务器下发时保持一致，有利于读取
rt_uint8_t sys_alarm_h_value = 0x32; // 50 rt_uint8_t sys_alarm_h_value = 0x32; // 50
rt_uint8_t sys_alarm_l_value = 0x0A; // 10 rt_uint8_t sys_alarm_l_value = SYS_ALARM_VALVE; // 10
rt_uint8_t sys_temp_alarm_threshold = 0x32; rt_uint8_t sys_temp_alarm_threshold = 0x32;
rt_uint8_t sys_emagnetic_switch = 0x04; // 具备阀门功能 rt_uint8_t sys_emagnetic_switch = 0x04; // 具备阀门功能
rt_uint8_t sys_relay_switch = 0x04; // 具备继电器功能 rt_uint8_t sys_relay_switch = 0x04; // 具备继电器功能
struct flash_sever_info sever_info = struct flash_sever_info sever_info =
{ {
.server_url = "8.130.117.149", .server_url = SYS_IOT_URL,
.server_port = "7137", .server_port = SYS_IOT_PORT,
// .server_url = "8.135.10.183",
// .server_port = "36125,"
}; };

83
bsp/src/bsp_nt26k.c
View File

@ -2,7 +2,7 @@
* @Author: mbw * @Author: mbw
* @Date: 2024-10-09 08:42:14 * @Date: 2024-10-09 08:42:14
* @LastEditors: mbw && 1600520629@qq.com * @LastEditors: mbw && 1600520629@qq.com
* @LastEditTime: 2024-12-30 17:33:50 * @LastEditTime: 2024-12-31 11:01:49
* @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\src\bsp_nt26k.c * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\src\bsp_nt26k.c
* @Description: * @Description:
* *
@ -60,12 +60,11 @@ static struct rt_thread nt26k_life_thread;
struct rt_event at_device_event; struct rt_event at_device_event;
rt_sem_t nt26k_recv_sem; rt_sem_t nt26k_recv_sem;
rt_sem_t nt26k_life_sem; rt_sem_t nt26k_disconnect_sem;
static rt_timer_t nt26k_timer; // 上报心跳 static rt_timer_t nt26k_timer; // 上报心跳
static rt_timer_t nt26k_upload_timer; // 更新本地时间定时器 static rt_timer_t nt26k_upload_timer; // 更新本地时间定时器
static rt_timer_t nt26k_power_error_timer; // 上电失败情况下启动定时器 static rt_timer_t nt26k_power_error_timer; // 上电失败情况下启动定时器
/*生命周期窗口定时器，用于管理tcp连接的断开*/
static rt_timer_t nt26k_life_timer;
rt_uint8_t nt26k_conncet_tcp_flag; rt_uint8_t nt26k_conncet_tcp_flag;
Nt26kEventIndex nt26k_event_index; Nt26kEventIndex nt26k_event_index;
@ -99,7 +98,7 @@ static struct at_device_nt26k _dev =
NT26K_PWR_EN_PIN, NT26K_PWR_EN_PIN,
NT26K_RST_PIN, NT26K_RST_PIN,
NT26K_WKP_PIN, NT26K_PWR_KEY_PIN,
NT26K_SAMPLE_RECV_BUFF_LEN, NT26K_SAMPLE_RECV_BUFF_LEN,
}; };
@ -179,11 +178,6 @@ static void Nt26k_Ht_Timer_Cb(void *parameter)
Nt26k_Send_Event(kNt26kHeartbeatEvent); Nt26k_Send_Event(kNt26kHeartbeatEvent);
} }
// 定时器回调函数,当1分钟内没有数据交互时，关闭tcp连接
static void Nt26k_Life_Timer_Cb(void *parameter)
{
rt_sem_release(nt26k_life_sem);
}
// 定时器回调函数,当1分钟内没有数据交互时，关闭tcp连接 // 定时器回调函数,当1分钟内没有数据交互时，关闭tcp连接
static void Nt26k_Error_Timer_Cb(void *parameter) static void Nt26k_Error_Timer_Cb(void *parameter)
@ -198,16 +192,6 @@ static void Nt26k_Error_Timer_Cb(void *parameter)
} }
} }
// 重置定时器
void Reset_Nt26k_Life_Timer(void)
{
if (nt26k_life_timer != RT_NULL)
{
// rt_timer_stop(nt26k_life_timer);//启动这个时，他会自动清除以前的定时器，所以不必担心是否已经启动的问题，困扰我不少时间，点进去第一二句就是
rt_timer_start(nt26k_life_timer);
}
}
int _Pack_Send(struct Nt26k_Ops *ops, char *buf) int _Pack_Send(struct Nt26k_Ops *ops, char *buf)
{ {
char nt26k_send_buf[512] = {0}; // 发送缓冲区，用于存储最终发送的数据 char nt26k_send_buf[512] = {0}; // 发送缓冲区，用于存储最终发送的数据
@ -807,7 +791,6 @@ int Nt26k_Process_Events(Nt26kEvent nt26k_recv_event, struct at_device *device,
if (device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_CONN, RT_NULL) == RT_EOK) // 打开连接 if (device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_CONN, RT_NULL) == RT_EOK) // 打开连接
{ {
LOG_D("nt26k connect tcp success\n"); LOG_D("nt26k connect tcp success\n");
Reset_Nt26k_Life_Timer();
// 重启后重新尝试发送 // 重启后重新尝试发送
result = event->send_func(device, nt26k_ops); result = event->send_func(device, nt26k_ops);
if (result != RT_EOK) if (result != RT_EOK)
@ -927,12 +910,7 @@ void Handle_Close_Valve(struct Nt26k_Ops *ops)
Get_Nb_Imei(imei, FLASH_NB_IMEI_LEN); Get_Nb_Imei(imei, FLASH_NB_IMEI_LEN);
char temp[32] = "0"; char temp[32] = "0";
String2Hex(temp, imei); // 将字符串转为十六进制字符串 String2Hex(temp, imei); // 将字符串转为十六进制字符串
// emv_state_flag = 1;
// rt_thread_mdelay(20);
// emv_state_flag = 0;
EMV_CLOSE_VALVE; EMV_CLOSE_VALVE;
// rt_uint8_t ret = BSP_Set_Emv_Status(0);
ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_CLOSE_VALVE, temp, RESPONSE_CODE_SUCCESS); ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_CLOSE_VALVE, temp, RESPONSE_CODE_SUCCESS);
} }
@ -1213,7 +1191,6 @@ void Handle_Cmd_Type(struct Nt26k_Ops *ops)
void Analyze_Recv_Frame(struct at_device *device, struct Nt26k_Ops *ops) void Analyze_Recv_Frame(struct at_device *device, struct Nt26k_Ops *ops)
{ {
rt_err_t ret = RT_EOK; rt_err_t ret = RT_EOK;
Reset_Nt26k_Life_Timer(); // 只要数据，则重置定时器，不管数据是否正确
ret = Compare_HeaderToTail(ops); ret = Compare_HeaderToTail(ops);
if (ret == RT_EOK) if (ret == RT_EOK)
@ -1282,7 +1259,6 @@ static void Nt26k_Send_Thread_Entry(void *param)
if (device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_CONN, RT_NULL) == RT_EOK) // 打开连接 if (device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_CONN, RT_NULL) == RT_EOK) // 打开连接
{ {
LOG_D("nt26k connect tcp success\n"); LOG_D("nt26k connect tcp success\n");
rt_timer_start(nt26k_life_timer);
} }
else else
{ {
@ -1291,7 +1267,6 @@ static void Nt26k_Send_Thread_Entry(void *param)
} }
if (nt26k_conncet_tcp_flag) if (nt26k_conncet_tcp_flag)
{ {
Reset_Nt26k_Life_Timer();
if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kPowerOnEvent)) if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kPowerOnEvent))
{ {
result = Nt26k_Process_Events(kNt26kPowerOnEvent, device, ops); // 当上电心跳包发送不成功时，其他事件不启动 result = Nt26k_Process_Events(kNt26kPowerOnEvent, device, ops); // 当上电心跳包发送不成功时，其他事件不启动
@ -1436,19 +1411,14 @@ static void Nt26k_Recv_Thread_Entry(void *parameter)
struct at_device_nt26k *nt26k = &_dev; struct at_device_nt26k *nt26k = &_dev;
struct at_device *device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, nt26k->device_name); struct at_device *device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, nt26k->device_name);
RT_ASSERT(device); RT_ASSERT(device);
rt_err_t ret;
LOG_D("nt26k recv thread entry\n"); LOG_D("nt26k recv thread entry\n");
while (1) while (1)
{ {
ret = rt_sem_take(nt26k_recv_sem, RT_WAITING_FOREVER); // 这个主要用来处理的数据 rt_sem_take(nt26k_recv_sem, RT_WAITING_FOREVER); // 这个主要用来处理的数据
if (ret == RT_EOK) /*对数据帧进行分析，判断所处的是对服务器响应还是指令下发*/
{ Analyze_Recv_Frame(device, ops);
rt_timer_start(nt26k_life_timer);
/*对数据帧进行分析，判断所处的是对服务器响应还是指令下发*/
Analyze_Recv_Frame(device, ops);
}
} }
} }
@ -1464,13 +1434,24 @@ static void Nt26k_Life_Thread_Entry(void *parameter)
while (1) while (1)
{ {
ret = rt_sem_take(nt26k_life_sem, RT_WAITING_FOREVER); ret = rt_sem_take(nt26k_disconnect_sem, RT_WAITING_FOREVER);
if (ret == RT_EOK) if (ret == RT_EOK)
{ {
if (nt26k_conncet_tcp_flag) if (!nt26k_conncet_tcp_flag)
{ {
device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_DISCONN, RT_NULL); LOG_D("重连网络中...\n");
LOG_D("close nt26k tcp connect\n "); device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_DISCONN, RT_NULL);//先关闭，再处理
if(device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_CONN, RT_NULL) == RT_EOK)
{
LOG_D("重连网络成功\n");
nt26k_conncet_tcp_flag = RT_TRUE;
}
else
{
LOG_D("重连网络失败\n");
rt_thread_mdelay(10000);
rt_sem_release(nt26k_disconnect_sem);
}
} }
} }
} }
@ -1490,21 +1471,21 @@ int BSP_Nt26k_Thread_Init(void)
rt_uint32_t nb_upload_time = (uint16_t)Flash_Get_SysCfg(kNbUploadCycleId); rt_uint32_t nb_upload_time = (uint16_t)Flash_Get_SysCfg(kNbUploadCycleId);
unsigned long timeout = nb_upload_time * 60 * RT_TICK_PER_SECOND; unsigned long timeout = nb_upload_time * 60 * RT_TICK_PER_SECOND;
LOG_I("上报服务器周期：%d分钟", nb_upload_time); LOG_I("上报服务器周期：%d分钟", nb_upload_time);
nt26k_mutex = rt_mutex_create("nt26k_mutex", RT_IPC_FLAG_FIFO); nt26k_mutex = rt_mutex_create("nt26k_mutex", RT_IPC_FLAG_PRIO);
if (nt26k_mutex == RT_NULL) if (nt26k_mutex == RT_NULL)
{ {
LOG_E("nt26k_mutex create failed"); LOG_E("nt26k_mutex create failed");
} }
nt26k_recv_sem = rt_sem_create("nt26k_recv", 0, RT_IPC_FLAG_FIFO); nt26k_recv_sem = rt_sem_create("nt26k_recv", 0, RT_IPC_FLAG_PRIO);
if (nt26k_recv_sem == RT_NULL) if (nt26k_recv_sem == RT_NULL)
{ {
LOG_E("nt26k_recv_sem create failed"); LOG_E("nt26k_recv_sem create failed");
} }
nt26k_life_sem = rt_sem_create("nt26k_life", 0, RT_IPC_FLAG_FIFO); nt26k_disconnect_sem = rt_sem_create("nt26k_life", 0, RT_IPC_FLAG_PRIO);
if (nt26k_life_sem == RT_NULL) if (nt26k_disconnect_sem == RT_NULL)
{ {
LOG_E("nt26k_life_sem create failed"); LOG_E("nt26k_disconnect_sem create failed");
} }
// 创建定时器 // 创建定时器
nt26k_timer = rt_timer_create("heartbeat", nt26k_timer = rt_timer_create("heartbeat",
@ -1518,16 +1499,6 @@ int BSP_Nt26k_Thread_Init(void)
rt_kprintf("创建定时器失败\n"); rt_kprintf("创建定时器失败\n");
return -1; return -1;
} }
nt26k_life_timer = rt_timer_create("nt26k_life",
Nt26k_Life_Timer_Cb,
RT_NULL,
30 * RT_TICK_PER_SECOND,
RT_TIMER_FLAG_ONE_SHOT);
if (nt26k_life_timer == RT_NULL)
{
rt_kprintf("创建定时器失败\n");
return -1;
}
nt26k_power_error_timer = rt_timer_create("nt26k_error_timer", nt26k_power_error_timer = rt_timer_create("nt26k_error_timer",
Nt26k_Error_Timer_Cb, Nt26k_Error_Timer_Cb,
RT_NULL, RT_NULL,