嵌入式系统第六章作业2

最新推荐文章于 2024-11-10 23:56:26 发布

lonelykk__

最新推荐文章于 2024-11-10 23:56:26 发布

阅读量314

点赞数 2

文章标签： vscode

本文链接：https://blog.csdn.net/lonelykk__/article/details/139631959

版权

一.实现UART_2串口的接收程序，收到字符时，

1、在电脑的输出窗口显示下一个字符，如收到A显示B；

2、亮灯：收到字符G，亮绿灯；收到字符R，亮红灯；收到字符B，亮蓝灯；收到其他字符，不亮灯。

（1）构件方式：

MAIN：

int main(void)
{
    // 关总中断，防止初始化过程中发生中断
    DISABLE_INTERRUPTS;
 
    // 用户外设模块初始化
    // 初始化蓝色LED，设置为输出模式，初始状态为关闭
    gpio_init(LIGHT_BLUE, GPIO_OUTPUT, LIGHT_OFF);
    // 初始化红色LED，设置为输出模式，初始状态为关闭
    gpio_init(LIGHT_RED, GPIO_OUTPUT, LIGHT_OFF);
    // 初始化绿色LED，设置为输出模式，初始状态为关闭
    gpio_init(LIGHT_GREEN, GPIO_OUTPUT, LIGHT_OFF);
 
    // 初始化串口模块，设置波特率为115200
    uart_init(UART_User, 115200);
  
    // 打开使能模块中断
    // 使能UART_User模块接收中断功能
    uart_enable_re_int(UART_User);
	
    // 开总中断，允许中断发生
    ENABLE_INTERRUPTS;
	
    // 提示进入串口工具进行操作
    printf("=====================================\n");
    printf("32107200045 ZGY\n");
    printf("=====================================\n");

    // 主循环（通常在嵌入式系统中需要一个无限循环以保持程序运行）
    while (1) {
        // 主循环内容，可以是其他任务或待机模式
    }

    return 0;  // 一般嵌入式系统主函数不会返回
}   // main函数（结尾）

ISR：

void UART_User_Handler(void)
{
    // 【1】声明局部变量
    uint8_t ch;    // 用于存储接收到的字节
    uint8_t flag;  // 用于标志是否成功接收到字节

    // 【2】关总中断，确保中断处理过程中不会被其他中断打断
    DISABLE_INTERRUPTS;

    // 【3】读取接收到的一个字节
    // 调用接收一个字节的函数，并清除接收中断位
    ch = uart_re1(UART_User, &flag);

    // 【4】根据flag判断是否真正收到一个字节的数据
    if (flag)  // 有数据
    {
        // 如果接收到的字符不是 'G'、'R' 或 'B'
        if ((ch != 'G') && (ch != 'R') && (ch != 'B'))
        {
            // 在电脑的输出窗口显示下一个字符
            uart_send1(UART_User, (ch + 1));
            // 发送字符串 "！ZGY"
            uart_send_string(UART_User, (uint8_t *)"！ZGY");
            // 关闭所有LED
            gpio_set(LIGHT_RED, LIGHT_OFF);
            gpio_set(LIGHT_BLUE, LIGHT_OFF);
            gpio_set(LIGHT_GREEN, LIGHT_OFF);
        }
        // 如果接收到的字符是 'G'
        if (ch == 'G')
        {
            // 发送字符串 "亮绿灯！ZGY"
            uart_send_string(UART_User, (uint8_t *)"亮绿灯！ZGY");
            // 关闭红色和蓝色LED
            gpio_set(LIGHT_RED, LIGHT_OFF);
            gpio_set(LIGHT_BLUE, LIGHT_OFF);
            // 打开绿色LED
            gpio_set(LIGHT_GREEN, LIGHT_ON);
        }
        // 如果接收到的字符是 'R'
        if (ch == 'R')
        {
            // 发送字符串 "亮红灯！ZGY"
            uart_send_string(UART_User, (uint8_t *)"亮红灯！ZGY");
            // 关闭绿色和蓝色LED
            gpio_set(LIGHT_GREEN, LIGHT_OFF);
            gpio_set(LIGHT_BLUE, LIGHT_OFF);
            // 打开红色LED
            gpio_set(LIGHT_RED, LIGHT_ON);
        }
        // 如果接收到的字符是 'B'
        if (ch == 'B')
        {
            // 发送字符串 "亮蓝灯！ZGY"
            uart_send_string(UART_User, (uint8_t *)"亮蓝灯！ZGY");
            // 关闭绿色和红色LED
            gpio_set(LIGHT_GREEN, LIGHT_OFF);
            gpio_set(LIGHT_RED, LIGHT_OFF);
            // 打开蓝色LED
            gpio_set(LIGHT_BLUE, LIGHT_ON);
        }
    }

    // 【5】开总中断，恢复中断使能
    ENABLE_INTERRUPTS;
}

