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
MCU=CH32V307RVT6
Link=WCH-Link
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.
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.
Mcu Type=CH32V30x
Address=0x08000000
Target Path=obj\JT-DT-YD4N02A_RTT_MRS-4G.hex

20
applications/main.c
View File

@ -2,7 +2,7 @@
* @Author: mbw
* @Date: 2024-10-23 17:14:16
* @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
* @Descrt_thread_
*
@ -91,8 +91,8 @@ void Send_Laser_Alarm_Event(AlarmEvent event_type)
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));
LOG_D("Send_Laser_Alarm_Event = %d", SysControl.status);
}
else
{
@ -183,7 +183,6 @@ int main(void)
rt_err_t result = RT_EINVAL;
rt_uint32_t received_event;
rt_kprintf("JT-DT-YD4N02A Software version: %02X", (uint8_t)Flash_Get_SysCfg(kSwVerId));
BSP_ADC_Init();
BSP_VIN_Detection_Init();
@ -394,7 +393,7 @@ int main(void)
else if (received_event & Get_Sys_Event_Flag(kPowerDownEvent)) // 掉电
{
LOG_D("掉电模式");
H308_PWR_OFF;
SysControl.last_status = SysControl.status;
SysControl.status = kPowerDownEvent;
@ -405,9 +404,8 @@ int main(void)
#if (IOT_MODULE_SWITCH == 1)
Nt26k_Send_Event(kNt26kPowerDownEvent);
#endif
LOG_D("Enter AnalogWatchdog Interrupt");
// 等待180s,要是还没断电就重启
for (uint8_t i = 0; i < 30; i++)
// 等待30s,要是还没断电就重启
for (uint8_t i = 0; i < 20; i++)
{
rt_thread_mdelay(1000);
LOG_D(" %d s", i);
@ -439,7 +437,7 @@ int main(void)
{
Flash_Write_Record(kRecordSensoEndOfLife);
}
BEEP_END_OF_LIFE;
// BEEP_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");
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

21
applications/user_sys.c
View File

@ -30,6 +30,8 @@
#include "bsp_rng.h"
#include "at_device_nt26k.h"
#define K 3 * 1000
volatile rt_uint16_t work_duration = 1; // 工作时长
volatile rt_uint8_t device_life_check = 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;
}
//利用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)
{
BSP_Flash_Init();

94
applications/user_sys.h
View File

@ -1,12 +1,12 @@
/***
/***
* @Author: mbw
* @Date: 2024-10-09 08:42:14
* @LastEditors: mbw && 1600520629@qq.com
* @LastEditTime: 2024-11-12 14:19:50
* @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\applications\user_sys.h
* @Description:
* @Description:
* @
* @Copyright (c) 2024 by ${git_name_email}, All Rights Reserved.
* @Copyright (c) 2024 by ${git_name_email}, All Rights Reserved.
*/
#ifndef __USER_SYS_H__
#define __USER_SYS_H__
@ -14,82 +14,84 @@
#include "rtdef.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 SYS_MUTE_TIME_S (uint8_t)(10 * 3)
#define MAX_EXPIRATION_DAYS (uint16_t)(365 * 10 + 30 * 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
{
kPowerOnEvent,
kPreheatingEvent,
kPowerOnEvent,
kPreheatingEvent,
kNormalDetectionEvents,
kAlarmEvent,
kAlarmRcyEvent,
kFaultEvent,
kFaultRcyEvent,
kSensorFailureEvent,
kPowerDownEvent,
kSelfCheckEvent,
KMuteEvent,
kAlarmEvent,
kAlarmRcyEvent,
kFaultEvent,
kFaultRcyEvent,
kSensorFailureEvent,
kPowerDownEvent,
kSelfCheckEvent,
KMuteEvent,
kAlarmExceptionEvent, // alarm_exception
kMaxEventcnt,
} AlarmEvent;
kMaxEventcnt,
} AlarmEvent;
// 定义开关状态枚举类型
typedef enum
{
kStatusOff = 0, // 关闭状态
kStatusOn // 打开状态
kStatusOff = 0, // 关闭状态
kStatusOn // 打开状态
} TeStatus;
// 定义系统标志位结构体
typedef struct
{
TeStatus valve_status; // 阀门状态
TeStatus relay_status; // 继电器状态
TeStatus valve_status; // 阀门状态
TeStatus relay_status; // 继电器状态
} TsDeviceStatus;
// 定义系统状态枚举类型
typedef enum
{
kSysToBeCalibStatus = 0, // 系统待校准状态
kSysGasCalibStatus, // 气体校准状态
KSysTestStatus, // 测试状态
kSysToBeCalibStatus = 0, // 系统待校准状态
kSysGasCalibStatus, // 气体校准状态
KSysTestStatus, // 测试状态
kSysSelfCheckingStatus, // 自检状态
kSysSelfCheckingStatus, // 自检状态
kSysPowerUpStatus, // 上电状态
kSysPowerDownStatus, // 下电状态
kSysPowerUpStatus, // 上电状态
kSysPowerDownStatus, // 下电状态
kSysStartupPreheatingStatus, // 启动预热状态
kSysRuningStatus, // 运行中状态
kSysStartupPreheatingStatus, // 启动预热状态
kSysRuningStatus, // 运行中状态
kSysAlarmStatus, // 报警状态
kSysMuteStatus, // 消音状态
kSysAlarmStatus, // 报警状态
kSysMuteStatus, // 消音状态
kSysFaultStatus, // 故障状态
kSysSensorEndOfLifeStatus, // 传感器寿命结束状态
kSysFaultStatus, // 故障状态
kSysSensorEndOfLifeStatus, // 传感器寿命结束状态
kSysRestoreFactoryStatus, // 恢复出厂设置状态
}TeSysStatus;
kSysRestoreFactoryStatus, // 恢复出厂设置状态
} TeSysStatus;
// 定义系统控制结构体
typedef struct
{
AlarmEvent status; // 当前状态
AlarmEvent last_status; // 上一次状态
AlarmEvent status; // 当前状态
AlarmEvent last_status; // 上一次状态
} TsSysControl;
extern volatile rt_uint16_t work_duration;//工作天数
extern volatile rt_uint16_t work_duration; // 工作天数
extern volatile rt_uint8_t device_state_flag;
extern struct rt_event alarm_event;
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);
void HexStrToBytes(const char *hexString, unsigned char *byteArray, size_t byteCount);
@ -99,7 +101,5 @@ int Extract_Value(const char *str, const char *key);
int _Self_Check_Mode(void);
int Convert_To_Hex(const struct flash_sever_info *sever_info, uint8_t *hex_array);
int BSP_SYS_Init(void);
rt_uint32_t IMEI_Delay(void);
#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 rst_pin;
int wkp_pin;
int pwr_key_pin;
size_t recv_line_num;
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_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"
@ -203,6 +202,7 @@ struct Nt26k_Ops
extern struct Nt26k_Ops nt26k_ops;
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 power_on_send_flag;
int nt26k_device_register(void);

