C语言 cortex-A7核 点LED灯 （附 汇编实现、使用C语言 循环实现、使用C语言 封装函数实现【重要、常用】）

已于 2023-09-21 21:13:36 修改
阅读量583 收藏
点赞数 1
分类专栏： ARM 文章标签： c语言 汇编 开发语言
于 2023-09-19 19:43:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Smallxu_/article/details/133043051
版权

1 汇编实现


text
global _start
start:
************** LED1点灯 ---> PE10 **************/
************** RCC章节初始化 **************/
CC_INIT:
   @1.使能GPIOE组控制器，通过RCC_MP_AHB4ENSETR寄存器设置GPIOE组使能0x50000A28[4]= 1
   ldr r0,=0x50000A28       @准备一块地址空间0x50000A28
   ldr r1,[r0]              @将0x50000A28这块地址中的内容，读到目标寄存器r1中
   orr r1,r1,#(0x3 << 4)    @将r1寄存器第[5:4] = 11，保证其他位不变 
   str r1,[r0]              @将r1寄存器中的值，写回0x50000A28这块地址空间中

************** LED1对应GPIO章节初始化 **************/
ED1_INIT:
   @1.通过GPIOE_MODER寄存器，设置PE10引脚为 输出模式 0x50006000[21:20] = 01
   ldr r0,=0x50006000
   ldr r1,[r0]
   orr r1,r1,#(0x3 << 20)
   and r1,r1,#(~(0x1 << 21))
   str r1,[r0]

   @2.通过GPIOE_OTYPER寄存器，设置PE10引脚为 推挽输出类型 0x50006004[10] = 0
   ldr r0,=0x50006004
   ldr r1,[r0]
   and r1,r1,#(~(0x1 << 10))
   str r1,[r0]

   @3.通过GPIOE_OSPEEDR寄存器，设置PE10引脚为 低速输出 0x50006008[21:20] = 00
   ldr r0,=0x50006008
   ldr r1,[r0]
   and r1,r1,#(~(0x3 << 20))
   str r1,[r0]

   @4.通过GPIOE_PUPDR寄存器，设置PE10引脚 禁止上下拉电阻 0x5000600C[21:20] = 00
   ldr r0,=0x5000600C
   ldr r1,[r0]
   and r1,r1,#(~(0x3 << 20))
   str r1,[r0]

************** LED2对应GPIO章节初始化 **************/
ED2_INIT:
   @1.通过GPIOE_MODER寄存器，设置PF10引脚为 输出模式 0x50007000[21:20] = 01
   ldr r0,=0x50007000
   ldr r1,[r0]
   orr r1,r1,#(0x3 << 20)
   and r1,r1,#(~(0x1 << 21))
   str r1,[r0]

   @2.通过GPIOE_OTYPER寄存器，设置PF10引脚为 推挽输出类型 0x50007004[10] = 0
   ldr r0,=0x50007004
   ldr r1,[r0]
   and r1,r1,#(~(0x1 << 10))
   str r1,[r0]

   @3.通过GPIOE_OSPEEDR寄存器，设置PF10引脚为 低速输出 0x50007008[21:20] = 00
   ldr r0,=0x50007008
   ldr r1,[r0]
   and r1,r1,#(~(0x3 << 20))
   str r1,[r0]

   @4.通过GPIOE_PUPDR寄存器，设置PF10引脚 禁止上下拉电阻 0x5000700C[21:20] = 00
   ldr r0,=0x5000700C
   ldr r1,[r0]
   and r1,r1,#(~(0x3 << 20))
   str r1,[r0]

   /************** LED3对应GPIO章节初始化 **************/
