// // Created by cfif on 13.03.2026. // #include "ArbiterCommand.h" #include "CmsisRtosThreadUtils.h" #include "SystemDelayInterface.h" #include "SerialPort.h" #include "AtCmdCommonProtected.h" #include "AsciiStringParsingUtils.h" #include "memory.h" #include #include "dig_pot.h" //начало ------------------------------Отправка без подтверждения------------------------------------------------------- //начало ------------------------------Отправка без подтверждения------------------------------------------------------- //начало ------------------------------Отправка без подтверждения------------------------------------------------------- void TaskSerialToCanCyclic0_Init(tTaskSerialToCanCyclic *env, tSerialPortFrameIO *ioCAN ) { env->ioCAN = ioCAN; env->txDataQueue = osMessageQueueNew(20, sizeof(can_rx_message_type), NULL); InitThreadAtrStatic(&env->thread.attr, "SerialCyclic", env->thread.controlBlock, env->thread.stack, osPriorityNormal); } static _Noreturn void Serial_ToCanCyclic0_Thread(tTaskSerialToCanCyclic *env) { for (;;) { 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); } } } } uint32_t GetCountQueueCanCyclic0(tTaskSerialToCanCyclic *env) { uint32_t count = 0; count = osMessageQueueGetCount(env->txDataQueue); return count; } osStatus_t PutQueueCanCyclic0(tTaskSerialToCanCyclic *env, can_rx_message_type *dataCan) { osStatus_t status = osErrorTimeout; status = osMessageQueuePut(env->txDataQueue, dataCan, 0x0, 0U); 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); } } //конец ------------------------------Отправка без подтверждения------------------------------------------------------- //конец ------------------------------Отправка без подтверждения------------------------------------------------------- //конец ------------------------------Отправка без подтверждения------------------------------------------------------- //начало ------------------------------Отправка без подтверждения------------------------------------------------------- //начало ------------------------------Отправка без подтверждения------------------------------------------------------- //начало ------------------------------Отправка без подтверждения------------------------------------------------------- void TaskSerialToCanCyclic1_Init(tTaskSerialToCanCyclic *env, tSerialPortFrameIO *ioCAN ) { env->ioCAN = ioCAN; env->txDataQueue = osMessageQueueNew(20, sizeof(can_rx_message_type), NULL); InitThreadAtrStatic(&env->thread.attr, "SerialCyclic", env->thread.controlBlock, env->thread.stack, osPriorityNormal); } static _Noreturn void Serial_ToCanCyclic1_Thread(tTaskSerialToCanCyclic *env) { for (;;) { 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); } } } } uint32_t GetCountQueueCanCyclic1(tTaskSerialToCanCyclic *env) { uint32_t count = 0; count = osMessageQueueGetCount(env->txDataQueue); return count; } osStatus_t PutQueueCanCyclic1(tTaskSerialToCanCyclic *env, can_rx_message_type *dataCan) { osStatus_t status = osErrorTimeout; status = osMessageQueuePut(env->txDataQueue, dataCan, 0x0, 0U); 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); } } //конец ------------------------------Отправка без подтверждения------------------------------------------------------- //конец ------------------------------Отправка без подтверждения------------------------------------------------------- //конец ------------------------------Отправка без подтверждения------------------------------------------------------- //начало ------------------------------Отправка с подтверждением------------------------------------------------------- //начало ------------------------------Отправка с подтверждением------------------------------------------------------- //начало ------------------------------Отправка с подтверждением------------------------------------------------------- void TaskSerialToCanSpontany_Init(tTaskSerialToCanSpontany *env, tSerialPortFrameIO *ioCAN, tSerialPortIO *ioUSB1, tSerialPortIO *ioUSB2 ) { env->ioCAN = ioCAN; env->ioUSB1 = ioUSB1; env->ioUSB2 = ioUSB2; env->txDataQueue = osMessageQueueNew(20, sizeof(can_rx_message_Spontany), NULL); InitThreadAtrStatic(&env->thread.attr, "SerialSpontany", env->thread.controlBlock, env->thread.stack, osPriorityNormal); } static _Noreturn void Serial_ToCanSpontany_Thread(tTaskSerialToCanSpontany *env) { for (;;) { 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_usb == FROM_USB1) { env->ioUSB1->transmit(env->ioUSB1->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000); } else { env->ioUSB2->transmit(env->ioUSB2->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000); } } else { 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->ioUSB2->transmit(env->ioUSB2->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n") - 1, 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_usb == FROM_USB1) { env->ioUSB1->transmit(env->ioUSB1->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000); } else { env->ioUSB2->transmit(env->ioUSB2->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000); } } else { 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->ioUSB2->transmit(env->ioUSB2->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n") - 1, 1000); } } } } } } osStatus_t PutQueueCanSpontany(tTaskSerialToCanSpontany *env, can_rx_message_Spontany *dataCan) { osStatus_t status = osErrorTimeout; status = osMessageQueuePut(env->txDataQueue, dataCan, 0x0, 0U); 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); } } //конец ------------------------------Отправка с подтверждением------------------------------------------------------- //конец ------------------------------Отправка с подтверждением------------------------------------------------------- //конец ------------------------------Отправка с подтверждением------------------------------------------------------- //начало ------------------------------Парсер команд-------------------------------------------------------------------- //начало ------------------------------Парсер команд-------------------------------------------------------------------- //начало ------------------------------Парсер команд-------------------------------------------------------------------- static bool setResistance(tTaskSerial *env, char *name, const TablePoint *table, int table_size, tSensorType sensorType, tSensorAdr sensorAdr1, tSensorAdr sensorAdr2) { char *start = env->At.rxBuffer.data + strlen(name); int16_t temperature = atoi(start); uint32_t resistance = get_resistance_by_temperature_linear(table, table_size, temperature); uint8_t step100; uint8_t step10; find_steps_for_resistance(resistance, &step100, &step10); step100 = 255 - step100; step10 = 255 - step10; bool result1 = setSpiSensor(env->sensorSPI, sensorType, sensorAdr1, step100); bool result2 = setSpiSensor(env->sensorSPI, sensorType, sensorAdr2, step10); if ((result1) && (result2)) { env->ioUSB->transmit(env->ioUSB->env, (uint8_t *) "OK\r\n", sizeof("OK\r\n") - 1, 1000); } else { env->ioUSB->transmit(env->ioUSB->env, (uint8_t *) "ERROR\r\n", sizeof("ERROR\r\n") - 1, 1000); } return (result1 && result2); } static bool setResistanceInit(tTaskSerial *env, char *name, int16_t temperature, const TablePoint *table, int table_size, tSensorType sensorType, tSensorAdr sensorAdr1, tSensorAdr sensorAdr2) { uint32_t resistance = get_resistance_by_temperature_linear(table, table_size, temperature); uint8_t step100; uint8_t step10; find_steps_for_resistance(resistance, &step100, &step10); step100 = 255 - step100; step10 = 255 - step10; bool result1 = setSpiSensor(env->sensorSPI, sensorType, sensorAdr1, step100); bool result2 = setSpiSensor(env->sensorSPI, sensorType, sensorAdr2, step10); return (result1 && result2); } // Коэффициенты перевода #define ATM_TO_KGF_CM2 1.033227f /** * @brief Рассчитать R1 по заданному давлению в атмосферах * * @param p_atm Давление в атмосферах (атм), при котором Vout = Vref * R1/(R1+R2) * @param r2 Нижний резистор делителя (Ом) * @param vref Опорное напряжение АЦП (В) * @param vdd Напряжение питания датчика (В) * @return float Сопротивление R1 (Ом), или 0.0f если делитель не нужен */ float calculate_r1_for_pressure_atm(float p_atm, float r2, float vref, float vdd) { // Переводим давление в кгс/см² float p_kgf = p_atm * ATM_TO_KGF_CM2; // Напряжение датчика при давлении P (в кгс/см²) float vsensor = vdd * (0.025f * p_kgf + 0.1f); // Проверка: Vref должно быть больше Vsensor if (vref <= vsensor) { return 0.0f; // Делитель не нужен или нужен усилитель } // Расчёт R1 float r1 = (r2 * vsensor) / (vref - vsensor); return r1; } static bool setPressure(tTaskSerial *env, char *name, tSensorType sensorType, tSensorAdr sensorAdr1, tSensorAdr sensorAdr2) { char *start = env->At.rxBuffer.data + strlen(name); int16_t pressure = atoi(start); uint32_t r1 = (uint32_t)calculate_r1_for_pressure_atm((float)pressure / 10, 51000.0f, 4.96f, 5.0f); uint8_t step100; uint8_t step10; find_steps_for_resistance(r1, &step100, &step10); step100 = 255 - step100; step10 = 255 - step10; bool result1 = setSpiSensor(env->sensorSPI, sensorType, sensorAdr1, step100); bool result2 = setSpiSensor(env->sensorSPI, sensorType, sensorAdr2, step10); return (result1 && result2); } static bool setPressureInit(tTaskSerial *env, char *name, int16_t pressure, tSensorType sensorType, tSensorAdr sensorAdr1, tSensorAdr sensorAdr2) { uint32_t r1 = (uint32_t)calculate_r1_for_pressure_atm((float)pressure / 10, 51000.0f, 4.96f, 5.0f); uint8_t step100; uint8_t step10; find_steps_for_resistance(r1, &step100, &step10); step100 = 255 - step100; step10 = 255 - step10; bool result1 = setSpiSensor(env->sensorSPI, sensorType, sensorAdr1, step100); bool result2 = setSpiSensor(env->sensorSPI, sensorType, sensorAdr2, step10); return (result1 && result2); } void SerialCommand_Scheduler(tTaskSerial *env) { osStatus_t status; while (AtCmdReceiveNextLine(&env->At, SystemWaitForever) == AT_OK) { if (AtCmdRxBeginWithStatic(&env->At, "T")) { uint8_t data[8]; memset(data, 0, sizeof(data)); uint8_t size = iAsciiStringParseHexBytes(data, &env->At.rxBuffer.data[1], 2); uint8_t opt = data[0]; size = iAsciiStringParseHexBytes(data, &env->At.rxBuffer.data[3], 2); uint8_t remote = data[0]; size = iAsciiStringParseHexBytes(data, &env->At.rxBuffer.data[5], 4); uint32_t adr = (data[0] << 8) | data[1]; uint8_t len = &env->At.rxBuffer.data[env->At.rxBuffer.len] - &env->At.rxBuffer.data[9] - 2; if (len > 16) { len = 16; } size = iAsciiStringParseHexBytes(data, &env->At.rxBuffer.data[9], len); can_rx_message_Spontany dataCan; 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; dataCan.can_rx_message.frame_type = remote; dataCan.can_rx_message.filter_index = 0; dataCan.can_rx_message.extended_id = 0; memcpy(dataCan.can_rx_message.data, data, size); if (opt) { status = PutQueueCanSpontany(env->TaskSerialToCanSpontany, &dataCan); } else { uint32_t count0 = GetCountQueueCanCyclic0(env->TaskSerialToCanCyclic0); uint32_t count1 = GetCountQueueCanCyclic1(env->TaskSerialToCanCyclic1); if (count0 <= count1) { status = PutQueueCanCyclic0(env->TaskSerialToCanCyclic0, &dataCan.can_rx_message); } else { status = PutQueueCanCyclic1(env->TaskSerialToCanCyclic1, &dataCan.can_rx_message); } } } if (AtCmdRxBeginWithStatic(&env->At, "t")) { uint8_t data[8]; memset(data, 0, sizeof(data)); uint8_t size = iAsciiStringParseHexBytes(data, &env->At.rxBuffer.data[1], 2); uint8_t opt = data[0]; size = iAsciiStringParseHexBytes(data, &env->At.rxBuffer.data[3], 2); uint8_t remote = data[0]; size = iAsciiStringParseHexBytes(data, &env->At.rxBuffer.data[5], 8); uint32_t adr = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | (data[3] << 0); uint8_t len = &env->At.rxBuffer.data[env->At.rxBuffer.len] - &env->At.rxBuffer.data[9] - 2; if (len > 16) { len = 16; } size = iAsciiStringParseHexBytes(data, &env->At.rxBuffer.data[9], len); can_rx_message_Spontany dataCan; 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; dataCan.can_rx_message.frame_type = remote; dataCan.can_rx_message.filter_index = 0; dataCan.can_rx_message.standard_id = 0; memcpy(dataCan.can_rx_message.data, data, size); if (opt) { status = PutQueueCanSpontany(env->TaskSerialToCanSpontany, &dataCan); } else { uint32_t count0 = GetCountQueueCanCyclic0(env->TaskSerialToCanCyclic0); uint32_t count1 = GetCountQueueCanCyclic1(env->TaskSerialToCanCyclic1); if (count0 <= count1) { status = PutQueueCanCyclic0(env->TaskSerialToCanCyclic0, &dataCan.can_rx_message); } else { status = PutQueueCanCyclic1(env->TaskSerialToCanCyclic1, &dataCan.can_rx_message); } } } if (AtCmdRxBeginWithStatic(&env->At, "V")) { env->ioUSB->transmit(env->ioUSB->env, (uint8_t *) "v001\r\nOK\r\n", sizeof("v001\r\nOK\r\n") - 1, 1000); } if (AtCmdRxBeginWithStatic(&env->At, "Duct_FL_Upper")) { setResistance(env, "Duct_FL_Upper", duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_1, SENSOR_ADR_2); } if (AtCmdRxBeginWithStatic(&env->At, "Duct_FR_Upper")) { setResistance(env, "Duct_FR_Upper", duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_3, SENSOR_ADR_4); } if (AtCmdRxBeginWithStatic(&env->At, "Duct_FL_Lower")) { setResistance(env, "Duct_FL_Lower", duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_5, SENSOR_ADR_6); } if (AtCmdRxBeginWithStatic(&env->At, "Duct_FR_Lower")) { setResistance(env, "Duct_FR_Lower", duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_7, SENSOR_ADR_8); } if (AtCmdRxBeginWithStatic(&env->At, "Duct_FL_Side")) { setResistance(env, "Duct_FL_Side", duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_9, SENSOR_ADR_10); } if (AtCmdRxBeginWithStatic(&env->At, "Duct_FR_Side")) { setResistance(env, "Duct_FR_Side", duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_11, SENSOR_ADR_12); } if (AtCmdRxBeginWithStatic(&env->At, "Eva_F")) { setResistance(env, "Eva_F", duct_lookup_table_20000, size_duct_lookup_table_20000, SENSOR_TYPE_A, SENSOR_ADR_13, SENSOR_ADR_14); } if (AtCmdRxBeginWithStatic(&env->At, "Duct_RL_Side")) { setResistance(env, "Duct_RL_Side", duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_B, SENSOR_ADR_5, SENSOR_ADR_6); continue; } if (AtCmdRxBeginWithStatic(&env->At, "Duct_RR_Side")) { setResistance(env, "Duct_RR_Side", duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_B, SENSOR_ADR_7, SENSOR_ADR_8); continue; } if (AtCmdRxBeginWithStatic(&env->At, "Duct_RL")) { setResistance(env, "Duct_RL", duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_B, SENSOR_ADR_1, SENSOR_ADR_2); } if (AtCmdRxBeginWithStatic(&env->At, "Duct_RR")) { setResistance(env, "Duct_RR", duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_B, SENSOR_ADR_3, SENSOR_ADR_4); } if (AtCmdRxBeginWithStatic(&env->At, "Eva_R")) { setResistance(env, "Eva_R", duct_lookup_table_20000, size_duct_lookup_table_20000, SENSOR_TYPE_B, SENSOR_ADR_9, SENSOR_ADR_10); } if (AtCmdRxBeginWithStatic(&env->At, "Incar_FL")) { setResistance(env, "Incar_FL", incar_lookup_table_20000, size_incar_lookup_table_20000, SENSOR_TYPE_D, SENSOR_ADR_1, SENSOR_ADR_2); } if (AtCmdRxBeginWithStatic(&env->At, "Incar_FL")) { setResistance(env, "Incar_FL", incar_lookup_table_20000, size_incar_lookup_table_20000, SENSOR_TYPE_D, SENSOR_ADR_5, SENSOR_ADR_6); } if (AtCmdRxBeginWithStatic(&env->At, "Incar_FR")) { setResistance(env, "Incar_FR", incar_lookup_table_20000, size_incar_lookup_table_20000, SENSOR_TYPE_D, SENSOR_ADR_3, SENSOR_ADR_4); } if (AtCmdRxBeginWithStatic(&env->At, "Incar_RR")) { setResistance(env, "Incar_RR", incar_lookup_table_20000, size_incar_lookup_table_20000, SENSOR_TYPE_D, SENSOR_ADR_7, SENSOR_ADR_8); } if (AtCmdRxBeginWithStatic(&env->At, "Pressure")) { setPressure(env, "Pressure", SENSOR_TYPE_D, SENSOR_ADR_9, SENSOR_ADR_10); } } } //конец ------------------------------Парсер команд-------------------------------------------------------------------- //конец ------------------------------Парсер команд-------------------------------------------------------------------- //конец ------------------------------Парсер команд-------------------------------------------------------------------- //начало ------------------------------Обработчик USB1 команд----------------------------------------------------------- //начало ------------------------------Обработчик USB1 команд----------------------------------------------------------- //начало ------------------------------Обработчик USB1 команд----------------------------------------------------------- void TaskSerialUSB1_Init(tTaskSerial *env, tFrom_usb from_usb, tSerialPortIO *ioUSB1, tTaskSerialToCanCyclic *TaskSerialToCanCyclic0, tTaskSerialToCanCyclic *TaskSerialToCanCyclic1, tTaskSerialToCanSpontany *TaskSerialToCanSpontany, tSensorSPI *sensorSPI ) { env->from_usb = from_usb; env->ioUSB = ioUSB1; env->sensorSPI = sensorSPI; env->TaskSerialToCanCyclic0 = TaskSerialToCanCyclic0; env->TaskSerialToCanCyclic1 = TaskSerialToCanCyclic1; env->TaskSerialToCanSpontany = TaskSerialToCanSpontany; SerialPortClearRxBuffer(env->ioUSB); AtCmdInit( &env->At, env->ioUSB, env->AtRx, sizeof(env->AtRx), env->AtTx, sizeof(env->AtTx), 2000, 2000 ); InitThreadAtrStatic(&env->thread.attr, "SerialUSB1", env->thread.controlBlock, env->thread.stack, osPriorityNormal); } static _Noreturn void Serial_USB1_Thread(tTaskSerial *env) { int16_t temperature = 300; int16_t pressure = 200; setResistanceInit(env, "Duct_FL_Upper", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_1, SENSOR_ADR_2); setResistanceInit(env, "Duct_FR_Upper", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_3, SENSOR_ADR_4); setResistanceInit(env, "Duct_FL_Lower", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_5, SENSOR_ADR_6); setResistanceInit(env, "Duct_FR_Lower", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_7, SENSOR_ADR_8); setResistanceInit(env, "Duct_FL_Side", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_9, SENSOR_ADR_10); setResistanceInit(env, "Duct_FR_Side", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_A, SENSOR_ADR_11, SENSOR_ADR_12); setResistanceInit(env, "Eva_F", temperature, duct_lookup_table_20000, size_duct_lookup_table_20000, SENSOR_TYPE_A, SENSOR_ADR_13, SENSOR_ADR_14); setResistanceInit(env, "Duct_RL_Side", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_B, SENSOR_ADR_5, SENSOR_ADR_6); setResistanceInit(env, "Duct_RR_Side", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_B, SENSOR_ADR_7, SENSOR_ADR_8); setResistanceInit(env, "Duct_RL", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_B, SENSOR_ADR_1, SENSOR_ADR_2); setResistanceInit(env, "Duct_RR", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_B, SENSOR_ADR_3, SENSOR_ADR_4); setResistanceInit(env, "Eva_R", temperature, duct_lookup_table_20000, size_duct_lookup_table_20000, SENSOR_TYPE_B, SENSOR_ADR_9, SENSOR_ADR_10); setResistanceInit(env, "Incar_FL", temperature, incar_lookup_table_20000, size_incar_lookup_table_20000, SENSOR_TYPE_D, SENSOR_ADR_1, SENSOR_ADR_2); setResistanceInit(env, "Incar_RL", temperature, incar_lookup_table_20000, size_incar_lookup_table_20000, SENSOR_TYPE_D, SENSOR_ADR_5, SENSOR_ADR_6); setResistanceInit(env, "Incar_FR", temperature, incar_lookup_table_20000, size_incar_lookup_table_20000, SENSOR_TYPE_D, SENSOR_ADR_3, SENSOR_ADR_4); setResistanceInit(env, "Incar_RR", temperature, incar_lookup_table_20000, size_incar_lookup_table_20000, SENSOR_TYPE_D, SENSOR_ADR_7, SENSOR_ADR_8); setPressureInit(env, "Pressure", pressure, SENSOR_TYPE_D, SENSOR_ADR_9, SENSOR_ADR_10); for (;;) { SerialCommand_Scheduler(env); SystemDelayMs(1); } } void TaskSerialUSB1_StartThread(tTaskSerial *env) { if (!env->thread.id) { env->thread.id = osThreadNew((osThreadFunc_t) (Serial_USB1_Thread), (void *) (env), &env->thread.attr); } } //конец ------------------------------Обработчик USB1 команд----------------------------------------------------------- //конец ------------------------------Обработчик USB1 команд----------------------------------------------------------- //конец ------------------------------Обработчик USB1 команд----------------------------------------------------------- //начало ------------------------------Обработчик USB2 команд------------------------------------------------------- //начало ------------------------------Обработчик USB2 команд------------------------------------------------------- //начало ------------------------------Обработчик USB2 команд------------------------------------------------------- void TaskSerialUSB2_Init(tTaskSerial *env, tFrom_usb from_usb, tSerialPortIO *ioUSB2, tTaskSerialToCanCyclic *TaskSerialToCanCyclic0, tTaskSerialToCanCyclic *TaskSerialToCanCyclic1, tTaskSerialToCanSpontany *TaskSerialToCanSpontany, tSensorSPI *sensorSPI ) { env->from_usb = from_usb; env->sensorSPI = sensorSPI; env->ioUSB = ioUSB2; env->TaskSerialToCanCyclic0 = TaskSerialToCanCyclic0; env->TaskSerialToCanCyclic1 = TaskSerialToCanCyclic1; env->TaskSerialToCanSpontany = TaskSerialToCanSpontany; SerialPortClearRxBuffer(env->ioUSB); AtCmdInit( &env->At, env->ioUSB, env->AtRx, sizeof(env->AtRx), env->AtTx, sizeof(env->AtTx), 2000, 2000 ); InitThreadAtrStatic(&env->thread.attr, "SerialUSB2", env->thread.controlBlock, env->thread.stack, osPriorityNormal); } static _Noreturn void Serial_USB2_Thread(tTaskSerial *env) { for (;;) { SerialCommand_Scheduler(env); SystemDelayMs(1); } } void TaskSerialUSB2_StartThread(tTaskSerial *env) { if (!env->thread.id) { env->thread.id = osThreadNew((osThreadFunc_t) (Serial_USB2_Thread), (void *) (env), &env->thread.attr); } } //конец ------------------------------Обработчик USB2 команд------------------------------------------------------- //конец ------------------------------Обработчик USB2 команд------------------------------------------------------- //конец ------------------------------Обработчик USB2 команд------------------------------------------------------- void toAddPrefixStr(char *out, char *in, size_t len) { if (len <= strlen(in)) { out[0] = '\0'; strcat(out, in); return; } size_t countPrefix = len - strlen(in); for (size_t i = 0; i < countPrefix; ++i) out[i] = '0'; out[countPrefix] = '\0'; strcat(out, in); } void SerialReceivedCommand_Scheduler(tTaskReceivedSerial *env) { uint16_t recv; 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) { strcat(env->text, "T"); // команда strcat(env->text, "00"); // Без ожидания OK strcat(env->text, "00"); // признак команда (00) utoa(env->canFrame.standard_id, env->buf, 16); toAddPrefixStr(env->bufWithPrefix, env->buf, 4); strcat(env->text, env->bufWithPrefix); // Адрес for (uint8_t i = 0; i < env->canFrame.dlc; ++i) { utoa(env->canFrame.data[i], env->buf, 16); toAddPrefixStr(env->bufWithPrefix, env->buf, 2); strcat(env->text, env->bufWithPrefix); // Адрес } strcat(env->text, "\r\n"); // CR } else { strcat(env->text, "t"); // команда strcat(env->text, "00"); // Без ожидания OK strcat(env->text, "00"); // признак команда (00) utoa(env->canFrame.extended_id, env->buf, 16); toAddPrefixStr(env->bufWithPrefix, env->buf, 8); strcat(env->text, env->bufWithPrefix); // Адрес for (uint8_t i = 0; i < env->canFrame.dlc; ++i) { utoa(env->canFrame.data[i], env->buf, 16); toAddPrefixStr(env->bufWithPrefix, env->buf, 2); strcat(env->text, env->bufWithPrefix); // Адрес } strcat(env->text, "\r\n"); // CR } env->ioUSB->transmit(env->ioUSB->env, (uint8_t *) env->text, strlen(env->text), 1000); } } //начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд----------------------------------------------------------- //начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд----------------------------------------------------------- //начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд----------------------------------------------------------- void Task_RECEIVED_SerialUSB1_Init(tTaskReceivedSerial *env, tSerialPortFrameIO *ioCAN, tFrom_usb from_usb1, tSerialPortIO *ioUSB1) { // env->access = osMutexNew(NULL); env->from_usb = from_usb1; env->ioUSB = ioUSB1; env->ioCAN = ioCAN; SerialPortClearRxBuffer(env->ioUSB); InitThreadAtrStatic(&env->thread.attr, "SerialReceivedCanUSB1", env->thread.controlBlock, env->thread.stack, osPriorityNormal); } static _Noreturn void Serial_RECEIVED_USB1_Thread(tTaskReceivedSerial *env) { for (;;) { // if (osMutexAcquire(env->access, 1000) == osOK) { SerialReceivedCommand_Scheduler(env); // osMutexRelease(env->access); // } SystemDelayMs(1); } } void Task_RECEIVED_SerialUSB1_StartThread(tTaskReceivedSerial *env) { if (!env->thread.id) { env->thread.id = osThreadNew((osThreadFunc_t) (Serial_RECEIVED_USB1_Thread), (void *) (env), &env->thread.attr); } } //конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд----------------------------------------------------------- //конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд----------------------------------------------------------- //конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB1 команд----------------------------------------------------------- //начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд------------------------------------------------------- //начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд------------------------------------------------------- //начало ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд------------------------------------------------------- void Task_RECEIVED_SerialUSB2_Init(tTaskReceivedSerial *env, tSerialPortFrameIO *ioCAN, tFrom_usb from_usb2, tSerialPortIO *ioUSB2) { // env->access = osMutexNew(NULL); env->from_usb = from_usb2; env->ioUSB = ioUSB2; env->ioCAN = ioCAN; SerialPortClearRxBuffer(env->ioUSB); InitThreadAtrStatic(&env->thread.attr, "SerialReceivedCanUSB2", env->thread.controlBlock, env->thread.stack, osPriorityNormal); } static _Noreturn void Serial_RECEIVED_USB2_Thread(tTaskReceivedSerial *env) { for (;;) { // if (osMutexAcquire(env->access, 1000) == osOK) { SerialReceivedCommand_Scheduler(env); // osMutexRelease(env->access); // } SystemDelayMs(1); } } void Task_RECEIVED_SerialUSB2_StartThread(tTaskReceivedSerial *env) { if (!env->thread.id) { env->thread.id = osThreadNew((osThreadFunc_t) (Serial_RECEIVED_USB2_Thread), (void *) (env), &env->thread.attr); } } //конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд------------------------------------------------------- //конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд------------------------------------------------------- //конец ------------------------------Обработчик очереди ВХОДЯЩИХ USB2 команд-------------------------------------------------------