diff --git a/ECU/Application/Inc/CANdler.h b/ECU/Application/Inc/CANdler.h index 47cb01326..b48062d06 100644 --- a/ECU/Application/Inc/CANdler.h +++ b/ECU/Application/Inc/CANdler.h @@ -1,6 +1,7 @@ #include #include +#include "CubeCAN.h" #include "GRCAN_BUS_ID.h" #include "GRCAN_CUSTOM_ID.h" #include "GRCAN_MSG_ID.h" @@ -10,6 +11,8 @@ #ifndef CANDLER_H #define CANDLER_H +void CANdler_Callback(const CubeCAN_Config_Context *const context, const CAN_Identifier *const identifier, const uint8_t *const data, const uint8_t size); + void ECU_CAN_MessageHandler(ECU_StateData *state_data, GRCAN_BUS_ID bus_id, GRCAN_MSG_ID msg_id, GRCAN_NODE_ID sender_id, uint8_t *data, uint32_t data_length); void ECU_CAN_DTI_MessageHandler(ECU_StateData *state_data, GRCAN_CUSTOM_ID id, uint8_t *data, uint32_t data_length); diff --git a/ECU/Application/Inc/CANutils.h b/ECU/Application/Inc/CANutils.h index ebe084970..f504be666 100644 --- a/ECU/Application/Inc/CANutils.h +++ b/ECU/Application/Inc/CANutils.h @@ -12,7 +12,7 @@ #define ECU_STATE_DATA_SEND_INTERVAL_MS 20 void ECU_CAN_Send(GRCAN_BUS_ID bus, GRCAN_NODE_ID destNode, GRCAN_MSG_ID messageID, void *data, uint32_t size); void ECU_CAN_Send_DTI(GRCAN_CUSTOM_ID msgID, void *data, uint32_t size); -void SendECUStateDataOverCAN(const ECU_StateData *stateData); -void SendECUAnalogDataOverCAN(const ECU_StateData *stateData); -void SendECUConfigOverCAN(const ECU_StateData *stateData); +// void SendECUStateDataOverCAN(const ECU_StateData *stateData); +// void SendECUAnalogDataOverCAN(const ECU_StateData *stateData); +// void SendECUConfigOverCAN(const ECU_StateData *stateData); #endif diff --git a/ECU/Application/Inc/CubeCAN_Config.h b/ECU/Application/Inc/CubeCAN_Config.h new file mode 100644 index 000000000..8400416d1 --- /dev/null +++ b/ECU/Application/Inc/CubeCAN_Config.h @@ -0,0 +1,8 @@ +#ifndef CUBE_CAN_CONFIG_H +#define CUBE_CAN_CONFIG_H + +#define CUBEMX_CAN_TX_QUEUE_SIZE 16U +#define CUBEMX_CAN_MAX_INSTANCES 3U +#define ECU_CAN_MAX_DATA_BYTES 64 // Replacing FDCAN_MAX_DATA_BYTES macro since can.h doesnt exist anymore + +#endif diff --git a/ECU/Application/Inc/StateData.h b/ECU/Application/Inc/StateData.h index 0cd60783f..e9fdacc01 100644 --- a/ECU/Application/Inc/StateData.h +++ b/ECU/Application/Inc/StateData.h @@ -1,9 +1,9 @@ #include #include +#include "CubeCAN.h" #include "GRCAN_MSG_DATA.h" #include "StateMachine.h" -#include "can.h" #ifndef _STATEDATA_H_ #define _STATEDATA_H_ @@ -124,8 +124,8 @@ typedef volatile struct ECU_StateData { GR_ECU_State ecu_state; - CANHandle *primary_can; - CANHandle *data_can; + CubeCAN_Handle *data_can; + CubeCAN_Handle *primary_can; } ECU_StateData; #endif diff --git a/ECU/Application/Inc/StateTicks.h b/ECU/Application/Inc/StateTicks.h index 636cd77a1..aa293e572 100644 --- a/ECU/Application/Inc/StateTicks.h +++ b/ECU/Application/Inc/StateTicks.h @@ -1,13 +1,13 @@ +#include "CubeCAN.h" #include "StateData.h" #include "StateMachine.h" #include "adc.h" -#include "can.h" #ifndef _STATE_TICKS_H_ #define _STATE_TICKS_H_ -extern CANHandle *primary_can; -extern CANHandle *data_can; +extern CubeCAN_Handle *primary_can; +extern CubeCAN_Handle *data_can; /** * @brief Tick function for the ECU state machine. diff --git a/ECU/Application/Src/CANdler.c b/ECU/Application/Src/CANdler.c index cd1bd97d7..e2f849edc 100644 --- a/ECU/Application/Src/CANdler.c +++ b/ECU/Application/Src/CANdler.c @@ -3,6 +3,7 @@ #include #include +#include "CubeCAN.h" #include "GRCAN_BUS_ID.h" #include "GRCAN_CUSTOM_ID.h" #include "GRCAN_MSG_ID.h" @@ -12,6 +13,8 @@ #include "StateData.h" #include "bitManipulations.h" +extern ECU_StateData stateLump; + #define WHEEL_RADIUS_INCHES 8.0f #define WHEEL_CIRCUMFERENCE_INCHES (2.0f * (float)M_PI * WHEEL_RADIUS_INCHES) #define WHEEL_RPM_TO_MPH_RATIO (WHEEL_CIRCUMFERENCE_INCHES / 63360.0f * 60.0f) @@ -24,7 +27,7 @@ void ReportBadMessageLength(GRCAN_BUS_ID bus_id, GRCAN_MSG_ID msg_id, GRCAN_NODE { // TODO Ideally change some state data to note a bad message, ie if ACU // that can be a comms error - LOGOMATIC("Bad ECU CAN Rx length! Bus: %d, Msg: %X, Sender: %X\n", bus_id, msg_id, sender_id); + LOGOMATIC_ERROR("Bad ECU CAN Rx length! Bus: %d, Msg: %X, Sender: %X\n", bus_id, msg_id, sender_id); } void ReportUnhandledMessage(GRCAN_BUS_ID bus_id, GRCAN_MSG_ID msg_id, GRCAN_NODE_ID sender_id) @@ -33,7 +36,7 @@ void ReportUnhandledMessage(GRCAN_BUS_ID bus_id, GRCAN_MSG_ID msg_id, GRCAN_NODE UNUSED(bus_id); UNUSED(msg_id); UNUSED(sender_id); - // LOGOMATIC("Unhandled ECU CAN Rx msg! Bus: %d, Msg: %X, Sender: %X\n", bus_id, msg_id, sender_id); + LOGOMATIC_ERROR("Unhandled ECU CAN Rx msg! Bus: %d, Msg: %X, Sender: %X\n", bus_id, msg_id, sender_id); } void ECU_CAN_MessageHandler(ECU_StateData *state_data, GRCAN_BUS_ID bus_id, GRCAN_MSG_ID msg_id, GRCAN_NODE_ID sender_id, uint8_t *data, uint32_t data_length) @@ -44,7 +47,7 @@ void ECU_CAN_MessageHandler(ECU_StateData *state_data, GRCAN_BUS_ID bus_id, GRCA ReportBadMessageLength(bus_id, msg_id, sender_id); break; } - LOGOMATIC("Received from %02X on bus %d: %.*s\n", sender_id, bus_id, (int)data_length, data); + LOGOMATIC_INFO("Received from %02X on bus %d: %.*s\n", sender_id, bus_id, (int)data_length, data); break; case GRCAN_DEBUG_FD: @@ -52,7 +55,7 @@ void ECU_CAN_MessageHandler(ECU_StateData *state_data, GRCAN_BUS_ID bus_id, GRCA ReportBadMessageLength(bus_id, msg_id, sender_id); break; } - LOGOMATIC("Received from %02X on bus %d: %.*s\n", sender_id, bus_id, (int)data_length, data); + LOGOMATIC_ERROR("Received from %02X on bus %d: %.*s\n", sender_id, bus_id, (int)data_length, data); break; case GRCAN_PING: @@ -112,8 +115,8 @@ void ECU_CAN_MessageHandler(ECU_StateData *state_data, GRCAN_BUS_ID bus_id, GRCA } GRCAN_DASH_STATUS_MSG *dash_data = (GRCAN_DASH_STATUS_MSG *)data; - LOGOMATIC("Dash button flags: TS Press %d | TS Hold %d | RTD Press %d | RTD Hold %d\n", dash_data->button_flags & 1, (dash_data->button_flags >> 2) & 1, - (dash_data->button_flags >> 1) & 1, (dash_data->button_flags >> 3) & 1); + LOGOMATIC_INFO("Dash button flags: TS Press %d | TS Hold %d | RTD Press %d | RTD Hold %d\n", dash_data->button_flags & 1, (dash_data->button_flags >> 2) & 1, + (dash_data->button_flags >> 1) & 1, (dash_data->button_flags >> 3) & 1); // LET IT BE KNOWN: these things are LSB FIRST, TODO: I'll get it right later if (state_data->ecu_state == GR_GLV_ON) { @@ -183,3 +186,24 @@ void ECU_CAN_DTI_MessageHandler(ECU_StateData *state_data, GRCAN_CUSTOM_ID id, u break; } } + +void CANdler_Callback(const CubeCAN_Config_Context *const context, const CAN_Identifier *const identifier, const uint8_t *const data, const uint8_t size) +{ + + if (context == NULL || identifier == NULL || data == NULL || size == 0) { + LOGOMATIC_ERROR("CANdler_Callback: Invalid parameters received. context: %p, identifier: %p, data: %p, size: %u\n", (void *const)context, (void *const)identifier, (void *const)data, + size); + return; + } + + const GRCAN_BUS_ID bus_id = context->busid_user_context; + const GRCAN_NODE_ID sender_id = identifier->tx_node_id; + const GRCAN_MSG_ID msg_id = identifier->msg_id; + + if (msg_id == (GRCAN_MSG_ID)DTI_DATA_1_CAN_ID) { + ECU_CAN_DTI_MessageHandler(&stateLump, (GRCAN_CUSTOM_ID)msg_id, (uint8_t *)data, size); + return; + } + + ECU_CAN_MessageHandler(&stateLump, bus_id, msg_id, sender_id, (uint8_t *)data, size); +} diff --git a/ECU/Application/Src/CANutils.c b/ECU/Application/Src/CANutils.c index 0e340fee8..b1a50a9f6 100644 --- a/ECU/Application/Src/CANutils.c +++ b/ECU/Application/Src/CANutils.c @@ -2,6 +2,7 @@ #include +#include "CubeCAN.h" #include "GRCAN_BUS_ID.h" #include "GRCAN_CUSTOM_ID.h" #include "GRCAN_MSG_ID.h" @@ -10,7 +11,6 @@ #include "StateData.h" #include "StateTicks.h" #include "StateUtils.h" -#include "can.h" #include "main.h" #include "stm32g4xx_hal_fdcan.h" #include "string.h" @@ -19,155 +19,205 @@ extern ECU_StateData stateLump; uint32_t lastTickECUStateDataSent = 0; +// FIXME: Help double check this is correct, current no build errors on debug + void ECU_CAN_Send(GRCAN_BUS_ID bus, GRCAN_NODE_ID destNode, GRCAN_MSG_ID messageID, void *data, uint32_t size) { - if (size > FDCAN_MAX_DATA_BYTES) { - size = FDCAN_MAX_DATA_BYTES; - LOGOMATIC("Tried to send more than 64 bytes over CAN\n"); - } - - uint32_t ID = ((0xFF & GRCAN_ECU) << 20) | ((0xFFF & messageID) << 8) | (0xFF & destNode); - - FDCAN_TxHeaderTypeDef header = { - .Identifier = ID, - .IdType = FDCAN_EXTENDED_ID, - .TxFrameType = FDCAN_DATA_FRAME, - .ErrorStateIndicator = FDCAN_ESI_ACTIVE, - .DataLength = BytesToCANDLC(size), - .BitRateSwitch = FDCAN_BRS_OFF, - .TxEventFifoControl = FDCAN_NO_TX_EVENTS, - .FDFormat = (bus == GRCAN_BUS_PRIMARY) ? FDCAN_CLASSIC_CAN : FDCAN_FD_CAN, - .MessageMarker = 0, - }; - - FDCANTxMessage msg = {0}; - msg.tx_header = header; - - memcpy(&(msg.data), data, size); + CubeCAN_Handle *handle = NULL; switch (bus) { case GRCAN_BUS_PRIMARY: - can_enqueue(stateLump.primary_can, &msg); + handle = stateLump.primary_can; break; case GRCAN_BUS_DATA: - can_enqueue(stateLump.data_can, &msg); + handle = stateLump.data_can; break; default: - LOGOMATIC("CAN: Invalid bus ID %d\n", bus); - break; + LOGOMATIC_ERROR("CAN: Invalid bus ID %d \n", bus); + return; } -} - -// TODO: If you try to send anything but control messages, you are cooked buddy -// Doesn't actually use Motorola order for multiple fields, just sends the bytes in reverse order -void ECU_CAN_Send_DTI(GRCAN_CUSTOM_ID msgID, void *data, uint32_t size) -{ - // if ((MSG_DTI_CONTROL_10 & 0xFF) != 0x16) { - // LOGOMATIC("NOT A DTI MESSAGE"); - // } - - FDCAN_TxHeaderTypeDef TxHeader = { - .IdType = FDCAN_EXTENDED_ID, - .TxFrameType = FDCAN_DATA_FRAME, - .ErrorStateIndicator = FDCAN_ESI_ACTIVE, // honestly this might be a value you have to read from a node - // FDCAN_ESI_ACTIVE is just a state that assumes there are minimal errors - .BitRateSwitch = FDCAN_BRS_OFF, - .TxEventFifoControl = FDCAN_NO_TX_EVENTS, // change to FDCAN_STORE_TX_EVENTS if you need to store info regarding transmitted messages - .MessageMarker = 0 // also change this to a real address if you change fifo control - }; - - TxHeader.Identifier = msgID; - TxHeader.DataLength = size; - - TxHeader.FDFormat = FDCAN_CLASSIC_CAN; - FDCANTxMessage msg = {0}; - msg.tx_header = TxHeader; - - uint8_t temp; - for (uint32_t i = 0; i < size / 2; ++i) { - temp = ((uint8_t *)data)[i]; - ((uint8_t *)data)[i] = ((uint8_t *)data)[size - i - 1]; - ((uint8_t *)data)[size - i - 1] = temp; + if (handle == NULL) { + LOGOMATIC_ERROR("CAN: handle is NULL for bus %d\n", bus); + return; } - memcpy(&(msg.data), data, size); + if (size > ECU_CAN_MAX_DATA_BYTES) { + LOGOMATIC_WARNING("Tried to send more than 64 bytes over CAN\n"); + size = ECU_CAN_MAX_DATA_BYTES; + } - // can_send(primary_can, &msg); - can_enqueue(stateLump.primary_can, &msg); + CubeCAN_Send(handle, destNode, messageID, data, (uint8_t)size); } -void SendECUStateDataOverCAN(const ECU_StateData *stateData) +void ECU_CAN_Send_DTI(GRCAN_CUSTOM_ID msgID, void *data, uint32_t size) { - uint32_t currentTime = MillisecondsSinceBoot(); - - if (lastTickECUStateDataSent > currentTime - ECU_STATE_DATA_SEND_INTERVAL_MS) { + if (stateLump.primary_can == NULL) { + LOGOMATIC_ERROR("CAN: primary handle is NULL\n"); return; } - lastTickECUStateDataSent = currentTime; - - ECU_StateDataToSend messages = {.ECUState = stateData->ecu_state, - .StatusBits = {stateData->status_bits[0], stateData->status_bits[1], stateData->status_bits[2]}, - .PowerLevelTorqueMap = (stateData->powerlevel << 4) | (stateData->torquemap & 0x0F), - .MaxCellTemp = (uint8_t)(stateData->max_cell_temp_c * 4), - .AccumulatorStateOfCharge = (uint8_t)(stateData->tractivebattery_soc), - .GLVStateOfCharge = (uint8_t)(stateData->glv_soc), - .TractiveSystemVoltage = (uint16_t)(stateData->ts_voltage * 100), - .VehicleSpeed = (uint16_t)(stateData->vehicle_speed_mph * 100), - .FRWheelRPM = (uint16_t)(stateData->fr_wheel_rpm * 10 + 32768), - .FLWheelRPM = (uint16_t)(stateData->fl_wheel_rpm * 10 + 32768), - .RRWheelRPM = (uint16_t)(stateData->rr_wheel_rpm * 10 + 32768), - .RLWheelRPM = (uint16_t)(stateData->rl_wheel_rpm * 10 + 32768)}; - - ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ALL, GRCAN_ECU_STATUS_1, (void *)&messages.ECUStatusMsgOne, sizeof(messages.ECUStatusMsgOne)); - ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ALL, GRCAN_ECU_STATUS_2, (void *)&messages.ECUStatusMsgTwo, sizeof(messages.ECUStatusMsgTwo)); - ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ALL, GRCAN_ECU_STATUS_3, (void *)&messages.ECUStatusMsgThree, sizeof(messages.ECUStatusMsgThree)); - - SendECUConfigOverCAN(stateData); -} - -void SendECUAnalogDataOverCAN(const ECU_StateData *stateData) -{ - uint32_t millis_since_boot = MillisecondsSinceBoot(); - - static uint32_t last_can_tcm_request_millis = 0; - if (millis_since_boot - last_can_tcm_request_millis > 30) { - GRCAN_ECU_ANALOG_DATA_MSG message = {.bspd_signal = stateData->bspd_signal, - .bse_signal = stateData->bse_signal, - .apps_1_signal = stateData->APPS1_Signal, - .apps_2_signal = stateData->APPS2_Signal, - .brakeline_f_signal = stateData->Brake_F_Signal, - .brakeline_r_signal = stateData->Brake_R_Signal, - .steering_angle_signal = stateData->steering_angle_signal, - .aux_signal = stateData->aux_signal, - .acc_pedal_travel = CalcAccPedalTravel(stateData) * 65535, - .brake_pedal_pressure = CalcBrakePressure(stateData)}; - ECU_CAN_Send(GRCAN_BUS_DATA, GRCAN_TCM, GRCAN_ECU_ANALOG_DATA, &message, sizeof(message)); - last_can_tcm_request_millis = millis_since_boot; + uint8_t *msg = (uint8_t *)data; + for (uint32_t i = 0; i < size / 2; ++i) { + uint8_t temp = msg[i]; + msg[i] = msg[size - i - 1]; + msg[size - i - 1] = temp; } -} -void SendECUConfigOverCAN(const ECU_StateData *stateData) -{ - GRCAN_ECU_CONFIG_MSG message = {.ping_timeout_delay = (uint8_t)(stateData->ping_timeout_delay_ms / 10.0f), - .brake_f_min = (uint8_t)(stateData->brake_f_min / 25.0f), - .brake_r_min = (uint8_t)(stateData->brake_r_min / 25.0f), - .brake_bse_min = (uint8_t)(stateData->brake_bse_min / 25.0f), - .apps_1_min = (uint8_t)(stateData->apps_1_min / 10.0f), - .apps_2_min = (uint8_t)(stateData->apps_2_min / 10.0f), - .apps_1_max = (uint8_t)(stateData->apps_1_max / 10.0f), - .apps_2_max = (uint8_t)(stateData->apps_2_max / 10), - .apps_deadzone = (uint8_t)(stateData->apps_deadzone * 25.5f), - .bms_min_threshold = (uint8_t)(stateData->bms_min_thresh * 20.0f), - .bms_max_threshold = (uint8_t)(stateData->bms_max_thresh * 20.0f), - .imd_min_threshold = (uint8_t)(stateData->imd_min_thresh * 20.0f), - .imd_max_threshold = (uint8_t)(stateData->imd_max_thresh * 20.0f), - .bspd_min_threshold = (uint8_t)(stateData->bspd_min_thresh * 20.0f), - .bspd_max_threshold = (uint8_t)(stateData->bspd_max_thresh * 20.0f), - .max_precharge_time = (uint8_t)(stateData->max_precharge_time_ms / 10), - .regen_strength = (uint8_t)(stateData->regen_strength * 10), - .enable_regen = stateData->enable_regen}; - - ECU_CAN_Send(GRCAN_BUS_DATA, GRCAN_TCM, GRCAN_ECU_CONFIG, &message, sizeof(message)); + CubeCAN_Send(stateLump.primary_can, GRCAN_ALL, (GRCAN_MSG_ID)msgID, msg, (uint8_t)size); } + +// Didnt want to delete this in case the change I made aren't necessary + +// void ECU_CAN_Send(GRCAN_BUS_ID bus, GRCAN_NODE_ID destNode, GRCAN_MSG_ID messageID, void *data, uint32_t size) +// { +// if (size > FDCAN_MAX_DATA_BYTES) { +// size = FDCAN_MAX_DATA_BYTES; +// LOGOMATIC_ERROR("Tried to send more than 64 bytes over CAN\n"); +// } + +// uint32_t ID = ((0xFF & GRCAN_ECU) << 20) | ((0xFFF & messageID) << 8) | (0xFF & destNode); + +// FDCAN_TxHeaderTypeDef header = { +// .Identifier = ID, +// .IdType = FDCAN_EXTENDED_ID, +// .TxFrameType = FDCAN_DATA_FRAME, +// .ErrorStateIndicator = FDCAN_ESI_ACTIVE, +// .DataLength = BytesToCANDLC(size), +// .BitRateSwitch = FDCAN_BRS_OFF, +// .TxEventFifoControl = FDCAN_NO_TX_EVENTS, +// .FDFormat = (bus == GRCAN_BUS_PRIMARY) ? FDCAN_CLASSIC_CAN : FDCAN_FD_CAN, +// .MessageMarker = 0, +// }; + +// FDCANTxMessage msg = {0}; +// msg.tx_header = header; + +// memcpy(&(msg.data), data, size); + +// switch (bus) { +// case GRCAN_BUS_PRIMARY: +// can_enqueue(stateLump.primary_can, &msg); +// break; +// case GRCAN_BUS_DATA: +// can_enqueue(stateLump.data_can, &msg); +// break; +// default: +// LOGOMATIC_ERROR("CAN: Invalid bus ID %d\n", bus); +// break; +// } +// } + +// // TODO: If you try to send anything but control messages, you are cooked buddy +// // Doesn't actually use Motorola order for multiple fields, just sends the bytes in reverse order +// void ECU_CAN_Send_DTI(GRCAN_CUSTOM_ID msgID, void *data, uint32_t size) +// { +// // if ((MSG_DTI_CONTROL_10 & 0xFF) != 0x16) { +// // LOGOMATIC("NOT A DTI MESSAGE"); +// // } + +// FDCAN_TxHeaderTypeDef TxHeader = { +// .IdType = FDCAN_EXTENDED_ID, +// .TxFrameType = FDCAN_DATA_FRAME, +// .ErrorStateIndicator = FDCAN_ESI_ACTIVE, // honestly this might be a value you have to read from a node +// // FDCAN_ESI_ACTIVE is just a state that assumes there are minimal errors +// .BitRateSwitch = FDCAN_BRS_OFF, +// .TxEventFifoControl = FDCAN_NO_TX_EVENTS, // change to FDCAN_STORE_TX_EVENTS if you need to store info regarding transmitted messages +// .MessageMarker = 0 // also change this to a real address if you change fifo control +// }; + +// TxHeader.Identifier = msgID; +// TxHeader.DataLength = size; + +// TxHeader.FDFormat = FDCAN_CLASSIC_CAN; + +// FDCANTxMessage msg = {0}; +// msg.tx_header = TxHeader; + +// uint8_t temp; +// for (uint32_t i = 0; i < size / 2; ++i) { +// temp = ((uint8_t *)data)[i]; +// ((uint8_t *)data)[i] = ((uint8_t *)data)[size - i - 1]; +// ((uint8_t *)data)[size - i - 1] = temp; +// } + +// memcpy(&(msg.data), data, size); + +// // can_send(primary_can, &msg); +// can_enqueue(stateLump.primary_can, &msg); +// } + +// void SendECUStateDataOverCAN(const ECU_StateData *stateData) +// { +// uint32_t currentTime = MillisecondsSinceBoot(); + +// if (lastTickECUStateDataSent > currentTime - ECU_STATE_DATA_SEND_INTERVAL_MS) { +// return; +// } + +// lastTickECUStateDataSent = currentTime; + +// ECU_StateDataToSend messages = {.ECUState = stateData->ecu_state, +// .StatusBits = {stateData->status_bits[0], stateData->status_bits[1], stateData->status_bits[2]}, +// .PowerLevelTorqueMap = (stateData->powerlevel << 4) | (stateData->torquemap & 0x0F), +// .MaxCellTemp = (uint8_t)(stateData->max_cell_temp_c * 4), +// .AccumulatorStateOfCharge = (uint8_t)(stateData->tractivebattery_soc), +// .GLVStateOfCharge = (uint8_t)(stateData->glv_soc), +// .TractiveSystemVoltage = (uint16_t)(stateData->ts_voltage * 100), +// .VehicleSpeed = (uint16_t)(stateData->vehicle_speed_mph * 100), +// .FRWheelRPM = (uint16_t)(stateData->fr_wheel_rpm * 10 + 32768), +// .FLWheelRPM = (uint16_t)(stateData->fl_wheel_rpm * 10 + 32768), +// .RRWheelRPM = (uint16_t)(stateData->rr_wheel_rpm * 10 + 32768), +// .RLWheelRPM = (uint16_t)(stateData->rl_wheel_rpm * 10 + 32768)}; + +// ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ALL, GRCAN_ECU_STATUS_1, (void *)&messages.ECUStatusMsgOne, sizeof(messages.ECUStatusMsgOne)); +// ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ALL, GRCAN_ECU_STATUS_2, (void *)&messages.ECUStatusMsgTwo, sizeof(messages.ECUStatusMsgTwo)); +// ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ALL, GRCAN_ECU_STATUS_3, (void *)&messages.ECUStatusMsgThree, sizeof(messages.ECUStatusMsgThree)); + +// SendECUConfigOverCAN(stateData); +// } + +// void SendECUAnalogDataOverCAN(const ECU_StateData *stateData) +// { +// uint32_t millis_since_boot = MillisecondsSinceBoot(); + +// static uint32_t last_can_tcm_request_millis = 0; +// if (millis_since_boot - last_can_tcm_request_millis > 30) { +// GRCAN_ECU_ANALOG_DATA_MSG message = {.bspd_signal = stateData->bspd_signal, +// .bse_signal = stateData->bse_signal, +// .apps_1_signal = stateData->APPS1_Signal, +// .apps_2_signal = stateData->APPS2_Signal, +// .brakeline_f_signal = stateData->Brake_F_Signal, +// .brakeline_r_signal = stateData->Brake_R_Signal, +// .steering_angle_signal = stateData->steering_angle_signal, +// .aux_signal = stateData->aux_signal, +// .acc_pedal_travel = CalcAccPedalTravel(stateData) * 65535, +// .brake_pedal_pressure = CalcBrakePressure(stateData)}; +// ECU_CAN_Send(GRCAN_BUS_DATA, GRCAN_TCM, GRCAN_ECU_ANALOG_DATA, &message, sizeof(message)); +// last_can_tcm_request_millis = millis_since_boot; +// } +// } + +// void SendECUConfigOverCAN(const ECU_StateData *stateData) +// { +// GRCAN_ECU_CONFIG_MSG message = {.ping_timeout_delay = (uint8_t)(stateData->ping_timeout_delay_ms / 10.0f), +// .brake_f_min = (uint8_t)(stateData->brake_f_min / 25.0f), +// .brake_r_min = (uint8_t)(stateData->brake_r_min / 25.0f), +// .brake_bse_min = (uint8_t)(stateData->brake_bse_min / 25.0f), +// .apps_1_min = (uint8_t)(stateData->apps_1_min / 10.0f), +// .apps_2_min = (uint8_t)(stateData->apps_2_min / 10.0f), +// .apps_1_max = (uint8_t)(stateData->apps_1_max / 10.0f), +// .apps_2_max = (uint8_t)(stateData->apps_2_max / 10), +// .apps_deadzone = (uint8_t)(stateData->apps_deadzone * 25.5f), +// .bms_min_threshold = (uint8_t)(stateData->bms_min_thresh * 20.0f), +// .bms_max_threshold = (uint8_t)(stateData->bms_max_thresh * 20.0f), +// .imd_min_threshold = (uint8_t)(stateData->imd_min_thresh * 20.0f), +// .imd_max_threshold = (uint8_t)(stateData->imd_max_thresh * 20.0f), +// .bspd_min_threshold = (uint8_t)(stateData->bspd_min_thresh * 20.0f), +// .bspd_max_threshold = (uint8_t)(stateData->bspd_max_thresh * 20.0f), +// .max_precharge_time = (uint8_t)(stateData->max_precharge_time_ms / 10), +// .regen_strength = (uint8_t)(stateData->regen_strength * 10), +// .enable_regen = stateData->enable_regen}; + +// ECU_CAN_Send(GRCAN_BUS_DATA, GRCAN_TCM, GRCAN_ECU_CONFIG, &message, sizeof(message)); +// } diff --git a/ECU/Application/Src/Lights.c b/ECU/Application/Src/Lights.c index c86bb1efe..68bdf2d7e 100644 --- a/ECU/Application/Src/Lights.c +++ b/ECU/Application/Src/Lights.c @@ -1,13 +1,13 @@ #include "Lights.h" #include "CANutils.h" +#include "CubeCAN.h" #include "Logomatic.h" #include "StateData.h" #include "StateMachine.h" #include "StateUtils.h" #include "adc.h" #include "bitManipulations.h" -#include "can.h" #include "main.h" #include "stm32g4xx_ll_gpio.h" @@ -118,7 +118,7 @@ void RTD_ButtonLightControl(ECU_StateData *stateLump) multiplier = 1.0f; break; default: - LOGOMATIC("Invalid powerlevel: %d. Defaulting to 0.\n", stateLump->powerlevel); + LOGOMATIC_WARNING("Invalid powerlevel: %d. Defaulting to 0.\n", stateLump->powerlevel); multiplier = 0.0f; } @@ -128,7 +128,7 @@ void RTD_ButtonLightControl(ECU_StateData *stateLump) ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_Dash_Panel, GRCAN_RTD_LIGHT_CTRL, &light_control, sizeof(light_control)); } else { - LOGOMATIC("Invalid torquemap: %d. Defaulting to off.\n", stateLump->torquemap); + LOGOMATIC_WARNING("Invalid torquemap: %d. Defaulting to off.\n", stateLump->torquemap); light_control.red = 0; light_control.green = 0; light_control.blue = 0; diff --git a/ECU/Application/Src/StateTicks.c b/ECU/Application/Src/StateTicks.c index 2a78ae364..d9bc115d7 100644 --- a/ECU/Application/Src/StateTicks.c +++ b/ECU/Application/Src/StateTicks.c @@ -5,6 +5,7 @@ #include "CANutils.h" #include "ComparatorMacros.h" +#include "CubeCAN.h" #include "GRCAN_BUS_ID.h" #include "GRCAN_MSG_DATA.h" #include "GRCAN_MSG_ID.h" @@ -14,7 +15,6 @@ #include "StateMachine.h" #include "StateUtils.h" #include "Unused.h" -#include "can.h" #include "stm32g4xx_ll_gpio.h" /** @@ -69,7 +69,7 @@ void ECU_State_Tick(void) static uint32_t last_ECU_status_msg_millis; if (millis_since_boot - last_ECU_status_msg_millis >= ECU_STATUS_MSG_PERIOD_MILLIS) { - LOGOMATIC("ECU Current State: %d\n", stateLump.ecu_state); + LOGOMATIC_INFO("ECU Current State: %d\n", stateLump.ecu_state); last_ECU_status_msg_millis = millis_since_boot; } @@ -107,8 +107,8 @@ void ECU_State_Tick(void) ECU_Tractive_System_Discharge(&stateLump); break; default: - LOGOMATIC("ECU Current State Unknown: %d\n", stateLump.ecu_state); - LOGOMATIC("ECU: Resetting to GLV On\n"); + LOGOMATIC_ERROR("ECU Current State Unknown: %d\n", stateLump.ecu_state); + LOGOMATIC_ERROR("ECU: Resetting to GLV On\n"); stateLump.ecu_state = GR_GLV_ON; break; } @@ -118,7 +118,7 @@ void ECU_GLV_Off(ECU_StateData *stateData) { disable_inverter(); UNUSED(stateData); - LOGOMATIC("ECU_GLV_Off state reached... this should never happen!\n"); + LOGOMATIC_CRITICAL("ECU_GLV_Off state reached... this should never happen!\n"); // TODO ERROR --> GLV_OFF should never be reached } @@ -127,21 +127,21 @@ void ECU_GLV_On(ECU_StateData *stateData) disable_inverter(); if (stateData->ts_voltage >= SAFE_VOLTAGE_LIMIT) { - LOGOMATIC("Error: TS Voltage >= %d!\n", SAFE_VOLTAGE_LIMIT); + LOGOMATIC_ERROR("Error: TS Voltage >= %d!\n", SAFE_VOLTAGE_LIMIT); ECU_Transition_To_Tractive_System_Discharge(stateData); ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_Debugger, GRCAN_DEBUG_2_0, "TS-Runwy", 8); return; } if (stateData->ts_active_button_pressed /* && stateData->ir_plus*/) { // TODO: Talk to Owen if this is correct for precharge start confirmation - LOGOMATIC("GLV ON to PRECHARGE START!\n"); + LOGOMATIC_INFO("GLV ON to PRECHARGE START!\n"); ECU_Transition_To_Precharge_Engaged(stateData); return; } if (stateData->rtd_button_pressed) { stateData->powerlevel = (stateData->powerlevel + 1) % 6; - LOGOMATIC("Power level now at %d\n", stateData->powerlevel); + LOGOMATIC_INFO("Power level now at %d\n", stateData->powerlevel); } } @@ -153,7 +153,7 @@ void ECU_Transition_To_Precharge_Engaged(ECU_StateData *stateData) GRCAN_ACU_PRECHARGE_MSG message = {.set_ts_active = 1}; // Go TS Active/Precharge ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ACU, GRCAN_ACU_PRECHARGE, &message, sizeof(message)); stateData->ecu_state = GR_PRECHARGE_ENGAGED; - LOGOMATIC("PRECHARGE START to PRECHARGE ENGAGED!\n"); + LOGOMATIC_INFO("PRECHARGE START to PRECHARGE ENGAGED!\n"); time_start_precharge = millis_since_boot; return; } @@ -164,18 +164,18 @@ void ECU_Precharge_Engaged(ECU_StateData *stateData) if (stateData->ir_plus) { stateData->ecu_state = GR_PRECHARGE_COMPLETE; - LOGOMATIC("PRECHARGE ENGAGED to PRECHARGE COMPLETE!\n"); + LOGOMATIC_INFO("PRECHARGE ENGAGED to PRECHARGE COMPLETE!\n"); return; } if (CriticalError(stateData) || (millis_since_boot - time_start_precharge) >= stateData->max_precharge_time_ms) { - LOGOMATIC("CRITICAL ERROR! PRECHARGE ENGAGED to TS DISCHARGE START!\n"); + LOGOMATIC_CRITICAL("CRITICAL ERROR! PRECHARGE ENGAGED to TS DISCHARGE START!\n"); ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_Debugger, GRCAN_DEBUG_2_0, "TS-P-ITR", 8); ECU_Transition_To_Tractive_System_Discharge(stateData); return; } if (stateData->ts_active_button_pressed) { - LOGOMATIC("ERROR: ts_active PRESSED! PRECHARGE ENGAGED to TS DISCHARGE START!\n"); + LOGOMATIC_ERROR("ERROR: ts_active PRESSED! PRECHARGE ENGAGED to TS DISCHARGE START!\n"); ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_Debugger, GRCAN_DEBUG_2_0, "TS-P-ITR", 8); ECU_Transition_To_Tractive_System_Discharge(stateData); return; @@ -188,12 +188,12 @@ void ECU_Precharge_Complete(ECU_StateData *stateData) disable_inverter(); if (stateData->ts_active_button_pressed) { - LOGOMATIC("TS Active Toggled Off. Discharging Tractive System.\n"); + LOGOMATIC_INFO("TS Active Toggled Off. Discharging Tractive System.\n"); ECU_Transition_To_Tractive_System_Discharge(stateData); return; } if (CriticalError(stateData)) { - LOGOMATIC("Error: Critical Error Occurred. Discharging Tractive System.\n"); + LOGOMATIC_CRITICAL("Error: Critical Error Occurred. Discharging Tractive System.\n"); ECU_Transition_To_Tractive_System_Discharge(stateData); ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_Debugger, GRCAN_DEBUG_2_0, "HV-CritE", 8); return; @@ -202,7 +202,7 @@ void ECU_Precharge_Complete(ECU_StateData *stateData) if (PressingBrake(stateData) && stateData->rtd_button_pressed && (CalcAccPedalTravel(stateData) < stateData->apps_deadzone)) { GRCAN_INV_CONFIG_MSG inverter_message = {.max_ac_current = 0xFFFF, .max_dc_current = 0xFFFF, .absolute_max_rpm_limit = 0xFFFF, .motor_direction = 0}; ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_GR_Inv, GRCAN_INV_CONFIG, &inverter_message, sizeof(inverter_message)); - LOGOMATIC("PRECHARGE COMPLETE to DRIVE START/ACTIVE!\n"); + LOGOMATIC_INFO("PRECHARGE COMPLETE to DRIVE START/ACTIVE!\n"); ECU_Transition_To_Drive_Active(stateData); } } @@ -218,13 +218,13 @@ void ECU_Transition_To_Drive_Active(ECU_StateData *stateData) void ECU_Drive_Active(ECU_StateData *stateData) { if (CriticalError(stateData)) { - LOGOMATIC("Error: Critical Error Occured. Discharging Tractive System.\n"); + LOGOMATIC_CRITICAL("Error: Critical Error Occured. Discharging Tractive System.\n"); ECU_Transition_To_Tractive_System_Discharge(stateData); ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_Debugger, GRCAN_DEBUG_2_0, "DA-CritE", 8); return; } if (stateData->ts_active_button_pressed) { - LOGOMATIC("Error: TS active button pressed in Drive Active state. Discharging Tractive System.\n"); + LOGOMATIC_ERROR("Error: TS active button pressed in Drive Active state. Discharging Tractive System.\n"); ECU_Transition_To_Tractive_System_Discharge(stateData); ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_Debugger, GRCAN_DEBUG_2_0, "DA-CritE", 8); return; @@ -239,7 +239,7 @@ void ECU_Drive_Active(ECU_StateData *stateData) if (stateData->rtd_button_pressed) { stateData->ecu_state = GR_PRECHARGE_COMPLETE; if (stateData->vehicle_speed_mph > 0) { - LOGOMATIC("Warning: Vehicle is moving during state transition.\n"); + LOGOMATIC_WARNING("Warning: Vehicle is moving during state transition.\n"); } return; } @@ -285,7 +285,7 @@ void ECU_Drive_Active(ECU_StateData *stateData) max_current = 350; break; default: - LOGOMATIC("Invalid power level: %d. Defaulting to no current.\n", stateData->powerlevel); + LOGOMATIC_ERROR("Invalid power level: %d. Defaulting to no current.\n", stateData->powerlevel); max_current = 0; break; } @@ -307,7 +307,7 @@ static uint32_t discharge_start_millis; void ECU_Transition_To_Tractive_System_Discharge(ECU_StateData *stateData) { stateData->ecu_state = GR_TS_DISCHARGE; - LOGOMATIC("ECU: ACU discharge Tractive System\n"); + LOGOMATIC_INFO("ECU: ACU discharge Tractive System\n"); GRCAN_ACU_PRECHARGE_MSG message = {.set_ts_active = 0}; ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ACU, GRCAN_ACU_PRECHARGE, &message, sizeof(message)); discharge_start_millis = millis_since_boot; @@ -322,7 +322,7 @@ void ECU_Tractive_System_Discharge(ECU_StateData *stateData) */ if (stateData->ts_voltage < SAFE_VOLTAGE_LIMIT) { stateData->ecu_state = GR_GLV_ON; - LOGOMATIC("TS DISCHARGE to GLV ON!\n"); + LOGOMATIC_INFO("TS DISCHARGE to GLV ON!\n"); return; } /* @@ -334,7 +334,7 @@ void ECU_Tractive_System_Discharge(ECU_StateData *stateData) static uint32_t last_discharge_request_millis; if (RATE_LIMIT_100_HZ(millis_since_boot, last_discharge_request_millis)) { if (millis_since_boot - discharge_start_millis > TRACTIVE_SYSTEM_MAX_PERMITTED_DISCHARGE_TIME_MILLIS) { - LOGOMATIC("Warning: Tractive System fails to discharge in %d ms.\n", TRACTIVE_SYSTEM_MAX_PERMITTED_DISCHARGE_TIME_MILLIS); + LOGOMATIC_WARNING("Warning: Tractive System fails to discharge in %d ms.\n", TRACTIVE_SYSTEM_MAX_PERMITTED_DISCHARGE_TIME_MILLIS); ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_Debugger, GRCAN_DEBUG_2_0, "TS-D-TLE", 8); } diff --git a/ECU/Application/Src/StateUtils.c b/ECU/Application/Src/StateUtils.c index 85929bafb..42e8cc859 100644 --- a/ECU/Application/Src/StateUtils.c +++ b/ECU/Application/Src/StateUtils.c @@ -17,7 +17,7 @@ #include "main.h" #include "stm32g4xx_hal.h" #include "stm32g4xx_ll_gpio.h" -#include "vcp.h" +// #include "vcp.h" /** * @brief Delay after startup to allow IMD sense to stabilize before considering IMD sense failures valid @@ -52,8 +52,9 @@ bool CriticalError(volatile const ECU_StateData *stateData) problem |= bmsFailure(stateData); problem |= bspdFailure(stateData); if (problem) { - LOGOMATIC("Critical Error Detected in State %d | %f C | %f V | ACU SW %d | IR+ %d | IR- %d | IMD %d | BMS %d | BSPD %d\n", stateData->ecu_state, stateData->max_cell_temp_c, - stateData->ts_voltage, stateData->acu_software_latch, stateData->ir_plus, stateData->ir_minus, imdFailure(stateData), bmsFailure(stateData), bspdFailure(stateData)); + LOGOMATIC_CRITICAL("Critical Error Detected in State %d | %f C | %f V | ACU SW %d | IR+ %d | IR- %d | IMD %d | BMS %d | BSPD %d\n", stateData->ecu_state, + (double)stateData->max_cell_temp_c, (double)stateData->ts_voltage, stateData->acu_software_latch, stateData->ir_plus, stateData->ir_minus, imdFailure(stateData), + bmsFailure(stateData), bspdFailure(stateData)); // LL_GPIO_ResetOutputPin(SOFTWARE_OK_CONTROL_GPIO_Port, SOFTWARE_OK_CONTROL_Pin); } return problem; @@ -185,5 +186,5 @@ void Send_VCP_APPS(const ECU_StateData *stateData, uint16_t apps1_raw, uint16_t #define SIZE 64 static char buf[SIZE]; snprintf(buf, SIZE, "%" PRIu32 " A1 %d A2 %d A1R %d A2R %d\n", MillisecondsSinceBoot(), stateData->APPS1_Signal, stateData->APPS2_Signal, apps1_raw, apps2_raw); - VCP_Send(buf, strlen(buf)); + // VCP_Send(buf, strlen(buf)); } diff --git a/ECU/CMakeLists.txt b/ECU/CMakeLists.txt index b63573e3a..f41af3d46 100644 --- a/ECU/CMakeLists.txt +++ b/ECU/CMakeLists.txt @@ -38,12 +38,10 @@ if(CMAKE_PRESET_NAME STREQUAL "HOOTLTest") PRIVATE GLOBALSHARE_LIB CANfigurator - LOGOMATIC_OLD_LIB + LOGOMATIC_LIB m - # GR_ADC - # PERIPHERAL_CAN_LIB + CUBE_CAN_LIB BitManipulations_Lib - VCP_LIB ) add_test(StateTicksTest StateTicksTest) @@ -88,10 +86,10 @@ target_link_libraries( ${GR_PROJECT_NAME}_USER_CODE INTERFACE CANfigurator - GR_ADC - PERIPHERAL_TIMEDCAN_LIB BitManipulations_Lib - VCP_LIB + CUBE_CAN_LIB + # CUBE_VCP_LIB # TODO Add VCP back in when we have a plan for how to use it + LOGOMATIC_LIB ) target_include_directories( diff --git a/ECU/Core/Inc/adc.h b/ECU/Core/Inc/adc.h index d1e987162..84e65a7f7 100644 --- a/ECU/Core/Inc/adc.h +++ b/ECU/Core/Inc/adc.h @@ -32,6 +32,10 @@ extern "C" { /* USER CODE END Includes */ +extern ADC_HandleTypeDef hadc1; + +extern ADC_HandleTypeDef hadc2; + /* USER CODE BEGIN Private defines */ /* USER CODE END Private defines */ @@ -41,6 +45,8 @@ void MX_ADC2_Init(void); /* USER CODE BEGIN Prototypes */ +void ADC_UpdateAnalogValues_EMA(volatile uint16_t *ADC_buffers, uint8_t num_signals, float alpha, volatile uint16_t *ADC_outputs); + /* USER CODE END Prototypes */ #ifdef __cplusplus @@ -48,3 +54,4 @@ void MX_ADC2_Init(void); #endif #endif /* __ADC_H__ */ + diff --git a/ECU/Core/Inc/dma.h b/ECU/Core/Inc/dma.h index ae819cab4..2a2856f62 100644 --- a/ECU/Core/Inc/dma.h +++ b/ECU/Core/Inc/dma.h @@ -49,3 +49,4 @@ void MX_DMA_Init(void); #endif #endif /* __DMA_H__ */ + diff --git a/ECU/Core/Inc/fdcan.h b/ECU/Core/Inc/fdcan.h index 9652dd8ad..51ce1bff4 100644 --- a/ECU/Core/Inc/fdcan.h +++ b/ECU/Core/Inc/fdcan.h @@ -52,3 +52,4 @@ void MX_FDCAN2_Init(void); #endif #endif /* __FDCAN_H__ */ + diff --git a/ECU/Core/Inc/gpio.h b/ECU/Core/Inc/gpio.h index 702fc0cc1..d291b7801 100644 --- a/ECU/Core/Inc/gpio.h +++ b/ECU/Core/Inc/gpio.h @@ -46,3 +46,4 @@ void MX_GPIO_Init(void); } #endif #endif /*__ GPIO_H__ */ + diff --git a/ECU/Core/Inc/main.h b/ECU/Core/Inc/main.h index 7331e5ca0..63ea03aab 100644 --- a/ECU/Core/Inc/main.h +++ b/ECU/Core/Inc/main.h @@ -28,24 +28,18 @@ extern "C" { /* Includes ------------------------------------------------------------------*/ #include "stm32g4xx_hal.h" -#include "stm32g4xx_ll_adc.h" + +/* Private includes ----------------------------------------------------------*/ +/* USER CODE BEGIN Includes */ +#include "GRCAN_MSG_DATA.h" +#include "GRCAN_NODE_ID.h" +#include "Plan_C.h" #include "stm32g4xx_ll_bus.h" -#include "stm32g4xx_ll_cortex.h" -#include "stm32g4xx_ll_crs.h" -#include "stm32g4xx_ll_dma.h" -#include "stm32g4xx_ll_exti.h" #include "stm32g4xx_ll_gpio.h" #include "stm32g4xx_ll_lpuart.h" -#include "stm32g4xx_ll_pwr.h" #include "stm32g4xx_ll_rcc.h" -#include "stm32g4xx_ll_system.h" #include "stm32g4xx_ll_usart.h" #include "stm32g4xx_ll_utils.h" - -/* Private includes ----------------------------------------------------------*/ -/* USER CODE BEGIN Includes */ -#include "GRCAN_NODE_ID.h" -#include "Plan_C.h" /* USER CODE END Includes */ /* Exported types ------------------------------------------------------------*/ @@ -96,59 +90,62 @@ void Error_Handler(void); /* USER CODE END EFP */ -/* USER CODE BEGIN Private defines */ -#define MAIN_LOOP_PERIOD_US 10000 -#define CAN_TIMER_SEND_PERIOD_US (MAIN_LOOP_PERIOD_US >> 4) - /* Private defines -----------------------------------------------------------*/ -// GPIOC -#define BSE_SIGNAL_Pin LL_GPIO_PIN_0 /// Following net names, see @ref ADC_BUFFER_SIG_BSE -#define BSE_SIGNAL_GPIO_Port GPIOC /// Following net names, see @ref ADC_BUFFER_SIG_BSE -#define BSPD_SIGNAL_Pin LL_GPIO_PIN_1 +#define BSE_SIGNAL_Pin GPIO_PIN_0 +#define BSE_SIGNAL_GPIO_Port GPIOC +#define BSPD_SIGNAL_Pin GPIO_PIN_1 #define BSPD_SIGNAL_GPIO_Port GPIOC -#define APPS1_SIGNAL_Pin LL_GPIO_PIN_2 +#define APPS1_SIGNAL_Pin GPIO_PIN_2 #define APPS1_SIGNAL_GPIO_Port GPIOC -#define APPS2_SIGNAL_Pin LL_GPIO_PIN_3 +#define APPS2_SIGNAL_Pin GPIO_PIN_3 #define APPS2_SIGNAL_GPIO_Port GPIOC - -// GPIOA -#define BSPD_SENSE_Pin LL_GPIO_PIN_5 -#define BSPD_SENSE_GPIO_Port GPIOA -#define IMD_SENSE_Pin LL_GPIO_PIN_6 +#define BPSD_SENSE_Pin GPIO_PIN_5 +#define BPSD_SENSE_GPIO_Port GPIOA +#define IMD_SENSE_Pin GPIO_PIN_6 #define IMD_SENSE_GPIO_Port GPIOA -#define AMS_SENSE_Pin LL_GPIO_PIN_7 +#define AMS_SENSE_Pin GPIO_PIN_7 #define AMS_SENSE_GPIO_Port GPIOA -#define ESTOP_SENSE_Pin LL_GPIO_PIN_15 -#define ESTOP_SENSE_GPIO_Port GPIOA - -// GPIOB -#define BRAKE_F_SIGNAL_Pin LL_GPIO_PIN_0 /// Following net names, see @ref ADC_BUFFER_SIG_BSE -#define BRAKE_F_SIGNAL_GPIO_Port GPIOB /// Following net names, see @ref ADC_BUFFER_SIG_BSE -#define BRAKE_R_SIGNAL_Pin LL_GPIO_PIN_1 /// Following net names, see @ref ADC_BUFFER_SIG_BSE -#define BRAKE_R_SIGNAL_GPIO_Port GPIOB /// Following net names, see @ref ADC_BUFFER_SIG_BSE -#define LED_TEST_Pin LL_GPIO_PIN_11 +#define BRAKE_D_SIGNAL_Pin GPIO_PIN_0 +#define BRAKE_D_SIGNAL_GPIO_Port GPIOB +#define BRAKE_R_SIGNAL_Pin GPIO_PIN_1 +#define BRAKE_R_SIGNAL_GPIO_Port GPIOB +#define LED_TEST_Pin GPIO_PIN_11 #define LED_TEST_GPIO_Port GPIOB -#define AUX_SIGNAL_Pin LL_GPIO_PIN_14 +#define AUX_SIGNAL_Pin GPIO_PIN_14 #define AUX_SIGNAL_GPIO_Port GPIOB -#define STEERING_ANGLE_Pin LL_GPIO_PIN_15 +#define STEERING_ANGLE_Pin GPIO_PIN_15 #define STEERING_ANGLE_GPIO_Port GPIOB -#define BRAKE_LIGHT_Pin LL_GPIO_PIN_4 +#define RTD_BTN_LED_CONTROL_Pin GPIO_PIN_8 +#define RTD_BTN_LED_CONTROL_GPIO_Port GPIOA +#define TS_ACTIVE_BTN_LED_CONTROL_Pin GPIO_PIN_9 +#define TS_ACTIVE_BTN_LED_CONTROL_GPIO_Port GPIOA +#define ESTOP_SENSE_Pin GPIO_PIN_15 +#define ESTOP_SENSE_GPIO_Port GPIOA +#define INERTIA_SW_SENSE_Pin GPIO_PIN_10 +#define INERTIA_SW_SENSE_GPIO_Port GPIOC +#define RTD_BTN_SENSE_Pin GPIO_PIN_11 +#define RTD_BTN_SENSE_GPIO_Port GPIOC +#define TS_ACTIVE_BTN_SENSE_Pin GPIO_PIN_12 +#define TS_ACTIVE_BTN_SENSE_GPIO_Port GPIOC +#define BRAKE_LIGHT_Pin GPIO_PIN_4 #define BRAKE_LIGHT_GPIO_Port GPIOB -#define TSSI_G_CONTROL_Pin LL_GPIO_PIN_5 +#define TSSI_G_CONTROL_Pin GPIO_PIN_5 #define TSSI_G_CONTROL_GPIO_Port GPIOB -#define TSSI_R_CONTROL_Pin LL_GPIO_PIN_6 +#define TSSI_R_CONTROL_Pin GPIO_PIN_6 #define TSSI_R_CONTROL_GPIO_Port GPIOB -#define TS_ACTIVE_BTN_LED_CONTROL_Pin LL_GPIO_PIN_9 -#define TS_ACTIVE_BTN_LED_CONTROL_GPIO_Port GPIOA -#define RTD_BTN_LED_CONTROL_Pin LL_GPIO_PIN_8 -#define RTD_BTN_LED_CONTROL_GPIO_Port GPIOA -#define RTD_CONTROL_Pin LL_GPIO_PIN_7 +#define RTD_CONTROL_Pin GPIO_PIN_7 #define RTD_CONTROL_GPIO_Port GPIOB -#define AUX_CONTROL_Pin LL_GPIO_PIN_8 +#define AUX_CONTROL_Pin GPIO_PIN_8 #define AUX_CONTROL_GPIO_Port GPIOB -#define SOFTWARE_OK_CONTROL_Pin LL_GPIO_PIN_9 +#define SOFTWARE_OK_CONTROL_Pin GPIO_PIN_9 #define SOFTWARE_OK_CONTROL_GPIO_Port GPIOB +/* USER CODE BEGIN Private defines */ +#define MAIN_LOOP_PERIOD_US 10000 +#define CAN_TIMER_SEND_PERIOD_US (MAIN_LOOP_PERIOD_US >> 4) + +/* Private defines -----------------------------------------------------------*/ + /* USER CODE END Private defines */ #ifdef __cplusplus diff --git a/ECU/Core/Inc/stm32g4xx_hal_conf.h b/ECU/Core/Inc/stm32g4xx_hal_conf.h index c67a3a915..e087b69e8 100644 --- a/ECU/Core/Inc/stm32g4xx_hal_conf.h +++ b/ECU/Core/Inc/stm32g4xx_hal_conf.h @@ -23,7 +23,7 @@ #define STM32G4xx_HAL_CONF_H #ifdef __cplusplus -extern "C" { + extern "C" { #endif /* Exported types ------------------------------------------------------------*/ @@ -31,12 +31,12 @@ extern "C" { /* ########################## Module Selection ############################## */ /** - * @brief This is the list of modules to be used in the HAL driver - */ + * @brief This is the list of modules to be used in the HAL driver + */ #define HAL_MODULE_ENABLED -/*#define HAL_ADC_MODULE_ENABLED */ + #define HAL_ADC_MODULE_ENABLED /*#define HAL_COMP_MODULE_ENABLED */ /*#define HAL_CORDIC_MODULE_ENABLED */ /*#define HAL_CRC_MODULE_ENABLED */ @@ -62,7 +62,7 @@ extern "C" { /*#define HAL_SMBUS_MODULE_ENABLED */ /*#define HAL_SPI_MODULE_ENABLED */ /*#define HAL_SRAM_MODULE_ENABLED */ -#define HAL_TIM_MODULE_ENABLED +/*#define HAL_TIM_MODULE_ENABLED */ /*#define HAL_UART_MODULE_ENABLED */ /*#define HAL_USART_MODULE_ENABLED */ /*#define HAL_WWDG_MODULE_ENABLED */ @@ -74,135 +74,125 @@ extern "C" { #define HAL_PWR_MODULE_ENABLED #define HAL_CORTEX_MODULE_ENABLED -/* ########################## Register Callbacks selection - * ############################## */ +/* ########################## Register Callbacks selection ############################## */ /** - * @brief This is the list of modules where register callback can be used - */ -#define USE_HAL_ADC_REGISTER_CALLBACKS 0U -#define USE_HAL_COMP_REGISTER_CALLBACKS 0U -#define USE_HAL_CORDIC_REGISTER_CALLBACKS 0U -#define USE_HAL_CRYP_REGISTER_CALLBACKS 0U -#define USE_HAL_DAC_REGISTER_CALLBACKS 0U -#define USE_HAL_EXTI_REGISTER_CALLBACKS 0U -#define USE_HAL_FDCAN_REGISTER_CALLBACKS 0U -#define USE_HAL_FMAC_REGISTER_CALLBACKS 0U -#define USE_HAL_HRTIM_REGISTER_CALLBACKS 0U -#define USE_HAL_I2C_REGISTER_CALLBACKS 0U -#define USE_HAL_I2S_REGISTER_CALLBACKS 0U -#define USE_HAL_IRDA_REGISTER_CALLBACKS 0U -#define USE_HAL_LPTIM_REGISTER_CALLBACKS 0U -#define USE_HAL_NAND_REGISTER_CALLBACKS 0U -#define USE_HAL_NOR_REGISTER_CALLBACKS 0U -#define USE_HAL_OPAMP_REGISTER_CALLBACKS 0U -#define USE_HAL_PCD_REGISTER_CALLBACKS 0U -#define USE_HAL_QSPI_REGISTER_CALLBACKS 0U -#define USE_HAL_RNG_REGISTER_CALLBACKS 0U -#define USE_HAL_RTC_REGISTER_CALLBACKS 0U -#define USE_HAL_SAI_REGISTER_CALLBACKS 0U -#define USE_HAL_SMARTCARD_REGISTER_CALLBACKS 0U -#define USE_HAL_SMBUS_REGISTER_CALLBACKS 0U -#define USE_HAL_SPI_REGISTER_CALLBACKS 0U -#define USE_HAL_SRAM_REGISTER_CALLBACKS 0U -#define USE_HAL_TIM_REGISTER_CALLBACKS 0U -#define USE_HAL_UART_REGISTER_CALLBACKS 0U -#define USE_HAL_USART_REGISTER_CALLBACKS 0U -#define USE_HAL_WWDG_REGISTER_CALLBACKS 0U - -/* ########################## Oscillator Values adaptation - * ####################*/ + * @brief This is the list of modules where register callback can be used + */ +#define USE_HAL_ADC_REGISTER_CALLBACKS 0U +#define USE_HAL_COMP_REGISTER_CALLBACKS 0U +#define USE_HAL_CORDIC_REGISTER_CALLBACKS 0U +#define USE_HAL_CRYP_REGISTER_CALLBACKS 0U +#define USE_HAL_DAC_REGISTER_CALLBACKS 0U +#define USE_HAL_EXTI_REGISTER_CALLBACKS 0U +#define USE_HAL_FDCAN_REGISTER_CALLBACKS 0U +#define USE_HAL_FMAC_REGISTER_CALLBACKS 0U +#define USE_HAL_HRTIM_REGISTER_CALLBACKS 0U +#define USE_HAL_I2C_REGISTER_CALLBACKS 0U +#define USE_HAL_I2S_REGISTER_CALLBACKS 0U +#define USE_HAL_IRDA_REGISTER_CALLBACKS 0U +#define USE_HAL_LPTIM_REGISTER_CALLBACKS 0U +#define USE_HAL_NAND_REGISTER_CALLBACKS 0U +#define USE_HAL_NOR_REGISTER_CALLBACKS 0U +#define USE_HAL_OPAMP_REGISTER_CALLBACKS 0U +#define USE_HAL_PCD_REGISTER_CALLBACKS 0U +#define USE_HAL_QSPI_REGISTER_CALLBACKS 0U +#define USE_HAL_RNG_REGISTER_CALLBACKS 0U +#define USE_HAL_RTC_REGISTER_CALLBACKS 0U +#define USE_HAL_SAI_REGISTER_CALLBACKS 0U +#define USE_HAL_SMARTCARD_REGISTER_CALLBACKS 0U +#define USE_HAL_SMBUS_REGISTER_CALLBACKS 0U +#define USE_HAL_SPI_REGISTER_CALLBACKS 0U +#define USE_HAL_SRAM_REGISTER_CALLBACKS 0U +#define USE_HAL_TIM_REGISTER_CALLBACKS 0U +#define USE_HAL_UART_REGISTER_CALLBACKS 0U +#define USE_HAL_USART_REGISTER_CALLBACKS 0U +#define USE_HAL_WWDG_REGISTER_CALLBACKS 0U + +/* ########################## Oscillator Values adaptation ####################*/ /** - * @brief Adjust the value of External High Speed oscillator (HSE) used in your - * application. This value is used by the RCC HAL module to compute the system - * frequency (when HSE is used as system clock source, directly or through the - * PLL). - */ -#if !defined(HSE_VALUE) -#define HSE_VALUE (16000000UL) /*!< Value of the External oscillator in Hz */ -#endif /* HSE_VALUE */ - -#if !defined(HSE_STARTUP_TIMEOUT) -#define HSE_STARTUP_TIMEOUT (100UL) /*!< Time out for HSE start up, in ms */ -#endif /* HSE_STARTUP_TIMEOUT */ + * @brief Adjust the value of External High Speed oscillator (HSE) used in your application. + * This value is used by the RCC HAL module to compute the system frequency + * (when HSE is used as system clock source, directly or through the PLL). + */ +#if !defined (HSE_VALUE) + #define HSE_VALUE (16000000UL) /*!< Value of the External oscillator in Hz */ +#endif /* HSE_VALUE */ + +#if !defined (HSE_STARTUP_TIMEOUT) + #define HSE_STARTUP_TIMEOUT (100UL) /*!< Time out for HSE start up, in ms */ +#endif /* HSE_STARTUP_TIMEOUT */ /** - * @brief Internal High Speed oscillator (HSI) value. - * This value is used by the RCC HAL module to compute the system - * frequency (when HSI is used as system clock source, directly or through the - * PLL). - */ -#if !defined(HSI_VALUE) -#define HSI_VALUE (16000000UL) /*!< Value of the Internal oscillator in Hz*/ -#endif /* HSI_VALUE */ + * @brief Internal High Speed oscillator (HSI) value. + * This value is used by the RCC HAL module to compute the system frequency + * (when HSI is used as system clock source, directly or through the PLL). + */ +#if !defined (HSI_VALUE) + #define HSI_VALUE (16000000UL) /*!< Value of the Internal oscillator in Hz*/ +#endif /* HSI_VALUE */ /** - * @brief Internal High Speed oscillator (HSI48) value for USB FS and RNG. - * This internal oscillator is mainly dedicated to provide a high - * precision clock to the USB peripheral by means of a special Clock Recovery - * System (CRS) circuitry. When the CRS is not used, the HSI48 RC oscillator - * runs on it default frequency which is subject to manufacturing process - * variations. - */ -#if !defined(HSI48_VALUE) -#define HSI48_VALUE \ - (48000000UL) /*!< Value of the Internal High Speed oscillator for USB \ - FS/RNG in Hz. The real value my vary depending on \ - manufacturing process variations.*/ -#endif /* HSI48_VALUE */ + * @brief Internal High Speed oscillator (HSI48) value for USB FS and RNG. + * This internal oscillator is mainly dedicated to provide a high precision clock to + * the USB peripheral by means of a special Clock Recovery System (CRS) circuitry. + * When the CRS is not used, the HSI48 RC oscillator runs on it default frequency + * which is subject to manufacturing process variations. + */ +#if !defined (HSI48_VALUE) + #define HSI48_VALUE (48000000UL) /*!< Value of the Internal High Speed oscillator for USB FS/RNG in Hz. + The real value my vary depending on manufacturing process variations.*/ +#endif /* HSI48_VALUE */ /** - * @brief Internal Low Speed oscillator (LSI) value. - */ -#if !defined(LSI_VALUE) + * @brief Internal Low Speed oscillator (LSI) value. + */ +#if !defined (LSI_VALUE) /*!< Value of the Internal Low Speed oscillator in Hz -The real value may vary depending on the variations in voltage and -temperature.*/ -#define LSI_VALUE (32000UL) /*!< LSI Typical Value in Hz*/ -#endif /* LSI_VALUE */ +The real value may vary depending on the variations in voltage and temperature.*/ +#define LSI_VALUE (32000UL) /*!< LSI Typical Value in Hz*/ +#endif /* LSI_VALUE */ /** - * @brief External Low Speed oscillator (LSE) value. - * This value is used by the UART, RTC HAL module to compute the system - * frequency - */ -#if !defined(LSE_VALUE) -#define LSE_VALUE (32768UL) /*!< Value of the External Low Speed oscillator in Hz */ -#endif /* LSE_VALUE */ + * @brief External Low Speed oscillator (LSE) value. + * This value is used by the UART, RTC HAL module to compute the system frequency + */ +#if !defined (LSE_VALUE) +#define LSE_VALUE (32768UL) /*!< Value of the External Low Speed oscillator in Hz */ +#endif /* LSE_VALUE */ -#if !defined(LSE_STARTUP_TIMEOUT) -#define LSE_STARTUP_TIMEOUT (5000UL) /*!< Time out for LSE start up, in ms */ -#endif /* LSE_STARTUP_TIMEOUT */ +#if !defined (LSE_STARTUP_TIMEOUT) +#define LSE_STARTUP_TIMEOUT (5000UL) /*!< Time out for LSE start up, in ms */ +#endif /* LSE_STARTUP_TIMEOUT */ /** - * @brief External clock source for I2S and SAI peripherals - * This value is used by the I2S and SAI HAL modules to compute the I2S - * and SAI clock source frequency, this source is inserted directly through - * I2S_CKIN pad. - */ -#if !defined(EXTERNAL_CLOCK_VALUE) -#define EXTERNAL_CLOCK_VALUE (12288000UL) /*!< Value of the External oscillator in Hz*/ -#endif /* EXTERNAL_CLOCK_VALUE */ + * @brief External clock source for I2S and SAI peripherals + * This value is used by the I2S and SAI HAL modules to compute the I2S and SAI clock source + * frequency, this source is inserted directly through I2S_CKIN pad. + */ +#if !defined (EXTERNAL_CLOCK_VALUE) +#define EXTERNAL_CLOCK_VALUE (12288000UL) /*!< Value of the External oscillator in Hz*/ +#endif /* EXTERNAL_CLOCK_VALUE */ /* Tip: To avoid modifying this file each time you need to use different HSE, === you can define the HSE value in your toolchain compiler preprocessor. */ /* ########################### System Configuration ######################### */ /** - * @brief This is the HAL system configuration section - */ + * @brief This is the HAL system configuration section + */ -#define VDD_VALUE (3300UL) /*!< Value of VDD in mv */ -#define TICK_INT_PRIORITY (15UL) /*!< tick interrupt priority (lowest by default) */ -#define USE_RTOS 0U -#define PREFETCH_ENABLE 0U -#define INSTRUCTION_CACHE_ENABLE 1U -#define DATA_CACHE_ENABLE 1U +#define VDD_VALUE (3300UL) /*!< Value of VDD in mv */ +#define TICK_INT_PRIORITY (15UL) /*!< tick interrupt priority (lowest by default) */ +#define USE_RTOS 0U +#define PREFETCH_ENABLE 0U +#define INSTRUCTION_CACHE_ENABLE 1U +#define DATA_CACHE_ENABLE 1U /* ########################## Assert Selection ############################## */ /** - * @brief Uncomment the line below to expanse the "assert_param" macro in the - * HAL drivers code - */ -/* #define USE_FULL_ASSERT 1U */ + * @brief Uncomment the line below to expanse the "assert_param" macro in the + * HAL drivers code + */ + #define USE_FULL_ASSERT 1U /* ################## SPI peripheral configuration ########################## */ @@ -211,12 +201,12 @@ temperature.*/ * Deactivated: CRC code cleaned from driver */ -#define USE_SPI_CRC 0U +#define USE_SPI_CRC 0U /* Includes ------------------------------------------------------------------*/ /** - * @brief Include module's header file - */ + * @brief Include module's header file + */ #ifdef HAL_RCC_MODULE_ENABLED #include "stm32g4xx_hal_rcc.h" @@ -367,15 +357,15 @@ temperature.*/ #endif /* HAL_WWDG_MODULE_ENABLED */ /* Exported macro ------------------------------------------------------------*/ -#ifdef USE_FULL_ASSERT +#ifdef USE_FULL_ASSERT /** - * @brief The assert_param macro is used for function's parameters check. - * @param expr: If expr is false, it calls assert_failed function - * which reports the name of the source file and the source - * line number of the call that failed. - * If expr is true, it returns no value. - * @retval None - */ + * @brief The assert_param macro is used for function's parameters check. + * @param expr: If expr is false, it calls assert_failed function + * which reports the name of the source file and the source + * line number of the call that failed. + * If expr is true, it returns no value. + * @retval None + */ #define assert_param(expr) ((expr) ? (void)0U : assert_failed((uint8_t *)__FILE__, __LINE__)) /* Exported functions ------------------------------------------------------- */ void assert_failed(uint8_t *file, uint32_t line); diff --git a/ECU/Core/Inc/stm32g4xx_it.h b/ECU/Core/Inc/stm32g4xx_it.h index e08bcd52a..f96143971 100644 --- a/ECU/Core/Inc/stm32g4xx_it.h +++ b/ECU/Core/Inc/stm32g4xx_it.h @@ -55,6 +55,13 @@ void SVC_Handler(void); void DebugMon_Handler(void); void PendSV_Handler(void); void SysTick_Handler(void); +void DMA1_Channel1_IRQHandler(void); +void ADC1_2_IRQHandler(void); +void FDCAN1_IT0_IRQHandler(void); +void FDCAN1_IT1_IRQHandler(void); +void DMA2_Channel1_IRQHandler(void); +void FDCAN2_IT0_IRQHandler(void); +void FDCAN2_IT1_IRQHandler(void); /* USER CODE BEGIN EFP */ /* USER CODE END EFP */ diff --git a/ECU/Core/Src/adc.c b/ECU/Core/Src/adc.c index ae1d230d3..7b913236b 100644 --- a/ECU/Core/Src/adc.c +++ b/ECU/Core/Src/adc.c @@ -24,304 +24,449 @@ /* USER CODE END 0 */ +ADC_HandleTypeDef hadc1; +ADC_HandleTypeDef hadc2; +DMA_HandleTypeDef hdma_adc1; +DMA_HandleTypeDef hdma_adc2; + /* ADC1 init function */ void MX_ADC1_Init(void) { - /* USER CODE BEGIN ADC1_Init 0 */ - - /* USER CODE END ADC1_Init 0 */ - - LL_ADC_InitTypeDef ADC_InitStruct = {0}; - LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0}; - LL_ADC_CommonInitTypeDef ADC_CommonInitStruct = {0}; - - LL_GPIO_InitTypeDef GPIO_InitStruct = {0}; - - LL_RCC_SetADCClockSource(LL_RCC_ADC12_CLKSOURCE_SYSCLK); - - /* Peripheral clock enable */ - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_ADC12); - - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOC); - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOB); - /**ADC1 GPIO Configuration - PC1 ------> ADC1_IN7 - PC2 ------> ADC1_IN8 - PC3 ------> ADC1_IN9 - PB0 ------> ADC1_IN15 - PB1 ------> ADC1_IN12 - PB14 ------> ADC1_IN5 - */ - GPIO_InitStruct.Pin = BSPD_SIGNAL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(BSPD_SIGNAL_GPIO_Port, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = APPS1_SIGNAL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(APPS1_SIGNAL_GPIO_Port, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = APPS2_SIGNAL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(APPS2_SIGNAL_GPIO_Port, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = BRAKE_F_SIGNAL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(BRAKE_F_SIGNAL_GPIO_Port, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = BRAKE_R_SIGNAL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(BRAKE_R_SIGNAL_GPIO_Port, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = AUX_SIGNAL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(AUX_SIGNAL_GPIO_Port, &GPIO_InitStruct); - - /* ADC1 DMA Init */ - - /* ADC1 Init */ - LL_DMA_SetPeriphRequest(DMA1, LL_DMA_CHANNEL_1, LL_DMAMUX_REQ_ADC1); - - LL_DMA_SetDataTransferDirection(DMA1, LL_DMA_CHANNEL_1, LL_DMA_DIRECTION_PERIPH_TO_MEMORY); - - LL_DMA_SetChannelPriorityLevel(DMA1, LL_DMA_CHANNEL_1, LL_DMA_PRIORITY_LOW); - - LL_DMA_SetMode(DMA1, LL_DMA_CHANNEL_1, LL_DMA_MODE_CIRCULAR); - - LL_DMA_SetPeriphIncMode(DMA1, LL_DMA_CHANNEL_1, LL_DMA_PERIPH_NOINCREMENT); - - LL_DMA_SetMemoryIncMode(DMA1, LL_DMA_CHANNEL_1, LL_DMA_MEMORY_INCREMENT); - - LL_DMA_SetPeriphSize(DMA1, LL_DMA_CHANNEL_1, LL_DMA_PDATAALIGN_HALFWORD); - - LL_DMA_SetMemorySize(DMA1, LL_DMA_CHANNEL_1, LL_DMA_MDATAALIGN_HALFWORD); - - /* USER CODE BEGIN ADC1_Init 1 */ - - /* USER CODE END ADC1_Init 1 */ - - /** Common config - */ - ADC_InitStruct.Resolution = LL_ADC_RESOLUTION_12B; - ADC_InitStruct.DataAlignment = LL_ADC_DATA_ALIGN_RIGHT; - ADC_InitStruct.LowPowerMode = LL_ADC_LP_MODE_NONE; - LL_ADC_Init(ADC1, &ADC_InitStruct); - ADC_REG_InitStruct.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE; - ADC_REG_InitStruct.SequencerLength = LL_ADC_REG_SEQ_SCAN_ENABLE_6RANKS; - ADC_REG_InitStruct.SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE; - ADC_REG_InitStruct.ContinuousMode = LL_ADC_REG_CONV_CONTINUOUS; - ADC_REG_InitStruct.DMATransfer = LL_ADC_REG_DMA_TRANSFER_UNLIMITED; - ADC_REG_InitStruct.Overrun = LL_ADC_REG_OVR_DATA_PRESERVED; - LL_ADC_REG_Init(ADC1, &ADC_REG_InitStruct); - LL_ADC_SetGainCompensation(ADC1, 0); - LL_ADC_SetOverSamplingScope(ADC1, LL_ADC_OVS_DISABLE); - ADC_CommonInitStruct.CommonClock = LL_ADC_CLOCK_ASYNC_DIV4; - ADC_CommonInitStruct.Multimode = LL_ADC_MULTI_INDEPENDENT; - LL_ADC_CommonInit(__LL_ADC_COMMON_INSTANCE(ADC1), &ADC_CommonInitStruct); - - /* Disable ADC deep power down (enabled by default after reset state) */ - LL_ADC_DisableDeepPowerDown(ADC1); - /* Enable ADC internal voltage regulator */ - LL_ADC_EnableInternalRegulator(ADC1); - /* Delay for ADC internal voltage regulator stabilization. */ - /* Compute number of CPU cycles to wait for, from delay in us. */ - /* Note: Variable divided by 2 to compensate partially */ - /* CPU processing cycles (depends on compilation optimization). */ - /* Note: If system core clock frequency is below 200kHz, wait time */ - /* is only a few CPU processing cycles. */ - uint32_t wait_loop_index; - wait_loop_index = ((LL_ADC_DELAY_INTERNAL_REGUL_STAB_US * (SystemCoreClock / (100000 * 2))) / 10); - while (wait_loop_index != 0) { - wait_loop_index--; - } + /* USER CODE BEGIN ADC1_Init 0 */ + + /* USER CODE END ADC1_Init 0 */ + + ADC_MultiModeTypeDef multimode = {0}; + ADC_ChannelConfTypeDef sConfig = {0}; + + /* USER CODE BEGIN ADC1_Init 1 */ + + /* USER CODE END ADC1_Init 1 */ + + /** Common config + */ + hadc1.Instance = ADC1; + hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4; + hadc1.Init.Resolution = ADC_RESOLUTION_12B; + hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT; + hadc1.Init.GainCompensation = 0; + hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE; + hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV; + hadc1.Init.LowPowerAutoWait = DISABLE; + hadc1.Init.ContinuousConvMode = ENABLE; + hadc1.Init.NbrOfConversion = 6; + hadc1.Init.DiscontinuousConvMode = DISABLE; + hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START; + hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; + hadc1.Init.DMAContinuousRequests = ENABLE; + hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED; + hadc1.Init.OversamplingMode = DISABLE; + if (HAL_ADC_Init(&hadc1) != HAL_OK) + { + Error_Handler(); + } + + /** Configure the ADC multi-mode + */ + multimode.Mode = ADC_MODE_INDEPENDENT; + if (HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode) != HAL_OK) + { + Error_Handler(); + } + + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_5; + sConfig.Rank = ADC_REGULAR_RANK_1; + sConfig.SamplingTime = ADC_SAMPLETIME_92CYCLES_5; + sConfig.SingleDiff = ADC_SINGLE_ENDED; + sConfig.OffsetNumber = ADC_OFFSET_NONE; + sConfig.Offset = 0; + if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) + { + Error_Handler(); + } + + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_7; + sConfig.Rank = ADC_REGULAR_RANK_2; + if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) + { + Error_Handler(); + } + + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_8; + sConfig.Rank = ADC_REGULAR_RANK_3; + if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) + { + Error_Handler(); + } + + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_9; + sConfig.Rank = ADC_REGULAR_RANK_4; + if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) + { + Error_Handler(); + } + + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_12; + sConfig.Rank = ADC_REGULAR_RANK_5; + if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) + { + Error_Handler(); + } + + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_15; + sConfig.Rank = ADC_REGULAR_RANK_6; + if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN ADC1_Init 2 */ + + /* USER CODE END ADC1_Init 2 */ - /** Configure Regular Channel - */ - LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_1, LL_ADC_CHANNEL_5); - LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_5, LL_ADC_SAMPLINGTIME_92CYCLES_5); - LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_5, LL_ADC_SINGLE_ENDED); - - /** Configure Regular Channel - */ - LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_2, LL_ADC_CHANNEL_7); - LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_7, LL_ADC_SAMPLINGTIME_92CYCLES_5); - LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_7, LL_ADC_SINGLE_ENDED); - - /** Configure Regular Channel - */ - LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_3, LL_ADC_CHANNEL_8); - LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_8, LL_ADC_SAMPLINGTIME_92CYCLES_5); - LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_8, LL_ADC_SINGLE_ENDED); - - /** Configure Regular Channel - */ - LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_4, LL_ADC_CHANNEL_9); - LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_9, LL_ADC_SAMPLINGTIME_92CYCLES_5); - LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_9, LL_ADC_SINGLE_ENDED); - - /** Configure Regular Channel - */ - LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_5, LL_ADC_CHANNEL_12); - LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_12, LL_ADC_SAMPLINGTIME_92CYCLES_5); - LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_12, LL_ADC_SINGLE_ENDED); - - /** Configure Regular Channel - */ - LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_6, LL_ADC_CHANNEL_15); - LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_15, LL_ADC_SAMPLINGTIME_92CYCLES_5); - LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_15, LL_ADC_SINGLE_ENDED); - /* USER CODE BEGIN ADC1_Init 2 */ - - /* USER CODE END ADC1_Init 2 */ } /* ADC2 init function */ void MX_ADC2_Init(void) { - /* USER CODE BEGIN ADC2_Init 0 */ - - /* USER CODE END ADC2_Init 0 */ - - LL_ADC_InitTypeDef ADC_InitStruct = {0}; - LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0}; - - LL_GPIO_InitTypeDef GPIO_InitStruct = {0}; - - LL_RCC_SetADCClockSource(LL_RCC_ADC12_CLKSOURCE_SYSCLK); - - /* Peripheral clock enable */ - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_ADC12); - - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOC); - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOA); - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOB); - /**ADC2 GPIO Configuration - PC0 ------> ADC2_IN6 - PA5 ------> ADC2_IN13 - PA6 ------> ADC2_IN3 - PA7 ------> ADC2_IN4 - PB15 ------> ADC2_IN15 - */ - GPIO_InitStruct.Pin = BSE_SIGNAL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(BSE_SIGNAL_GPIO_Port, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = BSPD_SENSE_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(BSPD_SENSE_GPIO_Port, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = IMD_SENSE_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(IMD_SENSE_GPIO_Port, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = AMS_SENSE_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(AMS_SENSE_GPIO_Port, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = STEERING_ANGLE_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(STEERING_ANGLE_GPIO_Port, &GPIO_InitStruct); - - /* ADC2 DMA Init */ - - /* ADC2 Init */ - LL_DMA_SetPeriphRequest(DMA2, LL_DMA_CHANNEL_1, LL_DMAMUX_REQ_ADC2); - - LL_DMA_SetDataTransferDirection(DMA2, LL_DMA_CHANNEL_1, LL_DMA_DIRECTION_PERIPH_TO_MEMORY); - - LL_DMA_SetChannelPriorityLevel(DMA2, LL_DMA_CHANNEL_1, LL_DMA_PRIORITY_LOW); - - LL_DMA_SetMode(DMA2, LL_DMA_CHANNEL_1, LL_DMA_MODE_CIRCULAR); - - LL_DMA_SetPeriphIncMode(DMA2, LL_DMA_CHANNEL_1, LL_DMA_PERIPH_NOINCREMENT); - - LL_DMA_SetMemoryIncMode(DMA2, LL_DMA_CHANNEL_1, LL_DMA_MEMORY_INCREMENT); - - LL_DMA_SetPeriphSize(DMA2, LL_DMA_CHANNEL_1, LL_DMA_PDATAALIGN_HALFWORD); - - LL_DMA_SetMemorySize(DMA2, LL_DMA_CHANNEL_1, LL_DMA_MDATAALIGN_HALFWORD); - - /* USER CODE BEGIN ADC2_Init 1 */ - - /* USER CODE END ADC2_Init 1 */ - - /** Common config - */ - ADC_InitStruct.Resolution = LL_ADC_RESOLUTION_12B; - ADC_InitStruct.DataAlignment = LL_ADC_DATA_ALIGN_RIGHT; - ADC_InitStruct.LowPowerMode = LL_ADC_LP_MODE_NONE; - LL_ADC_Init(ADC2, &ADC_InitStruct); - ADC_REG_InitStruct.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE; - ADC_REG_InitStruct.SequencerLength = LL_ADC_REG_SEQ_SCAN_ENABLE_5RANKS; - ADC_REG_InitStruct.SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE; - ADC_REG_InitStruct.ContinuousMode = LL_ADC_REG_CONV_CONTINUOUS; - ADC_REG_InitStruct.DMATransfer = LL_ADC_REG_DMA_TRANSFER_UNLIMITED; - ADC_REG_InitStruct.Overrun = LL_ADC_REG_OVR_DATA_PRESERVED; - LL_ADC_REG_Init(ADC2, &ADC_REG_InitStruct); - LL_ADC_SetGainCompensation(ADC2, 0); - LL_ADC_SetOverSamplingScope(ADC2, LL_ADC_OVS_DISABLE); - - /* Disable ADC deep power down (enabled by default after reset state) */ - LL_ADC_DisableDeepPowerDown(ADC2); - /* Enable ADC internal voltage regulator */ - LL_ADC_EnableInternalRegulator(ADC2); - /* Delay for ADC internal voltage regulator stabilization. */ - /* Compute number of CPU cycles to wait for, from delay in us. */ - /* Note: Variable divided by 2 to compensate partially */ - /* CPU processing cycles (depends on compilation optimization). */ - /* Note: If system core clock frequency is below 200kHz, wait time */ - /* is only a few CPU processing cycles. */ - uint32_t wait_loop_index; - wait_loop_index = ((LL_ADC_DELAY_INTERNAL_REGUL_STAB_US * (SystemCoreClock / (100000 * 2))) / 10); - while (wait_loop_index != 0) { - wait_loop_index--; - } + /* USER CODE BEGIN ADC2_Init 0 */ + + /* USER CODE END ADC2_Init 0 */ + + ADC_ChannelConfTypeDef sConfig = {0}; + + /* USER CODE BEGIN ADC2_Init 1 */ + + /* USER CODE END ADC2_Init 1 */ + + /** Common config + */ + hadc2.Instance = ADC2; + hadc2.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4; + hadc2.Init.Resolution = ADC_RESOLUTION_12B; + hadc2.Init.DataAlign = ADC_DATAALIGN_RIGHT; + hadc2.Init.GainCompensation = 0; + hadc2.Init.ScanConvMode = ADC_SCAN_ENABLE; + hadc2.Init.EOCSelection = ADC_EOC_SINGLE_CONV; + hadc2.Init.LowPowerAutoWait = DISABLE; + hadc2.Init.ContinuousConvMode = ENABLE; + hadc2.Init.NbrOfConversion = 5; + hadc2.Init.DiscontinuousConvMode = DISABLE; + hadc2.Init.ExternalTrigConv = ADC_SOFTWARE_START; + hadc2.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; + hadc2.Init.DMAContinuousRequests = ENABLE; + hadc2.Init.Overrun = ADC_OVR_DATA_PRESERVED; + hadc2.Init.OversamplingMode = DISABLE; + if (HAL_ADC_Init(&hadc2) != HAL_OK) + { + Error_Handler(); + } + + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_3; + sConfig.Rank = ADC_REGULAR_RANK_1; + sConfig.SamplingTime = ADC_SAMPLETIME_92CYCLES_5; + sConfig.SingleDiff = ADC_SINGLE_ENDED; + sConfig.OffsetNumber = ADC_OFFSET_NONE; + sConfig.Offset = 0; + if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK) + { + Error_Handler(); + } + + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_4; + sConfig.Rank = ADC_REGULAR_RANK_2; + if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK) + { + Error_Handler(); + } + + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_6; + sConfig.Rank = ADC_REGULAR_RANK_3; + if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK) + { + Error_Handler(); + } + + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_13; + sConfig.Rank = ADC_REGULAR_RANK_4; + if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK) + { + Error_Handler(); + } + + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_15; + sConfig.Rank = ADC_REGULAR_RANK_5; + if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN ADC2_Init 2 */ + + /* USER CODE END ADC2_Init 2 */ + +} + +static uint32_t HAL_RCC_ADC12_CLK_ENABLED=0; + +void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle) +{ - /** Configure Regular Channel - */ - LL_ADC_REG_SetSequencerRanks(ADC2, LL_ADC_REG_RANK_1, LL_ADC_CHANNEL_3); - LL_ADC_SetChannelSamplingTime(ADC2, LL_ADC_CHANNEL_3, LL_ADC_SAMPLINGTIME_92CYCLES_5); - LL_ADC_SetChannelSingleDiff(ADC2, LL_ADC_CHANNEL_3, LL_ADC_SINGLE_ENDED); - - /** Configure Regular Channel - */ - LL_ADC_REG_SetSequencerRanks(ADC2, LL_ADC_REG_RANK_2, LL_ADC_CHANNEL_4); - LL_ADC_SetChannelSamplingTime(ADC2, LL_ADC_CHANNEL_4, LL_ADC_SAMPLINGTIME_92CYCLES_5); - LL_ADC_SetChannelSingleDiff(ADC2, LL_ADC_CHANNEL_4, LL_ADC_SINGLE_ENDED); - - /** Configure Regular Channel - */ - LL_ADC_REG_SetSequencerRanks(ADC2, LL_ADC_REG_RANK_3, LL_ADC_CHANNEL_6); - LL_ADC_SetChannelSamplingTime(ADC2, LL_ADC_CHANNEL_6, LL_ADC_SAMPLINGTIME_92CYCLES_5); - LL_ADC_SetChannelSingleDiff(ADC2, LL_ADC_CHANNEL_6, LL_ADC_SINGLE_ENDED); - - /** Configure Regular Channel - */ - LL_ADC_REG_SetSequencerRanks(ADC2, LL_ADC_REG_RANK_4, LL_ADC_CHANNEL_13); - LL_ADC_SetChannelSamplingTime(ADC2, LL_ADC_CHANNEL_13, LL_ADC_SAMPLINGTIME_92CYCLES_5); - LL_ADC_SetChannelSingleDiff(ADC2, LL_ADC_CHANNEL_13, LL_ADC_SINGLE_ENDED); - - /** Configure Regular Channel - */ - LL_ADC_REG_SetSequencerRanks(ADC2, LL_ADC_REG_RANK_5, LL_ADC_CHANNEL_15); - LL_ADC_SetChannelSamplingTime(ADC2, LL_ADC_CHANNEL_15, LL_ADC_SAMPLINGTIME_92CYCLES_5); - LL_ADC_SetChannelSingleDiff(ADC2, LL_ADC_CHANNEL_15, LL_ADC_SINGLE_ENDED); - /* USER CODE BEGIN ADC2_Init 2 */ - - /* USER CODE END ADC2_Init 2 */ + GPIO_InitTypeDef GPIO_InitStruct = {0}; + RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; + if(adcHandle->Instance==ADC1) + { + /* USER CODE BEGIN ADC1_MspInit 0 */ + + /* USER CODE END ADC1_MspInit 0 */ + + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC12; + PeriphClkInit.Adc12ClockSelection = RCC_ADC12CLKSOURCE_SYSCLK; + if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } + + /* ADC1 clock enable */ + HAL_RCC_ADC12_CLK_ENABLED++; + if(HAL_RCC_ADC12_CLK_ENABLED==1){ + __HAL_RCC_ADC12_CLK_ENABLE(); + } + + __HAL_RCC_GPIOC_CLK_ENABLE(); + __HAL_RCC_GPIOB_CLK_ENABLE(); + /**ADC1 GPIO Configuration + PC1 ------> ADC1_IN7 + PC2 ------> ADC1_IN8 + PC3 ------> ADC1_IN9 + PB0 ------> ADC1_IN15 + PB1 ------> ADC1_IN12 + PB14 ------> ADC1_IN5 + */ + GPIO_InitStruct.Pin = BSPD_SIGNAL_Pin|APPS1_SIGNAL_Pin|APPS2_SIGNAL_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); + + GPIO_InitStruct.Pin = BRAKE_D_SIGNAL_Pin|BRAKE_R_SIGNAL_Pin|AUX_SIGNAL_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); + + /* ADC1 DMA Init */ + /* ADC1 Init */ + hdma_adc1.Instance = DMA1_Channel1; + hdma_adc1.Init.Request = DMA_REQUEST_ADC1; + hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY; + hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE; + hdma_adc1.Init.MemInc = DMA_MINC_ENABLE; + hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; + hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; + hdma_adc1.Init.Mode = DMA_CIRCULAR; + hdma_adc1.Init.Priority = DMA_PRIORITY_LOW; + if (HAL_DMA_Init(&hdma_adc1) != HAL_OK) + { + Error_Handler(); + } + + __HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc1); + + /* ADC1 interrupt Init */ + HAL_NVIC_SetPriority(ADC1_2_IRQn, 15, 0); + HAL_NVIC_EnableIRQ(ADC1_2_IRQn); + /* USER CODE BEGIN ADC1_MspInit 1 */ + + /* USER CODE END ADC1_MspInit 1 */ + } + else if(adcHandle->Instance==ADC2) + { + /* USER CODE BEGIN ADC2_MspInit 0 */ + + /* USER CODE END ADC2_MspInit 0 */ + + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC12; + PeriphClkInit.Adc12ClockSelection = RCC_ADC12CLKSOURCE_SYSCLK; + if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } + + /* ADC2 clock enable */ + HAL_RCC_ADC12_CLK_ENABLED++; + if(HAL_RCC_ADC12_CLK_ENABLED==1){ + __HAL_RCC_ADC12_CLK_ENABLE(); + } + + __HAL_RCC_GPIOC_CLK_ENABLE(); + __HAL_RCC_GPIOA_CLK_ENABLE(); + __HAL_RCC_GPIOB_CLK_ENABLE(); + /**ADC2 GPIO Configuration + PC0 ------> ADC2_IN6 + PA5 ------> ADC2_IN13 + PA6 ------> ADC2_IN3 + PA7 ------> ADC2_IN4 + PB15 ------> ADC2_IN15 + */ + GPIO_InitStruct.Pin = BSE_SIGNAL_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(BSE_SIGNAL_GPIO_Port, &GPIO_InitStruct); + + GPIO_InitStruct.Pin = BPSD_SENSE_Pin|IMD_SENSE_Pin|AMS_SENSE_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + + GPIO_InitStruct.Pin = STEERING_ANGLE_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(STEERING_ANGLE_GPIO_Port, &GPIO_InitStruct); + + /* ADC2 DMA Init */ + /* ADC2 Init */ + hdma_adc2.Instance = DMA2_Channel1; + hdma_adc2.Init.Request = DMA_REQUEST_ADC2; + hdma_adc2.Init.Direction = DMA_PERIPH_TO_MEMORY; + hdma_adc2.Init.PeriphInc = DMA_PINC_DISABLE; + hdma_adc2.Init.MemInc = DMA_MINC_ENABLE; + hdma_adc2.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; + hdma_adc2.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; + hdma_adc2.Init.Mode = DMA_CIRCULAR; + hdma_adc2.Init.Priority = DMA_PRIORITY_LOW; + if (HAL_DMA_Init(&hdma_adc2) != HAL_OK) + { + Error_Handler(); + } + + __HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc2); + + /* ADC2 interrupt Init */ + HAL_NVIC_SetPriority(ADC1_2_IRQn, 15, 0); + HAL_NVIC_EnableIRQ(ADC1_2_IRQn); + /* USER CODE BEGIN ADC2_MspInit 1 */ + + /* USER CODE END ADC2_MspInit 1 */ + } +} + +void HAL_ADC_MspDeInit(ADC_HandleTypeDef* adcHandle) +{ + + if(adcHandle->Instance==ADC1) + { + /* USER CODE BEGIN ADC1_MspDeInit 0 */ + + /* USER CODE END ADC1_MspDeInit 0 */ + /* Peripheral clock disable */ + HAL_RCC_ADC12_CLK_ENABLED--; + if(HAL_RCC_ADC12_CLK_ENABLED==0){ + __HAL_RCC_ADC12_CLK_DISABLE(); + } + + /**ADC1 GPIO Configuration + PC1 ------> ADC1_IN7 + PC2 ------> ADC1_IN8 + PC3 ------> ADC1_IN9 + PB0 ------> ADC1_IN15 + PB1 ------> ADC1_IN12 + PB14 ------> ADC1_IN5 + */ + HAL_GPIO_DeInit(GPIOC, BSPD_SIGNAL_Pin|APPS1_SIGNAL_Pin|APPS2_SIGNAL_Pin); + + HAL_GPIO_DeInit(GPIOB, BRAKE_D_SIGNAL_Pin|BRAKE_R_SIGNAL_Pin|AUX_SIGNAL_Pin); + + /* ADC1 DMA DeInit */ + HAL_DMA_DeInit(adcHandle->DMA_Handle); + + /* ADC1 interrupt Deinit */ + /* USER CODE BEGIN ADC1:ADC1_2_IRQn disable */ + /** + * Uncomment the line below to disable the "ADC1_2_IRQn" interrupt + * Be aware, disabling shared interrupt may affect other IPs + */ + /* HAL_NVIC_DisableIRQ(ADC1_2_IRQn); */ + /* USER CODE END ADC1:ADC1_2_IRQn disable */ + + /* USER CODE BEGIN ADC1_MspDeInit 1 */ + + /* USER CODE END ADC1_MspDeInit 1 */ + } + else if(adcHandle->Instance==ADC2) + { + /* USER CODE BEGIN ADC2_MspDeInit 0 */ + + /* USER CODE END ADC2_MspDeInit 0 */ + /* Peripheral clock disable */ + HAL_RCC_ADC12_CLK_ENABLED--; + if(HAL_RCC_ADC12_CLK_ENABLED==0){ + __HAL_RCC_ADC12_CLK_DISABLE(); + } + + /**ADC2 GPIO Configuration + PC0 ------> ADC2_IN6 + PA5 ------> ADC2_IN13 + PA6 ------> ADC2_IN3 + PA7 ------> ADC2_IN4 + PB15 ------> ADC2_IN15 + */ + HAL_GPIO_DeInit(BSE_SIGNAL_GPIO_Port, BSE_SIGNAL_Pin); + + HAL_GPIO_DeInit(GPIOA, BPSD_SENSE_Pin|IMD_SENSE_Pin|AMS_SENSE_Pin); + + HAL_GPIO_DeInit(STEERING_ANGLE_GPIO_Port, STEERING_ANGLE_Pin); + + /* ADC2 DMA DeInit */ + HAL_DMA_DeInit(adcHandle->DMA_Handle); + + /* ADC2 interrupt Deinit */ + /* USER CODE BEGIN ADC2:ADC1_2_IRQn disable */ + /** + * Uncomment the line below to disable the "ADC1_2_IRQn" interrupt + * Be aware, disabling shared interrupt may affect other IPs + */ + /* HAL_NVIC_DisableIRQ(ADC1_2_IRQn); */ + /* USER CODE END ADC2:ADC1_2_IRQn disable */ + + /* USER CODE BEGIN ADC2_MspDeInit 1 */ + + /* USER CODE END ADC2_MspDeInit 1 */ + } } /* USER CODE BEGIN 1 */ +void ADC_UpdateAnalogValues_EMA(volatile uint16_t *ADC_buffers, uint8_t num_signals, float alpha, volatile uint16_t *ADC_outputs) +{ + for (uint8_t i = 0; i < num_signals; i++) { + // Apply EMA formula: EMA_new = alpha * ADC_new + (1 - alpha) * EMA_old + ADC_outputs[i] = (uint16_t)(alpha * ADC_buffers[i] + (1.0f - alpha) * ADC_outputs[i]); + } +} + /* USER CODE END 1 */ + diff --git a/ECU/Core/Src/dma.c b/ECU/Core/Src/dma.c index 2e480d9a2..83fe3abc8 100644 --- a/ECU/Core/Src/dma.c +++ b/ECU/Core/Src/dma.c @@ -34,18 +34,27 @@ /* USER CODE END 1 */ /** - * Enable DMA controller clock - */ + * Enable DMA controller clock + */ void MX_DMA_Init(void) { - /* Init with LL driver */ - /* DMA controller clock enable */ - LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMAMUX1); - LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA1); - LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA2); + /* DMA controller clock enable */ + __HAL_RCC_DMAMUX1_CLK_ENABLE(); + __HAL_RCC_DMA1_CLK_ENABLE(); + __HAL_RCC_DMA2_CLK_ENABLE(); + + /* DMA interrupt init */ + /* DMA1_Channel1_IRQn interrupt configuration */ + HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0); + HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn); + /* DMA2_Channel1_IRQn interrupt configuration */ + HAL_NVIC_SetPriority(DMA2_Channel1_IRQn, 0, 0); + HAL_NVIC_EnableIRQ(DMA2_Channel1_IRQn); + } /* USER CODE BEGIN 2 */ /* USER CODE END 2 */ + diff --git a/ECU/Core/Src/fdcan.c b/ECU/Core/Src/fdcan.c index 2a66c7caf..0aa3688de 100644 --- a/ECU/Core/Src/fdcan.c +++ b/ECU/Core/Src/fdcan.c @@ -31,207 +31,226 @@ FDCAN_HandleTypeDef hfdcan2; void MX_FDCAN1_Init(void) { - /* USER CODE BEGIN FDCAN1_Init 0 */ - - /* USER CODE END FDCAN1_Init 0 */ - - /* USER CODE BEGIN FDCAN1_Init 1 */ - - /* USER CODE END FDCAN1_Init 1 */ - hfdcan1.Instance = FDCAN1; - hfdcan1.Init.ClockDivider = FDCAN_CLOCK_DIV1; - hfdcan1.Init.FrameFormat = FDCAN_FRAME_CLASSIC; - hfdcan1.Init.Mode = FDCAN_MODE_NORMAL; - hfdcan1.Init.AutoRetransmission = ENABLE; - hfdcan1.Init.TransmitPause = DISABLE; - hfdcan1.Init.ProtocolException = ENABLE; - hfdcan1.Init.NominalPrescaler = 1; - hfdcan1.Init.NominalSyncJumpWidth = 16; - hfdcan1.Init.NominalTimeSeg1 = 119; - hfdcan1.Init.NominalTimeSeg2 = 40; - hfdcan1.Init.DataPrescaler = 8; - hfdcan1.Init.DataSyncJumpWidth = 16; - hfdcan1.Init.DataTimeSeg1 = 14; - hfdcan1.Init.DataTimeSeg2 = 5; - hfdcan1.Init.StdFiltersNbr = 0; - hfdcan1.Init.ExtFiltersNbr = 2; - hfdcan1.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION; - if (HAL_FDCAN_Init(&hfdcan1) != HAL_OK) { - Error_Handler(); - } - /* USER CODE BEGIN FDCAN1_Init 2 */ - - /* USER CODE END FDCAN1_Init 2 */ + /* USER CODE BEGIN FDCAN1_Init 0 */ + + /* USER CODE END FDCAN1_Init 0 */ + + /* USER CODE BEGIN FDCAN1_Init 1 */ + + /* USER CODE END FDCAN1_Init 1 */ + hfdcan1.Instance = FDCAN1; + hfdcan1.Init.ClockDivider = FDCAN_CLOCK_DIV1; + hfdcan1.Init.FrameFormat = FDCAN_FRAME_FD_NO_BRS; + hfdcan1.Init.Mode = FDCAN_MODE_NORMAL; + hfdcan1.Init.AutoRetransmission = ENABLE; + hfdcan1.Init.TransmitPause = DISABLE; + hfdcan1.Init.ProtocolException = ENABLE; + hfdcan1.Init.NominalPrescaler = 1; + hfdcan1.Init.NominalSyncJumpWidth = 16; + hfdcan1.Init.NominalTimeSeg1 = 119; + hfdcan1.Init.NominalTimeSeg2 = 40; + hfdcan1.Init.DataPrescaler = 1; + hfdcan1.Init.DataSyncJumpWidth = 16; + hfdcan1.Init.DataTimeSeg1 = 9; + hfdcan1.Init.DataTimeSeg2 = 10; + hfdcan1.Init.StdFiltersNbr = 0; + hfdcan1.Init.ExtFiltersNbr = 3; + hfdcan1.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION; + if (HAL_FDCAN_Init(&hfdcan1) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN FDCAN1_Init 2 */ + + /* USER CODE END FDCAN1_Init 2 */ + } /* FDCAN2 init function */ void MX_FDCAN2_Init(void) { - /* USER CODE BEGIN FDCAN2_Init 0 */ - - /* USER CODE END FDCAN2_Init 0 */ - - /* USER CODE BEGIN FDCAN2_Init 1 */ - - /* USER CODE END FDCAN2_Init 1 */ - hfdcan2.Instance = FDCAN2; - hfdcan2.Init.ClockDivider = FDCAN_CLOCK_DIV1; - hfdcan2.Init.FrameFormat = FDCAN_FRAME_CLASSIC; - hfdcan2.Init.Mode = FDCAN_MODE_NORMAL; - hfdcan2.Init.AutoRetransmission = ENABLE; - hfdcan2.Init.TransmitPause = DISABLE; - hfdcan2.Init.ProtocolException = ENABLE; - hfdcan2.Init.NominalPrescaler = 1; - hfdcan2.Init.NominalSyncJumpWidth = 16; - hfdcan2.Init.NominalTimeSeg1 = 119; - hfdcan2.Init.NominalTimeSeg2 = 40; - hfdcan2.Init.DataPrescaler = 8; - hfdcan2.Init.DataSyncJumpWidth = 16; - hfdcan2.Init.DataTimeSeg1 = 14; - hfdcan2.Init.DataTimeSeg2 = 5; - hfdcan2.Init.StdFiltersNbr = 0; - hfdcan2.Init.ExtFiltersNbr = 2; - hfdcan2.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION; - if (HAL_FDCAN_Init(&hfdcan2) != HAL_OK) { - Error_Handler(); - } - /* USER CODE BEGIN FDCAN2_Init 2 */ - - /* USER CODE END FDCAN2_Init 2 */ + /* USER CODE BEGIN FDCAN2_Init 0 */ + + /* USER CODE END FDCAN2_Init 0 */ + + /* USER CODE BEGIN FDCAN2_Init 1 */ + + /* USER CODE END FDCAN2_Init 1 */ + hfdcan2.Instance = FDCAN2; + hfdcan2.Init.ClockDivider = FDCAN_CLOCK_DIV1; + hfdcan2.Init.FrameFormat = FDCAN_FRAME_CLASSIC; + hfdcan2.Init.Mode = FDCAN_MODE_NORMAL; + hfdcan2.Init.AutoRetransmission = DISABLE; + hfdcan2.Init.TransmitPause = DISABLE; + hfdcan2.Init.ProtocolException = DISABLE; + hfdcan2.Init.NominalPrescaler = 16; + hfdcan2.Init.NominalSyncJumpWidth = 1; + hfdcan2.Init.NominalTimeSeg1 = 1; + hfdcan2.Init.NominalTimeSeg2 = 1; + hfdcan2.Init.DataPrescaler = 1; + hfdcan2.Init.DataSyncJumpWidth = 1; + hfdcan2.Init.DataTimeSeg1 = 1; + hfdcan2.Init.DataTimeSeg2 = 1; + hfdcan2.Init.StdFiltersNbr = 0; + hfdcan2.Init.ExtFiltersNbr = 0; + hfdcan2.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION; + if (HAL_FDCAN_Init(&hfdcan2) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN FDCAN2_Init 2 */ + + /* USER CODE END FDCAN2_Init 2 */ + } -static uint32_t HAL_RCC_FDCAN_CLK_ENABLED = 0; +static uint32_t HAL_RCC_FDCAN_CLK_ENABLED=0; -void HAL_FDCAN_MspInit(FDCAN_HandleTypeDef *fdcanHandle) +void HAL_FDCAN_MspInit(FDCAN_HandleTypeDef* fdcanHandle) { - GPIO_InitTypeDef GPIO_InitStruct = {0}; - if (fdcanHandle->Instance == FDCAN1) { - /* USER CODE BEGIN FDCAN1_MspInit 0 */ - - /* USER CODE END FDCAN1_MspInit 0 */ - LL_RCC_SetFDCANClockSource(LL_RCC_FDCAN_CLKSOURCE_PCLK1); - - /* FDCAN1 clock enable */ - HAL_RCC_FDCAN_CLK_ENABLED++; - if (HAL_RCC_FDCAN_CLK_ENABLED == 1) { - __HAL_RCC_FDCAN_CLK_ENABLE(); - } - - __HAL_RCC_GPIOA_CLK_ENABLE(); - /**FDCAN1 GPIO Configuration - PA11 ------> FDCAN1_RX - PA12 ------> FDCAN1_TX - */ - GPIO_InitStruct.Pin = GPIO_PIN_11; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_PULLUP; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; - GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN1; - HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = GPIO_PIN_12; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; - GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN1; - HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); - - /* FDCAN1 interrupt Init */ - HAL_NVIC_SetPriority(FDCAN1_IT0_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(FDCAN1_IT0_IRQn); - /* USER CODE BEGIN FDCAN1_MspInit 1 */ - - /* USER CODE END FDCAN1_MspInit 1 */ - } else if (fdcanHandle->Instance == FDCAN2) { - /* USER CODE BEGIN FDCAN2_MspInit 0 */ - - /* USER CODE END FDCAN2_MspInit 0 */ - - LL_RCC_SetFDCANClockSource(LL_RCC_FDCAN_CLKSOURCE_PCLK1); - - /* FDCAN2 clock enable */ - HAL_RCC_FDCAN_CLK_ENABLED++; - if (HAL_RCC_FDCAN_CLK_ENABLED == 1) { - __HAL_RCC_FDCAN_CLK_ENABLE(); - } - - __HAL_RCC_GPIOB_CLK_ENABLE(); - /**FDCAN2 GPIO Configuration - PB12 ------> FDCAN2_RX - PB13 ------> FDCAN2_TX - */ - GPIO_InitStruct.Pin = GPIO_PIN_12; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_PULLUP; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; - GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN2; - HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); - - GPIO_InitStruct.Pin = GPIO_PIN_13; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; - GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN2; - HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); - - /* FDCAN2 interrupt Init */ - HAL_NVIC_SetPriority(FDCAN2_IT0_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(FDCAN2_IT0_IRQn); - /* USER CODE BEGIN FDCAN2_MspInit 1 */ - - /* USER CODE END FDCAN2_MspInit 1 */ - } + GPIO_InitTypeDef GPIO_InitStruct = {0}; + RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; + if(fdcanHandle->Instance==FDCAN1) + { + /* USER CODE BEGIN FDCAN1_MspInit 0 */ + + /* USER CODE END FDCAN1_MspInit 0 */ + + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_FDCAN; + PeriphClkInit.FdcanClockSelection = RCC_FDCANCLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } + + /* FDCAN1 clock enable */ + HAL_RCC_FDCAN_CLK_ENABLED++; + if(HAL_RCC_FDCAN_CLK_ENABLED==1){ + __HAL_RCC_FDCAN_CLK_ENABLE(); + } + + __HAL_RCC_GPIOA_CLK_ENABLE(); + /**FDCAN1 GPIO Configuration + PA11 ------> FDCAN1_RX + PA12 ------> FDCAN1_TX + */ + GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_12; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN1; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + + /* FDCAN1 interrupt Init */ + HAL_NVIC_SetPriority(FDCAN1_IT0_IRQn, 15, 0); + HAL_NVIC_EnableIRQ(FDCAN1_IT0_IRQn); + HAL_NVIC_SetPriority(FDCAN1_IT1_IRQn, 15, 0); + HAL_NVIC_EnableIRQ(FDCAN1_IT1_IRQn); + /* USER CODE BEGIN FDCAN1_MspInit 1 */ + + /* USER CODE END FDCAN1_MspInit 1 */ + } + else if(fdcanHandle->Instance==FDCAN2) + { + /* USER CODE BEGIN FDCAN2_MspInit 0 */ + + /* USER CODE END FDCAN2_MspInit 0 */ + + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_FDCAN; + PeriphClkInit.FdcanClockSelection = RCC_FDCANCLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } + + /* FDCAN2 clock enable */ + HAL_RCC_FDCAN_CLK_ENABLED++; + if(HAL_RCC_FDCAN_CLK_ENABLED==1){ + __HAL_RCC_FDCAN_CLK_ENABLE(); + } + + __HAL_RCC_GPIOB_CLK_ENABLE(); + /**FDCAN2 GPIO Configuration + PB12 ------> FDCAN2_RX + PB13 ------> FDCAN2_TX + */ + GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN2; + HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); + + /* FDCAN2 interrupt Init */ + HAL_NVIC_SetPriority(FDCAN2_IT0_IRQn, 15, 0); + HAL_NVIC_EnableIRQ(FDCAN2_IT0_IRQn); + HAL_NVIC_SetPriority(FDCAN2_IT1_IRQn, 15, 0); + HAL_NVIC_EnableIRQ(FDCAN2_IT1_IRQn); + /* USER CODE BEGIN FDCAN2_MspInit 1 */ + + /* USER CODE END FDCAN2_MspInit 1 */ + } } -void HAL_FDCAN_MspDeInit(FDCAN_HandleTypeDef *fdcanHandle) +void HAL_FDCAN_MspDeInit(FDCAN_HandleTypeDef* fdcanHandle) { - if (fdcanHandle->Instance == FDCAN1) { - /* USER CODE BEGIN FDCAN1_MspDeInit 0 */ - - /* USER CODE END FDCAN1_MspDeInit 0 */ - /* Peripheral clock disable */ - HAL_RCC_FDCAN_CLK_ENABLED--; - if (HAL_RCC_FDCAN_CLK_ENABLED == 0) { - __HAL_RCC_FDCAN_CLK_DISABLE(); - } - - /**FDCAN1 GPIO Configuration - PA11 ------> FDCAN1_RX - PA12 ------> FDCAN1_TX - */ - HAL_GPIO_DeInit(GPIOA, GPIO_PIN_11 | GPIO_PIN_12); - - /* FDCAN1 interrupt Deinit */ - HAL_NVIC_DisableIRQ(FDCAN1_IT0_IRQn); - /* USER CODE BEGIN FDCAN1_MspDeInit 1 */ - - /* USER CODE END FDCAN1_MspDeInit 1 */ - } else if (fdcanHandle->Instance == FDCAN2) { - /* USER CODE BEGIN FDCAN2_MspDeInit 0 */ - - /* USER CODE END FDCAN2_MspDeInit 0 */ - /* Peripheral clock disable */ - HAL_RCC_FDCAN_CLK_ENABLED--; - if (HAL_RCC_FDCAN_CLK_ENABLED == 0) { - __HAL_RCC_FDCAN_CLK_DISABLE(); - } - - /**FDCAN2 GPIO Configuration - PB12 ------> FDCAN2_RX - PB13 ------> FDCAN2_TX - */ - HAL_GPIO_DeInit(GPIOB, GPIO_PIN_12 | GPIO_PIN_13); - - /* FDCAN2 interrupt Deinit */ - HAL_NVIC_DisableIRQ(FDCAN2_IT0_IRQn); - /* USER CODE BEGIN FDCAN2_MspDeInit 1 */ - - /* USER CODE END FDCAN2_MspDeInit 1 */ - } + if(fdcanHandle->Instance==FDCAN1) + { + /* USER CODE BEGIN FDCAN1_MspDeInit 0 */ + + /* USER CODE END FDCAN1_MspDeInit 0 */ + /* Peripheral clock disable */ + HAL_RCC_FDCAN_CLK_ENABLED--; + if(HAL_RCC_FDCAN_CLK_ENABLED==0){ + __HAL_RCC_FDCAN_CLK_DISABLE(); + } + + /**FDCAN1 GPIO Configuration + PA11 ------> FDCAN1_RX + PA12 ------> FDCAN1_TX + */ + HAL_GPIO_DeInit(GPIOA, GPIO_PIN_11|GPIO_PIN_12); + + /* FDCAN1 interrupt Deinit */ + HAL_NVIC_DisableIRQ(FDCAN1_IT0_IRQn); + HAL_NVIC_DisableIRQ(FDCAN1_IT1_IRQn); + /* USER CODE BEGIN FDCAN1_MspDeInit 1 */ + + /* USER CODE END FDCAN1_MspDeInit 1 */ + } + else if(fdcanHandle->Instance==FDCAN2) + { + /* USER CODE BEGIN FDCAN2_MspDeInit 0 */ + + /* USER CODE END FDCAN2_MspDeInit 0 */ + /* Peripheral clock disable */ + HAL_RCC_FDCAN_CLK_ENABLED--; + if(HAL_RCC_FDCAN_CLK_ENABLED==0){ + __HAL_RCC_FDCAN_CLK_DISABLE(); + } + + /**FDCAN2 GPIO Configuration + PB12 ------> FDCAN2_RX + PB13 ------> FDCAN2_TX + */ + HAL_GPIO_DeInit(GPIOB, GPIO_PIN_12|GPIO_PIN_13); + + /* FDCAN2 interrupt Deinit */ + HAL_NVIC_DisableIRQ(FDCAN2_IT0_IRQn); + HAL_NVIC_DisableIRQ(FDCAN2_IT1_IRQn); + /* USER CODE BEGIN FDCAN2_MspDeInit 1 */ + + /* USER CODE END FDCAN2_MspDeInit 1 */ + } } /* USER CODE BEGIN 1 */ /* USER CODE END 1 */ + diff --git a/ECU/Core/Src/gpio.c b/ECU/Core/Src/gpio.c index caf5db01c..cd217a038 100644 --- a/ECU/Core/Src/gpio.c +++ b/ECU/Core/Src/gpio.c @@ -33,241 +33,98 @@ /* USER CODE END 1 */ /** Configure pins as - * Analog - * Input - * Output - * EVENT_OUT - * EXTI - * Free pins are configured automatically as Analog (this feature is enabled - * through the Code Generation settings) - */ + * Analog + * Input + * Output + * EVENT_OUT + * EXTI + * Free pins are configured automatically as Analog (this feature is enabled through + * the Code Generation settings) +*/ void MX_GPIO_Init(void) { - LL_GPIO_InitTypeDef GPIO_InitStruct = {0}; - - /* GPIO Ports Clock Enable */ - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOC); - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOF); - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOG); - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOA); - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOB); - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOD); - - /**/ - LL_GPIO_ResetOutputPin(LED_TEST_GPIO_Port, LED_TEST_Pin); - - /**/ - LL_GPIO_ResetOutputPin(BRAKE_LIGHT_GPIO_Port, BRAKE_LIGHT_Pin); - - /**/ - LL_GPIO_ResetOutputPin(TSSI_G_CONTROL_GPIO_Port, TSSI_G_CONTROL_Pin); - - /**/ - LL_GPIO_ResetOutputPin(TSSI_R_CONTROL_GPIO_Port, TSSI_R_CONTROL_Pin); - - /**/ - LL_GPIO_ResetOutputPin(RTD_CONTROL_GPIO_Port, RTD_CONTROL_Pin); - - /**/ - LL_GPIO_ResetOutputPin(AUX_CONTROL_GPIO_Port, AUX_CONTROL_Pin); - - /**/ - LL_GPIO_SetOutputPin(SOFTWARE_OK_CONTROL_GPIO_Port, SOFTWARE_OK_CONTROL_Pin); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_13; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_14; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_15; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_10; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOG, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_0; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOA, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_1; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOA, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_4; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOA, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_4; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_5; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_2; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOB, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_10; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOB, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LED_TEST_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT; - GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(LED_TEST_GPIO_Port, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_6; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_7; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_8; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_9; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_8; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOA, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_9; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOA, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_10; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOA, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_15; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOA, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_10; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_11; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_12; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOC, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = LL_GPIO_PIN_2; - GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(GPIOD, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = BRAKE_LIGHT_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT; - GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(BRAKE_LIGHT_GPIO_Port, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = TSSI_G_CONTROL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT; - GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(TSSI_G_CONTROL_GPIO_Port, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = TSSI_R_CONTROL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT; - GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(TSSI_R_CONTROL_GPIO_Port, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = RTD_CONTROL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT; - GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(RTD_CONTROL_GPIO_Port, &GPIO_InitStruct); - - /**/ - GPIO_InitStruct.Pin = AUX_CONTROL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT; - GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(AUX_CONTROL_GPIO_Port, &GPIO_InitStruct); + GPIO_InitTypeDef GPIO_InitStruct = {0}; + + /* GPIO Ports Clock Enable */ + __HAL_RCC_GPIOC_CLK_ENABLE(); + __HAL_RCC_GPIOF_CLK_ENABLE(); + __HAL_RCC_GPIOG_CLK_ENABLE(); + __HAL_RCC_GPIOA_CLK_ENABLE(); + __HAL_RCC_GPIOB_CLK_ENABLE(); + __HAL_RCC_GPIOD_CLK_ENABLE(); + + /*Configure GPIO pin Output Level */ + HAL_GPIO_WritePin(GPIOB, LED_TEST_Pin|BRAKE_LIGHT_Pin|TSSI_G_CONTROL_Pin|TSSI_R_CONTROL_Pin + |RTD_CONTROL_Pin|AUX_CONTROL_Pin|SOFTWARE_OK_CONTROL_Pin, GPIO_PIN_RESET); + + /*Configure GPIO pin Output Level */ + HAL_GPIO_WritePin(GPIOA, RTD_BTN_LED_CONTROL_Pin|TS_ACTIVE_BTN_LED_CONTROL_Pin, GPIO_PIN_RESET); + + /*Configure GPIO pins : PC13 PC14 PC15 PC4 + PC5 PC6 PC7 PC8 + PC9 */ + GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_4 + |GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8 + |GPIO_PIN_9; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); + + /*Configure GPIO pin : PG10 */ + GPIO_InitStruct.Pin = GPIO_PIN_10; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOG, &GPIO_InitStruct); + + /*Configure GPIO pins : PA0 PA1 PA2 PA3 + PA4 PA10 */ + GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3 + |GPIO_PIN_4|GPIO_PIN_10; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + + /*Configure GPIO pins : PB2 PB10 */ + GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_10; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); + + /*Configure GPIO pins : LED_TEST_Pin BRAKE_LIGHT_Pin TSSI_G_CONTROL_Pin TSSI_R_CONTROL_Pin + RTD_CONTROL_Pin AUX_CONTROL_Pin SOFTWARE_OK_CONTROL_Pin */ + GPIO_InitStruct.Pin = LED_TEST_Pin|BRAKE_LIGHT_Pin|TSSI_G_CONTROL_Pin|TSSI_R_CONTROL_Pin + |RTD_CONTROL_Pin|AUX_CONTROL_Pin|SOFTWARE_OK_CONTROL_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); + + /*Configure GPIO pins : RTD_BTN_LED_CONTROL_Pin TS_ACTIVE_BTN_LED_CONTROL_Pin */ + GPIO_InitStruct.Pin = RTD_BTN_LED_CONTROL_Pin|TS_ACTIVE_BTN_LED_CONTROL_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + + /*Configure GPIO pin : ESTOP_SENSE_Pin */ + GPIO_InitStruct.Pin = ESTOP_SENSE_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_INPUT; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(ESTOP_SENSE_GPIO_Port, &GPIO_InitStruct); + + /*Configure GPIO pins : INERTIA_SW_SENSE_Pin RTD_BTN_SENSE_Pin TS_ACTIVE_BTN_SENSE_Pin */ + GPIO_InitStruct.Pin = INERTIA_SW_SENSE_Pin|RTD_BTN_SENSE_Pin|TS_ACTIVE_BTN_SENSE_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_INPUT; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); + + /*Configure GPIO pin : PD2 */ + GPIO_InitStruct.Pin = GPIO_PIN_2; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); - /**/ - GPIO_InitStruct.Pin = SOFTWARE_OK_CONTROL_Pin; - GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT; - GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL; - GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; - LL_GPIO_Init(SOFTWARE_OK_CONTROL_GPIO_Port, &GPIO_InitStruct); } /* USER CODE BEGIN 2 */ diff --git a/ECU/Core/Src/main.c b/ECU/Core/Src/main.c index aa8f6f89b..ded0c9c4a 100644 --- a/ECU/Core/Src/main.c +++ b/ECU/Core/Src/main.c @@ -18,17 +18,10 @@ /* USER CODE END Header */ /* Includes ------------------------------------------------------------------*/ #include "main.h" - -#include "GRCAN_BUS_ID.h" -#include "GRCAN_MSG_DATA.h" -#include "GRCAN_NODE_ID.h" -#include "StateData.h" -#include "StateTicks.h" #include "adc.h" #include "dma.h" #include "fdcan.h" #include "gpio.h" -#include "gr_adc.h" /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ @@ -36,16 +29,18 @@ #include "CANdler.h" #include "CANutils.h" +#include "CubeCAN.h" #include "Lights.h" #include "Logomatic.h" #include "Pinging.h" #include "Plan_C.h" +#include "StateData.h" #include "StateTicks.h" #include "StateUtils.h" #include "adc.h" -#include "can.h" +#include "fdcan.h" #include "stm32g4xx_hal.h" -#include "vcp.h" +// #include "vcp.h" /* USER CODE END Includes */ /* Private typedef -----------------------------------------------------------*/ @@ -66,48 +61,31 @@ /* Private variables ---------------------------------------------------------*/ /* USER CODE BEGIN PV */ -LogomaticConfig logomaticConfig = {.clock_source = LOGOMATIC_PCLK1, - .bus = LOGOMATIC_BUS, - .gpio_port = LOGOMATIC_GPIOA, - .gpio_pin_rx_tx_mask = LL_GPIO_PIN_9 | LL_GPIO_PIN_10, - .baud_rate = 115200, - .data_width = LOGOMATIC_DATAWIDTH_8B, - .stop_bits = LOGOMATIC_STOPBITS_1, - .parity = LOGOMATIC_PARITY_NONE, - .transfer_direction = LOGOMATIC_DIRECTION_TX, - .hardware_flow_control = LOGOMATIC_HWCONTROL_NONE, - .prescaler = LOGOMATIC_PRESCALER_DIV1, - .tx_fifo_threshold = LOGOMATIC_FIFOTHRESHOLD_1_8, - .rx_fifo_threshold = LOGOMATIC_FIFOTHRESHOLD_1_8}; - -VCP_Config vcp_config = {.baud_rate = 2000000, - .clock_source = VCP_CLOCK_PCLK, - .gpio_tx_rx_pin_mask = LL_GPIO_PIN_2 | LL_GPIO_PIN_3, - .bus_port = VCP_Port_A, - .parity = VCP_Parity_None, - .prescaler = VCP_Prescalar_Div2, - .stop_bits = VCP_StopBits_1, - .oversampling = VCP_Oversampling_16, - .tx_fifo_threshold = VCP_Threshold_1_8, - .rx_fifo_threshold = VCP_Threshold_1_8, - .alternate_function = LL_GPIO_AF_7, - .rx_callback = NULL}; -/* USER CODE END PV */ -// ADC 1 -#define WINDOW_SIZE 10 // weighted average for now can extend to other window functions -#define NUM_SIGNALS_ADC1 7 -#define NUM_SIGNALS_ADC2 4 +// VCP_Config vcp_config = {.baud_rate = 2000000, +// .clock_source = VCP_CLOCK_PCLK, +// .gpio_tx_rx_pin_mask = LL_GPIO_PIN_2 | LL_GPIO_PIN_3, +// .bus_port = VCP_Port_A, +// .parity = VCP_Parity_None, +// .prescaler = VCP_Prescalar_Div2, +// .stop_bits = VCP_StopBits_1, +// .oversampling = VCP_Oversampling_16, +// .tx_fifo_threshold = VCP_Threshold_1_8, +// .rx_fifo_threshold = VCP_Threshold_1_8, +// .alternate_function = LL_GPIO_AF_7, +// .rx_callback = NULL}; + +#define NUM_SIGNALS_ADC1 6 +#define NUM_SIGNALS_ADC2 5 #define NUM_SIGNALS (NUM_SIGNALS_ADC1 + NUM_SIGNALS_ADC2) -// TODO: check which data size to use (floats...ints...etc) -volatile uint16_t ADC_buffers[NUM_SIGNALS] = {1024}; // Contains new values -uint16_t ADC_outputs[NUM_SIGNALS] = {1024}; // Updated averages - -// DIGITAL +volatile uint16_t ADC_buffers[NUM_SIGNALS] = {0}; +volatile uint16_t ADC_outputs[NUM_SIGNALS] = {0}; // STATE DATA extern ECU_StateData stateLump; +/* USER CODE END PV */ + /* Private function prototypes -----------------------------------------------*/ void SystemClock_Config(void); /* USER CODE BEGIN PFP */ @@ -117,86 +95,8 @@ void SystemClock_Config(void); /* Private user code ---------------------------------------------------------*/ /* USER CODE BEGIN 0 */ -/* USER CODE END 0 */ - -// TODO: state data stores stuff as either FLOATS or BOOLS...check -// TODO: TS and RTD button signals will come over CAN -void ADC_Logomatic(void) -{ - static uint16_t min_apps_1 = 4095; - static uint16_t min_apps_2 = 4095; - if (stateLump.APPS1_Signal < min_apps_1) { - min_apps_1 = stateLump.APPS1_Signal; - } - if (stateLump.APPS2_Signal < min_apps_2) { - min_apps_2 = stateLump.APPS2_Signal; - } - static uint16_t max_apps_1 = 0; - static uint16_t max_apps_2 = 0; - if (stateLump.APPS1_Signal > max_apps_1) { - max_apps_1 = stateLump.APPS1_Signal; - } - if (stateLump.APPS2_Signal > max_apps_2) { - max_apps_2 = stateLump.APPS2_Signal; - } - static uint16_t min_BSE = 4095; - if (stateLump.bse_signal < min_BSE) { - min_BSE = stateLump.bse_signal; - } - static uint16_t max_BSE = 0; - if (stateLump.bse_signal > max_BSE) { - max_BSE = stateLump.bse_signal; - } - - static uint16_t min_BR = 4095; - if (stateLump.Brake_R_Signal < min_BR) { - min_BR = stateLump.Brake_R_Signal; - } - static uint16_t max_BR = 0; - if (stateLump.Brake_R_Signal > max_BR) { - max_BR = stateLump.Brake_R_Signal; - } - - static uint16_t min_BF = 4095; - if (stateLump.Brake_F_Signal < min_BF) { - min_BF = stateLump.Brake_F_Signal; - } - static uint16_t max_BF = 0; - if (stateLump.Brake_F_Signal > max_BF) { - max_BF = stateLump.Brake_F_Signal; - } - - static uint16_t min_BSPD = 4095; - if (stateLump.bspd_signal < min_BSPD) { - min_BSPD = stateLump.bspd_signal; - } - static uint16_t max_BSPD = 0; - if (stateLump.bspd_signal > max_BSPD) { - max_BSPD = stateLump.bspd_signal; - } - - LOGOMATIC("APPS1 %d (min %d, max %d) APPS2 %d (min %d, max %d) BSE %d (min %d, max %d) BSPD %d (min %d, max %d) Brake F %d (min %d, max %d), Brake R %d (min %d, max %d), Aux %d, Steering " - "Angle %d\n", - stateLump.APPS1_Signal, min_apps_1, max_apps_1, stateLump.APPS2_Signal, min_apps_2, max_apps_2, stateLump.bse_signal, min_BSE, max_BSE, stateLump.bspd_signal, min_BSPD, max_BSPD, - stateLump.Brake_F_Signal, min_BF, max_BF, stateLump.Brake_R_Signal, min_BR, max_BR, stateLump.aux_signal, stateLump.steering_angle_signal); - - // static float travel1 = 0; - // static float travel2 = 0; - // static float travel = 0; - // travel1 = (stateLump.APPS1_Signal - THROTTLE_MIN_1) * (1.0f - 0.0f) / (THROTTLE_MAX_1 - THROTTLE_MIN_1) + 0.0f; - // travel2 = (stateLump.APPS2_Signal - THROTTLE_MIN_2) * (1.0f - 0.0f) / (THROTTLE_MAX_2 - THROTTLE_MIN_2) + 0.0f; - // travel = (travel1 + travel2) / 2.0f; - // LOGOMATIC("APPS1 Travel %f, APPS2 Travel %f, Average Travel %f\n", travel1, travel2, travel); -} - -void read_digital(void) -{ - stateLump.estop_sense = LL_GPIO_IsInputPinSet(ESTOP_SENSE_GPIO_Port, ESTOP_SENSE_Pin); -} - void write_adc_values_to_state_data(void) { - // analog stateLump.bse_signal = ADC_outputs[ADC_BUFFER_SIG_BSE]; stateLump.bspd_signal = ADC_outputs[ADC_BUFFER_SIG_BSPD]; stateLump.APPS1_Signal = ADC_outputs[ADC_BUFFER_SIG_APPS1]; @@ -204,298 +104,80 @@ void write_adc_values_to_state_data(void) stateLump.Brake_F_Signal = ADC_outputs[ADC_BUFFER_SIG_BRAKE_F]; stateLump.Brake_R_Signal = ADC_outputs[ADC_BUFFER_SIG_BRAKE_R]; stateLump.aux_signal = ADC_outputs[ADC_BUFFER_SIG_AUX]; - stateLump.steering_angle_signal = ADC_outputs[ADC_BUFFER_SIG_STEERING_ANGLE]; // TODO: convert to rad/deg...? + stateLump.steering_angle_signal = ADC_outputs[ADC_BUFFER_SIG_STEERING_ANGLE]; - // TODO: determine conversion factors for all of these (uint to float) - stateLump.bspd_sense = ADC_outputs[ADC_BUFFER_SENSE_BSPD] / 4095.0 * 3.3; - stateLump.imd_sense = ADC_outputs[ADC_BUFFER_SENSE_IMD] / 4095.0 * 3.3; - stateLump.bms_sense = ADC_outputs[ADC_BUFFER_SENSE_BMS] / 4095.0 * 3.3; + stateLump.bspd_sense = ADC_outputs[ADC_BUFFER_SENSE_BSPD] / 4095.0f * 3.3f; + stateLump.imd_sense = ADC_outputs[ADC_BUFFER_SENSE_IMD] / 4095.0f * 3.3f; + stateLump.bms_sense = ADC_outputs[ADC_BUFFER_SENSE_BMS] / 4095.0f * 3.3f; } void ADC_Configure(void) { - // Initialize which clock source to use - LL_RCC_SetADCClockSource(LL_RCC_ADC12_CLKSOURCE_SYSCLK); - /* Peripheral clock enable */ - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_ADC12); - LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOA); - - // ADC 1 - ADC_Init_Values Init_Vals_ADC1 = {0}; - Init_Vals_ADC1.ADC = ADC1; - Init_Vals_ADC1.PS_Value = PS_8; // TODO: change later - Init_Vals_ADC1.Res = RESOLUTION_12; // TODO: change later - Init_Vals_ADC1.Num_Pin_Port_Objs = 2; - Pin_Ports p1[2] = {{.pin = BSE_SIGNAL_Pin | BSPD_SENSE_Pin | APPS1_SIGNAL_Pin | APPS2_SIGNAL_Pin, .port = GPIOC}, - {.pin = BRAKE_F_SIGNAL_Pin | BRAKE_R_SIGNAL_Pin | AUX_SIGNAL_Pin, .port = GPIOB}}; - Init_Vals_ADC1.Pins = p1; - Init_Vals_ADC1.Num_Channels = 7; // check multiple GPIO stuff - Channel c1[] = {ADC_CHANNEL_6, ADC_CHANNEL_7, ADC_CHANNEL_8, ADC_CHANNEL_9, ADC_CHANNEL_15, ADC_CHANNEL_12, ADC_CHANNEL_5}; - Init_Vals_ADC1.Channels = c1; - SamplingTime s1 = LL_ADC_SAMPLINGTIME_92CYCLES_5; - Init_Vals_ADC1.SamplingTimes = &s1; - ADC_Init(&Init_Vals_ADC1); - - // TODO Use ADC peripheral API for configuring ideally... but honestly its fine - LL_ADC_SetOverSamplingScope(ADC1, LL_ADC_OVS_GRP_REGULAR_CONTINUED); - LL_ADC_ConfigOverSamplingRatioShift(ADC1, LL_ADC_OVS_RATIO_256, LL_ADC_OVS_SHIFT_RIGHT_8); - - // ADC 2 - ADC_Init_Values Init_Vals_ADC2 = {0}; - Init_Vals_ADC2.ADC = ADC2; - Init_Vals_ADC2.PS_Value = PS_8; // TODO: change later - Init_Vals_ADC2.Res = RESOLUTION_12; // TODO: change later - Init_Vals_ADC2.Num_Pin_Port_Objs = 1; - Pin_Ports p2[2] = {{.pin = BSPD_SENSE_Pin | IMD_SENSE_Pin | AMS_SENSE_Pin, .port = GPIOA}, {.pin = STEERING_ANGLE_Pin, .port = GPIOB}}; - Init_Vals_ADC2.Pins = p2; - Init_Vals_ADC2.Num_Channels = 4; - Channel c2[] = {ADC_CHANNEL_13, ADC_CHANNEL_3, ADC_CHANNEL_4, ADC_CHANNEL_15}; - Init_Vals_ADC2.Channels = c2; - SamplingTime s2 = LL_ADC_SAMPLINGTIME_92CYCLES_5; - Init_Vals_ADC2.SamplingTimes = &s2; - ADC_Init(&Init_Vals_ADC2); - - // TODO Use ADC peripheral API for configuring ideally... but honestly its fine - LL_ADC_SetOverSamplingScope(ADC2, LL_ADC_OVS_GRP_REGULAR_CONTINUED); - LL_ADC_ConfigOverSamplingRatioShift(ADC2, LL_ADC_OVS_RATIO_256, LL_ADC_OVS_SHIFT_RIGHT_8); - - /* - // Initialize DMA (ADC1 = CHANNEL 1, ADC2 = CHANNEL 2) - // DMA reads into buffer - DMA_Init(DMA1, LL_DMA_CHANNEL_1, LL_ADC_DMA_GetRegAddr(ADC1, LL_ADC_DMA_REG_REGULAR_DATA), ADC1_buffers, LL_DMA_PDATAALIGN_HALFWORD, LL_DMA_MDATAALIGN_HALFWORD, NUM_SIGNALS_ADC1, ADC1, HIGH); - LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1); - DMA_Init(DMA1, LL_DMA_CHANNEL_2, LL_ADC_DMA_GetRegAddr(ADC2, LL_ADC_DMA_REG_REGULAR_DATA), ADC2_buffers, LL_DMA_PDATAALIGN_HALFWORD, LL_DMA_MDATAALIGN_HALFWORD, NUM_SIGNALS_ADC2, ADC2, HIGH); - LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_2); - */ - // Initialize DMA (for both ADCs) - DMA_Init_Values DMA_Init_Vals_ADC1 = {0}; - DMA_Init_Vals_ADC1.DMA = DMA1; - DMA_Init_Vals_ADC1.ADC = ADC1; - DMA_Init_Vals_ADC1.Channel = DMA_CHANNEL_1; - DMA_Init_Vals_ADC1.Src_Address = LL_ADC_DMA_GetRegAddr(ADC1, LL_ADC_DMA_REG_REGULAR_DATA); - DMA_Init_Vals_ADC1.Dest_Address = ADC_buffers; - DMA_Init_Vals_ADC1.Data_Size = Half_Word; - DMA_Init_Vals_ADC1.Priority = HIGH; // TODO: check what this does - DMA_Init_Vals_ADC1.Num_Data = NUM_SIGNALS_ADC1; - DMA_Init(&DMA_Init_Vals_ADC1); - LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1); - - DMA_Init_Values DMA_Init_Vals_ADC2 = {0}; - DMA_Init_Vals_ADC2.DMA = DMA1; - DMA_Init_Vals_ADC2.ADC = ADC2; - DMA_Init_Vals_ADC2.Channel = DMA_CHANNEL_2; - DMA_Init_Vals_ADC2.Src_Address = LL_ADC_DMA_GetRegAddr(ADC2, LL_ADC_DMA_REG_REGULAR_DATA); - DMA_Init_Vals_ADC2.Dest_Address = ADC_buffers + NUM_SIGNALS_ADC1; - DMA_Init_Vals_ADC2.Data_Size = Half_Word; - DMA_Init_Vals_ADC2.Priority = HIGH; // TODO: check what this does - DMA_Init_Vals_ADC2.Num_Data = NUM_SIGNALS_ADC2; - DMA_Init(&DMA_Init_Vals_ADC2); - LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_2); - - ADC_Enable_And_Calibrate(ADC1); - ADC_Enable_And_Calibrate(ADC2); -} - -void CAN1_rx_callback(uint32_t ID, void *data, uint32_t size) -{ - if ((ID & 0x1FFFC0FF) == 0x00000016) { - ECU_CAN_DTI_MessageHandler(&stateLump, ID, data, size); - } else { - ECU_CAN_MessageHandler(&stateLump, GRCAN_BUS_PRIMARY, (0x000FFF00 & ID) >> 8, (0xFF00000 & ID) >> 20, data, size); - } + HAL_ADC_Start_DMA(&hadc1, (uint32_t *)&ADC_buffers[0], NUM_SIGNALS_ADC1); + HAL_ADC_Start_DMA(&hadc2, (uint32_t *)&ADC_buffers[NUM_SIGNALS_ADC1], NUM_SIGNALS_ADC2); } -void CAN2_rx_callback(uint32_t ID, void *data, uint32_t size) -{ - ECU_CAN_MessageHandler(&stateLump, GRCAN_BUS_DATA, (0x000FFF00 & ID) >> 8, (0xFF00000 & ID) >> 20, data, size); -} +/* USER CODE END 0 */ -void CAN_Configure(void) -{ - CANConfig canCfg; - - // SHARED config ddata for CAN1 and CAN2 - canCfg.hal_fdcan_init.ClockDivider = FDCAN_CLOCK_DIV1; - canCfg.hal_fdcan_init.FrameFormat = FDCAN_FRAME_FD_NO_BRS; - canCfg.hal_fdcan_init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION; - canCfg.hal_fdcan_init.Mode = FDCAN_MODE_NORMAL; - canCfg.hal_fdcan_init.AutoRetransmission = ENABLE; - canCfg.hal_fdcan_init.TransmitPause = DISABLE; - canCfg.hal_fdcan_init.ProtocolException = ENABLE; - canCfg.hal_fdcan_init.NominalPrescaler = 1; - canCfg.hal_fdcan_init.NominalSyncJumpWidth = 16; - canCfg.hal_fdcan_init.NominalTimeSeg1 = 119; // Updated for 160MHz: (1+119+40)*1 = 160 ticks -> 1 Mbps - canCfg.hal_fdcan_init.NominalTimeSeg2 = 40; - canCfg.hal_fdcan_init.DataPrescaler = 1; - canCfg.hal_fdcan_init.DataSyncJumpWidth = 16; - canCfg.hal_fdcan_init.DataTimeSeg1 = 9; // Updated for 160MHz: 160 MHz/((1+9+10)*1) = 8 Mbps - canCfg.hal_fdcan_init.DataTimeSeg2 = 10; - canCfg.hal_fdcan_init.StdFiltersNbr = 0; - canCfg.hal_fdcan_init.ExtFiltersNbr = 3; - - canCfg.rx_callback = NULL; - canCfg.rx_interrupt_priority = 15; // TODO: Maybe make these not hardcoded - canCfg.tx_interrupt_priority = 15; - // canCfg.tx_buffer_length = CAN_TX_BUFFER_LENGTH; - - // RX shared settings - canCfg.init_rx_gpio.Mode = GPIO_MODE_AF_PP; - canCfg.init_rx_gpio.Pull = GPIO_PULLUP; - canCfg.init_rx_gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH; - - // TX Shared settings - canCfg.init_tx_gpio.Mode = GPIO_MODE_AF_PP; - canCfg.init_tx_gpio.Pull = GPIO_NOPULL; - canCfg.init_tx_gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH; - - /*FDCAN_TxHeaderTypeDef TxHeader = { - .Identifier = 1, - - .IdType = FDCAN_STANDARD_ID, - .TxFrameType = FDCAN_DATA_FRAME, - .ErrorStateIndicator = FDCAN_ESI_ACTIVE, // honestly this might be a value you have to read from a node - // FDCAN_ESI_ACTIVE is just a state that assumes there are minimal errors - .DataLength = 1, - .BitRateSwitch = FDCAN_BRS_OFF, - .TxEventFifoControl = FDCAN_NO_TX_EVENTS, // change to FDCAN_STORE_TX_EVENTS if you need to store info regarding transmitted messages - .MessageMarker = 0 // also change this to a real address if you change fifo control - }; - - FDCANTxMessage msg = {.data = {0x80}, .tx_header = TxHeader}; - */ - - // PCLK1 from SYSCLK - can_set_clksource(LL_RCC_FDCAN_CLKSOURCE_PCLK1); - - // CAN1 ===================================================================== - canCfg.fdcan_instance = FDCAN1; - canCfg.rx_gpio = GPIOA; - canCfg.init_rx_gpio.Pin = GPIO_PIN_11; - canCfg.init_rx_gpio.Alternate = GPIO_AF9_FDCAN1; - - canCfg.tx_gpio = GPIOA; - canCfg.init_tx_gpio.Pin = GPIO_PIN_12; - canCfg.init_tx_gpio.Alternate = GPIO_AF9_FDCAN1; - - // RX Callback CAN1 - canCfg.rx_callback = CAN1_rx_callback; // TODO: Make sure the wrapper for this is defined correctly - - FDCAN_FilterTypeDef fdcan_primary_filter_ecu = {0}; - fdcan_primary_filter_ecu.IdType = FDCAN_EXTENDED_ID; - fdcan_primary_filter_ecu.FilterIndex = 0; - fdcan_primary_filter_ecu.FilterType = FDCAN_FILTER_MASK; - fdcan_primary_filter_ecu.FilterConfig = FDCAN_FILTER_TO_RXFIFO0; - fdcan_primary_filter_ecu.FilterID1 = GRCAN_ECU & 0xFF; - fdcan_primary_filter_ecu.FilterID2 = 0x000000FF; - - FDCAN_FilterTypeDef fdcan_primary_filter_all = {0}; - fdcan_primary_filter_all.IdType = FDCAN_EXTENDED_ID; - fdcan_primary_filter_all.FilterIndex = 1; - fdcan_primary_filter_all.FilterType = FDCAN_FILTER_MASK; - fdcan_primary_filter_all.FilterConfig = FDCAN_FILTER_TO_RXFIFO0; - fdcan_primary_filter_all.FilterID1 = GRCAN_ALL & 0xFF; - fdcan_primary_filter_all.FilterID2 = 0x000000FF; - - FDCAN_FilterTypeDef fdcan_primary_filter_dti = {0}; - fdcan_primary_filter_ecu.IdType = FDCAN_EXTENDED_ID; - fdcan_primary_filter_ecu.FilterIndex = 2; - fdcan_primary_filter_ecu.FilterType = FDCAN_FILTER_MASK; - fdcan_primary_filter_ecu.FilterConfig = FDCAN_FILTER_TO_RXFIFO0; - fdcan_primary_filter_ecu.FilterID1 = 0x00000016; - fdcan_primary_filter_ecu.FilterID2 = 0x1FFFC0FF; - - stateLump.primary_can = can_init(&canCfg); - - can_add_filter(stateLump.primary_can, &fdcan_primary_filter_ecu); - can_add_filter(stateLump.primary_can, &fdcan_primary_filter_all); - can_add_filter(stateLump.primary_can, &fdcan_primary_filter_dti); - - // CAN2 ====================================================== - canCfg.fdcan_instance = FDCAN2; - canCfg.rx_gpio = GPIOB; - canCfg.init_rx_gpio.Pin = GPIO_PIN_12; - canCfg.init_rx_gpio.Alternate = GPIO_AF9_FDCAN2; - - canCfg.tx_gpio = GPIOB; - canCfg.init_tx_gpio.Pin = GPIO_PIN_13; - canCfg.init_tx_gpio.Alternate = GPIO_AF9_FDCAN2; - - // RX Callback CAN2 - canCfg.rx_callback = CAN2_rx_callback; // TODO: Make sure the wrapper for this is defined correctly - - FDCAN_FilterTypeDef fdcan_data_filter_ecu = {0}; - fdcan_data_filter_ecu.IdType = FDCAN_EXTENDED_ID; - fdcan_data_filter_ecu.FilterIndex = 0; - fdcan_data_filter_ecu.FilterType = FDCAN_FILTER_MASK; - fdcan_data_filter_ecu.FilterConfig = FDCAN_FILTER_TO_RXFIFO0; - fdcan_data_filter_ecu.FilterID1 = GRCAN_ECU & 0xFF; - fdcan_data_filter_ecu.FilterID2 = 0x000000FF; - - FDCAN_FilterTypeDef fdcan_data_filter_all = {0}; - fdcan_data_filter_all.IdType = FDCAN_EXTENDED_ID; - fdcan_data_filter_all.FilterIndex = 1; - fdcan_data_filter_all.FilterType = FDCAN_FILTER_MASK; - fdcan_data_filter_all.FilterConfig = FDCAN_FILTER_TO_RXFIFO0; - fdcan_data_filter_all.FilterID1 = GRCAN_ALL & 0xFF; - fdcan_data_filter_all.FilterID2 = 0x000000FF; - - stateLump.data_can = can_init(&canCfg); - - can_add_filter(stateLump.data_can, &fdcan_data_filter_ecu); - can_add_filter(stateLump.data_can, &fdcan_data_filter_all); - - // timer can - can_start(stateLump.primary_can); - can_start(stateLump.data_can); -} /** - * @brief The application entry point. - * @retval int - */ + * @brief The application entry point. + * @retval int + */ int main(void) { - /* USER CODE BEGIN 1 */ + /* USER CODE BEGIN 1 */ - /* USER CODE END 1 */ + /* USER CODE END 1 */ - /* MCU - * Configuration--------------------------------------------------------*/ + /* MCU Configuration--------------------------------------------------------*/ - /* Reset of all peripherals, Initializes the Flash interface and the - * Systick. */ - HAL_Init(); + /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ + HAL_Init(); - /* USER CODE BEGIN Init */ + /* USER CODE BEGIN Init */ - /* USER CODE END Init */ + /* USER CODE END Init */ - /* Configure the system clock */ - SystemClock_Config(); + /* Configure the system clock */ + SystemClock_Config(); - /* USER CODE BEGIN SysInit */ + /* USER CODE BEGIN SysInit */ - /* USER CODE END SysInit */ + /* USER CODE END SysInit */ - /* Initialize all configured peripherals */ - // TODO: Figure out GPIO Init - MX_GPIO_Init(); - MX_DMA_Init(); - // MX_FDCAN1_Init(); - MX_ADC1_Init(); - MX_ADC2_Init(); - // MX_FDCAN2_Init(); - /* USER CODE BEGIN 2 */ - Setup_Logomatic(&logomaticConfig); - Setup_VCP(&vcp_config); + /* Initialize all configured peripherals */ + MX_GPIO_Init(); + MX_DMA_Init(); + MX_ADC1_Init(); + MX_ADC2_Init(); + MX_FDCAN1_Init(); + MX_FDCAN2_Init(); + /* USER CODE BEGIN 2 */ + Logomatic_SetLogLevel(LogLevel_Info); + // Setup_VCP(&vcp_config); // Initialize CAN - CAN_Configure(); + CubeCAN_Config primaryCanConfig = {.rx_callback = CANdler_Callback, .context.busid_user_context = GRCAN_BUS_PRIMARY, .sending_node_id = GRCAN_ECU}; + + CubeCAN_Config dataCanConfig = {.rx_callback = CANdler_Callback, .context.busid_user_context = GRCAN_BUS_DATA, .sending_node_id = GRCAN_ECU}; + + stateLump.primary_can = CubeCAN_Entrance(&hfdcan1, &primaryCanConfig); + if (stateLump.primary_can == NULL) { + LOGOMATIC_CRITICAL("Failed to initialize primary CAN handle\n"); + Error_Handler(); + } + + stateLump.data_can = CubeCAN_Entrance(&hfdcan2, &dataCanConfig); + if (stateLump.data_can == NULL) { + LOGOMATIC_CRITICAL("Failed to initialize data CAN handle\n"); + Error_Handler(); + } ADC_Configure(); float adc_alpha = 5000.0f / MAIN_LOOP_PERIOD_US; // around 5 time constants in one cycle of the main loop - LOGOMATIC("Boot completed at %lu ms\n", MillisecondsSinceBoot()); + LOGOMATIC_INFO("Boot completed at %lu ms\n", MillisecondsSinceBoot()); while (MillisecondsSinceBoot() < 5000) { // Notes per Andrey and Ryan BrakeLightControl(&stateLump); @@ -513,98 +195,67 @@ int main(void) write_adc_values_to_state_data(); } - LOGOMATIC("Initial ADC readings stabilized at %lu ms\n", MillisecondsSinceBoot()); + LOGOMATIC_INFO("Initial ADC readings stabilized at %lu ms\n", MillisecondsSinceBoot()); - /* USER CODE END 2 */ + /* USER CODE END 2 */ - /* Infinite loop */ - /* USER CODE BEGIN WHILE */ + /* Infinite loop */ + /* USER CODE BEGIN WHILE */ while (1) { - // adcs - read_digital(); - // main state lopp, queues can messages within it - static uint32_t delay_timer; - static uint32_t ping_timer; - static uint32_t adc_timer; - // ADC - if (MillisecondsSinceBoot() >= adc_timer) { - adc_timer = MillisecondsSinceBoot() + 1; - - ADC_UpdateAnalogValues_EMA(ADC_buffers, NUM_SIGNALS, adc_alpha, ADC_outputs); - write_adc_values_to_state_data(); - } - - if (MillisecondsSinceBoot() >= delay_timer) { -#ifdef PLAN_C - ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_Debugger, GRCAN_DEBUG_2_0, "!PLAN_C!", 8); -#endif - - delay_timer = MillisecondsSinceBoot() + (MAIN_LOOP_PERIOD_US / 1000); - - // ADC_UpdateAnalogValues_EMA(ADC_buffers, NUM_SIGNALS, 0.01, ADC_outputs); - // void ADC_UpdateAnalogValues(uint16_t **adcDataValues, volatile uint16_t *new_values, int num_signals, int window_size, uint16_t *weighted_output) - // ADC_UpdateAnalogValues(ADC_buffers, ADC_outputs, NUM_SIGNALS, WINDOW_SIZE, ); // TODO: figure out which alpha values to use for the different signals - // write_adc_values_to_state_data(); - - // state tick - ECU_State_Tick(); - - // preipheral updates - SendECUStateDataOverCAN(&stateLump); - SendECUAnalogDataOverCAN(&stateLump); - if (MillisecondsSinceBoot() >= ping_timer) { - ping_timer = MillisecondsSinceBoot() + (MAIN_LOOP_PERIOD_US / 500); // half period - pingAll(); - } - lightControl(&stateLump); - - Send_VCP_APPS(&stateLump, ADC_outputs[ADC_BUFFER_SIG_APPS1], ADC_outputs[ADC_BUFFER_SIG_APPS2]); - // ADC_Logomatic(); - } + /* USER CODE END WHILE */ + + /* USER CODE BEGIN 3 */ } - /* USER CODE END 3 */ + /* USER CODE END 3 */ } /** - * @brief System Clock Configuration - * @retval None - */ + * @brief System Clock Configuration + * @retval None + */ void SystemClock_Config(void) { - LL_FLASH_SetLatency(LL_FLASH_LATENCY_4); - while (LL_FLASH_GetLatency() != LL_FLASH_LATENCY_4) {} - LL_PWR_EnableRange1BoostMode(); - LL_RCC_HSE_Enable(); - /* Wait till HSE is ready */ - while (LL_RCC_HSE_IsReady() != 1) {} - - LL_RCC_HSE_EnableCSS(); - LL_RCC_PLL_ConfigDomain_SYS(LL_RCC_PLLSOURCE_HSE, LL_RCC_PLLM_DIV_1, 20, LL_RCC_PLLR_DIV_2); - LL_RCC_PLL_EnableDomain_SYS(); - LL_RCC_PLL_Enable(); - /* Wait till PLL is ready */ - while (LL_RCC_PLL_IsReady() != 1) {} - - LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_PLL); - - LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_2); - /* Wait till System clock is ready */ - while (LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_PLL) {} - - /* Insure 1us transition state at intermediate medium speed clock*/ - for (__IO uint32_t i = (160 >> 1); i != 0; i--) - ; - - /* Set AHB prescaler*/ - LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_1); - LL_RCC_SetAPB1Prescaler(LL_RCC_APB1_DIV_1); - LL_RCC_SetAPB2Prescaler(LL_RCC_APB2_DIV_1); - LL_SetSystemCoreClock(160000000); - - /* Update the time base */ - if (HAL_InitTick(TICK_INT_PRIORITY) != HAL_OK) { - Error_Handler(); - } + RCC_OscInitTypeDef RCC_OscInitStruct = {0}; + RCC_ClkInitTypeDef RCC_ClkInitStruct = {0}; + + /** Configure the main internal regulator output voltage + */ + HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1_BOOST); + + /** Initializes the RCC Oscillators according to the specified parameters + * in the RCC_OscInitTypeDef structure. + */ + RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE; + RCC_OscInitStruct.HSEState = RCC_HSE_ON; + RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; + RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE; + RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV1; + RCC_OscInitStruct.PLL.PLLN = 20; + RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2; + RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2; + RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2; + if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) + { + Error_Handler(); + } + + /** Initializes the CPU, AHB and APB buses clocks + */ + RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK + |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2; + RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; + RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; + RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1; + RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1; + + if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK) + { + Error_Handler(); + } + + /** Enables the Clock Security System + */ + HAL_RCC_EnableCSS(); } /* USER CODE BEGIN 4 */ @@ -612,30 +263,30 @@ void SystemClock_Config(void) /* USER CODE END 4 */ /** - * @brief This function is executed in case of error occurrence. - * @retval None - */ + * @brief This function is executed in case of error occurrence. + * @retval None + */ void Error_Handler(void) { - /* USER CODE BEGIN Error_Handler_Debug */ + /* USER CODE BEGIN Error_Handler_Debug */ /* User can add his own implementation to report the HAL error return * state */ __disable_irq(); while (1) {} - /* USER CODE END Error_Handler_Debug */ + /* USER CODE END Error_Handler_Debug */ } #ifdef USE_FULL_ASSERT /** - * @brief Reports the name of the source file and the source line number - * where the assert_param error has occurred. - * @param file: pointer to the source file name - * @param line: assert_param error line source number - * @retval None - */ + * @brief Reports the name of the source file and the source line number + * where the assert_param error has occurred. + * @param file: pointer to the source file name + * @param line: assert_param error line source number + * @retval None + */ void assert_failed(uint8_t *file, uint32_t line) { - /* USER CODE BEGIN 6 */ - LOGOMATIC("Assertion failed: file %s on line %d\r\n", file, line); - /* USER CODE END 6 */ + /* USER CODE BEGIN 6 */ + LOGOMATIC_ERROR("Assertion failed: file %s on line %d\r\n", file, (int)line); + /* USER CODE END 6 */ } #endif /* USE_FULL_ASSERT */ diff --git a/ECU/Core/Src/stm32g4xx_hal_msp.c b/ECU/Core/Src/stm32g4xx_hal_msp.c index f266230dd..7c45c4351 100644 --- a/ECU/Core/Src/stm32g4xx_hal_msp.c +++ b/ECU/Core/Src/stm32g4xx_hal_msp.c @@ -17,7 +17,6 @@ ****************************************************************************** */ /* USER CODE END Header */ - /* Includes ------------------------------------------------------------------*/ #include "main.h" /* USER CODE BEGIN Includes */ @@ -58,27 +57,27 @@ /* USER CODE END 0 */ /** - * Initializes the Global MSP. - */ + * Initializes the Global MSP. + */ void HAL_MspInit(void) { - /* USER CODE BEGIN MspInit 0 */ + /* USER CODE BEGIN MspInit 0 */ - /* USER CODE END MspInit 0 */ + /* USER CODE END MspInit 0 */ - __HAL_RCC_SYSCFG_CLK_ENABLE(); - __HAL_RCC_PWR_CLK_ENABLE(); + __HAL_RCC_SYSCFG_CLK_ENABLE(); + __HAL_RCC_PWR_CLK_ENABLE(); - /* System interrupt init*/ + /* System interrupt init*/ - /** Disable the internal Pull-Up in Dead Battery pins of UCPD peripheral - */ - HAL_PWREx_DisableUCPDDeadBattery(); + /** Disable the internal Pull-Up in Dead Battery pins of UCPD peripheral + */ + HAL_PWREx_DisableUCPDDeadBattery(); - /* USER CODE BEGIN MspInit 1 */ + /* USER CODE BEGIN MspInit 1 */ - /* USER CODE END MspInit 1 */ + /* USER CODE END MspInit 1 */ } /* USER CODE BEGIN 1 */ diff --git a/ECU/Core/Src/stm32g4xx_it.c b/ECU/Core/Src/stm32g4xx_it.c index 01ab766d9..5805742d6 100644 --- a/ECU/Core/Src/stm32g4xx_it.c +++ b/ECU/Core/Src/stm32g4xx_it.c @@ -18,11 +18,8 @@ /* USER CODE END Header */ /* Includes ------------------------------------------------------------------*/ -#include "stm32g4xx_it.h" - -#include "can.h" #include "main.h" -#include "stm32g4xx_ll_tim.h" +#include "stm32g4xx_it.h" /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ /* USER CODE END Includes */ @@ -58,6 +55,10 @@ /* USER CODE END 0 */ /* External variables --------------------------------------------------------*/ +extern DMA_HandleTypeDef hdma_adc1; +extern DMA_HandleTypeDef hdma_adc2; +extern ADC_HandleTypeDef hadc1; +extern ADC_HandleTypeDef hadc2; extern FDCAN_HandleTypeDef hfdcan1; extern FDCAN_HandleTypeDef hfdcan2; /* USER CODE BEGIN EV */ @@ -68,125 +69,236 @@ extern FDCAN_HandleTypeDef hfdcan2; /* Cortex-M4 Processor Interruption and Exception Handlers */ /******************************************************************************/ /** - * @brief This function handles Non maskable interrupt. - */ + * @brief This function handles Non maskable interrupt. + */ void NMI_Handler(void) { - /* USER CODE BEGIN NonMaskableInt_IRQn 0 */ + /* USER CODE BEGIN NonMaskableInt_IRQn 0 */ - /* USER CODE END NonMaskableInt_IRQn 0 */ - /* USER CODE BEGIN NonMaskableInt_IRQn 1 */ + /* USER CODE END NonMaskableInt_IRQn 0 */ + HAL_RCC_NMI_IRQHandler(); + /* USER CODE BEGIN NonMaskableInt_IRQn 1 */ while (1) {} - /* USER CODE END NonMaskableInt_IRQn 1 */ + /* USER CODE END NonMaskableInt_IRQn 1 */ } /** - * @brief This function handles Hard fault interrupt. - */ + * @brief This function handles Hard fault interrupt. + */ void HardFault_Handler(void) { - /* USER CODE BEGIN HardFault_IRQn 0 */ - - /* USER CODE END HardFault_IRQn 0 */ - while (1) { - /* USER CODE BEGIN W1_HardFault_IRQn 0 */ - /* USER CODE END W1_HardFault_IRQn 0 */ - } + /* USER CODE BEGIN HardFault_IRQn 0 */ + + /* USER CODE END HardFault_IRQn 0 */ + while (1) + { + /* USER CODE BEGIN W1_HardFault_IRQn 0 */ + /* USER CODE END W1_HardFault_IRQn 0 */ + } } /** - * @brief This function handles Memory management fault. - */ + * @brief This function handles Memory management fault. + */ void MemManage_Handler(void) { - /* USER CODE BEGIN MemoryManagement_IRQn 0 */ - - /* USER CODE END MemoryManagement_IRQn 0 */ - while (1) { - /* USER CODE BEGIN W1_MemoryManagement_IRQn 0 */ - /* USER CODE END W1_MemoryManagement_IRQn 0 */ - } + /* USER CODE BEGIN MemoryManagement_IRQn 0 */ + + /* USER CODE END MemoryManagement_IRQn 0 */ + while (1) + { + /* USER CODE BEGIN W1_MemoryManagement_IRQn 0 */ + /* USER CODE END W1_MemoryManagement_IRQn 0 */ + } } /** - * @brief This function handles Prefetch fault, memory access fault. - */ + * @brief This function handles Prefetch fault, memory access fault. + */ void BusFault_Handler(void) { - /* USER CODE BEGIN BusFault_IRQn 0 */ - - /* USER CODE END BusFault_IRQn 0 */ - while (1) { - /* USER CODE BEGIN W1_BusFault_IRQn 0 */ - /* USER CODE END W1_BusFault_IRQn 0 */ - } + /* USER CODE BEGIN BusFault_IRQn 0 */ + + /* USER CODE END BusFault_IRQn 0 */ + while (1) + { + /* USER CODE BEGIN W1_BusFault_IRQn 0 */ + /* USER CODE END W1_BusFault_IRQn 0 */ + } } /** - * @brief This function handles Undefined instruction or illegal state. - */ + * @brief This function handles Undefined instruction or illegal state. + */ void UsageFault_Handler(void) { - /* USER CODE BEGIN UsageFault_IRQn 0 */ - - /* USER CODE END UsageFault_IRQn 0 */ - while (1) { - /* USER CODE BEGIN W1_UsageFault_IRQn 0 */ - /* USER CODE END W1_UsageFault_IRQn 0 */ - } + /* USER CODE BEGIN UsageFault_IRQn 0 */ + + /* USER CODE END UsageFault_IRQn 0 */ + while (1) + { + /* USER CODE BEGIN W1_UsageFault_IRQn 0 */ + /* USER CODE END W1_UsageFault_IRQn 0 */ + } } /** - * @brief This function handles System service call via SWI instruction. - */ + * @brief This function handles System service call via SWI instruction. + */ void SVC_Handler(void) { - /* USER CODE BEGIN SVCall_IRQn 0 */ + /* USER CODE BEGIN SVCall_IRQn 0 */ - /* USER CODE END SVCall_IRQn 0 */ - /* USER CODE BEGIN SVCall_IRQn 1 */ + /* USER CODE END SVCall_IRQn 0 */ + /* USER CODE BEGIN SVCall_IRQn 1 */ - /* USER CODE END SVCall_IRQn 1 */ + /* USER CODE END SVCall_IRQn 1 */ } /** - * @brief This function handles Debug monitor. - */ + * @brief This function handles Debug monitor. + */ void DebugMon_Handler(void) { - /* USER CODE BEGIN DebugMonitor_IRQn 0 */ + /* USER CODE BEGIN DebugMonitor_IRQn 0 */ - /* USER CODE END DebugMonitor_IRQn 0 */ - /* USER CODE BEGIN DebugMonitor_IRQn 1 */ + /* USER CODE END DebugMonitor_IRQn 0 */ + /* USER CODE BEGIN DebugMonitor_IRQn 1 */ - /* USER CODE END DebugMonitor_IRQn 1 */ + /* USER CODE END DebugMonitor_IRQn 1 */ } /** - * @brief This function handles Pendable request for system service. - */ + * @brief This function handles Pendable request for system service. + */ void PendSV_Handler(void) { - /* USER CODE BEGIN PendSV_IRQn 0 */ + /* USER CODE BEGIN PendSV_IRQn 0 */ - /* USER CODE END PendSV_IRQn 0 */ - /* USER CODE BEGIN PendSV_IRQn 1 */ + /* USER CODE END PendSV_IRQn 0 */ + /* USER CODE BEGIN PendSV_IRQn 1 */ - /* USER CODE END PendSV_IRQn 1 */ + /* USER CODE END PendSV_IRQn 1 */ } /** - * @brief This function handles System tick timer. - */ + * @brief This function handles System tick timer. + */ void SysTick_Handler(void) { - /* USER CODE BEGIN SysTick_IRQn 0 */ + /* USER CODE BEGIN SysTick_IRQn 0 */ + + /* USER CODE END SysTick_IRQn 0 */ + HAL_IncTick(); + /* USER CODE BEGIN SysTick_IRQn 1 */ + + /* USER CODE END SysTick_IRQn 1 */ +} + +/******************************************************************************/ +/* STM32G4xx Peripheral Interrupt Handlers */ +/* Add here the Interrupt Handlers for the used peripherals. */ +/* For the available peripheral interrupt handler names, */ +/* please refer to the startup file (startup_stm32g4xx.s). */ +/******************************************************************************/ + +/** + * @brief This function handles DMA1 channel1 global interrupt. + */ +void DMA1_Channel1_IRQHandler(void) +{ + /* USER CODE BEGIN DMA1_Channel1_IRQn 0 */ + + /* USER CODE END DMA1_Channel1_IRQn 0 */ + HAL_DMA_IRQHandler(&hdma_adc1); + /* USER CODE BEGIN DMA1_Channel1_IRQn 1 */ + + /* USER CODE END DMA1_Channel1_IRQn 1 */ +} + +/** + * @brief This function handles ADC1 and ADC2 global interrupt. + */ +void ADC1_2_IRQHandler(void) +{ + /* USER CODE BEGIN ADC1_2_IRQn 0 */ + + /* USER CODE END ADC1_2_IRQn 0 */ + HAL_ADC_IRQHandler(&hadc1); + HAL_ADC_IRQHandler(&hadc2); + /* USER CODE BEGIN ADC1_2_IRQn 1 */ + + /* USER CODE END ADC1_2_IRQn 1 */ +} + +/** + * @brief This function handles FDCAN1 interrupt 0. + */ +void FDCAN1_IT0_IRQHandler(void) +{ + /* USER CODE BEGIN FDCAN1_IT0_IRQn 0 */ + + /* USER CODE END FDCAN1_IT0_IRQn 0 */ + HAL_FDCAN_IRQHandler(&hfdcan1); + /* USER CODE BEGIN FDCAN1_IT0_IRQn 1 */ + + /* USER CODE END FDCAN1_IT0_IRQn 1 */ +} + +/** + * @brief This function handles FDCAN1 interrupt 1. + */ +void FDCAN1_IT1_IRQHandler(void) +{ + /* USER CODE BEGIN FDCAN1_IT1_IRQn 0 */ + + /* USER CODE END FDCAN1_IT1_IRQn 0 */ + HAL_FDCAN_IRQHandler(&hfdcan1); + /* USER CODE BEGIN FDCAN1_IT1_IRQn 1 */ + + /* USER CODE END FDCAN1_IT1_IRQn 1 */ +} + +/** + * @brief This function handles DMA2 channel1 global interrupt. + */ +void DMA2_Channel1_IRQHandler(void) +{ + /* USER CODE BEGIN DMA2_Channel1_IRQn 0 */ + + /* USER CODE END DMA2_Channel1_IRQn 0 */ + HAL_DMA_IRQHandler(&hdma_adc2); + /* USER CODE BEGIN DMA2_Channel1_IRQn 1 */ + + /* USER CODE END DMA2_Channel1_IRQn 1 */ +} + +/** + * @brief This function handles FDCAN2 interrupt 0. + */ +void FDCAN2_IT0_IRQHandler(void) +{ + /* USER CODE BEGIN FDCAN2_IT0_IRQn 0 */ + + /* USER CODE END FDCAN2_IT0_IRQn 0 */ + HAL_FDCAN_IRQHandler(&hfdcan2); + /* USER CODE BEGIN FDCAN2_IT0_IRQn 1 */ + + /* USER CODE END FDCAN2_IT0_IRQn 1 */ +} + +/** + * @brief This function handles FDCAN2 interrupt 1. + */ +void FDCAN2_IT1_IRQHandler(void) +{ + /* USER CODE BEGIN FDCAN2_IT1_IRQn 0 */ - /* USER CODE END SysTick_IRQn 0 */ - HAL_IncTick(); - /* USER CODE BEGIN SysTick_IRQn 1 */ + /* USER CODE END FDCAN2_IT1_IRQn 0 */ + HAL_FDCAN_IRQHandler(&hfdcan2); + /* USER CODE BEGIN FDCAN2_IT1_IRQn 1 */ - /* USER CODE END SysTick_IRQn 1 */ + /* USER CODE END FDCAN2_IT1_IRQn 1 */ } /* USER CODE BEGIN 1 */ diff --git a/ECU/Core/Src/syscalls.c b/ECU/Core/Src/syscalls.c new file mode 100644 index 000000000..d2b217993 --- /dev/null +++ b/ECU/Core/Src/syscalls.c @@ -0,0 +1,233 @@ +/** + ****************************************************************************** + * @file syscalls.c + * @author Auto-generated by STM32CubeMX + * @brief Minimal System calls file + * + * For more information about which c-functions + * need which of these lowlevel functions + * please consult the Newlib or Picolibc libc-manual + ****************************************************************************** + * @attention + * + * Copyright (c) 2020-2025 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ + +/* Includes */ +#include +#include +#include +#include +#include +#include +#include +#include + +/* Variables */ +extern int __io_putchar(int ch) __attribute__((weak)); +extern int __io_getchar(void) __attribute__((weak)); + +char *__env[1] = {0}; +char **environ = __env; + +/* Functions */ +void initialise_monitor_handles() {} + +int _getpid(void) +{ + return 1; +} + +int _kill(int pid, int sig) +{ + (void)pid; + (void)sig; + errno = EINVAL; + return -1; +} + +void _exit(int status) +{ + _kill(status, -1); + while (1) {} /* Make sure we hang here */ +} + +__attribute__((weak)) int _read(int file, char *ptr, int len) +{ + (void)file; + int DataIdx; + + for (DataIdx = 0; DataIdx < len; DataIdx++) { + *ptr++ = __io_getchar(); + } + + return len; +} + +__attribute__((weak)) int _write(int file, char *ptr, int len) +{ + (void)file; + int DataIdx; + + for (DataIdx = 0; DataIdx < len; DataIdx++) { + __io_putchar(*ptr++); + } + return len; +} + +int _close(int file) +{ + (void)file; + return -1; +} + +int _fstat(int file, struct stat *st) +{ + (void)file; + st->st_mode = S_IFCHR; + return 0; +} + +int _isatty(int file) +{ + (void)file; + return 1; +} + +int _lseek(int file, int ptr, int dir) +{ + (void)file; + (void)ptr; + (void)dir; + return 0; +} + +int _open(char *path, int flags, ...) +{ + (void)path; + (void)flags; + /* Pretend like we always fail */ + return -1; +} + +int _wait(int *status) +{ + (void)status; + errno = ECHILD; + return -1; +} + +int _unlink(char *name) +{ + (void)name; + errno = ENOENT; + return -1; +} + +clock_t _times(struct tms *buf) +{ + (void)buf; + return -1; +} + +int _stat(const char *file, struct stat *st) +{ + (void)file; + st->st_mode = S_IFCHR; + return 0; +} + +int _link(char *old, char *new) +{ + (void)old; + (void)new; + errno = EMLINK; + return -1; +} + +int _fork(void) +{ + errno = EAGAIN; + return -1; +} + +int _execve(char *name, char **argv, char **env) +{ + (void)name; + (void)argv; + (void)env; + errno = ENOMEM; + return -1; +} + +// --- Picolibc Specific Section --- +#if defined(__PICOLIBC__) + +/** + * @brief Picolibc helper function to output a character to a FILE stream. + * This redirects the output to the low-level __io_putchar function. + * @param c Character to write. + * @param file FILE stream pointer (ignored). + * @retval int The character written. + */ +static int starm_putc(char c, FILE *file) +{ + (void)file; + __io_putchar(c); + return c; +} + +/** + * @brief Picolibc helper function to input a character from a FILE stream. + * This redirects the input from the low-level __io_getchar function. + * @param file FILE stream pointer (ignored). + * @retval int The character read, cast to an unsigned char then int. + */ +static int starm_getc(FILE *file) +{ + unsigned char c; + (void)file; + c = __io_getchar(); + return c; +} + +// Define and initialize the standard I/O streams for Picolibc. +// FDEV_SETUP_STREAM connects the starm_putc and starm_getc helper functions to a FILE structure. +// _FDEV_SETUP_RW indicates the stream is for reading and writing. +static FILE __stdio = FDEV_SETUP_STREAM(starm_putc, starm_getc, NULL, _FDEV_SETUP_RW); + +// Assign the standard stream pointers (stdin, stdout, stderr) to the initialized stream. +// Picolibc uses these pointers for standard I/O operations (printf, scanf, etc.). +FILE *const stdin = &__stdio; +__strong_reference(stdin, stdout); +__strong_reference(stdin, stderr); + +// Create strong aliases mapping standard C library function names (without underscore) +// to the implemented system call stubs (with underscore). Picolibc uses these +// standard names internally, so this linking is required. +__strong_reference(_read, read); +__strong_reference(_write, write); +__strong_reference(_times, times); +__strong_reference(_execve, execve); +__strong_reference(_fork, fork); +__strong_reference(_link, link); +__strong_reference(_unlink, unlink); +__strong_reference(_stat, stat); +__strong_reference(_wait, wait); +__strong_reference(_open, open); +__strong_reference(_close, close); +__strong_reference(_lseek, lseek); +__strong_reference(_isatty, isatty); +__strong_reference(_fstat, fstat); +__strong_reference(_exit, exit); +__strong_reference(_kill, kill); +__strong_reference(_getpid, getpid); + +#endif //__PICOLIBC__ diff --git a/ECU/Core/Src/sysmem.c b/ECU/Core/Src/sysmem.c new file mode 100644 index 000000000..3a092d114 --- /dev/null +++ b/ECU/Core/Src/sysmem.c @@ -0,0 +1,85 @@ +/** + ****************************************************************************** + * @file sysmem.c + * @author Generated by STM32CubeMX + * @brief System Memory calls file + * + * For more information about which C functions + * need which of these lowlevel functions + * please consult the Newlib or Picolibc libc manual + ****************************************************************************** + * @attention + * + * Copyright (c) 2025 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ + +/* Includes */ +#include +#include +#include + +/** + * Pointer to the current high watermark of the heap usage + */ +static uint8_t *__sbrk_heap_end = NULL; + +/** + * @brief _sbrk() allocates memory to the newlib heap and is used by malloc + * and others from the C library + * + * @verbatim + * ############################################################################ + * # .data # .bss # newlib heap # MSP stack # + * # # # # Reserved by _Min_Stack_Size # + * ############################################################################ + * ^-- RAM start ^-- _end _estack, RAM end --^ + * @endverbatim + * + * This implementation starts allocating at the '_end' linker symbol + * The '_Min_Stack_Size' linker symbol reserves a memory for the MSP stack + * The implementation considers '_estack' linker symbol to be RAM end + * NOTE: If the MSP stack, at any point during execution, grows larger than the + * reserved size, please increase the '_Min_Stack_Size'. + * + * @param incr Memory size + * @return Pointer to allocated memory + */ +void *_sbrk(ptrdiff_t incr) +{ + extern uint8_t _end; /* Symbol defined in the linker script */ + extern uint8_t _estack; /* Symbol defined in the linker script */ + extern uint32_t _Min_Stack_Size; /* Symbol defined in the linker script */ + const uint32_t stack_limit = (uint32_t)&_estack - (uint32_t)&_Min_Stack_Size; + const uint8_t *max_heap = (uint8_t *)stack_limit; + uint8_t *prev_heap_end; + + /* Initialize heap end at first call */ + if (NULL == __sbrk_heap_end) { + __sbrk_heap_end = &_end; + } + + /* Protect heap from growing into the reserved MSP stack */ + if (__sbrk_heap_end + incr > max_heap) { + errno = ENOMEM; + return (void *)-1; + } + + prev_heap_end = __sbrk_heap_end; + __sbrk_heap_end += incr; + + return (void *)prev_heap_end; +} + +#if defined(__PICOLIBC__) +// Picolibc expects syscalls without the leading underscore. +// This creates a strong alias so that +// calls to `sbrk()` are resolved to our `_sbrk()` implementation. +__strong_reference(_sbrk, sbrk); +#endif diff --git a/ECU/ECU.ioc b/ECU/ECU.ioc new file mode 100644 index 000000000..ce35ede6c --- /dev/null +++ b/ECU/ECU.ioc @@ -0,0 +1,406 @@ +#MicroXplorer Configuration settings - do not modify +ADC1.Channel-1\#ChannelRegularConversion=ADC_CHANNEL_5 +ADC1.Channel-2\#ChannelRegularConversion=ADC_CHANNEL_7 +ADC1.Channel-3\#ChannelRegularConversion=ADC_CHANNEL_8 +ADC1.Channel-4\#ChannelRegularConversion=ADC_CHANNEL_9 +ADC1.Channel-5\#ChannelRegularConversion=ADC_CHANNEL_12 +ADC1.Channel-6\#ChannelRegularConversion=ADC_CHANNEL_15 +ADC1.CommonPathInternal=null|null|null|null +ADC1.ContinuousConvMode=ENABLE +ADC1.DMAContinuousRequests=ENABLE +ADC1.IPParameters=Rank-1\#ChannelRegularConversion,Channel-1\#ChannelRegularConversion,SamplingTime-1\#ChannelRegularConversion,OffsetNumber-1\#ChannelRegularConversion,NbrOfConversionFlag,ContinuousConvMode,master,Rank-2\#ChannelRegularConversion,Channel-2\#ChannelRegularConversion,SamplingTime-2\#ChannelRegularConversion,OffsetNumber-2\#ChannelRegularConversion,Rank-3\#ChannelRegularConversion,Channel-3\#ChannelRegularConversion,SamplingTime-3\#ChannelRegularConversion,OffsetNumber-3\#ChannelRegularConversion,Rank-4\#ChannelRegularConversion,Channel-4\#ChannelRegularConversion,SamplingTime-4\#ChannelRegularConversion,OffsetNumber-4\#ChannelRegularConversion,Rank-5\#ChannelRegularConversion,Channel-5\#ChannelRegularConversion,SamplingTime-5\#ChannelRegularConversion,OffsetNumber-5\#ChannelRegularConversion,Rank-6\#ChannelRegularConversion,Channel-6\#ChannelRegularConversion,SamplingTime-6\#ChannelRegularConversion,OffsetNumber-6\#ChannelRegularConversion,NbrOfConversion,DMAContinuousRequests,CommonPathInternal +ADC1.NbrOfConversion=6 +ADC1.NbrOfConversionFlag=1 +ADC1.OffsetNumber-1\#ChannelRegularConversion=ADC_OFFSET_NONE +ADC1.OffsetNumber-2\#ChannelRegularConversion=ADC_OFFSET_NONE +ADC1.OffsetNumber-3\#ChannelRegularConversion=ADC_OFFSET_NONE +ADC1.OffsetNumber-4\#ChannelRegularConversion=ADC_OFFSET_NONE +ADC1.OffsetNumber-5\#ChannelRegularConversion=ADC_OFFSET_NONE +ADC1.OffsetNumber-6\#ChannelRegularConversion=ADC_OFFSET_NONE +ADC1.Rank-1\#ChannelRegularConversion=1 +ADC1.Rank-2\#ChannelRegularConversion=2 +ADC1.Rank-3\#ChannelRegularConversion=3 +ADC1.Rank-4\#ChannelRegularConversion=4 +ADC1.Rank-5\#ChannelRegularConversion=5 +ADC1.Rank-6\#ChannelRegularConversion=6 +ADC1.SamplingTime-1\#ChannelRegularConversion=ADC_SAMPLETIME_92CYCLES_5 +ADC1.SamplingTime-2\#ChannelRegularConversion=ADC_SAMPLETIME_92CYCLES_5 +ADC1.SamplingTime-3\#ChannelRegularConversion=ADC_SAMPLETIME_92CYCLES_5 +ADC1.SamplingTime-4\#ChannelRegularConversion=ADC_SAMPLETIME_92CYCLES_5 +ADC1.SamplingTime-5\#ChannelRegularConversion=ADC_SAMPLETIME_92CYCLES_5 +ADC1.SamplingTime-6\#ChannelRegularConversion=ADC_SAMPLETIME_92CYCLES_5 +ADC1.master=1 +ADC2.Channel-0\#ChannelRegularConversion=ADC_CHANNEL_3 +ADC2.Channel-1\#ChannelRegularConversion=ADC_CHANNEL_4 +ADC2.Channel-2\#ChannelRegularConversion=ADC_CHANNEL_6 +ADC2.Channel-3\#ChannelRegularConversion=ADC_CHANNEL_13 +ADC2.Channel-4\#ChannelRegularConversion=ADC_CHANNEL_15 +ADC2.CommonPathInternal=null|null|null|null +ADC2.ContinuousConvMode=ENABLE +ADC2.DMAContinuousRequests=ENABLE +ADC2.IPParameters=Rank-0\#ChannelRegularConversion,Channel-0\#ChannelRegularConversion,SamplingTime-0\#ChannelRegularConversion,OffsetNumber-0\#ChannelRegularConversion,NbrOfConversionFlag,ContinuousConvMode,Rank-1\#ChannelRegularConversion,Channel-1\#ChannelRegularConversion,SamplingTime-1\#ChannelRegularConversion,OffsetNumber-1\#ChannelRegularConversion,Rank-2\#ChannelRegularConversion,Channel-2\#ChannelRegularConversion,SamplingTime-2\#ChannelRegularConversion,OffsetNumber-2\#ChannelRegularConversion,Rank-3\#ChannelRegularConversion,Channel-3\#ChannelRegularConversion,SamplingTime-3\#ChannelRegularConversion,OffsetNumber-3\#ChannelRegularConversion,Rank-4\#ChannelRegularConversion,Channel-4\#ChannelRegularConversion,SamplingTime-4\#ChannelRegularConversion,OffsetNumber-4\#ChannelRegularConversion,NbrOfConversion,DMAContinuousRequests,CommonPathInternal +ADC2.NbrOfConversion=5 +ADC2.NbrOfConversionFlag=1 +ADC2.OffsetNumber-0\#ChannelRegularConversion=ADC_OFFSET_NONE +ADC2.OffsetNumber-1\#ChannelRegularConversion=ADC_OFFSET_NONE +ADC2.OffsetNumber-2\#ChannelRegularConversion=ADC_OFFSET_NONE +ADC2.OffsetNumber-3\#ChannelRegularConversion=ADC_OFFSET_NONE +ADC2.OffsetNumber-4\#ChannelRegularConversion=ADC_OFFSET_NONE +ADC2.Rank-0\#ChannelRegularConversion=1 +ADC2.Rank-1\#ChannelRegularConversion=2 +ADC2.Rank-2\#ChannelRegularConversion=3 +ADC2.Rank-3\#ChannelRegularConversion=4 +ADC2.Rank-4\#ChannelRegularConversion=5 +ADC2.SamplingTime-0\#ChannelRegularConversion=ADC_SAMPLETIME_92CYCLES_5 +ADC2.SamplingTime-1\#ChannelRegularConversion=ADC_SAMPLETIME_92CYCLES_5 +ADC2.SamplingTime-2\#ChannelRegularConversion=ADC_SAMPLETIME_92CYCLES_5 +ADC2.SamplingTime-3\#ChannelRegularConversion=ADC_SAMPLETIME_92CYCLES_5 +ADC2.SamplingTime-4\#ChannelRegularConversion=ADC_SAMPLETIME_92CYCLES_5 +CAD.formats= +CAD.pinconfig= +CAD.provider= +Dma.ADC1.0.Direction=DMA_PERIPH_TO_MEMORY +Dma.ADC1.0.EventEnable=DISABLE +Dma.ADC1.0.Instance=DMA1_Channel1 +Dma.ADC1.0.MemDataAlignment=DMA_MDATAALIGN_HALFWORD +Dma.ADC1.0.MemInc=DMA_MINC_ENABLE +Dma.ADC1.0.Mode=DMA_CIRCULAR +Dma.ADC1.0.PeriphDataAlignment=DMA_PDATAALIGN_HALFWORD +Dma.ADC1.0.PeriphInc=DMA_PINC_DISABLE +Dma.ADC1.0.Polarity=HAL_DMAMUX_REQ_GEN_RISING +Dma.ADC1.0.Priority=DMA_PRIORITY_LOW +Dma.ADC1.0.RequestNumber=1 +Dma.ADC1.0.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,SignalID,Polarity,RequestNumber,SyncSignalID,SyncPolarity,SyncEnable,EventEnable,SyncRequestNumber +Dma.ADC1.0.SignalID=NONE +Dma.ADC1.0.SyncEnable=DISABLE +Dma.ADC1.0.SyncPolarity=HAL_DMAMUX_SYNC_NO_EVENT +Dma.ADC1.0.SyncRequestNumber=1 +Dma.ADC1.0.SyncSignalID=NONE +Dma.ADC2.1.Direction=DMA_PERIPH_TO_MEMORY +Dma.ADC2.1.EventEnable=DISABLE +Dma.ADC2.1.Instance=DMA2_Channel1 +Dma.ADC2.1.MemDataAlignment=DMA_MDATAALIGN_HALFWORD +Dma.ADC2.1.MemInc=DMA_MINC_ENABLE +Dma.ADC2.1.Mode=DMA_CIRCULAR +Dma.ADC2.1.PeriphDataAlignment=DMA_PDATAALIGN_HALFWORD +Dma.ADC2.1.PeriphInc=DMA_PINC_DISABLE +Dma.ADC2.1.Polarity=HAL_DMAMUX_REQ_GEN_RISING +Dma.ADC2.1.Priority=DMA_PRIORITY_LOW +Dma.ADC2.1.RequestNumber=1 +Dma.ADC2.1.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,SignalID,Polarity,RequestNumber,SyncSignalID,SyncPolarity,SyncEnable,EventEnable,SyncRequestNumber +Dma.ADC2.1.SignalID=NONE +Dma.ADC2.1.SyncEnable=DISABLE +Dma.ADC2.1.SyncPolarity=HAL_DMAMUX_SYNC_NO_EVENT +Dma.ADC2.1.SyncRequestNumber=1 +Dma.ADC2.1.SyncSignalID=NONE +Dma.Request0=ADC1 +Dma.Request1=ADC2 +Dma.RequestsNb=2 +FDCAN1.AutoRetransmission=ENABLE +FDCAN1.CalculateBaudRateNominal=1000000 +FDCAN1.CalculateTimeBitNominal=1000 +FDCAN1.CalculateTimeQuantumNominal=6.25 +FDCAN1.DataSyncJumpWidth=16 +FDCAN1.DataTimeSeg1=9 +FDCAN1.DataTimeSeg2=10 +FDCAN1.ExtFiltersNbr=3 +FDCAN1.FrameFormat=FDCAN_FRAME_FD_NO_BRS +FDCAN1.IPParameters=CalculateTimeQuantumNominal,CalculateTimeBitNominal,CalculateBaudRateNominal,FrameFormat,AutoRetransmission,ProtocolException,ExtFiltersNbr,NominalPrescaler,NominalTimeSeg1,NominalTimeSeg2,NominalSyncJumpWidth,DataSyncJumpWidth,DataTimeSeg1,DataTimeSeg2 +FDCAN1.NominalPrescaler=1 +FDCAN1.NominalSyncJumpWidth=16 +FDCAN1.NominalTimeSeg1=119 +FDCAN1.NominalTimeSeg2=40 +FDCAN1.ProtocolException=ENABLE +FDCAN2.CalculateBaudRateNominal=3333333 +FDCAN2.CalculateTimeBitNominal=300 +FDCAN2.CalculateTimeQuantumNominal=100.0 +FDCAN2.IPParameters=CalculateTimeQuantumNominal,CalculateTimeBitNominal,CalculateBaudRateNominal +File.Version=6 +GPIO.groupedBy=Group By Peripherals +KeepUserPlacement=false +Mcu.CPN=STM32G474RET3 +Mcu.Family=STM32G4 +Mcu.IP0=ADC1 +Mcu.IP1=ADC2 +Mcu.IP2=DMA +Mcu.IP3=FDCAN1 +Mcu.IP4=FDCAN2 +Mcu.IP5=NVIC +Mcu.IP6=RCC +Mcu.IP7=SYS +Mcu.IPNb=8 +Mcu.Name=STM32G474R(B-C-E)Tx +Mcu.Package=LQFP64 +Mcu.Pin0=PF0-OSC_IN +Mcu.Pin1=PF1-OSC_OUT +Mcu.Pin10=PB1 +Mcu.Pin11=PB11 +Mcu.Pin12=PB12 +Mcu.Pin13=PB13 +Mcu.Pin14=PB14 +Mcu.Pin15=PB15 +Mcu.Pin16=PA8 +Mcu.Pin17=PA9 +Mcu.Pin18=PA11 +Mcu.Pin19=PA12 +Mcu.Pin2=PC0 +Mcu.Pin20=PA13 +Mcu.Pin21=PA14 +Mcu.Pin22=PA15 +Mcu.Pin23=PC10 +Mcu.Pin24=PC11 +Mcu.Pin25=PC12 +Mcu.Pin26=PB3 +Mcu.Pin27=PB4 +Mcu.Pin28=PB5 +Mcu.Pin29=PB6 +Mcu.Pin3=PC1 +Mcu.Pin30=PB7 +Mcu.Pin31=PB8-BOOT0 +Mcu.Pin32=PB9 +Mcu.Pin33=VP_SYS_VS_Systick +Mcu.Pin34=VP_SYS_VS_DBSignals +Mcu.Pin4=PC2 +Mcu.Pin5=PC3 +Mcu.Pin6=PA5 +Mcu.Pin7=PA6 +Mcu.Pin8=PA7 +Mcu.Pin9=PB0 +Mcu.PinsNb=35 +Mcu.ThirdPartyNb=0 +Mcu.UserConstants= +Mcu.UserName=STM32G474RETx +MxCube.Version=6.18.1 +MxDb.Version=DB.6.0.181 +NVIC.ADC1_2_IRQn=true\:15\:0\:true\:false\:true\:true\:true\:true +NVIC.BusFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false +NVIC.DMA1_Channel1_IRQn=true\:0\:0\:false\:false\:true\:false\:true\:true +NVIC.DMA2_Channel1_IRQn=true\:0\:0\:false\:false\:true\:false\:true\:true +NVIC.DebugMonitor_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false +NVIC.FDCAN1_IT0_IRQn=true\:15\:0\:true\:false\:true\:true\:true\:true +NVIC.FDCAN1_IT1_IRQn=true\:15\:0\:true\:false\:true\:true\:true\:true +NVIC.FDCAN2_IT0_IRQn=true\:15\:0\:true\:false\:true\:true\:true\:true +NVIC.FDCAN2_IT1_IRQn=true\:15\:0\:true\:false\:true\:true\:true\:true +NVIC.ForceEnableDMAVector=true +NVIC.HardFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false +NVIC.MemoryManagement_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false +NVIC.NonMaskableInt_IRQn=true\:0\:0\:false\:false\:true\:false\:true\:false +NVIC.PendSV_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false +NVIC.PriorityGroup=NVIC_PRIORITYGROUP_4 +NVIC.SVCall_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false +NVIC.SysTick_IRQn=true\:15\:0\:false\:false\:true\:false\:true\:false +NVIC.UsageFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false +PA11.Mode=FDCAN_Activate +PA11.Signal=FDCAN1_RX +PA12.Mode=FDCAN_Activate +PA12.Signal=FDCAN1_TX +PA13.Mode=Trace_Asynchronous_SW +PA13.Signal=SYS_JTMS-SWDIO +PA14.Mode=Trace_Asynchronous_SW +PA14.Signal=SYS_JTCK-SWCLK +PA15.GPIOParameters=GPIO_Label +PA15.GPIO_Label=ESTOP_SENSE +PA15.Locked=true +PA15.Signal=GPIO_Input +PA5.GPIOParameters=GPIO_Label +PA5.GPIO_Label=BPSD_SENSE +PA5.Locked=true +PA5.Mode=IN13-Single-Ended +PA5.Signal=ADC2_IN13 +PA6.GPIOParameters=GPIO_Label +PA6.GPIO_Label=IMD_SENSE +PA6.Locked=true +PA6.Mode=IN3-Single-Ended +PA6.Signal=ADC2_IN3 +PA7.GPIOParameters=GPIO_Label +PA7.GPIO_Label=AMS_SENSE +PA7.Locked=true +PA7.Mode=IN4-Single-Ended +PA7.Signal=ADC2_IN4 +PA8.GPIOParameters=GPIO_Label +PA8.GPIO_Label=RTD_BTN_LED_CONTROL +PA8.Locked=true +PA8.Signal=GPIO_Output +PA9.GPIOParameters=GPIO_Label +PA9.GPIO_Label=TS_ACTIVE_BTN_LED_CONTROL +PA9.Locked=true +PA9.Signal=GPIO_Output +PB0.GPIOParameters=GPIO_Label +PB0.GPIO_Label=BRAKE_D_SIGNAL +PB0.Locked=true +PB0.Mode=IN15-Single-Ended +PB0.Signal=ADC1_IN15 +PB1.GPIOParameters=GPIO_Label +PB1.GPIO_Label=BRAKE_R_SIGNAL +PB1.Locked=true +PB1.Mode=IN12-Single-Ended +PB1.Signal=ADC1_IN12 +PB11.GPIOParameters=GPIO_Label +PB11.GPIO_Label=LED_TEST +PB11.Locked=true +PB11.Signal=GPIO_Output +PB12.Mode=FDCAN_Activate +PB12.Signal=FDCAN2_RX +PB13.Mode=FDCAN_Activate +PB13.Signal=FDCAN2_TX +PB14.GPIOParameters=GPIO_Label +PB14.GPIO_Label=AUX_SIGNAL +PB14.Locked=true +PB14.Mode=IN5-Single-Ended +PB14.Signal=ADC1_IN5 +PB15.GPIOParameters=GPIO_Label +PB15.GPIO_Label=STEERING_ANGLE +PB15.Locked=true +PB15.Mode=IN15-Single-Ended +PB15.Signal=ADC2_IN15 +PB3.Mode=Trace_Asynchronous_SW +PB3.Signal=SYS_JTDO-SWO +PB4.GPIOParameters=GPIO_Label +PB4.GPIO_Label=BRAKE_LIGHT +PB4.Locked=true +PB4.Signal=GPIO_Output +PB5.GPIOParameters=GPIO_Label +PB5.GPIO_Label=TSSI_G_CONTROL +PB5.Locked=true +PB5.Signal=GPIO_Output +PB6.GPIOParameters=GPIO_Label +PB6.GPIO_Label=TSSI_R_CONTROL +PB6.Locked=true +PB6.Signal=GPIO_Output +PB7.GPIOParameters=GPIO_Label +PB7.GPIO_Label=RTD_CONTROL +PB7.Locked=true +PB7.Signal=GPIO_Output +PB8-BOOT0.GPIOParameters=GPIO_Label +PB8-BOOT0.GPIO_Label=AUX_CONTROL +PB8-BOOT0.Locked=true +PB8-BOOT0.Signal=GPIO_Output +PB9.GPIOParameters=GPIO_Label +PB9.GPIO_Label=SOFTWARE_OK_CONTROL +PB9.Locked=true +PB9.Signal=GPIO_Output +PC0.GPIOParameters=GPIO_Label +PC0.GPIO_Label=BSE_SIGNAL +PC0.Locked=true +PC0.Mode=IN6-Single-Ended +PC0.Signal=ADC2_IN6 +PC1.GPIOParameters=GPIO_Label +PC1.GPIO_Label=BSPD_SIGNAL +PC1.Locked=true +PC1.Mode=IN7-Single-Ended +PC1.Signal=ADC1_IN7 +PC10.GPIOParameters=GPIO_Label +PC10.GPIO_Label=INERTIA_SW_SENSE +PC10.Locked=true +PC10.Signal=GPIO_Input +PC11.GPIOParameters=GPIO_Label +PC11.GPIO_Label=RTD_BTN_SENSE +PC11.Locked=true +PC11.Signal=GPIO_Input +PC12.GPIOParameters=GPIO_Label +PC12.GPIO_Label=TS_ACTIVE_BTN_SENSE +PC12.Locked=true +PC12.Signal=GPIO_Input +PC2.GPIOParameters=GPIO_Label +PC2.GPIO_Label=APPS1_SIGNAL +PC2.Locked=true +PC2.Mode=IN8-Single-Ended +PC2.Signal=ADC1_IN8 +PC3.GPIOParameters=GPIO_Label +PC3.GPIO_Label=APPS2_SIGNAL +PC3.Locked=true +PC3.Mode=IN9-Single-Ended +PC3.Signal=ADC1_IN9 +PF0-OSC_IN.Mode=HSE-External-Oscillator +PF0-OSC_IN.Signal=RCC_OSC_IN +PF1-OSC_OUT.Mode=HSE-External-Oscillator +PF1-OSC_OUT.Signal=RCC_OSC_OUT +PinOutPanel.RotationAngle=0 +ProjectManager.AskForMigrate=true +ProjectManager.BackupPrevious=false +ProjectManager.CompilerLinker=GCC +ProjectManager.CompilerOptimize=6 +ProjectManager.ComputerToolchain=false +ProjectManager.CoupleFile=true +ProjectManager.CustomerFirmwarePackage= +ProjectManager.DefaultFWLocation=true +ProjectManager.DeletePrevious=true +ProjectManager.DeviceId=STM32G474RETx +ProjectManager.FirmwarePackage=STM32Cube FW_G4 V1.6.3 +ProjectManager.FreePins=true +ProjectManager.FreePinsContext= +ProjectManager.HalAssertFull=true +ProjectManager.HeapSize=0x200 +ProjectManager.KeepUserCode=true +ProjectManager.LastFirmware=true +ProjectManager.LibraryCopy=2 +ProjectManager.MainLocation=Core/Src +ProjectManager.NoMain=false +ProjectManager.PreviousToolchain= +ProjectManager.ProjectBuild=false +ProjectManager.ProjectFileName=ECU.ioc +ProjectManager.ProjectName=ECU +ProjectManager.ProjectStructure= +ProjectManager.RegisterCallBack= +ProjectManager.StackSize=0x400 +ProjectManager.TargetToolchain=CMake +ProjectManager.ToolChainLocation= +ProjectManager.UAScriptAfterPath= +ProjectManager.UAScriptBeforePath= +ProjectManager.UnderRoot=false +ProjectManager.functionlistsort=1-SystemClock_Config-RCC-false-HAL-false,2-MX_GPIO_Init-GPIO-false-HAL-true,3-MX_DMA_Init-DMA-false-HAL-true,4-MX_ADC1_Init-ADC1-false-HAL-true,5-MX_ADC2_Init-ADC2-false-HAL-true,6-MX_FDCAN1_Init-FDCAN1-false-HAL-true,7-MX_FDCAN2_Init-FDCAN2-false-HAL-true +RCC.ADC12Freq_Value=160000000 +RCC.ADC345Freq_Value=160000000 +RCC.AHBFreq_Value=160000000 +RCC.APB1Freq_Value=160000000 +RCC.APB1TimFreq_Value=160000000 +RCC.APB2Freq_Value=160000000 +RCC.APB2TimFreq_Value=160000000 +RCC.CRSFreq_Value=48000000 +RCC.CortexFreq_Value=160000000 +RCC.EXTERNAL_CLOCK_VALUE=12288000 +RCC.EnbaleCSS=true +RCC.FCLKCortexFreq_Value=160000000 +RCC.FDCANFreq_Value=160000000 +RCC.FamilyName=M +RCC.HCLKFreq_Value=160000000 +RCC.HRTIM1Freq_Value=160000000 +RCC.HSE_VALUE=16000000 +RCC.HSI48_VALUE=48000000 +RCC.HSI_VALUE=16000000 +RCC.I2C1Freq_Value=160000000 +RCC.I2C2Freq_Value=160000000 +RCC.I2C3Freq_Value=160000000 +RCC.I2C4Freq_Value=160000000 +RCC.I2SFreq_Value=160000000 +RCC.IPParameters=ADC12Freq_Value,ADC345Freq_Value,AHBFreq_Value,APB1Freq_Value,APB1TimFreq_Value,APB2Freq_Value,APB2TimFreq_Value,CRSFreq_Value,CortexFreq_Value,EXTERNAL_CLOCK_VALUE,EnbaleCSS,FCLKCortexFreq_Value,FDCANFreq_Value,FamilyName,HCLKFreq_Value,HRTIM1Freq_Value,HSE_VALUE,HSI48_VALUE,HSI_VALUE,I2C1Freq_Value,I2C2Freq_Value,I2C3Freq_Value,I2C4Freq_Value,I2SFreq_Value,LPTIM1Freq_Value,LPUART1Freq_Value,LSCOPinFreq_Value,LSE_VALUE,LSI_VALUE,MCO1PinFreq_Value,PLLN,PLLPoutputFreq_Value,PLLQoutputFreq_Value,PLLRCLKFreq_Value,PLLSourceVirtual,PWRFreq_Value,QSPIFreq_Value,RNGFreq_Value,SAI1Freq_Value,SYSCLKFreq_VALUE,SYSCLKSource,UART4Freq_Value,UART5Freq_Value,USART1Freq_Value,USART2Freq_Value,USART3Freq_Value,USBFreq_Value,VCOInputFreq_Value,VCOOutputFreq_Value +RCC.LPTIM1Freq_Value=160000000 +RCC.LPUART1Freq_Value=160000000 +RCC.LSCOPinFreq_Value=32000 +RCC.LSE_VALUE=32768 +RCC.LSI_VALUE=32000 +RCC.MCO1PinFreq_Value=16000000 +RCC.PLLN=20 +RCC.PLLPoutputFreq_Value=160000000 +RCC.PLLQoutputFreq_Value=160000000 +RCC.PLLRCLKFreq_Value=160000000 +RCC.PLLSourceVirtual=RCC_PLLSOURCE_HSE +RCC.PWRFreq_Value=160000000 +RCC.QSPIFreq_Value=160000000 +RCC.RNGFreq_Value=160000000 +RCC.SAI1Freq_Value=160000000 +RCC.SYSCLKFreq_VALUE=160000000 +RCC.SYSCLKSource=RCC_SYSCLKSOURCE_PLLCLK +RCC.UART4Freq_Value=160000000 +RCC.UART5Freq_Value=160000000 +RCC.USART1Freq_Value=160000000 +RCC.USART2Freq_Value=160000000 +RCC.USART3Freq_Value=160000000 +RCC.USBFreq_Value=160000000 +RCC.VCOInputFreq_Value=16000000 +RCC.VCOOutputFreq_Value=320000000 +VP_SYS_VS_DBSignals.Mode=DisableDeadBatterySignals +VP_SYS_VS_DBSignals.Signal=SYS_VS_DBSignals +VP_SYS_VS_Systick.Mode=SysTick +VP_SYS_VS_Systick.Signal=SYS_VS_Systick +board=custom diff --git a/ECU/Test/Src/StateTicksTest.c b/ECU/Test/Src/StateTicksTest.c index 41e86c9b0..b030edf50 100644 --- a/ECU/Test/Src/StateTicksTest.c +++ b/ECU/Test/Src/StateTicksTest.c @@ -11,7 +11,7 @@ /* - GLV ON - - LOGOMATIC working + - LOGOMATIC_INFO working - TSSI - PRECHARGE ENGAGED - PRECHARGE COMPLETE @@ -29,9 +29,9 @@ static void ECU_Pseudo_State_Tick(ECU_StateData *stateLumpTest) // EV.5.11.5: Flash, 2 Hz to 5 Hz, 50% duty cycle // Here we chose a period of 350ms if (bmsFailure(stateLumpTest) || imdFailure(stateLumpTest)) { - LOGOMATIC("TSSI: TS Faulty\n"); + LOGOMATIC_INFO("TSSI: TS Faulty\n"); } else { - LOGOMATIC("TSSI: TS Normal\n"); + LOGOMATIC_INFO("TSSI: TS Normal\n"); } if (stateLumpTest->ts_active_button_press_interrupt) { @@ -68,8 +68,8 @@ static void ECU_Pseudo_State_Tick(ECU_StateData *stateLumpTest) ECU_Tractive_System_Discharge(stateLumpTest); break; default: - LOGOMATIC("ECU Current State Unknown: %d\n", stateLumpTest->ecu_state); - LOGOMATIC("ECU: Resetting to GLV On\n"); + LOGOMATIC_INFO("ECU Current State Unknown: %d\n", stateLumpTest->ecu_state); + LOGOMATIC_INFO("ECU: Resetting to GLV On\n"); stateLumpTest->ecu_state = GR_GLV_ON; break; } @@ -119,10 +119,10 @@ int main(void) // ########################### // ## Step 0.0 ## // ########################### - LOGOMATIC("State Ticks test started\n"); + LOGOMATIC_INFO("State Ticks test started\n"); ECU_StateData stateLumpTest = defaultState; - LOGOMATIC("Check GLV ON at boot\n"); + LOGOMATIC_INFO("Check GLV ON at boot\n"); stateLumpTest.ecu_state = GR_GLV_ON; stateLumpTest.acu_software_latch = 1; ECU_Pseudo_State_Tick(&stateLumpTest); @@ -130,73 +130,73 @@ int main(void) // ########################## // ## Step 0.1 ## // ########################## - LOGOMATIC("Press and release RTD -> STAY IN GLV ON\n"); + LOGOMATIC_INFO("Press and release RTD -> STAY IN GLV ON\n"); stateLumpTest.rtd_button_press_interrupt = true; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_GLV_ON) { - LOGOMATIC("0.1 Failure: ecu state not in GLV ON\n"); + LOGOMATIC_INFO("0.1 Failure: ecu state not in GLV ON\n"); return 1; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.1 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.1 Failure: BMS or IMD reports faulty\n"); return 1; } // ########################## // ## Step 0.2 ## // ########################## - LOGOMATIC("Press throttle (1 and 2): STAY IN GLV ON\n"); + LOGOMATIC_INFO("Press throttle (1 and 2): STAY IN GLV ON\n"); stateLumpTest.APPS1_Signal = stateLumpTest.apps_1_max; stateLumpTest.APPS2_Signal = stateLumpTest.apps_2_max; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_GLV_ON) { - LOGOMATIC("0.2 Failure: ecu state not in GLV ON\n"); + LOGOMATIC_INFO("0.2 Failure: ecu state not in GLV ON\n"); return 2; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.2 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.2 Failure: BMS or IMD reports faulty\n"); return 1; } stateLumpTest.APPS1_Signal = stateLumpTest.apps_1_min; stateLumpTest.APPS2_Signal = stateLumpTest.apps_2_min; - LOGOMATIC("Press brake: STAY IN GLV ON\n"); + LOGOMATIC_INFO("Press brake: STAY IN GLV ON\n"); stateLumpTest.bse_signal = stateLumpTest.brake_bse_min + 69; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_GLV_ON) { - LOGOMATIC("0.2 Failure: ecu state not in GLV ON\n"); + LOGOMATIC_INFO("0.2 Failure: ecu state not in GLV ON\n"); return 2; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.2 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.2 Failure: BMS or IMD reports faulty\n"); return 2; } - LOGOMATIC("Release brake: STAY IN GLV ON\n"); + LOGOMATIC_INFO("Release brake: STAY IN GLV ON\n"); stateLumpTest.bse_signal = 0; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_GLV_ON) { - LOGOMATIC("0.2 Failure: ecu state not in GLV ON\n"); + LOGOMATIC_INFO("0.2 Failure: ecu state not in GLV ON\n"); return 2; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.2 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.2 Failure: BMS or IMD reports faulty\n"); return 2; } // ########################## // ## Step 0.3 ## // ########################## - LOGOMATIC("Press TS ACTIVE: Go to PRECHARGE ENGAGE\n"); + LOGOMATIC_INFO("Press TS ACTIVE: Go to PRECHARGE ENGAGE\n"); stateLumpTest.ts_active_button_press_interrupt = true; stateLumpTest.ir_minus = true; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_ENGAGED) { - LOGOMATIC("0.3 Failure: ecu state not in precharge engaged\n"); + LOGOMATIC_INFO("0.3 Failure: ecu state not in precharge engaged\n"); return 3; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.3 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.3 Failure: BMS or IMD reports faulty\n"); return 3; } @@ -204,281 +204,281 @@ int main(void) // ## Step 0.4 ## // ########################## if (stateLumpTest.ecu_state != GR_PRECHARGE_ENGAGED) { - LOGOMATIC("0.4 Failure: ecu state not in precharge engaged\n"); + LOGOMATIC_INFO("0.4 Failure: ecu state not in precharge engaged\n"); return 4; } // ########################## // ## Step 0.5 ## // ########################## - LOGOMATIC("Test Precharge Complete (IR PLUS)\n"); + LOGOMATIC_INFO("Test Precharge Complete (IR PLUS)\n"); stateLumpTest.ir_plus = true; stateLumpTest.ts_voltage = 400; // dummy value ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_COMPLETE) { - LOGOMATIC("0.5 Failure: ecu state not in precharge complete\n"); + LOGOMATIC_INFO("0.5 Failure: ecu state not in precharge complete\n"); return 5; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.5 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.5 Failure: BMS or IMD reports faulty\n"); return 5; } // ########################## // ## Step 0.6 ## // ########################## - LOGOMATIC("Press RTD -> STAY IN PRECHARGE COMPLETE\n"); + LOGOMATIC_INFO("Press RTD -> STAY IN PRECHARGE COMPLETE\n"); stateLumpTest.rtd_button_press_interrupt = true; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_COMPLETE) { - LOGOMATIC("0.6 Failure: ecu state not in precharge complete\n"); + LOGOMATIC_INFO("0.6 Failure: ecu state not in precharge complete\n"); return 6; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.6 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.6 Failure: BMS or IMD reports faulty\n"); return 6; } - LOGOMATIC("Release RTD -> STAY IN PRECHARGE COMPLETE\n"); + LOGOMATIC_INFO("Release RTD -> STAY IN PRECHARGE COMPLETE\n"); stateLumpTest.rtd_button_press_interrupt = false; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_COMPLETE) { - LOGOMATIC("0.6 Failure: ecu state not in precharge complete\n"); + LOGOMATIC_INFO("0.6 Failure: ecu state not in precharge complete\n"); return 6; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.6 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.6 Failure: BMS or IMD reports faulty\n"); return 6; } // ########################## // ## Step 0.7 ## // ########################## - LOGOMATIC("Press and release the RTD button WHILE pressing the brake\n"); + LOGOMATIC_INFO("Press and release the RTD button WHILE pressing the brake\n"); stateLumpTest.bse_signal = stateLumpTest.brake_bse_min + 69; - LOGOMATIC("Press RTD\n"); + LOGOMATIC_INFO("Press RTD\n"); stateLumpTest.rtd_button_press_interrupt = true; ECU_Pseudo_State_Tick(&stateLumpTest); - LOGOMATIC("Release RTD\n"); + LOGOMATIC_INFO("Release RTD\n"); ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_DRIVE_ACTIVE) { - LOGOMATIC("0.7 Failure: ecu state not in drive active\n"); + LOGOMATIC_INFO("0.7 Failure: ecu state not in drive active\n"); return 7; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.7 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.7 Failure: BMS or IMD reports faulty\n"); return 7; } // ########################## // ## Step 0.8 ## // ########################## - LOGOMATIC("Release Brakes -> STAY IN DRIVE ACTIVE\n"); + LOGOMATIC_INFO("Release Brakes -> STAY IN DRIVE ACTIVE\n"); stateLumpTest.bse_signal = 0; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_DRIVE_ACTIVE) { - LOGOMATIC("0.8 Failure: ecu state not in drive active\n"); + LOGOMATIC_INFO("0.8 Failure: ecu state not in drive active\n"); return 8; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.8 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.8 Failure: BMS or IMD reports faulty\n"); return 8; } // ########################## // ## Step 0.9 ## // ########################## - LOGOMATIC("Press Throttle -> STAY IN DRIVE ACTIVE\n"); + LOGOMATIC_INFO("Press Throttle -> STAY IN DRIVE ACTIVE\n"); stateLumpTest.APPS1_Signal = stateLumpTest.apps_1_max; stateLumpTest.APPS2_Signal = stateLumpTest.apps_2_max; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_DRIVE_ACTIVE) { - LOGOMATIC("0.9 Failure: ecu state not in drive active\n"); + LOGOMATIC_INFO("0.9 Failure: ecu state not in drive active\n"); return 9; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.9 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.9 Failure: BMS or IMD reports faulty\n"); return 9; } // ########################## // ## Step 0.10 ## // ########################## - LOGOMATIC("Release Throttle -> STAY IN DRIVE ACTIVE\n"); + LOGOMATIC_INFO("Release Throttle -> STAY IN DRIVE ACTIVE\n"); stateLumpTest.APPS1_Signal = 0; stateLumpTest.APPS2_Signal = 0; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_DRIVE_ACTIVE) { - LOGOMATIC("0.10 Failure: ecu state not in drive active\n"); + LOGOMATIC_INFO("0.10 Failure: ecu state not in drive active\n"); return 10; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.10 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.10 Failure: BMS or IMD reports faulty\n"); return 10; } // ########################## // ## Step 0.11 ## // ########################## - LOGOMATIC("Press Throttle and Brake -> STAY IN DRIVE ACTIVE\n"); + LOGOMATIC_INFO("Press Throttle and Brake -> STAY IN DRIVE ACTIVE\n"); stateLumpTest.APPS1_Signal = stateLumpTest.apps_1_max; stateLumpTest.APPS2_Signal = stateLumpTest.apps_2_max; stateLumpTest.bse_signal = stateLumpTest.brake_bse_min + 69; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_DRIVE_ACTIVE) { - LOGOMATIC("0.11 Failure: ecu state not in drive active\n"); + LOGOMATIC_INFO("0.11 Failure: ecu state not in drive active\n"); return 11; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.11 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.11 Failure: BMS or IMD reports faulty\n"); return 11; } // ########################## // ## Step 0.12 ## // ########################## - LOGOMATIC("Release Throttle and Brake-> STAY IN DRIVE ACTIVE\n"); + LOGOMATIC_INFO("Release Throttle and Brake-> STAY IN DRIVE ACTIVE\n"); stateLumpTest.APPS1_Signal = stateLumpTest.apps_1_min; stateLumpTest.APPS2_Signal = stateLumpTest.apps_2_min; stateLumpTest.bse_signal = 0; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_DRIVE_ACTIVE) { - LOGOMATIC("0.12 Failure: ecu state not in drive active\n"); + LOGOMATIC_INFO("0.12 Failure: ecu state not in drive active\n"); return 12; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.12 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.12 Failure: BMS or IMD reports faulty\n"); return 12; } // ########################## // ## Step 0.13 ## // ########################## - LOGOMATIC("Press Throttle -> STAY IN DRIVE ACTIVE\n"); + LOGOMATIC_INFO("Press Throttle -> STAY IN DRIVE ACTIVE\n"); stateLumpTest.APPS1_Signal = stateLumpTest.apps_1_max; stateLumpTest.APPS2_Signal = stateLumpTest.apps_2_max; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_DRIVE_ACTIVE) { - LOGOMATIC("0.13 Failure: ecu state not in drive active\n"); + LOGOMATIC_INFO("0.13 Failure: ecu state not in drive active\n"); return 13; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.13 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.13 Failure: BMS or IMD reports faulty\n"); return 13; } // ########################## // ## Step 0.14 ## // ########################## - LOGOMATIC("Release Throttle -> STAY IN DRIVE ACTIVE\n"); + LOGOMATIC_INFO("Release Throttle -> STAY IN DRIVE ACTIVE\n"); stateLumpTest.APPS1_Signal = stateLumpTest.apps_1_min; stateLumpTest.APPS2_Signal = stateLumpTest.apps_2_min; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_DRIVE_ACTIVE) { - LOGOMATIC("0.14 Failure: ecu state not in drive active\n"); + LOGOMATIC_INFO("0.14 Failure: ecu state not in drive active\n"); return 14; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.14 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.14 Failure: BMS or IMD reports faulty\n"); return 14; } // ########################## // ## Step 0.15 ## // ########################## - LOGOMATIC("Press RTD -> MOVE TO PRECHARGE COMPLETE\n"); + LOGOMATIC_INFO("Press RTD -> MOVE TO PRECHARGE COMPLETE\n"); stateLumpTest.rtd_button_press_interrupt = true; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_COMPLETE) { - LOGOMATIC("0.15 Failure: ecu state not in precharge complete\n"); + LOGOMATIC_INFO("0.15 Failure: ecu state not in precharge complete\n"); return 15; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.15 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.15 Failure: BMS or IMD reports faulty\n"); return 15; } - LOGOMATIC("Release RTD -> STAY IN PRECHARGE COMPLETE\n"); + LOGOMATIC_INFO("Release RTD -> STAY IN PRECHARGE COMPLETE\n"); ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_COMPLETE) { - LOGOMATIC("0.15 Failure: ecu state not in precharge complete\n"); + LOGOMATIC_INFO("0.15 Failure: ecu state not in precharge complete\n"); return 15; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.15 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.15 Failure: BMS or IMD reports faulty\n"); return 15; } // ########################## // ## Step 0.16 ## // ########################## - LOGOMATIC("Press Throttle -> STAY IN Precharge Complete\n"); + LOGOMATIC_INFO("Press Throttle -> STAY IN Precharge Complete\n"); stateLumpTest.APPS1_Signal = stateLumpTest.apps_1_max; stateLumpTest.APPS2_Signal = stateLumpTest.apps_2_max; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_COMPLETE) { - LOGOMATIC("0.16 Failure: ecu state not in precharge complete\n"); + LOGOMATIC_INFO("0.16 Failure: ecu state not in precharge complete\n"); return 16; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.16 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.16 Failure: BMS or IMD reports faulty\n"); return 16; } // ########################## // ## Step 0.17 ## // ########################## - LOGOMATIC("Release Throttle -> STAY IN Precharge Complete\n"); + LOGOMATIC_INFO("Release Throttle -> STAY IN Precharge Complete\n"); stateLumpTest.APPS1_Signal = stateLumpTest.apps_1_min; stateLumpTest.APPS2_Signal = stateLumpTest.apps_2_min; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_COMPLETE) { - LOGOMATIC("0.17 Failure: ecu state not in precharge complete\n"); + LOGOMATIC_INFO("0.17 Failure: ecu state not in precharge complete\n"); return 17; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.17 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.17 Failure: BMS or IMD reports faulty\n"); return 17; } // ########################## // ## Step 0.18 ## // ########################## - LOGOMATIC("Press TS Active Button -> MOVE to TS DISCHARGE\n"); + LOGOMATIC_INFO("Press TS Active Button -> MOVE to TS DISCHARGE\n"); stateLumpTest.ts_active_button_press_interrupt = true; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_TS_DISCHARGE) { - LOGOMATIC("0.18 Failure: ecu state not in ts discharge\n"); + LOGOMATIC_INFO("0.18 Failure: ecu state not in ts discharge\n"); return 18; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.18 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.18 Failure: BMS or IMD reports faulty\n"); return 18; } - LOGOMATIC("Release TS Active Button -> STAY IN TS DISCHARGE\n"); + LOGOMATIC_INFO("Release TS Active Button -> STAY IN TS DISCHARGE\n"); ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_TS_DISCHARGE) { - LOGOMATIC("0.18 Failure: ecu state not in ts discharge\n"); + LOGOMATIC_INFO("0.18 Failure: ecu state not in ts discharge\n"); return 18; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.18 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.18 Failure: BMS or IMD reports faulty\n"); return 18; } // ########################## // ## Step 0.19 ## // ########################## - LOGOMATIC("TS Voltage Less than 60 -> MOVE to GLV ON\n"); + LOGOMATIC_INFO("TS Voltage Less than 60 -> MOVE to GLV ON\n"); stateLumpTest.ts_voltage = 40; ECU_Pseudo_State_Tick(&stateLumpTest); stateLumpTest.ir_minus = !stateLumpTest.ir_minus; stateLumpTest.ir_plus = !stateLumpTest.ir_plus; if (stateLumpTest.ecu_state != GR_GLV_ON) { - LOGOMATIC("0.19 Failure: ecu state not in GLV ON\n"); + LOGOMATIC_INFO("0.19 Failure: ecu state not in GLV ON\n"); return 19; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("0.19 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("0.19 Failure: BMS or IMD reports faulty\n"); return 19; } } @@ -487,46 +487,46 @@ int main(void) // ########################## // ## Step 1.0 ## // ########################## - LOGOMATIC("Reset system\n"); + LOGOMATIC_INFO("Reset system\n"); ECU_StateData stateLumpTest = defaultState; - LOGOMATIC("State Tick Test 1 started\n"); + LOGOMATIC_INFO("State Tick Test 1 started\n"); ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_GLV_ON) { - LOGOMATIC("1.0 Failure: ecu state not in GLV ON\n"); + LOGOMATIC_INFO("1.0 Failure: ecu state not in GLV ON\n"); return 21; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("1.0 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("1.0 Failure: BMS or IMD reports faulty\n"); return 21; } // ########################## // ## Step 1.1 ## // ########################## - LOGOMATIC("TS Voltage Greater than 60 -> MOVE to TS DISCHARGE\n"); + LOGOMATIC_INFO("TS Voltage Greater than 60 -> MOVE to TS DISCHARGE\n"); stateLumpTest.ts_voltage = 500; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_TS_DISCHARGE) { - LOGOMATIC("1.1 Failure: ecu state not in TS DISCHARGE\n"); + LOGOMATIC_INFO("1.1 Failure: ecu state not in TS DISCHARGE\n"); return 21; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("1.1 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("1.1 Failure: BMS or IMD reports faulty\n"); return 21; } // ########################## // ## Step 1.2 ## // ########################## - LOGOMATIC("TS Voltage Less than 60 -> MOVE to GLV ON\n"); + LOGOMATIC_INFO("TS Voltage Less than 60 -> MOVE to GLV ON\n"); stateLumpTest.ts_voltage = 40; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_GLV_ON) { - LOGOMATIC("1.2 Failure: ecu state not in GLV ON\n"); + LOGOMATIC_INFO("1.2 Failure: ecu state not in GLV ON\n"); return 22; } if (bmsFailure(&stateLumpTest) || imdFailure(&stateLumpTest)) { - LOGOMATIC("1.2 Failure: BMS or IMD reports faulty\n"); + LOGOMATIC_INFO("1.2 Failure: BMS or IMD reports faulty\n"); return 21; } } diff --git a/ECU/Test/Src/dummy_test.c b/ECU/Test/Src/dummy_test.c index f1080e5e3..e33ef6353 100644 --- a/ECU/Test/Src/dummy_test.c +++ b/ECU/Test/Src/dummy_test.c @@ -2,6 +2,6 @@ int main(void) { - LOGOMATIC("Dummy test executed successfully.\n"); + LOGOMATIC_INFO("Dummy test executed successfully.\n"); return 0; }