philip/MDH-UAV-Control-System
Archived
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Working ADC with DMA. Needs some cleaning

Browse Source
This commit is contained in:
philsson 2016-09-20 11:43:17 +02:00
parent c3ce11d0cc
commit 5716445448
14 changed files with 1371 additions and 661 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -31,3 +31,8 @@
# Debug files
*.dSYM/
*.su
**.d
**/Debug/
**/Release/

4
UAV-ControlSystem/.cproject
View File

@ -37,10 +37,10 @@
<option id="gnu.c.compiler.option.preprocessor.def.symbols.103287632" name="Defined symbols (-D)" superClass="gnu.c.compiler.option.preprocessor.def.symbols" useByScannerDiscovery="false" valueType="definedSymbols">
<listOptionValue builtIn="false" value="STM32F4"/>
<listOptionValue builtIn="false" value="STM32"/>
<listOptionValue builtIn="false" value="STM32F411RETx"/>
<listOptionValue builtIn="false" value="DEBUG"/>
<listOptionValue builtIn="false" value="USE_HAL_DRIVER"/>
<listOptionValue builtIn="false" value="STM32F411xE"/>
<listOptionValue builtIn="false" value="STM32F405RGTx"/>
<listOptionValue builtIn="false" value="STM32F405xx"/>
</option>
<inputType id="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.c.1429172986" superClass="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.c"/>
<inputType id="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.s.1184599199" superClass="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.s"/>

BIN
UAV-ControlSystem/Debug/UAV-ControlSystem.bin
View File

Binary file not shown.

2
UAV-ControlSystem/Debug/objects.list
View File

@ -1,6 +1,8 @@
"src/drivers/adc.o"
"src/drivers/dma.o"
"src/main.o"
"src/stm32f4xx_it.o"
"src/syscalls.o"
"src/system_stm32f4xx.o"
"src/utilities.o"
"startup/startup_stm32.o"

1468
UAV-ControlSystem/Debug/output.map
View File

File diff suppressed because it is too large Load Diff

27
UAV-ControlSystem/inc/drivers/adc.h
View File

@ -39,15 +39,38 @@ void adc_configure();
* BRIEF: *
* INFORMATION: *
***********************************************************************/
void adc_pin_config(ADC_HandleTypeDef * g_AdcHandle, uint32_t adc_channel);
void adc_pin_add(uint32_t adc_channel);
/***********************************************************************
* BRIEF: *
* INFORMATION: *
***********************************************************************/
void adc_start();
/***********************************************************************
* BRIEF: *
* INFORMATION: *
***********************************************************************/
uint32_t adc_read_int(ADC_HandleTypeDef * g_AdcHandle);
uint32_t adc_read_int();
/***********************************************************************
* BRIEF: *
* INFORMATION: *
***********************************************************************/
//void HAL_ADC_ConvCpltCallback();
/***********************************************************************
* BRIEF: *
* INFORMATION: *
***********************************************************************/
//void D**MA2_Stream4_IRQHandler();
/***********************************************************************
* BRIEF: *
* INFORMATION: *
***********************************************************************/
void ADC_IRQHandler();

16
UAV-ControlSystem/inc/drivers/dma.h Normal file
View File

@ -0,0 +1,16 @@
/*
* dma.h
*
* Created on: 16 sep. 2016
* Author: Philip
*/
#ifndef DRIVERS_DMA_H_
#define DRIVERS_DMA_H_
#include "stm32f4xx.h"
#include "system_variables.h"
void configureDMA();
#endif /* DRIVERS_DMA_H_ */

43
UAV-ControlSystem/inc/system_variables.h Normal file
View File

