精华内容
下载资源
问答
  • 随着AMOLED显示器价格的快速下降,OLED显示器线定址的优势看来似乎维持不了多久,但即使是AMOLED也能从多线定址对於降低频率与功耗的要求受益。多线定址的更大优势可能来自於驱动数据到显示器时能够更大幅节省...
  • Arduino 驱动OLED屏幕IIC接线方式简单入门

    万次阅读 多人点赞 2016-11-04 18:38:23
    OLED一款小巧的显示屏,感觉可以做出很可爱的东西。 这次实验的这款是128X64的OLED屏幕 , 芯片是SSD1306,请确认自家模块芯片型号,不然对不上号啊 使用IIC的方法,简单实验显示示例程序。 (请确认你手头上的...

     

     

     

    OLED一款小巧的显示屏,感觉可以做出很可爱的东西。

    这次实验的这款是128X64的OLED屏幕 ,

    芯片是SSD1306,请确认自家模块芯片型号,不然对不上号啊

    使用IIC的方法,简单实验显示示例程序。

     

    (请确认你手头上的模块可以IIC连接,若干不支持那只能SPI方式接线)

    先实现连接与显示,之后再进行更深入的应用。

     

    任意门:

    Arduino Uno 驱动OLED进阶 显示中英文字

    Arduino Uno 驱动OLED进阶 显示图片

    Arduino Uno 驱动OLED进阶 显示几何动画

     

    编译的过程,可能会遇到以下问题:

    ①提示错误

     

    #error("Height incorrect, please fix Adafruit_SSD1306.h!");  

    错误信息意思是指:

    高度不正确,请修正Adafruit_SSD1306.h!

     

    进入Arduino安装文件夹的libraries文件夹的Adfruit_SSD1306-master 找到Adafruit_SSD1306.h

     

    打开此文件,找到第70行左右

     

    默认是定义 SSD1306_128_32 ,由于我们使用的是128*64的OLED,所以,把原来的#define SSD1306_128_32,前面加上//

    把#define SSD_128_64 前面的//去掉  

    最后就如上面图例一样

     

    ②模块的IIC 地址问题

    模块的地址修改在这个位置,示例程序的61行

     

    这个模块地址我用的是这个,但每个模块可能不一样,具体请咨询购买的商家,又或者可以参考下面链接的,IIC搜索地址程序。

    任意门:Arduino 和LCD1602液晶屏 I2C接口实验

     

     

    实验效果

     

     

    BOM表

    Arduino Uno             *1

    OLED 128*64           *1

    跳线若干


    针脚说明

    VCC   接3.3v电源

    GND  接地(GND)

    SCL   时钟线

    SDA   数据线

     

    接线图

     

     

     

    程序开源代码

    在上代码之前,先下载两个库分别是

    Adafruit SSD1306 Library:

    https://github.com/adafruit/Adafruit_SSD1306

    or

    http://download.csdn.net/detail/ling3ye/9729179

    or(以下是新增外链下载地址,如果上述地址都无法使用可以使用以下地址)

    https://u16460183.ctfile.com/fs/16460183-288560545

     

    Adafruit GFX Library:

    https://github.com/adafruit/Adafruit-GFX-Library

    or

    http://download.csdn.net/detail/ling3ye/9729180

    or(以下是新增外链下载地址,如果上述地址都无法使用可以使用以下地址)

    https://u16460183.ctfile.com/fs/16460183-288561300

     

    *_________*

    下载后把解压的文件放在 Arduino 安装目录里的 "libraries"

    例如:C:\Program Files (x86)\Arduino\libraries

     

    调出示例程序

     

    或者复制以下代码,都是一样的:

     

    /*********************************************************************
    This is an example for our Monochrome OLEDs based on SSD1306 drivers
    
      Pick one up today in the adafruit shop!
      ------> http://www.adafruit.com/category/63_98
    
    This example is for a 128x64 size display using I2C to communicate
    3 pins are required to interface (2 I2C and one reset)
    
    Adafruit invests time and resources providing this open source code, 
    please support Adafruit and open-source hardware by purchasing 
    products from Adafruit!
    
    Written by Limor Fried/Ladyada  for Adafruit Industries.  
    BSD license, check license.txt for more information
    All text above, and the splash screen must be included in any redistribution
    *********************************************************************/
    
    #include <SPI.h>
    #include <Wire.h>
    #include <Adafruit_GFX.h>
    #include <Adafruit_SSD1306.h>
    
    #define OLED_RESET 4
    Adafruit_SSD1306 display(OLED_RESET);
    
    #define NUMFLAKES 10
    #define XPOS 0
    #define YPOS 1
    #define DELTAY 2
    
    
    #define LOGO16_GLCD_HEIGHT 16 
    #define LOGO16_GLCD_WIDTH  16 
    static const unsigned char PROGMEM logo16_glcd_bmp[] =
    { B00000000, B11000000,
      B00000001, B11000000,
      B00000001, B11000000,
      B00000011, B11100000,
      B11110011, B11100000,
      B11111110, B11111000,
      B01111110, B11111111,
      B00110011, B10011111,
      B00011111, B11111100,
      B00001101, B01110000,
      B00011011, B10100000,
      B00111111, B11100000,
      B00111111, B11110000,
      B01111100, B11110000,
      B01110000, B01110000,
      B00000000, B00110000 };
    
    #if (SSD1306_LCDHEIGHT != 64)
    #error("Height incorrect, please fix Adafruit_SSD1306.h!");
    #endif
    
    void setup()   {                
      Serial.begin(9600);
    
      // by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
      display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3D (for the 128x64)
      // init done
      
      // Show image buffer on the display hardware.
      // Since the buffer is intialized with an Adafruit splashscreen
      // internally, this will display the splashscreen.
      display.display();
      delay(2000);
    
      // Clear the buffer.
      display.clearDisplay();
    
      // draw a single pixel
      display.drawPixel(10, 10, WHITE);
      // Show the display buffer on the hardware.
      // NOTE: You _must_ call display after making any drawing commands
      // to make them visible on the display hardware!
      display.display();
      delay(2000);
      display.clearDisplay();
    
      // draw many lines
      testdrawline();
      display.display();
      delay(2000);
      display.clearDisplay();
    
      // draw rectangles
      testdrawrect();
      display.display();
      delay(2000);
      display.clearDisplay();
    
      // draw multiple rectangles
      testfillrect();
      display.display();
      delay(2000);
      display.clearDisplay();
    
      // draw mulitple circles
      testdrawcircle();
      display.display();
      delay(2000);
      display.clearDisplay();
    
      // draw a white circle, 10 pixel radius
      display.fillCircle(display.width()/2, display.height()/2, 10, WHITE);
      display.display();
      delay(2000);
      display.clearDisplay();
    
      testdrawroundrect();
      delay(2000);
      display.clearDisplay();
    
      testfillroundrect();
      delay(2000);
      display.clearDisplay();
    
      testdrawtriangle();
      delay(2000);
      display.clearDisplay();
       
      testfilltriangle();
      delay(2000);
      display.clearDisplay();
    
      // draw the first ~12 characters in the font
      testdrawchar();
      display.display();
      delay(2000);
      display.clearDisplay();
    
      // draw scrolling text
      testscrolltext();
      delay(2000);
      display.clearDisplay();
    
      // text display tests
      display.setTextSize(1);
      display.setTextColor(WHITE);
      display.setCursor(0,0);
      display.println("Hello, world!");
      display.setTextColor(BLACK, WHITE); // 'inverted' text
      display.println(3.141592);
      display.setTextSize(2);
      display.setTextColor(WHITE);
      display.print("0x"); display.println(0xDEADBEEF, HEX);
      display.display();
      delay(2000);
      display.clearDisplay();
    
      // miniature bitmap display
      display.drawBitmap(30, 16,  logo16_glcd_bmp, 16, 16, 1);
      display.display();
      delay(1);
    
      // invert the display
      display.invertDisplay(true);
      delay(1000); 
      display.invertDisplay(false);
      delay(1000); 
      display.clearDisplay();
    
      // draw a bitmap icon and 'animate' movement
      testdrawbitmap(logo16_glcd_bmp, LOGO16_GLCD_HEIGHT, LOGO16_GLCD_WIDTH);
    }
    
    
    void loop() {
      
    }
    
    
    void testdrawbitmap(const uint8_t *bitmap, uint8_t w, uint8_t h) {
      uint8_t icons[NUMFLAKES][3];
     
      // initialize
      for (uint8_t f=0; f< NUMFLAKES; f++) {
        icons[f][XPOS] = random(display.width());
        icons[f][YPOS] = 0;
        icons[f][DELTAY] = random(5) + 1;
        
        Serial.print("x: ");
        Serial.print(icons[f][XPOS], DEC);
        Serial.print(" y: ");
        Serial.print(icons[f][YPOS], DEC);
        Serial.print(" dy: ");
        Serial.println(icons[f][DELTAY], DEC);
      }
    
      while (1) {
        // draw each icon
        for (uint8_t f=0; f< NUMFLAKES; f++) {
          display.drawBitmap(icons[f][XPOS], icons[f][YPOS], bitmap, w, h, WHITE);
        }
        display.display();
        delay(200);
        
        // then erase it + move it
        for (uint8_t f=0; f< NUMFLAKES; f++) {
          display.drawBitmap(icons[f][XPOS], icons[f][YPOS], bitmap, w, h, BLACK);
          // move it
          icons[f][YPOS] += icons[f][DELTAY];
          // if its gone, reinit
          if (icons[f][YPOS] > display.height()) {
            icons[f][XPOS] = random(display.width());
            icons[f][YPOS] = 0;
            icons[f][DELTAY] = random(5) + 1;
          }
        }
       }
    }
    
    
    void testdrawchar(void) {
      display.setTextSize(1);
      display.setTextColor(WHITE);
      display.setCursor(0,0);
    
      for (uint8_t i=0; i < 168; i++) {
        if (i == '\n') continue;
        display.write(i);
        if ((i > 0) && (i % 21 == 0))
          display.println();
      }    
      display.display();
      delay(1);
    }
    
    void testdrawcircle(void) {
      for (int16_t i=0; i<display.height(); i+=2) {
        display.drawCircle(display.width()/2, display.height()/2, i, WHITE);
        display.display();
        delay(1);
      }
    }
    
    void testfillrect(void) {
      uint8_t color = 1;
      for (int16_t i=0; i<display.height()/2; i+=3) {
        // alternate colors
        display.fillRect(i, i, display.width()-i*2, display.height()-i*2, color%2);
        display.display();
        delay(1);
        color++;
      }
    }
    
    void testdrawtriangle(void) {
      for (int16_t i=0; i<min(display.width(),display.height())/2; i+=5) {
        display.drawTriangle(display.width()/2, display.height()/2-i,
                         display.width()/2-i, display.height()/2+i,
                         display.width()/2+i, display.height()/2+i, WHITE);
        display.display();
        delay(1);
      }
    }
    
    void testfilltriangle(void) {
      uint8_t color = WHITE;
      for (int16_t i=min(display.width(),display.height())/2; i>0; i-=5) {
        display.fillTriangle(display.width()/2, display.height()/2-i,
                         display.width()/2-i, display.height()/2+i,
                         display.width()/2+i, display.height()/2+i, WHITE);
        if (color == WHITE) color = BLACK;
        else color = WHITE;
        display.display();
        delay(1);
      }
    }
    
    void testdrawroundrect(void) {
      for (int16_t i=0; i<display.height()/2-2; i+=2) {
        display.drawRoundRect(i, i, display.width()-2*i, display.height()-2*i, display.height()/4, WHITE);
        display.display();
        delay(1);
      }
    }
    
    void testfillroundrect(void) {
      uint8_t color = WHITE;
      for (int16_t i=0; i<display.height()/2-2; i+=2) {
        display.fillRoundRect(i, i, display.width()-2*i, display.height()-2*i, display.height()/4, color);
        if (color == WHITE) color = BLACK;
        else color = WHITE;
        display.display();
        delay(1);
      }
    }
       
    void testdrawrect(void) {
      for (int16_t i=0; i<display.height()/2; i+=2) {
        display.drawRect(i, i, display.width()-2*i, display.height()-2*i, WHITE);
        display.display();
        delay(1);
      }
    }
    
    void testdrawline() {  
      for (int16_t i=0; i<display.width(); i+=4) {
        display.drawLine(0, 0, i, display.height()-1, WHITE);
        display.display();
        delay(1);
      }
      for (int16_t i=0; i<display.height(); i+=4) {
        display.drawLine(0, 0, display.width()-1, i, WHITE);
        display.display();
        delay(1);
      }
      delay(250);
      
      display.clearDisplay();
      for (int16_t i=0; i<display.width(); i+=4) {
        display.drawLine(0, display.height()-1, i, 0, WHITE);
        display.display();
        delay(1);
      }
      for (int16_t i=display.height()-1; i>=0; i-=4) {
        display.drawLine(0, display.height()-1, display.width()-1, i, WHITE);
        display.display();
        delay(1);
      }
      delay(250);
      
      display.clearDisplay();
      for (int16_t i=display.width()-1; i>=0; i-=4) {
        display.drawLine(display.width()-1, display.height()-1, i, 0, WHITE);
        display.display();
        delay(1);
      }
      for (int16_t i=display.height()-1; i>=0; i-=4) {
        display.drawLine(display.width()-1, display.height()-1, 0, i, WHITE);
        display.display();
        delay(1);
      }
      delay(250);
    
      display.clearDisplay();
      for (int16_t i=0; i<display.height(); i+=4) {
        display.drawLine(display.width()-1, 0, 0, i, WHITE);
        display.display();
        delay(1);
      }
      for (int16_t i=0; i<display.width(); i+=4) {
        display.drawLine(display.width()-1, 0, i, display.height()-1, WHITE); 
        display.display();
        delay(1);
      }
      delay(250);
    }
    
    void testscrolltext(void) {
      display.setTextSize(2);
      display.setTextColor(WHITE);
      display.setCursor(10,0);
      display.clearDisplay();
      display.println("scroll");
      display.display();
      delay(1);
     
      display.startscrollright(0x00, 0x0F);
      delay(2000);
      display.stopscroll();
      delay(1000);
      display.startscrollleft(0x00, 0x0F);
      delay(2000);
      display.stopscroll();
      delay(1000);    
      display.startscrolldiagright(0x00, 0x07);
      delay(2000);
      display.startscrolldiagleft(0x00, 0x07);
      delay(2000);
      display.stopscroll();
    }

     

     

     

     

     

    展开全文
  • 0x00 前言之前看到一篇文章是关于TPYBoard v102控制...0x01 实验器材TPYBoard v102 开发板 1块(某宝上可以买到,价格不贵)0.96 寸OLED显示屏(ssd1306) 1块杜邦线 若干0x02 前期准备1、首先我们先来看一下,之前...

    0x00 前言

    之前看到一篇文章是关于TPYBoard v102控制OLED屏显示的,看到之后就想尝试一下使用OLED屏来显示中文。最近利用空余时间搞定了这个实验,特此将实验过程及源码分享出来,方便以后使用。

    0x01 实验器材

    TPYBoard v102 开发板 1块(某宝上可以买到,价格不贵)

    0.96 寸OLED显示屏(ssd1306) 1块

    杜邦线 若干

    0x02 前期准备

    1、首先我们先来看一下,之前参考的OLED显示字符的文章。

    http://docs.tpyboard.com/zh/latest/tpyboard/tutorial/v10x/oled/?highlight=oled

    文章中的源码文件都已上传到GitHub。地址:https://github.com/TPYBoard/developmentBoard/tree/master/TPYBoard-v10x-master

    找到11.学习使用OLED显示屏]里面就是源程序。我就是在font.py和ssd1306.py基础上做的开发。

    2、在font.py中增加中文字模。

    font.py中已有英文、数字和符号的字符,我们需要做中文的字模添加到font.py中。

    2.1首先下载字模提取工具。地址:http://tpyboard.com/download/tool/187.html

    解压,双击运行PCtoLCD2002.exe。

    383503-20180920163212696-1056804709.png

    2.2 顶端菜单栏,点击[选项]按下方图片设置,设置完毕后点击[确定]保存设置。

    383503-20180920163232889-1165829842.png

    2.2回到主界面,在输入框中输入“我”点击[生成字模]。

    383503-20180920163243034-1510197674.png

    取得的字模数据如下:

    383503-20180920163253713-774007519.png

    2.2将取到的字模数据添加到font.py中。

    383503-20180920163301895-1458644863.png

    绿色框中是“我”的16进制utf-8编码。

    在线工具:http://tool.lu/hexstr/

    参照以上方法,我依次添加了“我爱你祖国”这5个汉字的字模。

    byte2 = {

    0xe68891:

    [

    0x04,0x0E,0x78,0x08,0x08,0xFF,0x08,0x08,0x0A,0x0C,0x18,0x68,0x08,0x08,0x2B,0x10,

    0x40,0x50,0x48,0x48,0x40,0xFE,0x40,0x44,0x44,0x48,0x30,0x22,0x52,0x8A,0x06,0x02,

    ],#我

    0xe788b1:

    [

    0x00,0x01,0x7E,0x22,0x11,0x7F,0x42,0x82,0x7F,0x04,0x07,0x0A,0x11,0x20,0x43,0x1C,

    0x08,0xFC,0x10,0x10,0x20,0xFE,0x02,0x04,0xF8,0x00,0xF0,0x10,0x20,0xC0,0x30,0x0E,

    ],#爱

    0xe4bda0:

    [

    0x08,0x08,0x08,0x11,0x11,0x32,0x34,0x50,0x91,0x11,0x12,0x12,0x14,0x10,0x10,0x10,

    0x80,0x80,0x80,0xFE,0x02,0x04,0x20,0x20,0x28,0x24,0x24,0x22,0x22,0x20,0xA0,0x40,

    ],#你

    0xe7a596:

    [

    0x20,0x11,0x11,0xF9,0x09,0x11,0x11,0x39,0x55,0x95,0x11,0x11,0x11,0x11,0x17,0x10,

    0x00,0xF8,0x08,0x08,0x08,0xF8,0x08,0x08,0x08,0xF8,0x08,0x08,0x08,0x08,0xFE,0x00

    ],#祖

    0xe59bbd:

    [

    0x00,0x7F,0x40,0x40,0x5F,0x41,0x41,0x4F,0x41,0x41,0x41,0x5F,0x40,0x40,0x7F,0x40,

    0x00,0xFC,0x04,0x04,0xF4,0x04,0x04,0xE4,0x04,0x44,0x24,0xF4,0x04,0x04,0xFC,0x04

    ],#国

    }

    1、在ssd1306.py 文件中增加了draw_chinese显示中文的方法。

    defdraw_chinese(self,ch_str,x_axis,y_axis):

    offset_=0

    y_axis=y_axis*8#中文高度一行占8个

    x_axis=127-(x_axis*16)#中文宽度占16个

    for k inch_str:

    code= 0x00#将中文转成16进制编码

    data_code = k.encode("utf-8")

    code|= data_code[0]<<16code|= data_code[1]<<8code|= data_code[2]

    byte_data=font.byte2[code]for y in range(0,16):

    a_=bin(byte_data[y]).replace('0b','')while len(a_)<8:

    a_='0'+a_

    b_=bin(byte_data[y+16]).replace('0b','')while len(b_)<8:

    b_='0'+b_for x in range(0,8):

    self.set_pixel(x_axis-x-offset_,y+y_axis,int(a_[x]))#文字的上半部分

    self.set_pixel(x_axis-x-8-offset_,y+y_axis,int(b_[x]))#文字的下半部分

    offset_+=16

    github源码地址:https://github.com/TPYBoard/developmentBoard/tree/master/TPYBoard-v10x-master/

    找到[20.学习OLED显示中文]。

    0x03 硬件连接

    本次实验使用OLED的SPI通讯方式,TPYBoard v102带有2个SPI接口,我用的SPI1。

    383503-20180920163438465-1184501365.png

    具体接线方法如下:

    0x04 效果展示

    硬件接线OK后,将源码全部拷贝到TPYBaord v102加载的磁盘中,按下RST按键复位或者使用Putty软件Ctrl+D软复位,重新运行效果如下:

    383503-20180920163501738-1902993877.jpg

    展开全文
  • OLED

    2021-03-07 19:05:51
    D[7:0]:8 位双向数据线。 RST(RES):硬复位 OLED。 DC(RS):命令/数据标志(0,读写命令;1,读写数据)。 模块的 8080 并口读/写的过程为:先根据要写入/读取的数据的类型,设置 DC 为高(数 据)/低(命令),...

    简介OLED
    分辨率为:128*64
    多种接口方式,提供 8086 并口、6800 并口、4 线 SPI 和 IIC 等五种接口方式
    在这里插入图片描述
    使用说明:
    CS:OLED 片选信号。
    WR(RW):向 OLED 写入数据。
    RD:从 OLED 读取数据。
    D[7:0]:8 位双向数据线。
    RST(RES):硬复位 OLED。
    DC(RS):命令/数据标志(0,读写命令;1,读写数据)。
    模块的 8080 并口读/写的过程为:先根据要写入/读取的数据的类型,设置 DC 为高(数
    据)/低(命令),然后拉低片选,选中 SSD1306,接着我们根据是读数据,还是要写数据置
    RD/WR 为低,然后:在 RD 的上升沿, 使数据锁存到数据线(D[7:0])上;

    8080写时序:CS拉低,RD拉高,DC控制是写数据还是命令,WR在上升沿时写入数据
    在这里插入图片描述
    读时序
    在这里插入图片描述
    在读取真正的数据之前,由一个的假读的过程。这里的假读,其实就是第一个读到的字节丢弃不要,从第二个开始,才是我们真正要读的数据。

    一个典型的读显存的时序图在这里插入图片描述
    简介:显存与指令
    SSD1306 的显存总共为 12864bit 大小,SSD1306 将这些显存分为了 8 页
    在这里插入图片描述
    在单片机的内部建立一个 OLED 的 GRAM(需要 128
    8 个字节),在每次修改的时候,只是修改单片机上的 GRAM(实际上就是 SRAM),在修改完了之后,一次性把单片机内部的 GRAM 写入到 OLED 的 GRAM在这里插入图片描述
    写个字节函数
    在这里插入图片描述

    指令
    在这里插入图片描述
    在这里插入图片描述
    初始化流程
    在这里插入图片描述
    画点函数在这里插入图片描述
    在这里插入图片描述
    显示字符函数,OLED_ShowChar
    //在指定位置显示一个字符,包括部分字符
    //x:0~127
    //y:0~63
    //mode:0,反白显示;1,正常显示
    //size:选择字体 12/16/24
    void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size,u8 mode)
    {
    u8 temp,t,t1;
    u8 y0=y;
    u8 csize=(size/8+((size%8)?1:0))*(size/2);
    //得到字体一个字符对应点阵集所占的字节数
    chr=chr-’ ';//得到偏移后的值
    for(t=0;t<csize;t++)
    {
    if(size12)temp=asc2_1206[chr][t]; //调用 1206 字体
    else if(size
    16)temp=asc2_1608[chr][t]; //调用 1608 字体
    else if(size==24)temp=asc2_2412[chr][t]; //调用 2412 字体
    else return; //没有的字库
    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-y0)==size)
    {
    y=y0;
    x++;
    break;
    }
    }
    }
    }
    按照从上到小,从左到右的取模方式来编写的,先得到最高位,然后判断是写 1 还是 0,画点;接着读第二位,如此循环,直到一个字符的点阵全部取完为止,这其中涉及到列地址和行地址的自增

    展开全文
  • 基于SIP接口的OLED数据显示1. 显示自己的学号和姓名。2. 显示AHT20的温度和湿度。3. 上下或左右的滑动显示长字。 1. 显示自己的学号和姓名。 接线如图所示 修改字符矩阵 2. 显示AHT20的温度和湿度。 3. 上下或...

    1. 显示自己的学号和姓名。

    接线如图所示
    在这里插入图片描述
    修改字符矩阵
    在这里插入图片描述在这里插入图片描述在这里插入图片描述

    在这里插入图片描述使用PCtoLCD转化为点阵
    在这里插入图片描述

    在这里插入图片描述将次部分替换即可
    主函数部分

    
    #include "delay.h"
    #include "sys.h"
    #include "oled.h"
    #include "bmp.h"
    #include "stdlib.h"
    #include "bsp_i2c.h"
    #include "ATH20.h"
    #include "stm32f10x.h"
    #include "stm32f10x_usart.h"
    #include "misc.h"
    void GPIO_Configuration(void);
    void RCC_Configuration(void);
    
    GPIO_InitTypeDef GPIO_InitStructure;
    
    int main(void)
      {	int hcr=1;int i1=6,i2=26,i3=46,i4=66,i5=86,i6=106,	i7=126,i8=146,i9=166;
    		uint8_t ret = 0;
    		uint8_t LED_Stat = 0;
        float P,T,ALT;
        uint32_t CT_data[2];
    	int  c1,t1;
    		delay_init();	    	 //延时函数初始化	  
    		NVIC_Configuration(); 	 //设置NVIC中断分组2:2位抢占优先级,2位响应优先级 	LED_Init();			     //LED端口初始化
    		OLED_Init();			//初始化OLED  
    		OLED_Clear(0) ; 
    		RCC_Configuration();					   	//设置系统时钟
        GPIO_Configuration();					    //IO口设
    	    OLED_WR_Byte(0x2E,OLED_CMD); 
            OLED_ShowCHinese(6,0,24);
            OLED_ShowCHinese(26,0,25);
    	    OLED_ShowCHinese(46,0,21);
    	   OLED_ShowCHinese(66,0,6);
           OLED_ShowCHinese(86,0,7);
    	   OLED_ShowCHinese(106,0,8);
    	   OLED_ShowCHinese(6,3,22);
           OLED_ShowCHinese(26,3,23);
    	  OLED_ShowCHinese(46,3,21);
    	  OLED_ShowString(0,6,"631807030410",16);  	
    		}	
    
    

    显示结果
    在这里插入图片描述

    2. 显示AHT20的温度和湿度。

    显示温度部分和和上面部分有很多相识部分,这里我就不一一赘述

    #include "delay.h"
    #include "sys.h"
    #include "oled.h"
    #include "bmp.h"
    #include "stdlib.h"
    #include "bsp_i2c.h"
    #include "ATH20.h"
    #include "stm32f10x.h"
    #include "stm32f10x_usart.h"
    #include "misc.h"
    void GPIO_Configuration(void);
    void RCC_Configuration(void);
    
    GPIO_InitTypeDef GPIO_InitStructure;
    
    int main(void)
      {	int hcr=1;int i1=6,i2=26,i3=46,i4=66,i5=86,i6=106,	i7=126,i8=146,i9=166;
    		uint8_t ret = 0;
    		uint8_t LED_Stat = 0;
        float P,T,ALT;
        uint32_t CT_data[2];
    	int  c1,t1;
    		delay_init();	    	 //延时函数初始化	  
    		NVIC_Configuration(); 	 //设置NVIC中断分组2:2位抢占优先级,2位响应优先级 	LED_Init();			     //LED端口初始化
    		OLED_Init();			//初始化OLED  
    		OLED_Clear(0) ; 
    		RCC_Configuration();					   	//设置系统时钟
        GPIO_Configuration();					    //IO口设
    I2C_Bus_Init();
        ret = ATH20_Init();
        if(ret == 0)
    		while(1)
        {   OLED_Clear(0);
             OLED_ShowString(0,11,"631807030616",16);  
    		  delay_ms(2500);
           printf("ATH20传感器初始化错误\n");
        }
     while(1) 
    	{		for(hcr=0;hcr<=166;hcr+=20)
    		{
    		while(ATH20_Read_Cal_Enable() == 0)
           {
               ATH20_Init();//如果为0再使能一次
               delay_ms(25);
            }
            ATH20_Read_CTdata(CT_data);  //读取温度和湿度
            c1 = CT_data[0] * 1000 / 1024 / 1024;  //计算得到湿度值(放大了10倍,如果c1=523,表示现在湿度为52.3%)
            t1 = CT_data[1] * 200 *10 / 1024 / 1024 - 500;//计算得到温度值(放大了10倍,如果t1=245,表示现在温度为24.5℃)
            
          
            OLED_Clear(0);
    		  if((i1-hcr)>=0)
            OLED_ShowCHinese(6-hcr,0,9);//全
    	      if((i2-hcr)>=0)
            OLED_ShowCHinese(26-hcr,0,10);//欢
    	      if((i3-hcr)>=0)
    	      OLED_ShowCHinese(46-hcr,0,11);
            if((i4-hcr)>=0)
    	      OLED_ShowCHinese(66-hcr,0,12);//子
    	      if((i5-hcr)>=0)
            OLED_ShowCHinese(86-hcr,0,13);//技
    	      if((i6-hcr)>=0)
    	       OLED_ShowCHinese(106-hcr,0,14);//术
    
    	      if((i7-hcr)>=0&&(i7-hcr)<=106)
             OLED_ShowCHinese(126-hcr,0,15);//动
    	      if((i8-hcr)>=0&&(i8-hcr)<=106)
            	OLED_ShowCHinese(146-hcr,0,16);//电
            if((i9-hcr)>=0&&(i9-hcr)<=106)
    	      OLED_ShowCHinese(166-hcr,0,17);//子
    			
    		    OLED_ShowCHinese(6,3,18);//温
    		    OLED_ShowCHinese(26,3,20);//度
    		    OLED_ShowCHinese(46,3,21);//:
    		    OLED_ShowNum(66,3,c1,1,16);
    		   	OLED_ShowCHinese(6,6,19);//湿
    		    OLED_ShowCHinese(26,6,20);//度
    		    OLED_ShowCHinese(46,6,21);//:
    				OLED_ShowNum(66,6,t1,3,16);
    			  delay_ms(2500);
            delay_ms(2500);//每隔两秒读一次数
    
            if(LED_Stat == 0)
            {
                LED_Stat = 1;
                GPIO_ResetBits(GPIOC, GPIO_Pin_2);
    				   //	GPIO_ResetBits(GPIOC, GPIO_Pin_1);
            }
            else
            {
                LED_Stat = 0;
                GPIO_SetBits(GPIOC, GPIO_Pin_2);
    					 // GPIO_SetBits(GPIOC, GPIO_Pin_1);
            }
    				
    	    }
    	}	
    	
    }
    
    
    void RCC_Configuration(void)
    {
      SystemInit();
    
      RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC
      						| RCC_APB2Periph_GPIOD| RCC_APB2Periph_GPIOE , ENABLE);
    }
    void GPIO_Configuration(void)
    {
      GPIO_InitTypeDef GPIO_InitStructure;
    
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;				     //状态LED1
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;			 //通用推挽输出模式
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;			 //输出模式最大速度50MHz
      GPIO_Init(GPIOC, &GPIO_InitStructure);
    }
    
    

    效果展示
    在这里插入图片描述

    3. 上下或左右的滑动显示长字。

    滑动的基本原理就是通过不断地刷新坐标实现的
    实现水平滑动和竖直滑动的代码

    OLED_WR_Byte(0x2e,OLED_CMD);        //关闭滚动
    OLED_WR_Byte(0x29,OLED_CMD);        //水平垂直和水平滚动左右 29/2a
    OLED_WR_Byte(0x00,OLED_CMD);        //虚拟字节
    OLED_WR_Byte(0x00,OLED_CMD);        //起始页 0
    OLED_WR_Byte(0x07,OLED_CMD);        //滚动时间间隔
    OLED_WR_Byte(0x07,OLED_CMD);        //终止页 1
    OLED_WR_Byte(0x01,OLED_CMD);        //垂直滚动偏移量
    OLED_WR_Byte(0x2F,OLED_CMD);        //开启滚动
    

    主函数部分:

    
    int main(void)
      {	int hcr=1;int i1=6,i2=26,i3=46,i4=66,i5=86,i6=106,	i7=126,i8=146,i9=166;
    		uint8_t ret = 0;
    		uint8_t LED_Stat = 0;
        float P,T,ALT;
        uint32_t CT_data[2];
    	int  c1,t1;
    		delay_init();	    	 //延时函数初始化	  
    		NVIC_Configuration(); 	 //设置NVIC中断分组2:2位抢占优先级,2位响应优先级 	LED_Init();			     //LED端口初始化
    		OLED_Init();			//初始化OLED  
    		OLED_Clear(0) ; 
    		RCC_Configuration();					   	//设置系统时钟
        GPIO_Configuration();					    //IO口设
       OLED_WR_Byte(0x2E,OLED_CMD);        //关闭滚动
        OLED_WR_Byte(0x26,OLED_CMD);        //水平向左或者右滚动 26/27
        OLED_WR_Byte(0x00,OLED_CMD);        //虚拟字节
    	  OLED_WR_Byte(0x00,OLED_CMD);        //起始页 0
       	OLED_WR_Byte(0x07,OLED_CMD);        //滚动时间间隔
    	  OLED_WR_Byte(0x07,OLED_CMD);        //终止页 7
    	  OLED_WR_Byte(0x00,OLED_CMD);        //虚拟字节
    	  OLED_WR_Byte(0xFF,OLED_CMD);
    		    OLED_ShowCHinese(6,0,9);
            OLED_ShowCHinese(26,0,10);
    	      OLED_ShowCHinese(46,0,11);
    	      OLED_ShowCHinese(66,0,12);
            OLED_ShowCHinese(86,0,13);
    	      OLED_ShowCHinese(106,0,14);
            OLED_ShowCHinese(6,3,15);
            OLED_ShowCHinese(26,3,16);
    	      OLED_ShowCHinese(46,3,17);
    			  OLED_WR_Byte(0x2F,OLED_CMD);
    		}
    
    

    效果展示:
    在这里插入图片描述

    总结:OLED的显示是一个我们需要掌握的技能,可以有多种显示方法,是实现交互性的重要模块。可以和其它模块一起完成显示功能。

    展开全文
  • 基于STM32的OLED的SPI接口数据显示使用OLED显示数据 使用OLED显示数据 接线说明
  • 基于正点原子的IIC与OLED 显示,只需要两个接口即可,一根数据线,一根时钟线,内有如何将SPI-OLED改成IIC-OLED ,电路简单,代码少如即可点亮,还有汉字函数!
  • 基于SPI接口的OLED数据显示一、准备工作硬件准备SPI(串行外设接口)点阵法生成汉字二、简单OLED显示 一、准备工作 硬件准备 stm32f103指南者 0.96寸OLED显示屏模块(SPI协议) AHT20模块(IIC协议) 杜邦线及连接...
  • 1.完整源码:主函数oled.pyfrom ssd1306 import SSD1306_SPIfrom ssd1306 import SSD1306import fontimport machinedef draw_chinese(lcd,ch_str,x_axis,y_axis):offset_=0y_axis=y_axis*16#中文高度一行占8个x_axis...
  • 少废话,先上效果图 屏幕显示效果 全家福 观看演示效果: ... 一、基础认识及引脚介绍 ...SSD1306是一款带控制器的用于OLED点阵图形显示系统的单片CMOS OLED/PLED驱动器。它由128个SEG(列输出)和64个CO...
  • OLED的使用-4线SPI驱动

    万次阅读 多人点赞 2018-05-03 22:54:42
    一 、OLED屏 1.OLED屏(七针) 2.OLED电路图 ...3.0.96'OLED简介 ...1、三色可选,模块有两种单色和黄蓝双色两种颜色可选,单色为纯白色和纯蓝色,双 ...2、超小尺寸,显示尺寸为 ...4、接口模式,4 线串行 SPI 接口...
  • 基于SPI协议接口的OLED数据显示 文章目录基于SPI协议接口的OLED数据显示任务摘要一、SPI协议简介二、接口与程序1.接口定义2.SPI接线3.程序4.程序烧录三、OLED显示姓名学号四、显示温度-湿度五、OLED的滑屏显示六...
  • OLED中的Demura

    千次阅读 2017-10-11 21:43:00
    OLED作为一种电流型发光器件已越来越多地被应用于高性能显示。由于它自发光的特性,与LCD相比,AMOLED具有高对比度、超轻薄、可弯曲等诸多优点。但是,亮度均匀性和残像仍然是它目前面临的两个主要难题,要解决这...
  • 基于SPI/IIC接口的OLED数据显示 文章目录基于SPI/IIC接口的OLED数据显示实验器材实验代码数据显示 实验器材 1.stm32F103VE开发板 2.USB串口线 3.0.96寸SPI 7针OLED显示屏 实验代码 1.打开如下链接 ...
  • 关于SPI ...SPI 接口有 2 根单向数据线,为全双工通信,目前应用的数据速率可达几 Mbps 的水平。 提示:以下是本篇文章正文内容,下面案例可供参考 0.96OLED屏幕 相关资料:0.96inch SPI OLED Mo
  • 基于SPI的OLED数据显示

    2020-12-27 19:13:00
    利用SPI总线实现OLED屏幕显示,显示自己的学号和姓名。 本人所用开发板:野火STM32F103指南者; 代码编写烧录:KEIL5; 所用协议:SPI; 代码资料包:资料包 资料包下载 点击链接,下载这个资料包 找到如下路径 ...
  • LG宣布其在广州的8.5代OLED面板生产线将在今年三季度投产,其OLED面板产能将因此提升35.7%,从280万片增加至380万片。LG的OLED面板产能扩张有助于缓解...
  • OLED(OrganicLight-Emitting Diode),又称为有机电激光显示、有机发光半导体(OrganicElectroluminesence Display,OLED)。 文章目录一、基础知识1.OLED2.分类1)从器件结构上进行分类2)从驱动方式上进行分类3)...
  • OLED的SPI接口数据显示

    2020-12-23 11:11:21
    2、打开下图路径,在上述链接 3、进行野火stm32主板与OLED屏的连线 4、连线完成 5、使用软件生成字模 6、修改部分代码 将 6、编译成功,使用串口工具烧录 结果呈现 可以看到OLED屏亮显示学号姓名 总结 ...
  • STM32F103+OLED曲线绘制

    千次阅读 多人点赞 2020-05-26 12:29:42
    STM32F103+OLED曲线绘制 从本文的标题便能看出,此次分享的内容是以STM32F103C8T6芯片为控制核心,OLED则为0.96寸I2C通信的...根据上图我们可以看到,这个型号的OLED屏只有4个引脚,真正与MCU通信的信号线才2根,比较适
  • 理解OLED屏显和汉字点阵编码原理,使用STM32F103的SPI接口实现以下功能: 显示自己的学号和姓名; 显示AHT20的温度和湿度; 上下或左右的滑动显示长字符 器件准备:一块STM32d103最小芯片,一块AHT20温湿度...
  • Arduino Uno 驱动OLED进阶 显示英文字

    万次阅读 多人点赞 2016-11-29 22:22:47
    Arduino 驱动OLED屏幕IIC接线方式简单入门 实现文字的显示 这代码上实现在指定的坐标显示指定的英文字 先看看效果图 相关开源代码: 程序与库与软件打包下载:...
  • STM32开发基于SPI接口的OLED数据显示

    千次阅读 2020-12-26 11:43:30
    进行对SPI串口的通信的学习,进而用STM32建立工程实现OLED数据显示

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,572
精华内容 1,428
关键字:

oled中数据线