像STM8（寄存器级GPIO）一样编程STM32

Question

我编写了PD_ODR_ODR4 = 1;之类的STM8 GPIO，但是stm32f10x.h没有此功能。是否有任何.h文件定义了位。

对不起，但我不知道如何更好地解释这个问题。

我尝试了多个GPIO库。

强文本

Answer 1

您在问题中提到了stm32f10x.h，所以我假设它与STM32F1系列控制器有关。其他系列有一些不同，但是一般步骤是相同的​​。

GPIO引脚排列在16个称为端口的组中，每个端口都有自己的一组控制寄存器，分别称为GPIOA，GPIOB等。它们定义为指向GPIO_TypeDef结构的指针。有3个控制寄存器会影响引脚输出。

写入 ODR 一次可以设置所有16个引脚。 GPIOB->ODR = 0xF00F将引脚B0至B3和B12至B15设置为1，并将B4至B11设置为0，无论他们以前的状态。可以写入GPIOD->ODR |= (1<<4)来将引脚GPIOD4设置为1，或者写入GPIOD->ODR &= ~(1<<4)以对其进行重置。

写入 BSRR 会将写入的值视为两个位掩码。低半字是设置掩码，值为1的位将ODR中的相应位设置为1。高半字是复位掩码，值为1的位将ODR中的相应位设置为0。 GPIOC->BSRR = 0x000701E0会将C5至C8的引脚设置为1，将C0至C2重置为0，并保留所有其他端口位。尝试在写入BSRR时设置和重置相同的位，然后将其设置为1。

写 BRR 与在BSRR中写复位位掩码相同，即GPIOx->BRR = x等效于GPIOx->BSRR = (x << 16)。

现在可以编写一些宏了，例如

#define GPIOD_OUT(pin, value) GPIOD->BSRR = ((0x100 + value) << pin)
#define GPIOD4_OUT(value) GPIOD_SET(4, value)

更改单个引脚，但是它不如可能灵活。您不能将单个引脚的地址传递给变量。

位绑定

Cortex-M控制器（并非全部，但STM32F1系列具有）具有此功能，以使内部RAM和硬件寄存器中的各个位可寻址。 0x40000000-0x400FFFFF范围内的每个位都映射到0x42000000-0x43FFFFFF范围内的完整32位字。它不适用于该地址范围以外的外围设备，例如USB或NVIC。

可以使用此宏计算外设寄存器的位带地址

#define BB(reg) ((uint32_t *)(PERIPH_BB_BASE + ((uint32_t)&(reg) - PERIPH_BASE) * 32U))

，您可以将结果指针视为包含32个字的数组的基础，每个字对应于外设寄存器中的单个位。现在可以

#define PD_ODR_ODR4 (BB(GPIOD->ODR)[4])

，并在作业中使用它。读取它会得到0或1作为其值，写入它的值会将写入值的最低有效位复制到外设寄存器位。您甚至可以获取其地址，并将其传递给使用该引脚执行某些操作的函数。

在PM0056Cortex®-M3编程手册中记录了位带。

Answer 2

@berendi提供的答案和@P__J__提供的评论已经很有帮助，但是我想提供更多见解。对于STM32F103CB的GPIO读写寄存器的原始（裸机）跟踪（无NO库或头文件），请直接跳至底部。 此答案的目的是*教您*如何自己阅读数据表和文档，以便您可以将这些技术应用于*任何*包括STM32在内的任何微控制器中的*任何内存地址或寄存器*。 < / p>

请注意，底部的“原始，无头”示例是出于教育目的：我建议仅使用CMSIS和STM32提供的头文件（如果适用），而不要编写自己的头文件。但是，在某些情况下，您可能需要快速访问寄存器，这就是方法。

快速参考：

将任何地址定义为可读/可写：

#define MY_REGISTER (*(volatile uint32_t *)(ADDRESS_TO_MY_REGISTER)) // Be sure to add `UL` after ADDRESS_TO_MY_REGISTER to make it "unsigned long".

将ANY地址定义为只读：

#define MY_REGISTER (*(volatile const uint32_t *)(ADDRESS_TO_MY_REGISTER)) // Be sure to add `UL` after ADDRESS_TO_MY_REGISTER to make it "unsigned long".

