diff --git a/.cproject b/.cproject index 07e4900..847ec5a 100644 --- a/.cproject +++ b/.cproject @@ -174,7 +174,7 @@ - + diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs index 6d5733e..f8250df 100644 --- a/.settings/org.eclipse.core.resources.prefs +++ b/.settings/org.eclipse.core.resources.prefs @@ -4,10 +4,10 @@ encoding//applications/main.c=UTF-8 encoding//applications/user_sys.h=UTF-8 encoding//board/board.c=UTF-8 encoding//board/board.h=UTF-8 -encoding//bsp/inc/at_device_mb26.h=GBK +encoding//bsp/inc/at_device_nt26k.h=GBK encoding//bsp/inc/bsp_hr.h=GBK encoding//bsp/inc/bsp_led.h=UTF-8 -encoding//bsp/src/at_device_mb26.c=UTF-8 +encoding//bsp/src/at_device_nt26k.c=UTF-8 encoding//bsp/src/bsp_button.c=GBK encoding//bsp/src/bsp_flash.c=UTF-8 encoding//bsp/src/bsp_h308.c=UTF-8 diff --git a/.vscode/settings.json b/.vscode/settings.json index e1a6cbe..2cabbe5 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -39,7 +39,7 @@ "pin.h": "c", "cstring": "c", "bsp_beep.h": "c", - "at_device_mb26.h": "c", + "at_device_nt26k.h": "c", "at_log.h": "c", "at_device.h": "c", "stdlib.h": "c", diff --git a/applications/main.c b/applications/main.c index 42ee8c1..d2a2a2a 100644 --- a/applications/main.c +++ b/applications/main.c @@ -23,7 +23,7 @@ #include "bsp_flash.h" #include "bsp_hr.h" #include "bsp_h308.h" -#include "bsp_mb26.h" +#include "bsp_nt26k.h" #include "bsp_vin_detection.h" #include "user_sys.h" @@ -218,6 +218,7 @@ int main(void) else { LOG_D("欠压复位\r\n"); + NVIC_SystemReset(); // 直接重启系统 } while (1) @@ -323,8 +324,8 @@ int main(void) LED_R_ALARM; BEEP_ALARM; -#if (NB_MODULE_SWITCH == 1) - Mb26_Send_Event(kMb26AlarmEvent); +#if (IOT_MODULE_SWITCH == 1) + Nt26k_Send_Event(kNt26kAlarmEvent); #endif } else if (received_event & Get_Sys_Event_Flag(kAlarmRcyEvent)) // 报警恢复 @@ -340,8 +341,8 @@ int main(void) relay_state_flag = 0; BEEP_STOP; -#if (NB_MODULE_SWITCH == 1) - Mb26_Send_Event(kMb26AlarmRcyEvent); +#if (IOT_MODULE_SWITCH == 1) + Nt26k_Send_Event(kNt26kAlarmRcyEvent); #endif Send_Laser_Alarm_Event(kNormalDetectionEvents); @@ -357,8 +358,8 @@ int main(void) Flash_Write_Record(kRecordFault); LED_Y_FAULT; -#if (NB_MODULE_SWITCH == 1) - Mb26_Send_Event(kMb26FaultEvent); +#if (IOT_MODULE_SWITCH == 1) + Nt26k_Send_Event(kNt26kFaultEvent); #endif } else @@ -376,8 +377,8 @@ int main(void) Flash_Write_Record(kRecordFaultRcy); Send_Laser_Alarm_Event(kNormalDetectionEvents); -#if (NB_MODULE_SWITCH == 1) - Mb26_Send_Event(kMb26FaultRcyEvent); +#if (IOT_MODULE_SWITCH == 1) + Nt26k_Send_Event(kNt26kFaultRcyEvent); #endif } else if (received_event & Get_Sys_Event_Flag(KMuteEvent)) // 消音 @@ -386,8 +387,8 @@ int main(void) SysControl.last_status = SysControl.status; SysControl.status = KMuteEvent; BEEP_STOP; -#if (NB_MODULE_SWITCH == 1) - Mb26_Send_Event(kMb26SilenceEvent); +#if (IOT_MODULE_SWITCH == 1) + Nt26k_Send_Event(kNt26kSilenceEvent); #endif } else if (received_event & Get_Sys_Event_Flag(kPowerDownEvent)) // 掉电 @@ -401,8 +402,8 @@ int main(void) Flash_Write_Record(kRecordPowerDown); Flash_Set_WorkDuration(work_duration); // 写入工作时长 -#if (NB_MODULE_SWITCH == 1) - Mb26_Send_Event(kMb26PowerDownEvent); +#if (IOT_MODULE_SWITCH == 1) + Nt26k_Send_Event(kNt26kPowerDownEvent); #endif LOG_D("Enter AnalogWatchdog Interrupt"); // 等待180s,要是还没断电就重启 @@ -423,8 +424,8 @@ int main(void) _Self_Check_Mode(); -#if (NB_MODULE_SWITCH == 1) - Mb26_Send_Event(kMb26SelfCheckEvent); +#if (IOT_MODULE_SWITCH == 1) + Nt26k_Send_Event(kNt26kSelfCheckEvent); #endif Send_Laser_Alarm_Event(kNormalDetectionEvents); // 这里先返回检测模式，然后当事件触发时进入事件模式 } diff --git a/applications/user_sys.c b/applications/user_sys.c index 6c459a3..27eda69 100644 --- a/applications/user_sys.c +++ b/applications/user_sys.c @@ -22,13 +22,13 @@ #include "bsp_flash.h" #include "bsp_h308.h" #include "bsp_hr.h" -#include "bsp_mb26.h" +#include "bsp_nt26k.h" #include "bsp_relay.h" #include "bsp_vin_detection.h" #include "bsp_wdg.h" #include "rtdef.h" #include "bsp_rng.h" -#include "at_device_mb26.h" +#include "at_device_nt26k.h" volatile rt_uint16_t work_duration = 1; // 工作时长 volatile rt_uint8_t device_life_check = 0; @@ -238,9 +238,9 @@ int BSP_SYS_Init(void) BSP_BUTTON_Init(); BSP_H308_Init(); BSP_HR_Init(); - mb26_device_class_register(); - mb26_device_register(); - BSP_Mb26_Thread_Init(); + nt26k_device_class_register(); + nt26k_device_register(); + BSP_Nt26k_Thread_Init(); return 0; } // INIT_ENV_EXPORT(BSP_SYS_Init); diff --git a/bsp/inc/at_device_mb26.h b/bsp/inc/at_device_nt26k.h similarity index 61% rename from bsp/inc/at_device_mb26.h rename to bsp/inc/at_device_nt26k.h index a41b513..4d2ce03 100644 --- a/bsp/inc/at_device_mb26.h +++ b/bsp/inc/at_device_nt26k.h @@ -2,8 +2,8 @@ * @Author: mbw * @Date: 2024-10-09 08:42:14 * @LastEditors: mbw && 1600520629@qq.com - * @LastEditTime: 2024-11-07 14:21:17 - * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\inc\at_device_mb26.h + * @LastEditTime: 2024-12-30 16:30:57 + * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\inc\at_device_nt26k.h * @Description: * @ * @Copyright (c) 2024 by ${git_name_email}, All Rights Reserved. @@ -13,14 +13,14 @@ * @Date: 2024-10-09 08:42:14 * @LastEditors: mbw && 1600520629@qq.com * @LastEditTime: 2024-10-14 14:25:58 - * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\inc\at_device_mb26.h + * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\inc\at_device_nt26k.h * @Description: * @ * @Copyright (c) 2024 by ${git_name_email}, All Rights Reserved. */ -#ifndef __AT_DEVICE_MB26_H__ -#define __AT_DEVICE_MB26_H__ +#ifndef __AT_DEVICE_NT26K_H__ +#define __AT_DEVICE_NT26K_H__ #include @@ -33,29 +33,27 @@ //#define TCP_SERVER_URL ("8.135.10.183 ") // //#define TCP_SERVER_PORT ("35383") -#define AT_NSONMI_MODE_1 1 -#define AT_NSONMI_MODE_2 2 -#define AT_NSONMI_MODE_3 3 -#define AT_NSONMI_MODE_DEFAULT AT_NSONMI_MODE_3 +#define AT_NT26K_FORMAT_MODE_0 0 +#define AT_NSONMI_FORMAT_MODE_1 1 +#define AT_NSONMI_MODE_DEFAULT AT_NSONMI_FORMAT_MODE_1 #define AT_SEND_MSOSD_FLAG_100 ("0x100") #define AT_SEND_MSOSD_FLAG_200 ("0x200") #define AT_SEND_MSOSD_FLAG_400 ("0x400") #define AT_SEND_MSOSD_FLAG_DEFAULT AT_SEND_MSOSD_FLAG_100 -#define TCP_SOCKET_CREAT ("AT+SKTCREATE=1,1,6") // -#define TCP_CONNECT_CMD ("AT+SKTCONNECT=%d,%s,%s") +#define TCP_CONNECT_CMD ("AT+QIOPEN=1,0,\"TCP\",\"%s\",%s") #define TCP_READ_SET_CMD ("AT+NSORF=%d,%d") /* socket_id,length */ #define TCP_SET_NSONMI ("AT+NSONMI=%d") -#define TCP_SEND_DATA ("AT+SKTSEND=%d,%d,%s,%s") -#define TCP_CLOSE_SOCKET ("AT+NSOCL=%d") /* close socket_id */ +#define TCP_SEND_DATA ("AT+QISENDEX=%d,\"%s\"") +#define TCP_CLOSE_SOCKET ("AT+QICLOSE=%d") /* close socket_id */ -#define AT_DEVICE_MB26_SOCKETS_NUM 5 -/* The maximum number of sockets supported by the mb26 device */ +#define AT_DEVICE_NT26K_SOCKETS_NUM 5 +/* The maximum number of sockets supported by the nt26k device */ -struct at_device_mb26 +struct at_device_nt26k { char *device_name; char *client_name; @@ -83,13 +81,13 @@ typedef struct __attribute__((packed)) uint8_t rsrq; // RSRQ uint16_t pci; // PCI uint8_t snr; // SNR -} mb26_sys_info; +} nt26k_sys_info; -extern mb26_sys_info mb26; -extern rt_uint8_t mb26_init_complate_flag; -extern struct rt_completion mb26_init_complate; -int mb26_device_class_register(void); +extern nt26k_sys_info nt26k; +extern rt_uint8_t nt26k_init_complate_flag; +extern struct rt_completion nt26k_init_complate; +int nt26k_device_class_register(void); int at_send_data(struct at_device *device, const char *data, rt_size_t size); -rt_err_t Mb26_Reset(struct at_device *device); +rt_err_t Nt26k_Reset(struct at_device *device); int Time_Calibration(struct at_device *device); -#endif /* __AT_DEVICE_MB26_H__ */ +#endif /* __AT_DEVICE_NT26K_H__ */ diff --git a/bsp/inc/bsp_mb26.h b/bsp/inc/bsp_nt26k.h similarity index 71% rename from bsp/inc/bsp_mb26.h rename to bsp/inc/bsp_nt26k.h index a867fa9..304c024 100644 --- a/bsp/inc/bsp_mb26.h +++ b/bsp/inc/bsp_nt26k.h @@ -3,30 +3,20 @@ * @Date: 2024-10-09 08:42:14 * @LastEditors: mbw && 1600520629@qq.com * @LastEditTime: 2024-10-17 09:26:13 - * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\inc\bsp_mb26.h + * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\inc\bsp_nt26k.h * @Description: * @ * @Copyright (c) 2024 by ${git_name_email}, All Rights Reserved. */ -/*** - * @Author: mbw - * @Date: 2024-10-09 08:42:14 - * @LastEditors: mbw && 1600520629@qq.com - * @LastEditTime: 2024-10-16 09:03:41 - * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\inc\bsp_mb26.h - * @Description: - * @ - * @Copyright (c) 2024 by ${git_name_email}, All Rights Reserved. - */ -#include +#include #include "drv_gpio.h" -#define MB26_PWR_EN_PIN GET_PIN(B, 3) -#define MB26_RST_PIN GET_PIN(A, 11) -#define MB26_WKP_PIN GET_PIN(C, 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 MB26_SAMPLE_DEIVCE_NAME "mb26" +#define NT26K_SAMPLE_DEIVCE_NAME "nt26k" /*默认参数*/ #define DEVICE_MANUFACTURE 0x4454 // DT @@ -44,7 +34,7 @@ #define DATA_SERIAL_NUM 0x0001 // 1 /*设备类型*/ -#define DEVICE_TYPE_MB26 0x20 +#define DEVICE_TYPE_NT26K 0x20 /*事件类型*/ #define EVENT_TYPE_HEARTBEAT 0x30 // 心跳事件 #define EVENT_TYPE_SELF_CHECK 0x31 // 自检事件 @@ -84,7 +74,7 @@ #define MAX_DATA_LEN 256 // 数据长度 -#define MB26_DEFIENE_DATA "000000000000000000000000000000" +#define NT26K_DEFIENE_DATA "000000000000000000000000000000" #define DEVICE_DEFINE 1 //具备该设备功能 @@ -96,27 +86,27 @@ typedef enum { /****************优先级最低***************** */ - kMb26HeartbeatEvent, // 定时心跳事件 - kMb26SilenceEvent, // 消音事件 - kMb26ExceptionEvent, // 异常事件 - kMb26ValveStatusEvent, // 电磁阀状态改变事件 - kMb26FanStatusEvent, // 风机状态改变事件 - kMb26TempAnomalyEvent, // 产品工作温度异常事件 - kMb26AlarmEvent, // 报警事件 - kMb26AlarmRcyEvent, // 报警恢复事件 - kMb26FaultEvent, // 故障事件 - kMb26FaultRcyEvent, // 故障恢复事件 - kMb26DeviceFailureEvent, // 设备失效事件 - kMb26TimeCalibrationEvent, // 时间校准事件 + kNt26kHeartbeatEvent, // 定时心跳事件 + kNt26kSilenceEvent, // 消音事件 + kNt26kExceptionEvent, // 异常事件 + kNt26kValveStatusEvent, // 电磁阀状态改变事件 + kNt26kFanStatusEvent, // 风机状态改变事件 + kNt26kTempAnomalyEvent, // 产品工作温度异常事件 + kNt26kAlarmEvent, // 报警事件 + kNt26kAlarmRcyEvent, // 报警恢复事件 + kNt26kFaultEvent, // 故障事件 + kNt26kFaultRcyEvent, // 故障恢复事件 + kNt26kDeviceFailureEvent, // 设备失效事件 + kNt26kTimeCalibrationEvent, // 时间校准事件 /**********************优先级第三************************* */ - kMb26SelfCheckEvent, // 自检事件 + kNt26kSelfCheckEvent, // 自检事件 /**********************优先级第二************************* */ - kMb26PowerDownEvent, // 掉电事件 + kNt26kPowerDownEvent, // 掉电事件 /**********************优先级第一************************* */ - kMb26PowerOnEvent, // 上电事件 + kNt26kPowerOnEvent, // 上电事件 - kMb26MaxEventcnt // 最大事件计数 -} Mb26Event; // 当前所处的事件类型 + kNt26kMaxEventcnt // 最大事件计数 +} Nt26kEvent; // 当前所处的事件类型 typedef enum { @@ -128,13 +118,13 @@ typedef enum kSensorFaultStatus, // 传感器故障触发状态 kSensorRecoveredStatus, // 传感器故障解除状态 kPowerDownStatus, // 掉电状态 -} Mb26Status; // 当前所处的上报状态 +} Nt26kStatus; // 当前所处的上报状态 typedef struct { - Mb26Event current_event;//当前事件 - Mb26Event last_event;//上次事件 -}Mb26EventIndex; + Nt26kEvent current_event;//当前事件 + Nt26kEvent last_event;//上次事件 +}Nt26kEventIndex; struct __attribute__((packed)) DataBody @@ -165,7 +155,7 @@ struct __attribute__((packed)) DataBody }; // 定义数据帧结构体 -struct __attribute__((packed)) Mb26DataFrame +struct __attribute__((packed)) Nt26kDataFrame { uint8_t header[3]; // 帧头 uint8_t version; // 协议版本 @@ -178,7 +168,7 @@ struct __attribute__((packed)) Mb26DataFrame uint8_t tail[3]; // 帧尾 }; -struct __attribute__((packed)) Mb26Data +struct __attribute__((packed)) Nt26kData { rt_uint8_t device_type; // 设备类型 rt_uint8_t event_type; // 事件类型 @@ -186,7 +176,7 @@ struct __attribute__((packed)) Mb26Data rt_uint8_t res_num; }; -struct __attribute__((packed)) Mb26RecvData +struct __attribute__((packed)) Nt26kRecvData { rt_uint8_t header[3]; // 帧头 rt_uint8_t version; // 协议版本 @@ -194,27 +184,27 @@ struct __attribute__((packed)) Mb26RecvData rt_uint16_t datanumber; // 数据序列号 rt_uint8_t cmd; // 命令位 rt_uint16_t datalen; // 数据长度 - struct Mb26Data recv_data; // 接收数据体 + struct Nt26kData recv_data; // 接收数据体 rt_uint16_t crc16; // 校验位 rt_uint8_t tail[3]; // 帧尾 }; -struct Mb26_Ops +struct Nt26k_Ops { struct DataBody *body; - struct Mb26DataFrame *frame; - struct Mb26RecvData *recv; - int (*init)(struct Mb26_Ops *ops, rt_uint8_t version); - int (*update_data)(struct Mb26_Ops *ops, rt_uint8_t device_type, rt_uint8_t cmd); - int (*send)(struct Mb26_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type); - int (*Resp)(struct Mb26_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type, char *data, rt_uint8_t res); - int (*Recv)(struct Mb26_Ops *ops, char *data); // 解析数据 + struct Nt26kDataFrame *frame; + struct Nt26kRecvData *recv; + int (*init)(struct Nt26k_Ops *ops, rt_uint8_t version); + int (*update_data)(struct Nt26k_Ops *ops, rt_uint8_t device_type, rt_uint8_t cmd); + int (*send)(struct Nt26k_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type); + int (*Resp)(struct Nt26k_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type, char *data, rt_uint8_t res); + int (*Recv)(struct Nt26k_Ops *ops, char *data); // 解析数据 }; -extern struct Mb26_Ops mb26_ops; -extern rt_sem_t mb26_recv_sem; -extern rt_uint8_t mb26_conncet_tcp_flag; +extern struct Nt26k_Ops nt26k_ops; +extern rt_sem_t nt26k_recv_sem; +extern rt_uint8_t nt26k_conncet_tcp_flag; extern rt_uint8_t power_on_send_flag; -int mb26_device_register(void); -int BSP_Mb26_Thread_Init(void); -void Mb26_Send_Event(Mb26Event event_type); +int nt26k_device_register(void); +int BSP_Nt26k_Thread_Init(void); +void Nt26k_Send_Event(Nt26kEvent event_type); diff --git a/bsp/src/at_device_mb26.c b/bsp/src/at_device_nt26k.c similarity index 69% rename from bsp/src/at_device_mb26.c rename to bsp/src/at_device_nt26k.c index 4673eeb..07c67af 100644 --- a/bsp/src/at_device_mb26.c +++ b/bsp/src/at_device_nt26k.c @@ -2,8 +2,8 @@ * @Author : stark1898y 1658608470@qq.com * @Date : 2024-09-04 13:33:49 * @LastEditors: mbw && 1600520629@qq.com - * @LastEditTime: 2024-12-30 09:35:16 - * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\src\at_device_mb26.c + * @LastEditTime: 2024-12-30 17:19:08 + * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\src\at_device_nt26k.c * @Description : * * Copyright (c) 2024 by yzy, All Rights Reserved. @@ -21,101 +21,103 @@ #include #include #include "bsp_flash.h" -#include -#include "bsp_mb26.h" +#include +#include "bsp_nt26k.h" #include "user_sys.h" #include "bsp_rtc.h" #include "bsp_led.h" #include "bsp_rng.h" -#define LOG_TAG "at.dev.mb26" +#define LOG_TAG "at.dev.nt26k" #include #include "pin.h" -#if NB_MODULE_SWITCH == 1 +#if IOT_MODULE_SWITCH == 1 -#define MB26_POWER_OFF RT_FALSE -#define MB26_POWER_ON RT_TRUE -#define MB26_POWER_ON_TIME 3 -#define MB26_POWER_OFF_TIME 4 +#define NT26K_POWER_OFF RT_FALSE +#define NT26K_POWER_ON RT_TRUE +#define NT26K_POWER_ON_TIME 3 +#define NT26K_POWER_OFF_TIME 4 #define AT_CLIENT_RECV_BUFF_LEN 512 #define AT_DEFAULT_TIMEOUT 5000 -#ifdef AT_DEVICE_USING_MB26 -#define MB26_WAIT_CONNECT_TIME 5000 -#define MB26_THREAD_STACK_SIZE 4096 -#define MB26_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 2) -char data_buf[AT_CLIENT_RECV_BUFF_LEN] = {0}; +#ifdef AT_DEVICE_USING_NT26K +#define NT26K_WAIT_CONNECT_TIME 5000 +#define NT26K_THREAD_STACK_SIZE 4096 +#define NT26K_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 2) -mb26_sys_info mb26 = {0}; -struct rt_completion mb26_init_complate; +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; volatile rt_uint8_t socket_id = 0; -rt_err_t Mb26_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("MB26 Reset"); - rt_pin_mode(MB26_RST_PIN, PIN_MODE_OUTPUT); - rt_pin_write(MB26_RST_PIN, PIN_LOW); + LOG_I("NT26K Reset"); + rt_pin_mode(NT26K_RST_PIN, PIN_MODE_OUTPUT); + rt_pin_write(NT26K_RST_PIN, PIN_LOW); rt_thread_mdelay(10); - rt_pin_write(MB26_RST_PIN, PIN_HIGH); + rt_pin_write(NT26K_RST_PIN, PIN_HIGH); rt_thread_mdelay(50); - rt_pin_write(MB26_RST_PIN, PIN_LOW); + rt_pin_write(NT26K_RST_PIN, PIN_LOW); return RT_EOK; } -static int mb26_power_on(struct at_device *device) +static int nt26k_power_on(struct at_device *device) { - struct at_device_mb26 *mb26 = RT_NULL; + struct at_device_nt26k *nt26k = RT_NULL; - mb26 = (struct at_device_mb26 *)device->user_data; - mb26->power_status = RT_TRUE; + nt26k = (struct at_device_nt26k *)device->user_data; + nt26k->power_status = RT_TRUE; - /* not nead to set pin configuration for mb26 device power on */ - if (mb26->pwr_en_pin == -1) + /* not nead to set pin configuration for nt26k device power on */ + if (nt26k->pwr_en_pin == -1) { return (RT_EOK); } - rt_pin_write(mb26->pwr_en_pin, PIN_LOW); + rt_pin_write(nt26k->pwr_en_pin, PIN_LOW); rt_thread_mdelay(10); - rt_pin_write(mb26->pwr_en_pin, PIN_HIGH); + rt_pin_write(nt26k->pwr_en_pin, PIN_HIGH); return (RT_EOK); } -static rt_err_t mb26_power_off(struct at_device *device) +static rt_err_t nt26k_power_off(struct at_device *device) { - struct at_device_mb26 *mb26 = RT_NULL; + struct at_device_nt26k *nt26k = RT_NULL; - mb26 = (struct at_device_mb26 *)device->user_data; - if (mb26->power_status != RT_FALSE) + nt26k = (struct at_device_nt26k *)device->user_data; + if (nt26k->power_status != RT_FALSE) { - rt_pin_mode(mb26->pwr_en_pin, PIN_MODE_OUTPUT); - rt_pin_write(mb26->pwr_en_pin, PIN_HIGH); + rt_pin_mode(nt26k->pwr_en_pin, PIN_MODE_OUTPUT); + rt_pin_write(nt26k->pwr_en_pin, PIN_HIGH); } return RT_EOK; } #ifdef TEST_ENABLE -void TEST_Mb26_Reset() +void TEST_Nt26k_Reset() { - Mb26_Reset(RT_NULL); + Nt26k_Reset(RT_NULL); } -MSH_CMD_EXPORT(TEST_Mb26_Reset, "test_mb26_reset"); +MSH_CMD_EXPORT(TEST_Nt26k_Reset, "test_nt26k_reset"); #endif -static int mb26_sleep(struct at_device *device) +static int nt26k_sleep(struct at_device *device) { at_response_t resp = RT_NULL; - struct at_device_mb26 *mb26 = RT_NULL; + struct at_device_nt26k *nt26k = RT_NULL; - mb26 = (struct at_device_mb26 *)device->user_data; - if (!mb26->power_status) // power off + nt26k = (struct at_device_nt26k *)device->user_data; + if (!nt26k->power_status) // power off { return (RT_EOK); } - if (mb26->sleep_status) // is sleep status + if (nt26k->sleep_status) // is sleep status { return (RT_EOK); } @@ -147,24 +149,24 @@ static int mb26_sleep(struct at_device *device) return (-RT_ERROR); } - mb26->sleep_status = RT_TRUE; + nt26k->sleep_status = RT_TRUE; at_delete_resp(resp); return (RT_EOK); } -static int mb26_wakeup(struct at_device *device) +static int nt26k_wakeup(struct at_device *device) { at_response_t resp = RT_NULL; - struct at_device_mb26 *mb26 = RT_NULL; + struct at_device_nt26k *nt26k = RT_NULL; - mb26 = (struct at_device_mb26 *)device->user_data; - if (!mb26->power_status) // power off + nt26k = (struct at_device_nt26k *)device->user_data; + if (!nt26k->power_status) // power off { LOG_E("the power is off and the wake-up cannot be performed"); return (-RT_ERROR); } - if (!mb26->sleep_status) // no sleep status + if (!nt26k->sleep_status) // no sleep status { return (RT_EOK); } @@ -177,13 +179,13 @@ static int mb26_wakeup(struct at_device *device) return (-RT_ERROR); } - if (mb26->wkp_pin != -1) + if (nt26k->wkp_pin != -1) { - rt_pin_write(mb26->wkp_pin, PIN_LOW); + rt_pin_write(nt26k->wkp_pin, PIN_LOW); rt_thread_mdelay(100); - rt_pin_write(mb26->wkp_pin, PIN_HIGH); + rt_pin_write(nt26k->wkp_pin, PIN_HIGH); rt_thread_mdelay(100); - rt_pin_write(mb26->wkp_pin, PIN_LOW); + rt_pin_write(nt26k->wkp_pin, PIN_LOW); } /* disable sleep mode */ @@ -202,7 +204,7 @@ static int mb26_wakeup(struct at_device *device) return (-RT_ERROR); } - mb26->sleep_status = RT_FALSE; + nt26k->sleep_status = RT_FALSE; at_delete_resp(resp); return (RT_EOK); @@ -214,35 +216,35 @@ 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, "+NSONMI:%*d,%d,%s", &len, data_buf) == 2) + if (sscanf(data, "+QIURC: \"recv\",%*d,%d,%s", &len, data_buf) == 2) { HexStrToBytes(data_buf, recv_byte_buf, len * 2); - LOG_D("mb26 recv data: %s", data_buf); + LOG_D("nt26k recv data: %s", data_buf); crc16 = crc1021(data_buf, len * 2 - 10); // 去掉帧尾三个字节和2个字节的校验值，字符长度为10 rt_strncpy(crc16_buf, data_buf + len * 2 - 10, 4); - LOG_D("mb26 crc16: %04s", crc16_buf); + LOG_D("nt26k crc16: %04s", crc16_buf); rec_crc16 = strtol(crc16_buf, NULL, 16); if (crc16 != rec_crc16) // 看下数据接收的是否正确 { - LOG_E("mb26 recv data error {crc16 [%x]!= rec_crc16[%x]}", crc16, rec_crc16); + LOG_E("nt26k recv data error {crc16 [%x]!= rec_crc16[%x]}", crc16, rec_crc16); } else { /*比较数组的长度和结构体的长度是否一致，如果不一致则数据解析错误，如果一致复制数组值到结构体中*/ - if (len == sizeof(struct Mb26RecvData)) + if (len == sizeof(struct Nt26kRecvData)) { - rt_memset(mb26_ops.recv, 0, sizeof(struct Mb26RecvData)); // 清空结构体 - rt_memcpy(mb26_ops.recv, recv_byte_buf, sizeof(struct Mb26RecvData)); - - rt_sem_release(mb26_recv_sem); + 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)); } else { - LOG_E("mb26 recv data error {len [%d]!= sizeof(struct Mb26RecvData)[%d]}", len, sizeof(struct Mb26RecvData)); + LOG_E("nt26k recv data error {len [%d]!= sizeof(struct Nt26kRecvData)[%d]}", len, sizeof(struct Nt26kRecvData)); } } } @@ -251,7 +253,7 @@ static void urc_tcp_recv(struct at_client *client, const char *data, rt_size_t s static void urc_device_reset(struct at_client *client, const char *data, rt_size_t size) { LOG_D("device reset"); - mb26_conncet_tcp_flag = 0; + nt26k_conncet_tcp_flag = 0; } static void urc_tcp_disconnect(struct at_client *client, const char *data, rt_size_t size) @@ -263,18 +265,17 @@ static void urc_tcp_disconnect(struct at_client *client, const char *data, rt_si if ((id == socket_id) && (err_code == 107)) // 107错误一般是服务器没加这个IMEI { LOG_W("socket %d disconnect, error code: %d", id, err_code); - mb26_conncet_tcp_flag = 0; + nt26k_conncet_tcp_flag = 0; } } } static const struct at_urc urc_table[] = { - {"+NSONMI:", "\r\n", urc_tcp_recv}, - {"REBOOTING", "\r\n", urc_device_reset}, // 这个是软件复位时， + {"+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}, // 这个时硬件复位时回复 }; - void show_resp_info(at_response_t resp) { RT_ASSERT(resp); @@ -291,13 +292,13 @@ void show_resp_info(at_response_t resp) return; } -int at_device_mb26_disconnect_tcp(struct at_device *device) +int at_device_nt26k_disconnect_tcp(struct at_device *device) { -#define MB26_CLOSE_REP_TIME (5 * AT_DEFAULT_TIMEOUT) +#define NT26K_CLOSE_REP_TIME (5 * AT_DEFAULT_TIMEOUT) - if (mb26_conncet_tcp_flag) + if (nt26k_conncet_tcp_flag) { - at_response_t resp = at_create_resp(AT_CLIENT_RECV_BUFF_LEN, 0, MB26_CLOSE_REP_TIME); + at_response_t resp = at_create_resp(AT_CLIENT_RECV_BUFF_LEN, 0, NT26K_CLOSE_REP_TIME); if (resp == RT_NULL) { LOG_E("No memory for response structure!"); @@ -309,13 +310,14 @@ int at_device_mb26_disconnect_tcp(struct at_device *device) at_delete_resp(resp); return -RT_ERROR; } - mb26_conncet_tcp_flag = 0; + nt26k_conncet_tcp_flag = 0; at_delete_resp(resp); } return RT_EOK; } -int at_device_mb26_socket_creat(struct at_device *device) +#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); @@ -333,15 +335,15 @@ int at_device_mb26_socket_creat(struct at_device *device) { if (socket_id >= 0) { - LOG_I("mb26 create tcp socket success. socket id: %d", socket_id); + LOG_I("nt26k create tcp socket success. socket id: %d", socket_id); at_delete_resp(resp); return RT_EOK; } } else { - at_device_mb26_disconnect_tcp(device);//这里失败的原因有两种，一种是没有ID返回，一种是返回比较慢，导致错误出现 - LOG_E("mb26 create tcp socket failed. retry %d", retry); + at_device_nt26k_disconnect_tcp(device);//这里失败的原因有两种，一种是没有ID返回，一种是返回比较慢，导致错误出现 + LOG_E("nt26k create tcp socket failed. retry %d", retry); } } rt_thread_mdelay(5000); @@ -349,9 +351,12 @@ int at_device_mb26_socket_creat(struct at_device *device) at_delete_resp(resp); return RT_ERROR; } -static int at_device_mb26_connect_tcp(struct at_device *device) +#endif + +static int at_device_nt26k_connect_tcp(struct at_device *device) { - if (mb26_conncet_tcp_flag) + int err_code = 0; + if (nt26k_conncet_tcp_flag) return RT_EOK; ASSERT(device); rt_uint8_t retry = (rt_uint8_t)Flash_Get_SysCfg(kNbRetryId); @@ -362,25 +367,6 @@ static int at_device_mb26_connect_tcp(struct at_device *device) at_delete_resp(resp); return -RT_ENOMEM; } - if (at_device_mb26_socket_creat(device) != RT_EOK) - { - LOG_E("mb26 connect to tcp server failed."); - at_delete_resp(resp); - return -RT_ERROR; - } - - /* read data from tcp server */ - if (at_obj_exec_cmd(device->client, resp, TCP_READ_SET_CMD, socket_id, AT_CLIENT_RECV_BUFF_LEN) != RT_EOK) - { - at_delete_resp(resp); - return RT_ERROR; - } - /* enable tcp notification */ - if (at_obj_exec_cmd(device->client, resp, TCP_SET_NSONMI, AT_NSONMI_MODE_DEFAULT) != RT_EOK) - { - at_delete_resp(resp); - return RT_ERROR; - } if (Flash_Get_Sever_Data(&sever_info) != RT_EOK) { LOG_E("Get Sever Data Failed"); @@ -391,19 +377,27 @@ static int at_device_mb26_connect_tcp(struct at_device *device) 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, socket_id, 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, "+NSOCO:", "+NSOCO:%d", socket_id) > 0) + if (at_resp_parse_line_args_by_kw(resp, "+QIOPEN:", "+QIOPEN:%d,%d", socket_id, err_code) > 0) { - LOG_D("mb26 connect to tcp server success"); - mb26_conncet_tcp_flag = 1; - at_delete_resp(resp); - return RT_EOK; + if (err_code == 0) + { + LOG_D("nt26k connect to tcp server success"); + nt26k_conncet_tcp_flag = 1; + at_delete_resp(resp); + return RT_EOK; + } + else + { + at_device_nt26k_disconnect_tcp(device); + LOG_E("nt26k connect to tcp server failed. error code: %d",err_code); + } } else { - mb26_conncet_tcp_flag = 0; - LOG_E("mb26 connect to tcp server failed."); + nt26k_conncet_tcp_flag = 0; + LOG_E("nt26k connect to tcp server failed."); } } rt_thread_mdelay(5000); @@ -414,14 +408,15 @@ static int at_device_mb26_connect_tcp(struct at_device *device) int at_send_data(struct at_device *device, const char *data, rt_size_t size) { -#define MB26_SEND_RESP_TIME (3000) - +#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, 0, MB26_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); if (resp == RT_NULL) { - LOG_E("no memory for mb26 device(%s) response structure.", device->name); + LOG_E("no memory for nt26k device(%s) response structure.", device->name); at_delete_resp(resp); return -RT_ERROR; } @@ -429,17 +424,17 @@ 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());//获取一个随机延时 - if (at_obj_exec_cmd(device->client, resp, TCP_SEND_DATA, socket_id, size, data, AT_SEND_MSOSD_FLAG_DEFAULT) == RT_EOK) + if (at_obj_exec_cmd(device->client, resp, TCP_SEND_DATA, socket_id, data) == RT_EOK) { - if (at_resp_get_line_by_kw(resp, "OK") != RT_NULL) + if ((line_buffer = at_resp_get_line(resp, 2)) != RT_NULL) { - at_delete_resp(resp); - return RT_EOK; - } - else - { - LOG_E("send data error, retry %d times, socket_id: %d", retry + 1, socket_id); - } + if (rt_strstr(line_buffer, "SEND OK") != RT_NULL) + { + LOG_D("send data success, socket_id: %d", socket_id); + at_delete_resp(resp); + return RT_EOK; + } + } } retry++; rt_thread_mdelay(1000); @@ -449,28 +444,28 @@ int at_send_data(struct at_device *device, const char *data, rt_size_t size) return -RT_ERROR; } -static int mb26_check_link_status(struct at_device *device) +static int nt26k_check_link_status(struct at_device *device) { at_response_t resp = RT_NULL; - struct at_device_mb26 *mb26 = RT_NULL; + struct at_device_nt26k *nt26k = RT_NULL; int result = -RT_ERROR; - mb26 = (struct at_device_mb26 *)device->user_data; - if (!mb26->power_status) // power off + nt26k = (struct at_device_nt26k *)device->user_data; + if (!nt26k->power_status) // power off { LOG_D("the power is off,power on device"); device->class->device_ops->control(device, AT_DEVICE_CTRL_POWER_ON, RT_NULL); // 开启设备 } - if (mb26->sleep_status) // is sleep status + if (nt26k->sleep_status) // is sleep status { - if (mb26->wkp_pin != -1) + if (nt26k->wkp_pin != -1) { - rt_pin_write(mb26->wkp_pin, PIN_LOW); + rt_pin_write(nt26k->wkp_pin, PIN_LOW); rt_thread_mdelay(100); - rt_pin_write(mb26->wkp_pin, PIN_HIGH); + rt_pin_write(nt26k->wkp_pin, PIN_HIGH); rt_thread_mdelay(100); - rt_pin_write(mb26->wkp_pin, PIN_LOW); + rt_pin_write(nt26k->wkp_pin, PIN_LOW); } } @@ -495,7 +490,7 @@ static int mb26_check_link_status(struct at_device *device) } } - if (mb26->sleep_status) // is sleep status + if (nt26k->sleep_status) // is sleep status { if (at_obj_exec_cmd(device->client, resp, "AT+CPSMS=1,,,,\"00100010\"") != RT_EOK) { @@ -508,12 +503,12 @@ static int mb26_check_link_status(struct at_device *device) return (result); } -/* ============================= mb26 network interface operations ============================= */ -/* set mb26 network interface device status and address information */ -static int mb26_netdev_set_info(struct netdev *netdev) +/* ============================= nt26k network interface operations ============================= */ +/* set nt26k network interface device status and address information */ +static int nt26k_netdev_set_info(struct netdev *netdev) { -#define MB26_INFO_RESP_SIZE 128 -#define MB26_INFO_RESP_TIMO rt_tick_from_millisecond(1000) +#define NT26K_INFO_RESP_SIZE 128 +#define NT26K_INFO_RESP_TIMO rt_tick_from_millisecond(1000) int result = RT_EOK; ip_addr_t addr; @@ -534,7 +529,7 @@ static int mb26_netdev_set_info(struct netdev *netdev) netdev_low_level_set_link_status(netdev, RT_TRUE); netdev_low_level_set_dhcp_status(netdev, RT_TRUE); - resp = at_create_resp(MB26_INFO_RESP_SIZE, 0, MB26_INFO_RESP_TIMO); + resp = at_create_resp(NT26K_INFO_RESP_SIZE, 0, NT26K_INFO_RESP_TIMO); if (resp == RT_NULL) { LOG_E("no memory for resp create."); @@ -584,15 +579,15 @@ __exit: } /** - * @brief check mb26 network interface device status + * @brief check nt26k network interface device status * - * @param netdev: mb26 network interface device + * @param netdev: nt26k network interface device */ -static void mb26_check_link_status_entry(void *parameter) +static void nt26k_check_link_status_entry(void *parameter) { -#define MB26_LINK_DELAY_TIME (60 * RT_TICK_PER_SECOND) +#define NT26K_LINK_DELAY_TIME (60 * RT_TICK_PER_SECOND) -#define MB26_LINK_STATUS_OK 1 +#define NT26K_LINK_STATUS_OK 1 int link_status; struct at_device *device = RT_NULL; @@ -607,26 +602,26 @@ static void mb26_check_link_status_entry(void *parameter) while (1) { - link_status = mb26_check_link_status(device); + link_status = nt26k_check_link_status(device); if (link_status < 0) { - rt_thread_mdelay(MB26_LINK_DELAY_TIME); + rt_thread_mdelay(NT26K_LINK_DELAY_TIME); continue; } /* check the network interface device link status */ - if ((MB26_LINK_STATUS_OK == link_status) != netdev_is_link_up(netdev)) + if ((NT26K_LINK_STATUS_OK == link_status) != netdev_is_link_up(netdev)) { - netdev_low_level_set_link_status(netdev, (MB26_LINK_STATUS_OK == link_status)); + netdev_low_level_set_link_status(netdev, (NT26K_LINK_STATUS_OK == link_status)); } - rt_thread_delay(MB26_LINK_DELAY_TIME); + rt_thread_delay(NT26K_LINK_DELAY_TIME); } } -static int mb26_netdev_check_link_status(struct netdev *netdev) +static int nt26k_netdev_check_link_status(struct netdev *netdev) { -#define MB26_LINK_THREAD_TICK 20 -#define MB26_LINK_THREAD_STACK_SIZE (1024 + 512) -#define MB26_LINK_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX - 2) +#define NT26K_LINK_THREAD_TICK 20 +#define NT26K_LINK_THREAD_STACK_SIZE (1024 + 512) +#define NT26K_LINK_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX - 2) rt_thread_t tid; char tname[RT_NAME_MAX] = {0}; @@ -635,9 +630,9 @@ static int mb26_netdev_check_link_status(struct netdev *netdev) rt_snprintf(tname, RT_NAME_MAX, "%s", netdev->name); - /* create mb26 link status polling thread */ - tid = rt_thread_create(tname, mb26_check_link_status_entry, (void *)netdev, - MB26_LINK_THREAD_STACK_SIZE, MB26_LINK_THREAD_PRIORITY, MB26_LINK_THREAD_TICK); + /* create nt26k link status polling thread */ + tid = rt_thread_create(tname, nt26k_check_link_status_entry, (void *)netdev, + NT26K_LINK_THREAD_STACK_SIZE, NT26K_LINK_THREAD_PRIORITY, NT26K_LINK_THREAD_TICK); if (tid != RT_NULL) { rt_thread_startup(tid); @@ -646,9 +641,9 @@ static int mb26_netdev_check_link_status(struct netdev *netdev) return RT_EOK; } -static int mb26_net_init(struct at_device *device); +static int nt26k_net_init(struct at_device *device); -static int mb26_netdev_set_up(struct netdev *netdev) +static int nt26k_netdev_set_up(struct netdev *netdev) { struct at_device *device = RT_NULL; @@ -661,7 +656,7 @@ static int mb26_netdev_set_up(struct netdev *netdev) if (device->is_init == RT_FALSE) { - mb26_net_init(device); + nt26k_net_init(device); device->is_init = RT_TRUE; netdev_low_level_set_status(netdev, RT_TRUE); @@ -671,7 +666,7 @@ static int mb26_netdev_set_up(struct netdev *netdev) return RT_EOK; } -static int mb26_netdev_set_down(struct netdev *netdev) +static int nt26k_netdev_set_down(struct netdev *netdev) { struct at_device *device = RT_NULL; @@ -684,7 +679,7 @@ static int mb26_netdev_set_down(struct netdev *netdev) if (device->is_init == RT_TRUE) { - mb26_power_off(device); + nt26k_power_off(device); device->is_init = RT_FALSE; netdev_low_level_set_status(netdev, RT_FALSE); @@ -694,10 +689,10 @@ static int mb26_netdev_set_down(struct netdev *netdev) return RT_EOK; } -static int mb26_netdev_set_dns_server(struct netdev *netdev, uint8_t dns_num, ip_addr_t *dns_server) +static int nt26k_netdev_set_dns_server(struct netdev *netdev, uint8_t dns_num, ip_addr_t *dns_server) { -#define MB26_DNS_RESP_LEN 64 -#define MB26_DNS_RESP_TIMEO rt_tick_from_millisecond(300) +#define NT26K_DNS_RESP_LEN 64 +#define NT26K_DNS_RESP_TIMEO rt_tick_from_millisecond(300) int result = RT_EOK; at_response_t resp = RT_NULL; @@ -713,7 +708,7 @@ static int mb26_netdev_set_dns_server(struct netdev *netdev, uint8_t dns_num, ip return -RT_ERROR; } - resp = at_create_resp(MB26_DNS_RESP_LEN, 0, MB26_DNS_RESP_TIMEO); + resp = at_create_resp(NT26K_DNS_RESP_LEN, 0, NT26K_DNS_RESP_TIMEO); if (resp == RT_NULL) { LOG_D("no memory for resp create."); @@ -742,7 +737,7 @@ __exit: } #ifdef NETDEV_USING_PING -static int mb26_netdev_ping(struct netdev *netdev, const char *host, size_t data_len, +static int nt26k_netdev_ping(struct netdev *netdev, const char *host, size_t data_len, uint32_t timeout, struct netdev_ping_resp *ping_resp #if RT_VER_NUM >= 0x50100 , @@ -750,13 +745,13 @@ static int mb26_netdev_ping(struct netdev *netdev, const char *host, size_t data #endif ) { -#define MB26_PING_RESP_SIZE 128 -#define MB26_PING_IP_SIZE 16 -#define MB26_PING_TIMEO (MB26_CON_REP_TIME) +#define NT26K_PING_RESP_SIZE 128 +#define NT26K_PING_IP_SIZE 16 +#define NT26K_PING_TIMEO (NT26K_CON_REP_TIME) rt_err_t result = RT_EOK; int response = -1, recv_data_len, ping_time, ttl; - char ip_addr[MB26_PING_IP_SIZE] = {0}; + char ip_addr[NT26K_PING_IP_SIZE] = {0}; at_response_t resp = RT_NULL; struct at_device *device = RT_NULL; @@ -775,7 +770,7 @@ static int mb26_netdev_ping(struct netdev *netdev, const char *host, size_t data return -RT_ERROR; } - resp = at_create_resp(MB26_PING_RESP_SIZE, 4, MB26_PING_TIMEO); + resp = at_create_resp(NT26K_PING_RESP_SIZE, 4, NT26K_PING_TIMEO); if (resp == RT_NULL) { LOG_E("no memory for resp create"); @@ -830,22 +825,22 @@ __exit: } #endif /* NETDEV_USING_PING */ -const struct netdev_ops mb26_netdev_ops = +const struct netdev_ops nt26k_netdev_ops = { - mb26_netdev_set_up, - mb26_netdev_set_down, + nt26k_netdev_set_up, + nt26k_netdev_set_down, RT_NULL, - mb26_netdev_set_dns_server, + nt26k_netdev_set_dns_server, RT_NULL, #ifdef NETDEV_USING_PING - mb26_netdev_ping, + nt26k_netdev_ping, #endif RT_NULL, }; -static struct netdev *mb26_netdev_add(const char *netdev_name) +static struct netdev *nt26k_netdev_add(const char *netdev_name) { #define ETHERNET_MTU 1380 #define HWADDR_LEN 8 @@ -865,7 +860,7 @@ static struct netdev *mb26_netdev_add(const char *netdev_name) } netdev->mtu = ETHERNET_MTU; - netdev->ops = &mb26_netdev_ops; + netdev->ops = &nt26k_netdev_ops; netdev->hwaddr_len = HWADDR_LEN; #ifdef SAL_USING_AT @@ -879,10 +874,10 @@ static struct netdev *mb26_netdev_add(const char *netdev_name) return netdev; } -/* ============================= mb26 device operations ============================= */ +/* ============================= nt26k device operations ============================= */ -/* initialize for mb26 */ -static void mb26_init_thread_entry(void *parameter) +/* initialize for nt26k */ +static void nt26k_init_thread_entry(void *parameter) { #define INIT_RETRY 5 #define CPIN_RETRY 5 @@ -906,16 +901,16 @@ static void mb26_init_thread_entry(void *parameter) } LOG_D("start init %s device.", device->name); - mb26_power_off(device); + nt26k_power_off(device); rt_thread_mdelay(100); while (retry_num--) { - /* power on the mb26 device */ - mb26_power_on(device); + /* power on the nt26k device */ + nt26k_power_on(device); rt_thread_mdelay(1000); - /* wait mb26 startup finish, send AT every 500ms, if receive OK, SYNC success*/ - if (at_client_obj_wait_connect(client, MB26_WAIT_CONNECT_TIME)) + /* wait nt26k startup finish, send AT every 500ms, if receive OK, SYNC success*/ + if (at_client_obj_wait_connect(client, NT26K_WAIT_CONNECT_TIME)) { result = -RT_ETIMEOUT; goto __exit; @@ -934,30 +929,24 @@ static void mb26_init_thread_entry(void *parameter) result = -RT_ERROR; goto __exit; } - - /* disable eDRX mode */ - if (at_obj_exec_cmd(device->client, resp, "AT+CEDRXS=0") != RT_EOK) - { - result = -RT_ERROR; - goto __exit; - } - /* disable PSM mode */ if (at_obj_exec_cmd(device->client, resp, "AT+CPSMS=0") != RT_EOK) { result = -RT_ERROR; goto __exit; } - - /* Get the baudrate */ - if (at_obj_exec_cmd(device->client, resp, "AT+IPR?") != RT_EOK) + /*AT+QICFG="dataformat" 设置收发模式*/ + if (at_obj_exec_cmd(device->client, resp, "AT+QICFG=\"dataformat\",%d,%d",AT_NSONMI_MODE_DEFAULT, AT_NSONMI_MODE_DEFAULT) != RT_EOK) + { + result = -RT_ERROR; + goto __exit; + } + /*设置显示模式*/ + if (at_obj_exec_cmd(device->client, resp, "AT+QICFG=\"viewmode\",1") != RT_EOK) { result = -RT_ERROR; goto __exit; } - at_resp_parse_line_args_by_kw(resp, "+IPR:", "+IPR: %d", &i); - LOG_D("%s device baudrate %d", device->name, i); - /* get module version */ if (at_obj_exec_cmd(device->client, resp, "AT+CGMR") != RT_EOK) { @@ -970,20 +959,17 @@ static void mb26_init_thread_entry(void *parameter) } /* set network interface device hardware address(IMEI) */ { -#define MB26_NETDEV_HWADDR_LEN 8 -#define MB26_IMEI_LEN 15 +#define NT26K_NETDEV_HWADDR_LEN 8 +#define NT26K_IMEI_LEN 15 - char imei[MB26_IMEI_LEN] = {0}; - // int i = 0, j = 0; - - /* send "AT+GSN" commond to get device IMEI */ - if (at_obj_exec_cmd(device->client, resp, "AT+CGSN=1") != RT_EOK) + char imei[NT26K_IMEI_LEN] = {0}; + /* send "AT+CGSN" commond to get device IMEI */ + if (at_obj_exec_cmd(device->client, resp, "AT+CGSN") != RT_EOK) { result = -RT_ERROR; goto __exit; } - - if (at_resp_parse_line_args_by_kw(resp, "+CGSN:", "+CGSN:%s", imei) <= 0) + if (at_resp_parse_line_args_by_kw(resp, "86", "%s", imei) <= 0) { LOG_E("%s device prase \"AT+CGSN=1\" cmd error.", device->name); result = -RT_ERROR; @@ -992,8 +978,8 @@ static void mb26_init_thread_entry(void *parameter) LOG_D("%s device IMEI number: %s", device->name, imei); - rt_memcpy(mb26.imei, imei, MB26_IMEI_LEN); - Flash_Sys_Cfg(kNbImeiId, mb26.imei, MB26_IMEI_LEN); + rt_memcpy(nt26k.imei, imei, NT26K_IMEI_LEN); + Flash_Sys_Cfg(kNbImeiId, nt26k.imei, NT26K_IMEI_LEN); } /* check SIM card */ for (i = 0; i < CPIN_RETRY; i++) @@ -1035,9 +1021,9 @@ static void mb26_init_thread_entry(void *parameter) /* set network interface device hardware iccid */ { -#define MB26_ICCID_LEN 20 +#define NT26K_ICCID_LEN 20 - char iccid[MB26_ICCID_LEN] = {0}; + 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) @@ -1054,16 +1040,16 @@ static void mb26_init_thread_entry(void *parameter) LOG_D("%s device iccid number: %s", device->name, iccid); - rt_memcpy(mb26.iccid, iccid, MB26_ICCID_LEN); - Flash_Sys_Cfg(kNbIccidId, mb26.iccid, MB26_ICCID_LEN); + rt_memcpy(nt26k.iccid, iccid, NT26K_ICCID_LEN); + Flash_Sys_Cfg(kNbIccidId, nt26k.iccid, NT26K_ICCID_LEN); } /* set network interface device hardware imsi */ { -#define MB26_IMSI_LEN 15 +#define NT26K_IMSI_LEN 15 - char imsi[MB26_IMSI_LEN] = {0}; + char imsi[NT26K_IMSI_LEN] = {0}; /* send "AT+CIMI" commond to get device imsi */ if (at_obj_exec_cmd(device->client, resp, "AT+CIMI") != RT_EOK) @@ -1080,8 +1066,8 @@ static void mb26_init_thread_entry(void *parameter) LOG_D("%s device imsi number: %s", device->name, imsi); - rt_memcpy(mb26.imsi, imsi, MB26_IMSI_LEN); - Flash_Sys_Cfg(kNbImsiId, mb26.imsi, MB26_IMSI_LEN); + rt_memcpy(nt26k.imsi, imsi, NT26K_IMSI_LEN); + Flash_Sys_Cfg(kNbImsiId, nt26k.imsi, NT26K_IMSI_LEN); } /* check signal strength */ @@ -1098,7 +1084,7 @@ static void mb26_init_thread_entry(void *parameter) { LOG_D("%s device signal strength: %d, channel bit err_rate: %d", device->name, signal_strength, err_rate); - mb26.rssi = signal_strength; + nt26k.rssi = signal_strength; break; } } @@ -1138,31 +1124,6 @@ static void mb26_init_thread_entry(void *parameter) goto __exit; } - /* check the GPRS network IP address */ - for (i = 0; i < IPADDR_RETRY; i++) - { - - if (at_obj_exec_cmd(device->client, resp, "AT+CGPADDR=0") == RT_EOK) - { -#define IP_ADDR_SIZE_MAX 16 - char ipaddr[IP_ADDR_SIZE_MAX] = {0}; - - /* parse response data "+CGPADDR: 1," */ - if (at_resp_parse_line_args_by_kw(resp, "+CGPADDR:", "+CGPADDR: %*d,%s", ipaddr) > 0) - { - LOG_D("%s device IP address: %s", device->name, ipaddr); - break; - } - } - rt_thread_mdelay(1000); - } - if (i == IPADDR_RETRY) - { - LOG_E("%s device GPRS is get IP address failed", device->name); - result = -RT_ERROR; - goto __exit; - } - /* initialize successfully */ result = RT_EOK; break; @@ -1170,8 +1131,8 @@ static void mb26_init_thread_entry(void *parameter) __exit: if (result != RT_EOK) { - /* power off the mb26 device */ - // mb26_power_off(device); + /* power off the nt26k device */ + // nt26k_power_off(device); rt_thread_mdelay(1000); LOG_I("%s device initialize retry...", device->name); @@ -1186,11 +1147,11 @@ static void mb26_init_thread_entry(void *parameter) if (result == RT_EOK) { /* set network interface device status and address information */ - mb26_netdev_set_info(device->netdev); + // nt26k_netdev_set_info(device->netdev); /* check and create link staus sync thread */ - mb26_netdev_check_link_status(device->netdev); + // nt26k_netdev_check_link_status(device->netdev); LOG_I("%s device network initialize success.", device->name); - rt_completion_done(&mb26_init_complate); // 通知初始化完成 + rt_completion_done(&nt26k_init_complate); // 通知初始化完成 } else { @@ -1198,16 +1159,16 @@ static void mb26_init_thread_entry(void *parameter) } } -/* mb26 device network initialize */ -static int mb26_net_init(struct at_device *device) +/* nt26k device network initialize */ +static int nt26k_net_init(struct at_device *device) { -#ifdef AT_DEVICE_MB26_INIT_ASYN +#ifdef AT_DEVICE_NT26K_INIT_ASYN rt_thread_t tid; /* 初始化完成量对象 */ - rt_completion_init(&mb26_init_complate); + rt_completion_init(&nt26k_init_complate); - tid = rt_thread_create("mb26_net", mb26_init_thread_entry, (void *)device, - MB26_THREAD_STACK_SIZE, MB26_THREAD_PRIORITY, 20); + tid = rt_thread_create("nt26k_net", nt26k_init_thread_entry, (void *)device, + NT26K_THREAD_STACK_SIZE, NT26K_THREAD_PRIORITY, 20); if (tid) { rt_thread_startup(tid); @@ -1218,8 +1179,8 @@ static int mb26_net_init(struct at_device *device) return -RT_ERROR; } #else - mb26_init_thread_entry(device); -#endif /* AT_DEVICE_MB26_INIT_ASYN */ + nt26k_init_thread_entry(device); +#endif /* AT_DEVICE_NT26K_INIT_ASYN */ return RT_EOK; } @@ -1241,7 +1202,7 @@ void remove_crlf(char *str) } } -rt_err_t Mb26_Get_Signal_Info(struct at_device *device) +rt_err_t Nt26k_Get_Signal_Info(struct at_device *device) { #define RETRY 20 @@ -1271,7 +1232,7 @@ rt_err_t Mb26_Get_Signal_Info(struct at_device *device) { LOG_D("%s device signal strength: %d, channel bit err_rate: %d", device->name, signal_strength, err_rate); - mb26.rssi = signal_strength; + nt26k.rssi = signal_strength; break; } } @@ -1299,8 +1260,8 @@ rt_err_t Mb26_Get_Signal_Info(struct at_device *device) { LOG_D("%s device signal rsrp: %d, rsrq: %d", device->name, rsrp, rsrq); - mb26.rsrp = rsrp; - mb26.rsrq = rsrq; + nt26k.rsrp = rsrp; + nt26k.rsrq = rsrq; break; } } @@ -1332,9 +1293,9 @@ rt_err_t Mb26_Get_Signal_Info(struct at_device *device) if (snr != 0 && pci != 0) { - mb26.pci = pci; - mb26.snr = snr; - LOG_D("pci:%d,snr:%d", mb26.pci, mb26.snr); + nt26k.pci = pci; + nt26k.snr = snr; + LOG_D("pci:%d,snr:%d", nt26k.pci, nt26k.snr); break; } else @@ -1363,30 +1324,30 @@ rt_err_t Mb26_Get_Signal_Info(struct at_device *device) return result; } -/* mb26 device network interface attach +/* nt26k device network interface attach * - set network interface device link status */ -static int mb26_init(struct at_device *device) +static int nt26k_init(struct at_device *device) { - struct at_device_mb26 *mb26 = RT_NULL; + struct at_device_nt26k *nt26k = RT_NULL; RT_ASSERT(device); - mb26 = (struct at_device_mb26 *)device->user_data; - mb26->power_status = RT_FALSE; // default power is off. - mb26->sleep_status = RT_FALSE; // default sleep is disabled. + nt26k = (struct at_device_nt26k *)device->user_data; + nt26k->power_status = RT_FALSE; // default power is off. + nt26k->sleep_status = RT_FALSE; // default sleep is disabled. /* initialize AT client */ #if RT_VER_NUM >= 0x50100 - at_client_init(mb26->client_name, mb26->recv_line_num, mb26->recv_line_num); + at_client_init(nt26k->client_name, nt26k->recv_line_num, nt26k->recv_line_num); #else - at_client_init(mb26->client_name, mb26->recv_line_num); + at_client_init(nt26k->client_name, nt26k->recv_line_num); #endif - device->client = at_client_get(mb26->client_name); + device->client = at_client_get(nt26k->client_name); if (device->client == RT_NULL) { - LOG_E("get AT client(%s) failed.", mb26->client_name); + LOG_E("get AT client(%s) failed.", nt26k->client_name); return -RT_ERROR; } @@ -1394,43 +1355,43 @@ static int mb26_init(struct at_device *device) at_obj_set_urc_table(device->client, urc_table, sizeof(urc_table) / sizeof(urc_table[0])); #ifdef AT_USING_SOCKET - mb26_socket_init(device); + nt26k_socket_init(device); #endif - /* add mb26 device to the netdev list */ - device->netdev = mb26_netdev_add(mb26->device_name); + /* add nt26k device to the netdev list */ + device->netdev = nt26k_netdev_add(nt26k->device_name); if (device->netdev == RT_NULL) { - LOG_E("add netdev(%s) failed.", mb26->device_name); + LOG_E("add netdev(%s) failed.", nt26k->device_name); return -RT_ERROR; } - /* initialize mb26 pin configuration */ - if (mb26->pwr_en_pin != -1) + /* initialize nt26k pin configuration */ + if (nt26k->pwr_en_pin != -1) { - rt_pin_mode(mb26->pwr_en_pin, PIN_MODE_OUTPUT); - // rt_pin_write(mb26->pwr_en_pin, PIN_LOW); + rt_pin_mode(nt26k->pwr_en_pin, PIN_MODE_OUTPUT); + // rt_pin_write(nt26k->pwr_en_pin, PIN_LOW); } - if (mb26->rst_pin != -1) + if (nt26k->rst_pin != -1) { - rt_pin_mode(mb26->rst_pin, PIN_MODE_OUTPUT); + rt_pin_mode(nt26k->rst_pin, PIN_MODE_OUTPUT); } - if (mb26->wkp_pin != -1) + if (nt26k->wkp_pin != -1) { - rt_pin_mode(mb26->wkp_pin, PIN_MODE_OUTPUT); + rt_pin_mode(nt26k->wkp_pin, PIN_MODE_OUTPUT); } - /* initialize mb26 device network */ - return mb26_netdev_set_up(device->netdev); + /* initialize nt26k device network */ + return nt26k_netdev_set_up(device->netdev); } -static int mb26_deinit(struct at_device *device) +static int nt26k_deinit(struct at_device *device) { RT_ASSERT(device); - return mb26_netdev_set_down(device->netdev); + return nt26k_netdev_set_down(device->netdev); } -static int mb26_control(struct at_device *device, int cmd, void *arg) +static int nt26k_control(struct at_device *device, int cmd, void *arg) { int result = -RT_ERROR; @@ -1439,28 +1400,28 @@ static int mb26_control(struct at_device *device, int cmd, void *arg) switch (cmd) { case AT_DEVICE_CTRL_SLEEP: - result = mb26_sleep(device); + result = nt26k_sleep(device); break; case AT_DEVICE_CTRL_WAKEUP: - result = mb26_wakeup(device); + result = nt26k_wakeup(device); break; case AT_DEVICE_CTRL_NET_CONN: - result = at_device_mb26_connect_tcp(device); + result = at_device_nt26k_connect_tcp(device); break; case AT_DEVICE_CTRL_NET_DISCONN: - result = at_device_mb26_disconnect_tcp(device); // 直接删除Socket + result = at_device_nt26k_disconnect_tcp(device); // 直接删除Socket break; case AT_DEVICE_CTRL_GET_SIGNAL: - result = Mb26_Get_Signal_Info(device); + result = Nt26k_Get_Signal_Info(device); break; case AT_DEVICE_CTRL_RESET: - result = Mb26_Reset(device); + result = Nt26k_Reset(device); break; case AT_DEVICE_CTRL_POWER_ON: - result = mb26_power_on(device); + result = nt26k_power_on(device); break; case AT_DEVICE_CTRL_POWER_OFF: - result = mb26_power_off(device); + result = nt26k_power_off(device); break; case AT_DEVICE_CTRL_LOW_POWER: case AT_DEVICE_CTRL_SET_WIFI_INFO: @@ -1509,7 +1470,7 @@ int Time_Calibration(struct at_device *device) ; // 网络时间 int year, mounth, days, hous, min, sec; /*+CCLK:24/11/12,06:08:19+32*/ - if (at_resp_parse_line_args_by_kw(resp, "+CCLK:", "+CCLK:%d/%d/%d,%d:%d:%d+32", &year, &mounth, &days, &hous, &min, &sec) > 0) + if (at_resp_parse_line_args_by_kw(resp, "+CCLK:", "+CCLK: \"%d/%d/%d,%d:%d:%d+32\"", &year, &mounth, &days, &hous, &min, &sec) > 0) { rtc_dt.year = (2000 + year); rtc_dt.month = mounth; @@ -1531,14 +1492,14 @@ int Time_Calibration(struct at_device *device) return RT_ERROR; } -const struct at_device_ops mb26_device_ops = +const struct at_device_ops nt26k_device_ops = { - mb26_init, - mb26_deinit, - mb26_control, + nt26k_init, + nt26k_deinit, + nt26k_control, }; -int mb26_device_class_register(void) +int nt26k_device_class_register(void) { struct at_device_class *class = RT_NULL; @@ -1549,11 +1510,11 @@ int mb26_device_class_register(void) rt_free(class); return -RT_ENOMEM; } - class->device_ops = &mb26_device_ops; + class->device_ops = &nt26k_device_ops; - return at_device_class_register(class, AT_DEVICE_CLASS_MB26); + return at_device_class_register(class, AT_DEVICE_CLASS_NT26K); } -// INIT_DEVICE_EXPORT(mb26_device_class_register); -#endif //! NB_MODULE_SWITCH +// INIT_DEVICE_EXPORT(nt26k_device_class_register); +#endif //! IOT_MODULE_SWITCH -#endif /* AT_DEVICE_USING_MB26 */ +#endif /* AT_DEVICE_USING_NT26K */ diff --git a/bsp/src/bsp_flash.c b/bsp/src/bsp_flash.c index 70e00e6..3a8f08b 100644 --- a/bsp/src/bsp_flash.c +++ b/bsp/src/bsp_flash.c @@ -3,7 +3,7 @@ #include "bsp_rtc.h" // #include "bsp_wdg.h" #include "bsp_hr.h" -#include "at_device_mb26.h" +#include "at_device_nt26k.h" #include #include #include "user_sys.h" @@ -93,6 +93,8 @@ struct flash_sever_info sever_info = { .server_url = "8.130.117.149", .server_port = "7137", + // .server_url = "8.135.10.183", + // .server_port = "36125," }; diff --git a/bsp/src/bsp_h308.c b/bsp/src/bsp_h308.c index 03696cc..4039733 100644 --- a/bsp/src/bsp_h308.c +++ b/bsp/src/bsp_h308.c @@ -2,7 +2,7 @@ * @Author: mbw * @Date: 2024-11-14 10:21:04 * @LastEditors: mbw && 1600520629@qq.com - * @LastEditTime: 2024-12-30 09:24:19 + * @LastEditTime: 2024-12-30 17:30:15 * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\src\bsp_h308.c * @Description: * @@ -285,7 +285,7 @@ static void h308_thread_entry(void *param) if (len >= 44) { ret = H308_GetFrameData(str, len, &H308.Data); - // LOG_I("str:[%s]", str); + LOG_I("str:[%s]", str); if (ret == 0) { H308_CheckData(); diff --git a/bsp/src/bsp_hr.c b/bsp/src/bsp_hr.c index 6fbcd25..1a926ed 100644 --- a/bsp/src/bsp_hr.c +++ b/bsp/src/bsp_hr.c @@ -13,7 +13,7 @@ #include "lwrb.h" #include "bsp_flash.h" #include "bsp_rtc.h" -#include "at_device_mb26.h" +#include "at_device_nt26k.h" #include "user_sys.h" #include #include "bsp_emv.h" diff --git a/bsp/src/bsp_led.c b/bsp/src/bsp_led.c index 69be81f..16d4eaf 100644 --- a/bsp/src/bsp_led.c +++ b/bsp/src/bsp_led.c @@ -1,7 +1,7 @@ #include "bsp_led.h" #include "rtthread.h" #include "pin.h" -#include "bsp_mb26.h" +#include "bsp_nt26k.h" #include "user_sys.h" @@ -27,7 +27,7 @@ static void BSP_Led_thread_entry(void *param) while (1) { #if 0 - if (mb26_conncet_tcp_flag) + if (nt26k_conncet_tcp_flag) { if ((SysControl.status == kNormalDetectionEvents) && (led_state_flag != RT_TRUE)) { diff --git a/bsp/src/bsp_mb26.c b/bsp/src/bsp_nt26k.c similarity index 50% rename from bsp/src/bsp_mb26.c rename to bsp/src/bsp_nt26k.c index a749165..6386342 100644 --- a/bsp/src/bsp_mb26.c +++ b/bsp/src/bsp_nt26k.c @@ -2,8 +2,8 @@ * @Author: mbw * @Date: 2024-10-09 08:42:14 * @LastEditors: mbw && 1600520629@qq.com - * @LastEditTime: 2024-12-26 14:35:18 - * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\src\bsp_mb26.c + * @LastEditTime: 2024-12-30 17:33:50 + * @FilePath: \JT-DT-YD4N02A_RTT_MRS-4G\bsp\src\bsp_nt26k.c * @Description: * * Copyright (c) 2024 by ${git_name_email}, All Rights Reserved. @@ -18,9 +18,9 @@ * 2019-12-13 qiyongzhong first version */ -#include +#include #include "drv_gpio.h" -#include "bsp_mb26.h" +#include "bsp_nt26k.h" #include "user_sys.h" #include "bsp_flash.h" #include "bsp_h308.h" @@ -30,213 +30,213 @@ #include "bsp_relay.h" #include "bsp_rng.h" -#define LOG_TAG "mb26" +#define LOG_TAG "nt26k" #include -#if NB_MODULE_SWITCH == 1 -#define MB26_THREAD_STACK_SIZE (4096) -#define MB26_RECV_THREAD_STACK_SIZE (4096) -#define MB26_LIFE_THREAD_STACK_SIZE (1024) -#define MB26_THREAD_PRIORITY 25 -#define MB26_THREAD_TICKS 50 -#define MB26_RECV_THREAD_PRIORITY 24 -#define MB26_RECV_THREAD_TICKS 10 +#if IOT_MODULE_SWITCH == 1 +#define NT26K_THREAD_STACK_SIZE (4096) +#define NT26K_RECV_THREAD_STACK_SIZE (4096) +#define NT26K_LIFE_THREAD_STACK_SIZE (1024) +#define NT26K_THREAD_PRIORITY 25 +#define NT26K_THREAD_TICKS 50 +#define NT26K_RECV_THREAD_PRIORITY 24 +#define NT26K_RECV_THREAD_TICKS 10 -#define MB26_LIFE_THREAD_PRIORITY 26 -#define MB26_LIFE_THREAD_TICKS 10 +#define NT26K_LIFE_THREAD_PRIORITY 26 +#define NT26K_LIFE_THREAD_TICKS 10 -// static rt_uint32_t mb26_status = 0; +// static rt_uint32_t nt26k_status = 0; ALIGN(RT_ALIGN_SIZE) -static char mb26_thread_stack[MB26_THREAD_STACK_SIZE]; -static struct rt_thread mb26_thread; +static char nt26k_thread_stack[NT26K_THREAD_STACK_SIZE]; +static struct rt_thread nt26k_thread; ALIGN(RT_ALIGN_SIZE) -static char mb26_recv_thread_stack[MB26_RECV_THREAD_STACK_SIZE]; -static struct rt_thread mb26_recv_thread; +static char nt26k_recv_thread_stack[NT26K_RECV_THREAD_STACK_SIZE]; +static struct rt_thread nt26k_recv_thread; ALIGN(RT_ALIGN_SIZE) -static char mb26_life_thread_stack[MB26_LIFE_THREAD_STACK_SIZE]; -static struct rt_thread mb26_life_thread; +static char nt26k_life_thread_stack[NT26K_LIFE_THREAD_STACK_SIZE]; +static struct rt_thread nt26k_life_thread; struct rt_event at_device_event; -rt_sem_t mb26_recv_sem; -rt_sem_t mb26_life_sem; -static rt_timer_t mb26_timer; // 上报心跳 -static rt_timer_t mb26_upload_timer; // 更新本地时间定时器 -static rt_timer_t mb26_power_error_timer; // 上电失败情况下启动定时器 +rt_sem_t nt26k_recv_sem; +rt_sem_t nt26k_life_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 mb26_life_timer; -rt_uint8_t mb26_conncet_tcp_flag; -Mb26EventIndex mb26_event_index; +static rt_timer_t nt26k_life_timer; +rt_uint8_t nt26k_conncet_tcp_flag; +Nt26kEventIndex nt26k_event_index; rt_uint8_t power_on_send_flag = 0; -rt_mutex_t mb26_mutex; -int BSP_Mb26_Init(struct Mb26_Ops *ops, rt_uint8_t version); -int BSP_Mb26_Update(struct Mb26_Ops *ops, rt_uint8_t device_type, rt_uint8_t event_type); -int Mb26_Send_Data(struct Mb26_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type); -int Data_Resp(struct Mb26_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type, char *data, rt_uint8_t res); -int Mb26_Recv_Data(struct Mb26_Ops *ops, char *data); +rt_mutex_t nt26k_mutex; +int BSP_Nt26k_Init(struct Nt26k_Ops *ops, rt_uint8_t version); +int BSP_Nt26k_Update(struct Nt26k_Ops *ops, rt_uint8_t device_type, rt_uint8_t event_type); +int Nt26k_Send_Data(struct Nt26k_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type); +int Data_Resp(struct Nt26k_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type, char *data, rt_uint8_t res); +int Nt26k_Recv_Data(struct Nt26k_Ops *ops, char *data); static struct DataBody body; -static struct Mb26DataFrame frame; -static struct Mb26RecvData mb26_recv; +static struct Nt26kDataFrame frame; +static struct Nt26kRecvData nt26k_recv; -struct Mb26_Ops mb26_ops = { +struct Nt26k_Ops nt26k_ops = { .body = &body, .frame = &frame, - .recv = &mb26_recv, - .init = BSP_Mb26_Init, - .update_data = BSP_Mb26_Update, - .send = Mb26_Send_Data, + .recv = &nt26k_recv, + .init = BSP_Nt26k_Init, + .update_data = BSP_Nt26k_Update, + .send = Nt26k_Send_Data, .Resp = Data_Resp, - // .Recv = Mb26_Recv_Data,//，没用到 + // .Recv = Nt26k_Recv_Data,//，没用到 }; -static struct at_device_mb26 _dev = +static struct at_device_nt26k _dev = { - MB26_SAMPLE_DEIVCE_NAME, - MB26_SAMPLE_CLIENT_NAME, + NT26K_SAMPLE_DEIVCE_NAME, + NT26K_SAMPLE_CLIENT_NAME, - MB26_PWR_EN_PIN, - MB26_RST_PIN, - MB26_WKP_PIN, + NT26K_PWR_EN_PIN, + NT26K_RST_PIN, + NT26K_WKP_PIN, - MB26_SAMPLE_RECV_BUFF_LEN, + NT26K_SAMPLE_RECV_BUFF_LEN, }; -static rt_uint32_t mb26_event_flags[kMb26MaxEventcnt] = {0}; -static rt_bool_t mb26_event_initialized = RT_FALSE; // 是否初始化完成 +static rt_uint32_t nt26k_event_flags[kNt26kMaxEventcnt] = {0}; +static rt_bool_t nt26k_event_initialized = RT_FALSE; // 是否初始化完成 typedef enum { - MB26_PRIORITY_LOWEST, // 4、优先级最低（定时心跳、浓度异常、报警触发、报警解除、传感器故障触发 传感器故障解除） - MB26_PRIORITY_MEDIUM, // 2、优先级第三高 自检触发 - MB26_PRIORITY_HIGH, // 1、优先级第二高 掉电 - MB26_PRIORITY_HIGHEST, // 0 优先级最高(设备上电时的定时心跳) -} Mb26Priority; + NT26K_PRIORITY_LOWEST, // 4、优先级最低（定时心跳、浓度异常、报警触发、报警解除、传感器故障触发 传感器故障解除） + NT26K_PRIORITY_MEDIUM, // 2、优先级第三高 自检触发 + NT26K_PRIORITY_HIGH, // 1、优先级第二高 掉电 + NT26K_PRIORITY_HIGHEST, // 0 优先级最高(设备上电时的定时心跳) +} Nt26kPriority; typedef struct { - Mb26Event event_flag; - Mb26Priority priority; + Nt26kEvent event_flag; + Nt26kPriority priority; const char *event_name; int (*send_func)(struct at_device *device, void *param); -} Mb26EventInfo; +} Nt26kEventInfo; -static void Mb26_Set_Event(Mb26Event event_type) +static void Nt26k_Set_Event(Nt26kEvent event_type) { - if (event_type < kMb26MaxEventcnt) + if (event_type < kNt26kMaxEventcnt) { - mb26_event_flags[event_type] = (1 << event_type); + nt26k_event_flags[event_type] = (1 << event_type); } } -void Mb26_Event_Init(void) +void Nt26k_Event_Init(void) { - rt_err_t ret = rt_event_init(&at_device_event, "mb26_event", RT_IPC_FLAG_PRIO); + rt_err_t ret = rt_event_init(&at_device_event, "nt26k_event", RT_IPC_FLAG_PRIO); if (ret == RT_EOK) { - mb26_event_initialized = RT_TRUE; - for (Mb26Event event = kMb26HeartbeatEvent; event < kMb26MaxEventcnt; event++) + nt26k_event_initialized = RT_TRUE; + for (Nt26kEvent event = kNt26kHeartbeatEvent; event < kNt26kMaxEventcnt; event++) { - Mb26_Set_Event(event); + Nt26k_Set_Event(event); } } else { - LOG_E("mb26_event init failed!"); + LOG_E("nt26k_event init failed!"); } } -rt_uint32_t Mb26_Get_Event_Flag(Mb26Event event_type) +rt_uint32_t Nt26k_Get_Event_Flag(Nt26kEvent event_type) { - if (event_type < kMb26MaxEventcnt) + if (event_type < kNt26kMaxEventcnt) { - return mb26_event_flags[event_type]; + return nt26k_event_flags[event_type]; } return 0; } -void Mb26_Send_Event(Mb26Event event_type) +void Nt26k_Send_Event(Nt26kEvent event_type) { - LOG_D("Send_Mb26_Event = %d", event_type); - mb26_event_index.last_event = mb26_event_index.current_event; - mb26_event_index.current_event = event_type; - if (mb26_event_initialized == RT_TRUE) + LOG_D("Send_Nt26k_Event = %d", event_type); + nt26k_event_index.last_event = nt26k_event_index.current_event; + nt26k_event_index.current_event = event_type; + if (nt26k_event_initialized == RT_TRUE) { - rt_event_send(&at_device_event, Mb26_Get_Event_Flag(event_type)); + rt_event_send(&at_device_event, Nt26k_Get_Event_Flag(event_type)); } else { - LOG_E("mb26_event_initialized is false"); + LOG_E("nt26k_event_initialized is false"); } } // 定义定时器回调函数 -static void Mb26_Ht_Timer_Cb(void *parameter) +static void Nt26k_Ht_Timer_Cb(void *parameter) { - Mb26_Send_Event(kMb26HeartbeatEvent); + Nt26k_Send_Event(kNt26kHeartbeatEvent); } // 定时器回调函数,当1分钟内没有数据交互时，关闭tcp连接 -static void Mb26_Life_Timer_Cb(void *parameter) +static void Nt26k_Life_Timer_Cb(void *parameter) { - rt_sem_release(mb26_life_sem); + rt_sem_release(nt26k_life_sem); } // 定时器回调函数,当1分钟内没有数据交互时，关闭tcp连接 -static void Mb26_Error_Timer_Cb(void *parameter) +static void Nt26k_Error_Timer_Cb(void *parameter) { if (power_on_send_flag) // 上电成功时，停止定时器 { - rt_timer_stop(mb26_power_error_timer); + rt_timer_stop(nt26k_power_error_timer); } else { - Mb26_Send_Event(kMb26PowerOnEvent); + Nt26k_Send_Event(kNt26kPowerOnEvent); } } // 重置定时器 -void Reset_Mb26_Life_Timer(void) +void Reset_Nt26k_Life_Timer(void) { - if (mb26_life_timer != RT_NULL) + if (nt26k_life_timer != RT_NULL) { - // rt_timer_stop(mb26_life_timer);//启动这个时，他会自动清除以前的定时器，所以不必担心是否已经启动的问题，困扰我不少时间，点进去第一二句就是 - rt_timer_start(mb26_life_timer); + // rt_timer_stop(nt26k_life_timer);//启动这个时，他会自动清除以前的定时器，所以不必担心是否已经启动的问题，困扰我不少时间，点进去第一二句就是 + rt_timer_start(nt26k_life_timer); } } -int _Pack_Send(struct Mb26_Ops *ops, char *buf) +int _Pack_Send(struct Nt26k_Ops *ops, char *buf) { - char mb26_send_buf[512] = {0}; // 发送缓冲区，用于存储最终发送的数据 + char nt26k_send_buf[512] = {0}; // 发送缓冲区，用于存储最终发送的数据 // char byteArr1[512]; // 转换成字节值 unsigned short crc16 = 0; // 存储CRC16校验和 - struct at_device *device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, MB26_SAMPLE_DEIVCE_NAME); + struct at_device *device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, NT26K_SAMPLE_DEIVCE_NAME); ASSERT(device); crc16 = crc1021(buf, rt_strlen(buf)); LOG_D("buf: %s", buf); LOG_D("crc16: %X", crc16); // 将数据、校验和及尾部标识添加到发送缓冲区中 - if (rt_snprintf(mb26_send_buf, sizeof(mb26_send_buf), + if (rt_snprintf(nt26k_send_buf, sizeof(nt26k_send_buf), "%s%04X%02X%02X%02X", buf, crc16, ops->frame->tail[0], ops->frame->tail[1], - ops->frame->tail[2]) >= sizeof(mb26_send_buf)) + ops->frame->tail[2]) >= sizeof(nt26k_send_buf)) { // 发生缓冲区溢出 - LOG_E("Buffer overflow in mb26_send_buf"); + LOG_E("Buffer overflow in nt26k_send_buf"); return -RT_ERROR; } // 打印调试信息 - // LOG_D("mb26_send_buf: %s", mb26_send_buf); - rt_uint16_t data_len = rt_strlen(mb26_send_buf); - // 通过AT指令发送数据给MB26模块 - if (at_send_data(device, mb26_send_buf, data_len / 2) != RT_EOK) + // LOG_D("nt26k_send_buf: %s", nt26k_send_buf); + rt_uint16_t data_len = rt_strlen(nt26k_send_buf); + // 通过AT指令发送数据给NT26K模块 + if (at_send_data(device, nt26k_send_buf, data_len / 2) != RT_EOK) { return -RT_ERROR; } @@ -245,10 +245,10 @@ int _Pack_Send(struct Mb26_Ops *ops, char *buf) } /** - * @brief 发送数据到mb26模块 + * @brief 发送数据到nt26k模块 * * 本函数根据提供的数据和参数构建一个格式化字符串，计算其CRC16校验和， - * 然后将该字符串发送给MB26模块 + * 然后将该字符串发送给NT26K模块 *@param version 协议版本 * @param data 要发送的十六进制数据字符串 * @param len 数据字符串的十六进制数据格式长度 @@ -256,13 +256,13 @@ int _Pack_Send(struct Mb26_Ops *ops, char *buf) * @param cmd_num 命令编号 * @return int 返回0表示成功，非零表示失败 */ -static int _Send_Handle(struct Mb26_Ops *ops, rt_size_t data_num, rt_size_t cmd_num, const char *data) +static int _Send_Handle(struct Nt26k_Ops *ops, rt_size_t data_num, rt_size_t cmd_num, const char *data) { // 临时缓冲区，用于格式化数据 char data_buf[512] = {0}; rt_size_t data_len = rt_strlen(data); - // 格式化数据，构建发送给MB26模块的数据包 + // 格式化数据，构建发送给NT26K模块的数据包 rt_int32_t len = rt_snprintf(data_buf, sizeof(data_buf), "%02X%02X%02X%02X%04X%04X%02X%04X%s", ops->frame->header[0], @@ -286,14 +286,14 @@ static int _Send_Handle(struct Mb26_Ops *ops, rt_size_t data_num, rt_size_t cmd_ } // 初始化函数 -int BSP_Mb26_Init(struct Mb26_Ops *ops, rt_uint8_t version) +int BSP_Nt26k_Init(struct Nt26k_Ops *ops, rt_uint8_t version) { if (ops->frame == RT_NULL) { LOG_E("Memory allocation failed"); return -RT_ENOMEM; } - rt_memset(ops->frame, 0, sizeof(struct Mb26DataFrame)); + rt_memset(ops->frame, 0, sizeof(struct Nt26kDataFrame)); ops->frame->header[0] = 0x4A; ops->frame->header[1] = 0x54; @@ -309,13 +309,13 @@ int BSP_Mb26_Init(struct Mb26_Ops *ops, rt_uint8_t version) return RT_EOK; } // 更新函数 -int BSP_Mb26_Update(struct Mb26_Ops *ops, rt_uint8_t device_type, rt_uint8_t event_type) +int BSP_Nt26k_Update(struct Nt26k_Ops *ops, rt_uint8_t device_type, rt_uint8_t event_type) { ops->body->device_type = device_type; ops->body->event_type = event_type; ops->body->hw = (rt_uint8_t)Flash_Get_SysCfg(kHwVerId); ops->body->sw = (rt_uint8_t)Flash_Get_SysCfg(kSwVerId); - rt_memcpy(ops->body->imei, &mb26, sizeof(mb26_sys_info)); // 直接赋值结构体数据 + rt_memcpy(ops->body->imei, &nt26k, sizeof(nt26k_sys_info)); // 直接赋值结构体数据 rt_memcpy(&(ops->body->lel), &H308.Data, (rt_ubase_t)offsetof(TsH308Data, checksum)); // 复制除了校验码以外的数据 ops->body->product_work_temperature = ops->body->temp; // 暂时定为激光器测量的环境温度 ops->body->work_duration = work_duration; @@ -326,7 +326,7 @@ int BSP_Mb26_Update(struct Mb26_Ops *ops, rt_uint8_t device_type, rt_uint8_t eve return RT_EOK; } -int Mb26_Send_Data(struct Mb26_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type) +int Nt26k_Send_Data(struct Nt26k_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type) { int ret = 0; char data_buf[512] = {0}; @@ -344,8 +344,8 @@ int Mb26_Send_Data(struct Mb26_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt return RT_ERROR; } rt_memset(ops->body, 0, sizeof(struct DataBody)); - rt_mutex_take(mb26_mutex, RT_WAITING_FOREVER); - ret = mb26_ops.update_data(ops, device_type, event_type); + rt_mutex_take(nt26k_mutex, RT_WAITING_FOREVER); + ret = nt26k_ops.update_data(ops, device_type, event_type); if (ret == RT_EOK) { for (int i = 0; i < sizeof(struct DataBody); i++) @@ -359,15 +359,15 @@ int Mb26_Send_Data(struct Mb26_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt ret = -ret; } } - rt_mutex_release(mb26_mutex); + rt_mutex_release(nt26k_mutex); return ret; } -int Data_Resp(struct Mb26_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type, char *data, rt_uint8_t res) +int Data_Resp(struct Nt26k_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint8_t device_type, rt_uint8_t event_type, char *data, rt_uint8_t res) { - if (mb26_conncet_tcp_flag != 1) + if (nt26k_conncet_tcp_flag != 1) { - LOG_E("mb26_conncet_tcp_flag error"); + LOG_E("nt26k_conncet_tcp_flag error"); return -RT_ERROR; } @@ -383,7 +383,7 @@ int Data_Resp(struct Mb26_Ops *ops, rt_uint8_t data_num, rt_uint8_t cmd, rt_uint return _Send_Handle(ops, data_num, cmd, data_buf); } -int Mb26_Recv_Data(struct Mb26_Ops *ops, char *data) +int Nt26k_Recv_Data(struct Nt26k_Ops *ops, char *data) { // ops->body = (struct DataBody *)rt_malloc(sizeof(struct DataBody)); // rt_memset(ops->body, 0, sizeof(struct DataBody)); @@ -398,27 +398,27 @@ int Mb26_Recv_Data(struct Mb26_Ops *ops, char *data) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Heartbeat(struct at_device *device, void *param) +int Nt26k_Send_Heartbeat(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; int ret = 0; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } ret = device->class->device_ops->control(device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL); if (ret != RT_EOK) { - LOG_E("mb26 get signal failed\n"); + LOG_E("nt26k get signal failed\n"); return -RT_ERROR; } - ret = mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_DATA_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_HEARTBEAT); + ret = nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_DATA_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_HEARTBEAT); if (ret != RT_EOK) { - LOG_E("mb26 send data failed\n"); + LOG_E("nt26k send data failed\n"); return ret; } @@ -431,18 +431,18 @@ int Mb26_Send_Heartbeat(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Time_Calibration(struct at_device *device, void *param) +int Nt26k_Send_Time_Calibration(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_TIME_CALIBRATION, DEVICE_TYPE_MB26, EVENT_TYPE_TIME_CALIBRATION)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_TIME_CALIBRATION, DEVICE_TYPE_NT26K, EVENT_TYPE_TIME_CALIBRATION)) { - LOG_E("mb26 send cmd[%X] failed\n", CMD_TYPE_TIME_CALIBRATION); + LOG_E("nt26k send cmd[%X] failed\n", CMD_TYPE_TIME_CALIBRATION); return -RT_ERROR; } return RT_EOK; @@ -454,18 +454,18 @@ int Mb26_Send_Time_Calibration(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Alarm(struct at_device *device, void *param) +int Nt26k_Send_Alarm(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_ALARM)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_ALARM)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_ALARM); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_ALARM); return -RT_ERROR; } return RT_EOK; @@ -477,18 +477,18 @@ int Mb26_Send_Alarm(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Alarm_Recover(struct at_device *device, void *param) +int Nt26k_Send_Alarm_Recover(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_ALARM_RECOVER)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_ALARM_RECOVER)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_ALARM_RECOVER); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_ALARM_RECOVER); return -RT_ERROR; } return RT_EOK; @@ -500,18 +500,18 @@ int Mb26_Send_Alarm_Recover(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Fault(struct at_device *device, void *param) +int Nt26k_Send_Fault(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_FAULT)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_FAULT)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_FAULT); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_FAULT); return -RT_ERROR; } return RT_EOK; @@ -523,18 +523,18 @@ int Mb26_Send_Fault(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Fault_Recover(struct at_device *device, void *param) +int Nt26k_Send_Fault_Recover(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_FAULT_RECOVER)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_FAULT_RECOVER)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_FAULT_RECOVER); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_FAULT_RECOVER); return -RT_ERROR; } return RT_EOK; @@ -546,18 +546,18 @@ int Mb26_Send_Fault_Recover(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Self_Check(struct at_device *device, void *param) +int Nt26k_Send_Self_Check(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_SELF_CHECK)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_SELF_CHECK)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_SELF_CHECK); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_SELF_CHECK); return -RT_ERROR; } return RT_EOK; @@ -569,18 +569,18 @@ int Mb26_Send_Self_Check(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Silence(struct at_device *device, void *param) +int Nt26k_Send_Silence(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_SILENCE)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_SILENCE)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_SILENCE); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_SILENCE); return -RT_ERROR; } return RT_EOK; @@ -592,18 +592,18 @@ int Mb26_Send_Silence(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Exception(struct at_device *device, void *param) +int Nt26k_Send_Exception(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_EXCEPTION)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_EXCEPTION)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_EXCEPTION); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_EXCEPTION); return -RT_ERROR; } return RT_EOK; @@ -615,18 +615,18 @@ int Mb26_Send_Exception(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Valve_Status(struct at_device *device, void *param) +int Nt26k_Send_Valve_Status(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_VALVE_STATUS)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_VALVE_STATUS)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_VALVE_STATUS); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_VALVE_STATUS); return -RT_ERROR; } return RT_EOK; @@ -638,18 +638,18 @@ int Mb26_Send_Valve_Status(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Fan_Status(struct at_device *device, void *param) +int Nt26k_Send_Fan_Status(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_FAN_STATUS)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_FAN_STATUS)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_FAN_STATUS); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_FAN_STATUS); return -RT_ERROR; } return RT_EOK; @@ -661,18 +661,18 @@ int Mb26_Send_Fan_Status(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Temp_Anomaly(struct at_device *device, void *param) +int Nt26k_Send_Temp_Anomaly(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_TEMP_ANOMALY)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_TEMP_ANOMALY)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_TEMP_ANOMALY); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_TEMP_ANOMALY); return -RT_ERROR; } return RT_EOK; @@ -684,18 +684,18 @@ int Mb26_Send_Temp_Anomaly(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Power_Off(struct at_device *device, void *param) +int Nt26k_Send_Power_Off(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_POWER_OFF)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_POWER_OFF)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_POWER_OFF); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_POWER_OFF); return -RT_ERROR; } return RT_EOK; @@ -707,18 +707,18 @@ int Mb26_Send_Power_Off(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Power_On(struct at_device *device, void *param) +int Nt26k_Send_Power_On(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_POWER_ON)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_POWER_ON)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_POWER_ON); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_POWER_ON); return -RT_ERROR; } return RT_EOK; @@ -730,18 +730,18 @@ int Mb26_Send_Power_On(struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Mb26_Send_Device_Failure(struct at_device *device, void *param) +int Nt26k_Send_Device_Failure(struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - if ((device == RT_NULL) || (mb26_ops == RT_NULL)) + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E("mb26 param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (mb26_ops->send(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_MB26, EVENT_TYPE_DEVICE_FAILURE)) + if (nt26k_ops->send(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, EVENT_TYPE_DEVICE_FAILURE)) { - LOG_E("mb26 send cmd[%X] failed\n", EVENT_TYPE_DEVICE_FAILURE); + LOG_E("nt26k send cmd[%X] failed\n", EVENT_TYPE_DEVICE_FAILURE); return -RT_ERROR; } return RT_EOK; @@ -750,39 +750,39 @@ int Mb26_Send_Device_Failure(struct at_device *device, void *param) 思路感觉就是得重新开一个线程，然后再开一个任务队列，将所有的事件，发送到任务队列 在线程中，对任务队列进行查看并处理，看目前都有哪些事件，是处于那个优先级得，如果是最低优先级，就只发送一帧数据就行了， 如果是不同优先级，按照优先级顺序发送事件，但感觉这样会使得程序更复杂，本来发送就很快，感觉没必要这样搞*/ -const Mb26EventInfo mb26_event_info[] = { - {kMb26PowerOnEvent, MB26_PRIORITY_HIGHEST, "上电心跳事件", Mb26_Send_Power_On}, - {kMb26PowerDownEvent, MB26_PRIORITY_HIGH, "掉电事件", Mb26_Send_Power_Off}, - {kMb26SelfCheckEvent, MB26_PRIORITY_MEDIUM, "自检事件", Mb26_Send_Self_Check}, - {kMb26HeartbeatEvent, MB26_PRIORITY_LOWEST, "定时心跳事件", Mb26_Send_Heartbeat}, - {kMb26TempAnomalyEvent, MB26_PRIORITY_LOWEST, "温度异常事件", Mb26_Send_Temp_Anomaly}, - {kMb26AlarmEvent, MB26_PRIORITY_LOWEST, "报警触发事件", Mb26_Send_Alarm}, - {kMb26AlarmRcyEvent, MB26_PRIORITY_LOWEST, "报警解除事件", Mb26_Send_Alarm_Recover}, - {kMb26FaultEvent, MB26_PRIORITY_LOWEST, "传感器故障事件", Mb26_Send_Fault}, - {kMb26FaultRcyEvent, MB26_PRIORITY_LOWEST, "传感器故障解除事件", Mb26_Send_Fault_Recover}, - {kMb26TimeCalibrationEvent, MB26_PRIORITY_LOWEST, "时间校准事件", Mb26_Send_Time_Calibration}, - {kMb26SilenceEvent, MB26_PRIORITY_LOWEST, "消音事件", Mb26_Send_Silence}, - {kMb26ExceptionEvent, MB26_PRIORITY_LOWEST, "异常事件", Mb26_Send_Exception}, - {kMb26ValveStatusEvent, MB26_PRIORITY_LOWEST, "电磁阀状态改变事件", Mb26_Send_Valve_Status}, - {kMb26FanStatusEvent, MB26_PRIORITY_LOWEST, "风机状态改变事件", Mb26_Send_Fan_Status}, - {kMb26DeviceFailureEvent, MB26_PRIORITY_LOWEST, "设备失效事件", Mb26_Send_Device_Failure}}; +const Nt26kEventInfo nt26k_event_info[] = { + {kNt26kPowerOnEvent, NT26K_PRIORITY_HIGHEST, "上电心跳事件", Nt26k_Send_Power_On}, + {kNt26kPowerDownEvent, NT26K_PRIORITY_HIGH, "掉电事件", Nt26k_Send_Power_Off}, + {kNt26kSelfCheckEvent, NT26K_PRIORITY_MEDIUM, "自检事件", Nt26k_Send_Self_Check}, + {kNt26kHeartbeatEvent, NT26K_PRIORITY_LOWEST, "定时心跳事件", Nt26k_Send_Heartbeat}, + {kNt26kTempAnomalyEvent, NT26K_PRIORITY_LOWEST, "温度异常事件", Nt26k_Send_Temp_Anomaly}, + {kNt26kAlarmEvent, NT26K_PRIORITY_LOWEST, "报警触发事件", Nt26k_Send_Alarm}, + {kNt26kAlarmRcyEvent, NT26K_PRIORITY_LOWEST, "报警解除事件", Nt26k_Send_Alarm_Recover}, + {kNt26kFaultEvent, NT26K_PRIORITY_LOWEST, "传感器故障事件", Nt26k_Send_Fault}, + {kNt26kFaultRcyEvent, NT26K_PRIORITY_LOWEST, "传感器故障解除事件", Nt26k_Send_Fault_Recover}, + {kNt26kTimeCalibrationEvent, NT26K_PRIORITY_LOWEST, "时间校准事件", Nt26k_Send_Time_Calibration}, + {kNt26kSilenceEvent, NT26K_PRIORITY_LOWEST, "消音事件", Nt26k_Send_Silence}, + {kNt26kExceptionEvent, NT26K_PRIORITY_LOWEST, "异常事件", Nt26k_Send_Exception}, + {kNt26kValveStatusEvent, NT26K_PRIORITY_LOWEST, "电磁阀状态改变事件", Nt26k_Send_Valve_Status}, + {kNt26kFanStatusEvent, NT26K_PRIORITY_LOWEST, "风机状态改变事件", Nt26k_Send_Fan_Status}, + {kNt26kDeviceFailureEvent, NT26K_PRIORITY_LOWEST, "设备失效事件", Nt26k_Send_Device_Failure}}; /** - * 处理MB26设备的事件 - * @param mb26_recv_event 接收到的MB26事件标志 + * 处理NT26K设备的事件 + * @param nt26k_recv_event 接收到的NT26K事件标志 * @return */ -int Mb26_Process_Events(Mb26Event mb26_recv_event, struct at_device *device, void *param) +int Nt26k_Process_Events(Nt26kEvent nt26k_recv_event, struct at_device *device, void *param) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)param; - const Mb26EventInfo *event = RT_NULL; + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; + const Nt26kEventInfo *event = RT_NULL; - for (size_t i = 0; i < sizeof(mb26_event_info) / sizeof(Mb26EventInfo); ++i) + for (size_t i = 0; i < sizeof(nt26k_event_info) / sizeof(Nt26kEventInfo); ++i) { // 检查当前事件是否在接收到的事件标志中 - if (mb26_recv_event == mb26_event_info[i].event_flag) + if (nt26k_recv_event == nt26k_event_info[i].event_flag) { - event = &mb26_event_info[i]; + event = &nt26k_event_info[i]; break; } } @@ -796,23 +796,23 @@ int Mb26_Process_Events(Mb26Event mb26_recv_event, struct at_device *device, voi // 如果事件有关联的发送函数，则调用该发送函数 if (event->send_func) { - int result = event->send_func(device, mb26_ops); + int result = event->send_func(device, nt26k_ops); if (result != RT_EOK) { - LOG_E("mb26 send cmd failed\n"); - Mb26_Reset(device); // 重启模组 + LOG_E("nt26k send cmd failed\n"); + Nt26k_Reset(device); // 重启模组 rt_thread_mdelay(5000); - if (mb26_conncet_tcp_flag != 1) + if (nt26k_conncet_tcp_flag != 1) { if (device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_CONN, RT_NULL) == RT_EOK) // 打开连接 { - LOG_D("mb26 connect tcp success\n"); - Reset_Mb26_Life_Timer(); + LOG_D("nt26k connect tcp success\n"); + Reset_Nt26k_Life_Timer(); // 重启后重新尝试发送 - result = event->send_func(device, mb26_ops); + result = event->send_func(device, nt26k_ops); if (result != RT_EOK) { - LOG_E("mb26 send cmd after module reset failed\n"); + LOG_E("nt26k send cmd after module reset failed\n"); if (device->class->device_ops->control(device, AT_DEVICE_CTRL_POWER_OFF, RT_NULL) == RT_EOK) // 打开连接 { @@ -832,13 +832,13 @@ int Mb26_Process_Events(Mb26Event mb26_recv_event, struct at_device *device, voi } else { - LOG_E("mb26 connect tcp failed\n"); - Mb26_Reset(device); // 重启模组 + LOG_E("nt26k connect tcp failed\n"); + Nt26k_Reset(device); // 重启模组 } } else { - LOG_E("MB26连接标志有BUG\n"); + LOG_E("NT26K连接标志有BUG\n"); } } else @@ -850,7 +850,7 @@ int Mb26_Process_Events(Mb26Event mb26_recv_event, struct at_device *device, voi } // 比较帧头和帧尾 -int Compare_HeaderToTail(struct Mb26_Ops *ops) +int Compare_HeaderToTail(struct Nt26k_Ops *ops) { // 比较帧头 for (int i = 0; i < 3; i++) @@ -882,15 +882,15 @@ int Compare_HeaderToTail(struct Mb26_Ops *ops) return RT_EOK; } -void Handle_Server_Reply(struct Mb26_Ops *ops) +void Handle_Server_Reply(struct Nt26k_Ops *ops) { - if (ops->recv->recv_data.event_type == INSTRUCTION_HEART_BEAT) + if ((ops->recv->recv_data.event_type == INSTRUCTION_HEART_BEAT)|| (ops->recv->recv_data.event_type == EVENT_TYPE_POWER_ON)) { - LOG_D("mb26 send data success\n"); + LOG_D("nt26k send data success\n"); } } -void Handle_Self_Check(struct Mb26_Ops *ops) +void Handle_Self_Check(struct Nt26k_Ops *ops) { LOG_D("服务器下发自检指令\n"); char imei[16] = {0}; @@ -902,10 +902,10 @@ void Handle_Self_Check(struct Mb26_Ops *ops) LOG_D("temp: %s", temp); Send_Laser_Alarm_Event(kSelfCheckEvent); rt_thread_mdelay(100); - ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_SELF_CHECK, temp, RESPONSE_CODE_SUCCESS); + ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_SELF_CHECK, temp, RESPONSE_CODE_SUCCESS); } -void Handle_Mute(struct Mb26_Ops *ops) +void Handle_Mute(struct Nt26k_Ops *ops) { LOG_D("服务器下发消音指令\n"); @@ -916,10 +916,10 @@ void Handle_Mute(struct Mb26_Ops *ops) Send_Laser_Alarm_Event(KMuteEvent); rt_thread_mdelay(100); - ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_MUTE, temp, RESPONSE_CODE_SUCCESS); + ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_MUTE, temp, RESPONSE_CODE_SUCCESS); } -void Handle_Close_Valve(struct Mb26_Ops *ops) +void Handle_Close_Valve(struct Nt26k_Ops *ops) { LOG_D("服务器下发关闭阀门指令\n"); @@ -933,10 +933,10 @@ void Handle_Close_Valve(struct Mb26_Ops *ops) // 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_MB26, 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); } -void Handle_Open_Valve(struct Mb26_Ops *ops) +void Handle_Open_Valve(struct Nt26k_Ops *ops) { LOG_D("服务器下发打开阀门指令\n"); @@ -950,10 +950,10 @@ void Handle_Open_Valve(struct Mb26_Ops *ops) // rt_thread_mdelay(20); // emv_state_flag = 0; - // ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_OPEN_VALVE, temp, RESPONSE_CODE_SUCCESS); + // ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_OPEN_VALVE, temp, RESPONSE_CODE_SUCCESS); } -void Handle_Open_Relay(struct Mb26_Ops *ops) +void Handle_Open_Relay(struct Nt26k_Ops *ops) { LOG_D("服务器下发打开继电器指令\n"); @@ -964,10 +964,10 @@ void Handle_Open_Relay(struct Mb26_Ops *ops) relay_state_flag = 1; rt_thread_mdelay(10); // rt_uint8_t ret = BSP_Set_Relay_Status(0); - ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_OPEN_RELAY, temp, RESPONSE_CODE_SUCCESS); + ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_OPEN_RELAY, temp, RESPONSE_CODE_SUCCESS); } -void Handle_Close_Relay(struct Mb26_Ops *ops) +void Handle_Close_Relay(struct Nt26k_Ops *ops) { LOG_D("服务器下发关闭继电器指令\n"); @@ -979,10 +979,10 @@ void Handle_Close_Relay(struct Mb26_Ops *ops) relay_state_flag = 0; rt_thread_mdelay(100); - ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_CLOSE_RELAY, temp, RESPONSE_CODE_SUCCESS); + ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_CLOSE_RELAY, temp, RESPONSE_CODE_SUCCESS); } -void Handle_Query_Params(struct Mb26_Ops *ops) +void Handle_Query_Params(struct Nt26k_Ops *ops) { rt_uint8_t data[10] = {0}; char str[64] = {0}; @@ -995,10 +995,10 @@ void Handle_Query_Params(struct Mb26_Ops *ops) rt_sprintf(str, "0000000000%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); rt_thread_mdelay(100); // 释放下线程 - ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_QUERY_PARAMS, str, RESPONSE_CODE_SUCCESS); + ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_QUERY_PARAMS, str, RESPONSE_CODE_SUCCESS); } -int Handle_Config_Params(struct Mb26_Ops *ops) +int Handle_Config_Params(struct Nt26k_Ops *ops) { char data_buf[32] = {0}; rt_uint8_t recv_data[16] = {0}; @@ -1030,7 +1030,7 @@ int Handle_Config_Params(struct Mb26_Ops *ops) { if ((recv_data[2] > 25) || (recv_data[2] < 5)) /*家报的报警设定值应在5%~25%之间*/ { - if (ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_CONFIG_PARAMS, temp, RESPONSE_CODE_ACTION_FAILURE) == RT_EOK) + if (ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_CONFIG_PARAMS, temp, RESPONSE_CODE_ACTION_FAILURE) == RT_EOK) { LOG_W("recv_data[3] :%d", recv_data[3]); LOG_W("配置参数超出范围，请核实后重试\n"); @@ -1043,13 +1043,13 @@ int Handle_Config_Params(struct Mb26_Ops *ops) { rt_uint16_t nb_upload_time = (uint16_t)Flash_Get_SysCfg(kNbUploadCycleId); unsigned long timeout = nb_upload_time * 60 * RT_TICK_PER_SECOND; - // rt_timer_stop(mb26_timer); - rt_timer_control(mb26_timer, RT_TIMER_CTRL_SET_TIME, (void *)&timeout); // 更新上报周期 - // rt_timer_control(mb26_timer, RT_TIMER_CTRL_GET_TIME, &timeout); + // rt_timer_stop(nt26k_timer); + rt_timer_control(nt26k_timer, RT_TIMER_CTRL_SET_TIME, (void *)&timeout); // 更新上报周期 + // rt_timer_control(nt26k_timer, RT_TIMER_CTRL_GET_TIME, &timeout); // LOG_D("timeout:%d", timeout/1000/60); - rt_timer_start(mb26_timer); + rt_timer_start(nt26k_timer); LOG_D("上报周期由%dmin更新为%dmin", ((flash_info[5] << 8) | flash_info[6]), nb_upload_time); - if (ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_CONFIG_PARAMS, temp, RESPONSE_CODE_SUCCESS) == RT_EOK) + if (ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_CONFIG_PARAMS, temp, RESPONSE_CODE_SUCCESS) == RT_EOK) { LOG_D("配置参数写入成功\n"); } @@ -1058,7 +1058,7 @@ int Handle_Config_Params(struct Mb26_Ops *ops) else { LOG_D("配置参数写入失败\n"); - if (ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_CONFIG_PARAMS, temp, RESPONSE_CODE_ACTION_FAILURE) == RT_EOK) + if (ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_CONFIG_PARAMS, temp, RESPONSE_CODE_ACTION_FAILURE) == RT_EOK) { LOG_D("写入失败响应成功\n"); } @@ -1067,14 +1067,14 @@ int Handle_Config_Params(struct Mb26_Ops *ops) } } } - if (ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_CONFIG_PARAMS, temp, RESPONSE_CODE_SUCCESS) == RT_EOK) + if (ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_CONFIG_PARAMS, temp, RESPONSE_CODE_SUCCESS) == RT_EOK) { LOG_D("配置参数没有变化\n"); } return RT_EOK; } -void Handle_Time_Calibration_Data(struct Mb26_Ops *ops) +void Handle_Time_Calibration_Data(struct Nt26k_Ops *ops) { rt_uint8_t data[10] = {0}; TsRtcDateTime rtc_dt; @@ -1096,11 +1096,11 @@ void Handle_Time_Calibration_Data(struct Mb26_Ops *ops) rtc_dt.year, rtc_dt.month, rtc_dt.day, rtc_dt.hour, rtc_dt.minute, rtc_dt.second, rtc_dt.week); RTC_SetTime(rtc_dt.year, rtc_dt.month, rtc_dt.day, rtc_dt.hour, rtc_dt.minute, 0); /* Setup Time */ rt_thread_mdelay(100); // 释放下线程 - ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_TIME_CALIBRATION, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_TIME_CALIBRATION, temp, RESPONSE_CODE_SUCCESS); + ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_TIME_CALIBRATION, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_TIME_CALIBRATION, temp, RESPONSE_CODE_SUCCESS); } // 下发修改服务器地址指令 -void Handle_Sever_Addr_Set(struct Mb26_Ops *ops) +void Handle_Sever_Addr_Set(struct Nt26k_Ops *ops) { rt_uint8_t data[6] = {0}; char imei[16] = {0}; @@ -1118,11 +1118,11 @@ void Handle_Sever_Addr_Set(struct Mb26_Ops *ops) else { LOG_D("服务器地址修改成功\n"); - ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_SEVER_ADDR, temp, RESPONSE_CODE_SUCCESS); + ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_SEVER_ADDR, temp, RESPONSE_CODE_SUCCESS); } } -void Handle_Error(struct Mb26_Ops *ops, rt_err_t ret) +void Handle_Error(struct Nt26k_Ops *ops, rt_err_t ret) { LOG_E("数据帧解析失败，错误码: %d", ret); @@ -1131,49 +1131,49 @@ void Handle_Error(struct Mb26_Ops *ops, rt_err_t ret) Get_Nb_Imei(imei, FLASH_NB_IMEI_LEN); String2Hex(temp, imei); // 将字符串转为十六进制字符串 - ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, ops->recv->cmd, temp, RESPONSE_CODE_PARSE_FAIL); + ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, ops->recv->cmd, temp, RESPONSE_CODE_PARSE_FAIL); } -void Handle_Instruction_Down(struct Mb26_Ops *ops) +void Handle_Instruction_Down(struct Nt26k_Ops *ops) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)ops; + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)ops; - switch (mb26_ops->recv->recv_data.event_type) + switch (nt26k_ops->recv->recv_data.event_type) { case INSTRUCTION_DOWN_SELF_CHECK: - Handle_Self_Check(mb26_ops); + Handle_Self_Check(nt26k_ops); break; case INSTRUCTION_DOWN_MUTE: - Handle_Mute(mb26_ops); + Handle_Mute(nt26k_ops); break; case INSTRUCTION_DOWN_CLOSE_VALVE: - Handle_Close_Valve(mb26_ops); + Handle_Close_Valve(nt26k_ops); break; case INSTRUCTION_DOWN_OPEN_VALVE: - Handle_Open_Valve(mb26_ops); + Handle_Open_Valve(nt26k_ops); break; case INSTRUCTION_DOWN_OPEN_RELAY: - Handle_Open_Relay(mb26_ops); + Handle_Open_Relay(nt26k_ops); break; case INSTRUCTION_DOWN_CLOSE_RELAY: - Handle_Close_Relay(mb26_ops); + Handle_Close_Relay(nt26k_ops); break; case INSTRUCTION_DOWN_QUERY_PARAMS: - Handle_Query_Params(mb26_ops); + Handle_Query_Params(nt26k_ops); break; case INSTRUCTION_DOWN_CONFIG_PARAMS: - Handle_Config_Params(mb26_ops); + Handle_Config_Params(nt26k_ops); break; case INSTRUCTION_DOWN_TIME_CALIBRATION: - Handle_Time_Calibration_Data(mb26_ops); + Handle_Time_Calibration_Data(nt26k_ops); break; case INSTRUCTION_DOWN_SEVER_ADDR: - Handle_Sever_Addr_Set(mb26_ops); + Handle_Sever_Addr_Set(nt26k_ops); break; } } -void Handle_Time_Calibration(struct Mb26_Ops *ops) +void Handle_Time_Calibration(struct Nt26k_Ops *ops) { rt_uint8_t data[10] = {0}; LOG_D("服务器下发时间校准数据\n"); @@ -1186,34 +1186,34 @@ void Handle_Time_Calibration(struct Mb26_Ops *ops) LOG_I("时间: %04d-%02d-%02d %02d:%02d:%02d (星期%d)\n", rtc_dt.year, rtc_dt.month, rtc_dt.day, rtc_dt.hour, rtc_dt.minute, rtc_dt.second, rtc_dt.week); RTC_SetTime(rtc_dt.year, rtc_dt.month, rtc_dt.day, rtc_dt.hour, rtc_dt.minute, rtc_dt.second); /* Setup Time */ - ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, INSTRUCTION_DOWN_TIME_CALIBRATION, MB26_DEFIENE_DATA, RESPONSE_CODE_SUCCESS); + ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_TIME_CALIBRATION, NT26K_DEFIENE_DATA, RESPONSE_CODE_SUCCESS); } -void Handle_Cmd_Type(struct Mb26_Ops *ops) +void Handle_Cmd_Type(struct Nt26k_Ops *ops) { - struct Mb26_Ops *mb26_ops = (struct Mb26_Ops *)ops; + struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)ops; - switch (mb26_ops->recv->cmd) + switch (nt26k_ops->recv->cmd) { case CMD_TYPE_SERVER_REPLY: - Handle_Server_Reply(mb26_ops); + Handle_Server_Reply(nt26k_ops); break; case CMD_TYPE_INSTRUCTION_DOWN: - Handle_Instruction_Down(mb26_ops); + Handle_Instruction_Down(nt26k_ops); break; case CMD_TYPE_TIME_CALIBRATION: - Handle_Time_Calibration(mb26_ops); + Handle_Time_Calibration(nt26k_ops); break; default: - mb26_ops->Resp(mb26_ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_MB26, ops->recv->cmd, MB26_DEFIENE_DATA, RESPONSE_CODE_PARSE_FAIL); + nt26k_ops->Resp(nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, ops->recv->cmd, NT26K_DEFIENE_DATA, RESPONSE_CODE_PARSE_FAIL); break; } } -void Analyze_Recv_Frame(struct at_device *device, struct Mb26_Ops *ops) +void Analyze_Recv_Frame(struct at_device *device, struct Nt26k_Ops *ops) { rt_err_t ret = RT_EOK; - Reset_Mb26_Life_Timer(); // 只要数据，则重置定时器，不管数据是否正确 + Reset_Nt26k_Life_Timer(); // 只要数据，则重置定时器，不管数据是否正确 ret = Compare_HeaderToTail(ops); if (ret == RT_EOK) @@ -1231,196 +1231,196 @@ void Analyze_Recv_Frame(struct at_device *device, struct Mb26_Ops *ops) 发送一包数据后，转换到检测模式 120分钟发送一次数据 当有事件发生时，发送一包事件数据包 */ -static void Mb26_Send_Thread_Entry(void *param) +static void Nt26k_Send_Thread_Entry(void *param) { rt_err_t result = RT_EOK; - rt_uint32_t mb26_recv_event; - LOG_D("mb26 thread entry\n"); + rt_uint32_t nt26k_recv_event; + LOG_D("nt26k thread entry\n"); - struct Mb26_Ops *ops = (struct Mb26_Ops *)param; - struct at_device_mb26 *mb26 = &_dev; - struct at_device *device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, mb26->device_name); + struct Nt26k_Ops *ops = (struct Nt26k_Ops *)param; + 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); if (ops->init(ops, PROTOCOL_VERSION) != RT_EOK) { - LOG_E("mb26 init failed\n"); + LOG_E("nt26k init failed\n"); } else { - LOG_D("mb26 init success\n"); - rt_completion_wait(&mb26_init_complate, RT_WAITING_FOREVER); // wait for mb26 init finish - Mb26_Send_Event(kMb26PowerOnEvent); + LOG_D("nt26k init success\n"); + rt_completion_wait(&nt26k_init_complate, RT_WAITING_FOREVER); // wait for nt26k init finish + Nt26k_Send_Event(kNt26kPowerOnEvent); } while (1) { result = rt_event_recv(&at_device_event, - Mb26_Get_Event_Flag(kMb26PowerOnEvent) | - Mb26_Get_Event_Flag(kMb26HeartbeatEvent) | - Mb26_Get_Event_Flag(kMb26SelfCheckEvent) | - Mb26_Get_Event_Flag(kMb26SilenceEvent) | - Mb26_Get_Event_Flag(kMb26ExceptionEvent) | - Mb26_Get_Event_Flag(kMb26ValveStatusEvent) | - Mb26_Get_Event_Flag(kMb26FanStatusEvent) | - Mb26_Get_Event_Flag(kMb26TempAnomalyEvent) | - Mb26_Get_Event_Flag(kMb26PowerOnEvent) | - Mb26_Get_Event_Flag(kMb26PowerDownEvent) | - Mb26_Get_Event_Flag(kMb26AlarmEvent) | - Mb26_Get_Event_Flag(kMb26AlarmRcyEvent) | - Mb26_Get_Event_Flag(kMb26FaultEvent) | - Mb26_Get_Event_Flag(kMb26FaultRcyEvent) | - Mb26_Get_Event_Flag(kMb26DeviceFailureEvent) | - Mb26_Get_Event_Flag(kMb26TimeCalibrationEvent), + Nt26k_Get_Event_Flag(kNt26kPowerOnEvent) | + Nt26k_Get_Event_Flag(kNt26kHeartbeatEvent) | + Nt26k_Get_Event_Flag(kNt26kSelfCheckEvent) | + Nt26k_Get_Event_Flag(kNt26kSilenceEvent) | + Nt26k_Get_Event_Flag(kNt26kExceptionEvent) | + Nt26k_Get_Event_Flag(kNt26kValveStatusEvent) | + Nt26k_Get_Event_Flag(kNt26kFanStatusEvent) | + Nt26k_Get_Event_Flag(kNt26kTempAnomalyEvent) | + Nt26k_Get_Event_Flag(kNt26kPowerOnEvent) | + Nt26k_Get_Event_Flag(kNt26kPowerDownEvent) | + Nt26k_Get_Event_Flag(kNt26kAlarmEvent) | + Nt26k_Get_Event_Flag(kNt26kAlarmRcyEvent) | + Nt26k_Get_Event_Flag(kNt26kFaultEvent) | + Nt26k_Get_Event_Flag(kNt26kFaultRcyEvent) | + Nt26k_Get_Event_Flag(kNt26kDeviceFailureEvent) | + Nt26k_Get_Event_Flag(kNt26kTimeCalibrationEvent), RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, - RT_WAITING_FOREVER, &mb26_recv_event); // 这个事件一般是设备端发生了变化，发送到服务器时调用 + RT_WAITING_FOREVER, &nt26k_recv_event); // 这个事件一般是设备端发生了变化，发送到服务器时调用 if (result == RT_EOK) { - LOG_D("mb26 recv event OK\n"); - if (mb26_conncet_tcp_flag != 1) + LOG_D("nt26k recv event OK\n"); + if (nt26k_conncet_tcp_flag != 1) { if (device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_CONN, RT_NULL) == RT_EOK) // 打开连接 { - LOG_D("mb26 connect tcp success\n"); - rt_timer_start(mb26_life_timer); + LOG_D("nt26k connect tcp success\n"); + rt_timer_start(nt26k_life_timer); } else { - LOG_E("mb26 connect tcp failed\n"); + LOG_E("nt26k connect tcp failed\n"); } } - if (mb26_conncet_tcp_flag) + if (nt26k_conncet_tcp_flag) { - Reset_Mb26_Life_Timer(); - if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26PowerOnEvent)) + Reset_Nt26k_Life_Timer(); + if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kPowerOnEvent)) { - result = Mb26_Process_Events(kMb26PowerOnEvent, device, ops); // 当上电心跳包发送不成功时，其他事件不启动 + result = Nt26k_Process_Events(kNt26kPowerOnEvent, device, ops); // 当上电心跳包发送不成功时，其他事件不启动 if (result) { power_on_send_flag = 0; - rt_timer_start(mb26_power_error_timer); // 启动重连定时器， 3min一次，直到发送成功 - LOG_E("mb26 send data failed result = [%d]\n", result); + rt_timer_start(nt26k_power_error_timer); // 启动重连定时器， 3min一次，直到发送成功 + LOG_E("nt26k send data failed result = [%d]\n", result); } else { - rt_timer_start(mb26_timer); // 当上电心跳包发送成功时, 开始心跳包周期发送 + rt_timer_start(nt26k_timer); // 当上电心跳包发送成功时, 开始心跳包周期发送 power_on_send_flag = 1; - Mb26_Send_Event(kMb26TimeCalibrationEvent); // 上电网络连接成功时，更新下时间 - rt_timer_start(mb26_upload_timer); + Nt26k_Send_Event(kNt26kTimeCalibrationEvent); // 上电网络连接成功时，更新下时间 + rt_timer_start(nt26k_upload_timer); } } if (power_on_send_flag) { - if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26HeartbeatEvent)) + if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kHeartbeatEvent)) { - result = Mb26_Process_Events(kMb26HeartbeatEvent, device, ops); + result = Nt26k_Process_Events(kNt26kHeartbeatEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26TimeCalibrationEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kTimeCalibrationEvent)) { Time_Calibration(device); } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26AlarmEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kAlarmEvent)) { - result = Mb26_Process_Events(kMb26AlarmEvent, device, ops); + result = Nt26k_Process_Events(kNt26kAlarmEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26AlarmRcyEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kAlarmRcyEvent)) { - result = Mb26_Process_Events(kMb26AlarmRcyEvent, device, ops); + result = Nt26k_Process_Events(kNt26kAlarmRcyEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26FaultEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kFaultEvent)) { if (device_state_flag != 1) // 当设备失效时，只上报失效信息 { - result = Mb26_Process_Events(kMb26FaultEvent, device, ops); + result = Nt26k_Process_Events(kNt26kFaultEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26FaultRcyEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kFaultRcyEvent)) { - result = Mb26_Process_Events(kMb26FaultRcyEvent, device, ops); + result = Nt26k_Process_Events(kNt26kFaultRcyEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26SelfCheckEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kSelfCheckEvent)) { - result = Mb26_Process_Events(kMb26SelfCheckEvent, device, ops); + result = Nt26k_Process_Events(kNt26kSelfCheckEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26SilenceEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kSilenceEvent)) { - result = Mb26_Process_Events(kMb26SilenceEvent, device, ops); + result = Nt26k_Process_Events(kNt26kSilenceEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26ExceptionEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kExceptionEvent)) { - result = Mb26_Process_Events(kMb26ExceptionEvent, device, ops); + result = Nt26k_Process_Events(kNt26kExceptionEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26ValveStatusEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kValveStatusEvent)) { - result = Mb26_Process_Events(kMb26ValveStatusEvent, device, ops); + result = Nt26k_Process_Events(kNt26kValveStatusEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26FanStatusEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kFanStatusEvent)) { - result = Mb26_Process_Events(kMb26FanStatusEvent, device, ops); + result = Nt26k_Process_Events(kNt26kFanStatusEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26TempAnomalyEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kTempAnomalyEvent)) { - result = Mb26_Process_Events(kMb26TempAnomalyEvent, device, ops); + result = Nt26k_Process_Events(kNt26kTempAnomalyEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26PowerDownEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kPowerDownEvent)) { - result = Mb26_Process_Events(kMb26PowerDownEvent, device, ops); + result = Nt26k_Process_Events(kNt26kPowerDownEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } - mb26_event_initialized = RT_FALSE; // 当接收到掉电事件时，发送完成后删除事件，不再接收其他事件 + nt26k_event_initialized = RT_FALSE; // 当接收到掉电事件时，发送完成后删除事件，不再接收其他事件 } - else if (mb26_recv_event & Mb26_Get_Event_Flag(kMb26DeviceFailureEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kDeviceFailureEvent)) { - result = Mb26_Process_Events(kMb26DeviceFailureEvent, device, ops); + result = Nt26k_Process_Events(kNt26kDeviceFailureEvent, device, ops); if (result) { - LOG_E("mb26 send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } } @@ -1430,159 +1430,159 @@ static void Mb26_Send_Thread_Entry(void *param) } } -static void Mb26_Recv_Thread_Entry(void *parameter) +static void Nt26k_Recv_Thread_Entry(void *parameter) { - struct Mb26_Ops *ops = (struct Mb26_Ops *)parameter; - struct at_device_mb26 *mb26 = &_dev; - struct at_device *device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, mb26->device_name); + struct Nt26k_Ops *ops = (struct Nt26k_Ops *)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("mb26 recv thread entry\n"); + LOG_D("nt26k recv thread entry\n"); while (1) { - ret = rt_sem_take(mb26_recv_sem, RT_WAITING_FOREVER); // 这个主要用来处理的数据 + ret = rt_sem_take(nt26k_recv_sem, RT_WAITING_FOREVER); // 这个主要用来处理的数据 if (ret == RT_EOK) { - rt_timer_start(mb26_life_timer); + rt_timer_start(nt26k_life_timer); /*对数据帧进行分析，判断所处的是对服务器响应还是指令下发*/ Analyze_Recv_Frame(device, ops); } } } -static void Mb26_Life_Thread_Entry(void *parameter) +static void Nt26k_Life_Thread_Entry(void *parameter) { - struct at_device_mb26 *mb26 = &_dev; - struct at_device *device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, mb26->device_name); + 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("mb26_life_thread entry\n"); + LOG_D("nt26k_life_thread entry\n"); while (1) { - ret = rt_sem_take(mb26_life_sem, RT_WAITING_FOREVER); + ret = rt_sem_take(nt26k_life_sem, RT_WAITING_FOREVER); if (ret == RT_EOK) { - if (mb26_conncet_tcp_flag) + if (nt26k_conncet_tcp_flag) { device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_DISCONN, RT_NULL); - LOG_D("close mb26 tcp connect\n "); + LOG_D("close nt26k tcp connect\n "); } } } } // 定时器回调函数,当1分钟内没有数据交互时，关闭tcp连接 -static void Mb26_Upload_Timer_Cb(void *parameter) +static void Nt26k_Upload_Timer_Cb(void *parameter) { - Mb26_Send_Event(kMb26TimeCalibrationEvent); // 更新下时间 + Nt26k_Send_Event(kNt26kTimeCalibrationEvent); // 更新下时间 } -int BSP_Mb26_Thread_Init(void) +int BSP_Nt26k_Thread_Init(void) { rt_err_t ret; - Mb26_Event_Init(); + Nt26k_Event_Init(); 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); - mb26_mutex = rt_mutex_create("mb26_mutex", RT_IPC_FLAG_FIFO); - if (mb26_mutex == RT_NULL) + nt26k_mutex = rt_mutex_create("nt26k_mutex", RT_IPC_FLAG_FIFO); + if (nt26k_mutex == RT_NULL) { - LOG_E("mb26_mutex create failed"); + LOG_E("nt26k_mutex create failed"); } - mb26_recv_sem = rt_sem_create("mb26_recv", 0, RT_IPC_FLAG_FIFO); - if (mb26_recv_sem == RT_NULL) + nt26k_recv_sem = rt_sem_create("nt26k_recv", 0, RT_IPC_FLAG_FIFO); + if (nt26k_recv_sem == RT_NULL) { - LOG_E("mb26_recv_sem create failed"); + LOG_E("nt26k_recv_sem create failed"); } - mb26_life_sem = rt_sem_create("mb26_life", 0, RT_IPC_FLAG_FIFO); - if (mb26_life_sem == RT_NULL) + nt26k_life_sem = rt_sem_create("nt26k_life", 0, RT_IPC_FLAG_FIFO); + if (nt26k_life_sem == RT_NULL) { - LOG_E("mb26_life_sem create failed"); + LOG_E("nt26k_life_sem create failed"); } // 创建定时器 - mb26_timer = rt_timer_create("heartbeat", - Mb26_Ht_Timer_Cb, // 回调函数 + nt26k_timer = rt_timer_create("heartbeat", + Nt26k_Ht_Timer_Cb, // 回调函数 RT_NULL, // 参数 timeout, // 定时周期（120分钟） RT_TIMER_FLAG_PERIODIC); // 周期性定时器 - if (mb26_timer == RT_NULL) + if (nt26k_timer == RT_NULL) { rt_kprintf("创建定时器失败\n"); return -1; } - mb26_life_timer = rt_timer_create("mb26_life", - Mb26_Life_Timer_Cb, + 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 (mb26_life_timer == RT_NULL) + if (nt26k_life_timer == RT_NULL) { rt_kprintf("创建定时器失败\n"); return -1; } - mb26_power_error_timer = rt_timer_create("mb26_error_timer", - Mb26_Error_Timer_Cb, + nt26k_power_error_timer = rt_timer_create("nt26k_error_timer", + Nt26k_Error_Timer_Cb, RT_NULL, 3 * 60 * RT_TICK_PER_SECOND, // （3分钟） RT_TIMER_FLAG_PERIODIC); - mb26_upload_timer = rt_timer_create("mb26_upload_timer", - Mb26_Upload_Timer_Cb, + nt26k_upload_timer = rt_timer_create("nt26k_upload_timer", + Nt26k_Upload_Timer_Cb, RT_NULL, 24 * 60 * 60 * RT_TICK_PER_SECOND, RT_TIMER_FLAG_PERIODIC); - ret = rt_thread_init(&mb26_thread, - "mb26_send_thread", - Mb26_Send_Thread_Entry, - &mb26_ops, - &mb26_thread_stack[0], - sizeof(mb26_thread_stack), - MB26_THREAD_PRIORITY, - MB26_THREAD_TICKS); - rt_thread_startup(&mb26_thread); + ret = rt_thread_init(&nt26k_thread, + "nt26k_send_thread", + Nt26k_Send_Thread_Entry, + &nt26k_ops, + &nt26k_thread_stack[0], + sizeof(nt26k_thread_stack), + NT26K_THREAD_PRIORITY, + NT26K_THREAD_TICKS); + rt_thread_startup(&nt26k_thread); - ret = rt_thread_init(&mb26_recv_thread, - "mb26_recv_thread", - Mb26_Recv_Thread_Entry, - &mb26_ops, - &mb26_recv_thread_stack[0], - sizeof(mb26_recv_thread_stack), - MB26_RECV_THREAD_PRIORITY, - MB26_RECV_THREAD_TICKS); - rt_thread_startup(&mb26_recv_thread); + ret = rt_thread_init(&nt26k_recv_thread, + "nt26k_recv_thread", + Nt26k_Recv_Thread_Entry, + &nt26k_ops, + &nt26k_recv_thread_stack[0], + sizeof(nt26k_recv_thread_stack), + NT26K_RECV_THREAD_PRIORITY, + NT26K_RECV_THREAD_TICKS); + rt_thread_startup(&nt26k_recv_thread); - ret = rt_thread_init(&mb26_life_thread, - "mb26_life_thread", - Mb26_Life_Thread_Entry, - &mb26_ops, - &mb26_life_thread_stack[0], - sizeof(mb26_life_thread_stack), - MB26_LIFE_THREAD_PRIORITY, - MB26_LIFE_THREAD_TICKS); - rt_thread_startup(&mb26_life_thread); + ret = rt_thread_init(&nt26k_life_thread, + "nt26k_life_thread", + Nt26k_Life_Thread_Entry, + &nt26k_ops, + &nt26k_life_thread_stack[0], + sizeof(nt26k_life_thread_stack), + NT26K_LIFE_THREAD_PRIORITY, + NT26K_LIFE_THREAD_TICKS); + rt_thread_startup(&nt26k_life_thread); return ret; } -// INIT_APP_EXPORT(BSP_Mb26_Thread_Init); +// INIT_APP_EXPORT(BSP_Nt26k_Thread_Init); -int mb26_device_register(void) +int nt26k_device_register(void) { - struct at_device_mb26 *mb26 = &_dev; + struct at_device_nt26k *nt26k = &_dev; - return at_device_register(&(mb26->device), - mb26->device_name, - mb26->client_name, - AT_DEVICE_CLASS_MB26, - (void *)mb26); + return at_device_register(&(nt26k->device), + nt26k->device_name, + nt26k->client_name, + AT_DEVICE_CLASS_NT26K, + (void *)nt26k); } -// INIT_COMPONENT_EXPORT(mb26_device_register); +// INIT_COMPONENT_EXPORT(nt26k_device_register); -#endif // NB_MODULE_SWITCH +#endif // IOT_MODULE_SWITCH diff --git a/packages/at_device-2.1.0/at_device.h b/packages/at_device-2.1.0/at_device.h index f30caf7..3166193 100644 --- a/packages/at_device-2.1.0/at_device.h +++ b/packages/at_device-2.1.0/at_device.h @@ -55,7 +55,7 @@ extern "C" { #define AT_DEVICE_CLASS_L610 0X15U #define AT_DEVICE_CLASS_ML305 0X16U #define AT_DEVICE_CLASS_ML307 0X17U -#define AT_DEVICE_CLASS_MB26 0X18U +#define AT_DEVICE_CLASS_NT26K 0X18U /* Options and Commands for AT device control opreations */ #define AT_DEVICE_CTRL_POWER_ON 0x01L diff --git a/rt-thread/rtconfig.h b/rt-thread/rtconfig.h index 98d081b..55fb148 100644 --- a/rt-thread/rtconfig.h +++ b/rt-thread/rtconfig.h @@ -16,7 +16,7 @@ #define ENABLE_LOG_ALL #define TEST_ENABLE //打开所有的终端测试程序 #define ULOG_OUTPUT_LVL 7 // 生产时将其设为0 - #define NB_MODULE_SWITCH 1 //开启NB物联网功能 + #define IOT_MODULE_SWITCH 1 //开启NB物联网功能 /* RT-Thread Kernel */ @@ -204,12 +204,12 @@ /* end of CYW43439 WiFi */ /* end of Wi-Fi */ #define PKG_USING_AT_DEVICE - #define AT_DEVICE_USING_MB26 - #define AT_DEVICE_MB26_INIT_ASYN// - #define AT_DEVICE_MB26_SAMPLE + #define AT_DEVICE_USING_NT26K + #define AT_DEVICE_NT26K_INIT_ASYN// + #define AT_DEVICE_NT26K_SAMPLE - #define MB26_SAMPLE_CLIENT_NAME "uart1" - #define MB26_SAMPLE_RECV_BUFF_LEN 512 + #define NT26K_SAMPLE_CLIENT_NAME "uart1" + #define NT26K_SAMPLE_RECV_BUFF_LEN 512 #define PKG_USING_AT_DEVICE_LATEST_VERSION #define PKG_AT_DEVICE_VER_NUM 0x99999