Electronic – STM32 HAL drivers

cmsishal-librarystm32

I've been using STM32 ARM microcontrollers for more than two years, the best way of coding that I've found is using the CMSIS and ST std peripheral libraries, and I think it has no restrictions or any main disadvantages.

But now I want to try HAL drivers to compare with std libraries. It seems that ST has introduced a tool, "STM32CubeMX", that could graphically configure the microcontroller and generate code based on HAL drivers. My problem is that I don't want to use their graphical tool to generate my codes, but after many searches on the Internet I couldn't find any tutorial or example to use HAL drivers directly in my project.

However ST has an user manual that describes anything about HAL drivers, but unfortunately it is about 1300 pages and I think it takes me much time to read.

I really prefer a short instruction or maybe a simple example project for using GPIOs.

Best Answer

If you do not want to use the STM32CubeMX code generator tool but still need simple example projects then you should use the STM32Cubexx firmware examples that are available for all STM32 series.

Each link has an application note called "STM32Cube firmware examples for STM32xx Series" (example for F4) which is actually a huge table listing all the available examples for all the development boards.

Also there are the user manual for each series called " Description of STM32xxxx HAL drivers" (example for F4). Yes, this is the 900 - 1300 pages long document but you do not have to read through all of it, just open up the relevant part. There are a short step by step guide at the beginning of every chapter. In case of the GPIO Generic Driver:

27.2.2 How to use this driver

Enable the GPIO AHB clock using the following function: __HAL_RCC_GPIOx_CLK_ENABLE().

Configure the GPIO pin(s) using HAL_GPIO_Init().

Configure the IO mode using "Mode" member from GPIO_

InitTypeDef structure Activate Pull-up, Pull-down resistor using "Pull" member from GPIO_InitTypeDef structure.

In case of Output or alternate function mode selection: the speed is configured through "Speed" member from GPIO_InitTypeDef structure.

In alternate mode is selection, the alternate function connected to the IO is configured through "Alternate" member from GPIO_InitTypeDef structure.

Analog mode is required when a pin is to be used as ADC channel or DAC output.

In case of external interrupt/event selection the "Mode" member from GPIO_InitTypeDef structure select the type (interrupt or event) and the corresponding trigger event (rising or falling or both).

In case of external interrupt/event mode selection, configure NVIC IRQ priority mapped to the EXTI line using HAL_NVIC_SetPriority() and enable it using HAL_NVIC_EnableIRQ().

To get the level of a pin configured in input mode use HAL_GPIO_ReadPin().

To set/reset the level of a pin configured in output mode use HAL_GPIO_WritePin()/HAL_GPIO_TogglePin().

To lock pin configuration until next reset use HAL_GPIO_LockPin().

During and just after reset, the alternate functions are not active and the GPIO pins are configured in input floating mode (except JTAG pins).

The LSE oscillator pins OSC32_IN and OSC32_OUT can be used as general purpose (PC14 and PC15, respectively) when the LSE oscillator is off. The LSE has priority over the GPIO function.

The HSE oscillator pins OSC_IN/OSC_OUT can be used as general purpose PH0 and PH1, respectively, when the HSE oscillator is off. The HSE has priority over the GPIO function.

Based on this you can look up the function descriptions as well in this document and if you really need an example then there are the already mentioned STM32Cubexx example packages and you did not have to use the STM32CubeMX tool at all.

Related Solutions

Electrical – Standard Peripheral Library and HAL drivers together in Keil

Yes, it's quite possible and it has saved my life for a project I was working on where I had everything built around HAL.

Believe it or not, I kept resisting the transition to that HAL thing for so long, until I found myself forced to use it for my project due to many advantages it provides on certain aspect.

However, part of my project is to control a slave device over SPI and I had the library for the SPL from ST. After spending a tremendous time trying to solve an issue I had with the receive part of the SPI over HAL, and after giving up trying hundreds of examples and code snippets for the SPI, I have finally managed to figure it out by mixing the SPI driver from the SPL with the rest of my project, which was built with HAL.

Here's what I did in Keil uVision to get it to work for me without any problem. I have created pre-compiled objects for the SPI and any dependencies used by SPI and had those imported/linked into my HAL project. Of course, I have removed everything about HAL_SPI in the project and now the project compiles and runs quickly and smoothly. I can now drive my device with the SPL based SPI functions, and still enjoy what HAL has to offer for the remaining modules of the project.

Electronic – I2C busy flag strange behaviour

ST has released an errata sheet called:

STM32F100xC, STM32F10 0xD and STM32F100xE high-density value line device limitations.

The interesting point here is:

2.9.7 I2C analog filter may provide wrong value, locking BUSY flag and preventing master mode entry

There is a detailed 15 step workaround that worked for me, surprisingly for an STM32F446, so I2C peripherals of every STM32 CORTEX-M series might be affected.

During this operation, the lines must not be actively pulled up or down by a bus member. So if you connect two I2C interfaces of the same MCU to the bus, first set up the pins of both to Alternate Function/Open Drain, then call the routine, as a transition of logical levels is required.

Here is an example with HAL libraries I use after the first initialization and during runtime, if an error occurs. As said above, this is for STM32F4, libraries for SMT32F1 might differ a bit.

