欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 【Arduino】168種傳感器模塊系列實驗（145）---0.91寸OLED液晶屏 [打印本頁]
作者: eagler8    時間: 2020-2-19 13:13
標題: 【Arduino】168種傳感器模塊系列實驗（145）---0.91寸OLED液晶屏
37款傳感器與執行器的提法，在網絡上廣泛流傳，其實Arduino能夠兼容的傳感器模塊肯定是不止這37種的。鑒于本人手頭積累了一些傳感器和執行器模塊，依照實踐出真知（一定要動手做）的理念，以學習和交流為目的，這里準備逐一動手嘗試系列實驗，不管成功（程序走通）與否，都會記錄下來---小小的進步或是搞不掂的問題，希望能夠拋磚引玉。

【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC 12832液晶屏 兼容3.3v-5V








作者: eagler8    時間: 2020-2-19 14:26
本帖最后由 eagler8 于 2020-2-19 14:55 編輯



OLED
OLED是英文Organic Light Emitting Display（有機發光顯示器）的簡稱，它的發光原理是指有機半導體材料和發光材料在電場驅動下，通過載流子注入和復合導致發光。通過搭配不同的有機材料，就可以發出不同顏色的光，來達到彩顯示器的要求。也有人把OLED拼寫為 Organic Light Emitting Diode （有機發光二極管），兩種寫法意思基本一樣。

由于OLED是自發光器件，每個像素自己都會發光，并且透光率很高，因此，與時下液晶電視都采用的LCD面板相比，其亮度與對比度都比LCD勝出一籌，視角可達170度，圖像更加鮮艷，耗電量更小。另外，OLED的發光層比較輕，因此它的基層可使用富于柔韌性的材料，而不會使用剛性材料。OLED基層為塑料材質，而LCD、PDP、SED、TDEL等顯示器則需使用玻璃基板，因此，OLED顯示器的發光效率是目前所有顯示器中排名最高。

最近幾年，在歐洲還誕生了一種用高分子有機材料制造發光二極管的技術，稱為POLED（Polymer Organic Light Emitting Display）技術，由于高分子有機材料可以溶于有機溶劑，因此，POLED顯示器將來可以用印刷技術來進行生產，從而可以大大降低生產成本。

作者: eagler8    時間: 2020-2-19 14:41
OLED結構
OLED器件由基板、陰極、陽極、空穴注入層（HIL）、電子注入層（EIL）、空穴傳輸層（HTL）、電子傳輸層（ETL）、電子阻擋層（EBL）、空穴阻擋層（HBL）、發光層（EML）等部分構成。其中，基板是整個器件的基礎，所有功能層都需要蒸鍍到器件的基板上；通常采用玻璃作為器件的基板，但是如果需要制作可彎曲的柔性OLED器件，則需要使用其它材料如塑料等作為器件的基板。陽極與器件外加驅動電壓的正極相連，陽極中的空穴會在外加驅動電壓的驅動下向器件中的發光層移動，陽極需要在器件工作時具有一定的透光性，使得器件內部發出的光能夠被外界觀察到；陽極最常使用的材料是ITO。空穴注入層能夠對器件的陽極進行修飾，并可以使來自陽極的空穴順利的注入到空穴傳輸層；空穴傳輸層負責將空穴運輸到發光層；電子阻擋層會把來自陰極的電子阻擋在器件的發光層界面處，增大器件發光層界面處電子的濃度；發光層為器件電子和空穴再結合形成激子然后激子退激發光的地方；空穴阻擋層會將來自陽極的空穴阻擋在器件發光層的界面處，進而提高器件發光層界面處電子和空穴再結合的概率，增大器件的發光效率；電子傳輸層負責將來自陰極的電子傳輸到器件的發光層中；電子注入層起對陰極修飾及將電子傳輸到電子傳輸層的作用；陰極中的電子會在器件外加驅動電壓的驅動下向器件的發光層移動，然后在發光層與來自陽極的空穴進行再結合。




作者: eagler8    時間: 2020-2-19 14:54


OLED特性
OLED技術之所以能夠獲得廣泛的應用，在于其與其它技術相比，具有以下優點：
（1）功耗低
與LCD相比，OLED不需要背光源，而背光源在LCD中是比較耗能的一部分，所以OLED是比較節能的。例如，24in的AMOLED模塊功耗僅僅為440mw，而24in的多晶硅LCD模塊達到了605mw。
（2）響應速度快
OLED技術與其他技術相比，其響應速度快，響應時間可以達到微秒級別。較高的響應速度更好的實現了運動的圖像。根據有關的數據分析，其響應速度達到了液晶顯示器響應速度的1000倍左右。
（3）較寬的視角
與其他顯示相比，由于OLED是主動發光的，所以在很大視角范圍內畫面是不會顯示失真的。其上下，左右的視角寬度超過170度。
（4）能實現高分辨率顯示
大多高分辨率的OLED顯示采用的是有源矩陣也就是AMOLED，它的發光層可以是吸納26萬真彩色的高分辨率，并且隨著科學技術的發展，其分辨率在以后會得到更高的提升。
（5）寬溫度特性
與LCD相比，OLED可以在很大的溫度范圍內進行工作，根據有關的技術分析，溫度在-40攝氏度到80攝氏度都是可以正常運行的。這樣就可以降低地域限制，在極寒地帶也可以正常使用。
（6）OLED能夠實現軟屏
OLED可以在塑料、樹脂等不同的柔性襯底材料上進行生產，將有機層蒸鍍或涂布在塑料基襯上，就可以實現軟屏。
（7）OLED成品的質量比較輕
與其他產品相比，OLED的質量比較小，厚度與LCD相比是比較小的，其抗震系數較高，能夠適應較大的加速度，振動等比較惡劣的環境。

作者: eagler8    時間: 2020-2-19 15:07
OLED優勢
相比傳統的LCD技術，OLED顯示技術具有明顯的優勢，OLED屏幕厚度可以控制在1mm以內，而LCD屏幕厚度通常在3mm左右，并且重量更加輕盈。OLED屏幕的液態結構可以保證屏幕的抗衰性能，并且具有LCD不具備的廣視角，可以實現超大范圍內觀看同一塊屏幕，畫面不會失真。反應速度是LCD屏幕的千分之一。并且OLED屏幕耐低溫，可以在-40℃環境下正常顯示內容，發光效率更高、能耗低、生態環保，可以制作成曲面屏，從而給人們帶來不同的視覺沖擊。

OLED是一種利用多層有機薄膜結構產生電致發光的器件，它很容易制作，而且只需要低的驅動電壓，這些主要的特征使得OLED在滿足平面顯示器的應用上顯得非常突出。OLED顯示屏比LCD更輕薄、亮度高、功耗低、響應快、清晰度高、柔性好、發光效率高，能滿足消費者對顯示技術的新需求。全球越來越多的顯示器廠家紛紛投入研發，大大的推動了OLED的產業化進程。




作者: eagler8    時間: 2020-2-20 10:13


0.91寸OLED液晶屏顯示模塊參數
驅動芯片：SSD1306
支持接口：I2C
顯示顏色：白色
高分辨率： 128×32
可視角度：大于160°
工作電壓：3.3V / 5V
模塊大小：36 x 12.5（mm）

作者: eagler8    時間: 2020-2-20 10:39
驅動芯片SSD1306方塊圖



作者: eagler8    時間: 2020-2-20 10:52
模塊電原理圖



作者: eagler8    時間: 2020-2-20 11:05




作者: eagler8    時間: 2020-2-20 11:20

作者: eagler8    時間: 2020-2-20 11:33
本帖最后由 eagler8 于 2020-2-20 14:23 編輯


OLED模塊引腳說明
GND ------ 地線
VCC ------ 電源
（因為模塊內部自帶穩壓，所以3.3~5V供電都是ok的）
SDA ------ I2C 數據線（接A4）
SCL  ------ I2C 時鐘線（接A5）
（可以看到模塊后面有一個U2芯片，就是用來穩壓的）

作者: eagler8    時間: 2020-2-20 11:48
下載安裝最新庫
https://learn.adafruit.com/monoc ... ibrary-and-examples
其中OLED模塊的專用庫名稱是SSD1306，另外需要配合圖形庫GFX操作
不建議使用NB的U8glib，因為這個庫強大到哭，所以編譯和下載都太消耗時間了。




作者: eagler8    時間: 2020-2-20 11:58



將這些OLED與Arduino一起使用需要安裝兩個庫：Adafruit_SSD1306和Adafruit_GFX，Adafruit_SSD1306處理與硬件之間的低級通信，Adafruit_GFX在此基礎上構建以添加圖形功能，例如線條，圓圈和文本。
作者: eagler8    時間: 2020-2-20 12:50
Arduino的Adafruit_GFX庫為我們所有的LCD和OLED顯示器提供了通用語法和圖形功能集。這使Arduino草圖可以輕松地在顯示類型之間進行調整，而不必花太多精力……而且任何新功能，性能改進和錯誤修復將立即應用于我們完整的彩色顯示屏產品中。該Adafruit_GFX庫可以使用安裝Arduino的庫管理 ...這是首選的和現代的方式。從Arduino的“草圖”菜單中，選擇“包含庫”，然后選擇“管理庫…”。

