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

Init

This commit is contained in:
cfif 2026-05-07 16:20:45 +03:00
parent 88c1a4cf57
commit d699af1211
2 changed files with 148 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
ArbiterCommand.c
View File

@ -188,16 +188,16 @@ void TaskSerialToCanCyclic1_StartThread(tTaskSerialToCanCyclic *env) {
void TaskSerialToCanSpontany_Init(tTaskSerialToCanSpontany *env,
tSerialPortFrameIO *ioCAN,
tSerialPortIO *ioUART,
tSerialPortIO *ioUSB
tSerialPortIO *ioUSB1,
tSerialPortIO *ioUSB2
) {
// env->access = osMutexNew(NULL);
env->ioCAN = ioCAN;
env->ioUART = ioUART;
env->ioUSB = ioUSB;
env->ioUSB1 = ioUSB1;
env->ioUSB2 = ioUSB2;
env->txDataQueue = osMessageQueueNew(20, sizeof(can_rx_message_Spontany), NULL);
@ -219,16 +219,16 @@ static _Noreturn void Serial_ToCanSpontany_Thread(tTaskSerialToCanSpontany *env)
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") - 1, 1000);
if (data.from_usb == FROM_USB1) {
env->ioUSB1->transmit(env->ioUSB1->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000);
} else {
env->ioUSB->transmit(env->ioUSB->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000);
env->ioUSB2->transmit(env->ioUSB2->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000);
}
} else {
if (data.from_uart == FROM_UART) {
env->ioUART->transmit(env->ioUART->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n") - 1, 1000);
if (data.from_usb == FROM_USB1) {
env->ioUSB1->transmit(env->ioUSB1->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n") - 1, 1000);
} else {
env->ioUSB->transmit(env->ioUSB->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n") - 1, 1000);
env->ioUSB2->transmit(env->ioUSB2->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n") - 1, 1000);
}
}
@ -238,16 +238,16 @@ static _Noreturn void Serial_ToCanSpontany_Thread(tTaskSerialToCanSpontany *env)
1000);
if (sent) {
if (data.from_uart == FROM_UART) {
env->ioUART->transmit(env->ioUART->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000);
if (data.from_usb == FROM_USB1) {
env->ioUSB1->transmit(env->ioUSB1->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000);
} else {
env->ioUSB->transmit(env->ioUSB->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000);
env->ioUSB2->transmit(env->ioUSB2->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000);
}
} else {
if (data.from_uart == FROM_UART) {
env->ioUART->transmit(env->ioUART->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n") - 1, 1000);
if (data.from_usb == FROM_USB1) {
env->ioUSB1->transmit(env->ioUSB1->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n") - 1, 1000);
} else {
env->ioUSB->transmit(env->ioUSB->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n") - 1, 1000);
env->ioUSB2->transmit(env->ioUSB2->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n") - 1, 1000);
}
}
@ -316,7 +316,7 @@ void SerialCommand_Scheduler(tTaskSerial *env) {
can_rx_message_Spontany dataCan;
dataCan.from_uart = env->from_uart;
dataCan.from_usb = env->from_usb;
dataCan.can_rx_message.dlc = size;
dataCan.can_rx_message.id_type = CAN_ID_STANDARD;
dataCan.can_rx_message.standard_id = adr;
@ -366,7 +366,7 @@ void SerialCommand_Scheduler(tTaskSerial *env) {
size = iAsciiStringParseHexBytes(data, &env->At.rxBuffer.data[9], len);
can_rx_message_Spontany dataCan;
dataCan.from_uart = env->from_uart;
dataCan.from_usb = env->from_usb;
dataCan.can_rx_message.dlc = size;
dataCan.can_rx_message.id_type = CAN_ID_EXTENDED;
dataCan.can_rx_message.extended_id = adr;
@ -393,8 +393,8 @@ void SerialCommand_Scheduler(tTaskSerial *env) {
}
if (AtCmdRxBeginWithStatic(&env->At, "V")) {
env->ioUART->transmit(env->ioUART->env, (uint8_t *) "v001\r\n", sizeof("v001\r\n") - 1, 1000);
env->ioUART->transmit(env->ioUART->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000);
env->ioUSB->transmit(env->ioUSB->env, (uint8_t *) "v001\r\n", sizeof("v001\r\n") - 1, 1000);
env->ioUSB->transmit(env->ioUSB->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000);
}
}
@ -406,13 +406,13 @@ void SerialCommand_Scheduler(tTaskSerial *env) {
//начало ------------------------------Обработчик UART команд-----------------------------------------------------------
//начало ------------------------------Обработчик UART команд-----------------------------------------------------------
//начало ------------------------------Обработчик UART команд-----------------------------------------------------------
//начало ------------------------------Обработчик USB1 команд-----------------------------------------------------------
//начало ------------------------------Обработчик USB1 команд-----------------------------------------------------------
//начало ------------------------------Обработчик USB1 команд-----------------------------------------------------------
void TaskSerialUART_Init(tTaskSerial *env,
tFrom_uart from_uart,
tSerialPortIO *ioUART,
void TaskSerialUSB1_Init(tTaskSerial *env,
tFrom_usb from_usb,
tSerialPortIO *ioUSB1,
tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
tTaskSerialToCanSpontany *TaskSerialToCanSpontany
@ -420,28 +420,28 @@ void TaskSerialUART_Init(tTaskSerial *env,
) {
// env->access = osMutexNew(NULL);
env->from_uart = from_uart;
env->from_usb = from_usb;
env->ioUART = ioUART;
env->ioUSB = ioUSB1;
env->TaskSerialToCanCyclic0 = TaskSerialToCanCyclic0;
env->TaskSerialToCanCyclic1 = TaskSerialToCanCyclic1;
env->TaskSerialToCanSpontany = TaskSerialToCanSpontany;
SerialPortClearRxBuffer(env->ioUART);
SerialPortClearRxBuffer(env->ioUSB);
AtCmdInit(
&env->At, env->ioUART,
&env->At, env->ioUSB,
env->AtRx, sizeof(env->AtRx),
env->AtTx, sizeof(env->AtTx),
2000, 2000
);
InitThreadAtrStatic(&env->thread.attr, "SerialUART", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
InitThreadAtrStatic(&env->thread.attr, "SerialUSB1", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
}
static _Noreturn void Serial_UART_Thread(tTaskSerial *env) {
static _Noreturn void Serial_USB1_Thread(tTaskSerial *env) {
for (;;) {
// if (osMutexAcquire(env->access, 1000) == osOK) {
@ -455,52 +455,52 @@ static _Noreturn void Serial_UART_Thread(tTaskSerial *env) {
}
}
void TaskSerialUART_StartThread(tTaskSerial *env) {
void TaskSerialUSB1_StartThread(tTaskSerial *env) {
if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Serial_UART_Thread), (void *) (env), &env->thread.attr);
env->thread.id = osThreadNew((osThreadFunc_t) (Serial_USB1_Thread), (void *) (env), &env->thread.attr);
}
}
//конец ------------------------------Обработчик UART команд-----------------------------------------------------------
//конец ------------------------------Обработчик UART команд-----------------------------------------------------------
//конец ------------------------------Обработчик UART команд-----------------------------------------------------------
//конец ------------------------------Обработчик USB1 команд-----------------------------------------------------------
//конец ------------------------------Обработчик USB1 команд-----------------------------------------------------------
//конец ------------------------------Обработчик USB1 команд-----------------------------------------------------------
//начало ------------------------------Обработчик UART USB команд-------------------------------------------------------
//начало ------------------------------Обработчик UART USB команд-------------------------------------------------------
//начало ------------------------------Обработчик UART USB команд-------------------------------------------------------
//начало ------------------------------Обработчик USB2 команд-------------------------------------------------------
//начало ------------------------------Обработчик USB2 команд-------------------------------------------------------
//начало ------------------------------Обработчик USB2 команд-------------------------------------------------------
void TaskSerialUSB_Init(tTaskSerial *env,
tFrom_uart from_uart,
tSerialPortIO *ioUART,
void TaskSerialUSB2_Init(tTaskSerial *env,
tFrom_usb from_usb,
tSerialPortIO *ioUSB2,
tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
tTaskSerialToCanSpontany *TaskSerialToCanSpontany
) {
// env->access = osMutexNew(NULL);
env->from_uart = from_uart;
env->from_usb = from_usb;
env->ioUART = ioUART;
env->ioUSB = ioUSB2;
env->TaskSerialToCanCyclic0 = TaskSerialToCanCyclic0;
env->TaskSerialToCanCyclic1 = TaskSerialToCanCyclic1;
env->TaskSerialToCanSpontany = TaskSerialToCanSpontany;
SerialPortClearRxBuffer(env->ioUART);
SerialPortClearRxBuffer(env->ioUSB);
AtCmdInit(
&env->At, env->ioUART,
&env->At, env->ioUSB,
env->AtRx, sizeof(env->AtRx),
env->AtTx, sizeof(env->AtTx),
2000, 2000
);
InitThreadAtrStatic(&env->thread.attr, "SerialUSB", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
InitThreadAtrStatic(&env->thread.attr, "SerialUSB2", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
}
static _Noreturn void Serial_USB_Thread(tTaskSerial *env) {
static _Noreturn void Serial_USB2_Thread(tTaskSerial *env) {
for (;;) {
// if (osMutexAcquire(env->access, 1000) == osOK) {
@ -514,15 +514,15 @@ static _Noreturn void Serial_USB_Thread(tTaskSerial *env) {
}
}
void TaskSerialUSB_StartThread(tTaskSerial *env) {
void TaskSerialUSB2_StartThread(tTaskSerial *env) {
if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Serial_USB_Thread), (void *) (env), &env->thread.attr);
env->thread.id = osThreadNew((osThreadFunc_t) (Serial_USB2_Thread), (void *) (env), &env->thread.attr);
}
}
//конец ------------------------------Обработчик UART USB команд-------------------------------------------------------
//конец ------------------------------Обработчик UART USB команд-------------------------------------------------------
//конец ------------------------------Обработчик UART USB команд-------------------------------------------------------
//конец ------------------------------Обработчик USB2 команд-------------------------------------------------------
//конец ------------------------------Обработчик USB2 команд-------------------------------------------------------
//конец ------------------------------Обработчик USB2 команд-------------------------------------------------------
@ -548,13 +548,15 @@ void toAddPrefixStr(char *out, char *in, size_t len) {
void SerialReceivedCommand_Scheduler(tTaskReceivedSerial *env) {
uint16_t recv;
if (env->from_uart == FROM_UART) {
if (env->from_usb == FROM_USB1) {
recv = env->ioCAN->receive0(env->ioCAN->env, (uint8_t *) &env->canFrame, 1, 1000);
} else {
recv = env->ioCAN->receive1(env->ioCAN->env, (uint8_t *) &env->canFrame, 1, 1000);
}
if (recv > 0) {
env->text[0] = '\0';
if (env->canFrame.id_type == CAN_ID_STANDARD) {
@ -591,33 +593,34 @@ void SerialReceivedCommand_Scheduler(tTaskReceivedSerial *env) {
strcat(env->text, "\r\n"); // CR
}
env->ioUART->transmit(env->ioUART->env, (uint8_t *)env->text, strlen(env->text), 1000);
env->ioUSB->transmit(env->ioUSB->env, (uint8_t *) env->text, strlen(env->text), 1000);
}
}
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ UART команд-----------------------------------------------------------
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ UART команд-----------------------------------------------------------
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ UART команд-----------------------------------------------------------
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд-----------------------------------------------------------
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд-----------------------------------------------------------
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд-----------------------------------------------------------
void Task_RECEIVED_SerialUART_Init(tTaskReceivedSerial *env,
void Task_RECEIVED_SerialUSB1_Init(tTaskReceivedSerial *env,
tSerialPortFrameIO *ioCAN,
tFrom_uart from_uart,
tSerialPortIO *ioUART) {
tFrom_usb from_usb1,
tSerialPortIO *ioUSB1) {
// env->access = osMutexNew(NULL);
env->from_uart = from_uart;
env->ioUART = ioUART;
env->from_usb = from_usb1;
env->ioUSB = ioUSB1;
env->ioCAN = ioCAN;
SerialPortClearRxBuffer(env->ioUART);
SerialPortClearRxBuffer(env->ioUSB);
InitThreadAtrStatic(&env->thread.attr, "SerialReceivedCanUART", env->thread.controlBlock, env->thread.stack,
InitThreadAtrStatic(&env->thread.attr, "SerialReceivedCanUSB1", env->thread.controlBlock, env->thread.stack,
osPriorityNormal);
}
static _Noreturn void Serial_RECEIVED_UART_Thread(tTaskReceivedSerial *env) {
static _Noreturn void Serial_RECEIVED_USB1_Thread(tTaskReceivedSerial *env) {
for (;;) {
// if (osMutexAcquire(env->access, 1000) == osOK) {
@ -631,39 +634,39 @@ static _Noreturn void Serial_RECEIVED_UART_Thread(tTaskReceivedSerial *env) {
}
}
void Task_RECEIVED_SerialUART_StartThread(tTaskReceivedSerial *env) {
void Task_RECEIVED_SerialUSB1_StartThread(tTaskReceivedSerial *env) {
if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Serial_RECEIVED_UART_Thread), (void *) (env), &env->thread.attr);
env->thread.id = osThreadNew((osThreadFunc_t) (Serial_RECEIVED_USB1_Thread), (void *) (env), &env->thread.attr);
}
}
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ UART команд-----------------------------------------------------------
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ UART команд-----------------------------------------------------------
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ UART команд-----------------------------------------------------------
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд-----------------------------------------------------------
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд-----------------------------------------------------------
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд-----------------------------------------------------------
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ UART USB команд-------------------------------------------------------
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ UART USB команд-------------------------------------------------------
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ UART USB команд-------------------------------------------------------
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд-------------------------------------------------------
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд-------------------------------------------------------
//начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд-------------------------------------------------------
void Task_RECEIVED_SerialUSB_Init(tTaskReceivedSerial *env,
void Task_RECEIVED_SerialUSB2_Init(tTaskReceivedSerial *env,
tSerialPortFrameIO *ioCAN,
tFrom_uart from_uart,
tSerialPortIO *ioUART) {
tFrom_usb from_usb2,
tSerialPortIO *ioUSB2) {
// env->access = osMutexNew(NULL);
env->from_uart = from_uart;
env->ioUART = ioUART;
env->from_usb = from_usb2;
env->ioUSB= ioUSB2;
env->ioCAN = ioCAN;
SerialPortClearRxBuffer(env->ioUART);
SerialPortClearRxBuffer(env->ioUSB);
InitThreadAtrStatic(&env->thread.attr, "SerialReceivedCanUSB", env->thread.controlBlock, env->thread.stack,
InitThreadAtrStatic(&env->thread.attr, "SerialReceivedCanUSB2", env->thread.controlBlock, env->thread.stack,
osPriorityNormal);
}
static _Noreturn void Serial_RECEIVED_USB_Thread(tTaskReceivedSerial *env) {
static _Noreturn void Serial_RECEIVED_USB2_Thread(tTaskReceivedSerial *env) {
for (;;) {
// if (osMutexAcquire(env->access, 1000) == osOK) {
@ -677,12 +680,12 @@ static _Noreturn void Serial_RECEIVED_USB_Thread(tTaskReceivedSerial *env) {
}
}
void Task_RECEIVED_SerialUSB_StartThread(tTaskReceivedSerial *env) {
void Task_RECEIVED_SerialUSB2_StartThread(tTaskReceivedSerial *env) {
if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Serial_RECEIVED_USB_Thread), (void *) (env), &env->thread.attr);
env->thread.id = osThreadNew((osThreadFunc_t) (Serial_RECEIVED_USB2_Thread), (void *) (env), &env->thread.attr);
}
}
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ UART USB команд-------------------------------------------------------
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ UART USB команд-------------------------------------------------------
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ UART USB команд-------------------------------------------------------
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд-------------------------------------------------------
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд-------------------------------------------------------
//конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд-------------------------------------------------------

56
ArbiterCommand.h
View File

@ -12,9 +12,9 @@
typedef enum {
FROM_UART,
FROM_UART_USB
} tFrom_uart;
FROM_USB1,
FROM_USB2
} tFrom_usb;
typedef struct {
@ -34,7 +34,7 @@ typedef struct {
typedef struct {
can_rx_message_type can_rx_message;
tFrom_uart from_uart;
tFrom_usb from_usb;
} can_rx_message_Spontany;
typedef struct {
@ -43,8 +43,8 @@ typedef struct {
// osMutexId_t access;
osMessageQueueId_t txDataQueue;
tSerialPortIO *ioUART;
tSerialPortIO *ioUSB;
tSerialPortIO *ioUSB1;
tSerialPortIO *ioUSB2;
struct {
osThreadId_t id;
@ -62,8 +62,8 @@ typedef struct {
uint8_t AtRx[255];
uint8_t AtTx[255];
tSerialPortIO *ioUART;
tFrom_uart from_uart;
tSerialPortIO *ioUSB;
tFrom_usb from_usb;
// osMutexId_t access;
tTaskSerialToCanCyclic *TaskSerialToCanCyclic0;
@ -84,8 +84,8 @@ typedef struct {
typedef struct {
tSerialPortFrameIO *ioCAN;
tSerialPortIO *ioUART;
tFrom_uart from_uart;
tSerialPortIO *ioUSB;
tFrom_usb from_usb;
// osMutexId_t access;
can_rx_message_type canFrame;
@ -104,26 +104,26 @@ typedef struct {
} tTaskReceivedSerial;
void TaskSerialUART_Init(tTaskSerial *env,
tFrom_uart from_uart,
tSerialPortIO *ioUART,
void TaskSerialUSB1_Init(tTaskSerial *env,
tFrom_usb from_usb,
tSerialPortIO *ioUSB1,
tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
tTaskSerialToCanSpontany *TaskSerialToCanSpontany
);
void TaskSerialUART_StartThread(tTaskSerial *env);
void TaskSerialUSB1_StartThread(tTaskSerial *env);
void TaskSerialUSB_Init(tTaskSerial *env,
tFrom_uart from_uart,
tSerialPortIO *ioUART,
void TaskSerialUSB2_Init(tTaskSerial *env,
tFrom_usb from_usb,
tSerialPortIO *ioUSB2,
tTaskSerialToCanCyclic *TaskSerialToCanCyclic0,
tTaskSerialToCanCyclic *TaskSerialToCanCyclic1,
tTaskSerialToCanSpontany *TaskSerialToCanSpontany
);
void TaskSerialUSB_StartThread(tTaskSerial *env);
void TaskSerialUSB2_StartThread(tTaskSerial *env);
void TaskSerialToCanCyclic0_Init(tTaskSerialToCanCyclic *env,
@ -140,8 +140,8 @@ void TaskSerialToCanCyclic1_StartThread(tTaskSerialToCanCyclic *env);
void TaskSerialToCanSpontany_Init(tTaskSerialToCanSpontany *env,
tSerialPortFrameIO *ioCAN,
tSerialPortIO *ioUART,
tSerialPortIO *ioUSB
tSerialPortIO *ioUSB1,
tSerialPortIO *ioUSB2
);
@ -152,21 +152,21 @@ void TaskSerialToCanSpontany_StartThread(tTaskSerialToCanSpontany *env);
void Task_RECEIVED_SerialUART_Init(tTaskReceivedSerial *env,
void Task_RECEIVED_SerialUSB1_Init(tTaskReceivedSerial *env,
tSerialPortFrameIO *ioCAN,
tFrom_uart from_uart,
tSerialPortIO *ioUART);
tFrom_usb from_usb1,
tSerialPortIO *ioUSB1);
void Task_RECEIVED_SerialUART_StartThread(tTaskReceivedSerial *env);
void Task_RECEIVED_SerialUSB1_StartThread(tTaskReceivedSerial *env);
void Task_RECEIVED_SerialUSB_Init(tTaskReceivedSerial *env,
void Task_RECEIVED_SerialUSB2_Init(tTaskReceivedSerial *env,
tSerialPortFrameIO *ioCAN,
tFrom_uart from_uart,
tSerialPortIO *ioUART);
tFrom_usb from_usb2,
tSerialPortIO *ioUSB2);
void Task_RECEIVED_SerialUSB_StartThread(tTaskReceivedSerial *env);
void Task_RECEIVED_SerialUSB2_StartThread(tTaskReceivedSerial *env);