精华内容
下载资源
问答
  • 串口接收数据中断来控制LED亮/灭:通过串口助手向MCU发送数据,“A”把LED灯点亮,“B”把LED灯熄灭。 led_key.c #include "stm32f4xx.h" #include "bitband.h" void led_init()//PD0、PD1、PD2、PD3 { GPIO_...

    实验目的:
    实现芯片串口收发数据,按键中断串口发送数据:按下按键,向串口发送数据,并通过虚拟终端显示出来;
    串口接收数据中断来控制LED亮/灭:通过串口助手向MCU发送数据,“A”把LED灯点亮,“B”把LED灯熄灭。

    led_key.c

    #include "stm32f4xx.h" 
    #include "bitband.h"
    void led_init()//PD0、PD1、PD2、PD3
    {
    	GPIO_InitTypeDef d;
    	/*使能GPIOD的时钟*/
    	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD,ENABLE);
    	
    	/*配置PD0-PD6,为输出模,输出推挽类型,低速模式*/
    	d.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3| GPIO_Pin_4| GPIO_Pin_5| GPIO_Pin_6;
    	d.GPIO_Mode = GPIO_Mode_OUT;
    	d.GPIO_OType = GPIO_OType_PP;
    	d.GPIO_Speed = GPIO_Low_Speed;
    	GPIO_Init(GPIOD, &d);
    }
    
    void key_init()
    {       /*按键初始化*/
    	GPIO_InitTypeDef b;
    	/*使能GPIOB的时钟*/
    	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB,ENABLE);
    	
    	
    	/*配置PB2,PB6为输入模式,上拉,按下去就会变成低电平*/
    	b.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_6;
    	b.GPIO_Mode = GPIO_Mode_IN;
    	b.GPIO_PuPd = GPIO_PuPd_UP;
    	GPIO_Init(GPIOB, &b);
    
    }
    
    void led_control(int led_num,int status)
    {
    	switch(led_num)
    	{
    		case 0:
    	  	PDout(0) = status;
    			break;
    		case 1:
    			PDout(1) = status;
    			break;
    		case 2:
    			PDout(2) = status;
    			break;
    		case 3:
    			PDout(3) = status;
    			break;	
    			case 4:
    			PDout(4) = status;
    			break;	
    			case 5:
    			PDout(5) = status;
    			break;	
    			case 6:
    			PDout(6) = status;
    			break;	
    }
    	}
    
    	/*all_led_control,根据state的每一位来控制所有的LED灯*/
    	void all_led_control(unsigned char state)
    	{
    		PDout(0)=!!(state&(1<<0));    //!!把真变成1,把假变成0;
    	  PDout(1)=!!(state&(1<<1)); 
    		PDout(2)=!!(state&(1<<2)); 
    		PDout(3)=!!(state&(1<<3)); 
    		PDout(4)=!!(state&(1<<4)); 
    		PDout(5)=!!(state&(1<<5)); 
    		PDout(6)=!!(state&(1<<6)); 	
    	}
    	
    int key_status(int key_num)
    {
    	switch(key_num)
    	{
    		case 0:
    			return PBin(2);
    		case 1:
    			return PBin(6);
    	}
    	return -1;
    }
    
    void motor_init(void)//PA4
    {
    	GPIO_InitTypeDef a;
    	/*使能GPIOA的时钟*/
    	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);
    	
    	/*配置PA4为输出模,输出推挽类型,低速模式*/
    	a.GPIO_Pin = GPIO_Pin_4 ;
    	a.GPIO_Mode = GPIO_Mode_OUT;
    	a.GPIO_OType = GPIO_OType_PP;
    	a.GPIO_Speed = GPIO_Low_Speed;
    	GPIO_Init(GPIOA, &a);
    
    	PAout(4) = 0;
    }
    
    void motor_control(int status)
    {
    	PAout(4) = status;
    }
    
    void beep_init(void)//PB12
    {
    	GPIO_InitTypeDef b;
    	/*使能GPIOB的时钟*/
    	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB,ENABLE);
    	
    	/*配置PB12为输出模,输出推挽类型,低速模式*/
    	b.GPIO_Pin = GPIO_Pin_12 ;
    	b.GPIO_Mode = GPIO_Mode_OUT;
    	b.GPIO_OType = GPIO_OType_PP;
    	b.GPIO_Speed = GPIO_Low_Speed;
    	GPIO_Init(GPIOB, &b);
    
    	PBout(12) = 0;
    }
    
    void beep_control(int status)
    {
    	PBout(12) = status;
    }
    
    
    
    
    

    uart.c

    #include "uart.h"
    #include "led_key.h"
    void usart1_init(uint32_t BaudRate)  //PA9,PA10
    {
    	   
         /*GPIO口配置*/
    		GPIO_InitTypeDef GPIO_InitStruct;
    	
    	   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);  //使能时钟
    	   GPIO_InitStruct.GPIO_Pin=GPIO_Pin_9|GPIO_Pin_10;
    	   GPIO_InitStruct.GPIO_Mode=GPIO_Mode_AF;       //复用模式
    	   GPIO_InitStruct.GPIO_OType=GPIO_OType_PP;
    	   GPIO_InitStruct.GPIO_Speed=GPIO_High_Speed;    //速率
    	   GPIO_Init(GPIOA,&GPIO_InitStruct);//GPIO初始化;
    	
    	   GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_USART1);//指定复用功能
    	   GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_USART1);//指定复用功能
    	
    	  /*USART配置*/
    	   USART_InitTypeDef USART_InitStruct;
    	
    	  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能串口时钟
    	  USART_InitStruct.USART_BaudRate=BaudRate;//设置波特率
    	  USART_InitStruct.USART_HardwareFlowControl=USART_HardwareFlowControl_None;//无流控
    	  USART_InitStruct.USART_Mode=USART_Mode_Tx|USART_Mode_Rx;//发送接收模式
    	  USART_InitStruct.USART_Parity=USART_Parity_No;     //无校验
    	  USART_InitStruct.USART_StopBits=USART_StopBits_1;    //1个停止位
    		 USART_InitStruct.USART_WordLength=USART_WordLength_8b;    //8位数据长度
    		 USART_Init(USART1,&USART_InitStruct);
    		 
    		/*中断配置*/
    		NVIC_InitTypeDef NVIC_InitStruct;
    		
    		USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);   //来数据触发中断使能;
    		NVIC_InitStruct.NVIC_IRQChannel=USART1_IRQn;   //中断通道配置
    		NVIC_InitStruct.NVIC_IRQChannelCmd=ENABLE;
    		NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority=0x02;
    		NVIC_InitStruct.NVIC_IRQChannelSubPriority=0x02;
    		NVIC_Init(&NVIC_InitStruct);
    
        /*使能串口*/
    		USART_Cmd(USART1,ENABLE);
    
    }
    
    
    
    /*USART1的中断处理函数*/
    void USART1_IRQHandler(void)
    {
       unsigned char data;
    	if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET)
    	{
    	   data=USART_ReceiveData(USART1);
    		
    		if(data=='A')
    		{
            led_control(0,1);	
            led_control(1,1);	
            led_control(2,1);	
            led_control(3,1);				
    		
    		}
    		else if(data=='B')
    		{
            led_control(0,0);	
            led_control(1,0);	
            led_control(2,0);	
            led_control(3,0);				
    		}
    		
    	  USART_ClearITPendingBit(USART1,USART_IT_RXNE);  //清空标志位
    	
    	}
    
    }
    
    /* 串口数据的发送*/
    void USART_SendDatas(USART_TypeDef * USARTx,unsigned char *dataBuf,int len)
    {   
         int i;
    	    for(i=0;i<len;i++)
    	{       
    	     USART_SendData(USARTx,dataBuf[i]);
    		//等待发送完成
    		while(USART_GetFlagStatus(USARTx,USART_FLAG_TXE)==RESET);
    	
    	}
    }
    

    main.c

    #include "main.h"
    #include "led_key.h"
    #include "delay.h"
    //#include "timer.h"
    #include "uart.h"
    
    unsigned char str1[] = { "Hello, how are you?\n" };
    unsigned char str2[] = { "Fine, thank you, and you?\n" };
    
    int main(){ 
    
        led_init();
    	  key_init();
    	  usart1_init(9600);
    	
    	while(1){
    		
    		if (key_status(0) == 0)
    		{
    			USART_SendDatas(USART1, str1, sizeof(str1));
    			delay_ms(200);
    		}
    		
    		if (key_status(1) == 0)
    		{
    			USART_SendDatas(USART1, str2, sizeof(str2));
    			delay_ms(200);
    		}
    	}
     
    }
    
    
    

    实验框图:
    在这里插入图片描述

    实验现象:
    视频演示链接:https://www.bilibili.com/video/BV1Pi4y1x7q1
    部分截图
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在串口调试助手中发送B,灯全部熄灭
    在这里插入图片描述

    记录一个实验中遇到的问题:
    唯一一个问题就是VSPD和串口调试助手的使用。成功仿真了一次后,想要再仿真第二次,但是提示说“串口不存在或串口被占用”,于是我到注册列表中将串口全部关闭,此时VSPD已经显示串口处于关闭状态,但是打开串口调试助手还是出现提醒“串口不存在或串口被占用”。于是我想在VSPD中把这两个串口删除重新创建,但是删不掉,提示说“串口已经打开,无法删除”,但VSPD中显示串口是关闭状态并且注册列表中也将串口删除,于是我到设备管理器中卸载虚拟串口,再次尝试,还是失败。上网查了一下,发现不少人和我有一样的问题,只要把VPSD卸载重新安装并且将电脑重新启动就好了。

    展开全文
  • 使用串口2控制led亮

    2021-01-14 14:03:33
    STM32F103ZET6 用串口控制LED灯的1.串口定义 串口通信(Serial Communications)的概念非常简单,串口按位(bit)发送和接收字节。 串行通信:占用I/O较少,速度上较慢点 并行通信:占用I/O较多,速度上快速 2....

    STM32F103ZET6 用串口控制LED灯的亮灭

    1.串口定义

    串口通信(Serial Communications)的概念非常简单,串口按位(bit)发送和接收字节。
    串行通信:占用I/O较少,速度上较慢点
    并行通信:占用I/O较多,速度上快速

    2.常见通信方式

    1、单工通信

    单工通信只有一根数据线,通信只在一个方向上进行,这种方式的应用实例有:监视器、打印机、电视机等。

    2、半双工通信

    半双工通信也只有一根数据线,它也单工的区别是这根数据线既可作发送又可作发接收,虽然数据可在两个方向上传送,但通信双方不能同时收发数据。

    3、全双工通信

    数据的发送和接收用两根不同的数据线,通信双方在同一时刻都能进行发送和接收,这一工作方式称为全双工通信。在这种方式下,通信双方都有发送器和接收器,发送和接收可同时进行,没有时间延迟。

    3.使用串口通信配置库函数流程

    1. 串口时钟使能,GPIO 时钟使能。

    2. 设置引脚复用器映射:调用 GPIO_PinAFConfig 函数。

    3. GPIO 初始化设置:要设置模式为复用功能。

    4. 串口参数初始化:设置波特率,字长,奇偶校验等参数。

    5. 开启中断并且初始化 NVIC,使能中断(如果需要开启串口中断才需要这个步骤)。

    6. 使能串口。

    7. 编写中断处理函数:函数名格式为 USARTx_IRQHandler(x 对应串口号)。

    4.代码

    void uart_init(u32 bound)
    {
      //GPIO端口设置
      GPIO_InitTypeDef GPIO_InitStructure;
    	USART_InitTypeDef USART_InitStructure;
    	NVIC_InitTypeDef NVIC_InitStructure;
    	 
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	//使能USART1,GPIOA时钟
    	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
      
    	//USART1_TX   GPIOA.2
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //PA.2
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出
      GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.2
       
      //USART1_RX	  GPIOA.3初始化
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;//PA3
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
      GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.3
    
      //Usart1 NVIC 配置
      NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//子优先级3
    	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能
    	NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器
      
       //USART 初始化设置
    
    	USART_InitStructure.USART_BaudRate = bound;//串口波特率
    	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    	USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    	USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//收发模式
    
      USART_Init(USART2, &USART_InitStructure); //初始化串口1
      USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启串口接受中断
      USART_Cmd(USART2, ENABLE);                    //使能串口1 
    
    }
    
    void USART2_IRQHandler(void)                	//串口1中断服务程序
    	{
    	u8 Res;
    #if SYSTEM_SUPPORT_OS 		//如果SYSTEM_SUPPORT_OS为真,则需要支持OS.
    	OSIntEnter();    
    #endif
    		  if(USART_GetITStatus(USART2,USART_IT_RXNE) != RESET)  //判断是否接收到数据
        {
                USART_ClearITPendingBit(USART2,USART_IT_RXNE);  //清除中断标志位,防止重复进入中断
                Res =USART_ReceiveData(USART2);                 //将接受的数据传给Res
                switch(Res)
                {
                    case   1 :PBout(5) = 1;
    						break;
                    case   2 : PBout(5) = 0;
    						break;
    				case   3 : PEout(5) = 1;
    						break;
    				case   4 : PEout(5) = 0;
    					    break;
                    default : break;
                }
        }
    

    主函数

    int main(void)
     {		
     	int i;
      char a[15]="hello world\r\n";
    	delay_init();	    	 //延时函数初始化	  
    	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级,2位响应优先级
    	uart_init(115200);	 //串口初始化为115200
     	LED_Init();			     //LED端口初始化
    	KEY_Init();          //初始化与按键连接的硬件接口
     	while(1)
    	{
    		//这里是主函数检测一个按键有无按下,若有按下,则发送一串字符过去
            if( GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0) == 0)
            {
                delay_ms(2);   //消抖
                if( GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0) == 0)
                {     
                    for(i=0;i<20;i++)
                    {
                        //每次发送一个字节
                        USART_SendData(USART1, a[i]);  
                        //每次等待一个数据发送完成,再发下一个
                        while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET); 
                    }   
                }
            }
    	}	 
     }
    
    展开全文
  • 串口控制LED灭.rar

    2019-07-03 09:03:01
    STM32F103,串口控制LED灯,串口发送1、2,灯或灭。
  • 实现的功能 1.电脑发送‘ON’ 如果已是亮灯状态则返回‘the LED has been ON’ 如果为熄灭状态则点亮LED并返回‘the LED is ON now’ 2.电脑发送‘OFF’ ...如果已是熄灭状态则返回‘the LED has ...LED串口...

    实现的功能

           1.电脑发送‘ON’

    • 如果已是亮灯状态则返回‘the LED has been ON’

    • 如果为熄灭状态则点亮LED并返回‘the LED is ON now’

    2.电脑发送‘OFF’

    • 如果已是熄灭状态则返回‘the LED has been OFF’
    • 如果为亮灯状态则关闭LED并返回‘the LED is OFF now’

     

     

    最终效果

     

     

    使用的芯片为STM32F103C8T6,LED连接在GPIOC的第13号引脚

     

    LED和串口的初始化

    #include <stm32f10x.h>
    #include <stm32f10x_usart.h>
    #include <stm32f10x_gpio.h>
    #include <stm32f10x_rcc.h>
    #include <misc.h>
    #include <string.h>
    #include <stdio.h>
    
    //LED开关
    #define LED_ON GPIO_ResetBits(GPIOC,GPIO_Pin_13);
    #define LED_OFF GPIO_SetBits(GPIOC,GPIO_Pin_13);
    
    #define MAX 100 //最长的接收和发送数据大小
    u8 RxBuffer[MAX];   //接收寄存数组
    u8 TxBuffer[MAX];   //发送寄存数组
    
    int RxCount=0;     //接收发送字节数
    int TxCount=0;
    
    
    //LED的GPIO初始化
    void GPIO_LED_init()
    {
    	GPIO_InitTypeDef GPIO_InitStructure;
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
    	
    	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
    	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_13;
    	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    	GPIO_Init(GPIOC,&GPIO_InitStructure);
    	
    	GPIO_SetBits(GPIOC,GPIO_Pin_13);            //默认关闭LED
    }
    
    //串口GPIO的初始化 GPIOA_PIN_9为TX,GPIOA_PIN_10为RX
    void GPIO_USART_int()
    {
    	GPIO_InitTypeDef GPIO_InitStructure;
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    	
    	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;    //TX为复用推挽输出模式
    	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9;
    	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    	GPIO_Init(GPIOA,&GPIO_InitStructure);
    	
    	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;   //RX为输入悬空模式
    	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_10;
    	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    	GPIO_Init(GPIOA,&GPIO_InitStructure);
    }
    
    void USART_init()
    {
    	USART_InitTypeDef USART_InitStructure;
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    	
    	USART_InitStructure.USART_BaudRate=115200;          //波特率为115200
    	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
    	USART_InitStructure.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
    	USART_InitStructure.USART_Parity=USART_Parity_No;
    	USART_InitStructure.USART_StopBits=USART_StopBits_1;
    	USART_InitStructure.USART_WordLength=USART_WordLength_8b;
    	USART_Cmd(USART1,ENABLE);
    	USART_Init(USART1,&USART_InitStructure);
    }

    串口收发函数

    //查询法发送一字节
     char USART1_SendByte(u8 data)
    {
        USART_SendData(USART1,data);   //发送数据
    	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET)  //如果发送失败返回0
    	{
    			cnt++;
    			if(cnt>12000)
    			return 0;
    	}
       return 1;
    }
    
    //查询法接收一字符
    
    u8 USART1_GetByte()
    {
    	while(USART_GetFlagStatus(USART1,USART_FLAG_RXNE)==RESET){}  //等待接收完成
    		return (USART_ReceiveData(USART1));
    }
    
    
    u8 ReceiveData()
    {
    	vu32 cnt=0;
    	while(1)
    	{
    		RxBuffer[RxCount++]=USART1_GetByte();
    		if(strstr((char *)RxBuffer,"ON")!=NULL)    //对比串口接收到的字符串,为ON就返回1
    		{
    			RxCount=0;
    			return 1;
    		}
    		else 
    			if(strstr((char *)RxBuffer,"OFF")!=NULL) //对比窗口接收到的字符串,为OFF就返回2
    			{
    				RxCount=0;
    				return 2;
    			}
    		else 
    			if(RxCount>3)        //如果未接收到ON或OFF则重新接收并返回0
    			{
    				RxCount=0;
    				return 0;
    			}				
    		
    	}
    }
    
    void SendString(u8 *state)     //用来向串口调试助手发送字符串
    {
    	while(*state!='\0')
    	USART1_SendByte(*state++);
    }
    
    void EmptyRxBuffer(u8 len)      //清空接收寄存数组
    {
    	u8 i;
    	for(i=0;i<len;i++)
    	RxBuffer[i]=0;
    }

    主函数,通过串口收到的指令控制LED并向调试助手返回状态

    int main(void)
    {
    
    	GPIO_LED_init();   //LED有关的GPIO设置
    	GPIO_USART_int();  //串口有关的GPIO设置
    	USART_init();      //串口设置
    	while(1)
    	{
    		SendString((u8 *)("Welcome to my stm32 project\n"));
    		switch(ReceiveData())  //根据接收到的字符串,执行操作
    		{
    			case 1:
    				if((GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_13))==RESET)
                     //如果LED已经被点亮,则提示LED已是亮的
     				SendString((u8 *)("the LED has been ON\n"));
    			  else 
    				{
    					LED_ON;
                        //否则点亮LED并提示
    					SendString((u8 *)("the LED is ON now\n"));
    				}
    			break;
    			case 2:
    				if((GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_13))!=RESET)
                    //如LED已是灭灯状态,则提示LED已灭
    					SendString((u8 *)("the LED has been OFF\n"));
    				else 
    				{
    					LED_OFF;
                        //否则关闭LED,并返回状态
    					SendString((u8 *)("the LED is OFF now\n"));
    				}
    			break;
    			case 0:
    				SendString((u8 *)("Command erro!\n"));
    			  break;			
    		}
    	EmptyRxBuffer(MAX);
    	}
    }
    
    
    
    

     

    展开全文
  • STM32通过串口发送接收PC端消息,并控制LED灯的

    千次阅读 多人点赞 2020-10-17 11:39:09
    STM32F407ZE 通过串口发送接收PC端串口助手消息,并控制LED灯的灭 具体代码解析如下: ustart.h部分 #ifndef USTART_H #define USTART_H #include <stm32f4xx.h> #include <stm32f4xx_usart.h> #...

    STM32F407ZE 通过串口发送接收PC端串口助手消息,并控制LED灯的亮灭
    STM32串口USART1接收字符串
    具体代码解析如下:

    ustart.h部分

    #ifndef USTART_H
    #define USTART_H
    
    #include <stm32f4xx.h>
    #include <stm32f4xx_usart.h>
    #include "sys.h"
    
    void USART1_Init();
    void USART_SendString(USART_TypeDef* USARTx, char *DataString);
    #endif
    

    ustart.c部分

    #include "ustart.h"
    #include <string.h>
    
    void USART1_Init()
    {
    	GPIO_InitTypeDef 	GPIOInit_Struct;
    	USART_InitTypeDef 	USARTInit_Struct;
    	
    	//1、使能时钟
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
    	
    	//2、初始化对应的IO引脚复用为USART1功能
    	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);
    	
    	GPIOInit_Struct.GPIO_Pin 	= GPIO_Pin_9 | GPIO_Pin_10;
    	GPIOInit_Struct.GPIO_Mode	= GPIO_Mode_AF;
    	GPIOInit_Struct.GPIO_OType	= GPIO_OType_PP;
    	GPIOInit_Struct.GPIO_Speed 	= GPIO_Fast_Speed;
    	GPIOInit_Struct.GPIO_PuPd	= GPIO_PuPd_UP;
    	GPIO_Init(GPIOA,&GPIOInit_Struct);
    	
    	//将PA9  PA10复用为USART1功能
    	GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_USART1);
    	GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_USART1);
    	
    	//3、USART1初始化
    	USARTInit_Struct.USART_BaudRate 	= 115200; 								//波特率
    	USARTInit_Struct.USART_Parity		= USART_Parity_No;						//无校验位
    	USARTInit_Struct.USART_StopBits		= USART_StopBits_1;						//1位停止位
    	USARTInit_Struct.USART_WordLength	= USART_WordLength_8b;					//8位数据位
    	USARTInit_Struct.USART_Mode			= USART_Mode_Rx | USART_Mode_Tx;		//收发模式
    	USARTInit_Struct.USART_HardwareFlowControl	= USART_HardwareFlowControl_None;//无硬件控制流
    	USART_Init(USART1,&USARTInit_Struct);
    	
    	//4、开启串口
    	USART_Cmd(USART1,ENABLE);
    }
    
    void USART_SendString(USART_TypeDef* USARTx, char *DataString)
    {
    	int i = 0;
    	USART_ClearFlag(USARTx,USART_FLAG_TC);										//发送字符前清空标志位(否则缺失字符串的第一个字符)
    	while(DataString[i] != '\0')												//字符串结束符
    	{
    		USART_SendData(USARTx,DataString[i]);									//每次发送字符串的一个字符
    		while(USART_GetFlagStatus(USARTx,USART_FLAG_TC) == 0);					//等待数据发送成功
    		USART_ClearFlag(USARTx,USART_FLAG_TC);									//发送字符后清空标志位
    		i++;
    	}
    }
    

    main.c部分(接收PC端发送来的单个字符)

    #include <stm32f4xx.h> 
    #include "led.h"
    #include "ustart.h"
    
    int main()
    {
    	LED_Init();															//LED灯初始化
    	USART1_Init();														//串口初始化
    	USART_SendString(USART1, "Hello world!\r\n");						//发送字符串
    	
    	char USART1_ReceiveData = 0;										//接收PC端发送过来的字符
    	USART_ClearFlag(USART1,USART_FLAG_RXNE);							//接收前先清空标志位
    	while(1)
    	{
    		if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == 1)			//USART_FLAG_RXNE判断数据,== 1则有数据
    		{
    			USART1_ReceiveData = USART_ReceiveData(USART1);				//通过USART1串口接收字符
    			USART_ClearFlag(USART1,USART_FLAG_RXNE);					//接收后先清空标志位
    		}
    		
    		if( '1' == USART1_ReceiveData )									//如果数据为1,LED1灯电平翻转
    		{
    			PFout(9) = !PFout(9);
    		}
    		
    		if( '2' == USART1_ReceiveData )									//如果数据为2,LED2灯电平翻转
    		{
    			PFout(10) = !PFout(10);
    		}
    		USART1_ReceiveData = 0;											//数据清零
    	}
    }
    

    sys.h部分:

    #ifndef __SYS_H
    #define __SYS_H	 
    #include "stm32f4xx.h" 
    
    //IO口操作宏定义
    #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)) 
    //IO口地址映射
    #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 
     
    //STM32中  对寄存器的访问  是不能单独访问寄存器的单个bit  只能以32bit地址访问寄存器
    //这些位为只写形式,只能在字(word)--4byte、半字2byte 或字节模式下访问 
    //IO口操作,只对单一的IO口!
    //确保n的值小于16!
    #define PAout(n)   BIT_ADDR(GPIOA_ODR_Addr,n)  //输出 
    #define PAin(n)    BIT_ADDR(GPIOA_IDR_Addr,n)  //输入 
    
    #define PBout(n)   BIT_ADDR(GPIOB_ODR_Addr,n)  //输出 
    #define PBin(n)    BIT_ADDR(GPIOB_IDR_Addr,n)  //输入 
    
    #define PCout(n)   BIT_ADDR(GPIOC_ODR_Addr,n)  //输出 
    #define PCin(n)    BIT_ADDR(GPIOC_IDR_Addr,n)  //输入 
    
    #define PDout(n)   BIT_ADDR(GPIOD_ODR_Addr,n)  //输出 
    #define PDin(n)    BIT_ADDR(GPIOD_IDR_Addr,n)  //输入 
    
    #define PEout(n)   BIT_ADDR(GPIOE_ODR_Addr,n)  //输出 
    #define PEin(n)    BIT_ADDR(GPIOE_IDR_Addr,n)  //输入
    
    #define PFout(n)   BIT_ADDR(GPIOF_ODR_Addr,n)  //输出 
    #define PFin(n)    BIT_ADDR(GPIOF_IDR_Addr,n)  //输入
    
    #define PGout(n)   BIT_ADDR(GPIOG_ODR_Addr,n)  //输出 
    #define PGin(n)    BIT_ADDR(GPIOG_IDR_Addr,n)  //输入
    
    #define PHout(n)   BIT_ADDR(GPIOH_ODR_Addr,n)  //输出 
    #define PHin(n)    BIT_ADDR(GPIOH_IDR_Addr,n)  //输入
    
    #define PIout(n)   BIT_ADDR(GPIOI_ODR_Addr,n)  //输出 
    #define PIin(n)    BIT_ADDR(GPIOI_IDR_Addr,n)  //输入
    
    
    #endif
    

    开启串口终端接收PC端串口助手发送过来的字符

    ustart.c部分

    #include "ustart.h"
    #include <string.h>
    
    void USART1_Init()
    {
    	GPIO_InitTypeDef 	GPIOInit_Struct;
    	USART_InitTypeDef 	USARTInit_Struct;
    	NVIC_InitTypeDef  	USARTNVIC_Struct;
    	
    	//1、使能时钟
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
    	
    	//2、初始化对应的IO引脚复用为USART1功能
    	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);
    	
    	GPIOInit_Struct.GPIO_Pin 	= GPIO_Pin_9 | GPIO_Pin_10;
    	GPIOInit_Struct.GPIO_Mode	= GPIO_Mode_AF;
    	GPIOInit_Struct.GPIO_OType	= GPIO_OType_PP;
    	GPIOInit_Struct.GPIO_Speed 	= GPIO_Fast_Speed;
    	GPIOInit_Struct.GPIO_PuPd	= GPIO_PuPd_UP;
    	GPIO_Init(GPIOA,&GPIOInit_Struct);
    	
    	//将PA9  PA10复用为USART1功能
    	GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_USART1);
    	GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_USART1);
    	
    	//3、USART1初始化
    	USARTInit_Struct.USART_BaudRate 	= 115200; 								//波特率
    	USARTInit_Struct.USART_Parity		= USART_Parity_No;						//无校验位
    	USARTInit_Struct.USART_StopBits		= USART_StopBits_1;						//1位停止位
    	USARTInit_Struct.USART_WordLength	= USART_WordLength_8b;					//8位数据位
    	USARTInit_Struct.USART_Mode			= USART_Mode_Rx | USART_Mode_Tx;		//收发模式
    	USARTInit_Struct.USART_HardwareFlowControl	= USART_HardwareFlowControl_None;//无硬件控制流
    	USART_Init(USART1,&USARTInit_Struct);
    	
    	//开启串口中断
    	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
    	
    	USARTNVIC_Struct.NVIC_IRQChannel = USART1_IRQn;//stm32f4xx.h
    	USARTNVIC_Struct.NVIC_IRQChannelPreemptionPriority = 0;
    	USARTNVIC_Struct.NVIC_IRQChannelSubPriority        = 0;
    	USARTNVIC_Struct.NVIC_IRQChannelCmd	= ENABLE;
    	NVIC_Init(&USARTNVIC_Struct);
    	
    	//4、开启串口
    	USART_Cmd(USART1,ENABLE);
    }
    
    void USART_SendString(USART_TypeDef* USARTx, char *DataString)
    {
    	int i = 0;
    	USART_ClearFlag(USARTx,USART_FLAG_TC);										//发送字符前清空标志位(否则缺失字符串的第一个字符)
    	while(DataString[i] != '\0')												//字符串结束符
    	{
    		USART_SendData(USARTx,DataString[i]);									//每次发送字符串的一个字符
    		while(USART_GetFlagStatus(USARTx,USART_FLAG_TC) == 0);					//等待数据发送成功
    		USART_ClearFlag(USARTx,USART_FLAG_TC);									//发送字符后清空标志位
    		i++;
    	}
    }
    
    void USART1_IRQHandler(void)													//串口中断执行函数
    {
    	char USART1_ReceiveData = 0;												//接收PC端发送过来的字符
    	
    	if(USART_GetFlagStatus(USART1,USART_IT_RXNE) == 1)							//USART_FLAG_RXNE判断数据,== 1则有数据
    	{		
    		USART1_ReceiveData = USART_ReceiveData(USART1);							//通过USART1串口接收字符
    		USART_ClearFlag(USART1,USART_IT_RXNE);									//接收后先清空标志位
    	}
    	
    	if( '1' == USART1_ReceiveData )												//如果数据为1,LED1灯电平翻转
    	{
    		PFout(9) = !PFout(9);
    	}
    	
    	if( '2' == USART1_ReceiveData )												//如果数据为2,LED2灯电平翻转
    	{
    		PFout(10) = !PFout(10);
    	}
    }
    

    ustart.h部分

    #ifndef USTART_H
    #define USTART_H
    
    #include <stm32f4xx.h>
    #include <stm32f4xx_usart.h>
    #include "sys.h"
    
    void USART1_Init();
    void USART_SendString(USART_TypeDef* USARTx, char *DataString);
    #endif
    
    展开全文
  • 要求在PC上发送L11控制开发板led1亮发送L10控制开发板led1灭;在PC上发送L21控制开发板led2发送L20控制开发板led2灭;在PC上发送L31控制开发板led3发送L30控制开发板led3灭;在PC上发送L41控制开发板led4...
  • MSP430F55xxADC检测电压转换为数值发送串口,转化结果为0-4096 * A0=P6.0 Vcc=3.3V 超过一半Vcc则LED1亮,反之... * A0口默认上拉状态,即悬空时LED亮 * 可在后面增添其他ADC值 * 通过串口打印ADC检测到的电压值
  • STM32F407ZET6 用串口通过键盘控制LED灯的

    千次阅读 多人点赞 2017-09-28 11:33:34
    1串口定义 串口通信是一种设备间非常常用串行通信(数据交互)方式,因为它比较简单便捷,大部分电子设备支持串口通信方式,电子工工程师调试设备时常用的接口串行通信:占用I/O较少,速度上较慢点 并行通信:占用...
  • 通过串口控制LED灯.zip

    2020-02-05 23:56:23
    通过串口1发送1 2分别控制两个LED灯的灭,注意事项:波特率115200.实验现象:通过串口1发送1点亮红色LED灯 再次发送1即可熄灭红色LED灯,通过串口1发送2点亮绿色LED灯,再次发送2即可熄灭绿色LED灯。
  • 用模块化方法重新完成EXP_USART1_Receive_IT_LED __简明指导文件编程实现模块化设计,串口发送十六进制数字,控制LED灯亮相应秒数。例如,串口发送0x02,LED亮2秒。(1) 配置SYS、外部晶振、时钟、GPIO(PC12标签为...
  • PC发送d5on#或者d5off#控制灭。 波特率115200。 #include <ioCC2530.h> #include "stdio.h" #define uint unsigned int #define uchar unsigned char uchar Rxbuff[10]; uchar index=0; ...
  • 1发送什么就接收什么 /* 工程创建MCU选取,Atmel 89C55 单片机:STC12C5A60S2 晶振:12M 功能:串口的应用 波特率:4800 8 无 1 无 */ #include // 可以使用通用的头文件 //串口中断初始化程序 ...
  • 用模块化方法重新完成EXP_USART1_Receive_IT_LED __简明指导文件编程实现模块化设计,串口发送十六进制数字,控制LED灯亮相应秒数。例如,串口发送0x02,LED亮2秒。(1) 配置SYS、外部晶振、时钟、GPIO(PC12标签为...
  • 51单片机UART通信[发送接收数字字母中文,控制LED亮灭]【烧录的时候,一定选择外部晶振】内部6M的IRC时钟,会有各种问题!1发送什么就接收什么/* 工程创建MCU选取,Atmel89C55 单片机:STC12C5A60S2 晶振:12M ...
  • compim 控件 Led 灯 三栈灯红黄绿 virtual ...(一个串口发送,另一个串口接收,直接显示在灯) 首先初始化 init() ; TMOD “timer module”定时器 T0\T1 ;TH1存储数据 高电平寄存器;TL1低电平寄存器; TMO...
  • 在运行的时候,串口输入a,b,c,led灯一直,没有变化 ``` #define LED_PIN 1 void setup() { Serial.begin(9600); pinMode(1, OUTPUT); } void loop() { while (Serial.available()) { char abc = ...
  • cc2530 串口实验--控制led

    千次阅读 2014-01-11 20:38:01
    * project : PC机向cc2530发送指令,控制led灭 指令格式为“xy#”,其中x可以是B或Y, 代表着蓝灯或黄灯。y可以是0或1,0代表 关灯,1代表亮灯 * 时间 :2014年1月10 * 作者 :林少游 ******************
  • 2、阿里云物联网云平台下发命令通过AIR800控制STM32的LED亮灭(打开或关闭功能,或者定时 自动打开和自动关闭) 3、通过nrf24l01实现点对点通信,阿里云下发数据至air800,STM32(A)串口2接收数据之后进行判断,如果...
  • 2、阿里云物联网云平台下发命令通过AIR800控制STM32的LED亮灭(打开或关闭功能,或者定时 自动打开和自动关闭) 3、通过nrf24l01实现点对点通信,阿里云下发数据至air800,STM32(A)串口2接收数据之后进行判断,如果...
  • 1、手机端安装蓝牙串口APP,通过这个APP可发送控制命令 2、51单片机通过串行通信接口接收APP发出的控制信号 3、单片机判断控制信号并以此点亮或者熄灭LED灯 代码: #include <reg52.h> #define uchar unsigned ...
  • (2)安卓手机与蓝牙模块联合调试(二)—— 单片机蓝牙控制LED灭(上) (3)安卓手机与蓝牙模块联合调试(三)—— 单片机蓝牙控制LED灭(下) 本教程的项目地址:1989Jiangtao/BluetoothSCM: 安卓手机...
  • (2)安卓手机与蓝牙模块联合调试(二)—— 单片机蓝牙控制LED灭(上) (3)安卓手机与蓝牙模块联合调试(三)—— 单片机蓝牙控制LED灭(下) 本教程的项目地址:1989Jiangtao/BluetoothSCM: 安卓手机...
  • 单片机串口控制+程序

    2018-10-10 21:38:05
    1.实现串口控制多个LED小灯。 2.实现 串口控制温度模块使单片机显示板能显示当前温度。 3.实现串口控制一个继电器接风扇 4.以上串口控制,利用单片机上所留的RX、TX口输入数据,实现控制(比如,我往TX口发送字母...
  • 写一个ucgui ucos程序,实现ADC通道实时采样并在屏幕显示,以及用滑动条控制LED灯亮度的功能 程序蓝本为奋斗stm32配套例程中的ucgui ucos ADC...LED闪烁程序的功能是通过滑动条和串口控制LED1,LED2和LED3的闪烁...
  • 本文要实现的是:STM32F1 通过 ...并且通过Labview发送指令给STM32单片机,控制单片机上LED灭。通信的基本概念我们知道 STM32F1 芯片内含有非常多的通信接口,学习这些通信接口前,我们很有必要了解下通信的基...
  • 实验原理:  开发板上自带一片CH340芯片,完成本实验电脑需要...GPIO(PB7),通过串口发送命令控制LED灭。串口命令如下: LED_RED_ON\CR\LF---------------------LED红灯 LED_RED_OFF\CR\LF----------...
  • 问题是,我希望使用串口调试助手,发送0-9的数字,控制灯的亮度。但是发送过去,程序无法读出数据。 部分代码如下: #include&lt;reg52.h&gt; #define uint unsigned int #define uchar unsigned char ...
  • 串口实验

    2020-02-06 22:05:04
    通过串口控制LED灯的灭(学习stm32不久) 通过串口发送1 2分别控制两个LED灯的

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

串口发送1控制led亮