汉字点阵与OLED屏显

最新推荐文章于 2024-09-23 21:30:42 发布

闪电侠123

最新推荐文章于 2024-09-23 21:30:42 发布

阅读量53

点赞数

文章标签： stm32 嵌入式硬件

本文链接：https://blog.csdn.net/asd6666jkl/article/details/134492404

版权

汉字点阵与OLED屏显

文章目录

汉字点阵与OLED屏显
一、串口连接传输文件
二、在Ubuntu下用C/C++(或python) 调用opencv库编程显示一张图片
使用OLED屏显显示学号姓名，温度湿度

一、串口连接传输文件

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

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

设置波特率为115200，并发送文件
在这里插入图片描述

2.另一台电脑接收的文件，波特率115200

二、在Ubuntu下用C/C++(或python) 调用opencv库编程显示一张图片

汉字的机内码、区位码和字形数据存储格式是汉字编码中的三个重要概念。并配以简单的图示。

机内码（GB2312-80）
机内码是汉字在计算机内部存储和处理的编码方式。GB2312-80是中国制定的第一个汉字编码标准，包含6763个汉字，涵盖了大部分常用汉字。

编码规则：

机内码采用2字节（16位）的编码方式。
第一字节（高位字节）采用区号和位号表示，区号范围从0x4E00到0x9FA5，共94个区；位号范围从0x00到0xFF，共256个位。
第二字节（低位字节）采用区号和位号表示，但与第一字节的区号和位号紧密相连。例如，第一字节编码为0x4E00表示汉字"啊"，则第二字节编码为0x3F。
字形数据存储格式：
机内码的字形数据存储格式采用点阵形式，每个汉字点阵包含16×16=256个点，每个点用一位二进制表示。
字形数据存储时，首先存储字形数据的长度（字节数），然后存储实际的字形点阵数据。

区位码（GB2312-80）

区位码是汉字在计算机外部存储和传输的编码方式。它将汉字分为94个区，每个区有94个位，共计8836个汉字。

编码规则：

区位码采用4个十进制数字表示，前两个数字表示区号，后两个数字表示位号。例如，"啊"字的区位码为49 28H（H表示十六进制）。
区位码不包含重码字，即同一个汉字在同一个区位中只有一个编码。
1
2
字形数据存储格式：
区位码的字形数据存储格式通常采用轮廓矢量化格式，每个汉字的字形数据由一组矢量描述。这种格式可以节省存储空间，并可以通过软件进行字形缩放、旋转等操作。
字形数据存储时，通常会附带一些其他信息，如字体类型、大小、颜色等。

字形数据存储格式示例图（轮廓矢量化格式）

下面是一个示例图，展示了轮廓矢量化格式的字形数据存储方式：

字形数据：轮廓矢量化格式示例图

±---------------±---------------±---------------±---------------+
| 字形数据1（矢量）| 字形数据2（矢量）| 字形数据3（矢量）| 字形数据4（矢量）|
±---------------±---------------±---------------±---------------+
在轮廓矢量化格式中，每个汉字的字形数据由一组矢量描述。这些矢量定义了字形的轮廓和内部细节。存储时，每个字形数据的长度和具体矢量数据都会被记录下来。使用这种格式可以节省存储空间，并可以通过软件进行字形缩放、旋转等操作。

1.在Ubuntu下用C/C++(或python) 调用opencv库编程显示一张图片，并打开一个名为"logo.txt"的文本文件（其中只有一行文本文件，包括名字和学号），按照名字和学号去读取汉字2424点阵字形字库中对应字符的字形数据，将名字和学号叠加显示在此图片右下位置。
2.一张需要显示的图片，2424的点阵.hz文件，ASCII码.zf文件，需要显示的文本文件
在这里插入图片描述

安装cmake

sudo apt-get install cmake

输入命令

sudo apt-get update
sudo apt-get upgrade
sudo apt install cmake

下载opencv
打开浏览器输入网址
在这里插入图片描述
下载3.4.12.zip
下载完成后，在ununtu中解压
输入

   sudo apt-get install opencv-3.4.12.zip

在这里插入图片描述
解压成功后可以看到
再从网上搜索教程，完善openve的下载及内部环境搭建
将ASC和HZK文件拽入自行创建的文件夹中

创建word文件
在其中编写以下代码

#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="libao.jpg";//图片的名字
    char* logo_path="logo.txt";//汉字文件的名字
    put_text_to_image(200,350,image_path,logo_path);//change txt place
    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("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("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=18;//要打印的字符长度（打印多少字节长度就为多少，根据自己的情况调整）
    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();
}