另有下載庫鏈接  https://codeload.github.com/adaf ... -Library/zip/master




作者: eagler8    時間: 2020-2-20 14:43
實驗開源測試代碼


  1. /*
  2.   【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.   實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.   安裝庫：IDE—工具—管理庫—搜索Adafruit_SSD1306—安裝
  5.   安裝庫：IDE—工具—管理庫—搜索Adafruit_GFX—安裝
  6.   實驗接線方法
  7.   oled模塊    Ardunio Uno
  8.   GND---------GND接地線
  9.   VCC---------5V 接電源
  10.   SDA---------A4
  11.   SCL ------- A5
  12.   實驗之一：點亮SSD1306_128x32 OLED_i2c屏
  13. */

  15. #include <SPI.h>
  16. #include <Wire.h>
  17. #include <Adafruit_GFX.h>
  18. #include <Adafruit_SSD1306.h>

  20. #define SCREEN_WIDTH 128 // OLED display width, in pixels
  21. #define SCREEN_HEIGHT 32 // OLED display height, in pixels

  23. // Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
  24. #define OLED_RESET     4 // Reset pin # (or -1 if sharing Arduino reset pin)
  25. Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

  27. #define NUMFLAKES     10 // Number of snowflakes in the animation example

  29. #define LOGO_HEIGHT   16
  30. #define LOGO_WIDTH    16
  31. static const unsigned char PROGMEM logo_bmp[] =
  32. { B00000000, B11000000,
  33.   B00000001, B11000000,
  34.   B00000001, B11000000,
  35.   B00000011, B11100000,
  36.   B11110011, B11100000,
  37.   B11111110, B11111000,
  38.   B01111110, B11111111,
  39.   B00110011, B10011111,
  40.   B00011111, B11111100,
  41.   B00001101, B01110000,
  42.   B00011011, B10100000,
  43.   B00111111, B11100000,
  44.   B00111111, B11110000,
  45.   B01111100, B11110000,
  46.   B01110000, B01110000,
  47.   B00000000, B00110000
  48. };

  50. void setup() {
  51.   Serial.begin(9600);

  53.   // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  54.   if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3C for 128x32
  55.     Serial.println(F("SSD1306 allocation failed"));
  56.     for (;;); // Don't proceed, loop forever
  57.   }

  59.   // Show initial display buffer contents on the screen --
  60.   // the library initializes this with an Adafruit splash screen.
  61.   display.display();
  62.   delay(2000); // Pause for 2 seconds

  64.   // Clear the buffer
  65.   display.clearDisplay();

  67.   // Draw a single pixel in white
  68.   display.drawPixel(10, 10, SSD1306_WHITE);

  70.   // Show the display buffer on the screen. You MUST call display() after
  71.   // drawing commands to make them visible on screen!
  72.   display.display();
  73.   delay(2000);
  74.   // display.display() is NOT necessary after every single drawing command,
  75.   // unless that's what you want...rather, you can batch up a bunch of
  76.   // drawing operations and then update the screen all at once by calling
  77.   // display.display(). These examples demonstrate both approaches...

  79.   testdrawline();      // Draw many lines

  81.   testdrawrect();      // Draw rectangles (outlines)

  83.   testfillrect();      // Draw rectangles (filled)

  85.   testdrawcircle();    // Draw circles (outlines)

  87.   testfillcircle();    // Draw circles (filled)

  89.   testdrawroundrect(); // Draw rounded rectangles (outlines)

  91.   testfillroundrect(); // Draw rounded rectangles (filled)

  93.   testdrawtriangle();  // Draw triangles (outlines)

  95.   testfilltriangle();  // Draw triangles (filled)

  97.   testdrawchar();      // Draw characters of the default font

  99.   testdrawstyles();    // Draw 'stylized' characters

  101.   testscrolltext();    // Draw scrolling text

  103.   testdrawbitmap();    // Draw a small bitmap image

  105.   // Invert and restore display, pausing in-between
  106.   display.invertDisplay(true);
  107.   delay(1000);
  108.   display.invertDisplay(false);
  109.   delay(1000);

  111.   testanimate(logo_bmp, LOGO_WIDTH, LOGO_HEIGHT); // Animate bitmaps
  112. }

  114. void loop() {
  115. }

  117. void testdrawline() {
  118.   int16_t i;

  120.   display.clearDisplay(); // Clear display buffer

  122.   for (i = 0; i < display.width(); i += 4) {
  123.     display.drawLine(0, 0, i, display.height() - 1, SSD1306_WHITE);
  124.     display.display(); // Update screen with each newly-drawn line
  125.     delay(1);
  126.   }
  127.   for (i = 0; i < display.height(); i += 4) {
  128.     display.drawLine(0, 0, display.width() - 1, i, SSD1306_WHITE);
  129.     display.display();
  130.     delay(1);
  131.   }
  132.   delay(250);

  134.   display.clearDisplay();

  136.   for (i = 0; i < display.width(); i += 4) {
  137.     display.drawLine(0, display.height() - 1, i, 0, SSD1306_WHITE);
  138.     display.display();
  139.     delay(1);
  140.   }
  141.   for (i = display.height() - 1; i >= 0; i -= 4) {
  142.     display.drawLine(0, display.height() - 1, display.width() - 1, i, SSD1306_WHITE);
  143.     display.display();
  144.     delay(1);
  145.   }
  146.   delay(250);

  148.   display.clearDisplay();

  150.   for (i = display.width() - 1; i >= 0; i -= 4) {
  151.     display.drawLine(display.width() - 1, display.height() - 1, i, 0, SSD1306_WHITE);
  152.     display.display();
  153.     delay(1);
  154.   }
  155.   for (i = display.height() - 1; i >= 0; i -= 4) {
  156.     display.drawLine(display.width() - 1, display.height() - 1, 0, i, SSD1306_WHITE);
  157.     display.display();
  158.     delay(1);
  159.   }
  160.   delay(250);

  162.   display.clearDisplay();

  164.   for (i = 0; i < display.height(); i += 4) {
  165.     display.drawLine(display.width() - 1, 0, 0, i, SSD1306_WHITE);
  166.     display.display();
  167.     delay(1);
  168.   }
  169.   for (i = 0; i < display.width(); i += 4) {
  170.     display.drawLine(display.width() - 1, 0, i, display.height() - 1, SSD1306_WHITE);
  171.     display.display();
  172.     delay(1);
  173.   }

  175.   delay(2000); // Pause for 2 seconds
  176. }

  178. void testdrawrect(void) {
  179.   display.clearDisplay();

  181.   for (int16_t i = 0; i < display.height() / 2; i += 2) {
  182.     display.drawRect(i, i, display.width() - 2 * i, display.height() - 2 * i, SSD1306_WHITE);
  183.     display.display(); // Update screen with each newly-drawn rectangle
  184.     delay(1);
  185.   }

  187.   delay(2000);
  188. }

  190. void testfillrect(void) {
  191.   display.clearDisplay();

  193.   for (int16_t i = 0; i < display.height() / 2; i += 3) {
  194.     // The INVERSE color is used so rectangles alternate white/black
  195.     display.fillRect(i, i, display.width() - i * 2, display.height() - i * 2, SSD1306_INVERSE);
  196.     display.display(); // Update screen with each newly-drawn rectangle
  197.     delay(1);
  198.   }

  200.   delay(2000);
  201. }

  203. void testdrawcircle(void) {
  204.   display.clearDisplay();

  206.   for (int16_t i = 0; i < max(display.width(), display.height()) / 2; i += 2) {
  207.     display.drawCircle(display.width() / 2, display.height() / 2, i, SSD1306_WHITE);
  208.     display.display();
  209.     delay(1);
  210.   }

  212.   delay(2000);
  213. }

  215. void testfillcircle(void) {
  216.   display.clearDisplay();

  218.   for (int16_t i = max(display.width(), display.height()) / 2; i > 0; i -= 3) {
  219.     // The INVERSE color is used so circles alternate white/black
  220.     display.fillCircle(display.width() / 2, display.height() / 2, i, SSD1306_INVERSE);
  221.     display.display(); // Update screen with each newly-drawn circle
  222.     delay(1);
  223.   }

  225.   delay(2000);
  226. }

  228. void testdrawroundrect(void) {
  229.   display.clearDisplay();

  231.   for (int16_t i = 0; i < display.height() / 2 - 2; i += 2) {
  232.     display.drawRoundRect(i, i, display.width() - 2 * i, display.height() - 2 * i,
  233.                           display.height() / 4, SSD1306_WHITE);
  234.     display.display();
  235.     delay(1);
  236.   }

  238.   delay(2000);
  239. }

  241. void testfillroundrect(void) {
  242.   display.clearDisplay();

  244.   for (int16_t i = 0; i < display.height() / 2 - 2; i += 2) {
  245.     // The INVERSE color is used so round-rects alternate white/black
  246.     display.fillRoundRect(i, i, display.width() - 2 * i, display.height() - 2 * i,
  247.                           display.height() / 4, SSD1306_INVERSE);
  248.     display.display();
  249.     delay(1);
  250.   }

  252.   delay(2000);
  253. }

  255. void testdrawtriangle(void) {
  256.   display.clearDisplay();

  258.   for (int16_t i = 0; i < max(display.width(), display.height()) / 2; i += 5) {
  259.     display.drawTriangle(
  260.       display.width() / 2  , display.height() / 2 - i,
  261.       display.width() / 2 - i, display.height() / 2 + i,
  262.       display.width() / 2 + i, display.height() / 2 + i, SSD1306_WHITE);
  263.     display.display();
  264.     delay(1);
  265.   }

  267.   delay(2000);
  268. }

  270. void testfilltriangle(void) {
  271.   display.clearDisplay();

  273.   for (int16_t i = max(display.width(), display.height()) / 2; i > 0; i -= 5) {
  274.     // The INVERSE color is used so triangles alternate white/black
  275.     display.fillTriangle(
  276.       display.width() / 2  , display.height() / 2 - i,
  277.       display.width() / 2 - i, display.height() / 2 + i,
  278.       display.width() / 2 + i, display.height() / 2 + i, SSD1306_INVERSE);
  279.     display.display();
  280.     delay(1);
  281.   }

  283.   delay(2000);
  284. }

  286. void testdrawchar(void) {
  287.   display.clearDisplay();

  289.   display.setTextSize(1);      // Normal 1:1 pixel scale
  290.   display.setTextColor(SSD1306_WHITE); // Draw white text
  291.   display.setCursor(0, 0);     // Start at top-left corner
  292.   display.cp437(true);         // Use full 256 char 'Code Page 437' font

  294.   // Not all the characters will fit on the display. This is normal.
  295.   // Library will draw what it can and the rest will be clipped.
  296.   for (int16_t i = 0; i < 256; i++) {
  297.     if (i == '\n') display.write(' ');
  298.     else          display.write(i);
  299.   }

  301.   display.display();
  302.   delay(2000);
  303. }

  305. void testdrawstyles(void) {
  306.   display.clearDisplay();

  308.   display.setTextSize(1);             // Normal 1:1 pixel scale
  309.   display.setTextColor(SSD1306_WHITE);        // Draw white text
  310.   display.setCursor(0, 0);            // Start at top-left corner
  311.   display.println(F("Hello, world!"));

  313.   display.setTextColor(SSD1306_BLACK, SSD1306_WHITE); // Draw 'inverse' text
  314.   display.println(3.141592);

  316.   display.setTextSize(2);             // Draw 2X-scale text
  317.   display.setTextColor(SSD1306_WHITE);
  318.   display.print(F("0x")); display.println(0xDEADBEEF, HEX);

  320.   display.display();
  321.   delay(2000);
  322. }

  324. void testscrolltext(void) {
  325.   display.clearDisplay();

  327.   display.setTextSize(2); // Draw 2X-scale text
  328.   display.setTextColor(SSD1306_WHITE);
  329.   display.setCursor(10, 0);
  330.   display.println(F("scroll"));
  331.   display.display();      // Show initial text
  332.   delay(100);

  334.   // Scroll in various directions, pausing in-between:
  335.   display.startscrollright(0x00, 0x0F);
  336.   delay(2000);
  337.   display.stopscroll();
  338.   delay(1000);
  339.   display.startscrollleft(0x00, 0x0F);
  340.   delay(2000);
  341.   display.stopscroll();
  342.   delay(1000);
  343.   display.startscrolldiagright(0x00, 0x07);
  344.   delay(2000);
  345.   display.startscrolldiagleft(0x00, 0x07);
  346.   delay(2000);
  347.   display.stopscroll();
  348.   delay(1000);
  349. }

  351. void testdrawbitmap(void) {
  352.   display.clearDisplay();

  354.   display.drawBitmap(
  355.     (display.width()  - LOGO_WIDTH ) / 2,
  356.     (display.height() - LOGO_HEIGHT) / 2,
  357.     logo_bmp, LOGO_WIDTH, LOGO_HEIGHT, 1);
  358.   display.display();
  359.   delay(1000);
  360. }

  362. #define XPOS   0 // Indexes into the 'icons' array in function below
  363. #define YPOS   1
  364. #define DELTAY 2

  366. void testanimate(const uint8_t *bitmap, uint8_t w, uint8_t h) {
  367.   int8_t f, icons[NUMFLAKES][3];

  369.   // Initialize 'snowflake' positions
  370.   for (f = 0; f < NUMFLAKES; f++) {
  371.     icons[f][XPOS]   = random(1 - LOGO_WIDTH, display.width());
  372.     icons[f][YPOS]   = -LOGO_HEIGHT;
  373.     icons[f][DELTAY] = random(1, 6);
  374.     Serial.print(F("x: "));
  375.     Serial.print(icons[f][XPOS], DEC);
  376.     Serial.print(F(" y: "));
  377.     Serial.print(icons[f][YPOS], DEC);
  378.     Serial.print(F(" dy: "));
  379.     Serial.println(icons[f][DELTAY], DEC);
  380.   }

  382.   for (;;) { // Loop forever...
  383.     display.clearDisplay(); // Clear the display buffer

  385.     // Draw each snowflake:
  386.     for (f = 0; f < NUMFLAKES; f++) {
  387.       display.drawBitmap(icons[f][XPOS], icons[f][YPOS], bitmap, w, h, SSD1306_WHITE);
  388.     }

  390.     display.display(); // Show the display buffer on the screen
  391.     delay(200);        // Pause for 1/10 second

  393.     // Then update coordinates of each flake...
  394.     for (f = 0; f < NUMFLAKES; f++) {
  395.       icons[f][YPOS] += icons[f][DELTAY];
  396.       // If snowflake is off the bottom of the screen...
  397.       if (icons[f][YPOS] >= display.height()) {
  398.         // Reinitialize to a random position, just off the top
  399.         icons[f][XPOS]   = random(1 - LOGO_WIDTH, display.width());
  400.         icons[f][YPOS]   = -LOGO_HEIGHT;
  401.         icons[f][DELTAY] = random(1, 6);
  402.       }
  403.     }
  404.   }
  405. }