ED3_INIT:
   @1.通过GPIOE_MODER寄存器，设置PE8引脚为 输出模式 0x50006000[17:16] = 01
   ldr r0,=0x50006000
   ldr r1,[r0]
   orr r1,r1,#(0x3 << 16)
   and r1,r1,#(~(0x1 << 17))
   str r1,[r0]

   @2.通过GPIOE_OTYPER寄存器，设置PE8引脚为 推挽输出类型 0x50006004[8] = 0
   ldr r0,=0x50006004
   ldr r1,[r0]
   and r1,r1,#(~(0x1 << 8))
   str r1,[r0]

   @3.通过GPIOE_OSPEEDR寄存器，设置PE8引脚为 低速输出 0x50006008[17:16] = 00
   ldr r0,=0x50006008
   ldr r1,[r0]
   and r1,r1,#(~(0x3 << 16))
   str r1,[r0]

   @4.通过GPIOE_PUPDR寄存器，设置PE8引脚 禁止上下拉电阻 0x5000600C[17:16] = 00
   ldr r0,=0x5000600C
   ldr r1,[r0]
   and r1,r1,#(~(0x3 <<16))
   str r1,[r0]

oop:
   bl LED1_ON
   bl delay_1s
   bl LED1_OFF
   bl delay_1s

   bl LED2_ON
   bl delay_1s
   bl LED2_OFF
   bl delay_1s

   bl LED3_ON                                                                                                                   
   bl delay_1s
   bl LED3_OFF
   bl delay_1s

   b Loop

   /************** LED1点亮 **************/
ED1_ON:
   @1.通过GPIOE_ODR寄存器，设置PE10引脚输出高电平 0x50006014[10] = 1
   ldr r0,=0x50006014
   ldr r1,[r0]
   orr r1,r1,#(0x1 << 10)
   str r1,[r0]
   mov pc,lr
   /************** LED1熄灭 **************/
ED1_OFF:
   @1.通过GPIOE_ODR寄存器，设置PE10引脚输出低电平 0x50006014[10] = 0
   ldr r0,=0x50006014
   ldr r1,[r0]
   bic r1,r1,#(0x1 << 10)
   str r1,[r0]
   mov pc,lr

   /************** LED2点亮 **************/
ED2_ON:
   @1.通过GPIOF_ODR寄存器，设置PE10引脚输出高电平 0x50007014[10] = 1
   ldr r0,=0x50007014
   ldr r1,[r0]
   orr r1,r1,#(0x1 << 10)
   str r1,[r0]
   mov pc,lr
   /************** LED2熄灭 **************/
ED2_OFF:
   @1.通过GPIOF_ODR寄存器，设置PE10引脚输出低电平 0x50006014[10] = 0
   ldr r0,=0x50007014
   ldr r1,[r0]
   bic r1,r1,#(0x1 << 10)
   str r1,[r0]
   mov pc,lr

   /************** LED3点亮 **************/
ED3_ON:
   @1.通过GPIOF_ODR寄存器，设置PE10引脚输出高电平 0x50006014[8] = 1
   ldr r0,=0x50006014
   ldr r1,[r0]
   orr r1,r1,#(0x1 << 8)
   str r1,[r0]
   mov pc,lr
   /************** LED3熄灭 **************/
ED3_OFF:
   @1.通过GPIOE_ODR寄存器，设置PE10引脚输出低电平 0x50006014[8] = 0
   ldr r0,=0x50006014
   ldr r1,[r0]
   bic r1,r1,#(0x1 << 8)
   str r1,[r0]
   mov pc,lr

 大概1s的延时函数
elay_1s:
   mov r3, #0x10000000
   mm:
   cmp r3, #0
   subne r3, r3, #1
   bne mm
   mov pc, lr
end

2 C语言实现

led.h

#ifndef __LED_H__                                                 
#define __LED_H__                                                 
                                                                  
//结构体封装                                                      
typedef struct{                                                   
    volatile unsigned int MODER;                                  
    volatile unsigned int OTYPER;                                 
    volatile unsigned int OSPEEDR;                                
    volatile unsigned int PUPDR;                                  
    volatile unsigned int IDR;                                    
    volatile unsigned int ODR;                                    
}gpio_t;                                                          
                                                                  
#define GPIOE ((gpio_t*)0x50006000)                               
#define GPIOF ((gpio_t*)0x50007000)                               
#define RCC_MP_AHB4_ENSETR (*(volatile unsigned int*)0x50000A28)  
                                                                  
