STM32的位操作的方法-电子工程世界

分享到: 微博; QQ; 微信; LinkedIn

STM32 之位带操作

Cortex-M3 支持了位操作后，可以使用普通的加载/存储指令来对单一的比特进行读写。
　　在 CM3 支持的位带中，有两个区中实现了位带。

　　其中一个是 SRAM 区的最低 1MB 范围， 0x20000000 ‐ 0x200FFFFF（SRAM 区中的最低 1MB）；

　　第二个则是片内外设区的最低 1MB范围， 0x40000000 ‐ 0x400FFFFF（片上外设区中的最低 1MB）。

　　这两个区中的地址除了可以像普通的 RAM 一样使用外，它们还都有自己的“位带别名区”，位带别名区把每个比特膨胀成一个 32 位的字。当你通过位带别名区访问这些字时，就可以达到访问原始比特的目的。

　　CM3 使用如下术语来表示位带存储的相关地址

　　* 位带区：支持位带操作的地址区

　　* 位带别名：对别名地址的访问最终作用到位带区的访问上（注意：这中间有一个地址映射过程）

　　位带区中的每个比特都映射到别名地址区的一个字 —— 这是只有 LSB 有效的字（位带别名区的字只有最低位有意义）。

　　对于SRAM中的某个比特，

　　该比特在位带别名区的地址：

AliasAddr = 0x22000000 + ((A‐0x20000000)*8+n)*4

　　 = 0x22000000 + (A‐0x20000000)*32 + n*4　

对于片上外设位带区的某个比特，

　　该比特在位带别名区的地址：

AliasAddr = 0x42000000 + ((A‐0x40000000)*8+n)*4

　 = 0x42000000 + (A‐0x40000000)*32 + n*4　

　其中 A 为该比特所在的字节的地址，0 <= n <= 7

“*4”表示一个字为 4 个字节，“*8”表示一个字节中有 8 个特。

当然，位带操作并不只限于以字为单位的传送。亦可以按半字和字节为单位传送。　

　　位带操作有很多好处，其中重要的一项就是，在多任务系统中，用于实现共享资源在任务间的“互锁”访问。多任务的共享资源必须满足一次只有一个任务访问它——亦即所谓的“原子操作”。

　　在 C 语言中使用位带操作

　　在 C编译器中并没有直接支持位带操作。比如，C 编译器并不知道对于同一块内存，能够使用不同的地址来访问，也不知道对位带别名区的访问只对 LSB 有效。

　　欲在 C中使用位带操作，最简单的做法就是#define 一个位带别名区的地址。例如：

　　　　#define DEVICE_REG0 ((volatile unsigned long *) (0x40000000))

　　　　#define DEVICE_REG0_BIT0 ((volatile unsigned long *) (0x42000000))

　　　　#define DEVICE_REG0_BIT1 ((volatile unsigned long *) (0x42000004))

　　　　...

　　　　*DEVICE_REG0 = 0xAB;　　　　　　　　//使用正常地址访问寄存器

　　*DEVICE_REG0_BIT1 = 0x1; // 通过位带别名地址设置 bit1

　　还可以更简化：

　　　　//把“位带地址＋位序号” 转换成别名地址的宏

　　　　#define BITBAND(addr, bitnum)((addr & 0xF0000000)+0x2000000+((addr & 0xFFFFF)<<5)+(bitnum<<2))　　
　　　　//把该地址转换成一个指针

　　　　#define MEM_ADDR(addr) *((volatile unsigned long *) (addr))

　　　　于是：

　　　　MEM_ADDR(DEVICE_REG0) = 0xAB; 　//使用正常地址访问寄存器　　

　　　　MEM_ADDR(BITBAND(DEVICE_REG0,1)) = 0x1;　 //使用位带别名地址

　　注意：当你使用位带功能时，要访问的变量必须用 volatile 来定义。因为 C 编译器并不知道同一个比特可以有两个地址。所以就要通过 volatile，使得编译器每次都如实地把新数值写入存储器，而不再会出于优化的考虑，在中途使用寄存器来操作数据的复本，直到最后才把复本写回。

　　　在 GCC和 RealView MDK (即 Keil) 开发工具中，允许定义变量时手工指定其地址。如：

　　　volatile unsigned long bbVarAry[7]__attribute__(( at(0x20003014) ));

　　　volatile unsigned long* const pbbaVar= (void*)(0x22000000+0x3014*8*4);

　　　// 在 long*后面的“const”通知编译器：该指针不能再被修改而指向其它地址。

　　　// 注意：at()中的地址必须对齐到4 字节边界。

　　这样，就在0x20003014处分配了7个字，共得到了32*7=224 个比特。

　　再使用这些比特时，可以通过如下的的形式：

　　　 pbbaVar[136]=1; //置位第 136号比特

　　不过这有个局限：编译器无法检查是否下标越界。

　　那为什么不定义成“ baVarAry[224]“ 的数组呢？

　　这也是一个编译器的局限：它不知道这个数组其实就是 bbVarAry[7]，从而在计算程序对内存的占用量上，会平白无故地多计入224*4个字节。

　　对于指针义，为每个需要使用的比特取一个字面值的名字，在下标中只使用字面值名字，不再写真实的数字，就可以极大程度地避免数组越界。