復制代碼



作者: eagler8    時間: 2020-2-20 14:55

作者: eagler8    時間: 2020-2-20 15:24
  1. /*
  2.   【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.   實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.   安裝庫：IDE—工具—管理庫—搜索Adafruit_SSD1306—安裝
  5.   安裝庫：IDE—工具—管理庫—搜索Adafruit_GFX—安裝
  6.   實驗接線方法
  7.   oled模塊    Ardunio Uno
  8.   GND---------GND接地線
  9.   VCC---------5V 接電源
  10.   SDA---------A4
  11.   SCL ------- A5
  12.   實驗之二：自動計數器
  13. */

  15. #include <Arduino.h>
  16. #include <U8x8lib.h>

  18. U8X8_SSD1306_128X32_UNIVISION_HW_I2C u8x8(U8X8_PIN_NONE);


  21. int i = 0;
  22. void setup(void)
  23. {
  24.   u8x8.begin();
  25.   u8x8.setPowerSave(0);
  26. }

  28. void loop(void)
  29. {
  30.   
  31.   //u8x8.setFont(u8x8_font_chroma48medium8_r); //小字體，細
  32.   //u8x8.setFont(u8x8_font_pxplustandynewtv_r); //小字體，粗
  33.   //u8x8.setFont(u8x8_font_lucasarts_scumm_subtitle_r_2x2_r); //兩行字體，細
  34.   u8x8.setFont(u8x8_font_px437wyse700a_2x2_r); //兩行字體，粗

  36.   
  37.   String s = "PA:" ;
  38.   String s2;
  39.   s2 = s + i;
  40.   u8x8.drawString(0,0,s2.c_str());

  42.   s = "TL:";
  43.   s2 = s + (i * 2);

  45.   u8x8.drawString(0,2,s2.c_str());

  47.   delay(50);
  48.   i ++;
  49. }
復制代碼


作者: eagler8    時間: 2020-2-20 15:25

