Analysis of stm32 library function GPIO_Init()

The GPIO_Init function is the initialization function of the IO pin. It performs the initialization configuration of each pin. It mainly accepts two parameters, one is the configuration pin group (GPIO_TypeDef* GPIOx), and the other is the configuration parameter (GPIO_InitTypeDef* GPIO_InitStruct), as follows

1. void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
   

2. /*The first parameter is the group of pins. Each group has 16 pins, and each group has a different register configuration address. The second parameter is a data structure, which is where the basic configuration information is placed, and then the structure is passed into the function for configuration*/
   

3. //The data structure can be expressed as follows
   

4. typedef struct
   

5. {
   

6.   uint16_t GPIO_Pin; //pin number
   

7.   GPIOSpeed_TypeDef GPIO_Speed; //Configure speed
   

8.   GPIOMode_TypeDef GPIO_Mode; //Working mode
   

9. }GPIO_InitTypeDef;
   

10. 
    

11. //The configuration mode and working mode are enumeration variables of GPIOSpeed_TypeDef and GPIOMode_TypeDef

In order to analyze this function conveniently, we need to list the definitions of several constants.

1. //First is the pin definition

2. #define GPIO_Pin_0 ((uint16_t)0x0001) /* Pin 0 selected */

3. #define GPIO_Pin_1 ((uint16_t)0x0002) /* Pin 1 selected */

4. #define GPIO_Pin_2 ((uint16_t)0x0004) /* Pin 2 selected */

5. #define GPIO_Pin_3 ((uint16_t)0x0008) /* Pin 3 selected */

6. #define GPIO_Pin_4 ((uint16_t)0x0010) /* Pin 4 selected */

7. #define GPIO_Pin_5 ((uint16_t)0x0020) /* Pin 5 selected */

8. #define GPIO_Pin_6 ((uint16_t)0x0040) /* Pin 6 selected */

9. #define GPIO_Pin_7 ((uint16_t)0x0080) /* Pin 7 selected */

10. #define GPIO_Pin_8 ((uint16_t)0x0100) /* Pin 8 selected */

11. #define GPIO_Pin_9 ((uint16_t)0x0200) /* Pin 9 selected */

12. #define GPIO_Pin_10 ((uint16_t)0x0400) /* Pin 10 selected */

13. #define GPIO_Pin_11 ((uint16_t)0x0800) /* Pin 11 selected */

14. #define GPIO_Pin_12 ((uint16_t)0x1000) /* Pin 12 selected */

15. #define GPIO_Pin_13 ((uint16_t)0x2000) /* Pin 13 selected */

16. #define GPIO_Pin_14 ((uint16_t)0x4000) /* Pin 14 selected */

17. #define GPIO_Pin_15 ((uint16_t)0x8000) /* Pin 15 selected */

18. #define GPIO_Pin_All ((uint16_t)0xFFFF) /* All pins selected */

19. 
    

20. // Followed by the mode definition

21. typedef enum

22. { GPIO_Mode_AIN = 0x0, //Analog input

23. GPIO_Mode_IN_FLOATING = 0x04, //Floating input mode, default

24. GPIO_Mode_IPD = 0x28, //Pull-up/pull-down input mode

25. GPIO_Mode_IPU = 0x48, //Reserved

26. GPIO_Mode_Out_OD = 0x14, //General purpose open drain output

27. GPIO_Mode_Out_PP = 0x10, //General push-pull output

28. GPIO_Mode_AF_OD = 0x1C, //Multiplexed (open drain) output

29. GPIO_Mode_AF_PP = 0x18 //Multiplexed (push-pull) output

30. }GPIOMode_TypeDef;

31. 
    

32. //Finally, the speed definition

33. typedef enum

34. {

35. GPIO_Speed_10MHz = 1,

36. GPIO_Speed_2MHz,

37. GPIO_Speed_50MHz

38. }GPIOSpeed_TypeDef;