　　请注意：在定义这“两个”变量时，前面加上了“volatile”。如果不再使用bbVarAry 来访问这些比特，而仅仅使用位带别名的形式访问时，这两个 volatile 均不再需要。

Cortex?-M3 将片内外设和SRAM都做了位映射。=====这么处理，单片机就无法直接支持4G字节内存。哈。

（08年，笔记本电脑正在4G内存热炒，也来凑个热闹）

SRAM空间2000... 映射到2200...
实际上，为片内SRAM仅保留了2000,0000 - 200f,ffff。
Cortex?-M3 仅保留1Mbyte空间，马马虎虎====要知道，受到07年的飞身直落，08年的DDR2仅相当于1M折合1元人民币！（不好意思，又来了。20080313Hy512M DDR2-667仅58元人民币--板上8颗芯片？每颗芯片64Mbyte不到8元？实际上DDR芯片非存储部分占用了相当大面积，近乎一半，不能简单除法。内存与逻辑生产工艺也不相同。片内SRAM相当占面积，更不要提主流CPU内的高速缓存RAM......）

闲话少说，言归正传：
0x2000 0000   bit0 对应   0x2200 0000
0x2000 0000   bit1 对应   0x2200 0004
0x2000 0000   bit2 对应   0x2200 0008
......
0x200f ffff   bit15对应   0x23ff fffc    呵呵

由于32位系统，一次处理4个字节比较直观；所以，总是把4个字节一起处理；于是，字节地址0123就被一

次性处理掉了；总之，地址没有123那样连续，而是0,4,8,c,0这样蹦蹦跳跳。
=======为每一个bit分配一个 “32bit MCU 可以方便处理的地址”，需要占用32倍地址空间。

因此，嗯，是这样的，地址的计算公式，稍微复杂了点：
bit_word_addr = bit_band_base + (byte_offset x 32) + (bit_number × 4)

SRAM
2200 0000 加上偏移
SRAM_BB_BASE

void get_bit(u8 db8)
{
  vu32 VarAddr;
  VarAddr = (u32)&db8;
  VarAddr = (0x22000000 | ((VarAddr - 0x20000000) << 5) );
  bit0  = (*(vu8 *) VarAddr);  //VarAddr += 4;
......

}

特殊功能寄存器：
4200 0000 加上偏移
PERIPH_BB_BASE

#include "stm32f10x_map.h"

#define BIT_1 1
#define BIT_2 2
#define BIT_3 3
#define BIT_4 4
#define BIT_5 5

#define IO_ODR 0x0c

#define IO_OUT(a,b) (*(vu8 *)(PERIPH_BB_BASE | ((a - PERIPH_BASE + IO_ODR) << 5) + (b << 2)))

#define bitX  IO_OUT(GPIOD, BIT_Pin_3)
========bitX仅仅负责输出哦！ODR 可以输出0,也可以输出1。IDR才能输入，读取。还有BSRR,BRR，根据需要取用。

或者干脆

//       C9   C 40011000   ODR  C   bit 9
//              42220000      180      24
#define dd0           (*(vu8 *)0x422201A4)
//看明白了么？

dd0 = 1;

bitX = 1;

bitX = 0;

哈

在STM的官方的固件库下面有个Examples里有个CortexM3文件夹，Example1给出了bitbanding详解的使用描述。

偏移用的基地址都是固定的
#define RAM_BASE       0x20000000
#define RAM_BB_BASE    0x22000000

三个对位操作的宏定义，清零、置位、读位：
#define  Var_ResetBit_BB(VarAddr, BitNumber)
          (*(vu32 *) (RAM_BB_BASE | ((VarAddr - RAM_BASE) << 5) | RAM_BB_BASE | ((BitNumber) << 2)) = 0)

#define Var_SetBit_BB(VarAddr, BitNumber)
          (*(vu32 *) (RAM_BB_BASE | ((VarAddr - RAM_BASE) << 5) | RAM_BB_BASE | ((BitNumber) << 2)) = 1)

#define Var_GetBit_BB(VarAddr, BitNumber)
          (*(vu32 *) (RAM_BB_BASE | ((VarAddr - RAM_BASE) << 5) | RAM_BB_BASE | ((BitNumber) << 2)))


使用方法：
/* A mapping formula shows how to reference each word in the alias region to a corresponding bit in the bit-band region. The mapping formula is:
  bit_word_addr = bit_band_base + (byte_offset x 32) + (bit_number x4)

where:
   - bit_word_addr: is the address of the word in the alias memory region that maps to the targeted bit.
   - bit_band_base is the starting address of the alias region
   - byte_offset is the number of the byte in the bit-band region that contains the targeted bit
   - bit_number is the bit position (0-31) of the targeted bit */

/* Get the variable address --------------------------------------------------*/
  VarAddr = (u32)&Var;