//LED1  ===>  PE10                                                
//RCC/GPIO章节初始化                                              
void led1_rcc_gpio_init();                                        
//LED1点亮                                                        
void led1_on();                                                   
//LED1熄灭                                                        
void led1_off();                                                  
//LED1  ===>  PE10                                                
                                                                  
//LED2 ===> PF10                                                  
//RCC/GPIO章节初始化                                              
void led2_rcc_gpio_init();                                        
//LED2点亮                                                        
void led2_on();                                                   
//LED2熄灭                                                        
void led2_off();                                                  
                                                                  
//LED3  ===>  PE8                                                 
//RCC/GPIO章节初始化                                              
void led3_rcc_gpio_init();                                        
//LED3点亮                                                        
void led3_on();                                                   
//LED3熄灭                                                        
void led3_off();                                                  
#endif

led.c

#include "led.h"                                                                                 
                                                                                                 
//LED1 ---> PE10                                                                                 
//RCC/GPIO章节初始化                                                                             
void led1_rcc_gpio_init()                                                                        
{                                                                                                
    //0、使能GPIOE组控制器，通过RCC_MP_AHB4_ENSETR寄存器设置GPIOE组使能0x50000A28[4] = 1         
    RCC_MP_AHB4_ENSETR |= (0X1 << 4);                                                            
    //1、通过GPIOE_MODER寄存器，设置PE10引脚为输出模式 0x50006000[21:20] = 01                    
    GPIOE->MODER &= (~(0x1 << 21));  //21位清0                                                   
    GPIOE->MODER |= (0x1 << 20);     //20位置1                                                   
    //2、通过GPIOE_OTYPER寄存器，设置PE10引脚为推挽输出类型 0x50006004[10] = 0                   
    GPIOE->OTYPER &= (~(0x1 << 10));                                                             
    //3、通过GPIOE_OSPEEDR寄存器，设置PE10引脚为低速输出 0x50006008[21:20] = 00                  
    GPIOE->OSPEEDR &= (~(0x3 << 20));                                                            
    //4、通过GPIOE_PUPDR寄存器，设置PE10引脚禁止上下拉电阻 0x5000600C[21:20] = 00                
    GPIOE->PUPDR &= (~(0x3 << 20));                                                              
}                                                                                                
                                                                                                 
//LED1点亮                                                                                       
void led1_on()                                                                                   
{                                                                                                
    //通过GPIOE_ODR寄存器，设置PE10引脚输出高电平 0x50006014[10] = 1                             
    GPIOE->ODR |= (0x1 << 10);                                                                   
}                                                                                                
//LED1熄灭                                                                                       
void led1_off()                                                                                  
{                                                                                                
    //通过GPIOE_ODR寄存器，设置PE10引脚输出低电平 0x50006014[10] = 0                             
    GPIOE->ODR &= (~(0x1) << 10);                                                                
}                                                                                                
                                                                                                 
//LED2 ---> PF10                                                                                 
//RCC/GPIO章节初始化                                                                             
void led2_rcc_gpio_init()                                                                        
{                                                                                                
    //0、使能GPIOE组控制器，通过RCC_MP_AHB4_ENSETR寄存器设置GPIOE组使能0x50000A28[5] = 1         
    RCC_MP_AHB4_ENSETR |= (0X1 << 5);                                                            
    //1、通过GPIOF_MODER寄存器，设置PF10引脚为输出模式 0x50007000[21:20] = 01                    
    GPIOF->MODER &= (~(0x1 << 21));  //21位清0                                                   
    GPIOF->MODER |= (0x1 << 20);     //20位置1                                                   
    //2、通过GPIOE_OTYPER寄存器，设置PF10引脚为推挽输出类型 0x50007004[10] = 0                   
    GPIOF->OTYPER &= (~(0x1 << 10));                                                             
    //3、通过GPIOE_OSPEEDR寄存器，设置PF10引脚为低速输出 0x50007008[21:20] = 00                  
    GPIOF->OSPEEDR &= (~(0x3 << 20));                                                            
    //4、通过GPIOE_PUPDR寄存器，设置PF10引脚禁止上下拉电阻 0x5000700C[21:20] = 00                
    GPIOF->PUPDR &= (~(0x3 << 20));                                                              
}                                                                                                
                                                                                                 