作者: eagler8    時間: 2020-2-20 16:09
  1. /*
  2.     【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.     實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.     安裝庫：IDE—工具—管理庫—搜索Adafruit_SSD1306—安裝
  5.     安裝庫：IDE—工具—管理庫—搜索Adafruit_GFX—安裝
  6.     實驗接線方法
  7.     oled模塊    Ardunio Uno
  8.     GND---------GND接地線
  9.     VCC---------5V 接電源
  10.     SDA---------A4
  11.     SCL ------- A5
  12.     實驗之三：顯示英文 Hello, world!
  13. */

  15. #include <SPI.h>
  16. #include <Wire.h>
  17. #include <Adafruit_GFX.h>
  18. #include <Adafruit_SSD1306.h>

  20. #define OLED_RESET 4
  21. Adafruit_SSD1306 display(OLED_RESET);

  23. #if (SSD1306_LCDHEIGHT != 32)
  24. #error("Height incorrect, please fix Adafruit_SSD1306.h!");
  25. #endif

  27. void setup()   {
  28.   Serial.begin(9600);

  30.   // by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
  31.   display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3D (for the 128x64)
  32.   // init done

  34.   display.clearDisplay();

  36.   //英文字符顯示
  37.   display.setTextSize(1);             //設置字體大小
  38.   display.setTextColor(WHITE);        //設置字體顏色白色
  39.   display.setCursor(0, 0);            //設置字體的起始位置
  40.   display.println("Hello, world!");   //輸出字符并換行

  42.   display.setTextColor(BLACK, WHITE); //設置字體黑色，字體背景白色
  43.   display.println(3.141592);          //輸出數字并換行

  45.   display.setTextSize(2);             //設置字體大小
  46.   display.setTextColor(WHITE);        //設置字體白色
  47.   display.print("0x");                //輸出字符
  48.   display.println(0xDEADBEEF, HEX);   //輸出為ASCII編碼的十六進制
  49.   //display.display();                  //顯示以上
  50. }

  52. void loop() {

  54. }
復制代碼


作者: eagler8    時間: 2020-2-20 16:14

作者: eagler8    時間: 2020-2-21 08:59
I2C驅動的128x32 OLED
I2C (Inter-Integrated Circuit) 集成電路總線是I2CBus的簡稱，是一種串行通信總線，使用多主從架構。飛利浦公司在1980年代為了讓主板，嵌入式系統或手機用以連接低速周邊設備而發展。 I2C的正確讀法為"I-squared-C"。I2C只使用兩條雙向漏極開路(Open Drain): 串行數據SDA及串行時鐘頻率SCL總線，且利用上拉電阻將兩條總線的電位上拉。I2C允許相當大的工作電壓范圍，但典型的電壓準位為+3.3V或+5V. I2C的參考設計使用一個7bit長度的地址空間但保留了16個地址，所以在一組總線最多可和112個節點通信。

常見的I2C總線依傳輸速率的不同而有不同的模式: 標準模式100 Kbit/s，低速模式10 Kbit/s，但時鐘頻率可被允許下降至零，這代表可以暫停通信。而新一代的I2C總線可以和更多的節點(支持10比特長度的地址空間)以更快的速率通信: 快速模式400 Kbit/s，高速模式3.4 Mbit/s。在單片機中使用I2C通信協議的時候，需要編寫程序去模擬I2C總線的通信，對于I2C通信協議需要補充的一點是: 在實際通信傳輸數據時，SCL總線拉高的時間只要大于1.5μs都能夠正常傳輸數據。

這塊128x32 OLED的裸屏是由SSD1306驅動的，該芯片專為共陰極 OLED 面板設計，SSD1306 中嵌入了對比度控制器，顯示 RAM 和晶振，并因此減少了外部器件和功耗，有 256級亮度控制，數據/命令的發送有三種接口可選擇: 6800/8000串口、I2C接口或 SPI 接口。適用于多數簡單的應用，移動電話的屏顯, MP3播放器和計算器等。

SSD1306本身支持多種總線驅動方式包括SPI以及并口等，通過芯片的相應IO口拉低拉高來選擇哪一種接口。模塊通過電阻將相應IO口配置固化使用了I2C接口方式，但可能你買到的同樣的驅動芯片的模塊會采用其他接口。使用I2C接口時， SSD1306允許有最多兩個7位的I2C地址，同樣通過相應的IO口拉低拉高來切換， 一般默認是0x3C。在有些模塊(不是所有，有些PCB沒有預留)的背面，可以看到I2C地址選項提示，需要改變模塊I2C地址時只需要把提示位置的電阻取下焊接到另外一端即可。要注意的是版上的I2C地址是加上了第零位讀寫位后的數值。




作者: eagler8    時間: 2020-2-21 09:22
本帖最后由 eagler8 于 2020-2-21 09:25 編輯
  1. /*
  2.   【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.   實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.   安裝庫：IDE—工具—管理庫—搜索Adafruit_SSD1306—安裝
  5.   安裝庫：IDE—工具—管理庫—搜索Adafruit_GFX—安裝
  6.   實驗接線方法
  7.   oled模塊    Ardunio Uno
  8.   GND---------GND接地線
  9.   VCC---------5V 接電源
  10.   SDA---------A4
  11.   SCL ------- A5
  12.   實驗之四：輸出直線和文字以及文字滾動
  13. */

  15. #include <SPI.h>
  16. #include <Wire.h>
  17. #include <Adafruit_GFX.h>
  18. #include <Adafruit_SSD1306.h>

  20. #define OLED_RESET 4
  21. Adafruit_SSD1306 display(OLED_RESET);

  23. #if (SSD1306_LCDHEIGHT != 32)

  25. #endif

  27. void setup() {
  28.   Serial.begin(115200);

  30.   display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x32)
  31.   display.display();
  32.   delay(2000);
  33. }

  35. void loop() {
  36.   display.clearDisplay();
  37.   testdrawline();
  38.   delay(1000);

  40.   display.clearDisplay();
  41.   testdrawchar();
  42.   delay(1000);

  44.   display.clearDisplay();
  45.   testdrawchar2();
  46.   delay(2000);

  48.   display.clearDisplay();
  49.   testscrolltext();
  50.   delay(2000);
  51. }

  53. void testdrawline() {
  54.   for (int16_t i = 0; i < display.width(); i += 2) {
  55.     // x1 y1 x2 y2
  56.     display.drawLine(i, 0, i, display.height(), WHITE);
  57.     display.display();
  58.     delay(5);
  59.   }
  60.   delay(250);
  61.   display.clearDisplay();
  62.   for (int16_t i = 0; i < display.height(); i += 2) {
  63.     display.drawLine(0, i, display.width(), i, WHITE);
  64.     display.display();
  65.     delay(5);
  66.   }
  67. }

  69. void testdrawchar(void) {
  70.   display.setTextSize(1);
  71.   display.setTextColor(WHITE);
  72.   display.setCursor(0, 0);

  74.   for (uint8_t i = 0; i < 168; i++) {
  75.     if (i == '\n') continue;
  76.     display.write(i);
  77.     if ((i > 0) && (i % 21 == 0))
  78.       display.println();
  79.   }
  80.   display.display();
  81.   delay(1);
  82. }

  84. void testdrawchar2(void) {
  85.   display.setTextSize(2);
  86.   display.setTextColor(WHITE);

  88.   uint8_t j = 47;
  89.   for (uint8_t l = 0; l < 4; l++) {
  90.     display.setCursor(0, l * 16);
  91.     for (uint8_t i = 0; i < 10; i++) {
  92.       j++;
  93.       if (j == '\n') continue;
  94.       display.write(j);
  95.       display.display();
  96.       delay(5);
  97.     }
  98.   }
  99. }

  101. void testscrolltext(void) {
  102.   testdrawchar();
  103.   delay(5);
  104.   // startscrollright(uint8_t start, uint8_t stop)
  105.   // Activate a scroll to the right for rows start through stop The display is 16 rows tall. To scroll the whole display, run: display.scrollright(0x00, 0x0F)
  106.   // Parameters: start First row to scroll, stop  Last row to scroll
  107.   display.startscrollright(0x00, 0x02);
  108.   delay(1000);
  109.   display.startscrollright(0x03, 0x05);
  110.   delay(1000);
  111.   display.stopscroll();
  112.   delay(1000);
  113.   // Activate a scroll to the left for rows start through stop The display is 16 rows tall. To scroll the whole display, run: display.startscrollright(0x00, 0x0F)
  114.   display.startscrollleft(0x00, 0x05);
  115.   delay(2000);
  116.   display.startscrollleft(0x00, 0x0F);
  117.   delay(2000);
  118.   display.stopscroll();
  119.   delay(1000);
  120.   // Activate a scroll to the upper right for rows start through stop The display is 16 rows tall.
  121.   display.startscrolldiagright(0x00, 0x03);
  122.   delay(2000);
  123.   display.startscrolldiagright(0x00, 0x07);
  124.   delay(2000);
  125.   // Activate a scroll to the upper left for rows start through stop The display is 16 rows tall.
  126.   display.startscrolldiagleft(0x00, 0x03);
  127.   delay(2000);
  128.   display.startscrolldiagleft(0x00, 0x07);
  129.   delay(2000);
  130.   display.stopscroll();
  131. }
復制代碼

作者: eagler8    時間: 2020-2-21 09:40