@ -0,0 +1,43 @@
/*
* system_variables.h
*
* Created on: 15 sep. 2016
* Author: Philip
*/
#ifndef SYSTEM_VARIABLES_H_
#define SYSTEM_VARIABLES_H_
#define ADC_STATE_POLL AS_DMA
#define ADC_STATE
#include "stm32f4xx.h"
enum ADC_STATES { AS_POLL, AS_IRQ, AS_DMA };
/* A buffer for the ADC to write with DMA */
enum{ ADC_BUFFER_LENGTH = 9 };
extern volatile uint32_t g_ADCBuffer[ADC_BUFFER_LENGTH];
/* Defining boolean - false = 0, true = 1 */
enum BOOLEAN { false,true };
/* Counter of ADC readings */
extern int g_MeasurementNumber;
/* ADC Rank - For each IO we increment the rank?? */
extern int adc_rank;
/* Last ADC reading (when polling) */
extern __IO uint32_t g_ADCValue;
/* ADC handler - OBS: Tried to use this as a pointer but it did not work */
extern ADC_HandleTypeDef g_AdcHandle;
/* DMA handler */
extern DMA_HandleTypeDef g_DmaHandle;
#endif /* SYSTEM_VARIABLES_H_ */

17
UAV-ControlSystem/inc/utilities.h Normal file
View File

@ -0,0 +1,17 @@
/*
* utilities.h
*
* Created on: 16 sep. 2016
* Author: Philip
*/
#ifndef UTILITIES_H_
#define UTILITIES_H_
#include <stdint.h>
#include "stm32f4xx_it.h"
uint32_t accumulate(uint32_t list[], int length);
void Error_Handler(void);
#endif /* UTILITIES_H_ */

170
UAV-ControlSystem/src/drivers/adc.c
View File

