如何使用STM32F103的IIC信号线进行OLED显示

一、0.96OLED灯连线及其它准备

0.96OLED灯：
这里使用的是STM32F103的指南者板子
VCC：电源正极（接 5V 电源）
GND ：电源负极（接地）
SCL：IIC 时钟信号线，对应 OLED 的 D0 脚（接PB13）
SDA ：IIC 数据信号线，对应 OLED 的 D1 脚（接PB14）
取模工具：

可在链接: 资料.，然后在里面下载所需资料，在资料里有取模工具。
双击打开后，进行如下设置：





在第一步哪里输入需要的文字，点击生成字模，最后将其复制粘贴到代码部分，会在下面几步里说到。





二、OLED的显示

1、显示字符与温湿度

打开例程的工程后，在工程中的HAEDWARE的oledfont.h中进行修改。





修改位置如下图：
这里就可以将前面取得的字模复制粘贴过来了。





可以在oled.c中看到
这里就是显示汉字的程序





对于数字的显示，我们可以使用字符串的显示
可以看到，在main.c中，u8就是一个字符串数组，所以我们可以通过修改这个字符串数组的内容来输出自己想要输出的数字。





这是字符串显示的函数





温湿度显示
将AHT20初始化和IIC通信的源文件和头文件bsp_i2c移植到工程中。
可以看到，在bsp_i2c.c中添加了关于温湿度数据采集的算法程序





bsp_i2c.c代码如下：

#include "bsp_i2c.h"
#include "delay.h"
#include "oled.h"


uint8_t   ack_status=0;
uint8_t   readByte[6];
uint8_t   AHT20_status=0;


uint32_t  H1=0;  //Humility
uint32_t  T1=0;  //Temperature


uint8_t  AHT20_OutData[4];
uint8_t  AHT20sendOutData[10] = {0xFA, 0x06, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF};


void IIC_Init(void)
{                                             
        GPIO_InitTypeDef GPIO_InitStructure;
        RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );       
          
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //ÍÆÍìÊä³ö
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStructure);

        IIC_SCL=1;
        IIC_SDA=1;

}
//²úÉúIICÆðʼÐźÅ
void IIC_Start1(void)
{
        SDA_OUT();     //sdaÏßÊä³ö
        IIC_SDA=1;                    
        IIC_SCL=1;
        delay_us(4);
        IIC_SDA=0;//START:when CLK is high,DATA change form high to low
        delay_us(4);
        IIC_SCL=0;//ǯסI2C×ÜÏߣ¬×¼±¸·¢ËÍ»ò½ÓÊÕÊý¾Ý
}          
//²úÉúIICÍ£Ö¹ÐźÅ
void IIC_Stop1(void)
{
        SDA_OUT();//sdaÏßÊä³ö
        IIC_SCL=0;
        IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
        delay_us(4);
        IIC_SCL=1;
        IIC_SDA=1;//·¢ËÍI2C×ÜÏß½áÊøÐźÅ
        delay_us(4);                                                                  
}
//µÈ´ýÓ¦´ðÐźŵ½À´
//·µ»ØÖµ£º1£¬½ÓÊÕÓ¦´ðʧ°Ü
//        0£¬½ÓÊÕÓ¦´ð³É¹¦
u8 IIC_Wait_Ack1(void)
{
        u8 ucErrTime=0;
        SDA_IN();      //SDAÉèÖÃΪÊäÈë  
        IIC_SDA=1;delay_us(1);          
        IIC_SCL=1;delay_us(1);         
        while(READ_SDA)
        {
                ucErrTime++;
                if(ucErrTime>250)
                {
                        IIC_Stop();
                        return 1;
                }
        }
        IIC_SCL=0;//ʱÖÓÊä³ö0           
        return 0;  
}
//²úÉúACKÓ¦´ð
void IIC_Ack(void)
{
        IIC_SCL=0;
        SDA_OUT();
        IIC_SDA=0;
        delay_us(2);
        IIC_SCL=1;
        delay_us(2);
        IIC_SCL=0;
}
//²»²úÉúACKÓ¦´ð                    
void IIC_NAck(void)
{
        IIC_SCL=0;
        SDA_OUT();
        IIC_SDA=1;
        delay_us(2);
        IIC_SCL=1;
        delay_us(2);
        IIC_SCL=0;
}                                                                              
//IIC·¢ËÍÒ»¸ö×Ö½Ú
//·µ»Ø´Ó»úÓÐÎÞÓ¦´ð
//1£¬ÓÐÓ¦´ð
//0£¬ÎÞÓ¦´ð                          
void IIC_Send_Byte(u8 txd)
{                        
    u8 t;   
                SDA_OUT();             
    IIC_SCL=0;//À­µÍʱÖÓ¿ªÊ¼Êý¾Ý´«Êä
    for(t=0;t<8;t++)
    {              
        IIC_SDA=(txd&0x80)>>7;
        txd<<=1;           
                delay_us(2);   //¶ÔTEA5767ÕâÈý¸öÑÓʱ¶¼ÊDZØÐëµÄ
                IIC_SCL=1;
                delay_us(2);
                IIC_SCL=0;       
                delay_us(2);
    }         
}             
//¶Á1¸ö×Ö½Ú£¬ack=1ʱ£¬·¢ËÍACK£¬ack=0£¬·¢ËÍnACK   
u8 IIC_Read_Byte(unsigned char ack)
{
        unsigned char i,receive=0;
        SDA_IN();//SDAÉèÖÃΪÊäÈë
  for(i=0;i<8;i++ )
        {
    IIC_SCL=0;
    delay_us(2);
                IIC_SCL=1;
    receive<<=1;
    if(READ_SDA)receive++;   
                delay_us(1);
  }                                         
        if (!ack)
                        IIC_NAck();//·¢ËÍnACK
        else
                        IIC_Ack(); //·¢ËÍACK   
        return receive;
}

