【扩展】【程序】F407使用模拟IIC无法点亮OLED的问题

已于 2022-09-17 15:09:23 修改
阅读量1.6k 收藏 1
点赞数
分类专栏： 程序 文章标签： 单片机 嵌入式硬件
于 2022-09-16 23:02:46 首次发布
原文链接：https://blog.csdn.net/qq_56089182/article/details/126335888?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166339852316782412549557%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=166339852316782412549557&biz_i
版权

我之前一直都用F103C8T6采用模拟IIC来驱动OLED，模拟IIC的好处就是方便修改引脚。但当我升级到F407VET6之后就发现了一个问题：当主频跑到100MHz以上的时候OLED将会无法点亮。

问题在于之前写的模拟IIC代码中并没有延时函数，导致单片机能跑多快，信号发送就有多快，当主频提高之后，OLED就无法识别这么快速的信号了。

解决步骤：

  1. 在代码中添加延时函数
  2. 关闭编译优化

这里把修改过的oled.c和oled.h文件放出来，直接覆盖我之前博文中的文件就好了

oled.c（注释乱码了…但问题不大,里面的延时函数参考了别人的代码）

#include "oled.h"
#include "stdlib.h"
#include "oledfont.h"  	 

u8 OLED_GRAM[144][8];

//���Ժ���
void OLED_ColorTurn(u8 i)
{
	if(i==0)
		{
			OLED_WR_Byte(0xA6,OLED_CMD);//������ʾ
		}
	if(i==1)
		{
			OLED_WR_Byte(0xA7,OLED_CMD);//��ɫ��ʾ
		}
}

//��Ļ��ת180��
void OLED_DisplayTurn(u8 i)
{
	if(i==0)
		{
			OLED_WR_Byte(0xC8,OLED_CMD);//������ʾ
			OLED_WR_Byte(0xA1,OLED_CMD);
		}
	if(i==1)
		{
			OLED_WR_Byte(0xC0,OLED_CMD);//��ת��ʾ
			OLED_WR_Byte(0xA0,OLED_CMD);
		}
}

//��ʼ�ź�
void I2C_Start(void)
{
	OLED_SDIN_Set();
	OLED_SCLK_Set();
	My_Delay_us(1);
	OLED_SDIN_Clr();
	My_Delay_us(3);
	OLED_SCLK_Clr();
}

//�����ź�
void I2C_Stop(void)
{
	OLED_SCLK_Set();
	My_Delay_us(1);
	OLED_SDIN_Clr();
	OLED_SDIN_Set();
	My_Delay_us(1);
}

//�ȴ��ź���Ӧ
void I2C_WaitAck(void) //�������źŵĵ�ƽ
{
	OLED_SCLK_Set();
	My_Delay_us(1);
	OLED_SCLK_Clr();
	My_Delay_us(1);
}

//д��һ���ֽ�
void Send_Byte(u8 dat)
{
	u8 i;
	for(i=0;i<8;i++)
	{
		OLED_SCLK_Clr();//��ʱ���ź�����Ϊ�͵�ƽ
		if(dat&0x80)//��dat��8λ�����λ����д��
		{
			OLED_SDIN_Set();
    	}
		else
		{
			OLED_SDIN_Clr();
    	}
		OLED_SCLK_Set();//��ʱ���ź�����Ϊ�ߵ�ƽ
		My_Delay_us(2);
		OLED_SCLK_Clr();//��ʱ���ź�����Ϊ�͵�ƽ
		My_Delay_us(2);
		dat<<=1;
  }
}

//����һ���ֽ�
//��SSD1306д��һ���ֽڡ�
//mode:����/�����־ 0,��ʾ����;1,��ʾ����;
void OLED_WR_Byte(u8 dat,u8 mode)
{
	I2C_Start();
	Send_Byte(0x78);
	I2C_WaitAck();
	if(mode){Send_Byte(0x40);}
  else{Send_Byte(0x00);}
	I2C_WaitAck();
	Send_Byte(dat);
	I2C_WaitAck();
	I2C_Stop();
}


//����OLED��ʾ 
void OLED_DisPlay_On(void)
{
	OLED_WR_Byte(0x8D,OLED_CMD);//��ɱ�ʹ��
	OLED_WR_Byte(0x14,OLED_CMD);//������ɱ�
	OLED_WR_Byte(0xAF,OLED_CMD);//������Ļ
}

