FaSTTUBe/Master_Control
51
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Working version

Browse Source
This commit is contained in:
jazzpi
2022-07-18 16:54:42 +02:00
parent b49ac54166
commit 7795a7cd7d
25 changed files with 40462 additions and 19931 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
Core/Inc/AIR_State_Maschine.h
View File

@ -18,9 +18,12 @@
#define TS_DISCHARGE 3
#define TS_ERROR 4
#define TS_ACTIVE 1
#define TS_CHARGING_CHECK 5
#define TS_CHARGING 6
#define ADC_READ_TIMEOUT 500 // in ms
#define SDC_LOWER_THRESHOLD 2500 // in ADC Values
#define ADC_READ_TIMEOUT 500 // in ms
#define SDC_LOWER_THRESHOLD 2500 // in ADC Values
#define PRECHARGE_95_DURATION 1000 // in ms
// FIXME
#define LOWER_VEHICLE_SIDE_VOLTAGE_LIMIT 150000 // in mV
@ -30,18 +33,12 @@ typedef struct {
int32_t BatteryVoltageBatterySide;
uint8_t targetTSState;
uint8_t currentTSState;
uint16_t AIRPrechargeCurrent; // ADC Value
uint16_t AIRPositiveCurrent; // ADC Value
uint16_t AIRNegativeCurrent; // ADC Value
uint16_t RelaisSupplyVoltage;
uint16_t ShutdownCircuitVoltage;
uint32_t precharge95ReachedTimestamp;
uint32_t chargingCheckTimestamp;
} AIRStateHandler;
AIRStateHandler init_AIR_State_Maschine(ADC_HandleTypeDef* relay_adc,
ADC_HandleTypeDef* sc_adc,
DMA_HandleTypeDef* relay_dma,
DMA_HandleTypeDef* sc_dma);
AIRStateHandler init_AIR_State_Maschine();
void Update_AIR_Info(AIRStateHandler* airstate);
uint8_t Update_AIR_State(AIRStateHandler* airstate);
@ -54,6 +51,4 @@ void AIR_Discharge_Position();
void AIR_Active_Position();
void AIR_Error_Position();
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc);
#endif /* INC_AIR_STATE_MASCHINE_H_ */

2
Core/Inc/CAN_Communication.h
View File

@ -15,7 +15,7 @@
#include "stm32g4xx_hal.h"
#include "stm32g4xx_hal_fdcan.h"
#define CANFRAMEBUFFERSIZE 256
#define CANFRAMEBUFFERSIZE 512
// Frame ID = Base Address + Slave ID + MessageNr.
#define SLAVE_STATUS_BASE_ADDRESS 0x600

1
Core/Inc/SPI_Slave_Communication.h
View File

@ -14,7 +14,6 @@
#include "stm32g4xx_hal_crc.h"
#define SET_SHUNTDATA 0x01
#define SET_TSSTATE 0x02
#define GET_TSSTATE 0x03

3
Core/Inc/Slave_Monitoring.h
View File

