SPI模式OLED显示代码，包括oled.c和oled.h和main.c

很抱歉，由于篇幅限制，无法在此回答您的问题。不过，您可以在以下几个网站上找到相关的代码和教程：

1. GitHub: https://github.com/adafruit/Adafruit_SSD1306
2. 官方网站: https://www.adafruit.com/product/931
3. 知乎: https://zhuanlan.zhihu.com/p/34863588

希望能对您有所帮助。

相关问题

STM32F407库函数SPI模式OLED的oled.c函数 oled.h函数 main.c函数

以下是使用STM32F407库函数SPI模式控制OLED的示例代码：

oled.h:

#ifndef __OLED_H
#define __OLED_H

#include "stm32f4xx.h"

#define OLED_CMD  0 //写命令
#define OLED_DATA 1 //写数据

#define OLED_CS_SET()    GPIO_SetBits(GPIOB,GPIO_Pin_12)//片选信号置高
#define OLED_CS_CLR()    GPIO_ResetBits(GPIOB,GPIO_Pin_12)//片选信号置低

#define OLED_DC_SET()    GPIO_SetBits(GPIOB,GPIO_Pin_13)//数据/命令选择信号置高
#define OLED_DC_CLR()    GPIO_ResetBits(GPIOB,GPIO_Pin_13)//数据/命令选择信号置低

#define OLED_RST_SET()   GPIO_SetBits(GPIOB,GPIO_Pin_14)//复位信号置高
#define OLED_RST_CLR()   GPIO_ResetBits(GPIOB,GPIO_Pin_14)//复位信号置低

void OLED_Init(void);
void OLED_Clear(void);
void OLED_DrawPoint(uint8_t x,uint8_t y,uint8_t t);
void OLED_ShowChar(uint8_t x,uint8_t y,uint8_t chr,uint8_t size,uint8_t mode);
void OLED_ShowNum(uint8_t x,uint8_t y,uint32_t num,uint8_t len,uint8_t size);
void OLED_ShowString(uint8_t x,uint8_t y,uint8_t *p,uint8_t size);
void OLED_Set_Pos(uint8_t x,uint8_t y);
void OLED_WR_Byte(uint8_t dat,uint8_t cmd);
void OLED_ShowCHinese(uint8_t x,uint8_t y,uint8_t no,uint8_t size);
void OLED_DrawBMP(uint8_t x0,uint8_t y0,uint8_t x1,uint8_t y1,uint8_t BMP[]);
void OLED_ShowPicture(uint8_t x0,uint8_t y0,uint8_t x1,uint8_t y1,uint8_t *ptr);

#endif

oled.c:

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

//OLED缓存区
uint8_t OLED_GRAM[128][8];

//向OLED写入一个字节
void OLED_WR_Byte(uint8_t dat,uint8_t cmd)
{
    uint8_t i;

    if(cmd) OLED_DC_SET();
    else    OLED_DC_CLR();

    OLED_CS_CLR();

    for(i=0;i<8;i++)
    {       
        if(dat&0x80) GPIO_SetBits(GPIOB,GPIO_Pin_15);
        else         GPIO_ResetBits(GPIOB,GPIO_Pin_15);

        GPIO_SetBits(GPIOB,GPIO_Pin_10);//时钟信号置高
        dat<<=1;   //准备写入下一位
        GPIO_ResetBits(GPIOB,GPIO_Pin_10);//时钟信号置低    
    }

    OLED_CS_SET();
    OLED_DC_SET();
}

//OLED初始化
void OLED_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟

    //PB12~14输出模式配置
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//输出模式
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽型输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//速度100MHz
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB

    //PB15输出模式配置
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//输出模式
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽型输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//速度100MHz
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB

    OLED_RST_SET();//复位信号置高
    delay_ms(100);
    OLED_RST_CLR();//复位信号置低
    delay_ms(100);
    OLED_RST_SET();//复位信号置高

    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);//--turn on oled panel

    OLED_Clear();//清屏
}

//OLED清屏函数
void OLED_Clear(void)
{
    uint8_t i,n;

    for(i=0;i<8;i++)
    {
        OLED_WR_Byte(0xb0+i,OLED_CMD); //设置页地址（0~7）
        OLED_WR_Byte(0x00,OLED_CMD);   //设置显示位置—列低地址
        OLED_WR_Byte(0x10,OLED_CMD);   //设置显示位置—列高地址   
        for(n=0;n<128;n++)OLED_WR_Byte(0,OLED_DATA); 
    }
}

//OLED画点函数
void OLED_DrawPoint(uint8_t x,uint8_t y,uint8_t t)
{
    uint8_t pos,bx,tmp=0;

    if(x>127||y>63)return;//超出范围了.
    pos=7-y/8;
    bx=y%8;
    tmp=1<<(7-bx);
    if(t)OLED_GRAM[x][pos]|=tmp;
    else OLED_GRAM[x][pos]&=~tmp; 

    OLED_Set_Pos(x,y);
    OLED_WR_Byte(OLED_GRAM[x][pos],OLED_DATA);      
}