void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr)
{
        IIC_Start();  
       
        if(device_addr==0xA0) //eepromµØÖ·´óÓÚ1×Ö½Ú
                IIC_Send_Byte(0xA0 + ((addr/256)<<1));//·¢Ë͸ߵØÖ·
        else
                IIC_Send_Byte(device_addr);            //·¢Æ÷¼þµØÖ·
        IIC_Wait_Ack();
        IIC_Send_Byte(addr&0xFF);   //·¢Ë͵͵ØÖ·
        IIC_Wait_Ack();
        IIC_Send_Byte(data);     //·¢ËÍ×Ö½Ú                                                          
        IIC_Wait_Ack();                                
  IIC_Stop();//²úÉúÒ»¸öÍ£Ö¹Ìõ¼þ
        if(device_addr==0xA0) //
                delay_ms(10);
        else
                delay_us(2);
}

uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead)  //¶Á¼Ä´æÆ÷»ò¶ÁÊý¾Ý
{       
                uint16_t data;
                IIC_Start();  
                if(device_addr==0xA0)
                        IIC_Send_Byte(0xA0 + ((addr/256)<<1));
                else
                        IIC_Send_Byte(device_addr);       
                IIC_Wait_Ack();
                IIC_Send_Byte(addr&0xFF);   //·¢Ë͵͵ØÖ·
                IIC_Wait_Ack();

                IIC_Start();         
                IIC_Send_Byte(device_addr+1);            //·¢Æ÷¼þµØÖ·
                IIC_Wait_Ack();
                if(ByteNumToRead == 1)//LM75ζÈÊý¾ÝΪ11bit
                {
                        data=IIC_Read_Byte(0);
                }
                else
                        {
                                data=IIC_Read_Byte(1);
                                data=(data<<8)+IIC_Read_Byte(0);
                        }
                IIC_Stop();//²úÉúÒ»¸öÍ£Ö¹Ìõ¼þ            
                return data;
}




/**********
*ÉÏÃ沿·ÖΪIO¿ÚÄ£¿éI2CÅäÖÃ
*
*´ÓÕâÒÔÏ¿ªÊ¼ÎªAHT20µÄÅäÖÃI2C
*º¯ÊýÃûÓÐIICºÍI2CµÄÇø±ð£¬Çë×¢Ò⣡£¡£¡£¡£¡
*
*2020/2/23×îºóÐÞ¸ÄÈÕÆÚ
*
***********/
void  read_AHT20_once(void)
{
        delay_ms(10);


        reset_AHT20();
        delay_ms(10);


        init_AHT20();
        delay_ms(10);


        startMeasure_AHT20();
        delay_ms(80);


        read_AHT20();
        delay_ms(5);
}




void  reset_AHT20(void)
{


        I2C_Start();


        I2C_WriteByte(0x70);
        ack_status = Receive_ACK();
        if(ack_status) ;
        else printf("1-n-");
        I2C_WriteByte(0xBA);
        ack_status = Receive_ACK();
                if(ack_status) ;
        else printf("2-n-");
        I2C_Stop();


        /*
        AHT20_OutData[0] = 0;
        AHT20_OutData[1] = 0;
        AHT20_OutData[2] = 0;
        AHT20_OutData[3] = 0;
        */
}






