汉字点阵与LED屏显

已于 2023-11-19 22:08:14 修改
阅读量163 收藏
点赞数
文章标签： 电脑
于 2023-11-19 22:06:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67901122/article/details/134496200
版权

一、串口文件传输

1、目的

        将两台笔记本电脑，借助 usb转rs232 模块和杜邦线，建立起串口连接。然后用串口助手等工具软件（带文件传输功能）将一台笔记本上的一个大文件（图片、视频和压缩包软件）传输到另外一台电脑，预算文件大小、波特率和传输时间三者之间的关系，并对比实际传输时间。

2、实践过程

        *需要两台电脑，电脑上都下载好串口调试助手，方便接收和发送显示文件。两个串口线连接这两台电脑。打开串口调试助手。

        *打开串口调试助手，选择文件，设置波特率为115200，点击发送文件。

        *另一台电脑接收的文件，547KB 波特率115200时为70s 

（二）、使用Ubuntu调用opencv库编程显示一张图片

1、实验目的

         学习理解汉字的机内码、区位码编码规则和字形数据存储格式。在Ubuntu下用C/C++(或python) 调用opencv库编程显示一张图片，并打开一个名为"logo.txt"的文本文件（其中只有一行文本文件，包括你自己的名字和学号），按照名字和学号去读取汉字24*24点阵字形字库（压缩包中的文件HZKf2424.hz）中对应字符的字形数据，将名字和学号叠加显示在此图片右下位置。

2、汉字的机内码、区位码编码规则和字形数据存储格式

  1. 机内码：机内码是计算机内部使用的二进制代码，用于表示汉字。常见的机内码有GB2312、GBK、UTF-8等。其中，GB2312是我国制定的汉字编码标准，包含了6763个常用汉字和682个生僻汉字，每个汉字用两个字节表示。

  2. 区位码：区位码是GB2312编码中的一种表示方法，用于表示每个汉字在字符集中的位置。区位码由两个数字组成，前面的数字表示所在区，后面的数字表示所在位。例如，“啊”的区位码为1601。

  3. 字形数据存储格式：字形数据存储格式是指计算机中存储汉字的方式。常见的字形数据存储格式有点阵格式和轮廓格式。点阵格式是将每个汉字转换为一个由点阵组成的矩阵，每个点表示一个像素，用于显示汉字。轮廓格式是将每个汉字转换为一组由线条组成的轮廓，用于汉字识别和处理。

3、实验步骤

        *打开ubuntu新建文件夹用来存放代码、文本文件、图片等。

       

        *代码

#include<iostream>
#include<opencv/cv.h>
#include"opencv2/opencv.hpp"
#include<opencv/cxcore.h>
#include<opencv/highgui.h>
#include<math.h>
using namespace cv;
using namespace std;

void paint_chinese(Mat& image,int x_offset,int y_offset,unsigned long offset);
void paint_ascii(Mat& image,int x_offset,int y_offset,unsigned long offset);
void put_text_to_image(int x_offset,int y_offset,String image_path,char* logo_path);