/* Modify variable bit using bit-band access ---------------------------------*/
  /* Modify Var variable bit 0 -----------------------------------------------*/
  Var_ResetBit_BB(VarAddr, 0);  /* Var = 0x00005AA4 */
  Var_SetBit_BB(VarAddr, 0);    /* Var = 0x00005AA5 */

  /* Modify Var variable bit 11 -----------------------------------------------*/
  Var_ResetBit_BB(VarAddr, 11);             /* Var = 0x000052A5 */
  /* Get Var variable bit 11 value */
  VarBitValue = Var_GetBit_BB(VarAddr, 11); /* VarBitValue = 0x00000000 */

  Var_SetBit_BB(VarAddr, 11);               /* Var = 0x00005AA5 */
  /* Get Var variable bit 11 value */
  VarBitValue = Var_GetBit_BB(VarAddr, 11);    /* VarBitValue = 0x00000001 */

  /* Modify Var variable bit 31 -----------------------------------------------*/
  Var_SetBit_BB(VarAddr, 31);               /* Var = 0x80005AA5 */
  /* Get Var variable bit 31 value */
  VarBitValue = Var_GetBit_BB(VarAddr, 31); /* VarBitValue = 0x00000001 */

  Var_ResetBit_BB(VarAddr, 31);             /* Var = 0x00005AA5 */
  /* Get Var variable bit 31 value */
  VarBitValue = Var_GetBit_BB(VarAddr, 31); /* VarBitValue = 0x00000000 */

天在网上看到通过别名区的映射实现位操作功能，以前看STM32手册的时候看到过介绍，但一直没明白怎么用，今天用了一下，成功了！

我的STM32板子PA0和PA1接的LED灯，所以先映射这两位。

查看手册中的寄存器组起始地址:

(原文件名:地址.jpg) 引用图片

GPIOA是 0x4001 0800

端口输出数据寄存器(GPIOx_ODR)  的偏移地址是 0x0c

根据公式：别名区 =  ADDRESS=0x4200 0000 + (0x0001 080C*0x20) + (bitx*4)    ;bitx:第x位

得到PA.0和PA.1的别名区地址

#define PA_Bit0 ((volatile unsigned long *) (0x42210180))
#define PA_Bit1 ((volatile unsigned long *) (0x42210184))

接下来就可以对PA.0和PA.1进行位操作了

*PA_Bit0 = 1;  //PA.0 置1

*PA_Bit1 = 0;  //PA.1 置0

还可以读出这一位的值：

while(1)

{

       *PA_Bit1 =(~*PA_Bit1);

        Delay(1000);                      //延时1秒

}

PA.1接的LED会闪烁。

由于对STM32的存储结构不了解，0x4200 0000不知道是从哪里来的。

原来0x4200 0000是外设别名区域的地址。

来自http://www.ourdev.cn/bbs/bbs_content.jsp?bbs_sn=4414916&bbs_page_no=1&bbs_id=9999

利用MDK提供的关键字__attribute__((bitband))，可以很方便地进行Cortex-M3所提供的位区(bitband)操作。下面以USART的定义为例：

/* ------------------------ USART寄存器 ---------------------- */
typedef struct                                  // 状态寄存器结构
{
    u16 PE:1;                                   // 校验错误(r)
    u16 FE:1;                                   // 帧错误(r)
    u16 NE:1;                                   // 噪声错误标志(r)
    u16 ORE:1;                                  // 过载错误(r)
    u16 IDLE:1;                                 // 监测到总线空闲(r)
    u16 RXNE:1;                                 // 读数据寄存器非空(rc_w0)
    u16 TC:1;                                   // 发送完成(rc_w0)
    u16 TXE:1;                                  // 发送数据寄存器空(r)
    u16 LBD:1;                                  // LIN断开检测标志(rc_w0)
    u16 CTS:1;                                  // CTS 标志(rc_w0)
}USART_SR __attribute__((bitband));

typedef struct                                  // 控制寄存器1结构
{
    u16 SBK:1;                                  // 发送断开帧(rw 1:将要发送断开字符)
    u16 RWU:1;                                  // 接收唤醒(rw 1:接收器处于静默模式)
    u16 RE:1;                                   // 接收使能(rw)
    u16 TE:1;                                   // 发送使能(rw)
    u16 IDLEIE:1;                               // IDLE中断使能(rw)
    u16 RXNEIE:1;                               // 接收缓冲区非空中断使能(rw)
    u16 TCIE:1;                                 // 发送完成中断使能(rw)
    u16 TXEIE:1;                                // 发送缓冲区空中断使能(rw)
    u16 PEIE:1;                                 // PE中断使能(rw)
    u16 PS:1;                                   // 校验选择(rw 0:偶校验，1:奇校验)
    u16 PCE:1;                                  // 检验控制使能(rw)
    u16 WAKE:1;                                 // 唤醒的方法(rw 0:被空闲总线唤醒，1:被地址标记唤醒)
    u16 M:1;                                    // 字长(rw 0:8位，1:9位)
    u16 UE:1;                                   // USART使能(rw)
}USART_CR1 __attribute__((bitband));

typedef struct                                  // 控制寄存器2结构
{
    u16 ADDR:4;                                 // 本设备的USART节点地址(rw)
    u16 RESERVED1:1;
    u16 LBDL:1;                                 // LIN断开符检测长度(rw 0:10的断开符检测，1:11位)
    u16 LBDIE:1;                                // LIN断开符检测中断使能(rw)
    u16 RESERVED2:1;
    u16 LBCL:1;                                 // 最后一位时钟脉冲(rw )
    u16 MODE:2;                                 // 时钟相位(rw 0:在时钟的第一个边沿进行数据捕获，1:第二个)
                                                // 时钟极性(rw 0:总线空闲时CK引脚上保持低电平；1:高电平)
    u16 CLKEN:1;                                // 时钟使能(rw)
    u16 STOP:2;                                 // 停止位(rw)
    u16 LINEN:1;                                // LIN模式使能(rw)
}USART_CR2 __attribute__((bitband));

