zhunk 11 months atrás
parent
commit
b2866d3deb

+ 1 - 1
Application_cbd_apm32f1/.settings/projcfg.ini

@@ -1,5 +1,5 @@
 #RT-Thread Studio Project Configuration
 #RT-Thread Studio Project Configuration
-#Mon May 19 16:14:09 CST 2025
+#Tue Dec 02 16:30:43 CST 2025
 project_type=rtt
 project_type=rtt
 chip_name=STM32F103RE
 chip_name=STM32F103RE
 cpu_name=None
 cpu_name=None

+ 12 - 48
Application_cbd_apm32f1/applications/control.c

@@ -588,18 +588,15 @@ uint8_t ctr_shake(uint8_t status_shake,uint16_t shake_sec)
 uint8_t ctr_led(uint8_t status_led)
 uint8_t ctr_led(uint8_t status_led)
 {
 {
     rt_pin_mode(LED_SW, PIN_MODE_OUTPUT);
     rt_pin_mode(LED_SW, PIN_MODE_OUTPUT);
-    if(device_status.version_type==6)
-        rt_pin_mode(LED_P, PIN_MODE_OUTPUT);
+
     if(status_led==ON)
     if(status_led==ON)
     {
     {
         rt_pin_write(LED_SW,ON);
         rt_pin_write(LED_SW,ON);
-        if(device_status.version_type==6)
-        rt_pin_write(LED_P,ON);
+
     }
     }
     else if(status_led==OFF){
     else if(status_led==OFF){
         rt_pin_write(LED_SW,OFF);
         rt_pin_write(LED_SW,OFF);
-        if(device_status.version_type==6)
-            rt_pin_write(LED_P,OFF);
+
     }
     }
     return status_led;
     return status_led;
 }
 }
@@ -706,26 +703,16 @@ void turnzp(void)
 void ctr_router(uint8_t status_router)
 void ctr_router(uint8_t status_router)
 {
 {
     rt_pin_mode(ROUTER, PIN_MODE_OUTPUT);
     rt_pin_mode(ROUTER, PIN_MODE_OUTPUT);
-    if(device_status.version_type==6)
-    rt_pin_mode(ROUTER_P,PIN_MODE_OUTPUT);
 
 
     //rt_pin_mode(POWER_CLEAR, PIN_MODE_OUTPUT);
     //rt_pin_mode(POWER_CLEAR, PIN_MODE_OUTPUT);
     if(status_router==ON)
     if(status_router==ON)
     {
     {
         rt_pin_write(ROUTER,ON);
         rt_pin_write(ROUTER,ON);
-        //
-        #if LAMP_EN == 0
-        if(device_status.version_type==6)
-            rt_pin_write(ROUTER_P,ON);
-        #endif
+
     }
     }
     else {
     else {
         rt_pin_write(ROUTER,OFF);
         rt_pin_write(ROUTER,OFF);
-        //
-        #if LAMP_EN == 0
-        if(device_status.version_type==6)
-            rt_pin_write(ROUTER_P,OFF);
-        #endif
+
     }
     }
 }
 }
 //清扫-推杆电机
 //清扫-推杆电机
@@ -859,35 +846,6 @@ void HK_TakePhoto(void)
     }
     }
     ctr_led(OFF);
     ctr_led(OFF);
 }
 }
-//光控测试任务
-void SunTest(void)
-{
-    rt_uint16_t ui_timeout_l = 0;
-    //未检测到光照,一秒扫描等待,超时30S
-    while(Read_Light_Voltage()<500)
-    {
-        ui_timeout_l ++;
-        rt_thread_delay(1000);
-        if(ui_timeout_l==30) break;
-    }
-    rt_thread_delay(3000);
-    if(Read_Light_Voltage()<500)
-    {
-        device_status.sun_status = 0;//光控状态
-    }
-    if(Read_Light_Voltage()>500)
-    {
-        rt_thread_delay(1000);
-    }
-    rt_thread_delay(3000);
-    if(Read_Light_Voltage()>500)
-    {
-        device_status.sun_status = 1;
-        ctr_lamp(OFF,1);
-    }
-    device_status.sun_test = 0;
-    device_status.work_status=0;
-}
 
 
 /*上电初始化*/
 /*上电初始化*/
 void ResetInit(void)
 void ResetInit(void)
