diff --git a/ArbiterCommand.c b/ArbiterCommand.c
index 94b9f3a..adf3d3a 100644
--- a/ArbiterCommand.c
+++ b/ArbiterCommand.c
@@ -9,7 +9,7 @@
 #include "AsciiStringParsingUtils.h"
 #include "memory.h"
 
-
+/*
 void sendOk(tAtCmd *AtCmd) {
     AtCmdPrepare(AtCmd);
     AtCmdTxClear(AtCmd);
@@ -33,7 +33,7 @@ void sendVers(tAtCmd *AtCmd) {
     AtCmdTxSendLn(AtCmd);
     AtCmdRxClear(AtCmd);
 }
-
+*/
 
 
 //начало ------------------------------Отправка без подтверждения-------------------------------------------------------
@@ -41,13 +41,12 @@ void sendVers(tAtCmd *AtCmd) {
 //начало ------------------------------Отправка без подтверждения-------------------------------------------------------
 
 void TaskSerialToCanCyclic0_Init(tTaskSerialToCanCyclic *env,
-                                 tSerialPortFrameIO *ioCAN,
-                                 osMessageQueueId_t txDataQueue
+                                 tSerialPortFrameIO *ioCAN
 ) {
 
-    env->access = osMutexNew(NULL);
+//    env->access = osMutexNew(NULL);
     env->ioCAN = ioCAN;
-    env->txDataQueue = txDataQueue;
+    env->txDataQueue = osMessageQueueNew(20, sizeof(can_rx_message_type), NULL);
 
     InitThreadAtrStatic(&env->thread.attr, "SerialCyclic", env->thread.controlBlock, env->thread.stack,
                         osPriorityNormal);
@@ -57,25 +56,48 @@ void TaskSerialToCanCyclic0_Init(tTaskSerialToCanCyclic *env,
 static _Noreturn void Serial_ToCanCyclic0_Thread(tTaskSerialToCanCyclic *env) {
     for (;;) {
 
-        if (osMutexAcquire(env->access, 1000) == osOK) {
+//        if (osMutexAcquire(env->access, 1000) == osOK) {
 
-            can_rx_message_type data;
-            if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) {
+        can_rx_message_type data;
+        if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) {
 
-                if (data.id_type == CAN_ID_STANDARD) {
-                    uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.standard_id, 0, 0,
-                                                         1000);
-                } else {
-                    uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.extended_id, 1, 0,
-                                                         1000);
-                }
+            if (data.id_type == CAN_ID_STANDARD) {
+                uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.standard_id, 0, 0,
+                                                     1000);
+            } else {
+                uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.extended_id, 1, 0,
+                                                     1000);
             }
-
-            osMutexRelease(env->access);
         }
+
+//            osMutexRelease(env->access);
+//        }
     }
 }
 