int main(){
    String image_path="/home/lc/1/1.jpg";
    char* logo_path=(char*)"/home/lc/1/logo.txt";
    put_text_to_image(450,750,image_path,logo_path);//安排文字从图片像素坐标(450，750)开始显示
    return 0;
}
//在图片上绘制文字的起点坐标
void paint_ascii(Mat& image,int x_offset,int y_offset,unsigned long offset){
	Point p;
	p.x = x_offset;
	p.y = y_offset;
	//存放ascii字膜
	char buff[16];           
	//打开ascii字库文件
	FILE *ASCII;
	if ((ASCII = fopen("/home/lc/1/Asci0816.zf", "rb")) == NULL){
        printf("Can't open ascii.zf,Please check the path!");
		//getch();
		exit(0);
	}
	fseek(ASCII, offset, SEEK_SET);
	fread(buff, 16, 1, ASCII);
	int i, j;
	Point p1 = p;
	for (i = 0; i<16; i++)                  //十六个char
	{
		p.x = x_offset;
		for (j = 0; j < 8; j++)              //一个char八个bit
		{
			p1 = p;
			if (buff[i] & (0x80 >> j))    /*测试当前位是否为1*/
			{
				/*
					由于原本ascii字膜是8*16的，不够大，
					所以原本的一个像素点用4个像素点替换，
					替换后就有16*32个像素点
					ps：感觉这样写代码多余了，但目前暂时只想到了这种方法
				*/
				circle(image, p1, 0, Scalar(0, 0, 255), -1);
				p1.x++;
				circle(image, p1, 0, Scalar(0, 0, 255), -1);
				p1.y++;
				circle(image, p1, 0, Scalar(0, 0, 255), -1);
				p1.x--;
				circle(image, p1, 0, Scalar(0, 0, 255), -1);
			}						
			p.x+=2;            //原来的一个像素点变为四个像素点，所以x和y都应该+2
		}
		p.y+=2;
	}
}
//在图片替换像素点
void paint_chinese(Mat& image,int x_offset,int y_offset,unsigned long offset){
    Point p;
    p.x=x_offset;
    p.y=y_offset;
    FILE *HZK;
    char buff[72];//72个字节，用来存放汉字的
   if((HZK=fopen("/home/lc/1/HZKf2424.hz","rb"))==NULL){
        printf("Can't open HZKf2424.hz,Please check the path!");
        exit(0);//退出
    }
    fseek(HZK, offset, SEEK_SET);/*将文件指针移动到偏移量的位置*/
    fread(buff, 72, 1, HZK);/*从偏移量的位置读取72个字节，每个汉字占72个字节*/
    bool mat[24][24];//定义一个新的矩阵存放转置后的文字字膜
    int i,j,k;
    for (i = 0; i<24; i++)                 /*24x24点阵汉字，一共有24行*/
	{
		for (j = 0; j<3; j++)                /*横向有3个字节，循环判断每个字节的*/
			for (k = 0; k<8; k++)              /*每个字节有8位，循环判断每位是否为1*/
				if (buff[i * 3 + j] & (0x80 >> k))    /*测试当前位是否为1*/
				{
					mat[j * 8 + k][i] = true;          /*为1的存入新的字膜中*/
				}
				else {
					mat[j * 8 + k][i] = false;
				}
	}
    for (i = 0; i < 24; i++)
	{
		p.x = x_offset;
		for (j = 0; j < 24; j++)
		{		
			if (mat[i][j])
				circle(image, p, 1, Scalar(255, 0, 0), -1);		  //写(替换)像素点
			p.x++;                                                //右移一个像素点
		}
		p.y++;                                                    //下移一个像素点
	}
}
//将汉字放在图片上
void put_text_to_image(int x_offset,int y_offset,String image_path,char* logo_path){
//x和y就是第一个字在图片上的起始坐标
    //通过图片路径获取图片
    Mat image=imread(image_path);
    int length=22;//要打印的字符长度（字节）
    unsigned char qh,wh;//定义区号，位号
    unsigned long offset;//偏移量
    unsigned char hexcode[30];//用于存放记事本读取的十六进制,记得要用无符号
    FILE* file_logo;
    if ((file_logo = fopen(logo_path, "rb")) == NULL){
		printf("Can't open txtfile,Please check the path!");
		//getch();
		exit(0);
	}
    fseek(file_logo, 0, SEEK_SET);
    fread(hexcode, length, 1, file_logo);
    int x =x_offset,y = y_offset;//x,y:在图片上绘制文字的起始坐标
    for(int m=0;m<length;){
        if(hexcode[m]==0x23){
            break;//读到#号时结束
        }
        else if(hexcode[m]>0xaf){
            qh=hexcode[m]-0xaf;//使用的字库里是以汉字啊开头，而不是以汉字符号开头
            wh=hexcode[m+1] - 0xa0;//计算位码
            offset=(94*(qh-1)+(wh-1))*72L;
            paint_chinese(image,x,y,offset);
            /*
            计算在汉字库中的偏移量
            对于每个汉字，使用24*24的点阵来表示的
            一行有三个字节，一共24行，所以需要72个字节来表示
            */
            m=m+2;//一个汉字的机内码占两个字节，
            x+=24;//一个汉字为24*24个像素点，由于是水平放置，所以是向右移动24个像素点
        }
        else{//当读取的字符为ASCII码时
        wh=hexcode[m];
        offset=wh*16l;//计算英文字符的偏移量
        paint_ascii(image,x,y,offset);
        m++;//英文字符在文件里表示只占一个字节，所以往后移一位就行了
        x+=16;
        }
    }
    cv::imshow("image", image);//显示图片
    cv::waitKey();
}

        *编译

g++ test.c -o test `pkg-config --cflags --libs opencv`

        *运行

（三）、OLED屏显和汉字点阵编码 

        *首先取模软件需要将中文进行取模得到中文 

        *在oledfont.h中加入字模数组

        *加入AHT20温度传感器的.c.h函数

#include "stm32f10x.h" 
#include "AHT20-21_DEMO_V1_3.h" 




void Delay_N10us(uint32_t t)//延时函数
{
  uint32_t k;

   while(t--)
  {
    for (k = 0; k < 2; k++);//110
  }
}

void SensorDelay_us(uint32_t t)//延时函数
{
		
	for(t = t-2; t>0; t--)
	{
		Delay_N10us(1);
	}
}