（2）直接地址方式实现：

MAIN：

#define GLOBLE_VAR
#include "includes.h"      //包含总头文件
 
int main(void)
{
    //定义uart寄存器相关地址
    volatile uint32_t* RCC_AHB2;     //GPIO的A口时钟使能寄存器地址
    volatile uint32_t* RCC_APB1;     //UART的2口时钟使能寄存器地址
    volatile uint32_t* gpio_ptr;       //GPIO的A口基地址
    volatile uint32_t* uart_ptr;       //uart2端口的基地址
    volatile uint32_t* gpio_mode;    //引脚模式寄存器地址=口基地址
    volatile uint32_t* gpio_afrl;      //GPIO复用功能低位寄存器
    volatile uint32_t* uart_brr;      //UART波特率寄存器地址
    volatile uint32_t* uart_isr;      // UART中断和状态寄存器基地址
    volatile uint32_t* uart_cr1;      //UART控制寄存器1基地址 
    volatile uint32_t* uart_cr2;      // UART控制寄存器2基地址
    volatile uint32_t* uart_cr3;      // UART控制寄存器3基地址
    volatile uint32_t* uart_tdr;      // UART发送数据寄存器
    uint16_t usartdiv;   //BRR寄存器应赋的值
    
    //变量赋值
    RCC_APB1=0x40021058UL;   		//UART时钟使能寄存器地址
    RCC_AHB2=0x4002104CUL;   		//GPIO的A口时钟使能寄存器地址
    gpio_ptr=0x48000000UL;   		//GPIOA端口的基地址
    uart_ptr=0x40004400UL;  		//UART2端口的基地址
    gpio_mode=0x48000000UL;         //引脚模式寄存器地址=口基地址
    gpio_afrl=0x48000020UL;         //GPIO复用功能低位寄存器
    uart_cr1=0x40004400UL;          //UART控制寄存器1基地址 
    uart_brr=0x4000440CUL;          //UART波特率寄存器地址
    uart_isr=0x4000441CUL;          //UART中断和状态寄存器基地址
    uart_tdr=0x40004428UL;          //UART发送数据寄存器
    uart_cr2=0x40004404UL;     		//UART控制寄存器2基地址
    uart_cr3=0x40004408UL;      	//UART控制寄存器3基地址
    
    //关总中断
    DISABLE_INTERRUPTS;
    
    //用户外设模块初始化
    gpio_init(LIGHT_BLUE,GPIO_OUTPUT,LIGHT_OFF);
    gpio_init(LIGHT_RED,GPIO_OUTPUT,LIGHT_OFF);
    gpio_init(LIGHT_GREEN,GPIO_OUTPUT,LIGHT_OFF);
    
    //下面执行uart_init(UART_User,115200);的直接地址方式
    //使能GPIOA和UART2的时钟
    *RCC_APB1|=(0x1UL<<17U);       //UART2时钟使能 
    *RCC_AHB2 |=(0x1UL<<0U);       //GPIOA时钟使能
    
    //将GPIO端口设置为复用功能
    //首先将D7、D6、D5、D4清零
    *gpio_mode &= ~((0x3UL<<4U)|(0x3UL<<6U)); 
    //然后将D7、D6、D5、D4设为1010，设置PTA2、PTA3为复用功能串行功能。
    *gpio_mode |=((0x2UL<<4U)|(0x2UL<<6U));
    
    //选择引脚的端口复用功能
    //首先将D15~D8清零
    *gpio_afrl &= ~((0xFUL<<8U)|(0xFUL<<12U));
    //然后将D15~D8设置为01110111，分别将PTA3、PTA2引脚设置为USART2_RX、USART2_TX 
    *gpio_afrl=(((0x1UL<<8U)|(0x2UL<<8U)|(0x4UL<<8U))|((0x1UL<<12U)
    |(0x2UL<<12U)|(0x4UL<<12U)));         
    
    //暂时禁用UART功能，控制寄存器1的第0位对应的是UE—USART使能位。
    //此位清零后，USART预分频器和输出将立即停止，并丢弃所有当前操作。
    *uart_cr1 &= ~(0x1UL);
    
    //暂时关闭串口发送与接收功能，控制寄存器1的发送器使能位（D3）、接收器使能位（D2）
    *uart_cr1 &= ~((0x1UL<<3U)|(0x1UL<<2U));
    
    //一位起始位，八位数据位
    *uart_cr1 &= ~((0x1UL << 28U)|(0x1UL << 12U));
    
    //过采样因子为16
    *uart_cr1 &= ~(0x1UL << 15U);
    
    //配置波特率
    usartdiv = (uint16_t)((SystemCoreClock/115200));
    *uart_brr = usartdiv;
    
    //初始化控制寄存器和中断状态寄存器、清标志位
    //关中断
    *uart_isr = 0x0UL;    
    //将控制寄存器2的两个使能位清零。D14—LIN模式使能位、D11—时钟使能位 
    *uart_cr2 &= ~((0x1UL<<14U)|(0x1UL<<11U));
    //将控制寄存器3的三个使能位清零。D5 (SCEN) —smartcard模式使能位、
    //D3 (HDSEL) —半双工选择位、D1 (IREN) —IrDA 模式使能位
    *uart_cr3 &= ~((0x1UL<<5U) | (0x1UL<<3U) |(0x1UL<<1U));
    
    //启动串口发送与接收功能
    *uart_cr1 |= ((0x1UL<<3U)|(0x1UL<<2U)); 
    
    //开启UART功能
    *uart_cr1 |= (0x1UL<<0U); 
    
    
    //完成直接地址方式实现使能模块中断
    //uart_enable_re_int(UART_User);  //使能UART_User模块接收中断功能
    //两部分，开放UART接收中断，开中断控制器IRQ中断
    //开放UART接收中断(将RXNEIE置为1)
    *uart_cr1 |= (0x1UL<<5);
    //开中断控制器IRQ中断，这里不属于uart部分，直接调用函数
    NVIC_EnableIRQ(USART2_IRQn);
    
    //开总中断
    ENABLE_INTERRUPTS;
    
   	//提示进入串口工具进行操作
	printf("=====================================\n");
	printf("32107200045 ZGY\n");
	printf("=====================================\n");  
}