It is easy to see from the pin definition that if pin 0 is 1, the 0th position of the 16 bits is 1, if pin 2 is 1, and so on. Therefore, if you want to define multiple pins, you only need to use the OR logic operation (|).
Secondly, the mode definition also has its rules. Referring to the "stmf10xxx Reference Manual", it can be concluded that every 4 bits in the high and low configuration registers store a mode + speed, where the mode occupies the high 2 bits and the speed occupies the low 2 bits. 16 pins have 4*16=64 bits to store, so this definition makes sense. The reason is that the mode occupies the high bit. For example, 10 represents the pull-up/pull-down output mode, which occupies the high 2 bits in the 4 bits, which should be 1000. The low 2 bits are first represented by 00, so the pull-up/pull-down output mode can be represented as 1000=0x8, or it can be represented by the fourth bit of 0x28. The same is true for the others, that is, the fifth bit 1 represents the output mode and 0 represents the input mode.

The speed is directly represented by 1, 2, and 3.
The specific function analysis is as follows

1. void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
   

2. {
   

3.  /* Initialize each variable */
   

4.   uint32_t currentmode = 0x00, currentpin = 0x00, pinpos = 0x00, pos = 0x00;
   

5.   uint32_t tmpreg = 0x00, pinmask = 0x00;
   

6.   //currentmode is used to store temporary LCIR
   

7.   //currentpin is used to store the configured pin position
   

8.   //pinpos is used to store the pin number of the current operation
   

9.   //pos stores the pin position of the current operation
   

10.   //tmreg current CIR
    

11.   //pinmask
    

12. 
    

13. 
    

14.   //Judge the parameters
    

15.   assert_param(IS_GPIO_ALL_PERIPH(GPIOx));
    

16.   assert_param(IS_GPIO_MODE(GPIO_InitStruct->GPIO_Mode));
    

17.   assert_param(IS_GPIO_PIN(GPIO_InitStruct->GPIO_Pin)); 
    

18.   
    

19.   // Take out the mode information in the configuration information and take its lower 4 bits
    

20.   currentmode = ((uint32_t)GPIO_InitStruct->GPIO_Mode) & ((uint32_t)0x0F);
    

21.   if ((((uint32_t)GPIO_OInitStruct->GPIO_Mode) & ((uint32_t)0x10)) != 0x00) //Output mode
    

22.   { 
    

23. 
    

24.     //Judge the parameters
    

25.     assert_param(IS_GPIO_SPEED(GPIO_InitStruct->GPIO_Speed));
    

26.     
    

27.     //Put the speed information into the lower two bits of currentmode
    

28.     currentmode |= (uint32_t)GPIO_InitStruct->GPIO_Speed;
    

29.   }
    

30.   if (((uint32_t)GPIO_InitStruct->GPIO_Pin & ((uint32_t)0x00FF)) != 0x00) //The pin is defined
    

31.   {
    

32.     //Save the current CRL
    

33.     tmpreg = GPIOx->CRL;
    

34. 
    

35.     //Loop the lower eight pins
    

36.     for (pinpos = 0x00; pinpos < 0x08; pinpos++)
    

37.     {
    

38.       //The current pin is at position 1
    

39.       pos = ((uint32_t)0x01) << pinpos;
    

40. 
    

41.       //Read the current pin in the pin information
    

42.       currentpin = (GPIO_InitStruct->GPIO_Pin) & pos;
    

43.       if (currentpin == pos) //If the current pin exists in the configuration information
    

44.       {
    

45.         pos = pinpos << 2; //pos = pin number x2
    

46.         pinmask = ((uint32_t)0x0F) << pos; //1111<

47.         tmpreg &= ~pinmask; //The CRL bit that should be operated currently is cleared to 0
    

48.         tmpreg |= (currentmode << pos); //Set the CRL bit of the current operation
    

49.         if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPD) // Set the port to high level
    

50.         {
    

51.           GPIOx->BRR = (((uint32_t)0x01) << pinpos);
    

52.         }
    

53.         else
    

54.         {
    

55.           if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPU) // Port cleared
    

56.           {
    

57.             GPIOx->BSRR = (((uint32_t)0x01) << pinpos);
    

58.           }
    

59.         }
    

60.       }
    

61.     }
    

62.     GPIOx->CRL = tmpreg;
    

63.   }

The last step is to transfer the configured CRL to the CRL register.