933 lines
37 KiB
C
933 lines
37 KiB
C
//
|
||
// 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 <stdlib.h>
|
||
#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);
|
||
continue;
|
||
}
|
||
|
||
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);
|
||
continue;
|
||
}
|
||
|
||
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);
|
||
continue;
|
||
}
|
||
|
||
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);
|
||
continue;
|
||
}
|
||
|
||
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);
|
||
continue;
|
||
}
|
||
|
||
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);
|
||
continue;
|
||
}
|
||
|
||
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);
|
||
continue;
|
||
}
|
||
|
||
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_1, SENSOR_ADR_2);
|
||
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_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_3, SENSOR_ADR_4);
|
||
continue;
|
||
}
|
||
|
||
if (AtCmdRxBeginWithStatic(&env->At, "Duct_RR")) {
|
||
setResistance(env, "Duct_RR", duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_B,
|
||
SENSOR_ADR_7, SENSOR_ADR_8);
|
||
continue;
|
||
}
|
||
|
||
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_RL")) {
|
||
setResistance(env, "Incar_RL", 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 = 250;
|
||
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_1,
|
||
SENSOR_ADR_2);
|
||
setResistanceInit(env, "Duct_RR_Side", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000,
|
||
SENSOR_TYPE_B,
|
||
SENSOR_ADR_3,
|
||
SENSOR_ADR_4);
|
||
setResistanceInit(env, "Duct_RL", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_B,
|
||
SENSOR_ADR_5,
|
||
SENSOR_ADR_6);
|
||
setResistanceInit(env, "Duct_RR", temperature, duct_lookup_table_3000, size_duct_lookup_table_3000, SENSOR_TYPE_B,
|
||
SENSOR_ADR_7,
|
||
SENSOR_ADR_8);
|
||
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 команд-------------------------------------------------------
|