@ -4,74 +4,168 @@
* Created on: 13 sep. 2016
* Author: Philip
*/
#include <drivers/adc.h>
#include "drivers/adc.h"
#include "system_variables.h"
#include "utilities.h"
ADC_HandleTypeDef g_AdcHandle;
volatile uint32_t g_ADCBuffer[ADC_BUFFER_LENGTH] = {0};
int g_MeasurementNumber = 0;
int adc_rank = 0;
__IO uint32_t g_ADCValue = 0;
ADC_ChannelConfTypeDef sConfig;
void adc_configure()
{
__GPIOC_CLK_ENABLE();
__ADC1_CLK_ENABLE();
//
// __ADC1_CLK_ENABLE();
//
// HAL_NVIC_SetPriority(ADC_IRQn, 0,0);
// HAL_NVIC_EnableIRQ(ADC_IRQn);
g_AdcHandle.Instance = ADC1;
g_AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV8;
g_AdcHandle.Init.Resolution = ADC_RESOLUTION12b;
g_AdcHandle.Init.ScanConvMode = ENABLE; //DISABLE;
g_AdcHandle.Init.ContinuousConvMode = ENABLE;
g_AdcHandle.Init.DiscontinuousConvMode = DISABLE;
g_AdcHandle.Init.NbrOfDiscConversion = 0;
g_AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; //ADC_EXTERNALTRIGCONV_T1_CC1;
g_AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONVEDGE_NONE;
g_AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
g_AdcHandle.Init.NbrOfConversion = 3; //adc_rank;
g_AdcHandle.Init.DMAContinuousRequests = ENABLE;//DISABLE;
g_AdcHandle.Init.EOCSelection = EOC_SINGLE_CONV;
if (HAL_ADC_Init(&g_AdcHandle) != HAL_OK)
Error_Handler();
}
void adc_pin_config(ADC_HandleTypeDef * g_AdcHandle, uint32_t adc_channel)
void adc_pin_add(uint32_t adc_channel)
{
//ADC_HandleTypeDef g_AdcHandle;
/* Variable used to initialize the GPIO */
GPIO_InitTypeDef gpioInit;
/* Variable to assign the IO to its Port ex PA, PB etc */
GPIO_TypeDef * gpio_port;
// TODO!!!!
if (adc_channel == ADC_CHANNEL_12) gpioInit.Pin = GPIO_PIN_2;
else gpioInit.Pin = GPIO_PIN_1;
/* Configuration dependent on channel - TODO complete this switch */
switch (adc_channel)
{
case ADC_CHANNEL_0:
gpio_port = GPIOA;
gpioInit.Pin = GPIO_PIN_0;
break;
case ADC_CHANNEL_1:
gpio_port = GPIOA;
gpioInit.Pin = GPIO_PIN_1;
break;
case ADC_CHANNEL_2:
gpio_port = GPIOA;
gpioInit.Pin = GPIO_PIN_2;
break;
case ADC_CHANNEL_3:
case ADC_CHANNEL_4:
case ADC_CHANNEL_5:
case ADC_CHANNEL_6:
case ADC_CHANNEL_7:
case ADC_CHANNEL_8:
case ADC_CHANNEL_9:
case ADC_CHANNEL_10:
case ADC_CHANNEL_11:
gpio_port = GPIOC;
gpioInit.Pin = GPIO_PIN_1;
break;
case ADC_CHANNEL_12:
gpio_port = GPIOC;
gpioInit.Pin = GPIO_PIN_2;
break;
case ADC_CHANNEL_13:
case ADC_CHANNEL_14:
case ADC_CHANNEL_15:
break;
}
gpioInit.Mode = GPIO_MODE_ANALOG;
gpioInit.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOC,&gpioInit);
HAL_NVIC_SetPriority(ADC_IRQn, 0,0);
HAL_NVIC_EnableIRQ(ADC_IRQn);
ADC_ChannelConfTypeDef adcChannel;
HAL_GPIO_Init(gpio_port,&gpioInit);
g_AdcHandle->Instance = ADC1;
g_AdcHandle->Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
g_AdcHandle->Init.Resolution = ADC_RESOLUTION12b;
g_AdcHandle->Init.ScanConvMode = DISABLE;
g_AdcHandle->Init.ContinuousConvMode = ENABLE;
g_AdcHandle->Init.DiscontinuousConvMode = DISABLE;
g_AdcHandle->Init.NbrOfDiscConversion = 0;
g_AdcHandle->Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONV_T1_CC1;
g_AdcHandle->Init.DataAlign = ADC_DATAALIGN_RIGHT;
g_AdcHandle->Init.NbrOfConversion = 1;
g_AdcHandle->Init.DMAContinuousRequests = ENABLE;
g_AdcHandle->Init.EOCSelection = DISABLE;
HAL_ADC_Init(g_AdcHandle);
ADC_ChannelConfTypeDef adc_channel_conf;
adcChannel.Channel = adc_channel; // ex ADC_CHANNEL_12
adcChannel.Rank = 1;
adcChannel.SamplingTime = ADC_SAMPLETIME_480CYCLES;
adcChannel.Offset = 0;
if (HAL_ADC_ConfigChannel(g_AdcHandle, &adcChannel) != HAL_OK)
adc_channel_conf.Channel = adc_channel; // ex ADC_CHANNEL_12
adc_rank++;
adc_channel_conf.Rank = (uint32_t)adc_rank;
adc_channel_conf.SamplingTime = ADC_SAMPLETIME_480CYCLES;
adc_channel_conf.Offset = 0;
if (HAL_ADC_ConfigChannel(&g_AdcHandle, &adc_channel_conf) != HAL_OK)
{
asm("bkpt 255");
//asm("bkpt 255");
Error_Handler();
}
HAL_ADC_Start(g_AdcHandle);
}
uint32_t adc_read_int(ADC_HandleTypeDef * g_AdcHandle)
void adc_start()
{
if (ADC_STATE_POLL == AS_POLL)
/* Polling */
HAL_ADC_Start(&g_AdcHandle);
if (ADC_STATE_POLL == AS_IRQ)
/* Interrupt case */
//g_AdcHandle.DMA_Handle->XferCpltCallback = &HAL_ADC_ConvCpltCallback;
HAL_ADC_Start_IT(&g_AdcHandle);
if (ADC_STATE_POLL == AS_DMA)
/* DMA case */
//if (HAL_ADC_Start_DMA(&g_AdcHandle, g_ADCBuffer, ADC_BUFFER_LENGTH) != HAL_OK)
if (HAL_ADC_Start_DMA(&g_AdcHandle, (uint32_t*)&g_ADCBuffer, ADC_BUFFER_LENGTH) != HAL_OK)
{
Error_Handler();
}
}
uint32_t adc_read_int()
{
uint32_t value = 0;
if (HAL_ADC_PollForConversion(g_AdcHandle, 100) == HAL_OK)
if (HAL_ADC_PollForConversion(&g_AdcHandle, 100) == HAL_OK)
{
value = HAL_ADC_GetValue(g_AdcHandle);
value = HAL_ADC_GetValue(&g_AdcHandle);
}
return value;
}
//void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef * AdcHandle)
//{
// /* Interrupt case */
// //g_ADCValue = HAL_ADC_GetValue(AdcHandle);
//
//
// /* DMA case */
// /*
// g_ADCValue = accumulate(*g_ADCBuffer, ADC_BUFFER_LENGTH) / ADC_BUFFER_LENGTH;
// g_MeasurementNumber += ADC_BUFFER_LENGTH;
// */
//
//
// // Test to see if this functions is ran at all
// //g_ADCValue = 2;
//
// int hej = g_ADCValue;
//}