在自行创建文件夹中右键打开open in terminal
在这里插入图片描述
输入./word

弹出图片

使用OLED屏显显示学号姓名，温度湿度

配置好标准库后
在oled.h文件中加入下列代码

#ifndef __OLED_H
#define __OLED_H
#include "stm32f10x.h"                  // Device header

void OLED_Init(void);
void OLED_Clear(void);
void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char);
void OLED_ShowString(uint8_t Line, uint8_t Column, char *String);
void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length);
void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
void OLED_ShowChinese(uint8_t Line,uint8_t Column,uint8_t num);
void OLED_ShowChinese1(uint8_t Line,uint8_t Column,uint8_t num);
#endif

在oled.c文件中加入下列代码

#include "stm32f10x.h"
#include "OLED_Font.h"


/*Òý½ÅÅäÖÃ*/
#define OLED_W_SCL(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_8, (BitAction)(x))
#define OLED_W_SDA(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_9, (BitAction)(x))

/*Òý½Å³õÊ¼»¯*/
void OLED_I2C_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	
	
 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;//¿ªÂ©Êä³ö
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
 	GPIO_Init(GPIOB, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
 	GPIO_Init(GPIOB, &GPIO_InitStructure);
	
	OLED_W_SCL(1);
	OLED_W_SDA(1);
}

/**
  * @brief  I2C¿ªÊ¼
  * @param  ÎÞ
  * @retval ÎÞ
  */
void OLED_I2C_Start(void)
{
	OLED_W_SDA(1);
	OLED_W_SCL(1);
	OLED_W_SDA(0);
	OLED_W_SCL(0);
}

/**
  * @brief  I2CÍ£Ö¹
  * @param  ÎÞ
  * @retval ÎÞ
  */
void OLED_I2C_Stop(void)
{
	OLED_W_SDA(0);
	OLED_W_SCL(1);
	OLED_W_SDA(1);
}

/**
  * @brief  I2C·¢ËÍÒ»¸ö×Ö½Ú
  * @param  Byte Òª·¢ËÍµÄÒ»¸ö×Ö½Ú
  * @retval ÎÞ
  */
void OLED_I2C_SendByte(uint8_t Byte)
{
	uint8_t i;
	for (i = 0; i < 8; i++)
	{
		OLED_W_SDA(Byte & (0x80 >> i));
		OLED_W_SCL(1);
		OLED_W_SCL(0);
	}
	OLED_W_SCL(1);	//¶îÍâµÄÒ»¸öÊ±ÖÓ£¬²»´¦ÀíÓ¦´ðÐÅºÅ
	OLED_W_SCL(0);
}

/**
  * @brief  OLEDÐ´ÃüÁî
  * @param  Command ÒªÐ´ÈëµÄÃüÁî
  * @retval ÎÞ
  */
void OLED_WriteCommand(uint8_t Command)
{
	OLED_I2C_Start();
	OLED_I2C_SendByte(0x78);		//´Ó»úµØÖ·
	OLED_I2C_SendByte(0x00);		//Ð´ÃüÁî
	OLED_I2C_SendByte(Command); 
	OLED_I2C_Stop();
}

/**
  * @brief  OLEDÐ´Êý¾Ý
  * @param  Data ÒªÐ´ÈëµÄÊý¾Ý
  * @retval ÎÞ
  */
void OLED_WriteData(uint8_t Data)
{
	OLED_I2C_Start();
	OLED_I2C_SendByte(0x78);		//´Ó»úµØÖ·
	OLED_I2C_SendByte(0x40);		//Ð´Êý¾Ý
	OLED_I2C_SendByte(Data);
	OLED_I2C_Stop();
}

/**
  * @brief  OLEDÉèÖÃ¹â±êÎ»ÖÃ
  * @param  Y ÒÔ×óÉÏ½ÇÎªÔµã£¬ÏòÏÂ·½ÏòµÄ×ø±ê£¬·¶Î§£º0~7
  * @param  X ÒÔ×óÉÏ½ÇÎªÔµã£¬ÏòÓÒ·½ÏòµÄ×ø±ê£¬·¶Î§£º0~127
  * @retval ÎÞ
  */
