小飒星###

2021/11/22串行口的相关问题

1.预备知识

原理

PART1：

1.简单查询方式实现一帧数据的传送

#include

void DelayXms(unsigned int xms)
{
     
	unsigned int i,j;
	for(i=xms;i>0;i--)
		for(j=124;j>0;j--);
}

void UartInit(void)		//[email protected]
{
     
	PCON &= 0x7F;		//波特率不倍速
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TB8 RB8 TI RI
	TMOD &= 0x0F;		//设置定时器1模式      0   1   0   1   0   0   0  0
	TMOD |= 0x20;		//设置定时器1为8位自动重载模式
	TL1 = 0xFA;		//设置定时初始值
	TH1 = 0xFA;		//设置定时重载值
	ET1 = 0;		//禁止定时器1中断
	TR1 = 1;		//定时器1开始计时
}

void main()
{
     
	UartInit();
	while(1)
	{
     
		//SBUF=0x88;//10位异步串口通信 0 88H 1
		//SBUF='a';//显示的是ASCALL码
		SBUF=55/10+'0';
		while(!TI);
		TI=0;
		DelayXms(1000);
	}
}

稍微改进一下：封装为传递函数sendBytes()

#include

void DelayXms(unsigned int xms)
{
     
	unsigned int i,j;
	for(i=xms;i>0;i--)
		for(j=124;j>0;j--);
}
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
 
void UartInit(void)		//[email protected]
{
     
	PCON &= 0x7F;		//波特率不倍速
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TB8 RB8 TI RI
	TMOD &= 0x0F;		//设置定时器1模式      0   1   0   1   0   0   0  0
	TMOD |= 0x20;		//设置定时器1为8位自动重载模式
	TL1 = 0xFA;		//设置定时初始值
	TH1 = 0xFA;		//设置定时重载值
	ET1 = 0;		//禁止定时器1中断
	TR1 = 1;		//定时器1开始计时
}

void main()
{
     
	UartInit();
	while(1)
	{
     
		sentByte(0x88);
		DelayXms(1000);
	}
}

2.中断方式实现一帧数据的发送

#include

void DelayXms(unsigned int xms)
{
     
	unsigned int i,j;
	for(i=xms;i>0;i--)
		for(j=124;j>0;j--);
}
 
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	TR1 = 1;		//定时器1开始计时
	ES=1;
	EA=1;
}
void uart_ISR() interrupt 4
{
     
	if(TI)
	{
     
		TI=0;
	}
}

void main()
{
     
	UartInit();
	while(1)
	{
     
		SBUF=0x88;
		DelayXms(2000);
	}
}

3.简单查询实现一串数据传输

#include

void DelayXms(unsigned int xms)
{
     
	unsigned int i,j;
	for(i=xms;i>0;i--)
		for(j=124;j>0;j--);
}
 
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	TR1 = 1;		//定时器1开始计时
}
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
void sentString(unsigned char *dat)
{
     
	while(*dat!='\0')
	{
     
		sentByte(*dat++);
	}
}
void main()
{
     
	UartInit();
	while(1)
	{
     
//		sentByte('8');
//		sentByte('\r');//回车
//		sentByte('\n');//换行
		sentString("Hello World!\r\n");
		DelayXms(1000);
	}
}

4.重定向printf

首先了解C语言51单片机里面的printf不同数据类型输出格式

#include 

void tst_printf (void) {
     
  char a = 1;
  int b  = 12365;
  long c = 0x7FFFFFFF;

  unsigned char x = 'A';
  unsigned int y  = 54321;
  unsigned long z = 0x4A6F6E00;

  float f = 10.0;
  float g = 22.95;

  char buf [] = "Test String";
  char *p = buf;

  printf ("char %bd int %d long %ld\n",a,b,c);
  printf ("Uchar %bu Uint %u Ulong %lu\n",x,y,z);
  printf ("xchar %bx xint %x xlong %lx\n",x,y,z);
  printf ("String %s is at address %p\n",buf,p);
  printf ("%f != %g\n", f, g);
  printf ("%*f != %*g\n", (int)8, f, (int)8, g);
}

正式开始

#include
#include
void DelayXms(unsigned int xms)
{
     
	unsigned int i,j;
	for(i=xms;i>0;i--)
		for(j=124;j>0;j--);
}
 
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	TR1 = 1;		//定时器1开始计时
}
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
void sentString(unsigned char *dat)
{
     
	while(*dat!='\0')
	{
     
		sentByte(*dat++);
	}
}
char putchar(char c)
{
     
	sentByte(c);
	return c;	
}
void main()
{
     
	unsigned char dat=88;
	UartInit();
	while(1)
	{
     
//		sentByte('8');
//		sentByte('\r');//回车
//		sentByte('\n');//换行
		//sentString("Hello World!\r\n");
		printf("Hello World!\r\n");
		printf("dat=%bu\r\n",dat);
		DelayXms(1000);
	}
}

PART 2：

1. 单片机串行口从上位机接受数据帧

#include
#include
unsigned char recv_data;
//void DelayXms(unsigned int xms)
//{
     
//	unsigned int i,j;
//	for(i=xms;i>0;i--)
//		for(j=124;j>0;j--);
//}
 
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	ES=1;
	EA=1;
	TR1 = 1;		//定时器1开始计时
}

void uart_ISR() interrupt 4
{
     
	if(RI)
	{
     
		RI=0;
		recv_data=SBUF;//接收数据
		recv_data=recv_data+1;
		SBUF=recv_data;//重新发送数据
	}
	if(TI)
	{
     
		TI=0;
	}
}
//void sentByte(unsigned char dat)
//{
     
//	  SBUF=dat;
//		while(!TI);
//		TI=0;//手动置位
//}
//void sentString(unsigned char *dat)
//{
     
//	while(*dat!='\0')
//	{
     
//		sentByte(*dat++);
//	}
//}
//char putchar(char c)
//{
     
//	sentByte(c);
//	return c;	
//}
void main()
{
     
	UartInit();
	while(1)
	{
     
	}
}

传送一帧数据改进(拓展一下）：

#include
#include
unsigned char recv_data;
unsigned char recv_flag=0;
//void DelayXms(unsigned int xms)
//{
     
	//unsigned int i,j;
	//for(i=xms;i>0;i--)
		//for(j=124;j>0;j--);
//}
 
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	ES=1;
	EA=1;
	TR1 = 1;		//定时器1开始计时
}

void uart_ISR() interrupt 4
{
     
	if(RI)
	{
     
		RI=0;
		recv_data=SBUF;//接收数据
		recv_flag=1;
//		recv_data=recv_data+1;
//		SBUF=recv_data;//发送数据
	}
	if(TI)
	{
     
		TI=0;
	}
}
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
//void sentString(unsigned char *dat)
//{
     
//	while(*dat!='\0')
//	{
     
//		sentByte(*dat++);
//	}
//}
char putchar(char c)
{
     
	sentByte(c);
	return c;	
}
void main()
{
     
	UartInit();
	printf("Waitfor Serial Communication Test Strat.\r\n");
	printf("Please Send a  frame of data:\r\n");
	while(1)
	{
     
		if(recv_flag==1)
		{
     
			recv_flag=0;
			recv_data=recv_data+1;
			sentByte(recv_data);
			printf("\r\n");
			printf("%bd\r\n",recv_data);
		}
	}
}

简单实现串行口输入控制LED点亮

#include
#include
unsigned char recv_data;
unsigned char recv_flag=0;
sbit LED1=P1^0;
sbit LED2=P1^1;
sbit LED3=P1^2;
sbit LED4=P1^3;
void DelayXms(unsigned int xms)
{
     
	unsigned int i,j;
	for(i=xms;i>0;i--)
		for(j=124;j>0;j--);
}
 
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	ES=1;
	EA=1;
	TR1 = 1;		//定时器1开始计时
}

void uart_ISR() interrupt 4
{
     
	if(RI)
	{
     
		RI=0;
		recv_data=SBUF;//接收数据
		recv_flag=1;
//		recv_data=recv_data+1;
//		SBUF=recv_data;//发送数据
	}
	if(TI)
	{
     
		TI=0;
	}
}
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
//void sentString(unsigned char *dat)
//{
     
//	while(*dat!='\0')
//	{
     