//�ر�OLED��ʾ 
void OLED_DisPlay_Off(void)
{
	OLED_WR_Byte(0x8D,OLED_CMD);//��ɱ�ʹ��
	OLED_WR_Byte(0x10,OLED_CMD);//�رյ�ɱ�
	OLED_WR_Byte(0xAF,OLED_CMD);//�ر���Ļ
}

//�����Դ浽OLED	
void OLED_Refresh(void)
{
	u8 i,n;
	for(i=0;i<8;i++)
	{
	   OLED_WR_Byte(0xb0+i,OLED_CMD); //��������ʼ��ַ
	   OLED_WR_Byte(0x00,OLED_CMD);   //���õ�����ʼ��ַ
	   OLED_WR_Byte(0x10,OLED_CMD);   //���ø�����ʼ��ַ
	   for(n=0;n<128;n++)
		 OLED_WR_Byte(OLED_GRAM[n][i],OLED_DATA);
  }
}
//��������
void OLED_Clear(void)
{
	u8 i,n;
	for(i=0;i<8;i++)
	{
	   for(n=0;n<128;n++)
			{
			 OLED_GRAM[n][i]=0;//�����������
			}
  }
	OLED_Refresh();//������ʾ
}

//���� 
//x:0~127
//y:0~63
void OLED_DrawPoint(u8 x,u8 y)
{
	u8 i,m,n;
	i=y/8;
	m=y%8;
	n=1<<m;
	OLED_GRAM[x][i]|=n;
}

//���һ����
//x:0~127
//y:0~63
void OLED_ClearPoint(u8 x,u8 y)
{
	u8 i,m,n;
	i=y/8;
	m=y%8;
	n=1<<m;
	OLED_GRAM[x][i]=~OLED_GRAM[x][i];
	OLED_GRAM[x][i]|=n;
	OLED_GRAM[x][i]=~OLED_GRAM[x][i];
}


//����
//x:0~128
//y:0~64
void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2)
{
	u8 i,k,k1,k2,y0;
	if((x1<0)||(x2>128)||(y1<0)||(y2>64)||(x1>x2)||(y1>y2))return;
	if(x1==x2)    //������
	{
			for(i=0;i<(y2-y1);i++)
			{
				OLED_DrawPoint(x1,y1+i);
			}
  }
	else if(y1==y2)   //������
	{
			for(i=0;i<(x2-x1);i++)
			{
				OLED_DrawPoint(x1+i,y1);
			}
  }
	else      //���
	{
		k1=y2-y1;
		k2=x2-x1;
		k=k1*10/k2;
		for(i=0;i<(x2-x1);i++)
			{
			  OLED_DrawPoint(x1+i,y1+i*k/10);
			}
	}
}
//x,y:Բ������
//r:Բ�İ뾶
void OLED_DrawCircle(u8 x,u8 y,u8 r)
{
	int a, b,num;
    a = 0;
    b = r;
    while(2 * b * b >= r * r)      
    {
        OLED_DrawPoint(x + a, y - b);
        OLED_DrawPoint(x - a, y - b);
        OLED_DrawPoint(x - a, y + b);
        OLED_DrawPoint(x + a, y + b);
 
        OLED_DrawPoint(x + b, y + a);
        OLED_DrawPoint(x + b, y - a);
        OLED_DrawPoint(x - b, y - a);
        OLED_DrawPoint(x - b, y + a);
        
        a++;
        num = (a * a + b * b) - r*r;//���㻭�ĵ���Բ�ĵľ���
        if(num > 0)
        {
            b--;
            a--;
        }
    }
}



//��ָ��λ����ʾһ���ַ�,���������ַ�
//x:0~127
//y:0~63
//size:ѡ������ 12/16/24
void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1)
{
	u8 i,m,temp,size2,chr1;
	u8 y0=y;
	size2=(size1/8+((size1%8)?1:0))*(size1/2);  //�õ�����һ���ַ���Ӧ������ռ���ֽ���
	chr1=chr-' ';  //����ƫ�ƺ��ֵ
	for(i=0;i<size2;i++)
	{
		if(size1==12)
        {temp=asc2_1206[chr1][i];} //����1206����
		else if(size1==16)
        {temp=asc2_1608[chr1][i];} //����1608����
		else if(size1==24)
        {temp=asc2_2412[chr1][i];} //����2412����
		else return;
				for(m=0;m<8;m++)           //�����
				{
					if(temp&0x80)OLED_DrawPoint(x,y);
					else OLED_ClearPoint(x,y);
					temp<<=1;
					y++;
					if((y-y0)==size1)
					{
						y=y0;
						x++;
						break;
          }
				}
  }
}