void OLED_SetCursor(uint8_t Y, uint8_t X)
{
	OLED_WriteCommand(0xB0 | Y);					//ÉèÖÃYÎ»ÖÃ
	OLED_WriteCommand(0x10 | ((X & 0xF0) >> 4));	//ÉèÖÃXÎ»ÖÃµÍ4Î»
	OLED_WriteCommand(0x00 | (X & 0x0F));			//ÉèÖÃXÎ»ÖÃ¸ß4Î»
}

/**
  * @brief  OLEDÇåÆÁ
  * @param  ÎÞ
  * @retval ÎÞ
  */
void OLED_Clear(void)
{  
	uint8_t i, j;
	for (j = 0; j < 8; j++)
	{
		OLED_SetCursor(j, 0);
		for(i = 0; i < 128; i++)
		{
			OLED_WriteData(0x00);
		}
	}
}

/**
  * @brief  OLEDÏÔÊ¾Ò»¸ö×Ö·û
  * @param  Line ÐÐÎ»ÖÃ£¬·¶Î§£º1~4
  * @param  Column ÁÐÎ»ÖÃ£¬·¶Î§£º1~16
  * @param  Char ÒªÏÔÊ¾µÄÒ»¸ö×Ö·û£¬·¶Î§£ºASCII¿É¼û×Ö·û
  * @retval ÎÞ
  */
void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char)
{      	
	uint8_t i;
	OLED_SetCursor((Line - 1) * 2, (Column - 1) * 8);		//ÉèÖÃ¹â±êÎ»ÖÃÔÚÉÏ°ë²¿·Ö
	for (i = 0; i < 8; i++)
	{
		OLED_WriteData(OLED_F8x16[Char - ' '][i]);			//ÏÔÊ¾ÉÏ°ë²¿·ÖÄÚÈÝ
	}
	OLED_SetCursor((Line - 1) * 2 + 1, (Column - 1) * 8);	//ÉèÖÃ¹â±êÎ»ÖÃÔÚÏÂ°ë²¿·Ö
	for (i = 0; i < 8; i++)
	{
		OLED_WriteData(OLED_F8x16[Char - ' '][i + 8]);		//ÏÔÊ¾ÏÂ°ë²¿·ÖÄÚÈÝ
	}
}

/**
  * @brief  OLEDÏÔÊ¾×Ö·û´®
  * @param  Line ÆðÊ¼ÐÐÎ»ÖÃ£¬·¶Î§£º1~4
  * @param  Column ÆðÊ¼ÁÐÎ»ÖÃ£¬·¶Î§£º1~16
  * @param  String ÒªÏÔÊ¾µÄ×Ö·û´®£¬·¶Î§£ºASCII¿É¼û×Ö·û
  * @retval ÎÞ
  */
void OLED_ShowString(uint8_t Line, uint8_t Column, char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i++)
	{
		OLED_ShowChar(Line, Column + i, String[i]);
	}
}

/**
  * @brief  OLED´Î·½º¯Êý
  * @retval ·µ»ØÖµµÈÓÚXµÄY´Î·½
  */
uint32_t OLED_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y--)
	{
		Result *= X;
	}
	return Result;
}

/**
  * @brief  OLEDÏÔÊ¾Êý×Ö£¨Ê®½øÖÆ£¬ÕýÊý£©
  * @param  Line ÆðÊ¼ÐÐÎ»ÖÃ£¬·¶Î§£º1~4
  * @param  Column ÆðÊ¼ÁÐÎ»ÖÃ£¬·¶Î§£º1~16
  * @param  Number ÒªÏÔÊ¾µÄÊý×Ö£¬·¶Î§£º0~4294967295
  * @param  Length ÒªÏÔÊ¾Êý×ÖµÄ³¤¶È£¬·¶Î§£º1~10
  * @retval ÎÞ
  */
void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i++)							
	{
		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(10, Length - i - 1) % 10 + '0');
	}
}

/**
  * @brief  OLEDÏÔÊ¾Êý×Ö£¨Ê®½øÖÆ£¬´ø·ûºÅÊý£©
  * @param  Line ÆðÊ¼ÐÐÎ»ÖÃ£¬·¶Î§£º1~4
  * @param  Column ÆðÊ¼ÁÐÎ»ÖÃ£¬·¶Î§£º1~16
  * @param  Number ÒªÏÔÊ¾µÄÊý×Ö£¬·¶Î§£º-2147483648~2147483647
  * @param  Length ÒªÏÔÊ¾Êý×ÖµÄ³¤¶È£¬·¶Î§£º1~10
  * @retval ÎÞ
  */