typedef struct                                  // 控制寄存器3结构
{
    u16 EIE:1;                                  // 错误中断使能(rw)
    u16 IREN:1;                                 // 红外模式使能(rw)
    u16 IRLP:1;                                 // 红外低功耗(rw)
    u16 HDSEL:1;                                // 半双工选择(rw)
    u16 NACK:1;                                 // 智能卡NACK使能(rw)
    u16 SCEN:1;                                 // 智能卡模式使能(rw)
    u16 DMAR:1;                                 // DMA使能接收(rw)
    u16 DMAT:1;                                 // DMA使能发送(rw)
    u16 RTSE:1;                                 // RTS使能(rw)
    u16 CTSE:1;                                 // CTS使能(rw)
    u16 CTSIE:1;                                // CTS中断使能(rw)
}USART_CR3 __attribute__((bitband));

typedef struct                                  // 保护时间和预分频寄存器结构
{
    u16 PSC:8;                                  // 预分频器值(rw )
    u16 GT:8;                                   // 保护时间值(rw)
}USART_GTPR __attribute__((bitband));

typedef struct                                  // USART寄存器结构
{
    __IO USART_SR   SR;                         // 状态寄存器
    u16 RESERVED0;
    __IO u16        DR;                         // 数据寄存器
    u16 RESERVED1;
    __IO u16        BRR;                        // 波特比率寄存器
    u16 RESERVED2;
    __IO USART_CR1  CR1;                        // 控制寄存器1
    u16 RESERVED3;
    __IO USART_CR2  CR2;                        // 控制寄存器2
    u16 RESERVED4;
    __IO USART_CR3  CR3;                        // 控制寄存器3
    u16 RESERVED5;
    __IO USART_GTPR GTPR;                       // 保护时间和预分频寄存器
    u16 RESERVED6;
}USART_TypeDef;

#define PERIPH_BASE           0x40000000                            // 外围设备的基地址
#define APB1PERIPH_BASE       PERIPH_BASE                           // APB1设备的基地址
#define APB2PERIPH_BASE       (PERIPH_BASE + 0x10000)               // APB2设备的其地址

#define USART2_BASE           (APB1PERIPH_BASE + 0x4400)            // USART2基地址
#define USART3_BASE           (APB1PERIPH_BASE + 0x4800)            // USART3基地址
#define UART4_BASE            (APB1PERIPH_BASE + 0x4C00)            // UART4 基地址
#define UART5_BASE            (APB1PERIPH_BASE + 0x5000)            // UART5 基地址
#define USART1_BASE           (APB2PERIPH_BASE + 0x3800)            // USART1基地址

#define USART2                ((USART_TypeDef *) USART2_BASE)       // 定义USART2
#define USART3                ((USART_TypeDef *) USART3_BASE)       // 定义USART3
#define UART4                 ((USART_TypeDef *) UART4_BASE)        // 定义UART4
#define UART5                 ((USART_TypeDef *) UART5_BASE)        // 定义UART5
#define USART1                ((USART_TypeDef *) USART1_BASE)       // 定义USART1

    如果想给USART1的CR1寄存器的RXNEIE置位，直接这样操作就行了：
    USART1->CR1.RXNEIE = 1;
    MDK就能正确编译成位区操作地址，根本不需要自己去计算位区地址。

来自http://www.ourdev.cn/bbs/bbs_content.jsp?bbs_sn=3848831&bbs_page_no=1&search_mode=1&search_text=gpio&bbs_id=3020

#ifndef __STM32F10x_bit_band_H
#define __STM32F10x_bit_band_H

//#define GPIOF6_Out (*((u32*)0x42238198))//GPIOF端口起始地址为0x42011c00,输出寄存器ODR的偏移地址为0ch，第6位
//0x42238198=0x42000000+(0x11c00+0ch)*32（即0x20）+6*4（0x18）

#define GPIOA0_Out  (*((u32*)0x42210180))
#define GPIOA1_Out  (*((u32*)0x42210184))
#define GPIOA2_Out  (*((u32*)0x42210188))
#define GPIOA3_Out  (*((u32*)0x4221018c))
#define GPIOA4_Out  (*((u32*)0x42210190))
#define GPIOA5_Out  (*((u32*)0x42210194))
#define GPIOA6_Out  (*((u32*)0x42210198))
#define GPIOA7_Out  (*((u32*)0x4221019c))
#define GPIOA8_Out  (*((u32*)0x422101a0))
#define GPIOA9_Out  (*((u32*)0x422101a4))
#define GPIOA10_Out  (*((u32*)0x422101a8))
#define GPIOA11_Out  (*((u32*)0x422101ac))
#define GPIOA12_Out  (*((u32*)0x422101b0))
#define GPIOA13_Out  (*((u32*)0x422101b4))
#define GPIOA14_Out  (*((u32*)0x422101b8))
#define GPIOA15_Out  (*((u32*)0x422101bc))