void Delay_4us(void)		//延时函数
{	
	Delay_N10us(1);
	Delay_N10us(1);
	Delay_N10us(1);
	Delay_N10us(1);
}
void Delay_5us(void)		//延时函数
{	
	Delay_N10us(1);
	Delay_N10us(1);
	Delay_N10us(1);
	Delay_N10us(1);
	Delay_N10us(1);

}

void Delay_1ms(uint32_t t)		//延时函数
{
   while(t--)
  {
    SensorDelay_us(1000);//延时1ms
  }
}


void AHT20_Clock_Init(void)		//延时函数
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
}

void SDA_Pin_Output_High(void)   //将PB15配置为输出 ， 并设置为高电平， PB15作为I2C的SDA
{
	GPIO_InitTypeDef  GPIO_InitStruct;
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_OD;//开漏输出
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_1;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB,& GPIO_InitStruct);
	GPIO_SetBits(GPIOB,GPIO_Pin_1);
}

void SDA_Pin_Output_Low(void)  //将P15配置为输出  并设置为低电平
{

	GPIO_InitTypeDef  GPIO_InitStruct;
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_OD;//开漏输出
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_1;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB,& GPIO_InitStruct);
	GPIO_ResetBits(GPIOB,GPIO_Pin_1);
}

void SDA_Pin_IN_FLOATING(void)  //SDA配置为浮空输入
{

	GPIO_InitTypeDef  GPIO_InitStruct;
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;//
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_1;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init( GPIOB,&GPIO_InitStruct);
}

void SCL_Pin_Output_High(void) //SCL输出高电平，P14作为I2C的SCL
{
	GPIO_SetBits(GPIOB,GPIO_Pin_0);
}

void SCL_Pin_Output_Low(void) //SCL输出低电平
{
	GPIO_ResetBits(GPIOB,GPIO_Pin_0);
}

void Init_I2C_Sensor_Port(void) //初始化I2C接口,输出为高电平
{	
	GPIO_InitTypeDef  GPIO_InitStruct;
	
	AHT20_Clock_Init();
	
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_OD;//开漏输出
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_1;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB,&GPIO_InitStruct);
	GPIO_SetBits(GPIOB,GPIO_Pin_1);//输出高电平
	

	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_OD;//开漏输出
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB,&GPIO_InitStruct);
	GPIO_SetBits(GPIOB,GPIO_Pin_0);//输出高电平
	
}
void I2C_Start(void)		 //I2C主机发送START信号
{
	SDA_Pin_Output_High();
	SensorDelay_us(8);
	SCL_Pin_Output_High();
	SensorDelay_us(8);
	SDA_Pin_Output_Low();
	SensorDelay_us(8);
	SCL_Pin_Output_Low();
	SensorDelay_us(8);   
}


void AHT20_WR_Byte(uint8_t Byte) //往AHT20写一个字节
{
	uint8_t Data,N,i;	
	Data=Byte;
	i = 0x80;
	for(N=0;N<8;N++)
	{
		SCL_Pin_Output_Low(); 
		Delay_4us();	
		if(i&Data)
		{
			SDA_Pin_Output_High();
		}
		else
		{
			SDA_Pin_Output_Low();
		}	
			
    SCL_Pin_Output_High();
		Delay_4us();
		Data <<= 1;
		 
	}
	SCL_Pin_Output_Low();
	SensorDelay_us(8);   
	SDA_Pin_IN_FLOATING();
	SensorDelay_us(8);
	
}	


uint8_t AHT20_RD_Byte(void)//从AHT20读取一个字节
{
	uint8_t Byte,i,a;
	Byte = 0;
	SCL_Pin_Output_Low();
	SDA_Pin_IN_FLOATING();
	SensorDelay_us(8);	
	for(i=0;i<8;i++)
	{
    SCL_Pin_Output_High();		
		Delay_5us();
		a=0;
		if(GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_1)) a=1;
		Byte = (Byte<<1)|a;
		SCL_Pin_Output_Low();
		Delay_5us();
	}
  SDA_Pin_IN_FLOATING();
	SensorDelay_us(8);	
	return Byte;
}


uint8_t Receive_ACK(void)   //看AHT20是否有回复ACK
{
	uint16_t CNT;
	CNT = 0;
	SCL_Pin_Output_Low();	
	SDA_Pin_IN_FLOATING();
	SensorDelay_us(8);	
	SCL_Pin_Output_High();	
	SensorDelay_us(8);	
	while((GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_1))  && CNT < 100) 
	CNT++;
	if(CNT == 100)
	{
		return 0;
	}
 	SCL_Pin_Output_Low();	
	SensorDelay_us(8);	
	return 1;
}