作者: eagler8    時間: 2020-2-21 09:59
  1. /*
  2.   【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.   實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.   安裝庫：IDE—工具—管理庫—搜索Adafruit_SSD1306—安裝
  5.   安裝庫：IDE—工具—管理庫—搜索Adafruit_GFX—安裝
  6.   實驗接線方法
  7.   oled模塊    Ardunio Uno
  8.   GND---------GND接地線
  9.   VCC---------5V 接電源
  10.   SDA---------A4
  11.   SCL ------- A5
  12.   實驗之五：輸出輸出位圖(及漢字位圖)——實驗室
  13. */

  15. #include <SPI.h>
  16. #include <Wire.h>
  17. #include <Adafruit_GFX.h>
  18. #include <Adafruit_SSD1306.h>

  20. #define OLED_RESET 4
  21. Adafruit_SSD1306 display(OLED_RESET);

  23. #if (SSD1306_LCDHEIGHT != 32)
  24. #endif

  26. #define NUMFLAKES 5
  27. #define XPOS 0
  28. #define YPOS 1
  29. #define DELTAY 2
  30. #define LOGO16_GLCD_HEIGHT 16
  31. #define LOGO16_GLCD_WIDTH  16
  32. static const unsigned char PROGMEM logo16_glcd_bmp[] =
  33. { B00000000, B11000000,
  34.   B00000001, B11000000,
  35.   B00000001, B11000000,
  36.   B00000011, B11100000,
  37.   B11110011, B11100000,
  38.   B11111110, B11111000,
  39.   B01111110, B11111111,
  40.   B00110011, B10011111,
  41.   B00011111, B11111100,
  42.   B00001101, B01110000,
  43.   B00011011, B10100000,
  44.   B00111111, B11100000,
  45.   B00111111, B11110000,
  46.   B01111100, B11110000,
  47.   B01110000, B01110000,
  48.   B00000000, B00110000 };

  50. //中文：實  
  51. static const unsigned char PROGMEM str_1[] = {   
  52. 0x02,0x00,0x01,0x00,0x7F,0xFE,0x40,0x02,0x88,0x84,0x04,0x80,0x04,0x80,0x10,0x80,  
  53. 0x08,0x80,0x08,0x80,0xFF,0xFE,0x01,0x40,0x02,0x20,0x04,0x10,0x18,0x08,0x60,0x04  
  54. };

  56. //中文：驗  
  57. static const unsigned char PROGMEM str_2[] = {   
  58. 0x00,0x20,0xF8,0x20,0x08,0x50,0x48,0x50,0x48,0x88,0x49,0x04,0x4A,0xFA,0x7C,0x00,  
  59. 0x04,0x44,0x04,0x24,0x1D,0x24,0xE4,0xA8,0x44,0x88,0x04,0x10,0x2B,0xFE,0x10,0x00  
  60. };

  62. //中文：室  
  63. static const unsigned char PROGMEM str_3[] = {   
  64. 0x02,0x00,0x01,0x00,0x7F,0xFE,0x40,0x02,0x80,0x04,0x3F,0xF8,0x04,0x00,0x08,0x20,  
  65. 0x1F,0xF0,0x01,0x10,0x01,0x00,0x3F,0xF8,0x01,0x00,0x01,0x00,0xFF,0xFE,0x00,0x00  
  66. };

  68. void setup() {
  69.   Serial.begin(115200);

  71.   display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x64)
  72.   display.display();
  73.   delay(2000);
  74. }

  76. void loop() {
  77.   display.clearDisplay();
  78.   display.drawBitmap(30, 16,  logo16_glcd_bmp, 16, 16, WHITE);
  79.   display.display();
  80.   delay(2000);
  81.   display.drawBitmap(30, 16,  logo16_glcd_bmp, 16, 16, BLACK);
  82.   display.display();
  83.   delay(500);
  84.   display.drawBitmap(30, 16,  logo16_glcd_bmp, 16, 16, WHITE);
  85.   display.display();
  86.   delay(500);
  87.   display.clearDisplay();
  88.   display.drawBitmap(0, 0, str_1, 16, 16, WHITE);
  89.   display.drawBitmap(16, 0, str_2, 16, 16, WHITE);
  90.   display.drawBitmap(32, 0, str_3, 16, 16, WHITE);
  91.   display.display();
  92.   delay(2000);
  93.   display.clearDisplay();
  94.   testdrawbitmap(logo16_glcd_bmp, LOGO16_GLCD_HEIGHT, LOGO16_GLCD_WIDTH);
  95. }

  97. void testdrawbitmap(const uint8_t *bitmap, uint8_t w, uint8_t h) {
  98.   uint8_t icons[NUMFLAKES][3];

  100.   // initialize
  101.   for (uint8_t f=0; f< NUMFLAKES; f++) {
  102.     icons[f][XPOS] = random(display.width());
  103.     icons[f][YPOS] = 0;
  104.     icons[f][DELTAY] = random(8) + 2;
  105.    
  106.     Serial.print("x: ");
  107.     Serial.print(icons[f][XPOS], DEC);
  108.     Serial.print(" y: ");
  109.     Serial.print(icons[f][YPOS], DEC);
  110.     Serial.print(" dy: ");
  111.     Serial.println(icons[f][DELTAY], DEC);
  112.   }

  114.   while (1) {
  115.     // draw each icon
  116.     for (uint8_t f=0; f< NUMFLAKES; f++) {
  117.       display.drawBitmap(icons[f][XPOS], icons[f][YPOS], bitmap, w, h, WHITE);
  118.     }
  119.     display.display();
  120.     delay(200);
  121.    
  122.     // then erase it + move it
  123.     for (uint8_t f=0; f< NUMFLAKES; f++) {
  124.       display.drawBitmap(icons[f][XPOS], icons[f][YPOS], bitmap, w, h, BLACK);
  125.       // move it
  126.       icons[f][YPOS] += icons[f][DELTAY];
  127.       // if its gone, reinit
  128.       if (icons[f][YPOS] > display.height()) {
  129.         icons[f][XPOS] = random(display.width());
  130.         icons[f][YPOS] = 0;
  131.         icons[f][DELTAY] = random(8) + 2;
  132.       }
  133.     }
  134.    }
  135. }
復制代碼


作者: eagler8    時間: 2020-2-21 10:06

作者: eagler8    時間: 2020-2-21 11:51
  1. /*
  2.   【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.   實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.   實驗接線方法
  5.   oled模塊    Ardunio Uno
  6.   GND---------GND接地線
  7.   VCC---------5V 接電源
  8.   SDA---------A4
  9.   SCL ------- A5
  10.   實驗之八：查詢I2C地址（這里為0x3c）
  11. */

  13. #include <Wire.h>  
  14.    
  15. void setup(){  
  16.   Wire.begin();  
  17.   Serial.begin(9600);  
  18.   Serial.println("\nI2C Scanner");  
  19. }  
  20. void loop(){  
  21.   byte error, address;  
  22.   int nDevices;  
  23.   Serial.println("Scanning...");  
  24.   nDevices = 0;  
  25.   for (address = 1; address < 127; address++ ){  
  26.     // The i2c_scanner uses the return value of  
  27.     // the Write.endTransmisstion to see if  
  28.     // a device did acknowledge to the address.  
  29.     Wire.beginTransmission(address);  
  30.     error = Wire.endTransmission();  
  31.     if (error == 0){  
  32.       Serial.print("I2C device found at address 0x");  
  33.       if (address < 16)  
  34.         Serial.print("0");  
  35.       Serial.print(address, HEX);  
  36.       Serial.println(" !");  
  37.       nDevices++;  
  38.     }else if (error == 4){  
  39.       Serial.print("Unknow error at address 0x");  
  40.       if (address < 16)  
  41.         Serial.print("0");  
  42.       Serial.println(address, HEX);  
  43.     }  
  44.   }  
  45.   if (nDevices == 0)  
  46.     Serial.println("No I2C devices found\n");  
  47.   else  
  48.     Serial.println("done\n");  
  49.   delay(5000); // wait 5 seconds for next scan  
  50. }
復制代碼


作者: eagler8    時間: 2020-2-21 11:55
上傳到arduino板上，打開串口可查看地址