//��ʾ�ַ���
//x,y:�������  
//size1:�����С 
//*chr:�ַ�����ʼ��ַ 
void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1)
{
	while((*chr>=' ')&&(*chr<='~'))//�ж��Dz��ǷǷ��ַ�!
	{
		OLED_ShowChar(x,y,*chr,size1);
		x+=size1/2;
		if(x>128-size1)  //����
		{
			x=0;
			y+=2;
    }
		chr++;
  }
}

//m^n
u32 OLED_Pow(u8 m,u8 n)
{
	u32 result=1;
	while(n--)
	{
	  result*=m;
	}
	return result;
}

��ʾ2������
x,y :�������	 
len :���ֵ�λ��
size:�����С
void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1)
{
	u8 t,temp;
	for(t=0;t<len;t++)
	{
		temp=(num/OLED_Pow(10,len-t-1))%10;
			if(temp==0)
			{
				OLED_ShowChar(x+(size1/2)*t,y,'0',size1);
      }
			else 
			{
			  OLED_ShowChar(x+(size1/2)*t,y,temp+'0',size1);
			}
  }
}

//��ʾ����
//x,y:�������
//num:���ֶ�Ӧ�����
void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1)
{
	u8 i,m,n=0,temp,chr1;
	u8 x0=x,y0=y;
	u8 size3=size1/8;
	while(size3--)
	{
		chr1=num*size1/8+n;
		n++;
			for(i=0;i<size1;i++)
			{
				if(size1==16)
						{temp=Hzk1[chr1][i];}//����16*16����
				else if(size1==24)
						{temp=Hzk2[chr1][i];}//����24*24����
				else if(size1==32)       
						{temp=Hzk3[chr1][i];}//����32*32����
				else if(size1==64)
						{temp=Hzk4[chr1][i];}//����64*64����
				else return;
							
						for(m=0;m<8;m++)
							{
								if(temp&0x01)OLED_DrawPoint(x,y);
								else OLED_ClearPoint(x,y);
								temp>>=1;
								y++;
							}
							x++;
							if((x-x0)==size1)
							{x=x0;y0=y0+8;}
							y=y0;
			 }
	}
}

//num ��ʾ���ֵĸ���
//space ÿһ����ʾ�ļ��
void OLED_ScrollDisplay(u8 num,u8 space)
{
	u8 i,n,t=0,m=0,r;
	while(1)
	{
		if(m==0)
		{
	    OLED_ShowChinese(128,24,t,16); //д��һ�����ֱ�����OLED_GRAM[][]������
			t++;
		}
		if(t==num)
			{
				for(r=0;r<16*space;r++)      //��ʾ���
				 {
					for(i=0;i<144;i++)
						{
							for(n=0;n<8;n++)
							{
								OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
							}
						}
           OLED_Refresh();
				 }
        t=0;
      }
		m++;
		if(m==16){m=0;}
		for(i=0;i<144;i++)   //ʵ������
		{
			for(n=0;n<8;n++)
			{
				OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
			}
		}
		OLED_Refresh();
	}
}

//����д�����ݵ���ʼλ��
void OLED_WR_BP(u8 x,u8 y)
{
	OLED_WR_Byte(0xb0+y,OLED_CMD);//��������ʼ��ַ
	OLED_WR_Byte(((x&0xf0)>>4)|0x10,OLED_CMD);
	OLED_WR_Byte((x&0x0f)|0x01,OLED_CMD);
}