41
UAV-ControlSystem/src/drivers/dma.c Normal file
View File

@ -0,0 +1,41 @@
/*
* dma.c
*
* Created on: 16 sep. 2016
* Author: Philip
*/
#include "drivers/dma.h"
#include "stm32_hal_legacy.h"
DMA_HandleTypeDef g_DmaHandle;
void configureDMA()
{
//__DMA2_CLK_ENABLE();
__HAL_RCC_DMA2_CLK_ENABLE();
g_DmaHandle.Instance = DMA2_Stream4;
g_DmaHandle.Init.Channel = DMA_CHANNEL_0;
g_DmaHandle.Init.Direction = DMA_PERIPH_TO_MEMORY;
g_DmaHandle.Init.PeriphInc = DMA_PINC_DISABLE;
g_DmaHandle.Init.MemInc = DMA_MINC_ENABLE;
g_DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
g_DmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
g_DmaHandle.Init.Mode = DMA_CIRCULAR;
g_DmaHandle.Init.Priority = DMA_PRIORITY_HIGH;
g_DmaHandle.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
g_DmaHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;
g_DmaHandle.Init.MemBurst = DMA_MBURST_SINGLE;
g_DmaHandle.Init.PeriphBurst = DMA_PBURST_SINGLE;
HAL_DMA_Init(&g_DmaHandle);
__HAL_LINKDMA(&g_AdcHandle, DMA_Handle, g_DmaHandle);
// HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);)
HAL_NVIC_SetPriority(DMA2_Stream4_IRQn,0,0);
HAL_NVIC_EnableIRQ(DMA2_Stream4_IRQn);
}

189
UAV-ControlSystem/src/main.c
View File