void Send_ACK(void)		  //主机回复ACK信号
{
	SCL_Pin_Output_Low();	
	SensorDelay_us(8);	
	SDA_Pin_Output_Low();
	SensorDelay_us(8);	
	SCL_Pin_Output_High();	
	SensorDelay_us(8);
	SCL_Pin_Output_Low();	
	SensorDelay_us(8);
	SDA_Pin_IN_FLOATING();
	SensorDelay_us(8);
}

void Send_NOT_ACK(void)	//主机不回复ACK
{
	SCL_Pin_Output_Low();	
	SensorDelay_us(8);
	SDA_Pin_Output_High();
	SensorDelay_us(8);
	SCL_Pin_Output_High();	
	SensorDelay_us(8);		
	SCL_Pin_Output_Low();	
	SensorDelay_us(8);
    SDA_Pin_Output_Low();
	SensorDelay_us(8);
}

void Stop_I2C(void)	  //一条协议结束
{
	SDA_Pin_Output_Low();
	SensorDelay_us(8);
	SCL_Pin_Output_High();	
	SensorDelay_us(8);
	SDA_Pin_Output_High();
	SensorDelay_us(8);
}

uint8_t AHT20_Read_Status(void)//读取AHT20的状态寄存器
{

	uint8_t Byte_first;	
	I2C_Start();
	AHT20_WR_Byte(0x71);
	Receive_ACK();
	Byte_first = AHT20_RD_Byte();
	Send_NOT_ACK();
	Stop_I2C();
	return Byte_first;
}

void AHT20_SendAC(void) //向AHT20发送AC命令
{

	I2C_Start();
	AHT20_WR_Byte(0x70);
	Receive_ACK();
	AHT20_WR_Byte(0xac);//0xAC采集命令
	Receive_ACK();
	AHT20_WR_Byte(0x33);
	Receive_ACK();
	AHT20_WR_Byte(0x00);
	Receive_ACK();
	Stop_I2C();

}

//CRC校验类型：CRC8/MAXIM
//多项式：X8+X5+X4+1
//Poly：0011 0001  0x31
//高位放到后面就变成 1000 1100 0x8c
//C现实代码：
uint8_t Calc_CRC8(uint8_t *message,uint8_t Num)
{
        uint8_t i;
        uint8_t byte;
        uint8_t crc=0xFF;
  for(byte=0; byte<Num; byte++)
  {
    crc^=(message[byte]);
    for(i=8;i>0;--i)
    {
      if(crc&0x80) crc=(crc<<1)^0x31;
      else crc=(crc<<1);
    }
  }
        return crc;
}

void AHT20_Read_CTdata(uint32_t *ct) //没有CRC校验，直接读取AHT20的温度和湿度数据
{
	volatile uint8_t  Byte_1th=0;
	volatile uint8_t  Byte_2th=0;
	volatile uint8_t  Byte_3th=0;
	volatile uint8_t  Byte_4th=0;
	volatile uint8_t  Byte_5th=0;
	volatile uint8_t  Byte_6th=0;
	 uint32_t RetuData = 0;
	uint16_t cnt = 0;
	AHT20_SendAC();//向AHT20发送AC命令
	Delay_1ms(80);//延时80ms左右	
    cnt = 0;
	while(((AHT20_Read_Status()&0x80)==0x80))//直到状态bit[7]为0，表示为空闲状态，若为1，表示忙状态
	{
		SensorDelay_us(1508);
		if(cnt++>=100)
		{
		 break;
		 }
	}
	I2C_Start();
	AHT20_WR_Byte(0x71);
	Receive_ACK();
	Byte_1th = AHT20_RD_Byte();//状态字，查询到状态为0x98,表示为忙状态，bit[7]为1；状态为0x1C，或者0x0C，或者0x08表示为空闲状态，bit[7]为0
	Send_ACK();
	Byte_2th = AHT20_RD_Byte();//湿度
	Send_ACK();
	Byte_3th = AHT20_RD_Byte();//湿度
	Send_ACK();
	Byte_4th = AHT20_RD_Byte();//湿度/温度
	Send_ACK();
	Byte_5th = AHT20_RD_Byte();//温度
	Send_ACK();
	Byte_6th = AHT20_RD_Byte();//温度
	Send_NOT_ACK();
	Stop_I2C();

	RetuData = (RetuData|Byte_2th)<<8;
	RetuData = (RetuData|Byte_3th)<<8;
	RetuData = (RetuData|Byte_4th);
	RetuData =RetuData >>4;
	ct[0] = RetuData;//湿度
	RetuData = 0;
	RetuData = (RetuData|Byte_4th)<<8;
	RetuData = (RetuData|Byte_5th)<<8;
	RetuData = (RetuData|Byte_6th);
	RetuData = RetuData&0xfffff;
	ct[1] =RetuData; //温度

}


