How to Perform Analog to Digital Conversion with an STM32F407G Discovery Board in C

In this article, we go over how to perform analog to digital conversion with an STM32F407G discovery board in C.

Analog to digital conversion allows us to utilize analog devices in our circuits, such as temperature sensors, potentiometers, etc.

The value that an analog device outputs cannot be read directly by a microcontroller. A microcontroller can only read digital values. Therefore, an ADC is necessary to read the output value of an analog device.

We will show how to sample the ADC using a single conversion mode, which means that we sample the value from the ADC component a single time. We then show how to take continuous samples from the ADC so it continuously gets updated values from the ADC component.

The header file we use that contains needed macros and register structures is shown below.

This file is named stm32f407.h

Its contents are shown below.

/* * stm32f407.h * * Created on: May 6, 2022 * Author: dlhyl */ #ifndef STM32F407_H_ #define STM32F407_H_ #include <stdint.h> #define __vo volatile #define IRQ_NO_EXTI0 6 #define IRQ_NO_EXTI1 7 #define IRQ_NO_EXTI2 8 #define IRQ_NO_EXTI3 9 #define IRQ_NO_EXTI4 10 #define IRQ_NO_EXTI9_5 23 #define IRQ_NO_EXTI15_10 40 //Processor specific details #define NVIC_ISER0 0xE000E100U #define NVIC_ISER1 0xE000E104U #define NVIC_ISER2 0xE000E108U #define NVIC_ISER3 0xE000E10CU volatile uint32_t* pNVIC_ISER0= ((volatile uint32_t*)NVIC_ISER0); volatile uint32_t* pNVIC_ISER1= ((volatile uint32_t*)NVIC_ISER1); volatile uint32_t* pNVIC_ISER2= ((volatile uint32_t*)NVIC_ISER2); volatile uint32_t* pNVIC_ISER3= ((volatile uint32_t*)NVIC_ISER3); #define NVIC_ICER0 0xE000E180U #define NVIC_ICER1 0xE000E184U #define NVIC_ICER2 0xE000E188U #define NVIC_ICER3 0xE000E18CU volatile uint32_t* pNVIC_ICERO= ((volatile uint32_t*)NVIC_ICER0); volatile uint32_t* pNVIC_ICER1= ((volatile uint32_t*)NVIC_ICER1); volatile uint32_t* pNVIC_ICER2= ((volatile uint32_t*)NVIC_ICER2); volatile uint32_t* pNVIC_ICER3= ((volatile uint32_t*)NVIC_ICER3); #define NVIC_PR_BASEADDR 0xE000E400U volatile uint32_t* pNVIC_PR_BASEADDR= ((volatile uint32_t*)NVIC_PR_BASEADDR); #define SYS_FREQ 16000000U #define APB1_CLK SYS_FREQ #define USART_BAUDRATE 115200 #define FLASH_BASEADDR 0x08000000U #define SRAM1_BASEADDR 0x20000000U #define SRAM2_BASEADDR 0x20001C00U #define ROM_BASEADDR 0x1FFF0000U #define SRAM SRAM1_BASEADDR #define PERIPH_BASEADDR 0x40000000U #define APB1PERIPH_BASEADDR PERIPH_BASEADDR #define APB2PERIPH_BASEADDR 0x40010000U #define AHB1PERIPH_BASEADDR 0x40020000U #define AHB2PERIPH_BASEADDR 0x50000000U //#define SYSCFG_BASEADDR 0x40013800U //#define EXTI_BASEADDR 0x40013C00U #define GPIOA_BASEADDR (AHB1PERIPH_BASEADDR + 0x0000) #define GPIOB_BASEADDR (AHB1PERIPH_BASEADDR + 0x0400) #define GPIOC_BASEADDR (AHB1PERIPH_BASEADDR + 0x0800) #define GPIOD_BASEADDR (AHB1PERIPH_BASEADDR + 0x0C00) #define GPIOE_BASEADDR (AHB1PERIPH_BASEADDR + 0x1000) #define GPIOF_BASEADDR (AHB1PERIPH_BASEADDR + 0x1400) #define GPIOG_BASEADDR (AHB1PERIPH_BASEADDR + 0x1800) #define GPIOH_BASEADDR (AHB1PERIPH_BASEADDR + 0x1C00) #define GPIOI_BASEADDR (AHB1PERIPH_BASEADDR + 0x2000) #define RCC_BASEADDR (AHB1PERIPH_BASEADDR + 0x3800) #define I2C1_BASEADDR (APB1PERIPH_BASEADDR + 0x5400) #define I2C2_BASEADDR (APB1PERIPH_BASEADDR + 0x5800) #define I2C3_BASEADDR (APB1PERIPH_BASEADDR + 0x5C00) #define SPI2_BASEADDR (APB1PERIPH_BASEADDR + 0x3800) #define SPI3_BASEADDR (APB1PERIPH_BASEADDR + 0x3C00) #define USART2_BASEADDR (APB1PERIPH_BASEADDR + 0x4400) #define USART3_BASEADDR (APB1PERIPH_BASEADDR + 0x4800) #define UART4_BASEADDR (APB1PERIPH_BASEADDR + 0x4C00) #define UART5_BASEADDR (APB1PERIPH_BASEADDR + 0x5000) #define TIM2_BASEADDR (APB1PERIPH_BASEADDR + 0x0000) #define TIM3_BASEADDR (APB1PERIPH_BASEADDR + 0x0400) #define TIM4_BASEADDR (APB1PERIPH_BASEADDR + 0x0800) #define TIM5_BASEADDR (APB1PERIPH_BASEADDR + 0x0C00) #define EXTI_BASEADDR (APB2PERIPH_BASEADDR + 0x3C00) #define SPI1_BASEADDR (APB2PERIPH_BASEADDR + 0x3000) #define SPI4_BASEADDR (APB2PERIPH_BASEADDR + 0x3400) #define SYSCFG_BASEADDR (APB2PERIPH_BASEADDR + 0x3800) #define USART1_BASEADDR (APB2PERIPH_BASEADDR + 0x1000) #define USART6_BASEADDR (APB2PERIPH_BASEADDR + 0x1400) #define SPI5_BASEADDR (APB2PERIPH_BASEADDR + 0x5000) #define SPI6_BASEADDR (APB2PERIPH_BASEADDR + 0x5400) typedef struct { volatile uint32_t MODER; volatile uint32_t OTYPER; volatile uint32_t OSPEEDR; volatile uint32_t PUPDR; volatile uint32_t IDR; volatile uint32_t ODR; volatile uint32_t BSRR; volatile uint32_t LCKR; volatile uint32_t AFRL; volatile uint32_t AFRH; }GPIO_RegDef_t; #define GPIOA ((GPIO_RegDef_t*)GPIOA_BASEADDR) #define GPIOB ((GPIO_RegDef_t*)GPIOB_BASEADDR) #define GPIOC ((GPIO_RegDef_t*)GPIOC_BASEADDR) #define GPIOD ((GPIO_RegDef_t*)GPIOD_BASEADDR) #define GPIOE ((GPIO_RegDef_t*)GPIOE_BASEADDR) #define GPIOF ((GPIO_RegDef_t*)GPIOF_BASEADDR) #define GPIOG ((GPIO_RegDef_t*)GPIOG_BASEADDR) #define GPIOH ((GPIO_RegDef_t*)GPIOH_BASEADDR) #define GPIOI ((GPIO_RegDef_t*)GPIOI_BASEADDR) #define RCC ((RCC_RegDef_t*)RCC_BASEADDR) GPIO_RegDef_t *pGPIOA= GPIOA; GPIO_RegDef_t *pGPIOB= GPIOB; GPIO_RegDef_t *pGPIOC= GPIOC; GPIO_RegDef_t *pGPIOD= GPIOD; GPIO_RegDef_t *pGPIOE= GPIOE; GPIO_RegDef_t *pGPIOF= GPIOF; GPIO_RegDef_t *pGPIOG= GPIOG; GPIO_RegDef_t *pGPIOH= GPIOH; GPIO_RegDef_t *pGPIOI= GPIOI; typedef struct { volatile uint32_t CR; volatile uint32_t PLLCFGR; volatile uint32_t CFGR; volatile uint32_t CIR; volatile uint32_t AHB1RSTR; volatile uint32_t AHB2RSTR; volatile uint32_t AHB3RSTR; uint32_t RESERVED0; volatile uint32_t APB1RSTR; volatile uint32_t APB2RSTR; uint32_t RESERVED1[2]; volatile uint32_t AHB1ENR; volatile uint32_t AHB2ENR; volatile uint32_t AHB3ENR; uint32_t RESERVED2; volatile uint32_t APB1ENR; volatile uint32_t APB2ENR; uint32_t RESERVED3[2]; volatile uint32_t AHB1LPENR; volatile uint32_t AHB2LPENR; volatile uint32_t AHB3LPENR; uint32_t RESERVED4; volatile uint32_t APB1LPENR; volatile uint32_t APB2LPENR; uint32_t RESERVED5[2]; volatile uint32_t BDCR; volatile uint32_t CSR; uint32_t RESERVED6[2]; volatile uint32_t SSCGR; volatile uint32_t PLLI2SCFGR; volatile uint32_t PLLSAICFGR; volatile uint32_t DCKCFGR; volatile uint32_t CKGATENR; volatile uint32_t DCKCFGR2; }RCC_RegDef_t; RCC_RegDef_t *pRCC= RCC; typedef struct { volatile uint32_t MEMRMP; volatile uint32_t PMC; volatile uint32_t EXTICR1; volatile uint32_t EXTICR2; volatile uint32_t EXTICR3; volatile uint32_t EXTICR4; uint32_t RESERVED1[2]; volatile uint32_t CMPCR; }SYSCFG_RegDef_t; SYSCFG_RegDef_t *pSYSCFG= ((SYSCFG_RegDef_t*)SYSCFG_BASEADDR); #define SYSCFG ((SYSCFG_RegDef_t*)SYSCFG_BASEADDR) typedef struct { volatile uint32_t IMR; volatile uint32_t EMR; volatile uint32_t RTSR; volatile uint32_t FTSR; volatile uint32_t SWIER; volatile uint32_t PR; }EXTI_RegDef_t; EXTI_RegDef_t *pEXTI= ((EXTI_RegDef_t*)EXTI_BASEADDR); #define EXTI ((EXTI_RegDef_t*)EXTI_BASEADDR) typedef struct { volatile uint32_t CR1; volatile uint32_t CR2; volatile uint32_t SR; volatile uint32_t DR; volatile uint32_t CRCPR; volatile uint32_t RXCRCR; volatile uint32_t TXCRCR; volatile uint32_t I2SCFGR; volatile uint32_t I2SPR; }SPI_RegDef_t; SPI_RegDef_t *pSPI1= ((SPI_RegDef_t*)SPI1_BASEADDR); SPI_RegDef_t *pSPI2= ((SPI_RegDef_t*)SPI2_BASEADDR); SPI_RegDef_t *pSPI3= ((SPI_RegDef_t*)SPI3_BASEADDR); SPI_RegDef_t *pSPI4= ((SPI_RegDef_t*)SPI4_BASEADDR); SPI_RegDef_t *pSPI5= ((SPI_RegDef_t*)SPI5_BASEADDR); SPI_RegDef_t *pSPI6= ((SPI_RegDef_t*)SPI6_BASEADDR); #define SPI1 ((SPI_RegDef_t*)SPI1_BASEADDR) #define SPI2 ((SPI_RegDef_t*)SPI2_BASEADDR) #define SPI3 ((SPI_RegDef_t*)SPI3_BASEADDR) #define SPI4 ((SPI_RegDef_t*)SPI4_BASEADDR) #define SPI5 ((SPI_RegDef_t*)SPI5_BASEADDR) #define SPI6 ((SPI_RegDef_t*)SPI6_BASEADDR) typedef struct { volatile uint32_t CR1; volatile uint32_t CR2; volatile uint32_t OAR1; volatile uint32_t OAR2; volatile uint32_t DR; volatile uint32_t SR1; volatile uint32_t SR2; volatile uint32_t CCR; volatile uint32_t TRISE; volatile uint32_t FLTR; }I2C_RegDef_t; I2C_RegDef_t *pI2C1= ((I2C_RegDef_t*)I2C1_BASEADDR); I2C_RegDef_t *pI2C2= ((I2C_RegDef_t*)I2C2_BASEADDR); I2C_RegDef_t *pI2C3= ((I2C_RegDef_t*)I2C3_BASEADDR); #define I2C1 ((I2C_RegDef_t*)I2C1_BASEADDR) #define I2C2 ((I2C_RegDef_t*)I2C2_BASEADDR) #define I2C3 ((I2C_RegDef_t*)I2C3_BASEADDR) typedef struct { volatile uint32_t SR; volatile uint32_t DR; volatile uint32_t BRR; volatile uint32_t CR1; volatile uint32_t CR2; volatile uint32_t CR3; volatile uint32_t GTPR; }USART_RegDef_t; USART_RegDef_t *pUSART1= ((USART_RegDef_t*)USART1_BASEADDR); USART_RegDef_t *pUSART2= ((USART_RegDef_t*)USART2_BASEADDR); USART_RegDef_t *pUSART3= ((USART_RegDef_t*)USART3_BASEADDR); USART_RegDef_t *pUART4= ((USART_RegDef_t*)UART4_BASEADDR); USART_RegDef_t *pUART5= ((USART_RegDef_t*)UART5_BASEADDR); USART_RegDef_t *pUSART6= ((USART_RegDef_t*)USART6_BASEADDR); #define USART1 ((USART_RegDef_t*)USART1_BASEADDR) #define USART2 ((USART_RegDef_t*)USART2_BASEADDR) #define USART3 ((USART_RegDef_t*)USART3_BASEADDR) #define USART4 ((USART_RegDef_t*)UART4_BASEADDR) #define USART5 ((USART_RegDef_t*)UART5_BASEADDR) #define USART6 ((USART_RegDef_t*)USART6_BASEADDR) typedef struct { volatile uint32_t CR1; volatile uint32_t CR2; volatile uint32_t SMCR; volatile uint32_t DIER; volatile uint32_t SR; volatile uint32_t EGR; volatile uint32_t CCMR1; volatile uint32_t CCMR2; volatile uint32_t CCER; volatile uint32_t CNT; volatile uint32_t PSC; volatile uint32_t ARR; volatile uint32_t CCR1; volatile uint32_t CCR2; volatile uint32_t CCR3; volatile uint32_t CCR4; uint32_t RESERVED0; volatile uint32_t DCR; volatile uint32_t DMAR; volatile uint32_t OR; }TIM_RegDef_t; TIM_RegDef_t *pTIM2= ((TIM_RegDef_t*)TIM2_BASEADDR); TIM_RegDef_t *pTIM3= ((TIM_RegDef_t*)TIM3_BASEADDR); TIM_RegDef_t *pTIM4= ((TIM_RegDef_t*)TIM4_BASEADDR); TIM_RegDef_t *pTIM5= ((TIM_RegDef_t*)TIM5_BASEADDR); #define TIM2 ((TIM_RegDef_t*)TIM2_BASEADDR) #define TIM3 ((TIM_RegDef_t*)TIM3_BASEADDR) #define TIM4 ((TIM_RegDef_t*)TIM4_BASEADDR) #define TIM5 ((TIM_RegDef_t*)TIM5_BASEADDR) #endif /* STM32F407_H_ */