@@ -992,8 +950,14 @@ void WorkTask_BZYV2(void)
 /* 入口函数-工作状态检测 */
 /* 入口函数-工作状态检测 */
 static void Work_status_thread_entry(void *parameter)
 static void Work_status_thread_entry(void *parameter)
 {
 {
-     while(device_status.ds==1&&device_status.temp_status==0)
+     while(1)
      {
      {
+
+         if(device_status.ds==0||device_status.temp_status==1){
+             device_status.work_status = 0;
+             continue;
+         }
+
          while(alarmCheck(device_status.collecting_sh1,device_status.collecting_eh1,device_status.collt_min_sh1,device_status.collt_min_eh1) == ON)
          while(alarmCheck(device_status.collecting_sh1,device_status.collecting_eh1,device_status.collt_min_sh1,device_status.collt_min_eh1) == ON)
          {
          {
              device_status.work_status = 1;
              device_status.work_status = 1;

+ 1 - 5
Application_cbd_apm32f1/applications/control.h

@@ -17,7 +17,7 @@
 #define SENSOR_EN        0              //温湿度:0关闭,1打开
 #define SENSOR_EN        0              //温湿度:0关闭,1打开
 ////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////
 
 
-#define VERSION_BZY         "2.5.10"                   //孢子仪
+#define VERSION_BZY         "2.6.11"                   //孢子仪
 
 
 
 
 /*********************************************************************/
 /*********************************************************************/
@@ -227,10 +227,6 @@ typedef struct
 
 
 #define CTR_RO_LIMIT GET_PIN(B,15)
 #define CTR_RO_LIMIT GET_PIN(B,15)
 #define CTR_RC_LIMIT GET_PIN(C,6)
 #define CTR_RC_LIMIT GET_PIN(C,6)
-/******************************吸虫塔*********************************/
-#define HK_5000W_P GET_PIN(B,12)
-#define ROUTER_P   GET_PIN(B,10)
-#define LED_P      GET_PIN(B,11)
 
 
 #define PC7_TIM3_CH 2   //pwm8
 #define PC7_TIM3_CH 2   //pwm8
 #define PC8_TIM3_CH 3   //pwm8
 #define PC8_TIM3_CH 3   //pwm8

+ 82 - 192
Application_cbd_apm32f1/applications/dtu_uart2.c

@@ -23,6 +23,7 @@
 #include <ymodem.h>
 #include <ymodem.h>
 #include "beep.h"
 #include "beep.h"
 #include <selfcheck.h>
 #include <selfcheck.h>
+#include <lwjson.h>
 #define DBG_ENABLE
 #define DBG_ENABLE
 #define DBG_COLOR
 #define DBG_COLOR
 #define DBG_TAG "dtu"
 #define DBG_TAG "dtu"
@@ -47,16 +48,17 @@ struct rx_msg
     rt_size_t size;
     rt_size_t size;
 };
 };
 /* 消息队列句柄 */
 /* 消息队列句柄 */
-static struct rt_messagequeue  rx_mq_dtu;
+static struct rt_semaphore rx_sem;    /* 用于接收消息的信号量 */
 rt_thread_t dtu_recv_data = RT_NULL;
 rt_thread_t dtu_recv_data = RT_NULL;
 rt_thread_t dtu_send_data = RT_NULL;
 rt_thread_t dtu_send_data = RT_NULL;
 
 
-
 rt_device_t dtuserial;   /*串口设备句柄*/
 rt_device_t dtuserial;   /*串口设备句柄*/
 struct  serial_configure dtuconfig = RT_SERIAL_CONFIG_DEFAULT;  /*初始化配置参数*/
 struct  serial_configure dtuconfig = RT_SERIAL_CONFIG_DEFAULT;  /*初始化配置参数*/
 
 
 static uint8_t makejson_sta = 0;
 static uint8_t makejson_sta = 0;
 
 
+static lwjson_stream_parser_t lwparser;
+
 static int DTU_uart2_init(void)
 static int DTU_uart2_init(void)
 {
 {
         dtuserial  = rt_device_find(DTU_UART_NAME);
         dtuserial  = rt_device_find(DTU_UART_NAME);
@@ -75,7 +77,7 @@ static int DTU_uart2_init(void)
         rt_device_control(dtuserial, RT_DEVICE_CTRL_CONFIG, &dtuconfig);
         rt_device_control(dtuserial, RT_DEVICE_CTRL_CONFIG, &dtuconfig);
         /* step4:打开串口设备。以DMA接收及轮询发送模式打开串口设备 */
         /* step4:打开串口设备。以DMA接收及轮询发送模式打开串口设备 */
         #ifdef RT_USING_SERIAL_V2
         #ifdef RT_USING_SERIAL_V2
-        rt_err_t uart_res = rt_device_open(dtuserial, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_RX_NON_BLOCKING); // 串口设备使用模式为 (发送阻塞 接收非阻塞) 模式
+        rt_err_t uart_res = rt_device_open(dtuserial, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING); // 串口设备使用模式为 (发送阻塞 接收非阻塞) 模式
         #else
         #else
         rt_err_t uart_res = rt_device_open(dtuserial, RT_DEVICE_FLAG_DMA_RX);  //RT_DEVICE_FLAG_DMA_RX
         rt_err_t uart_res = rt_device_open(dtuserial, RT_DEVICE_FLAG_DMA_RX);  //RT_DEVICE_FLAG_DMA_RX
         #endif
         #endif
@@ -104,6 +106,7 @@ void DTU_Write(char *fmt, ...)
 /* 接收数据回调函数 */
 /* 接收数据回调函数 */
 static rt_err_t dtu_input(rt_device_t dev, rt_size_t size)
 static rt_err_t dtu_input(rt_device_t dev, rt_size_t size)
 {
 {
+#if 0
     struct rx_msg msg;
     struct rx_msg msg;
     rt_err_t result;
     rt_err_t result;
     msg.dev = dev;
     msg.dev = dev;
@@ -115,135 +118,75 @@ static rt_err_t dtu_input(rt_device_t dev, rt_size_t size)
         LOG_E("rx_mq_dtu message queue full!");
         LOG_E("rx_mq_dtu message queue full!");
         rt_mq_control(&rx_mq_dtu, RT_IPC_CMD_RESET, RT_NULL); // 清空队列
         rt_mq_control(&rx_mq_dtu, RT_IPC_CMD_RESET, RT_NULL); // 清空队列
     }
     }
-    return result;
+#endif
+    /* 串口接收到数据后产生中断,调用此回调函数,然后发送接收信号量 */
+    rt_sem_release(&rx_sem);
+    return RT_EOK;
 }
 }
 
 
-static void dtu_thread_entry_recv(void *parameter)
+
+static dtu_thread_entry_send(void *parameter)
 {
 {
-    struct rx_msg msg;
-    rt_memset(&msg, 0, sizeof(msg));
+    /* 安装信号 */
+    rt_signal_install(SIGUSR2, parseDtu);
+    rt_signal_unmask(SIGUSR2);
+    while(1){
+        rt_thread_mdelay(1000);
+    }
+}
 
 
-    rt_err_t result;
-    rt_uint32_t rx_length;
-    static char accum_buf[1024] = {0};  // 累积缓冲区(根据实际数据量调整)
-    static size_t accum_len = 0;        // 累积缓冲区当前长度
 
 
+static void dtu_thread_entry_recv(void *parameter)
+{
+    static char accum_buf[MAX_DTU_SIZE];  // 累积缓冲区(根据实际数据量调整)
+    static size_t accum_len = 0;        // 累积缓冲区当前长度
+    char ch;
     while (1) {
     while (1) {
-        result = rt_mq_recv(&rx_mq_dtu, &msg, sizeof(struct rx_msg), 50);
-        if (result == RT_EOK) {
-            // 计算实际可读取的缓冲区长度(避免溢出)
-            rx_length = (sizeof(accum_buf) - 1 > msg.size) ? msg.size : (sizeof(accum_buf) - 1 - accum_len);
-            if (rx_length <= 0) {
-                LOG_W("累积缓冲区已满,丢弃新数据!");
-                continue;
-            }
-
-            // 读取串口数据并追加到累积缓冲区
-            rx_length = rt_device_read(msg.dev, 0, accum_buf + accum_len, rx_length);
-            if (rx_length > 0) {
-                accum_len += rx_length;
-                accum_buf[accum_len] = '\0';  // 方便打印
-                LOG_D("累积接收数据: %s", accum_buf);
-            }
-
-            // 查找并解析完整的 JSON 数据包
-            char *json_start = strchr(accum_buf, '{');
-            if (json_start != NULL) {
-                char *json_end = strrchr(json_start, '}');
-                if (json_end != NULL) {
-                    size_t json_len = json_end - json_start + 1;
-                    char json_data[json_len + 1];
-                    memcpy(json_data, json_start, json_len);
-                    json_data[json_len] = '\0';
-
-                    // 解析 JSON(确保 parseDtu 能处理完整数据)
-                    parseDtu(json_data);
-
-                    // 截断累积缓冲区,保留剩余数据
-                    size_t remaining_len = accum_len - (json_end - accum_buf + 1);
-                    if (remaining_len > 0) {
-                        memmove(accum_buf, json_end + 1, remaining_len);
-                        accum_len = remaining_len;
-                        accum_buf[accum_len] = '\0';
-                    } else {
-                        accum_len = 0;  // 无剩余数据,清空缓冲区
-                    }
-                }
-            }
-
-            // 其他逻辑(如状态标记)
-            device_status.C01 &= ~(1 << 13);  // 通信正常
+        /* 从串口读取一个字节的数据,没有读取到则等待接收信号量 */
+        while (rt_device_read(dtuserial, -1, &ch, 1) != 1)
+        {
+            /* 阻塞等待接收信号量,等到信号量后再次读取数据 */
+            rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
+        }
+        accum_buf[accum_len++]=ch;
+        if (accum_len >= sizeof(accum_buf)) {
+            // 防止超范围
+            accum_len = 0;
+            lwjson_stream_reset(&lwparser);
+            continue;
         }
         }
+        lwjsonr_t ret;
+        ret = lwjson_stream_parse(&lwparser, ch); // 把串口数据逐字节的喂给解析器去解析
+        switch(ret)
+        {
+            case lwjsonERRJSON:             // 1, 无效的字符
+              case lwjsonSTREAMWAITFIRSTCHAR: // 2, 等待首字符
+                LOG_W("invalid JSON byte:%s[%x]",ch,ch);
+                break;
+              case lwjsonSTREAMINPROG:        // 3, 正在解析中
+                break;
+              case lwjsonSTREAMDONE:          // 4, 解析已完成
+                 parseDtu(accum_buf);
+                 accum_len = 0;
+                 //rt_thread_kill(dtu_send_data, SIGUSR2);
+                 lwjson_stream_reset(&lwparser);
+                 break;
+              case lwjsonERRMEM:             // 5, 嵌套的太深("LWJSON_CFG_STREAM_STACK_SIZE")
+                 LOG_E("parser stack overflow (ERRMEM), resetting parser!");
+                 lwjson_stream_reset(&lwparser);
+                 break;
+              default: // 流式解析时, 其它的返回值, 都不应该出现
+                  LOG_E("internal error, lwjson_stream_parse() returned: %d, data receive thread will exit!!!",ret);
+                  break;
+          }
     }
     }
 }
 }
-#if 0
-static void dtu_thread_entry_recv(void *parameter)
-{
-    struct rx_msg msg;
-    rt_memset(&msg, 0, sizeof(msg));
 
 
-    rt_err_t result;
-    rt_uint32_t rx_length;
-    static char str_check[2]={'{','}'};
-    static char rx_buffer[512];
-    static char rx_buffer_tmp[512];
-    static char rx_buffer_tmp2[512];
-    while(1)
-    {
-        result = rt_mq_recv(&rx_mq_dtu, &msg, sizeof(struct rx_msg), 50);
-        #if 1
-        if(result == RT_EOK)
-        {
-            rx_length =(sizeof(rx_buffer) - 1) > msg.size ?
-                    msg.size : sizeof(rx_buffer) - 1;
-            rx_length = rt_device_read(msg.dev, 0, &rx_buffer[0], rx_length);
-            rx_buffer[rx_length] = '\0';
-            LOG_D("recv data:%s",rx_buffer);
-            if(strstr(rx_buffer,"{")==RT_NULL||strstr(rx_buffer,"}")==RT_NULL)
-            {
-                if(device_status.dtype==3)
-                {
-                    HMI_WRITE("sysSet.va0.txt=\"%s\"",rx_buffer);
-                    rt_timer_stop(timer_uart2);
-                }
-            }
-            device_status.C01 &= ~(1<<13);   //通信 正常
-            //过滤异常数据
-            char str_check_head[2];
-            char str_check_end[2];
-            rt_sprintf(str_check_head, "%c",rx_buffer[0]);
-            rt_sprintf(str_check_end, "%c",rx_buffer[rx_length-1]);
-            if(str_check_end[0]==str_check[1]&&str_check_head[0]==str_check[0])
-            {
-                  parseDtu(rx_buffer);
-                  rt_memset(rx_buffer,0,sizeof(rx_buffer));
-                  rt_memset(rx_buffer_tmp,0,sizeof(rx_buffer_tmp));
-                  rt_memset(rx_buffer_tmp2,0,sizeof(rx_buffer_tmp2));
-            }
-            else {
-                   if(rx_buffer[rx_length-1]!='}')
-                   {
-                       rt_sprintf(rx_buffer_tmp, "%s",rx_buffer);
-                   }
-                   else {
-                       rt_sprintf(rx_buffer_tmp2,"%s",rx_buffer);
-                       rt_sprintf(rx_buffer, "%s%s",rx_buffer_tmp,rx_buffer_tmp2);
-                       parseDtu(rx_buffer);
-                       rt_memset(rx_buffer,0,sizeof(rx_buffer));
-                       rt_memset(rx_buffer_tmp,0,sizeof(rx_buffer_tmp));
-                       rt_memset(rx_buffer_tmp2,0,sizeof(rx_buffer_tmp2));
-                   }
-                 }
 
 
-         }
-   }
-        #endif
-}
-#endif
 int delete_thrad_dtu_recv_data(void)
 int delete_thrad_dtu_recv_data(void)
 {
 {
     LOG_W("delete_thrad_dtu_recv_data.");
     LOG_W("delete_thrad_dtu_recv_data.");
-    rt_mq_delete(&rx_mq_dtu);
+    //rt_mq_delete(&rx_mq_dtu);
 //    if(dtu_recv_data!=RT_NULL)
 //    if(dtu_recv_data!=RT_NULL)
 //    {
 //    {
 //        rt_thread_delete(dtu_recv_data);
 //        rt_thread_delete(dtu_recv_data);
@@ -253,17 +196,21 @@ int delete_thrad_dtu_recv_data(void)
 /* 创建线程 */
 /* 创建线程 */
 int dtu_data_play(void)
 int dtu_data_play(void)
 {
 {
+    lwjson_stream_init(&lwparser, NULL);
     rt_err_t rm_dtu_result;
     rt_err_t rm_dtu_result;
     DTU_uart2_init();
     DTU_uart2_init();
     //初始化消息队列
     //初始化消息队列
-    rm_dtu_result = rt_mq_init(&rx_mq_dtu, "dtu", &data_arry.msg_pool[0], 512 - sizeof(void*), sizeof(data_arry.msg_pool), RT_IPC_FLAG_FIFO);
-    if(rm_dtu_result==RT_EOK)
-    {
-        rt_kprintf("消息队列创建成功!!");
-    }
-    else {
-        rt_kprintf("消息队列创建失败!!");
-    }
+    //rm_dtu_result = rt_mq_init(&rx_mq_dtu, "dtu", &data_arry.msg_pool[0], 512 - sizeof(void*), sizeof(data_arry.msg_pool), RT_IPC_FLAG_FIFO);
+//    if(rm_dtu_result==RT_EOK)
+//    {
+//        rt_kprintf("消息队列创建成功!!");
+//    }
+//    else {
+//        rt_kprintf("消息队列创建失败!!");
+//    }
+    /* 初始化信号量 */
+    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
+
     /* 设置接收回调函数 */
     /* 设置接收回调函数 */
     rt_device_set_rx_indicate(dtuserial, dtu_input);
     rt_device_set_rx_indicate(dtuserial, dtu_input);
     #if 0
     #if 0
@@ -274,6 +221,9 @@ int dtu_data_play(void)
                                     3,                              //优先级高是为了保证数据上传的频率的精确度
                                     3,                              //优先级高是为了保证数据上传的频率的精确度
                                     20          //时间片
                                     20          //时间片
             );
             );
+    /* 如果获得线程控制块,启动这个线程 */
+    if(dtu_send_data!=RT_NULL)
+        rt_thread_startup(dtu_send_data);
     #endif
     #endif
     /* 创建线程-指令接收解析*/
     /* 创建线程-指令接收解析*/
     dtu_recv_data = rt_thread_create("t_uart2",
     dtu_recv_data = rt_thread_create("t_uart2",
@@ -281,12 +231,11 @@ int dtu_data_play(void)
             DTU_THREAD_STACK_SIZE,
             DTU_THREAD_STACK_SIZE,
             DTU_THREAD_PRIORITY,
             DTU_THREAD_PRIORITY,
             DTU_THREAD_TIMESLICE);
             DTU_THREAD_TIMESLICE);
-    /* 如果获得线程控制块,启动这个线程 */
-//    if(dtu_send_data!=RT_NULL)
-//        rt_thread_startup(dtu_send_data);
+
     /* 如果获得线程控制块,启动这个线程 */
     /* 如果获得线程控制块,启动这个线程 */
     if (dtu_recv_data != RT_NULL)
     if (dtu_recv_data != RT_NULL)
         rt_thread_startup(dtu_recv_data);
         rt_thread_startup(dtu_recv_data);
+
     return RT_EOK;
     return RT_EOK;
 }
 }
 
 
@@ -749,60 +698,9 @@ char * makeJson()
 }
 }
 
 
 
 
-int Parse_Cam_Param(cJSON *param_msg)
-{
-    cJSON* item_ext=cJSON_GetObjectItem(param_msg,"ext");
-    if(item_ext!=NULL)
-    {
-        cJSON *ExposureTime = cJSON_GetObjectItem(item_ext,"ExposureTime");
-        cJSON *Width = cJSON_GetObjectItem(item_ext,"Width");
-        cJSON *Height = cJSON_GetObjectItem(item_ext,"Height");
-        cJSON *Gamma = cJSON_GetObjectItem(item_ext,"Gamma");
-        cJSON *Hue = cJSON_GetObjectItem(item_ext,"Hue");
-        cJSON *Sharpness = cJSON_GetObjectItem(item_ext,"Sharpness");
-        cJSON *Balance = cJSON_GetObjectItem(item_ext,"Balance");
-        cJSON *LSC = cJSON_GetObjectItem(item_ext,"LSC");
-        if(ExposureTime!=NULL)
-        {
-            char d_ExposureTime[10];
-            sprintf(d_ExposureTime,"%lf",ExposureTime->valuedouble);
-            HMI_WRITE("camera.t9.txt=\"%s\"",d_ExposureTime);
-        }
-        if(Width!=NULL&&Height!=NULL)
-        {
-            HMI_WRITE("camera.cb0.txt=\"%d*%d\"",Width->valueint,Height->valueint);
-        }
-
-        if(Gamma!=NULL)
-        {
-            char d_Gamma[10];
-            sprintf(d_Gamma,"%.1lf",Gamma->valuedouble);
-            HMI_WRITE("camera.t10.txt=\"%s\"",d_Gamma);
-        }
-        if(Hue!=NULL)
-        {
-            HMI_WRITE("camera.t11.txt=\"%d\"",Hue->valueint);
-        }
-        if(Sharpness!=NULL)
-        {
-            HMI_WRITE("camera.t12.txt=\"%d\"",Sharpness->valueint);
-        }
-        if(Balance!=NULL)
-        {
-            HMI_WRITE("camera.cb1.val=%d",Balance->valueint);
-        }
-        if(LSC!=NULL)
-        {
-            HMI_WRITE("camera.sw1.val=%d",LSC->valueint);
-        }
-    }
-    return 0;
-}
-
 //JSON数据解析
 //JSON数据解析
 int parseDtu(char *json_string)
 int parseDtu(char *json_string)
 {
 {
-    char* json_s = NULL;
     cJSON* item_cmd = NULL;    //嵌套ext
     cJSON* item_cmd = NULL;    //嵌套ext
     cJSON* item_focus = NULL;
     cJSON* item_focus = NULL;
     cJSON* item_ext = NULL;    //嵌套ext
     cJSON* item_ext = NULL;    //嵌套ext
@@ -840,7 +738,8 @@ int parseDtu(char *json_string)
     cJSON* movy = NULL;
     cJSON* movy = NULL;
     cJSON* movz = NULL;
     cJSON* movz = NULL;
     cJSON* speed = NULL;
     cJSON* speed = NULL;
-    //rt_kprintf("%s\n",json_string);
+    rt_kprintf("解析串口接受区数据:%s\n",json_string);
+    //LOG_I("解析串口接受区数据:%s",json_string);
     cJSON *root = cJSON_Parse(json_string);
     cJSON *root = cJSON_Parse(json_string);
     if(!root)
     if(!root)
     {
     {
@@ -1133,16 +1032,7 @@ int parseDtu(char *json_string)
                       device_status.camsta = photo_sta->valueint;
                       device_status.camsta = photo_sta->valueint;
                       LOG_I("相机状态:%d",device_status.camsta);
                       LOG_I("相机状态:%d",device_status.camsta);
                   }
                   }
-                  if(value_commn!=RT_NULL)
-                  {
-                      HMI_WRITE("menu.eth1_sta.val=%d",atoi(value_commn->valuestring));
-                  }
-                  value_commn = cJSON_GetObjectItem(item_ext,"cpu_tmp");
-                  if(value_commn!=RT_NULL)
-                  {
-                      HMI_WRITE("menu.cpu_temp.txt=\"%d.%d℃\"",atoi(value_commn->valuestring)/1000,atoi(value_commn->valuestring)%1000);
 
 
-                  }
                   if(strstr(device_status.imei,imei->valuestring)==RT_NULL)
                   if(strstr(device_status.imei,imei->valuestring)==RT_NULL)
                   {
                   {
                        rt_kprintf("Change IMEI:new:%s-old:%s",imei->valuestring,device_status.imei);
                        rt_kprintf("Change IMEI:new:%s-old:%s",imei->valuestring,device_status.imei);
@@ -1267,7 +1157,7 @@ int parseDtu(char *json_string)
                   if(driver_4g!=RT_NULL)
                   if(driver_4g!=RT_NULL)
                   sprintf(device_status.driver_4g,"%s",driver_4g->valuestring);
                   sprintf(device_status.driver_4g,"%s",driver_4g->valuestring);
                   if(project!=RT_NULL)
                   if(project!=RT_NULL)
-                  sprintf(device_status.project,"%s",project->valuestring);
+                      sprintf(device_status.project,"%s",project->valuestring);
                   if(mqttcfg1!=NULL)
                   if(mqttcfg1!=NULL)
                   {
                   {
                       if(strstr("8.136.98.49",mqttcfg1->valuestring)!=RT_NULL)
                       if(strstr("8.136.98.49",mqttcfg1->valuestring)!=RT_NULL)
@@ -1294,7 +1184,7 @@ int parseDtu(char *json_string)
                   }
                   }
                   else if(device_status.num_updata!=0&&device_status.hmi_fresh==2)
                   else if(device_status.num_updata!=0&&device_status.hmi_fresh==2)
                   {
                   {
-                      if(strstr(device_status.project,"A7_DTU_V3")!=RT_NULL||strstr(device_status.project,"Android11")!=RT_NULL)
+                      if(strstr(device_status.project,"cgo")!=RT_NULL||strstr(device_status.project,"Android11")!=RT_NULL)
                       {
                       {
                           UpLoad_Data();
                           UpLoad_Data();
                       }
                       }

+ 4 - 12
Application_cbd_apm32f1/applications/hmi.c

@@ -1768,11 +1768,11 @@ void Check_ParamConfig(void)
             char *readinfo =  makeJson_ReadInfo();
             char *readinfo =  makeJson_ReadInfo();
             DTU_Write("%s",readinfo);
             DTU_Write("%s",readinfo);
             rt_free(readinfo);
             rt_free(readinfo);
-            rt_thread_delay(1000);
+            rt_thread_delay(10000);
             connect_num++;
             connect_num++;
             LOG_I("联网中......%d",connect_num);
             LOG_I("联网中......%d",connect_num);
-            //超时时间为3分钟
-            if(connect_num==180)
+            //超时时间为100S
+            if(connect_num==10)
             {
             {
                 device_status.timeSwitch = 0;
                 device_status.timeSwitch = 0;
                 LOG_W("Time not set:%04d-%02d-%02d %02d:%02d:%02d",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
                 LOG_W("Time not set:%04d-%02d-%02d %02d:%02d:%02d",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
@@ -1780,15 +1780,7 @@ void Check_ParamConfig(void)
             }
             }
         }
         }
         connect_num = 0;
         connect_num = 0;
-        while(atoi(device_status.net)==0)
-        {
-            char *readinfo =  makeJson_ReadInfo();
-            DTU_Write("%s",readinfo);
-            rt_free(readinfo);
-            rt_thread_delay(2000);
-            connect_num++;
-            if(connect_num>5) break;
-        }
+        rt_thread_delay(2000);
         DTU_Write("%s",makeJson_Warn("turnon", "device_stm32"));
         DTU_Write("%s",makeJson_Warn("turnon", "device_stm32"));
         rt_thread_delay(1000);
         rt_thread_delay(1000);
         device_status.num_updata = 1;
         device_status.num_updata = 1;

+ 773 - 0
Application_cbd_apm32f1/applications/lwjson.c

@@ -0,0 +1,773 @@
+/**
+ * \file            lwjson.c
+ * \brief           Lightweight JSON format parser
+ */
+
+/*
+ * Copyright (c) 2024 Tilen MAJERLE
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * This file is part of LwJSON - Lightweight JSON format parser.
+ *
+ * Author:          Tilen MAJERLE <tilen@majerle.eu>
+ * Version:         v1.8.1
+ */
+#include <string.h>
+#include "lwjson.h"
+
+/**
+ * \brief           Internal string object
+ */
+typedef struct {
+    const char* start; /*!< Original pointer to beginning of JSON object */
+    size_t len;        /*!< Total length of input json string */
+    const char* p;     /*!< Current char pointer */
+} lwjson_int_str_t;
+
+/**
+ * \brief           Allocate new token for JSON block
+ * \param[in]       lwobj: LwJSON instance
+ * \return          Pointer to new token
+ */
+static lwjson_token_t*
+prv_alloc_token(lwjson_t* lwobj) {
+    if (lwobj->next_free_token_pos < lwobj->tokens_len) {
+        LWJSON_MEMSET(&lwobj->tokens[lwobj->next_free_token_pos], 0x00, sizeof(*lwobj->tokens));
+        return &lwobj->tokens[lwobj->next_free_token_pos++];
+    }
+    return NULL;
+}
+
+/**
+ * \brief           Skip all characters that are considered *blank* as per RFC4627
+ * \param[in,out]   pobj: Pointer to text that is modified on success
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+static lwjsonr_t
+prv_skip_blank(lwjson_int_str_t* pobj) {
+    while (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p != '\0') {
+        if (*pobj->p == ' ' || *pobj->p == '\t' || *pobj->p == '\r' || *pobj->p == '\n' || *pobj->p == '\f') {
+            ++pobj->p;
+#if LWJSON_CFG_COMMENTS
+            /* Check for comments and remove them */
+        } else if (*pobj->p == '/') {
+            ++pobj->p;
+            if (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p == '*') {
+                ++pobj->p;
+                while (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p != '\0') {
+                    if (*pobj->p == '*') {
+                        ++pobj->p;
+                        if ((size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p == '/') {
+                            ++pobj->p;
+                            break;
+                        }
+                    }
+                    ++pobj->p;
+                }
+            }
+#endif /* LWJSON_CFG_COMMENTS */
+        } else {
+            break;
+        }
+    }
+    if (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p != '\0') {
+        return lwjsonOK;
+    }
+    return lwjsonERRJSON;
+}
+
+/**
+ * \brief           Parse JSON string that must start end end with double quotes `"` character
+ * It just parses length of characters and does not perform any decode operation
+ * \param[in,out]   pobj: Pointer to text that is modified on success
+ * \param[out]      pout: Pointer to pointer to string that is set where string starts
+ * \param[out]      poutlen: Length of string in units of characters is stored here
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+static lwjsonr_t
+prv_parse_string(lwjson_int_str_t* pobj, const char** pout, size_t* poutlen) {
+    lwjsonr_t res;
+    size_t len = 0;
+
+    res = prv_skip_blank(pobj);
+    if (res != lwjsonOK) {
+        return res;
+    }
+    if ((size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p++ != '"') {
+        return lwjsonERRJSON;
+    }
+    *pout = pobj->p;
+    /* Parse string but take care of escape characters */
+    for (;; ++pobj->p, ++len) {
+        if (pobj->p == NULL || (size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p == '\0') {
+            return lwjsonERRJSON;
+        }
+        /* Check special characters */
+        if (*pobj->p == '\\') {
+            ++pobj->p;
+            ++len;
+
+            if ((size_t)(pobj->p - pobj->start) >= pobj->len) {
+                return lwjsonERRJSON;
+            }
+
+            switch (*pobj->p) {
+                case '"':  /* fallthrough */
+                case '\\': /* fallthrough */
+                case '/':  /* fallthrough */
+                case 'b':  /* fallthrough */
+                case 'f':  /* fallthrough */
+                case 'n':  /* fallthrough */
+                case 'r':  /* fallthrough */
+                case 't': break;
+                case 'u':
+                    ++pobj->p;
+                    for (size_t i = 0; i < 4; ++i, ++len) {
+                        if (!(((size_t)(pobj->p - pobj->start) < pobj->len)
+                              && ((*pobj->p >= '0' && *pobj->p <= '9') || (*pobj->p >= 'a' && *pobj->p <= 'f')
+                                  || (*pobj->p >= 'A' && *pobj->p <= 'F')))) {
+                            return lwjsonERRJSON;
+                        }
+                        if (i < 3) {
+                            ++pobj->p;
+                        }
+                    }
+                    break;
+                default: return lwjsonERRJSON;
+            }
+        } else if (*pobj->p == '"') {
+            ++pobj->p;
+            break;
+        }
+    }
+    *poutlen = len;
+    return res;
+}
+
+/**
+ * \brief           Parse property name that must comply with JSON string format as in RFC4627
+ * Property string must be followed by colon character ":"
+ * \param[in,out]   pobj: Pointer to text that is modified on success
+ * \param[out]      t: Token instance to write property name to
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+static lwjsonr_t
+prv_parse_property_name(lwjson_int_str_t* pobj, lwjson_token_t* t) {
+    lwjsonr_t res;
+
+    /* Parse property string first */
+    res = prv_parse_string(pobj, &t->token_name, &t->token_name_len);
+    if (res != lwjsonOK) {
+        return res;
+    }
+    /* Skip any spaces */
+    res = prv_skip_blank(pobj);
+    if (res != lwjsonOK) {
+        return res;
+    }
+    /* Must continue with colon */
+    if ((size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p++ != ':') {
+        return lwjsonERRJSON;
+    }
+    /* Skip any spaces */
+    res = prv_skip_blank(pobj);
+    if (res != lwjsonOK) {
+        return res;
+    }
+    return lwjsonOK;
+}
+
+/**
+ * \brief           Calculate new value for exponent 10^exponent.
+ * \param[in]       exp: Exponent.
+ * \param[in]       is_minus: Indicates whether the exponent is negative.
+ * \return          Value of 10^exponent.
+ */
+static lwjson_real_t
+prv_power10(lwjson_int_t exp, uint8_t is_minus) {
+    lwjson_real_t result = (lwjson_real_t)1;
+    lwjson_real_t base = (lwjson_real_t)10;
+
+    for (; exp > 0; base *= base, exp >>= 1) {
+        if ((exp & 1) == 1) {
+            result *= base;
+        }
+    }
+
+    return is_minus ? ((lwjson_real_t)1 / result) : result;
+}
+
+/**
+ * \brief           Parse number as described in RFC4627
+ * \param[in,out]   pobj: Pointer to text that is modified on success
+ * \param[out]      tout: Pointer to output number format
+ * \param[out]      fout: Pointer to output real-type variable. Used if type is REAL.
+ * \param[out]      iout: Pointer to output int-type variable. Used if type is INT.
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+static lwjsonr_t
+prv_parse_number(lwjson_int_str_t* pobj, lwjson_type_t* tout, lwjson_real_t* fout, lwjson_int_t* iout) {
+    lwjsonr_t res;
+    uint8_t is_minus;
+    lwjson_real_t real_num = 0;
+    lwjson_int_t int_num = 0;
+    lwjson_type_t type = LWJSON_TYPE_NUM_INT;
+
+    res = prv_skip_blank(pobj);
+    if (res != lwjsonOK) {
+        return res;
+    }
+    if ((size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p == '\0') {
+        return lwjsonERRJSON;
+    }
+    is_minus = *pobj->p == '-' ? (++pobj->p, 1) : 0;
+    if ((size_t)(pobj->p - pobj->start) >= pobj->len /* End of json input */
+        || *pobj->p == '\0'                          /* Invalid string */
+        || *pobj->p < '0' || *pobj->p > '9'          /* Character outside number range */
+        || (*pobj->p == '0' && (size_t)(pobj->p + 1 - pobj->start) < pobj->len
+            && (pobj->p[1] >= '0' && pobj->p[1] <= '9'))) { /* Number starts with 0 but not followed by dot */
+        return lwjsonERRJSON;
+    }
+
+    /* Parse number */
+    for (int_num = 0; (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p >= '0' && *pobj->p <= '9'; ++pobj->p) {
+        int_num = int_num * (lwjson_int_t)10 + (*pobj->p - '0');
+    }
+
+    real_num = (lwjson_real_t)int_num;
+
+    if (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p == '.') { /* Number has exponent */
+        lwjson_real_t exp;
+        lwjson_int_t dec_num;
+
+        real_num = (lwjson_real_t)int_num;
+
+        type = LWJSON_TYPE_NUM_REAL; /* Format is real */
+        ++pobj->p;                   /* Ignore comma character */
+        if ((size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p < '0'
+            || *pobj->p > '9') { /* Must be followed by number characters */
+            return lwjsonERRJSON;
+        }
+
+        /* Get number after decimal point */
+        for (exp = (lwjson_real_t)1, dec_num = 0;
+             (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p >= '0' && *pobj->p <= '9';
+             ++pobj->p, exp *= (lwjson_real_t)10) {
+            dec_num = dec_num * (lwjson_int_t)10 + (lwjson_int_t)(*pobj->p - '0');
+        }
+
+        /* Add decimal part to number */
+        real_num += (lwjson_real_t)dec_num / exp;
+    }
+    if (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len
+        && (*pobj->p == 'e' || *pobj->p == 'E')) { /* Engineering mode */
+        uint8_t is_minus_exp;
+        lwjson_int_t exp_cnt;
+
+        type = LWJSON_TYPE_NUM_REAL; /* Format is real */
+        ++pobj->p;                   /* Ignore enginnering sing part */
+        if ((size_t)(pobj->p - pobj->start) >= pobj->len) {
+            return lwjsonERRJSON;
+        }
+        is_minus_exp = *pobj->p == '-' ? (++pobj->p, 1) : 0;                  /* Check if negative */
+        if ((size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p == '+') { /* Optional '+' is possible too */
+            ++pobj->p;
+        }
+        if ((size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p < '0'
+            || *pobj->p > '9') { /* Must be followed by number characters */
+            return lwjsonERRJSON;
+        }
+
+        /* Parse exponent number */
+        for (exp_cnt = 0; (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p >= '0' && *pobj->p <= '9';
+             ++pobj->p) {
+            exp_cnt = exp_cnt * (lwjson_int_t)10 + (lwjson_int_t)(*pobj->p - '0');
+        }
+
+        /* Calculate new value for exponent 10^exponent */
+        real_num *= prv_power10(exp_cnt, is_minus_exp);
+    }
+
+    /* Write output values */
+    if (tout != NULL) {
+        *tout = type;
+    }
+    if (type == LWJSON_TYPE_NUM_INT) {
+        *iout = is_minus ? -int_num : int_num;
+    } else {
+        *fout = is_minus ? -real_num : real_num;
+    }
+    return lwjsonOK;
+}
+
+/**
+ * \brief           Create path segment from input path for search operation
+ * \param[in,out]   ppath: Pointer to pointer to input path. Pointer is modified
+ * \param[out]      opath: Pointer to pointer to write path segment
+ * \param[out]      olen: Pointer to variable to write length of segment
+ * \param[out]      is_last: Pointer to write if this is last segment
+ * \return          `1` on success, `0` otherwise
+ */
+static uint8_t
+prv_create_path_segment(const char** ppath, const char** opath, size_t* olen, uint8_t* is_last) {
+    const char* segment = *ppath;
+
+    *is_last = 0;
+    *opath = NULL;
+    *olen = 0;
+
+    /* Check input path */
+    if (segment == NULL || *segment == '\0') {
+        *is_last = 1;
+        return 0;
+    }
+
+    /*
+     * Path must be one of:
+     * - literal text
+     * - "#" followed by dot "."
+     */
+    if (*segment == '#') {
+        *opath = segment;
+        for (*olen = 0;; ++segment, ++(*olen)) {
+            if (*segment == '.') {
+                ++segment;
+                break;
+            } else if (*segment == '\0') {
+                if (*olen == 1) {
+                    return 0;
+                } else {
+                    break;
+                }
+            }
+        }
+        *ppath = segment;
+    } else {
+        *opath = segment;
+        for (*olen = 0; *segment != '\0' && *segment != '.'; ++(*olen), ++segment) {}
+        *ppath = segment + 1;
+    }
+    if (*segment == '\0') {
+        *is_last = 1;
+    }
+    return 1;
+}
+
+/**
+ * \brief           Input recursive function for find operation
+ * \param[in]       parent: Parent token of type \ref LWJSON_TYPE_ARRAY or LWJSON_TYPE_OBJECT
+ * \param[in]       path: Path to search for starting this token further
+ * \return          Found token on success, `NULL` otherwise
+ */
+static const lwjson_token_t*
+prv_find(const lwjson_token_t* parent, const char* path) {
+    const char* segment;
+    size_t segment_len;
+    uint8_t is_last, res;
+
+    /* Get path segments */
+    res = prv_create_path_segment(&path, &segment, &segment_len, &is_last);
+    if (res != 0) {
+        /* Check if detected an array request */
+        if (*segment == '#') {
+            /* Parent must be array */
+            if (parent->type != LWJSON_TYPE_ARRAY) {
+                return NULL;
+            }
+
+            /* Check if index requested */
+            if (segment_len > 1) {
+                const lwjson_token_t* tkn;
+                size_t index = 0;
+
+                /* Parse number */
+                for (size_t i = 1; i < segment_len; ++i) {
+                    if (segment[i] < '0' || segment[i] > '9') {
+                        return NULL;
+                    } else {
+                        index = index * 10 + (segment[i] - '0');
+                    }
+                }
+
+                /* Start from beginning */
+                for (tkn = parent->u.first_child; tkn != NULL && index > 0; tkn = tkn->next, --index) {}
+                if (tkn != NULL) {
+                    if (is_last) {
+                        return tkn;
+                    } else {
+                        return prv_find(tkn, path);
+                    }
+                }
+                return NULL;
+            }
+
+            /* Scan all indexes and get first match */
+            for (const lwjson_token_t* tkn = parent->u.first_child; tkn != NULL; tkn = tkn->next) {
+                const lwjson_token_t* tmp = prv_find(tkn, path);
+                if (tmp != NULL) {
+                    return tmp;
+                }
+            }
+        } else {
+            if (parent->type != LWJSON_TYPE_OBJECT) {
+                return NULL;
+            }
+            for (const lwjson_token_t* tkn = parent->u.first_child; tkn != NULL; tkn = tkn->next) {
+                if (tkn->token_name_len == segment_len && !strncmp(tkn->token_name, segment, segment_len)) {
+                    const lwjson_token_t* tmp;
+                    if (is_last) {
+                        return tkn;
+                    }
+                    tmp = prv_find(tkn, path);
+                    if (tmp != NULL) {
+                        return tmp;
+                    }
+                }
+            }
+        }
+    }
+    return NULL;
+}
+
+/**
+ * \brief           Check for character after opening bracket of array or object
+ * \param[in,out]   pobj: JSON string
+ * \param[in]       t: Token to check for type
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+static inline lwjsonr_t
+prv_check_valid_char_after_open_bracket(lwjson_int_str_t* pobj, lwjson_token_t* t) {
+    lwjsonr_t res;
+
+    /* Check next character after object open */
+    res = prv_skip_blank(pobj);
+    if (res != lwjsonOK) {
+        return res;
+    }
+    if ((size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p == '\0'
+        || (t->type == LWJSON_TYPE_OBJECT && (*pobj->p != '"' && *pobj->p != '}'))
+        || (t->type == LWJSON_TYPE_ARRAY
+            && (*pobj->p != '"' && *pobj->p != ']' && *pobj->p != '[' && *pobj->p != '{' && *pobj->p != '-'
+                && (*pobj->p < '0' || *pobj->p > '9') && *pobj->p != 't' && *pobj->p != 'n' && *pobj->p != 'f'))) {
+        res = lwjsonERRJSON;
+    }
+    return res;
+}
+
+/**
+ * \brief           Setup LwJSON instance for parsing JSON strings
+ * \param[in,out]   lwobj: LwJSON instance
+ * \param[in]       tokens: Pointer to array of tokens used for parsing
+ * \param[in]       tokens_len: Number of tokens
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+lwjsonr_t
+lwjson_init(lwjson_t* lwobj, lwjson_token_t* tokens, size_t tokens_len) {
+    LWJSON_MEMSET(lwobj, 0x00, sizeof(*lwobj));
+    LWJSON_MEMSET(tokens, 0x00, sizeof(*tokens) * tokens_len);
+    lwobj->tokens = tokens;
+    lwobj->tokens_len = tokens_len;
+    lwobj->first_token.type = LWJSON_TYPE_OBJECT;
+    return lwjsonOK;
+}
+
+/**
+ * \brief           Parse JSON data with length parameter
+ * JSON format must be complete and must comply with RFC4627
+ * \param[in,out]   lwobj: LwJSON instance
+ * \param[in]       json_data: JSON string to parse
+ * \param[in]       jsonČlen: JSON data length
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+lwjsonr_t
+lwjson_parse_ex(lwjson_t* lwobj, const void* json_data, size_t json_len) {
+    lwjsonr_t res = lwjsonOK;
+    lwjson_token_t *t, *to;
+    lwjson_int_str_t pobj = {.start = json_data, .len = json_len, .p = json_data};
+
+    /* Check input parameters */
+    if (lwobj == NULL || json_data == NULL || json_len == 0) {
+        res = lwjsonERRPAR;
+        goto ret;
+    }
+
+    /* set first token */
+    to = &lwobj->first_token;
+
+    /* values from very beginning */
+    lwobj->flags.parsed = 0;
+    lwobj->next_free_token_pos = 0;
+    LWJSON_MEMSET(to, 0x00, sizeof(*to));
+
+    /* First parse */
+    res = prv_skip_blank(&pobj);
+    if (res != lwjsonOK) {
+        goto ret;
+    }
+    if ((size_t)(pobj.p - pobj.start) >= pobj.len) {
+        res = lwjsonERRJSON;
+        goto ret;
+    }
+    if (*pobj.p == '{') {
+        to->type = LWJSON_TYPE_OBJECT;
+    } else if (*pobj.p == '[') {
+        to->type = LWJSON_TYPE_ARRAY;
+    } else {
+        res = lwjsonERRJSON;
+        goto ret;
+    }
+    ++pobj.p;
+    res = prv_check_valid_char_after_open_bracket(&pobj, to);
+    if (res != lwjsonOK) {
+        goto ret;
+    }
+
+    /* Process all characters as indicated by input user */
+    while (pobj.p != NULL && (size_t)(pobj.p - pobj.start) < pobj.len && *pobj.p != '\0') {
+        /* Filter out blanks */
+        res = prv_skip_blank(&pobj);
+        if (res != lwjsonOK) {
+            goto ret;
+        }
+        if (*pobj.p == ',') {
+            ++pobj.p;
+            continue;
+        }
+
+        /* Check if end of object or array*/
+        if (*pobj.p == (to->type == LWJSON_TYPE_OBJECT ? '}' : ']')) {
+            lwjson_token_t* parent = to->next;
+            to->next = NULL;
+            ++pobj.p;
+
+            /* End of string if to == NULL (no parent), check if properly terminated */
+            to = parent;
+            if (to == NULL) {
+                prv_skip_blank(&pobj);
+                res = (pobj.p == NULL || (size_t)(pobj.p - pobj.start) >= pobj.len || *pobj.p == '\0') ? lwjsonOK
+                                                                                                       : lwjsonERR;
+                goto ret;
+            }
+            continue;
+        }
+
+        /* Allocate new token */
+        t = prv_alloc_token(lwobj);
+        if (t == NULL) {
+            res = lwjsonERRMEM;
+            goto ret;
+        }
+
+        /* If object type is not array, first thing is property that starts with quotes */
+        if (to->type != LWJSON_TYPE_ARRAY) {
+            if (*pobj.p != '"') {
+                res = lwjsonERRJSON;
+                goto ret;
+            }
+            res = prv_parse_property_name(&pobj, t);
+            if (res != lwjsonOK) {
+                goto ret;
+            }
+        }
+
+        /* Add element to linked list */
+        if (to->u.first_child == NULL) {
+            to->u.first_child = t;
+        } else {
+            lwjson_token_t* c;
+            for (c = to->u.first_child; c->next != NULL; c = c->next) {}
+            c->next = t;
+        }
+
+        /* Check next character to process */
+        switch (*pobj.p) {
+            case '{':
+            case '[':
+                t->type = *pobj.p == '{' ? LWJSON_TYPE_OBJECT : LWJSON_TYPE_ARRAY;
+                ++pobj.p;
+
+                res = prv_check_valid_char_after_open_bracket(&pobj, t);
+                if (res != lwjsonOK) {
+                    goto ret;
+                }
+                t->next = to; /* Temporary saved as parent object */
+                to = t;
+                break;
+            case '"':
+                res = prv_parse_string(&pobj, &t->u.str.token_value, &t->u.str.token_value_len);
+                if (res == lwjsonOK) {
+                    t->type = LWJSON_TYPE_STRING;
+                } else {
+                    goto ret;
+                }
+                break;
+            case 't':
+                /* RFC4627 is lower-case only */
+                if ((size_t)(pobj.p + 3 - pobj.start) < pobj.len && strncmp(pobj.p, "true", 4) == 0) {
+                    t->type = LWJSON_TYPE_TRUE;
+                    pobj.p += 4;
+                } else {
+                    res = lwjsonERRJSON;
+                    goto ret;
+                }
+                break;
+            case 'f':
+                /* RFC4627 is lower-case only */
+                if ((size_t)(pobj.p + 4 - pobj.start) < pobj.len && strncmp(pobj.p, "false", 5) == 0) {
+                    t->type = LWJSON_TYPE_FALSE;
+                    pobj.p += 5;
+                } else {
+                    res = lwjsonERRJSON;
+                    goto ret;
+                }
+                break;
+            case 'n':
+                /* RFC4627 is lower-case only */
+                if ((size_t)(pobj.p + 3 - pobj.start) < pobj.len && strncmp(pobj.p, "null", 4) == 0) {
+                    t->type = LWJSON_TYPE_NULL;
+                    pobj.p += 4;
+                } else {
+                    res = lwjsonERRJSON;
+                    goto ret;
+                }
+                break;
+            default:
+                if (*pobj.p == '-' || (*pobj.p >= '0' && *pobj.p <= '9')) {
+                    if (prv_parse_number(&pobj, &t->type, &t->u.num_real, &t->u.num_int) != lwjsonOK) {
+                        res = lwjsonERRJSON;
+                        goto ret;
+                    }
+                } else {
+                    res = lwjsonERRJSON;
+                    goto ret;
+                }
+                break;
+        }
+
+        /* Below code is used to check characters after valid tokens */
+        if (t->type == LWJSON_TYPE_ARRAY || t->type == LWJSON_TYPE_OBJECT) {
+            continue;
+        }
+
+        /*
+         * Check what are values after the token value
+         *
+         * As per RFC4627, every token value may have one or more
+         * blank characters, followed by one of below options:
+         *  - Comma separator for next token
+         *  - End of array indication
+         *  - End of object indication
+         */
+        res = prv_skip_blank(&pobj);
+        if (res != lwjsonOK) {
+            goto ret;
+        }
+        /* Check if valid string is availabe after */
+        if (pobj.p == NULL || (size_t)(pobj.p - pobj.start) >= pobj.len || *pobj.p == '\0'
+            || (*pobj.p != ',' && *pobj.p != ']' && *pobj.p != '}')) {
+            res = lwjsonERRJSON;
+            goto ret;
+        } else if (*pobj.p == ',') { /* Check to advance to next token immediately */
+            ++pobj.p;
+        }
+    }
+    if (to != &lwobj->first_token || (to != NULL && to->next != NULL)) {
+        res = lwjsonERRJSON;
+        to = NULL;
+    }
+    if (to != NULL) {
+        if (to->type != LWJSON_TYPE_ARRAY && to->type != LWJSON_TYPE_OBJECT) {
+            res = lwjsonERRJSON;
+        }
+        to->token_name = NULL;
+        to->token_name_len = 0;
+    }
+ret:
+    if (res == lwjsonOK) {
+        lwobj->flags.parsed = 1;
+    }
+    return res;
+}
+
+/**
+ * \brief           Parse input JSON format
+ * JSON format must be complete and must comply with RFC4627
+ * \param[in,out]   lwobj: LwJSON instance
+ * \param[in]       json_str: JSON string to parse
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+lwjsonr_t
+lwjson_parse(lwjson_t* lwobj, const char* json_str) {
+    return lwjson_parse_ex(lwobj, json_str, strlen(json_str));
+}
+
+/**
+ * \brief           Free token instances (specially used in case of dynamic memory allocation)
+ * \param[in,out]   lwobj: LwJSON instance
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+lwjsonr_t
+lwjson_free(lwjson_t* lwobj) {
+    LWJSON_MEMSET(lwobj->tokens, 0x00, sizeof(*lwobj->tokens) * lwobj->tokens_len);
+    lwobj->flags.parsed = 0;
+    return lwjsonOK;
+}
+
+/**
+ * \brief           Find first match in the given path for JSON entry
+ * JSON must be valid and parsed with \ref lwjson_parse function
+ * \param[in]       lwobj: JSON instance with parsed JSON string
+ * \param[in]       path: Path with dot-separated entries to search for the JSON key to return
+ * \return          Pointer to found token on success, `NULL` if token cannot be found
+ */
+const lwjson_token_t*
+lwjson_find(lwjson_t* lwobj, const char* path) {
+    if (lwobj == NULL || !lwobj->flags.parsed || path == NULL) {
+        return NULL;
+    }
+    return prv_find(lwjson_get_first_token(lwobj), path);
+}
+
+/**
+ * \brief           Find first match in the given path for JSON path
+ * JSON must be valid and parsed with \ref lwjson_parse function
+ *
+ * \param[in]       lwobj: JSON instance with parsed JSON string
+ * \param[in]       token: Root token to start search at.
+ *                      Token must be type \ref LWJSON_TYPE_OBJECT or \ref LWJSON_TYPE_ARRAY.
+ *                      Set to `NULL` to use root token of LwJSON object
+ * \param[in]       path: path with dot-separated entries to search for JSON key
+ * \return          Pointer to found token on success, `NULL` if token cannot be found
+ */
+const lwjson_token_t*
+lwjson_find_ex(lwjson_t* lwobj, const lwjson_token_t* token, const char* path) {
+    if (lwobj == NULL || !lwobj->flags.parsed || path == NULL) {
+        return NULL;
+    }
+    if (token == NULL) {
+        token = lwjson_get_first_token(lwobj);
+    }
+    if (token == NULL || (token->type != LWJSON_TYPE_ARRAY && token->type != LWJSON_TYPE_OBJECT)) {
+        return NULL;
+    }
+    return prv_find(token, path);
+}

+ 388 - 0
Application_cbd_apm32f1/applications/lwjson.h

@@ -0,0 +1,388 @@
+/**
+ * \file            lwjson.h
+ * \brief           LwJSON - Lightweight JSON format parser
+ */
+
+/*
+ * Copyright (c) 2024 Tilen MAJERLE
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * This file is part of LwJSON - Lightweight JSON format parser.
+ *
+ * Author:          Tilen MAJERLE <tilen@majerle.eu>
+ * Version:         v1.8.1
+ */
+#ifndef LWJSON_HDR_H
+#define LWJSON_HDR_H
+
+#include <stdint.h>
+#include <string.h>
+#include "lwjson_opt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * \defgroup        LWJSON Lightweight JSON format parser
+ * \brief           LwJSON - Lightweight JSON format parser
+ * \{
+ */
+
+/**
+ * \brief           Get size of statically allocated array
+ * \param[in]       x: Object to get array size of
+ * \return          Number of elements in array
+ */
+#define LWJSON_ARRAYSIZE(x) (sizeof(x) / sizeof((x)[0]))
+
+/**
+ * \brief           List of supported JSON types
+ */
+typedef enum {
+    LWJSON_TYPE_STRING,   /*!< String/Text format. Everything that has beginning and ending quote character */
+    LWJSON_TYPE_NUM_INT,  /*!< Number type for integer */
+    LWJSON_TYPE_NUM_REAL, /*!< Number type for real number */
+    LWJSON_TYPE_OBJECT,   /*!< Object data type */
+    LWJSON_TYPE_ARRAY,    /*!< Array data type */
+    LWJSON_TYPE_TRUE,     /*!< True boolean value */
+    LWJSON_TYPE_FALSE,    /*!< False boolean value */
+    LWJSON_TYPE_NULL,     /*!< Null value */
+} lwjson_type_t;
+
+#if defined(LWJSON_DEV)
+extern const char* const lwjson_type_strings[];
+#endif
+
+/**
+ * \brief           Real data type
+ */
+typedef LWJSON_CFG_REAL_TYPE lwjson_real_t;
+
+/**
+ * \brief           Integer data type
+ */
+typedef LWJSON_CFG_INT_TYPE lwjson_int_t;
+
+/**
+ * \brief           JSON token
+ */
+typedef struct lwjson_token {
+    struct lwjson_token* next; /*!< Next token on a list */
+    lwjson_type_t type;        /*!< Token type */
+    const char* token_name;    /*!< Token name (if exists) */
+    size_t token_name_len;     /*!< Length of token name (this is needed to support const input strings to parse) */
+
+    union {
+        struct {
+            const char* token_value; /*!< Pointer to the beginning of the string */
+            size_t
+                token_value_len; /*!< Length of token value (this is needed to support const input strings to parse) */
+        } str;                   /*!< String data */
+
+        lwjson_real_t num_real;           /*!< Real number format */
+        lwjson_int_t num_int;             /*!< Int number format */
+        struct lwjson_token* first_child; /*!< First children object for object or array type */
+    } u;                                  /*!< Union with different data types */
+} lwjson_token_t;
+
+/**
+ * \brief           JSON result enumeration
+ */
+typedef enum {
+    lwjsonOK = 0x00, /*!< Function returns successfully */
+    lwjsonERR,       /*!< Generic error message */
+    lwjsonERRJSON,   /*!< Error JSON format */
+    lwjsonERRMEM,    /*!< Memory error */
+    lwjsonERRPAR,    /*!< Parameter error */
+
+    lwjsonSTREAMWAITFIRSTCHAR, /*!< Streaming parser did not yet receive first valid character
+                                    indicating start of JSON sequence */
+    lwjsonSTREAMDONE,          /*!< Streaming parser is done,
+                                    closing character matched the stream opening one */
+    lwjsonSTREAMINPROG,        /*!< Stream parsing is still in progress */
+} lwjsonr_t;
+
+/**
+ * \brief           LwJSON instance
+ */
+typedef struct {
+    lwjson_token_t* tokens;     /*!< Pointer to array of tokens */
+    size_t tokens_len;          /*!< Size of all tokens */
+    size_t next_free_token_pos; /*!< Position of next free token instance */
+    lwjson_token_t first_token; /*!< First token on a list */
+
+    struct {
+        uint8_t parsed : 1; /*!< Flag indicating JSON parsing has finished successfully */
+    } flags;                /*!< List of flags */
+} lwjson_t;
+
+lwjsonr_t lwjson_init(lwjson_t* lwobj, lwjson_token_t* tokens, size_t tokens_len);
+lwjsonr_t lwjson_parse_ex(lwjson_t* lwobj, const void* json_data, size_t len);
+lwjsonr_t lwjson_parse(lwjson_t* lwobj, const char* json_str);
+const lwjson_token_t* lwjson_find(lwjson_t* lwobj, const char* path);
+const lwjson_token_t* lwjson_find_ex(lwjson_t* lwobj, const lwjson_token_t* token, const char* path);
+lwjsonr_t lwjson_free(lwjson_t* lwobj);
+
+void lwjson_print_token(const lwjson_token_t* token);
+void lwjson_print_json(const lwjson_t* lwobj);
+
+/**
+ * \brief           Object type for streaming parser
+ */
+typedef enum {
+    LWJSON_STREAM_TYPE_NONE,       /*!< No entry - not used */
+    LWJSON_STREAM_TYPE_OBJECT,     /*!< Object indication */
+    LWJSON_STREAM_TYPE_OBJECT_END, /*!< Object end indication */
+    LWJSON_STREAM_TYPE_ARRAY,      /*!< Array indication */
+    LWJSON_STREAM_TYPE_ARRAY_END,  /*!< Array end indication */
+    LWJSON_STREAM_TYPE_KEY,        /*!< Key string */
+    LWJSON_STREAM_TYPE_STRING,     /*!< Strin type */
+    LWJSON_STREAM_TYPE_TRUE,       /*!< True primitive */
+    LWJSON_STREAM_TYPE_FALSE,      /*!< False primitive */
+    LWJSON_STREAM_TYPE_NULL,       /*!< Null primitive */
+    LWJSON_STREAM_TYPE_NUMBER,     /*!< Generic number */
+} lwjson_stream_type_t;
+
+/**
+ * \brief           Stream parsing stack object
+ */
+typedef struct {
+    lwjson_stream_type_t type; /*!< Streaming type - current value */
+
+    union {
+        char name[LWJSON_CFG_STREAM_KEY_MAX_LEN
+                  + 1]; /*!< Last known key name, used only for \ref LWJSON_STREAM_TYPE_KEY type */
+        uint16_t index; /*!< Current index when type is an array */
+    } meta;             /*!< Meta information */
+} lwjson_stream_stack_t;
+
+typedef enum {
+    LWJSON_STREAM_STATE_WAITINGFIRSTCHAR = 0x00, /*!< State to wait for very first opening character */
+    LWJSON_STREAM_STATE_PARSING,        /*!< In parsing of the first char state - detecting next character state */
+    LWJSON_STREAM_STATE_PARSING_STRING, /*!< Parse string primitive */
+    LWJSON_STREAM_STATE_PARSING_PRIMITIVE, /*!< Parse any primitive that is non-string, either "true", "false", "null" or a number */
+    LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END, /*!< Expecting ',', '}' or ']' */
+    LWJSON_STREAM_STATE_EXPECTING_COLON,        /*!< Expecting ':' */
+} lwjson_stream_state_t;
+
+/* Forward declaration */
+struct lwjson_stream_parser;
+
+/**
+ * \brief           Callback function for various events
+ * 
+ */
+typedef void (*lwjson_stream_parser_callback_fn)(struct lwjson_stream_parser* jsp, lwjson_stream_type_t type);
+
+/**
+ * \brief           LwJSON streaming structure
+ */
+typedef struct lwjson_stream_parser {
+    lwjson_stream_stack_t
+        stack[LWJSON_CFG_STREAM_STACK_SIZE]; /*!< Stack used for parsing. TODO: Add conditional compilation flag */
+    size_t stack_pos;                        /*!< Current stack position */
+
+    lwjson_stream_state_t parse_state; /*!< Parser state */
+
+    lwjson_stream_parser_callback_fn evt_fn; /*!< Event function for user */
+
+    void* user_data; /*!< User data for callback function */
+
+    /* State */
+    union {
+        struct {
+            char buff[LWJSON_CFG_STREAM_STRING_MAX_LEN
+                      + 1];        /*!< Buffer to write temporary data. TODO: Size to be variable with define */
+            size_t buff_pos;       /*!< Buffer position for next write (length of bytes in buffer) */
+            size_t buff_total_pos; /*!< Total buffer position used up to now (in several data chunks) */
+            uint8_t is_last;       /*!< Status indicates if this is the last part of the string */
+        } str;                     /*!< String structure. It is only used for keys and string objects.
+                                        Use primitive part for all other options */
+
+        struct {
+            char buff[LWJSON_CFG_STREAM_PRIMITIVE_MAX_LEN + 1]; /*!< Temporary write buffer */
+            size_t buff_pos;                                    /*!< Buffer position for next write */
+        } prim; /*!< Primitive object. Used for all types, except key or string */
+
+        /* Todo: Add other types */
+    } data; /*!< Data union used to parse various */
+
+    char prev_c; /*!< History of characters */
+} lwjson_stream_parser_t;
+
+lwjsonr_t lwjson_stream_init(lwjson_stream_parser_t* jsp, lwjson_stream_parser_callback_fn evt_fn);
+lwjsonr_t lwjson_stream_set_user_data(lwjson_stream_parser_t* jsp, void* user_data);
+void* lwjson_stream_get_user_data(lwjson_stream_parser_t* jsp);
+lwjsonr_t lwjson_stream_reset(lwjson_stream_parser_t* jsp);
+lwjsonr_t lwjson_stream_parse(lwjson_stream_parser_t* jsp, char c);
+
+/**
+ * \brief           Get number of tokens used to parse JSON
+ * \param[in]       lwobj: Pointer to LwJSON instance
+ * \return          Number of tokens used to parse JSON
+ */
+#define lwjson_get_tokens_used(lwobj) (((lwobj) != NULL) ? ((lwobj)->next_free_token_pos + 1) : 0)
+
+/**
+ * \brief           Get very first token of LwJSON instance
+ * \param[in]       lwobj: Pointer to LwJSON instance
+ * \return          Pointer to first token
+ */
+#define lwjson_get_first_token(lwobj) (((lwobj) != NULL) ? (&(lwobj)->first_token) : NULL)
+
+/**
+ * \brief           Get token value for \ref LWJSON_TYPE_NUM_INT type
+ * \param[in]       token: token with integer type
+ * \return          Int number if type is integer, `0` otherwise
+ */
+#define lwjson_get_val_int(token)                                                                                      \
+    ((lwjson_int_t)(((token) != NULL && (token)->type == LWJSON_TYPE_NUM_INT) ? (token)->u.num_int : 0))
+
+/**
+ * \brief           Get token value for \ref LWJSON_TYPE_NUM_REAL type
+ * \param[in]       token: token with real type
+ * \return          Real numbeer if type is real, `0` otherwise
+ */
+#define lwjson_get_val_real(token)                                                                                     \
+    ((lwjson_real_t)(((token) != NULL && (token)->type == LWJSON_TYPE_NUM_REAL) ? (token)->u.num_real : 0))
+
+/**
+ * \brief           Get first child token for \ref LWJSON_TYPE_OBJECT or \ref LWJSON_TYPE_ARRAY types
+ * \param[in]       token: token with integer type
+ * \return          Pointer to first child or `NULL` if parent token is not object or array
+ */
+#define lwjson_get_first_child(token)                                                                                  \
+    (const void*)(((token) != NULL && ((token)->type == LWJSON_TYPE_OBJECT || (token)->type == LWJSON_TYPE_ARRAY))     \
+                      ? (token)->u.first_child                                                                         \
+                      : NULL)
+
+/**
+ * \brief           Get string value from JSON token
+ * \param[in]       token: Token with string type
+ * \param[out]      str_len: Pointer to variable holding length of string.
+ *                      Set to `NULL` if not used
+ * \return          Pointer to string or `NULL` if invalid token type
+ */
+static inline const char*
+lwjson_get_val_string(const lwjson_token_t* token, size_t* str_len) {
+    if (token != NULL && token->type == LWJSON_TYPE_STRING) {
+        if (str_len != NULL) {
+            *str_len = token->u.str.token_value_len;
+        }
+        return token->u.str.token_value;
+    }
+    return NULL;
+}
+
+/**
+ * \brief           Get length of string for \ref LWJSON_TYPE_STRING token type
+ * \param[in]       token: token with string type
+ * \return          Length of string in units of bytes
+ */
+#define lwjson_get_val_string_length(token)                                                                            \
+    ((size_t)(((token) != NULL && (token)->type == LWJSON_TYPE_STRING) ? (token)->u.str.token_value_len : 0))
+
+/**
+ * \brief           Compare string token with user input string for a case-sensitive match
+ * \param[in]       token: Token with string type
+ * \param[in]       str: NULL-terminated string to compare
+ * \return          `1` if equal, `0` otherwise
+ */
+static inline uint8_t
+lwjson_string_compare(const lwjson_token_t* token, const char* str) {
+    if (token != NULL && token->type == LWJSON_TYPE_STRING) {
+        return strncmp(token->u.str.token_value, str, token->u.str.token_value_len) == 0;
+    }
+    return 0;
+}
+
+/**
+ * \brief           Compare string token with user input string for a case-sensitive match
+ * \param[in]       token: Token with string type
+ * \param[in]       str: NULL-terminated string to compare
+ * \param[in]       len: Length of the string in bytes
+ * \return          `1` if equal, `0` otherwise
+ */
+static inline uint8_t
+lwjson_string_compare_n(const lwjson_token_t* token, const char* str, size_t len) {
+    if (token != NULL && token->type == LWJSON_TYPE_STRING && len <= token->u.str.token_value_len) {
+        return strncmp(token->u.str.token_value, str, len) == 0;
+    }
+    return 0;
+}
+
+/**
+ * \name            LWJSON_STREAM_SEQ
+ * \brief           Helper functions for stack analysis in a callback function
+ * \note            Useful exclusively for streaming functions
+ * \{
+ */
+
+/**
+ * \brief           Check the sequence of JSON stack, starting from start_number index
+ * \note            This applies only to one sequence element. Other macros, starting with
+ *                      `lwjson_stack_seq_X` (where X is the sequence length), provide
+ *                      more parameters for longer sequences.
+ * 
+ * \param[in]       jsp: LwJSON stream instance
+ * \param[in]       start_num: Start number in the stack. Typically starts with `0`, but user may choose another
+ *                      number, if intention is to check partial sequence only
+ * \param[in]       sp0: Stream stack type. Value of \ref lwjson_stream_type_t, but only last part of the enum.
+ *                      If user is interested in the \ref LWJSON_STREAM_TYPE_OBJECT,
+ *                      you should only write `OBJECT` as parameter.
+ *                      Idea behind is to make code smaller and easier to read, especially when
+ *                      using other sequence values with more parameters.
+ * \return          `0` if sequence doesn't match, non-zero otherwise
+ */
+#define lwjson_stack_seq_1(jsp, start_num, sp0) ((jsp)->stack[(start_num)].type == LWJSON_STREAM_TYPE_##sp0)
+#define lwjson_stack_seq_2(jsp, start_num, sp0, sp1)                                                                   \
+    (lwjson_stack_seq_1((jsp), (start_num) + 0, sp0) && lwjson_stack_seq_1((jsp), (start_num) + 1, sp1))
+#define lwjson_stack_seq_3(jsp, start_num, sp0, sp1, sp2)                                                              \
+    (lwjson_stack_seq_1((jsp), (start_num) + 0, sp0) && lwjson_stack_seq_2((jsp), (start_num) + 1, sp1, sp2))
+#define lwjson_stack_seq_4(jsp, start_num, sp0, sp1, sp2, sp3)                                                         \
+    (lwjson_stack_seq_1((jsp), (start_num) + 0, sp0) && lwjson_stack_seq_3((jsp), (start_num) + 1, sp1, sp2, sp3))
+#define lwjson_stack_seq_5(jsp, start_num, sp0, sp1, sp2, sp3, sp4)                                                    \
+    (lwjson_stack_seq_1((jsp), (start_num) + 0, sp0) && lwjson_stack_seq_4((jsp), (start_num) + 1, sp1, sp2, sp3, sp4))
+#define lwjson_stack_seq_6(jsp, start_num, sp0, sp1, sp2, sp3, sp4, sp5)                                               \
+    (lwjson_stack_seq_1((jsp), (start_num) + 0, sp0)                                                                   \
+     && lwjson_stack_seq_5((jsp), (start_num) + 1, sp1, sp2, sp3, sp4, sp5))
+#define lwjson_stack_seq_7(jsp, start_num, sp0, sp1, sp2, sp3, sp4, sp5, sp6)                                          \
+    (lwjson_stack_seq_1((jsp), (start_num) + 0, sp0)                                                                   \
+     && lwjson_stack_seq_6((jsp), (start_num) + 1, sp1, sp2, sp3, sp4, sp5, sp6))
+#define lwjson_stack_seq_8(jsp, start_num, sp0, sp1, sp2, sp3, sp4, sp5, sp6, sp7)                                     \
+    (lwjson_stack_seq_1((jsp), (start_num) + 0, sp0)                                                                   \
+     && lwjson_stack_seq_7((jsp), (start_num) + 1, sp1, sp2, sp3, sp4, sp5, sp6, sp7))
+
+/**
+ * \}
+ */
+
+/**
+ * \}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* LWJSON_HDR_H */

+ 133 - 0
Application_cbd_apm32f1/applications/lwjson_debug.c

@@ -0,0 +1,133 @@
+/**
+ * \file            lwjson_debug.c
+ * \brief           Debug and print function for tokens
+ */
+
+/*
+ * Copyright (c) 2024 Tilen MAJERLE
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * This file is part of LwJSON - Lightweight JSON format parser.
+ *
+ * Author:          Tilen MAJERLE <tilen@majerle.eu>
+ * Version:         v1.8.1
+ */
+#include <stdio.h>
+#include <string.h>
+#include "lwjson.h"
+
+/**
+ * \brief           Token print instance
+ */
+typedef struct {
+    size_t indent; /*!< Indent level for token print */
+} lwjson_token_print_t;
+
+/**
+ * \brief           Print token value
+ * \param[in]       prt: Token print instance
+ * \param[in]       token: Token to print
+ */
+static void
+prv_print_token(lwjson_token_print_t* prt, const lwjson_token_t* token) {
+#define print_indent() printf("%.*s", (int)((prt->indent)), "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t");
+
+    if (token == NULL) {
+        return;
+    }
+
+    /* Check if token has a name */
+    print_indent();
+    if (token->token_name != NULL) {
+        printf("\"%.*s\":", (int)token->token_name_len, token->token_name);
+    }
+
+    /* Print different types */
+    switch (token->type) {
+        case LWJSON_TYPE_OBJECT:
+        case LWJSON_TYPE_ARRAY: {
+            printf("%c", token->type == LWJSON_TYPE_OBJECT ? '{' : '[');
+            if (token->u.first_child != NULL) {
+                printf("\n");
+                ++prt->indent;
+                for (const lwjson_token_t* t = lwjson_get_first_child(token); t != NULL; t = t->next) {
+                    prv_print_token(prt, t);
+                }
+                --prt->indent;
+                print_indent();
+            }
+            printf("%c", token->type == LWJSON_TYPE_OBJECT ? '}' : ']');
+            break;
+        }
+        case LWJSON_TYPE_STRING: {
+            printf("\"%.*s\"", (int)lwjson_get_val_string_length(token), lwjson_get_val_string(token, NULL));
+            break;
+        }
+        case LWJSON_TYPE_NUM_INT: {
+            printf("%lld", (long long)lwjson_get_val_int(token));
+            break;
+        }
+        case LWJSON_TYPE_NUM_REAL: {
+            printf("%f", (double)lwjson_get_val_real(token));
+            break;
+        }
+        case LWJSON_TYPE_TRUE: {
+            printf("true");
+            break;
+        }
+        case LWJSON_TYPE_FALSE: {
+            printf("false");
+            break;
+        }
+        case LWJSON_TYPE_NULL: {
+            printf("NULL");
+            break;
+        }
+        default: break;
+    }
+    if (token->next != NULL) {
+        printf(",");
+    }
+    printf("\n");
+}
+
+/**
+ * \brief           Prints and outputs token data to the stream output
+ * \note            This function is not re-entrant
+ * \param[in]       token: Token to print
+ */
+void
+lwjson_print_token(const lwjson_token_t* token) {
+    lwjson_token_print_t prt = {0};
+    prv_print_token(&prt, token);
+}
+
+/**
+ * \brief           Prints and outputs full parsed LwJSON instance
+ * \note            This function is not re-entrant
+ * \param[in]       lwobj: LwJSON instance to print
+ */
+void
+lwjson_print_json(const lwjson_t* lwobj) {
+    lwjson_token_print_t prt = {0};
+    prv_print_token(&prt, lwjson_get_first_token(lwobj));
+}

+ 153 - 0
Application_cbd_apm32f1/applications/lwjson_opt.h

@@ -0,0 +1,153 @@
+/**
+ * \file            lwjson_opt.h
+ * \brief           LwJSON options
+ */
+
+/*
+ * Copyright (c) 2024 Tilen MAJERLE
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * This file is part of LwJSON - Lightweight JSON format parser.
+ *
+ * Author:          Tilen MAJERLE <tilen@majerle.eu>
+ * Version:         v1.8.1
+ */
+#ifndef LWJSON_OPT_HDR_H
+#define LWJSON_OPT_HDR_H
+
+/* Uncomment to ignore user options (or set macro in compiler flags) */
+/* #define LWJSON_IGNORE_USER_OPTS */
+
+/* Include application options */
+#ifndef LWJSON_IGNORE_USER_OPTS
+#include "lwjson_opts.h"
+#endif /* LWJSON_IGNORE_USER_OPTS */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * \defgroup        LWJSON_OPT Configuration
+ * \brief           LwJSON options
+ * \{
+ */
+
+/**
+ * \brief           Real data type used to parse numbers with floating point number
+ * \note            Data type must be signed, normally `float` or `double`
+ *
+ * This is used for numbers in \ref LWJSON_TYPE_NUM_REAL token data type.
+ */
+#ifndef LWJSON_CFG_REAL_TYPE
+#define LWJSON_CFG_REAL_TYPE float
+#endif
+
+/**
+ * \brief           Integer type used to parse numbers
+ * \note            Data type must be signed integer
+ *
+ * This is used for numbers in \ref LWJSON_TYPE_NUM_INT token data type.
+ */
+#ifndef LWJSON_CFG_INT_TYPE
+#define LWJSON_CFG_INT_TYPE long long
+#endif
+
+/**
+ * \brief           Enables `1` or disables `0` support for inline comments
+ *
+ * Default set to `0` to be JSON compliant
+ */
+#ifndef LWJSON_CFG_COMMENTS
+#define LWJSON_CFG_COMMENTS 0
+#endif
+
+/**
+ * \brief           Memory set function
+ * 
+ * \note            Function footprint is the same as \ref memset
+ */
+#ifndef LWJSON_MEMSET
+#define LWJSON_MEMSET(dst, val, len) memset((dst), (val), (len))
+#endif
+
+/**
+ * \brief           Memory copy function
+ * 
+ * \note            Function footprint is the same as \ref memcpy
+ */
+#ifndef LWJSON_MEMCPY
+#define LWJSON_MEMCPY(dst, src, len) memcpy((dst), (src), (len))
+#endif
+
+/**
+ * \defgroup        LWJSON_OPT_STREAM JSON stream
+ * \brief           JSON streaming confiuration
+ * \{
+ */
+
+/**
+ * \brief           Max length of token key (object key name) to be available for stack storage
+ * 
+ */
+#ifndef LWJSON_CFG_STREAM_KEY_MAX_LEN
+#define LWJSON_CFG_STREAM_KEY_MAX_LEN 32
+#endif
+
+/**
+ * \brief           Max stack size (depth) in units of \ref lwjson_stream_stack_t structure
+ * 
+ */
+#ifndef LWJSON_CFG_STREAM_STACK_SIZE
+#define LWJSON_CFG_STREAM_STACK_SIZE 16
+#endif
+
+/**
+ * \brief           Max size of string for single parsing in units of bytes
+ * 
+ */
+#ifndef LWJSON_CFG_STREAM_STRING_MAX_LEN
+#define LWJSON_CFG_STREAM_STRING_MAX_LEN 256
+#endif
+
+/**
+ * \brief           Max number of bytes used to parse primitive.
+ * 
+ * Primitives are all numbers and logical values (null, true, false)
+ */
+#ifndef LWJSON_CFG_STREAM_PRIMITIVE_MAX_LEN
+#define LWJSON_CFG_STREAM_PRIMITIVE_MAX_LEN 32
+#endif
+
+/**
+ * \}
+ */
+
+/**
+ * \}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* LWJSON_OPT_HDR_H */

+ 44 - 0
Application_cbd_apm32f1/applications/lwjson_opts.h

@@ -0,0 +1,44 @@
+/**
+ * \file            lwjson_opts_template.h
+ * \brief           Template config file
+ */
+
+/*
+ * Copyright (c) 2024 Tilen MAJERLE
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * This file is part of LwJSON - Lightweight JSON format parser.
+ *
+ * Author:          Tilen MAJERLE <tilen@majerle.eu>
+ * Version:         v1.8.1
+ */
+#ifndef LWJSON_OPTS_HDR_H
+#define LWJSON_OPTS_HDR_H
+
+/* Rename this file to "lwjson_opts.h" for your application */
+
+/*
+ * Open "include/lwjson/lwjson_opt.h" and
+ * copy & replace here settings you want to change values
+ */
+
+#endif /* LWJSON_OPTS_HDR_H */

+ 501 - 0
Application_cbd_apm32f1/applications/lwjson_stream.c

@@ -0,0 +1,501 @@
+/**
+ * \file            lwjson_stream.c
+ * \brief           Lightweight JSON format parser
+ */
+
+/*
+ * Copyright (c) 2024 Tilen MAJERLE
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * This file is part of LwJSON - Lightweight JSON format parser.
+ *
+ * Author:          Tilen MAJERLE <tilen@majerle.eu>
+ * Version:         v1.8.1
+ */
+#include <string.h>
+#include "lwjson.h"
+
+#if defined(LWJSON_DEV)
+#include <stdio.h>
+#define DEBUG_STRING_PREFIX_SPACES                                                                                     \
+    "                                                                                                "
+#define LWJSON_DEBUG(jsp, ...)                                                                                         \
+    do {                                                                                                               \
+        if ((jsp) != NULL) {                                                                                           \
+            printf("%.*s", (int)(4 * (jsp)->stack_pos), DEBUG_STRING_PREFIX_SPACES);                                   \
+        }                                                                                                              \
+        printf(__VA_ARGS__);                                                                                           \
+    } while (0)
+
+/* Strings for debug */
+const char* const lwjson_type_strings[] = {
+    [LWJSON_STREAM_TYPE_NONE] = "none",
+    [LWJSON_STREAM_TYPE_OBJECT] = "object",
+    [LWJSON_STREAM_TYPE_OBJECT_END] = "object_end",
+    [LWJSON_STREAM_TYPE_ARRAY] = "array",
+    [LWJSON_STREAM_TYPE_ARRAY_END] = "array_end",
+    [LWJSON_STREAM_TYPE_KEY] = "key",
+    [LWJSON_STREAM_TYPE_STRING] = "string",
+    [LWJSON_STREAM_TYPE_TRUE] = "true",
+    [LWJSON_STREAM_TYPE_FALSE] = "false",
+    [LWJSON_STREAM_TYPE_NULL] = "null",
+    [LWJSON_STREAM_TYPE_NUMBER] = "number",
+};
+#else
+#define LWJSON_DEBUG(jsp, ...)
+#endif /* defined(LWJSON_DEV) */
+
+/**
+ * \brief           Sends an event to user for further processing
+ * 
+ */
+#define SEND_EVT(jsp, type)                                                                                            \
+    if ((jsp) != NULL && (jsp)->evt_fn != NULL) {                                                                      \
+        (jsp)->evt_fn((jsp), (type));                                                                                  \
+    }
+
+/**
+ * \brief           Check if character is a space character (with extended chars)
+ * \param[in]       c: Character to check
+ * \return          `1` if considered extended space, `0` otherwise
+ */
+#define prv_is_space_char_ext(c) ((c) == ' ' || (c) == '\t' || (c) == '\r' || (c) == '\n' || (c) == '\f')
+
+/**
+ * \brief           Push "parent" state to the artificial stack
+ * \param           jsp: JSON stream parser instance
+ * \param           type: Stream type to be pushed on stack
+ * \return          `1` on success, `0` otherwise
+ */
+static uint8_t
+prv_stack_push(lwjson_stream_parser_t* jsp, lwjson_stream_type_t type) {
+    if (jsp->stack_pos < LWJSON_ARRAYSIZE(jsp->stack)) {
+        jsp->stack[jsp->stack_pos].type = type;
+        jsp->stack[jsp->stack_pos].meta.index = 0;
+        LWJSON_DEBUG(jsp, "Pushed to stack: %s\r\n", lwjson_type_strings[type]);
+        jsp->stack_pos++;
+        return 1;
+    }
+    return 0;
+}
+
+/**
+ * \brief           Pop value from stack (remove it) and return its value
+ * \param           jsp: JSON stream parser instance
+ * \return          Member of \ref lwjson_stream_type_t enumeration 
+ */
+static lwjson_stream_type_t
+prv_stack_pop(lwjson_stream_parser_t* jsp) {
+    if (jsp->stack_pos > 0) {
+        lwjson_stream_type_t type = jsp->stack[--jsp->stack_pos].type;
+
+        jsp->stack[jsp->stack_pos].type = LWJSON_STREAM_TYPE_NONE;
+        LWJSON_DEBUG(jsp, "Popped from stack: %s\r\n", lwjson_type_strings[type]);
+
+        /* Take care of array to indicate number of entries */
+        if (jsp->stack_pos > 0 && jsp->stack[jsp->stack_pos - 1].type == LWJSON_STREAM_TYPE_ARRAY) {
+            jsp->stack[jsp->stack_pos - 1].meta.index++;
+        }
+        return type;
+    }
+    return LWJSON_STREAM_TYPE_NONE;
+}
+
+/**
+ * \brief           Get top type value currently on the stack
+ * \param           jsp: JSON stream parser instance
+ * \return          Member of \ref lwjson_stream_type_t enumeration 
+ */
+static lwjson_stream_type_t
+prv_stack_get_top(lwjson_stream_parser_t* jsp) {
+    if (jsp->stack_pos > 0) {
+        return jsp->stack[jsp->stack_pos - 1].type;
+    }
+    return LWJSON_STREAM_TYPE_NONE;
+}
+
+/**
+ * \brief           Initialize LwJSON stream object before parsing takes place
+ * \param[in,out]   jsp: Stream JSON structure 
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+lwjsonr_t
+lwjson_stream_init(lwjson_stream_parser_t* jsp, lwjson_stream_parser_callback_fn evt_fn) {
+    LWJSON_MEMSET(jsp, 0x00, sizeof(*jsp));
+    jsp->parse_state = LWJSON_STREAM_STATE_WAITINGFIRSTCHAR;
+    jsp->evt_fn = evt_fn;
+    jsp->user_data = NULL;
+    return lwjsonOK;
+}
+
+/**
+ * \brief           Reset LwJSON stream structure
+ * 
+ * \param[in,out]   jsp: LwJSON stream parser
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+lwjsonr_t
+lwjson_stream_reset(lwjson_stream_parser_t* jsp) {
+    jsp->parse_state = LWJSON_STREAM_STATE_WAITINGFIRSTCHAR;
+    jsp->stack_pos = 0;
+    return lwjsonOK;
+}
+
+/**
+ * \brief           Set user_data in stream parser
+ * 
+ * \param[in,out]   jsp: LwJSON stream parser
+ * \param[in]       user_data: user data
+ * \return          \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
+ */
+lwjsonr_t
+lwjson_stream_set_user_data(lwjson_stream_parser_t* jsp, void* user_data) {
+    jsp->user_data = user_data;
+    return lwjsonOK;
+}
+
+/**
+ * \brief           Get user_data in stream parser
+ * 
+ * \param[in]       jsp: LwJSON stream parser
+ * \return          pointer to user data
+ */
+void*
+lwjson_stream_get_user_data(lwjson_stream_parser_t* jsp) {
+    return jsp->user_data;
+}
+
+/**
+ * \brief           Parse JSON string in streaming mode
+ * \param[in,out]   jsp: Stream JSON structure 
+ * \param[in]       chr: Character to parse
+ * \return          \ref lwjsonSTREAMWAITFIRSTCHAR when stream did not start parsing since no valid start character has been received
+ * \return          \ref lwjsonSTREAMINPROG if parsing is in progress and no hard error detected
+ * \return          \ref lwjsonSTREAMDONE when valid JSON was detected and stack level reached back `0` level
+ * \return          \ref One of enumeration otherwise
+ */
+lwjsonr_t
+lwjson_stream_parse(lwjson_stream_parser_t* jsp, char chr) {
+    /* Get first character first */
+    if (jsp->parse_state == LWJSON_STREAM_STATE_WAITINGFIRSTCHAR && chr != '{' && chr != '[') {
+        return prv_is_space_char_ext(chr) ? lwjsonSTREAMWAITFIRSTCHAR : lwjsonERRJSON;
+    }
+
+start_over:
+    /* Determine what to do from parsing state */
+    switch (jsp->parse_state) {
+
+        /*
+         * Waiting for very first valid characters,
+         * that is used to indicate start of JSON stream
+         */
+        case LWJSON_STREAM_STATE_WAITINGFIRSTCHAR:
+        case LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END:
+        case LWJSON_STREAM_STATE_PARSING: {
+            /* Ignore whitespace chars */
+            if (prv_is_space_char_ext(chr)) {
+                break;
+
+                /* Determine value separator */
+            } else if (chr == ',') {
+                if (jsp->parse_state == LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END) {
+                    jsp->parse_state = LWJSON_STREAM_STATE_PARSING;
+                } else {
+                    LWJSON_DEBUG(jsp, "ERROR - ',' can only follow value\r\n");
+                    return lwjsonERRJSON;
+                }
+
+                /* Determine end of object or an array */
+            } else if (chr == '}' || chr == ']') {
+                lwjson_stream_type_t type = prv_stack_get_top(jsp);
+
+                /* 
+                 * If it is a key last entry on closing area,
+                 * it is an error - an example: {"key":}
+                 */
+                if (type == LWJSON_STREAM_TYPE_KEY) {
+                    LWJSON_DEBUG(jsp, "ERROR - key should not be followed by ] without value for a key\r\n");
+                    return lwjsonERRJSON;
+                }
+
+                /*
+                 * Check if closing character matches stack value
+                 * Avoid cases like: {"key":"value"] or ["v1", "v2", "v3"}
+                 */
+                if ((chr == '}' && type != LWJSON_STREAM_TYPE_OBJECT)
+                    || (chr == ']' && type != LWJSON_STREAM_TYPE_ARRAY)) {
+                    LWJSON_DEBUG(jsp, "ERROR - closing character '%c' does not match stack element \"%s\"\r\n", chr,
+                                 lwjson_type_strings[type]);
+                    return lwjsonERRJSON;
+                }
+
+                /* Now remove the array or object from stack */
+                if (prv_stack_pop(jsp) == LWJSON_STREAM_TYPE_NONE) {
+                    return lwjsonERRJSON;
+                }
+
+                SEND_EVT(jsp, chr == '}' ? LWJSON_STREAM_TYPE_OBJECT_END : LWJSON_STREAM_TYPE_ARRAY_END);
+
+                /*
+                 * Check if above is a key type
+                 * and remove it too as we finished with processing of potential case.
+                 * 
+                 * {"key":{"abc":1}} - remove "key" part
+                 */
+                if (prv_stack_get_top(jsp) == LWJSON_STREAM_TYPE_KEY) {
+                    prv_stack_pop(jsp);
+                }
+
+                /* If that is the end of JSON */
+                if (jsp->stack_pos == 0) {
+                    lwjson_stream_reset(jsp);
+                    return lwjsonSTREAMDONE;
+                }
+
+                jsp->parse_state = LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END;
+
+                /* If comma or end was expected, then it is already error here */
+            } else if (jsp->parse_state == LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END) {
+                LWJSON_DEBUG(jsp, "ERROR - ',', '}' or ']' was expected\r\n");
+                return lwjsonERRJSON;
+
+                /* Determine start of string - can be key or regular string (in array or after key) */
+            } else if (chr == '"') {
+#if defined(LWJSON_DEV)
+                lwjson_stream_type_t type = prv_stack_get_top(jsp);
+                if (type == LWJSON_STREAM_TYPE_OBJECT) {
+                    LWJSON_DEBUG(jsp, "Start of string parsing - expected key name in an object\r\n");
+                } else if (type == LWJSON_STREAM_TYPE_KEY) {
+                    LWJSON_DEBUG(jsp,
+                                 "Start of string parsing - string value associated to previous key in an object\r\n");
+                } else if (type == LWJSON_STREAM_TYPE_ARRAY) {
+                    LWJSON_DEBUG(jsp, "Start of string parsing - string entry in an array\r\n");
+                }
+#endif /* defined(LWJSON_DEV) */
+                jsp->parse_state = LWJSON_STREAM_STATE_PARSING_STRING;
+                LWJSON_MEMSET(&jsp->data.str, 0x00, sizeof(jsp->data.str));
+
+            } else if (prv_stack_get_top(jsp) == LWJSON_STREAM_TYPE_OBJECT) {
+                /* Key must be before value */
+                LWJSON_DEBUG(jsp, "ERROR - key must be before value\r\n");
+                return lwjsonERRJSON;
+
+                /* Determine start of object or an array */
+            } else if (chr == '{' || chr == '[') {
+                /* Reset stack pointer if this character came from waiting for first character */
+                if (jsp->parse_state == LWJSON_STREAM_STATE_WAITINGFIRSTCHAR) {
+                    jsp->stack_pos = 0;
+                }
+                SEND_EVT(jsp, chr == '{' ? LWJSON_STREAM_TYPE_OBJECT : LWJSON_STREAM_TYPE_ARRAY);
+                if (!prv_stack_push(jsp, chr == '{' ? LWJSON_STREAM_TYPE_OBJECT : LWJSON_STREAM_TYPE_ARRAY)) {
+                    LWJSON_DEBUG(jsp, "Cannot push object/array to stack\r\n");
+                    return lwjsonERRMEM;
+                }
+                jsp->parse_state = LWJSON_STREAM_STATE_PARSING;
+
+                /* Check if this is start of number or "true", "false" or "null" */
+            } else if (chr == '-' || (chr >= '0' && chr <= '9') || chr == 't' || chr == 'f' || chr == 'n') {
+                if (prv_stack_get_top(jsp) == LWJSON_STREAM_TYPE_OBJECT) {
+                    LWJSON_DEBUG(jsp, "ERROR - key must be before value (primitive)\r\n");
+                    /* Key must be before value */
+                    return lwjsonERRJSON;
+                }
+
+                LWJSON_DEBUG(jsp, "Start of primitive parsing parsing - %s, First char: %c\r\n",
+                             (chr == '-' || (chr >= '0' && chr <= '9')) ? "number" : "true,false,null", chr);
+                jsp->parse_state = LWJSON_STREAM_STATE_PARSING_PRIMITIVE;
+                LWJSON_MEMSET(&jsp->data.prim, 0x00, sizeof(jsp->data.prim));
+                jsp->data.prim.buff[jsp->data.prim.buff_pos++] = chr;
+
+                /* Wrong char */
+            } else {
+                LWJSON_DEBUG(jsp, "ERROR - wrong char %c\r\n", chr);
+                return lwjsonERRJSON;
+            }
+            break;
+        }
+
+        /* Check for end of key character i.e. name separator ':' */
+        case LWJSON_STREAM_STATE_EXPECTING_COLON:
+            /* Ignore whitespace chars */
+            if (prv_is_space_char_ext(chr)) {
+                break;
+            } else if (chr == ':') {
+                jsp->parse_state = LWJSON_STREAM_STATE_PARSING;
+            } else {
+                LWJSON_DEBUG(jsp, "ERROR - expecting ':'\r\n");
+                return lwjsonERRJSON;
+            }
+            break;
+
+        /*
+         * Parse any type of string in a sequence
+         *
+         * It is used for key or string in an object or an array
+         */
+        case LWJSON_STREAM_STATE_PARSING_STRING: {
+            lwjson_stream_type_t type = prv_stack_get_top(jsp);
+
+            /* 
+             * Quote character may trigger end of string, 
+             * or if backslasled before - it is part of string
+             * 
+             * TODO: Handle backslash
+             */
+            if (chr == '"' && jsp->prev_c != '\\') {
+#if defined(LWJSON_DEV)
+                if (type == LWJSON_STREAM_TYPE_OBJECT) {
+                    LWJSON_DEBUG(jsp, "End of string parsing - object key name: \"%s\"\r\n", jsp->data.str.buff);
+                } else if (type == LWJSON_STREAM_TYPE_KEY) {
+                    LWJSON_DEBUG(
+                        jsp, "End of string parsing - string value associated to previous key in an object: \"%s\"\r\n",
+                        jsp->data.str.buff);
+                } else if (type == LWJSON_STREAM_TYPE_ARRAY) {
+                    LWJSON_DEBUG(jsp, "End of string parsing - an array string entry: \"%s\"\r\n", jsp->data.str.buff);
+                }
+#endif /* defined(LWJSON_DEV) */
+
+                /* Set is_last to 1 as this is the last part of this string token */
+                jsp->data.str.is_last = 1;
+
+                /*
+                 * When top of stack is object - string is treated as a key
+                 * When top of stack is a key - string is a value for a key - notify user and pop the value for key
+                 * When top of stack is an array - string is one type - notify user and don't do anything
+                 */
+                jsp->parse_state = LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END;
+                if (type == LWJSON_STREAM_TYPE_OBJECT) {
+                    SEND_EVT(jsp, LWJSON_STREAM_TYPE_KEY);
+                    if (prv_stack_push(jsp, LWJSON_STREAM_TYPE_KEY)) {
+                        size_t len = jsp->data.str.buff_pos;
+                        if (len > (sizeof(jsp->stack[0].meta.name) - 1)) {
+                            len = sizeof(jsp->stack[0].meta.name) - 1;
+                        }
+                        LWJSON_MEMCPY(jsp->stack[jsp->stack_pos - 1].meta.name, jsp->data.str.buff, len);
+                        jsp->stack[jsp->stack_pos - 1].meta.name[len] = '\0';
+                    } else {
+                        LWJSON_DEBUG(jsp, "Cannot push key to stack\r\n");
+                        return lwjsonERRMEM;
+                    }
+                    jsp->parse_state = LWJSON_STREAM_STATE_EXPECTING_COLON;
+                } else if (type == LWJSON_STREAM_TYPE_KEY) {
+                    SEND_EVT(jsp, LWJSON_STREAM_TYPE_STRING);
+                    prv_stack_pop(jsp);
+                    /* Next character to wait for is either space or comma or end of object */
+                } else if (type == LWJSON_STREAM_TYPE_ARRAY) {
+                    SEND_EVT(jsp, LWJSON_STREAM_TYPE_STRING);
+                    jsp->stack[jsp->stack_pos - 1].meta.index++;
+                }
+            } else {
+                /* TODO: Check other backslash elements */
+                jsp->data.str.buff[jsp->data.str.buff_pos++] = chr;
+                jsp->data.str.buff_total_pos++;
+
+                /* Handle buffer "overflow" */
+                if (jsp->data.str.buff_pos >= (LWJSON_CFG_STREAM_STRING_MAX_LEN - 1)) {
+                    jsp->data.str.buff[jsp->data.str.buff_pos] = '\0';
+
+                    /* 
+                     * - For array or key types - following one is always string
+                     * - For object type - character is key
+                     */
+                    SEND_EVT(jsp, (type == LWJSON_STREAM_TYPE_KEY || type == LWJSON_STREAM_TYPE_ARRAY)
+                                      ? LWJSON_STREAM_TYPE_STRING
+                                      : LWJSON_STREAM_TYPE_KEY);
+                    jsp->data.str.buff_pos = 0;
+                }
+            }
+            break;
+        }
+
+        /*
+         * Parse any type of primitive that is not a string.
+         *
+         * true, false, null or any number primitive
+         */
+        case LWJSON_STREAM_STATE_PARSING_PRIMITIVE: {
+            /* Any character except space, comma, or end of array/object are valid */
+            if (!prv_is_space_char_ext(chr) && chr != ',' && chr != ']' && chr != '}') {
+                if (jsp->data.prim.buff_pos < sizeof(jsp->data.prim.buff) - 1) {
+                    jsp->data.prim.buff[jsp->data.prim.buff_pos++] = chr;
+                } else {
+                    LWJSON_DEBUG(jsp, "Buffer overflow for primitive\r\n");
+                    return lwjsonERRJSON;
+                }
+            } else {
+                lwjson_stream_type_t type = prv_stack_get_top(jsp);
+
+#if defined(LWJSON_DEV)
+                if (type == LWJSON_STREAM_TYPE_KEY) {
+                    LWJSON_DEBUG(
+                        jsp,
+                        "End of primitive parsing - string value associated to previous key in an object: \"%s\"\r\n",
+                        jsp->data.prim.buff);
+                } else if (type == LWJSON_STREAM_TYPE_ARRAY) {
+                    LWJSON_DEBUG(jsp, "End of primitive parsing - an array string entry: \"%s\"\r\n",
+                                 jsp->data.prim.buff);
+                }
+#endif /* defined(LWJSON_DEV) */
+
+                /*
+                 * This is the end of primitive parsing
+                 *
+                 * It is assumed that buffer for primitive can handle at least
+                 * true, false, null or all number characters (that being real or int number)
+                 */
+                if (jsp->data.prim.buff_pos == 4 && strncmp(jsp->data.prim.buff, "true", 4) == 0) {
+                    LWJSON_DEBUG(jsp, "Primitive parsed as %s\r\n", "true");
+                    SEND_EVT(jsp, LWJSON_STREAM_TYPE_TRUE);
+                } else if (jsp->data.prim.buff_pos == 4 && strncmp(jsp->data.prim.buff, "null", 4) == 0) {
+                    LWJSON_DEBUG(jsp, "Primitive parsed as %s\r\n", "null");
+                    SEND_EVT(jsp, LWJSON_STREAM_TYPE_NULL);
+                } else if (jsp->data.prim.buff_pos == 5 && strncmp(jsp->data.prim.buff, "false", 5) == 0) {
+                    LWJSON_DEBUG(jsp, "Primitive parsed as %s\r\n", "false");
+                    SEND_EVT(jsp, LWJSON_STREAM_TYPE_FALSE);
+                } else if (jsp->data.prim.buff[0] == '-'
+                           || (jsp->data.prim.buff[0] >= '0' && jsp->data.prim.buff[0] <= '9')) {
+                    LWJSON_DEBUG(jsp, "Primitive parsed - number\r\n");
+                    SEND_EVT(jsp, LWJSON_STREAM_TYPE_NUMBER);
+                } else {
+                    LWJSON_DEBUG(jsp, "Invalid primitive type. Got: %s\r\n", jsp->data.prim.buff);
+                    return lwjsonERRJSON;
+                }
+                if (type == LWJSON_STREAM_TYPE_KEY) {
+                    prv_stack_pop(jsp);
+                } else if (type == LWJSON_STREAM_TYPE_ARRAY) {
+                    jsp->stack[jsp->stack_pos - 1].meta.index++;
+                }
+
+                /* 
+                 * Received character is not part of the primitive and must be processed again
+                 */
+                jsp->parse_state = LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END;
+                goto start_over;
+            }
+            break;
+        }
+
+        default: break;
+    }
+    jsp->prev_c = chr; /* Save current c as previous for next round */
+    return lwjsonSTREAMINPROG;
+}

+ 9 - 0
Application_cbd_apm32f1/readme.md

@@ -1,3 +1,12 @@
+# 2025-12-05 更新说明
+	#define VERSION_BZY         "2.6.11"                   //孢子仪
+	串口解析使用lwjson库
+
+# 2025-12-1 更新说明
+	#define VERSION_BZY         "2.5.11"                   //孢子仪
+	修复从温控状态解除后无法进入工作,需要重启才能恢复的问题;
+	修复接入测报灯RTU会导致DTU_UART线程异常问题,因为调用了HMI_WRITE,并且HMI_WRITE未启动;
+
 # 2025-12-1 更新说明
 # 2025-12-1 更新说明
 	#define VERSION_BZY         "2.5.10"                   //孢子仪
 	#define VERSION_BZY         "2.5.10"                   //孢子仪
 	工作状态增加拍照
 	工作状态增加拍照