• 基于ADuCM4050的串口打印printf重定向输出


    【ADI】基于ADuCM4050的串口打印printf重定向输出

    串口重定向

    ADuCM4050共有三种重定向方法 官方库中给出了重定向库进行选择 选择以后在每次printf的时候都会进行输出 以下将从三种重定向方法中着手进行分析和对比

    资源:

    download.csdn.net/download/weixin_53403301/86404116
    
    • 1

    无论是哪一种 都需要使能power 这个是必须的

    /* Initialize the power service */
        if (ADI_PWR_SUCCESS != adi_pwr_Init())
        {
            return 1;
        }
        if (ADI_PWR_SUCCESS != adi_pwr_SetClockDivider(ADI_CLOCK_HCLK,1))
        {
            return 1;
        }
        if (ADI_PWR_SUCCESS != adi_pwr_SetClockDivider(ADI_CLOCK_PCLK,1))
        {
            return 1;
        }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    Official_retarget_uart0:
    官方的重定向方法 通过器件里勾选重定向库和IO库 使设备能够直接调用printf函数
    优点:不需要串口初始化 只需要Power时钟初始化 易于操作
    缺点:不能自行配置 若强行配置同一个串口 会导致跑死 无法调用回调函数中断 无法读取数据 每次printf都会自动初始化一次 大部分串口函数功能不可用
    之所以不能自行配置 是因为串口对应的器件被static限制死了 无法传出也无法更改

    官方示例中 直接在器件库中勾选即可
    在这里插入图片描述
    如图所示 除了驱动外 还要重定向IO口 定义为User 以及最重要的重定向Uart

    之后printf调用即可

    改进版就是把重定向Uart部分放在main文件中 不需要声明static

    retarget_uart0:
    类似于Official_retarget_uart0 通过器件里勾选IO库 并将官方的重定向方法直接写进main函数中 使设备能够直接调用printf函数
    优点:不需要串口初始化 只需要Power时钟初始化 较易于操作 可以自行配置串口 可以进行回调函数中断
    缺点:无法读取数据 每次printf都会自动初始化一次 某些串口函数功能不可用

    #include "ADuCM4050.h"
    
    #include 
    #include 
    #include 
    #include 
    
    
    /* Amount of memory required by the driver for Rx and TX only. */
    #define ADI_UART_MEMORY_SIZE  (ADI_UART_BIDIR_MEMORY_SIZE)
    
    #define UART_DEVICE_NUM 0
    
    /* Handle for the UART device */
    ADI_UART_HANDLE handle_UART0;
    
    /* Memory for the driver */
    uint8_t UartDeviceMem[ADI_UART_MEMORY_SIZE];
    
    bool Init_Uart(void) {
    #if ADI_UART_SETUP_PINMUX
      static bool pinmux_done = false;
    
      if (!pinmux_done) {
        /* Configure GPIO0 pins 10 and 11 for UART0 TX and RX */
        uint32_t gpio0_cfg = *pREG_GPIO0_CFG;
        gpio0_cfg &= ~(BITM_GPIO_CFG_PIN10 | BITM_GPIO_CFG_PIN11);
        gpio0_cfg |= (1u << BITP_GPIO_CFG_PIN10) | (1u << BITP_GPIO_CFG_PIN11);
        *pREG_GPIO0_CFG = gpio0_cfg;
        pinmux_done = true;
      }
    #endif
      
      if (handle_UART0 == NULL) {
        /* Open the UART device. Data transfer is bidirectional with NORMAL mode by default.  */
        if(adi_uart_Open(UART_DEVICE_NUM,
                         ADI_UART_DIR_BIDIRECTION,
                         UartDeviceMem,
                         ADI_UART_MEMORY_SIZE,
                         &handle_UART0) != ADI_UART_SUCCESS) {
          return false;
        }
      }
      
      return true;
    }
    
    void Uninit_Uart(void) {
      /* Close the UART device */
      adi_uart_Close(handle_UART0);
      handle_UART0 = NULL;
    }
    
    static int write_to_uart(int ch) {
      uint32_t hwError;
      if ((Init_Uart() == false) || (adi_uart_Write(handle_UART0, &ch, /*nBufSize=*/1, /*bDMA=*/false, &hwError) != ADI_UART_SUCCESS)) {
        return EOF;
      } else {
        return ch;
      }
    }
    
    int stdout_putchar(int ch) {
      return write_to_uart(ch);
    }
    
    int stderr_putchar(int ch) {
      return write_to_uart(ch);
    }
    
    int stdin_getchar(void) {
      return EOF;
    }
    
    int ttywrch(int ch) {
      return write_to_uart(ch);
    }
    
    void _sys_exit(int exit_value) {
    #if ADI_UART_EXIT_BREAKPOINT
      __BKPT(0);
    #else
      while (1) {
        /* Do nothing */
      }
    #endif
    }
    
    void init_PWR(void)
    {
    	adi_pwr_Init();
    	adi_pwr_SetClockDivider(ADI_CLOCK_HCLK,1);
    	adi_pwr_SetClockDivider(ADI_CLOCK_PCLK,1);
    }
    
    void init_DMA(void)
    {
    	adi_dma_Init();
    	adi_dma_Enable(true);
    }
    
    int main(void)
    {
    	init_PWR();
    	init_DMA();
    	uint16_t pBuffer_RX;
    	printf("我hello!\n");
    	adi_uart_SubmitRxBuffer(handle_UART0,&pBuffer_RX,1,true);
    	printf("你hello!\n");
    	while(1)
    	{
    
    	}
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115

    另外最后一种重定向最简单的 就是直接写结构体赋值

    FILE_uart0:
    采用最简的重定向方法 定义结构体 导入发送字符串的API函数
    优点: 可以自行配置、扩展 高开发性 能调用回调函数中断
    缺点:需要进行引脚复用等串口初始化及Power时钟初始化

    #include "ADuCM4050.h"
    #include 
    #include 
    #include 
    #include "GPIO.h"
    #include "DELAY.h"
    
    /* Amount of memory required by the driver for Rx and TX only. */
    #define ADI_UART_MEMORY_SIZE  (ADI_UART_BIDIR_MEMORY_SIZE)
    
    #define UART_DEVICE_NUM 0
    
    /* Handle for the UART device */
    ADI_UART_HANDLE handle_UART0;
    
    /* Memory for the driver */
    uint8_t UartDeviceMem[ADI_UART_MEMORY_SIZE];
    
    
    //串口打印预设
    #pragma import(__use_no_semihosting_swi)
    struct __FILE { int handle; /* Add whatever you need here */ };
    FILE __stdout;
    FILE __stdin;
    void _sys_exit(int x) 
    { 
        x = x; 
    } 
    void _ttywrch(int ch)
    {
        ch = ch;
    }
    //串口打印配置函数
    int fputc(int ch, FILE *f)  
    {
     uint32_t usart0_error;
     adi_uart_Write(handle_UART0,&ch,1,false,&usart0_error);
     
     return ch;
    }
    
    uint8_t dat;
    void callback_UART0(void	*pCBParam,uint32_t	Event,void	*pArg);
    void init_UART(void)
    {	
    	uint32_t gpio0_cfg = *pREG_GPIO0_CFG;
    	gpio0_cfg &= ~(BITM_GPIO_CFG_PIN10 | BITM_GPIO_CFG_PIN11);
    	gpio0_cfg |= (1u << BITP_GPIO_CFG_PIN10) | (1u << BITP_GPIO_CFG_PIN11);
    	*pREG_GPIO0_CFG = gpio0_cfg;
    	
    	adi_uart_Open(0,ADI_UART_DIR_BIDIRECTION,&UartDeviceMem,ADI_UART_BIDIR_MEMORY_SIZE,&handle_UART0);
    	
    	
    	uint32_t pAutobaudErrors_UART0;
    	
    	adi_uart_SetRxFifoTriggerLevel(handle_UART0,ADI_UART_RX_FIFO_TRIG_LEVEL_1BYTE);
    	adi_uart_EnableFifo(handle_UART0,true);
    	
    	adi_uart_SetConfiguration(handle_UART0,ADI_UART_NO_PARITY,ADI_UART_ONE_STOPBIT,ADI_UART_WORDLEN_8BITS);  //0校验 1停止 8带宽
    	
    //	adi_uart_FlushTxFifo(handle_UART0);
    //	adi_uart_FlushRxFifo(handle_UART0);
    	adi_uart_ConfigBaudRate(handle_UART0,4,1,1563,3);
    	
    	adi_uart_RegisterCallback(handle_UART0,callback_UART0,NULL);
    	
    	uint16_t pBuffer_TX=0xff;  //发送
    //	uint16_t pBuffer_RX;  //接收
    	adi_uart_Write(handle_UART0,&pBuffer_TX,1,false,&pAutobaudErrors_UART0);  //阻塞发送
    //	adi_uart_SubmitRxBuffer(handle_UART0,&pBuffer_RX,1,true);  //非阻塞接收
    	
    }
    
    void init_PWR(void)
    {
    	adi_pwr_Init();
    	adi_pwr_SetClockDivider(ADI_CLOCK_HCLK,1);
    	adi_pwr_SetClockDivider(ADI_CLOCK_PCLK,1);
    }
    
    int main(void)
    {
    	init_PWR();
    	init_UART();
    	while(1){
    		printf("%x\n",dat);
    		delay_ms(100);
    	}
    }
    void callback_UART0(void	*pCBParam,uint32_t	Event,void	*pArg)
    {
    //	adi_uart_FlushRxChannel(handle_UART0);	
    	uint8_t RX;
    	adi_uart_GetRX(handle_UART0,&RX);
    	dat=RX;
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97

    ADI中文手册获取方式

    ADI官网可以搜索下载芯片手册 可以切换为中文网站 但是有的芯片找不到中文的下载链接

    亚德诺半导体技术有限公司
    Analog Devices, Inc.(简称ADI)。中国注册公司名字为“亚德诺半导体技术(上海)有限公司。

    所以:
    替换xxxxx的名称即可

    www.analog.com/media/cn/technical-documentation/data-sheets/xxxxx_cn.pdf
    
    如
    www.analog.com/media/cn/technical-documentation/data-sheets/ADF7023_cn.pdf
    
    • 1
    • 2
    • 3
    • 4

    效果:
    在这里插入图片描述
    在这里插入图片描述
    产品特性
    16位分辨率和单调性
    引脚可选的NAMUR兼容范围
    4 mA至20 mA
    3.8 mA至21 mA
    3.2 mA至24 mA
    NAMUR兼容报警电流
    下限报警电流 = 3.2 mA
    上限报警电流 = 22.8 mA/24 mA
    总不可调整误差(TUE):0.05%(最大值)
    积分非线性(INL)误差:0.0035% FSR(最大值)
    输出温度系数:3 ppm/°C(典型值)
    静态电流:300 µA(最大值)
    灵活的SPI兼容型串行数字接口采用施密特触发式输入
    通过FAULT引脚或报警电流提供片内故障报警
    每个写周期自动回读故障寄存器
    压摆率控制功能
    增益和失调调整寄存器
    片内基准源温度系数:4 ppm/°C(最大值)
    可选的稳压输出
    环路电压范围:5.5 V至52 V
    温度范围:−40°C至+105°C
    TSSOP和LFCSP封装
    应用
    工业过程控制
    4 mA至20 mA环路供电发射器
    智能发射器
    HART网络连接

    附录:Cortex-M架构的SysTick系统定时器精准延时和MCU位带操作

    SysTick系统定时器精准延时

    延时函数

    SysTick->LOAD中的值为计数值
    计算方法为工作频率值/分频值
    比如工作频率/1000 则周期为1ms

    以ADuCM4050为例:

    #include "ADuCM4050.h"
    
    void delay_ms(unsigned int ms)
    {
    	SysTick->LOAD = 26000000/1000-1; // Count from 255 to 0 (256 cycles)  载入计数值 定时器从这个值开始计数
    	SysTick->VAL = 0; // Clear current value as well as count flag  清空计数值到达0后的标记
    	SysTick->CTRL = 5; // Enable SysTick timer with processor clock  使能52MHz的系统定时器
    	while(ms--)
    	{
    		while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set  等待
    	}
    	SysTick->CTRL = 0; // Disable SysTick  关闭系统定时器
    }
    void delay_us(unsigned int us)
    {
    	SysTick->LOAD = 26000000/1000/1000-1; // Count from 255 to 0 (256 cycles)  载入计数值 定时器从这个值开始计数
    	SysTick->VAL = 0; // Clear current value as well as count flag  清空计数值到达0后的标记
    	SysTick->CTRL = 5; // Enable SysTick timer with processor clock  使能52MHz的系统定时器
    	while(us--)
    	{
    		while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set  等待
    	}
    	SysTick->CTRL = 0; // Disable SysTick  关闭系统定时器
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    其中的52000000表示芯片的系统定时器频率 32系列一般为外部定时器频率的两倍

    Cortex-M架构SysTick系统定时器阻塞和非阻塞延时

    阻塞延时

    首先是最常用的阻塞延时

    void delay_ms(unsigned int ms)
    {
    	SysTick->LOAD = 50000000/1000-1; // Count from 255 to 0 (256 cycles)  载入计数值 定时器从这个值开始计数
    	SysTick->VAL = 0; // Clear current value as well as count flag  清空计数值到达0后的标记
    	SysTick->CTRL = 5; // Enable SysTick timer with processor clock  使能26MHz的系统定时器
    	while(ms--)
    	{
    		while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set  等待
    	}
    	SysTick->CTRL = 0; // Disable SysTick  关闭系统定时器
    }
    void delay_us(unsigned int us)
    {
    	SysTick->LOAD = 50000000/1000/1000-1; // Count from 255 to 0 (256 cycles)  载入计数值 定时器从这个值开始计数
    	SysTick->VAL = 0; // Clear current value as well as count flag  清空计数值到达0后的标记
    	SysTick->CTRL = 5; // Enable SysTick timer with processor clock  使能26MHz的系统定时器
    	while(us--)
    	{
    		while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set  等待
    	}
    	SysTick->CTRL = 0; // Disable SysTick  关闭系统定时器
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    50000000表示工作频率
    分频后即可得到不同的延时时间
    以此类推

    那么 不用两个嵌套while循环 也可以写成:

    void delay_ms(unsigned int ms)
    {
    	SysTick->LOAD = 50000000/1000*ms-1; // Count from 255 to 0 (256 cycles)  载入计数值 定时器从这个值开始计数
    	SysTick->VAL = 0; // Clear current value as well as count flag  清空计数值到达0后的标记
    	SysTick->CTRL = 5; // Enable SysTick timer with processor clock  使能26MHz的系统定时器
    
    	while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set  等待
    
    	SysTick->CTRL = 0; // Disable SysTick  关闭系统定时器
    }
    void delay_us(unsigned int us)
    {
    	SysTick->LOAD = 50000000/1000/1000*us-1; // Count from 255 to 0 (256 cycles)  载入计数值 定时器从这个值开始计数
    	SysTick->VAL = 0; // Clear current value as well as count flag  清空计数值到达0后的标记
    	SysTick->CTRL = 5; // Enable SysTick timer with processor clock  使能26MHz的系统定时器
    	
    	while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set  等待
    
    	SysTick->CTRL = 0; // Disable SysTick  关闭系统定时器
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    但是这种写法有个弊端
    那就是输入ms后,最大定时不得超过计数值,也就是不能超过LOAD的最大值,否则溢出以后,则无法正常工作

    而LOAD如果最大是32位 也就是4294967295

    晶振为50M的话 50M的计数值为1s 4294967295计数值约为85s

    固最大定时时间为85s

    但用嵌套while的话 最大可以支持定时4294967295*85s

    非阻塞延时

    如果采用非阻塞的话 直接改写第二种方法就好了:

    void delay_ms(unsigned int ms)
    {
    	SysTick->LOAD = 50000000/1000*ms-1; // Count from 255 to 0 (256 cycles)  载入计数值 定时器从这个值开始计数
    	SysTick->VAL = 0; // Clear current value as well as count flag  清空计数值到达0后的标记
    	SysTick->CTRL = 5; // Enable SysTick timer with processor clock  使能26MHz的系统定时器
    
    	//while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set  等待
    
    	//SysTick->CTRL = 0; // Disable SysTick  关闭系统定时器
    }
    void delay_us(unsigned int us)
    {
    	SysTick->LOAD = 50000000/1000/1000*us-1; // Count from 255 to 0 (256 cycles)  载入计数值 定时器从这个值开始计数
    	SysTick->VAL = 0; // Clear current value as well as count flag  清空计数值到达0后的标记
    	SysTick->CTRL = 5; // Enable SysTick timer with processor clock  使能26MHz的系统定时器
    	
    	//while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set  等待
    
    	//SysTick->CTRL = 0; // Disable SysTick  关闭系统定时器
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    将等待和关闭定时器语句去掉
    在使用时加上判断即可变为阻塞:

    delay_ms(500);
    while ((SysTick->CTRL & 0x00010000)==0);
    SysTick->CTRL = 0;
    
    • 1
    • 2
    • 3

    在非阻塞状态下 可以提交定时器后 去做别的事情 然后再来等待

    不过这样又有一个弊端 那就是定时器会自动重载 可能做别的事情以后 定时器跑过了 然后就要等85s才能停下

    故可以通过内部定时器来进行非阻塞延时函数的编写

    基本上每个mcu的内部定时器都可以配置自动重载等功能 网上资料很多 这里就不再阐述了

    位带操作

    位带代码

    M3、M4架构的单片机 其输出口地址为端口地址+20 输入为+16
    M0架构的单片机 其输出口地址为端口地址+12 输入为+8
    以ADuCM4050为列:

    位带宏定义
    #ifndef __GPIO_H__
    #define __GPIO_H__
    #include "ADuCM4050.h"
    #include "adi_gpio.h"
    
    #define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
    #define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
    #define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum))
    
    #define GPIO0_ODR_Addr    (ADI_GPIO0_BASE+20) //0x40020014
    #define GPIO0_IDR_Addr    (ADI_GPIO0_BASE+16) //0x40020010
    
    #define GPIO1_ODR_Addr    (ADI_GPIO1_BASE+20) //0x40020054
    #define GPIO1_IDR_Addr    (ADI_GPIO1_BASE+16) //0x40020050
    
    #define GPIO2_ODR_Addr    (ADI_GPIO2_BASE+20) //0x40020094
    #define GPIO2_IDR_Addr    (ADI_GPIO2_BASE+16) //0x40020090
    
    #define GPIO3_ODR_Addr    (ADI_GPIO3_BASE+20) //0x400200D4
    #define GPIO3_IDR_Addr    (ADI_GPIO3_BASE+16) //0x400200D0
    
    #define P0_O(n)   	BIT_ADDR(GPIO0_ODR_Addr,n)  //输出 
    #define P0_I(n)    	BIT_ADDR(GPIO0_IDR_Addr,n)  //输入 
    
    #define P1_O(n)   	BIT_ADDR(GPIO1_ODR_Addr,n)  //输出 
    #define P1_I(n)    	BIT_ADDR(GPIO1_IDR_Addr,n)  //输入 
    
    #define P2_O(n)   	BIT_ADDR(GPIO2_ODR_Addr,n)  //输出 
    #define P2_I(n)    	BIT_ADDR(GPIO2_IDR_Addr,n)  //输入 
    
    #define P3_O(n)   	BIT_ADDR(GPIO3_ODR_Addr,n)  //输出 
    #define P3_I(n)    	BIT_ADDR(GPIO3_IDR_Addr,n)  //输入 
    
    #define Port0			(ADI_GPIO_PORT0)
    #define Port1			(ADI_GPIO_PORT1)
    #define Port2			(ADI_GPIO_PORT2)
    #define Port3			(ADI_GPIO_PORT3)
    
    #define Pin0			(ADI_GPIO_PIN_0)
    #define Pin1			(ADI_GPIO_PIN_1)
    #define Pin2			(ADI_GPIO_PIN_2)
    #define Pin3			(ADI_GPIO_PIN_3)
    #define Pin4			(ADI_GPIO_PIN_4)
    #define Pin5			(ADI_GPIO_PIN_5)
    #define Pin6			(ADI_GPIO_PIN_6)
    #define Pin7			(ADI_GPIO_PIN_7)
    #define Pin8			(ADI_GPIO_PIN_8)
    #define Pin9			(ADI_GPIO_PIN_9)
    #define Pin10			(ADI_GPIO_PIN_10)
    #define Pin11			(ADI_GPIO_PIN_11)
    #define Pin12			(ADI_GPIO_PIN_12)
    #define Pin13			(ADI_GPIO_PIN_13)
    #define Pin14			(ADI_GPIO_PIN_14)
    #define Pin15			(ADI_GPIO_PIN_15)
    
    void GPIO_OUT(unsigned int port,unsigned int pin,unsigned int flag);
    void GPIO_BUS_OUT(unsigned int port,unsigned int num);
    
    void P0_BUS_O(unsigned int num);
    unsigned int P0_BUS_I(void);
    
    void P1_BUS_O(unsigned int num);
    unsigned int P1_BUS_I(void);
    
    void P2_BUS_O(unsigned int num);
    unsigned int P2_BUS_I(void);
    
    void P3_BUS_O(unsigned int num);
    unsigned int P3_BUS_I(void);
    
    #endif
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    总线函数
    #include "ADuCM4050.h"
    #include "adi_gpio.h"
    #include "GPIO.h"
    
    void GPIO_OUT(unsigned int port,unsigned int pin,unsigned int flag)
    {
    	switch(port)
    	{
    		case 0:{
    			switch(pin)
    			{
    				case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_0));};break;
    				case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_1));};break;
    				case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_2));};break;
    				case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_3));};break;
    				case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_4));};break;
    				case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_5));};break;
    				case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_6));};break;
    				case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_7));};break;
    				case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_8));};break;
    				case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_9));};break;
    				case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_10));};break;
    				case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_11));};break;
    				case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_12));};break;
    				case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_13));};break;
    				case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_14));};break;
    				case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_15));};break;
    				default:pin=0;break;
    			}
    		}break;
    		
    		case 1:{
    			switch(pin)
    			{
    				case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_0));};break;
    				case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_1));};break;
    				case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_2));};break;
    				case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_3));};break;
    				case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_4));};break;
    				case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_5));};break;
    				case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_6));};break;
    				case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_7));};break;
    				case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_8));};break;
    				case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_9));};break;
    				case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_10));};break;
    				case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_11));};break;
    				case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_12));};break;
    				case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_13));};break;
    				case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_14));};break;
    				case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_15));};break;
    				default:pin=0;break;
    			}
    		}break;
    		
    		case 2:{
    			switch(pin)
    			{
    				case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_0));};break;
    				case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_1));};break;
    				case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_2));};break;
    				case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_3));};break;
    				case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_4));};break;
    				case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_5));};break;
    				case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_6));};break;
    				case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_7));};break;
    				case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_8));};break;
    				case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_9));};break;
    				case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_10));};break;
    				case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_11));};break;
    				case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_12));};break;
    				case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_13));};break;
    				case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_14));};break;
    				case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_15));};break;
    				default:pin=0;break;
    			}
    		}break;
    		
    		case 3:{
    			switch(pin)
    			{
    				case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_0));};break;
    				case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_1));};break;
    				case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_2));};break;
    				case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_3));};break;
    				case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_4));};break;
    				case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_5));};break;
    				case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_6));};break;
    				case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_7));};break;
    				case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_8));};break;
    				case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_9));};break;
    				case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_10));};break;
    				case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_11));};break;
    				case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_12));};break;
    				case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_13));};break;
    				case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_14));};break;
    				case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_15));};break;
    				default:pin=0;break;
    			}
    		}break;
    		
    		default:port=0;break;
    	}	
    }
    
    void GPIO_BUS_OUT(unsigned int port,unsigned int num)  //num最大为0xffff
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		GPIO_OUT(port,i,(num>>i)&0x0001);
    	}
    }
    
    
    void P0_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		P0_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int P0_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(P0_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    void P1_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		P1_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int P1_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(P1_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    void P2_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		P2_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int P2_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(P2_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    void P3_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		P3_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int P3_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(P3_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190

    一、位带操作理论及实践

    位带操作的概念其实30年前就有了,那还是 CM3 将此能力进化,这里的位带操作是 8051 位寻址区的威力大幅加强版

    位带区: 支持位带操作的地址区

    位带别名: 对别名地址的访问最终作 用到位带区的访问上(注意:这中途有一个 地址映射过程)

    位带操作对于硬件 I/O 密集型的底层程序最有用处

    支持了位带操作后,可以使用普通的加载/存储指令来对单一的比特进行读写。在CM4中,有两个区中实现了位带。其中一个是SRAM区的最低1MB范围,第二个则是片内外设区的最低1MB范围。这两个区中的地址除了可以像普通的RAM一样使用外,它们还都有自己的“位带别名区”,位带别名区把每个比特膨胀成一个32位的字。当你通过位带别名区访问这些字时,就可以达到访问原始比特的目的。

    位操作就是可以单独的对一个比特位读和写,类似与51中sbit定义的变量,stm32中通过访问位带别名区来实现位操作的功能
    STM32中有两个地方实现了位带,一个是SRAM,一个是片上外设。
    在这里插入图片描述
    (1)位带本质上是一块地址区(例如每一位地址位对应一个寄存器)映射到另一片地址区(实现每一位地址位对应一个寄存器中的一位),该区域就叫做位带别名区,将每一位膨胀成一个32位的字。
    (2)位带区的4个字节对应实际寄存器或内存区的一个位,虽然变大到4个字节,但实际上只有最低位有效(代表0或1)

    只有位带可以直接用=赋值的方式来操作寄存器 位带是把寄存器上的每一位 膨胀到32位 映射到位带区 比如0x4002 0000地址的第0个bit 映射到位带区的0地址 那么其对应的位带映射地址为0x00 - 0x04 一共32位 但只有LSB有效 采用位带的方式用=赋值时 就是把位带区对应的LSB赋值 然后MCU再转到寄存器对应的位里面 寄存器操作时 如果不改变其他位上面的值 那就只能通过&=或者|=的方式进行

    在这里插入图片描述

    要设置0x2000 0000这个字节的第二个位bit2为1,使用位带操作的步骤有:
    1、将1写入位 带别名区对应的映射地址(即0x22000008,因为1bit对应4个byte);
    2、将0x2000 0000的值 读取到内部的缓冲区(这一步骤是内核完成的,属于原子操作,不需要用户操作);
    3、将bit2置1,再把值写 回到0x2000 0000(属于原子操作,不需要用户操作)。

    关于GPIO引脚对应的访问地址,可以参考以下公式
    寄存器位带别名 = 0x42000000 + (寄存器的地址-0x40000000)32 + 引脚编号4

    如:端口F访问的起始地址GPIOF_BASE

    #define GPIOF ((GPIO_TypeDef *)GPIOF_BASE)

    在这里插入图片描述

    但好在官方库里面都帮我们定义好了 只需要在BASE地址加上便宜即可

    例如:

    GPIOF的ODR寄存器的地址 = GPIOF_BASE + 0x14

    寄存器位带别名 = 0x42000000 + (寄存器的地址-0x40000000)32 + 引脚编号4

    设置PF9引脚的话:

    uint32_t *PF9_BitBand =
    *(uint32_t *)(0x42000000 + ((uint32_t )&GPIOF->ODR– 0x40000000) *32 + 9*4)
    
    
    • 1
    • 2
    • 3

    封装一下:

    #define PFout(x) *(volatile uint32_t *)(0x42000000 + ((uint32_t )&GPIOF->ODR – 0x40000000) *32 + x*4)
    
    
    • 1
    • 2

    现在 可以把通用部分封装成一个小定义:

    #define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
    #define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
    #define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum))
    
    • 1
    • 2
    • 3

    那么 设置PF引脚的函数可以定义:

    #define GPIOF_ODR_Addr    (GPIOF_BASE+20) //0x40021414   
    #define GPIOF_IDR_Addr    (GPIOF_BASE+16) //0x40021410 
    
    #define PF_O(n)   	BIT_ADDR(GPIOF_ODR_Addr,n)  //输出 
    #define PF_I(n)    	BIT_ADDR(GPIOF_IDR_Addr,n)  //输入
    
    • 1
    • 2
    • 3
    • 4
    • 5

    若使PF9输入输出则:

    PF_O(9)=1;  //输出高电平
    uint8_t dat = PF_I(9);  //获取PF9引脚的值
    
    • 1
    • 2

    总线输入输出:

    void PF_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		PF_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int PF_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(PF_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    STM32的可用下面的函数:

    #ifndef __GPIO_H__
    #define __GPIO_H__
    #include "stm32l496xx.h"
    
    #define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
    #define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
    #define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum))
    
    #define GPIOA_ODR_Addr    (GPIOA_BASE+20) //0x40020014
    #define GPIOB_ODR_Addr    (GPIOB_BASE+20) //0x40020414 
    #define GPIOC_ODR_Addr    (GPIOC_BASE+20) //0x40020814 
    #define GPIOD_ODR_Addr    (GPIOD_BASE+20) //0x40020C14 
    #define GPIOE_ODR_Addr    (GPIOE_BASE+20) //0x40021014 
    #define GPIOF_ODR_Addr    (GPIOF_BASE+20) //0x40021414    
    #define GPIOG_ODR_Addr    (GPIOG_BASE+20) //0x40021814   
    #define GPIOH_ODR_Addr    (GPIOH_BASE+20) //0x40021C14    
    #define GPIOI_ODR_Addr    (GPIOI_BASE+20) //0x40022014     
    
    #define GPIOA_IDR_Addr    (GPIOA_BASE+16) //0x40020010 
    #define GPIOB_IDR_Addr    (GPIOB_BASE+16) //0x40020410 
    #define GPIOC_IDR_Addr    (GPIOC_BASE+16) //0x40020810 
    #define GPIOD_IDR_Addr    (GPIOD_BASE+16) //0x40020C10 
    #define GPIOE_IDR_Addr    (GPIOE_BASE+16) //0x40021010 
    #define GPIOF_IDR_Addr    (GPIOF_BASE+16) //0x40021410 
    #define GPIOG_IDR_Addr    (GPIOG_BASE+16) //0x40021810 
    #define GPIOH_IDR_Addr    (GPIOH_BASE+16) //0x40021C10 
    #define GPIOI_IDR_Addr    (GPIOI_BASE+16) //0x40022010 
     
    #define PA_O(n)   	BIT_ADDR(GPIOA_ODR_Addr,n)  //输出 
    #define PA_I(n)    	BIT_ADDR(GPIOA_IDR_Addr,n)  //输入 
    
    #define PB_O(n)   	BIT_ADDR(GPIOB_ODR_Addr,n)  //输出 
    #define PB_I(n)    	BIT_ADDR(GPIOB_IDR_Addr,n)  //输入 
    
    #define PC_O(n)   	BIT_ADDR(GPIOC_ODR_Addr,n)  //输出 
    #define PC_I(n)    	BIT_ADDR(GPIOC_IDR_Addr,n)  //输入 
    
    #define PD_O(n)   	BIT_ADDR(GPIOD_ODR_Addr,n)  //输出 
    #define PD_I(n)    	BIT_ADDR(GPIOD_IDR_Addr,n)  //输入 
    
    #define PE_O(n)   	BIT_ADDR(GPIOE_ODR_Addr,n)  //输出 
    #define PE_I(n)    	BIT_ADDR(GPIOE_IDR_Addr,n)  //输入
    
    #define PF_O(n)   	BIT_ADDR(GPIOF_ODR_Addr,n)  //输出 
    #define PF_I(n)    	BIT_ADDR(GPIOF_IDR_Addr,n)  //输入
    
    #define PG_O(n)   	BIT_ADDR(GPIOG_ODR_Addr,n)  //输出 
    #define PG_I(n)    	BIT_ADDR(GPIOG_IDR_Addr,n)  //输入
    
    #define PH_O(n)   	BIT_ADDR(GPIOH_ODR_Addr,n)  //输出 
    #define PH_I(n)    	BIT_ADDR(GPIOH_IDR_Addr,n)  //输入
    
    #define PI_O(n)			BIT_ADDR(GPIOI_ODR_Addr,n)  //输出 
    #define PI_I(n)   	BIT_ADDR(GPIOI_IDR_Addr,n)  //输入
    
    void PA_BUS_O(unsigned int num);
    unsigned int PA_BUS_I(void);
    
    void PB_BUS_O(unsigned int num);
    unsigned int PB_BUS_I(void);
    
    void PC_BUS_O(unsigned int num);
    unsigned int PC_BUS_I(void);
    
    void PD_BUS_O(unsigned int num);
    unsigned int PD_BUS_I(void);
    
    void PE_BUS_O(unsigned int num);
    unsigned int PE_BUS_I(void);
    
    void PF_BUS_O(unsigned int num);
    unsigned int PF_BUS_I(void);
    
    void PG_BUS_O(unsigned int num);
    unsigned int PG_BUS_I(void);
    
    void PH_BUS_O(unsigned int num);
    unsigned int PH_BUS_I(void);
    
    void PI_BUS_O(unsigned int num);
    unsigned int PI_BUS_I(void);
    
    #endif
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    #include "GPIO.h"
    
    void PA_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		PA_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int PA_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(PA_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    void PB_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		PB_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int PB_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(PB_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    void PC_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		PC_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int PC_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(PC_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    void PD_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		PD_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int PD_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(PD_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    void PE_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		PE_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int PE_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(PE_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    void PF_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		PF_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int PF_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(PF_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    void PG_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		PG_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int PG_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(PG_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    void PH_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		PH_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int PH_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(PH_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    void PI_BUS_O(unsigned int num)  //输入值num最大为0xFFFF
    {
    	int i;
    	for(i=0;i<16;i++)
    	{
    		PI_O(i)=(num>>i)&0x0001;
    	}
    }
    unsigned int PI_BUS_I(void)  //输出值num最大为0xFFFF
    {
    	unsigned int num;
    	int i;
    	for(i=0;i<16;i++)
    	{
    		num=num+(PI_I(i)<<i)&0xFFFF;
    	}
    	return num;
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173

    二、如何判断MCU的外设是否支持位带

    根据《ARM Cortex-M3与Cortex-M4权威指南(第3版)》中第6章第7节描述
    在这里插入图片描述
    也就是说 要实现对GPIO的位带操作 必须保证GPIO位于外设区域的第一个1MB中
    第一个1MB应该是0x4010 0000之前 位带不是直接操作地址 而是操作地址映射 地址映射被操作以后 MCU自动会修改对应寄存器的值

    位带区只有1MB 所以只能改0x4000 0000 - 0x400F FFFF的寄存器
    像F4系列 GPIO的首地址为0x4002 0000 就可以用位带来更改

    STM32L476的GPIO就不行:
    在这里插入图片描述
    AHB2的都不能用位带
    ABP 还有AHB1都可以用
    在这里插入图片描述
    但是L476的寄存器里面 GPIO和ADC都是AHB2

  • 相关阅读:
    Kubernetes存储:Ceph架构,部署和使用
    C++代码示例:组合数简单生成工具
    精进 JavaScript | 这些手写你都会吗 ?
    actuator--基础--6.2--端点解析--metrics端点
    flutter开发实战-StreamBuilder使用介绍及实例
    Mybatis框架学习
    单例模式(懒汉式,饿汉式,变体)
    Github每日精选(第30期):javascript 日期时间选择器flatpickr
    算法刷题笔记 食物链(详细注释的C++实现)
    谷歌浏览器安装 vue-devtools 拓展,仅需3分钟,提供插件
  • 原文地址:https://blog.csdn.net/weixin_53403301/article/details/126417940