ISR：

#include "includes.h"
#define GLOBLE_VAR
 
volatile uint32_t* uart_isr = (volatile uint32_t*)0x4000441CUL;	// UART中断和状态寄存器基地址
volatile uint32_t* uart_rdr = (volatile uint32_t*)0x40004424UL;	// UART接受数据寄存器
volatile uint32_t* uart_tdr = (volatile uint32_t*)0x40004428UL;	// UART发送数据寄存器
 
void User_SysFun(uint8_t ch);
//======================================================================
//程序名称：UART_User_Handler
//触发条件：UART_User串口收到一个字节触发
//备    注：进入本程序后，可使用uart_get_re_int函数可再进行中断标志判断
//          （1-有UART接收中断，0-没有UART接收中断）
//======================================================================
void USART2_IRQHandler(void)
{
	uint8_t ch;
	uint8_t flag;
	uint32_t t;
	uint32_t t1;
	
	DISABLE_INTERRUPTS;   //关总中断
	//接收一个字节的数据
	//ch=uart_re1(UART_User,&flag);  //调用接收一个字节的函数，清接收中断位
	for(t = 0; t < 0xFBBB; t++)//一直查询缓冲区是否有数据
	{	
		//先判断isr状态位，再获取数据
		if((*uart_isr)&(1<<5U))//第五位为1
		{
			ch = *uart_rdr;//从RDR寄存器取数
			flag = 1;
			*uart_isr &= ~(1<<5U);//第五位清零
			break;
		}
	}
	if(t>=0xFBBB)//超过指定次数
	{
		ch = 0XFF;
		flag = 0;
	}
	
	if(flag)                       //有数据
	{
		if((ch!='G')&&(ch!='R')&&(ch!='B'))
		{
			for (t1 = 0; t1 < 0xFBBB; t++)//查询指定次数
			{
				//发送缓冲区为空则发送数据
				//先判断isr状态位，再获取数据
				if ((*uart_isr)&(1<<7U))	//检查第7位是否为一
				{
					*uart_tdr = (ch+1);		//放到发送寄存器
					break;
				}
			}
			if (t1 >= 0xFBBB)
				return 0; //发送超时，发送失败
			gpio_set(LIGHT_RED,LIGHT_OFF);
			gpio_set(LIGHT_BLUE,LIGHT_OFF);
			gpio_set(LIGHT_GREEN,LIGHT_OFF);
		}
		if(ch == 'G')
		{
			uart_send_string(UART_User,(uint8_t *)"绿灯亮！ZGY");
			gpio_set(LIGHT_RED,LIGHT_OFF);
			gpio_set(LIGHT_BLUE,LIGHT_OFF);
			gpio_set(LIGHT_GREEN,LIGHT_ON);
		}
		if(ch == 'R')
		{
			uart_send_string(UART_User,(uint8_t *)"红灯亮！ZGY");
			gpio_set(LIGHT_GREEN,LIGHT_OFF);
			gpio_set(LIGHT_BLUE,LIGHT_OFF);
			gpio_set(LIGHT_RED,LIGHT_ON);
		}
		if(ch == 'B')
		{
			uart_send_string(UART_User,(uint8_t *)"蓝灯亮！ZGY");
			gpio_set(LIGHT_GREEN,LIGHT_OFF);
			gpio_set(LIGHT_RED,LIGHT_OFF);
			gpio_set(LIGHT_BLUE,LIGHT_ON);
		}
			
	}
	ENABLE_INTERRUPTS;    //开总中断
	
 }
 