//		sentByte(*dat++);
//	}
//}
char putchar(char c)
{
     
	sentByte(c);
	return c;	
}
void main()
{
     
	UartInit();
	printf("Waitfor Serial Communication Test Strat.\r\n");
	printf("Please Send a  command:\r\n");
	while(1)
	{
     
		if(recv_flag==1)
		{
     
			recv_flag=0;
			switch(recv_data)
			{
     
				case 0x1:LED1=0;break;
				case 0x2:LED2=0;break;
				case 0x3:LED3=0;break;
				case 0x4:LED4=0;break;
				default:break;
			}
		}
	}
}

简单实现串口数据从上位机接受一串固定长度数据（长度已知）

#include
#include
#define MAX_REV_NUM 10
unsigned char recv_data;
unsigned char recv_flag=0;
unsigned char recv_buf[MAX_REV_NUM];
//void DelayXms(unsigned int xms)
//{
     
//	unsigned int i,j;
//	for(i=xms;i>0;i--)
//		for(j=124;j>0;j--);
//}
// 
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	ES=1;
	EA=1;
	TR1 = 1;		//定时器1开始计时
}

void uart_ISR() interrupt 4
{
     
	static unsigned char recv_cnt=0;
	if(RI)
	{
     
		RI=0;
		recv_buf[recv_cnt]=SBUF;
		recv_cnt++;
		if(recv_cnt==8)//固定长度的
		{
     
			recv_flag=1;
			recv_cnt=0;
		}
	}
}
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
void sentString(unsigned char *dat)
{
     
	while(*dat!='\0')
	{
     
		sentByte(*dat++);
	}
}
char putchar(char c)
{
     
	sentByte(c);
	return c;	
}
void main()
{
     
	UartInit();
	printf("Waitfor Serial Communication Test Strat.\r\n");
	printf("Please Send a  command:\r\n");
	while(1)
	{
     
		if(recv_flag==1)
		{
     
			recv_flag=0;
			sentString(recv_buf);
		}
	}
}

简单实现串口数据从上位机接受一串不固定长度数据（长度不固定）（缺点：当0D 作为数据是传不过去的，因为会被认为是结束符号，可以选一个不常用的符号，另外包括结束符在内的数据长度需要<=缓冲区长度）

#include
#include
#define MAX_REV_NUM 15
#define REV_CNT 10
unsigned char recv_data;
unsigned char recv_flag=0;
unsigned char recv_length;
unsigned char recv_buf[MAX_REV_NUM];
//void DelayXms(unsigned int xms)
//{
     
//	unsigned int i,j;
//	for(i=xms;i>0;i--)
//		for(j=124;j>0;j--);
//}
// 
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	ES=1;
	EA=1;
	TR1 = 1;		//定时器1开始计时
}

void uart_ISR() interrupt 4
{
     
	static unsigned char recv_cnt=0;
	unsigned char temp;
	if(RI)
	{
     
		RI=0;
		temp=SBUF;
		if(temp!=0x0D)//是否为回车符
		{
     
			recv_buf[recv_cnt]=temp;
			recv_cnt++;
			if(recv_cnt>MAX_REV_NUM)
			{
     
				recv_cnt=MAX_REV_NUM;
			}
			else
			{
     
				recv_flag=1;
				recv_length=recv_cnt;
				recv_cnt=0;
			}
		}
	}
}
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
void sentString(unsigned char *dat)
{
     
	while(*dat!='\0')
	{
     
		sentByte(*dat++);
	}
}
char putchar(char c)
{
     
	sentByte(c);
	return c;	
}
void main()
{
     
	unsigned char i;
	UartInit();
	printf("Waitfor Serial Communication Test Strat.\r\n");
	printf("Please Send a  command:\r\n");
	while(1)
	{
     
		if(recv_flag==1)
		{
     
			recv_flag=0;
			//sentString(recv_buf);
			for(i=0;i<recv_length;i++)
			{
     
				sentByte(recv_buf[i]);
			}
		}
	}
}

Part3:串口+定时器超时检测实现接收一串数据

#include
#include
#define MAX_REV_NUM 20
#define REV_CNT 10
#define MAX_REV_TIME 5
unsigned char recv_flag=0;
unsigned char recv_timer_cnt;
unsigned char start_timer=0;
unsigned char recv_cnt;
unsigned char recv_buf[MAX_REV_NUM];
//void DelayXms(unsigned int xms)
//{
     
//	unsigned int i,j;
//	for(i=xms;i>0;i--)
//		for(j=124;j>0;j--);
//}
// 
//串口初始化和串口中断服务函数
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	ES=1;
	TR1 = 1;		//定时器1开始计时
}

void uart_ISR() interrupt 4
{
     
	//static unsigned char recv_cnt=0;
	if(RI)
	{
     
		RI=0;
		start_timer=1;//1.每接收第一帧数据的时候，打开软件定时器去计数
		if(recv_cnt<MAX_REV_NUM)
		{
     
			recv_buf[recv_cnt]=SBUF;//2.接收数据到数据缓冲区，注意缓冲区的大小范围问题
			recv_cnt++;
		}
		else
		{
     
			recv_cnt=MAX_REV_NUM;
		}
		recv_timer_cnt=0;//3.每接收一帧数据，记得把定时计数器清零，相当于信号                 //但是在定时中断里面会不断累加
	}
	if(TI)
	{
     
		TI=0;
	}
}
/**************************************************/
/**************************************************/


//定时器0的初始化和中断服务函数
void Timer0Init(void)		//1毫秒@11.0592MHz
{
     
	TMOD &= 0xF0;		//设置定时器模式
	TMOD |= 0x01;		//设置定时器模式
	TL0 = 0x66;		//设置定时初始值
	TH0 = 0xFC;		//设置定时初始值
	TF0 = 0;		//清除TF0标志
	ET0=1;
	TR0 = 1;		//定时器0开始计时
}
void timer0_ISR() interrupt 1
{
     
	TR0=0;
	if(start_timer==1)
	{
     
		recv_timer_cnt++;//1.累加定时时间计算器
		if(recv_timer_cnt>MAX_REV_TIME)//2.判断定时时间是否超过约定的最大阈值，超过则说明等待一段时间后没有新的数据到			                              
		{
       			我们判断一包数据接收完毕
			recv_timer_cnt=0;//3.清除定时计数器，处理数据，清除buffer(放到数据处理之后）
			recv_cnt=0;
			recv_flag=1;
		}
	}
	TL0 = 0x66;		//设置定时初始值
	TH0 = 0xFC;		//设置定时初始值
	TR0=1;
}
/**************************************************/
/**************************************************/


//传一位数据
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
/**************************************************/
/**************************************************/


//传一串数据
void sentString(unsigned char *dat)
{
     
	while(*dat!='\0')
	{
     
		sentByte(*dat++);
	}
}
/**************************************************/
/**************************************************/


//printf重定向
char putchar(char c)
{
     
	sentByte(c);
	return c;	
}
/**************************************************/
/**************************************************/


//清除缓冲区
void clr_recvbuffer(unsigned char *buf)
{
     
	unsigned char i;
	for(i=0;i<MAX_REV_NUM;i++)
	{
     
		buf[i]=0;
	}
}
/**************************************************/
/**************************************************/


/*主函数*/
void main()
{
     
	Timer0Init();
	UartInit();
	EA=1;
	printf("Waitfor Serial Communication Test Strat.\r\n");
	printf("Please Send a  command:\r\n");
	while(1)
	{
     
	  if(recv_flag)
		{
     
			recv_flag=0;
			start_timer=0;//关掉定时器
			sentString(recv_buf);//处理数据
			clr_recvbuffer(recv_buf);//清除缓冲buffer
		}
	}
}

在这里插入代码片

判读数据帧头来接收一串数据的串口通信程序编写

#include
#include
#define MAX_REV_NUM 20
#define REV_CNT 10
#define MAX_REV_TIME 5
sbit LED=P1^0;
unsigned char recv_flag=0;
unsigned char recv_timer_cnt;
unsigned char start_timer=0;
unsigned char recv_cnt;
unsigned char recv_buf[MAX_REV_NUM];
//void DelayXms(unsigned int xms)
//{
     
//	unsigned int i,j;
//	for(i=xms;i>0;i--)
//		for(j=124;j>0;j--);
//}
// 
//串口初始化和串口中断服务函数
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	ES=1;
	TR1 = 1;		//定时器1开始计时
}