详细信息：如何定义任何地址位置或在C中的内存中进行注册以使其可读/可写：

访问C中任何内存地址位置的标准方法（也是唯一可行的方法）是使用以下基于#define的易失指针构造：

#define MY_REGISTER (*(volatile uint32_t *)(ADDRESS_TO_MY_REGISTER)) // Be sure to add `UL` after ADDRESS_TO_MY_REGISTER to make it "unsigned long".

如何阅读：

（基本上从右到左阅读）：“取ADDRESS_TO_MY_REGISTER并将其强制转换为指向4个字节的易失性组的指针（即：4个易失性字节的一组），然后获取该组的内容4个字节，然后按照MY_REGISTER的意思进行操作。”即：MY_REGISTER现在在该地址位置修改存储器的内容。

需要强制转换为指针才能将地址​​位置转换为实际的内存地址（指针），最左侧的取消引用（*）是让我们修改以下内容的内容该寄存器或内存位于该地址，而不仅仅是修改地址本身。必须使用关键字volatile来防止编译器优化，否则编译器可能会尝试假定该寄存器中的内容并优化从该寄存器读取或写入该寄存器的代码。访问寄存器时始终需要volatile，因为必须假定它们可以从其他进程，外部事件或引脚更改或单片机本身的硬件和/或外围设备中更改。

即使此构造适用于C语言中的所有设备（不仅限于STM32），但请注意，转换为类型的大小（uint8_t，uint32_t等）对于您的体系结构很重要。即：不要尝试在8位微控制器上使用uint32_t类型，因为即使它看起来可行，也不能保证对8位微控制器上的32位内存进行原子访问。但是，实际上保证了对8位AVR微控制器的8位访问是自动原子的（相关阅读：C++ decrementing an element of a single-byte (volatile) array is not atomic! WHY? (Also: how do I force atomicity in Atmel AVR mcus/Arduino)）。但是，对于STM32 MCU，如我在这里https://stackoverflow.com/a/52785864/4561887所研究和描述的那样，32位或更小的内存访问是自动的。

上面的这种基于#define的类型的构造在所有微控制器中都可以使用，并且您可以使用它随意访问任何您认为合适的存储器位置，字面上说，在任何微控制器上，除非数据表和/或参考资料手册另有说明（例如：某些寄存器首先需要特殊的解锁说明）。例如，如果您跟踪AVRLibc上的寄存器（由Arduino使用-在此处下载：https://www.nongnu.org/avr-libc/->“下载”部分），并进行所有宏扩展，您会看到所有寄存器都是8位并归结为：

#define TCCR2A (*(volatile uint8_t *)(0xB0))

此处，寄存器TCCR2A或“定时器2的定时器计数器控制寄存器A”被设置为地址0xB0处的1字节。

除了寄存器通常是32位以外，STM32也是这样，因此您可以使用uint32_t代替uint8_t（尽管uint8_t也可以在STM32上使用），并且他们经常使用基于结构的构造。例如，来自“ stm32f767xx.h” ：

#define GPIOD               ((GPIO_TypeDef *) GPIOD_BASE)

GPIO_TypeDef是一个结构：

typedef struct
{
  __IO uint32_t MODER;    /*!< GPIO port mode register,               Address offset: 0x00      */
  __IO uint32_t OTYPER;   /*!< GPIO port output type register,        Address offset: 0x04      */
  __IO uint32_t OSPEEDR;  /*!< GPIO port output speed register,       Address offset: 0x08      */
  __IO uint32_t PUPDR;    /*!< GPIO port pull-up/pull-down register,  Address offset: 0x0C      */
  __IO uint32_t IDR;      /*!< GPIO port input data register,         Address offset: 0x10      */
  __IO uint32_t ODR;      /*!< GPIO port output data register,        Address offset: 0x14      */
  __IO uint32_t BSRR;     /*!< GPIO port bit set/reset register,      Address offset: 0x18      */
  __IO uint32_t LCKR;     /*!< GPIO port configuration lock register, Address offset: 0x1C      */
  __IO uint32_t AFR[2];   /*!< GPIO alternate function registers,     Address offset: 0x20-0x24 */
} GPIO_TypeDef;