void  init_AHT20(void)
{
        I2C_Start();


        I2C_WriteByte(0x70);
        ack_status = Receive_ACK();
        if(ack_status) ;
        else printf("3-n-");       
        I2C_WriteByte(0xE1);
        ack_status = Receive_ACK();
        if(ack_status) ;
        else printf("4-n-");
        I2C_WriteByte(0x08);
        ack_status = Receive_ACK();
        if(ack_status) ;
        else printf("5-n-");
        I2C_WriteByte(0x00);
        ack_status = Receive_ACK();
        if(ack_status) ;
        else printf("6-n-");
        I2C_Stop();
}






void  startMeasure_AHT20(void)
{
        //------------
        I2C_Start();


        I2C_WriteByte(0x70);
        ack_status = Receive_ACK();
        if(ack_status);
        else printf("7-n-");
        I2C_WriteByte(0xAC);
        ack_status = Receive_ACK();
        if(ack_status) ;
        else printf("8-n-");
        I2C_WriteByte(0x33);
        ack_status = Receive_ACK();
        if(ack_status);
        else printf("9-n-");
        I2C_WriteByte(0x00);
        ack_status = Receive_ACK();
        if(ack_status) ;
        else printf("10-n-");
        I2C_Stop();
}






void read_AHT20(void)
{
        uint8_t   i;


        for(i=0; i<6; i++)
        {
                readByte=0;
        }


        //-------------
        I2C_Start();


        I2C_WriteByte(0x71);
        ack_status = Receive_ACK();
        readByte[0]= I2C_ReadByte();
        Send_ACK();


        readByte[1]= I2C_ReadByte();
        Send_ACK();


        readByte[2]= I2C_ReadByte();
        Send_ACK();


        readByte[3]= I2C_ReadByte();
        Send_ACK();


        readByte[4]= I2C_ReadByte();
        Send_ACK();


        readByte[5]= I2C_ReadByte();
        SendNot_Ack();
        //Send_ACK();


        I2C_Stop();


        //--------------
        if( (readByte[0] & 0x68) == 0x08 )
        {
                H1 = readByte[1];
                H1 = (H1<<8) | readByte[2];
                H1 = (H1<<8) | readByte[3];
                H1 = H1>>4;


                H1 = (H1*1000)/1024/1024;


                T1 = readByte[3];
                T1 = T1 & 0x0000000F;
                T1 = (T1<<8) | readByte[4];
                T1 = (T1<<8) | readByte[5];


                T1 = (T1*2000)/1024/1024 - 500;


                AHT20_OutData[0] = (H1>>8) & 0x000000FF;
                AHT20_OutData[1] = H1 & 0x000000FF;


                AHT20_OutData[2] = (T1>>8) & 0x000000FF;
                AHT20_OutData[3] = T1 & 0x000000FF;
        }
        else
        {
                AHT20_OutData[0] = 0xFF;
                AHT20_OutData[1] = 0xFF;


                AHT20_OutData[2] = 0xFF;
                AHT20_OutData[3] = 0xFF;
                printf("ʧ°ÜÁË");


        }
       
        OLED_ShowCHinese(0,4,3);
        OLED_ShowCHinese(20,4,4);
        OLED_ShowNum(40,4,T1/10,2,16);
       
        OLED_ShowCHinese(0,6,5);
        OLED_ShowCHinese(20,6,6);
        OLED_ShowNum(40,6,H1/10,2,16);
       
}








uint8_t  Receive_ACK(void)
{
        uint8_t result=0;
        uint8_t cnt=0;


        IIC_SCL = 0;
        SDA_IN();
        delay_us(4);


        IIC_SCL = 1;
        delay_us(4);


        while(READ_SDA && (cnt<100))
        {
                cnt++;
        }


        IIC_SCL = 0;
        delay_us(4);


        if(cnt<100)
        {
                result=1;
        }
        return result;
}






void  Send_ACK(void)
{
        SDA_OUT();
        IIC_SCL = 0;
        delay_us(4);


        IIC_SDA = 0;
        delay_us(4);


        IIC_SCL = 1;
        delay_us(4);
        IIC_SCL = 0;
        delay_us(4);


        SDA_IN();
}






void  SendNot_Ack(void)
{
        SDA_OUT();
        IIC_SCL = 0;
        delay_us(4);


        IIC_SDA = 1;
        delay_us(4);


        IIC_SCL = 1;
        delay_us(4);


        IIC_SCL = 0;
        delay_us(4);


        IIC_SDA = 0;
        delay_us(4);
}




