leakage

calib_board/usr/algo/algo_queue.c

@@ -0,0 +1,192 @@
+#include "algo_queue.h"
+
+/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD>i<EFBFBD><69>Ԫ<EFBFBD>صĵ<D8B5>ַ */
+#define at(i)                       (((char *)(queue->base))+(i)*(queue->dsize))
+/* <20><><EFBFBD>ݸ<EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4>ַs<D6B7><73><EFBFBD><EFBFBD><EFBFBD>ݸ<EFBFBD><DDB8>Ƶ<EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD><EFBFBD>ַd */
+#define assign(d, s)                memcpy((d), (s), queue->dsize)
+/* <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߼<EFBFBD>λ<EFBFBD><CEBB>i<EFBFBD><69>Ԫ<EFBFBD>ص<EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ѭ<EFBFBD><D1AD><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD> */
+#define qa(i)                       at((queue->head + queue->capacity + (i)) % (queue->capacity))
+
+/* <20><><EFBFBD><EFBFBD><EFBFBD>ڴ渴<DAB4>ƺ<EFBFBD><C6BA><EFBFBD> */
+static void* memcpy(void* dest, const void* src, int n)
+{
+    char* dst = dest;
+    const char* s = src;
+    while (n--) *dst++ = *s++;
+    return dest;
+}
+
+/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD>index<65><78>ʼ<EFBFBD><CABC>size<7A><65>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD>ǰ<EFBFBD>ƶ<EFBFBD>һλ */
+static void move_forward(queue queue, int index, int size)
+{
+    for (int i = index; i < index + size; i++) assign(qa(i - 1), qa(i));
+}
+
+/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD>index<65><78>ʼ<EFBFBD><CABC>size<7A><65>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƶ<EFBFBD>һλ */
+static void move_backward(queue queue, int index, int size)
+{
+    for (int i = index + size; i > index; i--) assign(qa(i), qa(i - 1));
+}
+
+/**
+ *  \brief <20><>׼<EFBFBD><D7BC><EFBFBD>Ӳ<EFBFBD><D3B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>β<EFBFBD><CEB2><EFBFBD>ӣ<EFBFBD>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>ָ<EFBFBD><D6B8>
+ *  \param[in] data: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD>ַ<EFBFBD><D6B7>NULL<4C><4C>ʾ<EFBFBD><CABE><EFBFBD>ƶ<EFBFBD>ָ<EFBFBD>룩
+ *  \return 1=<3D>ɹ<EFBFBD>, 0=ʧ<>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ч<EFBFBD><D0A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ *  
+ *  \details <20>ڶ<EFBFBD><DAB6><EFBFBD>β<EFBFBD><CEB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD>ء<EFBFBD><D8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD>ܡ<EFBFBD>
+ *           <20><>data<74><61>ΪNULLʱ<4C><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݸ<EFBFBD><DDB8>Ƶ<EFBFBD><C6B5><EFBFBD><EFBFBD>д洢<D0B4><E6B4A2><EFBFBD><EFBFBD>
+ *           <20><><EFBFBD><EFBFBD>βָ<CEB2><D6B8><EFBFBD>Ͷ<EFBFBD><CDB6>д<EFBFBD>С<EFBFBD><D0A1>
+ */
+int queue_push(queue queue, void* data)
+{
+    if (!queue) return 0;               // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>Ч<EFBFBD><D0A7>
+    if (queue->size == queue->capacity) return 0;  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    if (data) assign(at(queue->tail), data);  // <20><><EFBFBD>ݸ<EFBFBD><DDB8>Ƶ<EFBFBD><C6B5><EFBFBD>β
+    queue->tail = (queue->tail + 1) % queue->capacity;  // <20><><EFBFBD><EFBFBD>βָ<CEB2>루ѭ<EBA3A8><D1AD><EFBFBD><EFBFBD>
+    queue->size++;                      // <20><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    return 1;
+}
+
+/**
+ *  \brief ǿ<><C7BF><EFBFBD><EFBFBD><EFBFBD>Ӳ<EFBFBD><D3B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD>ӣ<EFBFBD>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>ָ<EFBFBD><D6B8>
+ *  \param[in] data: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD>ַ<EFBFBD><D6B7>NULL<4C><4C>ʾ<EFBFBD><CABE><EFBFBD>ƶ<EFBFBD>ָ<EFBFBD>룩
+ *  \return 1=<3D>ɹ<EFBFBD>, 0=ʧ<>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Чʱ<D0A7><CAB1>
+ *  
+ *  \details <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>δ<EFBFBD><CEB4>ʱ<EFBFBD><CAB1>ͬ<EFBFBD><CDAC>queue_push()<29><>
+ *           <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݣ<EFBFBD><DDA3><EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD>ݣ<EFBFBD><DDA3><EFBFBD>
+ *           ʵ<><CAB5>ѭ<EFBFBD><D1AD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ч<EFBFBD><D0A7><EFBFBD><EFBFBD>
+ */
+int queue_push2(queue queue, void* data)
+{
+    if (!queue) return 0;
+    if (queue->size < queue->capacity) return queue_push(queue, data);  // <20><><EFBFBD><EFBFBD>δ<EFBFBD><CEB4>ʱ<EFBFBD><CAB1><EFBFBD>ñ<EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD>
+    
+    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>Ƕ<EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD>ݣ<EFBFBD>ʵ<EFBFBD><CAB5>ѭ<EFBFBD><D1AD><EFBFBD><EFBFBD><EFBFBD>ǣ<EFBFBD>
+    if (data) assign(at(queue->tail), data);
+    queue->tail = (queue->tail + 1) % queue->capacity;
+    queue->head = (queue->head + 1) % queue->capacity;  // ͷָ<CDB7><D6B8><EFBFBD><EFBFBD><EFBFBD>ƣ<EFBFBD><C6A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݣ<EFBFBD>
+    return 1;
+}
+
+/**
+ *  \brief <20><><EFBFBD>Ӳ<EFBFBD><D3B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD>Ƴ<EFBFBD><C6B3><EFBFBD>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>ָ<EFBFBD><D6B8>
+ *  \param[out] data: <20><><EFBFBD>ݽ<EFBFBD><DDBD>յ<EFBFBD>ַ<EFBFBD><D6B7>NULL<4C><4C>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݣ<EFBFBD>
+ *  \return 1=<3D>ɹ<EFBFBD>, 0=ʧ<>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ч<EFBFBD><D0A7>Ϊ<EFBFBD>գ<EFBFBD>
+ *  
+ *  \details <20>Ӷ<EFBFBD><D3B6><EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD>Ƴ<EFBFBD>Ԫ<EFBFBD>ء<EFBFBD><D8A1><EFBFBD><EFBFBD><EFBFBD>data<74><61>ΪNULL<4C><4C>
+ *           <20><><EFBFBD>Ƴ<EFBFBD><C6B3><EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8>Ƶ<EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>
+ *           <20><><EFBFBD><EFBFBD>ͷָ<CDB7><D6B8><EFBFBD>Ͷ<EFBFBD><CDB6>д<EFBFBD>С<EFBFBD><D0A1>
+ */
+int queue_pop(queue queue, void* data)
+{
+    if (!queue) return 0;
+    if (queue->size == 0) return 0;     // <20><><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA>
+    if (data) assign(data, at(queue->head));  // <20><><EFBFBD>ƶ<EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD><EFBFBD><EFBFBD>
+    queue->head = (queue->head + 1) % queue->capacity;  // <20><><EFBFBD><EFBFBD>ͷָ<CDB7>루ѭ<EBA3A8><D1AD><EFBFBD><EFBFBD>
+    queue->size--;                      // <20><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    return 1;
+}
+
+/**
+ *  \brief ָ<><D6B8>λ<EFBFBD>ò<EFBFBD><C3B2><EFBFBD>Ԫ<EFBFBD><D4AA>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>ָ<EFBFBD><D6B8>
+ *  \param[in] index: <20><><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0=<3D><>ͷ, size=<3D><>β<EFBFBD><CEB2>
+ *  \param[in] data: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD>ַ<EFBFBD><D6B7>NULL<4C><4C>ʾ<EFBFBD><CABE><EFBFBD>ճ<EFBFBD>λ<EFBFBD>ã<EFBFBD>
+ *  \return 1=<3D>ɹ<EFBFBD>, 0=ʧ<>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD>Խ<EFBFBD><D4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ *  
+ *  \details <20><>ָ<EFBFBD><D6B8>λ<EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD>أ<EFBFBD><D8A3><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD>غ<EFBFBD><D8BA>ơ<EFBFBD>
+ *           <20>Զ<EFBFBD>ѡ<EFBFBD><D1A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǰ<EFBFBD>ƻ<EFBFBD><C6BB><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD>أ<EFBFBD><D8A3><EFBFBD>
+ *           ʱ<>临<EFBFBD>Ӷ<EFBFBD>O(min(index, size-index))<29><>
+ */
+int queue_insert(queue queue, int index, void* data)
+{
+    if (!queue) return 0;
+    if (index < 0 || index > queue->size) return 0;  // <20><><EFBFBD><EFBFBD>Խ<EFBFBD><D4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    if (queue->size == queue->capacity) return 0;    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+    // <20><><EFBFBD>ݲ<EFBFBD><DDB2><EFBFBD>λ<EFBFBD><CEBB>ѡ<EFBFBD><D1A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD>
+    if (index <= queue->size / 2) {
+        // <20><>ǰ<EFBFBD>ƶ<EFBFBD>ǰ<EFBFBD>벿<EFBFBD><EBB2BF>Ԫ<EFBFBD><D4AA>
+        move_forward(queue, 0, index);
+        queue->head = (queue->head + queue->capacity - 1) % queue->capacity;  // ͷָ<CDB7><D6B8>ǰ<EFBFBD><C7B0>
+    } else {
+        // <20><><EFBFBD><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD>벿<EFBFBD><EBB2BF>Ԫ<EFBFBD><D4AA>
+        move_backward(queue, index, queue->size - index);
+        queue->tail = (queue->tail + 1) % queue->capacity;  // βָ<CEB2><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    }
+    
+    // <20>ڿճ<DABF><D5B3><EFBFBD>λ<EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    if (data) assign(at((queue->head + index) % (queue->capacity)), data);
+    queue->size++;
+    return 1;
+}
+
+/**
+ *  \brief ָ<><D6B8>λ<EFBFBD><CEBB>ɾ<EFBFBD><C9BE>Ԫ<EFBFBD><D4AA>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>ָ<EFBFBD><D6B8>
+ *  \param[in] index: ɾ<><C9BE>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0=<3D><>ͷ, size-1=<3D><>β<EFBFBD><CEB2>
+ *  \param[out] data: <20><><EFBFBD>ݽ<EFBFBD><DDBD>յ<EFBFBD>ַ<EFBFBD><D6B7>NULL<4C><4C>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݣ<EFBFBD>
+ *  \return 1=<3D>ɹ<EFBFBD>, 0=ʧ<>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD>Խ<EFBFBD><D4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD>գ<EFBFBD>
+ *  
+ *  \details ɾ<><C9BE>ָ<EFBFBD><D6B8>λ<EFBFBD><CEBB>Ԫ<EFBFBD>أ<EFBFBD><D8A3><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>ǰ<EFBFBD>ơ<EFBFBD>
+ *           <20>Զ<EFBFBD>ѡ<EFBFBD><D1A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ *           ʱ<>临<EFBFBD>Ӷ<EFBFBD>O(min(index, size-index))<29><>
+ */
+int queue_erase(queue queue, int index, void* data)
+{
+    if (!queue) return 0;
+    if (index < 0 || index >= queue->size) return 0;  // <20><><EFBFBD><EFBFBD>Խ<EFBFBD><D4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    if (queue->size == 0) return 0;     // <20><><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA>
+
+    // <20><><EFBFBD>汻ɾ<E6B1BB><C9BE>Ԫ<EFBFBD>أ<EFBFBD><D8A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>
+    if (data) assign(data, at((queue->head + index) % (queue->capacity)));
+
+    // <20><><EFBFBD><EFBFBD>ɾ<EFBFBD><C9BE>λ<EFBFBD><CEBB>ѡ<EFBFBD><D1A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD>
+    if (index <= queue->size / 2) {
+        // <20><><EFBFBD><EFBFBD><EFBFBD>ƶ<EFBFBD>ǰ<EFBFBD>벿<EFBFBD><EBB2BF>Ԫ<EFBFBD><D4AA>
+        move_backward(queue, 0, index);
+        queue->head = (queue->head + 1) % queue->capacity;  // ͷָ<CDB7><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    } else {
+        // <20><>ǰ<EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD>벿<EFBFBD><EBB2BF>Ԫ<EFBFBD><D4AA>
+        move_forward(queue, index + 1, queue->size - index - 1);
+        queue->tail = (queue->tail + queue->capacity - 1) % queue->capacity;  // βָ<CEB2><D6B8>ǰ<EFBFBD><C7B0>
+    }
+    
+    queue->size--;
+    return 1;
+}
+
+/**
+ *  \brief <20><><EFBFBD>ն<EFBFBD><D5B6><EFBFBD>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>ָ<EFBFBD><D6B8>
+ *  
+ *  \details <20><><EFBFBD>ö<EFBFBD><C3B6><EFBFBD>״̬<D7B4><CCAC>ͷβָ<CEB2><D6B8><EFBFBD><EFBFBD><EFBFBD>㣬<EFBFBD><E3A3AC>С<EFBFBD><D0A1><EFBFBD>㣩<EFBFBD><E3A3A9>
+ *           <20><><EFBFBD>ͷŴ洢<C5B4>ڴ棬<DAB4><E6A3AC><EFBFBD>ֶ<EFBFBD><D6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>䡣
+ */
+void queue_clear(queue queue)
+{
+    if (!queue) return;
+    queue->tail = 0;
+    queue->head = 0;
+    queue->size = 0;
+}
+
+/**
+ *  \brief <20><>ȡԪ<C8A1>ص<EFBFBD>ַ
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>ָ<EFBFBD><D6B8>
+ *  \param[in] index: Ԫ<><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0=<3D><>ͷ, size-1=<3D><>β<EFBFBD><CEB2>
+ *  \return Ԫ<>ص<EFBFBD>ַ<EFBFBD><D6B7>ʧ<EFBFBD>ܷ<EFBFBD><DCB7><EFBFBD>NULL<4C><4C>
+ *  
+ *  \details <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>λ<EFBFBD><CEBB>Ԫ<EFBFBD>ص<EFBFBD>ֱ<EFBFBD><D6B1>ָ<EFBFBD>롣
+ *           <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֱ<EFBFBD><D6B1><EFBFBD>޸<EFBFBD>Ԫ<EFBFBD><D4AA>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD>踴<EFBFBD>ƣ<EFBFBD><C6A3><EFBFBD>
+ *           \warning <20><><EFBFBD>ص<EFBFBD>ָ<EFBFBD><D6B8><EFBFBD>ڶ<EFBFBD><DAB6>нṹ<D0BD>޸ĺ<DEB8><C4BA><EFBFBD><EFBFBD><EFBFBD>ʧЧ<CAA7><D0A7>
+ */
+void* queue_data(queue queue, int index)
+{
+    if (!queue) return 0;
+    if (index < 0 || index >= queue->size) return 0;  // <20><><EFBFBD><EFBFBD>Խ<EFBFBD><D4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    return (void*)at((queue->head + index) % (queue->capacity));
+}

calib_board/usr/algo/algo_queue.h

@@ -0,0 +1,119 @@
+#ifndef _ALGO_QUEUE_H_
+#define _ALGO_QUEUE_H_
+
+/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ͷ<EFBFBD><CDB6><EFBFBD> */
+typedef struct QUEUE
+{
+    void* base;         /* <20><><EFBFBD>ݴ洢<DDB4><E6B4A2><EFBFBD>Ļ<EFBFBD><C4BB><EFBFBD>ַ */
+    int dsize;          /* ÿ<><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD>صĴ<D8B5>С<EFBFBD><D0A1><EFBFBD>ֽڣ<D6BD> */
+    int capacity;       /* <20><><EFBFBD>е<EFBFBD><D0B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
+    int size;           /* <20><>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
+    int head;           /* <20><>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>Ԫ<EFBFBD>أ<EFBFBD> */
+    int tail;           /* <20><>β<EFBFBD><CEB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD>ã<EFBFBD> */
+} *queue;  // <20><><EFBFBD><EFBFBD>queueΪָ<CEAA><D6B8><EFBFBD>ýṹ<C3BD><E1B9B9>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+/**
+ *  \brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ *  \param[in] type: <20><><EFBFBD><EFBFBD>Ԫ<EFBFBD>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ *  \param[in] capacity: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ *  \return <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD>ɵĶ<C9B5><C4B6>ж<EFBFBD><D0B6><EFBFBD>
+ *  
+ *  \note ʹ<>ø<EFBFBD><C3B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ջ<EFBFBD>ϴ<EFBFBD><CFB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>
+ *  \example queue(int, 10) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ10<31><30><EFBFBD><EFBFBD><EFBFBD>Ͷ<EFBFBD><CDB6><EFBFBD>
+ */
+#define queue(type, capacity)           (&(struct QUEUE){(type[capacity]){0},sizeof(type),capacity,0,0,0})
+
+// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+int queue_push(queue queue, void* data);
+int queue_push2(queue queue, void* data);
+int queue_pop(queue queue, void* data);
+int queue_insert(queue queue, int index, void* data);
+int queue_erase(queue queue, int index, void* data);
+void queue_clear(queue queue);
+void* queue_data(queue queue, int index);
+
+/**
+ *  \brief <20><><EFBFBD>ʶ<EFBFBD><CAB6><EFBFBD>ָ<EFBFBD><D6B8>λ<EFBFBD>õ<EFBFBD>Ԫ<EFBFBD><D4AA>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>
+ *  \param[in] type: Ԫ<><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ *  \param[in] i: Ԫ<><D4AA>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0-based<65><64>
+ *  \return ָ<><D6B8>Ԫ<EFBFBD>ص<EFBFBD><D8B5><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>
+ *  
+ *  \example queue_at(q, int, 0) = 42; // <20><><EFBFBD>ö<EFBFBD><C3B6><EFBFBD>Ԫ<EFBFBD><D4AA>
+ */
+#define queue_at(queue, type, i)        (*(type *)queue_data((queue),(i)))
+
+/**
+ *  \brief <20>ڶ<EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>
+ *  \param[in] data: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD>ַ<EFBFBD><D6B7>NULL<4C><4C>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5>
+ *  \return <20><><EFBFBD><EFBFBD><EFBFBD>ɹ<EFBFBD>״̬<D7B4><CCAC>1<EFBFBD>ɹ<EFBFBD>/0ʧ<30>ܣ<EFBFBD>
+ */
+#define queue_push_front(queue, data)   queue_insert((queue), 0, data)
+
+/**
+ *  \brief <20>ڶ<EFBFBD>β<EFBFBD><CEB2><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>
+ *  \param[in] data: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD>ַ<EFBFBD><D6B7>NULL<4C><4C>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5>
+ *  \return <20><><EFBFBD><EFBFBD><EFBFBD>ɹ<EFBFBD>״̬<D7B4><CCAC>1<EFBFBD>ɹ<EFBFBD>/0ʧ<30>ܣ<EFBFBD>
+ */
+#define queue_push_back(queue, data)    queue_push2((queue), data)
+
+/**
+ *  \brief <20>Ӷ<EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>
+ *  \param[out] data: <20><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵĵ<DDB5>ַ<EFBFBD><D6B7>NULL<4C><4C>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD>棩
+ *  \return <20><><EFBFBD><EFBFBD><EFBFBD>ɹ<EFBFBD>״̬<D7B4><CCAC>1<EFBFBD>ɹ<EFBFBD>/0ʧ<30>ܣ<EFBFBD>
+ */
+#define queue_pop_front(queue, data)    queue_pop((queue), data)
+
+/**
+ *  \brief <20>Ӷ<EFBFBD>β<EFBFBD><CEB2><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>
+ *  \param[out] data: <20><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵĵ<DDB5>ַ<EFBFBD><D6B7>NULL<4C><4C>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD>棩
+ *  \return <20><><EFBFBD><EFBFBD><EFBFBD>ɹ<EFBFBD>״̬<D7B4><CCAC>1<EFBFBD>ɹ<EFBFBD>/0ʧ<30>ܣ<EFBFBD>
+ */
+#define queue_pop_back(queue, data)     queue_erase((queue), (queue)->size - 1, data)
+
+/**
+ *  \brief <20><>ȡ<EFBFBD><C8A1><EFBFBD>е<EFBFBD>ǰԪ<C7B0><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>
+ *  \return <20><><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ */
+#define queue_size(queue)               ((queue)->size)
+
+/**
+ *  \brief <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>
+ *  \return <20><><EFBFBD>е<EFBFBD><D0B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ */
+#define queue_capacity(queue)           ((queue)->capacity)
+
+/**
+ *  \brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>Ϊ<EFBFBD><CEAA>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>
+ *  \return 0<><30>ʾ<EFBFBD>ǿգ<C7BF><D5A3><EFBFBD>0<EFBFBD><30>ʾ<EFBFBD><CABE>
+ */
+#define queue_empty(queue)              ((queue)->size == 0)
+
+/**
+ *  \brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>
+ *  \param[in] queue: <20><><EFBFBD>ж<EFBFBD><D0B6><EFBFBD>
+ *  \return 0<><30>ʾδ<CABE><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0<EFBFBD><30>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD>
+ */
+#define queue_full(queue)               ((queue)->size == (queue)->capacity)
+
+/** 
+ *  \brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĵ<EFBFBD>ַ<EFBFBD><D6B7>װ
+ *  \param[in] type: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͣ<EFBFBD><CDA3><EFBFBD>int/float<61>ȣ<EFBFBD>
+ *  \param[in] value: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
+ *  \return <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
+ *  
+ *  \note <20><><EFBFBD>ڽ<EFBFBD><DABD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>Ϊָ<CEAA><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ *  \example queue_push(q, literal(int, 42));
+ */
+#ifndef literal
+#define literal(type, value)            ((type[1]){value})
+#endif
+
+#endif

calib_board/usr/app/app.c

@@ -0,0 +1,145 @@
+#include "app.h"
+#include "os_timer.h"
+#include "stdio.h"
+#include "string.h"
+
+#include "bsp_Uart.h"
+#include "bsp_Wdg.h"
+#include "bsp_Led.h"
+#include "bsp_74HC4067.h"
+#include "bsp_Flash.h"
+#include "tjc_usart_hmi.h"
+
+#include "proto_modbus_master_tdlas.h"
+#include "proto_modbus_slave_ex.h"
+
+const char *HwVersion = "V1.0";
+char SwVersion[24] = "V0.001.0";
+void TASK_Idle(void); 
+void Task_10ms(void);
+void Task_50ms(void);
+void Task_100ms(void);
+void Task_200ms(void);
+void Task_500ms(void);
+void Task_1s(void);
+void Task_2s(void);
+
+/******************************************
+ * <20><><EFBFBD><EFBFBD>: AppInit
+ * <20><><EFBFBD><EFBFBD>: <20><>ʼ<EFBFBD><CABC>
+ * <20><><EFBFBD><EFBFBD>: <20><>
+ * <20><><EFBFBD><EFBFBD>: <20><>
+ * <20><><EFBFBD><EFBFBD>: <20><>
+ ******************************************/
+void App_Init(void)
+{
+    Usr_Flash.Init();
+    
+    COM_Uart1.Init(&COM_Uart1);
+    COM_Uart2.Init(&COM_Uart2);
+    COM_Uart4.Init(&COM_Uart4);
+    Led.Init();
+    UartCH_Config.init();
+      
+    
+
+    tdlas.init();
+    modbus_slave_ex.init();
+    TJC_Init(&COM_Uart2);
+    initRingBuffer();
+    char init_msg[] = "ϵͳ<EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD>...\r\n";
+    HAL_UART_Transmit(COM_Uart2.Uart, (uint8_t*)init_msg, strlen(init_msg), 100);
+    //Wdg.Init(); 
+}
+
+/******************************************
+ * <20><><EFBFBD><EFBFBD>: App_Task
+ * <20><><EFBFBD><EFBFBD>: <20><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>
+ * <20><><EFBFBD><EFBFBD>: <20><>
+ * <20><><EFBFBD><EFBFBD>: <20><>
+ * <20><><EFBFBD><EFBFBD>: <20><>ѭ<EFBFBD><D1AD><EFBFBD>е<EFBFBD><D0B5><EFBFBD>
+ ******************************************/
+void App_Task(void)
+{
+    if (TIME_TRUE == OsTimer_CheckTimeOut(OsTimeTick_10ms, osTime_MSecTick, 10))
+    {
+        OsTimeTick_10ms = osTime_MSecTick;
+        Task_10ms();
+    }
+    if (TIME_TRUE == OsTimer_CheckTimeOut(OsTimeTick_50ms, osTime_MSecTick, 50))
+    {
+        OsTimeTick_50ms = osTime_MSecTick;
+        Task_50ms();
+    }
+    if (TIME_TRUE == OsTimer_CheckTimeOut(OsTimeTick_100ms, osTime_MSecTick, 100))
+    {
+        OsTimeTick_100ms = osTime_MSecTick;
+        Task_100ms();
+    }
+    if (TIME_TRUE == OsTimer_CheckTimeOut(OsTimeTick_200ms, osTime_MSecTick, 200))
+    {
+        OsTimeTick_200ms = osTime_MSecTick;
+        Task_200ms();
+    }
+    if (TIME_TRUE == OsTimer_CheckTimeOut(OsTimeTick_500ms, osTime_MSecTick, 500))
+    {
+        OsTimeTick_500ms = osTime_MSecTick;
+        Task_500ms();
+    }
+    if (TIME_TRUE == OsTimer_CheckTimeOut(OsTimeTick_1s, osTime_MSecTick, 1000))
+    {
+        OsTimeTick_1s = osTime_MSecTick;
+        Task_1s();
+    }
+    if (TIME_TRUE == OsTimer_CheckTimeOut(OsTimeTick_2s, osTime_MSecTick, 2000))
+    {
+        OsTimeTick_2s = osTime_MSecTick;
+        Task_2s();
+    }
+    TASK_Idle();
+}
+/*<2A><><EFBFBD><EFBFBD>ִ<EFBFBD>еĺ<D0B5><C4BA><EFBFBD>*/
+void TASK_Idle(void)
+{
+    COM_Uart1.Rx_Task(&COM_Uart1);
+    COM_Uart2.Rx_Task(&COM_Uart2);
+    COM_Uart4.Rx_Task(&COM_Uart4);
+}
+
+void Task_10ms(void)
+{
+}
+
+void Task_50ms(void)
+{
+//     tdlas.tx_task();
+}
+
+void Task_100ms(void)
+{
+//  tdlas.tx_task();
+}
+
+void Task_200ms(void)
+{
+    
+}
+
+void Task_500ms(void)
+{
+//    UartCH_Config.ch_set(ch);
+//    tdlas.tx_task();
+    Led.Flash();
+}
+    
+
+void Task_1s(void)
+{
+    
+}
+
+void Task_2s(void)
+{
+    
+}
+

calib_board/usr/app/app.h

@@ -0,0 +1,10 @@
+#ifndef _APP_H_
+#define _APP_H_
+
+extern const char *HwVersion;
+extern char SwVersion[24];
+
+void App_Init(void);
+void App_Task(void);
+
+#endif

calib_board/usr/app/gas_data.c

@@ -0,0 +1,4 @@
+#include "gas_data.h"
+
+gas_data_t gas_data[SENSOR_NUM];
+

calib_board/usr/app/gas_data.h

@@ -0,0 +1,38 @@
+#ifndef _GAS_DATA_H__
+#define _GAS_DATA_H__
+
+#include "main.h"
+
+#define SENSOR_NUM  16
+
+typedef struct
+{
+    u8 ver[20];             /*<2A><><EFBFBD><EFBFBD><EFBFBD>汾<EFBFBD><E6B1BE>*/
+    u8 sn[20];              /*SN<53><4E>*/
+    u16 range;              /*<2A><><EFBFBD><EFBFBD>*/
+    s16 value;              /*Ũ<><C5A8>*/
+    u16 pp_ad;              /*<2A><><EFBFBD><EFBFBD>ֵ*/
+    u16 r_pp_ad;            /*ԭʼ<D4AD><CABC><EFBFBD><EFBFBD>ֵ*/
+    u16 pp_pix;             /*<2A><><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>*/
+    u16 light_ad;           /*<2A>⹦<EFBFBD><E2B9A6>*/
+    u16 tec_set_value;      /*tec<65>趨ֵ*/
+    u16 tec_temp;           /*tec<65>¶<EFBFBD>*/
+    s16 temp;               /*<2A><><EFBFBD><EFBFBD><EFBFBD>¶<EFBFBD>*/
+    u16 light_ad_max;       /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ*/
+    u16 light_ad_min;       /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Сֵ*/
+    u16 state_code;         /*״̬<D7B4><CCAC>*/
+    u16 dc_offset;          /*ֱ<><D6B1>ƫ<EFBFBD><C6AB>*/
+    //u16 ad_befor_multiple;  /*ADǰ<44>Ŵ<EFBFBD><C5B4><EFBFBD><EFBFBD><EFBFBD>*/
+    u16 demod_multiple;     /*<2A><><EFBFBD><EFBFBD><EFBFBD>Ŵ<EFBFBD><C5B4><EFBFBD><EFBFBD><EFBFBD>*/
+    //u16 mode;               /*ģʽ״̬*/
+    s16 calib_temp;         /*<2A>궨ʱ<EAB6A8><CAB1><EFBFBD>¶<EFBFBD>*/
+    u16 calib_press;        /*<2A>궨ʱ<EAB6A8><CAB1>ѹ<EFBFBD><D1B9>*/
+    u16 calib_humidity;     /*<2A>궨ʱ<EAB6A8><CAB1>ʪ<EFBFBD><CAAA>*/
+    u16 fac_calib_code_h;
+    u16 fac_calib_code_l;     /*<2A><><EFBFBD>ұ궨ʱ<EAB6A8><CAB1>״̬<D7B4><CCAC>*/
+    u16 reserve[1];         /*Ԥ<><D4A4>*/
+}gas_data_t;
+
+extern gas_data_t gas_data[SENSOR_NUM];
+
+#endif

calib_board/usr/app/os_timer.c

@@ -0,0 +1,121 @@
+#include "os_timer.h"
+
+unsigned short osTime_MSecTick = 0; /*<2A>δ<EFBFBD>ʱ<EFBFBD><CAB1>*/
+unsigned short osTime_SecTick = 0;
+unsigned short osTime_10SecTick = 0; /*10s<30><73>һ<EFBFBD><D2BB> <20><><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>¼*/
+
+static unsigned short osTimer_MSec1 = 0;
+static unsigned short osTimer_MSec2 = 0;
+
+unsigned short OsTimeTick_10ms;
+unsigned short OsTimeTick_50ms;
+unsigned short OsTimeTick_100ms;
+unsigned short OsTimeTick_200ms;
+unsigned short OsTimeTick_500ms;
+unsigned short OsTimeTick_1s;
+unsigned short OsTimeTick_2s;
+
+/****************************************************************************
+ * NAME:             OsTimer_Init
+ * CALLED BY:        Application
+ * PRECONDITIONS:
+ * INPUT PARAMETERS: None
+ * RETURN VALUES:    None
+ * DESCRIPTION:      OsTimer initialization
+ *
+ ****************************************************************************/
+
+void OsTimer_Init(void)
+{
+  osTimer_MSec1 = 0;
+  osTimer_MSec2 = 0;
+  osTime_SecTick = 0;
+  osTime_MSecTick = 0;
+
+  OsTimeTick_10ms = osTime_MSecTick;
+  OsTimeTick_50ms = osTime_MSecTick;
+  OsTimeTick_100ms = osTime_MSecTick;
+  OsTimeTick_200ms = osTime_MSecTick;
+  OsTimeTick_500ms = osTime_MSecTick;
+  OsTimeTick_1s = osTime_MSecTick;
+}
+
+/****************************************************************************
+ * NAME:             OsTimer_Increment
+ * CALLED BY:        ISR
+ * PRECONDITIONS:
+ * INPUT PARAMETERS: msec -  millisecond to increase
+ * RETURN VALUES:    None
+ * DESCRIPTION:      Increase the Timer
+ *
+ ****************************************************************************/
+void OsTimer_Increment(unsigned short msec)
+{
+  osTime_MSecTick += msec;
+  osTimer_MSec1 += msec;
+  osTimer_MSec2 += msec;
+  if (osTimer_MSec1 >= 1000U) /*1s*/
+  {
+    osTimer_MSec1 = 0U;
+    osTime_SecTick++;
+  }
+  if (osTimer_MSec2 >= 10000U) /*10s*/
+  {
+    osTimer_MSec2 = 0U;
+    osTime_10SecTick++;
+  }
+}
+
+/****************************************************************************
+ * NAME:             OsTimer_CheckTimeOut
+ * CALLED BY:        Application
+ * PRECONDITIONS:
+ * INPUT PARAMETERS: timeStart - start tick
+ *                   timeNow   - current tick
+ *                   timeOut   - expired tick
+ * RETURN VALUES:    whether timer is expired
+ * DESCRIPTION:      check if specified time is expired
+ *
+ ****************************************************************************/
+unsigned char OsTimer_CheckTimeOut(unsigned short timeStart, unsigned short timeNow, unsigned short timeOut)
+{
+  unsigned short timerActivateVal;
+  timerActivateVal = timeOut + timeStart;
+
+  if (timerActivateVal > timeStart)
+  {
+    if ((timeNow >= timerActivateVal) || (timeNow < timeStart))
+    {
+      return TIME_TRUE;
+    }
+  }
+  else if ((timeNow >= timerActivateVal) && (timeNow < timeStart))
+  {
+    return TIME_TRUE;
+  }
+  return TIME_FALSE;
+}
+
+/*
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>л<EFBFBD><EFBFBD>ж<EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>OsTimer_CheckTimeOut<75><74><EFBFBD><EFBFBD>ʹ<EFBFBD><CAB9>
+*/
+unsigned short OsTimer_CheckRunTime(unsigned short timeStart, unsigned short timeNow, unsigned short timeOut)
+{
+  unsigned short timerActivateVal;
+  timerActivateVal = timeOut + timeStart;
+
+  if (timerActivateVal > timeStart)
+  {
+    return (timerActivateVal - timeNow);
+  }
+  else
+  {
+    return (65535U - timeNow + timerActivateVal);
+  }
+}
+
+/*<2A><><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD>ʱ*/
+void Delay_ms(unsigned short delay)
+{
+    HAL_Delay(delay);
+}

calib_board/usr/app/os_timer.h

@@ -0,0 +1,29 @@
+#ifndef _OSTIMER_H_
+#define _OSTIMER_H_
+
+#include "main.h"
+
+#define TIME_TRUE 1U
+#define TIME_FALSE 0U
+
+
+extern unsigned short osTime_MSecTick;
+extern unsigned short osTime_SecTick;
+extern unsigned short osTime_10SecTick; // 10s<30><73>һ<EFBFBD><D2BB> <20><><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>¼
+
+extern unsigned short OsTimeTick_10ms;
+extern unsigned short OsTimeTick_50ms;
+extern unsigned short OsTimeTick_100ms;
+extern unsigned short OsTimeTick_200ms;
+extern unsigned short OsTimeTick_500ms;
+extern unsigned short OsTimeTick_1s;
+extern unsigned short OsTimeTick_2s;
+
+void OsTimer_Init(void);
+void OsTimer_Increment(unsigned short msec);
+unsigned char OsTimer_CheckTimeOut(unsigned short timeStart, unsigned short timeNow, unsigned short timeOut);
+unsigned short OsTimer_CheckRunTime(unsigned short timeStart, unsigned short timeNow, unsigned short timeOut);
+
+void Delay_ms(unsigned short delay);
+
+#endif

calib_board/usr/bsp/bsp_74HC4067.c

@@ -0,0 +1,113 @@
+#include "bsp_74HC4067.h"
+#include "os_timer.h"
+
+/*<2A><>Ƭ74HC4067<36><37>һƬTX  һƬRX  ÿƬ16ͨ<36><CDA8>*/
+
+#define BSP_74HC4067_CH_MAX 16
+
+/*TX*/
+#define TX_EN_ENABLE      HAL_GPIO_WritePin (TX_EN_GPIO_Port,    TX_EN_Pin,    GPIO_PIN_RESET)
+#define TX_EN_DISENABLE   HAL_GPIO_WritePin (TX_EN_GPIO_Port,    TX_EN_Pin,    GPIO_PIN_SET)
+
+/*RX*/
+#define RX_EN_ENABLE      HAL_GPIO_WritePin (RX_EN_GPIO_Port,    RX_EN_Pin,    GPIO_PIN_RESET)
+#define RX_EN_DISENABLE   HAL_GPIO_WritePin (RX_EN_GPIO_Port,    RX_EN_Pin,    GPIO_PIN_SET)
+
+
+/*LEDͨ<44><CDA8>ָʾ*/
+#define LED_CH0_ON        HAL_GPIO_WritePin (RX_S3_GPIO_Port,    RX_S3_Pin,    GPIO_PIN_RESET)
+#define LED_CH0_OFF       HAL_GPIO_WritePin (RX_S3_GPIO_Port,    RX_S3_Pin,    GPIO_PIN_SET)
+
+#define BSP_LOW     GPIO_PIN_RESET
+#define BSP_HIG     GPIO_PIN_SET
+
+#define BSP_LED_ON  GPIO_PIN_RESET
+#define BSP_LED_OFF GPIO_PIN_SET
+
+static GPIO_TypeDef* bsp_74HC4067_TX_SW_GPIO[4] = {TX_S0_GPIO_Port,TX_S1_GPIO_Port,TX_S2_GPIO_Port,TX_S3_GPIO_Port};
+static uint16_t bsp_74HC4067_TX_SW_Pin[4]       = {TX_S0_Pin,      TX_S1_Pin,      TX_S2_Pin,      TX_S3_Pin};
+
+static GPIO_TypeDef* bsp_74HC4067_RX_SW_GPIO[4] = {RX_S0_GPIO_Port,RX_S1_GPIO_Port,RX_S2_GPIO_Port,RX_S3_GPIO_Port}; 
+static uint16_t bsp_74HC4067_RX_SW_Pin[4]       = {RX_S0_Pin,      RX_S1_Pin,      RX_S2_Pin,      RX_S3_Pin};
+
+static GPIO_TypeDef* bsp_74HC4067_LED_CH_GPIO[BSP_74HC4067_CH_MAX] = {LED_CH1_GPIO_Port,    LED_CH2_GPIO_Port,    LED_CH3_GPIO_Port,    LED_CH4_GPIO_Port,    LED_CH5_GPIO_Port,    LED_CH6_GPIO_Port,    LED_CH7_GPIO_Port,    LED_CH8_GPIO_Port,    LED_CH9_GPIO_Port,    LED_CH10_GPIO_Port,    LED_CH11_GPIO_Port,    LED_CH12_GPIO_Port,    LED_CH13_GPIO_Port,    LED_CH14_GPIO_Port,    LED_CH15_GPIO_Port,    LED_CH16_GPIO_Port}; 
+static uint16_t bsp_74HC4067_LED_CH_Pin[BSP_74HC4067_CH_MAX]       = {LED_CH1_Pin,          LED_CH2_Pin,          LED_CH3_Pin,          LED_CH4_Pin,          LED_CH5_Pin,          LED_CH6_Pin,          LED_CH7_Pin,    LED_CH8_Pin,    LED_CH9_Pin,    LED_CH10_Pin,    LED_CH11_Pin,    LED_CH12_Pin,                                        LED_CH13_Pin,          LED_CH14_Pin,          LED_CH15_Pin,           LED_CH16_Pin};
+
+/*ͨ<><CDA8>ת<EFBFBD><D7AA><EFBFBD><EFBFBD>Ӳ<EFBFBD><D3B2>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD><EFBFBD>ӵ<EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD>оƬ<D0BE><C6AC><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>*/
+static u8 bsp_74HC4067_TX_CH_Conv[BSP_74HC4067_CH_MAX] = {13,14,15,12,11,10,9, 8, 7, 4, 3, 2, 1, 0, 6, 5};
+static u8 bsp_74HC4067_RX_CH_Conv[BSP_74HC4067_CH_MAX] = {13,14,15,8, 9, 10,11,12,0, 1, 2, 3, 4, 5, 6, 7};
+
+
+static void bsp_74HC4067_Init(void);
+static void bsp_74HC4067_Set_CH(u8 CH);
+static u8 bsp_74HC4067_Get_CH(void);
+
+static u8 bsp_74HC4067_CH;
+
+bsp_74HC4067_t UartCH_Config =
+{
+    .init  = bsp_74HC4067_Init,
+    .ch_set = bsp_74HC4067_Set_CH,
+    .ch_get = bsp_74HC4067_Get_CH,
+};
+/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˸<EFBFBD><CBB8><EFBFBD><EFBFBD>ʾ<EFBFBD><CABE>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+static void bsp_74HC4067_Init(void)
+{
+    bsp_74HC4067_CH = 0;
+    TX_EN_ENABLE;
+    RX_EN_ENABLE;
+    bsp_74HC4067_Set_CH(0);
+}
+
+
+//static u8 CH;
+static void bsp_74HC4067_Set_CH(u8 CH1)
+{
+    u8 CH = 0;
+    if(CH >= BSP_74HC4067_CH_MAX)
+    {
+        return ;
+    }
+    u8 i,TX_CH,RX_CH;
+    bsp_74HC4067_CH = CH;
+    TX_CH = bsp_74HC4067_TX_CH_Conv[CH];
+    RX_CH = bsp_74HC4067_RX_CH_Conv[CH];
+    /*ѡ<><D1A1><EFBFBD><EFBFBD>Ӧ<EFBFBD><D3A6>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+    for(i=0;i<4;i++)
+    {
+        if((TX_CH >> i) & 0x01)
+        {
+            HAL_GPIO_WritePin(bsp_74HC4067_TX_SW_GPIO[i],bsp_74HC4067_TX_SW_Pin[i],BSP_HIG);
+        }
+        else
+        {
+            HAL_GPIO_WritePin(bsp_74HC4067_TX_SW_GPIO[i],bsp_74HC4067_TX_SW_Pin[i],BSP_LOW);
+        }
+        if((RX_CH >> i) & 0x01)
+        {
+            HAL_GPIO_WritePin(bsp_74HC4067_RX_SW_GPIO[i],bsp_74HC4067_RX_SW_Pin[i],BSP_HIG);
+        }
+        else
+        {
+            HAL_GPIO_WritePin(bsp_74HC4067_RX_SW_GPIO[i],bsp_74HC4067_RX_SW_Pin[i],BSP_LOW);
+        }
+    }
+    /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӧָʾ<D6B8><CABE>*/
+    for(i=0;i<BSP_74HC4067_CH_MAX;i++)
+    {
+        if(i == CH)
+        {
+            HAL_GPIO_WritePin(bsp_74HC4067_LED_CH_GPIO[i],bsp_74HC4067_LED_CH_Pin[i],BSP_LED_ON);
+        }
+        else
+        {
+            HAL_GPIO_WritePin(bsp_74HC4067_LED_CH_GPIO[i],bsp_74HC4067_LED_CH_Pin[i],BSP_LED_OFF);
+        }
+    }
+   // HAL_Delay(20);
+}
+
+static u8 bsp_74HC4067_Get_CH(void)
+{
+    return bsp_74HC4067_CH;
+}

calib_board/usr/bsp/bsp_74HC4067.h

@@ -0,0 +1,15 @@
+#ifndef _BSP_74HC4067_H_
+#define _BSP_74HC4067_H_
+
+#include "main.h"
+
+typedef struct
+{
+    void (*init)(void);
+    void (*ch_set)(u8);
+    u8   (*ch_get)(void);
+}bsp_74HC4067_t;
+
+extern bsp_74HC4067_t UartCH_Config;
+
+#endif

calib_board/usr/bsp/bsp_Delay.c

@@ -0,0 +1 @@
+#include "bsp_Delay.h"

calib_board/usr/bsp/bsp_Delay.h

@@ -0,0 +1,6 @@
+#ifndef _BSP_DELAY_H_
+#define _BSP_DELAY_H_
+
+#include "main.h"
+
+#endif

calib_board/usr/bsp/bsp_Flash.c

@@ -0,0 +1,186 @@
+#include "bsp_Flash.h"
+#include "string.h"
+#include "bsp_Wdg.h"
+#include "gas_data.h"
+/* FLASH Memory Definitions */ 
+//#define BSP_FLASH_SIZE          (0x100000UL)    
+//#define BSP_FLASH_PAGE_SIZE     (PAGESIZE)
+//#define BSP_FLASH_PAGE_NUM      (BSP_FLASH_SIZE/BSP_FLASH_PAGE_SIZE) 
+
+//#define BSP_FLASH_ADDR_RW(n)    ((uint32_t)(FLASH_BASE + (BSP_FLASH_PAGE_NUM - (n)) * BSP_FLASH_PAGE_SIZE))
+//#define BSP_FLASH_DATASAVE_ADDR BSP_FLASH_ADDR_RW(1)
+
+//FLASH<53><48>ַ
+#define BSP_FLASH_SECTION_0_ADDR    ((u32)0x08000000)  //16k
+#define BSP_FLASH_SECTION_1_ADDR    ((u32)0x08004000)  //16k
+#define BSP_FLASH_SECTION_2_ADDR    ((u32)0x08008000)  //16k
+#define BSP_FLASH_SECTION_3_ADDR    ((u32)0x0800C000)  //16k
+#define BSP_FLASH_SECTION_4_ADDR    ((u32)0x08010000)  //64k
+#define BSP_FLASH_SECTION_5_ADDR    ((u32)0x08020000)  //128k
+#define BSP_FLASH_SECTION_6_ADDR    ((u32)0x08040000)  //128k
+#define BSP_FLASH_SECTION_7_ADDR    ((u32)0x08060000)  //128k 
+#define BSP_FLASH_SECTION_8_ADDR    ((u32)0x08080000)  //128k
+#define BSP_FLASH_SECTION_9_ADDR    ((u32)0x080A0000)  //128k
+#define BSP_FLASH_SECTION_10_ADDR   ((u32)0x080C0000)  //128k
+#define BSP_FLASH_SECTION_11_ADDR   ((u32)0x080E0000)  //128k
+
+#define BSP_FLASH_DATASAVE_ADDR BSP_FLASH_SECTION_11_ADDR//<2F><><EFBFBD><EFBFBD>һƬ<D2BB><C6AC><EFBFBD><EFBFBD> 128k
+
+static void bsp_Flash_Init(void);
+static void bsp_FlashDataWrite(void);
+static void bsp_FlashDataRead(void);
+static void bsp_FlashReset(void);
+
+bsp_Flash_t Usr_Flash = 
+{
+    .Init = bsp_Flash_Init,
+    .Write = bsp_FlashDataWrite,
+    .Read = bsp_FlashDataRead,
+    .Reset = bsp_FlashReset, 
+};
+
+bsp_Flash_t *p_Usr_Flash = &Usr_Flash;
+
+// <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>ҳ
+static HAL_StatusTypeDef bsp_FLASH_ErasePage(uint32_t PageAddress)
+{
+    //<2F><>ʼ<EFBFBD><CABC>FLASH_EraseInitTypeDef
+    FLASH_EraseInitTypeDef f;
+    
+    f.TypeErase = FLASH_TYPEERASE_SECTORS;
+    f.Sector = FLASH_SECTOR_11;
+    f.NbSectors = 1;
+    f.VoltageRange = VOLTAGE_RANGE_3;
+    //<2F><><EFBFBD><EFBFBD>PageError
+    uint32_t PageError = 0;
+    //<2F><><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    return HAL_FLASHEx_Erase(&f, &PageError);
+}
+
+// <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD> - <20><>32λ<32><CEBB>ȡ
+static void bsp_Flash_STMFLASH_Read(uint32_t ReadAddr, void *pBuffer, uint32_t size)
+{
+    uint8_t *pBuf = (uint8_t*)pBuffer;
+    uint32_t *addr = (uint32_t*)ReadAddr;
+    uint32_t words = size / 4;
+    uint32_t bytes_remaining = size % 4;
+    
+    // <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>32λ<32><CEBB>
+    for(uint32_t i = 0; i < words; i++)
+    {
+        *((uint32_t*)pBuf) = addr[i];
+        pBuf += 4;
+    }
+    
+    // <20><>ȡʣ<C8A1><CAA3><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>
+    if(bytes_remaining > 0)
+    {
+        uint32_t last_word = addr[words];
+        uint8_t *last_bytes = (uint8_t*)&last_word;
+        
+        for(uint32_t i = 0; i < bytes_remaining; i++)
+        {
+            pBuf[i] = last_bytes[i];
+        }
+    }
+}
+
+// д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><>32λд<CEBB><D0B4>
+static HAL_StatusTypeDef bsp_Flash_STMFLASH_Write(uint32_t WriteAddr, void *pBuffer, uint32_t size)
+{
+    HAL_StatusTypeDef status = HAL_OK;
+    uint8_t *pBuf = (uint8_t*)pBuffer;
+    uint32_t words = size / 4;
+    uint32_t bytes_remaining = size % 4;
+    uint32_t current_addr = WriteAddr;
+    
+    HAL_FLASH_Unlock();
+    
+    // <20><><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF>ҳ
+    status = bsp_FLASH_ErasePage(WriteAddr);
+    if(status != HAL_OK)
+    {
+        HAL_FLASH_Lock();
+        return status;
+    }
+    
+    // д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>32λ<32><CEBB>
+    for(uint32_t i = 0; i < words; i++)
+    {
+        status = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, 
+                                  current_addr, 
+                                  *((uint32_t*)pBuf));
+        if(status != HAL_OK) break;
+        
+        current_addr += 4;
+        pBuf += 4;
+    }
+    
+    // д<><D0B4>ʣ<EFBFBD><CAA3><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>
+    if(status == HAL_OK && bytes_remaining > 0)
+    {
+        uint32_t last_word = 0xFFFFFFFF; // Ĭ<><C4AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0xFF
+        uint8_t *last_bytes = (uint8_t*)&last_word;
+        
+        // <20><><EFBFBD><EFBFBD>ʣ<EFBFBD><CAA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+        for(uint32_t i = 0; i < bytes_remaining; i++)
+        {
+            last_bytes[i] = pBuf[i];
+        }
+        
+        status = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, current_addr, last_word);
+    }
+    
+    HAL_FLASH_Lock();
+    return status;
+}
+
+static void bsp_FlashReset(void)
+{
+    
+    bsp_FlashDataWrite();
+}
+
+static void bsp_Flash_Init(void)
+{
+    
+    bsp_FlashDataRead();
+    if(p_Usr_Flash->FlashData.modbus_read_reg_num > 1000)
+        p_Usr_Flash->FlashData.modbus_read_reg_num = sizeof(gas_data_t)/2;
+    if(p_Usr_Flash->FlashData.modbus_read_sensor_num > SENSOR_NUM)
+        p_Usr_Flash->FlashData.modbus_read_sensor_num = SENSOR_NUM;
+    memcpy(&Usr_Flash.TempFlashData, &Usr_Flash.FlashData, sizeof(bsp_FlashData_t));
+}
+
+static void bsp_FlashDataWrite(void)
+{ 
+    /*<2A><>ֹ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>д<EFBFBD><D0B4>ͬ<EFBFBD><CDAC><EFBFBD><EFBFBD>*/
+    if(memcmp(&Usr_Flash.TempFlashData, &Usr_Flash.FlashData, sizeof(bsp_FlashData_t)) != 0)
+    {
+        Wdg.Feed();
+        
+        __disable_irq(); // <20><><EFBFBD><EFBFBD>ȫ<EFBFBD><C8AB><EFBFBD>ж<EFBFBD>
+        
+        HAL_StatusTypeDef status = bsp_Flash_STMFLASH_Write(BSP_FLASH_DATASAVE_ADDR,&Usr_Flash.FlashData,sizeof(bsp_FlashData_t));
+        if(status == HAL_OK)
+        {
+            // д<><D0B4><EFBFBD>ɹ<EFBFBD><C9B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>
+            memcpy(&Usr_Flash.TempFlashData, &Usr_Flash.FlashData, sizeof(bsp_FlashData_t));
+        }
+        else
+        {
+               
+        }
+        __enable_irq(); // <20>ָ<EFBFBD><D6B8>ж<EFBFBD>
+        Wdg.Feed();
+    }
+}
+
+static void bsp_FlashDataRead(void)
+{ 
+    Wdg.Feed();
+    bsp_Flash_STMFLASH_Read(BSP_FLASH_DATASAVE_ADDR, 
+                           &Usr_Flash.FlashData, 
+                           sizeof(bsp_FlashData_t));
+    Wdg.Feed();
+}

