精华内容
下载资源
问答
  • STM32串口发送接收数据

    千次阅读 热门讨论 2021-07-14 18:56:39
    目录串口通信串口的结构体如何配置串口发送通过串口向电脑发送ok字符 串口通信 我用的32是stm32f10x最小系统没有UART4和UART5 USART : 通用同步异步收发器 UART : 通用异步收发器 nRTS : 请求发送 nCTS : 请求...

    1.串口通信

    在这里插入图片描述
    我用的32是stm32f10x最小系统没有UART4和UART5
    USART : 通用同步异步收发器
    UART : 通用异步收发器
    nRTS : 请求发送
    nCTS : 请求接收
    区别:USART指单片机的一个IO端口模块,可以根据需要配置成同步模式(SPI,IIC),也可以配置成异步模式(UART).可以理解为USART为SPI,IIC对等的”协议”。 UART则不是一个协议,为一个实体。

    2.串口的结构体

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    Fck : 串口的时钟(APB1 36M / APB2 72M )
    USARTDIV : 无符号的定点数

    115200= 72 * 1000000/16 * USARTDIV

    3.如何配置串口的发送

    1.配置时钟: GPIO口的时钟,串口的时钟, 引脚复用的时钟
    2.配置GPIO的结构体
    3.配置串口的结构体
    4.串口的发送

    在这里插入图片描述

    4.通过串口向电脑发送ok字符

    按照上面的四个步骤进行编写
    我们会发现只能一个一个发送字符,比较麻烦,所以后面封装了一个可以发送字符串的函数。
    usart.c

    #include "usart.h"
    #include "stm32f10x.h"
    
    void usart_init(void)
    {
    	GPIO_InitTypeDef gpio_init;
    	USART_InitTypeDef usartStruct;
    	
    	//1.ÅäÖÃʱÖÓ£ºGPIO¿ÚµÄʱÖÓ£¬Òý½Å¸´ÓõÄʱÖÓ£¬´®¿ÚµÄʱÖÓ
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    	
    	//2.ÅäÖÃGPIOµÄ½á¹¹Ìå
    	//2.1 TX
    	gpio_init.GPIO_Mode = GPIO_Mode_AF_PP;
    	gpio_init.GPIO_Pin = GPIO_Pin_9;
    	gpio_init.GPIO_Speed = GPIO_Speed_10MHz;
    	
    	GPIO_Init(GPIOA,&gpio_init);
    	
    	//2.2 RX
    	gpio_init.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    	gpio_init.GPIO_Pin = GPIO_Pin_10;
    	
    	GPIO_Init(GPIOA,&gpio_init);
    	
    	//3.ÅäÖô®¿ÚµÄ½á¹¹Ìå
    	usartStruct.USART_BaudRate = 115200;
    	usartStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    	usartStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    	usartStruct.USART_Parity = USART_Parity_No;
    	usartStruct.USART_StopBits = USART_StopBits_1;
    	usartStruct.USART_WordLength = USART_WordLength_8b;
    	
    	USART_Init(USART1,&usartStruct);
    	USART_Cmd(USART1, ENABLE );
    	
    }
    
    

    usart.h

    #include "stm32f10x.h"
    
    void usart_init(void);
    
    

    main.c

    #include "stm32f10x.h"
    #include "led.h"
    #include "relay.h"
    #include "shake.h"
    #include "exti.h"
    #include "usart.h"
    
    void delay(uint16_t time)
    {
    	uint16_t i =0;
    	while(time--){
    		i=12000;
    		while(i--);
    	}
    }
    
    int main()
    {
    	usart_init();
    	
    	while(1)
    	{
    		USART_SendData(USART1,'n');
    		//ÏÂÃæUSART_GetFlagStatusΪÁËÅжÏÊý¾Ý¼Ä´æÆ÷ÊÇ·ñΪ¿Õ
    		while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    		USART_SendData(USART1,'t');
    		while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    		USART_SendData(USART1,'\n');
    		while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    		delay(1000);
    	}
    
    }
    
    

    在这里插入图片描述

    5.封装发送字符串函数

    注意:在封装发送字符串函数时,while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);是为了把数据发送完
    usart.c

    #include "usart.h"
    #include "stm32f10x.h"
    
    void usart_init(void)
    {
    	GPIO_InitTypeDef gpio_init;
    	USART_InitTypeDef usartStruct;
    	
    	//1.ÅäÖÃʱÖÓ£ºGPIO¿ÚµÄʱÖÓ£¬Òý½Å¸´ÓõÄʱÖÓ£¬´®¿ÚµÄʱÖÓ
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    	
    	//2.ÅäÖÃGPIOµÄ½á¹¹Ìå
    	//2.1 TX
    	gpio_init.GPIO_Mode = GPIO_Mode_AF_PP;
    	gpio_init.GPIO_Pin = GPIO_Pin_9;
    	gpio_init.GPIO_Speed = GPIO_Speed_10MHz;
    	
    	GPIO_Init(GPIOA,&gpio_init);
    	
    	//2.2 RX
    	gpio_init.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    	gpio_init.GPIO_Pin = GPIO_Pin_10;
    	
    	GPIO_Init(GPIOA,&gpio_init);
    	
    	//3.ÅäÖô®¿ÚµÄ½á¹¹Ìå
    	usartStruct.USART_BaudRate = 115200;
    	usartStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    	usartStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    	usartStruct.USART_Parity = USART_Parity_No;
    	usartStruct.USART_StopBits = USART_StopBits_1;
    	usartStruct.USART_WordLength = USART_WordLength_8b;
    	
    	USART_Init(USART1,&usartStruct);
    	USART_Cmd(USART1, ENABLE );
    	
    }
    
    //·â×°ÁËһϷ¢ËÍ×Ö·û
    void usartSendByte(USART_TypeDef* USARTx, uint16_t Data)
    {
    	USART_SendData(USARTx,Data);
    	while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    
    }
    
    //·¢ËÍ×Ö·û´®
    void usartSendStr(USART_TypeDef* USARTx,char *str)
    {
    	uint16_t i = 0;
    	do{
    		usartSendByte(USARTx,*(str+i));
    		i++;
    	}while(*(str+i) != '\0');
    
    	//ÅжÏÊÇ·ñ·¢ËÍÍê
    	while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
    }
    
    

    usart.h

    #include "stm32f10x.h"
    
    void usart_init(void);
    void usartSendByte(USART_TypeDef* USARTx, uint16_t Data);
    void usartSendStr(USART_TypeDef* USARTx,char *str);
    
    

    main.c

    #include "stm32f10x.h"
    #include "led.h"
    #include "relay.h"
    #include "shake.h"
    #include "exti.h"
    #include "usart.h"
    
    void delay(uint16_t time)
    {
    	uint16_t i =0;
    	while(time--){
    		i=12000;
    		while(i--);
    	}
    }
    
    int main()
    {
    	usart_init();
    	
    	while(1)
    	{
    		usartSendStr(USART1,"Finny\r\n");
    		delay(1000);
    	}
    
    }
    
    

    在这里插入图片描述

    6.重定向printf串口发送

    要使用printf,我们需要添加#include <stdio.h>头文件(学过c的都应该知道吧)

    记得要给下图框住的内容打勾哦
    在这里插入图片描述
    stdio.h文件中有一个宏定义fputc,我们需要使用printf只需要重定向fputc就可以使用啦
    在这里插入图片描述
    usart.h

    #include "stm32f10x.h"
    #include <stdio.h>
    
    void usart_init(void);
    void usartSendByte(USART_TypeDef* USARTx, uint16_t Data);
    void usartSendStr(USART_TypeDef* USARTx,char *str);
    

    usart.c

    #include "usart.h"
    #include "stm32f10x.h"
    
    void usart_init(void)
    {
    	GPIO_InitTypeDef gpio_init;
    	USART_InitTypeDef usartStruct;
    	
    	//1.ÅäÖÃʱÖÓ£ºGPIO¿ÚµÄʱÖÓ£¬Òý½Å¸´ÓõÄʱÖÓ£¬´®¿ÚµÄʱÖÓ
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    	
    	//2.ÅäÖÃGPIOµÄ½á¹¹Ìå
    	//2.1 TX
    	gpio_init.GPIO_Mode = GPIO_Mode_AF_PP;
    	gpio_init.GPIO_Pin = GPIO_Pin_9;
    	gpio_init.GPIO_Speed = GPIO_Speed_10MHz;
    	
    	GPIO_Init(GPIOA,&gpio_init);
    	
    	//2.2 RX
    	gpio_init.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    	gpio_init.GPIO_Pin = GPIO_Pin_10;
    	
    	GPIO_Init(GPIOA,&gpio_init);
    	
    	//3.ÅäÖô®¿ÚµÄ½á¹¹Ìå
    	usartStruct.USART_BaudRate = 115200;
    	usartStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    	usartStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    	usartStruct.USART_Parity = USART_Parity_No;
    	usartStruct.USART_StopBits = USART_StopBits_1;
    	usartStruct.USART_WordLength = USART_WordLength_8b;
    	
    	USART_Init(USART1,&usartStruct);
    	USART_Cmd(USART1, ENABLE );
    	
    }
    
    //·â×°ÁËһϷ¢ËÍ×Ö·û
    void usartSendByte(USART_TypeDef* USARTx, uint16_t Data)
    {
    	USART_SendData(USARTx,Data);
    	while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET);
    
    }
    
    //·¢ËÍ×Ö·û´®
    void usartSendStr(USART_TypeDef* USARTx,char *str)
    {
    	uint16_t i = 0;
    	do{
    		usartSendByte(USARTx,*(str+i));
    		i++;
    	}while(*(str+i) != '\0');
    
    	//ÅжÏÊÇ·ñ·¢ËÍÍê
    	while(USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET);
    }
    
    int fputc(int ch,FILE *f)
    {
    	USART_SendData(USART1,(uint8_t)ch);
    	while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    	
    	return (ch);
    }
    
    

    main.c

    #include "stm32f10x.h"
    #include "led.h"
    #include "relay.h"
    #include "shake.h"
    #include "exti.h"
    #include "usart.h"
    #include "stdio.h"
    
    void delay(uint16_t time)
    {
    	uint16_t i =0;
    	while(time--){
    		i=12000;
    		while(i--);
    	}
    }
    
    int main()
    {
    	usart_init();
    	
    	GPIO_SetBits(GPIOA, GPIO_Pin_3);
    	GPIO_SetBits(GPIOC, GPIO_Pin_13);
    	
    	while(1)
    	{
    //		usartSendStr(USART1,"°ÂÀï¸ø\r\n");
    		int i = printf("Finny\r\n");
    		printf("%d\r\n",i);
    //		putchar('2');
    		
    		delay(1000);
    	}
    }
    
    

    图下为什么i不是5而是7呢,因为\r\n各占了1

    重定向fputc不只可以使用printf还可以使用putchar,大伙可以试试呀
    在这里插入图片描述

    7.串口输入控制LED灯开关

    输入o让led灯打开并输出Open LED light success,输入c让led灯关闭并输出Close LED light success

    提示: main.c中会看见有外部中断的代码,这是之前做震动感应灯的点此进入 STM32 EXTI(外部中断)
    在这里插入图片描述
    led.h

    #include "stm32f10x.h"
    void Led_init(void);
    
    

    led.c

    #include "stm32f10x.h"
    #include "led.h"
    
    void Led_init(void)
    {
    	GPIO_InitTypeDef Led_init;
    	
    	//1.ʹÄÜAPB2µÄʱÖÓGPIO
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
    	
    	//2.½á¹¹ÌåÅäÖÃ
    	Led_init.GPIO_Mode 	= GPIO_Mode_Out_PP;
    	Led_init.GPIO_Pin	  = GPIO_Pin_13;
    	Led_init.GPIO_Speed = GPIO_Speed_10MHz;
    	
    	GPIO_Init(GPIOC, &Led_init);
    }
    
    

    usart.h

    #include "stm32f10x.h"
    #include <stdio.h>
    
    void usart_init(void);
    void usartSendByte(USART_TypeDef* USARTx, uint16_t Data);
    void usartSendStr(USART_TypeDef* USARTx,char *str);
    
    

    usart.c

    #include "usart.h"
    #include "stm32f10x.h"
    
    void usart_init(void)
    {
    	GPIO_InitTypeDef  gpio_init;
    	USART_InitTypeDef usartStruct;
    	NVIC_InitTypeDef  nvic_initStruct;
    	
    	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    	
    	//1.ÅäÖÃʱÖÓ£ºGPIO¿ÚµÄʱÖÓ£¬Òý½Å¸´ÓõÄʱÖÓ£¬´®¿ÚµÄʱÖÓ
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    	
    	//2.ÅäÖÃGPIOµÄ½á¹¹Ìå
    	//2.1 TX
    	gpio_init.GPIO_Mode = GPIO_Mode_AF_PP;
    	gpio_init.GPIO_Pin = GPIO_Pin_9;
    	gpio_init.GPIO_Speed = GPIO_Speed_10MHz;
    	
    	GPIO_Init(GPIOA,&gpio_init);
    	
    	//2.2 RX
    	gpio_init.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    	gpio_init.GPIO_Pin = GPIO_Pin_10;
    	
    	GPIO_Init(GPIOA,&gpio_init);
    	
    	//3.ÅäÖô®¿ÚµÄ½á¹¹Ìå
    	usartStruct.USART_BaudRate = 115200;
    	usartStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    	usartStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    	usartStruct.USART_Parity = USART_Parity_No;
    	usartStruct.USART_StopBits = USART_StopBits_1;
    	usartStruct.USART_WordLength = USART_WordLength_8b;
    	
    	USART_Init(USART1,&usartStruct);
    	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);//ÅäÖô®¿ÚÖжÏ
    	USART_Cmd(USART1, ENABLE );
    	
    	nvic_initStruct.NVIC_IRQChannel = USART1_IRQn;
    	nvic_initStruct.NVIC_IRQChannelPreemptionPriority = 1;
    	nvic_initStruct.NVIC_IRQChannelSubPriority = 1;
    	nvic_initStruct.NVIC_IRQChannelCmd = ENABLE;
    	
    	NVIC_Init(&nvic_initStruct);
    
    	
    }
    
    //·â×°ÁËһϷ¢ËÍ×Ö·û
    void usartSendByte(USART_TypeDef* USARTx, uint16_t Data)
    {
    	USART_SendData(USARTx,Data);
    	while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET);
    
    }
    
    //·¢ËÍ×Ö·û´®
    void usartSendStr(USART_TypeDef* USARTx,char *str)
    {
    	uint16_t i = 0;
    	do{
    		usartSendByte(USARTx,*(str+i));
    		i++;
    	}while(*(str+i) != '\0');
    
    	//ÅжÏÊÇ·ñ·¢ËÍÍê
    	while(USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET);
    }
    
    int fputc(int ch,FILE *f)
    {
    	USART_SendData(USART1,(uint8_t)ch);
    	while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    	
    	return (ch);
    }
    
    int fgetc(FILE *f)
    {
    	while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET);
    	
    	return (int) USART_ReceiveData(USART1);
    }
    
    

    main.c

    #include "stm32f10x.h"
    #include "led.h"
    #include "relay.h"
    #include "shake.h"
    #include "exti.h"
    #include "usart.h"
    #include "stdio.h"
    
    void delay(uint16_t time)
    {
    	uint16_t i =0;
    	while(time--){
    		i=12000;
    		while(i--);
    	}
    }
    
    int main()
    {
    	Led_init();
    	Relay_Init();
    	Shake_init();
    	exti_init();
    	usart_init();
    	
    	//³õʼ»¯Òý½Å
    	GPIO_SetBits(GPIOA, GPIO_Pin_3);
    	GPIO_SetBits(GPIOC, GPIO_Pin_13);
    
    }
    
    void EXTI1_IRQHandler(void)
    {
    	if (EXTI_GetITStatus( EXTI_Line1 ) != RESET){// ÅжÏÊÇ·ñ·¢ÉúÖжÏ
    		GPIO_ResetBits(GPIOA, GPIO_Pin_3);
    		usartSendStr(USART1,"Open light success\r\n");
    		delay(1000);
    		GPIO_SetBits(GPIOA, GPIO_Pin_3);
    		usartSendStr(USART1,"Close light success\r\n");
    	}
    
    	EXTI_ClearFlag(EXTI_Line1);
    	
    }
    
    void USART1_IRQHandler(void)
    {
    	char temp;
    	
    	if(USART_GetITStatus(USART1,USART_IT_RXNE) != RESET){
    		
    		temp = USART_ReceiveData(USART1);
    
    		if(temp == 'o'){
    			GPIO_ResetBits(GPIOC, GPIO_Pin_13);
    			usartSendStr(USART1,"Open LED light success\r\n");
    		}
    		
    		if(temp == 'c'){
    			GPIO_SetBits(GPIOC, GPIO_Pin_13);
    			usartSendStr(USART1,"Close LED light success\r\n");
    		}
    	}
    }
    	
    

    遇到的问题

    评论区中小鲸鱼uu私信我了一个问题,就是他串口输出乱码
    为什么senddata不能发送int的数字,因为将数字转换成ASCII码输出了,至于ASCII码表百度一下吧

    展开全文
  • 本文主要给出一个实用的java 串口通信程序,供大家讨论学习./******************************************* 程序文件名称:SendComm.java* 功能:从串行口COM1发送数据****************************************...

    本文主要给出一个实用的java 串口通信程序,供大家讨论学习.

    /******************************************

    * 程序文件名称:SendComm.java

    * 功能:从串行口COM1中发送数据

    ******************************************/

    import java.awt.*;

    import java.awt.event.*;

    import java.io.*;

    import java.util.*;

    import javax.comm.*;

    class S_Frame extends Frame implements Runnable,ActionListener

    {

    /*检测系统中可用的通讯端口类 */

    static CommPortIdentifier portId;

    /*Enumeration 为枚举型类,在util中 */

    static Enumeration portList;

    OutputStream outputStream;

    /*RS-232的串行口 */

    SerialPort serialPort;

    Thread readThread;

    Panel p=new Panel();

    TextField in_message=new TextField("打开COM1,波特率9600,数据位8,停止位1.");

    TextArea out_message=new TextArea();

    Button btnOpen=new Button("打开串口, 发送数据");

    Button btnClose=new Button("关闭串口, 停止发送数据");

    byte data[]=new byte[10240];

    /*设置判断要是否关闭串口的标志*/

    boolean mark;

    /*安排窗体*/

    S_Frame()

    { super("串口发送数据");

    setSize(200,200);

    setVisible(true);

    add(out_message,"Center");

    add(p,"North");

    p.add(btnOpen);

    p.add(btnClose);

    add(in_message,"South");

    btnOpen.addActionListener(this);

    btnClose.addActionListener(this);

    } //R_Frame() end

    /*点击按扭打开串口.*/

    public void actionPerformed(ActionEvent event) {

    if (event.getSource()==btnClose){

    serialPort.close(); //关闭串口

    mark=true; //用于中止线程的run()方法

    in_message.setText("串口COM1已经关闭,停止发送数据.");

    }

    else { mark=false;

    /*从文本区按字节读取数据*/

    data=out_message.getText().getBytes();

    /*打开串口*/

    start();

    in_message.setText("串口COM1已经打开,正在每2秒钟发送一次数据.....");

    }

    } //actionPerformed() end

    /*打开串口,并调用线程发送数据*/

    public void start(){

    /*获取系统中所有的通讯端口 */

    portList=CommPortIdentifier.getPortIdentifiers();

    /* 用循环结构找出串口 */

    while (portList.hasMoreElements()){

    /*强制转换为通讯端口类型*/

    portId=(CommPortIdentifier)portList.nextElement();

    if(portId.getPortType() == CommPortIdentifier.PORT_SERIAL){

    if (portId.getName().equals("COM1")) {

    /*打开串口 */

    try {

    serialPort = (SerialPort) portId.open("ReadComm", 2000);

    }

    catch (PortInUseException e) { }

    /*设置串口输出流*/

    try {

    outputStream = serialPort.getOutputStream();

    }

    catch (IOException e) {}

    } //if end

    } //if end

    } //while end

    /*调用线程发送数据*/

    try{

    readThread = new Thread(this);

    //线程负责每发送一次数据,休眠2秒钟

    readThread.start();

    }

    catch (Exception e) { }

    } //start() end

    /*发送数据,休眠2秒钟后重发*/

    public void run() {

    /*设置串口通讯参数*/

    try {

    serialPort.setSerialPortParams(9600,

    SerialPort.DATABITS_8,

    SerialPort.STOPBITS_1,

    SerialPort.PARITY_NONE);

    }

    catch (UnsupportedCommOperationException e) { }

    /*发送数据流(将数组data[]中的数据发送出去)*/

    try {

    outputStream.write(data);

    }

    catch (IOException e) { }

    /*发送数据后休眠2秒钟,然后再重发*/

    try { Thread.sleep(2000);

    if (mark)

    {return; //结束run方法,导致线程死亡

    }

    start();

    }

    catch (InterruptedException e) { }

    } //run() end

    } //类S_Frame end

    public class SendComm

    {public static void main(String args[])

    { S_Frame S_win=new S_Frame();

    S_win.addWindowListener(new WindowAdapter()

    {public void windowClosing(WindowEvent e)

    {System.exit(0); }

    });

    S_win.pack();

    }

    }

    /******************************************

    * 程序文件名称:ReadComm.java

    * 功能:从串行口COM1中接收数据

    ******************************************/

    import java.awt.*;

    import java.awt.event.*;

    import java.io.*;

    import java.util.*;

    import javax.comm.*;

    class R_Frame extends Frame implements Runnable,ActionListener,SerialPortEventListener

    {

    /* 检测系统中可用的通讯端口类 */

    static CommPortIdentifier portId;

    /* Enumeration 为枚举型类,在java.util中 */

    static Enumeration portList;

    InputStream inputStream;

    /* 声明RS-232串行端口的成员变量 */

    SerialPort serialPort;

    Thread readThread;

    String str="";

    TextField out_message=new TextField("上面文本框显示接收到的数据");

    TextArea in_message=new TextArea();

    Button btnOpen=new Button("打开串口");

    /*建立窗体*/

    R_Frame()

    {

    super("串口接收数据");

    setSize(200,200);

    setVisible(true);

    btnOpen.addActionListener(this);

    add(out_message,"South");

    add(in_message,"Center");

    add(btnOpen,"North");

    } //R_Frame() end

    /*点击按扭所触发的事件:打开串口,并监听串口. */

    public void actionPerformed(ActionEvent event)

    {

    /*获取系统中所有的通讯端口 */

    portList=CommPortIdentifier.getPortIdentifiers();

    /* 用循环结构找出串口 */

    while (portList.hasMoreElements()){

    /*强制转换为通讯端口类型*/

    portId=(CommPortIdentifier)portList.nextElement();

    if(portId.getPortType() == CommPortIdentifier.PORT_SERIAL){

    if (portId.getName().equals("COM1")) {

    try {

    serialPort = (SerialPort) portId.open("ReadComm", 2000);

    out_message.setText("已打开端口COM1 ,正在接收数据..... ");

    }

    catch (PortInUseException e) { }

    /*设置串口监听器*/

    try {

    serialPort.addEventListener(this);

    }

    catch (TooManyListenersException e) { }

    /* 侦听到串口有数据,触发串口事件*/

    serialPort.notifyOnDataAvailable(true);

    } //if end

    } //if end

    } //while end

    readThread = new Thread(this);

    readThread.start(); //线程负责每接收一次数据休眠20秒钟

    } //actionPerformed() end

    /*接收数据后休眠20秒钟*/

    public void run() {

    try {

    Thread.sleep(20000);

    }

    catch (InterruptedException e) { }

    } //run() end

    /*串口监听器触发的事件,设置串口通讯参数,读取数据并写到文本区中*/

    public void serialEvent(SerialPortEvent event) {

    /*设置串口通讯参数:波特率、数据位、停止位、奇偶校验*/

    try {

    serialPort.setSerialPortParams(9600,

    SerialPort.DATABITS_8,

    SerialPort.STOPBITS_1,

    SerialPort.PARITY_NONE);

    }

    catch (UnsupportedCommOperationException e) {   }

    byte[] readBuffer = new byte[20];

    try {

    inputStream = serialPort.getInputStream();

    }

    catch (IOException e) {}

    try {

    /* 从线路上读取数据流 */

    while (inputStream.available() > 0) {

    int numBytes = inputStream.read(readBuffer);

    } //while end

    str=new String(readBuffer);

    /*接收到的数据存放到文本区中*/

    in_message.append(str+"/n");

    }

    catch (IOException e) { }

    } //serialEvent() end

    } //类R_Frame end

    public class ReadComm

    {

    public static void main(String args[])

    {

    /* 实例化接收串口数据的窗体类 */

    R_Frame R_win=new R_Frame();

    /* 定义窗体适配器的关闭按钮功能 */

    R_win.addWindowListener(new WindowAdapter()

    {public void windowClosing(WindowEvent e)

    {System.exit(0); }

    });

    R_win.pack();

    }

    }

    展开全文
  • 最近在做与设备进行串口通信交互的项目,然后简单...2.先获取电脑所有串口列表 获取到列表后绑定给conboBox,以便选择串口打开 String[] portnames = SerialPort.GetPortNames(); foreach (var item in portnames) {

    最近在做与设备进行串口通信交互的项目,然后简单记录一下过程

    使用的winform应用程序

    方式1

    1.声明串口对象 或者直接在工具箱拖拽串口控件

    本篇文章不采用拖拽工具箱控件 直接声明对象
    声明串口对象

    SerialPort port = new SerialPort();//在选择了串口之后设置 串口、波特率、校验位等
    

    也可以直接拖拽工具箱的串口控件SerialPort
    在这里插入图片描述

    2.引用串口命名控件 声明串口对象、声明委托

    using System.IO.Ports;
    
    		SerialPort serialPort1 = new SerialPort();
            public delegate void Displaydelegate(byte[] InputBuf);
            public Displaydelegate disp_delegate;
            public Form1()
            {
                InitializeComponent();
    
                disp_delegate = new Displaydelegate(DispUI);
                serialPort1.DataReceived += new SerialDataReceivedEventHandler(serialPort1_DataReceived);
            }
    

    3.先获取电脑所有串口列表

    获取到列表后绑定给conboBox,以便选择串口打开 在load事件绑定下拉框

    String[] portnames = SerialPort.GetPortNames();
                foreach (var item in portnames)
                {
                    comboBox1.Items.Add(item);
                }
    

    4.实例化串口打开串口

    选择串口后实例化串口

    string aaa = comboBox1.SelectedItem.ToString();
    serialPort11 = new SerialPort(aaa, 9600, Parity.None, 8, StopBits.One); //初始化串口设置   serialPort11 声明为全局变量
    
                serialPort1.Open();
                if (serialPort1.IsOpen)
                {
                    MessageBox.Show("打开成功");
                }
                else
                {
                    MessageBox.Show("打开失败");
                }
    

    5.写一个接收数据事件获取串口发送来的数据

     //编写一个接收事件
            private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
            {
               // writetxt("端口名称:" + serialPort1.PortName + "====" + "端口名称:" + "波特率:" + serialPort1.BaudRate + "串口状态:" + serialPort1.IsOpen + "错误信息:无");
                //string receive = "";//数据接收
                try
                {
                    Thread.Sleep(100);  //(毫秒)等待一定时间,确保数据的完整性 int len        
                    int len = serialPort1.BytesToRead;
                    if (len != 0)
                    {
                        byte[] buff = new byte[len];
                        serialPort1.Read(buff, 0, len);
                        //receive = Encoding.Default.GetString(buff);//数据接收内容
                        //textBox1.Text = receive + "\r\n"; //不能直接给textbox1 不然会报错
                        this.Invoke(disp_delegate, buff);
                    }
                }
                catch (Exception asd)
                {
                    //writetxt("端口名称:" + serialPort1.PortName + "====" + "端口名称:" + "波特率:" + serialPort1.BaudRate + "串口状态:" + serialPort1.IsOpen + "错误信息:" + asd.Message);
                    return;
                }
            }
    		public void DispUI(byte[] InputBuf)
            {
                //textBox1.Text = Convert.ToString(InputBuf);
                 
                string aaa = Encoding.Default.GetString(InputBuf);
                textBox1.Text = aaa;
               // writetxt("端口名称:" + serialPort1.PortName + "====" + "端口名称:" + "波特率:" + serialPort1.BaudRate + "串口状态:" + serialPort1.IsOpen + "错误信息:无     " + "数据:" + aaa);
    
            }
    

    6.模拟串口发送数据

    模拟串口调试工具可参考我另一篇文章链接https://blog.csdn.net/qq_39569480/article/details/120776868

    在这里插入图片描述

    方式2

    发送接收 完整代码示例

    源码下载地址demo

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    using System.IO.Ports;
    using System.Threading;//线程申明
    
    namespace ck3
    {
        public partial class Form1 : Form
        {
            private void CheckPort()//检查串口是否可用
            {
                ckCheckBox.Items.Clear();//清除控件中的当前值
                bool havePort = false;
                string[] a = SerialPort.GetPortNames();
                if (a != null)
                {
                    
                    for (int i = 0; i < a.Length; i++)
                    {
                        bool use = false;
                        try
                        {
                            SerialPort t = new SerialPort(a[i]);
                            sp.Open();
                            sp.Close();
                            use = true;
                        }
                        catch
                        {
                        }
                        if (use)
                        {
                            ckCheckBox.Items.Add(a[i]);
                            havePort = true;
                        }
                    }
                }
                if (havePort)
                {
                    ckCheckBox.SelectedIndex = 0;//??
                }
                else
                {
                    MessageBox.Show("无可用串口...", "错误");
                }
    
            }
            private void SetPort()//设置串口
            {
                try
                {
                    sp.PortName = ckCheckBox.Text.Trim();//串口名给了串口类
                    sp.BaudRate = Convert.ToInt32(SendBox.Text.Trim());//Trim除去前后空格,讲文本转换为32位字符给予串口类
                    if (JywCheckBox.Text.Trim() == "奇校验")
                    {
                        sp.Parity = Parity.Odd;//将奇校验位给了sp的协议
                    }
                    else if (JywCheckBox.Text.Trim() == "偶校验")
                    {
                        sp.Parity = Parity.Even;
                    }
                    else
                    {
                        sp.Parity = Parity.None;
                    }
                    if (StopCheckBox.Text.Trim() == "1.5")
                    {
                        sp.StopBits = StopBits.OnePointFive;//设置停止位有几位
                    }
                    else if (StopCheckBox.Text.Trim() == "2")
                    {
                        sp.StopBits = StopBits.Two;
                    }
                    else
                    {
                        sp.StopBits = StopBits.One;
                    }
                    sp.DataBits = Convert.ToInt16(DataBox.Text.ToString().Trim());//数据位
                    sp.Encoding = Encoding.UTF8;//串口通信的编码格式
                    sp.Open();
                }
                catch { }
    
            }
            private string HexToASCII(string str)
            {
                try
                {
                    string[] mystr1 = str.Trim().Split(' ');
                    byte[] t = new byte[mystr1.Length];
                    for (int i = 0; i < t.Length; i++)
                    {
                        t[i] = Convert.ToByte(mystr1[i], 16);
                    }
                    return Encoding.UTF8.GetString(t);
    
                }
                catch (Exception ex)
                {
                    rbtReceicedAscii.Select();
                    MessageBox.Show("转换失败!" + ex.Message, "错误提示");
                    return str;
    
                }
            }
            private string ASCIIToHex(string my2)
            {
                try
                {
                    byte[] a = Encoding.UTF8.GetBytes(my2.Trim());
                    string mystr1 = "";
                    for (int i = 0; i < a.Length; i++)
                    {
                        mystr1 += a[i].ToString("X2") + " ";
                    }
                    return mystr1;
                }
                catch (Exception ex)
                {
                    rbtReceicedAscii.Select();
                    MessageBox.Show("转换失败!" + ex.Message, "错误提示");
                    return my2;
                }
    
    
            }
           
          
    
            private void Form1_Load(object sender, EventArgs e)
            {
                statusText.Text = "";//状态条初始化
                //设置窗口大小
                this.MaximizeBox = false;//隐藏最大化按钮
                this.MaximumSize = this.Size;//固定窗口尺寸最大为当前尺寸
                this.MinimumSize = this.Size;//固定窗口尺寸最小为当前尺寸
                BtlCheckBox.SelectedIndex = 5;
              //  JywCheckBox.Items.Clear();
                JywCheckBox.SelectedIndex = 1;
                StopCheckBox.SelectedIndex = 1;
               // DataBox.Items.Clear();
                DataBox.SelectedIndex = 1;
                statusText.Text = "";
                rbtSendAscii.Select();//默认选择ASCII字符显示
                rbtReceicedAscii.Select();//默认选择ASCII字符显示
    
            }
    
            private void btnChecked_Click(object sender, EventArgs e)
            {
                statusText.Text = "检测串口开始!";
                CheckPort();
                statusText.Text = "串口检测完成!";
            }
            private void sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
            {
                Thread.Sleep(100);//等待
    
                this.Invoke((EventHandler)(delegate //异步委托一个线程
                {
                    try
                    {
                        byte[] a = new byte[sp.BytesToRead];//读出缓冲区串口通信的字节
                        sp.Read(a, 0, a.Length);//写入sp
                        string my2 = Encoding.UTF8.GetString(a);
                        string b = "";
                        if (rbtSendAscii.Checked)
                        {
                            b = ASCIIToHex(my2);
                        }
                        else
                        {
                            b = my2;
                        }
                        RecevieBox.Text += b + "\r\n";
                        statusText.Text = "接收成功!";
                    }
                    catch
                    {
                        statusText.Text = "接收失败!";
                    }
                }));
            }
            public Form1()
            {
                InitializeComponent();
            }
        
       
            //发送按钮
            private void button1_Click_1(object sender, EventArgs e)
            {
                try
                {
                    string mystr1 = SendBox.Text;
                    if (SixtyRe.Checked)//radio如果选择十六进制    则进行转换
                    {
                        mystr1 = HexToASCII(SendBox.Text);
                    }
                    byte[] a = Encoding.UTF8.GetBytes(mystr1);
                    string mystr2 = Encoding.UTF8.GetString(a);
                    sp.Write(mystr2);//将数据写入串行端口输出缓冲区
                    // tbxReceivedData.Text += tbxSendData.Text + "\r\n";
                    statusText.Text = "发送成功!";
                }
                catch
                {
                    statusText.Text = "发送失败";
                }
            }
    
            private void button1_Click_2(object sender, EventArgs e)
            {
                RecevieBox.Text = " ";
                SendBox.Text = " ";
            }
    
           
    
            private void BtnOpen_Click(object sender, EventArgs e)
            {
               
                    if (BtnOpen.Text == "打开串口")
                    {
                        SetPort();
                        if (sp.IsOpen)
                        {
                            statusText.Text = "串口" + ckCheckBox.Text + "已打开!";
                        }
                        else
                        {
                            try
                            {
                                sp.Open();
                                btnChecked.Enabled = false;
                                ckCheckBox.Enabled = false;
                                BtlCheckBox.Enabled = false;
                                JywCheckBox.Enabled = false;
                                StopCheckBox.Enabled = false;
                                DataBox.Enabled = false;
                                BtnOpen.Text = "关闭串口";
                                statusText.Text = "串口" + ckCheckBox.Text + "打开成功!";
                            }
                            catch (Exception ex)
                            {
                                MessageBox.Show("串口" + ckCheckBox.Text + "打开失败,失败原因:" + ex.Message, "错误提示");
                                statusText.Text = "串口" + ckCheckBox.Text + "打开失败,失败原因:" + ex.Message;
                            }
                        }
                    }
                    else //关闭串口
                    {
                        if (sp.IsOpen) //判断串口是否打开
                        {
                            try
                            {
                                sp.Close(); //关闭串口
                                            //启用设置控件
                            btnChecked.Enabled = true;
                            ckCheckBox.Enabled = true;
                            BtlCheckBox.Enabled = true;
                            JywCheckBox.Enabled = true;
                            StopCheckBox.Enabled = true;
                            DataBox.Enabled = true;
                            BtnOpen.Text = "打开串口";
                            statusText.Text = "串口" + ckCheckBox.Text + "关闭成功!";
                            }
                            catch (Exception ex)
                            {
                                MessageBox.Show("串口" + ckCheckBox.Text + "关闭失败,错误提示:" + ex.Message, "错误提示");
                            statusText.Text = "串口" + ckCheckBox.Text + "关闭失败,错误提示:" + ex.Message;
                            }
                        }
                        else
                        {
                        btnChecked.Enabled = true;
                        ckCheckBox.Enabled = true;
                        BtlCheckBox.Enabled = true;
                        JywCheckBox.Enabled = true;
                        StopCheckBox.Enabled = true;
                        DataBox.Enabled = true;
                        BtnOpen.Text = "打开串口";
                        statusText.Text = "串口未打开,无法关闭!";
                            MessageBox.Show("串口未打开,无法关闭!", "错误提示");
                        }
                    
    
                }
    
            }
    
           
            private void SixtySend_CheckedChanged(object sender, EventArgs e)
            {
                if (SixtyRe.Checked)//radio如果选择十六进制    则进行转换
                {
                    SendBox.Text = ASCIIToHex(SendBox.Text.ToString());
                }
            }
    
           
        }
    }
    
    
    展开全文
  • 这里写目录标题串口发送数据串口接受数据 串口发送数据 1串口发送数据最直接的方式就是标准调用库函数 。 void USART_SendData(USART_TypeDef* USARTx, uint16_t Data); 第一个参数是发送的串口号,第二个参数是...

    串口发送数据

    1、串口发送数据最直接的方式就是标准调用库函数 。

    void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);
    

    第一个参数是发送的串口号,第二个参数是要发送的数据了。但是用过的朋友应该觉得不好用,一次只能发送单个字符,所以我们有必要根据这个函数加以扩展:

    void Send_data(u8 *s)
    {
     while(*s!='\0')
     { 
      while(USART_GetFlagStatus(USART1,USART_FLAG_TC )==RESET); 
      USART_SendData(USART1,*s);
      s++;
     }
    }
    

    以上程序的形参就是我们调用该函数时要发送的字符串,这里通过循环调用USART_SendData来一 一发送我们的字符串。

    while(USART_GetFlagStatus(USART1,USART_FLAG_TC )==RESET);
    

    这句话有必要加,他是用于检查串口是否发送完成的标志,如果不加这句话会发生数据丢失的情况。这个函数只能用于串口1发送。有些时候根据需要,要用到多个串口发送那么就还需要改进这个程序。如下:

    void Send_data(USART_TypeDef * USARTx,u8 *s)
    {
     while(*s!='\0')
     { 
      while(USART_GetFlagStatus(USARTx,USART_FLAG_TC )==RESET); 
      USART_SendData(USARTx,*s);
      s++;
     }
    }
    

    这样就可实现任意的串口发送。但有一点,我在使用实时操作系统的时候(如UCOS,Freertos等),需考虑函数重入的问题。
    当然也可以简单的实现把该函数复制一下,然后修改串口号也可以避免该问题。然而这个函数不能像printf那样传递多个参数,所以还可以在改进,最终程序如下:

    void USART_printf ( USART_TypeDef * USARTx, char * Data, ... )
    {
     const char *s;
     int d;   
     char buf[16];
     
     va_list ap;
     va_start(ap, Data);
     
     while ( * Data != 0 )     // 判断是否到达字符串结束符
     {                              
      if ( * Data == 0x5c )  //'\'
      {           
       switch ( *++Data )
       {
        case 'r':                 //回车符
        USART_SendData(USARTx, 0x0d);
        Data ++;
        break;
     
        case 'n':                 //换行符
        USART_SendData(USARTx, 0x0a); 
        Data ++;
        break;
     
        default:
        Data ++;
        break;
       }    
      }
      
      else if ( * Data == '%')
      {           //
       switch ( *++Data )
       {    
        case 's':            //字符串
        s = va_arg(ap, const char *);
        
        for ( ; *s; s++) 
        {
         USART_SendData(USARTx,*s);
         while( USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET );
        }
        
        Data++;
        
        break;
     
        case 'd':   
         //十进制
        d = va_arg(ap, int);
        
        itoa(d, buf, 10);
        
        for (s = buf; *s; s++) 
        {
         USART_SendData(USARTx,*s);
         while( USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET );
        }
        
        Data++;
        
        break;
        
        default:
        Data++;
        
        break;
        
       }   
      }
      
      else USART_SendData(USARTx, *Data++);
      
      while ( USART_GetFlagStatus ( USARTx, USART_FLAG_TXE ) == RESET );
      
     }
    }
    

    该函数就可以像printf使用可变参数,方便很多。通过观察函数但这个函数只支持了%d,%s的参数,想要支持更多,可以仿照printf的函数写法加以补充。
    2、 直接使用printf函数。
    很多朋友都知道想要STM32要直接使用printf不行的。需要加上以下的重映射函数;
    在这里插入图片描述如果不想添加以上代码,也可以勾选以下的Use MicroLI选项来支持printf函数使用:
    在这里插入图片描述

    串口接受数据

    串口接收最后应有一定的协议,如发送一帧数据应该有头标志或尾标志,也可两个标志都有。
    这样在处理数据时既能能保证数据的正确接收,也有利于接收完后我们处理数据。串口的配置在这里就不在赘述,这里我以串口2接收中断服务程序函数且接收的数据包含头尾标识为例。

    #define Max_BUFF_Len 18
    unsigned char Uart2_Buffer[Max_BUFF_Len];
    unsigned int Uart2_Rx=0;
    void USART2_IRQHandler() 
    {
     if(USART_GetITStatus(USART2,USART_IT_RXNE) != RESET) //中断产生 
     {
      USART_ClearITPendingBit(USART2,USART_IT_RXNE); //清除中断标志
        
      Uart2_Buffer[Uart2_Rx] = USART_ReceiveData(USART2);     //接收串口1数据到buff缓冲区
      Uart2_Rx++; 
            
      if(Uart2_Buffer[Uart2_Rx-1] == 0x0a || Uart2_Rx == Max_BUFF_Len)    //如果接收到尾标识是换行符(或者等于最大接受数就清空重新接收)
      {
       if(Uart2_Buffer[0] == '+')                      //检测到头标识是我们需要的 
       {
        printf("%s\r\n",Uart2_Buffer);        //这里我做打印数据处理
        Uart2_Rx=0;                                   
       } 
       else
       {
        Uart2_Rx=0;                                   //不是我们需要的数据或者达到最大接收数则开始重新接收
       }
      }
     }
    }
    

    数据的头标识为“\n”既换行符,尾标识为“+”。该函数将串口接收的数据存放在USART_Buffer数组中,然后先判断当前字符是不是尾标识,如果是说明接收完毕,然后再来判断头标识是不是“+”号,如果还是那么就是我们想要的数据,接下来就可以进行相应数据的处理了。但如果不是那么就让Usart2_Rx=0重新接收数据。
    这样做的有以下好处:
    1.可以接受不定长度的数据,最大接收长度可以通过Max_BUFF_Len来更改
    2.可以接受指定的数据
    3.防止接收的数据使数组越界
    这里我的把接受正确数据直接打印出来,也可以通过设置标识位,然后在主函数里面轮询再操作。

    以上的接收形式,是中断一次就接收一个字符,这在UCOS等实时内核系统中频繁的中断,非常消耗CPU资源,在有些时候我们需要接收大量数据时且波特率很高的情况下,长时间中断会带来一些额外的问题。
    所以以DMA形式配合串口的IDLE(空闲中断)来接受数据将会大大的提高CPU的利用率,减少系统资源的消耗。首先还是先看代码。

    #define DMA_USART1_RECEIVE_LEN 18
    void USART1_IRQHandler(void)                                 
    {     
        u32 temp = 0;  
        uint16_t i = 0;  
          
        if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)  
        {  
            USART1->SR;  
            USART1->DR; //这里我们通过先读SR(状态寄存器)和DR(数据寄存器)来清USART_IT_IDLE标志    
            DMA_Cmd(DMA1_Channel5,DISABLE);  
            temp = DMA_USART1_RECEIVE_LEN - DMA_GetCurrDataCounter(DMA1_Channel5); //接收的字符串长度=设置的接收长度-剩余DMA缓存大小 
            for (i = 0;i < temp;i++)  
            {  
                Uart2_Buffer[i] = USART1_RECEIVE_DMABuffer[i];  
                    
            }  
            //设置传输数据长度  
            DMA_SetCurrDataCounter(DMA1_Channel5,DMA_USART1_RECEIVE_LEN);  
            //打开DMA  
            DMA_Cmd(DMA1_Channel5,ENABLE);  
        }        
    } 
    

    之前的串口中断是一个一个字符的接收,现在改为串口空闲中断,就是一帧数据过来才中断进入一次。而且接收的数据时候是DMA来搬运到我们指定的缓冲区(也就是程序中的USART1_RECEIVE_DMABuffer数组),是不占用CPU时间资源的。

    最后在讲下DMA的发送:

    #define DMA_USART1_SEND_LEN 64
    void DMA_SEND_EN(void)
    {
     DMA_Cmd(DMA1_Channel4, DISABLE);      
     DMA_SetCurrDataCounter(DMA1_Channel4,DMA_USART1_SEND_LEN);   
     DMA_Cmd(DMA1_Channel4, ENABLE);
    }
    

    这里需要注意下DMA_Cmd(DMA1_Channel4,DISABLE)函数需要在设置传输大小之前调用一下,否则不会重新启动DMA发送。

    展开全文
  • 十六进制 HEX /hexadecimal /ˌheksəˈdesɪml/ 十进制 DEC /decimalism/'desiməlizəm/ 二进制 BIN /binary/ˈbaɪnəri/ 八进制 OCT /octonary /ˈ...串口向电脑发送数据: #include <REGX52.H> void...
  • 在进行PID参数整定的工作过程中,我需要...在整个过程中采用了Matlab来进行串口数据的读写。目前整个流程已经走通,在此将实现过程中遇到的问题,解决方法,以及尚未解决的疑问进行总结。首先声明本人是一个初学Mat...
  • 接线 星瞳教程 发送数据 接收数据 不过我比较奇怪为何它们的uart不需要初始化 openmv传送数据 1、初始化以及uart参数设置 uart pyb.UART(3, 115200) #串口3 波特率115200uart.init(115目录参考接线星瞳教程openmv...
  • STM32如何利用串口发送接收数据

    千次阅读 热门讨论 2021-05-08 11:38:49
    STM32如何利用串口发送接收数据? 我现在计划利用STM32F103X的串口对迪文屏发送及接收数据。 手中硬件:正点原子开发板(旗舰版),迪文屏(4.3寸),电脑 软件:MCU程序下载:FLYMCU;串口助手:XCOM;迪文屏配置:...
  • 串口发送数据1串口发送数据最直接的方式就是标准调用库函数 。voidUSART_SendData(USART_TypeDef*USARTx,uint16_tData); 第一个...
  • 一、我们可以通过Arduino发送数据给电脑通过串口监视器进行观察 ...二、可以通过调用函数Serial.available()来判断有没有数据发送过来,从而接收数据。 三、函数Serial.read()可以读取串口过来的数据 ...
  • stm32串口使用DMA模式接收发送数据 在cubeMX中调整DMA相关设置 在DMA Setting里点击Add添加USART1_TX,Mode有两种模式, 一种是普通模式,使用一次发送语句就发一次; 另一种是循环模式,使用一次发送会一直发送。 ...
  • 硬件平台:STM32F030CC软件平台:RT-Thread-NANO V3.1.2问题:在移植FinSH控制台时,配置串口1为中断接收,但接收到的字符是乱码的。串口数据发送正常。串口1的配置代码:static void RccConfigure(void){/* Enable ...
  • 完整性判断 while (buffer.Count >= 7) { //至少包含标头(1字节),长度(1字节),校验位(2字节)等等 //2.1 查找数据标记头 if (buffer[0] == 0x00) //传输数据有帧头,用于判断 { int len = buffer[1]; if (buffer....
  • C/C++ code//////////////////////////////////////////////////////////////////////////// 名称: SIO_Init// 说明: 8.0MHZ晶震下初始化串口波特率为1200bps// 8位数据位,1位停止位,无校验// 返回: voidvoid SIO_...
  • GD32串口接收发送数据总结

    千次阅读 2021-04-26 16:52:49
    在使用GD32串口接收数据的过程中,遇到了数据无法接收的问题,在导师的帮助下,需要调用usart_flag_get函数来使RBNE置1,RBNE:读数据时缓冲区非空,当数据缓存区接收到来自移位寄存器的数据时,该位置1. 0:读数据...
  • 串口发送接收数据

    2021-04-17 02:20:55
    1.定义串口接收数据的缓冲区,最大可以保存64个字节u8 RS485_RX_BUF1[64];2.定义接收发送数据的长度 u8 RS485_RX_CNT;3.发送数据的函数一般有两个printf和 USART_SendData,这里主要说USART_SendData的使用。printf...
  • Java接收串口数据

    2021-03-05 21:12:01
    Java使用javax.comm库接收串口数据,使用单独的线程,实时处理接收数据1.[代码][Java]代码import java.io.*;import java.util.*;import javax.comm.*;public class SerialBean implements Runnable,...
  • i++) if (support_baud[i] == baud) return 1; return 0; } static speed_t int_to_speed(int baud) { if (is_support_baud(baud)) { switch (baud) { case 0: return B0; case 50: return B50; case 75: return ...
  • 1. 选择芯片,配置串口引脚
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼请问一下为什么用串口来连接两台计算机,做发送接收,可是却没反应呢?帮我看下程序,行么?发送端的clear;s=serial('com2','baudrate',1200);set(s,'Parity','none');%...
  • 求一个单片机串口通信程序 悬赏分:50 | 解决时间:2011-9-19 22:39 |求一个PC与单片机串口通信的程序,要求如下:1、如果在电脑上发送以$开始的字符串,则将整个字符串原样返回(字符串长度不是固定的)。2、如果接收...
  • 串口可以发送数据但是无法接收数据的一种解决方案端口配置问题,一般我们的RX配置方法可能不是通用的对于AT系列的单片机我们可以把 端口配置问题,一般我们的RX配置方法可能不是通用的 我们端口配置的时候一般是这样...
  • 它是这样解释的: How it Works: WinNT The Portmon GUI is responsible for identifying serial and parallel ports. It does so by enumerating the serial ... TO:arthurtu 你是说过滤COM1的IRP,截取数据吗?
  • python串口接收数据

    2021-03-17 02:44:28
    python3.5 读取串口中的数据怎么解码数据: b'\x0e\xbeUS\xf8]m\xf6\x97Z\n'采用默认通信参数 import serial t = serial.Serial('com1',9600) n = t.write('you are my world')print t.portstrprint n str = t.read...
  • 从树莓派的相关资料我们可以看到,树莓派有两个串口可以使用,一个是硬件串口(/dev/ttyAMA0),另一个是mini串口(/dev/ttyS0)。硬件串口有单独的波特率时钟源,性能好,稳定性强;mini串口功能简单,稳定性较差,...
  • Arduino读取串口接收到的数据发送数据 源程序: void setup() { Serial.begin(115200); } void loop() { String comdata ; while (Serial.available() > 0) { comdata += char(Serial.read()); delay(2); } if...
  • 这是一个串口2收发数据的程序,本人亲测有效。 需要注意一下的是串口的初始化时钟不一样看下图 废话不多说直接上.c文件 /** ****************************************************************************** *...
  • 1 中断服务函数传输一帧数据1Byte),寄存器SBUF 2 建立缓冲区数组recv_buf[MAX_LENGTH]。其中,MAX_LENGTH***数组长度大小要大于实际接收数据长度***。因为字符串结尾是’\0’,否则会出错 unsigned char recv_...
  • 问题描述:最近在做一个关于串口读压力模块压力值的项目,用到的压力模块的基本工作原理为,通过串口向压力模块发送读压力指令"1:R:MRMD:0:0"(字符串),压力模块会返回压力值字符串"1:F:MRMD:101.00:KPA"(非定长字符...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,327
精华内容 26,530
关键字:

串口1接收的数据让串口2发送