From f4faea4749e20a1b5439aaf46edce99a76a9018a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B0=8F=E9=A9=AC=5F666?= <13089258+pony-six-hundred-and-sixty-six@user.noreply.gitee.com> Date: Fri, 17 Jan 2025 13:23:16 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BC=98=E5=8C=96=E4=BA=86=E6=96=AD=E7=BD=91?= =?UTF-8?q?=E9=87=8D=E8=BF=9E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bsp/src/at_device_nt26k.c | 957 ++++++++++++++-------------- bsp/src/bsp_nt26k.c | 1241 +++++++++++++++++++------------------ rt-thread/rtconfig.h | 6 +- 3 files changed, 1120 insertions(+), 1084 deletions(-) diff --git a/bsp/src/at_device_nt26k.c b/bsp/src/at_device_nt26k.c index 29aa33a..e81029a 100644 --- a/bsp/src/at_device_nt26k.c +++ b/bsp/src/at_device_nt26k.c @@ -2,7 +2,7 @@ * @Author : stark1898y 1658608470@qq.com * @Date : 2024-09-04 13:33:49 * @LastEditors: mbw && 1600520629@qq.com - * @LastEditTime: 2025-01-17 10:22:34 + * @LastEditTime: 2025-01-17 13:21:08 * @FilePath: \JT-DT-YD4N02A_RTT_MRS-NT26K\bsp\src\at_device_nt26k.c * @Description : * @@ -33,16 +33,16 @@ #if IOT_MODULE_SWITCH == 1 -#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 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 +#define AT_DEFAULT_TIMEOUT 5000 #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) +#define NT26K_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 2) char data_buf[AT_CLIENT_RECV_BUFF_LEN] = {0}; @@ -51,12 +51,12 @@ struct rt_completion nt26k_init_complate; volatile rt_uint8_t socket_id = 0; // 将本地时间转换为对应时区时间 -void Time_Zone_Conversion (TsRtcDateTime *timeInfo) +void Time_Zone_Conversion(TsRtcDateTime *timeInfo) { // 根据时区差异进行转换，这里时区差为8小时，没有分钟差异。 - timeInfo->hour += RT_LIBC_DEFAULT_TIMEZONE; // 小时部分加8小时 + timeInfo->hour += RT_LIBC_DEFAULT_TIMEZONE; // 小时部分加8小时 if (timeInfo->hour >= 24) - { // 如果超过24小时，则天数加1，小时数减24。 + { // 如果超过24小时，则天数加1，小时数减24。 timeInfo->day++; timeInfo->hour -= 24; if (timeInfo->day > 365) @@ -66,281 +66,286 @@ void Time_Zone_Conversion (TsRtcDateTime *timeInfo) } } -rt_err_t Nt26k_Reset (struct at_device *device) +rt_err_t Nt26k_Reset(struct at_device *device) { - 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 (NT26K_RST_PIN, PIN_HIGH); - rt_thread_mdelay (50); - rt_pin_write (NT26K_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(NT26K_RST_PIN, PIN_HIGH); + rt_thread_mdelay(50); + rt_pin_write(NT26K_RST_PIN, PIN_LOW); return RT_EOK; } -static int nt26k_power_on (struct at_device *device) +static int nt26k_power_on(struct at_device *device) { struct at_device_nt26k *nt26k = RT_NULL; nt26k = (struct at_device_nt26k *)device->user_data; - rt_pin_write (nt26k->pwr_en_pin, PIN_LOW); - rt_thread_mdelay (10); - rt_pin_write (nt26k->pwr_en_pin, PIN_HIGH); - - return device->class->device_ops->control (device, AT_DEVICE_CTRL_WAKEUP, RT_NULL); + rt_pin_write(nt26k->pwr_en_pin, PIN_LOW); + rt_thread_mdelay(10); + rt_pin_write(nt26k->pwr_en_pin, PIN_HIGH); + + return device->class->device_ops->control(device, AT_DEVICE_CTRL_WAKEUP, RT_NULL); } -static rt_err_t nt26k_power_off (struct at_device *device) +static rt_err_t nt26k_power_off(struct at_device *device) { struct at_device_nt26k *nt26k = RT_NULL; - nt26k = (struct at_device_nt26k *)device->user_data; + nt26k = (struct at_device_nt26k *)device->user_data; - device->class->device_ops->control (device, AT_DEVICE_RF_CLOSE, RT_NULL); + device->class->device_ops->control(device, AT_DEVICE_RF_CLOSE, RT_NULL); - rt_pin_write (nt26k->pwr_en_pin, PIN_LOW); + rt_pin_write(nt26k->pwr_en_pin, PIN_LOW); return RT_EOK; } -static rt_err_t nt26k_Close_Rf (struct at_device *device) +static rt_err_t nt26k_Close_Rf(struct at_device *device) { - at_response_t resp = at_create_resp (64, 0, rt_tick_from_millisecond (60000)); + at_response_t resp = at_create_resp(64, 0, rt_tick_from_millisecond(60000)); if (resp == RT_NULL) { - LOG_D ("no memory for resp create."); - at_delete_resp (resp); + LOG_D("no memory for resp create."); + at_delete_resp(resp); return (-RT_ERROR); } - if (at_obj_exec_cmd (device->client, resp, "AT+QPOWD=1") == RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+QPOWD=1") == RT_EOK) { - at_delete_resp (resp); - return RT_EOK; + if (at_resp_get_line_by_kw(resp, "POWERED DOWN") != RT_NULL) + { + at_delete_resp(resp); + return RT_EOK; + } } - + at_delete_resp(resp); return (-RT_ERROR); } #ifdef TEST_ENABLE void TEST_Nt26k_Reset() { - Nt26k_Reset (RT_NULL); + Nt26k_Reset(RT_NULL); } -MSH_CMD_EXPORT (TEST_Nt26k_Reset, "test_nt26k_reset"); +MSH_CMD_EXPORT(TEST_Nt26k_Reset, "test_nt26k_reset"); #endif -static int nt26k_sleep (struct at_device *device) +static int nt26k_sleep(struct at_device *device) { - at_response_t resp = RT_NULL; + at_response_t resp = RT_NULL; struct at_device_nt26k *nt26k = RT_NULL; nt26k = (struct at_device_nt26k *)device->user_data; - if (!nt26k->power_status) // power off + if (!nt26k->power_status) // power off { return (RT_EOK); } - if (nt26k->sleep_status) // is sleep status + if (nt26k->sleep_status) // is sleep status { return (RT_EOK); } - resp = at_create_resp (64, 0, rt_tick_from_millisecond (300)); + resp = at_create_resp(64, 0, rt_tick_from_millisecond(300)); if (resp == RT_NULL) { - LOG_D ("no memory for resp create."); - at_delete_resp (resp); + LOG_D("no memory for resp create."); + at_delete_resp(resp); return (-RT_ERROR); } - /* enable sleep mode */ + /* enable sleep mode */ // Sleep1 - if (at_obj_exec_cmd (device->client, resp, "AT+ECPMUCFG=1,2") != RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+ECPMUCFG=1,2") != RT_EOK) { - LOG_D ("enable sleep fail.\"AT+ECPMUCFG=1,2\" execute fail."); - at_delete_resp (resp); + LOG_D("enable sleep fail.\"AT+ECPMUCFG=1,2\" execute fail."); + at_delete_resp(resp); return (-RT_ERROR); } /* enable PSM mode */ - if (at_obj_exec_cmd (device->client, resp, "AT+CPSMS=1,,,,\"00100010\"") != RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+CPSMS=1,,,,\"00100010\"") != RT_EOK) { - LOG_D ("enable sleep fail.\"AT+CPSMS=1,,,,\"00100010\" execute fail."); - at_delete_resp (resp); + LOG_D("enable sleep fail.\"AT+CPSMS=1,,,,\"00100010\" execute fail."); + at_delete_resp(resp); return (-RT_ERROR); } nt26k->sleep_status = RT_TRUE; - at_delete_resp (resp); + at_delete_resp(resp); return (RT_EOK); } -static int nt26k_wakeup (struct at_device *device) +static int nt26k_wakeup(struct at_device *device) { struct at_device_nt26k *nt26k = RT_NULL; nt26k = (struct at_device_nt26k *)device->user_data; if (nt26k->pwr_key_pin != -1) { - rt_pin_write (nt26k->pwr_key_pin, PIN_LOW); - rt_thread_mdelay (100); - rt_pin_write (nt26k->pwr_key_pin, PIN_HIGH); + rt_pin_write(nt26k->pwr_key_pin, PIN_LOW); + rt_thread_mdelay(100); + rt_pin_write(nt26k->pwr_key_pin, PIN_HIGH); nt26k->sleep_status = RT_TRUE; } return (RT_EOK); } -static void urc_tcp_recv (struct at_client *client, const char *data, rt_size_t size) +static void urc_tcp_recv(struct at_client *client, const char *data, rt_size_t size) { - int len = 0; - rt_uint16_t crc16 = 0; - rt_uint16_t rec_crc16 = 0; - char crc16_buf[6] = {0}; + int len = 0; + 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)); + rt_memset(data_buf, 0, sizeof(data_buf)); - if (sscanf (data, "+QIURC: \"recv\",%*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 ("nt26k recv data: %s", data_buf); - crc16 = crc1021 (data_buf, len * 2 - 10); // 去掉帧尾三个字节和2个字节的校验值，字符长度为10 + HexStrToBytes(data_buf, recv_byte_buf, len * 2); + 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 ("nt26k crc16: %04s", crc16_buf); - rec_crc16 = strtol (crc16_buf, NULL, 16); - if (crc16 != rec_crc16) // 看下数据接收的是否正确 + rt_strncpy(crc16_buf, data_buf + len * 2 - 10, 4); + LOG_D("nt26k crc16: %04s", crc16_buf); + rec_crc16 = strtol(crc16_buf, NULL, 16); + if (crc16 != rec_crc16) // 看下数据接收的是否正确 { - LOG_E ("nt26k 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 Nt26kRecvData)) + if (len == sizeof(struct Nt26kRecvData)) { - rt_memset (nt26k_ops.recv, 0, sizeof (struct Nt26kRecvData)); // 清空结构体 - rt_memcpy (nt26k_ops.recv, recv_byte_buf, sizeof (struct Nt26kRecvData)); - if (nt26k_ops.recv->recv_data.event_type != INSTRUCTION_HEART_BEAT) // 加这个的原因就是如果有指令下发，会出现两个信号量，指令会执行两次，所以排除心跳包才释放信号量 + rt_memset(nt26k_ops.recv, 0, sizeof(struct Nt26kRecvData)); // 清空结构体 + rt_memcpy(nt26k_ops.recv, recv_byte_buf, sizeof(struct Nt26kRecvData)); + if ((nt26k_ops.recv->recv_data.event_type == INSTRUCTION_HEART_BEAT) || + (nt26k_ops.recv->recv_data.event_type == EVENT_TYPE_POWER_ON)) + // 加这个的原因就是如果有指令下发，会出现两个信号量，指令会执行两次，所以排除心跳包才释放信号量 { - rt_sem_release (nt26k_recv_sem); + rt_sem_release(nt26k_recv_heart_sem); } else { // 接收到的是心跳包 - rt_sem_release (nt26k_recv_heart_sem); + rt_sem_release(nt26k_recv_sem); } } else { - LOG_E ("nt26k recv data error {len [%d]!= sizeof(struct Nt26kRecvData)[%d]}", len, sizeof (struct Nt26kRecvData)); + LOG_E("nt26k recv data error {len [%d]!= sizeof(struct Nt26kRecvData)[%d]}", len, sizeof(struct Nt26kRecvData)); } } } - rt_memset (recv_byte_buf, 0, sizeof (recv_byte_buf)); + rt_memset(recv_byte_buf, 0, sizeof(recv_byte_buf)); } -static void urc_device_reset (struct at_client *client, const char *data, rt_size_t size) +static void urc_device_reset(struct at_client *client, const char *data, rt_size_t size) { - LOG_D ("device reset"); + LOG_D("device reset"); nt26k_conncet_tcp_flag = 0; } -static void urc_tcp_disconnect (struct at_client *client, const char *data, rt_size_t size) +static void urc_tcp_disconnect(struct at_client *client, const char *data, rt_size_t size) { size_t id; - if (sscanf (data, "+QIURC: \"closed\",%d", &id) == 1) + if (sscanf(data, "+QIURC: \"closed\",%d", &id) == 1) { if (id == socket_id) { - LOG_W ("socket %d disconnect", id); + LOG_W("socket %d disconnect", id); nt26k_conncet_tcp_flag = 0; - rt_sem_release (nt26k_disconnect_sem); + rt_sem_release(nt26k_disconnect_sem); } } } static const struct at_urc urc_table[] = { - {"+QIURC: \"recv\"", "\r\n", urc_tcp_recv }, - {"boot.rom", "\r\n", urc_device_reset }, // 这个是软件复位时， - {"Lierda", "\r\n", urc_device_reset }, // 这个时硬件复位时回复 + {"+QIURC: \"recv\"", "\r\n", urc_tcp_recv}, + {"boot.rom", "\r\n", urc_device_reset}, // 这个是软件复位时， + {"Lierda", "\r\n", urc_device_reset}, // 这个时硬件复位时回复 {"+QIURC: \"closed\"", "\r\n", urc_tcp_disconnect}, // tcp连接断开 }; -void show_resp_info (at_response_t resp) +void show_resp_info(at_response_t resp) { - RT_ASSERT (resp); + RT_ASSERT(resp); /* Print response line buffer */ const char *line_buffer = RT_NULL; for (rt_size_t line_num = 1; line_num <= resp->line_counts; line_num++) { - if ((line_buffer = at_resp_get_line (resp, line_num)) != RT_NULL) - LOG_I ("line %d buffer : %s", line_num, line_buffer); + if ((line_buffer = at_resp_get_line(resp, line_num)) != RT_NULL) + LOG_I("line %d buffer : %s", line_num, line_buffer); else - LOG_I ("Parse line buffer error!"); + LOG_I("Parse line buffer error!"); } return; } -int at_device_nt26k_disconnect_tcp (struct at_device *device) +int at_device_nt26k_disconnect_tcp(struct at_device *device) { #define NT26K_CLOSE_REP_TIME (5 * AT_DEFAULT_TIMEOUT) - at_response_t resp = at_create_resp (AT_CLIENT_RECV_BUFF_LEN, 0, NT26K_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!"); - at_delete_resp (resp); + LOG_E("No memory for response structure!"); + at_delete_resp(resp); return -RT_ENOMEM; } - if (at_obj_exec_cmd (device->client, resp, TCP_CLOSE_SOCKET, socket_id) != RT_EOK) + if (at_obj_exec_cmd(device->client, resp, TCP_CLOSE_SOCKET, socket_id) != RT_EOK) { - at_delete_resp (resp); + at_delete_resp(resp); return -RT_ERROR; } nt26k_conncet_tcp_flag = 0; - at_delete_resp (resp); + at_delete_resp(resp); return RT_EOK; } -static int at_device_nt26k_connect_tcp (struct at_device *device) +static int at_device_nt26k_connect_tcp(struct at_device *device) { if (nt26k_conncet_tcp_flag) return RT_EOK; - ASSERT (device); - int err_code = 0; - at_response_t resp = at_create_resp (64, 4, AT_DEFAULT_TIMEOUT); + ASSERT(device); + int err_code = 0; + at_response_t resp = at_create_resp(64, 4, AT_DEFAULT_TIMEOUT); if (resp == RT_NULL) { - LOG_E ("No memory for response structure!"); - at_delete_resp (resp); + LOG_E("No memory for response structure!"); + at_delete_resp(resp); return -RT_ENOMEM; } - if (Flash_Get_Sever_Data (&sever_info) != RT_EOK) + if (Flash_Get_Sever_Data(&sever_info) != RT_EOK) { - LOG_E ("Get Sever Data Failed"); - at_delete_resp (resp); + LOG_E("Get Sever Data Failed"); + at_delete_resp(resp); return RT_ERROR; } - if (at_obj_exec_cmd (device->client, resp, TCP_CONNECT_CMD, sever_info.server_url, sever_info.server_port) == RT_EOK) + if (at_obj_exec_cmd(device->client, resp, TCP_CONNECT_CMD, sever_info.server_url, sever_info.server_port) == RT_EOK) { - if (at_resp_parse_line_args_by_kw (resp, "+QIOPEN:", "+QIOPEN:%d,%d", &socket_id, &err_code) > 0) + if (at_resp_parse_line_args_by_kw(resp, "+QIOPEN:", "+QIOPEN:%d,%d", &socket_id, &err_code) > 0) { if (err_code == 0) { - LOG_D ("nt26k connect to tcp server success"); + LOG_D("nt26k connect to tcp server success"); nt26k_conncet_tcp_flag = 1; - at_delete_resp (resp); + at_delete_resp(resp); return RT_EOK; } else { - LOG_E ("nt26k connect to tcp server failed. error code: %d", err_code); + LOG_E("nt26k connect to tcp server failed. error code: %d", err_code); if (err_code == 570) { nt26k_disconnect_pdp_flag = 1; @@ -348,65 +353,65 @@ static int at_device_nt26k_connect_tcp (struct at_device *device) } } } - at_delete_resp (resp); + at_delete_resp(resp); return RT_ERROR; } -int at_send_data (struct at_device *device, const char *data, rt_size_t size) +int at_send_data(struct at_device *device, const char *data, rt_size_t size) { #define NT26K_SEND_RESP_TIME (3000) - const char *line_buffer = RT_NULL; - rt_uint8_t retry = 0; - at_response_t resp = at_create_resp (AT_CLIENT_RECV_BUFF_LEN / 4, 2, NT26K_SEND_RESP_TIME); - rt_uint8_t max_retry_count = (rt_uint8_t)Flash_Get_SysCfg (kIotRetryId); + const char *line_buffer = RT_NULL; + rt_uint8_t retry = 0; + at_response_t resp = at_create_resp(AT_CLIENT_RECV_BUFF_LEN / 4, 2, NT26K_SEND_RESP_TIME); + rt_uint8_t max_retry_count = (rt_uint8_t)Flash_Get_SysCfg(kIotRetryId); if (resp == RT_NULL) { - LOG_E ("no memory for nt26k device(%s) response structure.", device->name); - at_delete_resp (resp); + LOG_E("no memory for nt26k device(%s) response structure.", device->name); + at_delete_resp(resp); return -RT_ERROR; } while (retry < max_retry_count) { - rt_thread_mdelay (IMEI_Delay()); // 获取一个随机延时 - if (at_obj_exec_cmd (device->client, resp, TCP_SEND_DATA, socket_id, data) == RT_EOK) + rt_thread_mdelay(IMEI_Delay()); // 获取一个随机延时 + if (at_obj_exec_cmd(device->client, resp, TCP_SEND_DATA, socket_id, data) == RT_EOK) { - if ((line_buffer = at_resp_get_line (resp, 2)) != RT_NULL) + if ((line_buffer = at_resp_get_line(resp, 2)) != RT_NULL) { - if (rt_strstr (line_buffer, "SEND OK") != RT_NULL) + if (rt_strstr(line_buffer, "SEND OK") != RT_NULL) { - LOG_D ("send data success, socket_id: %d", socket_id); - at_delete_resp (resp); + LOG_D("send data success, socket_id: %d", socket_id); + at_delete_resp(resp); return RT_EOK; } } } retry++; - rt_thread_mdelay (1000); + rt_thread_mdelay(1000); } - at_delete_resp (resp); + at_delete_resp(resp); return -RT_ERROR; } -int nt26k_check_link_status (struct at_device *device) +int nt26k_check_link_status(struct at_device *device) { at_response_t resp = RT_NULL; - int result = -RT_ERROR; + int result = -RT_ERROR; - resp = at_create_resp (64, 0, rt_tick_from_millisecond (300)); + resp = at_create_resp(64, 0, rt_tick_from_millisecond(300)); if (resp == RT_NULL) { - LOG_D ("no memory for resp create."); - at_delete_resp (resp); + LOG_D("no memory for resp create."); + at_delete_resp(resp); return (-RT_ERROR); } result = -RT_ERROR; - if (at_obj_exec_cmd (device->client, resp, "AT+CEREG?") == RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+CEREG?") == RT_EOK) { int link_stat = 0; - if (at_resp_parse_line_args_by_kw (resp, "+CEREG:", "+CEREG: %*d,%d", &link_stat) > 0) + if (at_resp_parse_line_args_by_kw(resp, "+CEREG:", "+CEREG: %*d,%d", &link_stat) > 0) { if (link_stat == 1 || link_stat == 5) { @@ -415,49 +420,49 @@ int nt26k_check_link_status (struct at_device *device) } } - at_delete_resp (resp); + at_delete_resp(resp); return (result); } /* ============================= nt26k network interface operations ============================= */ /* set nt26k network interface device status and address information */ -int nt26k_netdev_set_info (struct netdev *netdev) +int nt26k_netdev_set_info(struct netdev *netdev) { #define NT26K_INFO_RESP_SIZE 128 -#define NT26K_INFO_RESP_TIMO rt_tick_from_millisecond (1000) +#define NT26K_INFO_RESP_TIMO rt_tick_from_millisecond(1000) - int result = RT_EOK; - at_response_t resp = RT_NULL; + int result = RT_EOK; + at_response_t resp = RT_NULL; struct at_device *device = RT_NULL; - RT_ASSERT (netdev); + RT_ASSERT(netdev); - device = at_device_get_by_name (AT_DEVICE_NAMETYPE_NETDEV, netdev->name); + device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name); if (device == RT_NULL) { - LOG_E ("get device(%s) failed.", netdev->name); + LOG_E("get device(%s) failed.", netdev->name); return -RT_ERROR; } /* set network interface device status */ - netdev_low_level_set_status (netdev, RT_TRUE); - netdev_low_level_set_link_status (netdev, RT_TRUE); - netdev_low_level_set_dhcp_status (netdev, RT_TRUE); + netdev_low_level_set_status(netdev, RT_TRUE); + netdev_low_level_set_link_status(netdev, RT_TRUE); + netdev_low_level_set_dhcp_status(netdev, RT_TRUE); - resp = at_create_resp (NT26K_INFO_RESP_SIZE, 0, NT26K_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."); - at_delete_resp (resp); + LOG_E("no memory for resp create."); + at_delete_resp(resp); result = -RT_ENOMEM; goto __exit; } - device->class->device_ops->control (device, AT_DEVICE_CTRL_NET_CONN, RT_NULL); // 打开连接 + device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_CONN, RT_NULL); // 打开连接 __exit: if (resp) { - at_delete_resp (resp); + at_delete_resp(resp); } return result; @@ -468,216 +473,216 @@ __exit: * * @param netdev: nt26k network interface device */ -static void nt26k_check_link_status_entry (void *parameter) +static void nt26k_check_link_status_entry(void *parameter) { #define NT26K_LINK_DELAY_TIME (10 * 60 * RT_TICK_PER_SECOND) -#define NT26K_LINK_STATUS_OK 1 +#define NT26K_LINK_STATUS_OK 1 int link_status; struct at_device *device = RT_NULL; - struct netdev *netdev = (struct netdev *)parameter; + struct netdev *netdev = (struct netdev *)parameter; - device = at_device_get_by_name (AT_DEVICE_NAMETYPE_NETDEV, netdev->name); + device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name); if (device == RT_NULL) { - LOG_E ("get device(%s) failed.", netdev->name); + LOG_E("get device(%s) failed.", netdev->name); return; } while (1) { - link_status = nt26k_check_link_status (device); + link_status = nt26k_check_link_status(device); if (link_status < 0) { - rt_thread_mdelay (NT26K_LINK_DELAY_TIME); + rt_thread_mdelay(NT26K_LINK_DELAY_TIME); continue; } /* check the network interface device link status */ - if ((NT26K_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, (NT26K_LINK_STATUS_OK == link_status)); + netdev_low_level_set_link_status(netdev, (NT26K_LINK_STATUS_OK == link_status)); } - rt_thread_delay (NT26K_LINK_DELAY_TIME); + rt_thread_delay(NT26K_LINK_DELAY_TIME); } } -int nt26k_netdev_check_link_status (struct netdev *netdev) +int nt26k_netdev_check_link_status(struct netdev *netdev) { -#define NT26K_LINK_THREAD_TICK 20 +#define NT26K_LINK_THREAD_TICK 20 #define NT26K_LINK_THREAD_STACK_SIZE (1024 + 512) -#define NT26K_LINK_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX - 2) +#define NT26K_LINK_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX - 2) rt_thread_t tid; char tname[RT_NAME_MAX] = {0}; - RT_ASSERT (netdev); + RT_ASSERT(netdev); - rt_snprintf (tname, RT_NAME_MAX, "%s", netdev->name); + rt_snprintf(tname, RT_NAME_MAX, "%s", netdev->name); /* 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); + 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); + rt_thread_startup(tid); } return RT_EOK; } -static int nt26k_net_init (struct at_device *device); +static int nt26k_net_init(struct at_device *device); -static int nt26k_netdev_set_up (struct netdev *netdev) +static int nt26k_netdev_set_up(struct netdev *netdev) { struct at_device *device = RT_NULL; - device = at_device_get_by_name (AT_DEVICE_NAMETYPE_NETDEV, netdev->name); - LOG_D("netdev->name:%s",netdev->name); + device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name); + LOG_D("netdev->name:%s", netdev->name); if (device == RT_NULL) { - LOG_E ("get device(%s) failed.", netdev->name); + LOG_E("get device(%s) failed.", netdev->name); return -RT_ERROR; } if (device->is_init == RT_FALSE) { - nt26k_net_init (device); + nt26k_net_init(device); device->is_init = RT_TRUE; - netdev_low_level_set_status (netdev, RT_TRUE); - LOG_D ("network interface device(%s) set up status.", netdev->name); + netdev_low_level_set_status(netdev, RT_TRUE); + LOG_D("network interface device(%s) set up status.", netdev->name); } return RT_EOK; } -static int nt26k_netdev_set_down (struct netdev *netdev) +static int nt26k_netdev_set_down(struct netdev *netdev) { struct at_device *device = RT_NULL; - device = at_device_get_by_name (AT_DEVICE_NAMETYPE_NETDEV, netdev->name); + device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name); if (device == RT_NULL) { - LOG_E ("get device(%s) failed.", netdev->name); + LOG_E("get device(%s) failed.", netdev->name); return -RT_ERROR; } if (device->is_init == RT_TRUE) { - nt26k_power_off (device); + nt26k_power_off(device); device->is_init = RT_FALSE; - netdev_low_level_set_status (netdev, RT_FALSE); - LOG_D ("network interface device(%s) set down status.", netdev->name); + netdev_low_level_set_status(netdev, RT_FALSE); + LOG_D("network interface device(%s) set down status.", netdev->name); } return RT_EOK; } -static int nt26k_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 NT26K_DNS_RESP_LEN 64 -#define NT26K_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; + int result = RT_EOK; + at_response_t resp = RT_NULL; struct at_device *device = RT_NULL; - RT_ASSERT (netdev); - RT_ASSERT (dns_server); + RT_ASSERT(netdev); + RT_ASSERT(dns_server); - device = at_device_get_by_name (AT_DEVICE_NAMETYPE_NETDEV, netdev->name); + device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name); if (device == RT_NULL) { - LOG_E ("get device(%s) failed.", netdev->name); + LOG_E("get device(%s) failed.", netdev->name); return -RT_ERROR; } - resp = at_create_resp (NT26K_DNS_RESP_LEN, 0, NT26K_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."); - at_delete_resp (resp); + LOG_D("no memory for resp create."); + at_delete_resp(resp); result = -RT_ENOMEM; goto __exit; } /* send "AT+QIDNSCFG=[,]" commond to set dns servers */ - if (at_obj_exec_cmd (device->client, resp, "AT+QIDNSCFG=%d,%s", - dns_num, inet_ntoa (*dns_server)) != RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+QIDNSCFG=%d,%s", + dns_num, inet_ntoa(*dns_server)) != RT_EOK) { result = -RT_ERROR; goto __exit; } - netdev_low_level_set_dns_server (netdev, dns_num, dns_server); + netdev_low_level_set_dns_server(netdev, dns_num, dns_server); __exit: if (resp) { - at_delete_resp (resp); + at_delete_resp(resp); } return result; } #ifdef NETDEV_USING_PING -static int nt26k_netdev_ping (struct netdev *netdev, const char *host, size_t data_len, - uint32_t timeout, struct netdev_ping_resp *ping_resp +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 - , - rt_bool_t is_bind + , + rt_bool_t is_bind #endif ) { #define NT26K_PING_RESP_SIZE 128 -#define NT26K_PING_IP_SIZE 16 -#define NT26K_PING_TIMEO (NT26K_CON_REP_TIME) +#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; + rt_err_t result = RT_EOK; + int response = -1, recv_data_len, ping_time, ttl; char ip_addr[NT26K_PING_IP_SIZE] = {0}; - at_response_t resp = RT_NULL; - struct at_device *device = RT_NULL; + at_response_t resp = RT_NULL; + struct at_device *device = RT_NULL; #if RT_VER_NUM >= 0x50100 - RT_UNUSED (is_bind); + RT_UNUSED(is_bind); #endif - RT_ASSERT (netdev); - RT_ASSERT (host); - RT_ASSERT (ping_resp); + RT_ASSERT(netdev); + RT_ASSERT(host); + RT_ASSERT(ping_resp); - device = at_device_get_by_name (AT_DEVICE_NAMETYPE_NETDEV, netdev->name); + device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, netdev->name); if (device == RT_NULL) { - LOG_E ("get device(%s) failed.", netdev->name); + LOG_E("get device(%s) failed.", netdev->name); return -RT_ERROR; } - resp = at_create_resp (NT26K_PING_RESP_SIZE, 4, NT26K_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"); - at_delete_resp (resp); + LOG_E("no memory for resp create"); + at_delete_resp(resp); return -RT_ENOMEM; } /* send "AT+QPING=""[,[][,]]" commond to send ping request */ - if (at_obj_exec_cmd (device->client, resp, "AT+QPING=1,\"%s\",%d,1", host, timeout / RT_TICK_PER_SECOND) < 0) + if (at_obj_exec_cmd(device->client, resp, "AT+QPING=1,\"%s\",%d,1", host, timeout / RT_TICK_PER_SECOND) < 0) { result = -RT_ERROR; goto __exit; } - at_resp_parse_line_args_by_kw (resp, "+QPING:", "+QPING:%d", &response); + at_resp_parse_line_args_by_kw(resp, "+QPING:", "+QPING:%d", &response); /* Received the ping response from the server */ if (response == 0) { - if (at_resp_parse_line_args_by_kw (resp, "+QPING:", "+QPING:%d,\"%[^\"]\",%d,%d,%d", - &response, ip_addr, &recv_data_len, &ping_time, &ttl) <= 0) + if (at_resp_parse_line_args_by_kw(resp, "+QPING:", "+QPING:%d,\"%[^\"]\",%d,%d,%d", + &response, ip_addr, &recv_data_len, &ping_time, &ttl) <= 0) { result = -RT_ERROR; goto __exit; @@ -687,25 +692,25 @@ static int nt26k_netdev_ping (struct netdev *netdev, const char *host, size_t da /* prase response number */ switch (response) { - case 0: - inet_aton (ip_addr, &(ping_resp->ip_addr)); - ping_resp->data_len = recv_data_len; - ping_resp->ticks = ping_time; - ping_resp->ttl = ttl; - result = RT_EOK; - break; - case 569: - result = -RT_ETIMEOUT; - break; - default: - result = -RT_ERROR; - break; + case 0: + inet_aton(ip_addr, &(ping_resp->ip_addr)); + ping_resp->data_len = recv_data_len; + ping_resp->ticks = ping_time; + ping_resp->ttl = ttl; + result = RT_EOK; + break; + case 569: + result = -RT_ETIMEOUT; + break; + default: + result = -RT_ERROR; + break; } __exit: if (resp) { - at_delete_resp (resp); + at_delete_resp(resp); } return result; @@ -727,36 +732,36 @@ const struct netdev_ops nt26k_netdev_ops = RT_NULL, }; -static struct netdev *nt26k_netdev_add (const char *netdev_name) +static struct netdev *nt26k_netdev_add(const char *netdev_name) { #define ETHERNET_MTU 1380 -#define HWADDR_LEN 8 +#define HWADDR_LEN 8 struct netdev *netdev = RT_NULL; - netdev = netdev_get_by_name (netdev_name); + netdev = netdev_get_by_name(netdev_name); if (netdev != RT_NULL) { return (netdev); } - netdev = (struct netdev *)rt_calloc (1, sizeof (struct netdev)); + netdev = (struct netdev *)rt_calloc(1, sizeof(struct netdev)); if (netdev == RT_NULL) { - LOG_E ("no memory for netdev create."); + LOG_E("no memory for netdev create."); return RT_NULL; } - netdev->mtu = ETHERNET_MTU; - netdev->ops = &nt26k_netdev_ops; + netdev->mtu = ETHERNET_MTU; + netdev->ops = &nt26k_netdev_ops; netdev->hwaddr_len = HWADDR_LEN; #ifdef SAL_USING_AT - extern int sal_at_netdev_set_pf_info (struct netdev * netdev); + extern int sal_at_netdev_set_pf_info(struct netdev * netdev); /* set the network interface socket/netdb operations */ - sal_at_netdev_set_pf_info (netdev); + sal_at_netdev_set_pf_info(netdev); #endif - netdev_register (netdev, netdev_name, RT_NULL); + netdev_register(netdev, netdev_name, RT_NULL); return netdev; } @@ -764,77 +769,76 @@ static struct netdev *nt26k_netdev_add (const char *netdev_name) /* ============================= nt26k device operations ============================= */ /* initialize for nt26k */ -static void nt26k_init_thread_entry (void *parameter) +static void nt26k_init_thread_entry(void *parameter) { -#define INIT_RETRY 5 -#define CPIN_RETRY 20 -#define CSQ_RETRY 30 -#define CEREG_RETRY 60 +#define INIT_RETRY 5 +#define CPIN_RETRY 20 +#define CSQ_RETRY 30 +#define CEREG_RETRY 60 #define IPADDR_RETRY 10 int i; - rt_err_t result = RT_EOK; - at_response_t resp = RT_NULL; + rt_err_t result = RT_EOK; + at_response_t resp = RT_NULL; struct at_device *device = (struct at_device *)parameter; struct at_client *client = device->client; - resp = at_create_resp (128, 0, rt_tick_from_millisecond (300)); + resp = at_create_resp(128, 0, rt_tick_from_millisecond(300)); if (resp == RT_NULL) { - LOG_E ("no memory for resp create."); - at_delete_resp (resp); + LOG_E("no memory for resp create."); + at_delete_resp(resp); return; } - LOG_D ("start init %s device.", device->name); + LOG_D("start init %s device.", device->name); while (1) { /* power on the nt26k device */ - device->class->device_ops->control (device, AT_DEVICE_CTRL_POWER_ON, RT_NULL); - rt_thread_mdelay (100); + device->class->device_ops->control(device, AT_DEVICE_CTRL_POWER_ON, RT_NULL); /* wait nt26k startup finish, send AT every 500ms, if recei ve OK, SYNC success*/ - if (at_client_obj_wait_connect (client, NT26K_WAIT_CONNECT_TIME)) + if (at_client_obj_wait_connect(client, RT_WAITING_FOREVER)) { result = -RT_ETIMEOUT; goto __exit; } /* disable echo */ - if (at_obj_exec_cmd (device->client, resp, "ATE0") != RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "ATE0") != RT_EOK) { result = -RT_ERROR; goto __exit; } /* get module version */ - if (at_obj_exec_cmd (device->client, resp, "AT+CGMR") != RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+CGMR") != RT_EOK) { result = -RT_ERROR; goto __exit; } for (i = 0; i < (int)resp->line_counts - 1; i++) { - LOG_D ("%s", at_resp_get_line (resp, i + 1)); + LOG_D("%s", at_resp_get_line(resp, i + 1)); } /*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) + 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) + if (at_obj_exec_cmd(device->client, resp, "AT+QICFG=\"viewmode\",1") != RT_EOK) { result = -RT_ERROR; goto __exit; } /*设置保活信息*/ - if (at_obj_exec_cmd (device->client, resp, "AT+QICFG=\"tcp/keepalive\",1,10000,100,10") != RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+QICFG=\"tcp/keepalive\",1,1000,100,10") != RT_EOK) { result = -RT_ERROR; goto __exit; } - if (at_obj_exec_cmd (device->client, resp, "AT+QICFG=\"passiveclosed\",1") != RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+QICFG=\"passiveclosed\",1") != RT_EOK) { result = -RT_ERROR; goto __exit; @@ -842,51 +846,51 @@ static void nt26k_init_thread_entry (void *parameter) /* check SIM card */ for (i = 0; i < CPIN_RETRY; i++) { - if (at_obj_exec_cmd (device->client, resp, "AT+CPIN?") == RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+CPIN?") == RT_EOK) { - if (at_resp_get_line_by_kw (resp, "+CPIN: READY") != RT_NULL) + if (at_resp_get_line_by_kw(resp, "+CPIN: READY") != RT_NULL) break; } - rt_thread_mdelay (1000); + rt_thread_mdelay(1000); } if (i == CPIN_RETRY) { - LOG_E ("%s device SIM card detection failed.", device->name); + LOG_E("%s device SIM card detection failed.", device->name); result = -RT_ERROR; goto __exit; } /* set etwork interface device hardware address(IMEI) */ - if ((*(rt_uint16_t *)FLASH_IOT_IMEI_ADDR == 0xE339) || (*(rt_uint16_t *)FLASH_IOT_IMEI_ADDR == 0x39E3)) // 未写入 + if ((*(rt_uint16_t *)FLASH_IOT_IMEI_ADDR == 0xE339) || (*(rt_uint16_t *)FLASH_IOT_IMEI_ADDR == 0x39E3)) // 未写入 { #define NT26K_NETDEV_HWADDR_LEN 8 -#define NT26K_IMEI_LEN 15 +#define NT26K_IMEI_LEN 15 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) + 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, "86", "%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); + LOG_E("%s device prase \"AT+CGSN=1\" cmd error.", device->name); result = -RT_ERROR; goto __exit; } - LOG_D ("%s device IMEI number: %s", device->name, imei); + LOG_D("%s device IMEI number: %s", device->name, imei); - rt_memcpy (nt26k.imei, imei, NT26K_IMEI_LEN); - Flash_Sys_Cfg (kIotImeiId, nt26k.imei, NT26K_IMEI_LEN); + rt_memcpy(nt26k.imei, imei, NT26K_IMEI_LEN); + Flash_Sys_Cfg(kIotImeiId, nt26k.imei, NT26K_IMEI_LEN); } else { rt_memset((char *)nt26k.imei, 0, NT26K_IMEI_LEN); Get_IotImei((char *)&nt26k.imei[0], NT26K_IMEI_LEN); } - rt_thread_mdelay (10); + rt_thread_mdelay(1); /* set network interface device hardware iccid */ - if ((*(rt_uint16_t *)FLASH_IOT_ICCID_ADDR == 0xE339) || (*(rt_uint16_t *)FLASH_IOT_ICCID_ADDR == 0x39E3)) // 未写入 + if ((*(rt_uint16_t *)FLASH_IOT_ICCID_ADDR == 0xE339) || (*(rt_uint16_t *)FLASH_IOT_ICCID_ADDR == 0x39E3)) // 未写入 { #define NT26K_ICCID_LEN 20 @@ -894,31 +898,31 @@ static void nt26k_init_thread_entry (void *parameter) char iccid[NT26K_ICCID_LEN] = {0}; /* send "AT+ECICCID" commond to get device iccid */ - if (at_obj_exec_cmd (device->client, resp, "AT+QCCID") != RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+QCCID") != RT_EOK) { result = -RT_ERROR; goto __exit; } - if (at_resp_parse_line_args_by_kw (resp, "+QCCID:", "+QCCID:%s", iccid) <= 0) + if (at_resp_parse_line_args_by_kw(resp, "+QCCID:", "+QCCID:%s", iccid) <= 0) { - LOG_E ("%s device prase \"AT+ECICCID\" cmd error.", device->name); + LOG_E("%s device prase \"AT+ECICCID\" cmd error.", device->name); result = -RT_ERROR; goto __exit; } - LOG_D ("%s device iccid number: %s", device->name, iccid); + LOG_D("%s device iccid number: %s", device->name, iccid); - rt_memcpy (nt26k.iccid, iccid, NT26K_ICCID_LEN); - Flash_Sys_Cfg (kIotIccidId, nt26k.iccid, NT26K_ICCID_LEN); + rt_memcpy(nt26k.iccid, iccid, NT26K_ICCID_LEN); + Flash_Sys_Cfg(kIotIccidId, nt26k.iccid, NT26K_ICCID_LEN); } else { rt_memset((char *)nt26k.iccid, 0, NT26K_ICCID_LEN); Get_IotIccid((char *)&nt26k.iccid[0], NT26K_ICCID_LEN); } - rt_thread_mdelay (10); + rt_thread_mdelay(100); /* set network interface device hardware imsi */ - if ((*(rt_uint16_t *)FLASH_IOT_IMSI_ADDR == 0xE339) || (*(rt_uint16_t *)FLASH_IOT_IMSI_ADDR == 0x39E3)) // 未写入 + if ((*(rt_uint16_t *)FLASH_IOT_IMSI_ADDR == 0xE339) || (*(rt_uint16_t *)FLASH_IOT_IMSI_ADDR == 0x39E3)) // 未写入 { #define NT26K_IMSI_LEN 15 @@ -926,84 +930,82 @@ static void nt26k_init_thread_entry (void *parameter) 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) + if (at_obj_exec_cmd(device->client, resp, "AT+CIMI") != RT_EOK) { result = -RT_ERROR; goto __exit; } - if (at_resp_parse_line_args_by_kw (resp, "46", "%s", imsi) <= 0) + if (at_resp_parse_line_args_by_kw(resp, "46", "%s", imsi) <= 0) { - LOG_E ("%s device prase \"AT+CIMI\" cmd error.", device->name); + LOG_E("%s device prase \"AT+CIMI\" cmd error.", device->name); result = -RT_ERROR; goto __exit; } - LOG_D ("%s device imsi number: %s", device->name, imsi); + LOG_D("%s device imsi number: %s", device->name, imsi); - rt_memcpy (nt26k.imsi, imsi, NT26K_IMSI_LEN); - Flash_Sys_Cfg (kIotImsiId, nt26k.imsi, NT26K_IMSI_LEN); + rt_memcpy(nt26k.imsi, imsi, NT26K_IMSI_LEN); + Flash_Sys_Cfg(kIotImsiId, nt26k.imsi, NT26K_IMSI_LEN); } else { - //已经写入了，将其赋值给结构体 + // 已经写入了，将其赋值给结构体 rt_memset((char *)nt26k.imsi, 0, NT26K_IMSI_LEN); Get_IotImei((char *)&nt26k.imsi[0], NT26K_IMSI_LEN); - } - rt_thread_mdelay (10); + rt_thread_mdelay(1000); /* check signal strength */ for (i = 0; i < CSQ_RETRY; i++) { - if (at_obj_exec_cmd(device->client, resp, "AT+CSQ") == RT_EOK) - { - int signal_strength = 0, err_rate = 0; + if (at_obj_exec_cmd(device->client, resp, "AT+CSQ") == RT_EOK) + { + int signal_strength = 0, err_rate = 0; - if (at_resp_parse_line_args_by_kw(resp, "+CSQ:", "+CSQ: %d,%d", &signal_strength, &err_rate) > 0) - { - if ((signal_strength != 99) && (signal_strength != 0)) - { - LOG_D("%s device signal strength: %d, channel bit err_rate: %d", - device->name, signal_strength, err_rate); - nt26k.rssi = signal_strength; - break; - } - } - } - rt_thread_mdelay(1000); + if (at_resp_parse_line_args_by_kw(resp, "+CSQ:", "+CSQ: %d,%d", &signal_strength, &err_rate) > 0) + { + if ((signal_strength != 99) && (signal_strength != 0)) + { + LOG_D("%s device signal strength: %d, channel bit err_rate: %d", + device->name, signal_strength, err_rate); + nt26k.rssi = signal_strength; + break; + } + } + } + rt_thread_mdelay(1000); } if (i == CSQ_RETRY) { - LOG_E("%s device signal strength check failed", device->name); - result = -RT_ERROR; - goto __exit; + LOG_E("%s device signal strength check failed", device->name); + result = -RT_ERROR; + goto __exit; } /* check the GPRS network is registered */ for (i = 0; i < CEREG_RETRY; i++) { - if (at_obj_exec_cmd (device->client, resp, "AT+CEREG?") == RT_EOK)//60s内注册CS业务 + if (at_obj_exec_cmd(device->client, resp, "AT+CEREG?") == RT_EOK) // 60s内注册CS业务 { int link_stat = 0; - if (at_resp_parse_line_args_by_kw (resp, "+CEREG:", "+CEREG: %*d,%d", &link_stat) > 0) + if (at_resp_parse_line_args_by_kw(resp, "+CEREG:", "+CEREG: %*d,%d", &link_stat) > 0) { if ((link_stat == 1) || (link_stat == 5)) { - LOG_D ("%s device GPRS is registered", device->name); + LOG_D("%s device GPRS is registered", device->name); break; } } - } - rt_thread_mdelay (1000); + rt_thread_mdelay(1000); + } + if (i == CEREG_RETRY) + { + result = -RT_ERROR; + goto __exit; } - if (i == CEREG_RETRY) - { - result = -RT_ERROR; - goto __exit; - } // for (i = 0; i < CEREG_RETRY; i++) // { @@ -1020,118 +1022,117 @@ static void nt26k_init_thread_entry (void *parameter) // } for (i = 0; i < CEREG_RETRY; i++) { - if (at_obj_exec_cmd (device->client, resp, "AT+CGACT=1,1") == RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+CGACT=1,1") == RT_EOK) { - LOG_D ("pdp激活成功"); + LOG_D("pdp激活成功"); break; } - else { - // AT+CGACT=0,1 //去激活 PDP - if (at_obj_exec_cmd (device->client, resp, "AT+CGACT=0,1") == RT_EOK) - { - LOG_D ("pdp去激活成功"); - - } + else + { + // AT+CGACT=0,1 //去激活 PDP + if (at_obj_exec_cmd(device->client, resp, "AT+CGACT=0,1") == RT_EOK) + { + LOG_D("pdp去激活成功"); + } } - rt_thread_mdelay (5000); + rt_thread_mdelay(5000); } if (i == CEREG_RETRY) { result = -RT_ERROR; goto __exit; } - if (at_obj_exec_cmd (device->client, resp, "AT+CCLK?") == RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+CCLK?") == RT_EOK) { TsRtcDateTime rtc_dt; 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; - rtc_dt.day = days; - rtc_dt.hour = hous; // 此时为零区时间，需要转化为东八区 + rtc_dt.year = (2000 + year); + rtc_dt.month = mounth; + rtc_dt.day = days; + rtc_dt.hour = hous; // 此时为零区时间，需要转化为东八区 rtc_dt.minute = min; rtc_dt.second = sec; - Time_Zone_Conversion (&rtc_dt); // 时区设置 - rtc_dt.week = RTC_GetWeek (rtc_dt.year, rtc_dt.month, rtc_dt.day); - RTC_SetTime (rtc_dt.year, rtc_dt.month, rtc_dt.day, - rtc_dt.hour, rtc_dt.minute, rtc_dt.second); // 设置时间 - LOG_I ("RTC时间: %04d-%02d-%02d %02d:%02d:%02d \n", - rtc_dt.year, rtc_dt.month, rtc_dt.day, rtc_dt.hour, rtc_dt.minute, rtc_dt.second); + Time_Zone_Conversion(&rtc_dt); // 时区设置 + rtc_dt.week = RTC_GetWeek(rtc_dt.year, rtc_dt.month, rtc_dt.day); + RTC_SetTime(rtc_dt.year, rtc_dt.month, rtc_dt.day, + rtc_dt.hour, rtc_dt.minute, rtc_dt.second); // 设置时间 + LOG_I("RTC时间: %04d-%02d-%02d %02d:%02d:%02d \n", + rtc_dt.year, rtc_dt.month, rtc_dt.day, rtc_dt.hour, rtc_dt.minute, rtc_dt.second); result = RT_EOK; } } /* initialize successfully */ result = RT_EOK; break; - -__exit: + + __exit: if (result != RT_EOK) { /* power off the nt26k device */ nt26k_power_off(device); - rt_thread_mdelay (1000); - LOG_I ("%s device initialize retry...", device->name); + rt_thread_mdelay(1000); + LOG_I("%s device initialize retry...", device->name); } } if (resp) { - at_delete_resp (resp); + at_delete_resp(resp); } if (result == RT_EOK) { /* set network interface device status and address information */ - nt26k_netdev_set_info (device->netdev); + nt26k_netdev_set_info(device->netdev); /* check and create link staus sync thread */ - nt26k_netdev_check_link_status (device->netdev); - LOG_I ("%s device network initialize success.", device->name); - rt_completion_done (&nt26k_init_complate); // 通知初始化完成 + nt26k_netdev_check_link_status(device->netdev); + LOG_I("%s device network initialize success.", device->name); + rt_completion_done(&nt26k_init_complate); // 通知初始化完成 } else { - LOG_E ("%s device network initialize failed(%d).", device->name, result); + LOG_E("%s device network initialize failed(%d).", device->name, result); } - } /* nt26k device network initialize */ -static int nt26k_net_init (struct at_device *device) +static int nt26k_net_init(struct at_device *device) { #ifdef AT_DEVICE_NT26K_INIT_ASYN rt_thread_t tid; /* 初始化完成量对象 */ - rt_completion_init (&nt26k_init_complate); + rt_completion_init(&nt26k_init_complate); - tid = rt_thread_create ("nt26k_net", nt26k_init_thread_entry, (void *)device, - NT26K_THREAD_STACK_SIZE, NT26K_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); + rt_thread_startup(tid); } else { - LOG_E ("create %s device init thread failed.", device->name); + LOG_E("create %s device init thread failed.", device->name); return -RT_ERROR; } #else - nt26k_init_thread_entry (device); + nt26k_init_thread_entry(device); #endif /* AT_DEVICE_NT26K_INIT_ASYN */ return RT_EOK; } // 去除字符串中的 \r 和 \n -void remove_crlf (char *str) +void remove_crlf(char *str) { char *p = str; while (*p) { if (*p == '\r' || *p == '\n') { - memmove (p, p + 1, strlen (p)); + memmove(p, p + 1, strlen(p)); } else { @@ -1140,47 +1141,49 @@ void remove_crlf (char *str) } } -rt_err_t Nt26k_Get_Signal_Info (struct at_device *device) +rt_err_t Nt26k_Get_Signal_Info(struct at_device *device) { -#define RETRY 20 +#define RETRY 10 - rt_err_t result = RT_EOK; + rt_err_t result = RT_EOK; at_response_t resp = RT_NULL; rt_uint8_t i; - RT_ASSERT (device); - resp = at_create_resp (1024, 4, rt_tick_from_millisecond (2000)); + RT_ASSERT(device); + resp = at_create_resp(1024, 4, rt_tick_from_millisecond(2000)); if (resp == RT_NULL) { - LOG_E ("no memory for resp create."); - at_delete_resp (resp); + LOG_E("no memory for resp create."); + at_delete_resp(resp); return RT_ERROR; } /* check signal strength */ for (i = 0; i < RETRY; i++) { - if (at_obj_exec_cmd (device->client, resp, "AT+CSQ") == RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+CSQ") == RT_EOK) { int signal_strength = 0, err_rate = 0; - if (at_resp_parse_line_args_by_kw (resp, "+CSQ:", "+CSQ: %d,%d", &signal_strength, &err_rate) > 0) + if (at_resp_parse_line_args_by_kw(resp, "+CSQ:", "+CSQ: %d,%d", &signal_strength, &err_rate) > 0) { if ((signal_strength != 99) && (signal_strength != 0)) { - LOG_D ("%s device signal strength: %d, channel bit err_rate: %d", - device->name, signal_strength, err_rate); + LOG_D("%s device signal strength: %d, channel bit err_rate: %d", + device->name, signal_strength, err_rate); nt26k.rssi = signal_strength; break; } } } - rt_thread_mdelay (1000); + rt_thread_mdelay(1000); } if (i == RETRY) { - LOG_E ("%s device signal strength check failed", device->name); + LOG_E("%s device signal strength check failed", device->name); result = -RT_ERROR; + at_delete_resp(resp); + return result; } /* check signal strength */ @@ -1188,27 +1191,27 @@ rt_err_t Nt26k_Get_Signal_Info (struct at_device *device) for (i = 0; i < RETRY; i++) { - if (at_obj_exec_cmd (device->client, resp, "AT+CESQ") == RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+CESQ") == RT_EOK) { rt_uint8_t rsrp = 0, rsrq = 0; - if (at_resp_parse_line_args_by_kw (resp, "+CESQ:", "+CESQ:%*[^,],%*[^,],%*[^,],%*[^,],%d,%d", &rsrq, &rsrp) > 0) + if (at_resp_parse_line_args_by_kw(resp, "+CESQ:", "+CESQ:%*[^,],%*[^,],%*[^,],%*[^,],%d,%d", &rsrq, &rsrp) > 0) { if ((rsrp <= 97) && (rsrp > 0) && ((rsrq <= 34) && (rsrq > 0))) { - LOG_D ("%s device signal rsrp: %d, rsrq: %d", - device->name, rsrp, rsrq); + LOG_D("%s device signal rsrp: %d, rsrq: %d", + device->name, rsrp, rsrq); nt26k.rsrp = rsrp; nt26k.rsrq = rsrq; break; } } } - rt_thread_mdelay (1000); + rt_thread_mdelay(1000); } if (i == RETRY) { - LOG_E ("%s device signal data failed", device->name); + LOG_E("%s device signal data failed", device->name); result = -RT_ERROR; } // /* get signal snr, pci */ @@ -1258,162 +1261,162 @@ rt_err_t Nt26k_Get_Signal_Info (struct at_device *device) // result = -RT_ERROR; // } - at_delete_resp (resp); + at_delete_resp(resp); return result; } /* nt26k device network interface attach * - set network interface device link status */ -static int nt26k_init (struct at_device *device) +static int nt26k_init(struct at_device *device) { struct at_device_nt26k *nt26k = RT_NULL; - RT_ASSERT (device); + RT_ASSERT(device); - 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. + 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 (nt26k->client_name, nt26k->recv_line_num, nt26k->recv_line_num); + at_client_init(nt26k->client_name, nt26k->recv_line_num, nt26k->recv_line_num); #else - at_client_init (nt26k->client_name, nt26k->recv_line_num); + at_client_init(nt26k->client_name, nt26k->recv_line_num); #endif - device->client = at_client_get (nt26k->client_name); + device->client = at_client_get(nt26k->client_name); if (device->client == RT_NULL) { - LOG_E ("get AT client(%s) failed.", nt26k->client_name); + LOG_E("get AT client(%s) failed.", nt26k->client_name); return -RT_ERROR; } /* register URC data execution function */ - at_obj_set_urc_table (device->client, urc_table, sizeof (urc_table) / sizeof (urc_table[0])); + at_obj_set_urc_table(device->client, urc_table, sizeof(urc_table) / sizeof(urc_table[0])); #ifdef AT_USING_SOCKET - nt26k_socket_init (device); + nt26k_socket_init(device); #endif /* add nt26k device to the netdev list */ - device->netdev = nt26k_netdev_add (nt26k->device_name); + device->netdev = nt26k_netdev_add(nt26k->device_name); if (device->netdev == RT_NULL) { - LOG_E ("add netdev(%s) failed.", nt26k->device_name); + LOG_E("add netdev(%s) failed.", nt26k->device_name); return -RT_ERROR; } /* initialize nt26k pin configuration */ if (nt26k->pwr_en_pin != -1) { - rt_pin_mode (nt26k->pwr_en_pin, PIN_MODE_OUTPUT); + rt_pin_mode(nt26k->pwr_en_pin, PIN_MODE_OUTPUT); } if (nt26k->rst_pin != -1) { - rt_pin_mode (nt26k->rst_pin, PIN_MODE_OUTPUT); + rt_pin_mode(nt26k->rst_pin, PIN_MODE_OUTPUT); } if (nt26k->pwr_key_pin != -1) { - rt_pin_mode (nt26k->pwr_key_pin, PIN_MODE_OUTPUT); - device->class->device_ops->control (device, AT_DEVICE_CTRL_WAKEUP, RT_NULL); + rt_pin_mode(nt26k->pwr_key_pin, PIN_MODE_OUTPUT); + device->class->device_ops->control(device, AT_DEVICE_CTRL_WAKEUP, RT_NULL); } /* initialize nt26k device network */ - return nt26k_netdev_set_up (device->netdev); + return nt26k_netdev_set_up(device->netdev); } -static int nt26k_deinit (struct at_device *device) +static int nt26k_deinit(struct at_device *device) { - RT_ASSERT (device); + RT_ASSERT(device); - return nt26k_netdev_set_down (device->netdev); + return nt26k_netdev_set_down(device->netdev); } -static int nt26k_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; - RT_ASSERT (device); + RT_ASSERT(device); switch (cmd) { - case AT_DEVICE_CTRL_SLEEP: - result = nt26k_sleep (device); - break; - case AT_DEVICE_CTRL_WAKEUP: - result = nt26k_wakeup (device); - break; - case AT_DEVICE_CTRL_NET_CONN: - result = at_device_nt26k_connect_tcp (device); - break; - case AT_DEVICE_CTRL_NET_DISCONN: - result = at_device_nt26k_disconnect_tcp (device); // 直接删除Socket - break; - case AT_DEVICE_CTRL_GET_SIGNAL: - result = Nt26k_Get_Signal_Info (device); - break; - case AT_DEVICE_CTRL_RESET: - result = Nt26k_Reset (device); - break; - case AT_DEVICE_CTRL_POWER_ON: - result = nt26k_power_on (device); - break; - case AT_DEVICE_CTRL_POWER_OFF: - result = nt26k_power_off (device); - break; - case AT_DEVICE_RF_CLOSE: - result = nt26k_Close_Rf(device); - break; - case AT_DEVICE_CTRL_LOW_POWER: - case AT_DEVICE_CTRL_SET_WIFI_INFO: - case AT_DEVICE_CTRL_GET_GPS: - case AT_DEVICE_CTRL_GET_VER: - LOG_W ("not support the control command(%d).", cmd); - break; - default: - LOG_E ("input error control command(%d).", cmd); - break; + case AT_DEVICE_CTRL_SLEEP: + result = nt26k_sleep(device); + break; + case AT_DEVICE_CTRL_WAKEUP: + result = nt26k_wakeup(device); + break; + case AT_DEVICE_CTRL_NET_CONN: + result = at_device_nt26k_connect_tcp(device); + break; + case AT_DEVICE_CTRL_NET_DISCONN: + result = at_device_nt26k_disconnect_tcp(device); // 直接删除Socket + break; + case AT_DEVICE_CTRL_GET_SIGNAL: + result = Nt26k_Get_Signal_Info(device); + break; + case AT_DEVICE_CTRL_RESET: + result = Nt26k_Reset(device); + break; + case AT_DEVICE_CTRL_POWER_ON: + result = nt26k_power_on(device); + break; + case AT_DEVICE_CTRL_POWER_OFF: + result = nt26k_power_off(device); + break; + case AT_DEVICE_RF_CLOSE: + result = nt26k_Close_Rf(device); + break; + case AT_DEVICE_CTRL_LOW_POWER: + case AT_DEVICE_CTRL_SET_WIFI_INFO: + case AT_DEVICE_CTRL_GET_GPS: + case AT_DEVICE_CTRL_GET_VER: + LOG_W("not support the control command(%d).", cmd); + break; + default: + LOG_E("input error control command(%d).", cmd); + break; } return result; } -int Time_Calibration (struct at_device *device) +int Time_Calibration(struct at_device *device) { at_response_t resp = RT_NULL; - RT_ASSERT (device); - resp = at_create_resp (64, 2, rt_tick_from_millisecond (2000)); + RT_ASSERT(device); + resp = at_create_resp(64, 2, rt_tick_from_millisecond(2000)); if (resp == RT_NULL) { - LOG_E ("no memory for resp create."); - at_delete_resp (resp); + LOG_E("no memory for resp create."); + at_delete_resp(resp); return RT_ERROR; } - if (at_obj_exec_cmd (device->client, resp, "AT+CCLK?") == RT_EOK) + if (at_obj_exec_cmd(device->client, resp, "AT+CCLK?") == RT_EOK) { TsRtcDateTime rtc_dt; - ; // 网络时间 + ; // 网络时间 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; - rtc_dt.day = days; - rtc_dt.hour = hous; // 此时为零区时间，需要转化为东八区 + rtc_dt.year = (2000 + year); + rtc_dt.month = mounth; + rtc_dt.day = days; + rtc_dt.hour = hous; // 此时为零区时间，需要转化为东八区 rtc_dt.minute = min; rtc_dt.second = sec; - Time_Zone_Conversion (&rtc_dt); // 时区设置 - rtc_dt.week = RTC_GetWeek (rtc_dt.year, rtc_dt.month, rtc_dt.day); - RTC_SetTime (rtc_dt.year, rtc_dt.month, rtc_dt.day, - rtc_dt.hour, rtc_dt.minute, rtc_dt.second); // 设置时间 - LOG_I ("RTC时间: %04d-%02d-%02d %02d:%02d:%02d \n", - rtc_dt.year, rtc_dt.month, rtc_dt.day, rtc_dt.hour, rtc_dt.minute, rtc_dt.second); - at_delete_resp (resp); + Time_Zone_Conversion(&rtc_dt); // 时区设置 + rtc_dt.week = RTC_GetWeek(rtc_dt.year, rtc_dt.month, rtc_dt.day); + RTC_SetTime(rtc_dt.year, rtc_dt.month, rtc_dt.day, + rtc_dt.hour, rtc_dt.minute, rtc_dt.second); // 设置时间 + LOG_I("RTC时间: %04d-%02d-%02d %02d:%02d:%02d \n", + rtc_dt.year, rtc_dt.month, rtc_dt.day, rtc_dt.hour, rtc_dt.minute, rtc_dt.second); + at_delete_resp(resp); return RT_EOK; } } - at_delete_resp (resp); + at_delete_resp(resp); return RT_ERROR; } @@ -1424,23 +1427,23 @@ const struct at_device_ops nt26k_device_ops = nt26k_control, }; -static int nt26k_device_class_register (void) +static int nt26k_device_class_register(void) { struct at_device_class *class = RT_NULL; - class = (struct at_device_class *)rt_calloc (1, sizeof (struct at_device_class)); + class = (struct at_device_class *)rt_calloc(1, sizeof(struct at_device_class)); if (class == RT_NULL) { - LOG_E ("no memory for device class create."); - rt_free (class); + LOG_E("no memory for device class create."); + rt_free(class); return -RT_ENOMEM; } class->device_ops = &nt26k_device_ops; - return at_device_class_register (class, AT_DEVICE_CLASS_NT26K); + return at_device_class_register(class, AT_DEVICE_CLASS_NT26K); } INIT_DEVICE_EXPORT(nt26k_device_class_register); -#endif //! IOT_MODULE_SWITCH +#endif //! IOT_MODULE_SWITCH -#endif /* AT_DEVICE_USING_NT26K */ +#endif /* AT_DEVICE_USING_NT26K */ diff --git a/bsp/src/bsp_nt26k.c b/bsp/src/bsp_nt26k.c index c28aa9f..abe92f6 100644 --- a/bsp/src/bsp_nt26k.c +++ b/bsp/src/bsp_nt26k.c @@ -2,7 +2,7 @@ * @Author: mbw * @Date: 2024-10-09 08:42:14 * @LastEditors: mbw && 1600520629@qq.com - * @LastEditTime: 2025-01-17 10:37:54 + * @LastEditTime: 2025-01-17 11:22:04 * @FilePath: \JT-DT-YD4N02A_RTT_MRS-NT26K\bsp\src\bsp_nt26k.c * @Description: * @@ -34,63 +34,63 @@ #include #if IOT_MODULE_SWITCH == 1 -#define NT26K_THREAD_STACK_SIZE (4096) +#define NT26K_THREAD_STACK_SIZE (4096) #define NT26K_RECV_THREAD_STACK_SIZE (4096) #define NT26K_LIFE_THREAD_STACK_SIZE (2048) -#define NT26K_THREAD_PRIORITY 25 -#define NT26K_THREAD_TICKS 50 -#define NT26K_RECV_THREAD_PRIORITY 24 -#define NT26K_RECV_THREAD_TICKS 10 +#define NT26K_THREAD_PRIORITY 25 +#define NT26K_THREAD_TICKS 50 +#define NT26K_RECV_THREAD_PRIORITY 24 +#define NT26K_RECV_THREAD_TICKS 10 -#define NT26K_LIFE_THREAD_PRIORITY 26 -#define NT26K_LIFE_THREAD_TICKS 10 +#define NT26K_LIFE_THREAD_PRIORITY 26 +#define NT26K_LIFE_THREAD_TICKS 10 // static rt_uint32_t nt26k_status = 0; -ALIGN (RT_ALIGN_SIZE) +ALIGN(RT_ALIGN_SIZE) static char nt26k_thread_stack[NT26K_THREAD_STACK_SIZE]; static struct rt_thread nt26k_thread; -ALIGN (RT_ALIGN_SIZE) +ALIGN(RT_ALIGN_SIZE) static char nt26k_recv_thread_stack[NT26K_RECV_THREAD_STACK_SIZE]; static struct rt_thread nt26k_recv_thread; -ALIGN (RT_ALIGN_SIZE) +ALIGN(RT_ALIGN_SIZE) 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 nt26k_recv_sem; -rt_sem_t nt26k_recv_heart_sem;// 用于接收心跳信号 +rt_sem_t nt26k_recv_heart_sem; // 用于接收心跳信号 rt_sem_t nt26k_disconnect_sem; -static rt_timer_t nt26k_timer; // 上报心跳 -static rt_timer_t nt26k_upload_timer; // 更新本地时间定时器 -static rt_timer_t nt26k_power_error_timer; // 上电失败情况下启动定时器 +static rt_timer_t nt26k_timer; // 上报心跳 +static rt_timer_t nt26k_upload_timer; // 更新本地时间定时器 +static rt_timer_t nt26k_power_error_timer; // 上电失败情况下启动定时器 rt_uint8_t nt26k_conncet_tcp_flag; -rt_uint8_t nt26k_disconnect_pdp_flag; // PDP断开连接标志 - +rt_uint8_t nt26k_disconnect_pdp_flag; // PDP断开连接标志 +rt_uint8_t nt26k_disconnect_retry_flag = 0; // 用于判断是否已经启动了重连，如果启动，不需要每次都进入 Nt26kEventIndex nt26k_event_index; rt_uint8_t power_on_send_flag = 0; 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); +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 Nt26kDataFrame frame; static struct Nt26kRecvData nt26k_recv; struct Nt26k_Ops nt26k_ops = { - .body = &body, - .frame = &frame, - .recv = &nt26k_recv, - .init = BSP_Nt26k_Init, + .body = &body, + .frame = &frame, + .recv = &nt26k_recv, + .init = BSP_Nt26k_Init, .update_data = BSP_Nt26k_Update, - .send = Nt26k_Send_Data, - .Resp = Data_Resp, + .send = Nt26k_Send_Data, + .Resp = Data_Resp, // .Recv = Nt26k_Recv_Data,//，没用到 }; @@ -107,15 +107,15 @@ static struct at_device_nt26k _dev = }; static rt_uint32_t nt26k_event_flags[kNt26kMaxEventcnt] = {0}; -static rt_bool_t nt26k_event_initialized = RT_FALSE; // 是否初始化完成 +static rt_bool_t nt26k_event_initialized = RT_FALSE; // 是否初始化完成 typedef enum { - NT26K_PRIORITY_LOWEST, // 4、优先级最低（定时心跳、浓度异常、报警触发、报警解除、传感器故障触发 传感器故障解除） - NT26K_PRIORITY_MEDIUM, // 2、优先级第三高 自检触发 - NT26K_PRIORITY_HIGH, // 1、优先级第二高 掉电 - NT26K_PRIORITY_HIGHEST, // 0 优先级最高(设备上电时的定时心跳) + NT26K_PRIORITY_LOWEST, // 4、优先级最低（定时心跳、浓度异常、报警触发、报警解除、传感器故障触发 传感器故障解除） + NT26K_PRIORITY_MEDIUM, // 2、优先级第三高 自检触发 + NT26K_PRIORITY_HIGH, // 1、优先级第二高 掉电 + NT26K_PRIORITY_HIGHEST, // 0 优先级最高(设备上电时的定时心跳) } Nt26kPriority; typedef struct @@ -123,10 +123,10 @@ typedef struct Nt26kEvent event_flag; Nt26kPriority priority; const char *event_name; - int (*send_func) (struct at_device *device, void *param); + int (*send_func)(struct at_device *device, void *param); } Nt26kEventInfo; -static void Nt26k_Set_Event (Nt26kEvent event_type) +static void Nt26k_Set_Event(Nt26kEvent event_type) { if (event_type < kNt26kMaxEventcnt) { @@ -134,24 +134,24 @@ static void Nt26k_Set_Event (Nt26kEvent event_type) } } -void Nt26k_Event_Init (void) +void Nt26k_Event_Init(void) { - rt_err_t ret = rt_event_init (&at_device_event, "nt26k_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) { nt26k_event_initialized = RT_TRUE; for (Nt26kEvent event = kNt26kHeartbeatEvent; event < kNt26kMaxEventcnt; event++) { - Nt26k_Set_Event (event); + Nt26k_Set_Event(event); } } else { - LOG_E ("nt26k_event init failed!"); + LOG_E("nt26k_event init failed!"); } } -rt_uint32_t Nt26k_Get_Event_Flag (Nt26kEvent event_type) +rt_uint32_t Nt26k_Get_Event_Flag(Nt26kEvent event_type) { if (event_type < kNt26kMaxEventcnt) { @@ -160,69 +160,69 @@ rt_uint32_t Nt26k_Get_Event_Flag (Nt26kEvent event_type) return 0; } -void Nt26k_Send_Event (Nt26kEvent event_type) +void Nt26k_Send_Event(Nt26kEvent event_type) { - LOG_D ("Send_Nt26k_Event = %d", event_type); - nt26k_event_index.last_event = nt26k_event_index.current_event; + 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, Nt26k_Get_Event_Flag (event_type)); + rt_event_send(&at_device_event, Nt26k_Get_Event_Flag(event_type)); } else { - LOG_E ("nt26k_event_initialized is false"); + LOG_E("nt26k_event_initialized is false"); } } // 定义定时器回调函数 -static void Nt26k_Ht_Timer_Cb (void *parameter) +static void Nt26k_Ht_Timer_Cb(void *parameter) { - Nt26k_Send_Event (kNt26kHeartbeatEvent); + Nt26k_Send_Event(kNt26kHeartbeatEvent); } // 定时器回调函数,当1分钟内没有数据交互时，关闭tcp连接 -static void Nt26k_Error_Timer_Cb (void *parameter) +static void Nt26k_Error_Timer_Cb(void *parameter) { - if (power_on_send_flag) // 上电成功时，停止定时器 + if (power_on_send_flag) // 上电成功时，停止定时器 { - rt_timer_stop (nt26k_power_error_timer); + rt_timer_stop(nt26k_power_error_timer); } else { - Nt26k_Send_Event (kNt26kPowerOnEvent); + Nt26k_Send_Event(kNt26kPowerOnEvent); } } -int _Pack_Send (struct Nt26k_Ops *ops, char *buf) +int _Pack_Send(struct Nt26k_Ops *ops, char *buf) { - char nt26k_send_buf[512] = {0}; // 发送缓冲区，用于存储最终发送的数据 - // char byteArr1[512]; // 转换成字节值 - unsigned short crc16 = 0; // 存储CRC16校验和 + 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, NT26K_SAMPLE_DEIVCE_NAME); - ASSERT (device); - crc16 = crc1021 (buf, rt_strlen (buf)); - LOG_D ("buf: %s", buf); - LOG_D ("crc16: %X", crc16); + 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 (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 (nt26k_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(nt26k_send_buf)) { // 发生缓冲区溢出 - LOG_E ("Buffer overflow in nt26k_send_buf"); + LOG_E("Buffer overflow in nt26k_send_buf"); return -RT_ERROR; } // 打印调试信息 // LOG_D("nt26k_send_buf: %s", nt26k_send_buf); - rt_uint16_t data_len = rt_strlen (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) + if (at_send_data(device, nt26k_send_buf, data_len / 2) != RT_EOK) { return -RT_ERROR; } @@ -242,50 +242,50 @@ int _Pack_Send (struct Nt26k_Ops *ops, char *buf) * @param cmd_num 命令编号 * @return int 返回0表示成功，非零表示失败 */ -static int _Send_Handle (struct Nt26k_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); + rt_size_t data_len = rt_strlen(data); // 格式化数据，构建发送给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], - ops->frame->header[1], - ops->frame->header[2], - ops->frame->version, // 协议版本 - ops->frame->manufacture, // 制造商ID - data_num, - cmd_num, - data_len / 2, - data); - if (len < 0 || len >= sizeof (data_buf)) + rt_int32_t len = rt_snprintf(data_buf, sizeof(data_buf), + "%02X%02X%02X%02X%04X%04X%02X%04X%s", + ops->frame->header[0], + ops->frame->header[1], + ops->frame->header[2], + ops->frame->version, // 协议版本 + ops->frame->manufacture, // 制造商ID + data_num, + cmd_num, + data_len / 2, + data); + if (len < 0 || len >= sizeof(data_buf)) { - LOG_E ("Send Data buffer overflow"); + LOG_E("Send Data buffer overflow"); return -RT_ERROR; } // LOG_D("data_buf: %s", data_buf); - return _Pack_Send (ops, data_buf); + return _Pack_Send(ops, data_buf); } // 初始化函数 -int BSP_Nt26k_Init (struct Nt26k_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"); + LOG_E("Memory allocation failed"); return -RT_ENOMEM; } - rt_memset (ops->frame, 0, sizeof (struct Nt26kDataFrame)); + rt_memset(ops->frame, 0, sizeof(struct Nt26kDataFrame)); ops->frame->header[0] = 0x4A; ops->frame->header[1] = 0x54; ops->frame->header[2] = 0x34; - ops->frame->version = version; + ops->frame->version = version; ops->frame->manufacture = DEVICE_MANUFACTURE; ops->frame->tail[0] = 0x42; @@ -296,81 +296,81 @@ 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 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, &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; - ops->body->device_status = device_state_flag; - ops->body->emv_status = emv_state_flag; - ops->body->relay_status = relay_state_flag; + 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, &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; + ops->body->device_status = device_state_flag; + ops->body->emv_status = emv_state_flag; + ops->body->relay_status = relay_state_flag; return RT_EOK; } -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 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; + int ret = 0; char data_buf[512] = {0}; - char temp[3]; // 临时缓冲区，用于存储每个字节的十六进制表示 + char temp[3]; // 临时缓冲区，用于存储每个字节的十六进制表示 if (ops == NULL || ops->body == NULL) { // 处理 ops 或 ops->body 为 NULL 的情况 - return RT_ERROR; // 或者抛出异常，返回错误码等 + return RT_ERROR; // 或者抛出异常，返回错误码等 } - if (sizeof (struct DataBody) == 0) + if (sizeof(struct DataBody) == 0) { - data_buf[0] = '\0'; // 确保 data_buf 被正确初始化 + data_buf[0] = '\0'; // 确保 data_buf 被正确初始化 return RT_ERROR; } - rt_memset (ops->body, 0, sizeof (struct DataBody)); - rt_mutex_take (nt26k_mutex, RT_WAITING_FOREVER); - ret = nt26k_ops.update_data (ops, device_type, event_type); + rt_memset(ops->body, 0, sizeof(struct DataBody)); + 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++) + for (int i = 0; i < sizeof(struct DataBody); i++) { - rt_snprintf (temp, sizeof (temp), "%02X", ((rt_uint8_t *)ops->body)[i]); - rt_memcpy (data_buf + i * 2, temp, 2); + rt_snprintf(temp, sizeof(temp), "%02X", ((rt_uint8_t *)ops->body)[i]); + rt_memcpy(data_buf + i * 2, temp, 2); } - ret = _Send_Handle (ops, data_num, cmd, data_buf); + ret = _Send_Handle(ops, data_num, cmd, data_buf); if (ret != RT_EOK) { ret = -ret; } } - rt_mutex_release (nt26k_mutex); + rt_mutex_release(nt26k_mutex); return ret; } -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 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 (nt26k_conncet_tcp_flag != 1) { - LOG_E ("nt26k_conncet_tcp_flag error"); + LOG_E("nt26k_conncet_tcp_flag error"); return -RT_ERROR; } char data_buf[512] = {0}; - rt_int32_t len = rt_snprintf (data_buf, sizeof (data_buf), "%02X%02X%30s%02X", device_type, event_type, data, res); - if (len < 0 || len >= sizeof (data_buf)) + rt_int32_t len = rt_snprintf(data_buf, sizeof(data_buf), "%02X%02X%30s%02X", device_type, event_type, data, res); + if (len < 0 || len >= sizeof(data_buf)) { - LOG_E ("Resp Data buffer overflow"); + LOG_E("Resp Data buffer overflow"); return -RT_ERROR; } // LOG_D("data_buf: %s", data_buf); - return _Send_Handle (ops, data_num, cmd, data_buf); + return _Send_Handle(ops, data_num, cmd, data_buf); } -int Nt26k_Recv_Data (struct Nt26k_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)); @@ -385,27 +385,27 @@ int Nt26k_Recv_Data (struct Nt26k_Ops *ops, char *data) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Heartbeat (struct at_device *device, void *param) +int Nt26k_Send_Heartbeat(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; - int ret = 0; + int ret = 0; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k 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); + ret = device->class->device_ops->control(device, AT_DEVICE_CTRL_GET_SIGNAL, RT_NULL); if (ret != RT_EOK) { - LOG_E ("nt26k get signal failed\n"); + LOG_E("nt26k get signal failed\n"); return -RT_ERROR; } - ret = nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_DATA_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k send data failed\n"); + LOG_E("nt26k send data failed\n"); return ret; } @@ -418,18 +418,18 @@ int Nt26k_Send_Heartbeat (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Time_Calibration (struct at_device *device, void *param) +int Nt26k_Send_Time_Calibration(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_TIME_CALIBRATION, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -441,18 +441,18 @@ int Nt26k_Send_Time_Calibration (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Alarm (struct at_device *device, void *param) +int Nt26k_Send_Alarm(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -464,18 +464,18 @@ int Nt26k_Send_Alarm (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Alarm_Recover (struct at_device *device, void *param) +int Nt26k_Send_Alarm_Recover(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -487,18 +487,18 @@ int Nt26k_Send_Alarm_Recover (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Fault (struct at_device *device, void *param) +int Nt26k_Send_Fault(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -510,18 +510,18 @@ int Nt26k_Send_Fault (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Fault_Recover (struct at_device *device, void *param) +int Nt26k_Send_Fault_Recover(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -533,18 +533,18 @@ int Nt26k_Send_Fault_Recover (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Self_Check (struct at_device *device, void *param) +int Nt26k_Send_Self_Check(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -556,18 +556,18 @@ int Nt26k_Send_Self_Check (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Silence (struct at_device *device, void *param) +int Nt26k_Send_Silence(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -579,18 +579,18 @@ int Nt26k_Send_Silence (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Exception (struct at_device *device, void *param) +int Nt26k_Send_Exception(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -602,18 +602,18 @@ int Nt26k_Send_Exception (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Valve_Status (struct at_device *device, void *param) +int Nt26k_Send_Valve_Status(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -625,18 +625,18 @@ int Nt26k_Send_Valve_Status (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Fan_Status (struct at_device *device, void *param) +int Nt26k_Send_Fan_Status(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -648,18 +648,18 @@ int Nt26k_Send_Fan_Status (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Temp_Anomaly (struct at_device *device, void *param) +int Nt26k_Send_Temp_Anomaly(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -671,18 +671,18 @@ int Nt26k_Send_Temp_Anomaly (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Power_Off (struct at_device *device, void *param) +int Nt26k_Send_Power_Off(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -694,18 +694,18 @@ int Nt26k_Send_Power_Off (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Power_On (struct at_device *device, void *param) +int Nt26k_Send_Power_On(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -717,18 +717,18 @@ int Nt26k_Send_Power_On (struct at_device *device, void *param) * @param param 操作结构体指针 * @return 操作结果 */ -int Nt26k_Send_Device_Failure (struct at_device *device, void *param) +int Nt26k_Send_Device_Failure(struct at_device *device, void *param) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; if ((device == RT_NULL) || (nt26k_ops == RT_NULL)) { - LOG_E ("nt26k param error\n"); + LOG_E("nt26k param error\n"); return RT_ERROR; } - if (nt26k_ops->send (nt26k_ops, DATA_SERIAL_NUM, CMD_TYPE_DEVICE_EVENT_REPORT, DEVICE_TYPE_NT26K, 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 ("nt26k 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; @@ -739,35 +739,34 @@ int Nt26k_Send_Device_Failure (struct at_device *device, void *param) 在线程中，对任务队列进行查看并处理，看目前都有哪些事件，是处于那个优先级得，如果是最低优先级，就只发送一帧数据就行了， 如果是不同优先级，按照优先级顺序发送事件，但感觉这样会使得程序更复杂，本来发送就很快，感觉没必要这样搞*/ 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 } -}; + {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}}; /** * 处理NT26K设备的事件 * @param nt26k_recv_event 接收到的NT26K事件标志 * @return */ -int Nt26k_Process_Events (Nt26kEvent nt26k_recv_event, struct at_device *device, void *param) +int Nt26k_Process_Events(Nt26kEvent nt26k_recv_event, struct at_device *device, void *param) { - rt_uint8_t max_retry_count = (rt_uint8_t)Flash_Get_SysCfg (kIotRetryId); + rt_uint8_t max_retry_count = (rt_uint8_t)Flash_Get_SysCfg(kIotRetryId); struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)param; const Nt26kEventInfo *event = RT_NULL; - for (size_t i = 0; i < sizeof (nt26k_event_info) / sizeof (Nt26kEventInfo); ++i) + for (size_t i = 0; i < sizeof(nt26k_event_info) / sizeof(Nt26kEventInfo); ++i) { // 检查当前事件是否在接收到的事件标志中 if (nt26k_recv_event == nt26k_event_info[i].event_flag) @@ -777,10 +776,10 @@ int Nt26k_Process_Events (Nt26kEvent nt26k_recv_event, struct at_device *device, } } - if (event) // 处理该事件 + if (event) // 处理该事件 { // 打印事件的名称 - LOG_D ("%s上报\n", event->event_name); + LOG_D("%s上报\n", event->event_name); for (size_t i = 0; i < max_retry_count; i++) { if (nt26k_conncet_tcp_flag) @@ -788,53 +787,68 @@ int Nt26k_Process_Events (Nt26kEvent nt26k_recv_event, struct at_device *device, if (event->send_func) { #ifdef TEST_ENABLE - RTC_ShowTime(); // 每次发送打印下时间，容易定位问题 + RTC_ShowTime(); // 每次发送打印下时间，容易定位问题 #endif // 如果事件有关联的发送函数，则调用该发送函数 - rt_thread_mdelay (IMEI_Delay()); - int result = event->send_func (device, nt26k_ops); + rt_thread_mdelay(IMEI_Delay()); + int result = event->send_func(device, nt26k_ops); if (result != RT_EOK) { - LOG_E ("nt26k send cmd failed\n"); + LOG_E("nt26k send cmd failed\n"); + nt26k_conncet_tcp_flag = 0; + if (!nt26k_disconnect_retry_flag) + { + LOG_D("断网,启动重连\n"); + rt_sem_release(nt26k_disconnect_sem); + } + rt_thread_mdelay(5000); + continue; } else { - if (rt_strcmp (event->event_name, "定时心跳事件") == RT_EOK)//定时心跳是有回应的 + if ((rt_strcmp(event->event_name, "定时心跳事件") == RT_EOK) || (rt_strcmp(event->event_name, "上电心跳事件") == RT_EOK)) // 定时心跳是有回应的 { - if (rt_sem_take(nt26k_recv_heart_sem, 5000) == RT_EOK) + if (rt_sem_take(nt26k_recv_heart_sem, 5000) == RT_EOK) { - LOG_D ("收到心跳回复\n"); - return RT_EOK; // 函数执行完毕，返回0 + LOG_D("收到心跳回复\n"); + return RT_EOK; // 函数执行完毕，返回0 } else { - LOG_E ("nt26k send cmd failed\n");//收不到说明断网了，重连下10s后再发送 + LOG_E("nt26k send cmd failed\n"); // 收不到说明断网了，重连下10s后再发送 + LOG_D("rt_sem_release (nt26k_disconnect_sem)"); nt26k_conncet_tcp_flag = 0; - rt_sem_release (nt26k_disconnect_sem); - rt_thread_mdelay (5000); + rt_thread_mdelay(1); + rt_sem_release(nt26k_disconnect_sem); + rt_thread_mdelay(5000); continue; } } - else if (rt_strcmp (event->event_name, "掉电事件") == RT_EOK)//定时心跳是有回应的 + else if (rt_strcmp(event->event_name, "掉电事件") == RT_EOK) // 定时心跳是有回应的 { - if (device->class->device_ops->control (device, AT_DEVICE_RF_CLOSE, RT_NULL) == RT_EOK) + if (device->class->device_ops->control(device, AT_DEVICE_CTRL_POWER_OFF, RT_NULL) == RT_EOK) { LOG_D("关闭模组"); } } else { - return RT_EOK; // 函数执行完毕，返回0 + return RT_EOK; // 函数执行完毕，返回0 } - } + } } } else { - LOG_D ("断网\n"); - rt_sem_release (nt26k_disconnect_sem); + + if (!nt26k_disconnect_retry_flag) + { + LOG_D("断网,启动重连\n"); + rt_sem_release(nt26k_disconnect_sem); + } + LOG_D("断网,等待连接中......\n"); } - rt_thread_mdelay (5000); + rt_thread_mdelay(5000); } } // 函数执行完毕，返回0 @@ -842,14 +856,14 @@ int Nt26k_Process_Events (Nt26kEvent nt26k_recv_event, struct at_device *device, } // 比较帧头和帧尾 -int Compare_HeaderToTail (struct Nt26k_Ops *ops) +int Compare_HeaderToTail(struct Nt26k_Ops *ops) { // 比较帧头 for (int i = 0; i < 3; i++) { if (ops->frame->header[i] != ops->recv->header[i]) { - LOG_E ("ops->frame->header[%x] != ops->recv->header[%x]\n", ops->frame->header[i], ops->recv->header[i]); + LOG_E("ops->frame->header[%x] != ops->recv->header[%x]\n", ops->frame->header[i], ops->recv->header[i]); return -1; } @@ -860,72 +874,72 @@ int Compare_HeaderToTail (struct Nt26k_Ops *ops) { if (ops->frame->tail[i] != ops->recv->tail[i]) { - LOG_E ("ops->frame->tail[%x] != ops->recv->tail[%x]\n", ops->frame->tail[i], ops->recv->tail[i]); + LOG_E("ops->frame->tail[%x] != ops->recv->tail[%x]\n", ops->frame->tail[i], ops->recv->tail[i]); return -2; } } - if (ops->recv->recv_data.res_num != RESPONSE_CODE_SUCCESS) // 判断是否为成功响应 + if (ops->recv->recv_data.res_num != RESPONSE_CODE_SUCCESS) // 判断是否为成功响应 { - LOG_E ("ops->recv->recv_data.res_num[%x] != RESPONSE_CODE_SUCCESS\n", ops->recv->recv_data.res_num); + LOG_E("ops->recv->recv_data.res_num[%x] != RESPONSE_CODE_SUCCESS\n", ops->recv->recv_data.res_num); return -3; } return RT_EOK; } -void Handle_Server_Reply (struct Nt26k_Ops *ops) +void Handle_Server_Reply(struct Nt26k_Ops *ops) { if ((ops->recv->recv_data.event_type == INSTRUCTION_HEART_BEAT) || (ops->recv->recv_data.event_type == EVENT_TYPE_POWER_ON)) { - LOG_D ("nt26k send data success\n"); + LOG_D("nt26k send data success\n"); } } -void Handle_Self_Check (struct Nt26k_Ops *ops) +void Handle_Self_Check(struct Nt26k_Ops *ops) { - LOG_D ("服务器下发自检指令\n"); + LOG_D("服务器下发自检指令\n"); char imei[16] = {0}; - Get_IotImei (imei, FLASH_IOT_IMEI_LEN); - LOG_D ("imei:%s\n", imei); + Get_IotImei(imei, FLASH_IOT_IMEI_LEN); + LOG_D("imei:%s\n", imei); char temp[32] = "0"; - String2Hex (temp, imei); // 将字符串转为十六进制字符串 - 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_NT26K, INSTRUCTION_DOWN_SELF_CHECK, temp, RESPONSE_CODE_SUCCESS); + String2Hex(temp, imei); // 将字符串转为十六进制字符串 + 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_NT26K, INSTRUCTION_DOWN_SELF_CHECK, temp, RESPONSE_CODE_SUCCESS); } -void Handle_Mute (struct Nt26k_Ops *ops) +void Handle_Mute(struct Nt26k_Ops *ops) { - LOG_D ("服务器下发消音指令\n"); + LOG_D("服务器下发消音指令\n"); char imei[16] = {0}; - Get_IotImei (imei, FLASH_IOT_IMEI_LEN); + Get_IotImei(imei, FLASH_IOT_IMEI_LEN); char temp[32] = "0"; - String2Hex (temp, imei); // 将字符串转为十六进制字符串 + String2Hex(temp, imei); // 将字符串转为十六进制字符串 - Send_Laser_Alarm_Event (KMuteEvent); - rt_thread_mdelay (100); - ops->Resp (ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_MUTE, temp, RESPONSE_CODE_SUCCESS); + Send_Laser_Alarm_Event(KMuteEvent); + rt_thread_mdelay(100); + 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 Nt26k_Ops *ops) +void Handle_Close_Valve(struct Nt26k_Ops *ops) { - LOG_D ("服务器下发关闭阀门指令\n"); + LOG_D("服务器下发关闭阀门指令\n"); char imei[16] = {0}; - Get_IotImei (imei, FLASH_IOT_IMEI_LEN); + Get_IotImei(imei, FLASH_IOT_IMEI_LEN); char temp[32] = "0"; - String2Hex (temp, imei); // 将字符串转为十六进制字符串 + String2Hex(temp, imei); // 将字符串转为十六进制字符串 EMV_CLOSE_VALVE; - ops->Resp (ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_CLOSE_VALVE, temp, RESPONSE_CODE_SUCCESS); + ops->Resp(ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_CLOSE_VALVE, temp, RESPONSE_CODE_SUCCESS); } -void Handle_Open_Valve (struct Nt26k_Ops *ops) +void Handle_Open_Valve(struct Nt26k_Ops *ops) { - LOG_D ("服务器下发打开阀门指令\n"); + LOG_D("服务器下发打开阀门指令\n"); // char imei[16] = {0}; // Get_IotImei(imei, FLASH_IOT_IMEI_LEN); @@ -940,275 +954,275 @@ void Handle_Open_Valve (struct Nt26k_Ops *ops) // 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 Nt26k_Ops *ops) +void Handle_Open_Relay(struct Nt26k_Ops *ops) { - LOG_D ("服务器下发打开继电器指令\n"); + LOG_D("服务器下发打开继电器指令\n"); char imei[16] = {0}; - Get_IotImei (imei, FLASH_IOT_IMEI_LEN); + Get_IotImei(imei, FLASH_IOT_IMEI_LEN); char temp[32] = "0"; - String2Hex (temp, imei); // 将字符串转为十六进制字符串 + String2Hex(temp, imei); // 将字符串转为十六进制字符串 relay_state_flag = 1; - rt_thread_mdelay (10); + 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_NT26K, 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 Nt26k_Ops *ops) +void Handle_Close_Relay(struct Nt26k_Ops *ops) { - LOG_D ("服务器下发关闭继电器指令\n"); + LOG_D("服务器下发关闭继电器指令\n"); char imei[16] = {0}; char temp[32] = "0"; - Get_IotImei (imei, FLASH_IOT_IMEI_LEN); - String2Hex (temp, imei); // 将字符串转为十六进制字符串 + Get_IotImei(imei, FLASH_IOT_IMEI_LEN); + String2Hex(temp, imei); // 将字符串转为十六进制字符串 relay_state_flag = 0; - rt_thread_mdelay (100); - ops->Resp (ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_CLOSE_RELAY, temp, RESPONSE_CODE_SUCCESS); + rt_thread_mdelay(100); + 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 Nt26k_Ops *ops) +void Handle_Query_Params(struct Nt26k_Ops *ops) { rt_uint8_t data[10] = {0}; - char str[64] = {0}; - LOG_D ("服务器下发查询系统参数\n"); + char str[64] = {0}; + LOG_D("服务器下发查询系统参数\n"); - rt_memcpy (data, (rt_uint8_t *)FLASH_HW_VER_ADDR, sizeof (sys_config_info) - 50); - LOG_D ("hw_ver:%02x sw_ver:%02x alarm_low:%02x alarm_high:%02x temp_alarm:%02x iot_upload_cycle:%dmin retry:%02x emagnetic:%02X relay_switch:%02X\n", - data[0], data[1], data[2], data[3], data[4], ((data[5]) | (data[6] << 8)), data[7], data[8], data[9]); + rt_memcpy(data, (rt_uint8_t *)FLASH_HW_VER_ADDR, sizeof(sys_config_info) - 50); + LOG_D("hw_ver:%02x sw_ver:%02x alarm_low:%02x alarm_high:%02x temp_alarm:%02x iot_upload_cycle:%dmin retry:%02x emagnetic:%02X relay_switch:%02X\n", + data[0], data[1], data[2], data[3], data[4], ((data[5]) | (data[6] << 8)), data[7], data[8], data[9]); - 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_NT26K, INSTRUCTION_DOWN_QUERY_PARAMS, str, RESPONSE_CODE_SUCCESS); + 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_NT26K, INSTRUCTION_DOWN_QUERY_PARAMS, str, RESPONSE_CODE_SUCCESS); } -int Handle_Config_Params (struct Nt26k_Ops *ops) +int Handle_Config_Params(struct Nt26k_Ops *ops) { - char data_buf[32] = {0}; - rt_uint8_t recv_data[16] = {0}; + char data_buf[32] = {0}; + rt_uint8_t recv_data[16] = {0}; rt_uint8_t flash_info[16] = {0}; - char imei[16] = {0}; - char temp[32] = "0"; + char imei[16] = {0}; + char temp[32] = "0"; - LOG_D ("服务器下发配置参数\n"); + LOG_D("服务器下发配置参数\n"); - Get_IotImei (imei, FLASH_IOT_IMEI_LEN); - String2Hex (temp, imei); // 将字符串转为十六进制字符串 + Get_IotImei(imei, FLASH_IOT_IMEI_LEN); + String2Hex(temp, imei); // 将字符串转为十六进制字符串 - rt_memset (data_buf, '0', 32); - rt_memcpy (recv_data, (ops->recv->recv_data.res_data + 5), sizeof (sys_config_info) - 50); - rt_memcpy (flash_info, (rt_uint8_t *)FLASH_HW_VER_ADDR, sizeof (sys_config_info) - 50); + rt_memset(data_buf, '0', 32); + rt_memcpy(recv_data, (ops->recv->recv_data.res_data + 5), sizeof(sys_config_info) - 50); + rt_memcpy(flash_info, (rt_uint8_t *)FLASH_HW_VER_ADDR, sizeof(sys_config_info) - 50); - LOG_D ("hw_ver:%02x sw_ver:%02x alarm_low:%02x alarm_high:%02x temp_alarm:%02x iot_upload_cycle:%d min retry:%02x emagnetic:%02X relay_switch:%02X\n", - flash_info[0], flash_info[1], flash_info[2], flash_info[3], flash_info[4], (flash_info[5] | (flash_info[6] << 8)), flash_info[7], flash_info[8], recv_data[9]); - LOG_D ("recv_data: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x \n", - recv_data[0], recv_data[1], recv_data[2], recv_data[3], recv_data[4], - recv_data[5], recv_data[6], recv_data[7], recv_data[8], recv_data[9], - recv_data[10], recv_data[11], recv_data[12], recv_data[13], recv_data[14], recv_data[15]); - LOG_D ("data:%s\n", data_buf); + LOG_D("hw_ver:%02x sw_ver:%02x alarm_low:%02x alarm_high:%02x temp_alarm:%02x iot_upload_cycle:%d min retry:%02x emagnetic:%02X relay_switch:%02X\n", + flash_info[0], flash_info[1], flash_info[2], flash_info[3], flash_info[4], (flash_info[5] | (flash_info[6] << 8)), flash_info[7], flash_info[8], recv_data[9]); + LOG_D("recv_data: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x \n", + recv_data[0], recv_data[1], recv_data[2], recv_data[3], recv_data[4], + recv_data[5], recv_data[6], recv_data[7], recv_data[8], recv_data[9], + recv_data[10], recv_data[11], recv_data[12], recv_data[13], recv_data[14], recv_data[15]); + LOG_D("data:%s\n", data_buf); - for (rt_uint8_t i = 0; i < (sizeof (sys_config_info) - 50); i++) + for (rt_uint8_t i = 0; i < (sizeof(sys_config_info) - 50); i++) { - LOG_D ("recv_data[%d] = %d", i, recv_data[i]); + LOG_D("recv_data[%d] = %d", i, recv_data[i]); if (recv_data[i] != flash_info[i]) { if ((recv_data[2] > 25) || (recv_data[2] < 5)) /*家报的报警设定值应在5%~25%之间*/ { - 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) + 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"); + LOG_W("recv_data[3] :%d", recv_data[3]); + LOG_W("配置参数超出范围，请核实后重试\n"); } return RT_EOK; } - else // 如果没有超出，再写入信息 + else // 如果没有超出，再写入信息 { - if (BSP_Flash_Write_Info (recv_data, sizeof (sys_config_info) - 50) != 0) + if (BSP_Flash_Write_Info(recv_data, sizeof(sys_config_info) - 50) != 0) { - rt_uint16_t iot_upload_time = (uint16_t)Flash_Get_SysCfg (kIotUploadCycleId); - unsigned long timeout = iot_upload_time * 60 * RT_TICK_PER_SECOND; + rt_uint16_t iot_upload_time = (uint16_t)Flash_Get_SysCfg(kIotUploadCycleId); + unsigned long timeout = iot_upload_time * 60 * RT_TICK_PER_SECOND; // 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_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 (nt26k_timer); - LOG_D ("上报周期由%dmin更新为%dmin", ((flash_info[5] << 8) | flash_info[6]), iot_upload_time); - if (ops->Resp (ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_CONFIG_PARAMS, temp, RESPONSE_CODE_SUCCESS) == RT_EOK) + rt_timer_start(nt26k_timer); + LOG_D("上报周期由%dmin更新为%dmin", ((flash_info[5] << 8) | flash_info[6]), iot_upload_time); + 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"); + LOG_D("配置参数写入成功\n"); } return RT_EOK; } else { - LOG_D ("配置参数写入失败\n"); - 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"); + 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"); + LOG_D("写入失败响应成功\n"); } return RT_ERROR; } } } } - if (ops->Resp (ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, 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"); + LOG_D("配置参数没有变化\n"); } return RT_EOK; } -void Handle_Time_Calibration_Data (struct Nt26k_Ops *ops) +void Handle_Time_Calibration_Data(struct Nt26k_Ops *ops) { rt_uint8_t data[10] = {0}; TsRtcDateTime rtc_dt; char imei[16] = {0}; char temp[32] = "0"; - LOG_D ("时间校准数据\n"); + LOG_D("时间校准数据\n"); - Get_IotImei (imei, FLASH_IOT_IMEI_LEN); - String2Hex (temp, imei); // 将字符串转为十六进制字符串 + Get_IotImei(imei, FLASH_IOT_IMEI_LEN); + String2Hex(temp, imei); // 将字符串转为十六进制字符串 - rt_memcpy (data, ops->recv->recv_data.res_data, sizeof (data)); + rt_memcpy(data, ops->recv->recv_data.res_data, sizeof(data)); // 提取后4个字节作为时间戳 time_t timestamp = (data[6] << 24) | (data[7] << 16) | (data[8] << 8) | data[9]; - Timestamp_To_Rtc_DateTime (timestamp, &rtc_dt); + Timestamp_To_Rtc_DateTime(timestamp, &rtc_dt); // 打印结果 - 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, 0); /* Setup Time */ - rt_thread_mdelay (100); // 释放下线程 - ops->Resp (ops, DATA_SERIAL_NUM, CMD_TYPE_TIME_CALIBRATION, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_TIME_CALIBRATION, temp, RESPONSE_CODE_SUCCESS); + 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, 0); /* Setup Time */ + rt_thread_mdelay(100); // 释放下线程 + 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 Nt26k_Ops *ops) +void Handle_Sever_Addr_Set(struct Nt26k_Ops *ops) { rt_uint8_t data[6] = {0}; - char imei[16] = {0}; - char temp[32] = "0"; + char imei[16] = {0}; + char temp[32] = "0"; - Get_IotImei (imei, FLASH_IOT_IMEI_LEN); - String2Hex (temp, imei); // 将字符串转为十六进制字符串 - rt_memcpy (data, (ops->recv->recv_data.res_data + 9), FLASH_SERVER_LEN); - LOG_D ("data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x", 0, data[0], 1, data[1], 2, data[2], 3, data[3], 4, data[4], 5, data[5]); - Flash_Set_Sever_Data (data); - if (Flash_Get_Sever_Data (&sever_info) != RT_EOK) + Get_IotImei(imei, FLASH_IOT_IMEI_LEN); + String2Hex(temp, imei); // 将字符串转为十六进制字符串 + rt_memcpy(data, (ops->recv->recv_data.res_data + 9), FLASH_SERVER_LEN); + LOG_D("data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x data[%d] = %x", 0, data[0], 1, data[1], 2, data[2], 3, data[3], 4, data[4], 5, data[5]); + Flash_Set_Sever_Data(data); + if (Flash_Get_Sever_Data(&sever_info) != RT_EOK) { - LOG_E ("服务器地址修改失败\n"); + LOG_E("服务器地址修改失败\n"); } else { - LOG_D ("服务器地址修改成功\n"); - ops->Resp (ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, INSTRUCTION_DOWN_SEVER_ADDR, temp, RESPONSE_CODE_SUCCESS); + LOG_D("服务器地址修改成功\n"); + 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 Nt26k_Ops *ops, rt_err_t ret) +void Handle_Error(struct Nt26k_Ops *ops, rt_err_t ret) { - LOG_E ("数据帧解析失败，错误码: %d", ret); + LOG_E("数据帧解析失败，错误码: %d", ret); char imei[16] = {0}; char temp[32] = "0"; - Get_IotImei (imei, FLASH_IOT_IMEI_LEN); - String2Hex (temp, imei); // 将字符串转为十六进制字符串 - ops->Resp (ops, DATA_SERIAL_NUM, CMD_TYPE_INSTRUCTION_REPLY, DEVICE_TYPE_NT26K, ops->recv->cmd, temp, RESPONSE_CODE_PARSE_FAIL); + Get_IotImei(imei, FLASH_IOT_IMEI_LEN); + String2Hex(temp, imei); // 将字符串转为十六进制字符串 + 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 Nt26k_Ops *ops) +void Handle_Instruction_Down(struct Nt26k_Ops *ops) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)ops; switch (nt26k_ops->recv->recv_data.event_type) { - case INSTRUCTION_DOWN_SELF_CHECK: - Handle_Self_Check (nt26k_ops); - break; - case INSTRUCTION_DOWN_MUTE: - Handle_Mute (nt26k_ops); - break; - case INSTRUCTION_DOWN_CLOSE_VALVE: - Handle_Close_Valve (nt26k_ops); - break; - case INSTRUCTION_DOWN_OPEN_VALVE: - Handle_Open_Valve (nt26k_ops); - break; - case INSTRUCTION_DOWN_OPEN_RELAY: - Handle_Open_Relay (nt26k_ops); - break; - case INSTRUCTION_DOWN_CLOSE_RELAY: - Handle_Close_Relay (nt26k_ops); - break; - case INSTRUCTION_DOWN_QUERY_PARAMS: - Handle_Query_Params (nt26k_ops); - break; - case INSTRUCTION_DOWN_CONFIG_PARAMS: - Handle_Config_Params (nt26k_ops); - break; - case INSTRUCTION_DOWN_TIME_CALIBRATION: - Handle_Time_Calibration_Data (nt26k_ops); - break; - case INSTRUCTION_DOWN_SEVER_ADDR: - Handle_Sever_Addr_Set (nt26k_ops); - break; + case INSTRUCTION_DOWN_SELF_CHECK: + Handle_Self_Check(nt26k_ops); + break; + case INSTRUCTION_DOWN_MUTE: + Handle_Mute(nt26k_ops); + break; + case INSTRUCTION_DOWN_CLOSE_VALVE: + Handle_Close_Valve(nt26k_ops); + break; + case INSTRUCTION_DOWN_OPEN_VALVE: + Handle_Open_Valve(nt26k_ops); + break; + case INSTRUCTION_DOWN_OPEN_RELAY: + Handle_Open_Relay(nt26k_ops); + break; + case INSTRUCTION_DOWN_CLOSE_RELAY: + Handle_Close_Relay(nt26k_ops); + break; + case INSTRUCTION_DOWN_QUERY_PARAMS: + Handle_Query_Params(nt26k_ops); + break; + case INSTRUCTION_DOWN_CONFIG_PARAMS: + Handle_Config_Params(nt26k_ops); + break; + case INSTRUCTION_DOWN_TIME_CALIBRATION: + Handle_Time_Calibration_Data(nt26k_ops); + break; + case INSTRUCTION_DOWN_SEVER_ADDR: + Handle_Sever_Addr_Set(nt26k_ops); + break; } } -void Handle_Time_Calibration (struct Nt26k_Ops *ops) +void Handle_Time_Calibration(struct Nt26k_Ops *ops) { rt_uint8_t data[10] = {0}; - LOG_D ("服务器下发时间校准数据\n"); - rt_memcpy (data, ops->recv->recv_data.res_data, sizeof (data)); + LOG_D("服务器下发时间校准数据\n"); + rt_memcpy(data, ops->recv->recv_data.res_data, sizeof(data)); TsRtcDateTime rtc_dt; // 提取后4个字节作为时间戳 time_t timestamp = (data[6] << 24) | (data[7] << 16) | (data[8] << 8) | data[9]; - Timestamp_To_Rtc_DateTime (timestamp, &rtc_dt); + Timestamp_To_Rtc_DateTime(timestamp, &rtc_dt); // 打印结果 - 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_NT26K, INSTRUCTION_DOWN_TIME_CALIBRATION, NT26K_DEFIENE_DATA, RESPONSE_CODE_SUCCESS); + 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_NT26K, INSTRUCTION_DOWN_TIME_CALIBRATION, NT26K_DEFIENE_DATA, RESPONSE_CODE_SUCCESS); } -void Handle_Cmd_Type (struct Nt26k_Ops *ops) +void Handle_Cmd_Type(struct Nt26k_Ops *ops) { struct Nt26k_Ops *nt26k_ops = (struct Nt26k_Ops *)ops; switch (nt26k_ops->recv->cmd) { - case CMD_TYPE_SERVER_REPLY: - Handle_Server_Reply (nt26k_ops); - break; - case CMD_TYPE_INSTRUCTION_DOWN: - Handle_Instruction_Down (nt26k_ops); - break; - case CMD_TYPE_TIME_CALIBRATION: - Handle_Time_Calibration (nt26k_ops); - break; - default: - 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; + case CMD_TYPE_SERVER_REPLY: + Handle_Server_Reply(nt26k_ops); + break; + case CMD_TYPE_INSTRUCTION_DOWN: + Handle_Instruction_Down(nt26k_ops); + break; + case CMD_TYPE_TIME_CALIBRATION: + Handle_Time_Calibration(nt26k_ops); + break; + default: + 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 Nt26k_Ops *ops) +void Analyze_Recv_Frame(struct at_device *device, struct Nt26k_Ops *ops) { rt_err_t ret = RT_EOK; - ret = Compare_HeaderToTail (ops); + ret = Compare_HeaderToTail(ops); if (ret == RT_EOK) { - Handle_Cmd_Type (ops); + Handle_Cmd_Type(ops); } else { - Handle_Error (ops, ret); + Handle_Error(ops, ret); } } @@ -1217,180 +1231,180 @@ void Analyze_Recv_Frame (struct at_device *device, struct Nt26k_Ops *ops) 发送一包数据后，转换到检测模式 120分钟发送一次数据 当有事件发生时，发送一包事件数据包 */ -static void Nt26k_Send_Thread_Entry (void *param) +static void Nt26k_Send_Thread_Entry(void *param) { rt_err_t result = RT_EOK; rt_uint32_t nt26k_recv_event; - LOG_D ("nt26k thread entry\n"); + LOG_D("nt26k thread entry\n"); - struct Nt26k_Ops *ops = (struct Nt26k_Ops *)param; + 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); + 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) + if (ops->init(ops, PROTOCOL_VERSION) != RT_EOK) { - LOG_E ("nt26k init failed\n"); + LOG_E("nt26k init failed\n"); } else { - LOG_D ("nt26k init success\n"); - rt_completion_wait (&nt26k_init_complate, RT_WAITING_FOREVER); // wait for nt26k init finish - Nt26k_Send_Event (kNt26kPowerOnEvent); + 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, - 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, &nt26k_recv_event); // 这个事件一般是设备端发生了变化，发送到服务器时调用 + result = rt_event_recv(&at_device_event, + 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, &nt26k_recv_event); // 这个事件一般是设备端发生了变化，发送到服务器时调用 if (result == RT_EOK) { - if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kPowerOnEvent)) + if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kPowerOnEvent)) { - result = Nt26k_Process_Events (kNt26kPowerOnEvent, device, ops); // 当上电心跳包发送不成功时，其他事件不启动 + result = Nt26k_Process_Events(kNt26kPowerOnEvent, device, ops); // 当上电心跳包发送不成功时，其他事件不启动 if (result) { power_on_send_flag = 0; - rt_timer_start (nt26k_power_error_timer); // 启动重连定时器， 3min一次，直到发送成功 - LOG_E ("nt26k 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 (nt26k_timer); // 当上电心跳包发送成功时, 开始心跳包周期发送 + rt_timer_start(nt26k_timer); // 当上电心跳包发送成功时, 开始心跳包周期发送 - rt_timer_start (nt26k_upload_timer); // 周期修改时间更新 + rt_timer_start(nt26k_upload_timer); // 周期修改时间更新 power_on_send_flag = 1; } } if (power_on_send_flag) { - if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kHeartbeatEvent)) + if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kHeartbeatEvent)) { - result = Nt26k_Process_Events (kNt26kHeartbeatEvent, device, ops); + result = Nt26k_Process_Events(kNt26kHeartbeatEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kTimeCalibrationEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kTimeCalibrationEvent)) { - Time_Calibration (device); + Time_Calibration(device); } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kAlarmEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kAlarmEvent)) { - result = Nt26k_Process_Events (kNt26kAlarmEvent, device, ops); + result = Nt26k_Process_Events(kNt26kAlarmEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kAlarmRcyEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kAlarmRcyEvent)) { - result = Nt26k_Process_Events (kNt26kAlarmRcyEvent, device, ops); + result = Nt26k_Process_Events(kNt26kAlarmRcyEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kFaultEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kFaultEvent)) { - if (device_state_flag != 1) // 当设备失效时，只上报失效信息 + if (device_state_flag != 1) // 当设备失效时，只上报失效信息 { - result = Nt26k_Process_Events (kNt26kFaultEvent, device, ops); + result = Nt26k_Process_Events(kNt26kFaultEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kFaultRcyEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kFaultRcyEvent)) { - result = Nt26k_Process_Events (kNt26kFaultRcyEvent, device, ops); + result = Nt26k_Process_Events(kNt26kFaultRcyEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kSelfCheckEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kSelfCheckEvent)) { - result = Nt26k_Process_Events (kNt26kSelfCheckEvent, device, ops); + result = Nt26k_Process_Events(kNt26kSelfCheckEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kSilenceEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kSilenceEvent)) { - result = Nt26k_Process_Events (kNt26kSilenceEvent, device, ops); + result = Nt26k_Process_Events(kNt26kSilenceEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kExceptionEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kExceptionEvent)) { - result = Nt26k_Process_Events (kNt26kExceptionEvent, device, ops); + result = Nt26k_Process_Events(kNt26kExceptionEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kValveStatusEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kValveStatusEvent)) { - result = Nt26k_Process_Events (kNt26kValveStatusEvent, device, ops); + result = Nt26k_Process_Events(kNt26kValveStatusEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kFanStatusEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kFanStatusEvent)) { - result = Nt26k_Process_Events (kNt26kFanStatusEvent, device, ops); + result = Nt26k_Process_Events(kNt26kFanStatusEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kTempAnomalyEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kTempAnomalyEvent)) { - result = Nt26k_Process_Events (kNt26kTempAnomalyEvent, device, ops); + result = Nt26k_Process_Events(kNt26kTempAnomalyEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kPowerDownEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kPowerDownEvent)) { - nt26k_event_initialized = RT_FALSE; // 当接收到掉电事件时，发送完成后删除事件，不再接收其他事件 - result = Nt26k_Process_Events (kNt26kPowerDownEvent, device, ops); + nt26k_event_initialized = RT_FALSE; // 当接收到掉电事件时，发送完成后删除事件，不再接收其他事件 + result = Nt26k_Process_Events(kNt26kPowerDownEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } - else if (nt26k_recv_event & Nt26k_Get_Event_Flag (kNt26kDeviceFailureEvent)) + else if (nt26k_recv_event & Nt26k_Get_Event_Flag(kNt26kDeviceFailureEvent)) { - result = Nt26k_Process_Events (kNt26kDeviceFailureEvent, device, ops); + result = Nt26k_Process_Events(kNt26kDeviceFailureEvent, device, ops); if (result) { - LOG_E ("nt26k send data failed result = [%d]\n", result); + LOG_E("nt26k send data failed result = [%d]\n", result); } } } @@ -1398,211 +1412,230 @@ static void Nt26k_Send_Thread_Entry (void *param) } } -static void Nt26k_Recv_Thread_Entry (void *parameter) +static void Nt26k_Recv_Thread_Entry(void *parameter) { - struct Nt26k_Ops *ops = (struct Nt26k_Ops *)parameter; + 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); + struct at_device *device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, nt26k->device_name); + RT_ASSERT(device); - LOG_D ("nt26k recv thread entry\n"); + LOG_D("nt26k recv thread entry\n"); while (1) { - rt_sem_take (nt26k_recv_sem, RT_WAITING_FOREVER); // 这个主要用来处理的数据 + rt_sem_take(nt26k_recv_sem, RT_WAITING_FOREVER); // 这个主要用来处理的数据 /*对数据帧进行分析，判断所处的是对服务器响应还是指令下发*/ - Analyze_Recv_Frame (device, ops); + Analyze_Recv_Frame(device, ops); } } -static void Nt26k_Life_Thread_Entry (void *parameter) +static void Nt26k_Life_Thread_Entry(void *parameter) { struct at_device_nt26k *nt26k = &_dev; - struct at_device *device = at_device_get_by_name (AT_DEVICE_NAMETYPE_NETDEV, nt26k->device_name); - RT_ASSERT (device); - rt_err_t ret; + struct at_device *device = at_device_get_by_name(AT_DEVICE_NAMETYPE_NETDEV, nt26k->device_name); + RT_ASSERT(device); + rt_err_t result = RT_EOK; rt_uint32_t delay_n = 1; - rt_uint32_t delay_t = 80000; - LOG_D ("nt26k_life_thread entry\n"); + LOG_D("nt26k_life_thread entry\n"); while (1) { - ret = rt_sem_take (nt26k_disconnect_sem, RT_WAITING_FOREVER); - if (ret == RT_EOK) + result = rt_sem_take(nt26k_disconnect_sem, RT_WAITING_FOREVER); + if (result == RT_EOK) { if (!nt26k_conncet_tcp_flag) { - LOG_D ("重连网络中...\n"); - at_response_t resp = at_create_resp (64, 0, 5000); + LOG_D("重连网络中...\n"); + at_response_t resp = at_create_resp(64, 0, 5000); if (resp == RT_NULL) { - LOG_E ("No memory for response structure!"); - at_delete_resp (resp); + LOG_E("No memory for response structure!"); + at_delete_resp(resp); + result = -RT_ETIMEOUT; } - if (device->class->device_ops->control (device, AT_DEVICE_CTRL_POWER_OFF, RT_NULL) == RT_EOK) + if (device->class->device_ops->control(device, AT_DEVICE_CTRL_POWER_ON, RT_NULL) == RT_EOK) { - LOG_D("AT device power off success"); + LOG_D("AT device power on success"); rt_thread_mdelay(1000); - if (device->class->device_ops->control (device, AT_DEVICE_CTRL_POWER_ON, RT_NULL) == RT_EOK) + /* disable echo */ + at_obj_exec_cmd(device->client, resp, "ATE0"); + /*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) { - LOG_D("AT device power on success"); - /* disable echo */ - at_obj_exec_cmd(device->client, resp, "ATE0"); - /*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) - { - LOG_E ("AT+QICFG=\"dataformat\" error\n"); - } - /*设置显示模式*/ - if (at_obj_exec_cmd (device->client, resp, "AT+QICFG=\"viewmode\",1") != RT_EOK) - { - LOG_E ("AT+QICFG=\"viewmode\" error\n"); - } - /*设置保活信息*/ - if (at_obj_exec_cmd (device->client, resp, "AT+QICFG=\"tcp/keepalive\",1,10000,100,10") != RT_EOK) - { - LOG_E ("AT+QICFG=\"tcp/keepalive\" error\n"); - } - if (at_obj_exec_cmd (device->client, resp, "AT+QICFG=\"passiveclosed\",1") != RT_EOK) - { - LOG_E ("AT+QICFG=\"passiveclosed\" error\n"); - } - if (at_obj_exec_cmd (device->client, resp, "AT+CGACT=1,1") != RT_EOK) - { - LOG_E ("AT+CGACT=1,1 error\n"); - } - if (device->class->device_ops->control (device, AT_DEVICE_CTRL_NET_CONN, RT_NULL) == RT_EOK) - { - LOG_D ("重连网络成功\n"); - nt26k_conncet_tcp_flag = RT_TRUE; - delay_n =0; - } - else - { - delay_t = (rt_uint32_t)(2^(delay_n - 1) * delay_t); - LOG_D ("重连网络失败,等待%d s后重连\n", delay_t); - rt_thread_mdelay (delay_t); - delay_n++; - rt_sem_release (nt26k_disconnect_sem); - } - at_delete_resp (resp); + LOG_E("AT+QICFG=\"dataformat\" error\n"); + result = -RT_ETIMEOUT; + goto __exit; } + /*设置显示模式*/ + if (at_obj_exec_cmd(device->client, resp, "AT+QICFG=\"viewmode\",1") != RT_EOK) + { + LOG_E("AT+QICFG=\"viewmode\" error\n"); + result = -RT_ETIMEOUT; + goto __exit; + } + /*设置保活信息*/ + if (at_obj_exec_cmd(device->client, resp, "AT+QICFG=\"tcp/keepalive\",1,1000,100,10") != RT_EOK) + { + LOG_E("AT+QICFG=\"tcp/keepalive\" error\n"); + result = -RT_ETIMEOUT; + goto __exit; + } + if (at_obj_exec_cmd(device->client, resp, "AT+QICFG=\"passiveclosed\",1") != RT_EOK) + { + LOG_E("AT+QICFG=\"passiveclosed\" error\n"); + result = -RT_ETIMEOUT; + goto __exit; + } + if (at_obj_exec_cmd(device->client, resp, "AT+CGACT=1,1") != RT_EOK) + { + LOG_E("AT+CGACT=1,1 error\n"); + result = -RT_ETIMEOUT; + goto __exit; + } + if (device->class->device_ops->control(device, AT_DEVICE_CTRL_NET_CONN, RT_NULL) == RT_EOK) + { + LOG_D("重连网络成功\n"); + nt26k_conncet_tcp_flag = RT_TRUE; + delay_n = 0; + nt26k_disconnect_retry_flag = 0; + } + else + { + result = -RT_ETIMEOUT; + goto __exit; + } + at_delete_resp(resp); } } - else + } + else + { + delay_n = 0; + goto __exit; + } + __exit: + if (result != RT_EOK) + { + LOG_D("重连网络失败,等待10s后重连\n"); + rt_thread_mdelay(delay_n * 5000); + delay_n++; + if (delay_n >= 360) { + Flash_Set_WorkDuration(work_duration); delay_n = 0; + reboot(); } + rt_sem_release(nt26k_disconnect_sem); + nt26k_disconnect_retry_flag = 1; } } } - // 定时器回调函数,当1分钟内没有数据交互时，关闭tcp连接 -static void Nt26k_Upload_Timer_Cb (void *parameter) +static void Nt26k_Upload_Timer_Cb(void *parameter) { - Nt26k_Send_Event (kNt26kTimeCalibrationEvent); // 更新下时间 + Nt26k_Send_Event(kNt26kTimeCalibrationEvent); // 更新下时间 } -int BSP_Nt26k_Thread_Init (void) +int BSP_Nt26k_Thread_Init(void) { rt_err_t ret; Nt26k_Event_Init(); - rt_uint32_t iot_upload_time = (uint16_t)Flash_Get_SysCfg (kIotUploadCycleId); - unsigned long timeout = iot_upload_time * 60 * RT_TICK_PER_SECOND; - LOG_I ("上报服务器周期：%d分钟", iot_upload_time); - nt26k_mutex = rt_mutex_create ("nt26k_mutex", RT_IPC_FLAG_PRIO); + rt_uint32_t iot_upload_time = (uint16_t)Flash_Get_SysCfg(kIotUploadCycleId); + unsigned long timeout = iot_upload_time * 60 * RT_TICK_PER_SECOND; + LOG_I("上报服务器周期：%d分钟", iot_upload_time); + nt26k_mutex = rt_mutex_create("nt26k_mutex", RT_IPC_FLAG_PRIO); if (nt26k_mutex == RT_NULL) { - LOG_E ("nt26k_mutex create failed"); + LOG_E("nt26k_mutex create failed"); } - nt26k_recv_sem = rt_sem_create ("nt26k_recv", 0, RT_IPC_FLAG_PRIO); + nt26k_recv_sem = rt_sem_create("nt26k_recv", 0, RT_IPC_FLAG_PRIO); if (nt26k_recv_sem == RT_NULL) { - LOG_E ("nt26k_recv_sem create failed"); + LOG_E("nt26k_recv_sem create failed"); } - nt26k_recv_heart_sem = rt_sem_create ("nt26k_recv_heart", 0, RT_IPC_FLAG_PRIO); + nt26k_recv_heart_sem = rt_sem_create("nt26k_recv_heart", 0, RT_IPC_FLAG_PRIO); if (nt26k_recv_heart_sem == RT_NULL) { - LOG_E ("nt26k_recv_heart_sem create failed"); + LOG_E("nt26k_recv_heart_sem create failed"); } - nt26k_disconnect_sem = rt_sem_create ("nt26k_life", 0, RT_IPC_FLAG_PRIO); + nt26k_disconnect_sem = rt_sem_create("nt26k_life", 0, RT_IPC_FLAG_PRIO); if (nt26k_disconnect_sem == RT_NULL) { - LOG_E ("nt26k_disconnect_sem create failed"); + LOG_E("nt26k_disconnect_sem create failed"); } // 创建定时器 - nt26k_timer = rt_timer_create ("heartbeat", - Nt26k_Ht_Timer_Cb, // 回调函数 - RT_NULL, // 参数 - timeout, // 定时周期（120分钟） - RT_TIMER_FLAG_PERIODIC); // 周期性定时器 + nt26k_timer = rt_timer_create("heartbeat", + Nt26k_Ht_Timer_Cb, // 回调函数 + RT_NULL, // 参数 + timeout, // 定时周期（120分钟） + RT_TIMER_FLAG_PERIODIC); // 周期性定时器 if (nt26k_timer == RT_NULL) { - rt_kprintf ("创建定时器失败\n"); + rt_kprintf("创建定时器失败\n"); return -1; } - 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); - 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); + 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); + 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 (&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(&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 (&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(&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 (&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); + 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_Nt26k_Thread_Init); -static int nt26k_device_register (void) +static int nt26k_device_register(void) { struct at_device_nt26k *nt26k = &_dev; - return at_device_register (&(nt26k->device), - nt26k->device_name, - nt26k->client_name, - AT_DEVICE_CLASS_NT26K, - (void *)nt26k); + return at_device_register(&(nt26k->device), + nt26k->device_name, + nt26k->client_name, + AT_DEVICE_CLASS_NT26K, + (void *)nt26k); } INIT_COMPONENT_EXPORT(nt26k_device_register); -#endif // IOT_MODULE_SWITCH +#endif // IOT_MODULE_SWITCH diff --git a/rt-thread/rtconfig.h b/rt-thread/rtconfig.h index 87d505c..022bae3 100644 --- a/rt-thread/rtconfig.h +++ b/rt-thread/rtconfig.h @@ -15,11 +15,11 @@ /*使用动态日志及密码功能时，需开启宏 FINSH_USING_AUTH ULOG_USING_FILTER ENABLE_LOG_ALL ULOG_OUTPUT_LVL = 7 以及设置ulog.c 1522行 输出等级为0*/ /**/ -#define FINSH_USING_AUTH //开启终端密码登录功能 -#define ULOG_USING_FILTER //开启动态修改日志等级 默认修改在ulog.c 1522行 +// #define FINSH_USING_AUTH //开启终端密码登录功能 +// #define ULOG_USING_FILTER //开启动态修改日志等级 默认修改在ulog.c 1522行 #define ENABLE_LOG_ALL -// #define TEST_ENABLE //打开所有的终端测试程序 +#define TEST_ENABLE //打开所有的终端测试程序 #define ULOG_OUTPUT_LVL 7 // 生产时将其设为0 #define IOT_MODULE_SWITCH 1 //开启物联网功能