//LED2点亮                                                                                       
void led2_on()                                                                                   
{                                                                                                
    //通过GPIOF_ODR寄存器，设置PF10引脚输出高电平 0x50007014[10] = 1                             
    GPIOF->ODR |= (0x1 << 10);                                                                   
}                                                                                                
//LED2熄灭                                                                                       
void led2_off()                                                                                  
{                                                                                                
    //通过GPIOF_ODR寄存器，设置PF10引脚输出低电平 0x50007014[10] = 0                             
    GPIOF->ODR &= (~(0x1) << 10);                                                                
}                                                                                                
                                                                                                 
//LED3 ---> PE8                                                                                  
//RCC/GPIO章节初始化                                                                             
void led3_rcc_gpio_init()                                                                        
{                                                                                                
    //0、使能GPIOE组控制器，通过RCC_MP_AHB4_ENSETR寄存器设置GPIOE组使能0x50000A28[4] = 1         
    RCC_MP_AHB4_ENSETR |= (0X1 << 4);                                                            
    //1、通过GPIOE_MODER寄存器，设置PE10引脚为输出模式 0x50006000[17:16] = 01                    
    GPIOE->MODER &= (~(0x1 << 17));  //17位清0                                                   
    GPIOE->MODER |= (0x1 << 16);     //16位置1                                                   
    //2、通过GPIOE_OTYPER寄存器，设置PE10引脚为推挽输出类型 0x50006004[8] = 0                    
    GPIOE->OTYPER &= (~(0x1 << 8));                                                              
    //3、通过GPIOE_OSPEEDR寄存器，设置PE10引脚为低速输出 0x50006008[17:16] = 00                  
    GPIOE->OSPEEDR &= (~(0x3 << 16));                                                            
    //4、通过GPIOE_PUPDR寄存器，设置PE10引脚禁止上下拉电阻 0x5000600C[17:16] = 00                
    GPIOE->PUPDR &= (~(0x3 << 16));                                                              
}                                                                                                
                                                                                                 
//LED1点亮                                                                                       
void led3_on()                                                                                   
{                                                                                                
    //通过GPIOE_ODR寄存器，设置PE10引脚输出高电平 0x50006014[8] = 1                              
    GPIOE->ODR |= (0x1 << 8);                                                                    
}                                                                                                
//LED1熄灭                                                                                       
void led3_off()                                                                                  
{                                                                                                
    //通过GPIOE_ODR寄存器，设置PE10引脚输出低电平 0x50006014[8] = 0                              
    GPIOE->ODR &= (~(0x1) << 8);                                                                 
}

main.c

#include "led.h"
extern void printf(const char *fmt, ...);
void delay_ms(int ms)
{
    int i,j;
    for(i = 0; i < ms;i++)
        for (j = 0; j < 1800; j++);
}


int main()
{
    led1_rcc_gpio_init(); // LED灯初始化
    led2_rcc_gpio_init(); // LED灯初始化
    led3_rcc_gpio_init(); // LED灯初始化
    while(1)
    {
        led1_on();
        delay_ms(500);
        led1_off();
        delay_ms(500);

        led2_on();
        delay_ms(500);
        led2_off();
        delay_ms(500);
                                                     
        led3_on();
        delay_ms(500);
        led3_off();
        delay_ms(500);
    }
    return 0;
}

3 循环实现

led.h

#ifndef __LED_H__                                                 
#define __LED_H__                                                 
                                                                  
#define RCC_MP_AHB4_ENSETR (*(volatile unsigned int*)0x50000A28)  
                                                                  