void uart_ISR() interrupt 4
{
     
	//static unsigned char recv_cnt=0;
	if(RI)
	{
     
		RI=0;
		start_timer=1;//1.每接收第一帧数据的时候，打开软件定时器去计数
		if(recv_cnt<MAX_REV_NUM)
		{
     
			recv_buf[recv_cnt]=SBUF;//2.接收数据到数据缓冲区，注意缓冲区的大小范围问题
			recv_cnt++;
		}
		else
		{
     
			recv_cnt=MAX_REV_NUM;
		}
		recv_timer_cnt=0;//3.每接收一帧数据，记得把定时计数器清零，相当于信号                 //但是在定时中断里面会不断累加
	}
	if(TI)
	{
     
		TI=0;
	}
}
/**************************************************/
/**************************************************/


//定时器0的初始化和中断服务函数
void Timer0Init(void)		//1毫秒@11.0592MHz
{
     
	TMOD &= 0xF0;		//设置定时器模式
	TMOD |= 0x01;		//设置定时器模式
	TL0 = 0x66;		//设置定时初始值
	TH0 = 0xFC;		//设置定时初始值
	TF0 = 0;		//清除TF0标志
	ET0=1;
	TR0 = 1;		//定时器0开始计时
}
void timer0_ISR() interrupt 1
{
     
	TR0=0;
	if(start_timer==1)
	{
     
		recv_timer_cnt++;//1.累加定时时间计算器
		if(recv_timer_cnt>MAX_REV_TIME)//2.判断定时时间是否超过约定的最大阈值，超过则说明等待一段时间后没有新的数据到			                              
		{
       			我们判断一包数据接收完毕
			recv_timer_cnt=0;//3.清除定时计数器，处理数据，清除buffer(放到数据处理之后）
			//recv_cnt=0;
			recv_flag=1;
		}
	}
	TL0 = 0x66;		//设置定时初始值
	TH0 = 0xFC;		//设置定时初始值
	TR0=1;
}
/**************************************************/
/**************************************************/


//传一位数据
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
/**************************************************/
/**************************************************/


//传一串数据
void sentString(unsigned char *dat)
{
     
	while(*dat!='\0')
	{
     
		sentByte(*dat++);
	}
}
/**************************************************/
/**************************************************/


//printf重定向
char putchar(char c)
{
     
	sentByte(c);
	return c;	
}
/**************************************************/
/**************************************************/


//清除缓冲区
void clr_recvbuffer(unsigned char *buf)
{
     
	unsigned char i;
	for(i=0;i<MAX_REV_NUM;i++)
	{
     
		buf[i]=0;
	}
}
/**************************************************/
/**************************************************/
void uart_service(unsigned char *buf)
{
     
	unsigned char recv_move_index;
	if(recv_flag)
		{
     
			recv_flag=0;
			start_timer=0;//关掉定时器
			sentString(buf);//处理数据
      while((recv_cnt>=5)&&(recv_move_index<=recv_cnt))
			{
     
				if((buf[recv_move_index+0]==0x55)&&(buf[recv_move_index+1]==0xAA)&&(buf[recv_move_index+2]==0x55))
				{
     
					if((buf[recv_move_index+3]==0x01)&&(buf[recv_move_index+4]==0x02))
					{
     
						LED=0;
						break;
					}
					if((buf[recv_move_index+3]==0x02)&&(buf[recv_move_index+4]==0x01))
					{
     
						LED=1;
						break;
					}
				}
			}
			recv_cnt=0;
			clr_recvbuffer(recv_buf);//清除缓冲buffer
		}
}

/*主函数*/
void main()
{
     
	Timer0Init();
	UartInit();
	EA=1;
	printf("Waitfor Serial Communication Test Strat.\r\n");
	printf("Please Send a  command:\r\n");
	while(1)
	{
     
		uart_service(recv_buf);
	}
}

串口中断中即时解析数据帧头的通信程序（<帧头>AA 55 +01或02+两位数据+0D<帧尾>）

#include
#include
#define MAX_REV_NUM 20
#define REV_CNT 10
#define MAX_REV_TIME 5
sbit LED=P1^0;
sbit BUZZER=P3^7;
unsigned char recv_flag=0;
unsigned char recv_timer_cnt;
unsigned char start_timer=0;
unsigned char recv_cnt;
unsigned char machine_step;
unsigned char recv_buf[MAX_REV_NUM];
unsigned int led_data;
unsigned int beep_data;
unsigned int led_cnt;
unsigned int beep_cnt;
void DelayXms(unsigned int xms)
{
     
	unsigned int i,j;
	for(i=xms;i>0;i--)
		for(j=124;j>0;j--);
}
 
//串口初始化和串口中断服务函数
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	ES=1;
	TR1 = 1;		//定时器1开始计时
}

void uart_ISR() interrupt 4
{
     
	
	if(RI)
	{
     
		RI=0;
		switch(machine_step)
		{
     
			case 0:recv_buf[0]=SBUF;
			  if(recv_buf[0]==0xAA)
				{
     
					machine_step=1;
				}
				else
				{
     
					machine_step=0;
				}
			  break;
			case 1:recv_buf[1]=SBUF;
				if(recv_buf[1]==0x55)
				{
     
					machine_step=2;
					recv_cnt=2;
				}
				else
				{
     
					machine_step=0;
				}
			  break;
			case 2:recv_buf[recv_cnt]=SBUF;
				recv_cnt++;
				if(recv_cnt>4)
				{
     
					machine_step=3;
				}
				else
				{
     
					machine_step=2;
				}
				break;
			case 3:recv_buf[recv_cnt]=SBUF;
				if(recv_buf[recv_cnt]==0x0D)
				{
     
					switch(recv_buf[2])
					{
     
						case 1:led_data=recv_buf[3];
						       led_data=led_data<<8;
						       led_data=led_data+recv_buf[4];
						       led_cnt=0;//目的是使得LED点亮上述接收数据时间
						       break;
						case 2:beep_data=recv_buf[3];
						       beep_data=beep_data<<8;
						       beep_data=beep_data+recv_buf[4];
						       beep_cnt=beep_data;
						       break;
						default:break;
					}
					machine_step=0;
					recv_cnt=0;
					recv_flag=1;//接收完一串数据，标志为1
				}
				break;
			default:break;	
		}
	}
	if(TI)
	{
     
		TI=0;
	}
}
/**************************************************/
/**************************************************/


//定时器0的初始化和中断服务函数
void Timer0Init(void)		//1毫秒@11.0592MHz
{
     
	TMOD &= 0xF0;		//设置定时器模式
	TMOD |= 0x01;		//设置定时器模式
	TL0 = 0x66;		//设置定时初始值
	TH0 = 0xFC;		//设置定时初始值
	TF0 = 0;		//清除TF0标志
	ET0=1;
	TR0 = 1;		//定时器0开始计时
}
void timer0_ISR() interrupt 1
{
     
	TR0=0;
	if(led_cnt<led_data)
	{
     
		led_cnt++;
		LED=0;
	}
	else{
     
		LED=1;
	}
	if(beep_cnt!=0)
	{
     
		beep_cnt--;
		BUZZER=~BUZZER;
	}

	TL0 = 0x66;		//设置定时初始值
	TH0 = 0xFC;		//设置定时初始值
	TR0=1;
}
/**************************************************/
/**************************************************/


//传一位数据
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
/**************************************************/
/**************************************************/


//传一串数据
void sentString(unsigned char *dat)
{
     
	while(*dat!='\0')
	{
     
		sentByte(*dat++);
	}
}
/**************************************************/
/**************************************************/


//printf重定向
char putchar(char c)
{
     
	sentByte(c);
	return c;	
}
/**************************************************/
/**************************************************/


//清除缓冲区
void clr_recvbuffer(unsigned char *buf)
{
     
	unsigned char i;
	for(i=0;i<MAX_REV_NUM;i++)
	{
     
		buf[i]=0;
	}
}
/**************************************************/
/**************************************************/



/*主函数*/
void main()
{
     
	Timer0Init();
	UartInit();
	EA=1;
	printf("Waitfor Serial Communication Test Strat.\r\n");
	printf("Please Send a  command:\r\n");
	DelayXms(10);
	BUZZER=0;
	while(1)
	{
     
		if(recv_flag==1)
		{
     
			recv_flag=0;
			sentString(recv_buf);
			clr_recvbuffer(recv_buf);
		}
	}
}

