解决STM32F407高主频用模拟IIC无法点亮四脚OLED的问题

最新推荐文章于 2024-05-13 12:01:26 发布
最新推荐文章于 2024-05-13 12:01:26 发布
阅读量1.6k 收藏 18
点赞数 4
文章标签： stm32 单片机 arm 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56089182/article/details/126335888
版权

我之前一直都用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屏幕截图 2022-08-14 202803

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

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

image-20220814203021512

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

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

NanHaibei
关注
  • 4
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
STM32（HAL库）软件IIC驱动OLED
weixin_44597885的博客
07-17 6514
本文通过STM32F103C8T6单片机（HAL库）通过软件IIC方式对OLED进行驱动。
STM32F407（1）
sw6256的博客
03-05 3122
STM32F407主频为168MHz是指SYSCLK（系统时钟）的频率为168MHz STM32F407中5个时钟源： 1、LSIRC（32kHz）（低速内部时钟、RC振荡器产生、精度低）    --〉IWDGCLK(独立看门狗)
（五）STM32F407 cubemx IIC驱动OLED（2）硬件篇
最新发布
weixin_52531699的博客
05-13 1147
本文不会概述OLED的物理工作原理，而是从技术手册的角度上简述它。首先要学习OLED就得先了解其驱动芯片，**SSD1306**。
Stm32软件模拟IIC驱动OLED异常
qq_44377374的博客
05-08 787
检查过后发现在在SDA转为输出之后，应该先拉低SDA后拉高SCL。题主猜测如果按照上面的程序逻辑，在发起停止信号前，SDA为高电平， 这时候先拉高SCL再拉低SDA，就会再SCL高电平期间实现SDA的下降沿，就产生了起始信号，而反过来就会避免这种情况发生。题主在学习IIC驱动OLED过程中，模仿例程的逻辑编写好代码，程序几乎一致但是OLED啥也显示不出来。分析IIC时钟线和数据线的时序信号，检查具体是哪里出了问题。，导致IIC信号传输异常，之后具体查询这部分代码。
stm32f407zgt6移植OLED遇到的问题（附有OLED官方例程）
vivanDeng_的博客
04-21 1639
最近在做一个项目，用到了正点原子的stm32f4zgt6开发板，自然首先驱动OLED方便后续调试代码，然而发现许多问题，现在解决了，在这里跟大家分享一下。
stm32f407VET6驱动IIC 0.96寸OLED.rar
05-04
STM32F407VET6是一款高性能的微控制器，属于STM32F4系列，基于ARM Cortex-M4内核，拥有浮点运算单元（FPU），在嵌入式系统设计中广泛应用。驱动0.96寸OLED显示器则是通过IIC（Inter-Integrated Circuit）总线进行...
STM32实现0.96寸OLED显示模拟IIC和IIC四种实现(标准库和HAL库)
11-17
STM32实现0.96寸OLED显示模拟IIC和IIC实现(标准库和HAL库) 博客地址：https://blog.csdn.net/XiaoCaiDaYong/article/details/127907499
STM32F407：IIC+SPI+0.96oled屏幕资料总汇(0331)
03-31
在这个资料总汇中，我们聚焦于如何使用STM32F407进行IIC、SPI通信以及驱动0.96英寸的OLED屏幕。下面将详细介绍这些知识点。 1. IIC（Inter-Integrated Circuit，集成电路间总线）： IIC是一种串行通信协议，由...
STM32F407 软件模拟IIC通信程序
01-10
在STM32F407上模拟IIC通信是为了实现与IIC设备的数据交换，如本例中的24C256 EEPROM。 24C256是一款具有256K位（32K字节）存储容量的IIC接口电可擦除可编程只读存储器（EEPROM）。它有8个地址线，因此可以寻址2^8 =...
基于STM32F407ZGT6硬件IIC驱动OLED（ssd1306 0.96）动态显示例程
03-24
本例程基于正点原子探索者开发板而写，应该适用于所有STM32F4的芯片吧，本人也是新手，哈哈哈哈。 再说说这个ST硬件IIC吧 ，调了好多天，一直死在EV6或者EV8事件的检查里跳不出来，找了网上无数大神的作品，最后调出来了，显示出来的那一刻感觉中大奖一样！！！ 调出来后又根据原子哥的汉字显示例程，汉字显示的功能（是不用取模的哟，直接填汉字进显示字符串的函数即可，会通过SPI读取W25QXX芯片的汉字信息解析显示）
关于STM32F407启动后的系统时钟频率问题
12-26
关于STM32F407启动后的系统时钟频率问题
STM32F407-OLED四线IIC.zip
05-24
在"STM32F407-OLED四线IIC.zip"压缩包中，"OLED-F4"可能是一个源代码文件或库，包含了实现上述功能的C语言代码。开发者下载后，只需根据自己的需求修改显示的字符，就可以在OLED屏幕上显示出相应的信息。 为了正确...
STM32F407库函数的IIC.rar_STM32F407库函数的IIC_identityf3s_importance2oc_
07-15
STM32F407库函数的IIC是嵌入式开发中的一个重要组成部分，尤其对于使用STM32F407微控制器的项目而言。IIC（Inter-Integrated Circuit），也称为I²C，是一种多主设备通信协议，由Philips（现NXP）公司开发，用于在...
STM32F103C8T6模拟IIC控制4针0.96寸OLED显示屏
07-02
该程序经本人测试可以正常使用，也可先去搜索我的同名博客（STM32F103C8T6模拟IIC控制4针0.96寸OLED显示屏）先查看是否符合你的要求再进行下载，以免浪费下载积分，博客内容介绍有如何获取字模等步骤。
STM32新建工程以F407VET6为例
asty008的博客
09-20 3405
#include "stm32f4xx.h" // Device header int main(void) { while(1) { } } 添加main函数后进行编译,这时候会有很多警告..需要添加宏定义.... 加完后再编译就没有问题了. 附 : STM32F4xx_DSP_StdPeriph_Lib_V1.8.0.zip 链接：https://pan.baidu.com/s/1Z_bmGREjJIZ9T4fjBi...
stm32控制OLED显示实验（IIC、汉字显示）
qq_45941706的博客
05-26 7348
OLED显示
I2C总线之(一)---概述
hailin0716的专栏
05-27 1645
文章转载于http://www.cnblogs.com/BitArt/archive/2013/05/27/3101037.html，在此感谢博主。 概述：I²C 是Inter-Integrated Circuit的缩写，发音为"eye-squared cee" or "eye-two-cee" , 它是一种两线接口。I²C 只是用两条双向的线，一条 Serial Data Line (SD
hal stm32f407 oled iic 0.96
07-19
综上所述，"HAL STM32F407 OLED IIC 0.96"意味着使用STM32F407微控制器，通过HAL函数库驱动一个0.96英寸的OLED显示屏，使用IIC总线进行通信。这种硬件组合可以实现在STM32F407上驱动OLED屏幕显示各种信息，例如文本...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值