HVAC_DEV
/
HVAC_DEV_ArbiterCommand
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Начало

This commit is contained in:
cfif 2026-03-24 12:19:49 +03:00
parent cde6f62063
commit 2b4d9cd832
2 changed files with 207 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

278
ArbiterCommand.c
View File

@ -9,7 +9,7 @@
#include "AsciiStringParsingUtils.h" #include "AsciiStringParsingUtils.h"
#include "memory.h" #include "memory.h"
/*
void sendOk(tAtCmd *AtCmd) { void sendOk(tAtCmd *AtCmd) {
AtCmdPrepare(AtCmd); AtCmdPrepare(AtCmd);
AtCmdTxClear(AtCmd); AtCmdTxClear(AtCmd);
@ -33,7 +33,7 @@ void sendVers(tAtCmd *AtCmd) {
AtCmdTxSendLn(AtCmd); AtCmdTxSendLn(AtCmd);
AtCmdRxClear(AtCmd); AtCmdRxClear(AtCmd);
} }
*/
//начало ------------------------------Отправка без подтверждения------------------------------------------------------- //начало ------------------------------Отправка без подтверждения-------------------------------------------------------
@ -41,13 +41,12 @@ void sendVers(tAtCmd *AtCmd) {
//начало ------------------------------Отправка без подтверждения------------------------------------------------------- //начало ------------------------------Отправка без подтверждения-------------------------------------------------------
void TaskSerialToCanCyclic0_Init(tTaskSerialToCanCyclic *env, void TaskSerialToCanCyclic0_Init(tTaskSerialToCanCyclic *env,
tSerialPortFrameIO *ioCAN, tSerialPortFrameIO *ioCAN
osMessageQueueId_t txDataQueue
) { ) {
env->access = osMutexNew(NULL); // env->access = osMutexNew(NULL);
env->ioCAN = ioCAN; 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, InitThreadAtrStatic(&env->thread.attr, "SerialCyclic", env->thread.controlBlock, env->thread.stack,
osPriorityNormal); osPriorityNormal);
@ -57,25 +56,48 @@ void TaskSerialToCanCyclic0_Init(tTaskSerialToCanCyclic *env,
static _Noreturn void Serial_ToCanCyclic0_Thread(tTaskSerialToCanCyclic *env) { static _Noreturn void Serial_ToCanCyclic0_Thread(tTaskSerialToCanCyclic *env) {
for (;;) { for (;;) {
if (osMutexAcquire(env->access, 1000) == osOK) { // if (osMutexAcquire(env->access, 1000) == osOK) {
can_rx_message_type data; can_rx_message_type data;
if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) { if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) {
if (data.id_type == CAN_ID_STANDARD) { 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, uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.standard_id, 0, 0,
1000); 1000);
} else { } else {
uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.extended_id, 1, 0, uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.extended_id, 1, 0,
1000); 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) { void TaskSerialToCanCyclic0_StartThread(tTaskSerialToCanCyclic *env) {
if (!env->thread.id) { if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Serial_ToCanCyclic0_Thread), (void *) (env), &env->thread.attr); 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, void TaskSerialToCanCyclic1_Init(tTaskSerialToCanCyclic *env,
tSerialPortFrameIO *ioCAN, tSerialPortFrameIO *ioCAN
osMessageQueueId_t txDataQueue
) { ) {
env->access = osMutexNew(NULL); // env->access = osMutexNew(NULL);
env->ioCAN = ioCAN; 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, InitThreadAtrStatic(&env->thread.attr, "SerialCyclic", env->thread.controlBlock, env->thread.stack,
osPriorityNormal); osPriorityNormal);
@ -108,25 +129,47 @@ void TaskSerialToCanCyclic1_Init(tTaskSerialToCanCyclic *env,
static _Noreturn void Serial_ToCanCyclic1_Thread(tTaskSerialToCanCyclic *env) { static _Noreturn void Serial_ToCanCyclic1_Thread(tTaskSerialToCanCyclic *env) {
for (;;) { for (;;) {
if (osMutexAcquire(env->access, 1000) == osOK) { // if (osMutexAcquire(env->access, 1000) == osOK) {
can_rx_message_type data; can_rx_message_type data;
if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) { if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) {
if (data.id_type == CAN_ID_STANDARD) { 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, uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.standard_id, 0, 1,
1000); 1000);
} else { } else {
uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.extended_id, 1, 1, uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.data, data.dlc, data.extended_id, 1, 1,
1000); 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) { void TaskSerialToCanCyclic1_StartThread(tTaskSerialToCanCyclic *env) {
if (!env->thread.id) { if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Serial_ToCanCyclic1_Thread), (void *) (env), &env->thread.attr); 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, void TaskSerialToCanSpontany_Init(tTaskSerialToCanSpontany *env,
tSerialPortFrameIO *ioCAN, tSerialPortFrameIO *ioCAN,
osMessageQueueId_t txDataQueue, tSerialPortIO *ioUART,
tAtCmd *At_UART, tSerialPortIO *ioUSB
tAtCmd *At_UART_USB
) { ) {
env->access = osMutexNew(NULL); // env->access = osMutexNew(NULL);
env->ioCAN = ioCAN; env->ioCAN = ioCAN;
env->At_UART = At_UART; env->ioUART = ioUART;
env->At_UART_USB = At_UART_USB; 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, InitThreadAtrStatic(&env->thread.attr, "SerialSpontany", env->thread.controlBlock, env->thread.stack,
osPriorityNormal); osPriorityNormal);
@ -166,56 +208,67 @@ void TaskSerialToCanSpontany_Init(tTaskSerialToCanSpontany *env,
static _Noreturn void Serial_ToCanSpontany_Thread(tTaskSerialToCanSpontany *env) { static _Noreturn void Serial_ToCanSpontany_Thread(tTaskSerialToCanSpontany *env) {
for (;;) { for (;;) {
if (osMutexAcquire(env->access, 1000) == osOK) { // if (osMutexAcquire(env->access, 1000) == osOK) {
can_rx_message_Spontany data; can_rx_message_Spontany data;
if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) { if (osMessageQueueGet(env->txDataQueue, &data, NULL, 1000) == osOK) {
if (data.can_rx_message.id_type == CAN_ID_STANDARD) { if (data.can_rx_message.id_type == CAN_ID_STANDARD) {
uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.can_rx_message.data, 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, data.can_rx_message.dlc, data.can_rx_message.standard_id, 0, 2,
1000); 1000);
if (sent) { if (sent) {
if (data.from_uart == FROM_UART) { if (data.from_uart == FROM_UART) {
sendOk(env->At_UART); env->ioUART->transmit(env->ioUART->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n"), 1000);
} else {
sendOk(env->At_UART_USB);
}
} else { } else {
if (data.from_uart == FROM_UART) { env->ioUART->transmit(env->ioUSB->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n"), 1000);
sendError(env->At_UART);
} else {
sendError(env->At_UART_USB);
}
} }
} else { } else {
uint16_t sent = env->ioCAN->transmit(env->ioCAN->env, data.can_rx_message.data, if (data.from_uart == FROM_UART) {
data.can_rx_message.dlc, data.can_rx_message.extended_id, 1, 2, env->ioUART->transmit(env->ioUART->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n"), 1000);
1000);
if (sent) {
if (data.from_uart == FROM_UART) {
sendOk(env->At_UART);
} else {
sendOk(env->At_UART_USB);
}
} else { } else {
if (data.from_uart == FROM_UART) { env->ioUART->transmit(env->ioUSB->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n"), 1000);
sendError(env->At_UART);
} else {
sendError(env->At_UART_USB);
}
} }
} }
}
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) { void TaskSerialToCanSpontany_StartThread(tTaskSerialToCanSpontany *env) {
if (!env->thread.id) { if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Serial_ToCanSpontany_Thread), (void *) (env), &env->thread.attr); 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); memcpy(dataCan.can_rx_message.data, data, size);
if (opt) { if (opt) {
status = osMessageQueuePut(env->txDataQueue_Spontany, &dataCan, 0x0, 0U);
status = PutQueueCanSpontany(env->TaskSerialToCanSpontany, &dataCan);
} else { } else {
uint32_t count0 = osMessageQueueGetCount(env->txDataQueue_Cyclic0); uint32_t count0 = GetCountQueueCanCyclic0(env->TaskSerialToCanCyclic0);
uint32_t count1 = osMessageQueueGetCount(env->txDataQueue_Cyclic1); uint32_t count1 = GetCountQueueCanCyclic1(env->TaskSerialToCanCyclic1);
if (count0 <= count1) { if (count0 <= count1) {
status = osMessageQueuePut(env->txDataQueue_Cyclic0, &dataCan.can_rx_message, 0x0, 0U); status = PutQueueCanCyclic0(env->TaskSerialToCanCyclic0, &dataCan.can_rx_message);
} else { } 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); memcpy(dataCan.can_rx_message.data, data, size);
if (opt) { if (opt) {
status = osMessageQueuePut(env->txDataQueue_Spontany, &dataCan, 0x0, 0U);
status = PutQueueCanSpontany(env->TaskSerialToCanSpontany, &dataCan);
} else { } else {
uint32_t count0 = osMessageQueueGetCount(env->txDataQueue_Cyclic0); uint32_t count0 = GetCountQueueCanCyclic0(env->TaskSerialToCanCyclic0);
uint32_t count1 = osMessageQueueGetCount(env->txDataQueue_Cyclic1); uint32_t count1 = GetCountQueueCanCyclic1(env->TaskSerialToCanCyclic1);
if (count0 <= count1) { if (count0 <= count1) {
status = osMessageQueuePut(env->txDataQueue_Cyclic0, &dataCan.can_rx_message, 0x0, 0U); status = PutQueueCanCyclic0(env->TaskSerialToCanCyclic0, &dataCan.can_rx_message);
} else { } 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")) { if (AtCmdRxBeginWithStatic(&env->At, "V")) {
sendVers(&env->At); env->ioUART->transmit(env->ioUART->env, (uint8_t *) "v001\r\n", sizeof("v001\r\n"), 1000);
sendOk(&env->At); 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, void TaskSerialUART_Init(tTaskSerial *env,
tFrom_uart from_uart, tFrom_uart from_uart,
tSerialPortIO *ioUART, tSerialPortIO *ioUART,
osMessageQueueId_t txDataQueue_Cyclic0, tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
osMessageQueueId_t txDataQueue_Cyclic1, tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
osMessageQueueId_t txDataQueue_Spontany tTaskSerialToCanSpontany *TaskSerialToCanSpontany
) { ) {
env->access = osMutexNew(NULL); // env->access = osMutexNew(NULL);
env->from_uart = from_uart; env->from_uart = from_uart;
env->ioUART = ioUART; env->ioUART = ioUART;
env->txDataQueue_Cyclic0 = txDataQueue_Cyclic0; env->TaskSerialToCanCyclic0 = TaskSerialToCanCyclic0;
env->txDataQueue_Cyclic1 = txDataQueue_Cyclic1; env->TaskSerialToCanCyclic1 = TaskSerialToCanCyclic1;
env->txDataQueue_Spontany = txDataQueue_Spontany; env->TaskSerialToCanSpontany = TaskSerialToCanSpontany;
SerialPortClearRxBuffer(env->ioUART); SerialPortClearRxBuffer(env->ioUART);
@ -387,12 +443,12 @@ void TaskSerialUART_Init(tTaskSerial *env,
static _Noreturn void Serial_UART_Thread(tTaskSerial *env) { static _Noreturn void Serial_UART_Thread(tTaskSerial *env) {
for (;;) { for (;;) {
if (osMutexAcquire(env->access, 1000) == osOK) { // if (osMutexAcquire(env->access, 1000) == osOK) {
SerialCommand_Scheduler(env); SerialCommand_Scheduler(env);
osMutexRelease(env->access); // osMutexRelease(env->access);
} // }
SystemDelayMs(1); SystemDelayMs(1);
} }
@ -416,19 +472,19 @@ void TaskSerialUART_StartThread(tTaskSerial *env) {
void TaskSerialUSB_Init(tTaskSerial *env, void TaskSerialUSB_Init(tTaskSerial *env,
tFrom_uart from_uart, tFrom_uart from_uart,
tSerialPortIO *ioUART, tSerialPortIO *ioUART,
osMessageQueueId_t txDataQueue_Spontany, tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
osMessageQueueId_t txDataQueue_Cyclic0, tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
osMessageQueueId_t txDataQueue_Cyclic1 tTaskSerialToCanSpontany *TaskSerialToCanSpontany
) { ) {
env->access = osMutexNew(NULL); // env->access = osMutexNew(NULL);
env->from_uart = from_uart; env->from_uart = from_uart;
env->ioUART = ioUART; env->ioUART = ioUART;
env->txDataQueue_Spontany = txDataQueue_Spontany; env->TaskSerialToCanCyclic0 = TaskSerialToCanCyclic0;
env->txDataQueue_Cyclic0 = txDataQueue_Cyclic0; env->TaskSerialToCanCyclic1 = TaskSerialToCanCyclic1;
env->txDataQueue_Cyclic1 = txDataQueue_Cyclic1; env->TaskSerialToCanSpontany = TaskSerialToCanSpontany;
SerialPortClearRxBuffer(env->ioUART); SerialPortClearRxBuffer(env->ioUART);
@ -446,12 +502,12 @@ void TaskSerialUSB_Init(tTaskSerial *env,
static _Noreturn void Serial_USB_Thread(tTaskSerial *env) { static _Noreturn void Serial_USB_Thread(tTaskSerial *env) {
for (;;) { for (;;) {
if (osMutexAcquire(env->access, 1000) == osOK) { // if (osMutexAcquire(env->access, 1000) == osOK) {
SerialCommand_Scheduler(env); SerialCommand_Scheduler(env);
osMutexRelease(env->access); // osMutexRelease(env->access);
} // }
SystemDelayMs(1); SystemDelayMs(1);
} }

82
ArbiterCommand.h
View File

@ -10,40 +10,16 @@
#include "AtCmdCommon.h" #include "AtCmdCommon.h"
#include "CanSerialPortFrame.h" #include "CanSerialPortFrame.h"
typedef enum { typedef enum {
FROM_UART, FROM_UART,
FROM_UART_USB FROM_UART_USB
} tFrom_uart; } 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 { typedef struct {
tSerialPortFrameIO *ioCAN; tSerialPortFrameIO *ioCAN;
osMutexId_t access; // osMutexId_t access;
osMessageQueueId_t txDataQueue; osMessageQueueId_t txDataQueue;
struct { struct {
@ -64,11 +40,11 @@ typedef struct {
typedef struct { typedef struct {
tSerialPortFrameIO *ioCAN; tSerialPortFrameIO *ioCAN;
osMutexId_t access; // osMutexId_t access;
osMessageQueueId_t txDataQueue; osMessageQueueId_t txDataQueue;
tAtCmd *At_UART; tSerialPortIO *ioUART;
tAtCmd *At_UART_USB; tSerialPortIO *ioUSB;
struct { struct {
osThreadId_t id; osThreadId_t id;
@ -80,12 +56,37 @@ typedef struct {
} tTaskSerialToCanSpontany; } 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, void TaskSerialUART_Init(tTaskSerial *env,
tFrom_uart from_uart, tFrom_uart from_uart,
tSerialPortIO *ioUART, tSerialPortIO *ioUART,
osMessageQueueId_t txDataQueue_Spontany, tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
osMessageQueueId_t txDataQueue_Cyclic0, tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
osMessageQueueId_t txDataQueue_Cyclic1 tTaskSerialToCanSpontany *TaskSerialToCanSpontany
); );
void TaskSerialUART_StartThread(tTaskSerial *env); void TaskSerialUART_StartThread(tTaskSerial *env);
@ -93,9 +94,9 @@ void TaskSerialUART_StartThread(tTaskSerial *env);
void TaskSerialUSB_Init(tTaskSerial *env, void TaskSerialUSB_Init(tTaskSerial *env,
tFrom_uart from_uart, tFrom_uart from_uart,
tSerialPortIO *ioUART, tSerialPortIO *ioUART,
osMessageQueueId_t txDataQueue_Spontany, tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
osMessageQueueId_t txDataQueue_Cyclic0, tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
osMessageQueueId_t txDataQueue_Cyclic1 tTaskSerialToCanSpontany *TaskSerialToCanSpontany
); );
@ -103,24 +104,21 @@ void TaskSerialUSB_StartThread(tTaskSerial *env);
void TaskSerialToCanCyclic0_Init(tTaskSerialToCanCyclic *env, void TaskSerialToCanCyclic0_Init(tTaskSerialToCanCyclic *env,
tSerialPortFrameIO *ioCAN, tSerialPortFrameIO *ioCAN
osMessageQueueId_t txDataQueue
); );
void TaskSerialToCanCyclic0_StartThread(tTaskSerialToCanCyclic *env); void TaskSerialToCanCyclic0_StartThread(tTaskSerialToCanCyclic *env);
void TaskSerialToCanCyclic1_Init(tTaskSerialToCanCyclic *env, void TaskSerialToCanCyclic1_Init(tTaskSerialToCanCyclic *env,
tSerialPortFrameIO *ioCAN, tSerialPortFrameIO *ioCAN);
osMessageQueueId_t txDataQueue);
void TaskSerialToCanCyclic1_StartThread(tTaskSerialToCanCyclic *env); void TaskSerialToCanCyclic1_StartThread(tTaskSerialToCanCyclic *env);
void TaskSerialToCanSpontany_Init(tTaskSerialToCanSpontany *env, void TaskSerialToCanSpontany_Init(tTaskSerialToCanSpontany *env,
tSerialPortFrameIO *ioCAN, tSerialPortFrameIO *ioCAN,
osMessageQueueId_t txDataQueue, tSerialPortIO *ioUART,
tAtCmd *At_UART, tSerialPortIO *ioUSB
tAtCmd *At_UART_USB
); );