#define GPIOA0_IN  (*((u32*)0x42210100))
#define GPIOA1_IN  (*((u32*)0x42210104))
#define GPIOA2_IN  (*((u32*)0x42210108))
#define GPIOA3_IN  (*((u32*)0x4221010c))
#define GPIOA4_IN  (*((u32*)0x42210110))
#define GPIOA5_IN  (*((u32*)0x42210114))
#define GPIOA6_IN  (*((u32*)0x42210118))
#define GPIOA7_IN  (*((u32*)0x4221011c))
#define GPIOA8_IN  (*((u32*)0x42210120))
#define GPIOA9_IN  (*((u32*)0x42210124))
#define GPIOA10_IN  (*((u32*)0x42210128))
#define GPIOA11_IN  (*((u32*)0x4221012c))
#define GPIOA12_IN  (*((u32*)0x42210130))
#define GPIOA13_IN  (*((u32*)0x42210134))
#define GPIOA14_IN  (*((u32*)0x42210138))
#define GPIOA15_IN  (*((u32*)0x4221013c))

#define GPIOB0_Out  (*((u32*)0x42218180))
#define GPIOB1_Out  (*((u32*)0x42218184))
#define GPIOB2_Out  (*((u32*)0x42218188))
#define GPIOB3_Out  (*((u32*)0x4221818c))
#define GPIOB4_Out  (*((u32*)0x42218190))
#define GPIOB5_Out  (*((u32*)0x42218194))
#define GPIOB6_Out  (*((u32*)0x42218198))
#define GPIOB7_Out  (*((u32*)0x4221819c))
#define GPIOB8_Out  (*((u32*)0x422181a0))
#define GPIOB9_Out  (*((u32*)0x422181a4))
#define GPIOB10_Out  (*((u32*)0x422181a8))
#define GPIOB11_Out  (*((u32*)0x422181ac))
#define GPIOB12_Out  (*((u32*)0x422181b0))
#define GPIOB13_Out  (*((u32*)0x422181b4))
#define GPIOB14_Out  (*((u32*)0x422181b8))
#define GPIOB15_Out  (*((u32*)0x422181bc))

#define GPIOB0_IN  (*((u32*)0x42218100))
#define GPIOB1_IN  (*((u32*)0x42218104))
#define GPIOB2_IN  (*((u32*)0x42218108))
#define GPIOB3_IN  (*((u32*)0x4221810c))
#define GPIOB4_IN  (*((u32*)0x42218110))
#define GPIOB5_IN  (*((u32*)0x42218114))
#define GPIOB6_IN  (*((u32*)0x42218118))
#define GPIOB7_IN  (*((u32*)0x4221811c))
#define GPIOB8_IN  (*((u32*)0x42218120))
#define GPIOB9_IN  (*((u32*)0x42218124))
#define GPIOB10_IN  (*((u32*)0x42218128))
#define GPIOB11_IN  (*((u32*)0x4221812c))
#define GPIOB12_IN  (*((u32*)0x42218130))
#define GPIOB13_IN  (*((u32*)0x42218134))
#define GPIOB14_IN  (*((u32*)0x42218138))
#define GPIOB15_IN  (*((u32*)0x4221813c))

#define GPIOC0_Out  (*((u32*)0x42220180))
#define GPIOC1_Out  (*((u32*)0x42220184))
#define GPIOC2_Out  (*((u32*)0x42220188))
#define GPIOC3_Out  (*((u32*)0x4222018c))
#define GPIOC4_Out  (*((u32*)0x42220190))
#define GPIOC5_Out  (*((u32*)0x42220194))
#define GPIOC6_Out  (*((u32*)0x42220198))
#define GPIOC7_Out  (*((u32*)0x4222019c))
#define GPIOC8_Out  (*((u32*)0x422201a0))
#define GPIOC9_Out  (*((u32*)0x422201a4))
#define GPIOC10_Out  (*((u32*)0x422201a8))
#define GPIOC11_Out  (*((u32*)0x422201ac))
#define GPIOC12_Out  (*((u32*)0x422201b0))
#define GPIOC13_Out  (*((u32*)0x422201b4))
#define GPIOC14_Out  (*((u32*)0x422201b8))
#define GPIOC15_Out  (*((u32*)0x422201bc))

#define GPIOC0_IN  (*((u32*)0x42220100))
#define GPIOC1_IN  (*((u32*)0x42220104))
#define GPIOC2_IN  (*((u32*)0x42220108))
#define GPIOC3_IN  (*((u32*)0x4222010c))
#define GPIOC4_IN  (*((u32*)0x42220110))
#define GPIOC5_IN  (*((u32*)0x42220114))
#define GPIOC6_IN  (*((u32*)0x42220118))
#define GPIOC7_IN  (*((u32*)0x4222011c))
#define GPIOC8_IN  (*((u32*)0x42220120))
#define GPIOC9_IN  (*((u32*)0x42220124))
#define GPIOC10_IN  (*((u32*)0x42220128))
#define GPIOC11_IN  (*((u32*)0x4222012c))
#define GPIOC12_IN  (*((u32*)0x42220130))
#define GPIOC13_IN  (*((u32*)0x42220134))
#define GPIOC14_IN  (*((u32*)0x42220138))
#define GPIOC15_IN  (*((u32*)0x4222013c))