//OLED显示字符函数
void OLED_ShowChar(uint8_t x,uint8_t y,uint8_t chr,uint8_t size,uint8_t mode)
{
    uint8_t temp,t,t1;
    uint8_t y0=y;
    uint8_t csize=(size/8+((size%8)?1:0))*(size/2);
    chr=chr-' ';//得到偏移后的值
    for(t=0;t<csize;t++)
    {   
        if(size==12)temp=asc2_1206[chr][t];  //调用1206字体
        else temp=asc2_1608[chr][t];         //调用1608字体
        for(t1=0;t1<8;t1++)
        {
            if(temp&0x80)OLED_DrawPoint(x,y,mode);
            else OLED_DrawPoint(x,y,!mode);
            temp<<=1;
            y++;
            if(y>=64)
            {
                y=0;
                x++;
            }
            if(x>=128)return;//超出范围了
        }
    }
}

//OLED显示数字函数
void OLED_ShowNum(uint8_t x,uint8_t y,uint32_t num,uint8_t len,uint8_t size)
{
    uint8_t t,temp;
    uint8_t enshow=0;
    for(t=0;t<len;t++)
    {
        temp=(num/10^(len-t-1))%10;
        if(enshow==0&&t<(len-1))
        {
            if(temp==0)
            {
                OLED_ShowChar(x+(size/2)*t,y,' ',size,1);
                continue;
            }else enshow=1; 
        }
        OLED_ShowChar(x+(size/2)*t,y,temp+'0',size,1); 
    }
}

//OLED显示字符串函数
void OLED_ShowString(uint8_t x,uint8_t y,uint8_t *p,uint8_t size)
{
    while((*p<='~')&&(*p>=' '))//判断是不是非法字符!
    {
        if(x>120){x=0;y+=size;}
        if(y>56){y=x=0;OLED_Clear();}
        OLED_ShowChar(x,y,*p,size,1);
        x+=size/2;
        p++;
    }
}

//OLED设置位置函数
void OLED_Set_Pos(uint8_t x,uint8_t 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); 
}

//OLED显示汉字函数
void OLED_ShowCHinese(uint8_t x,uint8_t y,uint8_t no,uint8_t size)
{
    uint8_t t,adder=0;
    OLED_Set_Pos(x,y);
    for(t=0;t<size;t++)
    {
        OLED_WR_Byte(Hzk[2*no][t],OLED_DATA);
    }
    OLED_Set_Pos(x,y+1);
    for(t=0;t<size;t++)
    {
        OLED_WR_Byte(Hzk[2*no+1][t],OLED_DATA);
    }
}

//OLED显示BMP图片函数
void OLED_DrawBMP(uint8_t x0,uint8_t y0,uint8_t x1,uint8_t y1,uint8_t BMP[])
{
    uint32_t j=0;
    uint8_t x,y;

    if(y1%8==0) y=y1/8;      
    else y=y1/8+1;
    for(y=y0;y<y1;y++)
    {
        OLED_Set_Pos(x0,y);
        for(x=x0;x<x1;x++)
        {      
            OLED_WR_Byte(BMP[j++],OLED_DATA);      
        }
    }
}

//OLED显示图片函数
void OLED_ShowPicture(uint8_t x0,uint8_t y0,uint8_t x1,uint8_t y1,uint8_t *ptr)
{
    uint32_t j=0;
    uint8_t x,y;
    if(y1%8==0) y=y1/8;      
    else y=y1/8+1;
    for(y=y0;y<y1;y++)
    {
        OLED_Set_Pos(x0,y);
        for(x=x0;x<x1;x++)
        {      
            OLED_WR_Byte(*(ptr+j++),OLED_DATA);      
        }
    }
}

main.c:

#include "oled.h"

int main(void)
{
    OLED_Init();    //OLED初始化

    OLED_ShowString(0,0,"Hello World!",12);  //OLED显示字符串

    while(1);
}

oled显示屏spi协议驱动代码

以下是一份基于SPI协议驱动OLED显示屏的示例代码，供参考：

#include <reg51.h>

// 定义OLED的引脚
sbit OLED_RST = P1^0;
sbit OLED_DC = P1^1;
sbit OLED_CS = P1^4;
sbit OLED_SCL = P1^6;
sbit OLED_SDA = P1^7;

// 定义SPI通信命令
#define CMD_SET_COL_ADDR 0x15
#define CMD_SET_PAGE_ADDR 0x75
#define CMD_WRITE_RAM 0x5C

// 定义屏幕分辨率
#define OLED_WIDTH 128
#define OLED_HEIGHT 64

// 定义字体
const unsigned char F6x8[][6] = {
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ' '
    {0x00, 0x00, 0x00, 0x2f, 0x00, 0x00}, // '!'
    {0x00, 0x00, 0x07, 0x00, 0x07, 0x00}, // '"'
    // ...
};

