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

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 */