//结构体封装                                                      
typedef struct{                                                   
    volatile unsigned int MODER;                                  
    volatile unsigned int OTYPER;                                 
    volatile unsigned int OSPEEDR;                                
    volatile unsigned int PUPDR;                                  
    volatile unsigned int IDR;                                    
    volatile unsigned int ODR;                                    
}gpio_t;                                                          
                                                                  
typedef enum{                                                     
    LED_OFF=0,                                                    
    LED_ON,                                                       
}LED_C;                                                           
                                                                  
typedef enum{                                                     
    LED1=0,                                                       
    LED2,                                                         
    LED3                                                          
}LED;                                                             
                                                                  
#define GPIOE ((gpio_t*)0x50006000)                               
#define GPIOF ((gpio_t*)0x50007000)                               
                                                                  
void led_init(LED l);                                             
void led_con(LED l,LED_C c);                                      
#endif

led.c

#include "led.h"                                         
//初始化灯                                               
void led_init(LED led)                                   
{                                                        
    switch(led)                                          
    {                                                    
    case LED1:                                           
        RCC_MP_AHB4_ENSETR |= (0X1 << 4);                
        GPIOE->MODER &= (~(0x1 << 21));  //21位清0       
        GPIOE->MODER |= (0x1 << 20);     //20位置1       
        GPIOE->OTYPER &= (~(0x1 << 10));                 
        GPIOE->OSPEEDR &= (~(0x3 << 20));                
        GPIOE->PUPDR &= (~(0x3 << 20));                  
        break;                                           
    case LED2:                                           
        RCC_MP_AHB4_ENSETR |= (0X1 << 5);                
        GPIOF->MODER &= (~(0x1 << 21));  //21位清0       
        GPIOF->MODER |= (0x1 << 20);     //20位置1       
        GPIOF->OTYPER &= (~(0x1 << 10));                 
        GPIOF->OSPEEDR &= (~(0x3 << 20));                
        GPIOF->PUPDR &= (~(0x3 << 20));                  
        break;                                           
    case LED3:                                           
        RCC_MP_AHB4_ENSETR |= (0X1 << 4);                
        GPIOE->MODER &= (~(0x1 << 17));  //17位清0       
        GPIOE->MODER |= (0x1 << 16);     //16位置1       
        GPIOE->OTYPER &= (~(0x1 << 8));                  
        GPIOE->OSPEEDR &= (~(0x3 << 16));                
        GPIOE->PUPDR &= (~(0x3 << 16));                  
        break;                                           
    }                                                    
}                                                        
//控制灯                                                 
void led_con(LED led,LED_C c)                            
{                                                        
    switch(led)                                          
    {                                                    
    case LED1:                                           
        switch(c)                                        
        {                                                
        case LED_OFF:                                    
            GPIOE->ODR &= (~(0X1 << 10));                
            break;                                       
        case LED_ON:                                     
            GPIOE->ODR |= (0X1 << 10);                   
            break;                                       
        }                                                
        break;                                           
    case LED2:                                           
        switch(c)                                        
        {                                                
        case LED_OFF:                                    
            GPIOF->ODR &= (~(0X1 << 10));                
            break;                                       
        case LED_ON:                                     
            GPIOF->ODR |= (0X1 << 10);                   
            break;                                       
        }                                                
        break;                                           
    case LED3:                                           
        switch(c)                                        
        {                                                
        case LED_OFF:                                    
            GPIOE->ODR &= (~(0X1 << 8));                 
            break;                                       
        case LED_ON:                                     
            GPIOE->ODR |= (0X1 << 8);                    
            break;                                       
        }                                                
        break;                                           
    }                                                    
}

main.c

#include "led.h"
extern void printf(const char *fmt, ...);
void delay_ms(int ms)
{
    int i,j;
    for(i = 0; i < ms;i++)
        for (j = 0; j < 1800; j++);
}


int main()
{
    led_init(LED1);
    led_init(LED2);
    led_init(LED3);
    while(1)
    {
        led_con(LED1,LED_ON);
        delay_ms(200);
        led_con(LED1,LED_OFF);
        delay_ms(200);

        led_con(LED2,LED_ON);
        delay_ms(200);
        led_con(LED2,LED_OFF);
        delay_ms(200);

        led_con(LED3,LED_ON);
        delay_ms(200);
        led_con(LED3,LED_OFF);
        delay_ms(200);
    }
    return 0;
}