calib_board/usr/bsp/bsp_Flash.h

@@ -0,0 +1,31 @@
+#ifndef _BSP_FLASH_H_
+#define _BSP_FLASH_H_
+
+#include "main.h"
+#include "stdio.h"
+#include "string.h"
+
+typedef struct
+{
+    /*<2A><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD><D0B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>һ<EFBFBD><D2BB>*/
+    u16 sn[5];
+    u8 modbus_id;
+    u16 modbus_read_reg_num;
+    u16 modbus_read_sensor_num;
+} bsp_FlashData_t;
+
+typedef struct
+{
+    bsp_FlashData_t TempFlashData;
+    bsp_FlashData_t FlashData;
+    void (*Init)(void);
+    void (*Write)(void);
+    void (*Read)(void);
+    void (*Reset)(void);
+} bsp_Flash_t;
+
+
+
+extern bsp_Flash_t Usr_Flash;
+
+#endif

calib_board/usr/bsp/bsp_Led.c

@@ -0,0 +1,38 @@
+#include "bsp_Led.h"
+#include "os_timer.h"
+
+#define LED1_ON          HAL_GPIO_WritePin (LED1_GPIO_Port,    LED1_Pin,    GPIO_PIN_RESET)
+#define LED1_OFF         HAL_GPIO_WritePin (LED1_GPIO_Port,    LED1_Pin,    GPIO_PIN_SET)
+#define LED1_TOGGLE      HAL_GPIO_TogglePin(LED1_GPIO_Port,    LED1_Pin)
+
+#define LED2_ON          HAL_GPIO_WritePin (LED2_GPIO_Port,    LED2_Pin,    GPIO_PIN_RESET)
+#define LED2_OFF         HAL_GPIO_WritePin (LED2_GPIO_Port,    LED2_Pin,    GPIO_PIN_SET)
+#define LED2_TOGGLE      HAL_GPIO_TogglePin(LED2_GPIO_Port,    LED2_Pin)
+
+#define LED3_ON          HAL_GPIO_WritePin (LED3_GPIO_Port,    LED3_Pin,    GPIO_PIN_RESET)
+#define LED3_OFF         HAL_GPIO_WritePin (LED3_GPIO_Port,    LED3_Pin,    GPIO_PIN_SET)
+#define LED3_TOGGLE      HAL_GPIO_TogglePin(LED3_GPIO_Port,    LED3_Pin)
+
+
+static void bsp_Led_Init(void);
+static void bsp_Led_Flash(void);
+
+bsp_Led_t Led =
+{
+    .Init = bsp_Led_Init,
+    .Flash = bsp_Led_Flash,
+};
+/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˸<EFBFBD><CBB8><EFBFBD><EFBFBD>ʾ<EFBFBD><CABE>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+static void bsp_Led_Init(void)
+{
+    for(u8 i = 0;i < 20;i++)
+    {
+        Delay_ms(50);
+        HAL_GPIO_TogglePin(LED1_GPIO_Port, LED1_Pin);
+    }
+}
+
+static void bsp_Led_Flash(void)
+{
+    HAL_GPIO_TogglePin(LED1_GPIO_Port, LED1_Pin);
+}