void AHT20_Read_CTdata_crc(uint32_t *ct) //CRC校验后，读取AHT20的温度和湿度数据
{
	volatile uint8_t  Byte_1th=0;
	volatile uint8_t  Byte_2th=0;
	volatile uint8_t  Byte_3th=0;
	volatile uint8_t  Byte_4th=0;
	volatile uint8_t  Byte_5th=0;
	volatile uint8_t  Byte_6th=0;
	volatile uint8_t  Byte_7th=0;
	 uint32_t RetuData = 0;
	 uint16_t cnt = 0;
	// uint8_t  CRCDATA=0;
	 uint8_t  CTDATA[6]={0};//用于CRC传递数组
	
	AHT20_SendAC();//向AHT20发送AC命令
	Delay_1ms(80);//延时80ms左右	
    cnt = 0;
	while(((AHT20_Read_Status()&0x80)==0x80))//直到状态bit[7]为0，表示为空闲状态，若为1，表示忙状态
	{
		SensorDelay_us(1508);
		if(cnt++>=100)
		{
		 break;
		}
	}
	
	I2C_Start();

	AHT20_WR_Byte(0x71);
	Receive_ACK();
	CTDATA[0]=Byte_1th = AHT20_RD_Byte();//状态字，查询到状态为0x98,表示为忙状态，bit[7]为1；状态为0x1C，或者0x0C，或者0x08表示为空闲状态，bit[7]为0
	Send_ACK();
	CTDATA[1]=Byte_2th = AHT20_RD_Byte();//湿度
	Send_ACK();
	CTDATA[2]=Byte_3th = AHT20_RD_Byte();//湿度
	Send_ACK();
	CTDATA[3]=Byte_4th = AHT20_RD_Byte();//湿度/温度
	Send_ACK();
	CTDATA[4]=Byte_5th = AHT20_RD_Byte();//温度
	Send_ACK();
	CTDATA[5]=Byte_6th = AHT20_RD_Byte();//温度
	Send_ACK();
	Byte_7th = AHT20_RD_Byte();//CRC数据
	Send_NOT_ACK();                           //注意: 最后是发送NAK
	Stop_I2C();
	
	if(Calc_CRC8(CTDATA,6)==Byte_7th)
	{
	RetuData = (RetuData|Byte_2th)<<8;
	RetuData = (RetuData|Byte_3th)<<8;
	RetuData = (RetuData|Byte_4th);
	RetuData =RetuData >>4;
	ct[0] = RetuData;//湿度
	RetuData = 0;
	RetuData = (RetuData|Byte_4th)<<8;
	RetuData = (RetuData|Byte_5th)<<8;
	RetuData = (RetuData|Byte_6th);
	RetuData = RetuData&0xfffff;
	ct[1] =RetuData; //温度
		
	}
	else
	{
		ct[0]=0x00;
		ct[1]=0x00;//校验错误返回值，客户可以根据自己需要更改
	}//CRC数据
}


void JH_Reset_REG(uint8_t addr)
{
	
	uint8_t Byte_first,Byte_second,Byte_third,Byte_fourth;
	I2C_Start();
	AHT20_WR_Byte(0x70);//原来是0x70
	Receive_ACK();
	AHT20_WR_Byte(addr);
	Receive_ACK();
	AHT20_WR_Byte(0x00);
	Receive_ACK();
	AHT20_WR_Byte(0x00);
	Receive_ACK();
	Stop_I2C();

	Delay_1ms(5);//延时5ms左右
	I2C_Start();
	AHT20_WR_Byte(0x71);//
	Receive_ACK();
	Byte_first = AHT20_RD_Byte();
	Send_ACK();
	Byte_second = AHT20_RD_Byte();
	Send_ACK();
	Byte_third = AHT20_RD_Byte();
	Send_NOT_ACK();
	Stop_I2C();
	
    Delay_1ms(10);//延时10ms左右
	I2C_Start();
	AHT20_WR_Byte(0x70);///
	Receive_ACK();
	AHT20_WR_Byte(0xB0|addr);寄存器命令
	Receive_ACK();
	AHT20_WR_Byte(Byte_second);
	Receive_ACK();
	AHT20_WR_Byte(Byte_third);
	Receive_ACK();
	Stop_I2C();
	
	Byte_second=0x00;
	Byte_third =0x00;
}

void AHT20_Start_Init(void)
{
	JH_Reset_REG(0x1b);
	JH_Reset_REG(0x1c);
	JH_Reset_REG(0x1e);
}