//内部函数
void User_SysFun(uint8_t ch)
{
    //（1）收到的一个字节参与组帧
    if(gcRecvLen == 0)  gcRecvLen =useremuart_frame(ch,(uint8_t*)gcRecvBuf);
    //（2）字节进入组帧后，判断gcRecvLen=0？若为0，表示组帧尚未完成，
    //     下次收到一个字节，再继续组帧
    if(gcRecvLen == 0) goto User_SysFun_Exit;
    //（3）至此，gcRecvLen≠0,表示组帧完成，gcRecvLen为帧的长度,校验序列号后（与
    //     根据Flash中倒数一扇区开始的16字节进行比较）
    //     gcRecvBuf[16]进行跳转
    if(strncmp((char *)(gcRecvBuf),(char *)((MCU_SECTOR_NUM-1)*MCU_SECTORSIZE+
       MCU_FLASH_ADDR_START),16) != 0)
    {
        gcRecvLen = 0;         //恢复接收状态
        goto User_SysFun_Exit;
    }
    //（4）至此，不仅收到完整帧，且序号比较也一致， 根据命令字节gcRecvBuf[16]进行跳转
    //若为User串口程序更新命令，则进行程序更新
    switch(gcRecvBuf[16])  //帧标识
    {
        case 0:
            SYSTEM_FUNCTION((uint8_t *)(gcRecvBuf+17));
            gcRecvLen = 0;         //恢复接收状态
        break;
        default:
        break;
    }
User_SysFun_Exit:
    return;
}