struct I2C_Module
{
  I2C_HandleTypeDef   instance;
  uint16_t            sdaPin;
  GPIO_TypeDef*       sdaPort;
  uint16_t            sclPin;
  GPIO_TypeDef*       sclPort;
};

void I2C_ClearBusyFlagErratum(struct I2C_Module* i2c)
{
  GPIO_InitTypeDef GPIO_InitStructure;

  // 1. Clear PE bit.
  i2c->instance.Instance->CR1 &= ~(0x0001);

  //  2. Configure the SCL and SDA I/Os as General Purpose Output Open-Drain, High level (Write 1 to GPIOx_ODR).
  GPIO_InitStructure.Mode         = GPIO_MODE_OUTPUT_OD;
  GPIO_InitStructure.Alternate    = I2C_PIN_MAP;
  GPIO_InitStructure.Pull         = GPIO_PULLUP;
  GPIO_InitStructure.Speed        = GPIO_SPEED_FREQ_HIGH;

  GPIO_InitStructure.Pin          = i2c->sclPin;
  HAL_GPIO_Init(i2c->sclPort, &GPIO_InitStructure);
  HAL_GPIO_WritePin(i2c->sclPort, i2c->sclPin, GPIO_PIN_SET);

  GPIO_InitStructure.Pin          = i2c->sdaPin;
  HAL_GPIO_Init(i2c->sdaPort, &GPIO_InitStructure);
  HAL_GPIO_WritePin(i2c->sdaPort, i2c->sdaPin, GPIO_PIN_SET);

  // 3. Check SCL and SDA High level in GPIOx_IDR.
  while (GPIO_PIN_SET != HAL_GPIO_ReadPin(i2c->sclPort, i2c->sclPin))
  {
    asm("nop");
  }

  while (GPIO_PIN_SET != HAL_GPIO_ReadPin(i2c->sdaPort, i2c->sdaPin))
  {
    asm("nop");
  }

  // 4. Configure the SDA I/O as General Purpose Output Open-Drain, Low level (Write 0 to GPIOx_ODR).
  HAL_GPIO_WritePin(i2c->sdaPort, i2c->sdaPin, GPIO_PIN_RESET);

  //  5. Check SDA Low level in GPIOx_IDR.
  while (GPIO_PIN_RESET != HAL_GPIO_ReadPin(i2c->sdaPort, i2c->sdaPin))
  {
    asm("nop");
  }

  // 6. Configure the SCL I/O as General Purpose Output Open-Drain, Low level (Write 0 to GPIOx_ODR).
  HAL_GPIO_WritePin(i2c->sclPort, i2c->sclPin, GPIO_PIN_RESET);

  //  7. Check SCL Low level in GPIOx_IDR.
  while (GPIO_PIN_RESET != HAL_GPIO_ReadPin(i2c->sclPort, i2c->sclPin))
  {
    asm("nop");
  }

  // 8. Configure the SCL I/O as General Purpose Output Open-Drain, High level (Write 1 to GPIOx_ODR).
  HAL_GPIO_WritePin(i2c->sclPort, i2c->sclPin, GPIO_PIN_SET);

  // 9. Check SCL High level in GPIOx_IDR.
  while (GPIO_PIN_SET != HAL_GPIO_ReadPin(i2c->sclPort, i2c->sclPin))
  {
    asm("nop");
  }

  // 10. Configure the SDA I/O as General Purpose Output Open-Drain , High level (Write 1 to GPIOx_ODR).
  HAL_GPIO_WritePin(i2c->sdaPort, i2c->sdaPin, GPIO_PIN_SET);

  // 11. Check SDA High level in GPIOx_IDR.
  while (GPIO_PIN_SET != HAL_GPIO_ReadPin(i2c->sdaPort, i2c->sdaPin))
  {
    asm("nop");
  }

  // 12. Configure the SCL and SDA I/Os as Alternate function Open-Drain.
  GPIO_InitStructure.Mode         = GPIO_MODE_AF_OD;
  GPIO_InitStructure.Alternate    = I2C_PIN_MAP;

  GPIO_InitStructure.Pin          = i2c->sclPin;
  HAL_GPIO_Init(i2c->sclPort, &GPIO_InitStructure);

  GPIO_InitStructure.Pin          = i2c->sdaPin;
  HAL_GPIO_Init(i2c->sdaPort, &GPIO_InitStructure);

  // 13. Set SWRST bit in I2Cx_CR1 register.
  i2c->instance.Instance->CR1 |= 0x8000;

  asm("nop");

  // 14. Clear SWRST bit in I2Cx_CR1 register.
  i2c->instance.Instance->CR1 &= ~0x8000;

  asm("nop");

  // 15. Enable the I2C peripheral by setting the PE bit in I2Cx_CR1 register
  i2c->instance.Instance->CR1 |= 0x0001;

  // Call initialization function.
  HAL_I2C_Init(&(i2c->instance));
}

Best Answer

Related Solutions

Electrical – Standard Peripheral Library and HAL drivers together in Keil

Electronic – I2C busy flag strange behaviour

Related Topic