Part 3：串口中断即时解析用户自定义通讯协议（接收数据字节固定）的编程实现(固定长度）

点击这里可以进行校验的计算

#include
#include
#define MAX_REV_NUM 20
#define REV_CNT 10
#define MAX_REV_TIME 5
sbit LED=P1^0;
sbit BUZZER=P3^7;
unsigned char recv_flag=0;
unsigned char recv_timer_cnt;
unsigned char start_timer=0;
unsigned char recv_cnt;
unsigned char machine_step;
unsigned char recv_buf[MAX_REV_NUM];
unsigned int led_data;
unsigned int beep_data;
unsigned int led_cnt;
unsigned int beep_cnt;
void DelayXms(unsigned int xms)
{
     
	unsigned int i,j;
	for(i=xms;i>0;i--)
		for(j=124;j>0;j--);
}
/**************************************************/
/**************************************************/


//传一位数据
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
/**************************************************/
/**************************************************/

 
//printf重定向
char putchar(char c)
{
     
	sentByte(c);
	return c;	
}
/**************************************************/
/**************************************************/


//传一串数据
void sentString(unsigned char *dat)
{
     
	while(*dat!='\0')
	{
     
		sentByte(*dat++);
	}
}



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


//清除缓冲区
void clr_recvbuffer(unsigned char *buf)
{
     
	unsigned char i;
	for(i=0;i<MAX_REV_NUM;i++)
	{
     
		buf[i]=0;
	}
}
/**************************************************/
/**************************************************/

//串口初始化和串口中断服务函数
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	ES=1;
	TR1 = 1;		//定时器1开始计时
}

void uart_ISR() interrupt 4
{
     
	
	unsigned char recv_data;//接收数据的中间变量
	static unsigned char sum_check;
	static unsigned char xor_check;
	if(RI)
	{
     
		RI=0;
		recv_data=SBUF; 
		
		switch(machine_step)
		{
     
			case 0:
			  if(recv_data==0x55)
				{
     
					machine_step=1;
					sentByte('A');
					
				}
				else
				{
     
					machine_step=0;
				}
			  break;
			case 1:
				if(recv_data==0xAA)
				{
     
					machine_step=2;
					sentByte('A');
					recv_cnt=0;
				}
				else
				{
     
					machine_step=0;
				}
			  break;
			case 2://开始和校验，异或校验
				sum_check+=recv_data;
			  xor_check^=recv_data;
			  recv_buf[recv_cnt]=recv_data;
				recv_cnt++;
			  sentByte('A');
				if(recv_cnt>2)//数据固定长度，可以手动设置
				{
     
					machine_step=3;
				}
				else
				{
     
					machine_step=2;
				}
				break;
			case 3:
				  if(sum_check==recv_data)//和校验正确
					{
     
						machine_step=4;
					}
					else
					{
     
						machine_step=0;
						printf("SUM CHECK ERROR!\r\n");
					}
					break;
			case 4:
				  if(xor_check==recv_data)//异或校验正确
					{
     
						recv_flag=1;//正确接收一串数据
						sentByte('A');
					}
					else
					{
     
						printf("XOR CHECK ERROR!\r\n");
					}
					machine_step=0;
					recv_cnt=0;
          sum_check=0;
					xor_check=0;
				break;
			default:break;	
		}
	}
	if(TI)
	{
     
		TI=0;
	}
}
/**************************************************/
/**************************************************/


//定时器0的初始化和中断服务函数
void Timer0Init(void)		//1毫秒@11.0592MHz
{
     
	TMOD &= 0xF0;		//设置定时器模式
	TMOD |= 0x01;		//设置定时器模式
	TL0 = 0x66;		//设置定时初始值
	TH0 = 0xFC;		//设置定时初始值
	TF0 = 0;		//清除TF0标志
	ET0=1;
	TR0 = 1;		//定时器0开始计时
}
void timer0_ISR() interrupt 1
{
     
	TR0=0;
	if(led_cnt<led_data)
	{
     
		led_cnt++;
		LED=0;
	}
	else{
     
		LED=1;
	}
	if(beep_cnt!=0)
	{
     
		beep_cnt--;
		BUZZER=~BUZZER;
	}

	TL0 = 0x66;		//设置定时初始值
	TH0 = 0xFC;		//设置定时初始值
	TR0=1;
}


/*主函数*/
void main()
{
     
	Timer0Init();
	UartInit();
	EA=1;
	printf("Waitfor Serial Communication Test Strat.\r\n");
	printf("Please Send a  command:\r\n");
	DelayXms(10);
	BUZZER=0;
	while(1)
	{
     
		if(recv_flag==1)
		{
     
			recv_flag=0;
			sentString(recv_buf);
      switch(recv_buf[0])
			{
     
					case 1:led_data=recv_buf[1];
						     led_data=led_data<<8;
						     led_data=led_data+recv_buf[2];
						     led_cnt=0;//目的是使得LED点亮上述接收数据时间
						     break;
				  case 2:beep_data=recv_buf[1];
						     beep_data=beep_data<<8;
						     beep_data=beep_data+recv_buf[2];
						     beep_cnt=beep_data;
						     break;
				 default:
					 	clr_recvbuffer(recv_buf);
				 break;
			}
		}
	}
}

串口中断即时解析用户自定义通讯协议（协议内带字节长度及接收应答处理）的编程实现

#include
#include
#define MAX_REV_NUM 20
#define REV_CNT 10
#define MAX_REV_TIME 5
sbit LED=P1^0;
sbit BUZZER=P3^7;
#define GPIO_DIG P0  //断码IO口
#define GPIO_PLACE P2  //位选IO口
#define N  4           //数码管个数
unsigned char LEDBUF[]={
     0,0,0,0};//数据显示缓冲区
unsigned char code PLACE_CODE[]={
     0x01,0x02,0x04,0x08};//位信号
unsigned char recv_flag=0;
unsigned char recv_timer_cnt;
unsigned char start_timer=0;
unsigned char recv_cnt;
unsigned char machine_step;
unsigned char recv_buf[MAX_REV_NUM];
unsigned char recv_length;
unsigned char code recv_correct[]={
     0x55,0xAA,0x80,0x0,0x80,0x80};
unsigned char code sum_check_error[]={
     0x55,0xAA,0x81,0x0,0x81,0x81};
unsigned char code xor_check_error[]={
     0x55,0xAA,0x82,0x0,0x82,0x82};
unsigned char leddata[]={
      

						0xC0,  //"0"
						0xF9,  //"1"
						0xA4,  //"2"
						0xB0,  //"3"
						0x99,  //"4"
						0x92,  //"5"
						0x82,  //"6"
						0xF8,  //"7"
						0x80,  //"8"
						0x90,  //"9"
						0x88,  //"A"
						0x83,  //"B"
						0xC6,  //"C"
						0xA1,  //"D"
						0x86,  //"E"
						0x8E,  //"F"
						0x89,  //"H"
						0xC7,  //"L"
						0xC8,  //"n"
						0xC1,  //"u"
						0x8C,  //"P"
						0xA3,  //"o"
						0xBF,  //"-"
						0xFF,  //熄灭
};
/**************************************************/
/**************************************************/


void DelayXms(unsigned int xms)
{
     
	unsigned int i,j;
	for(i=xms;i>0;i--)
		for(j=124;j>0;j--);
}
/**************************************************/
/**************************************************/


void Display()
{
     
	 unsigned char i;
	//unsigned char i;
	//1,送段码
	
	//2.送位选
	
	//3.延时1ms<10ms
	
	//4.消隐
	switch(i)
	{
     
		case 0:
		  GPIO_DIG=leddata[LEDBUF[0]];
		  GPIO_PLACE=PLACE_CODE[0];
		  DelayXms(1);
		  GPIO_DIG=0xff;
		  i++;
		  break;
			
		case 1:
		  GPIO_DIG=leddata[LEDBUF[1]];
		  GPIO_PLACE=PLACE_CODE[1];
		  DelayXms(1);
		  GPIO_DIG=0xff;
		  i++;
		  break;
			
		case 2:
		  GPIO_DIG=leddata[LEDBUF[2]];
		  GPIO_PLACE=PLACE_CODE[2];
		  DelayXms(1);
		  GPIO_DIG=0xff;
		  i++;
		  break;
			
		case 3:
		  GPIO_DIG=leddata[LEDBUF[3]];
		  GPIO_PLACE=PLACE_CODE[3];
		  DelayXms(1);
		  GPIO_DIG=0xff;
		  i=0;
		  break;	
		default:break;
	}
}