void I2C_WriteByte(uint8_t  input)
{
        uint8_t  i;
        SDA_OUT();
        for(i=0; i<8; i++)
        {
                IIC_SCL = 0;
                delay_ms(5);


                if(input & 0x80)
                {
                        IIC_SDA = 1;
                        //delaymm(10);
                }
                else
                {
                        IIC_SDA = 0;
                        //delaymm(10);
                }


                IIC_SCL = 1;
                delay_ms(5);


                input = (input<<1);
        }


        IIC_SCL = 0;
        delay_us(4);


        SDA_IN();
        delay_us(4);
}       




uint8_t I2C_ReadByte(void)
{
        uint8_t  resultByte=0;
        uint8_t  i=0, a=0;


        IIC_SCL = 0;
        SDA_IN();
        delay_ms(4);


        for(i=0; i<8; i++)
        {
                IIC_SCL = 1;
                delay_ms(3);


                a=0;
                if(READ_SDA)
                {
                        a=1;
                }
                else
                {
                        a=0;
                }


                //resultByte = resultByte | a;
                resultByte = (resultByte << 1) | a;


                IIC_SCL = 0;
                delay_ms(3);
        }


        SDA_IN();
        delay_ms(10);


        return   resultByte;
}




void  set_AHT20sendOutData(void)
{
        /* --------------------------
         * 0xFA 0x06 0x0A temperature(2 Bytes) humility(2Bytes) short Address(2 Bytes)
         * And Check (1 byte)
         * -------------------------*/
        AHT20sendOutData[3] = AHT20_OutData[0];
        AHT20sendOutData[4] = AHT20_OutData[1];
        AHT20sendOutData[5] = AHT20_OutData[2];
        AHT20sendOutData[6] = AHT20_OutData[3];


//        AHT20sendOutData[7] = (drf1609.shortAddress >> 8) & 0x00FF;
//        AHT20sendOutData[8] = drf1609.shortAddress  & 0x00FF;


//        AHT20sendOutData[9] = getXY(AHT20sendOutData,10);
}




void  I2C_Start(void)
{
        SDA_OUT();
        IIC_SCL = 1;
        delay_ms(4);


        IIC_SDA = 1;
        delay_ms(4);
        IIC_SDA = 0;
        delay_ms(4);


        IIC_SCL = 0;
        delay_ms(4);
}






void  I2C_Stop(void)
{
        SDA_OUT();
        IIC_SDA = 0;
        delay_ms(4);


        IIC_SCL = 1;
        delay_ms(4);


        IIC_SDA = 1;
        delay_ms(4);
}
在main.c中添加调用的程序




2、滚动显示

这里用的是硬件刷新的模式，通过给oled发送SSD1306的驱动显示命令，控制屏幕进行平滑滚动显示。更多的驱动命令可以在驱动手册里去看。
主函数main.c 代码如下：

#include "delay.h"
#include "sys.h"
#include "oled.h"
#include "bmp.h"
#include "delay.h"
#include "usart.h"
#include "bsp_i2c.h"
int main(void)
  {
                u8 a[]={'6','3','1','8','0','7','0','3','0','6','0','5',''};
                delay_init();                     //延时函数初始化           
                NVIC_Configuration();          //设置NVIC中断分组2：2位抢占优先级，2位响应优先级       
                OLED_Init();                        //初始化OLED  
                OLED_Clear(0)          ;
                uart_init(115200);         //串口初始化为115200
          IIC_Init();
               
               
               
    OLED_WR_Byte(0x2e,OLED_CMD);//关闭滚动
    OLED_WR_Byte(0x2a,OLED_CMD);//选择滚动的方式
    OLED_WR_Byte(0x00,OLED_CMD);//A:空字节
    OLED_WR_Byte(0x00,OLED_CMD);//B:滚动起始页
    OLED_WR_Byte(0x00,OLED_CMD);//C:水平滚动速度
    OLED_WR_Byte(0x01,OLED_CMD);//D:滚动结束页
    OLED_WR_Byte(0x03,OLED_CMD);//E:每次垂直滚动的位移
               
                OLED_ShowCHinese(0,0,0);//
                OLED_ShowCHinese(20,0,1);//
                OLED_ShowCHinese(40,0,2);//
               
          OLED_WR_Byte(0x2f,OLED_CMD);//开始滚动
                delay_ms(1000);delay_ms(1000);delay_ms(1000);delay_ms(1000);delay_ms(1000);


                OLED_Clear(0);  //清屏
                OLED_WR_Byte(0x2e,OLED_CMD);//关闭滚动
        while(1)
        {
                read_AHT20_once();   
                OLED_ShowCHinese(0,0,0);//
                OLED_ShowCHinese(20,0,1);//
                OLED_ShowCHinese(40,0,2);//
                OLED_ShowString(0,2,a,16);
                delay_ms(1000);
        }                 
}


编译无错之后，将其烧进板子运行。