258
bsp/src/at_device_nt26k.c
View File

@ -2,7 +2,7 @@
* @Author : stark1898y 1658608470@qq.com
* @Date : 2024-09-04 13:33:49
* @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
* @Description :
*
@ -46,7 +46,7 @@
#define NT26K_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 2)
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};
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)
{
// at_client_send("AT+NRB\r\n", rt_strlen("AT+NRB\r\n"));
LOG_I("NT26K Reset");
rt_pin_mode(NT26K_RST_PIN, PIN_MODE_OUTPUT);
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)
{
at_response_t resp = RT_NULL;
struct at_device_nt26k *nt26k = RT_NULL;
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");
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_pin_write(nt26k->pwr_key_pin, PIN_LOW);
rt_thread_mdelay(100);
rt_pin_write(nt26k->wkp_pin, PIN_HIGH);
rt_thread_mdelay(100);
rt_pin_write(nt26k->wkp_pin, PIN_LOW);
rt_pin_write(nt26k->pwr_key_pin, PIN_HIGH);
nt26k->sleep_status = RT_TRUE;
}
/* 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);
}
@ -216,7 +175,8 @@ static void urc_tcp_recv(struct at_client *client, const char *data, rt_size_t s
rt_uint16_t crc16 = 0;
rt_uint16_t rec_crc16 = 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));
if (sscanf(data, "+QIURC: \"recv\",%*d,%d,%s", &len, data_buf) == 2)
@ -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_memcpy(nt26k_ops.recv, recv_byte_buf, sizeof(struct Nt26kRecvData));
rt_sem_release(nt26k_recv_sem);
rt_memset(recv_byte_buf, 0, sizeof(recv_byte_buf));
if (nt26k_ops.recv->recv_data.event_type != INSTRUCTION_HEART_BEAT)//加这个的原因就是如果有指令下发，会出现两个信号量，指令会执行两次，所以排除心跳包才释放信号量
{
rt_sem_release(nt26k_recv_sem);
}
}
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)
{
LOG_D("device reset");
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)
{
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;
rt_sem_release(nt26k_disconnect_sem);
}
}
}
@ -274,7 +239,7 @@ static const struct at_urc urc_table[] = {
{"+QIURC: \"recv\"", "\r\n", urc_tcp_recv},
{"boot.rom", "\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)
{
@ -311,48 +276,12 @@ int at_device_nt26k_disconnect_tcp(struct at_device *device)
return -RT_ERROR;
}
nt26k_conncet_tcp_flag = 0;
rt_sem_release(nt26k_disconnect_sem);
at_delete_resp(resp);
}
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)
{
int err_code = 0;
@ -360,7 +289,7 @@ static int at_device_nt26k_connect_tcp(struct at_device *device)
return RT_EOK;
ASSERT(device);
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)
{
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);
return RT_ERROR;
}
at_delete_resp(resp);
resp = at_create_resp(32, 4, AT_DEFAULT_TIMEOUT);
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_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)
{
@ -390,18 +317,14 @@ static int at_device_nt26k_connect_tcp(struct at_device *device)
}
else
{
at_device_nt26k_disconnect_tcp(device);
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);
}
at_device_nt26k_disconnect_tcp(device);
rt_sem_release(nt26k_disconnect_sem);
at_delete_resp(resp);
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)
const char *line_buffer = RT_NULL;
int len = 0;
rt_uint8_t retry = 0;
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);
@ -423,7 +345,7 @@ int at_send_data(struct at_device *device, const char *data, rt_size_t size)
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 ((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;
}
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;
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->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_pin_write(nt26k->wkp_pin, PIN_HIGH);
rt_pin_write(nt26k->pwr_key_pin, PIN_HIGH);
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 ============================= */
/* 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_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_STACK_SIZE (1024 + 512)
@ -947,6 +869,18 @@ static void nt26k_init_thread_entry(void *parameter)
result = -RT_ERROR;
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 */
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 */
for (i = 0; i < CPIN_RETRY; i++)
{
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;
}
rt_thread_mdelay(1000);
rt_thread_mdelay(2000);
}
if (i == CPIN_RETRY)
{
@ -1002,7 +935,7 @@ static void nt26k_init_thread_entry(void *parameter)
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)
{
@ -1026,12 +959,12 @@ static void nt26k_init_thread_entry(void *parameter)
char iccid[NT26K_ICCID_LEN] = {0};
/* 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;
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);
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);
result = -RT_ERROR;
}
/* get signal snr, pci */
for (int i = 0; i < RETRY; i++)
{
if (at_obj_exec_cmd(device->client, resp, "AT+NUESTATS") == RT_EOK)
{
const char *key1 = "SNR:";
const char *key2 = "PCI:";
int pci = 0, snr = 0;
// show_resp_info(resp);
// /* get signal snr, pci */
// for (int i = 0; i < RETRY; i++)
// {
// if (at_obj_exec_cmd(device->client, resp, "AT+NUESTATS") == RT_EOK)
// {
// const char *key1 = "SNR:";
// const char *key2 = "PCI:";
// int pci = 0, snr = 0;
// // show_resp_info(resp);
// 获取第 2 行的响应
const char *line = at_resp_get_line(resp, 2);
// // 获取第 2 行的响应
// const char *line = at_resp_get_line(resp, 2);
if (line != NULL)
{
snr = Extract_Value(line, key1);
pci = Extract_Value(line, key2);
// if (line != NULL)
// {
// snr = Extract_Value(line, key1);
// pci = Extract_Value(line, key2);
if (snr != 0 && pci != 0)
{
nt26k.pci = pci;
nt26k.snr = snr;
LOG_D("pci:%d,snr:%d", nt26k.pci, nt26k.snr);
break;
}
else
{
LOG_D("Extracted values are invalid: SNR=%d, PCI=%d", snr, pci);
}
}
else
{
LOG_D("Failed to get line 2 from response");
}
}
else
{
LOG_D("Failed to execute AT command");
}
rt_thread_mdelay(2000);
}
if (i == RETRY)
{
LOG_E("%s device signal data failed", device->name);
result = -RT_ERROR;
}
// if (snr != 0 && pci != 0)
// {
// nt26k.pci = pci;
// nt26k.snr = snr;
// LOG_D("pci:%d,snr:%d", nt26k.pci, nt26k.snr);
// break;
// }
// else
// {
// LOG_D("Extracted values are invalid: SNR=%d, PCI=%d", snr, pci);
// }
// }
// else
// {
// LOG_D("Failed to get line 2 from response");
// }
// }
// else
// {
// LOG_D("Failed to execute AT command");
// }
// rt_thread_mdelay(2000);
// }
// if (i == RETRY)
// {
// LOG_E("%s device signal data failed", device->name);
// result = -RT_ERROR;
// }
at_delete_resp(resp);
return result;
@ -1376,9 +1309,10 @@ static int nt26k_init(struct at_device *device)
{
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 */
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;
/*默认的系统配置*/
rt_uint8_t sys_hw_ver = 0x10;
rt_uint8_t sys_sw_ver = 0x12;
rt_uint8_t sys_hw_ver = SYS_HW_VERSION;
rt_uint8_t sys_sw_ver = SYS_SW_VERSION;
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_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_emagnetic_switch = 0x04; // 具备阀门功能
rt_uint8_t sys_relay_switch = 0x04; // 具备继电器功能
struct flash_sever_info sever_info =
{
.server_url = "8.130.117.149",
.server_port = "7137",
// .server_url = "8.135.10.183",
// .server_port = "36125,"
.server_url = SYS_IOT_URL,
.server_port = SYS_IOT_PORT,
};

83
bsp/src/bsp_nt26k.c
View File

@ -2,7 +2,7 @@
* @Author: mbw
* @Date: 2024-10-09 08:42:14
* @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
* @Description:
*
@ -60,12 +60,11 @@ static struct rt_thread nt26k_life_thread;
struct rt_event at_device_event;
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_upload_timer; // 更新本地时间定时器
static rt_timer_t nt26k_power_error_timer; // 上电失败情况下启动定时器
/*生命周期窗口定时器，用于管理tcp连接的断开*/
static rt_timer_t nt26k_life_timer;
rt_uint8_t nt26k_conncet_tcp_flag;
Nt26kEventIndex nt26k_event_index;
@ -99,7 +98,7 @@ static struct at_device_nt26k _dev =
NT26K_PWR_EN_PIN,
NT26K_RST_PIN,
NT26K_WKP_PIN,
NT26K_PWR_KEY_PIN,
NT26K_SAMPLE_RECV_BUFF_LEN,
};
@ -179,11 +178,6 @@ static void Nt26k_Ht_Timer_Cb(void *parameter)
Nt26k_Send_Event(kNt26kHeartbeatEvent);
}
// 定时器回调函数,当1分钟内没有数据交互时，关闭tcp连接
static void Nt26k_Life_Timer_Cb(void *parameter)
{
rt_sem_release(nt26k_life_sem);
}
// 定时器回调函数,当1分钟内没有数据交互时，关闭tcp连接
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)
{
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) // 打开连接
{
LOG_D("nt26k connect tcp success\n");
Reset_Nt26k_Life_Timer();
// 重启后重新尝试发送
result = event->send_func(device, nt26k_ops);
if (result != RT_EOK)
@ -927,12 +910,7 @@ void Handle_Close_Valve(struct Nt26k_Ops *ops)
Get_Nb_Imei(imei, FLASH_NB_IMEI_LEN);
char temp[32] = "0";
String2Hex(temp, imei); // 将字符串转为十六进制字符串
// emv_state_flag = 1;
// rt_thread_mdelay(20);
// emv_state_flag = 0;
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);
}
@ -1213,7 +1191,6 @@ void Handle_Cmd_Type(struct Nt26k_Ops *ops)
void Analyze_Recv_Frame(struct at_device *device, struct Nt26k_Ops *ops)
{
rt_err_t ret = RT_EOK;
Reset_Nt26k_Life_Timer(); // 只要数据，则重置定时器，不管数据是否正确
ret = Compare_HeaderToTail(ops);
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) // 打开连接
{
LOG_D("nt26k connect tcp success\n");
rt_timer_start(nt26k_life_timer);
}
else
{
@ -1291,7 +1267,6 @@ static void Nt26k_Send_Thread_Entry(void *param)
}
if (nt26k_conncet_tcp_flag)
{
Reset_Nt26k_Life_Timer();
if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kPowerOnEvent))
{
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 *device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, nt26k->device_name);
RT_ASSERT(device);
rt_err_t ret;
LOG_D("nt26k recv thread entry\n");
while (1)
{
ret = rt_sem_take(nt26k_recv_sem, RT_WAITING_FOREVER); // 这个主要用来处理的数据
if (ret == RT_EOK)
{
rt_timer_start(nt26k_life_timer);
/*对数据帧进行分析，判断所处的是对服务器响应还是指令下发*/
Analyze_Recv_Frame(device, ops);
}
rt_sem_take(nt26k_recv_sem, RT_WAITING_FOREVER); // 这个主要用来处理的数据
/*对数据帧进行分析，判断所处的是对服务器响应还是指令下发*/
Analyze_Recv_Frame(device, ops);
}
}
@ -1464,13 +1434,24 @@ static void Nt26k_Life_Thread_Entry(void *parameter)
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 (nt26k_conncet_tcp_flag)
if (!nt26k_conncet_tcp_flag)
{
device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_DISCONN, RT_NULL);
LOG_D("close nt26k tcp connect\n ");
LOG_D("重连网络中...\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);
unsigned long timeout = nb_upload_time * 60 * RT_TICK_PER_SECOND;
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)
{
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)
{
LOG_E("nt26k_recv_sem create failed");
}
nt26k_life_sem = rt_sem_create("nt26k_life", 0, RT_IPC_FLAG_FIFO);
if (nt26k_life_sem == RT_NULL)
nt26k_disconnect_sem = rt_sem_create("nt26k_life", 0, RT_IPC_FLAG_PRIO);
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",
@ -1518,16 +1499,6 @@ int BSP_Nt26k_Thread_Init(void)
rt_kprintf("创建定时器失败\n");
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_Error_Timer_Cb,
RT_NULL,