4 封装函数实现【重要】【常用】

初始化函数函数===>函数参数、函数实现

led.h

#ifndef __LED_H__
#define __LED_H__

//LED1 ---> PE10
//LED2 ---> PF10
//LED3 ---> PE8

//结构体封装
typedef struct{
	volatile unsigned int MODER; //0x00
	volatile unsigned int OTYPER; //0x04
	volatile unsigned int OSPEEDR; //0x08
	volatile unsigned int PUPDR; //0x0c
	volatile unsigned int IDR; //0x10
	volatile unsigned int ODR; //0x14
}gpio_t;

//GPIOE组基地址 0x50006000
#define GPIOE ((gpio_t*)0x50006000)

//GPIOF组基地址 0x50007000
#define GPIOF ((gpio_t*)0x50007000)

#define RCC_MP_AHB4ENSETR (*(volatile unsigned int*)0x50000A28)

//引脚编号封装
#define GPIO_PIN_0 0
#define GPIO_PIN_1 1
#define GPIO_PIN_2 2
#define GPIO_PIN_3 3
#define GPIO_PIN_4 4
#define GPIO_PIN_5 5
#define GPIO_PIN_6 6
#define GPIO_PIN_7 7
#define GPIO_PIN_8 8
#define GPIO_PIN_9 9
#define GPIO_PIN_10 10
#define GPIO_PIN_11 11
#define GPIO_PIN_12 12
#define GPIO_PIN_13 13
#define GPIO_PIN_14 14
#define GPIO_PIN_15 15

//模式寄存器封装
typedef enum{
	INPUT, //输入模式
	OUTPUT, //输出模式
	ALT, //复用功能模式
	ANALOG, //模拟功能模式
}gpio_moder_t;

//输出类型寄存器封装
typedef enum{
	PP, //推挽
	OD, //开漏
}gpio_otyper_t;

//输出速率寄存器封装
typedef enum{
	LOW, //低速
	MED, //中速
	HIGH, //高速
	VERY_HIGH, //快速
}gpio_ospeedr_t;

//是否需要上下拉电阻进行封装
typedef enum{
	NO_PU_PD, //禁止上下拉电阻
	PU, //上拉
	PD, //下拉
}gpio_pupdr_t;

//封装初始化结构体
typedef struct{
	gpio_moder_t moder; //模式相关寄存器
	gpio_otyper_t otyper; //输出类型寄存器
	gpio_ospeedr_t ospeedr; //输出速率寄存器
	gpio_pupdr_t pupdr; //是否需要上下拉电阻寄存器
}gpio_init_t;

//输出高低电平
typedef enum{
	GPIO_RESET_T, //低电平
	GPIO_SET_T, //高电平
}gpio_status_t;

//函数功能：gpio相关初始化工作
//参数1：GPIO组编号
//参数2：GPIO引脚编号
//参数3：初始化相关内容
//返回值：无
void hal_gpio_init(gpio_t * gpiox,unsigned int pin,gpio_init_t* init);

//函数功能：gpio写相关操作
//参数1：GPIO组编号
//参数2：GPIO引脚编号
//参数3：写值 写1高电平 写0低电平
//返回值：无
void hal_gpio_write(gpio_t* gpiox,unsigned int pin,gpio_status_t status);

#endif

led.c

#include "led.h"
void hal_gpio_init(gpio_t * gpiox,unsigned int pin,gpio_init_t* init)
{
	//设置模式
	gpiox->MODER &= (~(0x3 << (pin * 2)));
	gpiox->MODER |= (init->moder << (pin * 2));
	//设置输出类型
	gpiox->OTYPER &= (~(0x1 << pin));
	gpiox->OTYPER |= (init->otyper << pin);
	//设置输出速率
	gpiox->OSPEEDR &= (~(0x3 << pin));
	gpiox->OSPEEDR |= (init->ospeedr << pin);
	//设置是否需要上下拉电阻
	gpiox->PUPDR &= (~(0x3 << pin));
	gpiox->PUPDR |= (init->pupdr << pin);
}