//传一位数据
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
/**************************************************/
/**************************************************/

 
//printf重定向
char putchar(char c)
{
     
	sentByte(c);
	return c;	
}
/**************************************************/
/**************************************************/


//传一串数据
void sentString(unsigned char *dat)
{
     
	while(*dat!='\0')
	{
     
		sentByte(*dat++);
	}
}
/**************************************************/
/**************************************************/


//清除缓冲区
void clr_recvbuffer(unsigned char *buf)
{
     
	unsigned char i;
	for(i=0;i<MAX_REV_NUM;i++)
	{
     
		buf[i]=0;
	}
}
/**************************************************/
/**************************************************/

//串口初始化和串口中断服务函数
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	ES=1;
	TR1 = 1;		//定时器1开始计时
}

void uart_ISR() interrupt 4
{
     
	
	unsigned char i;
	unsigned char recv_data;//接收数据的中间变量
	static unsigned char sum_check;
	static unsigned char xor_check;
	if(RI)
	{
     
		RI=0;
		recv_data=SBUF; 
		
		switch(machine_step)
		{
     
			case 0:
			  if(recv_data==0x55)
				{
     
					machine_step=1;
					
				}
				else
				{
     
					machine_step=0;
				}
			  break;
			case 1:
				if(recv_data==0xAA)
				{
     
					machine_step=2;
					recv_cnt=0;
				}
				else
				{
     
					machine_step=0;
				}
			  break;
			case 2://开始和校验，异或校验
				sum_check=recv_data;
			  xor_check=recv_data;
			  recv_buf[recv_cnt]=recv_data;
				recv_cnt++;
				machine_step=3;
				break;
			case 3:
				  sum_check+=recv_data;
			    xor_check^=recv_data;
				  recv_length=recv_data;
			    machine_step=4;
					break;
			case 4:
				  sum_check+=recv_data;
			    xor_check^=recv_data;
			    recv_buf[recv_cnt]=recv_data;
			    if(recv_cnt>=recv_length)
					{
     
						machine_step=5;
					}
					else
					{
     
						machine_step=4;
					}
					recv_cnt++;
					break;
			case 5:
				  if(sum_check==recv_data)
					{
     
						machine_step=6;
					}
					else
					{
     
						machine_step=0;
						for(i=0;i<6;i++)
						{
     
							sentByte(sum_check_error[i]);
						}
					}
				break;
			case 6:
				  if(xor_check==recv_data)
					{
     
						recv_flag=1;//正确接收一串数据
						for(i=0;i<6;i++)
						{
     
							sentByte(recv_correct[i]);
						}
					}
					else{
     
						for(i=0;i<6;i++)
						{
     
							sentByte(xor_check_error[i]);
						}
					}
					machine_step=0;
					recv_cnt=0;
					sum_check=0;
					xor_check=0;
					break;
		  default:break;	
		}
	}
	if(TI)
	{
     
		TI=0;
	}
}
/**************************************************/
/**************************************************/


//定时器0的初始化和中断服务函数
void Timer0Init(void)		//1毫秒@11.0592MHz
{
     
	TMOD &= 0xF0;		//设置定时器模式
	TMOD |= 0x01;		//设置定时器模式
	TL0 = 0x66;		//设置定时初始值
	TH0 = 0xFC;		//设置定时初始值
	TF0 = 0;		//清除TF0标志
	ET0=1;
	TR0 = 1;		//定时器0开始计时
}
void timer0_ISR() interrupt 1
{
     
	TR0=0;
	Display();
	TL0 = 0x66;		//设置定时初始值
	TH0 = 0xFC;		//设置定时初始值
	TR0=1;
}


/*主函数*/
void main()
{
     
	Timer0Init();
	UartInit();
	EA=1;
	printf("Waitfor Serial Communication Test Strat.\r\n");
	printf("Please Send a  command:\r\n");
	DelayXms(10);
	BUZZER=0;
	while(1)
	{
     
		if(recv_flag==1)
		{
     
			recv_flag=0;
			switch(recv_buf[0])
			{
     
				case 1:
					LEDBUF[0]=23;
				  LEDBUF[1]=23;
				  LEDBUF[2]=recv_buf[1]>>4;
				  LEDBUF[3]=recv_buf[1]&0x0F;
					break;
				case 2:
					LEDBUF[0]=recv_buf[1]>>4;
				  LEDBUF[1]=recv_buf[1]&0x0F;
				  LEDBUF[2]=recv_buf[2]>>4;
				  LEDBUF[3]=recv_buf[2]&0x0F;
					break;
				case 3:
					LEDBUF[0]=recv_buf[1]>>4;
				  LEDBUF[1]=recv_buf[1]&0x0F;
				  LEDBUF[2]=recv_buf[2]>>4;
				  LEDBUF[3]=recv_buf[2]&0x0F;
					break;
				default:break;
			}
     
		}
	}
}

#include
#include
unsigned char recv_data;
unsigned char recv_flag=0;
unsigned char *H=0x30;
unsigned char *Q=0x40;
//void DelayXms(unsigned int xms)
//{
     
	//unsigned int i,j;
	//for(i=xms;i>0;i--)
		//for(j=124;j>0;j--);
//}
 
void UartInit(void)		//[email protected]
{
     
	SCON = 0x50;		//8位数据,可变波特率
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;		//设置定时初始值
	TH1 = 0xFD;		//设置定时重载值
	ET1 = 0;		//禁止定时器%d中断
	ES=1;
	EA=1;
	TR1 = 1;		//定时器1开始计时
}

void uart_ISR() interrupt 4
{
     
	if(RI)
	{
     
		RI=0;
		if(0xAA==SBUF)
		{
     
			while(H<=0x3F)
			{
     
				SBUF=*H;
				H++;
				while(!TI);
				TI=0;
			}
			H=0x30;
		}
		else if(0xE0==SBUF)
		{
     
			while(Q<=0x5F)
			{
     
				SBUF=*Q;
				Q++;
				while(!TI);
				TI=0;
			}
			Q=0x40;
		}
		else{
     
      recv_data=SBUF;//接收数据
      SBUF=recv_data;//发送数据
		}
		recv_flag=1;
	}
	if(TI)
	{
     
		TI=0;
	}
}
void sentByte(unsigned char dat)
{
     
	  SBUF=dat;
		while(!TI);
		TI=0;//手动置位
}
void sentString(unsigned char *dat)
{
     
	while(*dat!='\0')
	{
     
		sentByte(*dat++);
	}
}
char putchar(char c)
{
     
	sentByte(c);
	return c;	
}
void main()
{
     
	UartInit();
	sentString("Hello Server!\r\n");
	printf("Waitfor Serial Communication Test Strat.\r\n");
	printf("Please Send a  frame of data:\r\n");
	while(1)
	{
     
		if(recv_flag==1)
		{
     
			recv_flag=0;
			//sentByte(recv_data);
		}
	}
}

拓展：循环冗余校验

你可能感兴趣的:(单片机,嵌入式硬件,矩阵)