//x0,y0���������
//x1,y1���յ�����
//BMP[]��Ҫд���ͼƬ����
void OLED_ShowPicture(u8 x0,u8 y0,u8 x1,u8 y1,u8 BMP[])
{
	u32 j=0;
	u8 x=0,y=0;
	if(y%8==0)y=0;
	else y+=1;
	for(y=y0;y<y1;y++)
	 {
		 OLED_WR_BP(x0,y);
		 for(x=x0;x<x1;x++)
		 {
			 OLED_WR_Byte(BMP[j],OLED_DATA);
			 j++;
     }
	 }
}
//OLED�ij�ʼ��
void OLED_Init(void)
{
	OLED_WR_Byte(0xAE,OLED_CMD);//--turn off oled panel
	OLED_WR_Byte(0x00,OLED_CMD);//---set low column address
	OLED_WR_Byte(0x10,OLED_CMD);//---set high column address
	OLED_WR_Byte(0x40,OLED_CMD);//--set start line address  Set Mapping RAM Display Start Line (0x00~0x3F)
	OLED_WR_Byte(0x81,OLED_CMD);//--set contrast control register
	OLED_WR_Byte(0xCF,OLED_CMD);// Set SEG Output Current Brightness
	OLED_WR_Byte(0xA1,OLED_CMD);//--Set SEG/Column Mapping     0xa0���ҷ��� 0xa1����
	OLED_WR_Byte(0xC8,OLED_CMD);//Set COM/Row Scan Direction   0xc0���·��� 0xc8����
	OLED_WR_Byte(0xA6,OLED_CMD);//--set normal display
	OLED_WR_Byte(0xA8,OLED_CMD);//--set multiplex ratio(1 to 64)
	OLED_WR_Byte(0x3f,OLED_CMD);//--1/64 duty
	OLED_WR_Byte(0xD3,OLED_CMD);//-set display offset	Shift Mapping RAM Counter (0x00~0x3F)
	OLED_WR_Byte(0x00,OLED_CMD);//-not offset
	OLED_WR_Byte(0xd5,OLED_CMD);//--set display clock divide ratio/oscillator frequency
	OLED_WR_Byte(0x80,OLED_CMD);//--set divide ratio, Set Clock as 100 Frames/Sec
	OLED_WR_Byte(0xD9,OLED_CMD);//--set pre-charge period
	OLED_WR_Byte(0xF1,OLED_CMD);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
	OLED_WR_Byte(0xDA,OLED_CMD);//--set com pins hardware configuration
	OLED_WR_Byte(0x12,OLED_CMD);
	OLED_WR_Byte(0xDB,OLED_CMD);//--set vcomh
	OLED_WR_Byte(0x40,OLED_CMD);//Set VCOM Deselect Level
	OLED_WR_Byte(0x20,OLED_CMD);//-Set Page Addressing Mode (0x00/0x01/0x02)
	OLED_WR_Byte(0x02,OLED_CMD);//
	OLED_WR_Byte(0x8D,OLED_CMD);//--set Charge Pump enable/disable
	OLED_WR_Byte(0x14,OLED_CMD);//--set(0x10) disable
	OLED_WR_Byte(0xA4,OLED_CMD);// Disable Entire Display On (0xa4/0xa5)
	OLED_WR_Byte(0xA6,OLED_CMD);// Disable Inverse Display On (0xa6/a7) 
	OLED_WR_Byte(0xAF,OLED_CMD);
	OLED_Clear();
}

/**************************************************
 * ���ܣ�����OLED��ʼ�������趨��ʾ������������ɫ����
 * ���룺��
 * �������
 * ************************************************/
void OLED_Init_Run(void)
{
	OLED_Init();
  	OLED_ColorTurn(0);
  	OLED_DisplayTurn(0);
  	OLED_Refresh();
}

/******************************
 * 自己写的延时函数
 * *****************************/
void My_Delay_us(uint32_t nus)
{
    uint32_t Delay = nus * 168/4;
    do
    {
        __NOP();
    }
    while (Delay --);
}

/******************************
 * 自己写的延时函数
 * *****************************/
void My_Delay(uint32_t nus)
{
    uint32_t Delay = nus;
    do
    {
        __NOP();
    }
    while (Delay --);
}

oled.h

#ifndef __OLED_H
#define __OLED_H 


#include "stdlib.h"	
#include "stm32f4xx.h"
#include <stdio.h>

/*定义IIC引脚*/
#define OLED_IIC_SCL_PORT GPIOC
#define OLED_IIC_SCL_PIN GPIO_PIN_1
#define OLED_IIC_SDA_PORT GPIOC
#define OLED_IIC_SDA_PIN GPIO_PIN_0