#define GPIOD0_Out  (*((u32*)0x42228180))
#define GPIOD1_Out  (*((u32*)0x42228184))
#define GPIOD2_Out  (*((u32*)0x42228188))
#define GPIOD3_Out  (*((u32*)0x4222818c))
#define GPIOD4_Out  (*((u32*)0x42228190))
#define GPIOD5_Out  (*((u32*)0x42228194))
#define GPIOD6_Out  (*((u32*)0x42228198))
#define GPIOD7_Out  (*((u32*)0x4222819c))
#define GPIOD8_Out  (*((u32*)0x422281a0))
#define GPIOD9_Out  (*((u32*)0x422281a4))
#define GPIOD10_Out  (*((u32*)0x422281a8))
#define GPIOD11_Out  (*((u32*)0x422281ac))
#define GPIOD12_Out  (*((u32*)0x422281b0))
#define GPIOD13_Out  (*((u32*)0x422281b4))
#define GPIOD14_Out  (*((u32*)0x422281b8))
#define GPIOD15_Out  (*((u32*)0x422281bc))

#define GPIOD0_IN  (*((u32*)0x42228100))
#define GPIOD1_IN  (*((u32*)0x42228104))
#define GPIOD2_IN  (*((u32*)0x42228108))
#define GPIOD3_IN  (*((u32*)0x4222810c))
#define GPIOD4_IN  (*((u32*)0x42228110))
#define GPIOD5_IN  (*((u32*)0x42228114))
#define GPIOD6_IN  (*((u32*)0x42228118))
#define GPIOD7_IN  (*((u32*)0x4222811c))
#define GPIOD8_IN  (*((u32*)0x42228120))
#define GPIOD9_IN  (*((u32*)0x42228124))
#define GPIOD10_IN  (*((u32*)0x42228128))
#define GPIOD11_IN  (*((u32*)0x4222812c))
#define GPIOD12_IN  (*((u32*)0x42228130))
#define GPIOD13_IN  (*((u32*)0x42228134))
#define GPIOD14_IN  (*((u32*)0x42228138))
#define GPIOD15_IN  (*((u32*)0x4222813c))

#define GPIOE0_Out  (*((u32*)0x42230180))
#define GPIOE1_Out  (*((u32*)0x42230184))
#define GPIOE2_Out  (*((u32*)0x42230188))
#define GPIOE3_Out  (*((u32*)0x4223018c))
#define GPIOE4_Out  (*((u32*)0x42230190))
#define GPIOE5_Out  (*((u32*)0x42230194))
#define GPIOE6_Out  (*((u32*)0x42230198))
#define GPIOE7_Out  (*((u32*)0x4223019c))
#define GPIOE8_Out  (*((u32*)0x422301a0))
#define GPIOE9_Out  (*((u32*)0x422301a4))
#define GPIOE10_Out  (*((u32*)0x422301a8))
#define GPIOE11_Out  (*((u32*)0x422301ac))
#define GPIOE12_Out  (*((u32*)0x422301b0))
#define GPIOE13_Out  (*((u32*)0x422301b4))
#define GPIOE14_Out  (*((u32*)0x422301b8))
#define GPIOE15_Out  (*((u32*)0x422301bc))

#define GPIOE0_IN  (*((u32*)0x42230100))
#define GPIOE1_IN  (*((u32*)0x42230104))
#define GPIOE2_IN  (*((u32*)0x42230108))
#define GPIOE3_IN  (*((u32*)0x4223010c))
#define GPIOE4_IN  (*((u32*)0x42230110))
#define GPIOE5_IN  (*((u32*)0x42230114))
#define GPIOE6_IN  (*((u32*)0x42230118))
#define GPIOE7_IN  (*((u32*)0x4223011c))
#define GPIOE8_IN  (*((u32*)0x42230120))
#define GPIOE9_IN  (*((u32*)0x42230124))
#define GPIOE10_IN  (*((u32*)0x42230128))
#define GPIOE11_IN  (*((u32*)0x4223012c))
#define GPIOE12_IN  (*((u32*)0x42230130))
#define GPIOE13_IN  (*((u32*)0x42230134))
#define GPIOE14_IN  (*((u32*)0x42230138))
#define GPIOE15_IN  (*((u32*)0x4223013c))

#define GPIOF0_Out  (*((u32*)0x42238180))
#define GPIOF1_Out  (*((u32*)0x42238184))
#define GPIOF2_Out  (*((u32*)0x42238188))
#define GPIOF3_Out  (*((u32*)0x4223818c))
#define GPIOF4_Out  (*((u32*)0x42238190))
#define GPIOF5_Out  (*((u32*)0x42238194))
#define GPIOF6_Out  (*((u32*)0x42238198))
#define GPIOF7_Out  (*((u32*)0x4223819c))
#define GPIOF8_Out  (*((u32*)0x422381a0))
#define GPIOF9_Out  (*((u32*)0x422381a4))
#define GPIOF10_Out  (*((u32*)0x422381a8))
#define GPIOF11_Out  (*((u32*)0x422381ac))
#define GPIOF12_Out  (*((u32*)0x422381b0))
#define GPIOF13_Out  (*((u32*)0x422381b4))
#define GPIOF14_Out  (*((u32*)0x422381b8))
#define GPIOF15_Out  (*((u32*)0x422381bc))