//int32_t main(void)
//{
//    uint32_t CT_data[2];
//	volatile int  c1,t1;
//	/***********************************************************************************/
//	/**///上电初始化SDA，SCL的IO口
//	/***********************************************************************************/
//	Init_I2C_Sensor_Port();
//	/***********************************************************************************/
//	/**///①刚上电，产品芯片内部就绪需要时间，延时100~500ms,建议500ms
//	/***********************************************************************************/
//	Delay_1ms(500);
//	/***********************************************************************************/
//	/**///②上电第一次发0x71读取状态字，判断状态字是否为0x18,如果不是0x18,进行寄存器初始化
//	/***********************************************************************************/
//	if((AHT20_Read_Status()&0x18)!=0x18)
//	{
//	AHT20_Start_Init(); //重新初始化寄存器
//	Delay_1ms(10);
//	}
//	
//	/***********************************************************************************/
//	/**///③根据客户自己需求发测量命令读取温湿度数据，当前while（1）循环发测量命令读取温湿度数据，仅供参考
//	/***********************************************************************************/
//	while(1)
//	{
//	 AHT20_Read_CTdata(CT_data);       //不经过CRC校验，直接读取AHT20的温度和湿度数据    推荐每隔大于1S读一次
//    //AHT20_Read_CTdata_crc(CT_data);  //crc校验后，读取AHT20的温度和湿度数据 
//	

//	 c1 = CT_data[0]*100*10/1024/1024;  //计算得到湿度值c1（放大了10倍）
//	 t1 = CT_data[1]*200*10/1024/1024-500;//计算得到温度值t1（放大了10倍）
//	下一步客户处理显示数据，
//	/***********************************************************************************/
//	/**///延时1.5s，建议间隔1.5s读一次
//	/***********************************************************************************/
//	delay_ms(1500);
//	 }

// }	



#ifndef _AHT20_H_
#define _AHT20_H_

#include "stm32f10x.h"  

void Delay_N10us(uint32_t t);//延时函数
void SensorDelay_us(uint32_t t);//延时函数
void Delay_4us(void);		//延时函数
void Delay_5us(void);		//延时函数
void Delay_1ms(uint32_t t);	
void AHT20_Clock_Init(void);		//延时函数
void SDA_Pin_Output_High(void)  ; //将PB15配置为输出 ， 并设置为高电平， PB15作为I2C的SDA
void SDA_Pin_Output_Low(void);  //将P15配置为输出  并设置为低电平
void SDA_Pin_IN_FLOATING(void);  //SDA配置为浮空输入
void SCL_Pin_Output_High(void); //SCL输出高电平，P14作为I2C的SCL
void SCL_Pin_Output_Low(void); //SCL输出低电平
void Init_I2C_Sensor_Port(void); //初始化I2C接口,输出为高电平
void I2C_Start(void);		 //I2C主机发送START信号
void AHT20_WR_Byte(uint8_t Byte); //往AHT20写一个字节
uint8_t AHT20_RD_Byte(void);//从AHT20读取一个字节
uint8_t Receive_ACK(void);   //看AHT20是否有回复ACK
void Send_ACK(void)	;	  //主机回复ACK信号
void Send_NOT_ACK(void);	//主机不回复ACK
void Stop_I2C(void);	  //一条协议结束
uint8_t AHT20_Read_Status(void);//读取AHT20的状态寄存器
void AHT20_SendAC(void); //向AHT20发送AC命令
uint8_t Calc_CRC8(uint8_t *message,uint8_t Num);
void AHT20_Read_CTdata(uint32_t *ct); //没有CRC校验，直接读取AHT20的温度和湿度数据
void AHT20_Read_CTdata_crc(uint32_t *ct); //CRC校验后，读取AHT20的温度和湿度数据
void JH_Reset_REG(uint8_t addr);///重置寄存器
void AHT20_Start_Init(void);///上电初始化进入正常测量状态

#endif

        *主函数

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "AHT20-21_DEMO_V1_3.h"
#include <stdio.h>


int main(void)
{
	
		Init_I2C_Sensor_Port();//初始化SDA，SCL的IO口的函数
		uint32_t CT_data[2];
		volatile int  c1,t1;
		Delay_1ms(500);
		OLED_Init();//初始化OLED
		if((AHT20_Read_Status()&0x18)!=0x18)
		{
			AHT20_Start_Init(); //重新初始化寄存器
			Delay_1ms(10);
		}


		OLED_ShowCN(1,1,0); 
		OLED_ShowCN(1,2,1); 
		OLED_ShowCN(1,3,2); 
		OLED_ShowString(2,1,"632007060523"); 
		OLED_ShowCN(3,1,4);
		OLED_ShowCN(3,2,5);
		OLED_ShowString(3,6,":"); 
		OLED_ShowCN(4,1,3);
		OLED_ShowCN(4,2,5);
		OLED_ShowString(4,6,":"); 
		while(1)
		{
				AHT20_Read_CTdata_crc(CT_data);   
		
				while(CT_data[0]==0x00&&CT_data[1]==0x00) 
				{
					AHT20_Read_CTdata_crc(CT_data);
				}
				c1 = CT_data[0]*100*10/1024/1024;  
				t1 = CT_data[1]*200*10/1024/1024-500;
				char str1[5];
				char str2[5];
				sprintf(str1,"%.1f",c1/10.0);
				sprintf(str2,"%.1f",t1/10.0);
				OLED_ShowString(3,7,str1);
				OLED_ShowString(4,7,str2);
				Delay_1ms(2000);
	}
}