#define OLED_SCLK_Clr() HAL_GPIO_WritePin(OLED_IIC_SCL_PORT,OLED_IIC_SCL_PIN,GPIO_PIN_RESET)//SCL
#define OLED_SCLK_Set() HAL_GPIO_WritePin(OLED_IIC_SCL_PORT,OLED_IIC_SCL_PIN,GPIO_PIN_SET)

#define OLED_SDIN_Clr() HAL_GPIO_WritePin(OLED_IIC_SDA_PORT,OLED_IIC_SDA_PIN,GPIO_PIN_RESET)//DIN
#define OLED_SDIN_Set() HAL_GPIO_WritePin(OLED_IIC_SDA_PORT,OLED_IIC_SDA_PIN,GPIO_PIN_SET)




#define OLED_CMD  0	
#define OLED_DATA 1	
#define u8 uint8_t
#define u32 uint32_t
#define DELAY_TIME 1000000

void OLED_ClearPoint(u8 x,u8 y);
void OLED_ColorTurn(u8 i);
void OLED_DisplayTurn(u8 i);
void I2C_Start(void);
void I2C_Stop(void);
void I2C_WaitAck(void);
void Send_Byte(u8 dat);
void OLED_WR_Byte(u8 dat,u8 mode);
void OLED_DisPlay_On(void);
void OLED_DisPlay_Off(void);
void OLED_Refresh(void);
void OLED_Clear(void);
void OLED_DrawPoint(u8 x,u8 y);
void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2);
void OLED_DrawCircle(u8 x,u8 y,u8 r);
void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1);
void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1);
void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1);
void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1);
void OLED_ScrollDisplay(u8 num,u8 space);
void OLED_WR_BP(u8 x,u8 y);
void OLED_ShowPicture(u8 x0,u8 y0,u8 x1,u8 y1,u8 BMP[]);
void OLED_Init(void);
void OLED_Init_Run(void);
void My_Delay_us(uint32_t nus);
void My_Delay(uint32_t nus);

#endif

替换之后还要把编译器的优化关掉

否则编译器会认为延时函数是无效代码，不会编译也不会烧到单片机里面的。