#define GPIOF0_IN  (*((u32*)0x42238100))
#define GPIOF1_IN  (*((u32*)0x42238104))
#define GPIOF2_IN  (*((u32*)0x42238108))
#define GPIOF3_IN  (*((u32*)0x4223810c))
#define GPIOF4_IN  (*((u32*)0x42238110))
#define GPIOF5_IN  (*((u32*)0x42238114))
#define GPIOF6_IN  (*((u32*)0x42238118))
#define GPIOF7_IN  (*((u32*)0x4223811c))
#define GPIOF8_IN  (*((u32*)0x42238120))
#define GPIOF9_IN  (*((u32*)0x42238124))
#define GPIOF10_IN  (*((u32*)0x42238128))
#define GPIOF11_IN  (*((u32*)0x4223812c))
#define GPIOF12_IN  (*((u32*)0x42238130))
#define GPIOF13_IN  (*((u32*)0x42238134))
#define GPIOF14_IN  (*((u32*)0x42238138))
#define GPIOF15_IN  (*((u32*)0x4223813c))

#define GPIOG0_Out  (*((u32*)0x42240180))
#define GPIOG1_Out  (*((u32*)0x42240184))
#define GPIOG2_Out  (*((u32*)0x42240188))
#define GPIOG3_Out  (*((u32*)0x4224018c))
#define GPIOG4_Out  (*((u32*)0x42240190))
#define GPIOG5_Out  (*((u32*)0x42240194))
#define GPIOG6_Out  (*((u32*)0x42240198))
#define GPIOG7_Out  (*((u32*)0x4224019c))
#define GPIOG8_Out  (*((u32*)0x422401a0))
#define GPIOG9_Out  (*((u32*)0x422401a4))
#define GPIOG10_Out  (*((u32*)0x422401a8))
#define GPIOG11_Out  (*((u32*)0x422401ac))
#define GPIOG12_Out  (*((u32*)0x422401b0))
#define GPIOG13_Out  (*((u32*)0x422401b4))
#define GPIOG14_Out  (*((u32*)0x422401b8))
#define GPIOG15_Out  (*((u32*)0x422401bc))

#define GPIOG0_IN  (*((u32*)0x42240100))
#define GPIOG1_IN  (*((u32*)0x42240104))
#define GPIOG2_IN  (*((u32*)0x42240108))
#define GPIOG3_IN  (*((u32*)0x4224010c))
#define GPIOG4_IN  (*((u32*)0x42240110))
#define GPIOG5_IN  (*((u32*)0x42240114))
#define GPIOG6_IN  (*((u32*)0x42240118))
#define GPIOG7_IN  (*((u32*)0x4224011c))
#define GPIOG8_IN  (*((u32*)0x42240120))
#define GPIOG9_IN  (*((u32*)0x42240124))
#define GPIOG10_IN  (*((u32*)0x42240128))
#define GPIOG11_IN  (*((u32*)0x4224012c))
#define GPIOG12_IN  (*((u32*)0x42240130))
#define GPIOG13_IN  (*((u32*)0x42240134))
#define GPIOG14_IN  (*((u32*)0x42240138))
#define GPIOG15_IN  (*((u32*)0x4224013c))

#endif

将以上的stm32f10x_bit_band.h文件添加到main.c文件中即可调用。
例如：要F8口输出低，则为GPIOF8=0;（前提是已经将GPIOF的8口设为输出口）

------------------------------------------------------------------

#define GPIOx_Bitx(IOx,bitx) (*(volatile unsigned long *)((0x42000000+(((IOx&0x000fffff)+0xC)*0x20))+(bitx<<2)))
有了这句，所有的IO就可以用你下面写的方式写0写1了是吗？
#define PA_Bit0 GPIOx_Bitx(GPIOA_BASE,0)
#define PA_Bit1 GPIOx_Bitx(GPIOA_BASE,1)

关键字：STM32 位操作引用地址：STM32的位操作的方法

上一篇：怎么使用ST的库开发STM32
下一篇：LPC2131 UART使用方法简介

推荐阅读最新更新时间：2024-03-16 15:28

一种STM32的串口控制台的实现

一.背景曾经玩Linux时非常喜欢这种基于出串口的控制台, 通过简单的串口TX和RX能实现嵌入式硬件的人机交互,非常实用, 那么STM32能否实现通过超级终端与用户互动的构想呢? 答案是肯定的，由于这个UART控制平台就像应用程序套上一层可访问的外科（Shell）故而我将这种基于UART的控制平台简称Shell,构架和效果如下图: 这张图箭头指向的是输入的指令,其余是STM32串口输出的信息,，可以看到通过这些简单的指令输入我们通过Shell可以做很多事情: 1. 现场设备发生故障，可以通过Shell可以查看设备的故障状态统计信息 2. 能实现串口程序升级(需要Shell+IAP驱动程序支持) 3.

[单片机]

一种<font color='red'>STM32</font>的串口控制台的实现

stm32专题三十一：电源管理