__IO被简单定义为volatile。由于此结构的每个成员均为4个字节，并且具有4个字节的对齐方式，因此该结构会自动打包，因此最终该结构的每个新元素仅指向地址位置“地址偏移量”（如右边的注释）远离基址，因此一切正常！

例如，使用STM32定义的GPIOD->BSRR类型构造的另一种方法是自己手动完成操作：

#define GPIOD_BSRR (*(volatile uint32_t *)(GPIOD_BASE + 0x18UL)) // Don't forget the `U` or `UL` at the end of 0x18 here!

如果您想将寄存器设为只读怎么办？只需将const添加到投射到指针的*的左的任何位置：

#define MY_REGISTER (*(volatile const uint32_t *)(ADDRESS_TO_MY_REGISTER)) // Be sure to add `UL` after ADDRESS_TO_MY_REGISTER to make it "unsigned long".

获取，设置和清除位：

现在，您可以使用位移，位掩码和位操作，或使用可能定义的一些宏来设置或获取寄存器中的任何位。

例如：

// get bit30 from the address location you just described above
bool bit30 = (MY_REGISTER >> 30UL) & 0x1UL;
// or (relies on the fact that anything NOT 0 in C is automatically `true`):
bool bit30 = MY_REGISTER & (1UL << 30UL);

// set bit 30 to 1
MY_REGISTER |= (1UL << 30UL);

// clear bit 30 to 0
MY_REGISTER &= ~(1UL << 30UL);

或： （例如，就像Arduino在这里所做的：https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/Arduino.h）

#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
#define bitSet(value, bit) ((value) |= (1UL << (bit)))
#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))

然后：

// get bit 30
bool bit30 = bitRead(MY_REGISTER, 30);

// set bit 30 to 1
bitSet(MY_REGISTER, 30);
// or
bitWrite(MY_REGISTER, 30, 1);

// clear bit 30 to 0
bitClear(MY_REGISTER, 30);
// or
bitWrite(MY_REGISTER, 30, 0);

STM32F103CB的GPIO读写寄存器的原始（裸机）跟踪，没有库或头文件。

我们将需要：

1. 此芯片的主要参考页：https://www.st.com/content/st_com/en/products/microcontrollers-microprocessors/stm32-32-bit-arm-cortex-mcus/stm32-mainstream-mcus/stm32f1-series/stm32f103/stm32f103cb.html#design-scroll
2. STM32参考手册（包含寄存器定义）：RM0008, Reference Manual for STM32F101xx, 101xx, 103xx, etc
3. STM32数据表（包含基地址）：DS5319

阅读RM0008 p161-162。

我不会详细介绍所有内容（如上所示），但是要读取一个引脚，您需要使用GPIOx_IDR（GPIO输入数据寄存器）。要将引脚写入0或1，您需要GPIOx_ODR（GPIO输出数据寄存器）。显然（基于上面所示的RM0008中的措词），对GPIOx_ODR的写操作不是一组原子的，因此，如果您希望端口上的一堆引脚被原子级写（全部在同一瞬间），需要使用GPIOx_BSRR（GPIO位设置/重置寄存器）或GPIOx_BRR（GPIO位重置寄存器-只能将位清除为0）。

假设我们只要做端口A，这意味着我们需要为以下寄存器定义：

GPIOA_IDR   // Input Data Register (for reading pins on Port A)
GPIOA_ODR   // Output Data Register (for *nonatomically* writing 0 or 1 to pins on Port A)
GPIOA_BSRR  // Bit Set/Reset Register (for *atomically* setting (writing 1) or resetting (writing 0) pins on Port A)
GPIOA_BRR   // Bit Reset Register (for *atomically* resetting (writing 0) pins on Port A)

让我们找到这些寄存器的地址！

请参阅RM0008 p172至174。

我们可以看到偏移量和数据方向如下：

| Register   | "Address offset"| direction
|------------|-----------------|---------------
| GPIOA_IDR  | 0x08            | r (read only)   
| GPIOA_ODR  | 0x0C            | rw (read/write) 
| GPIOA_BSRR | 0x10            | w (write only)
| GPIOA_BRR  | 0x14            | w (write only)