void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length)
{
	uint8_t i;
	uint32_t Number1;
	if (Number >= 0)
	{
		OLED_ShowChar(Line, Column, '+');
		Number1 = Number;
	}
	else
	{
		OLED_ShowChar(Line, Column, '-');
		Number1 = -Number;
	}
	for (i = 0; i < Length; i++)							
	{
		OLED_ShowChar(Line, Column + i + 1, Number1 / OLED_Pow(10, Length - i - 1) % 10 + '0');
	}
}

/**
  * @brief  OLEDÏÔÊ¾Êý×Ö£¨Ê®Áù½øÖÆ£¬ÕýÊý£©
  * @param  Line ÆðÊ¼ÐÐÎ»ÖÃ£¬·¶Î§£º1~4
  * @param  Column ÆðÊ¼ÁÐÎ»ÖÃ£¬·¶Î§£º1~16
  * @param  Number ÒªÏÔÊ¾µÄÊý×Ö£¬·¶Î§£º0~0xFFFFFFFF
  * @param  Length ÒªÏÔÊ¾Êý×ÖµÄ³¤¶È£¬·¶Î§£º1~8
  * @retval ÎÞ
  */
void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
	uint8_t i, SingleNumber;
	for (i = 0; i < Length; i++)							
	{
		SingleNumber = Number / OLED_Pow(16, Length - i - 1) % 16;
		if (SingleNumber < 10)
		{
			OLED_ShowChar(Line, Column + i, SingleNumber + '0');
		}
		else
		{
			OLED_ShowChar(Line, Column + i, SingleNumber - 10 + 'A');
		}
	}
}

/**
  * @brief  OLEDÏÔÊ¾Êý×Ö£¨¶þ½øÖÆ£¬ÕýÊý£©
  * @param  Line ÆðÊ¼ÐÐÎ»ÖÃ£¬·¶Î§£º1~4
  * @param  Column ÆðÊ¼ÁÐÎ»ÖÃ£¬·¶Î§£º1~16
  * @param  Number ÒªÏÔÊ¾µÄÊý×Ö£¬·¶Î§£º0~1111 1111 1111 1111
  * @param  Length ÒªÏÔÊ¾Êý×ÖµÄ³¤¶È£¬·¶Î§£º1~16
  * @retval ÎÞ
  */
void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i++)							
	{
		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(2, Length - i - 1) % 2 + '0');
	}
}

/**********************************
ÏÔÊ¾Ò»¸öÎÄ×Ö
ÊäÈëÊý¾Ý£º 
x----ÐÐ
y----ÁÐ
no----×Ö¿âÊý×éÎÄ×Ö¶ÔÓ¦µÄÎ»ÖÃ
**********************************/
 void OLED_ShowChinese(uint8_t Line,uint8_t Column,uint8_t num)
 {
	 uint8_t i;
	 OLED_SetCursor((Line-1)*2,(Column-1)*16);
	 for(i=0;i<16;i++)
	 {
		 OLED_WriteData(Font_Chinese[2*num][i]);
		 
	 }
	 
 	 OLED_SetCursor((Line-1)*2+1,(Column-1)*16);
	 for(i=0;i<16;i++)
	 {
		 OLED_WriteData(Font_Chinese[2*num+1][i]);
	 }
	 
 }
 
 void OLED_ShowChinese1(uint8_t Line,uint8_t Column,uint8_t num)
 {
	 uint8_t i;
	 OLED_SetCursor((Line-1)*2,(Column-1)*16);
	 for(i=0;i<16;i++)
	 {
		 OLED_WriteData(Font_Chinese1[2*num][i]);
		 
	 }
	 
 	 OLED_SetCursor((Line-1)*2+1,(Column-1)*16);
	 for(i=0;i<16;i++)
	 {
		 OLED_WriteData(Font_Chinese1[2*num+1][i]);
	 }
	 
 }


/**
  * @brief  OLED³õÊ¼»¯
  * @param  ÎÞ
  * @retval ÎÞ
  */