calib_board/usr/bsp/bsp_Led.h

@@ -0,0 +1,15 @@
+#ifndef _BSP_LED_H_
+#define _BSP_LED_H_
+
+#include "main.h"
+
+
+typedef struct
+{
+    void (*Init)(void);
+    void (*Flash)(void);
+}bsp_Led_t;
+
+extern bsp_Led_t Led;
+
+#endif

calib_board/usr/bsp/bsp_Uart.c

@@ -0,0 +1,396 @@
+#include "bsp_Uart.h"
+
+#include "string.h"
+
+//#define RS485_RX HAL_GPIO_WritePin(RS485_EN_GPIO_Port, RS485_EN_Pin, GPIO_PIN_RESET)
+#define RS485_RX HAL_GPIO_WritePin(RS485_EN_GPIO_Port, RS485_EN_Pin, GPIO_PIN_SET)
+#define RS485_TX HAL_GPIO_WritePin(RS485_EN_GPIO_Port, RS485_EN_Pin, GPIO_PIN_SET)
+
+/*<2A><><EFBFBD><EFBFBD><EFBFBD>շ<EFBFBD><D5B7><EFBFBD>*/
+#define  RX_TEMP_BUFF_NUM (3000U)
+u8 Rx_Temp_Buff[RX_TEMP_BUFF_NUM];
+
+#define UART1_TX_LEN (3000U)
+#define UART1_RX_LEN (3000U)
+
+#define UART2_TX_LEN (3000U)
+#define UART2_RX_LEN (3000U)
+
+#define UART4_TX_LEN (3000U)
+#define UART4_RX_LEN (3000U)
+
+u8 Uart1_TX_Buff[UART1_TX_LEN];
+u8 Uart1_Rx_Buff[UART1_RX_LEN];
+
+u8 Uart2_TX_Buff[UART2_TX_LEN];
+u8 Uart2_Rx_Buff[UART2_RX_LEN];
+
+u8 Uart4_TX_Buff[UART4_TX_LEN];
+u8 Uart4_Rx_Buff[UART4_RX_LEN];
+
+static void bsp_Uart_Init(bsp_Uart_t *p_Uart);
+static void bsp_Uart_Send(bsp_Uart_t *p_Uart,u8 *pData, u16 Len);
+static void bsp_Uart_Rx_IdleInt(bsp_Uart_t *p_Uart);
+static void bsp_Uart_Rx_TimeIncrement(bsp_Uart_t *p_Uart,u16 Time);
+static void bsp_Uart_Rx_Task(bsp_Uart_t *p_Uart);
+static void bsp_Uart_Rx_TimeStart(bsp_Uart_t *p_Uart);
+static void bsp_Uart_Tx_DMA_TCInt(bsp_Uart_t *p_Uart);
+ 
+extern UART_HandleTypeDef huart1;
+extern UART_HandleTypeDef huart2;
+extern UART_HandleTypeDef huart4;
+
+extern DMA_HandleTypeDef hdma_usart1_rx;
+extern DMA_HandleTypeDef hdma_usart1_tx;
+extern DMA_HandleTypeDef hdma_usart2_rx;
+extern DMA_HandleTypeDef hdma_usart2_tx;
+extern DMA_HandleTypeDef hdma_uart4_rx;
+extern DMA_HandleTypeDef hdma_uart4_tx;
+
+bsp_Uart_t COM_Uart1 =
+{ 
+    .RxQueue = queue(u8,UART1_RX_LEN),
+    .Uart =&huart1,
+    
+    .Tx_DMA = &hdma_usart1_tx,
+    .Rx_DMA = &hdma_usart1_rx,
+    
+    .Tx_DMA_Len = UART1_TX_LEN,
+    .Rx_DMA_Len = UART1_RX_LEN,
+    
+    .Tx_Addr = &Uart1_TX_Buff[0],
+    .Rx_Addr = &Uart1_Rx_Buff[0],
+    
+    .Tx_DMA_CompleteFlag = 1,
+    .Rx_TimeOver = 0,
+
+    .relay.uart = NULL,
+    
+    .Init = bsp_Uart_Init,
+    .Send = bsp_Uart_Send,
+    
+    .Tx_DMA_TCInt = bsp_Uart_Tx_DMA_TCInt,
+    .Rx_IdleInt = bsp_Uart_Rx_IdleInt,
+    .Rx_TimeIncrementInt = bsp_Uart_Rx_TimeIncrement,
+    .Rx_DataAnalysis = NULL,
+    .Rx_Task = bsp_Uart_Rx_Task,
+};
+
+bsp_Uart_t COM_Uart2 =
+{ 
+    .RxQueue = queue(u8,UART2_RX_LEN),
+    .Uart =&huart2,
+    
+    .Tx_DMA = &hdma_usart2_tx,
+    .Rx_DMA = &hdma_usart2_rx,
+    
+    .Tx_DMA_Len = UART2_TX_LEN,
+    .Rx_DMA_Len = UART2_RX_LEN,
+    
+    .Tx_Addr = &Uart2_TX_Buff[0],
+    .Rx_Addr = &Uart2_Rx_Buff[0],
+    
+    .Tx_DMA_CompleteFlag = 1,
+    .Rx_TimeOver = 0,
+
+    .relay.uart = &COM_Uart4,
+    
+    .Init = bsp_Uart_Init,
+    .Send = bsp_Uart_Send,
+    .Tx_DMA_TCInt = bsp_Uart_Tx_DMA_TCInt,
+    .Rx_IdleInt = bsp_Uart_Rx_IdleInt,
+    .Rx_TimeIncrementInt = bsp_Uart_Rx_TimeIncrement,
+    .Rx_DataAnalysis = NULL,
+    .Rx_Task = bsp_Uart_Rx_Task,
+};
+
+bsp_Uart_t COM_Uart4 =
+{ 
+    .RxQueue = queue(u8,UART4_RX_LEN),
+    .Uart =&huart4,
+    
+    .Tx_DMA = &hdma_uart4_tx,
+    .Rx_DMA = &hdma_uart4_rx,
+    
+    .Tx_DMA_Len = UART4_TX_LEN,
+    .Rx_DMA_Len = UART4_RX_LEN,
+    
+    .Tx_Addr = &Uart4_TX_Buff[0],
+    .Rx_Addr = &Uart4_Rx_Buff[0],
+    
+    .Tx_DMA_CompleteFlag = 1,
+    .Rx_TimeOver = 0,
+
+    .relay.uart = NULL,
+    
+    .Init = bsp_Uart_Init,
+    .Send = bsp_Uart_Send,
+    .Tx_DMA_TCInt = bsp_Uart_Tx_DMA_TCInt,
+    .Rx_IdleInt = bsp_Uart_Rx_IdleInt,
+    .Rx_TimeIncrementInt = bsp_Uart_Rx_TimeIncrement,
+    .Rx_DataAnalysis = NULL,
+    .Rx_Task = bsp_Uart_Rx_Task,
+};
+
+
+/* <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
+static void bsp_Uart_Init(bsp_Uart_t *p_Uart)
+{  
+        /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݽ<EFBFBD><DDBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+    //p_Uart->Rx_DataAnalysis = NULL;
+    
+    /* <20><><EFBFBD>ÿ<EFBFBD><C3BF><EFBFBD><EFBFBD>ж<EFBFBD> */
+    __HAL_UART_ENABLE_IT(p_Uart->Uart, UART_IT_IDLE);
+    
+    /* <20><><EFBFBD><EFBFBD>DMA<4D><41><EFBFBD><EFBFBD> */
+    //HAL_UART_Receive_DMA(p_Uart->Uart, p_Uart->Rx_Addr, p_Uart->Rx_DMA_Len);
+    /* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
+    HAL_UARTEx_ReceiveToIdle_DMA(p_Uart->Uart, p_Uart->Rx_Addr, p_Uart->Rx_DMA_Len);
+}
+
+
+static void bsp_Uart_DMASend(bsp_Uart_t *p_Uart,u8 *pData, u16 Len)
+{
+    u32 tickstart,tick;
+    p_Uart->Tx_DMA_CompleteFlag = 0;      
+    if(p_Uart->Tx_DMA_Len  < Len)
+        Len = p_Uart->Tx_DMA_Len;
+    memcpy(p_Uart->Tx_Addr, pData, Len); /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD><EFBFBD>ͻ<EFBFBD><CDBB><EFBFBD>*/
+   
+//    /*<2A><><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD>ͣ<EFBFBD><CDA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD>ͣ<EFBFBD><CDA3>ᵼ<EFBFBD><E1B5BC><EFBFBD>շ<EFBFBD><D5B7><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD>л<EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+//    HAL_UART_Transmit(p_Uart->Uart,p_Uart->Tx_Addr,Len,500);
+    
+    
+    HAL_UART_Transmit_DMA(p_Uart->Uart,p_Uart->Tx_Addr,Len);
+    tickstart = HAL_GetTick();
+    while( !p_Uart->Tx_DMA_CompleteFlag)
+    {
+        tick = HAL_GetTick();
+        if((tick - tickstart) > 200) // 1000ms <20><>ʱ
+        {
+            p_Uart->Tx_DMA_CompleteFlag = 1;
+            break;
+        }
+    }
+}
+
+/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+static void bsp_Uart_Send(bsp_Uart_t *p_Uart,u8 *pData, u16 Len)
+{
+    u16 i,SendNum;
+    
+    if(p_Uart == &COM_Uart4)
+        RS485_TX;
+    SendNum = Len / p_Uart->Tx_DMA_Len;
+    for(i=0;i<SendNum;i++)
+    {
+        bsp_Uart_DMASend(p_Uart,&pData[p_Uart->Tx_DMA_Len * i], p_Uart->Tx_DMA_Len);
+    }
+    
+    /*<2A><><EFBFBD><EFBFBD>ʣ<EFBFBD><CAA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+    Len -= p_Uart->Tx_DMA_Len * i;
+    if(0 == Len)
+    {
+        return ;
+    }
+    else
+    {
+        bsp_Uart_DMASend(p_Uart,&pData[p_Uart->Tx_DMA_Len * i],Len);
+    }
+}
+
+static void bsp_Uart_Tx_DMA_TCInt(bsp_Uart_t *p_Uart)
+{
+    p_Uart->Tx_DMA_CompleteFlag = 1;
+} 
+
+/*<2A><><EFBFBD>н<EFBFBD><D0BD><EFBFBD><EFBFBD>ж<EFBFBD>*/
+static void bsp_Uart_Rx_IdleInt(bsp_Uart_t *p_Uart)
+{
+    u16 Rx_Length, i;
+    /*ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD>*/    
+    HAL_UART_DMAStop(p_Uart->Uart);    
+
+    /* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD> */
+    Rx_Length = p_Uart->Rx_DMA_Len - __HAL_DMA_GET_COUNTER(p_Uart->Rx_DMA);
+    
+    /* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ0<CEAA><30>ֱ<EFBFBD>ӷ<EFBFBD><D3B7><EFBFBD> */
+    if (Rx_Length == 0) {
+        return;
+    }
+   
+    /* <20><><EFBFBD><EFBFBD> */
+    for (i = 0; i < Rx_Length; i++) 
+    {
+        queue_push_back(p_Uart->RxQueue, (void *)&p_Uart->Rx_Addr[i]);
+    } 
+    /* <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD> */
+    bsp_Uart_Rx_TimeStart(p_Uart); 
+//    HAL_UART_Receive_DMA(p_Uart->Uart, p_Uart->Rx_Addr, p_Uart->Rx_DMA_Len);
+    HAL_UARTEx_ReceiveToIdle_DMA(p_Uart->Uart, p_Uart->Rx_Addr, p_Uart->Rx_DMA_Len);
+}
+
+
+
+
+/*<2A>жϼ<D0B6><CFBC><EFBFBD>*/
+static void bsp_Uart_Rx_TimeIncrement(bsp_Uart_t *p_Uart,u16 Time)
+{
+    /*<2A><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>*/
+    if(1 == p_Uart->Rx_StartFlag)
+    {
+        p_Uart->Rx_TimeCount += Time;
+    }
+}
+
+/*<2A><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>*/
+static void bsp_Uart_Rx_TimeStart(bsp_Uart_t *p_Uart)
+{
+    p_Uart->Rx_StartFlag = 1;
+    p_Uart->Rx_TimeCount = 0;
+}
+
+/*ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD>*/
+static void bsp_Uart_Rx_TimeStop(bsp_Uart_t *p_Uart)
+{
+    p_Uart->Rx_StartFlag = 0;
+    p_Uart->Rx_TimeCount = 0;
+}
+
+static void bsp_Uart_Rx_Task(bsp_Uart_t *p_Uart)
+{
+    /*<2A><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><C9A3><EFBFBD><EFBFBD>յ<EFBFBD>һ֡<D2BB><D6A1><EFBFBD><EFBFBD>*/
+    if(p_Uart->Rx_TimeOver < p_Uart->Rx_TimeCount)
+    {
+        p_Uart->Rx_Len = queue_size(p_Uart->RxQueue);
+        /*ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD>*/
+        bsp_Uart_Rx_TimeStop(p_Uart);   
+        if(p_Uart->Rx_Len <= p_Uart->Rx_DMA_Len && (0 != p_Uart->Rx_Len))
+        {
+            if(RX_TEMP_BUFF_NUM < p_Uart->Rx_Len)
+            {
+                 queue_clear(p_Uart->RxQueue);
+            }
+            else
+            {
+                for(u16 i = 0;i < p_Uart->Rx_Len;i++)
+                {
+                    queue_pop(p_Uart->RxQueue,&Rx_Temp_Buff[i]);
+                }
+                if(NULL != p_Uart->Rx_DataAnalysis)
+                {
+                    p_Uart->Rx_DataAnalysis(Rx_Temp_Buff,p_Uart->Rx_Len,p_Uart);  /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/  
+                }
+               // p_Uart->Send(p_Uart,Rx_Temp_Buff,p_Uart->Rx_Len);
+            }
+        }
+    }
+}
+
+
+
+// <20><><EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD>ORE
+void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) 
+{
+    bsp_Uart_t *p_Uart = NULL;
+    if (huart->Instance == USART1) 
+    {
+        p_Uart = &COM_Uart1;
+    }
+    else if (huart->Instance == USART2) 
+    {
+        p_Uart = &COM_Uart2;
+    }
+    else if (huart->Instance == UART4) 
+    {
+        p_Uart = &COM_Uart4;
+    }
+    
+        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    if(huart->ErrorCode & HAL_UART_ERROR_NE)
+    {
+        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+        __HAL_UART_CLEAR_NEFLAG(huart);
+    }
+    if(huart->ErrorCode & HAL_UART_ERROR_FE)
+    {
+        // <20><><EFBFBD><EFBFBD>֡<EFBFBD><D6A1><EFBFBD><EFBFBD>
+        __HAL_UART_CLEAR_FEFLAG(huart);
+    }
+    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>...
+    if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) 
+     {
+         __HAL_UART_CLEAR_OREFLAG(huart); // <20><><EFBFBD><EFBFBD>ORE<52><45>־
+     }
+        if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) 
+     {
+         __HAL_UART_CLEAR_FEFLAG(huart); // <20><><EFBFBD><EFBFBD>ORE<52><45>־
+     }
+        
+//    
+    if(p_Uart != NULL)
+    {
+//        HAL_UART_DeInit(huart);
+//        HAL_UART_Init(huart);
+//        HAL_UART_DMAStop(p_Uart->Uart);
+        HAL_UARTEx_ReceiveToIdle_DMA(p_Uart->Uart, p_Uart->Rx_Addr, p_Uart->Rx_DMA_Len);
+    }
+}
+
+// ʵ<>ֿ<EFBFBD><D6BF><EFBFBD><EFBFBD>жϻص<CFBB>
+void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
+{
+    if (huart->Instance == USART1) 
+    {
+        bsp_Uart_Rx_IdleInt(&COM_Uart1);
+    } 
+    else if (huart->Instance == USART2) 
+    {
+        bsp_Uart_Rx_IdleInt(&COM_Uart2);
+    } 
+    else if (huart->Instance == UART4) 
+    {
+        bsp_Uart_Rx_IdleInt(&COM_Uart4);
+    }
+}
+
+/* <20><><EFBFBD>ڽ<EFBFBD><DABD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɻص<C9BB><D8B5><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD> */
+void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
+{
+//    if (__HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE)) 
+//    {
+//        __HAL_UART_CLEAR_IDLEFLAG(huart);
+
+//        if (huart->Instance == USART1) 
+//        {
+//            bsp_Uart_Rx_IdleInt(&COM_Uart1);
+//        } 
+//        else if (huart->Instance == USART2) 
+//        {
+//            bsp_Uart_Rx_IdleInt(&COM_Uart2);
+//        } 
+//        else if (huart->Instance == UART4) 
+//        {
+//            bsp_Uart_Rx_IdleInt(&COM_Uart4);
+//        }
+//    }
+}
+
+
+void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) 
+{
+    if (huart->Instance == USART1) 
+    {
+        COM_Uart1.Tx_DMA_TCInt(&COM_Uart1);
+    }
+    else if (huart->Instance == USART2) 
+    {
+        COM_Uart2.Tx_DMA_TCInt(&COM_Uart2);
+    }
+    else if (huart->Instance == UART4) 
+    {
+        RS485_RX;
+        COM_Uart4.Tx_DMA_TCInt(&COM_Uart4);
+    }
+}
+