@ -10,21 +10,31 @@
*/
#include <drivers/adc.h>
#include "drivers/adc.h"
#include "stm32f4xx.h"
#include "system_variables.h"
#include "drivers/dma.h"
#include "utilities.h"
#include <string.h>
/* Private function prototypes -----------------------------------------------*/
static void SystemClock_Config(void);
static void Error_Handler(void);
static void SystemClock_Config_Lennart(void);
ADC_HandleTypeDef adc_testinput_handle; // For example battery voltage
ADC_HandleTypeDef adc_test2input_handle;
uint32_t g_ADCValue;
uint32_t g_ADC2;
int g_MeasurementNumber;
int main(void)
{
// Comment?
HAL_Init();
@ -35,50 +45,40 @@ int main(void)
SystemClock_Config();
adc_configure();
adc_pin_config(&adc_testinput_handle,ADC_CHANNEL_12);
//adc_pin_config(&adc_testinput_handle,ADC_CHANNEL_11);
adc_pin_add(ADC_CHANNEL_0);
adc_pin_add(ADC_CHANNEL_1);
adc_pin_add(ADC_CHANNEL_12);
/*##-1- Enable GPIOA Clock (to be able to program the configuration registers) */
__HAL_RCC_GPIOA_CLK_ENABLE();
__GPIOB_CLK_ENABLE();
GPIO_InitTypeDef gpinit;
gpinit.Pin = GPIO_PIN_0;
gpinit.Pin = GPIO_PIN_5;
gpinit.Mode = GPIO_MODE_OUTPUT_PP;
gpinit.Pull = GPIO_PULLUP;
gpinit.Speed = GPIO_SPEED_FAST;
gpinit.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(GPIOB, &gpinit);
/*##-2- Configure PA05 IO in output push-pull mode to drive external LED ###*/
//GPIO_InitStruct.Pin = GPIO_PIN_5 | GPIO_PIN_6;
//GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
//GPIO_InitStruct.Pull = GPIO_PULLUP;
//GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(GPIOA, &gpinit);
adc_start();
/*##-3- Toggle PA05 IO in an infinite loop #################################*/
while (1)
{
i++;
/* Insert a 100ms delay */
HAL_Delay(100);
// ADC part
//g_ADCValue = adc_read_int(&adc_testinput_handle);
HAL_Delay(10);
g_ADC2 = adc_read_int(&adc_testinput_handle);
g_MeasurementNumber++;
if (g_ADC2 > 2000)
g_ADCValue = accumulate(g_ADCBuffer,ADC_BUFFER_LENGTH) / ADC_BUFFER_LENGTH;
//HAL_Delay(100);
int offTime = g_ADCValue;
int onTime = 4096 - offTime;
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5,GPIO_PIN_SET);
for (int i = 0; i < onTime; i++)
{
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_0);
asm("nop");
}
else
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5,GPIO_PIN_RESET);
for (int i = 0; i < offTime; i++)
{
asm("nop");
}
}
@ -86,69 +86,95 @@ int main(void)
for(;;);
}
HAL_ADC_MspInit(ADC_HandleTypeDef * hadc)
{
//static DMA_HandleTypeDef g_DmaHandle;
// Enable DMA, ADC and related GPIO ports clock
__DMA2_CLK_ENABLE();
__ADC1_CLK_ENABLE();
__GPIOA_CLK_ENABLE();
__GPIOC_CLK_ENABLE();
// DMA2 Stream4 channel1 (physically mapped to ADC1) configuration
g_DmaHandle.Instance = DMA2_Stream4;
g_DmaHandle.Init.Channel = DMA_CHANNEL_0;
g_DmaHandle.Init.Direction = DMA_PERIPH_TO_MEMORY;
g_DmaHandle.Init.PeriphInc = DMA_PINC_DISABLE;
g_DmaHandle.Init.MemInc = DMA_MINC_ENABLE;
g_DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
g_DmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
g_DmaHandle.Init.Mode = DMA_CIRCULAR;
g_DmaHandle.Init.Priority = DMA_PRIORITY_HIGH;
g_DmaHandle.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
g_DmaHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;
g_DmaHandle.Init.MemBurst = DMA_MBURST_SINGLE;
g_DmaHandle.Init.PeriphBurst = DMA_PBURST_SINGLE;
HAL_DMA_Init(&g_DmaHandle);
// Associate the initialized DMA handle to the the ADC handle
//__HAL_LINKDMA(adc_handler, DMA_Handle, g_DmaHandle);
__HAL_LINKDMA(&g_AdcHandle, DMA_Handle, g_DmaHandle);
// NVIC configuration for DMA transfer complete interrupt
//HAL_NVIC_SetPriority(DMA2_Stream4_IRQn, 15, 15);
//HAL_NVIC_EnableIRQ(DMA2_Stream4_IRQn);
}
//void DMA2_Stream4_IRQHandler(void)
//{
// //HAL_DMA_IRQHandler(g_AdcHandle.DMA_Handle);
// HAL_DMA_IRQHandler(&g_DmaHandle);
//}
//
//void ADC_IRQHandler()
//{
// HAL_ADC_IRQHandler(&g_AdcHandle);
//}
//
//void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef * AdcHandle)
//{
// int i = 2;
//}
/**
* @brief System Clock Configuration
* The system Clock is configured as follow :
* System Clock source = PLL (HSI)
* SYSCLK(Hz) = 100000000
* HCLK(Hz) = 100000000
* AHB Prescaler = 1
* APB1 Prescaler = 2
* APB2 Prescaler = 1
* HSI Frequency(Hz) = 16000000
* PLL_M = 16
* PLL_N = 400
* PLL_P = 4
* PLL_Q = 7
* VDD(V) = 3.3
* Main regulator output voltage = Scale2 mode
* Flash Latency(WS) = 3
* @param None
* @retval None
*/
static void SystemClock_Config(void)
{
RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;
/* Enable Power Control clock */
__HAL_RCC_PWR_CLK_ENABLE();
/* The voltage scaling allows optimizing the power consumption when the device is
clocked below the maximum system frequency, to update the voltage scaling value
regarding system frequency refer to product datasheet. */
//__PWR_CLK_ENABLE(); // samma skit
__HAL_RCC_PWR_CLK_ENABLE();
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);
/* Enable HSI Oscillator and activate PLL with HSI as source */
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = 0x10;
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_HSI;
RCC_OscInitStruct.PLL.PLLM = 16;
RCC_OscInitStruct.PLL.PLLN = 400;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
RCC_OscInitStruct.PLL.PLLQ = 7;
if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 8;
RCC_OscInitStruct.PLL.PLLN = 288;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 6;
HAL_RCC_OscConfig(&RCC_OscInitStruct);
/* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2
clocks dividers */
RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK)
{
Error_Handler();
}
}
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4);
if (HAL_GetREVID() == 0x1001)
__HAL_FLASH_PREFETCH_BUFFER_ENABLE();
//SystemCoreClockUpdate();
}
@ -157,9 +183,4 @@ static void SystemClock_Config(void)
* @param None
* @retval None
*/
static void Error_Handler(void)
{
while(1)
{
}
}