+uint32_t GetCountQueueCanCyclic0(tTaskSerialToCanCyclic *env) {
+    uint32_t count = 0;
+
+//    if (osMutexAcquire(env->access, 1000) == osOK) {
+    count = osMessageQueueGetCount(env->txDataQueue);
+//        osMutexRelease(env->access);
+//    }
+
+    return count;
+}
+
+osStatus_t PutQueueCanCyclic0(tTaskSerialToCanCyclic *env, can_rx_message_type *dataCan) {
+    osStatus_t status = osErrorTimeout;
+
+//    if (osMutexAcquire(env->access, 1000) == osOK) {
+    status = osMessageQueuePut(env->txDataQueue, dataCan, 0x0, 0U);
+//        osMutexRelease(env->access);
+//    }
+
+    return status;
+}
+
+
 void TaskSerialToCanCyclic0_StartThread(tTaskSerialToCanCyclic *env) {
     if (!env->thread.id) {
         env->thread.id = osThreadNew((osThreadFunc_t) (Serial_ToCanCyclic0_Thread), (void *) (env), &env->thread.attr);
@@ -91,14 +113,13 @@ void TaskSerialToCanCyclic0_StartThread(tTaskSerialToCanCyclic *env) {
 //начало ------------------------------Отправка без подтверждения-------------------------------------------------------
 
 void TaskSerialToCanCyclic1_Init(tTaskSerialToCanCyclic *env,
-                                 tSerialPortFrameIO *ioCAN,
-                                 osMessageQueueId_t txDataQueue
+                                 tSerialPortFrameIO *ioCAN
 
 ) {
 
-    env->access = osMutexNew(NULL);
+//    env->access = osMutexNew(NULL);
     env->ioCAN = ioCAN;
-    env->txDataQueue = txDataQueue;
+    env->txDataQueue = osMessageQueueNew(20, sizeof(can_rx_message_type), NULL);
 
     InitThreadAtrStatic(&env->thread.attr, "SerialCyclic", env->thread.controlBlock, env->thread.stack,
                         osPriorityNormal);
@@ -108,25 +129,47 @@ void TaskSerialToCanCyclic1_Init(tTaskSerialToCanCyclic *env,
 static _Noreturn void Serial_ToCanCyclic1_Thread(tTaskSerialToCanCyclic *env) {
     for (;;) {
 
-        if (osMutexAcquire(env->access, 1000) == osOK) {
+//        if (osMutexAcquire(env->access, 1000) == osOK) {
 
-            can_rx_message_type data;
-            if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) {
+        can_rx_message_type data;
+        if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) {
 
-                if (data.id_type == CAN_ID_STANDARD) {
-                    uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.standard_id, 0, 1,
-                                                         1000);
-                } else {
-                    uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.extended_id, 1, 1,
-                                                         1000);
-                }
+            if (data.id_type == CAN_ID_STANDARD) {
+                uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.standard_id, 0, 1,
+                                                     1000);
+            } else {
+                uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.extended_id, 1, 1,
+                                                     1000);
             }
-
-            osMutexRelease(env->access);
         }
+
+//            osMutexRelease(env->access);
+//        }
     }
 }
 
+uint32_t GetCountQueueCanCyclic1(tTaskSerialToCanCyclic *env) {
+    uint32_t count = 0;
+
+//    if (osMutexAcquire(env->access, 1000) == osOK) {
+    count = osMessageQueueGetCount(env->txDataQueue);
+//        osMutexRelease(env->access);
+//    }
+
+    return count;
+}
+
+osStatus_t PutQueueCanCyclic1(tTaskSerialToCanCyclic *env, can_rx_message_type *dataCan) {
+    osStatus_t status = osErrorTimeout;
+
+//    if (osMutexAcquire(env->access, 1000) == osOK) {
+    status = osMessageQueuePut(env->txDataQueue, dataCan, 0x0, 0U);
+//        osMutexRelease(env->access);
+//    }
+
+    return status;
+}
+
 void TaskSerialToCanCyclic1_StartThread(tTaskSerialToCanCyclic *env) {
     if (!env->thread.id) {
         env->thread.id = osThreadNew((osThreadFunc_t) (Serial_ToCanCyclic1_Thread), (void *) (env), &env->thread.attr);
@@ -144,19 +187,18 @@ void TaskSerialToCanCyclic1_StartThread(tTaskSerialToCanCyclic *env) {
 
 void TaskSerialToCanSpontany_Init(tTaskSerialToCanSpontany *env,
                                   tSerialPortFrameIO *ioCAN,
-                                  osMessageQueueId_t txDataQueue,
-                                  tAtCmd *At_UART,
-                                  tAtCmd *At_UART_USB
+                                  tSerialPortIO *ioUART,
+                                  tSerialPortIO *ioUSB
 
 ) {
 
-    env->access = osMutexNew(NULL);
+//    env->access = osMutexNew(NULL);
     env->ioCAN = ioCAN;
 
-    env->At_UART = At_UART;
-    env->At_UART_USB = At_UART_USB;
+    env->ioUART = ioUART;
+    env->ioUSB = ioUSB;
 
-    env->txDataQueue = txDataQueue;
+    env->txDataQueue = osMessageQueueNew(20, sizeof(can_rx_message_Spontany), NULL);
 
     InitThreadAtrStatic(&env->thread.attr, "SerialSpontany", env->thread.controlBlock, env->thread.stack,
                         osPriorityNormal);
@@ -166,56 +208,67 @@ void TaskSerialToCanSpontany_Init(tTaskSerialToCanSpontany *env,
 static _Noreturn void Serial_ToCanSpontany_Thread(tTaskSerialToCanSpontany *env) {
     for (;;) {
 
-        if (osMutexAcquire(env->access, 1000) == osOK) {
+//        if (osMutexAcquire(env->access, 1000) == osOK) {
 
-            can_rx_message_Spontany data;
-            if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) {
+        can_rx_message_Spontany data;
+        if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) {
 
-                if (data.can_rx_message.id_type == CAN_ID_STANDARD) {
-                    uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.can_rx_message.data,
-                                                         data.can_rx_message.dlc, data.can_rx_message.standard_id, 0, 2,
-                                                         1000);
-                    if (sent) {
-                        if (data.from_uart == FROM_UART) {
-                            sendOk(env->At_UART);
-                        } else {
-                            sendOk(env->At_UART_USB);
-                        }
+            if (data.can_rx_message.id_type == CAN_ID_STANDARD) {
+                uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.can_rx_message.data,
+                                                     data.can_rx_message.dlc, data.can_rx_message.standard_id, 0, 2,
+                                                     1000);
+                if (sent) {
+                    if (data.from_uart == FROM_UART) {
+                        env->ioUART->transmit(env->ioUART->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n"), 1000);
                     } else {
-                        if (data.from_uart == FROM_UART) {
-                            sendError(env->At_UART);
-                        } else {
-                            sendError(env->At_UART_USB);
-                        }
+                        env->ioUART->transmit(env->ioUSB->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n"), 1000);
                     }
-
                 } else {
-                    uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.can_rx_message.data,
-                                                         data.can_rx_message.dlc, data.can_rx_message.extended_id, 1, 2,
-                                                         1000);
-
-                    if (sent) {
-                        if (data.from_uart == FROM_UART) {
-                            sendOk(env->At_UART);
-                        } else {
-                            sendOk(env->At_UART_USB);
-                        }
+                    if (data.from_uart == FROM_UART) {
+                        env->ioUART->transmit(env->ioUART->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n"), 1000);
                     } else {
-                        if (data.from_uart == FROM_UART) {
-                            sendError(env->At_UART);
-                        } else {
-                            sendError(env->At_UART_USB);
-                        }
+                        env->ioUART->transmit(env->ioUSB->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n"), 1000);
                     }
-
                 }
-            }
 
-            osMutexRelease(env->access);
+            } else {
+                uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.can_rx_message.data,
+                                                     data.can_rx_message.dlc, data.can_rx_message.extended_id, 1, 2,
+                                                     1000);
+
+                if (sent) {
+                    if (data.from_uart == FROM_UART) {
+                        env->ioUART->transmit(env->ioUART->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n"), 1000);
+                    } else {
+                        env->ioUART->transmit(env->ioUSB->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n"), 1000);
+                    }
+                } else {
+                    if (data.from_uart == FROM_UART) {
+                        env->ioUART->transmit(env->ioUART->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n"), 1000);
+                    } else {
+                        env->ioUART->transmit(env->ioUSB->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n"), 1000);
+                    }
+                }
+
+            }
         }
+
+//            osMutexRelease(env->access);
+//        }
     }
 }
 
+osStatus_t PutQueueCanSpontany(tTaskSerialToCanSpontany *env, can_rx_message_Spontany *dataCan) {
+    osStatus_t status = osErrorTimeout;
+
+//    if (osMutexAcquire(env->access, 1000) == osOK) {
+    status = osMessageQueuePut(env->txDataQueue, dataCan, 0x0, 0U);
+//        osMutexRelease(env->access);
+//    }
+
+    return status;
+}
+
 void TaskSerialToCanSpontany_StartThread(tTaskSerialToCanSpontany *env) {
     if (!env->thread.id) {
         env->thread.id = osThreadNew((osThreadFunc_t) (Serial_ToCanSpontany_Thread), (void *) (env), &env->thread.attr);
@@ -272,16 +325,18 @@ void SerialCommand_Scheduler(tTaskSerial *env) {
             memcpy(dataCan.can_rx_message.data, data, size);
 
             if (opt) {
-                status = osMessageQueuePut(env->txDataQueue_Spontany, &dataCan, 0x0, 0U);
+
+                status = PutQueueCanSpontany(env->TaskSerialToCanSpontany, &dataCan);
+
             } else {
 
-                uint32_t count0 = osMessageQueueGetCount(env->txDataQueue_Cyclic0);
-                uint32_t count1 = osMessageQueueGetCount(env->txDataQueue_Cyclic1);
+                uint32_t count0 = GetCountQueueCanCyclic0(env->TaskSerialToCanCyclic0);
+                uint32_t count1 = GetCountQueueCanCyclic1(env->TaskSerialToCanCyclic1);
 
                 if (count0 <= count1) {
-                    status = osMessageQueuePut(env->txDataQueue_Cyclic0, &dataCan.can_rx_message, 0x0, 0U);
+                    status = PutQueueCanCyclic0(env->TaskSerialToCanCyclic0, &dataCan.can_rx_message);
                 } else {
-                    status = osMessageQueuePut(env->txDataQueue_Cyclic1, &dataCan.can_rx_message, 0x0, 0U);
+                    status = PutQueueCanCyclic1(env->TaskSerialToCanCyclic1, &dataCan.can_rx_message);
                 }
             }
         }
@@ -320,24 +375,25 @@ void SerialCommand_Scheduler(tTaskSerial *env) {
             memcpy(dataCan.can_rx_message.data, data, size);
 
             if (opt) {
-                status = osMessageQueuePut(env->txDataQueue_Spontany, &dataCan, 0x0, 0U);
+
+                status = PutQueueCanSpontany(env->TaskSerialToCanSpontany, &dataCan);
+
             } else {
 
-                uint32_t count0 = osMessageQueueGetCount(env->txDataQueue_Cyclic0);
-                uint32_t count1 = osMessageQueueGetCount(env->txDataQueue_Cyclic1);
+                uint32_t count0 = GetCountQueueCanCyclic0(env->TaskSerialToCanCyclic0);
+                uint32_t count1 = GetCountQueueCanCyclic1(env->TaskSerialToCanCyclic1);
 
                 if (count0 <= count1) {
-                    status = osMessageQueuePut(env->txDataQueue_Cyclic0, &dataCan.can_rx_message, 0x0, 0U);
+                    status = PutQueueCanCyclic0(env->TaskSerialToCanCyclic0, &dataCan.can_rx_message);
                 } else {
-                    status = osMessageQueuePut(env->txDataQueue_Cyclic1, &dataCan.can_rx_message, 0x0, 0U);
+                    status = PutQueueCanCyclic1(env->TaskSerialToCanCyclic1, &dataCan.can_rx_message);
                 }
             }
-
         }
 
         if (AtCmdRxBeginWithStatic(&env->At, "V")) {
-            sendVers(&env->At);
-            sendOk(&env->At);
+            env->ioUART->transmit(env->ioUART->env, (uint8_t *) "v001\r\n", sizeof("v001\r\n"), 1000);
+            env->ioUART->transmit(env->ioUART->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n"), 1000);
         }
     }
 
@@ -356,20 +412,20 @@ void SerialCommand_Scheduler(tTaskSerial *env) {
 void TaskSerialUART_Init(tTaskSerial *env,
                          tFrom_uart from_uart,
                          tSerialPortIO *ioUART,
-                         osMessageQueueId_t txDataQueue_Cyclic0,
-                         osMessageQueueId_t txDataQueue_Cyclic1,
-                         osMessageQueueId_t txDataQueue_Spontany
+                         tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
+                         tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
+                         tTaskSerialToCanSpontany *TaskSerialToCanSpontany
 
 ) {
 
-    env->access = osMutexNew(NULL);
+//    env->access = osMutexNew(NULL);
     env->from_uart = from_uart;
 
     env->ioUART = ioUART;
 
-    env->txDataQueue_Cyclic0 = txDataQueue_Cyclic0;
-    env->txDataQueue_Cyclic1 = txDataQueue_Cyclic1;
-    env->txDataQueue_Spontany = txDataQueue_Spontany;
+    env->TaskSerialToCanCyclic0 = TaskSerialToCanCyclic0;
+    env->TaskSerialToCanCyclic1 = TaskSerialToCanCyclic1;
+    env->TaskSerialToCanSpontany = TaskSerialToCanSpontany;
 
     SerialPortClearRxBuffer(env->ioUART);
 
@@ -387,12 +443,12 @@ void TaskSerialUART_Init(tTaskSerial *env,
 static _Noreturn void Serial_UART_Thread(tTaskSerial *env) {
     for (;;) {
 
-        if (osMutexAcquire(env->access, 1000) == osOK) {
+//        if (osMutexAcquire(env->access, 1000) == osOK) {
 
             SerialCommand_Scheduler(env);
 
-            osMutexRelease(env->access);
-        }
+//            osMutexRelease(env->access);
+//        }
 
         SystemDelayMs(1);
     }
@@ -416,19 +472,19 @@ void TaskSerialUART_StartThread(tTaskSerial *env) {
 void TaskSerialUSB_Init(tTaskSerial *env,
                         tFrom_uart from_uart,
                         tSerialPortIO *ioUART,
-                        osMessageQueueId_t txDataQueue_Spontany,
-                        osMessageQueueId_t txDataQueue_Cyclic0,
-                        osMessageQueueId_t txDataQueue_Cyclic1
+                        tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
+                        tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
+                        tTaskSerialToCanSpontany *TaskSerialToCanSpontany
 ) {
 
-    env->access = osMutexNew(NULL);
+//    env->access = osMutexNew(NULL);
     env->from_uart = from_uart;
 
     env->ioUART = ioUART;
 
-    env->txDataQueue_Spontany = txDataQueue_Spontany;
-    env->txDataQueue_Cyclic0 = txDataQueue_Cyclic0;
-    env->txDataQueue_Cyclic1 = txDataQueue_Cyclic1;
+    env->TaskSerialToCanCyclic0 = TaskSerialToCanCyclic0;
+    env->TaskSerialToCanCyclic1 = TaskSerialToCanCyclic1;
+    env->TaskSerialToCanSpontany = TaskSerialToCanSpontany;
 
     SerialPortClearRxBuffer(env->ioUART);
 
@@ -446,12 +502,12 @@ void TaskSerialUSB_Init(tTaskSerial *env,
 static _Noreturn void Serial_USB_Thread(tTaskSerial *env) {
     for (;;) {
 
-        if (osMutexAcquire(env->access, 1000) == osOK) {
+//        if (osMutexAcquire(env->access, 1000) == osOK) {
 
             SerialCommand_Scheduler(env);
 
-            osMutexRelease(env->access);
-        }
+//            osMutexRelease(env->access);
+//        }
 
         SystemDelayMs(1);
     }
diff --git a/ArbiterCommand.h b/ArbiterCommand.h
index f926ab4..cc78893 100644
--- a/ArbiterCommand.h
+++ b/ArbiterCommand.h
@@ -10,40 +10,16 @@
 #include "AtCmdCommon.h"
 #include "CanSerialPortFrame.h"
 
+
 typedef enum {
     FROM_UART,
     FROM_UART_USB
 } tFrom_uart;
 
-typedef struct {
-
-    tAtCmd At;
-    uint8_t AtRx[255];
-    uint8_t AtTx[255];
-
-    tSerialPortIO *ioUART;
-    tFrom_uart from_uart;
-    osMutexId_t access;
-
-    osMessageQueueId_t txDataQueue_Spontany;
-    osMessageQueueId_t txDataQueue_Cyclic0;
-    osMessageQueueId_t txDataQueue_Cyclic1;
-
-    struct {
-        osThreadId_t id;
-        uint32_t stack[1024];
-        StaticTask_t controlBlock;
-        osThreadAttr_t attr;
-    } thread;
-
-
-} tTaskSerial;
-
-
 typedef struct {
 
     tSerialPortFrameIO *ioCAN;
-    osMutexId_t access;
+//    osMutexId_t access;
     osMessageQueueId_t txDataQueue;
 
     struct {
@@ -64,11 +40,11 @@ typedef struct {
 typedef struct {
 
     tSerialPortFrameIO *ioCAN;
-    osMutexId_t access;
+//    osMutexId_t access;
     osMessageQueueId_t txDataQueue;
 
-    tAtCmd *At_UART;
-    tAtCmd *At_UART_USB;
+    tSerialPortIO *ioUART;
+    tSerialPortIO *ioUSB;
 
     struct {
         osThreadId_t id;
@@ -80,12 +56,37 @@ typedef struct {
 
 } tTaskSerialToCanSpontany;
 
+typedef struct {
+
+    tAtCmd At;
+    uint8_t AtRx[255];
+    uint8_t AtTx[255];
+
+    tSerialPortIO *ioUART;
+    tFrom_uart from_uart;
+//    osMutexId_t access;
+
+    tTaskSerialToCanCyclic *TaskSerialToCanCyclic0;
+    tTaskSerialToCanCyclic *TaskSerialToCanCyclic1;
+    tTaskSerialToCanSpontany *TaskSerialToCanSpontany;
+
+    struct {
+        osThreadId_t id;
+        uint32_t stack[1024];
+        StaticTask_t controlBlock;
+        osThreadAttr_t attr;
+    } thread;
+
+
+} tTaskSerial;
+
+
 void TaskSerialUART_Init(tTaskSerial *env,
                          tFrom_uart from_uart,
                          tSerialPortIO *ioUART,
-                         osMessageQueueId_t txDataQueue_Spontany,
-                         osMessageQueueId_t txDataQueue_Cyclic0,
-                         osMessageQueueId_t txDataQueue_Cyclic1
+                         tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
+                         tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
+                         tTaskSerialToCanSpontany *TaskSerialToCanSpontany
 );
 
 void TaskSerialUART_StartThread(tTaskSerial *env);
@@ -93,9 +94,9 @@ void TaskSerialUART_StartThread(tTaskSerial *env);
 void TaskSerialUSB_Init(tTaskSerial *env,
                         tFrom_uart from_uart,
                         tSerialPortIO *ioUART,
-                        osMessageQueueId_t txDataQueue_Spontany,
-                        osMessageQueueId_t txDataQueue_Cyclic0,
-                        osMessageQueueId_t txDataQueue_Cyclic1
+                        tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
+                        tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
+                        tTaskSerialToCanSpontany *TaskSerialToCanSpontany
 
 );
 
@@ -103,24 +104,21 @@ void TaskSerialUSB_StartThread(tTaskSerial *env);
 
 
 void TaskSerialToCanCyclic0_Init(tTaskSerialToCanCyclic *env,
-                                 tSerialPortFrameIO *ioCAN,
-                                 osMessageQueueId_t txDataQueue
+                                 tSerialPortFrameIO *ioCAN
 );
 
 void TaskSerialToCanCyclic0_StartThread(tTaskSerialToCanCyclic *env);
 
 
 void TaskSerialToCanCyclic1_Init(tTaskSerialToCanCyclic *env,
-                                 tSerialPortFrameIO *ioCAN,
-                                 osMessageQueueId_t txDataQueue);
+                                 tSerialPortFrameIO *ioCAN);
 
 void TaskSerialToCanCyclic1_StartThread(tTaskSerialToCanCyclic *env);
 
 void TaskSerialToCanSpontany_Init(tTaskSerialToCanSpontany *env,
                                   tSerialPortFrameIO *ioCAN,
-                                  osMessageQueueId_t txDataQueue,
-                                  tAtCmd *At_UART,
-                                  tAtCmd *At_UART_USB
+                                  tSerialPortIO *ioUART,
+                                  tSerialPortIO *ioUSB
 
 );