stm32的电源管理上电复位与掉电复位（POR PDR）：这个滞回电压，是为了让单片机容忍一定程度的电压波动，而不是只要电压稍微一变化，就立刻掉电复位。可编程电压监测器PVD： PVD中断的上升沿或下降沿，表示的是VDD电压是超过阈值还是低于阈值，关于PVD中断的描述如下： stm32电源系统为了方便进行电源管理，STM32 把它的外设、内核等模块跟据功能划分了供电区域，其内部电源区域划分如图： CPU内核为1.8V供电，以降低功耗，整个1.8V供电区域由电压调节器单独供电，有时CPU可以休眠，有时可以不休眠，这是由电压调节器来提供的。关于时钟的具体描述：这里，值得注意的是后备供电区

[单片机]

<font color='red'>stm32</font>专题三十一：电源管理

STM32 uCos的移植问题

中断优先级分组的设置：从ucos官网下载的例程，经过验证查看该例程并未进行优先级的分组设置。如果AIRCR【10：8】是0的话说明为未设置中断分组，而采用的默认即按照中断向量号来进行中断排序。 STM32的分组只能是： #define NVIC_PriorityGroup_0 ((u32)0x700) /* 0 bits for pre-emption priority 4 bits for subpriority */ #define NVIC_PriorityGroup_1 ((u32)0x600) /* 1 bits for pre-emption priority 3 bits for su

[单片机]

STM32从入门到精通—GPIO简介

今天通过这篇文章带大家简单地了解一下GPIO，让大家有一个简单的认识，能够尽快应用。 GPIO简介每个通用I/O端口包括4个32位配置寄存器、2个32位数据寄存器、1个32位置位/复位寄存器、1个32位锁定寄存器和2个32位复用功能选择寄存器。 GPIO主要特性受控I/O多达16个输出状态：推免或开漏+上拉/下拉从输出数据寄存器或外设输出数据可为每个I/O选择不同的速度输入状态：浮空、上拉/下拉、模拟将数据输入到输入寄存器或外设置位和复位寄存器，对GPIO_ODR具有按位写权限锁定机制，可冻结I/O配置模拟功能复用功能输入/输出选择寄存器快速翻转，每次翻转最快最需要两个时钟周期

[单片机]

<font color='red'>STM32</font>从入门到精通—GPIO简介

MDK软件不能模拟仿真STM32的问题解决方法

引言　　MDK软件在模拟仿真时，不能很好地支持各种STM32系列芯片，目前对STM32F103系列芯片支持模拟仿真，但对于其他系列芯片不支持或只是部分支持。主要存在的问题是：PC和SP不能自动装载，存储器不能访问，中断服务程序不能执行或触发，外设寄存器不能修改或观察。要解决上述问题，必须通过相应的设置和相关的操作，才能完成模拟仿真。 1 模拟仿真的实现及PC和SP的自动装载　　在MDK软件中，只有部分STM32芯片支持模拟仿真（如STM32F103），大部分芯片都不支持模拟仿真。主要的问题是，当进入调试界面后，R15 (PC)的值为0x00000000，不能进行调试操作（如单步、全速等）。要能对STM32进行模拟仿真，必须使P

[单片机]

STM32学习笔记之定时器输入捕获实验

实验目的：在串口调试助手上打印出按键按下的时间实验步骤：实验程序： /*******************************timer.c********************************/ #include sys.h #include stm32f4xx.h extern u8 TIM5CHA1_CAPTURE_STA; extern u16 TIM5CHA1_CAPTURE_VAL; /* 本示例的作用就是，当按键按下时，每次输入捕获的时间差，然后从串口调试助手中打印出其时间差； */ /*

[单片机]

stm32 9位通信的原理和工作过程

STM32是ST（意法半导体）推出的基于ARM® Cortex® M 处理器内核的 32位闪存微控制器产品，融高性能、实时性、数字信号处理、低功耗、低电压于一身，同时保持高集成度和开发简易的特点。拥有业内最强大的产品阵容，基于工业标准的处理器，大量的软硬件开发工具，让STM32单片机成为各类中小项目和完整平台解决方案的理想选择。作为国内第一个智能硬件自助开发（PaaS）及云服务（SaaS）平台和意法半导体战略合作伙伴，机智云率先开发出了基于STM32的物联网开源套件 Gokit 和STM32代码自动生成工具，帮助物联网智能硬件开发者快速打造产品原型。 STM32用9位方式多机通信时，串口模式必须在方式2或方式3。其

[单片机]

基于STM32的FreeRTOS开发（1）----FreeRTOS简介

为什么使用freertos FreeRTOS 是一个免费和开源的实时操作系统，它主要用于嵌入式系统。它非常轻量级，可以在很小的硬件资源上运行，因此非常适合在限制硬件资源的嵌入式系统中使用。 FreeRTOS提供了一组简单的任务管理功能，可以让您在嵌入式系统中实现多任务环境，这对于涉及多个独立功能的系统是非常重要的。它还提供了一些高级功能，如事件组、信号量、邮箱等，可用于实现任务之间的同步和通信。 FreeRTOS还提供了许多可移植性，可以在各种不同的硬件平台上运行，并且有大量的文档和示例代码可以帮助您快速上手。总之，FreeRTOS是一个非常受欢迎的嵌入式实时操作系统，因为它简单易用，资源占用小，功能丰富，可移植性好，对于嵌入式

[单片机]