2

我对STM8 GPIO进行了编程，PD_ODR_ODR4 = 1;但stm32f10x.h没有这个功能。是否有任何.h文件具有位定义。

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

我尝试了多个 GPIO 库。

强文本

4

2 回答 2

9

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

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

写入ODR一次设置所有 16 个引脚，例如GPIOB->ODR = 0xF00F将引脚设置为 1，然后设置为0 ，无论它们之前的状态如何B0。可以写入将引脚设置为 1，或将其重置。B3B12B15B4B11GPIOD->ODR |= (1<<4)GPIOD4GPIOD->ODR &= ~(1<<4)

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

写入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都映射到范围内的一个完整的 32 位字0x42000000-0x43FFFFFF。它不适用于此地址范围之外的外围设备，例如 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 作为它的值，写入它的值会将写入值的最低有效位复制到外围寄存器位。您甚至可以获取它的地址，并将其传递给一个对引脚执行某些操作的函数。

位带记录在 PM0056 Cortex®-M3 编程手册中。

于 2019-02-18T10:58:10.043 回答
7

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

请注意，底部的“原始，无标题”示例用于教育目的：我建议仅使用 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".

将任何地址定义为只读：

#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基于 volatile 指针构造：

#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访问寄存器时总是需要的，因为必须假设它们可以从其他进程、外部事件或引脚更改或 MCU 本身的硬件和/或外围设备中更改。

尽管此构造适用于 C 语言中的所有设备（不仅仅是 STM32），但请注意，您转换为 ( , 等) 的类型的大小uint8_t对uint32_t您的架构很重要。即：不要尝试uint32_t在 8 位微控制器上使用类型，因为即使它看起来可行，也不能保证对 8 位微控制器上的 32 位内存块进行原子访问。然而，8 位 AVR 微控制器上的 8 位访问实际上保证是自动原子的（相关阅读：C++ 递减单字节（易失性）数组的元素不是原子的！为什么？（另外：如何我在 Atmel AVR mcus/Arduino 中强制原子性））。然而，对于 STM32 单片机，32 位或更小的内存访问自动是原子的，正如我在这里研究和描述的：https://stackoverflow.com/a/52785864/4561887。

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

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

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

STM32 也是如此，只是寄存器一般都是 32 位的，所以可以使用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，STM32F101xx、101xx、103xx等参考手册
  3. STM32 数据表（包含基地址）：DS5319

阅读 RM0008 p161-162。 在此处输入图像描述

我不会详细介绍（阅读上文），但要读取一个引脚，您需要GPIOx_IDR（GPIO 输入数据寄存器）。要将引脚写入 0 或 1，您需要GPIOx_ODR（GPIO 输出数据寄存器）。显然（基于上面显示的 RM0008 中的措辞）写入GPIOx_ODR不是作为一个组原子的，因此如果您希望端口上的一堆引脚被原子地写入（全部在同一时刻），您需要使用GPIOx_BSRR( GPIO 位设置/复位寄存器）或GPIOx_BRR（GPIO 位复位寄存器——只能将位清零）。

假设我们只要做端口 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))

现在让我们读写一个pin：

// 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

或者：只需使用 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;
  }
}

结尾

于 2019-02-21T02:44:23.053 回答