推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程极客小张 stm32 qt 机器人物联网人机交互毕业设计 c语言
一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
matlab delsat = setdiff(1:69,unique(Eph(30,:)))；语句含义黄卷青灯77 matlab 开发语言 setdiff
这行MATLAB代码用于计算在范围1:69中不包含在Eph矩阵第30行的唯一值集合中的所有元素。具体解释如下：delsat=setdiff(1:69,unique(Eph(30,:)));解释Eph(30,:)Eph(30,:)提取矩阵Eph的第30行的所有列元素。这是一个行向量，包含了第30行的所有值。unique(Eph(30,:))unique函数返回Eph(30,:)中的唯一元素。这意味着
高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
（1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
51单片机——I2C总线存储器24C02的应用老侯（Old monkey） 51单片机嵌入式硬件单片机
目标实现功能单片机先向24C02写入256个字节的数据，再从24C02中一次读取2个字节的数据、并在数码管上动态显示，直至读完24C02中256个字节的数据。1.I2C总线简介I2C总线有两根双向的信号线，一根是数据线SDA,另一根是时钟线SCL。I2C总线通过上拉电阻接正电源，因此，当总线空闲时为高电平。2.I2C通信协议起始信号、停止信号由主机发出。在数据传送时，当时钟线为高电平时，数据线上的
嵌入式单片机中数码管基本实现方法嵌入式开发星球单片机项目实战操作之优秀单片机
1.点亮数码管本节课利用已经学习的LED知识去控制一个8位数码管。本节的原理比较简单。不需要多少时间讲。更多时间是跟大家一起编码调试，从中学习一些编码思路和学习方法。1.1.什么是数码管数码管是什么？下图就是一个数码管从硬件上个看，其实就是8个LED组合在一起。8个LED应该有16个引脚，但是数码管上只有10个引脚。为什么呢？请看下图：1个LED有两个引脚，要控制LED，1个引脚接控制信号，另外一
【机器人建模和控制】读书笔记 Piccab0o 机器人
机器人建模和控制——马克·斯庞A.x10=x1∙x0x^0_1=x_1\bulletx_0x10=x1∙x0，其实就是：1）x1x_1x1轴向量在O0O_0O0系下的坐标2）在x0x_0x0轴上的投影3）坐标变换矩阵的R10R_1^0R10的第一个元素B.点p在o1x1y1z1o_1x_1y_1z_1o1x1y1z1系下的坐标p1p^1p1可以表示为：p=ux1+vy1+wz1p=ux_1+vy_
python 读写csv文件方法菩提本无树007 python pandas 开发语言
csv是一种结构化文件，可以将文本转化成矩阵的形式，方便程序读取和处理。下面来介绍一下使用python读写csv文件的方法：1.首先需要使用pip安装python包，然后将csv文件解压到一个文件夹下2.使用pip安装python包，安装完成后在终端输入：3.在终端输入命令：4.输入完成后，打开终端，在命令行输入以下代码：5.最后输出结果，可以看到csv文件已经打开了。6.将csv文件放入到pyt
MATLAB语言基础教程、小项目1：简单的计算器、小项目2：有页面的计算器、使用App Designer创建GUI计算器 azuredragonz 学习教程 matlab 开发语言
MATLABMATLAB语言基础教程1.MATLAB简介2.基本语法变量与赋值向量与矩阵矩阵运算数学函数控制流3.函数4.绘图案例：简单方程求解小项目1：简单的科学计算器功能代码项目说明小项目2：有页面的计算器使用AppDesigner创建GUI计算器主要步骤：完整代码（使用MATLAB编写）说明：如何运行：小项目总结MATLAB语言基础教程1.MATLAB简介MATLAB（矩阵实验室）是一种用于
np.identity()/np.eye() 听风1996
两个函数的原型为：np.identity(n,dtype=None)np.eye(N,M=None,k=0,dtype=)；np.identity只能创建方形矩阵np.eye可以创建矩形矩阵，且k值可以调节，为1的对角线的位置偏离度，0居中，1向上偏离1，2偏离2，以此类推，-1向下偏离。值绝对值过大就偏离出去了，整个矩阵就全是0了。两者在创建单位矩阵上，并无区别，两者的区别主要在接口上；np.i
图像匹配---（Python）阳光下的Smiles Python图像处理
图像匹配---（Python）图像匹配分为以灰度为基础的匹配和以特征为基础的匹配：（1）灰度匹配是基于像素的匹配。灰度匹配通过利用某种相似性度量，如相关函数、协方差函数、差平方和、差绝对值和等测度极值，判定两幅图像中的对应关系。（2）特征匹配则是基于区域的匹配。基于特征的匹配所处理的图像一般包含的特征有颜色特征、纹理特征、形状特征、空间位置特征等1、差分矩阵求和差分矩阵=图像A矩阵数据-图像B矩阵
洛谷P1719 最大加权矩形 0hang 算法 c++开发语言
洛谷P1719最大加权矩形题目描述为了更好的备战NOIP2013，电脑组的几个女孩子LYQ,ZSC,ZHQ认为，我们不光需要机房，我们还需要运动，于是就决定找校长申请一块电脑组的课余运动场地，听说她们都是电脑组的高手，校长没有马上答应他们，而是先给她们出了一道数学题，并且告诉她们：你们能获得的运动场地的面积就是你们能找到的这个最大的数字。校长先给他们一个n\timesnn×n矩阵。要求矩阵中最大加
4×4矩阵键盘详解（STM32）辰哥单片机设计 STM32传感器教学矩阵计算机外设 stm32 嵌入式硬件单片机传感器
目录一、介绍二、传感器原理1.原理图2.工作原理介绍三、程序设计main.c文件button4_4.h文件button4_4.c文件四、实验效果五、资料获取项目分享一、介绍矩阵键盘，又称为行列式键盘，是用4条I/O线作为行线，4条I/O线作为列线组成的键盘。在行线和列线的每一个交叉点上设置一个按键，因此键盘中按键的个数是4×4个。这种行列式键盘结构能够有效地提高单片机系统中I/O口的利用率，节约单
抖音开始怎么吸粉（可以试试这几种办法）配音新手圈
如何在抖音短视频平台上快速积累人气和粉丝，抖音短视频平台已成为“我们媒体”和全媒体矩阵，是客户获取、推广和收入的重要平台之一。兼职副业推荐公众号，配音新手圈，声优配音圈，新配音兼职圈，配音就业圈，鼎音副业，有声新手圈，每天更新各种远程工作与在线兼职，职位包括：写手、程序开发、剪辑、设计、翻译、配音、无门槛、插画、翻译、等等。。。每日更新兼职。但对于初学者来说，如何在抖音上建立自己的品牌，积累粉丝，
云服务业界动态简报-20180128 Captain7
一、青云青云QingCloud推出深度学习平台DeepLearningonQingCloud，包含了主流的深度学习框架及数据科学工具包，通过QingCloudAppCenter一键部署交付，可以让算法工程师和数据科学家快速构建深度学习开发环境，将更多的精力放在模型和算法调优。二、腾讯云1.腾讯云正式发布腾讯专有云TCE(TencentCloudEnterprise)矩阵，涵盖企业版、大数据版、AI
学单片机怎么在3-5个月内找到工作？无际单片机编程单片机嵌入式开发物联网 stm32 c语言
每个初学者，都如履薄冰，10几年前，我自学单片机时，也一样。想通过学习，找一份体面点的工作，又害怕辛辛苦苦学出来，找不到工作。好在，当初执行力，还算可以，自学java没成功，后面自学单片机，成功入行了。转眼间，毕业到现在有13年了，马上也到了奔4的年纪。这13年一直在跟单片机打交道，打过工，创过业，对行业，对企业，都有一定的认知，坚持看完这篇内容，相信能帮你少走几个月弯路。有些老铁，加了我很久，时
51单片机：P3.3口输入/P 1口输出实验 li星野单片机
51单片机：P3.3口输入/P1口输出实验一、实验内容1P3.3口做输入口，外接一脉冲,每输入一个脉冲,P1口按十六进制除2（乘2）。2.P1口做输出口，P1口接的8个发光二极管L1—L8按十六进制除2（乘2）方式点亮。二、仿真图三、代码实现C语言实现：#include#includesbitKEY=P3^3;voiddelay10ms(void);voidmain(){charnum=0xfe;
2020-11-12 写单片机内存的脚本 nc openocd 事务自动测试 linuxScripter
这是写单片机内存的脚本：z@z-ThinkPad-T400:~/zworkT400/EDA_heiche/zREPOgit/simple-gcc-stm32-project$catz.wholeRun.oneCase.cmdcattmp6.toWrite|awk'{system("echomwb"$1""$2"|nclocalhost4444");}'catUSER/DEBUG/debug.h|g
开微信公众号怎么赚钱？解析盈利策略与实操指南氧惠_飞智666999
微信公众号成为了人们获取信息、交流思想的重要平台。越来越多的人选择开设自己的微信公众号，希望通过这一平台实现个人价值或创造经济效益。那么，开微信公众号怎么赚钱呢？本文将为您详细解析微信公众号的盈利策略与实操指南。公众号流量主就找善士导师（shanshi2024）公众号：「善士笔记」主理人，《我的亲身经历，四个月公众号流量主从0到日入过万！》公司旗下管理800+公众号矩阵账号。代表案例如：爸妈领域、
GIS数据处理软件：地理信息与遥感领域的智慧引擎 GeoSaaS 地理信息智慧城市数据库人工智能大数据 gis
在地理信息与遥感技术的广阔天地间，数据处理软件如同一座桥接驳岸的智慧引擎，将海量的原始数据转化为决策的金矿，推动着城市规划、环境保护、灾害管理、资源开发等领域的深度变革。本文将深入解析其核心功能、技术前沿、应用实例及未来展望，探析数据处理软件如何为地理信息与遥感技术插上智慧的翅膀。数据处理软件的核心技术与功能矩阵数据清洗与格式转换：自动去除冗余杂乱码、异常值，格式标准化数据，确保后续处理的准确性与
单片机中断 woainizhongguo. STM32单片机原理解析篇单片机嵌入式硬件
**在51单片机中，中断向量表的地址是如何被设置的？**在51单片机中，中断向量表的设置是中断系统的核心部分，它定义了中断服务程序的入口地址。以下是中断向量表的设置方法：中断向量表的位置：51单片机的中断向量表通常位于程序存储器的起始位置，即地址0x0000到0x000F（对于双字节的中断向量，实际占用0x0000到0x001F）。这些地址是固定的，由单片机的硬件设计决定。中断向量的分配：每个中断
微信公众号如何盈利赚钱?变现模式都能月入过万氧惠购物达人
在移动互联网时代，微信公众号成为了众多内容创作者、品牌商家和个人展示自我、传递价值、实现商业变现的重要平台。那么，公众号究竟如何通过运营实现盈利呢？本文将深入剖析公众号赚钱的多种途径，帮助广大运营者找到适合自己的盈利模式。公众号流量主就找善士导师（shanshi2024）公众号：「善士笔记」主理人，《我的亲身经历，四个月公众号流量主从0到日入过万！》公司旗下管理800+公众号矩阵账号。代表案例如：
第二章按问题编程 ronghuilin 程序特征程序设计
程序设计的基础，建立计算机编程思维，掌握基本问题的分析，与编写源程序。1.在一组数据中寻找一个元素操作“寻找”在计算机软件中是“搜索”，近几年称为“扫描”。首先应了解这些数据存放在什么结构中。一组数据能存储在线性表(one-to-one)中，每个元素只有一个前趋和后继，常用的是数组array，应用性能高的是栈Stack与队列queue。数学计算在计算机程序中的基础是矩阵计算，矩阵存放在二维数组中。
windows C++ 并行编程-编写parallel_for 循环 sului windows C++并行编程技术 c++开发语言
示例：计算两个矩阵的乘积以下示例显示了matrix_multiply函数，可计算两个方阵的乘积。//Computestheproductoftwosquarematrices.voidmatrix_multiply(double**m1,double**m2,double**result,size_tsize){for(size_ti=0;i#include#include#includeusin
面试经典 150 题 2 —（二分查找）— 74. 搜索二维矩阵 BreezeChasingDrizzle leetcode 矩阵算法 leetcode c++二分查找
74.搜索二维矩阵方法classSolution{public:boolsearchMatrix(vector>&matrix,inttarget){intmatrixRows=matrix.size(),matrixCols=matrix[0].size();//先找target所在的行inttargetAtRow=-1;for(inti=0;i>&matrix,inttarget){intma
三点or多点的变换矩阵求解opencv & eigen 合工大机器人实验室 C++矩阵 opencv 线性代数
《Estimating3-DRigidBodyTransformations:AComparisonofFourMajorAlgorithms》，它使用SVD方法计算T和t。只要算出变换矩阵，就可以算出A坐标系的一个点P在坐标系B里的对应点坐标，即R为3x3的转换矩阵，t为3x1的位移变换向量，这里点坐标均为3x1的列向量（非齐次形式，齐次形式下为4x1列向量，多出的一个元素值补1而已）。理论上只
构建蛋白质复合体结构中所有链序列的同源性矩阵 qq_27390023 生物信息学 python
为了生成蛋白质复合体结构中所有链之间的同源性矩阵，我们可以使用基于结构比对的工具（如TM-align），逐对地比对所有链，并根据比对结果（通常是TM-score）构建同源性矩阵。具体步骤包括：提取每条链的序列：从蛋白质复合体的PDB文件中提取每个链的序列，并保存成单独的文件。使用TM-align进行比对：对每对链进行比对，计算它们的TM-score。构建同源性矩阵：将每对链的TM-score记录到
Matlab2024a安装教程是阿宇呢信息可视化开发语言
MATLAB是一款商业数学软件，用于算法开发、数据可视化、数据分析以及数值计算的高级技术计算语言和交互式环境，主要包括MATLAB和Simulink两大部分，可以进行矩阵运算、绘制函数和数据、实现算法、创建用户界面、连接其他编程语言的程序等，主要应用于工程计算、控制设计、信号处理与通讯、图像处理、信号检测、金融建模设计与分析等领域。1.解压安装包：①鼠标右击【MATLABR2024a(64bit)
基于STC12C5A60S2单片机的LED汉字显示系统的设计 lantiandianzi 单片机嵌入式硬件
本设计基于单片机的LED汉字显示装置，该设计以STC12C5A60S2单片机为核心，利用最小系统和多个模块完成设计，包括点阵驱动模块、时钟模块、串口通信模块、红外线接收模块以及LED点阵屏。其中，点阵驱动模块采用74HC245芯片设计完成，结合DS1302时钟芯片完成LED点阵显示屏的汉字与时间显示，使用按键、串口、红外线遥控可以完成时间的实时更新、自定义汉字显示、改变汉字显示颜色、改变汉字滚动方
51单片机-AT24C02-实验2-秒表实验（可参考上一节） Whappy001 51单片机嵌入式硬件单片机
利用定时器去对按键和数码管进行扫描(Whappy)main.c#include#include"LCD1602.h"#include"AT24C02.h"#include"Delay.h"#include"Timer0.h"#include"Nixie.h"#include"Key.h"unsignedcharKeyNum;unsignedcharMin,Sec,MiniSec;unsignedc
统一思想认识永夜-极光思想
1.统一思想认识的基础,才能有的放矢原因: 总有一种描述事物的方式最贴近本质,最容易让人理解. 如何让教育更轻松,在于找到最适合学生的方式. 难点在于,如何模拟对方的思维基础选择合适的方式. &
Joda Time使用笔记 bylijinnan java joda time
Joda Time的介绍可以参考这篇文章： http://www.ibm.com/developerworks/cn/java/j-jodatime.html 工作中也常常用到Joda Time，为了避免每次使用都查API，记录一下常用的用法： /** * DateTime变化（增减） */ @Tes
FileUtils API eksliang FileUtils FileUtils API
转载请出自出处：http://eksliang.iteye.com/blog/2217374 一、概述这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。非常的好用。
各种新兴技术不懂事的小屁孩技术
1:gradle Gradle 是以 Groovy 语言为基础，面向Java应用为主。基于DSL（领域特定语言）语法的自动化构建工具。现在构建系统常用到maven工具，现在有更容易上手的gradle，搭建java环境: http://www.ibm.com/developerworks/cn/opensource/os-cn-gradle/ 搭建android环境： http://m
tomcat6的https双向认证酷的飞上天空 tomcat6
1.生成服务器端证书 keytool -genkey -keyalg RSA -dname "cn=localhost,ou=sango,o=none,l=china,st=beijing,c=cn" -alias server -keypass password -keystore server.jks -storepass password -validity 36
托管虚拟桌面市场势不可挡蓝儿唯美
用户还需要冗余的数据中心，dinCloud的高级副总裁兼首席营销官Ali Din指出。该公司转售一个MSP可以让用户登录并管理和提供服务的用于DaaS的云自动化控制台，提供服务或者MSP也可以自己来控制。在某些情况下，MSP会在dinCloud的云服务上进行服务分层，如监控和补丁管理。 MSP的利润空间将根据其参与的程度而有所不同，Din说。 “我们有一些合作伙伴负责将我们推荐给客户作为个
spring学习——xml文件的配置 a-john spring
在Spring的学习中，对于其xml文件的配置是必不可少的。在Spring的多种装配Bean的方式中，采用XML配置也是最常见的。以下是一个简单的XML配置文件： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.or
HDU 4342 History repeat itself 模拟 aijuans 模拟
来源：http://acm.hdu.edu.cn/showproblem.php?pid=4342 题意：首先让求第几个非平方数，然后求从1到该数之间的每个sqrt(i)的下取整的和。思路：一个简单的模拟题目，但是由于数据范围大，需要用__int64。我们可以首先把平方数筛选出来，假如让求第n个非平方数的话，看n前面有多少个平方数，假设有x个，则第n个非平方数就是n+x。注意两种特殊情况，即
java中最常用jar包的用途 asia007 java
java中最常用jar包的用途 jar包用途axis.jarSOAP引擎包commons-discovery-0.2.jar用来发现、查找和实现可插入式接口，提供一些一般类实例化、单件的生命周期管理的常用方法.jaxrpc.jarAxis运行所需要的组件包saaj.jar创建到端点的点到点连接的方法、创建并处理SOAP消息和附件的方法，以及接收和处理SOAP错误的方法. w
ajax获取Struts框架中的json编码异常和Struts中的主控制器异常的解决办法百合不是茶 js json编码返回异常
一:ajax获取自定义Struts框架中的json编码出现以下问题: 1,强制flush输出 json编码打印在首页 2, 不强制flush js会解析json 打印出来的是错误的jsp页面却没有跳转到错误页面 3, ajax中的dataType的json 改为text 会
JUnit使用的设计模式 bijian1013 java 设计模式 JUnit
JUnit源代码涉及使用了大量设计模式 1、模板方法模式（Template Method）定义一个操作中的算法骨架，而将一些步骤延伸到子类中去，使得子类可以不改变一个算法的结构，即可重新定义该算法的某些特定步骤。这里需要复用的是算法的结构，也就是步骤，而步骤的实现可以在子类中完成。
Linux常用命令（摘录） sunjing crond chkconfig
chkconfig --list 查看linux所有服务 chkconfig --add servicename 添加linux服务 netstat -apn | grep 8080 查看端口占用 env 查看所有环境变量 echo $JAVA_HOME 查看JAVA_HOME环境变量安装编译器 yum install -y gcc
【Hadoop一】Hadoop伪集群环境搭建 bit1129 hadoop
结合网上多份文档，不断反复的修正hadoop启动和运行过程中出现的问题，终于把Hadoop2.5.2伪分布式安装起来，跑通了wordcount例子。Hadoop的安装复杂性的体现之一是，Hadoop的安装文档非常多，但是能一个文档走下来的少之又少，尤其是Hadoop不同版本的配置差异非常的大。Hadoop2.5.2于前两天发布，但是它的配置跟2.5.0，2.5.1没有分别。 &nb
Anychart图表系列五之事件监听白糖_ chart
创建图表事件监听非常简单：首先是通过addEventListener('监听类型',js监听方法)添加事件监听，然后在js监听方法中定义具体监听逻辑。以钻取操作为例，当用户点击图表某一个point的时候弹出point的name和value，代码如下： <script> //创建AnyChart var chart = new AnyChart(); //添加钻取操作&quo
Web前端相关段子 braveCS web前端
Web标准：结构、样式和行为分离使用语义化标签 0）标签的语义：使用有良好语义的标签，能够很好地实现自我解释，方便搜索引擎理解网页结构，抓取重要内容。去样式后也会根据浏览器的默认样式很好的组织网页内容，具有很好的可读性，从而实现对特殊终端的兼容。 1）div和span是没有语义的：只是分别用作块级元素和行内元素的区域分隔符。当页面内标签无法满足设计需求时，才会适当添加div
编程之美-24点游戏 bylijinnan 编程之美
import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Random; import java.util.Set; public class PointGame { /**编程之美
主页面子页面传值总结 chengxuyuancsdn 总结
1、showModalDialog returnValue是javascript中html的window对象的属性,目的是返回窗口值,当用window.showModalDialog函数打开一个IE的模式窗口时,用于返回窗口的值主界面 var sonValue=window.showModalDialog("son.jsp"); 子界面 window.retu
[网络与经济]互联网+的含义 comsci 互联网+
互联网+后面是一个人的名字 = 网络控制系统互联网+你的名字 = 网络个人数据库每日提示:如果人觉得不舒服,千万不要外出到处走动,就呆在床上,玩玩手游,更不能够去开车,现在交通状况不
oracle 创建视图 with check option daizj 视图 view oralce
我们来看下面的例子： create or replace view testview as select empno,ename from emp where ename like ‘M%’ with check option; 这里我们创建了一个视图，并使用了with check option来限制了视图。然后我们来看一下视图包含的结果： select * from testv
ToastPlugin插件在cordova3.3下使用 dibov Cordova
自己开发的Todos应用，想实现“ 再按一次返回键退出程序 ”的功能，采用网上的ToastPlugins插件，发现代码或文章基本都是老版本，运行问题比较多。折腾了好久才弄好。下面吧基于cordova3.3下的ToastPlugins相关代码共享。 ToastPlugin.java package&nbs
C语言22个系统函数 dcj3sjt126com c function
C语言系统函数一、数学函数下列函数存放在math.h头文件中Double floor(double num) 求出不大于num的最大数。Double fmod(x, y) 求整数x/y的余数。Double frexp(num, exp); double num; int *exp; 将num分为数字部分（尾数）x和以2位的指数部分n，即num=x*2n，指数n存放在exp指向的变量中，返回x。D
开发一个类的流程 dcj3sjt126com 开发
本人近日根据自己的开发经验总结了一个类的开发流程。这个流程适用于单独开发的构件，并不适用于对一个项目中的系统对象开发。开发出的类可以存入私人类库，供以后复用。以下是开发流程： 1. 明确类的功能，抽象出类的大概结构 2. 初步设想类的接口 3. 类名设计（驼峰式命名） 4. 属性设置(权限设置) 判断某些变量是否有必要作为成员属
java 并发 shuizhaosi888 java 并发
能够写出高伸缩性的并发是一门艺术在JAVA SE5中新增了3个包 java.util.concurrent java.util.concurrent.atomic java.util.concurrent.locks 在java的内存模型中，类的实例字段、静态字段和构成数组的对象元素都会被多个线程所共享，局部变量与方法参数都是线程私有的，不会被共享。
Spring Security（11）——匿名认证 234390216 Spring Security ROLE_ANNOYMOUS 匿名
匿名认证目录 1.1 配置 1.2 AuthenticationTrustResolver 对于匿名访问的用户，Spring Security支持为其建立一个匿名的AnonymousAuthenticat
NODEJS项目实践0.2[ express,ajax通信...] 逐行分析JS源代码 Ajax nodejs express
一、前言通过上节学习，我们已经 ubuntu系统搭建了一个可以访问的nodejs系统，并做了nginx转发。本节原要做web端服务及 mongodb的存取，但写着写着，web端就
在Struts2 的Action中怎样获取表单提交上来的多个checkbox的值 lhbthanks java html struts checkbox
第一种方法：获取结果String类型在 Action 中获得的是一个 String 型数据，每一个被选中的 checkbox 的 value 被拼接在一起，每个值之间以逗号隔开(,)。所以在 Action 中定义一个跟 checkbox 的 name 同名的属性来接收这些被选中的 checkbox 的 value 即可。以下是实现的代码：前台 HTML 代码：
003.Kafka基本概念 nweiren hadoop kafka
Kafka基本概念：Topic、Partition、Message、Producer、Broker、Consumer。 Topic：消息源（Message）的分类。 Partition： Topic物理上的分组，一
Linux环境下安装JDK roadrunners jdk linux
1、准备工作创建JDK的安装目录： mkdir -p /usr/java/ 下载JDK，找到适合自己系统的JDK版本进行下载： http://www.oracle.com/technetwork/java/javase/downloads/index.html 把JDK安装包下载到/usr/java/目录，然后进行解压： tar -zxvf jre-7
Linux忘记root密码的解决思路 tomcat_oracle linux
1：使用同版本的linux启动系统，chroot到忘记密码的根分区passwd改密码　　2：grub启动菜单中加入init=/bin/bash进入系统，不过这时挂载的是只读分区。根据系统的分区情况进一步判断. 　　3: grub启动菜单中加入 single以单用户进入系统. 　　4:用以上方法mount到根分区把/etc/passwd中的root密码去除　　例如: 　　ro
跨浏览器 HTML5 postMessage 方法以及 message 事件模拟实现 xueyou jsonp jquery 框架 UI html5
postMessage 是 HTML5 新方法，它可以实现跨域窗口之间通讯。到目前为止，只有 IE8+, Firefox 3, Opera 9, Chrome 3和 Safari 4 支持，而本篇文章主要讲述 postMessage 方法与 message 事件跨浏览器实现。postMessage 方法 JSONP 技术不一样，前者是前端擅长跨域文档数据即时通讯，后者擅长针对跨域服务端数据通讯，p