void hal_gpio_write(gpio_t* gpiox,unsigned int pin,gpio_status_t status)
{
	if(status == GPIO_RESET_T)
	{
		//熄灭
		gpiox->ODR &= (~(0X1 << pin));
	}
	else
	{
		//点亮
		gpiox->ODR |= (0x1 << pin);
	}
}

main.c

#include "led.h"

extern void printf(const char *fmt, ...);

void delay_ms(int ms)

{

	int i,j;

	for(i = 0; i < ms;i++)

		for (j = 0; j < 1800; j++);

}



void led_init()

{

	//GPIOE组 / GPIOF组使能

	RCC_MP_AHB4ENSETR |= (0x3 << 4);

	//结构体初始化

	gpio_init_t init = {OUTPUT,PP,LOW,NO_PU_PD};

	hal_gpio_init(GPIOE,GPIO_PIN_10,&init);

	hal_gpio_init(GPIOF,GPIO_PIN_10,&init);

	hal_gpio_init(GPIOE,GPIO_PIN_8,&init);

}



int main()

{

	led_init(); //LED灯初始化

	while(1)

	{

		hal_gpio_write(GPIOE,GPIO_PIN_10,GPIO_SET_T);

		delay_ms(200);

		hal_gpio_write(GPIOE,GPIO_PIN_10,GPIO_RESET_T);

		delay_ms(200);

		

		hal_gpio_write(GPIOF,GPIO_PIN_10,GPIO_SET_T);

		delay_ms(200);

		hal_gpio_write(GPIOF,GPIO_PIN_10,GPIO_RESET_T);

		delay_ms(200);



		hal_gpio_write(GPIOE,GPIO_PIN_8,GPIO_SET_T);

		delay_ms(200);

		hal_gpio_write(GPIOE,GPIO_PIN_8,GPIO_RESET_T);

		delay_ms(200);

	}

	return 0;

}