现在，我们只需要端口A的基地址。转到 DS5319第4章：内存映射，图11.内存映射，您将看到“端口A”的基地址是 0x40010800 ，如下所示并突出显示：

现在，让我们手动定义寄存器：

#define GPIOA_IDR  (*(volatile const uint32_t *)(0x40010800UL + 0x08UL)) // use `const` since this register is read-only
#define GPIOA_ODR  (*(volatile uint32_t *)(0x40010800UL + 0x0CUL))
#define GPIOA_BSRR (*(volatile uint32_t *)(0x40010800UL + 0x10UL))
#define GPIOA_BRR  (*(volatile uint32_t *)(0x40010800UL + 0x14UL))

现在让我们读写一个图钉：

// Choose a pin number from 0 to 15
uint8_t pin_i = 0; // pin index

// Read it
bool pin_state = (GPIOA_IDR >> (uint32_t)pin_i) & 0x1;

// Write it to 1
GPIOA_ODR |= 1UL << (uint32_t)pin_i; // not to be used for writing to more than 1 pin at a time since apparently its operation is not atomic?
// OR
GPIOA_BSRR |= 1UL << (uint32_t)pin_i; // GOOD! RECOMMENDED approach

// Write it to 0
GPIOA_ODR &= ~(1UL << (uint32_t)pin_i); // not to be used for writing to more than 1 pin at a time since apparently its operation is not atomic?
// OR
GPIOA_BSRR |= (1UL << (uint32_t)pin_i) << 16UL; // GOOD! RECOMMENDED approach, but a bit confusing obviously
// OR
GPIOA_BRR |= 1UL << (uint32_t)pin_i; // GOOD! RECOMMENDED approach

OR：只需使用HAL库即可。

例如：来自“ STM32Cube_FW_F1_V1.6.0 / Drivers / STM32F1xx_HAL_Driver / Src / stm32f1xx_hal_gpio.c”：

HAL_GPIO_ReadPin()（请注意，他们使用GPIOx->IDR寄存器进行读取）：

/**
  * @brief  Reads the specified input port pin.
  * @param  GPIOx: where x can be (A..G depending on device used) to select the GPIO peripheral
  * @param  GPIO_Pin: specifies the port bit to read.
  *         This parameter can be GPIO_PIN_x where x can be (0..15).
  * @retval The input port pin value.
  */
GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
{
  GPIO_PinState bitstatus;

  /* Check the parameters */
  assert_param(IS_GPIO_PIN(GPIO_Pin));

  if ((GPIOx->IDR & GPIO_Pin) != (uint32_t)GPIO_PIN_RESET)
  {
    bitstatus = GPIO_PIN_SET;
  }
  else
  {
    bitstatus = GPIO_PIN_RESET;
  }
  return bitstatus;
}

HAL_GPIO_WritePin()（请注意，他们使用GPIOx->BSRR寄存器将引脚同时写入0和1）：

/**
  * @brief  Sets or clears the selected data port bit.
  * 
  * @note   This function uses GPIOx_BSRR register to allow atomic read/modify 
  *         accesses. In this way, there is no risk of an IRQ occurring between
  *         the read and the modify access.
  *               
  * @param  GPIOx: where x can be (A..G depending on device used) to select the GPIO peripheral
  * @param  GPIO_Pin: specifies the port bit to be written.
  *          This parameter can be one of GPIO_PIN_x where x can be (0..15).
  * @param  PinState: specifies the value to be written to the selected bit.
  *          This parameter can be one of the GPIO_PinState enum values:
  *            @arg GPIO_BIT_RESET: to clear the port pin
  *            @arg GPIO_BIT_SET: to set the port pin
  * @retval None
  */
void HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState)
{
  /* Check the parameters */
  assert_param(IS_GPIO_PIN(GPIO_Pin));
  assert_param(IS_GPIO_PIN_ACTION(PinState));

  if(PinState != GPIO_PIN_RESET)
  {
    GPIOx->BSRR = GPIO_Pin;
  }
  else
  {
    GPIOx->BSRR = (uint32_t)GPIO_Pin << 16U;
  }
}

END