void OLED_Init(void)
{
	uint32_t i, j;
	
	for (i = 0; i < 1000; i++)			//ÉÏµçÑÓÊ±
	{
		for (j = 0; j < 1000; j++);
	}
	
	OLED_I2C_Init();			//¶Ë¿Ú³õÊ¼»¯
	
	OLED_WriteCommand(0xAE);	//¹Ø±ÕÏÔÊ¾
	
	OLED_WriteCommand(0xD5);	//ÉèÖÃÏÔÊ¾Ê±ÖÓ·ÖÆµ±È/Õñµ´Æ÷ÆµÂÊ
	OLED_WriteCommand(0x80);
	
	OLED_WriteCommand(0xA8);	//ÉèÖÃ¶àÂ·¸´ÓÃÂÊ
	OLED_WriteCommand(0x3F);
	
	OLED_WriteCommand(0xD3);	//ÉèÖÃÏÔÊ¾Æ«ÒÆ
	OLED_WriteCommand(0x00);
	
	OLED_WriteCommand(0x40);	//ÉèÖÃÏÔÊ¾¿ªÊ¼ÐÐ
	
	OLED_WriteCommand(0xA1);	//ÉèÖÃ×óÓÒ·½Ïò£¬0xA1Õý³£ 0xA0×óÓÒ·´ÖÃ
	
	OLED_WriteCommand(0xC8);	//ÉèÖÃÉÏÏÂ·½Ïò£¬0xC8Õý³£ 0xC0ÉÏÏÂ·´ÖÃ

	OLED_WriteCommand(0xDA);	//ÉèÖÃCOMÒý½ÅÓ²¼þÅäÖÃ
	OLED_WriteCommand(0x12);
	
	OLED_WriteCommand(0x81);	//ÉèÖÃ¶Ô±È¶È¿ØÖÆ
	OLED_WriteCommand(0xCF);

	OLED_WriteCommand(0xD9);	//ÉèÖÃÔ¤³äµçÖÜÆÚ
	OLED_WriteCommand(0xF1);

	OLED_WriteCommand(0xDB);	//ÉèÖÃVCOMHÈ¡ÏûÑ¡Ôñ¼¶±ð
	OLED_WriteCommand(0x30);

	OLED_WriteCommand(0xA4);	//ÉèÖÃÕû¸öÏÔÊ¾´ò¿ª/¹Ø±Õ

	OLED_WriteCommand(0xA6);	//ÉèÖÃÕý³£/µ¹×ªÏÔÊ¾

	OLED_WriteCommand(0x8D);	//ÉèÖÃ³äµç±Ã
	OLED_WriteCommand(0x14);

	OLED_WriteCommand(0xAF);	//¿ªÆôÏÔÊ¾
		
	OLED_Clear();				//OLEDÇåÆÁ
}

生成字模
在这里插入图片描述
添加到oled_font.h中

温度湿度显示
在main.c中添加如下程序

int main()
{
	Delay_ms(100);

  OLED_Init();
	uart_init(9600);
	OLED_Clear();
  RCC_Configuration();
	RTC_Config();
	OLED_ShowChinese1(1, 1,2);						//Êª	
	OLED_ShowChinese1(1, 2, 3);	//¶È
		OLED_ShowChinese1(1, 3, 4);	//¶È
	OLED_ShowString(2,1,"632107030603");	

  OLED_ShowChinese(3, 1,0);						//ÎÂ
	OLED_ShowChinese(3, 2, 1); 	          //¶È
	OLED_ShowString(3,5,":");						//:
  OLED_ShowString(3,9,".");	
	OLED_ShowChinese1(4, 1,0);						//Êª	
	OLED_ShowChinese1(4, 2, 1); 	          //¶È
  OLED_ShowString(4,5,":");	
	OLED_ShowString(4,9,".");	
	RTC_Set(2023,11,15,15,20,00);
	while(1)
	{
		Delay_ms(1000);
	
		DHT11_REC_Data(); //½ÓÊÕÎÂ¶ÈºÍÊª¶ÈµÄÊý¾Ý
		
	  OLED_ShowNum(3,7,rec_data[2],2);
		OLED_ShowNum(3,10,rec_data[3],1);
		OLED_ShowNum(4,7,rec_data[0],2);
		OLED_ShowNum(4,10,rec_data[1],2);

	}
}

在DHT11.c中添加

#include "stm32f10x.h"                  // Device header
#include  "dht11.h"
#include  "Delay.h"
//Êý¾Ý
unsigned int rec_data[4];


//¶ÔÓÚstm32À´Ëµ£¬ÊÇÊä³ö
void DH11_GPIO_Init_OUT(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	
	GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP; //ÍÆÍìÊä³ö
	GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_12;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	
	GPIO_Init(GPIOB, &GPIO_InitStructure);

}

//¶ÔÓÚstm32À´Ëµ£¬ÊÇÊäÈë
void DH11_GPIO_Init_IN(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	
	GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IN_FLOATING; //¸¡¿ÕÊäÈë
	GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_12;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	
	GPIO_Init(GPIOB, &GPIO_InitStructure);

}