如果在Keil[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DaUUFT0G-1663340507807)(https://picgo-nanhaibei.oss-cn-beijing.aliyuncs.com/img/%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-08-14%20202803.png)]

先点击魔法棒，然后把优化级别改成level 0就好（Keil里我没有实验过，仅供参考）

如果在CLion，进入CMakeLists.txt,把这里的add_compile_options()都注释了就好

image-20220814203021512

到这里，100MHz以上的F407也能正常用模拟IIC点亮OLED了

但是加了延时函数之后OLED的相应速度不会像原来那么快，但也完全够用了。

电工电子创新中心
关注
专栏目录
基于STM32设计的智能门锁(微信小程序+手机APP等多种方式开锁)(188)
07-17 9048
当前智能门锁项目是基于STM32微控制器、ESP8266-WIFI模块、OLED显示屏、指纹模块、蓝牙模块、门禁刷卡模块、烟雾检测模块、火光检测模块、温湿度检测模块等硬件设备开发的一种智能门锁系统
基于STM32设计的盆栽种植自动管理系统(微信小程序)(201)
最新发布
08-06 742
基于STM32设计的盆栽种植自动管理系统，通过集成多种传感器监测环境参数，结合WiFi联网功能和微信小程序远程控制，实现了对植物生长环境的自动化、精细化管理。用户可以随时随地查看当前的土壤含水量、环境温湿度、光照强度等信息，并根据实际需求设置相应的阈值以触发自动补水、灯光调节等功能。当环境条件超出设定范围时，系统能够立即通过蜂鸣器报警提醒用户，并采取相应措施调整环境条件，确保植物始终处于最佳生长状态。
STM32F407 软件模拟IIC通信程序
01-10
在STM32F407中实现模拟IIC功能读取24C256程序,测试程序稳定运行.
解决STM32F407高主频用模拟IIC无法点亮四脚OLED的问题
qq_56089182的博客
08-14 3423
但当我升级到F407VET6之后就发现了一个问题：当主频跑到100MHz以上的时候OLED将会无法点亮。问题在于之前写的模拟IIC代码中并没有延时函数，导致单片机能跑多快，信号发送就有多快，当主频提高之后，OLED就无法识别这么快速的信号了。这里把修改过的oled.c和oled.h文件放出来，直接覆盖我之前博文中的文件就好了。但是加了延时函数之后OLED的相应速度不会像原来那么快，但也完全够用了。oled.c（注释乱码了…到这里，100MHz以上的F407也能正常用模拟IIC点亮OLED了。...
STM32F407的硬件I2C
weixin_33830216的博客
12-23 1360
源：STM32F407的硬件I2C 我使用的是STM32的固件库。 硬件模块使用之前必须配置其参数，I2C的配置如下： void IIC_Config(void) { GPIO_InitTypeDef GPIO_InitStructure; I2C_InitTypeDef I2C_InitStructure; RCC_ClocksTypeDef rc...
STM32F407单片机HAL库模拟软件IIC（可移植到其他单片机）
weixin_69435861的博客
07-06 293
【代码】STM32F407单片机模拟软件IIC。
Stm32软件模拟IIC驱动OLED异常
qq_44377374的博客
05-08 919
检查过后发现在在SDA转为输出之后，应该先拉低SDA后拉高SCL。题主猜测如果按照上面的程序逻辑，在发起停止信号前，SDA为高电平， 这时候先拉高SCL再拉低SDA，就会再SCL高电平期间实现SDA的下降沿，就产生了起始信号，而反过来就会避免这种情况发生。题主在学习IIC驱动OLED过程中，模仿例程的逻辑编写好代码，程序几乎一致但是OLED啥也显示不出来。分析IIC时钟线和数据线的时序信号，检查具体是哪里出了问题。，导致IIC信号传输异常，之后具体查询这部分代码。
STM32V107VCT6，基于HAL库的用IO口模拟I2C的0.96寸OLED驱动
天马行空
12-16 745
STM32V107RCT6，基于HAL库的用IO口模拟I2C的0.96寸OLED驱动 前言 作为一个初学者，当然希望有比较好的范例可以学习，但在CSDN和众多家的单片机学习网站，没发现现成的I2C模拟接口的HAL库的0.96寸的OLED驱动，经过努力，把这个代码调试出来，为此，基于技术共享的前提以及给后来者多个参考，把代码发表出来，大家互相学习指正。 一、相应的环境 单片机：STM32F107VCT6 开发环境：MDKV5.28 库函数：HAL库 开发板：Kicad自画开发板一块 OLED模块：P
基于I2C/SPI总线的温湿度采集与OLED显示
weixin_45919652的博客
11-21 3356
文章目录一、实验要求二、实验过程及结果（一）温湿度显示1. I2C总线通信协议1）I2C 物理层2）协议层2. 采集温湿度（二）OLED显示（三）信号分析三、实验总结四、参考资料 一、实验要求 学习I2C总线通信协议，使用STM32F103完成基于I2C协议的AHT20温湿度传感器的数据采集，并将采集的温度-湿度值通过串口输出。具体任务： 1）解释什么是“软件I2C”和“硬件I2C”？（阅读野火配套教材的第23章“I2C–读写EEPROM”原理章节） 2）阅读AHT20数据手册，编程实现：每隔2秒钟
基于I2C协议的AHT20温湿度传感器的数据采集及OLED屏显示
shutupbb的博客
11-25 4282
一、 I2C协议简介 1、何为I2C协议 I2C 通讯协议(Inter－Integrated Circuit)是由 Phiilps 公司开发的，由于它引脚少，硬件实现简单，可扩展性强，不需要 USART、CAN 等通讯协议的外部收发设备，现在被广泛地使用在系统内多个集成电路(IC)间的通讯。 2、软件I2C与硬件I2C 所谓硬件I2C对应芯片上的I2C外设，有相应I2C驱动电路，其所使用的I2C管脚也是专用的；软件I2C一般是用GPIO管脚，用软件控制管脚状态以模拟I2C通信波形。 硬件I2C的效率要远高于
STM32F407_OLED显示
09-03
主要是在STM32F407上加载OLED显示屏的驱动，用于显示功能，该驱是从STM32F103平台上移植过来的，相关的错误已经完全排除，已经调试完成，可以正常显示，仅供参考，不当之处，还请指正。
OLED显示屏STM32F407的I2C通信
04-22
OLED显示屏STM32F407的I2C通信
stm32f407+0.96寸oled屏显示字符、字符串、数字
06-26
使用stm32f407+0.96寸oled屏利用IIC通信显示字符、字符串、数字 。 引脚连接PB6-IIC_SCL PB7-IIC_SDA 显示一个字符函数 OLED_ShowChar(列数（从0开始）,行数（从0开始）,要显示的字符串,字体大小（6-16可清晰显示）) 显示字符串函数 OLED_ShowString(列数（从0开始）,行数（从0开始）,要显示的字符串,字体大小（6-16可清晰显示）) 显示int型变量函数 OLED_Show_Num(列数（从0开始）,行数（从0开始）,要显示的字符串,字体大小（6-16可清晰显示）) 注：一直刷新频率，若要更改刷新频率，根据oled_int（）函数中的注释更改。可根据需要在oled_int（）添加引脚初始化等内容，等待0.96寸屏初始化完成后有明显提示。
STM32F407-OLED四线IIC.zip
05-24
STM32F407四线OLED，四线iic控制oled，下载后直接将其更改显示字符即可使用
stm32f407ZET驱动IIC 0.96寸OLED
08-07
加延时 STM32F407ZGT6 ZET6 VET6开发板STM32核心板M4ARM系统扩展版学习
STM32F407 模拟IIC AT24C16出坑记录
MAYONG1的博客
11-25 4206
事情经过：有个项目一个模拟IIC上挂了3个外设，其中一个为AT24C02,模拟IIC用的是原子的。这种模式下使用完全没有问题，直到项目需要更换AT24C16。。。第一次找了两个供应商打样了一批AT24C16的IC卡，直接替换没有问题，认为方案替换没有问题。问题在于，当供应商批量供货的时候，懵了，全部不能读写，但是这些卡在另外的（程序一样就是主控芯片和电路不一样）一个读卡设备上却是可以的。 分析过程： 一、供应商确认前后两批AT24C16的卡都是同一个型号，就是批次不一样。？？？批次出问题了？但为什么同样
【解决方案】OLED程序（IIC）从stm32f103移植到stm32f429不显示
嵌入式阿齐Archie
11-08 3091
【解决方案】OLED程序（IIC）从stm32f103移植到stm32f429出现bug不显示
STM32F407单片机移植MS5611气压计（基于IIC）---同时解决温度低于20度时计算得到的大气压错误的问题
u010134355的博客
09-29 1962
        最近一个工程项目需要使用MS5611气压计，就花时间研究了一下，发现网上很多都是基于STM32F103单片机的MS5611气压计源程序，当移植到STM32F407时发现采集的大气压力和温度值不对，同时发现网上部分程序在温度高于20度时，计算得到的大气压力是正确的，但是当温度低于20度时，计算得到的大气压力是错误的。网上程序代码问题主要集中在以下几个方面： ...
STM32F407开发板驱动OLED液晶屏
m0_58556180的博客
04-26 1464
模块供电可以是3.3V 也可以是5V，不需要修改模块电路，同时兼容3种通信方式：4 线SPI、3线SPI、 IIC，通信模式的选择可以根据提供的BOM表进行跳选。聚合材料可以是天然的，也可能是人工合成的，可能尺寸很大，也可能尺寸很小。在这OLED需要SPI接口与F407 Micropython开发板进行连接传输数据，SPI接口是在CPU和外围低速器件之间进行同步串行数据传输，F407 Micropython开发板自带两个SPI接口，本实验中我们用的F407 Micropython开发板的SPI1接口。
字符串加密与解密，输入一字符串，按如下规则加密，将原文中每个字符转换为对应的ascii码后，再将该ascii码加上一100至200之间的整数得到的数值即为该字符对应的密文；解密即为上述过程的逆运算。将该字符串加密后再解密，并且显示原文、密文、解密后文本。
03-26
示例： 输入字符串：hello world 加密后密文：ňľľŬĊĭŭũĨŲĬŲĨ 解密后文本：hello world 代码实现： ```python import random def encrypt(s): res = [] for c in s: code = ord(c) + random.randint(100, 200) res.append(chr(code)) return ''.join(res) def decrypt(s): res = [] for c in s: code = ord(c) - random.randint(100, 200) res.append(chr(code)) return ''.join(res) s = input("请输入要加密的字符串：") encrypted = encrypt(s) print("加密后密文：", encrypted) decrypted = decrypt(encrypted) print("解密后文本：", decrypted) ``` 注意：由于加密过程中使用了随机数，因此每次加密得到的密文不同。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值