作者: eagler8    時間: 2020-2-21 12:45
  1. /*
  2.     【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.     實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.     安裝庫：IDE—工具—管理庫—搜索Adafruit_SSD1306—安裝
  5.     安裝庫：IDE—工具—管理庫—搜索Adafruit_GFX—安裝
  6.     實驗接線方法
  7.     oled模塊    Ardunio Uno
  8.     GND---------GND接地線
  9.     VCC---------5V 接電源
  10.     SDA---------A4
  11.     SCL ------- A5
  12.     實驗之九：綜合測試，顯示線段、圖形與英文字母數字
  13. */

  15. #include <Wire.h>
  16. #include <Adafruit_GFX.h>
  17. #include <Adafruit_SSD1306.h>

  19. #define OLED_RESET 4
  20. Adafruit_SSD1306 display(OLED_RESET);

  22. #define NUMFLAKES 10
  23. #define XPOS 0
  24. #define YPOS 1
  25. #define DELTAY 2

  27. #define LOGO16_GLCD_HEIGHT 16
  28. #define LOGO16_GLCD_WIDTH  16

  30. #if (SSD1306_LCDHEIGHT != 32)
  31. #error("Height incorrect, please fix Adafruit_SSD1306.h!");
  32. #endif

  34. void setup()        //初始化
  35. {
  36.   Serial.begin(9600);
  37.   delay(500);

  39.   // by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
  40.   display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x32) ，0x3C為I2C協議通訊地址，需根據實際情況更改
  41. }
  42. void loop()
  43. {
  44.   test_SSD1306();     //調用測試函數
  45. }

  47. void test_SSD1306(void)   //測試函數
  48. {
  49.   /*-----------------點亮全屏檢測屏幕是否有不正常點亮現象-----------------------------*/

  51.   display.fillScreen(WHITE);
  52.   display.display();
  53.   delay(2000);

  55.   /*------------------------------畫點 點坐標(64,16)-------------------------------*/
  56.   display.clearDisplay();   // clears the screen and buffer
  57.   display.drawPixel(64, 16, WHITE);
  58.   display.display();
  59.   delay(2000);

  61.   /*-------------------------- 畫線 從(0,0)到(128,32)----------------------------*/
  62.   display.clearDisplay();   // clears the screen and buffer
  63.   display.drawLine(0, 0, 128, 32, WHITE);
  64.   display.display();
  65.   delay(2000);
  66.   display.clearDisplay();   // clears the screen and buffer
  67.   display.drawLine(0, 32, 128, 0, WHITE);
  68.   display.display();
  69.   delay(2000);

  71.   /*--------------.畫空心矩形  左上角坐標(x0,y0)  右下角坐標(x1,y1)------------------*/
  72.   display.clearDisplay();   // clears the screen and buffer
  73.   display.drawRect(0, 0, 128, 32, WHITE);
  74.   display.display();
  75.   delay(2000);

  77.   /*-----------------------實心矩形---------------------------*/
  78.   display.clearDisplay();   // clears the screen and buffer
  79.   display.fillRect(0, 0, 128, 32, WHITE);
  80.   display.display();
  81.   delay(2000);

  83.   /*------------------------畫空心圓-------------------------*/
  84.   display.clearDisplay();   // clears the screen and buffer
  85.   display.drawCircle(64, 16, 13, WHITE);
  86.   display.display();
  87.   delay(2000);

  89.   /*----------------------畫實心圓---------------------------*/
  90.   display.clearDisplay();   // clears the screen and buffer
  91.   display.fillCircle(64, 16, 13, WHITE);
  92.   display.display();
  93.   delay(2000);

  95.   /*---------------------畫空心三角形-------------------------*/
  96.   display.clearDisplay();   // clears the screen and buffer
  97.   display.drawTriangle(32, 0, 0, 30, 128, 30, WHITE);
  98.   display.display();
  99.   delay(2000);

  101.   /*------------------------畫實心三角形-----------------------*/
  102.   display.clearDisplay();   // clears the screen and buffer
  103.   display.fillTriangle(32, 0, 0, 30, 128, 30, WHITE);
  104.   display.display();
  105.   delay(2000);

  107.   /*-----------------------空心圓角矩形------------------------*/
  108.   display.clearDisplay();   // clears the screen and buffer
  109.   display.drawRoundRect(0, 0, 128, 32, 5, WHITE);
  110.   display.display();
  111.   delay(2000);

  113.   /*----------------------畫實心圓角矩形-----------------------*/
  114.   display.clearDisplay();   // clears the screen and buffer
  115.   display.fillRoundRect(0, 0, 128, 32, 5, WHITE);
  116.   display.display();
  117.   delay(2000);

  119.   /*------------------------顯示英文 數字---------------------*/
  120.   display.clearDisplay();   // clears the screen and buffer
  121.   display.setTextSize(1); //選擇字號
  122.   display.setTextColor(WHITE);  //字體顏色
  123.   display.setCursor(0, 0);  //起點坐標
  124.   display.println("Hello, Arduino!");
  125.   display.setTextColor(BLACK, WHITE); // 'inverted' text
  126.   display.println(3.141592);
  127.   display.setTextSize(2);
  128.   display.setTextColor(WHITE);
  129.   display.print("0x"); display.println(0xDEADBEEF, HEX);
  130.   display.display();
  131.   delay(2000);
  132. }
復制代碼


作者: eagler8    時間: 2020-2-21 13:24
  1. /*
  2.     【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.     實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.     安裝庫：IDE—工具—管理庫—搜索U8g2lib—安裝
  5.    
  6.     實驗接線方法
  7.     oled模塊    Ardunio Uno
  8.     GND---------GND接地線
  9.     VCC---------5V 接電源
  10.     SDA---------A4
  11.     SCL ------- A5
  12.     實驗之十：綜合測試，顯示電子鐘
  13. */

  15. #include <Arduino.h>
  16. #include <U8g2lib.h>
  17. #include <Wire.h>

  19. //iic驅動方式
  20. U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);

  22. void setup(void) {
  23.   u8g2.begin();
  24. }

  26. uint8_t m = 24;

  28. void loop(void) {
  29.   char m_str[3];
  30.   strcpy(m_str, u8x8_u8toa(m, 2));    /* convert m to a string with two digits */
  31.   u8g2.firstPage();
  32.   do {
  33.     u8g2.setFont(u8g2_font_logisoso62_tn);
  34.     u8g2.drawStr(0, 63, "6");
  35.     u8g2.drawStr(33, 63, ":");
  36.     u8g2.drawStr(50, 63, m_str);
  37.   } while ( u8g2.nextPage() );
  38.   delay(1000);
  39.   m++;
  40.   if ( m == 60 )
  41.     m = 0;
  42. }
復制代碼


作者: eagler8    時間: 2020-2-21 13:31
相關函數
u8g2.begin()：U8g2構造函數。
u8g2.clean()：清除屏幕顯示，清除緩沖區，光標回到原點位置。
u8g2.setFont()：設置字體。
u8g2.drawStr()：繪制字符串。
u8g2.firstPage()/nextPage()：循環刷新顯示。

U8g2庫提供的API函數有很多，其他的介紹可以參考官方手冊。
（https://github.com/olikraus/u8g2/wiki/u8g2reference）

作者: eagler8    時間: 2020-2-21 13:37

作者: eagler8    時間: 2020-2-21 13:49
  1. /*
  2.     【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.     實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.     安裝庫：IDE—工具—管理庫—搜索Adafruit_SSD1306—安裝
  5.     安裝庫：IDE—工具—管理庫—搜索Adafruit_GFX—安裝
  6.     實驗接線方法
  7.     oled模塊    Ardunio Uno
  8.     GND---------GND接地線
  9.     VCC---------5V 接電源
  10.     SDA---------A4
  11.     SCL ------- A5
  12.     實驗之十一：綜合測試，中文顯示
  13. */

  15. #include <Wire.h>
  16. #include <Adafruit_GFX.h>
  17. #include <Adafruit_SSD1306.h>

  19. #define OLED_RESET     4
  20. Adafruit_SSD1306 display(128, 32, &Wire, OLED_RESET);

  22. //取16X16漢字字模 逐行式 順向高位在前
  23. static const unsigned char PROGMEM str1[] =
  24. {
  25.   0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x3F, 0xF8, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08,
  26.   0x21, 0x08, 0x21, 0x08, 0x3F, 0xF8, 0x21, 0x08, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00
  27. };/*"中",0*/

  29. static const unsigned char PROGMEM str2[] =
  30. {
  31.   0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0xFF, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x08, 0x20, 0x08, 0x20,
  32.   0x04, 0x40, 0x02, 0x80, 0x01, 0x00, 0x02, 0x80, 0x04, 0x40, 0x08, 0x20, 0x30, 0x18, 0xC0, 0x06
  33. };/*"文",1*/
  34. static const unsigned char PROGMEM str3[] =
  35. {
  36.   0x00, 0x00, 0x1F, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x1F, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x1F, 0xF0,
  37.   0x04, 0x40, 0x44, 0x44, 0x24, 0x44, 0x14, 0x48, 0x14, 0x50, 0x04, 0x40, 0xFF, 0xFE, 0x00, 0x00
  38. };/*"顯",2*/

  40. static const unsigned char PROGMEM str4[] =
  41. {
  42.   0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFE, 0x01, 0x00,
  43.   0x01, 0x00, 0x11, 0x10, 0x11, 0x08, 0x21, 0x04, 0x41, 0x02, 0x81, 0x02, 0x05, 0x00, 0x02, 0x00
  44. };/*"示",3*/

  46. void setup() {
  47.   display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  48.   display.setTextColor(WHITE);//開像素點發光
  49.   display.clearDisplay();//清屏

  51.   display.setTextSize(2); //設置字體大小
  52.   display.setCursor(0, 0);//設置顯示位置
  53.   display.println("-TonyCode-");//輸出字符

  55.   display.drawBitmap(32, 16, str1, 16, 16, 1); //畫出字符對應點陣數據
  56.   display.drawBitmap(48, 16, str2, 16, 16, 1); //畫出字符對應點陣數據
  57.   display.drawBitmap(64, 16, str3, 16, 16, 1); //畫出字符對應點陣數據
  58.   display.drawBitmap(80, 16, str4, 16, 16, 1); //畫出字符對應點陣數據
  59.   display.display();//開顯示

  61. }

  63. void loop() {

  65. }