//Ö÷»ú·¢ËÍ¿ªÊ¼ÐÅºÅ
void DHT11_Start(void)
{
	DH11_GPIO_Init_OUT(); //Êä³öÄ£Ê½
	
	dht11_high; //ÏÈÀ¸ß
	Delay_us(30);
	
	dht11_low; //ÀµÍµçÆ½ÖÁÉÙ18us
	Delay_ms(20);
	
	dht11_high; //À¸ßµçÆ½20~40us
	Delay_us(30);
	
	DH11_GPIO_Init_IN(); //ÊäÈëÄ£Ê½
}


//»ñÈ¡Ò»¸ö×Ö½Ú
char DHT11_Rec_Byte(void)
{
	unsigned char i = 0;
	unsigned char data;
	
	for(i=0;i<8;i++) //1¸öÊý¾Ý¾ÍÊÇ1¸ö×Ö½Úbyte£¬1¸ö×Ö½ÚbyteÓÐ8Î»bit
	{
		while( Read_Data == 0); //´Ó1bit¿ªÊ¼£¬µÍµçÆ½±ä¸ßµçÆ½£¬µÈ´ýµÍµçÆ½½áÊø
		Delay_us(30); //ÑÓ³Ù30usÊÇÎªÁËÇø±ðÊý¾Ý0ºÍÊý¾Ý1£¬0Ö»ÓÐ26~28us
		
		data <<= 1; //×óÒÆ
		
		if( Read_Data == 1 ) //Èç¹û¹ýÁË30us»¹ÊÇ¸ßµçÆ½µÄ»°¾ÍÊÇÊý¾Ý1
		{
			data |= 1; //Êý¾Ý+1
		}
		
		while( Read_Data == 1 ); //¸ßµçÆ½±äµÍµçÆ½£¬µÈ´ý¸ßµçÆ½½áÊø
	}
	
	return data;
}

//»ñÈ¡Êý¾Ý

void DHT11_REC_Data(void)
{
	unsigned int R_H,R_L,T_H,T_L;
	unsigned char RH,RL,TH,TL,CHECK;
	
	DHT11_Start(); //Ö÷»ú·¢ËÍÐÅºÅ
	dht11_high; //À¸ßµçÆ½
	
	if( Read_Data == 0 ) //ÅÐ¶ÏDHT11ÊÇ·ñÏìÓ¦
	{
		while( Read_Data == 0); //µÍµçÆ½±ä¸ßµçÆ½£¬µÈ´ýµÍµçÆ½½áÊø
		while( Read_Data == 1); //¸ßµçÆ½±äµÍµçÆ½£¬µÈ´ý¸ßµçÆ½½áÊø
		
		R_H = DHT11_Rec_Byte();
		R_L = DHT11_Rec_Byte();
		T_H = DHT11_Rec_Byte();
		T_L = DHT11_Rec_Byte();
		CHECK = DHT11_Rec_Byte(); //½ÓÊÕ5¸öÊý¾Ý
		
		dht11_low; //µ±×îºóÒ»bitÊý¾Ý´«ËÍÍê±Ïºó£¬DHT11ÀµÍ×ÜÏß 50us
		Delay_us(55); //ÕâÀïÑÓÊ±55us
		dht11_high; //Ëæºó×ÜÏßÓÉÉÏÀµç×èÀ¸ß½øÈë¿ÕÏÐ×´Ì¬¡£
		
		if(R_H + R_L + T_H + T_L == CHECK) //ºÍ¼ìÑéÎ»¶Ô±È£¬ÅÐ¶ÏÐ£Ñé½ÓÊÕµ½µÄÊý¾ÝÊÇ·ñÕýÈ·
		{
			RH = R_H;
			RL = R_L;
			TH = T_H;
			TL = T_L;
		}
	}
	rec_data[0] = RH;
	rec_data[1] = RL;
	rec_data[2] = TH;
	rec_data[3] = TL;
}

在DHT11.h中添加

#ifndef __DHT11_H
#define __DHT11_H
#include "stm32f10x.h"                  // Device header



#define dht11_high GPIO_SetBits(GPIOB, GPIO_Pin_12)
#define dht11_low GPIO_ResetBits(GPIOB, GPIO_Pin_12)
#define Read_Data GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_12)

void DHT11_GPIO_Init_OUT(void);
void DHT11_GPIO_Init_IN(void);
void DHT11_Start(void);
unsigned char DHT11_REC_Byte(void);
void DHT11_REC_Data(void);



#endif