calib_board/usr/bsp/bsp_Uart.h

@@ -0,0 +1,59 @@
+#ifndef _BSP_UART_H_
+#define _BSP_UART_H_
+
+#include "main.h"
+#include "algo_Queue.h"
+
+typedef struct bsp_Uart_t bsp_Uart_t;
+
+
+#define usart_type          UART_HandleTypeDef 
+#define dma_type            DMA_HandleTypeDef     
+
+/*<2A><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>*/
+typedef struct
+{
+    u8 flag;                              /*<2A><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD>־λ*/
+    bsp_Uart_t *uart;                      /*ת<><D7AA><EFBFBD><EFBFBD>ȥ<EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>*/
+    u16 time_out;                         /*ת<><D7AA><EFBFBD><EFBFBD>ʱʱ<CAB1><CAB1>*/
+}bsp_uart_relay_t;
+
+struct bsp_Uart_t
+{
+    queue RxQueue;                                  /*<2A><><EFBFBD>ݽ<EFBFBD><DDBD>ն<EFBFBD><D5B6><EFBFBD>*/
+    usart_type *Uart;                               /*<2A><><EFBFBD><EFBFBD>*/    
+        
+    dma_type *Tx_DMA;                               /*DMA*/   
+    dma_type *Rx_DMA;
+
+    u8 Tx_DMA_CH;           
+    u8 Rx_DMA_CH;           
+    vu8 Tx_DMA_CompleteFlag;                        /*DMA<4D><41><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɱ<EFBFBD>־λ*/
+        
+    u8 *Tx_Addr;                                    /*DMA<4D><41><EFBFBD>˻<EFBFBD><CBBB><EFBFBD>*/
+    u8 *Rx_Addr;
+    u16 Tx_DMA_Len;
+    u16 Rx_DMA_Len;
+
+    u16 Rx_Len;                                     /*<2A><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>*/
+    u16 Rx_TimeCount;                               /*<2A><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>*/
+    u16 Rx_TimeOver;                                /*<2A><>ʱʱ<CAB1><CAB1>*/
+    u8 Rx_StartFlag;                                /*<2A><>ʼ<EFBFBD><CABC>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>־λ*/
+    
+
+    bsp_uart_relay_t relay;                         /*<2A><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>*/
+    void (*Init)(bsp_Uart_t *);                     /*<2A><>ʼ<EFBFBD><CABC>*/
+    void (*Send)(bsp_Uart_t *,u8 *,u16);            /*<2A><><EFBFBD>ڷ<EFBFBD><DAB7>ͺ<EFBFBD><CDBA><EFBFBD>*/
+
+    void (*Tx_DMA_TCInt)(bsp_Uart_t *);             /*DMA<4D><41><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD>*/
+
+    void (*Rx_IdleInt)(bsp_Uart_t *);               /*<2A><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD>*/
+    void (*Rx_TimeIncrementInt)(bsp_Uart_t *,u16);  /*<2A>жϼ<D0B6><CFBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+    void (*Rx_DataAnalysis)(u8 *,u16,void *);       /*<2A><><EFBFBD>ݽ<EFBFBD><DDBD><EFBFBD>*/
+    void (*Rx_Task)(bsp_Uart_t *);                  /*<2A><><EFBFBD>ڽ<EFBFBD><DABD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/ 
+};
+
+extern bsp_Uart_t COM_Uart1;
+extern bsp_Uart_t COM_Uart2;
+extern bsp_Uart_t COM_Uart4;
+#endif

calib_board/usr/bsp/bsp_Wdg.c

@@ -0,0 +1,25 @@
+#include "bsp_Wdg.h"
+
+//#include "iwdg.h"
+
+static void bsp_Wdg_Init(void);
+static void bsp_Wdg_Feed(void);
+
+bsp_Wdg_t Wdg = 
+{
+    .Init = bsp_Wdg_Init,
+    .Feed = bsp_Wdg_Feed,
+};
+
+bsp_Wdg_t *pWdg = &Wdg;
+
+static void bsp_Wdg_Init(void)
+{
+// __HAL_DBGMCU_FREEZE_IWDG();	  //<2F><><EFBFBD><EFBFBD>ģʽ<C4A3>£<EFBFBD><C2A3><EFBFBD><EFBFBD>ῴ<EFBFBD>Ź<EFBFBD><C5B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
+}
+
+static void bsp_Wdg_Feed(void)
+{
+// HAL_IWDG_Refresh(&hiwdg);
+}
+

calib_board/usr/bsp/bsp_Wdg.h

@@ -0,0 +1,13 @@
+#ifndef _BSP_WDG_H_
+#define _BSP_WDG_H_
+
+#include "main.h"
+
+typedef struct
+{
+    void (*Init)(void);
+    void (*Feed)(void);
+}bsp_Wdg_t;
+
+extern bsp_Wdg_t Wdg;
+#endif

calib_board/usr/bsp/sys.h

@@ -0,0 +1,104 @@
+#ifndef _SYS_H_
+#define _SYS_H_ 
+
+#include "stm32f4xx.h"
+
+//<2F><><EFBFBD><EFBFBD>һЩ<D2BB><D0A9><EFBFBD>õ<EFBFBD><C3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ͷ̹ؼ<CCB9><D8BC><EFBFBD> 
+typedef int32_t  s32;
+typedef int16_t s16;
+typedef int8_t  s8;
+
+typedef const int32_t sc32;  
+typedef const int16_t sc16;  
+typedef const int8_t sc8;  
+
+typedef __IO int32_t  vs32;
+typedef __IO int16_t  vs16;
+typedef __IO int8_t   vs8;
+
+typedef __I int32_t vsc32;  
+typedef __I int16_t vsc16; 
+typedef __I int8_t vsc8;   
+
+typedef uint32_t  u32;
+typedef uint16_t u16;
+typedef uint8_t  u8;
+
+typedef const uint32_t uc32;  
+typedef const uint16_t uc16;  
+typedef const uint8_t uc8; 
+
+typedef __IO uint32_t  vu32;
+typedef __IO uint16_t vu16;
+typedef __IO uint8_t  vu8;
+
+typedef __I uint32_t vuc32;  
+typedef __I uint16_t vuc16; 
+typedef __I uint8_t vuc8;  
+
+
+#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
+#define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
+#define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum)) 
+//IO<49>ڵ<EFBFBD>ַӳ<D6B7><D3B3>
+#define GPIOA_ODR_Addr    (GPIOA_BASE+12) //0x4001080C 
+#define GPIOB_ODR_Addr    (GPIOB_BASE+12) //0x40010C0C 
+#define GPIOC_ODR_Addr    (GPIOC_BASE+12) //0x4001100C 
+#define GPIOD_ODR_Addr    (GPIOD_BASE+12) //0x4001140C 
+#define GPIOE_ODR_Addr    (GPIOE_BASE+12) //0x4001180C 
+#define GPIOF_ODR_Addr    (GPIOF_BASE+12) //0x40011A0C    
+#define GPIOG_ODR_Addr    (GPIOG_BASE+12) //0x40011E0C    
+
+#define GPIOA_IDR_Addr    (GPIOA_BASE+8) //0x40010808 
+#define GPIOB_IDR_Addr    (GPIOB_BASE+8) //0x40010C08 
+#define GPIOC_IDR_Addr    (GPIOC_BASE+8) //0x40011008 
+#define GPIOD_IDR_Addr    (GPIOD_BASE+8) //0x40011408 
+#define GPIOE_IDR_Addr    (GPIOE_BASE+8) //0x40011808 
+#define GPIOF_IDR_Addr    (GPIOF_BASE+8) //0x40011A08 
+#define GPIOG_IDR_Addr    (GPIOG_BASE+8) //0x40011E08 
+ 
+//IO<49>ڲ<EFBFBD><DAB2><EFBFBD>,ֻ<>Ե<EFBFBD>һ<EFBFBD><D2BB>IO<49><4F>!
+//ȷ<><C8B7>n<EFBFBD><6E>ֵС<D6B5><D0A1>16!
+#define PAout(n)   BIT_ADDR(GPIOA_ODR_Addr,n)  //<2F><><EFBFBD><EFBFBD> 
+#define PAin(n)    BIT_ADDR(GPIOA_IDR_Addr,n)  //<2F><><EFBFBD><EFBFBD> 
+
+#define PBout(n)   BIT_ADDR(GPIOB_ODR_Addr,n)  //<2F><><EFBFBD><EFBFBD> 
+#define PBin(n)    BIT_ADDR(GPIOB_IDR_Addr,n)  //<2F><><EFBFBD><EFBFBD> 
+
+#define PCout(n)   BIT_ADDR(GPIOC_ODR_Addr,n)  //<2F><><EFBFBD><EFBFBD> 
+#define PCin(n)    BIT_ADDR(GPIOC_IDR_Addr,n)  //<2F><><EFBFBD><EFBFBD> 
+
+#define PDout(n)   BIT_ADDR(GPIOD_ODR_Addr,n)  //<2F><><EFBFBD><EFBFBD> 
+#define PDin(n)    BIT_ADDR(GPIOD_IDR_Addr,n)  //<2F><><EFBFBD><EFBFBD> 
+
+#define PEout(n)   BIT_ADDR(GPIOE_ODR_Addr,n)  //<2F><><EFBFBD><EFBFBD> 
+#define PEin(n)    BIT_ADDR(GPIOE_IDR_Addr,n)  //<2F><><EFBFBD><EFBFBD>
+
+#define PFout(n)   BIT_ADDR(GPIOF_ODR_Addr,n)  //<2F><><EFBFBD><EFBFBD> 
+#define PFin(n)    BIT_ADDR(GPIOF_IDR_Addr,n)  //<2F><><EFBFBD><EFBFBD>
+
+#define PGout(n)   BIT_ADDR(GPIOG_ODR_Addr,n)  //<2F><><EFBFBD><EFBFBD> 
+#define PGin(n)    BIT_ADDR(GPIOG_IDR_Addr,n)  //<2F><><EFBFBD><EFBFBD>
+/////////////////////////////////////////////////////////////////
+//Ex_NVIC_Configר<67>ö<EFBFBD><C3B6><EFBFBD>
+#define GPIO_A 0
+#define GPIO_B 1
+#define GPIO_C 2
+#define GPIO_D 3
+#define GPIO_E 4
+#define GPIO_F 5
+#define GPIO_G 6 
+#define FTIR   1  //<2F>½<EFBFBD><C2BD>ش<EFBFBD><D8B4><EFBFBD>
+#define RTIR   2  //<2F><><EFBFBD><EFBFBD><EFBFBD>ش<EFBFBD><D8B4><EFBFBD>
+
+
+
+
+#endif
+
+
+
+
+
+
+

calib_board/usr/bsp/tjc_usart_hmi.h

@@ -0,0 +1,155 @@
+#ifndef __TJCUSARTHMI_H_
+#define __TJCUSARTHMI_H_
+
+#include "stm32f4xx.h"
+#include "main.h"  // <20><><EFBFBD><EFBFBD> HAL <20><>ͷ<EFBFBD>ļ<EFBFBD>
+#include "bsp_Uart.h"
+#include "bsp_Flash.h"  // <20><><EFBFBD><EFBFBD>Flash<73><68><EFBFBD><EFBFBD>֧<EFBFBD><D6A7>
+
+// <20><><EFBFBD><EFBFBD>ʹ<EFBFBD>õĴ<C3B5><C4B4>ھ<EFBFBD><DABE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>main.c<>ж<EFBFBD><D0B6><EFBFBD><EFBFBD><EFBFBD>huart2<74><32>
+extern UART_HandleTypeDef huart2;
+
+// <20><><EFBFBD>崮<EFBFBD><E5B4AE><EFBFBD><EFBFBD>ʹ<EFBFBD>õĴ<C3B5><C4B4><EFBFBD>
+#define TJC_UART huart2
+
+// <20><><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+#define RINGBUFF_LEN (500)
+
+// ָ<><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>TJC<4A><43><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Э<EFBFBD>飩
+#define TJC_END_BYTES 0xFF
+
+// <20><><EFBFBD><EFBFBD>ָ<EFBFBD><EFBFBD><EEB3A4>
+#define MAX_COMMAND_LEN 200  // <20><><EFBFBD>ӳ<EFBFBD><D3B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӧ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
+
+// <20>Զ<EFBFBD><D4B6><EFBFBD>ָ<EFBFBD><EFBFBD><EEB6A8>
+#define CUSTOM_CMD_HEADER_0 0xAA
+#define CUSTOM_CMD_HEADER_1 0x55
+
+// ָ<><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+#define CMD_DISPLAY_DATA       0x02  // <20><>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD>
+#define CMD_ALARM              0x03  // <20><><EFBFBD><EFBFBD>
+#define CMD_DELETE_DEVICE      0x04  // ɾ<><C9BE><EFBFBD>豸
+
+// <20><>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+#define SUB_CMD_SHOW_DEVICES   0x01  // <20><>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD>ӵ<EFBFBD><D3B5>豸
+#define SUB_CMD_REGION_STATS   0x02  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʾ
+#define SUB_CMD_REGION1_DEVICES 0x03 // <20><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>豸
+#define SUB_CMD_REGION2_DEVICES 0x04 // <20>ڶ<EFBFBD><DAB6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>豸
+#define SUB_CMD_REGION3_DEVICES 0x05 // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>豸
+#define SUB_CMD_REGION4_DEVICES 0x06 // <20><><EFBFBD>ĸ<EFBFBD><C4B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>豸
+
+// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+#define SUB_CMD_HISTORY_ALARM  0x01  // <20><>ʷ<EFBFBD><CAB7><EFBFBD><EFBFBD>
+#define SUB_CMD_REALTIME_ALARM 0x02  // ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD>
+
+// <20><><EFBFBD><EFBFBD><EFBFBD>豸ָ<E8B1B8><D6B8>ʶ<EFBFBD><CAB6>
+#define ADD_DEVICE_CMD_BYTE    0x43  // 'C'<27><>ASCII<49><49>
+
+// <20>ָ<EFBFBD><D6B8><EFBFBD>
+#define DATA_SEPARATOR 0xAA
+
+// ͨ<><CDA8>״̬ö<CCAC><C3B6>
+typedef enum {
+    COMM_STATUS_NORMAL = 0,      // <20><><EFBFBD><EFBFBD>
+    COMM_STATUS_ABNORMAL         // <20>쳣
+} CommStatus;
+
+// ©Һ״̬ö<CCAC><C3B6>
+typedef enum {
+    LEAK_NORMAL = 0,      // <20><><EFBFBD><EFBFBD>
+    LEAK_ABNORMAL         // ©Һ
+} LeakStatus;
+
+// <20>ϴ<EFBFBD>״̬ö<CCAC><C3B6>
+typedef enum {
+    BREAK_NORMAL = 0,     // <20><><EFBFBD><EFBFBD>
+    BREAK_ABNORMAL        // <20>ϴ<EFBFBD>
+} BreakStatus;
+
+// ͨ<><CDA8>״̬<D7B4>ṹ<EFBFBD><E1B9B9>
+typedef struct {
+    LeakStatus leak_status;      // ©Һ״̬
+    BreakStatus break_status;    // <20>ϴ<EFBFBD>״̬
+    int leak_meter;              // ©Һ<C2A9><D2BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>©Һ״̬Ϊ©Һ<C2A9><D2BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʾ0<CABE><30>
+} ChannelStatus;
+
+// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ö<EFBFBD><C3B6>
+typedef enum {
+    ALARM_LEAK = 0,      // ©Һ
+    ALARM_BREAK,         // <20>ϴ<EFBFBD>
+    ALARM_COMM           // ͨ<><CDA8><EFBFBD>쳣
+} AlarmType;
+
+// <20>豸<EFBFBD><E8B1B8>Ϣ<EFBFBD>ṹ<EFBFBD><E1B9B9>
+typedef struct {
+    uint8_t port;           // <20>˿ں<CBBF>
+    char region[20];        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӣ<EFBFBD>ģ<EFBFBD>
+    uint8_t device_id;      // <20>豸ID (1-254)
+    char device_name[20];   // <20>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>Ӣ<EFBFBD>ģ<EFBFBD>
+    LeakStatus leak_status;    // ©Һ״̬
+    BreakStatus break_status;  // <20>ϴ<EFBFBD>״̬
+    CommStatus comm_status;    // ͨ<><CDA8>״̬
+    ChannelStatus channels[4]; // <20>ĸ<EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD>״̬
+} DeviceInfo;
+
+// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD>ṹ<EFBFBD><E1B9B9>
+typedef struct {
+    char region[20];        // <20>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>
+    uint8_t device_id;      // <20>豸ID
+    char device_name[20];   // <20>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>
+    AlarmType alarm_type;   // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    char start_time[20];    // <20><>ʼʱ<CABC><CAB1>
+    char end_time[20];      // <20><><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
+} AlarmInfo;
+
+// <20><><EFBFBD><EFBFBD>ͳ<EFBFBD>ƽṹ<C6BD><E1B9B9>
+typedef struct {
+    char region_name[20];    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    uint8_t total_devices;   // <20><><EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>
+    uint8_t leak_devices;    // ©Һ<C2A9>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>
+    uint8_t break_devices;   // <20>ϴ<EFBFBD><CFB4>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>
+    uint8_t comm_devices;    // ͨ<><CDA8><EFBFBD>쳣<EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>
+} RegionStats;
+
+// <20>ⲿ<EFBFBD>ɵ<EFBFBD><C9B5>ú<EFBFBD><C3BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+void TJC_Init(bsp_Uart_t *pUart);
+void TJC_SendData(uint8_t *data, uint16_t len);
+void TJCPrintf(const char *cmd, ...);
+
+// <20><><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>غ<EFBFBD><D8BA><EFBFBD>
+uint16_t TJC_CleanBufferFromInvalidPatterns(void);
+void initRingBuffer(void);
+void writeRingBuff(uint8_t data);
+void deleteRingBuff(uint16_t size);
+uint16_t getRingBuffLength(void);
+uint8_t read1BFromRingBuff(uint16_t position);
+uint8_t isRingBuffOverflow(void);
+
+// ָ<><EFBFBD><EEB4A6><EFBFBD><EFBFBD><EFBFBD>غ<EFBFBD><D8BA><EFBFBD>
+void TJC_ProcessCommand(uint8_t *cmd, uint16_t len);
+uint8_t TJC_CheckEndBytes(uint8_t *data, uint16_t len, uint16_t *end_pos);
+void TJC_SendResponse(const char *response);
+void TJC_ProcessSerialData(u8 *data, u16 len, void *p_arg);
+void TJC_DeleteDevices(uint8_t *delete_flags, uint8_t flag_count);
+void TJC_ProcessDeleteCommand(uint8_t *cmd, uint16_t len);
+
+/*<2A><><EFBFBD>Է<EFBFBD><D4B7><EFBFBD><EFBFBD><EFBFBD>ʷ<EFBFBD><CAB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+void TJC_SendInitCommands(void);
+
+// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+uint16_t CalculateCRC16(uint8_t *data, uint16_t length);
+void TJC_ProcessCustomCommand(uint8_t *cmd, uint16_t len);
+void TJC_SendAlarmHistory(void);
+void TJC_SendRealtimeAlarms(void);
+void TJC_SendDeviceList(void);
+uint8_t TJC_AddDeviceToFlash(uint8_t *data, uint16_t len);
+void TJC_SendRegionStats(void);  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͳ<EFBFBD><CDB3>
+void TJC_SendRegionDeviceDetails(uint8_t region_index); 
+
+// <20>궨<EFBFBD><EAB6A8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+#define usize getRingBuffLength()
+#define code_c() initRingBuffer()
+#define udelete(x) deleteRingBuff(x)
+#define u(x) read1BFromRingBuff(x)
+
+#endif

calib_board/usr/protocol/proto_modbus_lib.c

@@ -0,0 +1,300 @@
+#include "proto_modbus_lib.h"
+#include "stdio.h"
+#include "string.h"
+#include "bsp_Uart.h"
+
+/**************************************************
+ *<2A><><EFBFBD>ƣ<EFBFBD> modbus_lib_crc16
+ *<2A><><EFBFBD>ܣ<EFBFBD> modbus crc16У<36><D0A3>
+ *<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> p_data -- У<><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
+ *       len    -- <20><><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD> 
+ *<2A><><EFBFBD>أ<EFBFBD> У<><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+**************************************************/
+u16 modbus_lib_crc16(u8 *p_data, u16 len)
+{
+    u16 crc16 = 0xffff;
+    u16 i;
+    while(len--)
+    {
+        crc16 = crc16^(*p_data++);
+        for(i=0; i++<8; )
+        {
+            if(crc16&0x0001)
+            {
+                crc16 = (crc16>>1)^0xa001;
+            }
+            else 
+            {
+                crc16>>=1;
+            }
+        }
+    }
+    return crc16;
+}
+
+/************************************
+ * <20><><EFBFBD><EFBFBD>: Float2u16
+ * <20><><EFBFBD><EFBFBD>: <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĸ<EFBFBD>16<31><36><EFBFBD><EFBFBD>16λ
+ * <20><><EFBFBD><EFBFBD>: float_data : Ҫת<D2AA><D7AA><EFBFBD>ĸ<EFBFBD><C4B8><EFBFBD><EFBFBD><EFBFBD>
+         h_l      : <20><><EFBFBD>ظ<EFBFBD>16λ<36><CEBB><EFBFBD>ǵ<EFBFBD>16λ
+ * <20><><EFBFBD><EFBFBD>: <20><><EFBFBD>ض<EFBFBD>Ӧ<EFBFBD>ĸ<EFBFBD>16λ<36><CEBB><EFBFBD>ǵ<EFBFBD>16λ
+ * <20><><EFBFBD><EFBFBD>: <20><>
+ ******************************************/
+u16 float_to_u16(float float_data,unsigned char h_l)
+{
+  u16 temp = 0XFFFF;
+  if(h_l == U16_DATA_L)
+  {
+    temp = *((u32 *)&float_data) & 0x0000ffff; 
+  }
+  else if(h_l == U16_DATA_H)
+  {
+    temp = ((*((u32 *)&float_data)) >> 16) & 0x0000ffff;
+  }
+  return temp;
+}
+
+/******************************************
+ * <20><><EFBFBD><EFBFBD>: u32TOu16
+ * <20><><EFBFBD><EFBFBD>: <20><>ȡu32<33>ĸ<EFBFBD>16<31><36><EFBFBD><EFBFBD>16λ
+ * <20><><EFBFBD><EFBFBD>: u32_data   : Ҫת<D2AA><D7AA><EFBFBD><EFBFBD>u32
+         h_l      : <20><><EFBFBD>ظ<EFBFBD>16λ<36><CEBB><EFBFBD>ǵ<EFBFBD>16λ
+ * <20><><EFBFBD><EFBFBD>: <20><><EFBFBD>ض<EFBFBD>Ӧ<EFBFBD>ĸ<EFBFBD>16λ<36><CEBB><EFBFBD>ǵ<EFBFBD>16λ
+ * <20><><EFBFBD><EFBFBD>: <20><>
+ ******************************************/
+u16 u32_to_u16(u32 u32_data,unsigned char h_l)
+{
+  u16 temp = 0XFFFF;
+  if(h_l == U16_DATA_L)
+  {
+    temp = u32_data & 0x0000ffff; 
+  }
+  else if(h_l == U16_DATA_H)
+  {
+    temp = (u32_data >> 16) & 0x0000ffff;
+  }
+  return temp;
+}
+
+void u32_to_u8(u32 u32_data,u8 *p_data,u8 endian)
+{
+    if(BIG_ENDIAN == endian)
+    {
+        for(u8 i = 0;i < 4;i++)
+        {
+            p_data[i] = (u32_data >> (8 * (3 - i))) & 0xff;
+        } 
+    }
+    else if(LITTLE_ENDIAN == endian)
+    {
+        for(u8 i = 0;i < 4;i++)
+        {
+            p_data[i] = (u32_data >> (8 * i)) & 0xff;
+        } 
+    }
+}
+
+void u16_to_u8(u16 u16_data,u8 *p_data,u8 endian)
+{
+    if(BIG_ENDIAN == endian)
+    {
+        for(u8 i = 0;i < 2;i++)
+        {
+            p_data[i] = (u16_data >> (8 * (1 - i))) & 0xff;
+        } 
+    }
+    else if(LITTLE_ENDIAN == endian)
+    {
+        for(u8 i = 0;i < 2;i++)
+        {
+            p_data[i] = (u16_data >> (8 * i)) & 0xff;
+        } 
+    }
+}
+
+float u32_to_float(u32 u32_data,unsigned char h_l)
+{
+    float temp = 0;
+    temp = *((float *)&u32_data); 
+    return temp;
+}
+
+/*<2A><>u8_endian<61><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>p_u8dataת<61><D7AA>Ϊ<EFBFBD><CEAA>Ƭ<EFBFBD><C6AC><EFBFBD><EFBFBD>Ӧ<EFBFBD><D3A6>С<EFBFBD><D0A1><EFBFBD><EFBFBD>*/
+u32 u8_to_u32(u8 *p_u8data,unsigned char u8_endian)
+{
+    u32 temp = 0;
+    if(BIG_ENDIAN == u8_endian)
+    {
+        for(u8 i = 0;i < 4;i++)
+        {
+            temp |= p_u8data[i] << ((3 - i) * 8);  
+        } 
+    }
+    else if(LITTLE_ENDIAN == u8_endian)
+    {
+        for(u8 i = 0;i < 4;i++)
+        {
+            temp |= p_u8data[i] << (i * 8);  
+        }
+    }
+    return temp;
+}
+
+/*<2A><>u8_endian<61><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>p_u8dataת<61><D7AA>Ϊ<EFBFBD><CEAA>Ƭ<EFBFBD><C6AC><EFBFBD><EFBFBD>Ӧ<EFBFBD><D3A6>С<EFBFBD><D0A1><EFBFBD><EFBFBD>*/
+u16 u8_to_u16(u8 *p_u8data,unsigned char u8_endian)
+{
+    u32 temp = 0;
+    if(BIG_ENDIAN == u8_endian)
+    {
+        for(u8 i = 0;i < 2;i++)
+        {
+            temp |= p_u8data[i] << ((1 - i) * 8);  
+        } 
+    }
+    else if(LITTLE_ENDIAN == u8_endian)
+    {
+        for(u8 i = 0;i < 2;i++)
+        {
+            temp |= p_u8data[i] << (i * 8);  
+        }
+    }
+    return temp;
+}
+
+/*<2A>ֽڶ<D6BD><DAB6><EFBFBD>ת<EFBFBD><D7AA>*/
+u32 u32_endian_conv(u32 data)
+{
+    u32 temp = 0;
+    temp =   (((data >> 0 ) & 0xff) << 24)
+               | (((data >> 8 ) & 0xff) << 16)
+               | (((data >> 16) & 0xff) << 8 )
+               | (((data >> 24) & 0xff) << 0 );
+     return temp;
+}
+
+/*<2A>ֽڶ<D6BD><DAB6><EFBFBD>ת<EFBFBD><D7AA>*/
+u16 u16_endian_conv(u16 data)
+{
+    u16 temp = 0;
+    temp =    (((data >> 0) & 0xff) << 8)
+               | (((data >> 8) & 0xff) << 0);
+     return temp;
+}
+
+
+/******************************************
+* <20><><EFBFBD><EFBFBD>: ModbusReaddata
+* <20><><EFBFBD><EFBFBD>: MODBUS<55><53><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+* <20><><EFBFBD><EFBFBD>: Id   :MODBUS<55>ӻ<EFBFBD><D3BB><EFBFBD>ַ
+*       addr :д<><D0B4><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD>ʼ<EFBFBD><CABC>ַ
+*       Num  :д<>ļĴ<C4BC><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+*       send  :<3A><><EFBFBD>ڷ<EFBFBD><DAB7>ͺ<EFBFBD><CDBA><EFBFBD>
+* <20><><EFBFBD><EFBFBD>: <20><>
+* <20><><EFBFBD><EFBFBD>: <20><>
+******************************************/
+void modbus_lib_data_read(u8 id,u16 addr,u16 num,void (*send)(u8 *,u16 ))
+{
+  u8 tx[8];
+  u16 crc16;
+  tx[0] = id;
+  tx[1] = 0x41;//0x03;
+  tx[2] = (addr >> 8) & 0xff;
+  tx[3] = addr & 0xff;
+  tx[4] = (num >> 8) & 0xff;
+  tx[5] = num & 0xff;
+  crc16 = modbus_lib_crc16(tx,6);
+  tx[6] = crc16 & 0xff;
+  tx[7] = (crc16 >> 8) & 0xff;  
+  send(tx,8);
+}
+
+/******************************************
+* <20><><EFBFBD><EFBFBD>: modbus_multiple_data_write
+* <20><><EFBFBD><EFBFBD>: MODBUSд<53><D0B4><EFBFBD><EFBFBD>
+* <20><><EFBFBD><EFBFBD>: Id   :MODBUS<55>ӻ<EFBFBD><D3BB><EFBFBD>ַ
+*       addr :д<><D0B4><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD>ʼ<EFBFBD><CABC>ַ
+*       Num  :д<>ļĴ<C4BC><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+*       data :д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+*       send  :<3A><><EFBFBD>ڷ<EFBFBD><DAB7>ͺ<EFBFBD><CDBA><EFBFBD>
+* <20><><EFBFBD><EFBFBD>: <20><>
+* <20><><EFBFBD><EFBFBD>: <20><>
+******************************************/
+void modbus_lib_multiple_data_write(u8 id,u16 addr,u16 Num,u16 *data,void (*send)(u8 *,u16 ))
+{
+  u8 tx[50];
+  u16 crc16,i;
+  tx[0] = id;
+  tx[1] = 0x10;
+  tx[2] = (addr >> 8) & 0xff;
+  tx[3] = addr & 0xff;
+  tx[4] = (Num >> 8) & 0xff;
+  tx[5] = Num & 0xff;
+  tx[6] = Num * 2;
+  for(i = 0;i < tx[6]/2;i++)
+  {
+    tx[7 + 2 * i] = (data[i] >> 8) & 0xff;
+    tx[8 + 2 * i] = data[i] & 0xff;  
+  }
+  crc16 = modbus_lib_crc16(tx,7 + 2 * i);
+  tx[7 + 2 * i] = crc16 & 0xff;
+  tx[8 + 2 * i] = (crc16 >> 8) & 0xff;  
+  send(tx,9 + 2 * i);
+}
+
+void modbus_lib_only_data_write(u8 id,u16 addr,u16 value,void (*send)(u8 *,u16 ))
+{
+  u8 tx[8];
+  u16 crc16;
+  tx[0] = id;
+  tx[1] = 0x06;
+  tx[2] = (addr >> 8) & 0xff;
+  tx[3] = addr & 0xff;
+  tx[4] = (value >> 8) & 0xff;
+  tx[5] = value & 0xff;  
+  crc16 = modbus_lib_crc16(tx,6);
+  tx[6] = crc16 & 0xff;
+  tx[7] = (crc16 >> 8) & 0xff;  
+  send(tx,8);
+}
+
+
+//01    10      00 02           00 01        02               12 34          CRC
+//id    Func    Startaddress    RegNumber    wdataaddress    
+u8 modbus_lib_analysis(modbus_analysis_data_t *p_modbus, u8 *p_data, u16 len)
+{
+    u16 crc16;
+    u16 u16_temp;
+
+    if(NULL == p_modbus) return 0;
+    if(len < 8) return 0;
+
+    crc16 = modbus_lib_crc16(p_data, len-2);
+    u16_temp = *(p_data+len-1);
+    u16_temp <<= 8;
+    u16_temp |= *(p_data+len-2);
+    if(u16_temp != crc16) return 0;
+
+    p_modbus->id = *p_data;
+    p_modbus->func = *(p_data+1);
+
+    p_modbus->start_addr = (*(p_data+2))<<8;
+    p_modbus->start_addr |= *(p_data+3);
+
+    /*<2A><><EFBFBD><EFBFBD>дһ<D0B4><D2BB><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>*/
+    if(0x06 == p_modbus->func)
+    {
+        p_modbus->write_data_addr = p_data+4;
+    } 
+    else if(0x10 == p_modbus->func) /*д<><D0B4><EFBFBD><EFBFBD><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>*/
+    {
+        p_modbus->reg_number = (*(p_data+4))<<8;
+        p_modbus->reg_number |= *(p_data+5);
+        p_modbus->write_data_addr = p_data+7;
+    }
+    else
+    {
+        p_modbus->reg_number = (*(p_data+4))<<8;
+        p_modbus->reg_number |= *(p_data+5);
+    } 
+    return 1;
+}

calib_board/usr/protocol/proto_modbus_lib.h

@@ -0,0 +1,67 @@
+#ifndef _PROTO_MODBUS_LIB_H_
+#define _PROTO_MODBUS_LIB_H_
+
+#include "main.h"
+
+#define MODBUS_DEFAULT_ID  (0x01)
+#define MODBUS_SENDBUF_LEN (2048U)
+
+#define U16_DATA_L      (0)//<2F><>16λ
+#define U16_DATA_H      (1)//<2F><>16λ
+
+#define BIG_ENDIAN      (0)//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+#define LITTLE_ENDIAN   (1)//С<><D0A1><EFBFBD><EFBFBD>
+
+typedef struct {
+  u8 send_buffer[MODBUS_SENDBUF_LEN];
+  u16 len;
+}modbus_communication_send_buf_t;
+
+typedef struct
+{
+    u8 id;                          /*ModbusID*/
+    u8 func;                        /*<2A><><EFBFBD>ܺ<EFBFBD>*/
+    u16 start_addr;                 /*<2A><>ʼ<EFBFBD><CABC>ַ*/
+    u16 reg_number;                 /*<2A>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+    u8 *write_data_addr;            /*д<><D0B4><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD>ַ*/
+}modbus_analysis_data_t;
+
+typedef enum
+{
+    ModbusErrorCode_Success         = 0x00,
+    ModbusErrorCode_IllegalFunction = 0x01,
+    ModbusErrorCode_IllegalAddr     = 0x02,
+    ModbusErrorCode_IllegalData     = 0x03,
+    ModbusErrorCode_DeviceBusy      = 0x06
+}modbus_error_code_e;
+
+typedef struct proto_Modbus_t proto_Modbus_t;
+struct proto_Modbus_t
+{
+    u8 id;
+    u16 (*data_read)(u16);                          /*Modbus<75><73><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+    modbus_error_code_e (*data_write)(u16,u16);     /*Modbusд<73><D0B4><EFBFBD><EFBFBD>*/
+    void (*init)(void);                             /*<2A><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+    void (*task)(void);                             /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+    void (*data_analysis)(u8 *,u16,void *);         /*<2A><><EFBFBD>ݽ<EFBFBD><DDBD><EFBFBD>*/
+};
+
+
+u16 float_to_u16(float float_data,u8 h_l);
+u16 u32_to_u16(u32 u32_Data,u8 h_l);
+u32 u8_to_u32(u8 *p_u8_Data,u8 endian);
+u16 u8_to_u16(u8 *p_u8_Data,u8 endian);
+
+void u32_to_u8(u32 u32_Data,u8 *p_data,u8 endian);
+void u16_to_u8(u16 u16_Data,u8 *p_data,u8 endian);
+
+u32 u32_endian_conv(u32 data);
+u16 u16_endian_conv(u16 data);
+
+u16 modbus_lib_crc16(u8 *p_data, u16 len);
+void modbus_lib_data_read(u8 Id,u16 Addr,u16 Num,void (*UsartSendBuffer)(u8 *,u16 ));
+void modbus_lib_multiple_data_write(u8 ID,u16 Addr,u16 Num,u16 *Data,void (*UsartSendBuffer)(u8 *,u16 ));
+void modbus_lib_only_data_write(u8 ID,u16 Addr,u16 Value,void (*UsartSendBuffer)(u8 *,u16 ));
+u8 modbus_lib_analysis(modbus_analysis_data_t *p_modbus, u8 *p_data, u16 len);
+
+#endif

calib_board/usr/protocol/proto_modbus_master_tdlas.c

@@ -0,0 +1,412 @@
+#include "proto_modbus_master_tdlas.h"
+#include "string.h"
+#include "stdio.h"
+
+#include "app.h"
+#include "os_timer.h"
+
+#include "bsp_Uart.h"
+#include "bsp_74HC4067.h"
+#include "bsp_Flash.h"
+
+#include "proto_print.h"
+#include "proto_modbus_lib.h"
+
+#define TDLAS_MODBUS_ID    (0xe8)
+#define TDLAS_DATA_ENDIAN  (LITTLE_ENDIAN)          /*<2A><><EFBFBD>ô<EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD>*/
+
+#define PROTO_TDLAS_GET_CURR_DATA_START_ADDR                  (20000)
+#define PROTO_TDLAS_SET_ZERO_CALIB_START_ADDR                 (12)
+#define PROTO_TDLAS_SET_SPAN_CALIB_START_ADDR                 (13)
+#define PROTO_TDLAS_GET_RESET_START_ADDR                      (0x0000)
+#define PROTO_TDLAS_GET_FAC_CALIB_START_ADDR                  (11010)
+#define PROTO_TDLAS_GET_FAC_CALIB_PARA_SET_START_ADDR         (11000)
+#define PROTO_TDLAS_GET_FAC_CALIB_DATA_START_ADDR             (250)
+
+
+static void proto_tdlas_init(void);
+static void proto_tdlas_control_zero_calib(u16 calib_value);
+
+static void proto_tdlas_control_span_calib(u16 CalibValue);
+static void proto_tdlas_control_reset(void);
+static void proto_tdlas_control_fac_calib(u16 calib_value,u8 calib_point,u8 temp_point);
+static void proto_tdlas_control_fac_calib_para_set(s16 temp,u16 press,u16 humidity);
+static void proto_tdlas_tx_task(void);
+static void proto_tdlas_rx_task(u8 *p_data,u16 len,void *other_data);
+static void proto_tdlas_control_fac_calib_data_get(u8 ch);
+
+/*<2A><><EFBFBD>ĸ<EFBFBD><C4B8><EFBFBD><EFBFBD>ڽ<EFBFBD><DABD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD>*/
+static bsp_Uart_t *rx_uart = NULL;
+
+proto_tdlas_t tdlas=
+{
+    .modbus_id                  = TDLAS_MODBUS_ID,
+      
+    .init                       = proto_tdlas_init,
+    .tx_task                    = proto_tdlas_tx_task,
+    .rx_task                    = proto_tdlas_rx_task,
+//    .print                      = proto_tdlas_print_debug_data,
+                          
+    .control.zero_calib         = proto_tdlas_control_zero_calib,        
+    .control.span_calib         = proto_tdlas_control_span_calib,        
+    .control.reset              = proto_tdlas_control_reset,             
+    .control.fac_calib          = proto_tdlas_control_fac_calib,         
+    .control.fac_calib_para_set = proto_tdlas_control_fac_calib_para_set,
+    .control.fac_calib_data_get = proto_tdlas_control_fac_calib_data_get,
+};
+
+proto_tdlas_t *p_sensor = &tdlas;
+bsp_Uart_t *p_use_uart = &COM_Uart4;
+    
+static void proto_tdlas_init(void)
+{
+    COM_Uart4.Rx_DataAnalysis = p_sensor->rx_task;
+}
+
+static void proto_tdlas_send(u8 *p_data,u16 len)
+{
+      COM_Uart4.Send(&COM_Uart4,p_data,len);
+}
+
+static void proto_sensor_switch(u8 ch)
+{     
+   UartCH_Config.ch_set(ch);
+}
+
+/*<2A><><EFBFBD><EFBFBD>У׼*/
+static void proto_tdlas_control_zero_calib(u16 calib_value)
+{
+    u8 i;
+    for(i=0;i<Usr_Flash.FlashData.modbus_read_sensor_num;i++)
+    {
+        p_sensor->sys[i].sys_state = PROTO_TDLAS_SYS_STATE_ZERO_CALIB;
+        p_sensor->set_data.calib_value = calib_value;
+    }
+}
+
+/*<2A><><EFBFBD><EFBFBD>У׼         */
+static void proto_tdlas_control_span_calib(u16 CalibValue)
+{
+    u8 i;
+    for(i=0;i<Usr_Flash.FlashData.modbus_read_sensor_num;i++)
+    {
+        p_sensor->sys[i].sys_state = PROTO_TDLAS_SYS_STATE_SPAN_CALIB;
+        p_sensor->set_data.calib_value = CalibValue;
+    }
+
+}
+
+/*<2A>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>    */
+static void proto_tdlas_control_reset(void)
+{
+    u8 i;
+    for(i=0;i<Usr_Flash.FlashData.modbus_read_sensor_num;i++)
+    {
+        p_sensor->sys[i].sys_state = PROTO_TDLAS_SYS_STATE_RESET;
+    }
+}
+
+/*<2A><><EFBFBD>ұ궨*/
+static void proto_tdlas_control_fac_calib(u16 calib_value,u8 calib_point,u8 temp_point)
+{
+    u8 i;
+    for(i=0;i<Usr_Flash.FlashData.modbus_read_sensor_num;i++)
+    {
+        p_sensor->sys[i].sys_state = PROTO_TDLAS_SYS_STATE_FAC_CALIB;
+        p_sensor->set_data.calib_value                  = calib_value;
+        p_sensor->set_data.calib_point                  = calib_point;
+        p_sensor->set_data.temp_point                   = temp_point;
+    }
+}
+
+/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+static void proto_tdlas_control_fac_calib_para_set(s16 temp,u16 press,u16 humidity)
+{
+    u8 i;
+    for(i=0;i<Usr_Flash.FlashData.modbus_read_sensor_num;i++)
+    {
+        p_sensor->sys[i].sys_state = PROTO_TDLAS_SYS_STATE_FAC_CALIB_PARA_SET;
+        p_sensor->set_data.temp                         = (-1 == temp) ? p_sensor->set_data.temp : temp;
+        p_sensor->set_data.humidity                     = (0xffff == humidity) ? p_sensor->set_data.humidity : humidity;
+        p_sensor->set_data.press                        = (0xffff == press) ? p_sensor->set_data.press : press;
+    }        
+}
+
+/*<2A><>ȡ<EFBFBD>궨<EFBFBD><EAB6A8><EFBFBD><EFBFBD>*/
+static void proto_tdlas_control_fac_calib_data_get(u8 ch)
+{
+    if(Usr_Flash.FlashData.modbus_read_sensor_num > ch)
+    {
+        p_sensor->sensor_index = ch;
+        p_sensor->sys[ch].sys_state = PROTO_TDLAS_SYS_STATE_FAC_CALIB_DATA_GET;
+        proto_sensor_switch(ch);
+    }
+}
+
+/********<2A><><EFBFBD><EFBFBD>***********/
+static void proto_tdlas_tx_curr_data_get(void)
+{
+    u16 addr = PROTO_TDLAS_GET_CURR_DATA_START_ADDR;
+    u8 len = Usr_Flash.FlashData.modbus_read_reg_num;
+    modbus_lib_data_read(p_sensor->modbus_id,addr,len,proto_tdlas_send);
+}
+
+static void proto_tdlas_tx_zero_calib(void)
+{
+    u16 addr = PROTO_TDLAS_SET_ZERO_CALIB_START_ADDR;
+    u8 len = 1;
+    u16 data[1];
+    data[0] = 0;
+
+    modbus_lib_multiple_data_write(p_sensor->modbus_id,addr,len,data,proto_tdlas_send);
+}
+
+static void proto_tdlas_tx_span_calib(void)
+{
+    u16 addr = PROTO_TDLAS_SET_SPAN_CALIB_START_ADDR;
+    u8 len = 1;
+    u16 data[1];
+    data[0] = p_sensor->set_data.calib_value;
+    modbus_lib_multiple_data_write(p_sensor->modbus_id,addr,len,data,proto_tdlas_send);
+}
+
+static void proto_tdlas_tx_Reset(void)
+{
+    u16 addr = PROTO_TDLAS_GET_RESET_START_ADDR;
+    u8 len = 1;
+    u16 data[1];
+    data[0] = 0x00FE;
+    //modbus_lib_multiple_data_write(p_sensor->modbus_id,addr,len,data,proto_tdlas_send);
+}
+
+static void proto_tdlas_tx_fac_calib(void)
+{
+    u16 addr = PROTO_TDLAS_GET_FAC_CALIB_START_ADDR;
+    u8 len = 1;
+    u16 data[1];
+    data[0] = p_sensor->set_data.calib_value;
+    addr = addr + p_sensor->set_data.temp_point * 10 + p_sensor->set_data.calib_point;
+    modbus_lib_multiple_data_write(p_sensor->modbus_id,addr,len,data,proto_tdlas_send);
+}
+
+static void proto_tdlas_tx_fac_calib_para_set(void)
+{
+    u16 addr = PROTO_TDLAS_GET_FAC_CALIB_PARA_SET_START_ADDR;
+    u8 len = 3;
+    u16 data[3];
+    
+    data[0] = *((u16 *)(&p_sensor->set_data.temp));         /*<2A>¶<EFBFBD>*/
+    data[1] = p_sensor->set_data.press;                     /*ѹ<><D1B9>*/
+    data[2] = p_sensor->set_data.humidity;                  /*ʪ<><CAAA>*/
+    
+    modbus_lib_multiple_data_write(p_sensor->modbus_id,addr,len,data,proto_tdlas_send);
+}
+
+static void  proto_tdlas_tx_fac_calib_data_get(void)
+{
+    u16 addr = PROTO_TDLAS_GET_FAC_CALIB_DATA_START_ADDR;
+    u8 len = 1;
+    u16 data[1];
+    
+    data[0] = 3;         /*<2A>¶<EFBFBD>*/
+    modbus_lib_multiple_data_write(p_sensor->modbus_id,addr,len,data,proto_tdlas_send);
+}
+
+static void proto_tdlas_tx_task(void)
+{
+    u8 SendFlag = 0;
+    proto_tdlas_sys_t *p_sensor_sys;
+    p_sensor_sys = &p_sensor->sys[p_sensor->sensor_index];
+   
+    if(0 == (p_sensor_sys->state_error_flag & (0x00000001 << PROTO_TDLAS_ERROR_FLAG_TIME_OUT)))
+    {
+        if((++p_sensor_sys->tx_time_out_count) > 8)/*ͨѶ<CDA8><D1B6>ʱ*/
+        {
+            p_sensor_sys->state_error_flag |= (0x00000001 << PROTO_TDLAS_ERROR_FLAG_TIME_OUT);
+            /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+            memset(&gas_data[p_sensor->sensor_index],0,sizeof(gas_data_t));
+        }
+    }
+ 
+    switch(p_sensor_sys->sys_state)
+    {
+        case PROTO_TDLAS_SYS_STATE_INIT:
+        {
+            
+        }break;
+        case PROTO_TDLAS_SYS_STATE_CURR_DATA_GET:
+        {
+            proto_tdlas_tx_curr_data_get();
+        }break;            
+        case PROTO_TDLAS_SYS_STATE_ZERO_CALIB:
+        {
+            proto_tdlas_tx_zero_calib();
+        }break;            
+        case PROTO_TDLAS_SYS_STATE_SPAN_CALIB:
+        {
+            proto_tdlas_tx_span_calib();
+        }break;
+        case PROTO_TDLAS_SYS_STATE_RESET:
+        {
+            proto_tdlas_tx_Reset();
+        }break;
+        case PROTO_TDLAS_SYS_STATE_FAC_CALIB:
+        {
+            proto_tdlas_tx_fac_calib();
+        }break;
+        case PROTO_TDLAS_SYS_STATE_FAC_CALIB_PARA_SET:
+        {
+            proto_tdlas_tx_fac_calib_para_set();
+        }break;
+        case PROTO_TDLAS_SYS_STATE_FAC_CALIB_DATA_GET:
+        {
+            if(0 == p_sensor_sys->send_time)
+            {
+                p_use_uart->relay.flag = 1;
+                proto_tdlas_tx_fac_calib_data_get();
+            }
+            p_sensor_sys->send_time++;
+            if(p_sensor_sys->send_time > 50)
+            {
+                p_use_uart->relay.flag = 0;
+                p_sensor_sys->send_time = 0;
+                p_sensor_sys->sys_state = PROTO_TDLAS_SYS_STATE_CURR_DATA_GET;
+                p_sensor->sensor_index++;
+                if(p_sensor->sensor_index >= Usr_Flash.FlashData.modbus_read_sensor_num)
+                {
+                    p_sensor->sensor_index = 0;
+                }
+                proto_sensor_switch(p_sensor->sensor_index);
+            }
+            SendFlag = 1;
+        }break;
+        default:
+        {
+        
+        }break;
+    } 
+    if(SendFlag)
+    {
+        return ;
+    }
+    else
+    {
+
+        
+        p_sensor_sys->send_time++;
+        if(p_sensor_sys->send_time >= 3)    /*<2A><><EFBFBD><EFBFBD><EFBFBD>쳣*/
+        {
+            p_sensor_sys->state_error_flag |= (0x00000001 << p_sensor_sys->sys_state);/*<2A><>¼<EFBFBD>쳣״̬*/
+            p_sensor_sys->send_time = 0;
+            p_sensor_sys->sys_state = PROTO_TDLAS_SYS_STATE_CURR_DATA_GET;
+            p_sensor->sensor_index++;
+            if(p_sensor->sensor_index >= Usr_Flash.FlashData.modbus_read_sensor_num)
+            {
+                p_sensor->sensor_index = 0;
+            }
+            proto_sensor_switch(p_sensor->sensor_index);
+        }
+        
+   }
+}
+
+static void proto_tdlas_rx_task(u8 *p_data,u16 len,void *other_data)
+{
+    u8 send_time_flag = 0;
+    u8 modbus_id,cmd;
+    u16 check_crc16,modbus_crc16;
+    u16 *p_u16_temp;
+    u16 i;
+    u8 *p_rx_valid;
+    
+    proto_tdlas_sys_t *p_sensor_sys;
+    p_sensor_sys = &p_sensor->sys[p_sensor->sensor_index];
+    
+    if( p_use_uart->relay.flag == 1)
+    {
+        p_use_uart->relay.uart->Send(p_use_uart->relay.uart,p_data,len);
+    }
+       
+    if(p_sensor->modbus_id != p_data[0])
+    {
+        p_data = &p_data[1];
+        len -= 1; 
+    }
+    modbus_id = *p_data;
+    cmd = *(p_data+1);
+    check_crc16 = p_data[len-2] << 8 | p_data[len-1];
+    
+    if(modbus_id != p_sensor->modbus_id) return ;
+    if(cmd != 0x04 && cmd != 0x06 && cmd != 0x10 && cmd != 0x41) return ;
+
+    modbus_crc16 = modbus_lib_crc16(p_data,len-2);
+    modbus_crc16 = (modbus_crc16 >> 8) | (modbus_crc16 << 8);
+    
+    if(check_crc16 != modbus_crc16) return ;
+    
+    if(cmd == 0x41)
+    {
+       p_rx_valid = &p_data[6]; 
+    }
+    rx_uart = (bsp_Uart_t *)other_data;
+    
+    p_sensor_sys->tx_time_out_count = 0;
+    p_sensor_sys->state_error_flag &= (~(0x00000001 << PROTO_TDLAS_ERROR_FLAG_TIME_OUT));
+    
+    switch(p_sensor_sys->sys_state)
+    {
+        case PROTO_TDLAS_SYS_STATE_INIT:
+        {
+
+        }break;
+        case PROTO_TDLAS_SYS_STATE_CURR_DATA_GET:
+        {
+            p_u16_temp = (u16 *)&(gas_data[p_sensor->sensor_index]);
+            for(i=0;i<Usr_Flash.FlashData.modbus_read_reg_num;i++)
+            {
+                p_u16_temp[i] = p_rx_valid[i * 2] << 8 | p_rx_valid[i * 2 + 1];
+            }   
+        }break;            
+        case PROTO_TDLAS_SYS_STATE_ZERO_CALIB:
+        {
+
+        }break;            
+        case PROTO_TDLAS_SYS_STATE_SPAN_CALIB:
+        {
+
+        }break;
+        case PROTO_TDLAS_SYS_STATE_RESET:
+        {
+            
+        }break;
+        case PROTO_TDLAS_SYS_STATE_FAC_CALIB:
+        {
+            
+        }break;
+        case PROTO_TDLAS_SYS_STATE_FAC_CALIB_PARA_SET:
+        {
+            
+        }break;   
+        case PROTO_TDLAS_SYS_STATE_FAC_CALIB_DATA_GET:
+        {
+        
+        }break;
+    }
+    if(send_time_flag)
+    {
+        return;
+    }
+    else
+    {
+        p_sensor_sys->sys_state = PROTO_TDLAS_SYS_STATE_CURR_DATA_GET;
+        p_sensor_sys->state_error_flag &= (~(0x00000001 << p_sensor_sys->sys_state));/*<2A><><EFBFBD><EFBFBD><EFBFBD>쳣״̬*/  
+        p_sensor_sys->send_time = 0; 
+        p_sensor->sensor_index++;
+        if(p_sensor->sensor_index >= Usr_Flash.FlashData.modbus_read_sensor_num)
+        {
+            p_sensor->sensor_index = 0;
+        }
+        proto_sensor_switch(p_sensor->sensor_index);
+        return;
+    }
+}

calib_board/usr/protocol/proto_modbus_master_tdlas.h

@@ -0,0 +1,68 @@
+#ifndef _PROTO_MODBUS_MASTER_SENSOR_H_
+#define _PROTO_MODBUS_MASTER_SENSOR_H_
+#include "main.h"
+#include "gas_data.h"
+
+/*NIDR״̬*/
+#define PROTO_TDLAS_SYS_STATE_INIT                   (0U)    /*<2A><>ʼ<EFBFBD><CABC>      */
+#define PROTO_TDLAS_SYS_STATE_CURR_DATA_GET          (1U)    /*<2A><>ȡʵʱ<CAB5><CAB1><EFBFBD><EFBFBD>*/
+#define PROTO_TDLAS_SYS_STATE_ZERO_CALIB             (2U)    /*<2A><><EFBFBD><EFBFBD>У׼    */
+#define PROTO_TDLAS_SYS_STATE_SPAN_CALIB             (3U)    /*<2A><><EFBFBD><EFBFBD>У׼    */
+#define PROTO_TDLAS_SYS_STATE_RESET                  (4U)    /*<2A>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD>    */
+#define PROTO_TDLAS_SYS_STATE_FAC_CALIB              (5U)    /*<2A><><EFBFBD>ұ궨    */
+#define PROTO_TDLAS_SYS_STATE_FAC_CALIB_PARA_SET     (6U)    /*<2A><><EFBFBD>ұ궨ʱ<EAB6A8>Ļ<EFBFBD><C4BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+#define PROTO_TDLAS_SYS_STATE_FAC_CALIB_DATA_GET     (7U)    /*<2A><>ȡ<EFBFBD>궨<EFBFBD><EAB6A8>Ϣ*/
+
+#define PROTO_TDLAS_ERROR_FLAG_TIME_OUT              (30U)    /*ͨѶ<CDA8><D1B6>ʱ*/
+
+
+typedef struct
+{
+    void (*zero_calib)(u16);                                /*<2A><><EFBFBD><EFBFBD>У׼*/
+    void (*span_calib)(u16);                                /*<2A><><EFBFBD>̵<EFBFBD>У׼*/
+    void (*reset)(void);                                    /*<2A>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+    void (*fac_calib)(u16,u8,u8);                           /*<2A><><EFBFBD>ұ궨ʱ<EAB6A8><CAB1>Ũ<EFBFBD><C5A8>*/
+    void (*fac_calib_para_set)(s16,u16,u16);                /*<2A><><EFBFBD>ұ궨ʱ<EAB6A8><CAB1><EFBFBD>õ<EFBFBD><C3B5>¶ȡ<C2B6>ʪ<EFBFBD>ȡ<EFBFBD>ѹ<EFBFBD><D1B9>*/
+    void (*fac_calib_data_get)(u8);                         /*<2A><><EFBFBD>ұ궨ʱ<EAB6A8><CAB1><EFBFBD>õ<EFBFBD><C3B5>¶ȡ<C2B6>ʪ<EFBFBD>ȡ<EFBFBD>ѹ<EFBFBD><D1B9>*/
+}proto_tdlas_control_t;
+
+typedef struct
+{
+    u8 sys_state;
+    u16 send_time;                                          /*<2A><><EFBFBD>ʹ<EFBFBD><CDB4><EFBFBD>*/
+    u32 sensor_state;                                       /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>״̬*/
+    u8 print_flag;                                          /*ʵʱ<CAB5><CAB1><EFBFBD>ݴ<EFBFBD>ӡ<EFBFBD><D3A1>־λ*/  
+    u32 state_error_flag;                                   /*ϵͳ<CFB5><CDB3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>־λ*/
+    u16 tx_time_out_count;                                  /*Э<><D0AD>ָ<EFBFBD><EFBFBD>ʹ<EFBFBD><CDB4><EFBFBD>*/
+}proto_tdlas_sys_t;
+
+typedef struct
+{
+    
+    u8 calib_point;
+    u8 temp_point;
+    u16 calib_value;
+    s16 temp;
+    u16 humidity;
+    u16 press;
+}proto_tdlas_set_data_t;
+
+typedef struct
+{
+    u8 modbus_id;
+
+    u16 sensor_index;                                       /*<2A><>ǰ<EFBFBD><C7B0><EFBFBD>ĸ<EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>*/
+    proto_tdlas_set_data_t set_data;
+    proto_tdlas_sys_t sys[SENSOR_NUM];
+    proto_tdlas_control_t control;
+
+    void (*init)(void);
+    void (*tx_task)(void);
+    void (*rx_task)(u8 *,u16,void *);
+    void (*print)(void);
+    void (*warm_task)(void);
+}proto_tdlas_t;
+
+extern proto_tdlas_t tdlas;
+
+#endif

calib_board/usr/protocol/proto_modbus_slave_ex.c

@@ -0,0 +1,362 @@
+/*<2A><><EFBFBD><EFBFBD>ͨѶ modbus<75>ӻ<EFBFBD>*/
+#include "proto_modbus_slave_ex.h"
+#include "string.h"
+#include "stdio.h"
+
+#include "app.h"
+#include "os_timer.h"
+
+#include "bsp_Uart.h"
+#include "bsp_Flash.h"
+
+#include "proto_print.h"
+#include "proto_modbus_master_tdlas.h"
+
+static modbus_analysis_data_t modbus_analysis_data;//ָ<><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ṹ<EFBFBD><E1B9B9>
+static modbus_communication_send_buf_t send_struct;//<2F><><EFBFBD>ͽṹ<CDBD><E1B9B9>
+
+static void proto_modbus_communication_data_analysis(u8 *pData, u16 len, void *data);
+static void proto_modbus_communication_data_send(u8 *pData, u16 len);
+static void proto_modbus_init(void);
+static void proto_modbus_task(void);
+static modbus_error_code_e proto_modbus_data_write(u16 Addr, u16 Value);
+static u16 proto_modbus_data_read(u16 Addr);
+
+proto_Modbus_t modbus_slave_ex=
+{
+    .id            = 0x01,
+    .data_read     = proto_modbus_data_read,
+    .data_write    = proto_modbus_data_write,
+    .data_analysis = proto_modbus_communication_data_analysis,
+    .init          = proto_modbus_init,
+    .task          = proto_modbus_task,
+};
+
+static proto_Modbus_t  *p_modbus = &modbus_slave_ex;
+static bsp_Uart_t * rx_uart;
+
+static void proto_modbus_communication_data_send(u8 *pData, u16 len)
+{
+    if(&COM_Uart1 == rx_uart)
+    {
+        COM_Uart1.Send(&COM_Uart1,pData,len);
+    }
+    else if(&COM_Uart4 == rx_uart)
+    {
+        COM_Uart4.Send(&COM_Uart4,pData,len);
+    }
+    
+}
+
+static void proto_modbus_init(void)
+{
+    p_modbus->id = Usr_Flash.FlashData.modbus_id;
+    COM_Uart1.Rx_DataAnalysis = proto_modbus_communication_data_analysis;
+    COM_Uart4.Rx_DataAnalysis = proto_modbus_communication_data_analysis; 
+}
+static void proto_modbus_task(void)
+{
+    
+}
+
+static void proto_modbus_communication_data_analysis(u8 *pData, u16 len,void *other_data)
+{
+  modbus_error_code_e error_code;
+  u16 inx;
+  u16 TempAddr, TempData, crc_16;
+
+    
+  if (0 == modbus_lib_analysis(&modbus_analysis_data, pData, len))//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD> У<><D0A3><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD>ȷ
+    return;
+  if (p_modbus->id != modbus_analysis_data.id && modbus_analysis_data.id != 0xe8)//<2F>ж<EFBFBD>ID<49>Ƿ<EFBFBD><C7B7><EFBFBD>ȷ
+    return; 
+
+  error_code = ModbusErrorCode_Success;
+  
+
+/*  //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD>Ƿ񳬳<C7B7><F1B3ACB3><EFBFBD>Χ
+  if ((modbus_analysis_data.start_addr >= MODBUS_REG_LEN) || (modbus_analysis_data.reg_number >= MODBUS_REG_LEN) ||
+      (modbus_analysis_data.start_addr + modbus_analysis_data.reg_number >= MODBUS_REG_LEN))
+  {
+    ErrorCode = ModbusErrorCode_IllegalAddr;
+    goto Error;
+  }
+  */
+    rx_uart = (bsp_Uart_t*)other_data;
+    switch (modbus_analysis_data.func)
+    {
+        case 0x03:
+        case 0x04:
+        {
+            TempAddr = modbus_analysis_data.start_addr;
+            send_struct.send_buffer[0] = modbus_analysis_data.id;
+            send_struct.send_buffer[1] = modbus_analysis_data.func;
+            send_struct.send_buffer[2] = 2 * modbus_analysis_data.reg_number;
+            for (inx = 0; inx < modbus_analysis_data.reg_number; inx++)
+            {
+                TempData = proto_modbus_data_read(TempAddr);
+                send_struct.send_buffer[3 + 2 * inx] = (TempData >> 8) & 0xff;
+                send_struct.send_buffer[4 + 2 * inx] = TempData & 0xff;
+                TempAddr++;
+            }
+            crc_16 = modbus_lib_crc16(send_struct.send_buffer, 3 + send_struct.send_buffer[2]);
+            send_struct.send_buffer[3 + send_struct.send_buffer[2]] = crc_16 & 0xff;
+            send_struct.send_buffer[4 + send_struct.send_buffer[2]] = (crc_16 >> 8) & 0xff;
+            send_struct.len = 5 + send_struct.send_buffer[2];
+        }goto Success;
+        /*<2A><><EFBFBD><EFBFBD>Э<EFBFBD><D0AD>*/
+        case 0x41:
+        {
+            TempAddr = modbus_analysis_data.start_addr;
+            send_struct.send_buffer[0] = modbus_analysis_data.id;
+            send_struct.send_buffer[1] = modbus_analysis_data.func;
+            send_struct.send_buffer[2] = modbus_analysis_data.start_addr >> 8;
+            send_struct.send_buffer[3] = modbus_analysis_data.start_addr & 0xff;
+            send_struct.send_buffer[4] = (2 * modbus_analysis_data.reg_number) >> 8;
+            send_struct.send_buffer[5] = (2 * modbus_analysis_data.reg_number) & 0xff;
+            for (inx = 0; inx < modbus_analysis_data.reg_number; inx++)
+            {
+                TempData = proto_modbus_data_read(TempAddr);
+                send_struct.send_buffer[6 + 2 * inx] = (TempData >> 8) & 0xff;
+                send_struct.send_buffer[7 + 2 * inx] = TempData & 0xff;
+                TempAddr++;
+            }
+            crc_16 = modbus_lib_crc16(send_struct.send_buffer, 6 + 2 * modbus_analysis_data.reg_number);
+            send_struct.send_buffer[6 + 2 * modbus_analysis_data.reg_number] = crc_16 & 0xff;
+            send_struct.send_buffer[7 + 2 * modbus_analysis_data.reg_number] = (crc_16 >> 8) & 0xff;
+            send_struct.len = 8 + 2 * modbus_analysis_data.reg_number;
+        }goto Success;
+        
+        case 0x06:
+        {
+            TempAddr = modbus_analysis_data.start_addr;
+            TempData = (modbus_analysis_data.write_data_addr[0] << 8) | modbus_analysis_data.write_data_addr[1];
+            error_code = proto_modbus_data_write(TempAddr, TempData);
+            if (error_code)
+            {
+                goto Error;
+            }    
+
+            send_struct.len = 8;
+            send_struct.send_buffer[0] = modbus_analysis_data.id;
+            send_struct.send_buffer[1] = modbus_analysis_data.func;
+            send_struct.send_buffer[2] = modbus_analysis_data.start_addr >> 8;
+            send_struct.send_buffer[3] = modbus_analysis_data.start_addr & 0xff;
+            send_struct.send_buffer[4] = modbus_analysis_data.write_data_addr[0];
+            send_struct.send_buffer[5] = modbus_analysis_data.write_data_addr[1];
+            crc_16 = modbus_lib_crc16(send_struct.send_buffer, 6);
+            send_struct.send_buffer[6] = crc_16 & 0xff;
+            send_struct.send_buffer[7] = (crc_16 >> 8) & 0xff;    
+        }break;
+
+        case 0x10:
+        {
+            TempAddr = modbus_analysis_data.start_addr;
+            for (inx = 0; inx < modbus_analysis_data.reg_number; inx++)
+            {
+                TempData = modbus_analysis_data.write_data_addr[2 * inx];
+                TempData = (TempData << 8) | modbus_analysis_data.write_data_addr[2 * inx + 1];
+                error_code = proto_modbus_data_write(TempAddr, TempData);
+                TempAddr++;
+                if (error_code)
+                {
+                    goto Error;
+                }    
+            }
+            send_struct.len = 8;
+            send_struct.send_buffer[0] = modbus_analysis_data.id;
+            send_struct.send_buffer[1] = modbus_analysis_data.func;
+            send_struct.send_buffer[2] = modbus_analysis_data.start_addr >> 8;
+            send_struct.send_buffer[3] = modbus_analysis_data.start_addr & 0xff;
+            send_struct.send_buffer[4] = modbus_analysis_data.reg_number >> 8;
+            send_struct.send_buffer[5] = modbus_analysis_data.reg_number & 0xff;
+            crc_16 = modbus_lib_crc16(send_struct.send_buffer, 6);
+            send_struct.send_buffer[6] = crc_16 & 0xff;
+            send_struct.send_buffer[7] = (crc_16 >> 8) & 0xff;
+        }
+        break;
+        default:
+        {
+            error_code = ModbusErrorCode_IllegalFunction;
+        }
+        goto Error;
+    }
+
+Success:
+    proto_modbus_communication_data_send(send_struct.send_buffer, send_struct.len);
+    return;
+
+Error:
+    send_struct.len = 5;
+    send_struct.send_buffer[0] = modbus_analysis_data.id;
+    send_struct.send_buffer[1] = modbus_analysis_data.func | 0x80;
+    send_struct.send_buffer[2] = error_code;
+    crc_16 = modbus_lib_crc16(send_struct.send_buffer, 3);
+    send_struct.send_buffer[3] = crc_16 & 0xff;
+    send_struct.send_buffer[4] = (crc_16 >> 8) & 0xff;
+    proto_modbus_communication_data_send(send_struct.send_buffer, send_struct.len);
+}
+
+/******************************************
+ * <20><><EFBFBD><EFBFBD>: proto_modbus_data_write
+ * <20><><EFBFBD><EFBFBD>: Modbusд<73>Ĵ<EFBFBD><C4B4><EFBFBD>
+ * <20><><EFBFBD><EFBFBD>: Addr: <20><>ַ
+         Value:<3A><><EFBFBD><EFBFBD>
+ * <20><><EFBFBD><EFBFBD>: <20><>
+ * <20><><EFBFBD><EFBFBD>: <20><>
+ ******************************************/
+static modbus_error_code_e proto_modbus_data_write(u16 addr, u16 data)
+{
+    modbus_error_code_e error_code;
+    u8 temp_point,cali_point;
+    
+    error_code = ModbusErrorCode_Success;
+
+    switch(addr)
+    {
+        /*<2A>¶<EFBFBD> ѹ<><D1B9> ʪ<><CAAA>*/
+        case 11000:
+        {
+            tdlas.control.fac_calib_para_set(*((u16 *)(&data)),0xffff,0xffff);
+        }break;
+        case 11001:
+        {
+            tdlas.control.fac_calib_para_set(0xffff,data,0xffff);
+        }break;
+        case 11002:
+        {
+            tdlas.control.fac_calib_para_set(0xffff,0xffff,data);
+        }break;
+        
+        /*<2A><><EFBFBD><EFBFBD>У׼*/
+        case 11003:
+        {
+            tdlas.control.zero_calib(0);
+        }break;
+        /*<2A><><EFBFBD>̵<EFBFBD>У׼*/
+        case 11004:
+        {
+            tdlas.control.span_calib(data);
+        }break;
+         
+        /*<2A><><EFBFBD>ұ궨*/
+        case 11010 ... 11109:
+        {
+            temp_point = (addr - 11010) / 10;
+            cali_point = (addr - 11010) % 10;
+            tdlas.control.fac_calib(data,cali_point,temp_point);
+        }break;
+        
+        /*ת<><D7AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>궨<EFBFBD><EAB6A8>Ϣ*/
+        case 11200:
+        {
+            tdlas.control.fac_calib_data_get(data);
+        }break;
+        
+        
+        /*sn*/
+        case 20000 ... 20004:
+        {
+            Usr_Flash.FlashData.sn[addr - 20000] = data;
+            Usr_Flash.Write();
+        }break;
+        /*modbus_id*/
+        case 20005:
+        {
+            Usr_Flash.FlashData.modbus_id = data;
+            modbus_slave_ex.id = Usr_Flash.FlashData.modbus_id;
+            Usr_Flash.Write();
+        }break;
+        /*modbus_read_reg_num*/
+        case 20006:
+        {
+            if(data > 1000)
+            {
+                error_code = ModbusErrorCode_IllegalData;
+            }
+            else
+            {
+                Usr_Flash.FlashData.modbus_read_reg_num = data;
+                Usr_Flash.Write();
+            }
+        }break;
+        case 20007:
+        {
+            if(data > 16)
+            {
+                error_code = ModbusErrorCode_IllegalData;
+            }
+            else
+            {
+                Usr_Flash.FlashData.modbus_read_sensor_num = data;
+                Usr_Flash.Write();
+            }
+        }break;
+        /*FC<46><43>ӡ<EFBFBD><D3A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+        case 252:
+        {
+            print.set(data);
+        }break;
+    }
+    return error_code;
+}
+
+/******************************************
+ * <20><><EFBFBD><EFBFBD>: proto_modbus_data_read
+ * <20><><EFBFBD><EFBFBD>: Modbus<75><73><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ * <20><><EFBFBD><EFBFBD>: Addr: <20><>ַ
+ * <20><><EFBFBD><EFBFBD>: <20><>ַ<EFBFBD><D6B7>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+ * <20><><EFBFBD><EFBFBD>: <20><>
+ ******************************************/
+static u16 proto_modbus_data_read(u16 addr)
+{
+    u16 data = 0;
+    u16 *p_data;
+    u16 num,offset;
+
+    switch(addr)
+    {
+        /*ʵʱ<CAB5><CAB1><EFBFBD><EFBFBD>*/
+        case 0 ... 639:
+        {
+            u16 size;
+            size = sizeof(gas_data_t);
+            /* TDLASĬ<53>϶<EFBFBD>ȡ*/
+           if( size== (2 * Usr_Flash.FlashData.modbus_read_reg_num))
+           {
+               p_data = (u16 *)&gas_data; 
+               data = p_data[addr];
+           }
+           else if((2 * Usr_Flash.FlashData.modbus_read_reg_num )< sizeof(gas_data_t))/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
+           {
+               num = addr / Usr_Flash.FlashData.modbus_read_reg_num;
+               offset = addr % Usr_Flash.FlashData.modbus_read_reg_num;
+               p_data = (u16 *)&gas_data[num];
+               data = p_data[offset];
+           }    
+           
+        }break;
+        
+        /*sn*/
+        case 20000 ... 20004:
+        {
+            data = Usr_Flash.FlashData.sn[addr - 20000];
+        }break;
+        /*modbus_id*/
+        case 20005:
+        {
+            data = Usr_Flash.FlashData.modbus_id;
+        }break;
+        /*modbus_read_reg_num*/
+        case 20006:
+        {
+            data = Usr_Flash.FlashData.modbus_read_reg_num;
+        }break;
+        case 20007:
+        {
+            data = Usr_Flash.FlashData.modbus_read_sensor_num;
+        }break;
+        default:data = 0;
+    }
+    return data;
+}

calib_board/usr/protocol/proto_modbus_slave_ex.h

@@ -0,0 +1,9 @@
+#ifndef _PROTO_MODBUS_SLAVE_EX_H_
+#define _PROTO_MODBUS_SLAVE_EX_H_
+#include "main.h"
+#include "gas_data.h"
+#include "proto_modbus_lib.h"
+
+extern proto_Modbus_t modbus_slave_ex;
+
+#endif

calib_board/usr/protocol/proto_print.c

@@ -0,0 +1,64 @@
+#include "proto_print.h"
+
+#include "stdio.h"
+#include "bsp_Uart.h"
+
+u16 proto_print_data_type;
+
+void proto_print_datatype_set(u8 type);
+static void proto_print_task(void);
+
+proto_print_t print =
+{
+    .task = proto_print_task,
+    .set  = proto_print_datatype_set,
+};
+
+proto_print_t *p_print = &print;
+
+static void proto_print_datatype_set(u8 type)
+{
+    if(type > PROTO_PRINT_MAX)
+    {
+       
+    }
+    else
+    {
+        if(proto_print_data_type == type)
+        {
+            proto_print_data_type = PROTO_PRINT_NULL;
+        }
+        else
+        {
+            proto_print_data_type = type;
+        }
+    }
+}
+
+static void proto_print_task(void)
+{
+    switch(proto_print_data_type)
+    {
+        case PROTO_PRINT_NULL:
+        {
+                
+        }break;
+        case PROTO_PRINT_CURDATA:
+        {
+
+        }break;
+        case PROTO_PRINT_WAVE:
+        {
+        
+        }break;
+        case PROTO_PRINT_CALIB:
+        {
+        
+        }break;
+        default:
+        {
+        
+        }break;
+    }
+}
+

calib_board/usr/protocol/proto_print.h

@@ -0,0 +1,21 @@
+#ifndef _PROTO_PRINT_H_
+#define _PROTO_PRINT_H_
+
+#include "main.h"
+
+#define PROTO_PRINT_MAX       3
+        
+#define PROTO_PRINT_NULL      0
+#define PROTO_PRINT_CURDATA   1
+#define PROTO_PRINT_WAVE      2
+#define PROTO_PRINT_CALIB     3
+
+typedef struct
+{
+    void (*task)(void);
+    void (*set)(u8);
+}proto_print_t;
+
+extern proto_print_t print;
+
+#endif