復制代碼


作者: eagler8    時間: 2020-2-21 15:49

作者: eagler8    時間: 2020-2-22 08:21

作者: eagler8    時間: 2020-2-23 09:48
實驗之十二：滾動顯示字符“Hello World!”

  1. /*
  2.   【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.   實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.   安裝庫：FLOW庫
  5.   
  6.   實驗接線方法
  7.   oled模塊    Ardunio Uno
  8.   GND---------GND接地線
  9.   VCC---------5V 接電源
  10.   SDA---------A4
  11.   SCL ------- A5
  12.   實驗之十二：滾動顯示字符“Hello World!”
  13. */

  15. #include<FLOW.h>
  16. FLOW first;
  17. String s="Hello World!";
  18. void setup(){
  19.   first.Begin();
  20. }
  21. void loop(){
  22.   first.Now(16,6,s,1);
  23.   first.Clear(66);
  24. }
復制代碼



作者: eagler8    時間: 2020-2-23 10:01

作者: eagler8    時間: 2020-2-23 10:06
【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  安裝庫：IDE—工具—管理庫—搜索U8g2lib—安裝

  實驗接線方法
  oled模塊    Ardunio Uno
  GND---------GND接地線
  VCC---------5V 接電源
  SDA---------A4
  SCL ------- A5
  實驗之六：使用U8g2輸出中文（世界很大我想走走）
  （在Example里有PrintUTF8例子, 里面有中文輸出, 注意: 這個并非所有漢字都能輸出. 根據自己的硬件, 取消對應的注釋）

  1. /*
  2.   【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.   實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.   安裝庫：IDE—工具—管理庫—搜索U8g2lib—安裝
  5.   
  6.   實驗接線方法
  7.   oled模塊    Ardunio Uno
  8.   GND---------GND接地線
  9.   VCC---------5V 接電源
  10.   SDA---------A4
  11.   SCL ------- A5
  12.   實驗之六：使用U8g2輸出中文（世界很大我想走走）
  13.   （在Example里有PrintUTF8例子, 里面有中文輸出, 注意: 這個并非所有漢字都能輸出. 根據自己的硬件, 取消對應的注釋）
  14. */

  16. #include <Arduino.h>
  17. #include <U8g2lib.h>

  19. //#ifdef U8X8_HAVE_HW_SPI
  20. //#include <SPI.h>
  21. //#endif
  22. #ifdef U8X8_HAVE_HW_I2C
  23. #include <Wire.h>
  24. #endif

  26. /*
  27.   U8glib Example Overview:
  28.     Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
  29.     Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
  30.     U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
  31. */

  33. // Please UNCOMMENT one of the contructor lines below
  34. // U8g2 Contructor List (Frame Buffer)
  35. // The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
  36. // Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
  37. //U8G2_NULL u8g2(U8G2_R0);    // null device, a 8x8 pixel display which does nothing
  38. //U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  39. //U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);    // Arduboy (Production, Kickstarter Edition)
  40. //U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  41. //U8G2_SSD1306_128X64_NONAME_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
  42. //U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
  43. //U8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the "every 2nd line skipped" problem
  44. //U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
  45. //U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
  46. //U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
  47. //U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
  48. //U8G2_SSD1306_128X64_NONAME_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
  49. //U8G2_SSD1306_128X64_NONAME_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
  50. //U8G2_SSD1306_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);    // same as the NONAME variant, but maximizes setContrast() range
  51. //U8G2_SSD1306_128X64_ALT0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);    // same as the NONAME variant, but may solve the "every 2nd line skipped" problem
  52. //U8G2_SH1106_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  53. //U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
  54. //U8G2_SH1106_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);        // same as the NONAME variant, but maximizes setContrast() range
  55. //U8G2_SH1106_128X64_WINSTAR_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);        // same as the NONAME variant, but uses updated SH1106 init sequence
  56. //U8G2_SH1107_64X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  57. //U8G2_SH1107_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  58. //U8G2_SH1107_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
  59. //U8G2_SH1107_SEEED_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  60. //U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
  61. U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
  62. //U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
  63. //U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
  64. //U8G2_SSD1306_64X48_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
  65. //U8G2_SSD1306_64X32_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
  66. //U8G2_SSD1306_64X32_1F_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
  67. //U8G2_SSD1306_96X16_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69" OLED
  68. //U8G2_SSD1322_NHD_256X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);    // Enable U8G2_16BIT in u8g2.h
  69. //U8G2_SSD1322_NHD_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);    // Enable U8G2_16BIT in u8g2.h
  70. //U8G2_SSD1322_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  71. //U8G2_SSD1322_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  72. //U8G2_SSD1325_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  73. //U8G2_SSD1325_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  74. //U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
  75. //U8G2_SSD1327_SEEED_96X96_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);    // Seeedstudio Grove OLED 96x96
  76. //U8G2_SSD1327_SEEED_96X96_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);    // Seeedstudio Grove OLED 96x96
  77. //U8G2_SSD1327_MIDAS_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  78. //U8G2_SSD1327_MIDAS_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  79. //U8G2_SSD1329_128X96_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  80. //U8G2_SSD1329_128X96_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  81. //U8G2_SSD1305_128X32_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  82. //U8G2_SSD1305_128X32_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  83. //U8G2_SSD1309_128X64_NONAME0_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  84. //U8G2_SSD1309_128X64_NONAME0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  85. //U8G2_SSD1309_128X64_NONAME2_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  86. //U8G2_SSD1309_128X64_NONAME2_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  87. //U8G2_LD7032_60X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);    // SW SPI Nano Board
  88. //U8G2_LD7032_60X32_F_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);    // NOT TESTED!
  89. //U8G2_UC1701_EA_DOGS102_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  90. //U8G2_UC1701_EA_DOGS102_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  91. //U8G2_PCD8544_84X48_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Nokia 5110 Display
  92. //U8G2_PCD8544_84X48_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // Nokia 5110 Display
  93. //U8G2_PCF8812_96X65_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);    // Could be also PCF8814
  94. //U8G2_PCF8812_96X65_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);                        // Could be also PCF8814
  95. //U8G2_HX1230_96X68_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
  96. //U8G2_HX1230_96X68_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  97. //U8G2_KS0108_128X64_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE);     // Set R/W to low!
  98. //U8G2_KS0108_ERM19264_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE);     // Set R/W to low!
  99. //U8G2_ST7920_192X32_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
  100. //U8G2_ST7920_192X32_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
  101. //U8G2_ST7920_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);    // Remember to set R/W to 0
  102. //U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
  103. //U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
  104. //U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
  105. //U8G2_ST7565_EA_DOGM128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  106. //U8G2_ST7565_EA_DOGM128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  107. //U8G2_ST7565_64128N_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  108. //U8G2_ST7565_64128N_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  109. //U8G2_ST7565_EA_DOGM132_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);    // DOGM132 Shield
  110. //U8G2_ST7565_EA_DOGM132_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);    // DOGM132 Shield
  111. //U8G2_ST7565_ZOLEN_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  112. //U8G2_ST7565_ZOLEN_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  113. //U8G2_ST7565_LM6059_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);        // Adafruit ST7565 GLCD
  114. //U8G2_ST7565_LM6059_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);        // Adafruit ST7565 GLCD
  115. //U8G2_ST7565_ERC12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  116. //U8G2_ST7565_ERC12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  117. //U8G2_ST7565_NHD_C12832_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  118. //U8G2_ST7565_NHD_C12832_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  119. //U8G2_ST7565_NHD_C12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  120. //U8G2_ST7565_NHD_C12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  121. //U8G2_ST7567_PI_132X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
  122. //U8G2_ST7567_PI_132X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
  123. //U8G2_ST7567_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
  124. //U8G2_ST7567_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
  125. //U8G2_ST75256_JLX172104_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  126. //U8G2_ST75256_JLX172104_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  127. //U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);    // Enable U8g2 16 bit mode for this display
  128. //U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);        // Enable U8g2 16 bit mode for this display
  129. //U8G2_ST75256_JLX25664_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);    // Due, 2nd I2C, enable U8g2 16 bit mode for this display
  130. //U8G2_NT7534_TG12864R_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  131. //U8G2_NT7534_TG12864R_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  132. //U8G2_ST7588_JLX12864_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);
  133. //U8G2_ST7588_JLX12864_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
  134. //U8G2_IST3020_ERC19264_F_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
  135. //U8G2_IST3020_ERC19264_F_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
  136. //U8G2_IST3020_ERC19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  137. //U8G2_LC7981_160X80_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
  138. //U8G2_LC7981_160X160_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
  139. //U8G2_LC7981_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
  140. //U8G2_SED1520_122X32_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4);     // Set R/W to low!
  141. //U8G2_T6963_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
  142. //U8G2_T6963_256X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
  143. //U8G2_SED1330_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FG with GND
  144. //U8G2_SED1330_240X128_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // A0 is dc pin!
  145. //U8G2_RA8835_NHD_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
  146. //U8G2_RA8835_NHD_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
  147. //U8G2_UC1604_JLX19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  148. //U8G2_UC1604_JLX19264_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  149. //U8G2_UC1608_ERC24064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
  150. //U8G2_UC1608_ERC240120_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
  151. //U8G2_UC1608_240X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
  152. //U8G2_UC1610_EA_DOGXL160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
  153. //U8G2_UC1610_EA_DOGXL160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
  154. //U8G2_UC1611_EA_DOGM240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);    // Due, 2nd I2C, DOGM240 Test Board
  155. //U8G2_UC1611_EA_DOGM240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
  156. //U8G2_UC1611_EA_DOGXL240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);    // Due, 2nd I2C, DOGXL240 Test Board
  157. //U8G2_UC1611_EA_DOGXL240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
  158. //U8G2_UC1611_EW50850_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 16); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
  159. //U8G2_UC1638_160X128_F_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);      // Not tested
  160. //U8G2_SSD1606_172X72_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);        // eInk/ePaper Display
  161. //U8G2_SSD1607_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);    // eInk/ePaper Display, original LUT from embedded artists
  162. //U8G2_SSD1607_GD_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);    // Good Display
  163. //U8G2_IL3820_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);    // WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
  164. //U8G2_IL3820_V2_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);    // ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!

  166. // End of constructor list

  168. void setup(void) {
  169.   u8g2.begin();
  170.   u8g2.enableUTF8Print();        // enable UTF8 support for the Arduino print() function
  171. }

  173. void loop(void) {
  174.   u8g2.setFont(u8g2_font_unifont_t_chinese2);  // use chinese2 for all the glyphs of "你好世界"
  175.   u8g2.setFontDirection(0);
  176.   u8g2.clearBuffer();
  177.   u8g2.setCursor(0, 15);
  178.   u8g2.print("Hello World!");
  179.   u8g2.setCursor(0, 30);
  180.   u8g2.print("世界很大我想走走");   
  181.   u8g2.sendBuffer();

  183.   delay(1000);
  184. }
