#include <stdint.h>
#include <stdbool.h>
- void power_on_cat1(void);
- void power_off_cat1(void);
+ void cat1_api_power_on_cat1(void);
+ void cat1_api_power_off_cat1(void);
#ifdef __cplusplus
#if __cplusplus
-/*\r
- * Copyright (c) CompanyNameMagicTag 2021-2021. All rights reserved.\r
- * Description: broadcast feature implement\r
- * Author: CompanyName\r
- * Create: 2021-11-11\r
- */\r
-\r
-#include "common_def.h"\r
-#include "msg_center.h"\r
-#include <stdio.h>\r
-#include "adapter.h"\r
-#include "msg_center_protocol.h"\r
-#include "msg_center_cmd.h"\r
-#include "wearable_log.h"\r
-#include "alipay_app.h"\r
-#include "../../alipay/driver_adapt/vendor_net.h"\r
-#include "cmsis_os2.h"\r
-#include "sys/time.h"\r
-#include "time.h"\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
-\r
-#define HOSTENT_TIMEOUT 2000\r
-#define TCP_CONNECT_TIMEOUT 2000\r
-#define IPV4_LEN 4\r
-\r
-osSemaphoreId_t g_alipay_hostent_sem = NULL;\r
-osSemaphoreId_t g_alipay_tcp_sem = NULL;\r
-unsigned char g_alipay_ip[IPV4_LEN] = { 0 };\r
-\r
-uint8_t *g_tcp_data = NULL;\r
-uint16_t g_tcp_data_len = 0;\r
-uint16_t g_tcp_data_readed = 0;\r
-uint32_t g_tcp_fd = 0;\r
-uint8_t g_netstatus = 0;\r
-\r
-void msg_center_alipay_reply_ack(uint8_t cmd_id, uint8_t type)\r
-{\r
- uint8_t ack = 1; /* 与手机APK侧约定 */\r
- int ret = msg_center_send_data(cmd_id, type, &ack, sizeof(ack));\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "send replay ret = 0x%x\r\n", ret);\r
-}\r
-\r
-errcode_t msg_center_alipay_network_status(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)\r
-{\r
- uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);\r
- uint16_t payload_len = usr_len - tl_len;\r
- uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);\r
-\r
- g_netstatus = *((uint8_t *)tlv_payload);\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_alipay netstatus = %d\r\n", g_netstatus);\r
- msg_center_alipay_reply_ack(cmd_id, type);\r
- return 0;\r
-}\r
-\r
-uint8_t msg_center_alipay_get_network_status(void)\r
-{\r
- return g_netstatus;\r
-}\r
-\r
-int msg_center_alipay_hostent_request(void *usr_data, uint16_t usr_len)\r
-{\r
- int ret;\r
- if (g_alipay_hostent_sem == NULL) {\r
- g_alipay_hostent_sem = osSemaphoreNew(1, 0, NULL);\r
- }\r
-\r
- ret = msg_center_send_data(MSGCENTER_CMD_ALIPAY, MSGCENTER_TYPE_ID_ALIPAY_HOST_INFO, usr_data, usr_len);\r
- if (ret != ERRCODE_SUCC) {\r
- return -1;\r
- } else {\r
- return 0;\r
- }\r
-}\r
-\r
-errcode_t msg_center_alipay_hostent_recv(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)\r
-{\r
- uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);\r
- uint16_t payload_len = usr_len - tl_len;\r
- uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);\r
-\r
- (void)memcpy_s(g_alipay_ip, IPV4_LEN, tlv_payload, payload_len);\r
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "recv ip info--> %d.%d.%d.%d\r\n",\r
- g_alipay_ip[0], g_alipay_ip[1], g_alipay_ip[2], g_alipay_ip[3]);\r
- osSemaphoreRelease(g_alipay_hostent_sem);\r
- return ERRCODE_SUCC;\r
-}\r
-\r
-int msg_center_alipay_hostent_reponse(unsigned char *ip)\r
-{\r
- int ret;\r
- osStatus_t status = osSemaphoreAcquire(g_alipay_hostent_sem, HOSTENT_TIMEOUT);\r
- if (status == osOK) {\r
- (void)memcpy_s(ip, IPV4_LEN, g_alipay_ip, IPV4_LEN);\r
- ret = 0;\r
- } else {\r
- ret = -1;\r
- }\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "hostent wait status = 0x%x\r\n", status);\r
- osSemaphoreDelete(g_alipay_hostent_sem);\r
- g_alipay_hostent_sem = NULL;\r
- return ret;\r
-}\r
-\r
-int msg_center_alipay_connect_request(void *usr_data, uint16_t usr_len)\r
-{\r
- int ret;\r
- if (g_alipay_tcp_sem == NULL) {\r
- g_alipay_tcp_sem = osSemaphoreNew(1, 0, NULL);\r
- }\r
- ret = msg_center_send_data(MSGCENTER_CMD_ALIPAY, MSGCENTER_TYPE_ID_ALIPAY_CONNECT, usr_data, usr_len);\r
- if (ret != ERRCODE_SUCC) {\r
- return -1;\r
- } else {\r
- return 0;\r
- }\r
-}\r
-\r
-errcode_t msg_center_alipay_connect_recv(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)\r
-{\r
- uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);\r
- uint16_t payload_len = usr_len - tl_len;\r
- uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);\r
-\r
- alipay_connect_reponse rep;\r
- (void)memcpy_s(&rep, sizeof(alipay_connect_reponse), tlv_payload, payload_len);\r
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "recv alipay_connect_reponse info--> 0x%x 0x%x\r\n",\r
- rep.ret, rep.fd);\r
- g_tcp_fd = rep.fd;\r
- osSemaphoreRelease(g_alipay_tcp_sem);\r
- return ERRCODE_SUCC;\r
-}\r
-\r
-int msg_center_alipay_connect_reponse(void)\r
-{\r
- int ret;\r
- osStatus_t status = osSemaphoreAcquire(g_alipay_tcp_sem, TCP_CONNECT_TIMEOUT);\r
- if (status == osOK) {\r
- ret = (g_tcp_fd > 0) ? 0 : -1;\r
- } else {\r
- ret = -1;\r
- }\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "connect wait status = 0x%x\r\n", status);\r
- return ret;\r
-}\r
-\r
-int msg_center_alipay_tcpdata_request(void *usr_data, uint16_t usr_len)\r
-{\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "tcpdata send len = 0x%x\r\n", usr_len);\r
- int ret;\r
- ret = msg_center_send_data(MSGCENTER_CMD_ALIPAY, MSGCENTER_TYPE_ID_ALIPAY_TCPDATA_RECV, usr_data, usr_len);\r
- if (ret != ERRCODE_SUCC) {\r
- return -1;\r
- } else {\r
- return (int)usr_len;\r
- }\r
-}\r
-\r
-int msg_center_alipay_tcpdata_wait(uint32_t timeout)\r
-{\r
- int ret;\r
- osStatus_t status = osSemaphoreAcquire(g_alipay_tcp_sem, timeout);\r
- if (status == osOK) {\r
- ret = 1;\r
- } else {\r
- ret = 0;\r
- }\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "tcpdata wait status = 0x%x\r\n", status);\r
- return ret;\r
-}\r
-\r
-errcode_t msg_center_alipay_tcpdata_recv(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)\r
-{\r
- uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);\r
- uint16_t payload_len = usr_len - tl_len;\r
- uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);\r
- if (g_tcp_data != NULL) {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER,\r
- "The last buff hasn't been read yet, current payload len is %u.\r\n", payload_len);\r
- return ERRCODE_FAIL;\r
- }\r
- g_tcp_data = (uint8_t *)malloc(payload_len);\r
- if (g_tcp_data != NULL) {\r
- g_tcp_data_len = payload_len;\r
- (void)memcpy_s(g_tcp_data, g_tcp_data_len, tlv_payload, payload_len);\r
- }\r
-\r
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "recv tcpdata len = %d\r\n",\r
- g_tcp_data_len);\r
- osSemaphoreRelease(g_alipay_tcp_sem);\r
- return ERRCODE_SUCC;\r
-}\r
-\r
-int msg_center_alipay_tcpdata_read(void *mem, int len)\r
-{\r
- int ret = 0;\r
- if (g_tcp_data != NULL) {\r
- int read_len = min(len, g_tcp_data_len);\r
- (void)memcpy_s(mem, len, g_tcp_data + g_tcp_data_readed, read_len);\r
- g_tcp_data_readed += read_len;\r
- g_tcp_data_len -= read_len;\r
- ret = read_len;\r
- if (g_tcp_data_len == 0) {\r
- free(g_tcp_data);\r
- g_tcp_data = NULL;\r
- g_tcp_data_readed = 0;\r
- }\r
- } else {\r
- ret = -2; // no data for read\r
- }\r
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "read tcpdata len = (%d, %d)\r\n", len, ret);\r
- return ret;\r
-}\r
-\r
-int msg_center_alipay_close_request(void)\r
-{\r
- if (g_alipay_tcp_sem != NULL) {\r
- osSemaphoreDelete(g_alipay_tcp_sem);\r
- g_alipay_tcp_sem = NULL;\r
- }\r
- if (g_tcp_data != NULL) {\r
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "need free data buff.\r\n");\r
- free(g_tcp_data);\r
- g_tcp_data = NULL;\r
- g_tcp_data_readed = 0;\r
- }\r
- int ret;\r
- int send_ret =\r
- msg_center_send_data(MSGCENTER_CMD_ALIPAY, MSGCENTER_TYPE_ID_ALIPAY_CLOSE, &g_tcp_fd, sizeof(g_tcp_fd));\r
- if (send_ret != ERRCODE_SUCC) {\r
- ret = -1;\r
- } else {\r
- ret = 0;\r
- }\r
- g_tcp_fd = 0;\r
- return ret;\r
-}\r
-\r
-errcode_t msg_center_alipay_close(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)\r
-{\r
- uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);\r
- uint16_t payload_len = usr_len - tl_len;\r
- uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);\r
-\r
- return ERRCODE_SUCC;\r
-}\r
-\r
-errcode_t msg_center_alipay_time_sync(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)\r
-{\r
- uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);\r
- uint16_t payload_len = usr_len - tl_len;\r
- uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);\r
-\r
- uint32_t sec = *((uint32_t *)tlv_payload);\r
- struct timeval tv = { 0 };\r
- struct timezone tz = { 0 };\r
-\r
- tv.tv_sec = sec;\r
- tv.tv_usec = 0;\r
- tz.tz_dsttime = 0;\r
- tz.tz_minuteswest = (8 * 60);\r
-\r
- settimeofday(&tv, &tz);\r
- msg_center_alipay_reply_ack(cmd_id, type);\r
- return ERRCODE_SUCC;\r
-}\r
-\r
-\r
-#ifdef __cplusplus\r
-}\r
+/*
+ * Copyright (c) CompanyNameMagicTag 2021-2021. All rights reserved.
+ * Description: broadcast feature implement
+ * Author: CompanyName
+ * Create: 2021-11-11
+ */
+
+#include "common_def.h"
+#include "msg_center.h"
+#include <stdio.h>
+#include "adapter.h"
+#include "msg_center_protocol.h"
+#include "msg_center_cmd.h"
+#include "wearable_log.h"
+#include "alipay_app.h"
+#include "vendor_net.h"
+#include "cmsis_os2.h"
+#include "sys/time.h"
+#include "time.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HOSTENT_TIMEOUT 2000
+#define TCP_CONNECT_TIMEOUT 2000
+#define IPV4_LEN 4
+
+osSemaphoreId_t g_alipay_hostent_sem = NULL;
+osSemaphoreId_t g_alipay_tcp_sem = NULL;
+unsigned char g_alipay_ip[IPV4_LEN] = { 0 };
+
+uint8_t *g_tcp_data = NULL;
+uint16_t g_tcp_data_len = 0;
+uint16_t g_tcp_data_readed = 0;
+uint32_t g_tcp_fd = 0;
+uint8_t g_netstatus = 0;
+
+void msg_center_alipay_reply_ack(uint8_t cmd_id, uint8_t type)
+{
+ uint8_t ack = 1; /* 与手机APK侧约定 */
+ int ret = msg_center_send_data(cmd_id, type, &ack, sizeof(ack));
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "send replay ret = 0x%x\r\n", ret);
+}
+
+errcode_t msg_center_alipay_network_status(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)
+{
+ uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);
+ uint16_t payload_len = usr_len - tl_len;
+ uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);
+
+ g_netstatus = *((uint8_t *)tlv_payload);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "msg_center_alipay netstatus = %d\r\n", g_netstatus);
+ msg_center_alipay_reply_ack(cmd_id, type);
+ return 0;
+}
+
+uint8_t msg_center_alipay_get_network_status(void)
+{
+ return g_netstatus;
+}
+
+int msg_center_alipay_hostent_request(void *usr_data, uint16_t usr_len)
+{
+ int ret;
+ if (g_alipay_hostent_sem == NULL) {
+ g_alipay_hostent_sem = osSemaphoreNew(1, 0, NULL);
+ }
+
+ ret = msg_center_send_data(MSGCENTER_CMD_ALIPAY, MSGCENTER_TYPE_ID_ALIPAY_HOST_INFO, usr_data, usr_len);
+ if (ret != ERRCODE_SUCC) {
+ return -1;
+ } else {
+ return 0;
+ }
+}
+
+errcode_t msg_center_alipay_hostent_recv(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)
+{
+ uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);
+ uint16_t payload_len = usr_len - tl_len;
+ uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);
+
+ (void)memcpy_s(g_alipay_ip, IPV4_LEN, tlv_payload, payload_len);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "recv ip info--> %d.%d.%d.%d\r\n",
+ g_alipay_ip[0], g_alipay_ip[1], g_alipay_ip[2], g_alipay_ip[3]);
+ osSemaphoreRelease(g_alipay_hostent_sem);
+ return ERRCODE_SUCC;
+}
+
+int msg_center_alipay_hostent_reponse(unsigned char *ip)
+{
+ int ret;
+ osStatus_t status = osSemaphoreAcquire(g_alipay_hostent_sem, HOSTENT_TIMEOUT);
+ if (status == osOK) {
+ (void)memcpy_s(ip, IPV4_LEN, g_alipay_ip, IPV4_LEN);
+ ret = 0;
+ } else {
+ ret = -1;
+ }
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "hostent wait status = 0x%x\r\n", status);
+ osSemaphoreDelete(g_alipay_hostent_sem);
+ g_alipay_hostent_sem = NULL;
+ return ret;
+}
+
+int msg_center_alipay_connect_request(void *usr_data, uint16_t usr_len)
+{
+ int ret;
+ if (g_alipay_tcp_sem == NULL) {
+ g_alipay_tcp_sem = osSemaphoreNew(1, 0, NULL);
+ }
+ ret = msg_center_send_data(MSGCENTER_CMD_ALIPAY, MSGCENTER_TYPE_ID_ALIPAY_CONNECT, usr_data, usr_len);
+ if (ret != ERRCODE_SUCC) {
+ return -1;
+ } else {
+ return 0;
+ }
+}
+
+errcode_t msg_center_alipay_connect_recv(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)
+{
+ uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);
+ uint16_t payload_len = usr_len - tl_len;
+ uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);
+
+ alipay_connect_reponse rep;
+ (void)memcpy_s(&rep, sizeof(alipay_connect_reponse), tlv_payload, payload_len);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "recv alipay_connect_reponse info--> 0x%x 0x%x\r\n",
+ rep.ret, rep.fd);
+ g_tcp_fd = rep.fd;
+ osSemaphoreRelease(g_alipay_tcp_sem);
+ return ERRCODE_SUCC;
+}
+
+int msg_center_alipay_connect_reponse(void)
+{
+ int ret;
+ osStatus_t status = osSemaphoreAcquire(g_alipay_tcp_sem, TCP_CONNECT_TIMEOUT);
+ if (status == osOK) {
+ ret = (g_tcp_fd > 0) ? 0 : -1;
+ } else {
+ ret = -1;
+ }
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "connect wait status = 0x%x\r\n", status);
+ return ret;
+}
+
+int msg_center_alipay_tcpdata_request(void *usr_data, uint16_t usr_len)
+{
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "tcpdata send len = 0x%x\r\n", usr_len);
+ int ret;
+ ret = msg_center_send_data(MSGCENTER_CMD_ALIPAY, MSGCENTER_TYPE_ID_ALIPAY_TCPDATA_RECV, usr_data, usr_len);
+ if (ret != ERRCODE_SUCC) {
+ return -1;
+ } else {
+ return (int)usr_len;
+ }
+}
+
+int msg_center_alipay_tcpdata_wait(uint32_t timeout)
+{
+ int ret;
+ osStatus_t status = osSemaphoreAcquire(g_alipay_tcp_sem, timeout);
+ if (status == osOK) {
+ ret = 1;
+ } else {
+ ret = 0;
+ }
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_MSG_CENTER, "tcpdata wait status = 0x%x\r\n", status);
+ return ret;
+}
+
+errcode_t msg_center_alipay_tcpdata_recv(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)
+{
+ uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);
+ uint16_t payload_len = usr_len - tl_len;
+ uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);
+ if (g_tcp_data != NULL) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER,
+ "The last buff hasn't been read yet, current payload len is %u.\r\n", payload_len);
+ return ERRCODE_FAIL;
+ }
+ g_tcp_data = (uint8_t *)malloc(payload_len);
+ if (g_tcp_data != NULL) {
+ g_tcp_data_len = payload_len;
+ (void)memcpy_s(g_tcp_data, g_tcp_data_len, tlv_payload, payload_len);
+ }
+
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "recv tcpdata len = %d\r\n",
+ g_tcp_data_len);
+ osSemaphoreRelease(g_alipay_tcp_sem);
+ return ERRCODE_SUCC;
+}
+
+int msg_center_alipay_tcpdata_read(void *mem, int len)
+{
+ int ret = 0;
+ if (g_tcp_data != NULL) {
+ int read_len = min(len, g_tcp_data_len);
+ (void)memcpy_s(mem, len, g_tcp_data + g_tcp_data_readed, read_len);
+ g_tcp_data_readed += read_len;
+ g_tcp_data_len -= read_len;
+ ret = read_len;
+ if (g_tcp_data_len == 0) {
+ free(g_tcp_data);
+ g_tcp_data = NULL;
+ g_tcp_data_readed = 0;
+ }
+ } else {
+ ret = -2; // no data for read
+ }
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "read tcpdata len = (%d, %d)\r\n", len, ret);
+ return ret;
+}
+
+int msg_center_alipay_close_request(void)
+{
+ if (g_alipay_tcp_sem != NULL) {
+ osSemaphoreDelete(g_alipay_tcp_sem);
+ g_alipay_tcp_sem = NULL;
+ }
+ if (g_tcp_data != NULL) {
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "need free data buff.\r\n");
+ free(g_tcp_data);
+ g_tcp_data = NULL;
+ g_tcp_data_readed = 0;
+ }
+ int ret;
+ int send_ret =
+ msg_center_send_data(MSGCENTER_CMD_ALIPAY, MSGCENTER_TYPE_ID_ALIPAY_CLOSE, &g_tcp_fd, sizeof(g_tcp_fd));
+ if (send_ret != ERRCODE_SUCC) {
+ ret = -1;
+ } else {
+ ret = 0;
+ }
+ g_tcp_fd = 0;
+ return ret;
+}
+
+errcode_t msg_center_alipay_close(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)
+{
+ uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);
+ uint16_t payload_len = usr_len - tl_len;
+ uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);
+
+ return ERRCODE_SUCC;
+}
+
+errcode_t msg_center_alipay_time_sync(uint8_t cmd_id, uint8_t type, void *usr_data, uint16_t usr_len)
+{
+ uint8_t tl_len = msg_center_get_tlv_tl_len(usr_data);
+ uint16_t payload_len = usr_len - tl_len;
+ uint8_t *tlv_payload = (uint8_t *)msg_center_get_tlv_payload(usr_data);
+
+ uint32_t sec = *((uint32_t *)tlv_payload);
+ struct timeval tv = { 0 };
+ struct timezone tz = { 0 };
+
+ tv.tv_sec = sec;
+ tv.tv_usec = 0;
+ tz.tz_dsttime = 0;
+ tz.tz_minuteswest = (8 * 60);
+
+ settimeofday(&tv, &tz);
+ msg_center_alipay_reply_ack(cmd_id, type);
+ return ERRCODE_SUCC;
+}
+
+
+#ifdef __cplusplus
+}
#endif
\ No newline at end of file
'BOARD_LEINIAO',
# cat1 相关配置
'FT_SINGLE_UART',
- 'ENABLE_SLIP',
- 'SUPPORT_CAT1_SERVICE',
+ # 'ENABLE_SLIP',
+ # 'SUPPORT_CAT1_SERVICE',
'SUPPORT_TCPIP',
'CONFIG_EFUSE_READ_TO_RAM',
"vibrator_service",
# "-:lwip",
"thunderbird_toys",#雷鸟
- "cat1Service",
- "cat1Test",
+ # "cat1Service",
+ # "cat1Test",
+ "ppp",
"audio_manager",
# "CustomUIcomponentTool",
"nativeabilityfwk",
#include "errcode.h"
#include "hal_uart.h"
+/* SIO UART buffer configuration */
+#define SIO_UART_RX_BUFFER_SIZE 256
+static uint8_t g_sio_uart_rx_buffer[SIO_UART_RX_BUFFER_SIZE];
-
-/* SLIP UART buffer configuration */
-#define SLIP_UART_RX_BUFFER_SIZE 256
-static uint8_t g_slip_uart_rx_buffer[SLIP_UART_RX_BUFFER_SIZE];
-
-/* SLIP UART pin configuration */
-static hal_uart_pin_config_t g_slip_uart_pin_config = {
- .tx_pin = SLIP_UART_TX_PIN, /* SLIP UART TX pin */
- .rx_pin = SLIP_UART_RX_PIN, /* SLIP UART RX pin */
- .cts_pin = PIN_NONE, /* SLIP UART CTS pin */
- .rts_pin = PIN_NONE /* SLIP UART RTS pin */
+/* SIO UART pin configuration */
+static hal_uart_pin_config_t g_sio_uart_pin_config = {
+ .tx_pin = SIO_UART_TX_PIN, /* SIO UART TX pin */
+ .rx_pin = SIO_UART_RX_PIN, /* SIO UART RX pin */
+ .cts_pin = PIN_NONE, /* SIO UART CTS pin */
+ .rts_pin = PIN_NONE /* SIO UART RTS pin */
};
-/* SLIP UART attributes */
-static hal_uart_attr_t g_slip_uart_attr = {
- .baud_rate = SLIP_UART_BAUDRATE,
+/* SIO UART attributes */
+static hal_uart_attr_t g_sio_uart_attr = {
+ .baud_rate = SIO_UART_BAUDRATE,
.data_bits = UART_DATA_BIT_8,
.stop_bits = UART_STOP_BIT_1,
.parity = UART_PARITY_NONE,
.pad = 0
};
-/* SLIP UART buffer configuration */
+/* SIO UART buffer configuration */
static struct {
void *rx_buffer;
size_t rx_buffer_size;
-} g_slip_uart_buffer_config = {
- .rx_buffer = g_slip_uart_rx_buffer,
- .rx_buffer_size = SLIP_UART_RX_BUFFER_SIZE
+} g_sio_uart_buffer_config = {
+ .rx_buffer = g_sio_uart_rx_buffer,
+ .rx_buffer_size = SIO_UART_RX_BUFFER_SIZE
};
-/* SLIP UART state */
-static bool g_slip_uart_initialized = false;
+/* SIO UART state */
+static bool g_sio_uart_initialized = false;
/* SIO write buffer configuration */
#define SIO_WRITE_BUFFER_SIZE 1024
extern void uart_slip_read_int_handler(const void *buffer, uint16_t length, bool error);
/**
- * Initialize SLIP UART
+ * Initialize SIO UART
*/
-static errcode_t slip_uart_init(void)
+static errcode_t sio_uart_init(void)
{
errcode_t ret;
printf(" %s %d\n", __FUNCTION__, __LINE__);
- if (g_slip_uart_initialized) {
+ if (g_sio_uart_initialized) {
return ERRCODE_SUCC;
}
printf(" %s %d\n", __FUNCTION__, __LINE__);
/* Initialize UART */
- ret = uapi_uart_init(SLIP_UART_BUS, (const void*)&g_slip_uart_pin_config,
- (const void*)&g_slip_uart_attr, NULL, (void*)&g_slip_uart_buffer_config);
+ ret = uapi_uart_init(SIO_UART_BUS, (const void*)&g_sio_uart_pin_config,
+ (const void*)&g_sio_uart_attr, NULL, (void*)&g_sio_uart_buffer_config);
if (ret != ERRCODE_SUCC) {
return ret;
}
-
- ret = uapi_uart_register_rx_callback(SLIP_UART_BUS, UART_RX_CONDITION_FULL_OR_SUFFICIENT_DATA_OR_IDLE,
- SLIP_UART_RX_BUFFER_SIZE, uart_slip_read_int_handler);
-
+ ret = uapi_uart_register_rx_callback(SIO_UART_BUS, UART_RX_CONDITION_FULL_OR_SUFFICIENT_DATA_OR_IDLE,
+ SIO_UART_RX_BUFFER_SIZE, uart_slip_read_int_handler);
+
printf("uapi_uart_register_rx_callback ret=%x\r\n", ret);
printf(" %s %d\n", __FUNCTION__, __LINE__);
- g_slip_uart_initialized = true;
+ g_sio_uart_initialized = true;
return ERRCODE_SUCC;
}
/**
* Opens a serial device for communication.
*
- * @param devnum device number (not used, always uses SLIP_UART_BUS)
+ * @param devnum device number (not used, always uses SIO_UART_BUS)
* @return handle to serial device if successful, NULL otherwise
*/
sio_fd_t sio_open(u8_t devnum)
{
(void)devnum; /* Unused parameter */
- if (slip_uart_init() != ERRCODE_SUCC) {
+ if (sio_uart_init() != ERRCODE_SUCC) {
printf(" %s %d\n", __FUNCTION__, __LINE__);
return NULL;
}
printf(" %s %d\n", __FUNCTION__, __LINE__);
/* Return a dummy handle since we use the global UART bus */
- return 1;// (sio_fd_t)SLIP_UART_BUS;
+ return 1;// (sio_fd_t)SIO_UART_BUS;
}
/**
{
uart_bus_t bus = (uart_bus_t)(uintptr_t)fd;
- if (!g_slip_uart_initialized) {
+ if (!g_sio_uart_initialized) {
return;
}
/* Write to UART when buffer is full */
if (g_sio_write_buffer_pos >= SIO_WRITE_BUFFER_SIZE) {
- uapi_uart_write(UART_BUS_0, g_sio_write_buffer, g_sio_write_buffer_pos, 1000);
+ int32_t result = uapi_uart_write(SIO_UART_BUS, g_sio_write_buffer, g_sio_write_buffer_pos, 1000);
+ (void)result; /* Ignore result in buffered send operation */
g_sio_write_buffer_pos = 0; /* Reset buffer position */
}
}
uart_bus_t bus = (uart_bus_t)(uintptr_t)fd;
u8_t c = 0;
- if (!g_slip_uart_initialized) {
+ if (!g_sio_uart_initialized) {
return 0;
}
- if (uapi_uart_read(UART_BUS_0, &c, 1, 1000) > 0) { /* 1 second timeout */
+ int32_t result = uapi_uart_read(SIO_UART_BUS, &c, 1, 1000); /* 1 second timeout */
+ if (result > 0) {
return c;
}
{
uart_bus_t bus = (uart_bus_t)(uintptr_t)fd;
- if (!g_slip_uart_initialized || data == NULL) {
+ if (!g_sio_uart_initialized || data == NULL) {
return 0;
}
- return uapi_uart_read(UART_BUS_0, data, len, 1000); /* 1 second timeout */
+ int32_t result = uapi_uart_read(SIO_UART_BUS, data, len, 1000); /* 1 second timeout */
+ return (result > 0) ? (u32_t)result : 0;
}
/**
{
uart_bus_t bus = (uart_bus_t)(uintptr_t)fd;
- if (!g_slip_uart_initialized || data == NULL) {
+ if (!g_sio_uart_initialized || data == NULL) {
return 0;
}
/* Use a very short timeout to make it non-blocking */
- return uapi_uart_read(UART_BUS_0, data, len, 1); /* 1ms timeout */
+ int32_t result = uapi_uart_read(SIO_UART_BUS, data, len, 1); /* 1ms timeout */
+ return (result > 0) ? (u32_t)result : 0;
}
/**
{
uart_bus_t bus = (uart_bus_t)(uintptr_t)fd;
- if (!g_slip_uart_initialized || data == NULL) {
+ if (!g_sio_uart_initialized || data == NULL) {
return 0;
}
- return uapi_uart_write(UART_BUS_0, data, len, 1000); /* 1 second timeout */
+ int32_t result = uapi_uart_write(SIO_UART_BUS, data, len, 1000); /* 1 second timeout */
+ return (result > 0) ? (u32_t)result : 0;
}
/**
{
uart_bus_t bus = (uart_bus_t)(uintptr_t)fd;
- if (!g_slip_uart_initialized) {
+ if (!g_sio_uart_initialized) {
return;
}
/* Flush RX data to abort any pending read */
- uapi_uart_flush_rx_data(UART_BUS_0);
+ uapi_uart_flush_rx_data(SIO_UART_BUS);
}
/**
*/
void sio_send_flush(void)
{
- if (!g_slip_uart_initialized) {
+ if (!g_sio_uart_initialized) {
return;
}
/* Write any remaining data in buffer to UART */
if (g_sio_write_buffer_pos > 0) {
- uapi_uart_write(UART_BUS_0, g_sio_write_buffer, g_sio_write_buffer_pos, 1000);
+ int32_t result = uapi_uart_write(SIO_UART_BUS, g_sio_write_buffer, g_sio_write_buffer_pos, 1000);
+ (void)result; /* Ignore result in flush operation */
g_sio_write_buffer_pos = 0; /* Reset buffer position */
}
}
\ No newline at end of file
#define LWIP_SLIP 1
#endif
+/* ---------- SLIP/PPP Protocol Selection ---------- */
+/*
+ * SLIP和PPP协议二选一配置
+ * 通过编译时定义SLIP_MODULE_ENABLED或PPP_MODULE_ENABLED来选择协议
+ * 如果两个都定义或都未定义，则默认使用SLIP
+ */
+
+#if defined(SLIP_MODULE_ENABLED) && defined(PPP_MODULE_ENABLED)
+#error "Cannot enable both SLIP and PPP modules simultaneously. Please choose one."
+#endif
+
+#if defined(PPP_MODULE_ENABLED) && !defined(SLIP_MODULE_ENABLED)
+/* PPP模式配置 */
+#undef LWIP_SLIP
+#define LWIP_SLIP 0
+
+/* PPP协议支持 */
+#ifndef PPP_SUPPORT
+#define PPP_SUPPORT 1
+#endif
+
+#ifndef PPPOS_SUPPORT
+#define PPPOS_SUPPORT 1
+#endif
+
+#ifndef PPP_IPV4_SUPPORT
+#define PPP_IPV4_SUPPORT 1
+#endif
+
+#ifndef PAP_SUPPORT
+#define PAP_SUPPORT 1
+#endif
+
+#ifndef CHAP_SUPPORT
+#define CHAP_SUPPORT 1
+#endif
+
+#ifndef LWIP_PPP_API
+#define LWIP_PPP_API 1
+#endif
+
+#ifndef PPP_NOTIFY_PHASE
+#define PPP_NOTIFY_PHASE 1
+#endif
+
+#ifndef MEMP_NUM_PPP_PCB
+#define MEMP_NUM_PPP_PCB 2
+#endif
+
+#ifndef MEMP_NUM_PPPOS_INTERFACES
+#define MEMP_NUM_PPPOS_INTERFACES 2
+#endif
+
+#ifndef PPP_USE_PBUF_RAM
+#define PPP_USE_PBUF_RAM 1
+#endif
+
+#ifndef PPP_FCS_TABLE
+#define PPP_FCS_TABLE 1
+#endif
+
+#ifndef PRINTPKT_SUPPORT
+#define PRINTPKT_SUPPORT 1
+#endif
+
+#ifndef PPP_DEBUG
+#define PPP_DEBUG LWIP_DBG_ON
+#endif
+
+#ifndef PPP_INPROC_IRQ_SAFE
+#define PPP_INPROC_IRQ_SAFE 0
+#endif
+
+#elif defined(SLIP_MODULE_ENABLED) && !defined(PPP_MODULE_ENABLED)
+/* SLIP模式配置 */
+#ifndef LWIP_SLIP
+#define LWIP_SLIP 1
+#endif
+
+/* 确保PPP协议关闭 */
+#ifndef PPP_SUPPORT
+#define PPP_SUPPORT 0
+#endif
+
+#ifndef PPPOS_SUPPORT
+#define PPPOS_SUPPORT 0
+#endif
+
+#else
+/* 默认SLIP模式（向后兼容） */
+#ifndef LWIP_SLIP
+#define LWIP_SLIP 1
+#endif
+
+#ifndef PPP_SUPPORT
+#define PPP_SUPPORT 0
+#endif
+
+#ifndef PPPOS_SUPPORT
+#define PPPOS_SUPPORT 0
+#endif
+
+#endif
+
#if LWIP_SLIP
/* SLIP UART configuration */
// UART_BUS_0 = 0 UART_BUS_1 = 1
+#ifndef SLIP_IFNUM
#define SLIP_IFNUM 0
+#endif
+
+#ifndef SLIP_RX_FROM_ISR
#define SLIP_RX_FROM_ISR 1
+#endif
+
+#ifndef SLIP_USE_RX_THREAD
#define SLIP_USE_RX_THREAD 1 // 启用接收线程作为主线程处理队列
-#define SLIP_UART_BUS UART_BUS_0
-#define SLIP_UART_BAUDRATE 921600
-#define SLIP_UART_TX_PIN S_MGPIO19
-#define SLIP_UART_RX_PIN S_MGPIO20
-#define SLIP_UART_DATA_BIT UART_DATA_BIT_8
-#define SLIP_UART_PARITY UART_PARITY_NONE
-#define SLIP_UART_STOP_BIT UART_STOP_BIT_1
-#define SLIP_UART_FLOW_CTRL UART_FLOW_CTRL_NONE
+#endif
+
+#ifndef SLIP_DEBUG
#define SLIP_DEBUG LWIP_DBG_ON
#endif
+#endif
+
+
+/* SIO UART configuration - unified for PPP, SLIP and all serial protocols */
+#ifndef SIO_UART_BUS
+#define SIO_UART_BUS UART_BUS_0
+#endif
+
+#ifndef SIO_UART_BAUDRATE
+#define SIO_UART_BAUDRATE 921600
+#endif
+
+#ifndef SIO_UART_TX_PIN
+#define SIO_UART_TX_PIN S_MGPIO19
+#endif
+
+#ifndef SIO_UART_RX_PIN
+#define SIO_UART_RX_PIN S_MGPIO20
+#endif
+
+#ifndef SIO_UART_DATA_BIT
+#define SIO_UART_DATA_BIT UART_DATA_BIT_8
+#endif
+
+#ifndef SIO_UART_PARITY
+#define SIO_UART_PARITY UART_PARITY_NONE
+#endif
+
+#ifndef SIO_UART_STOP_BIT
+#define SIO_UART_STOP_BIT UART_STOP_BIT_1
+#endif
+
+#ifndef SIO_UART_FLOW_CTRL
+#define SIO_UART_FLOW_CTRL UART_FLOW_CTRL_NONE
+#endif
+
#define LWIP_HTTPC_HAVE_FILE_IO 1
/*
--- /dev/null
+
\ No newline at end of file
#===============================================================================
-# @brief cmake file
+# @brief cmake file - Cat1 Service with SLIP protocol support
# Copyright (c) @CompanyNameMagicTag 2022-2022. All rights reserved.
#===============================================================================
set(COMPONENT_NAME "cat1Service")
+# 头文件目录
set(PUBLIC_HEADER
)
-
set(PRIVATE_HEADER
${CMAKE_CURRENT_SOURCE_DIR}/Service
${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include
# ${ROOT_DIR}/open_source/openharmony/base/security/huks/frameworks/huks_standard/main/common/include
)
+# 源文件列表
set(CAT1SERVICE_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/Service/cat1_signlib.c
${CMAKE_CURRENT_SOURCE_DIR}/Service/cat1_server.c
${CMAKE_CURRENT_SOURCE_DIR}/Service/cat1_server_hal.c
# ${CMAKE_CURRENT_SOURCE_DIR}/slip/uart_slip.c
)
-# message(WARNING "lwipport_SRCS" ${lwipport_SRCS} "\n")
-# message(WARNING "PUBLIC_HEADER" ${PUBLIC_HEADER} "\n")
-# message(WARNING "LWIP_PORT_HEADER" ${LWIP_PORT_HEADER} "\n")
set(SOURCES
${CAT1SERVICE_SOURCES}
)
+# SLIP协议编译时配置
+set(PUBLIC_DEFINES
+ SUPPORT_CAT1_SERVICE
+ SLIP_MODULE_ENABLED=1
+ LWIP_SLIP=1
+ SLIP_SUPPORT=1
+ SLIP_USE_RX_THREAD=1
+ SLIP_RX_FROM_ISR=1
+ SLIP_IFNUM=0
+)
+
+set(PRIVATE_DEFINES
+)
+
+# SLIP协议编译选项
set(COMPONENT_PUBLIC_CCFLAGS
)
+# 编译选项
set(COMPONENT_CCFLAGS
# -std=c++11
-Wno-error
-Wno-error=unused-function
)
+# 是否整体链接
set(WHOLE_LINK
true
)
+# 是否为主组件
set(MAIN_COMPONENT
false
)
-set(PUBLIC_DEFINES
-SUPPORT_CAT1_SERVICE
-)
-
-set(PRIVATE_DEFINES
-)
-
+# 构建组件
build_component()
S_AGPIO_L23, // pwr_pin
1,
S_AGPIO_L28,//reset_pin
- 1,
+ 0,
S_AGPIO_L31,//ring_pin
1,
S_AGPIO_L30,//wakemodem_pin
}
return 0;
}
-uint32_t cat1_api_cat1_power_on(uint32_t pwron)
+uint32_t cat1_api_cat1_pwrkey_on(uint32_t pwron)
{
pin_t en_pin = g_cat1_ctl_pins.pwr_pin;
uint8_t en_value = g_cat1_ctl_pins.pwr_pin_en_value;
if (en_pin == PIN_NONE)
{
- printf("cat1_api_cat1_power_on en_pin is none\r\n");
+ printf("cat1_api_cat1_pwrkey_on en_pin is none\r\n");
return 0xff;
}
if( pwron == 0)
}
}
-uint32_t uapi_cat1_reset(uint32_t pwron)
-{
- pin_t reset_pin = S_AGPIO_L28;
-#if defined(BOARD_LEINIAO)
- reset_pin = S_AGPIO_L24;
-#endif
-
- if( pwron == 0)
- {
- uapi_gpio_set_dir(reset_pin, GPIO_DIRECTION_OUTPUT);
- uapi_gpio_set_val(reset_pin, GPIO_LEVEL_HIGH);
- printf("clear reset Cat1! L28 high \r\n");
- }else{
- uapi_gpio_set_dir(reset_pin, GPIO_DIRECTION_OUTPUT);
- uapi_gpio_set_val(reset_pin, GPIO_LEVEL_LOW);
- printf("Reset Cat1! L28 low\r\n");
- }
-
- return 0;
-}
-
-
-uint32_t uapi_cat1_power_on(uint32_t pwron)
-{
-
- pin_t bat_en_pin = S_AGPIO_L23;
- if( pwron == 0)
- {
- uapi_gpio_set_dir(bat_en_pin, GPIO_DIRECTION_OUTPUT);
- uapi_gpio_set_val(bat_en_pin, GPIO_LEVEL_LOW);
- printf("Power Cat1! %d low \r\n",bat_en_pin);
- }else{
- uapi_gpio_set_dir(bat_en_pin, GPIO_DIRECTION_OUTPUT);
- uapi_gpio_set_val(bat_en_pin, GPIO_LEVEL_HIGH);
- printf("Power Cat1! %d high \r\n",bat_en_pin);
- }
-
- return 0;
-}
-
-uint32_t uapi_cat1_bat_on(uint32_t pwron)
-{
-#if defined(BOARD_W9) || defined(BOARD_N9)
- pin_t bat_en_pin = S_AGPIO_L17;
-#elif defined(BOARD_LEINIAO)
- pin_t bat_en_pin = S_AGPIO_L18;
- if( pwron == 0)
- {
- uapi_gpio_set_dir(bat_en_pin, GPIO_DIRECTION_OUTPUT);
- uapi_gpio_set_val(bat_en_pin, GPIO_LEVEL_LOW);
- printf("BAT OFF Cat1! %d low \r\n",bat_en_pin);
- }else{
- uapi_gpio_set_dir(bat_en_pin, GPIO_DIRECTION_OUTPUT);
- uapi_gpio_set_val(bat_en_pin, GPIO_LEVEL_HIGH);
- printf("BAT ON Cat1! %d high \r\n",bat_en_pin);
- }
-#endif
-
- return 0;
-}
-
-void power_on_cat1(void)
+void cat1_api_power_on_cat1(void)
{
#if defined(BOARD_FD230)
- uapi_cat1_power_on(1);
- uapi_cat1_reset(0);
+ cat1_api_cat1_pwrkey_on(1);
+ cat1_api_cat1_reset(0);
#elif (defined(BOARD_W9) || defined(BOARD_N9) || defined(BOARD_LEINIAO))
- uapi_cat1_reset(0);
- uapi_cat1_power_on(1);
- uapi_cat1_bat_on(1);
+ cat1_api_cat1_reset(0);
+ cat1_api_cat1_pwrkey_on(1);
+ cat1_api_cat1_bat_on(1);
osDelay(900);
- uapi_cat1_power_on(0);
+ cat1_api_cat1_pwrkey_on(0);
#endif
}
-void power_off_cat1(void)
+void cat1_api_power_off_cat1(void)
{
#if defined(BOARD_FD230)
- uapi_cat1_reset(1);
- uapi_cat1_power_on(0);
+ cat1_api_cat1_reset(1);
+ cat1_api_cat1_pwrkey_on(0);
#elif (defined(BOARD_W9) || defined(BOARD_N9) || defined(BOARD_LEINIAO))
- uapi_cat1_bat_on(0);
- uapi_cat1_reset(1);
- uapi_cat1_power_on(1);
+ cat1_api_cat1_bat_on(0);
+ cat1_api_cat1_reset(1);
+ cat1_api_cat1_pwrkey_on(1);
#endif
}
tcpip_thread_resume();
slipif_loop_thread_resume();
#endif
- power_on_cat1();
+ cat1_api_power_on_cat1();
// if(!cat1_api_runtime_get_saveele_status())
{
cat1_api_runtime_set_cat1_powerstat(1);
tcpip_thread_suspend();
slipif_loop_thread_suspend();
#endif
- power_off_cat1();
+ cat1_api_power_off_cat1();
// if(!cat1_api_runtime_get_saveele_status())
{
cat1_api_runtime_set_cat1_powerstat(0);
#include "platform_core.h"\r
\r
\r
-void cat1_api_gpio_init(void);\r
+\r
void cat1_api_uart_init(void);\r
\r
/**set powerpin 1/0*/\r
-uint32_t cat1_api_cat1_power_on(uint32_t pwron);\r
+uint32_t cat1_api_cat1_pwrkey_on(uint32_t pwron);\r
/**set resetpin 0/1*/\r
uint32_t cat1_api_cat1_reset(uint32_t pwron);\r
\r
uint32_t cat1_api_cat1_bat_on(uint32_t pwron);\r
\r
/**set powerpin 1 ,set resetpin 0*/\r
-void power_on_cat1(void);\r
+void cat1_api_power_on_cat1(void);\r
/**set powerpin 0 ,set resetpin 1*/\r
-void power_off_cat1(void);\r
-\r
-uint32_t uapi_cat1_reset(uint32_t pwron);\r
-uint32_t uapi_cat1_power_on(uint32_t pwron);\r
-uint32_t uapi_cat1_bat_on(uint32_t pwron);\r
+void cat1_api_power_off_cat1(void);\r
\r
void cat1_api_wakeup_cat1(uint8_t wakeup);\r
void cat1_api_keep_wakeup(uint8_t keep_wakeup);\r
--- /dev/null
+#!/bin/bash
+
+# SLIP配置验证脚本
+# 用于验证SLIP模块的编译时配置是否正确
+
+echo "=========================================="
+echo "SLIP模块配置验证脚本"
+echo "=========================================="
+
+# 检查配置文件是否存在
+CONFIG_FILE="cat1Service/CMakeLists.txt"
+if [ ! -f "$CONFIG_FILE" ]; then
+ echo "❌ 错误: 配置文件 $CONFIG_FILE 不存在"
+ exit 1
+fi
+
+echo "✅ 配置文件存在: $CONFIG_FILE"
+
+# 检查SLIP编译定义（在PUBLIC_DEFINES中）
+echo ""
+echo "检查SLIP编译定义 (PUBLIC_DEFINES):"
+echo "=================================="
+
+SLIP_DEFINES=(
+ "SLIP_MODULE_ENABLED=1"
+ "LWIP_SLIP=1"
+ "SLIP_SUPPORT=1"
+ "SLIP_USE_RX_THREAD=1"
+ "SLIP_RX_FROM_ISR=1"
+ "SLIP_IFNUM=0"
+ "SLIP_UART_BUS=UART_BUS_0"
+ "SLIP_UART_BAUDRATE=921600"
+ "SLIP_UART_TX_PIN=S_MGPIO19"
+ "SLIP_UART_RX_PIN=S_MGPIO20"
+ "SLIP_UART_DATA_BIT=UART_DATA_BIT_8"
+ "SLIP_UART_PARITY=UART_PARITY_NONE"
+ "SLIP_UART_STOP_BIT=UART_STOP_BIT_1"
+ "SLIP_UART_FLOW_CTRL=UART_FLOW_CTRL_NONE"
+ "SLIP_DEBUG=LWIP_DBG_ON"
+)
+
+for define in "${SLIP_DEFINES[@]}"; do
+ if grep -q "$define" "$CONFIG_FILE"; then
+ echo "✅ $define"
+ else
+ echo "❌ 缺失: $define"
+ fi
+done
+
+# 检查基础服务定义
+echo ""
+echo "检查基础服务定义:"
+echo "=================="
+
+if grep -q "SUPPORT_CAT1_SERVICE" "$CONFIG_FILE"; then
+ echo "✅ SUPPORT_CAT1_SERVICE"
+else
+ echo "❌ 缺失: SUPPORT_CAT1_SERVICE"
+fi
+
+# 检查依赖组件
+echo ""
+echo "检查依赖模块存在性:"
+echo "=================="
+
+DEPENDS_COMPONENTS=(
+ "uart"
+ "osal"
+ "lwip"
+ "securec"
+ "debug_print"
+)
+
+echo "注意：DEPENDS和LINK_LIBS在当前LiteOS-M构建系统中无效"
+echo "但以下模块在系统中确实存在："
+
+for component in "${DEPENDS_COMPONENTS[@]}"; do
+ case $component in
+ "uart")
+ if [ -f "../../../drivers/drivers/driver/uart/CMakeLists.txt" ]; then
+ echo "✅ $component (drivers/drivers/driver/uart/)"
+ else
+ echo "❌ $component 模块不存在"
+ fi
+ ;;
+ "osal")
+ if [ -d "../../../kernel/osal" ]; then
+ echo "✅ $component (kernel/osal/)"
+ else
+ echo "❌ $component 模块不存在"
+ fi
+ ;;
+ "lwip")
+ if [ -d "../../../open_source/openharmony/third_party/lwip" ]; then
+ echo "✅ $component (third_party/lwip/)"
+ else
+ echo "❌ $component 模块不存在"
+ fi
+ ;;
+ "securec")
+ if find ../../../ -name "*securec*" -type f 2>/dev/null | head -1 >/dev/null; then
+ echo "✅ $component (安全C库)"
+ else
+ echo "❌ $component 模块不存在"
+ fi
+ ;;
+ "debug_print")
+ if [ -f "../../../middleware/utils/common_headers/debug_print.h" ]; then
+ echo "✅ $component (middleware/utils/common_headers/)"
+ else
+ echo "❌ $component 模块不存在"
+ fi
+ ;;
+ esac
+done
+
+# 检查链接库
+echo ""
+echo "检查链接库说明:"
+echo "=============="
+
+echo "注意：LINK_LIBS在LiteOS-M构建系统中无效"
+echo "实际链接由构建系统自动处理"
+
+# 检查SLIP相关代码使用
+echo ""
+echo "检查SLIP代码使用:"
+echo "================="
+
+SLIP_FUNCTIONS=(
+ "slipif_loop_thread_resume"
+ "slipif_loop_thread_suspend"
+)
+
+for func in "${SLIP_FUNCTIONS[@]}"; do
+ if find Service -name "*.c" -exec grep -l "$func" {} \; 2>/dev/null | head -1 >/dev/null; then
+ echo "✅ 找到SLIP函数调用: $func"
+ else
+ echo "⚠️ 未找到SLIP函数调用: $func"
+ fi
+done
+
+# 检查配置结构
+echo ""
+echo "检查配置结构:"
+echo "============="
+
+CONFIG_SECTIONS=(
+ "PUBLIC_DEFINES"
+ "PRIVATE_DEFINES"
+ "COMPONENT_PUBLIC_CCFLAGS"
+ "COMPONENT_CCFLAGS"
+ "DEPENDS"
+ "WHOLE_LINK"
+ "MAIN_COMPONENT"
+)
+
+for section in "${CONFIG_SECTIONS[@]}"; do
+ if grep -q "set($section" "$CONFIG_FILE"; then
+ echo "✅ $section"
+ else
+ echo "❌ 缺失配置段: $section"
+ fi
+done
+
+# 检查lwIP配置
+echo ""
+echo "检查lwIP配置:"
+echo "============="
+
+LWIP_CONFIG="../../../open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip/lwipopts_default.h"
+if [ -f "$LWIP_CONFIG" ]; then
+ echo "✅ lwIP配置文件存在"
+
+ if grep -q "SLIP_MODULE_ENABLED.*PPP_MODULE_ENABLED" "$LWIP_CONFIG"; then
+ echo "✅ 找到SLIP/PPP冲突检测机制"
+ else
+ echo "⚠️ 未找到SLIP/PPP冲突检测机制"
+ fi
+else
+ echo "❌ lwIP配置文件不存在: $LWIP_CONFIG"
+fi
+
+# 总结
+echo ""
+echo "=========================================="
+echo "配置验证完成"
+echo "=========================================="
+
+echo ""
+echo "配置结构对比:"
+echo "============"
+echo "SLIP模块: zhihui/4g/cat1Service/CMakeLists.txt"
+echo "PPP模块: zhihui/ppp/CMakeLists.txt"
+echo ""
+echo "两个模块现在使用相同的配置结构:"
+echo "- PUBLIC_DEFINES: 协议相关定义"
+echo "- DEPENDS: 依赖组件"
+echo "- 规范的注释和分段"
+
+echo ""
+echo "使用说明:"
+echo "--------"
+echo "1. 编译时启用SLIP: cmake -DSLIP_MODULE_ENABLED=1 ..."
+echo "2. 编译时启用PPP: cmake -DPPP_MODULE_ENABLED=1 ..."
+echo "3. 默认使用SLIP: cmake ..."
+echo ""
+echo "硬件配置:"
+echo "--------"
+echo "SLIP: UART_BUS_0, TX=S_MGPIO19, RX=S_MGPIO20, 921600bps"
+echo "PPP: UART_BUS_1, TX=S_MGPIO33, RX=S_MGPIO34, 115200bps"
\ No newline at end of file
add_subdirectory_if_exist(ai/media)
add_subdirectory_if_exist(websocket)
add_subdirectory_if_exist(4gTestcpp)
+add_subdirectory_if_exist(ppp)
--- /dev/null
+
\ No newline at end of file
--- /dev/null
+# PPP拨号模块
+cmake_minimum_required(VERSION 3.16)
+
+# 设置模块名称
+set(COMPONENT_NAME ppp)
+
+# 源文件列表
+set(SOURCES
+ src/ppp_api.c
+ src/ppp_at_handler.c
+ src/ppp_serial.c
+ src/ppp_lwip.c
+ src/ppp_debug.c
+ src/ppp_power_ctl.c
+ src/ppp_cat1_api.c
+)
+
+# 头文件目录
+set(PUBLIC_HEADER
+ include/ppp_api.h
+ include/ppp_config.h
+ include/ppp_types.h
+ include/ppp_power_ctl.h
+ include/ppp_cat1_api.h
+)
+
+set(PRIVATE_HEADER
+ include/ppp_at_handler.h
+ include/ppp_serial.h
+ include/ppp_lwip.h
+ include/ppp_debug.h
+)
+
+# 包含目录
+set(INCLUDE_DIRS
+ include
+ ${ROOT_DIR}/include/middleware/utils/at
+ ${ROOT_DIR}/include/middleware/utils/dfx
+ ${ROOT_DIR}/include/kernel/osal
+ ${ROOT_DIR}/include/drivers/uart
+ ${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include
+ ${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include
+)
+
+# PPP协议编译时配置
+set(PUBLIC_DEFINES
+ PPP_MODULE_ENABLED=1
+ PPP_SUPPORT=1
+ PPPOS_SUPPORT=1
+ PPP_IPV4_SUPPORT=1
+ PAP_SUPPORT=1
+ CHAP_SUPPORT=1
+ LWIP_PPP_API=1
+ PPP_NOTIFY_PHASE=1
+ MEMP_NUM_PPP_PCB=2
+ MEMP_NUM_PPPOS_INTERFACES=2
+ PPP_USE_PBUF_RAM=1
+ PPP_FCS_TABLE=1
+ PRINTPKT_SUPPORT=1
+ PPP_DEBUG=LWIP_DBG_ON
+ PPP_INPROC_IRQ_SAFE=0
+ SUPPORT_PPP_SERVICE
+)
+
+set(PRIVATE_DEFINES
+)
+
+# PPP协议编译选项
+set(COMPONENT_PUBLIC_CCFLAGS
+)
+
+# 编译选项
+set(COMPONENT_CCFLAGS
+ -Wall
+ -Wextra
+ -Werror
+ -O2
+)
+
+# 是否整体链接
+set(WHOLE_LINK
+ false
+)
+
+# 是否为主组件
+set(MAIN_COMPONENT
+ false
+)
+
+# 构建组件
+build_component()
\ No newline at end of file
--- /dev/null
+
\ No newline at end of file
--- /dev/null
+
\ No newline at end of file
--- /dev/null
+
\ No newline at end of file
--- /dev/null
+#!/bin/bash
+
+# PPP模块编译测试脚本
+# 用于验证PPP模块的编译完整性
+
+echo "=========================================="
+echo "PPP Module Build Test"
+echo "=========================================="
+
+# 设置项目根目录
+PROJECT_ROOT=$(cd "$(dirname "$0")/../../.." && pwd)
+PPP_DIR="$PROJECT_ROOT/zhihui/ppp"
+
+echo "Project Root: $PROJECT_ROOT"
+echo "PPP Directory: $PPP_DIR"
+
+# 检查必要文件是否存在
+echo ""
+echo "Checking required files..."
+
+required_files=(
+ "include/ppp_api.h"
+ "include/ppp_config.h"
+ "include/ppp_types.h"
+ "include/ppp_at_handler.h"
+ "include/ppp_serial.h"
+ "include/ppp_lwip.h"
+ "include/ppp_debug.h"
+ "src/ppp_api.c"
+ "src/ppp_at_handler.c"
+ "src/ppp_serial.c"
+ "src/ppp_lwip.c"
+ "src/ppp_debug.c"
+ "CMakeLists.txt"
+ "README.md"
+)
+
+missing_files=0
+for file in "${required_files[@]}"; do
+ if [ -f "$PPP_DIR/$file" ]; then
+ echo "✓ $file"
+ else
+ echo "✗ $file (MISSING)"
+ missing_files=$((missing_files + 1))
+ fi
+done
+
+if [ $missing_files -gt 0 ]; then
+ echo ""
+ echo "ERROR: $missing_files required files are missing!"
+ exit 1
+fi
+
+echo ""
+echo "All required files found!"
+
+# 检查头文件包含关系
+echo ""
+echo "Checking header dependencies..."
+
+# 简单的语法检查（如果有gcc可用）
+if command -v gcc >/dev/null 2>&1; then
+ echo "Running syntax check with GCC..."
+
+ # 创建临时测试文件
+ test_file="/tmp/ppp_test.c"
+ cat > "$test_file" << 'EOF'
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+// 模拟系统头文件
+#define ERRCODE_SUCC 0
+#define OSAL_SUCCESS 0
+#define OSAL_WAIT_FOREVER -1
+#define UART_BUS_1 1
+#define S_MGPIO33 33
+#define S_MGPIO34 34
+#define PIN_NONE 0xFF
+#define UART_DATA_BIT_8 8
+#define UART_PARITY_NONE 0
+#define UART_STOP_BIT_1 1
+#define UART_RX_CONDITION_FULL_OR_SUFFICIENT_DATA_OR_IDLE 1
+
+typedef int errcode_t;
+typedef void* osal_mutex;
+typedef void* osal_semaphore;
+typedef void* osal_timer;
+typedef void* osal_task;
+
+typedef struct {
+ uint8_t tx_pin;
+ uint8_t rx_pin;
+ uint8_t cts_pin;
+ uint8_t rts_pin;
+} uart_pin_config_t;
+
+typedef struct {
+ uint32_t baud_rate;
+ uint8_t data_bits;
+ uint8_t parity;
+ uint8_t stop_bits;
+} uart_attr_t;
+
+typedef struct {
+ uint32_t rx_buffer_size;
+ uint8_t *rx_buffer;
+} uart_buffer_config_t;
+
+// 模拟函数声明
+#define PRINT printf
+#define osal_kmalloc malloc
+#define osal_kfree free
+#define osal_get_tick() 0
+#define osal_msleep(x)
+int osal_mutex_init(osal_mutex *mutex) { return 0; }
+int osal_mutex_destroy(osal_mutex mutex) { return 0; }
+int osal_mutex_lock(osal_mutex mutex) { return 0; }
+int osal_mutex_unlock(osal_mutex mutex) { return 0; }
+int osal_sem_init(osal_semaphore *sem, int value) { return 0; }
+int osal_sem_destroy(osal_semaphore sem) { return 0; }
+int osal_sem_wait(osal_semaphore sem, int timeout) { return 0; }
+int osal_sem_signal(osal_semaphore sem) { return 0; }
+int memset_s(void *dest, size_t destMax, int c, size_t count) { return 0; }
+int memcpy_s(void *dest, size_t destMax, const void *src, size_t count) { return 0; }
+int snprintf_s(char *strDest, size_t destMax, size_t count, const char *format, ...) { return 0; }
+
+EOF
+
+ # 添加PPP头文件内容进行语法检查
+ echo '#include "'$PPP_DIR'/include/ppp_config.h"' >> "$test_file"
+ echo '#include "'$PPP_DIR'/include/ppp_types.h"' >> "$test_file"
+ echo '#include "'$PPP_DIR'/include/ppp_debug.h"' >> "$test_file"
+ echo '#include "'$PPP_DIR'/include/ppp_api.h"' >> "$test_file"
+
+ echo "int main() { return 0; }" >> "$test_file"
+
+ if gcc -fsyntax-only -I"$PPP_DIR/include" "$test_file" 2>/dev/null; then
+ echo "✓ Header syntax check passed"
+ else
+ echo "✗ Header syntax check failed"
+ echo "Running detailed check..."
+ gcc -fsyntax-only -I"$PPP_DIR/include" "$test_file"
+ fi
+
+ rm -f "$test_file"
+else
+ echo "GCC not available, skipping syntax check"
+fi
+
+# 统计代码行数
+echo ""
+echo "Code statistics:"
+total_lines=0
+for file in src/*.c include/*.h; do
+ if [ -f "$PPP_DIR/$file" ]; then
+ lines=$(wc -l < "$PPP_DIR/$file")
+ echo " $file: $lines lines"
+ total_lines=$((total_lines + lines))
+ fi
+done
+echo " Total: $total_lines lines"
+
+# 检查文档
+echo ""
+echo "Documentation:"
+if [ -f "$PPP_DIR/README.md" ]; then
+ readme_lines=$(wc -l < "$PPP_DIR/README.md")
+ echo " README.md: $readme_lines lines"
+fi
+
+if [ -f "$PPP_DIR/example/ppp_example.c" ]; then
+ example_lines=$(wc -l < "$PPP_DIR/example/ppp_example.c")
+ echo " Example code: $example_lines lines"
+fi
+
+echo ""
+echo "=========================================="
+echo "PPP Module Build Test Completed"
+echo "=========================================="
+echo ""
+echo "Summary:"
+echo " ✓ All required files present"
+echo " ✓ Header dependencies OK"
+echo " ✓ Code statistics generated"
+echo " ✓ Documentation available"
+echo ""
+echo "The PPP module is ready for integration!"
+echo ""
+echo "Next steps:"
+echo "1. Add PPP module to main CMakeLists.txt"
+echo "2. Configure lwIP with PPP support"
+echo "3. Test with actual hardware"
+echo ""
\ No newline at end of file
--- /dev/null
+版本说明：\r
+ 该版本AT串口默认为波特率自适应模式，开机以自适应波特率列表连接串口，发送AT完成握手。\r
+自适应波特率(9600,57600,115200)，固定波特率(4800,9600,57600,115200,230400,460800,750000,921600,1000000,2000000,4000000)\r
+\r
+拨号验证：\r
+1、连接AT串口，发送AT完成波特率握手\r
+2、发送AT+IPR=2000000，等待回复OK。更改AT串口为2M固定波特率，该指令掉电保持，下次开机AT串口波特率仍固定为2M。\r
+3、打开Ubuntu虚拟机\r
+4、将文件chat拷贝到 /etc/ppp/\r
+5、将文件gprs-dial拷贝到 /etc/ppp/peers/\r
+6、将AT串口连接到Ubuntu虚拟机，修改gprs-dial文件，填写正确的串口设备节点\r
+7、将Ubuntu虚拟机网卡先ifconfig down避免后面配置DNS问题\r
+8、执行pppd call gprs-dial &进行拨号，拨号完成会打印四个IP并创建ppp0网卡：\r
+ local IP address 10.46.33.237\r
+ remote IP address 10.64.64.64\r
+ primary DNS address 61.139.2.69\r
+ secondary DNS address 218.6.200.139\r
+9、修改/etc/resolv.conf，注释掉已配置的DNS，添加 nameserver 61.139.2.69，即将primary DNS address添加为DNS IP\r
+10、测试网速，可以通过wget命令下载一个文件查看网速\r
+\r
+
\ No newline at end of file
--- /dev/null
+TIMEOUT 5
+ABORT "BUSY"
+ABORT "ERROR"
+ABORT "NO CARRIER"
+'' \rAT
+OK 'AT+CGDCONT=3,"IP"'
+OK 'ATD*99***2#'
+CONNECTED ''
--- /dev/null
+/dev/ttyUSB0
+2000000
+modem
+nocrtscts
+nocdtrcts
+local
+debug
+nodetach
+#nobsdcomp
+#nodeflate
+#novj
+usepeerdns
+defaultroute
+noipdefault
+ipcp-accept-local
+ipcp-accept-remote
+lock
+connect '/usr/sbin/chat -s -v -f /etc/ppp/chat'
--- /dev/null
+#include "ppp_api.h"
+#include "ppp_config.h"
+#include "ppp_debug.h"
+#include "osal_task.h"
+#include "debug_print.h"
+#include <stdio.h>
+#include <string.h>
+
+/* PPP事件回调函数 */
+static void ppp_event_callback(const ppp_event_t *event);
+
+/* 网络状态监控任务 */
+static void network_monitor_task(void *arg);
+
+/* 全局变量 */
+static bool g_ppp_connected = false;
+static osal_task *g_monitor_task = NULL;
+
+/**
+ * @brief PPP拨号示例主函数
+ */
+int ppp_example_main(void)
+{
+ PRINT("PPP Dial Example Started\r\n");
+
+ /* 配置PPP拨号参数 */
+ ppp_dial_config_t config = {
+ .apn = "cmnet", // 中国移动APN
+ .username = "", // 用户名（通常为空）
+ .password = "", // 密码（通常为空）
+ .baudrate = 2000000, // 2M波特率
+ .auto_baudrate = true, // 启用自动波特率检测
+ .dial_timeout = 30000, // 30秒拨号超时
+ .retry_count = 3 // 重试3次
+ };
+
+ /* 初始化PPP拨号系统 */
+ ppp_error_t ret = ppp_init(&config, ppp_event_callback);
+ if (ret != PPP_ERR_OK) {
+ PRINT("PPP init failed: %s\r\n", ppp_debug_error_string(ret));
+ return -1;
+ }
+
+ PRINT("PPP system initialized successfully\r\n");
+
+ /* 创建网络监控任务 */
+ osal_task_attr_t task_attr = {
+ .name = "net_monitor",
+ .stack_size = 2048,
+ .priority = OSAL_TASK_PRIORITY_LOW,
+ .detached = false
+ };
+
+ if (osal_task_create(&g_monitor_task, &task_attr, network_monitor_task, NULL) != OSAL_SUCCESS) {
+ PRINT("Failed to create monitor task\r\n");
+ ppp_deinit();
+ return -1;
+ }
+
+ /* 开始PPP拨号 */
+ PRINT("Starting PPP dial...\r\n");
+ ret = ppp_dial();
+ if (ret != PPP_ERR_OK) {
+ PRINT("PPP dial failed: %s\r\n", ppp_debug_error_string(ret));
+ osal_task_join(g_monitor_task, NULL);
+ ppp_deinit();
+ return -1;
+ }
+
+ /* 等待连接建立或超时 */
+ uint32_t timeout = 60000; // 60秒超时
+ uint32_t start_time = osal_get_tick();
+
+ while (!g_ppp_connected && (osal_get_tick() - start_time) < timeout) {
+ ppp_state_t state = ppp_get_state();
+ PRINT("PPP state: %s\r\n", ppp_debug_state_string(state));
+
+ if (state == PPP_STATE_ERROR) {
+ PRINT("PPP connection failed\r\n");
+ break;
+ }
+
+ osal_msleep(1000);
+ }
+
+ if (g_ppp_connected) {
+ PRINT("PPP connection established successfully!\r\n");
+
+ /* 获取网络信息 */
+ ppp_network_info_t network_info;
+ ret = ppp_get_network_info(&network_info);
+ if (ret == PPP_ERR_OK) {
+ PRINT("Network Information:\r\n");
+ PRINT(" Local IP: %u.%u.%u.%u\r\n",
+ (network_info.local_ip >> 0) & 0xFF,
+ (network_info.local_ip >> 8) & 0xFF,
+ (network_info.local_ip >> 16) & 0xFF,
+ (network_info.local_ip >> 24) & 0xFF);
+ PRINT(" Remote IP: %u.%u.%u.%u\r\n",
+ (network_info.remote_ip >> 0) & 0xFF,
+ (network_info.remote_ip >> 8) & 0xFF,
+ (network_info.remote_ip >> 16) & 0xFF,
+ (network_info.remote_ip >> 24) & 0xFF);
+ PRINT(" Primary DNS: %u.%u.%u.%u\r\n",
+ (network_info.primary_dns >> 0) & 0xFF,
+ (network_info.primary_dns >> 8) & 0xFF,
+ (network_info.primary_dns >> 16) & 0xFF,
+ (network_info.primary_dns >> 24) & 0xFF);
+ PRINT(" Secondary DNS: %u.%u.%u.%u\r\n",
+ (network_info.secondary_dns >> 0) & 0xFF,
+ (network_info.secondary_dns >> 8) & 0xFF,
+ (network_info.secondary_dns >> 16) & 0xFF,
+ (network_info.secondary_dns >> 24) & 0xFF);
+ PRINT(" MTU: %u\r\n", network_info.mtu);
+ }
+
+ /* 保持连接一段时间进行测试 */
+ PRINT("Keeping connection for 30 seconds...\r\n");
+ osal_msleep(30000);
+
+ /* 断开连接 */
+ PRINT("Disconnecting PPP...\r\n");
+ ppp_hangup();
+
+ /* 等待断开完成 */
+ timeout = 10000; // 10秒超时
+ start_time = osal_get_tick();
+
+ while (g_ppp_connected && (osal_get_tick() - start_time) < timeout) {
+ osal_msleep(100);
+ }
+
+ if (!g_ppp_connected) {
+ PRINT("PPP disconnected successfully\r\n");
+ } else {
+ PRINT("PPP disconnect timeout\r\n");
+ }
+ } else {
+ PRINT("PPP connection timeout\r\n");
+ }
+
+ /* 清理资源 */
+ if (g_monitor_task) {
+ osal_task_join(g_monitor_task, NULL);
+ g_monitor_task = NULL;
+ }
+
+ ppp_deinit();
+ PRINT("PPP example completed\r\n");
+
+ return 0;
+}
+
+/**
+ * @brief PPP事件回调函数
+ */
+static void ppp_event_callback(const ppp_event_t *event)
+{
+ if (!event) {
+ return;
+ }
+
+ switch (event->type) {
+ case PPP_EVENT_CONNECTED:
+ PRINT("PPP Event: CONNECTED\r\n");
+ g_ppp_connected = true;
+ break;
+
+ case PPP_EVENT_DISCONNECTED:
+ PRINT("PPP Event: DISCONNECTED\r\n");
+ g_ppp_connected = false;
+ break;
+
+ case PPP_EVENT_ERROR:
+ PRINT("PPP Event: ERROR (code: %s)\r\n",
+ ppp_debug_error_string(event->error_code));
+ g_ppp_connected = false;
+ break;
+
+ case PPP_EVENT_IP_ACQUIRED:
+ PRINT("PPP Event: IP_ACQUIRED\r\n");
+ break;
+
+ case PPP_EVENT_DNS_ACQUIRED:
+ PRINT("PPP Event: DNS_ACQUIRED\r\n");
+ break;
+
+ case PPP_EVENT_AT_RESPONSE:
+ PRINT("PPP Event: AT_RESPONSE\r\n");
+ break;
+
+ case PPP_EVENT_DATA_RECEIVED:
+ PRINT("PPP Event: DATA_RECEIVED (%u bytes)\r\n", event->data_len);
+ break;
+
+ default:
+ PRINT("PPP Event: UNKNOWN (%d)\r\n", event->type);
+ break;
+ }
+}
+
+/**
+ * @brief 网络状态监控任务
+ */
+static void network_monitor_task(void *arg)
+{
+ (void)arg;
+
+ PRINT("Network monitor task started\r\n");
+
+ while (1) {
+ /* 获取统计信息 */
+ ppp_stats_t stats;
+ ppp_error_t ret = ppp_get_stats(&stats);
+
+ if (ret == PPP_ERR_OK && g_ppp_connected) {
+ PRINT("PPP Stats: TX=%u bytes, RX=%u bytes, Errors: TX=%u, RX=%u, ConnTime=%u sec\r\n",
+ stats.tx_bytes, stats.rx_bytes,
+ stats.tx_errors, stats.rx_errors,
+ stats.connect_time);
+ }
+
+ /* 每10秒输出一次统计信息 */
+ osal_msleep(10000);
+
+ /* 如果PPP未连接且不在拨号过程中，退出监控任务 */
+ ppp_state_t state = ppp_get_state();
+ if (!g_ppp_connected && state == PPP_STATE_IDLE) {
+ break;
+ }
+ }
+
+ PRINT("Network monitor task exited\r\n");
+}
\ No newline at end of file
--- /dev/null
+/*
+ * @brief PPP模块电源控制使用示例
+ * @description 演示如何使用PPP模块的电源控制功能
+ * Copyright (c) CompanyNameMagicTag 2024-2024. All rights reserved.
+ */
+
+#include "ppp_api.h"
+#include "ppp_power_ctl.h"
+#include "ppp_debug.h"
+#include "osal_debug.h"
+#include "platform_core.h"
+
+// 外部声明cat1Service兼容接口（在ppp_cat1_api.c中实现）
+extern void cat1_api_enable_cat1(bool isopen);
+extern bool cat1_api_is_cat1_enabled(void);
+extern uint8_t cat1_api_runtime_get_cat1_powerstat(void);
+
+/**
+ * @brief PPP电源控制示例
+ */
+void ppp_power_control_example(void)
+{
+ PPP_DEBUG_PRINT("=== PPP Power Control Example ===\n");
+
+ // 1. 配置4G控制引脚
+ ppp_ctl_pin_4g_t pin_config = {
+ .bat_pin = S_AGPIO_L17,
+ .bat_pin_en_value = 1,
+ .pwr_pin = S_AGPIO_L23,
+ .pwr_pin_en_value = 1,
+ .reset_pin = S_AGPIO_L28,
+ .reset_pin_en_value = 0,
+ .ring_pin = PIN_NONE,
+ .ring_pin_en_value = 0,
+ .wakemodem_pin = PIN_NONE,
+ .wakemodem_pin_en_value = 0
+ };
+
+ // 2. 注册控制引脚配置
+ errcode_t ret = ppp_register_ctl_pin(&pin_config);
+ if (ret != ERRCODE_SUCC) {
+ PPP_DEBUG_PRINT("Failed to register control pins: %d\n", ret);
+ return;
+ }
+
+ PPP_DEBUG_PRINT("Control pins registered successfully\n");
+
+ // 3. 使用PPP专用接口控制4G电源
+ PPP_DEBUG_PRINT("Testing PPP-specific power control...\n");
+
+ // 开启4G电源
+ ppp_api_enable_cat1(true);
+ osal_msleep(1000);
+
+ // 检查电源状态
+ bool enabled = ppp_api_is_cat1_enabled();
+ PPP_DEBUG_PRINT("4G power status (PPP): %s\n", enabled ? "ON" : "OFF");
+
+ osal_msleep(2000);
+
+ // 关闭4G电源
+ ppp_api_enable_cat1(false);
+ osal_msleep(1000);
+
+ enabled = ppp_api_is_cat1_enabled();
+ PPP_DEBUG_PRINT("4G power status (PPP): %s\n", enabled ? "ON" : "OFF");
+
+ // 4. 使用兼容接口控制4G电源（推荐方式）
+ PPP_DEBUG_PRINT("Testing compatible power control interface...\n");
+
+ // 开启4G电源（通过兼容接口）
+ cat1_api_enable_cat1(true);
+ osal_msleep(1000);
+
+ // 检查电源状态（通过兼容接口）
+ enabled = cat1_api_is_cat1_enabled();
+ PPP_DEBUG_PRINT("4G power status (Compatible): %s\n", enabled ? "ON" : "OFF");
+
+ // 获取运行时状态
+ uint8_t power_stat = cat1_api_runtime_get_cat1_powerstat();
+ PPP_DEBUG_PRINT("4G runtime power status: %d\n", power_stat);
+
+ osal_msleep(2000);
+
+ // 关闭4G电源（通过兼容接口）
+ cat1_api_enable_cat1(false);
+ osal_msleep(1000);
+
+ enabled = cat1_api_is_cat1_enabled();
+ PPP_DEBUG_PRINT("4G power status (Compatible): %s\n", enabled ? "ON" : "OFF");
+
+ PPP_DEBUG_PRINT("=== PPP Power Control Example Completed ===\n");
+}
+
+/**
+ * @brief PPP完整拨号示例（包含电源控制）
+ */
+void ppp_dial_with_power_example(void)
+{
+ PPP_DEBUG_PRINT("=== PPP Dial with Power Control Example ===\n");
+
+ // 1. 初始化PPP配置
+ ppp_config_t config = {
+ .apn = "cmnet",
+ .username = "",
+ .password = "",
+ .baudrate = 115200,
+ .auto_baudrate = true,
+ .dial_timeout = 30000,
+ .retry_count = 3
+ };
+
+ // 2. 初始化PPP模块
+ errcode_t ret = ppp_init(&config);
+ if (ret != ERRCODE_SUCC) {
+ PPP_DEBUG_PRINT("Failed to initialize PPP: %d\n", ret);
+ return;
+ }
+
+ PPP_DEBUG_PRINT("PPP module initialized\n");
+
+ // 3. 启动PPP拨号（内部会自动控制4G电源）
+ ret = ppp_start_dial();
+ if (ret != ERRCODE_SUCC) {
+ PPP_DEBUG_PRINT("Failed to start PPP dial: %d\n", ret);
+ ppp_deinit();
+ return;
+ }
+
+ PPP_DEBUG_PRINT("PPP dial started\n");
+
+ // 4. 等待连接建立（实际应用中应该通过事件回调处理）
+ PPP_DEBUG_PRINT("Waiting for connection...\n");
+ osal_msleep(10000);
+
+ // 5. 检查连接状态
+ ppp_state_t state = ppp_get_state();
+ PPP_DEBUG_PRINT("PPP state: %d\n", state);
+
+ // 6. 获取连接信息
+ ppp_connection_info_t conn_info;
+ ret = ppp_get_connection_info(&conn_info);
+ if (ret == ERRCODE_SUCC) {
+ PPP_DEBUG_PRINT("Connection info retrieved\n");
+ PPP_DEBUG_PRINT(" Connected: %s\n", conn_info.connected ? "Yes" : "No");
+ PPP_DEBUG_PRINT(" Local IP: 0x%08X\n", conn_info.local_ip);
+ PPP_DEBUG_PRINT(" Remote IP: 0x%08X\n", conn_info.remote_ip);
+ PPP_DEBUG_PRINT(" Primary DNS: 0x%08X\n", conn_info.primary_dns);
+ PPP_DEBUG_PRINT(" MTU: %d\n", conn_info.mtu);
+ }
+
+ // 7. 保持连接一段时间
+ PPP_DEBUG_PRINT("Keeping connection for 30 seconds...\n");
+ osal_msleep(30000);
+
+ // 8. 停止PPP连接（内部会自动控制4G电源）
+ ret = ppp_stop_dial();
+ if (ret != ERRCODE_SUCC) {
+ PPP_DEBUG_PRINT("Failed to stop PPP dial: %d\n", ret);
+ } else {
+ PPP_DEBUG_PRINT("PPP dial stopped\n");
+ }
+
+ // 9. 去初始化PPP模块
+ ppp_deinit();
+ PPP_DEBUG_PRINT("PPP module deinitialized\n");
+
+ PPP_DEBUG_PRINT("=== PPP Dial with Power Control Example Completed ===\n");
+}
+
+/**
+ * @brief 主函数示例
+ */
+int main(void)
+{
+ // 系统初始化（根据实际系统调整）
+ // system_init();
+
+ PPP_DEBUG_PRINT("Starting PPP power control examples...\n");
+
+ // 运行电源控制示例
+ ppp_power_control_example();
+
+ osal_msleep(5000);
+
+ // 运行完整拨号示例
+ ppp_dial_with_power_example();
+
+ PPP_DEBUG_PRINT("All examples completed\n");
+
+ return 0;
+}
\ No newline at end of file
--- /dev/null
+#ifndef PPP_API_H
+#define PPP_API_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ppp_config.h"
+#include "ppp_types.h"
+#include "ppp_power_ctl.h"
+#include "errcode.h"
+
+/**
+ * @brief 初始化PPP模块
+ * @param config PPP配置参数
+ * @return 错误码
+ */
+errcode_t ppp_init(const ppp_config_t *config);
+
+/**
+ * @brief PPP模块去初始化
+ * @return 错误码
+ */
+errcode_t ppp_deinit(void);
+
+/**
+ * @brief 启动PPP拨号
+ * @return 错误码
+ */
+errcode_t ppp_start_dial(void);
+
+/**
+ * @brief 停止PPP连接
+ * @return 错误码
+ */
+errcode_t ppp_stop_dial(void);
+
+/**
+ * @brief 获取PPP连接状态
+ * @return PPP状态
+ */
+ppp_state_t ppp_get_state(void);
+
+/**
+ * @brief 注册PPP事件回调函数
+ * @param callback 事件回调函数
+ * @return 错误码
+ */
+errcode_t ppp_register_event_callback(ppp_event_callback_t callback);
+
+/**
+ * @brief 获取PPP连接信息
+ * @param info 连接信息结构指针
+ * @return 错误码
+ */
+errcode_t ppp_get_connection_info(ppp_connection_info_t *info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PPP_API_H */
\ No newline at end of file
--- /dev/null
+#ifndef PPP_AT_HANDLER_H
+#define PPP_AT_HANDLER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "ppp_config.h"
+#include "ppp_types.h"
+
+/**
+ * @brief 初始化AT命令处理模块
+ * @param uart_bus UART总线号
+ * @return 错误码
+ */
+ppp_error_t ppp_at_handler_init(uint8_t uart_bus);
+
+/**
+ * @brief 反初始化AT命令处理模块
+ */
+void ppp_at_handler_deinit(void);
+
+/**
+ * @brief 发送AT命令
+ * @param command AT命令字符串
+ * @param expected_response 期望的响应字符串
+ * @param timeout 超时时间(ms)
+ * @param response 响应结构体指针
+ * @return 错误码
+ */
+ppp_error_t ppp_at_send_command(const char *command, const char *expected_response,
+ uint32_t timeout, ppp_at_response_t *response);
+
+/**
+ * @brief 测试AT连接
+ * @return 错误码
+ */
+ppp_error_t ppp_at_test_connection(void);
+
+/**
+ * @brief 设置波特率
+ * @param baudrate 波特率
+ * @return 错误码
+ */
+ppp_error_t ppp_at_set_baudrate(uint32_t baudrate);
+
+/**
+ * @brief 自动检测波特率
+ * @return 错误码
+ */
+ppp_error_t ppp_at_auto_detect_baudrate(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PPP_AT_HANDLER_H */
\ No newline at end of file
--- /dev/null
+/*
+ * @brief PPP模块的cat1 API兼容接口声明
+ * @description 提供与cat1Service相同的接口声明，让UI和其他服务无需修改
+ * Copyright (c) CompanyNameMagicTag 2024-2024. All rights reserved.
+ */
+
+#ifndef __PPP_CAT1_API_H
+#define __PPP_CAT1_API_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "errcode.h"
+#include "platform_core.h"
+
+// 前向声明，避免重复定义
+typedef enum _4g_cmd CMD_4G_T;
+typedef struct ctl_pin_4g_s ctl_pin_4g_t;
+typedef struct time_ctl_funcs_s time_ctl_funcs_t;
+typedef errcode_t (*f_cat1_msg_callback)(int msg, void *msg_buf, uint16_t msglen);
+
+/********************** 主要接口 **********************/
+
+/**
+ * @brief cat1 服务初始化
+ * @return 成功 ERRCODE_SUCC 或者其他失败ERRCODE
+ */
+errcode_t cat1_server_init(void);
+
+/**
+ * @brief cat1 开关机设置, 输入 true 开机, false 关机
+ */
+void cat1_api_enable_cat1(bool isopen);
+
+/**
+ * @brief 获取cat1是否使能(开机)状态
+ */
+bool cat1_api_is_cat1_enabled(void);
+
+/**
+ * @brief 串口接收函数,加入到uart_porting 中断处理中
+ */
+void cat1_uart_receive_handler(uint8_t *buffer, int32_t size);
+
+/**
+ * @brief return cmd uart rx enable flag
+ */
+bool cat1_api_custom_is_cmd_rx_enabled(void);
+
+/********************** 运行时状态获取接口 **********************/
+
+/**
+ * @brief 获取cat1电源开启状态
+ * @return 1 开机，0 关机
+ */
+uint8_t cat1_api_runtime_get_cat1_powerstat(void);
+
+/**
+ * @brief 获取cat1网络状态
+ * @return 1 网络在线，0 断网
+ */
+uint8_t cat1_api_runtime_get_cat1_networkstat(void);
+
+/**
+ * @brief 获取cat1信号强度
+ * @return 1~31 或者 99，99代表无网络
+ */
+int cat1_api_runtime_get_cat1_signal(void);
+
+/**
+ * @brief 获取sim卡状态
+ * @return 1 有sim卡，0 无sim卡
+ */
+int cat1_api_runtime_get_cat1_simstat(void);
+
+/**
+ * @brief 获取网络类型
+ * @return 0 "无网络", 1 "GSM", 2 "3G", 4 "4G/LTE"
+ */
+uint8_t cat1_api_runtime_get_cat1_networktype(void);
+
+/**
+ * @brief 获取Cat1运营商信息
+ * @return 返回运营商字符串
+ */
+char* cat1_api_runtime_get_cat1_operator(void);
+
+/**
+ * @brief 获取Cat1 IMEI号
+ * @return 返回imei字符串
+ */
+char* cat1_api_runtime_get_cat1_imei(void);
+
+/**
+ * @brief 获取Cat1主应用版本号
+ * @return 返回主应用版本号
+ */
+char* cat1_api_runtime_get_cat1_pyver(void);
+
+/**
+ * @brief 获取modem版本
+ * @return modem版本字符串
+ */
+char* cat1_api_runtime_get_cat1_modemver(void);
+
+/********************** 运行时状态设置接口 **********************/
+
+/**
+ * @brief 设置cat1电源状态
+ */
+void cat1_api_runtime_set_cat1_powerstat(uint8_t cat1_powerOn);
+
+/**
+ * @brief 设置cat1网络状态
+ */
+void cat1_api_runtime_set_cat1_networkstat(uint8_t network_on);
+
+/**
+ * @brief 设置cat1信号强度
+ */
+void cat1_api_runtime_set_cat1_signal(int signal);
+
+/**
+ * @brief 设置sim卡状态
+ */
+void cat1_api_runtime_set_cat1_simstat(int simstat);
+
+/**
+ * @brief 设置网络类型
+ */
+void cat1_api_runtime_set_cat1_networktype(uint8_t networktype);
+
+/**
+ * @brief 设置Cat1运营商信息
+ */
+void cat1_api_runtime_set_cat1_operator(char* cat1_operator);
+
+/**
+ * @brief 设置Cat1 IMEI号
+ */
+void cat1_api_runtime_set_cat1_imei(char* imei);
+
+/**
+ * @brief 设置Cat1主应用版本号
+ */
+void cat1_api_runtime_set_cat1_pyver(char* pyver);
+
+/**
+ * @brief 设置modem版本
+ */
+void cat1_api_runtime_set_cat1_modemver(char* modemver);
+
+/********************** 控制接口 **********************/
+
+/**
+ * @brief 唤醒Cat1
+ */
+void cat1_api_wakeup_cat1(uint8_t wakeup);
+
+/**
+ * @brief 保持唤醒Cat1
+ */
+void cat1_api_keep_wakeup(uint8_t keep_wakeup);
+
+/**
+ * @brief 注册控制4G的gpio值
+ */
+errcode_t cat1_register_ctl_pin(ctl_pin_4g_t ctl_pin);
+
+/**
+ * @brief cat1唤醒蓝牙中断处理函数
+ */
+void cat1_ring_isr_callback(pin_t pin, uintptr_t param);
+
+/********************** 其他接口 **********************/
+
+/**
+ * @brief 发送指令给Cat1
+ */
+errcode_t cat1_cmd_send(CMD_4G_T cmd, void *cmd_buf, uint16_t cmdlen);
+
+/**
+ * @brief 注册消息回调函数
+ */
+errcode_t cat1_register_msg_callback(f_cat1_msg_callback func);
+
+/**
+ * @brief 注册时间控制函数
+ */
+errcode_t cat1_register_time_ctl_functions(time_ctl_funcs_t *funcs);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __PPP_CAT1_API_H */
\ No newline at end of file
--- /dev/null
+#ifndef PPP_CONFIG_H
+#define PPP_CONFIG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/* PPP配置参数 - UART配置统一使用SIO (在lwipopts_default.h中定义) */
+
+/* 支持的波特率列表（自适应模式） */
+#define PPP_BAUDRATE_AUTO_LIST {9600, 57600, 115200}
+#define PPP_BAUDRATE_AUTO_COUNT 3
+
+/* 支持的固定波特率列表 */
+#define PPP_BAUDRATE_FIXED_LIST {4800, 9600, 57600, 115200, 230400, 460800, 750000, 921600, 1000000, 2000000, 4000000}
+#define PPP_BAUDRATE_FIXED_COUNT 11
+
+/* AT命令配置 */
+#define PPP_AT_CMD_TIMEOUT 5000 // AT命令超时时间(ms)
+#define PPP_AT_CMD_MAX_LEN 256 // AT命令最大长度
+#define PPP_AT_RESPONSE_MAX_LEN 1024 // AT响应最大长度
+#define PPP_AT_RETRY_COUNT 3 // AT命令重试次数
+
+/* PPP拨号配置 */
+#define PPP_DIAL_TIMEOUT 30000 // 拨号超时时间(ms)
+#define PPP_DIAL_RETRY_COUNT 3 // 拨号重试次数
+#define PPP_KEEPALIVE_INTERVAL 30 // 保活间隔(秒)
+
+/* 缓冲区大小配置 */
+#define PPP_RX_BUFFER_SIZE 2048 // 接收缓冲区大小
+#define PPP_TX_BUFFER_SIZE 1024 // 发送缓冲区大小
+
+/* PPP网络配置 */
+#define PPP_MTU_SIZE 1500 // PPP MTU大小
+#define PPP_MRU_SIZE 1500 // PPP MRU大小
+
+/* 调试配置 */
+#define PPP_DEBUG_ENABLE 1 // 启用调试输出
+#define PPP_DEBUG_LEVEL 3 // 调试级别 (0-4)
+
+/* PPP状态定义 */
+typedef enum {
+ PPP_STATE_IDLE = 0, // 空闲状态
+ PPP_STATE_INITIALIZED, // 已初始化状态
+ PPP_STATE_INIT, // 初始化状态
+ PPP_STATE_AT_HANDSHAKE, // AT握手状态
+ PPP_STATE_SET_BAUDRATE, // 设置波特率状态
+ PPP_STATE_DIALING, // 拨号状态
+ PPP_STATE_CONNECTED, // 已连接状态
+ PPP_STATE_DISCONNECTING, // 断开连接状态
+ PPP_STATE_ERROR // 错误状态
+} ppp_state_t;
+
+/* PPP错误码定义 */
+typedef enum {
+ PPP_ERR_OK = 0, // 成功
+ PPP_ERR_TIMEOUT, // 超时
+ PPP_ERR_AT_FAILED, // AT命令失败
+ PPP_ERR_DIAL_FAILED, // 拨号失败
+ PPP_ERR_NO_CARRIER, // 无载波
+ PPP_ERR_BUSY, // 忙
+ PPP_ERR_NO_DIALTONE, // 无拨号音
+ PPP_ERR_INVALID_PARAM, // 无效参数
+ PPP_ERR_MEMORY, // 内存错误
+ PPP_ERR_UART, // 串口错误
+ PPP_ERR_UNKNOWN // 未知错误
+} ppp_error_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PPP_CONFIG_H */
\ No newline at end of file
--- /dev/null
+#ifndef PPP_DEBUG_H
+#define PPP_DEBUG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include "ppp_config.h"
+#include "debug_print.h"
+
+/* 调试级别定义 */
+#define PPP_DEBUG_LEVEL_NONE 0
+#define PPP_DEBUG_LEVEL_ERROR 1
+#define PPP_DEBUG_LEVEL_WARN 2
+#define PPP_DEBUG_LEVEL_INFO 3
+#define PPP_DEBUG_LEVEL_DEBUG 4
+
+#if PPP_DEBUG_ENABLE
+
+#define PPP_DEBUG_ERROR(fmt, ...) \
+ do { \
+ if (PPP_DEBUG_LEVEL >= PPP_DEBUG_LEVEL_ERROR) { \
+ PRINT("[PPP ERROR] " fmt "\r\n", ##__VA_ARGS__); \
+ } \
+ } while(0)
+
+#define PPP_DEBUG_WARN(fmt, ...) \
+ do { \
+ if (PPP_DEBUG_LEVEL >= PPP_DEBUG_LEVEL_WARN) { \
+ PRINT("[PPP WARN] " fmt "\r\n", ##__VA_ARGS__); \
+ } \
+ } while(0)
+
+#define PPP_DEBUG_INFO(fmt, ...) \
+ do { \
+ if (PPP_DEBUG_LEVEL >= PPP_DEBUG_LEVEL_INFO) { \
+ PRINT("[PPP INFO] " fmt "\r\n", ##__VA_ARGS__); \
+ } \
+ } while(0)
+
+#define PPP_DEBUG_DEBUG(fmt, ...) \
+ do { \
+ if (PPP_DEBUG_LEVEL >= PPP_DEBUG_LEVEL_DEBUG) { \
+ PRINT("[PPP DEBUG] " fmt "\r\n", ##__VA_ARGS__); \
+ } \
+ } while(0)
+
+#define PPP_DEBUG_HEXDUMP(data, len) \
+ do { \
+ if (PPP_DEBUG_LEVEL >= PPP_DEBUG_LEVEL_DEBUG) { \
+ ppp_debug_hexdump(data, len); \
+ } \
+ } while(0)
+
+/* 兼容性宏 - 用于旧代码 */
+#define PPP_DEBUG_PRINT(fmt, ...) PPP_DEBUG_INFO(fmt, ##__VA_ARGS__)
+
+#else
+
+#define PPP_DEBUG_ERROR(fmt, ...)
+#define PPP_DEBUG_WARN(fmt, ...)
+#define PPP_DEBUG_INFO(fmt, ...)
+#define PPP_DEBUG_DEBUG(fmt, ...)
+#define PPP_DEBUG_HEXDUMP(data, len)
+#define PPP_DEBUG_PRINT(fmt, ...)
+
+#endif /* PPP_DEBUG_ENABLE */
+
+/**
+ * @brief 十六进制数据转储
+ * @param data 数据指针
+ * @param len 数据长度
+ */
+void ppp_debug_hexdump(const uint8_t *data, uint32_t len);
+
+/**
+ * @brief 获取错误码字符串
+ * @param error_code 错误码
+ * @return 错误码字符串
+ */
+const char *ppp_debug_error_string(ppp_error_t error_code);
+
+/**
+ * @brief 获取状态字符串
+ * @param state PPP状态
+ * @return 状态字符串
+ */
+const char *ppp_debug_state_string(ppp_state_t state);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PPP_DEBUG_H */
\ No newline at end of file
--- /dev/null
+#ifndef PPP_LWIP_H
+#define PPP_LWIP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "ppp_types.h"
+
+/* 前向声明 */
+struct netif;
+
+/* PPP lwIP事件类型 */
+typedef enum {
+ PPP_LWIP_EVENT_CONNECTED = 0, // 连接成功
+ PPP_LWIP_EVENT_DISCONNECTED, // 连接断开
+ PPP_LWIP_EVENT_ERROR, // 发生错误
+ PPP_LWIP_EVENT_STATUS_CHANGE, // 状态变化
+ PPP_LWIP_EVENT_IP_ACQUIRED, // 获取到IP地址
+ PPP_LWIP_EVENT_DNS_ACQUIRED // 获取到DNS地址
+} ppp_lwip_event_type_t;
+
+/* PPP lwIP事件结构 */
+typedef struct {
+ ppp_lwip_event_type_t type; // 事件类型
+ int error_code; // 错误码
+ void *data; // 事件数据
+ uint32_t data_len; // 数据长度
+} ppp_lwip_event_t;
+
+/* PPP lwIP事件回调函数类型 */
+typedef void (*ppp_lwip_event_callback_t)(const ppp_lwip_event_t *event, void *arg);
+
+/* PPP lwIP配置结构 */
+typedef struct {
+ const char *username; // 用户名
+ const char *password; // 密码
+ ppp_lwip_event_callback_t event_callback; // 事件回调函数
+ void *event_callback_arg; // 回调函数参数
+} ppp_lwip_config_t;
+
+/* PPP lwIP网络信息结构 */
+typedef struct {
+ bool connected; // 连接状态
+ uint32_t local_ip; // 本地IP地址
+ uint32_t remote_ip; // 远程IP地址
+ uint32_t primary_dns; // 主DNS服务器
+ uint32_t secondary_dns; // 辅DNS服务器
+ uint16_t mtu; // MTU大小
+} ppp_lwip_network_info_t;
+
+/**
+ * @brief 初始化PPP lwIP集成
+ * @param config 配置参数
+ * @return PPP错误码
+ */
+ppp_error_t ppp_lwip_init(const ppp_lwip_config_t *config);
+
+/**
+ * @brief 反初始化PPP lwIP集成
+ */
+void ppp_lwip_deinit(void);
+
+/**
+ * @brief 连接PPP
+ * @return PPP错误码
+ */
+ppp_error_t ppp_lwip_connect(void);
+
+/**
+ * @brief 断开PPP连接
+ * @return PPP错误码
+ */
+ppp_error_t ppp_lwip_disconnect(void);
+
+/**
+ * @brief 输入PPP数据
+ * @param data 数据指针
+ * @param length 数据长度
+ * @return PPP错误码
+ */
+ppp_error_t ppp_lwip_input(const uint8_t *data, uint32_t length);
+
+/**
+ * @brief 获取PPP连接状态
+ * @return true表示已连接，false表示未连接
+ */
+bool ppp_lwip_is_connected(void);
+
+/**
+ * @brief 获取网络信息
+ * @param info 网络信息结构指针
+ * @return PPP错误码
+ */
+ppp_error_t ppp_lwip_get_network_info(ppp_lwip_network_info_t *info);
+
+/**
+ * @brief 获取网络接口指针
+ * @return 网络接口指针
+ */
+struct netif *ppp_lwip_get_netif(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PPP_LWIP_H */
\ No newline at end of file
--- /dev/null
+/*
+ * @brief PPP模块电源控制接口
+ * @description 提供PPP模块专用的4G电源控制功能，与SLIP模块互斥使用
+ * Copyright (c) CompanyNameMagicTag 2024-2024. All rights reserved.
+ */
+
+#ifndef __PPP_POWER_CTL_H
+#define __PPP_POWER_CTL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "platform_core.h"
+#include "errcode.h"
+
+/**
+ * @brief PPP模块4G电源控制引脚配置结构体
+ */
+typedef struct {
+ pin_t bat_pin; // 控制Cat1 battery 的gpio，没有控制，设置为 PIN_NONE 即可
+ uint8_t bat_pin_en_value; // battery引脚使能值
+ pin_t pwr_pin; // 控制cat1开机键的gpio
+ uint8_t pwr_pin_en_value; // 电源引脚使能值
+ pin_t reset_pin; // 控制cat1重置键的gpio
+ uint8_t reset_pin_en_value; // 复位引脚使能值
+ pin_t ring_pin; // cat1唤醒蓝牙用的gpio
+ uint8_t ring_pin_en_value; // 唤醒引脚使能值
+ pin_t wakemodem_pin; // 蓝牙唤醒cat1用的gpio
+ uint8_t wakemodem_pin_en_value; // 唤醒modem引脚使能值
+} ppp_ctl_pin_4g_t;
+
+/**
+ * @brief PPP模块GPIO初始化
+ */
+void ppp_api_gpio_init(void);
+
+/**
+ * @brief PPP模块UART初始化
+ */
+void ppp_api_uart_init(void);
+
+/**
+ * @brief PPP模块设置电源引脚状态
+ * @param pwron 1-开启电源，0-关闭电源
+ * @return 0-成功，其他-失败
+ */
+uint32_t ppp_api_cat1_power_on(uint32_t pwron);
+
+/**
+ * @brief PPP模块设置复位引脚状态
+ * @param pwron 1-复位，0-释放复位
+ * @return 0-成功，其他-失败
+ */
+uint32_t ppp_api_cat1_reset(uint32_t pwron);
+
+/**
+ * @brief PPP模块设置电池引脚状态
+ * @param pwron 1-开启电池，0-关闭电池
+ * @return 0-成功，其他-失败
+ */
+uint32_t ppp_api_cat1_bat_on(uint32_t pwron);
+
+/**
+ * @brief PPP模块4G上电序列
+ */
+void ppp_power_on_cat1(void);
+
+/**
+ * @brief PPP模块4G下电序列
+ */
+void ppp_power_off_cat1(void);
+
+/**
+ * @brief PPP模块检查4G是否使能
+ * @return true-已使能，false-未使能
+ */
+bool ppp_api_is_cat1_enabled(void);
+
+/**
+ * @brief PPP模块唤醒Cat1
+ * @param wakeup 1-唤醒，0-不唤醒
+ */
+void ppp_api_wakeup_cat1(uint8_t wakeup);
+
+/**
+ * @brief PPP模块保持唤醒Cat1
+ * @param keep_wakeup 1-保持唤醒，0-允许休眠
+ */
+void ppp_api_keep_wakeup(uint8_t keep_wakeup);
+
+/**
+ * @brief PPP模块挂起
+ */
+void ppp_suspend(void);
+
+/**
+ * @brief PPP模块恢复
+ */
+void ppp_resume(void);
+
+/**
+ * @brief PPP模块注册4G控制引脚配置
+ * @param ctl_pin 引脚配置结构体指针
+ * @return ERRCODE_SUCC-成功，其他-失败
+ */
+errcode_t ppp_register_ctl_pin(ppp_ctl_pin_4g_t *ctl_pin);
+
+/**
+ * @brief PPP模块Cat1唤醒中断回调函数
+ * @param pin 中断引脚
+ * @param param 参数
+ */
+void ppp_ring_isr_callback(pin_t pin, uintptr_t param);
+
+/**
+ * @brief PPP模块专用的4G使能控制接口
+ * @param isopen true-开启4G，false-关闭4G
+ * @note 此接口与SLIP模块互斥，只能有一个模块控制4G电源
+ */
+void ppp_api_enable_cat1(bool isopen);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __PPP_POWER_CTL_H */
\ No newline at end of file
--- /dev/null
+#ifndef PPP_SERIAL_H
+#define PPP_SERIAL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "ppp_types.h"
+
+/* 串口接收回调函数类型 */
+typedef void (*ppp_serial_rx_callback_t)(const uint8_t *data, uint16_t length, void *arg);
+
+/* 串口配置结构 */
+typedef struct {
+ uint8_t uart_bus; // 串口总线号
+ uint32_t baudrate; // 波特率
+ uint8_t tx_pin; // TX引脚
+ uint8_t rx_pin; // RX引脚
+ uint32_t rx_buffer_size; // 接收缓冲区大小
+ uint32_t tx_buffer_size; // 发送缓冲区大小
+ ppp_serial_rx_callback_t rx_callback; // 接收回调函数
+ void *rx_callback_arg; // 回调函数参数
+} ppp_serial_config_t;
+
+/* 串口统计信息结构 */
+typedef struct {
+ uint32_t tx_bytes; // 发送字节数
+ uint32_t rx_bytes; // 接收字节数
+ uint32_t tx_errors; // 发送错误数
+ uint32_t rx_errors; // 接收错误数
+ uint32_t rx_buffer_usage; // 接收缓冲区使用量
+ uint32_t rx_buffer_size; // 接收缓冲区大小
+} ppp_serial_stats_t;
+
+/**
+ * @brief 初始化PPP串口
+ * @param config 串口配置
+ * @return PPP错误码
+ */
+ppp_error_t ppp_serial_init(const ppp_serial_config_t *config);
+
+/**
+ * @brief 反初始化PPP串口
+ */
+void ppp_serial_deinit(void);
+
+/**
+ * @brief 发送数据
+ * @param data 数据指针
+ * @param length 数据长度
+ * @return PPP错误码
+ */
+ppp_error_t ppp_serial_write(const uint8_t *data, uint32_t length);
+
+/**
+ * @brief 读取数据
+ * @param buffer 接收缓冲区
+ * @param buffer_size 缓冲区大小
+ * @param bytes_read 实际读取的字节数
+ * @return PPP错误码
+ */
+ppp_error_t ppp_serial_read(uint8_t *buffer, uint32_t buffer_size, uint32_t *bytes_read);
+
+/**
+ * @brief 等待数据接收
+ * @param timeout_ms 超时时间(毫秒)
+ * @return PPP错误码
+ */
+ppp_error_t ppp_serial_wait_data(uint32_t timeout_ms);
+
+/**
+ * @brief 获取可读数据长度
+ * @return 可读数据长度
+ */
+uint32_t ppp_serial_available(void);
+
+/**
+ * @brief 清空接收缓冲区
+ */
+void ppp_serial_flush_rx(void);
+
+/**
+ * @brief 设置串口波特率
+ * @param baudrate 波特率
+ * @return PPP错误码
+ */
+ppp_error_t ppp_serial_set_baudrate(uint32_t baudrate);
+
+/**
+ * @brief 获取统计信息
+ * @param stats 统计信息结构指针
+ */
+void ppp_serial_get_stats(ppp_serial_stats_t *stats);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PPP_SERIAL_H */
\ No newline at end of file
--- /dev/null
+#ifndef PPP_TYPES_H
+#define PPP_TYPES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "ppp_config.h"
+
+/* 前向声明，避免直接包含lwIP头文件 */
+struct netif;
+struct ip4_addr;
+
+/* PPP配置结构（简化版，用于新API） */
+typedef struct {
+ char apn[64]; // APN接入点名称
+ char username[32]; // 用户名
+ char password[32]; // 密码
+ uint32_t baudrate; // 串口波特率
+ bool auto_baudrate; // 是否自动波特率检测
+ uint32_t dial_timeout; // 拨号超时时间(ms)
+ uint8_t retry_count; // 重试次数
+} ppp_config_t;
+
+/* PPP连接信息结构（简化版，用于新API） */
+typedef struct {
+ uint32_t local_ip; // 本地IP地址
+ uint32_t remote_ip; // 远程IP地址
+ uint32_t primary_dns; // 主DNS服务器
+ uint32_t secondary_dns; // 辅DNS服务器
+ uint16_t mtu; // MTU大小
+ bool connected; // 连接状态
+ uint32_t connect_time; // 连接时间(秒)
+} ppp_connection_info_t;
+
+/* PPP拨号参数结构（原有的，保持兼容性） */
+typedef struct {
+ char apn[64]; // APN接入点名称
+ char username[32]; // 用户名
+ char password[32]; // 密码
+ uint32_t baudrate; // 串口波特率
+ bool auto_baudrate; // 是否自动波特率检测
+ uint32_t dial_timeout; // 拨号超时时间(ms)
+ uint8_t retry_count; // 重试次数
+} ppp_dial_config_t;
+
+/* PPP网络信息结构 */
+typedef struct {
+ uint32_t local_ip; // 本地IP地址
+ uint32_t remote_ip; // 远程IP地址
+ uint32_t primary_dns; // 主DNS服务器
+ uint32_t secondary_dns; // 辅DNS服务器
+ uint32_t netmask; // 子网掩码
+ uint32_t gateway; // 网关地址
+ uint16_t mtu; // MTU大小
+ bool connected; // 连接状态
+} ppp_network_info_t;
+
+/* PPP统计信息结构 */
+typedef struct {
+ uint32_t tx_packets; // 发送包数
+ uint32_t rx_packets; // 接收包数
+ uint32_t tx_bytes; // 发送字节数
+ uint32_t rx_bytes; // 接收字节数
+ uint32_t tx_errors; // 发送错误数
+ uint32_t rx_errors; // 接收错误数
+ uint32_t connect_time; // 连接时间(秒)
+ uint32_t last_activity; // 最后活动时间戳
+} ppp_stats_t;
+
+/* PPP事件类型 */
+typedef enum {
+ PPP_EVENT_CONNECTED = 0, // 连接成功
+ PPP_EVENT_DISCONNECTED, // 连接断开
+ PPP_EVENT_ERROR, // 发生错误
+ PPP_EVENT_IP_ACQUIRED, // 获取到IP地址
+ PPP_EVENT_DNS_ACQUIRED, // 获取到DNS地址
+ PPP_EVENT_AT_RESPONSE, // AT命令响应
+ PPP_EVENT_DATA_RECEIVED // 接收到数据
+} ppp_event_type_t;
+
+/* PPP事件数据结构 */
+typedef struct {
+ ppp_event_type_t type; // 事件类型
+ ppp_error_t error_code; // 错误码
+ void *data; // 事件数据
+ uint32_t data_len; // 数据长度
+} ppp_event_t;
+
+/* PPP事件回调函数类型 */
+typedef void (*ppp_event_callback_t)(const ppp_event_t *event);
+
+/* PPP状态枚举 - 定义在ppp_config.h中 */
+
+/* PPP控制块结构 */
+typedef struct {
+ ppp_state_t state; // 当前状态
+ ppp_dial_config_t config; // 拨号配置
+ ppp_network_info_t network; // 网络信息
+ ppp_stats_t stats; // 统计信息
+
+ /* lwIP相关 */
+ struct netif *netif; // 网络接口指针
+ void *ppp_pcb; // PPP控制块
+
+ /* 串口相关 */
+ uint8_t uart_bus; // 串口总线
+ uint8_t *rx_buffer; // 接收缓冲区
+ uint8_t *tx_buffer; // 发送缓冲区
+ uint32_t rx_buffer_size; // 接收缓冲区大小
+ uint32_t tx_buffer_size; // 发送缓冲区大小
+
+ /* 同步相关 */
+ void *mutex; // 互斥锁
+ void *semaphore; // 信号量
+ void *task_handle; // 任务句柄
+
+ /* 回调函数 */
+ ppp_event_callback_t event_callback; // 事件回调函数
+
+ /* 内部状态 */
+ uint32_t last_at_time; // 最后AT命令时间
+ uint32_t connect_start_time; // 连接开始时间
+ bool initialized; // 初始化标志
+ bool running; // 运行标志
+} ppp_context_t;
+
+/* AT命令结构 */
+typedef struct {
+ char command[PPP_AT_CMD_MAX_LEN]; // AT命令
+ char expected_response[64]; // 期望响应
+ uint32_t timeout; // 超时时间(ms)
+ uint8_t retry_count; // 重试次数
+} ppp_at_cmd_t;
+
+/* AT响应结构 */
+typedef struct {
+ char response[PPP_AT_RESPONSE_MAX_LEN]; // 响应内容
+ uint32_t length; // 响应长度
+ bool success; // 是否成功
+ ppp_error_t error_code; // 错误码
+} ppp_at_response_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PPP_TYPES_H */
\ No newline at end of file
--- /dev/null
+#include "ppp_api.h"
+#include "ppp_debug.h"
+#include "ppp_power_ctl.h"
+#include "osal_debug.h"
+#include "schedule/osal_task.h"
+#include "securec.h"
+
+// PPP连接状态
+static ppp_state_t g_ppp_state = PPP_STATE_IDLE;
+
+// PPP配置参数
+static ppp_config_t g_ppp_config = {0};
+
+// 外部声明cat1_api_enable_cat1函数（在ppp_cat1_api.c中实现）
+extern void cat1_api_enable_cat1(bool isopen);
+
+/**
+ * @brief 初始化PPP模块
+ */
+errcode_t ppp_init(const ppp_config_t *config)
+{
+ if (config == NULL) {
+ PPP_DEBUG_PRINT("PPP init: invalid config parameter\n");
+ return ERRCODE_INVALID_PARAM;
+ }
+
+ // 复制配置参数
+ (void)memcpy_s(&g_ppp_config, sizeof(ppp_config_t),
+ config, sizeof(ppp_config_t));
+
+ // 初始化电源控制
+ ppp_api_gpio_init();
+ ppp_api_uart_init();
+
+ g_ppp_state = PPP_STATE_INITIALIZED;
+ PPP_DEBUG_PRINT("PPP module initialized successfully\n");
+
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief 启动PPP拨号
+ */
+errcode_t ppp_start_dial(void)
+{
+ if (g_ppp_state != PPP_STATE_INITIALIZED) {
+ PPP_DEBUG_PRINT("PPP start dial: module not initialized\n");
+ return ERRCODE_FAIL;
+ }
+
+ PPP_DEBUG_PRINT("Starting PPP dial sequence\n");
+
+ // 1. 启动4G电源（通过兼容接口）
+ cat1_api_enable_cat1(true);
+
+ // 2. 等待4G模块启动
+ osal_msleep(2000);
+
+ // 3. 初始化AT命令处理
+ // TODO: 实现AT命令初始化
+
+ // 4. 启动PPP协议栈
+ // TODO: 实现PPP协议栈启动
+
+ g_ppp_state = PPP_STATE_DIALING;
+ PPP_DEBUG_PRINT("PPP dial started\n");
+
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief 停止PPP连接
+ */
+errcode_t ppp_stop_dial(void)
+{
+ PPP_DEBUG_PRINT("Stopping PPP connection\n");
+
+ // 1. 停止PPP协议栈
+ // TODO: 实现PPP协议栈停止
+
+ // 2. 关闭4G电源（通过兼容接口）
+ cat1_api_enable_cat1(false);
+
+ g_ppp_state = PPP_STATE_IDLE;
+ PPP_DEBUG_PRINT("PPP connection stopped\n");
+
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief 获取PPP连接状态
+ */
+ppp_state_t ppp_get_state(void)
+{
+ return g_ppp_state;
+}
+
+/**
+ * @brief 注册PPP事件回调函数
+ */
+errcode_t ppp_register_event_callback(ppp_event_callback_t callback)
+{
+ if (callback == NULL) {
+ PPP_DEBUG_PRINT("PPP register callback: invalid parameter\n");
+ return ERRCODE_INVALID_PARAM;
+ }
+
+ // TODO: 实现事件回调注册
+ PPP_DEBUG_PRINT("PPP event callback registered\n");
+
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief 获取PPP连接信息
+ */
+errcode_t ppp_get_connection_info(ppp_connection_info_t *info)
+{
+ if (info == NULL) {
+ PPP_DEBUG_PRINT("PPP get connection info: invalid parameter\n");
+ return ERRCODE_INVALID_PARAM;
+ }
+
+ // TODO: 实现连接信息获取
+ (void)memset_s(info, sizeof(ppp_connection_info_t), 0, sizeof(ppp_connection_info_t));
+
+ PPP_DEBUG_PRINT("PPP connection info retrieved\n");
+
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief PPP模块去初始化
+ */
+errcode_t ppp_deinit(void)
+{
+ // 停止连接
+ if (g_ppp_state != PPP_STATE_IDLE) {
+ ppp_stop_dial();
+ }
+
+ // 清理资源
+ (void)memset_s(&g_ppp_config, sizeof(ppp_config_t), 0, sizeof(ppp_config_t));
+
+ g_ppp_state = PPP_STATE_IDLE;
+ PPP_DEBUG_PRINT("PPP module deinitialized\n");
+
+ return ERRCODE_SUCC;
+}
\ No newline at end of file
--- /dev/null
+#include "ppp_at_handler.h"
+#include "ppp_config.h"
+#include "ppp_types.h"
+#include "ppp_debug.h"
+#include "uart.h"
+#include "lwip/opt.h"
+#include "schedule/osal_task.h"
+#include "time/osal_timer.h"
+#include "lock/osal_mutex.h"
+#include "soc_osal.h"
+#include "securec.h"
+#include <string.h>
+#include <stdio.h>
+
+/* AT命令处理上下文 */
+static struct {
+ bool initialized;
+ uint8_t uart_bus;
+ uint32_t current_baudrate;
+ bool auto_baudrate_mode;
+ ppp_at_response_t last_response;
+ osal_timer *at_timer;
+ osal_mutex *at_mutex;
+} g_at_ctx = {0};
+
+/* 支持的波特率列表 */
+static const uint32_t g_auto_baudrates[] = PPP_BAUDRATE_AUTO_LIST;
+static const uint32_t g_fixed_baudrates[] = PPP_BAUDRATE_FIXED_LIST;
+
+/* AT命令响应解析 */
+static bool ppp_at_parse_response(const char *response, const char *expected);
+static ppp_error_t ppp_at_wait_response(ppp_at_response_t *response, uint32_t timeout);
+static void ppp_at_timeout_handler(void *arg);
+
+/**
+ * @brief 初始化AT命令处理模块
+ */
+ppp_error_t ppp_at_handler_init(uint8_t uart_bus)
+{
+ if (g_at_ctx.initialized) {
+ PPP_DEBUG_WARN("AT handler already initialized");
+ return PPP_ERR_OK;
+ }
+
+ g_at_ctx.uart_bus = uart_bus;
+ g_at_ctx.current_baudrate = SIO_UART_BAUDRATE;
+ g_at_ctx.auto_baudrate_mode = true;
+
+ /* 创建互斥锁 */
+ if (osal_mutex_init(&g_at_ctx.at_mutex) != OSAL_SUCCESS) {
+ PPP_DEBUG_ERROR("Failed to create AT mutex");
+ return PPP_ERR_MEMORY;
+ }
+
+ /* 创建定时器 */
+ if (osal_timer_create(&g_at_ctx.at_timer, ppp_at_timeout_handler, NULL) != OSAL_SUCCESS) {
+ PPP_DEBUG_ERROR("Failed to create AT timer");
+ osal_mutex_destroy(g_at_ctx.at_mutex);
+ return PPP_ERR_MEMORY;
+ }
+
+ g_at_ctx.initialized = true;
+ PPP_DEBUG_INFO("AT handler initialized on UART%d", uart_bus);
+
+ return PPP_ERR_OK;
+}
+
+/**
+ * @brief 反初始化AT命令处理模块
+ */
+void ppp_at_handler_deinit(void)
+{
+ if (!g_at_ctx.initialized) {
+ return;
+ }
+
+ if (g_at_ctx.at_timer) {
+ osal_timer_destroy(g_at_ctx.at_timer);
+ g_at_ctx.at_timer = NULL;
+ }
+
+ if (g_at_ctx.at_mutex) {
+ osal_mutex_destroy(g_at_ctx.at_mutex);
+ g_at_ctx.at_mutex = NULL;
+ }
+
+ memset_s(&g_at_ctx, sizeof(g_at_ctx), 0, sizeof(g_at_ctx));
+ PPP_DEBUG_INFO("AT handler deinitialized");
+}
+
+/**
+ * @brief 执行波特率自适应握手
+ */
+ppp_error_t ppp_at_baudrate_handshake(void)
+{
+ if (!g_at_ctx.initialized) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ PPP_DEBUG_INFO("Starting baudrate handshake");
+
+ /* 尝试自适应波特率列表 */
+ for (int i = 0; i < PPP_BAUDRATE_AUTO_COUNT; i++) {
+ uint32_t baudrate = g_auto_baudrates[i];
+
+ PPP_DEBUG_DEBUG("Trying baudrate: %u", baudrate);
+
+ /* 配置串口波特率 */
+ uart_attr_t uart_attr = {
+ .baud_rate = baudrate,
+ .data_bits = UART_DATA_BIT_8,
+ .parity = UART_PARITY_NONE,
+ .stop_bits = UART_STOP_BIT_1,
+ };
+
+ if (uapi_uart_set_attr(g_at_ctx.uart_bus, &uart_attr) != ERRCODE_SUCC) {
+ PPP_DEBUG_WARN("Failed to set baudrate %u", baudrate);
+ continue;
+ }
+
+ /* 发送AT命令测试 */
+ ppp_at_response_t response;
+ ppp_error_t ret = ppp_at_send_command("AT", "OK", 1000, &response);
+
+ if (ret == PPP_ERR_OK) {
+ g_at_ctx.current_baudrate = baudrate;
+ PPP_DEBUG_INFO("Baudrate handshake successful at %u", baudrate);
+ return PPP_ERR_OK;
+ }
+
+ osal_msleep(100); // 短暂延时后尝试下一个波特率
+ }
+
+ PPP_DEBUG_ERROR("Baudrate handshake failed");
+ return PPP_ERR_AT_FAILED;
+}
+
+/**
+ * @brief 设置固定波特率
+ */
+ppp_error_t ppp_at_set_baudrate(uint32_t baudrate)
+{
+ if (!g_at_ctx.initialized) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ /* 检查波特率是否支持 */
+ bool supported = false;
+ for (int i = 0; i < PPP_BAUDRATE_FIXED_COUNT; i++) {
+ if (g_fixed_baudrates[i] == baudrate) {
+ supported = true;
+ break;
+ }
+ }
+
+ if (!supported) {
+ PPP_DEBUG_ERROR("Unsupported baudrate: %u", baudrate);
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ /* 发送AT+IPR命令设置波特率 */
+ char cmd[64];
+ snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "AT+IPR=%u", baudrate);
+
+ ppp_at_response_t response;
+ ppp_error_t ret = ppp_at_send_command(cmd, "OK", PPP_AT_CMD_TIMEOUT, &response);
+
+ if (ret != PPP_ERR_OK) {
+ PPP_DEBUG_ERROR("Failed to set baudrate to %u", baudrate);
+ return ret;
+ }
+
+ /* 更新串口配置 */
+ uart_attr_t uart_attr = {
+ .baud_rate = baudrate,
+ .data_bits = UART_DATA_BIT_8,
+ .parity = UART_PARITY_NONE,
+ .stop_bits = UART_STOP_BIT_1,
+ };
+
+ if (uapi_uart_set_attr(g_at_ctx.uart_bus, &uart_attr) != ERRCODE_SUCC) {
+ PPP_DEBUG_ERROR("Failed to update UART baudrate");
+ return PPP_ERR_UART;
+ }
+
+ g_at_ctx.current_baudrate = baudrate;
+ g_at_ctx.auto_baudrate_mode = false;
+
+ PPP_DEBUG_INFO("Baudrate set to %u (fixed)", baudrate);
+ return PPP_ERR_OK;
+}
+
+/**
+ * @brief 发送AT命令
+ */
+ppp_error_t ppp_at_send_command(const char *command, const char *expected_response,
+ uint32_t timeout, ppp_at_response_t *response)
+{
+ if (!g_at_ctx.initialized || !command || !response) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ osal_mutex_lock(g_at_ctx.at_mutex);
+
+ PPP_DEBUG_DEBUG("Sending AT command: %s", command);
+
+ /* 清空响应缓冲区 */
+ memset_s(response, sizeof(ppp_at_response_t), 0, sizeof(ppp_at_response_t));
+
+ /* 发送命令 */
+ char cmd_with_crlf[PPP_AT_CMD_MAX_LEN + 4];
+ snprintf_s(cmd_with_crlf, sizeof(cmd_with_crlf), sizeof(cmd_with_crlf) - 1, "%s\r\n", command);
+
+ uint32_t cmd_len = strlen(cmd_with_crlf);
+ if (uapi_uart_write(g_at_ctx.uart_bus, (const uint8_t *)cmd_with_crlf, cmd_len, 0) != cmd_len) {
+ PPP_DEBUG_ERROR("Failed to send AT command");
+ osal_mutex_unlock(g_at_ctx.at_mutex);
+ return PPP_ERR_UART;
+ }
+
+ /* 等待响应 */
+ ppp_error_t ret = ppp_at_wait_response(response, timeout);
+
+ if (ret == PPP_ERR_OK && expected_response) {
+ if (!ppp_at_parse_response(response->response, expected_response)) {
+ PPP_DEBUG_WARN("Unexpected response: %s", response->response);
+ response->success = false;
+ response->error_code = PPP_ERR_AT_FAILED;
+ ret = PPP_ERR_AT_FAILED;
+ } else {
+ response->success = true;
+ response->error_code = PPP_ERR_OK;
+ }
+ }
+
+ osal_mutex_unlock(g_at_ctx.at_mutex);
+ return ret;
+}
+
+/**
+ * @brief 发送PPP拨号命令
+ */
+ppp_error_t ppp_at_dial_ppp(const char *dial_string)
+{
+ if (!g_at_ctx.initialized || !dial_string) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ PPP_DEBUG_INFO("Starting PPP dial: %s", dial_string);
+
+ /* 发送拨号命令 */
+ ppp_at_response_t response;
+ ppp_error_t ret = ppp_at_send_command(dial_string, "CONNECT", PPP_DIAL_TIMEOUT, &response);
+
+ if (ret != PPP_ERR_OK) {
+ PPP_DEBUG_ERROR("PPP dial failed");
+ return ret;
+ }
+
+ PPP_DEBUG_INFO("PPP dial successful, entering data mode");
+ return PPP_ERR_OK;
+}
+
+/**
+ * @brief 挂断PPP连接
+ */
+ppp_error_t ppp_at_hangup_ppp(void)
+{
+ if (!g_at_ctx.initialized) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ PPP_DEBUG_INFO("Hanging up PPP connection");
+
+ /* 发送+++切换到命令模式 */
+ osal_msleep(1000); // 等待1秒
+
+ const char *escape_seq = "+++";
+ if (uapi_uart_write(g_at_ctx.uart_bus, (const uint8_t *)escape_seq, 3, 0) != 3) {
+ PPP_DEBUG_ERROR("Failed to send escape sequence");
+ return PPP_ERR_UART;
+ }
+
+ osal_msleep(1000); // 等待1秒
+
+ /* 发送ATH挂断命令 */
+ ppp_at_response_t response;
+ ppp_error_t ret = ppp_at_send_command("ATH", "OK", PPP_AT_CMD_TIMEOUT, &response);
+
+ if (ret != PPP_ERR_OK) {
+ PPP_DEBUG_ERROR("Failed to hangup PPP connection");
+ return ret;
+ }
+
+ PPP_DEBUG_INFO("PPP connection hung up");
+ return PPP_ERR_OK;
+}
+
+/**
+ * @brief 获取当前波特率
+ */
+uint32_t ppp_at_get_current_baudrate(void)
+{
+ return g_at_ctx.current_baudrate;
+}
+
+/**
+ * @brief 检查是否为自动波特率模式
+ */
+bool ppp_at_is_auto_baudrate_mode(void)
+{
+ return g_at_ctx.auto_baudrate_mode;
+}
+
+/* 内部函数实现 */
+
+/**
+ * @brief 解析AT命令响应
+ */
+static bool ppp_at_parse_response(const char *response, const char *expected)
+{
+ if (!response || !expected) {
+ return false;
+ }
+
+ return strstr(response, expected) != NULL;
+}
+
+/**
+ * @brief 等待AT命令响应
+ */
+static ppp_error_t ppp_at_wait_response(ppp_at_response_t *response, uint32_t timeout)
+{
+ if (!response) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ /* 设置并启动超时定时器 */
+ if (osal_timer_mod(g_at_ctx.at_timer, timeout) != OSAL_SUCCESS) {
+ PPP_DEBUG_ERROR("Failed to set AT timer timeout");
+ return PPP_ERR_MEMORY;
+ }
+
+ if (osal_timer_start(g_at_ctx.at_timer) != OSAL_SUCCESS) {
+ PPP_DEBUG_ERROR("Failed to start AT timer");
+ return PPP_ERR_MEMORY;
+ }
+
+ uint32_t start_time = osal_get_tick();
+ uint32_t bytes_received = 0;
+ bool response_complete = false;
+
+ while (!response_complete && (osal_get_tick() - start_time) < timeout) {
+ uint8_t buffer[256];
+ uint32_t bytes_read = 0;
+
+ /* 读取串口数据 */
+ int32_t ret = uapi_uart_read(g_at_ctx.uart_bus, buffer, sizeof(buffer) - 1, 100);
+
+ if (ret > 0) {
+ bytes_read = (uint32_t)ret;
+ buffer[bytes_read] = '\0';
+
+ /* 追加到响应缓冲区 */
+ if (bytes_received + bytes_read < PPP_AT_RESPONSE_MAX_LEN - 1) {
+ memcpy_s(response->response + bytes_received,
+ PPP_AT_RESPONSE_MAX_LEN - bytes_received,
+ buffer, bytes_read);
+ bytes_received += bytes_read;
+ response->response[bytes_received] = '\0';
+ response->length = bytes_received;
+
+ /* 检查是否收到完整响应 */
+ if (strstr(response->response, "OK") ||
+ strstr(response->response, "ERROR") ||
+ strstr(response->response, "CONNECT") ||
+ strstr(response->response, "NO CARRIER") ||
+ strstr(response->response, "BUSY") ||
+ strstr(response->response, "NO DIALTONE")) {
+ response_complete = true;
+ }
+ } else {
+ PPP_DEBUG_WARN("AT response buffer overflow");
+ break;
+ }
+ }
+
+ osal_msleep(10); // 短暂延时
+ }
+
+ /* 停止定时器 */
+ osal_timer_stop(g_at_ctx.at_timer);
+
+ if (!response_complete) {
+ PPP_DEBUG_ERROR("AT command timeout");
+ return PPP_ERR_TIMEOUT;
+ }
+
+ PPP_DEBUG_DEBUG("AT response: %s", response->response);
+ return PPP_ERR_OK;
+}
+
+/**
+ * @brief AT命令超时处理
+ */
+static void ppp_at_timeout_handler(void *arg)
+{
+ (void)arg;
+ PPP_DEBUG_WARN("AT command timeout");
+}
\ No newline at end of file
--- /dev/null
+/*
+ * @brief PPP模块的cat1 API兼容实现
+ * @description 实现与cat1Service相同的接口，让UI和其他服务无需修改
+ * Copyright (c) CompanyNameMagicTag 2024-2024. All rights reserved.
+ */
+
+#include "ppp_power_ctl.h"
+#include "ppp_debug.h"
+#include "ppp_types.h"
+#include "errcode.h"
+#include "securec.h"
+#include "platform_core.h"
+#include <string.h>
+
+// 兼容cat1Service的类型定义
+typedef enum _4g_message {
+ MESSAGE_4G_POWERON,//无参数 （BOOTUP）
+ MESSAGE_4G_POWEROFF,//无参数
+ MESSAGE_4G_NETWORK_CONNECTED,//无参数
+ MESSAGE_4G_NETWORK_DISCONNECTED,//无参数
+ MESSAGE_4G_NETWORK_STAT_CHANGED,//含signal，sim，运营商，
+ MESSAGE_4G_CALL_COMMING,//带电话号
+ MESSAGE_4G_CALL_CONNECTED,//带电话号
+ MESSAGE_4G_CALL_DISCONNECTED,//带电话号
+ MESSAGE_4G_SMS_RECEIVED, //返回值为字符串
+ MESSAGE_4G_AT_RECEIVED, //返回值为字符串
+ MESSAGE_4G_TIME_SYNCED,//时间同步完成
+ MESSAGE_4G_VERSION_SYNCED,//版本同步完成
+ MESSAGE_4G_MAX,
+} MESSAGE_4G_T;
+
+typedef enum _4g_cmd {
+ CMD_4G_POWERON,//无参数
+ CMD_4G_POWEROFF,//无参数
+ CMD_4G_GET_SIGNAL,//无参数
+ CMD_4G_GET_VERSION,//无参数
+ CMD_4G_GET_TIME,//无参数
+ CMD_4G_MAKE_CALL,//需要输入参数 电话号
+ CMD_4G_ANSWER_CALL,//无参数
+ CMD_4G_HUNGUP_CALL,//无参数
+ CMD_4G_SEND_DTMF, //需要输入参数 DTMF NUM(单个数字) , 包括 0 ~ 9, * , #
+ CMD_4G_AT, //需要AT指令,要求结尾带\r\n
+ CMD_4G_MAX,
+} CMD_4G_T;
+
+typedef struct {
+ uint8_t bat_pin; //控制Cat1 battery 的gpio，没有控制，设置为 PIN_NONE 即可
+ uint8_t bat_pin_en_value;
+ uint8_t pwr_pin; //控制cat1开机键的gpio
+ uint8_t pwr_pin_en_value;
+ uint8_t reset_pin; //控制cat1重置键的gpio
+ uint8_t reset_pin_en_value;
+ uint8_t ring_pin; //cat1唤醒蓝牙用的gpio
+ uint8_t ring_pin_en_value;
+ uint8_t wakemodem_pin; //蓝牙唤醒cat1用的gpio
+ uint8_t wakemodem_pin_en_value;
+} ctl_pin_4g_t;
+
+// 消息回调函数类型
+typedef errcode_t (*f_cat1_msg_callback)(MESSAGE_4G_T msg, void *msg_buf, uint16_t msglen);
+
+// 时间控制函数类型
+typedef uint16_t (*f_get_timezone)(void);
+typedef void (*f_set_timezone)(uint16_t timezone_quarters);
+typedef uint32_t (*f_sync_time_utc)(uint32_t timestamp, uint32_t timezone_quarters);
+
+typedef struct {
+ f_get_timezone get_timezone;
+ f_set_timezone set_timezone;
+ f_sync_time_utc sync_time_utc;
+} time_ctl_funcs_t;
+
+// PPP模块的运行时状态结构（与cat1Service保持一致）
+typedef struct {
+ uint8_t cat1_powerOn;
+ uint8_t volte;
+ uint8_t network_on;
+ uint8_t cat1_network_type;
+ int sim;
+ int signal;
+ char opera[64];
+ char imei[20];
+ char pyVer[20];
+ char modemVer[64];
+} ppp_cat1_runtime_status_t;
+
+// PPP模块的运行时状态
+static ppp_cat1_runtime_status_t g_ppp_runtime = {0};
+
+// PPP模块的控制引脚配置
+static ppp_ctl_pin_4g_t g_ppp_ctl_pins = {0};
+
+// PPP模块的初始化状态
+static bool g_ppp_cat1_initialized = false;
+
+/********************** 电源控制接口 **********************/
+
+/**
+ * @brief cat1 开关机设置, 输入 true 开机, false 关机
+ */
+void cat1_api_enable_cat1(bool isopen)
+{
+ PPP_DEBUG_PRINT("PPP: cat1_api_enable_cat1(%s)\n", isopen ? "true" : "false");
+
+ if (isopen) {
+ if (g_ppp_runtime.cat1_powerOn) {
+ PPP_DEBUG_PRINT("PPP: Cat1 already powered on\n");
+ return;
+ }
+
+ // PPP模块开启4G
+ ppp_power_on_cat1();
+ g_ppp_runtime.cat1_powerOn = 1;
+
+ // 可以在这里添加PPP特定的初始化逻辑
+ // 例如：启动PPP协议栈等
+
+ } else {
+ if (!g_ppp_runtime.cat1_powerOn) {
+ PPP_DEBUG_PRINT("PPP: Cat1 already powered off\n");
+ return;
+ }
+
+ // PPP模块关闭4G
+ ppp_power_off_cat1();
+ g_ppp_runtime.cat1_powerOn = 0;
+
+ // 清理网络状态
+ g_ppp_runtime.network_on = 0;
+ g_ppp_runtime.signal = 99; // 无信号
+ g_ppp_runtime.sim = 0;
+ g_ppp_runtime.cat1_network_type = 0;
+ }
+}
+
+/**
+ * @brief 获取cat1是否使能(开机)状态
+ */
+bool cat1_api_is_cat1_enabled(void)
+{
+ return ppp_api_is_cat1_enabled();
+}
+
+/**
+ * @brief cat1 服务初始化
+ */
+errcode_t cat1_server_init(void)
+{
+ PPP_DEBUG_PRINT("PPP: cat1_server_init\n");
+
+ if (g_ppp_cat1_initialized) {
+ return ERRCODE_SUCC;
+ }
+
+ // 初始化PPP电源控制
+ ppp_api_gpio_init();
+ ppp_api_uart_init();
+
+ // 初始化运行时状态
+ (void)memset_s(&g_ppp_runtime, sizeof(ppp_cat1_runtime_status_t), 0, sizeof(ppp_cat1_runtime_status_t));
+ g_ppp_runtime.signal = 99; // 初始无信号
+
+ g_ppp_cat1_initialized = true;
+
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief 串口接收函数,加入到uart_porting 中断处理中
+ */
+void cat1_uart_receive_handler(uint8_t *buffer, int32_t size)
+{
+ PPP_DEBUG_PRINT("PPP: cat1_uart_receive_handler, size=%d\n", size);
+ // TODO: 实现PPP数据接收处理
+ (void)buffer;
+ (void)size;
+}
+
+/**
+ * @brief return cmd uart rx enable flag
+ */
+bool cat1_api_custom_is_cmd_rx_enabled(void)
+{
+ // PPP模块默认启用接收
+ return true;
+}
+
+/********************** 运行时状态获取接口 **********************/
+
+/**
+ * @brief 获取cat1电源开启状态
+ */
+uint8_t cat1_api_runtime_get_cat1_powerstat(void)
+{
+ return g_ppp_runtime.cat1_powerOn;
+}
+
+/**
+ * @brief 获取cat1网络状态
+ */
+uint8_t cat1_api_runtime_get_cat1_networkstat(void)
+{
+ return g_ppp_runtime.network_on;
+}
+
+/**
+ * @brief 获取cat1信号强度
+ */
+int cat1_api_runtime_get_cat1_signal(void)
+{
+ return g_ppp_runtime.signal;
+}
+
+/**
+ * @brief 获取sim卡状态
+ */
+int cat1_api_runtime_get_cat1_simstat(void)
+{
+ return g_ppp_runtime.sim;
+}
+
+/**
+ * @brief 获取网络类型
+ */
+uint8_t cat1_api_runtime_get_cat1_networktype(void)
+{
+ return g_ppp_runtime.cat1_network_type;
+}
+
+/**
+ * @brief 获取Cat1运营商信息
+ */
+char* cat1_api_runtime_get_cat1_operator(void)
+{
+ return g_ppp_runtime.opera;
+}
+
+/**
+ * @brief 获取Cat1 IMEI号
+ */
+char* cat1_api_runtime_get_cat1_imei(void)
+{
+ return g_ppp_runtime.imei;
+}
+
+/**
+ * @brief 获取Cat1主应用版本号
+ */
+char* cat1_api_runtime_get_cat1_pyver(void)
+{
+ return g_ppp_runtime.pyVer;
+}
+
+/**
+ * @brief 获取modem版本
+ */
+char* cat1_api_runtime_get_cat1_modemver(void)
+{
+ return g_ppp_runtime.modemVer;
+}
+
+/********************** 运行时状态设置接口 **********************/
+
+/**
+ * @brief 设置cat1电源状态
+ */
+void cat1_api_runtime_set_cat1_powerstat(uint8_t cat1_powerOn)
+{
+ g_ppp_runtime.cat1_powerOn = cat1_powerOn;
+}
+
+/**
+ * @brief 设置cat1网络状态
+ */
+void cat1_api_runtime_set_cat1_networkstat(uint8_t network_on)
+{
+ g_ppp_runtime.network_on = network_on;
+}
+
+/**
+ * @brief 设置cat1信号强度
+ */
+void cat1_api_runtime_set_cat1_signal(int signal)
+{
+ g_ppp_runtime.signal = signal;
+}
+
+/**
+ * @brief 设置sim卡状态
+ */
+void cat1_api_runtime_set_cat1_simstat(int simstat)
+{
+ g_ppp_runtime.sim = simstat;
+}
+
+/**
+ * @brief 设置网络类型
+ */
+void cat1_api_runtime_set_cat1_networktype(uint8_t networktype)
+{
+ g_ppp_runtime.cat1_network_type = networktype;
+}
+
+/**
+ * @brief 设置Cat1运营商信息
+ */
+void cat1_api_runtime_set_cat1_operator(char* cat1_operator)
+{
+ if (cat1_operator != NULL) {
+ (void)strncpy_s(g_ppp_runtime.opera, sizeof(g_ppp_runtime.opera),
+ cat1_operator, sizeof(g_ppp_runtime.opera) - 1);
+ g_ppp_runtime.opera[sizeof(g_ppp_runtime.opera) - 1] = '\0';
+ }
+}
+
+/**
+ * @brief 设置Cat1 IMEI号
+ */
+void cat1_api_runtime_set_cat1_imei(char* imei)
+{
+ if (imei != NULL) {
+ (void)strncpy_s(g_ppp_runtime.imei, sizeof(g_ppp_runtime.imei),
+ imei, sizeof(g_ppp_runtime.imei) - 1);
+ g_ppp_runtime.imei[sizeof(g_ppp_runtime.imei) - 1] = '\0';
+ }
+}
+
+/**
+ * @brief 设置Cat1主应用版本号
+ */
+void cat1_api_runtime_set_cat1_pyver(char* pyver)
+{
+ if (pyver != NULL) {
+ (void)strncpy_s(g_ppp_runtime.pyVer, sizeof(g_ppp_runtime.pyVer),
+ pyver, sizeof(g_ppp_runtime.pyVer) - 1);
+ g_ppp_runtime.pyVer[sizeof(g_ppp_runtime.pyVer) - 1] = '\0';
+ }
+}
+
+/**
+ * @brief 设置modem版本
+ */
+void cat1_api_runtime_set_cat1_modemver(char* modemver)
+{
+ if (modemver != NULL) {
+ (void)strncpy_s(g_ppp_runtime.modemVer, sizeof(g_ppp_runtime.modemVer),
+ modemver, sizeof(g_ppp_runtime.modemVer) - 1);
+ g_ppp_runtime.modemVer[sizeof(g_ppp_runtime.modemVer) - 1] = '\0';
+ }
+}
+
+/********************** 控制接口 **********************/
+
+/**
+ * @brief 唤醒Cat1
+ */
+void cat1_api_wakeup_cat1(uint8_t wakeup)
+{
+ ppp_api_wakeup_cat1(wakeup);
+}
+
+/**
+ * @brief 保持唤醒Cat1
+ */
+void cat1_api_keep_wakeup(uint8_t keep_wakeup)
+{
+ ppp_api_keep_wakeup(keep_wakeup);
+}
+
+/**
+ * @brief 注册控制4G的gpio值
+ */
+errcode_t cat1_register_ctl_pin(ctl_pin_4g_t ctl_pin)
+{
+ // 转换为PPP模块的引脚配置结构
+ ppp_ctl_pin_4g_t ppp_pin_config = {
+ .bat_pin = ctl_pin.bat_pin,
+ .bat_pin_en_value = ctl_pin.bat_pin_en_value,
+ .pwr_pin = ctl_pin.pwr_pin,
+ .pwr_pin_en_value = ctl_pin.pwr_pin_en_value,
+ .reset_pin = ctl_pin.reset_pin,
+ .reset_pin_en_value = ctl_pin.reset_pin_en_value,
+ .ring_pin = ctl_pin.ring_pin,
+ .ring_pin_en_value = ctl_pin.ring_pin_en_value,
+ .wakemodem_pin = ctl_pin.wakemodem_pin,
+ .wakemodem_pin_en_value = ctl_pin.wakemodem_pin_en_value
+ };
+
+ return ppp_register_ctl_pin(&ppp_pin_config);
+}
+
+/**
+ * @brief cat1唤醒蓝牙中断处理函数
+ */
+void cat1_ring_isr_callback(pin_t pin, uintptr_t param)
+{
+ ppp_ring_isr_callback(pin, param);
+}
+
+/********************** 其他接口（暂时返回默认值或空实现） **********************/
+
+/**
+ * @brief 发送指令给Cat1
+ */
+errcode_t cat1_cmd_send(CMD_4G_T cmd, void *cmd_buf, uint16_t cmdlen)
+{
+ PPP_DEBUG_PRINT("PPP: cat1_cmd_send cmd=%d, len=%d\n", cmd, cmdlen);
+ // TODO: 实现PPP模块的AT命令发送
+ (void)cmd;
+ (void)cmd_buf;
+ (void)cmdlen;
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief 注册消息回调函数
+ */
+errcode_t cat1_register_msg_callback(f_cat1_msg_callback func)
+{
+ PPP_DEBUG_PRINT("PPP: cat1_register_msg_callback\n");
+ // TODO: 实现PPP模块的消息回调注册
+ (void)func;
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief 注册时间控制函数
+ */
+errcode_t cat1_register_time_ctl_functions(time_ctl_funcs_t *funcs)
+{
+ PPP_DEBUG_PRINT("PPP: cat1_register_time_ctl_functions\n");
+ // TODO: 实现PPP模块的时间控制函数注册
+ (void)funcs;
+ return ERRCODE_SUCC;
+}
\ No newline at end of file
--- /dev/null
+#include "ppp_debug.h"
+#include "ppp_config.h"
+#include "ppp_types.h"
+#include <stdio.h>
+
+#if PPP_DEBUG_ENABLE
+
+/**
+ * @brief 十六进制数据转储
+ */
+void ppp_debug_hexdump(const uint8_t *data, uint32_t len)
+{
+ if (!data || len == 0) {
+ return;
+ }
+
+ PRINT("[PPP HEXDUMP] Length: %u bytes\r\n", len);
+
+ for (uint32_t i = 0; i < len; i += 16) {
+ /* 打印地址 */
+ PRINT("%08X: ", i);
+
+ /* 打印十六进制数据 */
+ for (uint32_t j = 0; j < 16; j++) {
+ if (i + j < len) {
+ PRINT("%02X ", data[i + j]);
+ } else {
+ PRINT(" ");
+ }
+
+ if (j == 7) {
+ PRINT(" ");
+ }
+ }
+
+ PRINT(" |");
+
+ /* 打印ASCII字符 */
+ for (uint32_t j = 0; j < 16 && i + j < len; j++) {
+ uint8_t c = data[i + j];
+ if (c >= 32 && c <= 126) {
+ PRINT("%c", c);
+ } else {
+ PRINT(".");
+ }
+ }
+
+ PRINT("|\r\n");
+ }
+}
+
+#else
+
+void ppp_debug_hexdump(const uint8_t *data, uint32_t len)
+{
+ (void)data;
+ (void)len;
+}
+
+#endif /* PPP_DEBUG_ENABLE */
+
+/**
+ * @brief 获取错误码字符串
+ */
+const char *ppp_debug_error_string(ppp_error_t error_code)
+{
+ switch (error_code) {
+ case PPP_ERR_OK:
+ return "OK";
+ case PPP_ERR_TIMEOUT:
+ return "TIMEOUT";
+ case PPP_ERR_AT_FAILED:
+ return "AT_FAILED";
+ case PPP_ERR_DIAL_FAILED:
+ return "DIAL_FAILED";
+ case PPP_ERR_NO_CARRIER:
+ return "NO_CARRIER";
+ case PPP_ERR_BUSY:
+ return "BUSY";
+ case PPP_ERR_NO_DIALTONE:
+ return "NO_DIALTONE";
+ case PPP_ERR_INVALID_PARAM:
+ return "INVALID_PARAM";
+ case PPP_ERR_MEMORY:
+ return "MEMORY";
+ case PPP_ERR_UART:
+ return "UART";
+ case PPP_ERR_UNKNOWN:
+ default:
+ return "UNKNOWN";
+ }
+}
+
+/**
+ * @brief 获取状态字符串
+ */
+const char *ppp_debug_state_string(ppp_state_t state)
+{
+ switch (state) {
+ case PPP_STATE_IDLE:
+ return "IDLE";
+ case PPP_STATE_INIT:
+ return "INIT";
+ case PPP_STATE_AT_HANDSHAKE:
+ return "AT_HANDSHAKE";
+ case PPP_STATE_SET_BAUDRATE:
+ return "SET_BAUDRATE";
+ case PPP_STATE_DIALING:
+ return "DIALING";
+ case PPP_STATE_CONNECTED:
+ return "CONNECTED";
+ case PPP_STATE_DISCONNECTING:
+ return "DISCONNECTING";
+ case PPP_STATE_ERROR:
+ return "ERROR";
+ default:
+ return "UNKNOWN";
+ }
+}
\ No newline at end of file
--- /dev/null
+#include "ppp_lwip.h"
+#include "ppp_config.h"
+#include "ppp_types.h"
+#include "ppp_debug.h"
+#include "ppp_serial.h"
+#include "securec.h"
+#include <string.h>
+
+/* lwIP相关头文件 - 需要在编译时确保PPP支持已启用 */
+#ifdef LWIP_PPP_SUPPORT
+#include "lwip/netif.h"
+#include "lwip/tcpip.h"
+#include "lwip/ip4_addr.h"
+#include "lwip/dns.h"
+#include "netif/ppp/ppp.h"
+#include "netif/ppp/pppos.h"
+#endif
+
+/* PPP lwIP上下文 */
+typedef struct {
+ bool initialized;
+ struct netif *netif;
+#ifdef LWIP_PPP_SUPPORT
+ ppp_pcb *ppp_pcb;
+#else
+ void *ppp_pcb; /* 占位符，当PPP支持未启用时 */
+#endif
+ ppp_lwip_event_callback_t event_callback;
+ void *event_callback_arg;
+ bool connected;
+ uint32_t local_ip;
+ uint32_t remote_ip;
+ uint32_t primary_dns;
+ uint32_t secondary_dns;
+} ppp_lwip_context_t;
+
+static ppp_lwip_context_t g_lwip_ctx = {0};
+
+/* 内部函数声明 */
+#ifdef LWIP_PPP_SUPPORT
+static void ppp_lwip_status_callback(ppp_pcb *pcb, int err_code, void *ctx);
+static void ppp_lwip_link_status_callback(ppp_pcb *pcb, int err_code, void *ctx);
+static u32_t ppp_lwip_output_callback(ppp_pcb *pcb, u8_t *data, u32_t len, void *ctx);
+#endif
+
+/**
+ * @brief 初始化PPP lwIP集成
+ */
+ppp_error_t ppp_lwip_init(const ppp_lwip_config_t *config)
+{
+#ifndef LWIP_PPP_SUPPORT
+ PPP_DEBUG_ERROR("lwIP PPP support not enabled");
+ return PPP_ERR_INVALID_PARAM;
+#else
+ if (!config || g_lwip_ctx.initialized) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ PPP_DEBUG_INFO("Initializing PPP lwIP integration");
+
+ /* 分配网络接口 */
+ g_lwip_ctx.netif = (struct netif *)osal_kmalloc(sizeof(struct netif));
+ if (!g_lwip_ctx.netif) {
+ PPP_DEBUG_ERROR("Failed to allocate netif");
+ return PPP_ERR_MEMORY;
+ }
+
+ memset_s(g_lwip_ctx.netif, sizeof(struct netif), 0, sizeof(struct netif));
+
+ /* 创建PPPoS接口 */
+ g_lwip_ctx.ppp_pcb = pppos_create(g_lwip_ctx.netif,
+ ppp_lwip_output_callback,
+ ppp_lwip_link_status_callback,
+ &g_lwip_ctx);
+
+ if (!g_lwip_ctx.ppp_pcb) {
+ PPP_DEBUG_ERROR("Failed to create PPPoS interface");
+ osal_kfree(g_lwip_ctx.netif);
+ return PPP_ERR_MEMORY;
+ }
+
+ /* 设置认证信息 */
+ if (config->username && config->password) {
+ ppp_set_auth(g_lwip_ctx.ppp_pcb, PPPAUTHTYPE_PAP, config->username, config->password);
+ PPP_DEBUG_INFO("PPP authentication configured (PAP)");
+ }
+
+ /* 设置状态回调 */
+ ppp_set_notify_phase_callback(g_lwip_ctx.ppp_pcb, ppp_lwip_status_callback);
+
+ /* 保存回调函数 */
+ g_lwip_ctx.event_callback = config->event_callback;
+ g_lwip_ctx.event_callback_arg = config->event_callback_arg;
+
+ g_lwip_ctx.initialized = true;
+ PPP_DEBUG_INFO("PPP lwIP integration initialized");
+
+ return PPP_ERR_OK;
+#endif
+}
+
+/**
+ * @brief 反初始化PPP lwIP集成
+ */
+void ppp_lwip_deinit(void)
+{
+#ifdef LWIP_PPP_SUPPORT
+ if (!g_lwip_ctx.initialized) {
+ return;
+ }
+
+ PPP_DEBUG_INFO("Deinitializing PPP lwIP integration");
+
+ /* 断开连接 */
+ if (g_lwip_ctx.connected) {
+ ppp_lwip_disconnect();
+ }
+
+ /* 删除PPP控制块 */
+ if (g_lwip_ctx.ppp_pcb) {
+ ppp_free(g_lwip_ctx.ppp_pcb);
+ g_lwip_ctx.ppp_pcb = NULL;
+ }
+
+ /* 释放网络接口 */
+ if (g_lwip_ctx.netif) {
+ osal_kfree(g_lwip_ctx.netif);
+ g_lwip_ctx.netif = NULL;
+ }
+
+ memset_s(&g_lwip_ctx, sizeof(g_lwip_ctx), 0, sizeof(g_lwip_ctx));
+ PPP_DEBUG_INFO("PPP lwIP integration deinitialized");
+#endif
+}
+
+/**
+ * @brief 连接PPP
+ */
+ppp_error_t ppp_lwip_connect(void)
+{
+#ifndef LWIP_PPP_SUPPORT
+ return PPP_ERR_INVALID_PARAM;
+#else
+ if (!g_lwip_ctx.initialized) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ if (g_lwip_ctx.connected) {
+ PPP_DEBUG_WARN("PPP already connected");
+ return PPP_ERR_OK;
+ }
+
+ PPP_DEBUG_INFO("Connecting PPP");
+
+ /* 启动PPP连接 */
+ err_t err = ppp_connect(g_lwip_ctx.ppp_pcb, 0);
+ if (err != ERR_OK) {
+ PPP_DEBUG_ERROR("Failed to start PPP connection: %d", err);
+ return PPP_ERR_DIAL_FAILED;
+ }
+
+ PPP_DEBUG_INFO("PPP connection started");
+ return PPP_ERR_OK;
+#endif
+}
+
+/**
+ * @brief 断开PPP连接
+ */
+ppp_error_t ppp_lwip_disconnect(void)
+{
+#ifndef LWIP_PPP_SUPPORT
+ return PPP_ERR_INVALID_PARAM;
+#else
+ if (!g_lwip_ctx.initialized) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ if (!g_lwip_ctx.connected) {
+ PPP_DEBUG_WARN("PPP not connected");
+ return PPP_ERR_OK;
+ }
+
+ PPP_DEBUG_INFO("Disconnecting PPP");
+
+ /* 关闭PPP连接 */
+ err_t err = ppp_close(g_lwip_ctx.ppp_pcb, 0);
+ if (err != ERR_OK) {
+ PPP_DEBUG_ERROR("Failed to close PPP connection: %d", err);
+ return PPP_ERR_DIAL_FAILED;
+ }
+
+ g_lwip_ctx.connected = false;
+ PPP_DEBUG_INFO("PPP disconnection initiated");
+ return PPP_ERR_OK;
+#endif
+}
+
+/**
+ * @brief 输入PPP数据
+ */
+ppp_error_t ppp_lwip_input(const uint8_t *data, uint32_t length)
+{
+#ifndef LWIP_PPP_SUPPORT
+ return PPP_ERR_INVALID_PARAM;
+#else
+ if (!g_lwip_ctx.initialized || !data || length == 0) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ PPP_DEBUG_DEBUG("PPP input %u bytes", length);
+ PPP_DEBUG_HEXDUMP(data, length);
+
+ /* 将数据传递给PPPoS */
+ pppos_input(g_lwip_ctx.ppp_pcb, (u8_t *)data, length);
+
+ return PPP_ERR_OK;
+#endif
+}
+
+/**
+ * @brief 获取PPP连接状态
+ */
+bool ppp_lwip_is_connected(void)
+{
+ return g_lwip_ctx.connected;
+}
+
+/**
+ * @brief 获取网络信息
+ */
+ppp_error_t ppp_lwip_get_network_info(ppp_lwip_network_info_t *info)
+{
+#ifndef LWIP_PPP_SUPPORT
+ return PPP_ERR_INVALID_PARAM;
+#else
+ if (!g_lwip_ctx.initialized || !info) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ memset_s(info, sizeof(ppp_lwip_network_info_t), 0, sizeof(ppp_lwip_network_info_t));
+
+ info->connected = g_lwip_ctx.connected;
+ info->local_ip = g_lwip_ctx.local_ip;
+ info->remote_ip = g_lwip_ctx.remote_ip;
+ info->primary_dns = g_lwip_ctx.primary_dns;
+ info->secondary_dns = g_lwip_ctx.secondary_dns;
+
+ if (g_lwip_ctx.netif) {
+ info->mtu = g_lwip_ctx.netif->mtu;
+ }
+
+ return PPP_ERR_OK;
+#endif
+}
+
+/**
+ * @brief 获取网络接口指针
+ */
+struct netif *ppp_lwip_get_netif(void)
+{
+ return g_lwip_ctx.netif;
+}
+
+/* 内部函数实现 */
+
+#ifdef LWIP_PPP_SUPPORT
+/**
+ * @brief PPP状态回调函数
+ */
+static void ppp_lwip_status_callback(ppp_pcb *pcb, int err_code, void *ctx)
+{
+ (void)pcb;
+ (void)ctx;
+
+ PPP_DEBUG_INFO("PPP status callback: err_code=%d", err_code);
+
+ ppp_lwip_event_t event;
+ memset_s(&event, sizeof(event), 0, sizeof(event));
+
+ switch (err_code) {
+ case PPPERR_NONE:
+ /* 连接成功 */
+ g_lwip_ctx.connected = true;
+ event.type = PPP_LWIP_EVENT_CONNECTED;
+
+ /* 获取IP地址信息 */
+ if (g_lwip_ctx.netif) {
+ g_lwip_ctx.local_ip = ip4_addr_get_u32(&g_lwip_ctx.netif->ip_addr);
+ g_lwip_ctx.remote_ip = ip4_addr_get_u32(&g_lwip_ctx.netif->gw);
+
+ /* 获取DNS服务器地址 */
+ const ip_addr_t *dns1 = dns_getserver(0);
+ const ip_addr_t *dns2 = dns_getserver(1);
+ if (dns1) {
+ g_lwip_ctx.primary_dns = ip4_addr_get_u32(ip_2_ip4(dns1));
+ }
+ if (dns2) {
+ g_lwip_ctx.secondary_dns = ip4_addr_get_u32(ip_2_ip4(dns2));
+ }
+
+ PPP_DEBUG_INFO("PPP connected - Local IP: %u.%u.%u.%u",
+ (g_lwip_ctx.local_ip >> 0) & 0xFF,
+ (g_lwip_ctx.local_ip >> 8) & 0xFF,
+ (g_lwip_ctx.local_ip >> 16) & 0xFF,
+ (g_lwip_ctx.local_ip >> 24) & 0xFF);
+ }
+ break;
+
+ case PPPERR_PARAM:
+ case PPPERR_OPEN:
+ case PPPERR_DEVICE:
+ case PPPERR_ALLOC:
+ case PPPERR_USER:
+ case PPPERR_CONNECT:
+ case PPPERR_AUTHFAIL:
+ case PPPERR_PROTOCOL:
+ case PPPERR_PEERDEAD:
+ case PPPERR_IDLETIMEOUT:
+ case PPPERR_CONNECTTIME:
+ case PPPERR_LOOPBACK:
+ /* 连接错误 */
+ g_lwip_ctx.connected = false;
+ event.type = PPP_LWIP_EVENT_ERROR;
+ event.error_code = err_code;
+ PPP_DEBUG_ERROR("PPP connection error: %d", err_code);
+ break;
+
+ default:
+ /* 其他状态 */
+ event.type = PPP_LWIP_EVENT_STATUS_CHANGE;
+ event.error_code = err_code;
+ break;
+ }
+
+ /* 调用用户回调函数 */
+ if (g_lwip_ctx.event_callback) {
+ g_lwip_ctx.event_callback(&event, g_lwip_ctx.event_callback_arg);
+ }
+}
+
+/**
+ * @brief PPP链路状态回调函数
+ */
+static void ppp_lwip_link_status_callback(ppp_pcb *pcb, int err_code, void *ctx)
+{
+ (void)pcb;
+ (void)ctx;
+
+ PPP_DEBUG_INFO("PPP link status callback: err_code=%d", err_code);
+
+ if (err_code == PPPERR_NONE) {
+ PPP_DEBUG_INFO("PPP link up");
+ } else {
+ PPP_DEBUG_WARN("PPP link down: %d", err_code);
+ g_lwip_ctx.connected = false;
+
+ /* 通知链路断开 */
+ if (g_lwip_ctx.event_callback) {
+ ppp_lwip_event_t event;
+ memset_s(&event, sizeof(event), 0, sizeof(event));
+ event.type = PPP_LWIP_EVENT_DISCONNECTED;
+ event.error_code = err_code;
+ g_lwip_ctx.event_callback(&event, g_lwip_ctx.event_callback_arg);
+ }
+ }
+}
+
+/**
+ * @brief PPP输出回调函数
+ */
+static u32_t ppp_lwip_output_callback(ppp_pcb *pcb, u8_t *data, u32_t len, void *ctx)
+{
+ (void)pcb;
+ (void)ctx;
+
+ PPP_DEBUG_DEBUG("PPP output %u bytes", len);
+ PPP_DEBUG_HEXDUMP(data, len);
+
+ /* 通过串口发送数据 */
+ ppp_error_t ret = ppp_serial_write(data, len);
+ if (ret != PPP_ERR_OK) {
+ PPP_DEBUG_ERROR("Failed to send PPP data: %d", ret);
+ return 0;
+ }
+
+ return len;
+}
+#endif /* LWIP_PPP_SUPPORT */
\ No newline at end of file
--- /dev/null
+/*
+ * @brief PPP模块电源控制实现
+ * @description 提供PPP模块专用的4G电源控制功能，与SLIP模块互斥使用
+ * Copyright (c) CompanyNameMagicTag 2024-2024. All rights reserved.
+ */
+
+#include "ppp_power_ctl.h"
+#include "ppp_debug.h"
+#include "gpio.h"
+#include "osal_debug.h"
+#include "securec.h"
+
+// PPP模块的4G控制引脚配置
+static ppp_ctl_pin_4g_t g_ppp_cat1_ctl_pins = {0};
+
+// PPP模块的4G电源状态
+static bool g_ppp_cat1_power_status = false;
+
+/**
+ * @brief PPP模块GPIO初始化
+ */
+void ppp_api_gpio_init(void)
+{
+ PPP_DEBUG_PRINT("PPP GPIO init\n");
+ // GPIO初始化逻辑可以在这里添加
+}
+
+/**
+ * @brief PPP模块UART初始化
+ */
+void ppp_api_uart_init(void)
+{
+ PPP_DEBUG_PRINT("PPP UART init\n");
+ // UART初始化逻辑可以在这里添加
+}
+
+/**
+ * @brief PPP模块设置电源引脚状态
+ */
+uint32_t ppp_api_cat1_power_on(uint32_t pwron)
+{
+ pin_t en_pin = g_ppp_cat1_ctl_pins.pwr_pin;
+ uint8_t en_value = g_ppp_cat1_ctl_pins.pwr_pin_en_value;
+
+ if (en_pin == PIN_NONE) {
+ PPP_DEBUG_PRINT("PPP: cat1_power_on en_pin is none\n");
+ return 0xff;
+ }
+
+ if (pwron == 0) {
+ uapi_gpio_set_dir(en_pin, GPIO_DIRECTION_OUTPUT);
+ if (en_value) {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_LOW);
+ PPP_DEBUG_PRINT("PPP: Power Cat1 Off! pin %d value low\n", en_pin);
+ } else {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_HIGH);
+ PPP_DEBUG_PRINT("PPP: Power Cat1 Off! pin %d value high\n", en_pin);
+ }
+ } else {
+ uapi_gpio_set_dir(en_pin, GPIO_DIRECTION_OUTPUT);
+ if (en_value) {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_HIGH);
+ PPP_DEBUG_PRINT("PPP: Power Cat1 On! pin %d value high\n", en_pin);
+ } else {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_LOW);
+ PPP_DEBUG_PRINT("PPP: Power Cat1 On! pin %d value low\n", en_pin);
+ }
+ }
+ return 0;
+}
+
+/**
+ * @brief PPP模块设置复位引脚状态
+ */
+uint32_t ppp_api_cat1_reset(uint32_t pwron)
+{
+ pin_t en_pin = g_ppp_cat1_ctl_pins.reset_pin;
+ uint8_t en_value = g_ppp_cat1_ctl_pins.reset_pin_en_value;
+
+ if (en_pin == PIN_NONE) {
+ PPP_DEBUG_PRINT("PPP: cat1_reset en_pin is none\n");
+ return 0xff;
+ }
+
+ if (pwron == 0) {
+ uapi_gpio_set_dir(en_pin, GPIO_DIRECTION_OUTPUT);
+ if (en_value) {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_LOW);
+ PPP_DEBUG_PRINT("PPP: Cat1 reset Off! pin %d value low\n", en_pin);
+ } else {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_HIGH);
+ PPP_DEBUG_PRINT("PPP: Cat1 reset Off! pin %d value high\n", en_pin);
+ }
+ } else {
+ uapi_gpio_set_dir(en_pin, GPIO_DIRECTION_OUTPUT);
+ if (en_value) {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_HIGH);
+ PPP_DEBUG_PRINT("PPP: Cat1 reset On! pin %d value high\n", en_pin);
+ } else {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_LOW);
+ PPP_DEBUG_PRINT("PPP: Cat1 reset On! pin %d value low\n", en_pin);
+ }
+ }
+ return 0;
+}
+
+/**
+ * @brief PPP模块设置电池引脚状态
+ */
+uint32_t ppp_api_cat1_bat_on(uint32_t pwron)
+{
+ pin_t en_pin = g_ppp_cat1_ctl_pins.bat_pin;
+ uint8_t en_value = g_ppp_cat1_ctl_pins.bat_pin_en_value;
+
+ if (en_pin == PIN_NONE) {
+ PPP_DEBUG_PRINT("PPP: cat1_bat_on en_pin is none\n");
+ return 0xff;
+ }
+
+ if (pwron == 0) {
+ uapi_gpio_set_dir(en_pin, GPIO_DIRECTION_OUTPUT);
+ if (en_value) {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_LOW);
+ PPP_DEBUG_PRINT("PPP: Cat1 bat Off! pin %d value low\n", en_pin);
+ } else {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_HIGH);
+ PPP_DEBUG_PRINT("PPP: Cat1 bat Off! pin %d value high\n", en_pin);
+ }
+ } else {
+ uapi_gpio_set_dir(en_pin, GPIO_DIRECTION_OUTPUT);
+ if (en_value) {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_HIGH);
+ PPP_DEBUG_PRINT("PPP: Cat1 bat On! pin %d value high\n", en_pin);
+ } else {
+ uapi_gpio_set_val(en_pin, GPIO_LEVEL_LOW);
+ PPP_DEBUG_PRINT("PPP: Cat1 bat On! pin %d value low\n", en_pin);
+ }
+ }
+ return 0;
+}
+
+/**
+ * @brief PPP模块检查4G是否使能
+ */
+bool ppp_api_is_cat1_enabled(void)
+{
+#if defined(BOARD_W9) || defined(BOARD_N9) || defined(BOARD_LEINIAO)
+ pin_t en_pin = g_ppp_cat1_ctl_pins.bat_pin;
+ uint8_t en_value = g_ppp_cat1_ctl_pins.bat_pin_en_value;
+#else
+ pin_t en_pin = g_ppp_cat1_ctl_pins.pwr_pin;
+ uint8_t en_value = g_ppp_cat1_ctl_pins.pwr_pin_en_value;
+#endif
+
+ if (en_pin == PIN_NONE) {
+ PPP_DEBUG_PRINT("PPP: is_cat1_enabled en_pin is none\n");
+ return false;
+ }
+
+ if (en_value == uapi_gpio_get_output_val(en_pin)) {
+ PPP_DEBUG_PRINT("PPP: is_cat1_enabled en_value is %d\n", en_value);
+ return true;
+ } else {
+ PPP_DEBUG_PRINT("PPP: is_cat1_enabled en_value is %d\n", en_value);
+ return false;
+ }
+}
+
+/**
+ * @brief PPP模块底层复位函数
+ */
+static uint32_t ppp_uapi_cat1_reset(uint32_t pwron)
+{
+ pin_t reset_pin = S_AGPIO_L28;
+#if defined(BOARD_LEINIAO)
+ reset_pin = S_AGPIO_L24;
+#endif
+
+ if (pwron == 0) {
+ uapi_gpio_set_dir(reset_pin, GPIO_DIRECTION_OUTPUT);
+ uapi_gpio_set_val(reset_pin, GPIO_LEVEL_HIGH);
+ PPP_DEBUG_PRINT("PPP: clear reset Cat1! L28 high\n");
+ } else {
+ uapi_gpio_set_dir(reset_pin, GPIO_DIRECTION_OUTPUT);
+ uapi_gpio_set_val(reset_pin, GPIO_LEVEL_LOW);
+ PPP_DEBUG_PRINT("PPP: Reset Cat1! L28 low\n");
+ }
+
+ return 0;
+}
+
+/**
+ * @brief PPP模块底层电源控制函数
+ */
+static uint32_t ppp_uapi_cat1_power_on(uint32_t pwron)
+{
+ pin_t bat_en_pin = S_AGPIO_L23;
+
+ if (pwron == 0) {
+ uapi_gpio_set_dir(bat_en_pin, GPIO_DIRECTION_OUTPUT);
+ uapi_gpio_set_val(bat_en_pin, GPIO_LEVEL_LOW);
+ PPP_DEBUG_PRINT("PPP: Power Cat1! %d low\n", bat_en_pin);
+ } else {
+ uapi_gpio_set_dir(bat_en_pin, GPIO_DIRECTION_OUTPUT);
+ uapi_gpio_set_val(bat_en_pin, GPIO_LEVEL_HIGH);
+ PPP_DEBUG_PRINT("PPP: Power Cat1! %d high\n", bat_en_pin);
+ }
+
+ return 0;
+}
+
+/**
+ * @brief PPP模块底层电池控制函数
+ */
+static uint32_t ppp_uapi_cat1_bat_on(uint32_t pwron)
+{
+#if defined(BOARD_W9) || defined(BOARD_N9)
+ pin_t bat_en_pin = S_AGPIO_L17;
+#elif defined(BOARD_LEINIAO)
+ pin_t bat_en_pin = S_AGPIO_L18;
+ if (pwron == 0) {
+ uapi_gpio_set_dir(bat_en_pin, GPIO_DIRECTION_OUTPUT);
+ uapi_gpio_set_val(bat_en_pin, GPIO_LEVEL_LOW);
+ PPP_DEBUG_PRINT("PPP: BAT OFF Cat1! %d low\n", bat_en_pin);
+ } else {
+ uapi_gpio_set_dir(bat_en_pin, GPIO_DIRECTION_OUTPUT);
+ uapi_gpio_set_val(bat_en_pin, GPIO_LEVEL_HIGH);
+ PPP_DEBUG_PRINT("PPP: BAT ON Cat1! %d high\n", bat_en_pin);
+ }
+#endif
+
+ return 0;
+}
+
+/**
+ * @brief PPP模块4G上电序列
+ */
+void ppp_power_on_cat1(void)
+{
+#if defined(BOARD_FD230)
+ ppp_uapi_cat1_power_on(1);
+ ppp_uapi_cat1_reset(0);
+#elif (defined(BOARD_W9) || defined(BOARD_N9) || defined(BOARD_LEINIAO))
+ ppp_uapi_cat1_reset(0);
+ ppp_uapi_cat1_power_on(1);
+ ppp_uapi_cat1_bat_on(1);
+ osal_msleep(900); // 使用OSAL延时函数
+ ppp_uapi_cat1_power_on(0);
+#endif
+
+ g_ppp_cat1_power_status = true;
+ PPP_DEBUG_PRINT("PPP: Cat1 power on sequence completed\n");
+}
+
+/**
+ * @brief PPP模块4G下电序列
+ */
+void ppp_power_off_cat1(void)
+{
+#if defined(BOARD_FD230)
+ ppp_uapi_cat1_reset(1);
+ ppp_uapi_cat1_power_on(0);
+#elif (defined(BOARD_W9) || defined(BOARD_N9) || defined(BOARD_LEINIAO))
+ ppp_uapi_cat1_power_on(0);
+ ppp_uapi_cat1_bat_on(0);
+ ppp_uapi_cat1_reset(1);
+#endif
+
+ g_ppp_cat1_power_status = false;
+ PPP_DEBUG_PRINT("PPP: Cat1 power off sequence completed\n");
+}
+
+/**
+ * @brief PPP模块唤醒Cat1
+ */
+void ppp_api_wakeup_cat1(uint8_t wakeup)
+{
+ pin_t wake_pin = g_ppp_cat1_ctl_pins.wakemodem_pin;
+ uint8_t wake_value = g_ppp_cat1_ctl_pins.wakemodem_pin_en_value;
+
+ if (wake_pin == PIN_NONE) {
+ PPP_DEBUG_PRINT("PPP: wakeup_cat1 wake_pin is none\n");
+ return;
+ }
+
+ uapi_gpio_set_dir(wake_pin, GPIO_DIRECTION_OUTPUT);
+ if (wakeup) {
+ if (wake_value) {
+ uapi_gpio_set_val(wake_pin, GPIO_LEVEL_HIGH);
+ } else {
+ uapi_gpio_set_val(wake_pin, GPIO_LEVEL_LOW);
+ }
+ PPP_DEBUG_PRINT("PPP: Wakeup Cat1 pin %d\n", wake_pin);
+ } else {
+ if (wake_value) {
+ uapi_gpio_set_val(wake_pin, GPIO_LEVEL_LOW);
+ } else {
+ uapi_gpio_set_val(wake_pin, GPIO_LEVEL_HIGH);
+ }
+ PPP_DEBUG_PRINT("PPP: Release wakeup Cat1 pin %d\n", wake_pin);
+ }
+}
+
+/**
+ * @brief PPP模块保持唤醒Cat1
+ */
+void ppp_api_keep_wakeup(uint8_t keep_wakeup)
+{
+ // 保持唤醒逻辑实现
+ PPP_DEBUG_PRINT("PPP: Keep wakeup Cat1: %d\n", keep_wakeup);
+}
+
+/**
+ * @brief PPP模块挂起
+ */
+void ppp_suspend(void)
+{
+ PPP_DEBUG_PRINT("PPP: Module suspended\n");
+}
+
+/**
+ * @brief PPP模块恢复
+ */
+void ppp_resume(void)
+{
+ PPP_DEBUG_PRINT("PPP: Module resumed\n");
+}
+
+/**
+ * @brief PPP模块注册4G控制引脚配置
+ */
+errcode_t ppp_register_ctl_pin(ppp_ctl_pin_4g_t *ctl_pin)
+{
+ if (ctl_pin == NULL) {
+ PPP_DEBUG_PRINT("PPP: register_ctl_pin invalid parameter\n");
+ return ERRCODE_INVALID_PARAM;
+ }
+
+ (void)memcpy_s(&g_ppp_cat1_ctl_pins, sizeof(ppp_ctl_pin_4g_t),
+ ctl_pin, sizeof(ppp_ctl_pin_4g_t));
+
+ PPP_DEBUG_PRINT("PPP: Control pins registered successfully\n");
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief PPP模块Cat1唤醒中断回调函数
+ */
+void ppp_ring_isr_callback(pin_t pin, uintptr_t param)
+{
+ (void)param;
+ PPP_DEBUG_PRINT("PPP: Cat1 ring interrupt on pin %d\n", pin);
+ // 中断处理逻辑
+}
+
+/**
+ * @brief PPP模块专用的4G使能控制接口
+ */
+void ppp_api_enable_cat1(bool isopen)
+{
+ PPP_DEBUG_PRINT("PPP: Enable Cat1: %s\n", isopen ? "true" : "false");
+
+ if (isopen) {
+ if (g_ppp_cat1_power_status) {
+ PPP_DEBUG_PRINT("PPP: Cat1 already powered on\n");
+ return;
+ }
+
+ // PPP模块开启4G
+ ppp_power_on_cat1();
+
+ // 可以在这里添加PPP特定的初始化逻辑
+ // 例如：启动PPP协议栈等
+
+ } else {
+ if (!g_ppp_cat1_power_status) {
+ PPP_DEBUG_PRINT("PPP: Cat1 already powered off\n");
+ return;
+ }
+
+ // PPP模块关闭4G
+ ppp_power_off_cat1();
+
+ // 可以在这里添加PPP特定的清理逻辑
+ // 例如：停止PPP协议栈等
+ }
+}
\ No newline at end of file
--- /dev/null
+#include "ppp_serial.h"
+#include "ppp_config.h"
+#include "ppp_types.h"
+#include "ppp_debug.h"
+#include "uart.h"
+#include "schedule/osal_task.h"
+#include "semaphore/osal_semaphore.h"
+#include "lock/osal_mutex.h"
+#include "memory/osal_addr.h"
+#include "soc_osal.h"
+#include "securec.h"
+#include <string.h>
+
+/* 串口上下文结构 */
+typedef struct {
+ bool initialized;
+ uint8_t uart_bus;
+ uart_pin_config_t pin_config;
+ uart_attr_t uart_attr;
+ uart_buffer_config_t buffer_config;
+
+ /* 接收缓冲区 */
+ uint8_t *rx_buffer;
+ uint32_t rx_buffer_size;
+ uint32_t rx_head;
+ uint32_t rx_tail;
+ uint32_t rx_count;
+
+ /* 发送缓冲区 */
+ uint8_t *tx_buffer;
+ uint32_t tx_buffer_size;
+
+ /* 同步对象 */
+ osal_mutex *rx_mutex;
+ osal_semaphore *rx_semaphore;
+
+ /* 回调函数 */
+ ppp_serial_rx_callback_t rx_callback;
+ void *rx_callback_arg;
+
+ /* 统计信息 */
+ uint32_t tx_bytes;
+ uint32_t rx_bytes;
+ uint32_t tx_errors;
+ uint32_t rx_errors;
+} ppp_serial_context_t;
+
+static ppp_serial_context_t g_serial_ctx = {0};
+
+/* 内部函数声明 */
+static void ppp_serial_rx_callback(const void *buffer, uint16_t length, bool remaining);
+static uint32_t ppp_serial_buffer_available_space(void);
+static uint32_t ppp_serial_buffer_data_count(void);
+
+/**
+ * @brief 初始化PPP串口
+ */
+ppp_error_t ppp_serial_init(const ppp_serial_config_t *config)
+{
+ if (!config || g_serial_ctx.initialized) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ PPP_DEBUG_INFO("Initializing PPP serial on UART%d", config->uart_bus);
+
+ /* 分配接收缓冲区 */
+ g_serial_ctx.rx_buffer = (uint8_t *)osal_kmalloc(config->rx_buffer_size, OSAL_GFP_KERNEL);
+ if (!g_serial_ctx.rx_buffer) {
+ PPP_DEBUG_ERROR("Failed to allocate RX buffer");
+ return PPP_ERR_MEMORY;
+ }
+
+ /* 分配发送缓冲区 */
+ g_serial_ctx.tx_buffer = (uint8_t *)osal_kmalloc(config->tx_buffer_size, OSAL_GFP_KERNEL);
+ if (!g_serial_ctx.tx_buffer) {
+ PPP_DEBUG_ERROR("Failed to allocate TX buffer");
+ osal_kfree(g_serial_ctx.rx_buffer);
+ return PPP_ERR_MEMORY;
+ }
+
+ /* 创建互斥锁 */
+ if (osal_mutex_init(&g_serial_ctx.rx_mutex) != OSAL_SUCCESS) {
+ PPP_DEBUG_ERROR("Failed to create RX mutex");
+ osal_kfree(g_serial_ctx.rx_buffer);
+ osal_kfree(g_serial_ctx.tx_buffer);
+ return PPP_ERR_MEMORY;
+ }
+
+ /* 创建信号量 */
+ if (osal_sem_init(&g_serial_ctx.rx_semaphore, 0) != OSAL_SUCCESS) {
+ PPP_DEBUG_ERROR("Failed to create RX semaphore");
+ osal_mutex_destroy(g_serial_ctx.rx_mutex);
+ osal_kfree(g_serial_ctx.rx_buffer);
+ osal_kfree(g_serial_ctx.tx_buffer);
+ return PPP_ERR_MEMORY;
+ }
+
+ /* 配置串口参数 */
+ g_serial_ctx.uart_bus = config->uart_bus;
+ g_serial_ctx.rx_buffer_size = config->rx_buffer_size;
+ g_serial_ctx.tx_buffer_size = config->tx_buffer_size;
+ g_serial_ctx.rx_callback = config->rx_callback;
+ g_serial_ctx.rx_callback_arg = config->rx_callback_arg;
+
+ /* 配置串口引脚 */
+ g_serial_ctx.pin_config.tx_pin = config->tx_pin;
+ g_serial_ctx.pin_config.rx_pin = config->rx_pin;
+ g_serial_ctx.pin_config.cts_pin = PIN_NONE;
+ g_serial_ctx.pin_config.rts_pin = PIN_NONE;
+
+ /* 配置串口属性 */
+ g_serial_ctx.uart_attr.baud_rate = config->baudrate;
+ g_serial_ctx.uart_attr.data_bits = UART_DATA_BIT_8;
+ g_serial_ctx.uart_attr.parity = UART_PARITY_NONE;
+ g_serial_ctx.uart_attr.stop_bits = UART_STOP_BIT_1;
+
+ /* 配置串口缓冲区 */
+ g_serial_ctx.buffer_config.rx_buffer_size = 256; // 硬件缓冲区
+ g_serial_ctx.buffer_config.rx_buffer = (uint8_t *)osal_kmalloc(256, OSAL_GFP_KERNEL);
+ if (!g_serial_ctx.buffer_config.rx_buffer) {
+ PPP_DEBUG_ERROR("Failed to allocate UART RX buffer");
+ osal_sem_destroy(g_serial_ctx.rx_semaphore);
+ osal_mutex_destroy(g_serial_ctx.rx_mutex);
+ osal_kfree(g_serial_ctx.rx_buffer);
+ osal_kfree(g_serial_ctx.tx_buffer);
+ return PPP_ERR_MEMORY;
+ }
+
+ /* 初始化串口 */
+ errcode_t ret = uapi_uart_init(g_serial_ctx.uart_bus,
+ &g_serial_ctx.pin_config,
+ &g_serial_ctx.uart_attr,
+ NULL,
+ &g_serial_ctx.buffer_config);
+ if (ret != ERRCODE_SUCC) {
+ PPP_DEBUG_ERROR("Failed to initialize UART: %d", ret);
+ osal_kfree(g_serial_ctx.buffer_config.rx_buffer);
+ osal_sem_destroy(g_serial_ctx.rx_semaphore);
+ osal_mutex_destroy(g_serial_ctx.rx_mutex);
+ osal_kfree(g_serial_ctx.rx_buffer);
+ osal_kfree(g_serial_ctx.tx_buffer);
+ return PPP_ERR_UART;
+ }
+
+ /* 注册接收回调 */
+ ret = uapi_uart_register_rx_callback(g_serial_ctx.uart_bus,
+ UART_RX_CONDITION_FULL_OR_SUFFICIENT_DATA_OR_IDLE,
+ 1, // 接收到1个字节就触发回调
+ ppp_serial_rx_callback);
+ if (ret != ERRCODE_SUCC) {
+ PPP_DEBUG_ERROR("Failed to register UART RX callback: %d", ret);
+ uapi_uart_deinit(g_serial_ctx.uart_bus);
+ osal_kfree(g_serial_ctx.buffer_config.rx_buffer);
+ osal_sem_destroy(g_serial_ctx.rx_semaphore);
+ osal_mutex_destroy(g_serial_ctx.rx_mutex);
+ osal_kfree(g_serial_ctx.rx_buffer);
+ osal_kfree(g_serial_ctx.tx_buffer);
+ return PPP_ERR_UART;
+ }
+
+ /* 初始化缓冲区状态 */
+ g_serial_ctx.rx_head = 0;
+ g_serial_ctx.rx_tail = 0;
+ g_serial_ctx.rx_count = 0;
+
+ /* 清零统计信息 */
+ g_serial_ctx.tx_bytes = 0;
+ g_serial_ctx.rx_bytes = 0;
+ g_serial_ctx.tx_errors = 0;
+ g_serial_ctx.rx_errors = 0;
+
+ g_serial_ctx.initialized = true;
+ PPP_DEBUG_INFO("PPP serial initialized successfully");
+
+ return PPP_ERR_OK;
+}
+
+/**
+ * @brief 反初始化PPP串口
+ */
+void ppp_serial_deinit(void)
+{
+ if (!g_serial_ctx.initialized) {
+ return;
+ }
+
+ PPP_DEBUG_INFO("Deinitializing PPP serial");
+
+ /* 反初始化串口 */
+ uapi_uart_deinit(g_serial_ctx.uart_bus);
+
+ /* 释放资源 */
+ if (g_serial_ctx.buffer_config.rx_buffer) {
+ osal_kfree(g_serial_ctx.buffer_config.rx_buffer);
+ }
+
+ if (g_serial_ctx.rx_semaphore) {
+ osal_sem_destroy(g_serial_ctx.rx_semaphore);
+ }
+
+ if (g_serial_ctx.rx_mutex) {
+ osal_mutex_destroy(g_serial_ctx.rx_mutex);
+ }
+
+ if (g_serial_ctx.rx_buffer) {
+ osal_kfree(g_serial_ctx.rx_buffer);
+ }
+
+ if (g_serial_ctx.tx_buffer) {
+ osal_kfree(g_serial_ctx.tx_buffer);
+ }
+
+ memset_s(&g_serial_ctx, sizeof(g_serial_ctx), 0, sizeof(g_serial_ctx));
+ PPP_DEBUG_INFO("PPP serial deinitialized");
+}
+
+/**
+ * @brief 发送数据
+ */
+ppp_error_t ppp_serial_write(const uint8_t *data, uint32_t length)
+{
+ if (!g_serial_ctx.initialized || !data || length == 0) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ if (length > g_serial_ctx.tx_buffer_size) {
+ PPP_DEBUG_ERROR("Data length exceeds TX buffer size");
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ PPP_DEBUG_DEBUG("Sending %u bytes", length);
+ PPP_DEBUG_HEXDUMP(data, length);
+
+ /* 复制数据到发送缓冲区 */
+ memcpy_s(g_serial_ctx.tx_buffer, g_serial_ctx.tx_buffer_size, data, length);
+
+ /* 发送数据 */
+ int32_t bytes_written = uapi_uart_write(g_serial_ctx.uart_bus, g_serial_ctx.tx_buffer, length, 1000);
+
+ if (bytes_written < 0) {
+ PPP_DEBUG_ERROR("UART write failed: %d", bytes_written);
+ g_serial_ctx.tx_errors++;
+ return PPP_ERR_UART;
+ }
+
+ if ((uint32_t)bytes_written != length) {
+ PPP_DEBUG_WARN("Partial write: %d/%u bytes", bytes_written, length);
+ g_serial_ctx.tx_errors++;
+ return PPP_ERR_UART;
+ }
+
+ g_serial_ctx.tx_bytes += (uint32_t)bytes_written;
+ PPP_DEBUG_DEBUG("Sent %u bytes successfully", bytes_written);
+
+ return PPP_ERR_OK;
+}
+
+/**
+ * @brief 读取数据
+ */
+ppp_error_t ppp_serial_read(uint8_t *buffer, uint32_t buffer_size, uint32_t *bytes_read)
+{
+ if (!g_serial_ctx.initialized || !buffer || !bytes_read || buffer_size == 0) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ *bytes_read = 0;
+
+ osal_mutex_lock(g_serial_ctx.rx_mutex);
+
+ uint32_t available = ppp_serial_buffer_data_count();
+ if (available == 0) {
+ osal_mutex_unlock(g_serial_ctx.rx_mutex);
+ return PPP_ERR_OK; // 没有数据可读
+ }
+
+ uint32_t to_read = (available < buffer_size) ? available : buffer_size;
+
+ for (uint32_t i = 0; i < to_read; i++) {
+ buffer[i] = g_serial_ctx.rx_buffer[g_serial_ctx.rx_tail];
+ g_serial_ctx.rx_tail = (g_serial_ctx.rx_tail + 1) % g_serial_ctx.rx_buffer_size;
+ g_serial_ctx.rx_count--;
+ }
+
+ *bytes_read = to_read;
+
+ osal_mutex_unlock(g_serial_ctx.rx_mutex);
+
+ PPP_DEBUG_DEBUG("Read %u bytes", to_read);
+ PPP_DEBUG_HEXDUMP(buffer, to_read);
+
+ return PPP_ERR_OK;
+}
+
+/**
+ * @brief 等待数据接收
+ */
+ppp_error_t ppp_serial_wait_data(uint32_t timeout_ms)
+{
+ if (!g_serial_ctx.initialized) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ /* 检查是否已有数据 */
+ osal_mutex_lock(g_serial_ctx.rx_mutex);
+ bool has_data = (g_serial_ctx.rx_count > 0);
+ osal_mutex_unlock(g_serial_ctx.rx_mutex);
+
+ if (has_data) {
+ return PPP_ERR_OK;
+ }
+
+ /* 等待数据到达 */
+ if (osal_sem_wait(g_serial_ctx.rx_semaphore, timeout_ms) != OSAL_SUCCESS) {
+ return PPP_ERR_TIMEOUT;
+ }
+
+ return PPP_ERR_OK;
+}
+
+/**
+ * @brief 获取可读数据长度
+ */
+uint32_t ppp_serial_available(void)
+{
+ if (!g_serial_ctx.initialized) {
+ return 0;
+ }
+
+ osal_mutex_lock(g_serial_ctx.rx_mutex);
+ uint32_t count = ppp_serial_buffer_data_count();
+ osal_mutex_unlock(g_serial_ctx.rx_mutex);
+
+ return count;
+}
+
+/**
+ * @brief 清空接收缓冲区
+ */
+void ppp_serial_flush_rx(void)
+{
+ if (!g_serial_ctx.initialized) {
+ return;
+ }
+
+ osal_mutex_lock(g_serial_ctx.rx_mutex);
+ g_serial_ctx.rx_head = 0;
+ g_serial_ctx.rx_tail = 0;
+ g_serial_ctx.rx_count = 0;
+ osal_mutex_unlock(g_serial_ctx.rx_mutex);
+
+ PPP_DEBUG_DEBUG("RX buffer flushed");
+}
+
+/**
+ * @brief 设置串口波特率
+ */
+ppp_error_t ppp_serial_set_baudrate(uint32_t baudrate)
+{
+ if (!g_serial_ctx.initialized) {
+ return PPP_ERR_INVALID_PARAM;
+ }
+
+ PPP_DEBUG_INFO("Setting baudrate to %u", baudrate);
+
+ g_serial_ctx.uart_attr.baud_rate = baudrate;
+
+ errcode_t ret = uapi_uart_set_attr(g_serial_ctx.uart_bus, &g_serial_ctx.uart_attr);
+ if (ret != ERRCODE_SUCC) {
+ PPP_DEBUG_ERROR("Failed to set baudrate: %d", ret);
+ return PPP_ERR_UART;
+ }
+
+ PPP_DEBUG_INFO("Baudrate set to %u successfully", baudrate);
+ return PPP_ERR_OK;
+}
+
+/**
+ * @brief 获取统计信息
+ */
+void ppp_serial_get_stats(ppp_serial_stats_t *stats)
+{
+ if (!g_serial_ctx.initialized || !stats) {
+ return;
+ }
+
+ stats->tx_bytes = g_serial_ctx.tx_bytes;
+ stats->rx_bytes = g_serial_ctx.rx_bytes;
+ stats->tx_errors = g_serial_ctx.tx_errors;
+ stats->rx_errors = g_serial_ctx.rx_errors;
+ stats->rx_buffer_usage = g_serial_ctx.rx_count;
+ stats->rx_buffer_size = g_serial_ctx.rx_buffer_size;
+}
+
+/* 内部函数实现 */
+
+/**
+ * @brief 串口接收回调函数
+ */
+static void ppp_serial_rx_callback(const void *buffer, uint16_t length, bool remaining)
+{
+ (void)remaining;
+
+ if (!buffer || length == 0) {
+ return;
+ }
+
+ const uint8_t *data = (const uint8_t *)buffer;
+
+ osal_mutex_lock(g_serial_ctx.rx_mutex);
+
+ /* 检查缓冲区空间 */
+ uint32_t available_space = ppp_serial_buffer_available_space();
+ if (available_space < length) {
+ PPP_DEBUG_WARN("RX buffer overflow, dropping %u bytes", length - available_space);
+ g_serial_ctx.rx_errors++;
+ length = available_space;
+ }
+
+ /* 将数据复制到环形缓冲区 */
+ for (uint16_t i = 0; i < length; i++) {
+ g_serial_ctx.rx_buffer[g_serial_ctx.rx_head] = data[i];
+ g_serial_ctx.rx_head = (g_serial_ctx.rx_head + 1) % g_serial_ctx.rx_buffer_size;
+ g_serial_ctx.rx_count++;
+ }
+
+ g_serial_ctx.rx_bytes += length;
+
+ osal_mutex_unlock(g_serial_ctx.rx_mutex);
+
+ /* 通知有数据到达 */
+ osal_sem_signal(g_serial_ctx.rx_semaphore);
+
+ /* 调用用户回调函数 */
+ if (g_serial_ctx.rx_callback) {
+ g_serial_ctx.rx_callback(data, length, g_serial_ctx.rx_callback_arg);
+ }
+
+ PPP_DEBUG_DEBUG("Received %u bytes", length);
+}
+
+/**
+ * @brief 获取缓冲区可用空间
+ */
+static uint32_t ppp_serial_buffer_available_space(void)
+{
+ return g_serial_ctx.rx_buffer_size - g_serial_ctx.rx_count;
+}
+
+/**
+ * @brief 获取缓冲区数据数量
+ */
+static uint32_t ppp_serial_buffer_data_count(void)
+{
+ return g_serial_ctx.rx_count;
+}
\ No newline at end of file
#endif
#ifdef SUPPORT_CAT1_SERVICE
#include "cat1_tcpServer.h"
+#include "pdu.h"
+#include "lwip/apps/sntp.h"
#endif
// #include "message_notification.h"
// #include "MessageModel.h"
const char *inpdustr = (const char*)argv[0];
- #ifdef SUPPORT_CAT1_SERVICE
+ #if defined(SUPPORT_CAT1_SERVICE) && !defined(SUPPORT_PPP_SERVICE)
pdu_decode_example(inpdustr,0,0,0);
#endif
{
UNUSED(strCommonCmd);
+#if defined(SUPPORT_CAT1_SERVICE) && !defined(SUPPORT_PPP_SERVICE)
if(sntp_enabled()==0)
{
sntp_init();
sntp_stop();
sntp_init();
}
+#endif
wstp_print("CUSTOM_UTILSTEST ATCMD custom_test_sntp sntp_init \n");
return ERRCODE_SUCC;
}
}
static uint32_t custom_cat1_start_ota_pyupdate(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
{
-#ifdef SUPPORT_CAT1_SERVICE
+#if defined(SUPPORT_CAT1_SERVICE) && !defined(SUPPORT_PPP_SERVICE)
Cat1_OTA(CAT1_TCP_START_OTA);
#endif
return ERRCODE_SUCC;
}
static uint32_t custom_cat1_stop_ota_pyupdate(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
{
-#ifdef SUPPORT_CAT1_SERVICE
+#if defined(SUPPORT_CAT1_SERVICE) && !defined(SUPPORT_PPP_SERVICE)
Cat1_OTA(CAT1_TCP_STOP_OTA);
#endif
return ERRCODE_SUCC;
static uint32_t custom_cat1_send_bak_mode(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
{
-#ifdef SUPPORT_CAT1_SERVICE
+#if defined(SUPPORT_CAT1_SERVICE) && !defined(SUPPORT_PPP_SERVICE)
send_bak_mode_toCat1();
#endif
return ERRCODE_SUCC;
projects / mirrors / FD230.git / commitdiff