小李同学ggB
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言程序设计-汉字点阵
盘盘的博客
11-16 4083
课程设计题目及要求：汉字点阵 编写程序，根据用户的中文输入，在屏幕上输出相应的汉字点阵（用户一次输入一个汉字），如图 17.1 所示。要求程序能以正常、斜体、加宽、加高四种不同的方式显示汉字点阵，并能设置汉字点阵的字符图案。 第一部分：引言 进行课程设计： 1.重点掌握选择结构程序设计，循环结构设计。 2.进一步掌握自定义函数及其调用。 3.掌握简单的文件操作。 4.养成良好的编程习惯。 5.进一步学习C语言的标准库和函数的使用方法。 6.学习较长程序的编程。 实践依据： 1.点阵汉字原理使得计算机可以显示
LED点阵显示名字
aoyuan4706的博客
11-25 1920
学习了一周的单片机，然后中途有事打断了两周，现在温习一下之前学的东西，用“普中科技单片机”上的LED点阵显示自己的名字。 P1接J19（绿）、P2接J20（红），P0接J12（数码管段选）；5V电压； 显示图片如下： LED点阵原理说明：链接: http://pan.baidu.com/s/1eQtqF 密码: h9b3 代码如下： 1 #include ...
一种LED点阵汉字显示屏的制作
08-28
本文主要通过介绍用89c51 控制的LED 点阵汉字显示屏电路设计原理、电路板制作方法， 有利于初学者通过实践， 掌握单片机的一般设计应用及电路板制作方法。
PHP读取汉字的点阵数据
10-24
本文给大家详细讲述了使用PHP读取汉字的点阵数据的方法和示例，十分的实用，有需要的小伙伴可以参考下。
OLED与LCD屏显的对比分析
01-19
导读：近年来，随着OLED的迅速发展，以前OLED主要用于手机或者MP3等小尺寸的设备上，现在OLED越来越广泛的应用在手机屏幕或者电视屏幕领域。 　　针对目前的手机/电视屏幕多种多样，显示效果各不相同，但归根结底它们的屏幕材质无非只有以上提到的LCD和OLED两种，那么这两种材质有什么区别呢？本文将从三个方面来简要分析OLED与LCD的对比。 　　一、OLED与LCD的概念 　　OLED,即有机发光二极管或者有机电激光显示。OLED具有自发光的特性，采用非常薄的有机材料涂层和玻璃基板，当电流通过时，有机材料就会发光，而且OLED显示屏幕可视角度大，可以实现柔性化，并且能够显着节省电能。
汉字点阵字库及读取程序
04-14
在单片机液晶中，如何显示点阵汉字，给大家提供了： 1. 含有16X16的标准点阵汉字库 2. 含有读取该点阵字库的C语言程序
LED 点阵实验~点亮一个点、数字、汉字、图
weixin_60461563的博客
01-11 9077
LED 点阵实验~点亮一个点、数字、汉字、图
点阵汉字的字模读取与显示
最新发布
m0_63232027的博客
11-19 197
为了解决这个问题，有些点阵字库会将 14×14 和 12×12 的字库按 16×14 和 16×12 来存储，即，每行还是按两个字节来存储，但是 14×14 的字库，每 两个字节的最后两位是没有使用，12×12 的字节，每两字节的最后 4 位是没有 使用，这个根据不同的字库会有不同的处理方式，所以在使用字库时要注意这个 问题，特别是 14×14 的字库。即每两个字节代表一行的 16 个点，共需要 16 行，显示汉字时，只需一次 性读取 32 个字节，并将每两个字节为一行打印出来，即可形成一个汉字。
读取汉字点阵数据并通过图片显示
手可摘星辰博客
11-12 1461
一、汉字点阵字库原理 一、汉字编码 1.区位码 国标码是一个四位十六进制数，区位码是一个四位的十进制数，每个国标码或区位码都对应着一个唯一的汉字或符号，但因为十六进制数我们很少用到，所以大家常用的是区位码，它的前两位叫做区码，后两位叫做位码。 2.机内码 二、点阵字库结构 三、点阵字库获取 二、代码编写 三、实验效果 四、总结 ...
ARM实验板移植Linux操作系统，LCD显示汉字（名字）
qq_34623223的博客
01-10 4023
一、实验目的 1.熟悉点阵字库的使用 2.熟悉Linux操作系统的使用 3.熟悉ARM嵌入式系统开发的过程 二、实验内容 1.pc端编写用×和空格显示自己名字的c程序 2.安装交叉编译工具，修改程序，交叉编译 3.制作新的文件系统镜像，烧写。 三、实验设备及工具 硬件：MX1ADS嵌入式实验平台、PC机 软件：Linux操作系统、交叉编译工具 四、实验原理 1.16×16点阵字库HZK16的使用 ...
OLED屏显和汉字点阵编码
pink_lemon的博客
11-25 1709
一、SPI协议 （1）SPI协议简介 SPI 协议是由摩托罗拉公司提出的通讯协议 (Serial Peripheral Interface)，即串行外围设备接口，是 一种高速全双工的通信总线。它被广泛地使用在 ADC、LCD 等设备与 MCU 间，要求通讯速率 较高的场合。 （2）SPI物理层 SPI 通讯设备之间的常用连接方式如下 SPI 通讯使用 3 条总线及片选线，3 条总线分别为 SCK、MOSI、MISO，片选线为 SS ，它们的作 用介绍如下： ①SS*(* Slave Se..
在OLED屏幕上显示汉字
m0_61824471的博客
11-25 6617
一、了解SPI SPI的定义 SPI（Serial Peripheral Interface）就是串行外围设备接口。 SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚。SPI 是一个环形总线结构，由 ss(cs)、sck、sdi、sdo 构成，时序主要是在 sck 的控制下，两个双向移位寄存器进行数据交换。 上升沿发送、下降沿接收、高位先发送。 上升沿到来的时候，sdo 上的电平将被发送到从设备的寄存器中。 下降沿到来的时候，sdi 上的电平将被接收到主设备的寄
易语言读汉字点阵字库
08-21
读汉字点阵字库系统结构:十进制转换为二进制, ======窗口程序集1 || ||------_按钮1_被单击 || ||------十进制转换为二进制
汉字字模点阵数据批量生成工具安装程序
11-03
汉字字模点阵数据批量生成工具安装程序.exe
汉字点阵数据生成工具
07-11
汉字点阵数据生成工具，绿色版，我一直在用，是对液晶LCD数据生成的一种工具。
汉字字模点阵数据批量生成工具_suki_v5.0破解版
01-22
汉字字模点阵数据批量生成工具支持 1024x1024以内的任意点阵汉字支持 所有Windows汉字字体设置支持 汉字大小调整 支持 汉字位置调整 支持 单个汉字字模生成 支持 海量汉字批量字模生成 支持 按汉语拼音排序 支持 横扫纵扫两种扫描方式生成数据 支持 8位一组”Z”扫描方式支持 4-32bit多种数据长度分组选择 支持 字模数据取反 支持 字节按位倒置 支持 汉语拼音自动命名C语言数组格式 支持 汉语拼音自动命名汇编语言标号DB表格式 支持 自动编号数组命名及自动编号汇编DB表命名方式 支持 图片Logo点阵数据生成 支持 二进制数据字库DAT和BIN 文件的生成 支持 二进制字库文件索引(两个字节索引) 支持 GB2312 字符集选择导入及字库生成 支持 GBK字符集选择导入及字库生成(仅供参考) 支持繁简字体自由转换 支持 单字节字符 支持 RS232串口通讯、可把字模数据发送到移动存储设备集成汉字自动识别功能，清除非汉字字符，提取汉字功能 适合用于产生点阵LED大屏幕、LCD液晶汉字字模，可用作开发辅助工具，得到精减汉字库，节约有限的ROM空间资源。也可用作带点阵LCD显示系统的汉化工具或其它需要汉字点阵数据的地方。 绿色破解版
OLED屏显和汉字点阵编码原理-附件资源
03-05
OLED屏显和汉字点阵编码原理-附件资源
LED多功能遥控显示屏设计与实现
01-19
显示屏由1024只高亮发红光二极管构成的16×64点阵组成，行扫描电路采用74HC154译码器芯片驱动，列扫描电路用8块74HC595驱动，红外遥控发射头采用一体化红外收发器.系统实现数字.字母.汉字等信息的动静态显示，和PC机...
LED照明中的全彩屏显表贴LED技术6大特性
10-19
　二， 在配光上来说，蓝色红色和绿色LED在各个角度上看上去其亮度都是相同的，这个能让屏显更完美的展示自己的播放效果，不论观看者在何种角度都可以欣赏到最好的色彩画面，而不会像其他类型的屏显那样，在角度偏差...
具体的分析一下串口屏显
07-11
5. 应用程序接口：为了方便使用串口屏幕，通常会提供一些应用程序接口（API）或软件库，用于简化与屏幕的交互。这些接口可以提供高级的绘图功能、文本处理和用户界面设计等，使开发人员能够更轻松地使用串口屏幕。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值