Electrical – How to assign peripherals to physical pins for STM32 MCUs

peripheral-pin-selectstm32

I'm using STM32F series MCUs with a RTOS. Since the OS provides API to configure the peripherals and their physical output assignment, I didn't pay much attention in the past. Now I want to have full control of this type of hardware configurations.

The point I've confused is that, according to datasheet, a physical pin might be in one of 3 different modes (for STM32F103, in this case):

Main function (after reset)
Primary alternate function (Alternate function/Default)
Remapped alternate function

"Main function" is easy to understand. However, for example, one primary alternate function can be assigned to 3 different peripherals for the same physical pin:

Question

Where are we configuring if PA2 is used for whether USART2_TX or ADC12_IN2 or TIM2_CH3?

Best Answer

Where are we configuring if PA2 is used whether USART2_TX or ADC12_IN2 or TIM2_CH3?

Every GPIO has a Port configuration register (GPIOx_CRL/GPIOx_CRH).
The STM32F1 series also has AFIO (alternate function input output) registers with remap bits. These are per function, not per pin. See AFIO_MAPR.

The REMAP register is where things get difficult, because this remaps multiple pins.

To solve this puzzle I recommend you use the STM32Cube initialization code generator.

Is it the operating systems' or the STM's headers' responsibility generating an error message if we try to configure PA2 as both USART2_TX and ADC12_IN2?

It it physically not possible to configure PA2 as USART2_TX and ADC_IN12.

To put it in ADC_IN12, you only set CNF to Analog and MODE to input.
To put it in USART2_TX set CNF push-pull and enable alternate function.
To put it in TIM2_CH3, set CNF to floating or push-pull, enable alternate function, and enable TIM2_REMAP in AFIO_MAPR.

Analog mode has priority. This disables the digital features, such as schmitt trigger and output control.

(You might still be able to use the ADC while digital input/output functions are enabled, I have never tried this)

both settings for TIM2_CH3 and USART2_TX have the same configuration

That is because they require the same functionality.
REMAP configures if you use TIM or USART.

Related Solutions

STM32: Running many peripherals at the same time

You don't need to exercise every peripheral, only those you use in your product. STM32 has clock gating and nearly all optional peripherals are disabled at startup. You only need to be concerned about peripherals that you enable in your production firmware.

As far as simultaneous operation is concerned, if you actually need that (it seems a different mode of operation from your production code which you say is blocking, so EMI may be different, too), you have 3 options: interrupts, DMA and preemptive RTOS tasks. Each of these is a topic in itself, but many examples exist, e.g. most examples that come with the standard peripheral library are interrupt-driven. Note that small implementation details may again result in very different performance (and therefore bus and peripheral activity). Making "all peripherals churn full-speed at the same time" is a very challenging task if you actually mean that literally.

Electronic – STM32 SRAM to DMA GPIO pins

Short description:

Timer trig DMA with desired speed, DMA write data to GPIO output register.

Long description:

Prepare selected GPIO port output state to default state low/high
Configure selected GPIO port PX to output push-pull/open drain
Configure any timer to desired period of GPIO port updating
Configure selected DMA and link it to selected TIM
Configure callbacks for DMA IRQs: HT, TC, ERR
Enable DMA for write you data buffer, buffer length to selected PX->ODR
Enable TIM to generate DMA events
Run TIM
Handle DMA state in callbacks and control TIM as you need

Code blank:

All code written right here and not tested, it may content simple mistakes such as using variable instead it pointer in HAL macros or functions calls.

GPIO_InitTypeDef GPIO_InitStruct;
TIM_HandleTypeDef htim1;
DMA_HandleTypeDef hdma_tim1_uev;

/* 1 (Port GPIOA) */
__HAL_RCC_GPIOA_CLK_ENABLE();
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_All, GPIO_PIN_RESET);

/* 2 (Port GPIOA) */
GPIO_InitStruct.Pin = GPIO_PIN_All;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

/* 3 (Timer TIM1) */
__HAL_RCC_TIM1_CLK_ENABLE();
htim1.Instance = TIM1;
htim1.Init.Prescaler = DESIRED_PRESCALER;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = DESIRED_PERIOD;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
HAL_TIM_Base_Init(&htim1)

/* 4 (DMA1 Channel2) */
__HAL_RCC_DMA1_CLK_ENABLE();
hdma_tim1_uev.Instance = DMA1_Channel2;
hdma_tim1_uev.Init.Direction = DMA_MEMORY_TO_PERIF;
hdma_tim1_uev.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_tim1_uev.Init.MemInc = DMA_MINC_ENABLE;
hdma_tim1_uev.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; // 16 bits
hdma_tim1_uev.Init.MemDataAlignment = DMA_PDATAALIGN_HALFWORD;
hdma_tim1_uev.Init.Mode = DMA_NORMAL;
hdma_tim1_uev.Init.Priority = DMA_PRIORITY_LOW;
HAL_DMA_Init(&hdma_tim1_uev);
__HAL_DMA1_REMAP(HAL_DMA1_CH2_TIM1_UP);
__HAL_LINKDMA(&htim1,hdma[TIM_DMA_ID_UPDATE],hdma_tim1_uev);
HAL_NVIC_SetPriority(DMA1_Ch2_3_DMA2_Ch1_2_IRQn, 0, 0); // enable DMA IRQ
HAL_NVIC_EnableIRQ(DMA1_Ch2_3_DMA2_Ch1_2_IRQn);

/* 5 (Callbacks for DMA IRQs) */
htim->hdma[TIM_DMA_ID_UPDATE]->XferCpltCallback = data_tramsmitted_handler;
htim->hdma[TIM_DMA_ID_UPDATE]->XferErrorCallback = transmit_error_handler;

/* 6 (Enable DMA) */
HAL_DMA_Start_IT(htim1.hdma[TIM_DMA_ID_UPDATE],(uint32_t)&my_data_buf, 
    (uint32_t)&GPIOA->ODR, my_data_buf_length);

/* 7 (Enable TIM for DMA events) */
__HAL_TIM_ENABLE_DMA(&htim1, TIM_DMA_UPDATE);

/* 8 (Run TIM) */
__HAL_TIM_ENABLE(&htim1);

/* 9 (DMA IRQ callbacks) */
void data_tramsmitted_handler(DMA_HandleTypeDef *hdma)
{
    /* Stop timer */
    __HAL_TIM_DISABLE(&htim1);
    /* Reconfigure DMA */
    HAL_DMA_Start_IT(htim1.hdma[TIM_DMA_ID_UPDATE],(uint32_t)&my_data_buf, 
        (uint32_t)&GPIOA, my_data_buf_length);
    /* Start timer for new data transmit */
    __HAL_TIM_ENABLE(&htim1);
}

void transmit_error_handler(DMA_HandleTypeDef *hdma)
{
    /* Stop timer */
    __HAL_TIM_DISABLE(&htim1);
    /* Some error handle ? */
}

Question

Best Answer

Related Solutions

STM32: Running many peripherals at the same time

Electronic – STM32 SRAM to DMA GPIO pins

Related Topic