// 定义函数
void spi_write_byte(unsigned char dat);
void spi_write_cmd(unsigned char cmd);
void spi_write_data(unsigned char dat);
void oled_init();
void oled_set_pos(unsigned char x, unsigned char y);
void oled_clear();
void oled_show_string(unsigned char x, unsigned char y, const char *str);

// 主函数
void main() {
    // 初始化OLED显示屏
    oled_init();

    // 在屏幕上显示字符串
    oled_show_string(0, 0, "Hello, world!");
}

// SPI写入一个字节
void spi_write_byte(unsigned char dat) {
    unsigned char i;
    for (i = 0; i < 8; i++) {
        OLED_SDA = (dat & 0x80) >> 7;
        dat <<= 1;
        OLED_SCL = 1;
        OLED_SCL = 0;
    }
}

// SPI写入一个命令
void spi_write_cmd(unsigned char cmd) {
    OLED_DC = 0;
    OLED_CS = 0;
    spi_write_byte(cmd);
    OLED_CS = 1;
}

// SPI写入一个数据
void spi_write_data(unsigned char dat) {
    OLED_DC = 1;
    OLED_CS = 0;
    spi_write_byte(dat);
    OLED_CS = 1;
}

// 初始化OLED显示屏
void oled_init() {
    OLED_RST = 0;
    delay(200);
    OLED_RST = 1;

    spi_write_cmd(0xAE); // 关闭显示
    spi_write_cmd(0xD5); // 设置时钟分频因子
    spi_write_cmd(0x80); // 时钟分频因子，越小越快
    spi_write_cmd(0xA8); // 设置驱动路数
    spi_write_cmd(0x3F); // 默认值(1/64)
    spi_write_cmd(0xD3); // 设置显示偏移
    spi_write_cmd(0x00); // 默认值
    spi_write_cmd(0x40); // 设置显示起始行
    spi_write_cmd(0x8D); // 电荷泵设置
    spi_write_cmd(0x14); // bit2，开启/关闭
    spi_write_cmd(0x20); // 设置内存地址模式
    spi_write_cmd(0x02); // 按列地址，从左到右，从上到下
    spi_write_cmd(0xA1); // 设置列映射
    spi_write_cmd(0xC8); // 设置行映射
    spi_write_cmd(0xDA); // 设置COM硬件引脚配置
    spi_write_cmd(0x12); // 默认值
    spi_write_cmd(0x81); // 对比度设置
    spi_write_cmd(0xCF); // 默认值
    spi_write_cmd(0xD9); // 设置预充电周期
    spi_write_cmd(0xF1); // 默认值
    spi_write_cmd(0xDB); // 设置VCOMH电压倍率
    spi_write_cmd(0x40); // 默认值
    spi_write_cmd(0xA4); // 全局显示开启
    spi_write_cmd(0xA6); // 设置显示方式，白色显示
    spi_write_cmd(0xAF); // 开启显示
    oled_clear(); // 清屏
}

// 设置显示位置
void oled_set_pos(unsigned char x, unsigned char y) {
    spi_write_cmd(CMD_SET_COL_ADDR);
    spi_write_cmd(x);
    spi_write_cmd(OLED_WIDTH - 1);
    spi_write_cmd(CMD_SET_PAGE_ADDR);
    spi_write_cmd(y / 8);
    spi_write_cmd(OLED_HEIGHT / 8 - 1);
}

// 清屏
void oled_clear() {
    unsigned char i, j;
    for (i = 0; i < 8; i++) {
        oled_set_pos(0, i);
        for (j = 0; j < OLED_WIDTH; j++) {
            spi_write_data(0x00);
        }
    }
}

// 在指定位置显示字符串
void oled_show_string(unsigned char x, unsigned char y, const char *str) {
    unsigned char i = 0;
    while (str[i] != '\0') {
        oled_show_char(x + i * 6, y, str[i]);
        i++;
    }
}

// 在指定位置显示一个字符
void oled_show_char(unsigned char x, unsigned char y, unsigned char ch) {
    unsigned char i, j;
    for (i = 0; i < 6; i++) {
        unsigned char byte = F6x8[ch - ' '][i];
        for (j = 0; j < 8; j++) {
            if (byte & 0x01) {
                spi_write_data(0xff << (j % 8));
            } else {
                spi_write_data(0x00);
            }
            byte >>= 1;
        }
        oled_set_pos(x + i, y);
    }
}

在上述代码中，我们使用了51单片机的SPI接口来驱动OLED显示屏。在初始化函数中，我们通过向OLED发送一系列的命令来配置OLED的参数，以及打开显示。在显示函数中，我们通过内置的字体表来逐个显示字符，并使用`spi_write_data()`函数向OLED发送相应的数据。需要注意的是，OLED的显示是按页来进行的，每页8个像素。因此，在设置显示位置时，需要将纵坐标除以8。