復制代碼




作者: eagler8    時間: 2020-2-23 10:08

作者: eagler8    時間: 2020-2-23 10:11
實驗之七：使用U8g2輸出中文（一心一意打擊病毒）

  1. /*
  2.   【Arduino】168種傳感器模塊系列實驗（資料 +代碼 +圖形 +仿真）
  3.   實驗一百四十四：0.91寸OLED液晶屏顯示模塊 IIC
  4.   安裝庫：IDE—工具—管理庫—搜索U8g2lib—安裝

  6.   實驗接線方法
  7.   oled模塊    Ardunio Uno
  8.   GND---------GND接地線
  9.   VCC---------5V 接電源
  10.   SDA---------A4
  11.   SCL ------- A5
  12.   實驗之七：使用U8g2輸出中文（一心一意打擊病毒）
  13. */

  15. #include <Arduino.h>
  16. #include <U8g2lib.h>

  18. #ifdef U8X8_HAVE_HW_I2C
  19. #include <Wire.h>
  20. #endif

  22. U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
  23. //SSD1306_128X32 I2C接口

  25. void setup(void) {
  26.   u8g2.begin();
  27.   u8g2.enableUTF8Print();
  28.   // 為Arduino print（）函數啟用UTF8支持
  29. }

  31. void loop(void) {
  32.   u8g2.clearBuffer();  // 清除緩存
  33.   u8g2.setFont(u8g2_font_victoriabold8_8r);// 設置字母字體
  34.   u8g2.drawStr(0, 7, "I"); // 顯示“I”
  35.   u8g2.setFont(u8g2_font_open_iconic_human_1x_t); // 設置心形字體
  36.   u8g2.drawGlyph(8, 7, 66); // 畫心
  37.   u8g2.drawGlyph(16, 7, 66); // 畫心
  38.   u8g2.setFont(u8g2_font_victoriabold8_8r);// 設置字母字體
  39.   u8g2.drawStr(24, 7, "U"); // 顯示“U”
  40.   u8g2.sendBuffer();          // 顯示內容
  41.   delay(1000);


  44.   u8g2.setFont(u8g2_font_unifont_t_chinese2);
  45.   // 對“一心一意打擊病毒”的所有字形使用chinese2
  46.   u8g2.setFontDirection(0);
  47.   u8g2.clearBuffer();
  48.   u8g2.setCursor(0, 15);
  49.   u8g2.print("Attack virus");
  50.   u8g2.setCursor(0, 30);
  51.   u8g2.print("一心一意打擊病毒");
  52.   u8g2.sendBuffer();
  53.   delay(1000);
  54. }
復制代碼



作者: eagler8    時間: 2020-2-23 10:19

作者: eagler8    時間: 2020-2-23 12:36
本實驗案例中，通過程序之二enroll，注冊了“huadaio”的二個指紋1#和3號，注冊了“zhanghaoze”一個指紋2#。識別指紋ID后，在串口顯示匹配的信心值，在OLED屏顯示匹配的招呼語。

Found fingerprint sensor!
找到指紋傳感器！




作者: eagler8    時間: 2020-2-23 12:46
OLED顯示

Waiting fingerprint
等待指紋



作者: eagler8    時間: 2020-2-23 12:52
串口顯示識別的三個指紋ID



作者: eagler8    時間: 2020-2-23 13:05
OLED屏顯示識別1#指紋“huadaio”



作者: eagler8    時間: 2020-2-23 13:10
OLED屏顯示識別2#指紋“zhanghaoze”



作者: 以后能提供    時間: 2020-2-23 18:44
樓主太棒了！ 給我們帶來那么多參考 市面上有很多的教程都是互相抄來抄去 或者都是些比較簡單基本的 之前我一直想找的oled教程都沒找到0.91寸 非常感謝樓主
作者: eagler8    時間: 2020-2-24 18:56
以后能提供 發表于 2020-2-23 18:44
樓主太棒了！ 給我們帶來那么多參考 市面上有很多的教程都是互相抄來抄去 或者都是些比較簡單基本的  ...

謝謝鼓勵，多交流
作者: by64214    時間: 2020-3-4 22:18
謝謝樓主分享     I2C學習
         采用 Adafruit_SSD1306.h   display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  可以點亮
                采用  U8g2lib.h  不知需要那里修改  自帶例程 也無法點亮   尋求幫助！！！
作者: eagler8    時間: 2020-3-5 11:48
by64214 發表于 2020-3-4 22:18
謝謝樓主分享     I2C學習
         采用 Adafruit_SSD1306.h   display.begin(SSD1306_SWITCHCAPVCC, 0x3 ...

試試這個前面的程序

實驗之二：自動計數器
作者: zxy1004211072    時間: 2020-4-18 14:06
#error ("Height incorrect, please fix Adafruit_SSD1306.h!");
一直顯示這個錯誤
作者: zxy1004211072    時間: 2020-4-18 15:01
C:\Users\Administrator\Documents\Arduino\libraries\Adafruit_SSD1306-master/Adafruit_SSD1306.h:40:17: fatal error: SPI.h: No such file or directory
請問樓主這個錯誤是什么意思呀
作者: eagler8    時間: 2020-10-24 15:51
zxy1004211072 發表于 2020-4-18 15:01
C:\Users\Administrator\Documents\Arduino\libraries\Adafruit_SSD1306-master/Adafruit_SSD1306.h:40:17: ...

應該是沒有安裝庫，Adafruit_SSD1306.h
作者: niuquanwang    時間: 2021-1-14 14:28
#include <Adafruit_SSD1306.h>樓主您好，怎么清除屏幕某一塊區域的顯示的東西呢？（不是全部清屏）謝謝
作者: 大漠游民    時間: 2021-3-8 17:41
不錯的資料，值得學習。
作者: 1113額    時間: 2021-11-27 12:17
給樓主頂起
作者: TT學弟    時間: 2021-11-27 18:42
其實這個東西很簡單的，你可以做一些按鍵在這個上面，可以控制其他東西



歡迎光臨 (http://www.raoushi.com/bbs/) Powered by Discuz! X3.1