24
UAV-ControlSystem/src/utilities.c Normal file
View File

@ -0,0 +1,24 @@
/*
* utilities.c
*
* Created on: 16 sep. 2016
* Author: Philip
*/
#include "utilities.h"
uint32_t accumulate(uint32_t * list, int length)
{
int value = 0;
for (int i = 0; i < length; i++)
{
value += list[i];
}
return value;
}
void Error_Handler(void)
{
while(1)
{
}
}

6
revolution_hal_lib/.cproject
View File

@ -40,9 +40,10 @@
<option id="gnu.c.compiler.option.preprocessor.def.symbols.1112709806" name="Defined symbols (-D)" superClass="gnu.c.compiler.option.preprocessor.def.symbols" useByScannerDiscovery="false" valueType="definedSymbols">
<listOptionValue builtIn="false" value="STM32F4"/>
<listOptionValue builtIn="false" value="STM32"/>
<listOptionValue builtIn="false" value="STM32F411RETx"/>
<listOptionValue builtIn="false" value="USE_HAL_DRIVER"/>
<listOptionValue builtIn="false" value="STM32F411xE"/>
<listOptionValue builtIn="false" value="STM32F405RGTx"/>
<listOptionValue builtIn="false" value="STM32F405xx"/>
<listOptionValue builtIn="false" value="STM32F4xx_it"/>
</option>
<inputType id="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.c.2034000507" superClass="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.c"/>
<inputType id="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.s.993011920" superClass="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.s"/>
@ -159,4 +160,5 @@
</scannerConfigBuildInfo>
</storageModule>
<storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
<storageModule moduleId="refreshScope"/>
</cproject>