This header file contains the needed ADC register structure, as well as other items we need.

Single Conversion Mode

Below is the main.c file, which contains the functions we need to do an ADC conversion with a single sample from the sensor.

#include <stdio.h> #include <stdint.h> #include "stm32f407.h" void pa1_adc_init(void); void adc_start_conversion(void); uint32_t adc_read(void); int adc_value; int main(void) { pa1_adc_init(); adc_start_conversion(); while(1) { adc_value= adc_read(); printf("ADC value: %d \n\r", adc_value); } } void pa1_adc_init(void) { //Enables peripheral clock register for ADC1 pRCC->APB2ENR |= (1 << 8); //Turns on the clock for GPIO Port A pRCC->AHB1ENR |= (1 << 0); //Sets pin PA1 as analog pGPIOA->MODER |= (0b11 << 2); //Conversion sequence start //Makes the first ADC sampling start at channel 1 pADC1->SQR3 |= (1 << 0); //Specify conversion sequence length pADC1->SQR1 = 0; //Enable the ADC pADC1->CR2 |= (1 << 0); } void adc_start_conversion(void) { //Start ADC conversion pADC1->CR2 |= (1 << 30); } uint32_t adc_read(void) { //Wait for the conversion to be complete while(!(pADC1->SR & (1 << 1))); //Read converted result return(pADC1->DR); }