徐艺桐
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cortex-A7核中断实验（库）
Satellitex的博客
08-23 84
【代码】cortex-A7核中断实验（库）
cortex-A7、M4核LED灯实验-----10.1
crispy715的博客
10-01 283
arm复习day1
Cortex-A7核按键中断实验
m0_61633791的博客
12-29 146
完成Cortex-A7核按键中断实验。
ARM - cortex-A7核/M4核按键中断实验
欢迎来到斛XX的博客
10-04 1054
ARM - cortex-A7核按键中断实验
cortex-A7核LED灯实验--STM32MP157
MaGuangming001的博客
08-25 724
实验目的：实现LED1 / LED2 / LED3三盏灯工作。
交叉编译、GNU 汇编语法、Cortex-A7 常用汇编指令、IO使用、使用汇编点亮LED
不善挽留
03-31 2651
Arm与Cortex、交叉编译简介与安装、GNU 汇编语法、Cortex-A7 常用汇编指令等。
ARM - LED灯实验（cortex A7核/cortex M4核）
欢迎来到斛XX的博客
10-02 1318
ARM - LED灯实验（cortex A7核/cortex M4核）
基于Cortex-A7架构的嵌入式linux ARM裸机开发＜2＞——LED灯闪烁（C版本）
嵌入式点灯砖家的博客
12-22 2148
文章目录一、利用汇编初始化C环境二、C语言部分实验程序编写三、Makefile程序编写四、链接脚本程序编写五、编译及烧录 利用汇编编写LED灯点亮程序我们已经实现过了，所以这里不再着重讲解基本原理，直接上C语言版实现过程了。 一、利用汇编初始化C环境 1、确定Cortex-A 处理器运行模式 我们说过 Cortex-A 有九个运行模型，这里我们设置处理器运行在 SVC 模式下。处理器模式的设置是通过修改 CPSR(程序状态)寄存器来完成的，其中 M[4:0](CPSR 的 bit[4:0])就是设置处理器运
C语言和汇编实现STM32F103点亮LED
m0_49297422的博客
10-20 1020
目录一、芯片准备1）芯片选取STM32F103C8T62)点亮流水灯原理二、C语言点亮1）keil创建项目及配置2）配置环境3）魔法棒配置4）编译5）最后成功结果三、汇编点亮四、总结五、参考链接六、需要的软件 一、芯片准备 1）芯片选取STM32F103C8T6 材料：STM32最小系统核心板(STM32F103C8T6)+面包板+3只红绿黄LED 搭建电路，使用GPIOB、GPIOC、GPIOD这3个端口控制LED灯（最高时钟2Mhz），轮流闪烁，间隔时长1.34s（这里的间隔时长是实验所得）。 STM3
C语言实现使用静态数组实现循环队列源码.zip
11-13
c语言数组 C语言实现使用静态数组实现循环队列源码.zipC语言实现使用静态数组实现循环队列源码.zipC语言实现使用静态数组实现循环队列源码.zipC语言实现使用静态数组实现循环队列源码.zip
C语言数组-C语言实现使用静态数组实现循环队列.zip
03-02
c语言数组 C语言数组_C语言实现使用静态数组实现循环队列
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
09-20
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
C语言数组-C语言实现使用动态数组来构建循环链表.zip
03-02
c语言数组
汇编语言实现对引脚底层的配置，使用C语言调用汇编语言函数进行点灯.zip
05-05
汇编语言实现对引脚底层的配置，使用C语言调用汇编语言函数进行点灯.zip汇编语言实现对引脚底层的配置，使用C语言调用汇编语言函数进行点灯.zip汇编语言实现对引脚底层的配置，使用C语言调用汇编语言函数进行点灯....
打开常用C语言常用内存函数的大门 ——memcmp函数及其模拟实现(完结篇)
tianxiawushanu的博客
06-03 594
本文讲解了memcmp函数的使用及其模拟实现。另外，本篇也是C语言常用的内存函数完结篇了，如果前面还有没看的函数，记得补一下哦！！！👍👍👍🎇
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 分月饼 (200分) - 三语言AC题解(Python/Java/Cpp)
最新发布
KK爱Coding的博客
06-07 114
🍭 大家好这里是，一枚热爱算法的程序员✨ 本系列打算持续跟新的三语言AC题解💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导。
汇编：数组定义&数据填充
WolvenSec的博客
06-04 578
在32位汇编语言中，定义数组时，通常使用定义数据指令（如DBDWDDDQ）和标签来指定数组的名称和内容。DB定义字节数组（每个元素占1字节）、DW定义字数组（每个元素占2字节）、DD定义双字数组（每个元素占4字节）、DQ.data定义一个包含5个字节（8位）的数组定义一个包含5个字（16位）的数组定义四字数组数组名 命令 元素个数 dup(?这个时候如果要手动对数组进行修改或者初始化则需要使用stos系列的指令；STOS指令在 x86 汇编语言中用于将数据从累加器寄存器（ALAX或EAX。
8086 汇编笔记（七）：数据处理的两个基本问题
Flag少侠的博客
06-04 4021
在使用过程中有几处需要注意的地方：（1）在 8086CPU 中，只有这4个寄存器可以用在“[....]”中来进行内存单元的寻址。其他寄存器是不可以的，例如“mov bx, [ax]”就是错误的用法。（2）在[...]中，这四个寄存器可以单个出现，或只能以4种组合出现：bx和si、bx和di、bp和si、bp和di。为了方便记忆可以将si和di看做一组，将bx和bp看做一组。组间可以自由组合，组内不能组合。
SoC开发板汇编c语言混合,基于Cortex-A9 LED汇编、C语言应用程序编写
05-26
在SoC开发板上，可以使用汇编语言和C语言混合编写应用程序。这种混合编程的方式可以充分发挥汇编语言的高效性能和C语言的可读性和易用性。以下是一个基于Cortex-A9的LED控制应用程序的示例代码，其中包含了汇编语言...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值