@ -14,12 +14,11 @@
#include "stm32g441xx.h"
#define NUMBEROFSLAVES 6
#define NUMBEROFCELLS 10
#define NUMBEROFTEMPS 32
#define SLAVETIMEOUT 2000
#define SLAVETIMEOUT 500
typedef struct {

28
Core/Inc/main.h
View File

@ -67,42 +67,14 @@ void AMS_Error_Handler(AMSErrorHandle);
#define BOOT0_FF_CLK_GPIO_Port GPIOC
#define BOOT0_FF_DATA_Pin GPIO_PIN_15
#define BOOT0_FF_DATA_GPIO_Port GPIOC
#define Relay_Supply_Voltage_Pin GPIO_PIN_0
#define Relay_Supply_Voltage_GPIO_Port GPIOA
#define Pos_AIR_Current_Pin GPIO_PIN_1
#define Pos_AIR_Current_GPIO_Port GPIOA
#define Neg_AIR_Current_Pin GPIO_PIN_2
#define Neg_AIR_Current_GPIO_Port GPIOA
#define PreCharge_AIR_Current_Pin GPIO_PIN_3
#define PreCharge_AIR_Current_GPIO_Port GPIOA
#define SC_Supply_Voltage_Pin GPIO_PIN_4
#define SC_Supply_Voltage_GPIO_Port GPIOA
#define AMS_ERROR_Pin GPIO_PIN_0
#define AMS_ERROR_GPIO_Port GPIOB
#define IMD_Error_Pin GPIO_PIN_1
#define IMD_Error_GPIO_Port GPIOB
#define AMS_Error_LED_Pin GPIO_PIN_2
#define AMS_Error_LED_GPIO_Port GPIOB
#define Volt_Error_CPU_Pin GPIO_PIN_10
#define Volt_Error_CPU_GPIO_Port GPIOB
#define Positive_Side_Error_CPU_Pin GPIO_PIN_11
#define Positive_Side_Error_CPU_GPIO_Port GPIOB
#define Neg_Side_Error_CPU_Pin GPIO_PIN_12
#define Neg_Side_Error_CPU_GPIO_Port GPIOB
#define HV_Inactive_CPU_Pin GPIO_PIN_13
#define HV_Inactive_CPU_GPIO_Port GPIOB
#define Neg_AIR_Open_CPU_Pin GPIO_PIN_14
#define Neg_AIR_Open_CPU_GPIO_Port GPIOB
#define High_Side_Open_CPU_Pin GPIO_PIN_15
#define High_Side_Open_CPU_GPIO_Port GPIOB
#define Inter_STM_CS_Pin GPIO_PIN_8
#define Inter_STM_CS_GPIO_Port GPIOA
#define Inter_STM_IRQ_Pin GPIO_PIN_9
#define Inter_STM_IRQ_GPIO_Port GPIOA
#define Status_LED_Pin GPIO_PIN_10
#define Status_LED_GPIO_Port GPIOA
#define IMD_Error_LED_Pin GPIO_PIN_3
#define IMD_Error_LED_GPIO_Port GPIOB
#define PreCharge_Control_Pin GPIO_PIN_5
#define PreCharge_Control_GPIO_Port GPIOB
#define AIR_Positive_Control_Pin GPIO_PIN_6

2
Core/Inc/stm32g4xx_hal_conf.h
View File

@ -36,7 +36,7 @@
#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

3
Core/Inc/stm32g4xx_it.h
View File

@ -56,12 +56,9 @@ void SVC_Handler(void);
void DebugMon_Handler(void);
void PendSV_Handler(void);
void SysTick_Handler(void);
void DMA1_Channel2_IRQHandler(void);
void ADC1_2_IRQHandler(void);
void FDCAN1_IT0_IRQHandler(void);
void FDCAN1_IT1_IRQHandler(void);
void SPI1_IRQHandler(void);
void DMA2_Channel1_IRQHandler(void);
/* USER CODE BEGIN EFP */
/* USER CODE END EFP */

116
Core/Src/AIR_State_Maschine.c
View File

@ -7,8 +7,7 @@
#include "AIR_State_Maschine.h"
ADC_HandleTypeDef* air_current_adc = {0};
ADC_HandleTypeDef* sdc_voltage_adc = {0};
#include "stm32g4xx_hal.h"
DMA_HandleTypeDef* air_current_dma = {0};
DMA_HandleTypeDef* sdc_voltage_dma = {0};
@ -16,25 +15,11 @@ DMA_HandleTypeDef* sdc_voltage_dma = {0};
uint8_t air_adc_complete = 0;
uint8_t sdc_adc_complete = 0;
AIRStateHandler init_AIR_State_Maschine(ADC_HandleTypeDef* relay_adc,
ADC_HandleTypeDef* sc_adc,
DMA_HandleTypeDef* relay_dma,
DMA_HandleTypeDef* sc_dma) {
air_current_adc = relay_adc;
sdc_voltage_adc = sc_adc;
air_current_dma = relay_dma;
sdc_voltage_dma = sc_dma;
AIRStateHandler init_AIR_State_Maschine() {
AIRStateHandler airstate = {0};
airstate.targetTSState = TS_INACTIVE;
airstate.currentTSState = TS_INACTIVE;
airstate.ShutdownCircuitVoltage = 0;
airstate.RelaisSupplyVoltage = 0;
airstate.AIRNegativeCurrent = 0;
airstate.AIRPositiveCurrent = 0;
airstate.AIRPrechargeCurrent = 0;
airstate.BatteryVoltageBatterySide = 0;
airstate.BatteryVoltageVehicleSide = 0;
@ -65,16 +50,6 @@ void Update_AIR_Info(AIRStateHandler* airstate) {
status = HAL_ADC_PollForConversion(air_current_adc, 10);
uint32_t adcval5 = HAL_ADC_GetValue(air_current_adc);
HAL_ADC_Stop(air_current_adc);*/
uint32_t startmils = HAL_GetTick() + ADC_READ_TIMEOUT;
{
airstate->RelaisSupplyVoltage = 3000;
airstate->AIRPositiveCurrent = 0;
airstate->AIRNegativeCurrent = 0;
airstate->AIRPrechargeCurrent = 0;
airstate->ShutdownCircuitVoltage = 3000;
}
}
uint8_t Update_AIR_State(AIRStateHandler* airstate) {
@ -91,25 +66,7 @@ uint8_t Update_AIR_State(AIRStateHandler* airstate) {
if (airstate->currentTSState == TS_ERROR) // No Escape from TS Error State
{
return TS_ERROR;
}
else if ((airstate->currentTSState == TS_INACTIVE) &&
(airstate->targetTSState ==
TS_ACTIVE)) // Transition from Inactive to Active via Precharge
{
if ((airstate->RelaisSupplyVoltage) > SDC_LOWER_THRESHOLD) {
airstate->currentTSState = TS_PRECHARGE;
}
}
// TODO: Is it correct that we also go from precharge to discharge?
else if ((airstate->currentTSState == TS_ACTIVE ||
airstate->currentTSState == TS_PRECHARGE) &&
(airstate->targetTSState ==
TS_INACTIVE)) // Transition from Active to Inactive via Discharge
{
airstate->currentTSState = TS_DISCHARGE;
// Don't change anything, but prevent any other if from being entered
}
else if (airstate->targetTSState ==
@ -118,6 +75,41 @@ uint8_t Update_AIR_State(AIRStateHandler* airstate) {
airstate->currentTSState = TS_ERROR;
}
else if ((airstate->currentTSState == TS_INACTIVE) &&
(airstate->targetTSState ==
TS_ACTIVE)) // Transition from Inactive to Active via Precharge
{
airstate->currentTSState = TS_PRECHARGE;
airstate->precharge95ReachedTimestamp = 0;
}
else if ((airstate->currentTSState == TS_INACTIVE) &&
(airstate->targetTSState == TS_CHARGING)) {
airstate->currentTSState = TS_CHARGING_CHECK;
airstate->chargingCheckTimestamp = HAL_GetTick();
}
// TODO: Is it correct that we also go from precharge to discharge?
else if ((airstate->currentTSState == TS_ACTIVE ||
airstate->currentTSState == TS_PRECHARGE ||
airstate->currentTSState == TS_CHARGING_CHECK ||
airstate->currentTSState == TS_CHARGING) &&
(airstate->targetTSState ==
TS_INACTIVE)) // Transition from Active to Inactive via Discharge
{
airstate->currentTSState = TS_DISCHARGE;
}
else if ((airstate->targetTSState == TS_CHARGING) &&
(airstate->currentTSState == TS_CHARGING_CHECK)) {
if (airstate->BatteryVoltageVehicleSide >
airstate->BatteryVoltageBatterySide) {
airstate->currentTSState = TS_CHARGING;
} else if (HAL_GetTick() > airstate->chargingCheckTimestamp + 2000) {
airstate->currentTSState = TS_ERROR;
}
}
else if (airstate->currentTSState ==
TS_PRECHARGE) // Change from Precharge to Active at 95% TS Voltage at
// Vehicle Side
@ -125,15 +117,20 @@ uint8_t Update_AIR_State(AIRStateHandler* airstate) {
if ((airstate->BatteryVoltageVehicleSide >
LOWER_VEHICLE_SIDE_VOLTAGE_LIMIT)) {
if (airstate->BatteryVoltageVehicleSide >
(airstate->BatteryVoltageBatterySide * 0.90)) {
airstate->currentTSState = TS_ACTIVE;
(airstate->BatteryVoltageBatterySide * 0.95)) {
if (airstate->precharge95ReachedTimestamp == 0) {
airstate->precharge95ReachedTimestamp = HAL_GetTick();
} else if (HAL_GetTick() - airstate->precharge95ReachedTimestamp >=
PRECHARGE_95_DURATION) {
airstate->currentTSState = TS_ACTIVE;
}
}
}
}
else if (airstate->currentTSState ==
TS_DISCHARGE) // Change from Discharge to Inactive at 95% TS Voltage
// at Vehicle Side
TS_DISCHARGE) // Change from Discharge to Inactive at 95% TS
// Voltage at Vehicle Side
{
airstate->currentTSState = TS_INACTIVE;
}
@ -149,6 +146,14 @@ uint8_t Update_AIR_State(AIRStateHandler* airstate) {
AIR_Discharge_Position();
}
if (airstate->currentTSState == TS_CHARGING_CHECK) {
AIR_Precharge_Position();
}
if (airstate->currentTSState == TS_CHARGING) {
AIR_Active_Position();
}
if (airstate->currentTSState == TS_ACTIVE) {
AIR_Active_Position();
}
@ -218,14 +223,3 @@ void AIR_Error_Position() {
HAL_GPIO_WritePin(AIR_Positive_Control_GPIO_Port, AIR_Positive_Control_Pin,
GPIO_PIN_RESET);
}
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) {
if (hadc == air_current_adc) {
air_adc_complete = 1;
HAL_ADC_Stop_DMA(air_current_adc);
}
if (hadc == sdc_voltage_adc) {
sdc_adc_complete = 1;
HAL_ADC_Stop_DMA(sdc_voltage_adc);
}
}

45
Core/Src/CAN_Communication.c
View File

@ -11,12 +11,12 @@
#include "stm32g4xx_hal_fdcan.h"
// 3 should be programmed with CAN id 2
const uint16_t slave_CAN_id_to_slave_index[7] = {
0, 1, 2, 3, 255, 5, 4}; // TODO: Make this pretty pls
0, 1, 2, 3, 4, 5, 255}; // TODO: Make this pretty pls
canFrame framebuffer[CANFRAMEBUFFERSIZE] = {0};
uint8_t framebufferwritepointer;
uint8_t framebufferreadpointer;
uint32_t framebufferwritepointer;
uint32_t framebufferreadpointer;
void CAN_Init(FDCAN_HandleTypeDef* hcan) {
HAL_FDCAN_Stop(hcan);
@ -27,8 +27,8 @@ void CAN_Init(FDCAN_HandleTypeDef* hcan) {
FDCAN_FilterTypeDef fdfilter = {0};
fdfilter.FilterConfig = FDCAN_FILTER_TO_RXFIFO0;
fdfilter.FilterID1 = 0x000; // Range start
fdfilter.FilterID2 = 0x000; // Range stop
fdfilter.FilterID1 = 0x000; // ID
fdfilter.FilterID2 = 0x000; // Mask
fdfilter.FilterIndex = 0;
fdfilter.FilterType = FDCAN_FILTER_MASK;
@ -38,6 +38,10 @@ void CAN_Init(FDCAN_HandleTypeDef* hcan) {
HAL_StatusTypeDef status = HAL_FDCAN_Start(hcan);
if (status) {
return;
}
status =
HAL_FDCAN_ActivateNotification(hcan, FDCAN_IT_RX_FIFO0_NEW_MESSAGE, 0);
}
@ -59,23 +63,20 @@ uint8_t CAN_Receive(FDCAN_HandleTypeDef* hcan) {
slaveID = slave_CAN_id_to_slave_index[slaveID];
uint8_t messageID = msg & 0x00F;
updateSlaveInfo(slaveID, messageID, rxFrame);
} else if (rxFrame.FrameID == SLAVE_EMERGENCY_ADDRESS) {
AMSErrorHandle errorframe = {0};
errorframe.errorcode = SlavesErrorFrameError;
errorframe.errorarg[0] = rxFrame.data[0];
errorframe.errorarg[1] = rxFrame.data[1];
errorframe.errorarg[2] = rxFrame.data[2];
errorframe.errorarg[3] = rxFrame.data[3];
errorframe.errorarg[4] = rxFrame.data[4];
errorframe.errorarg[5] = rxFrame.data[5];
errorframe.errorarg[6] = rxFrame.data[6];
errorframe.errorarg[7] = rxFrame.data[7];
AMS_Error_Handler(errorframe);
}
/* if(rxFrame.FrameID == SLAVE_EMERGENCY_ADDRESS)
{
AMSErrorHandle errorframe = {0};
errorframe.errorcode = SlavesErrorFrameError;
errorframe.errorarg[0] = rxFrame.data[0];
errorframe.errorarg[1] = rxFrame.data[1];
errorframe.errorarg[2] = rxFrame.data[2];
errorframe.errorarg[3] = rxFrame.data[3];
errorframe.errorarg[4] = rxFrame.data[4];
errorframe.errorarg[5] = rxFrame.data[5];
errorframe.errorarg[6] = rxFrame.data[6];
errorframe.errorarg[7] = rxFrame.data[7];
AMS_Error_Handler(errorframe);
}*/
}
return 0;

19
Core/Src/Error_Check.c
View File

@ -9,24 +9,5 @@
ErrorFlags CheckErrorFlags() {
ErrorFlags errors = {0};
errors.IMD_ERROR = !HAL_GPIO_ReadPin(IMD_Error_GPIO_Port, IMD_Error_Pin);
errors.IMD_ERROR_LED =
HAL_GPIO_ReadPin(IMD_Error_LED_GPIO_Port, IMD_Error_LED_Pin);
errors.AMS_ERROR_LED =
HAL_GPIO_ReadPin(AMS_ERROR_GPIO_Port, AMS_Error_LED_Pin);
errors.TS_no_voltage_error =
HAL_GPIO_ReadPin(Volt_Error_CPU_GPIO_Port, Volt_Error_CPU_Pin);
errors.positive_AIR_or_PC_error = HAL_GPIO_ReadPin(
Positive_Side_Error_CPU_GPIO_Port, Positive_Side_Error_CPU_Pin);
errors.negative_AIR_error =
HAL_GPIO_ReadPin(Neg_Side_Error_CPU_GPIO_Port, Neg_Side_Error_CPU_Pin);
errors.HV_inactive =
HAL_GPIO_ReadPin(HV_Inactive_CPU_GPIO_Port, HV_Inactive_CPU_Pin);
errors.negative_AIR_open =
HAL_GPIO_ReadPin(Neg_AIR_Open_CPU_GPIO_Port, Neg_AIR_Open_CPU_Pin);
errors.positive_AIR_and_PC_open =
HAL_GPIO_ReadPin(High_Side_Open_CPU_GPIO_Port, High_Side_Open_CPU_Pin);
return errors;
}

31
Core/Src/SPI_Slave_Communication.c
View File

@ -15,7 +15,6 @@
#include <stdint.h>
#define SPI_BUFFER_SIZE 1024
#define DUMMYBYTES 2
@ -313,26 +312,16 @@ void InterSTMFrame() {
spitxbuf[tsstatebaseaddress + 0] = spi_airstates->currentTSState;
spitxbuf[tsstatebaseaddress + 1] = (uint8_t)(spi_airstates->targetTSState);
spitxbuf[tsstatebaseaddress + 2] =
(uint8_t)(spi_airstates->RelaisSupplyVoltage >> 8) & 0xFF;
spitxbuf[tsstatebaseaddress + 3] =
(uint8_t)(spi_airstates->RelaisSupplyVoltage & 0xFF);
spitxbuf[tsstatebaseaddress + 4] =
(uint8_t)((spi_airstates->ShutdownCircuitVoltage >> 8) & 0xFF);
spitxbuf[tsstatebaseaddress + 5] =
(uint8_t)(spi_airstates->ShutdownCircuitVoltage & 0xFF);
spitxbuf[tsstatebaseaddress + 6] =
(uint8_t)((spi_airstates->AIRNegativeCurrent >> 8) & 0xFF);
spitxbuf[tsstatebaseaddress + 7] =
(uint8_t)(spi_airstates->AIRNegativeCurrent & 0xFF);
spitxbuf[tsstatebaseaddress + 8] =
(uint8_t)((spi_airstates->AIRPositiveCurrent >> 8) & 0xFF);
spitxbuf[tsstatebaseaddress + 9] =
(uint8_t)((spi_airstates->AIRPositiveCurrent) & 0xFF);
spitxbuf[tsstatebaseaddress + 10] =
(uint8_t)((spi_airstates->AIRPrechargeCurrent >> 8) & 0xFF);
spitxbuf[tsstatebaseaddress + 11] =
(uint8_t)((spi_airstates->AIRPrechargeCurrent) & 0xFF);
spitxbuf[tsstatebaseaddress + 2] = (uint8_t)(0) & 0xFF;
spitxbuf[tsstatebaseaddress + 3] = (uint8_t)(0);
spitxbuf[tsstatebaseaddress + 4] = (uint8_t)((0) & 0xFF);
spitxbuf[tsstatebaseaddress + 5] = (uint8_t)(0);
spitxbuf[tsstatebaseaddress + 6] = (uint8_t)((0) & 0xFF);
spitxbuf[tsstatebaseaddress + 7] = (uint8_t)(0);
spitxbuf[tsstatebaseaddress + 8] = (uint8_t)((0) & 0xFF);
spitxbuf[tsstatebaseaddress + 9] = (uint8_t)((0) & 0xFF);
spitxbuf[tsstatebaseaddress + 10] = (uint8_t)((0) & 0xFF);
spitxbuf[tsstatebaseaddress + 11] = (uint8_t)((0) & 0xFF);
spitxbuf[tsstatebaseaddress + 12] =
(uint8_t)((spi_airstates->BatteryVoltageBatterySide >> 24) & 0xFF);
spitxbuf[tsstatebaseaddress + 13] =

191
Core/Src/main.c
View File

@ -46,11 +46,6 @@
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;
ADC_HandleTypeDef hadc2;
DMA_HandleTypeDef hdma_adc1;
DMA_HandleTypeDef hdma_adc2;
CRC_HandleTypeDef hcrc;
FDCAN_HandleTypeDef hfdcan1;
@ -64,9 +59,6 @@ SPI_HandleTypeDef hspi1;
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_ADC1_Init(void);
static void MX_ADC2_Init(void);
static void MX_FDCAN1_Init(void);
static void MX_SPI1_Init(void);
static void MX_CRC_Init(void);
@ -110,15 +102,12 @@ int main(void) {
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_ADC1_Init();
MX_ADC2_Init();
MX_FDCAN1_Init();
MX_SPI1_Init();
MX_CRC_Init();
/* USER CODE BEGIN 2 */
airstates = init_AIR_State_Maschine(&hadc1, &hadc2, &hdma_adc1, &hdma_adc2);
airstates = init_AIR_State_Maschine();
initSlaves();
set_SPI_errorInfo(&defaulterrorhandle);
spi_communication_init(&hspi1, &airstates);
@ -173,7 +162,7 @@ void SystemClock_Config(void) {
RCC_OscInitStruct.PLL.PLLN = 8;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV8;
RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV8;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
Error_Handler();
}
@ -187,153 +176,11 @@ void SystemClock_Config(void) {
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK) {
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK) {
Error_Handler();
}
}
/**
* @brief ADC1 Initialization Function
* @param None
* @retval None
*/
static void MX_ADC1_Init(void) {
/* 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_ASYNC_DIV64;
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 = DISABLE;
hadc1.Init.NbrOfConversion = 4;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hadc1.Init.DMAContinuousRequests = DISABLE;
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_1;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME_2CYCLES_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_2;
sConfig.Rank = ADC_REGULAR_RANK_2;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_3;
sConfig.Rank = ADC_REGULAR_RANK_3;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_4;
sConfig.Rank = ADC_REGULAR_RANK_4;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
Error_Handler();
}
/* USER CODE BEGIN ADC1_Init 2 */
/* USER CODE END ADC1_Init 2 */
}
/**
* @brief ADC2 Initialization Function
* @param None
* @retval None
*/
static void MX_ADC2_Init(void) {
/* 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_ASYNC_DIV64;
hadc2.Init.Resolution = ADC_RESOLUTION_12B;
hadc2.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc2.Init.GainCompensation = 0;
hadc2.Init.ScanConvMode = ADC_SCAN_DISABLE;
hadc2.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
hadc2.Init.LowPowerAutoWait = DISABLE;
hadc2.Init.ContinuousConvMode = DISABLE;
hadc2.Init.NbrOfConversion = 1;
hadc2.Init.DiscontinuousConvMode = DISABLE;
hadc2.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc2.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hadc2.Init.DMAContinuousRequests = DISABLE;
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_17;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME_2CYCLES_5;
sConfig.SingleDiff = ADC_SINGLE_ENDED;
sConfig.OffsetNumber = ADC_OFFSET_NONE;
sConfig.Offset = 0;
if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK) {
Error_Handler();
}
/* USER CODE BEGIN ADC2_Init 2 */
/* USER CODE END ADC2_Init 2 */
}
/**
* @brief CRC Initialization Function
* @param None
@ -438,25 +285,6 @@ static void MX_SPI1_Init(void) {
/* USER CODE END SPI1_Init 2 */
}
/**
* Enable DMA controller clock
*/
static void MX_DMA_Init(void) {
/* DMA controller clock enable */
__HAL_RCC_DMAMUX1_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
__HAL_RCC_DMA2_CLK_ENABLE();
/* DMA interrupt init */
/* DMA1_Channel2_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 4, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
/* DMA2_Channel1_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA2_Channel1_IRQn, 4, 0);
HAL_NVIC_EnableIRQ(DMA2_Channel1_IRQn);
}
/**
* @brief GPIO Initialization Function
* @param None
@ -493,18 +321,11 @@ static void MX_GPIO_Init(void) {
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/*Configure GPIO pins : AMS_ERROR_Pin IMD_Error_Pin AMS_Error_LED_Pin
Volt_Error_CPU_Pin Positive_Side_Error_CPU_Pin Neg_Side_Error_CPU_Pin
HV_Inactive_CPU_Pin Neg_AIR_Open_CPU_Pin High_Side_Open_CPU_Pin
IMD_Error_LED_Pin */
GPIO_InitStruct.Pin = AMS_ERROR_Pin | IMD_Error_Pin | AMS_Error_LED_Pin |
Volt_Error_CPU_Pin | Positive_Side_Error_CPU_Pin |
Neg_Side_Error_CPU_Pin | HV_Inactive_CPU_Pin |
Neg_AIR_Open_CPU_Pin | High_Side_Open_CPU_Pin |
IMD_Error_LED_Pin;
/*Configure GPIO pin : AMS_ERROR_Pin */
GPIO_InitStruct.Pin = AMS_ERROR_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
HAL_GPIO_Init(AMS_ERROR_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pin : Inter_STM_CS_Pin */
GPIO_InitStruct.Pin = Inter_STM_CS_Pin;

209
Core/Src/stm32g4xx_hal_msp.c
View File

@ -24,9 +24,6 @@
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */
extern DMA_HandleTypeDef hdma_adc1;
extern DMA_HandleTypeDef hdma_adc2;
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN TD */
@ -96,212 +93,6 @@ void HAL_MspInit(void)
/* USER CODE END MspInit 1 */
}
static uint32_t HAL_RCC_ADC12_CLK_ENABLED=0;
/**
* @brief ADC MSP Initialization
* This function configures the hardware resources used in this example
* @param hadc: ADC handle pointer
* @retval None
*/
void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
if(hadc->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();
}
/* Peripheral clock enable */
HAL_RCC_ADC12_CLK_ENABLED++;
if(HAL_RCC_ADC12_CLK_ENABLED==1){
__HAL_RCC_ADC12_CLK_ENABLE();
}
__HAL_RCC_GPIOA_CLK_ENABLE();
/**ADC1 GPIO Configuration
PA0 ------> ADC1_IN1
PA1 ------> ADC1_IN2
PA2 ------> ADC1_IN3
PA3 ------> ADC1_IN4
*/
GPIO_InitStruct.Pin = Relay_Supply_Voltage_Pin|Pos_AIR_Current_Pin|Neg_AIR_Current_Pin|PreCharge_AIR_Current_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* ADC1 DMA Init */
/* ADC1 Init */
hdma_adc1.Instance = DMA1_Channel2;
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_NORMAL;
hdma_adc1.Init.Priority = DMA_PRIORITY_LOW;
if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)
{
Error_Handler();
}
__HAL_LINKDMA(hadc,DMA_Handle,hdma_adc1);
/* ADC1 interrupt Init */
HAL_NVIC_SetPriority(ADC1_2_IRQn, 4, 0);
HAL_NVIC_EnableIRQ(ADC1_2_IRQn);
/* USER CODE BEGIN ADC1_MspInit 1 */
/* USER CODE END ADC1_MspInit 1 */
}
else if(hadc->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();
}
/* Peripheral clock enable */
HAL_RCC_ADC12_CLK_ENABLED++;
if(HAL_RCC_ADC12_CLK_ENABLED==1){
__HAL_RCC_ADC12_CLK_ENABLE();
}
__HAL_RCC_GPIOA_CLK_ENABLE();
/**ADC2 GPIO Configuration
PA4 ------> ADC2_IN17
*/
GPIO_InitStruct.Pin = SC_Supply_Voltage_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(SC_Supply_Voltage_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_NORMAL;
hdma_adc2.Init.Priority = DMA_PRIORITY_LOW;
if (HAL_DMA_Init(&hdma_adc2) != HAL_OK)
{
Error_Handler();
}
__HAL_LINKDMA(hadc,DMA_Handle,hdma_adc2);
/* ADC2 interrupt Init */
HAL_NVIC_SetPriority(ADC1_2_IRQn, 4, 0);
HAL_NVIC_EnableIRQ(ADC1_2_IRQn);
/* USER CODE BEGIN ADC2_MspInit 1 */
/* USER CODE END ADC2_MspInit 1 */
}
}
/**
* @brief ADC MSP De-Initialization
* This function freeze the hardware resources used in this example
* @param hadc: ADC handle pointer
* @retval None
*/
void HAL_ADC_MspDeInit(ADC_HandleTypeDef* hadc)
{
if(hadc->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
PA0 ------> ADC1_IN1
PA1 ------> ADC1_IN2
PA2 ------> ADC1_IN3
PA3 ------> ADC1_IN4
*/
HAL_GPIO_DeInit(GPIOA, Relay_Supply_Voltage_Pin|Pos_AIR_Current_Pin|Neg_AIR_Current_Pin|PreCharge_AIR_Current_Pin);
/* ADC1 DMA DeInit */
HAL_DMA_DeInit(hadc->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(hadc->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
PA4 ------> ADC2_IN17
*/
HAL_GPIO_DeInit(SC_Supply_Voltage_GPIO_Port, SC_Supply_Voltage_Pin);
/* ADC2 DMA DeInit */
HAL_DMA_DeInit(hadc->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 */
}
}
/**
* @brief CRC MSP Initialization
* This function configures the hardware resources used in this example

47
Core/Src/stm32g4xx_it.c
View File

@ -57,10 +57,6 @@
/* 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 SPI_HandleTypeDef hspi1;
/* USER CODE BEGIN EV */
@ -211,35 +207,6 @@ void SysTick_Handler(void)
/* please refer to the startup file (startup_stm32g4xx.s). */
/******************************************************************************/
/**
* @brief This function handles DMA1 channel2 global interrupt.
*/
void DMA1_Channel2_IRQHandler(void)
{
/* USER CODE BEGIN DMA1_Channel2_IRQn 0 */
/* USER CODE END DMA1_Channel2_IRQn 0 */
HAL_DMA_IRQHandler(&hdma_adc1);
/* USER CODE BEGIN DMA1_Channel2_IRQn 1 */
/* USER CODE END DMA1_Channel2_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.
*/
@ -282,20 +249,6 @@ void SPI1_IRQHandler(void)
/* USER CODE END SPI1_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 */
}
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */