Обновление

LinActuatorTasks.c

@@ -2,7 +2,7 @@
 // Created by cfif on 05.04.2024.
 //
 #include <SystemDelayInterface.h>
-#include "LinTasks.h"
+#include "LinActuatorTasks.h"
 #include "CmsisRtosThreadUtils.h"
 #include "CanPorts.h"
 #include "fc7xxx_driver_lin.h"
@@ -12,12 +12,8 @@
 #define LOG_SIGN "Lin0"
 #define LOGGER env->logger
 
-//начало----------------------------------------- LIN 0 ----------------------------------------------------------------
-//начало----------------------------------------- LIN 0 ----------------------------------------------------------------
-//начало----------------------------------------- LIN 0 ----------------------------------------------------------------
-//начало----------------------------------------- LIN 0 ----------------------------------------------------------------
 
-void GetLin0CallbackHandler(tLinData *env, uint8_t u8LinIndex, void *state) {
+void GetLin123CallbackHandler(tLinData *env, uint8_t u8LinIndex, void *state) {
     lin_xfer_state_t *pXferState = state;
     //uint32_t s_countIndex = 0U;
     //bool s_rxError = false;
@@ -115,7 +111,7 @@ static lin_event_id_t SEND_ACTUATOR_COM_x(tLinIO *linIo, uint8_t COM_ADR) {
 }
 
 
-lin_event_id_t DFR_PRG_x(tLinIO *linIo, tLinData *linData,
+static lin_event_id_t DFR_PRG_x(tLinIO *linIo, tLinData *linData,
                          uint8_t BUS_ADR) {
     lin_event_id_t res;
 
@@ -145,7 +141,7 @@ lin_event_id_t DFR_PRG_x(tLinIO *linIo, tLinData *linData,
     return res;
 }
 
-lin_event_id_t RFR_PRG_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
+static lin_event_id_t RFR_PRG_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
                          uint8_t *BUS_ADR,
                          uint8_t *BUS_NEW_ADR,
                          uint8_t *NOTL_DREH_Master,
@@ -193,7 +189,7 @@ lin_event_id_t RFR_PRG_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
 }
 
 
-lin_event_id_t DFR_IDE_x(tLinIO *linIo, tLinData *linData,
+static lin_event_id_t DFR_IDE_x(tLinIO *linIo, tLinData *linData,
                          uint8_t BUS_ADR) {
     lin_event_id_t res;
 
@@ -221,7 +217,7 @@ lin_event_id_t DFR_IDE_x(tLinIO *linIo, tLinData *linData,
     return res;
 }
 
-lin_event_id_t RFR_IDE_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
+static lin_event_id_t RFR_IDE_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
                          uint8_t *BUS_ADR,
                          uint8_t *IDE_ref,
                          uint8_t *IDE_Sup,
@@ -262,7 +258,7 @@ lin_event_id_t RFR_IDE_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
     return res;
 }
 
-lin_event_id_t DFR_STA_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADR) {
+static lin_event_id_t DFR_STA_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADR) {
     lin_event_id_t res;
 
     linData->direction = LIN_DIRECTION_SET;
@@ -289,7 +285,7 @@ lin_event_id_t DFR_STA_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADR) {
     return res;
 }
 
-lin_event_id_t RFR_STA_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
+static lin_event_id_t RFR_STA_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
                          uint8_t *BUS_ADR,
                          uint16_t *CPOS_ALL,
                          eEmrf_Slave_STA *Emrf_Slave,
@@ -344,7 +340,7 @@ lin_event_id_t RFR_STA_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
     return res;
 }
 
-lin_event_id_t ISSR_x(tLinIO *linIo, tLinData *linData, uint8_t COM,
+static lin_event_id_t ISSR_x(tLinIO *linIo, tLinData *linData, uint8_t COM,
                       uint8_t *BLOCK_MT,
                       uint16_t *CPOS_ALL,
                       uint8_t *DIAGNOSE_MT) {
@@ -379,7 +375,7 @@ lin_event_id_t ISSR_x(tLinIO *linIo, tLinData *linData, uint8_t COM,
 
 }
 
-lin_event_id_t CFR_MOD_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
+static lin_event_id_t CFR_MOD_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
                          eMode_Mod Mode_Slave) {
     lin_event_id_t res;
 
@@ -410,7 +406,7 @@ lin_event_id_t CFR_MOD_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
     return res;
 }
 
-lin_event_id_t CFR_INI_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
+static lin_event_id_t CFR_INI_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
                          uint16 INI_CPOS) {
     lin_event_id_t res;
 
@@ -440,7 +436,7 @@ lin_event_id_t CFR_INI_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
     return res;
 }
 
-lin_event_id_t CFR_SET_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
+static lin_event_id_t CFR_SET_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
                          uint16 FINAL_POS,
                          eStall_SET Stall_SET,
                          eLnoise_SET Lnoise_SET,
@@ -484,7 +480,7 @@ lin_event_id_t CFR_SET_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
 }
 
 /*
-lin_event_id_t CFR_PRG_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
+static lin_event_id_t CFR_PRG_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
                          uint16_t BUS_NEW_ADR,
                          uint8_t NOTL_DREH_Master,
                          uint8_t NOTL_ENAB_Master,
@@ -525,20 +521,6 @@ lin_event_id_t CFR_PRG_x(tLinIO *linIo, tLinData *linData, uint8_t BUS_ADDRESS,
     return res;
 }
 */
-void Lin_0_Init(tLinTaskActuator *env,
-                tLinData *linData,
-                tLinIO *linIO,
-                tLoggerInterface *logger) {
-
-    env->linIo = linIO;
-    env->linData = linData;
-    env->logger = logger;
-    env->access = osMutexNew(NULL);
-
-    InitThreadAtrStatic(&env->thread.attr, "Lin0", env->thread.controlBlock, env->thread.stack,
-                        osPriorityNormal);
-}
-
 
 static bool setState20(tLinTaskActuator *env, bool isError, uint8_t index) {
 
@@ -552,7 +534,7 @@ static bool setState20(tLinTaskActuator *env, bool isError, uint8_t index) {
     env->linCommandActuator[index].isRFR_STA = 1;
 
     if (env->linCommandActuator[index].BUS_ADR == 0) {
-        for (uint8_t j = 0; j < LIN0_ISSR_ALL; ++j) {
+        for (uint8_t j = 0; j < env->LIN_ISSR_ALL; ++j) {
 
             env->linCommandActuator[j].COM = LIN_ACT_CFR_SUCCESSFUL;
             env->linCommandActuator[j].isRFR_STA = 1;
@@ -570,11 +552,11 @@ static bool setState20(tLinTaskActuator *env, bool isError, uint8_t index) {
 }
 
 
-lin_event_id_t Lin0_Scheduler(tLinTaskActuator *env) {
+static lin_event_id_t Lin_Scheduler(tLinTaskActuator *env) {
 
     lin_event_id_t ret = LIN_NO_EVENT;
 
-    for (uint8_t i = 0; i < LIN0_ISSR_ALL; ++i) {
+    for (uint8_t i = 0; i < env->LIN_ISSR_ALL; ++i) {
 
         if (env->linCommandActuator[i].COM == LIN_ACT_CFR_MOD) {
 
@@ -610,7 +592,7 @@ lin_event_id_t Lin0_Scheduler(tLinTaskActuator *env) {
 
     }
 
-    for (uint8_t i = 0; i < LIN0_ISSR_ALL; ++i) {
+    for (uint8_t i = 0; i < env->LIN_ISSR_ALL; ++i) {
 
         if (env->linCommandActuator[i].COM == LIN_ACT_CFR_INI) {
 #if (LOG_LIN_ACTUATOR == 1)
@@ -644,7 +626,7 @@ lin_event_id_t Lin0_Scheduler(tLinTaskActuator *env) {
         }
     }
 
-    for (uint8_t i = 0; i < LIN0_ISSR_ALL; ++i) {
+    for (uint8_t i = 0; i < env->LIN_ISSR_ALL; ++i) {
 
         if (env->linCommandActuator[i].COM == LIN_ACT_CFR_SET) {
 #if (LOG_LIN_ACTUATOR == 1)
@@ -704,7 +686,7 @@ lin_event_id_t Lin0_Scheduler(tLinTaskActuator *env) {
     }
 
 
-    for (uint8_t i = 0; i < LIN0_ISSR_ALL; ++i) {
+    for (uint8_t i = 0; i < env->LIN_ISSR_ALL; ++i) {
 /*
         uint8_t BLOCK_MT;
         uint8_t DIAGNOSE_MT;
@@ -761,7 +743,7 @@ lin_event_id_t Lin0_Scheduler(tLinTaskActuator *env) {
                     asm("nop");
                 }
 
-                if (BUS_ADR < LIN0_ISSR_ALL) {
+                if (BUS_ADR < env->LIN_ISSR_ALL) {
 
                     if ((env->linStateActuator[BUS_ADR].CPOS_ALL != CPOS_ALL) ||
                         (env->linStateActuator[BUS_ADR].Emrf_Slave != Emrf_Slave) ||
@@ -841,7 +823,7 @@ lin_event_id_t Lin0_Scheduler(tLinTaskActuator *env) {
 
 bool setBusy(tLinTaskActuator *env) {
 
-    for (uint8_t i = 0; i < LIN0_ISSR_ALL; ++i) {
+    for (uint8_t i = 0; i < env->LIN_ISSR_ALL; ++i) {
 
         if ((env->linCommandActuator[i].COM != LIN_ACT_CFR_NONE) &&
             (env->linCommandActuator[i].COM != LIN_ACT_CFR_SUCCESSFUL)) {
@@ -856,7 +838,7 @@ bool setBusy(tLinTaskActuator *env) {
 
 void resetStall(tLinTaskActuator *env, uint8_t *dataLocalStall) {
 
-    for (uint8_t i = 0; i < LIN0_ISSR_ALL; ++i) {
+    for (uint8_t i = 0; i < env->LIN_ISSR_ALL; ++i) {
 
 //        if (env->linCommandActuator[i].COM == LIN_ACT_CFR_SET) {
 #if (LOG_LIN_ACTUATOR == 1)
@@ -867,7 +849,7 @@ void resetStall(tLinTaskActuator *env, uint8_t *dataLocalStall) {
 
             if (env->linCommandActuator[i].BUS_ADR == 0) {
 
-                for (uint8_t j = 0; j < LIN0_ISSR_ALL; ++j) {
+                for (uint8_t j = 0; j < env->LIN_ISSR_ALL; ++j) {
                     env->linStateActuator[j].Stall_Slave = LIN_STALL_STA_OFF;
                     dataLocalStall[j] = LIN_STALL_STA_OFF;
                 }
@@ -880,19 +862,41 @@ void resetStall(tLinTaskActuator *env, uint8_t *dataLocalStall) {
 
 }
 
-static _Noreturn void Lin0_Thread(tLinTaskActuator *env) {
+//начало----------------------------------------- LIN 1 ----------------------------------------------------------------
+//начало----------------------------------------- LIN 1 ----------------------------------------------------------------
+//начало----------------------------------------- LIN 1 ----------------------------------------------------------------
+//начало----------------------------------------- LIN 1 ---------------------------------------------------------------
+
+void Lin_1_Init(tLinTaskActuator *env,
+                tLinData *linData,
+                tLinIO *linIO,
+                uint8_t LIN_ISSR_ALL,
+                tLoggerInterface *logger) {
+
+    env->linIo = linIO;
+    env->linData = linData;
+    env->logger = logger;
+    env->LIN_ISSR_ALL = LIN_ISSR_ALL;
+    env->access = osMutexNew(NULL);
+
+    InitThreadAtrStatic(&env->threadLin.attr, "Lin1", env->threadLin.controlBlock, env->threadLin.stack,
+                        osPriorityNormal);
+}
+
+
+static _Noreturn void Lin1_Thread(tLinTaskActuator *env) {
     for (;;) {
 
         if (osMutexAcquire(env->access, 1000) == osOK) {
-            lin_event_id_t res = Lin0_Scheduler(env);
+            lin_event_id_t res = Lin_Scheduler(env);
 
             uint8_t isError = 0;
-            for (uint8_t i = 0; i < LIN0_ISSR_ALL; ++i) {
+            for (uint8_t i = 0; i < env->LIN_ISSR_ALL; ++i) {
                 if (env->linStateActuator[i].error_connect == 1)
                     ++isError;
             }
 
-            if (isError == LIN0_ISSR_ALL) {
+            if (isError == env->LIN_ISSR_ALL) {
                 env->error_connect = 1;
             } else {
                 env->error_connect = 0;
@@ -907,13 +911,137 @@ static _Noreturn void Lin0_Thread(tLinTaskActuator *env) {
     }
 }
 
-void Lin0_StartThread(tLinTaskActuator *env) {
+void Lin1_StartThread(tLinTaskActuator *env) {
-    if (!env->thread.id) {
+    if (!env->threadLin.id) {
-        env->thread.id = osThreadNew((osThreadFunc_t) (Lin0_Thread), (void *) (env), &env->thread.attr);
+        env->threadLin.id = osThreadNew((osThreadFunc_t) (Lin1_Thread), (void *) (env), &env->threadLin.attr);
     }
 }
 
-//конец----------------------------------------- LIN 0 ----------------------------------------------------------------
+//конец----------------------------------------- LIN 1 ----------------------------------------------------------------
-//конец----------------------------------------- LIN 0 ----------------------------------------------------------------
+//конец----------------------------------------- LIN 1 ----------------------------------------------------------------
-//конец----------------------------------------- LIN 0 ----------------------------------------------------------------
+//конец----------------------------------------- LIN 1 ----------------------------------------------------------------
-//конец----------------------------------------- LIN 0 ----------------------------------------------------------------
+//конец----------------------------------------- LIN 1 ----------------------------------------------------------------
+
+
+
+//начало----------------------------------------- LIN 2 ----------------------------------------------------------------
+//начало----------------------------------------- LIN 2 ----------------------------------------------------------------
+//начало----------------------------------------- LIN 2 ----------------------------------------------------------------
+//начало----------------------------------------- LIN 2 ---------------------------------------------------------------
+
+void Lin_2_Init(tLinTaskActuator *env,
+                tLinData *linData,
+                tLinIO *linIO,
+                uint8_t LIN_ISSR_ALL,
+                tLoggerInterface *logger) {
+
+    env->linIo = linIO;
+    env->linData = linData;
+    env->logger = logger;
+    env->LIN_ISSR_ALL = LIN_ISSR_ALL;
+    env->access = osMutexNew(NULL);
+
+    InitThreadAtrStatic(&env->threadLin.attr, "Lin2", env->threadLin.controlBlock, env->threadLin.stack,
+                        osPriorityNormal);
+}
+
+
+static _Noreturn void Lin2_Thread(tLinTaskActuator *env) {
+    for (;;) {
+
+        if (osMutexAcquire(env->access, 1000) == osOK) {
+            lin_event_id_t res = Lin_Scheduler(env);
+
+            uint8_t isError = 0;
+            for (uint8_t i = 0; i < env->LIN_ISSR_ALL; ++i) {
+                if (env->linStateActuator[i].error_connect == 1)
+                    ++isError;
+            }
+
+            if (isError == env->LIN_ISSR_ALL) {
+                env->error_connect = 1;
+            } else {
+                env->error_connect = 0;
+            }
+
+            env->busy = false;
+
+            osMutexRelease(env->access);
+        }
+
+        SystemDelayMs(50);
+    }
+}
+
+void Lin2_StartThread(tLinTaskActuator *env) {
+    if (!env->threadLin.id) {
+        env->threadLin.id = osThreadNew((osThreadFunc_t) (Lin2_Thread), (void *) (env), &env->threadLin.attr);
+    }
+}
+
+//конец----------------------------------------- LIN 2 ----------------------------------------------------------------
+//конец----------------------------------------- LIN 2 ----------------------------------------------------------------
+//конец----------------------------------------- LIN 2 ----------------------------------------------------------------
+//конец----------------------------------------- LIN 2 ----------------------------------------------------------------
+
+
+
+//начало----------------------------------------- LIN 3 ----------------------------------------------------------------
+//начало----------------------------------------- LIN 3 ----------------------------------------------------------------
+//начало----------------------------------------- LIN 3 ----------------------------------------------------------------
+//начало----------------------------------------- LIN 3 ---------------------------------------------------------------
+
+void Lin_3_Init(tLinTaskActuator *env,
+                tLinData *linData,
+                tLinIO *linIO,
+                uint8_t LIN_ISSR_ALL,
+                tLoggerInterface *logger) {
+
+    env->linIo = linIO;
+    env->linData = linData;
+    env->logger = logger;
+    env->LIN_ISSR_ALL = LIN_ISSR_ALL;
+    env->access = osMutexNew(NULL);
+
+    InitThreadAtrStatic(&env->threadLin.attr, "Lin3", env->threadLin.controlBlock, env->threadLin.stack,
+                        osPriorityNormal);
+}
+
+
+static _Noreturn void Lin3_Thread(tLinTaskActuator *env) {
+    for (;;) {
+
+        if (osMutexAcquire(env->access, 1000) == osOK) {
+            lin_event_id_t res = Lin_Scheduler(env);
+
+            uint8_t isError = 0;
+            for (uint8_t i = 0; i < env->LIN_ISSR_ALL; ++i) {
+                if (env->linStateActuator[i].error_connect == 1)
+                    ++isError;
+            }
+
+            if (isError == env->LIN_ISSR_ALL) {
+                env->error_connect = 1;
+            } else {
+                env->error_connect = 0;
+            }
+
+            env->busy = false;
+
+            osMutexRelease(env->access);
+        }
+
+        SystemDelayMs(50);
+    }
+}
+
+void Lin3_StartThread(tLinTaskActuator *env) {
+    if (!env->threadLin.id) {
+        env->threadLin.id = osThreadNew((osThreadFunc_t) (Lin3_Thread), (void *) (env), &env->threadLin.attr);
+    }
+}
+
+//конец----------------------------------------- LIN 3 ----------------------------------------------------------------
+//конец----------------------------------------- LIN 3 ----------------------------------------------------------------
+//конец----------------------------------------- LIN 3 ----------------------------------------------------------------
+//конец----------------------------------------- LIN 3 ----------------------------------------------------------------

LinActuatorTasks.h

@@ -367,10 +367,6 @@ typedef struct __attribute__ ((packed)) {
     uint8_t DIAGNOSE_MT: 1;
 } ACT_RFR_ISSR;
 
-#define LIN0_ISSR_ALL 0x09
-#define LIN1_ISSR_ALL 0x06
-#define LIN2_ISSR_ALL 0x08
-
 typedef struct {
 
     uint8_t BLOCK_MT;
@@ -455,6 +451,8 @@ typedef struct {
 
     tLinData *linData;
 
+    uint8_t LIN_ISSR_ALL;
+
     tLoggerInterface *logger;
 
     struct {
@@ -462,21 +460,37 @@ typedef struct {
         uint32_t stack[1024];
         StaticTask_t controlBlock;
         osThreadAttr_t attr;
-    } thread;
+    } threadLin;
 
 } tLinTaskActuator;
 
-void Lin_0_Init(tLinTaskActuator *env,
+void Lin_1_Init(tLinTaskActuator *env,
                 tLinData *linData,
                 tLinIO *linIO,
+                uint8_t LIN_ISSR_ALL,
                 tLoggerInterface *logger);
 
-void Lin0_StartThread(tLinTaskActuator *env);
+void Lin1_StartThread(tLinTaskActuator *env);
 
-void GetLin0CallbackHandler(tLinData *env, uint8_t u8LinIndex, void *state);
+void Lin_2_Init(tLinTaskActuator *env,
+                tLinData *linData,
+                tLinIO *linIO,
+                uint8_t LIN_ISSR_ALL,
+                tLoggerInterface *logger);
 
+void Lin2_StartThread(tLinTaskActuator *env);
+
+void Lin_3_Init(tLinTaskActuator *env,
+                tLinData *linData,
+                tLinIO *linIO,
+                uint8_t LIN_ISSR_ALL,
+                tLoggerInterface *logger);
+
+void Lin3_StartThread(tLinTaskActuator *env);
+
+
+void GetLin123CallbackHandler(tLinData *env, uint8_t u8LinIndex, void *state);
 void resetStall(tLinTaskActuator *env, uint8_t *dataLocalStall);
-
 bool setBusy(tLinTaskActuator *env);
 
 #endif //HVAC_LIN_TASKS_H

LinSensorTasks.c

@@ -0,0 +1,48 @@
+//
+// Created by cfif on 12.02.2026.
+//
+#include <SystemDelayInterface.h>
+#include "LinSensorTasks.h"
+#include "CmsisRtosThreadUtils.h"
+#include "CanPorts.h"
+#include "fc7xxx_driver_lin.h"
+#include "Lins.h"
+#include "LoggerInterface.h"
+#include "memory.h"
+
+#define LOG_SIGN "Lin0"
+#define LOGGER env->logger
+
+static lin_event_id_t SEND_SENSOR_COM_x(tLinIO *linIo, uint8_t COM_ADR) {
+    lin_event_id_t res = linIo->runCommand(linIo->env, COM_ADR, 40);
+    SystemDelayMs(30);
+    return res;
+}
+
+
+static lin_event_id_t Get_AirQS_Stat(tLinIO *linIo, tLinData *linData, tAirQS_Stat *p_AirQS_Stat) {
+    lin_event_id_t res;
+
+    tAirQS_Stat *tAirQS_Stat_ = (tAirQS_Stat *) linData->g_aRxBuffer;
+
+    uint8_t retry = 3;
+
+    while (retry) {
+
+        linData->direction = LIN_DIRECTION_GET;
+
+        linData->g_aTxBufferLen = 0;
+        linData->g_aRxBufferLen = sizeof(tAirQS_Stat);
+
+        res = SEND_SENSOR_COM_x(linIo, AirQS_Stat);
+
+        if (res == LIN_RX_COMPLETED) {
+            memcpy(p_AirQS_Stat, tAirQS_Stat_, sizeof(tAirQS_Stat));
+            break;
+        }
+
+        --retry;
+    }
+
+    return res;
+}

LinSensorTasks.h

@@ -0,0 +1,192 @@
+//
+// Created by cfif on 12.02.2026.
+//
+
+#ifndef HVAC_M7_LINSENSORTASKS_H
+#define HVAC_M7_LINSENSORTASKS_H
+
+#include <cmsis_os.h>
+#include "stdbool.h"
+#include "LinIO.h"
+#include "LoggerInterface.h"
+
+#define AirQS_Stat 0x14
+#define Aroma_Stat 0x5
+#define CCU_Req 0x1
+#define Ionizer_Stat 0x1C
+#define eTXV_fHVAC_Stat 0x1E
+#define eTXV_rHVAC_Stat 0x20
+#define eTXV_batChiller_Stat 0x22
+#define eTXV_eeChiller_Stat 0x24
+
+#define CCU_DRS_Req 0x1
+#define DRS_DL_Stat 0xD
+#define DRS_DR_Stat 0x12
+#define DRS_FCL_Stat 0x2B
+#define DRS_FCR_Stat 0x30
+#define DRS_FPL_Stat 0x17
+#define DRS_FPR_Stat 0x1C
+#define DRS_RLB_Stat 0x21
+#define DRS_RRB_Stat 0x26
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t AirQS_LinRespErr_Stat: 1; // 0
+    uint8_t AirQS_Sens_Stat: 2; // 1
+    uint8_t AirQS_Combined_Stat: 3; // 3
+    uint8_t unused1: 2; // 6
+    uint8_t AirQS_Err_Stat: 3; // 8
+    uint8_t AirQS_COLvl_Stat: 4; // 11
+    uint8_t unused2: 1; // 15
+    uint8_t AirQS_NOxLvl_Stat: 4; // 16
+    uint8_t AirQS_NH3Lvl_Stat: 4; // 20
+} tAirQS_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t Aroma_LinRespErr_Stat: 1; // 0
+    uint8_t Aroma_CartridgeSw_Stat: 1; // 1
+    uint8_t unused1: 2; // 2
+    uint8_t Aroma_Err_Stat: 2; // 4
+    uint8_t Aroma_Intens_Stat: 2; // 6
+    uint8_t unused2: 2; // 8
+    uint8_t Aroma_CartridgeFlavor_Stat: 4; // 10
+    uint16_t unused3: 10;   // биты 14–23
+    uint8_t Aroma_CartridgeCapacity_Stat: 4; // 24
+    uint8_t unused4: 4;   // биты 28–31
+    uint8_t unused5: 8;   // биты 32–39
+} tAroma_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t CCU_Ionization_Req: 1; // 0
+    uint8_t unused1: 2; // 1
+    uint8_t CCU_AromaIntens_Req: 2; // 3
+    uint8_t unused2: 3;     // биты 5–7
+    uint8_t unused3: 8;     // биты 8–15
+    uint8_t unused4: 8;     // биты 16–23
+    uint8_t CCU_AirQS_Req: 1; // 24
+    uint8_t CCU_fHVAC_Pos_Val: 7; // 25
+    uint8_t CCU_rHVAC_Pos_Val: 7; // 32
+    uint8_t unused5: 1; // 39
+    uint8_t CCU_batChiller_Pos_Val: 7; // 40
+    uint8_t unused6: 1; // 47
+    uint8_t CCU_eeChiller_Pos_Val: 7; // 48
+    uint8_t unused7: 1; // 55 – явное заполнение
+} tCCU_Req;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t Ionizer_LinRespErr_Stat: 1; // 0
+    uint8_t Ionizer_Err_Stat: 2; // 1
+    uint8_t unused1: 5; // 3
+    uint8_t Ionizer_Ionization_Stat: 1; // 8
+} tIonizer_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t eTXV_fHVAC_Pos_Stat: 7; // 0
+    uint8_t eTXV_fHVAC_LinRespErr_Stat: 1; // 7
+    uint8_t eTXV_fHVAC_Err_Stat: 2; // 8
+    uint8_t eTXV_fHVAC_Pressure_Val: 6; // 10
+    uint8_t eTXV_fHVAC_Temp_Val: 7; // 16
+} teTXV_fHVAC_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t eTXV_rHVAC_Pos_Stat: 7; // 0
+    uint8_t eTXV_rHVAC_LinRespErr_Stat: 1; // 7
+    uint8_t eTXV_rHVAC_Err_Stat: 2; // 8
+    uint8_t eTXV_rHVAC_Pressure_Val: 6; // 10
+    uint8_t eTXV_rHVAC_Temp_Val: 7; // 16
+} teTXV_rHVAC_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t eTXV_batChiller_Pos_Stat        : 7; // 0
+    uint8_t eTXV_batChiller_LinRespErr_Stat : 1; // 7
+    uint8_t eTXV_batChiller_Err_Stat        : 2; // 8
+    uint8_t eTXV_batChiller_Pressure_Val    : 6; // 10
+    uint8_t eTXV_batChiller_Temp_Val        : 7; // 16
+} teTXV_batChiller_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t eTXV_eeChiller_Stat_: 7; // 0
+    uint8_t eTXV_eeChiller_LinRespErr_Stat: 1; // 7
+    uint8_t eTXV_eeChiller_Err_Stat: 2; // 8
+    uint8_t eTXV_eeChiller_Pressure_Val: 6; // 10
+    uint8_t eTXV_eeChiller_Temp_Val: 7; // 16
+} teTXV_eeChiller_Stat;
+
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t CCU_DLLed1_Req: 1; // 0
+    uint8_t CCU_DLLed2_Req: 1; // 1
+    uint8_t CCU_DLLed3_Req: 1; // 2
+    uint8_t CCU_DRLed1_Req: 1; // 3
+    uint8_t CCU_DRLed2_Req: 1; // 4
+    uint8_t CCU_DRLed3_Req: 1; // 5
+    uint8_t CCU_FPLLed1_Req: 1; // 6
+    uint8_t CCU_FPLLed2_Req: 1; // 7
+    uint8_t CCU_FPLLed3_Req: 1; // 8
+    uint8_t CCU_FPRLed1_Req: 1; // 9
+    uint8_t CCU_FPRLed2_Req: 1; // 10
+    uint8_t CCU_FPRLed3_Req: 1; // 11
+    uint8_t CCU_RLBLed1_Req: 1; // 12
+    uint8_t CCU_RLBLed2_Req: 1; // 13
+    uint8_t CCU_RLBLed3_Req: 1; // 14
+    uint8_t CCU_RRBLed1_Req: 1; // 15
+    uint8_t CCU_RRBLed2_Req: 1; // 16
+    uint8_t CCU_RRBLed3_Req: 1; // 17
+    uint8_t CCU_FCLLed1_Req: 1; // 18
+    uint8_t CCU_FCLLed2_Req: 1; // 19
+    uint8_t CCU_FCLLed3_Req: 1; // 20
+    uint8_t CCU_FCRLed1_Req: 1; // 21
+    uint8_t CCU_FCRLed2_Req: 1; // 22
+    uint8_t CCU_FCRLed3_Req: 1; // 23
+    uint8_t BCM_SwIndIntens_Stat: 1; // 24
+    uint8_t BCM_IndFadingTime_Req: 5; // 25
+} tCCU_DRS_Req;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t DRS_DL_Btn_Stat: 1; // 0
+    uint8_t DRS_DL_LinRespErr_Stat: 1; // 1
+    uint8_t DRS_DL_Err_Stat: 1; // 2
+} tDRS_DL_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t DRS_DR_Btn_Stat: 1; // 0
+    uint8_t DRS_DR_LinRespErr_Stat: 1; // 1
+    uint8_t DRS_DR_Err_Stat: 1; // 2
+} tDRS_DR_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t DRS_FCL_Btn_Stat: 1; // 0
+    uint8_t DRS_FCL_LinRespErr_Stat: 1; // 1
+    uint8_t DRS_FCL_Err_Stat: 1; // 2
+} tDRS_FCL_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t DRS_FCR_Btn_Stat: 1; // 0
+    uint8_t DRS_FCR_LinRespErr_Stat: 1; // 1
+    uint8_t DRS_FCR_Err_Stat: 1; // 2
+} tDRS_FCR_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t DRS_FPL_Btn_Stat: 1; // 0
+    uint8_t DRS_FPL_LinRespErr_Stat: 1; // 1
+    uint8_t DRS_FPL_Err_Stat: 1; // 2
+} tDRS_FPL_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t DRS_FPR_Btn_Stat: 1; // 0
+    uint8_t DRS_FPR_LinRespErr_Stat: 1; // 1
+    uint8_t DRS_FPR_Err_Stat: 1; // 2
+} tDRS_FPR_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t DRS_RLB_Btn_Stat: 1; // 0
+    uint8_t DRS_RLB_LinRespErr_Stat: 1; // 1
+    uint8_t DRS_RLB_Err_Stat: 1; // 2
+} tDRS_RLB_Stat;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t DRS_RRB_Btn_Stat: 1; // 0
+    uint8_t DRS_RRB_LinRespErr_Stat: 1; // 1
+    uint8_t DRS_RRB_Err_Stat: 1; // 2
+} tDRS_RRB_Stat;
+
+#endif //HVAC_M7_LINSENSORTASKS_H