So we have 2 include statements, which includes header files.

We create an integer, adc_value, which is the value returned from the sensor in our circuit.

Within our main() function, we initialize our ADC component with the pa1_adc_init() function.

We then have a while(1) function so that we create an infinite loop (even though it really isn't necessary in this case, since it only samples the ADC component a single time and not continuously).

We start the conversion process with the adc_start_conversion() function.

We read the value into our adc_value variable and then print out the value.

Next, we go to our individual functions.

We have the function, pa1_adc_init(). This function initializes ADC functionality for pin PA1 of our board.

So in order to perform analog to digital conversion with an STM32F407G discovery board, we have to work with a variety of registers.

One of the first things to notice about all of the ADCs on the STM32F407G board is the bus that they are connected to it, which is the APB2 bus. This is important because we have to enable the peripheral clock of this bus in order to use the ADC component attached to it.

This diagram is shown below.

You can see that all 3 ADCs are connected to this bus.

Thus, we must enable the clock of this bus.

This is done through the RCC APB2 peripheral clock enable register (RCC_APB2ENR), which is shown below.

You can see on this register, that you can activate ADC1 by setting 1 to bit 8 activate ADC2 by setting 1 to bit 9, and activate ADC3 by setting 1 to bit 10.

On this register, you can see all of the rest of the components which are connected to the APB2 bus. This register is how you enable any component attached to this bus.

In our project, we will be working with ADC1, so we set 1 to pin 8.

So, with this now, we have activated the peripheral clock for component ADC1.

Next we need to choose a general I/O pin, which will function as an ADC pin. We need to then activate the peripheral clock register for this GPIO port.

We will choose pin 1 of GPIO port A. This is PA1.

All of the GPIO ports of the STM32F407G board are connected to the AHB1 bus. Therefore, in order to work with a GPIO pin, we need to enable the peripheral clock for the AHB1 bus.

You can see the diagram of this shown below.

So the next thing we have to do is look at the AHB1 peripheral clock register (RCC_AHB1ENR). This is shown below.

So through this register, we can enable the peripheral clock for any GPIO port. You can see based on the diagram that pin 0 controls GPIO Port A, pin 1 controls GPIO Port B, pin 2 controls GPIO Port C, pin 3 controls GPIO Port D, pin 4 controls GPIO Port E, pin 5 controls GPIO Port F, pin 6 controls GPIO Port G, pin 7 controls GPIO Port I.

In this case, we want to use pin 1 of GPIO Port A, so we enable pin A.

We then must select the mode that the PA1 pin must be in. This is done through the GPIO port mode register (GPIOx_MODER).

This is shown in the diagram below.

You can see that in order to make a pin analog, we need to write '11' to the pin. In the case of PA1, we need to write a 11 to pins 2 and 3, which is what we do in our code.

Next, we deal with ADC sampling.

So let's say we have multiple ADC devices in our circuit. After all, the board has multiple ADC components (ADC1, ADC2, and ADC3). We can sample up to 3 ADC devices. The ADC regular sequence registers can determine which ADCs we sample and in what order. For example, we can sample ADC2, then ADC3, and then ADC1, and we can even resample from those again.

In our circuit, we only have 1 ADC component, ADC1.

The register we need to deal with in this case is the ADC regular sequence register 3 (ADC_SQR3).

This register is shown in the diagram below.

SQ1, the first 4 bits of the register, is the first sequence of the ADC sampling. SQ2 would be if you have another ADC component. SQ3 would be if you have a third ADC component, and so on.

Since we are using ADC1 as the first (the only) sequence, we set bit 0 to 1.

The next thing we need to do is specify the sequence length (how many elements we are doing ADC sampling from).

This is done through the ADC regular sequence register 1. This is shown in the diagram below.

Bits 20 to 23 control the regular channel sequence length. This determines the total number of conversions in the regular channel conversion sequence. In our case, it is 1. Therefore, we set bits 20 to 23 to 0. However, since everything should be 0, we simply set the entire register to 0.

The last thing we must do is enable the ADC, ADC1, in our case.

This is done through the ACD control register 2. This is shown in the diagram below.

Bit 0 is the ADON bit, which stands for A/D converter ON/OFF. To enable the ADC, a 1 must be set to bit 0.

Next we must on to the next function, adc_start_conversion()

This function actually starts the ADC conversion cycle.

To start the conversion process, we use the ADC control register 2 (ADC_CR2), which is the register shown above .

Bit 30 is the SWSTART bit, which when set to 1 starts the conversion of regular channels.

Our last function, adc_read(), returns the value of the ADC device.

Before we can get the value of the ADC device, we must wait for the conversion to be complete. We use a while function to check for this. If the conversion is not complete, nothing is done. If the conversion is complete, we return the value from the ADC data register.

The value that we get from the ADC regular data register is 12 bits, which means it returns values from 0 o 4095 (4096 data sampling points).

Continuous Conversions Mode

Note that this is only a single conversion, so it only takes a single sample from the ADC component.

To sample the value from the ADC component continuously, you would have to set the ADC in continuous mode.

Continuous mode is set by setting 1 to bit 1 of ADC control register 2.

So in order to take continuous samples from a sensor, we need to make changes to the main.c file.

The main.c file is shown below.

#include <stdio.h> #include <stdint.h> #include "stm32f407.h" void pa1_adc_init(void); void adc_start_conversion(void); uint32_t adc_read(void); int adc_value; int main(void) { pa1_adc_init(); while(1) { adc_start_conversion(); adc_value= adc_read(); printf("ADC value: %d \n\r", adc_value); } } void pa1_adc_init(void) { //Enables peripheral clock register for ADC1 pRCC->APB2ENR |= (1 << 8); //Turns on the clock for GPIO Port A pRCC->AHB1ENR |= (1 << 0); //Sets pin PA1 as analog pGPIOA->MODER |= (0b11 << 2); //Conversion sequence start //Makes the first ADC sampling start at channel 1 pADC1->SQR3 |= (1 << 0); //Specify conversion sequence length pADC1->SQR1 = 0; //Enable the ADC pADC1->CR2 |= (1 << 0); } void adc_start_conversion(void) { //Optional-Remove the following line if you don't want to continuous mode //Sets ADC to continuous sampling mode pADC1->CR2 |= (1 << 1); //Start ADC conversion pADC1->CR2 |= (1 << 30); } uint32_t adc_read(void) { //Wait for the conversion to be complete while(!(pADC1->SR & (1 << 1))); //Read converted result return(pADC1->DR); }

We added one line to the beginning of the adc_start_conversion() function, pADC1->CR2 |= (1 << 1);

This places the ADC in continuous sampling mode.

The one change that we must make to the main.c file is that we take the adc_start_conversion() function out of the infinite while loop and place it before this loop.

This is because before, the ADC was in single conversion mode. In single conversion mode, in order to get multiple samples, we must start the conversion process each time (since each time, it only samples a single time).

Howwever, with continuous sampling mode, we only need to start the conversion once. Therefore, we do not want this function in an infinite loop, so that it starts over and over again (which is unnecessary and unwanted when the ADC is in continuous sampling mode). Therefore, we take it out of the infinite while loop and place it before, so that the conversion process is started only once.

The program reads continuous samples from the ADC and prints out these values.

If you want a sample, for example, every second or a certain time period, you would create a delay within the code.

And this is how to perform analog to digital conversion, either a single conversion or continuous conversions, with an STM32F407G discovery board in C.

Related Resources

How to Set Bits of a Number in C

How to Clear Bits of a Number in C