Vui vẻ với màn hình OLED và Arduino: 12 bước (có hình ảnh)

2024 Tác giả: John Day | [email protected]. Sửa đổi lần cuối: 2024-01-30 13:31

Tôi khá chắc rằng bạn chắc chắn đã nghe nói về công nghệ màn hình OLED. Nó tương đối mới và cung cấp chất lượng tốt hơn so với công nghệ LCD cũ. Trong hướng dẫn này, chúng tôi muốn xem xét các bước cần thiết để hiển thị dữ liệu trên một trong những mô-đun màn hình OLED một màu phổ biến nhất hiện có trên thị trường. Tôi sẽ cố gắng giải thích các chức năng được cung cấp bởi thư viện Adafruit tương ứng để hiển thị dữ liệu trên mô-đun này.

Bước 1: Chúng ta sẽ sử dụng mô-đun OLED nào?

Mô-đun OLED có nhiều kích thước và tính năng khác nhau. Mô-đun chúng tôi sẽ sử dụng trong hướng dẫn này là mô-đun OLED 128x64 màu đơn sắc. Loại mô-đun này có sẵn với các kích thước sau (Để bạn thấy trên hình ảnh):

• 128x64
• 128x32
• 96x16
• 64x48
• 64x32

Vì tất cả các mô-đun này đều hỗ trợ giao thức I2C như một phương tiện để giao tiếp, nên mã và hệ thống dây của tất cả chúng đều hoàn toàn giống nhau. Sự khác biệt duy nhất là bạn phải xem xét kích thước của màn hình hiển thị trên mã của mình để nội dung bạn sắp hiển thị nằm vừa vặn trên đó.

Bước 2: I2C trong Nutshell

Mạch tích hợp liên kết (IIC) thường được gọi là I2C (I bình phương C) do Philips phát triển vào những năm 80 như một bus trao đổi dữ liệu được sử dụng để truyền dữ liệu giữa bộ xử lý trung tâm (CPU) hoặc bộ vi điều khiển (MCU) của một thiết bị và chip ngoại vi. Về cơ bản, nó đã được nhắm mục tiêu cho ứng dụng TV. Do tính đơn giản của nó, nó đã trở nên phổ biến đến nỗi sau một thời gian, nó trở thành một trong những cơ chế truyền dữ liệu chính cho CPU và MCU và các thiết bị ngoại vi không cần thiết trong cùng một bảng mạch PCB và được kết nối với nó qua dây (ví dụ như cảm biến, mô-đun hiển thị, v.v.).

I2C bao gồm một bus truyền thông được làm bằng hai dây hỗ trợ truyền dữ liệu hai chiều giữa một thiết bị chính và một số thiết bị phụ. Thông thường, nút chính phụ trách điều khiển bus - thực sự được thực hiện bằng cách tạo ra tín hiệu đồng bộ hóa trên đường đồng hồ nối tiếp (SCL). Đó là một tín hiệu sẽ được gửi liên tục bởi chính trong quá trình truyền và tất cả các nút khác được kết nối với xe buýt sẽ sử dụng tín hiệu đó để đồng bộ hóa giao tiếp của chúng và phát hiện tốc độ của xe buýt. Dữ liệu được chuyển giữa chủ và tớ thông qua một đường dữ liệu nối tiếp (SDA). Tốc độ truyền có thể lên đến 3,4 Mbps. Tất cả các thiết bị muốn truyền dữ liệu qua I2C phải có một địa chỉ duy nhất và có thể hoạt động như một máy phát hoặc máy thu tùy thuộc vào chức năng của thiết bị. Ví dụ, một mô-đun màn hình OLED là một bộ thu nhận một số dữ liệu và hiển thị chúng, trong khi cảm biến nhiệt độ là một bộ thu phát gửi nhiệt độ thu được qua bus I2C. Thông thường thiết bị chủ là thiết bị bắt đầu truyền dữ liệu trên bus và tạo ra các tín hiệu đồng hồ để cho phép truyền. Trong quá trình chuyển giao đó, bất kỳ thiết bị nào được định địa chỉ bởi chính này đều được coi là thiết bị phụ và đọc dữ liệu đó.

Khi một nút muốn gửi một số dữ liệu, byte đầu tiên của dữ liệu phải là địa chỉ của người nhận và sau đó là dữ liệu thực tế. Điều này có nghĩa là để gửi dữ liệu đến thiết bị đầu ra bằng I2C (ví dụ: mô-đun màn hình OLED I2C), trước tiên chúng ta phải tìm địa chỉ I2C của nó và đây là những gì chúng ta sẽ làm trước tiên trong các bước tiếp theo.

Nếu bạn quan tâm để biết thêm về các chi tiết và lý thuyết về I2C bus, bạn có thể sử dụng các tài liệu tham khảo sau:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Bước 3: Mô-đun và thành phần bắt buộc

Tại đây, bạn có thể tìm thấy danh sách các thành phần mà bạn cần để hoàn thành hướng dẫn này:

Liên kết eBay:

• 1 x Arduino Uno:
• 1 x mô-đun OLED 128x64:
• 4 x cáp Dupont:
• 1 x breadboard không hàn mini:

Liên kết Amazon.com:

• 1 x Arduino Uno:
• 1 x mô-đun OLED 128x64:
• 4 x cáp Dupont:
• 1 x breadboard không hàn mini:

Bước 4: Kết nối Mô-đun màn hình OLED với Arduino

Một lưu ý quan trọng về các thiết bị hỗ trợ I2C là cách bạn nên kết nối chúng với Arduino đều giống nhau. Điều này là do Arduino chỉ chạy giao tiếp I2C của nó trên các chân cụ thể. Trong hướng dẫn này, tôi đang sử dụng Arduino Uno. Arduino Uno sử dụng chân A5 làm SCK và A4 làm SDA. Vì vậy, chúng tôi có thể kết nối mô-đun màn hình OLED với Arduino Uno như được hiển thị trong chế độ xem giản đồ. Như bạn có thể nhận thấy trong hình ảnh tôi đã chụp từ mô-đun màn hình OLED của mình, đầu nối cho VCC và GND khác với chế độ xem giản đồ. Hãy nhớ kiểm tra nhãn của các chân trên mô-đun của bạn để đảm bảo bạn đang kết nối đúng cách.

Chúng tôi chỉ cần 4 chân nên được kết nối như sau:

Arduino VCC -> Mô-đun OLED VCC

Arduino GND -> Mô-đun OLED GND

Arduino 4 -> Mô-đun OLED SDA

Arduino 5 -> Mô-đun OLED SCK

Bước 5: Tìm địa chỉ của mô-đun hiển thị

Bước đầu tiên khi kết nối với thiết bị hỗ trợ I2C, bạn cần có địa chỉ của mô-đun. Để làm như vậy, sau khi kết nối mô-đun với Arduino của bạn, bạn chỉ cần tải mã được đính kèm lên Arduino của bạn. Mã này kết hợp thư viện Wire là thư viện được bao gồm trong Arduino IDE xử lý giao tiếp I2C. Nó cố gắng quét các thiết bị I2C được kết nối và gửi địa chỉ của chúng qua cổng nối tiếp đến máy tính của bạn. Vì vậy, bạn có thể truy cập đầu ra của nó thông qua công cụ Serial Monitor trong Arduino IDE. Phiên bản gốc có sẵn tại Arduino Playground). Ngoài ra, bạn có thể xem nó theo cách dễ đọc hơn trong Trình chỉnh sửa Arduino trực tuyến của tôi. Đừng mong đợi bất cứ điều gì được hiển thị trên màn hình trong khi mã này đang chạy.

Như bạn có thể thấy trên hình, mô-đun của tôi được liên kết với địa chỉ 0x3C. Thông thường, tất cả các thiết bị trong một dòng sản phẩm cụ thể (ví dụ: tất cả các mô-đun OLED 128x64) đều có cùng một địa chỉ.

Địa chỉ của thiết bị I2C được giới hạn từ 1 đến 126. Mã này chỉ cần cố gắng kết nối với từng thiết bị theo thứ tự (mà không truyền bất kỳ dữ liệu nào) và sau đó kiểm tra xem có bất kỳ lỗi nào được thư viện cơ sở báo cáo khi kết nối với địa chỉ được cung cấp hay không. Nếu không có lỗi, sau đó in địa chỉ dưới dạng một mô-đun khả dụng để kết nối. Ngoài ra, cần lưu ý rằng 15 địa chỉ đầu tiên đã được đặt trước, vì vậy nó sẽ nhảy qua chúng và chỉ in những địa chỉ trên phạm vi này. Hãy nhớ rằng địa chỉ của các mô-đun I2C này được mã hóa cứng trên thiết bị và nó không thể thay đổi được. Vì vậy, bạn nên viết nó ra đâu đó hoặc dán nhãn lên mô-đun khi bạn định đặt nó trở lại giá phòng thí nghiệm của mình để lần sau, việc chạy mã máy quét sẽ không cần thiết. Tuy nhiên, đó không phải là một thủ tục phức tạp;)

Bước 6: Cài đặt các thư viện cần thiết để hiển thị dữ liệu trên mô-đun OLED

Thư viện Wire có thể xử lý giao tiếp mức thấp với các thiết bị I2C. Khi bạn muốn kết nối với một thiết bị cụ thể để đọc / ghi dữ liệu từ / vào thiết bị đó, thông thường bạn sẽ sử dụng thư viện do công ty đã xây dựng mô-đun đó ban đầu cung cấp. Thư viện này xử lý tất cả các chi tiết giao tiếp I2C với mô-đun nhất định và cho phép chúng tôi tập trung hơn vào công việc kinh doanh của mình, trong trường hợp này là hiển thị dữ liệu theo cách chúng tôi muốn.

Adafruit, công ty sản xuất phiên bản gốc của các mô-đun màn hình như vậy, cung cấp một thư viện có tên Adafruit SSD1306 để hiển thị dữ liệu trên các màn hình đơn sắc này. Vì vậy, trước khi bắt đầu viết mã, chúng tôi phải cài đặt thư viện này qua Trình quản lý thư viện (có thể truy cập qua menu Sketch> Bao gồm Thư viện> Quản lý Thư viện…) trong Arduino IDE. Ngoài ra còn có một thư viện khác được gọi là Adafruit GFX Library xử lý nhiều nội dung đồ họa cấp thấp hơn và được Adafruit SSD1306 sử dụng nội bộ. Bạn cần phải cài đặt cả hai thứ trên Arduino IDE của mình như bạn có thể thấy trên hình.

Bước 7: Khởi tạo mô-đun hiển thị

Mô-đun vẽ trên màn hình được bao bọc trong một lớp có tên Adafruit_SSD1306. Định nghĩa của lớp này nằm trên thư viện Adafruit, vì vậy trước tiên chúng ta cần đưa vào thư viện đó. Sau đó, chúng ta phải khởi tạo một thể hiện của lớp này trước tiên. Hàm tạo của lớp này lấy số cổng mà tại đó màn hình có thể được đặt lại, đó là chân 4 (được kết nối với SCK). Phần mã này nên được đặt ở đầu tệp (ngoài các hàm setup () và loop ()).

#bao gồm

Màn hình Adafruit_SSD1306 (4);

Bây giờ bên trong hàm setup (), chúng ta nên gọi hàm bắt đầu của đối tượng hiển thị bằng cách chuyển địa chỉ I2C của chúng ta như bên dưới (SSD1306_SWITCHCAPVCC là một giá trị không đổi chỉ định loại nguồn điện cho thư viện):

void setup () {

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.display (); } void loop () {} // hiện tại có thể để trống vòng lặp

Bây giờ đối tượng hiển thị đã sẵn sàng và chúng ta có thể gọi các hàm của nó (ví dụ: display.write (), display.drawLine, v.v.). Lưu ý quan trọng là bất cứ khi nào chúng ta vẽ thứ gì đó bằng cách gọi đối tượng hiển thị của mình, chúng ta cần gọi hàm display.display () để làm cho bản vẽ thực sự diễn ra ở cấp độ phần cứng. Điều này chủ yếu là do các chức năng vẽ mà chúng ta gọi, chỉ cần cập nhật biểu diễn "trong bộ nhớ" của màn hình vì lý do hiệu suất. Nó thực sự lưu trữ những thay đổi trong bộ nhớ. Vì vậy, chúng ta nên nhớ gọi hàm display () khi chúng ta vẽ xong một thứ gì đó trên màn hình.

display.write (…); // tiếp tục cập nhật trong bộ nhớ

display.drawLine (…); // tiếp tục cập nhật trong bộ nhớ. display.display (); // xóa tất cả các thay đổi đối với phần cứng hiển thị

Nếu bạn cố gắng tải lên mã của mình trong bước này, bạn sẽ nhận thấy rằng logo của Adafruit Industries sẽ được hiển thị. Bạn có thể tự hỏi ai đã yêu cầu nó vẽ điều đó! Trên thực tế, đây là những gì thư viện Adafruit làm. Nó khởi tạo bộ nhớ của mô-đun (đại diện trong bộ nhớ của phần cứng màn hình) với logo của công ty này. Nếu bạn không muốn thấy điều đó trong quá trình khởi tạo, bạn có thể thử gọi hàm display.clearDisplay () ngay trước khi gọi hàm display.display () trong hàm thiết lập của mình. Chức năng này, như tên gọi của nó, sẽ xóa hoàn toàn màn hình.

#bao gồm

Màn hình Adafruit_SSD1306 (4); void setup () {display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.display (); } void loop () {}

Dựa trên tài liệu của thư viện Adafruit_SSD1306, bạn có thể sử dụng các hàm khác nhau do lớp này cung cấp để vẽ trên màn hình hoặc thao tác trực tiếp với các pixel trên đó. Trong các phần tiếp theo, chúng tôi sẽ cố gắng trình bày một ví dụ cho mỗi một trong số chúng để bạn có thể có ý tưởng về cách hoạt động của nó. Hầu hết các ví dụ này sẽ chỉ hiển thị một nội dung tĩnh đơn giản, vì vậy chúng ta có thể đặt chúng vào bên trong hàm setup () (sau mã khởi tạo). Bằng cách đó, nó sẽ chỉ được chạy một lần và vẫn ở đó.

Bước 8: Hiển thị một văn bản đơn giản

Để hiển thị một văn bản, chúng ta có thể sử dụng hàm display.println () đơn giản của thư viện. Nó chấp nhận văn bản dưới dạng một chuỗi và cố gắng hiển thị nó. Điều quan trọng cần biết là chúng ta phải thông báo cho thư viện biết nơi chúng ta sẽ trình bày văn bản trên màn hình. Mỗi pixel trên màn hình có một tọa độ được chỉ định bằng X và Y. X tăng từ trái sang phải và Y tăng từ trên xuống dưới. Góc trên bên trái của màn hình là (X = 0, Y = 0) và góc dưới bên phải là (X = 127, Y = 63). Tôi ghi chú tọa độ của các góc trên hình đầu tiên. Chúng ta có thể sử dụng hàm display.setCursor () để chỉ định nơi chúng ta sẽ hiển thị văn bản trên màn hình.

Một thuộc tính khác của văn bản là màu sắc của nó. Chúng ta có thể chỉ định màu bằng cách sử dụng display.setTextColor () như được hiển thị trên mẫu sau.

display.clearDisplay ();

display.setTextColor (TRẮNG); display.setCursor (35, 30); display.println ("Xin chào Thế giới!"); display.display ();

Chúng ta cũng có thể sử dụng hàm display.write () để hiển thị một ký tự. Nó chấp nhận một mã ký tự là kiểu uint8_t và hiển thị ký tự tương ứng với mã đó trên chuỗi. Ví dụ: nếu chúng ta muốn hiển thị cùng một chuỗi bằng cách sử dụng hàm này, chúng ta có thể sử dụng đoạn mã sau:

display.clearDisplay ();

display.setTextColor (TRẮNG); display.setCursor (35, 30); display.write (72); display.write (101); display.write (108); display.write (108); display.write (111); display.write (32); display.write (87); display.write (111); display.write (114); display.write (108); display.write (100); display.write (33); display.display ();

Cũng có thể vẽ văn bản bằng màu đen với nền trắng. Để làm như vậy, bạn phải gọi hàm display.setTextColor như sau:

display.clearDisplay ();

// Đặt màu thành đen với nền trắng display.setTextColor (BLACK, WHITE); display.setCursor (25, 30); display.println ("Văn bản bị đảo ngược!"); display.display ();

Bạn cũng có tùy chọn đặt kích thước của văn bản bằng cách sử dụng hàm display.setTextSize (). Nó chấp nhận một số nguyên làm kích thước. Số càng lớn, văn bản sẽ càng lớn. Kích thước nhỏ nhất là 1 là kích thước mặc định của văn bản. Đoạn mã sau cố gắng viết chữ "A" ở 6 kích thước khác nhau:

display.clearDisplay ();

display.setTextColor (TRẮNG); display.setCursor (0, 0); display.setTextSize (1); display.print ("A"); display.setTextSize (2); display.print ("A"); display.setTextSize (3); display.print ("A"); display.setTextSize (4); display.print ("A"); display.setTextSize (5); display.print ("A"); display.setTextSize (6); display.print ("A"); display.display ();

Bước 9: Vẽ các hình dạng cơ bản

Vẽ các hình dạng cơ bản như hình chữ nhật, hình tròn, hình tam giác, đường thẳng hoặc điểm rất dễ dàng và có một chức năng dành riêng cho từng hình dạng.

Vẽ đường

Để vẽ một đường thẳng, bạn có thể gọi display.drawLine (startX, startY, endX, endY, color). Ví dụ: mã sau đây vẽ một đường chéo trên màn hình để chúng tạo thành hình chữ X lớn:

display.clearDisplay ();

display.drawLine (0, 0, display.width () - 1, display.height () - 1, WHITE); display.drawLine (display.width () - 1, 0, 0, display.height () - 1, WHITE); display.display ();

Bạn có thể truy cập chiều rộng và chiều cao của màn hình bằng các hàm display.width () và display.height (). Làm như vậy mã của bạn sẽ độc lập với kích thước màn hình.

Vẽ hình chữ nhật

Hàm để vẽ hình chữ nhật là display.drawRect (upperLeftX, upperLeftY, width, height, color). Đây là đoạn mã vẽ ba hình chữ nhật trên một số vị trí ngẫu nhiên:

display.clearDisplay ();

display.drawRect (100, 10, 20, 20, WHITE); display.fillRect (10, 10, 45, 15, WHITE); display.drawRoundRect (60, 20, 35, 35, 8, WHITE); display.display ();

Bằng cách gọi display.fillRect (upperLeftX, upperLeftY, width, height, WHITE), bạn có thể vẽ một hình chữ nhật được tô bằng màu đã chỉ định. Ngoài ra, hàm thứ ba trong ví dụ này là display.drawRoundRect (upperLeftX, upperLeftY, width, height, angleRadius, color) mà bạn có thể thấy trong hình được sử dụng để vẽ một hình chữ nhật với các góc tròn. Nó chấp nhận một tham số phụ trước màu là một số nguyên cho biết bán kính góc. Giá trị càng lớn thì góc càng tròn. Nó cũng có một chức năng điền tương ứng có tên là display.drawFillRoundRect mà tôi nghĩ bạn có thể đoán nó làm gì.

Vẽ vòng tròn

Chức năng là display.drawCircle (centerX, centerY, bán kính, màu sắc). Đây là một ví dụ vẽ một hình giống như mặt cười:

display.drawCircle (60, 30, 30, WHITE);

display.fillCircle (50, 20, 5, WHITE); display.fillCircle (70, 20, 5, TRẮNG);

Giống như hình chữ nhật, bạn có thể sử dụng hàm display.fillCircle để vẽ một hình tròn với màu đã cho.

Vẽ tam giác

À, lại là một hàm có tên display.drawTriangle (poin1X, point1Y, point2X, point2Y, point3X, point3Y, color) và display.fillTriangle tương ứng vẽ một tam giác đầy.

display.drawTriangle (24, 1, 3, 55, 45, 55, TRẮNG);

display.fillTriangle (104, 62, 125, 9, 83, 9, TRẮNG);

Vẽ một điểm

Bạn cũng có thể tô màu một điểm cụ thể (được gọi là pixel) trên màn hình thông qua chức năng display.drawPixel (pixelX, pixelY, color).

display.drawPixel (20, 35, WHITE);

display.drawPixel (45, 12, WHITE); display.drawPixel (120, 59, WHITE); display.drawPixel (97, 20, WHITE); display.drawPixel (35, 36, WHITE); display.drawPixel (72, 19, WHITE); display.drawPixel (90, 7, WHITE); display.drawPixel (11, 29, WHITE); display.drawPixel (57, 42, WHITE); display.drawPixel (69, 34, WHITE); display.drawPixel (108, 12, WHITE);

Bước 10: Vẽ hình ảnh

Vẽ một hình ảnh là khác nhau và một chút phức tạp. Vì mô-đun hiển thị là màu đơn sắc, trước tiên chúng ta cần chuyển đổi hình ảnh của mình sang định dạng được gọi là bitmap đơn màu (còn được gọi là đen trắng). Ở định dạng như vậy, mỗi pixel của hình ảnh được hiển thị bằng 0 hoặc 1. Các số 1 thể hiện sự tồn tại của màu sắc và các số 0 có nghĩa là một không gian trống. Bạn có thể xem ví dụ về biểu trưng Arduino ở định dạng này ở đầu phần này. Hàm để vẽ ảnh bitmap là display.drawBitmap (topLeftX, topLeftY, imageData, width, height, color). Tham số imageData là một mảng các số tính bằng byte. Mỗi byte có 8 bit, vì vậy mỗi byte chứa dữ liệu của 8 pixel của hình ảnh. Bằng cách chỉ định chiều rộng và chiều cao của hình ảnh, hàm drawBitmap sẽ biết hàng pixel tiếp theo bắt đầu từ bit nào.

Giải pháp mà tôi đã chọn để chuyển đổi hình ảnh của mình sang định dạng này là trước tiên sử dụng một trong những "trình chuyển đổi hình ảnh sang ASCII" trực tuyến (ví dụ: https://my.asciiart.club) để chuyển đổi hình ảnh của tôi thành một tập hợp các ký tự ASCII và sau đó thay thế các ký tự được sử dụng cho không gian trống bằng 0 và các ký tự khác bằng 1. Đó là những gì bạn thấy bên dưới. Bạn có thể coi mỗi 0 và 1 là một pixel trên màn hình. Vì vậy, kích thước của hình ảnh không được vượt quá kích thước hiển thị của chúng tôi là 128x64.

Lưu ý: Sử dụng kỹ thuật ASCII này không phải là cách tiếp cận được khuyến khích vì do tỷ lệ khung hình của các ký tự, hình ảnh của bạn sẽ bị biến dạng (các ký tự không phải là một hình vuông). Tôi đã thử kỹ thuật này chỉ vì nó giúp chuyển đổi hình ảnh sang định dạng cần thiết dễ dàng hơn. Nếu không, có thể đạt được kết quả tốt nhất thông qua một số lập trình hoặc sử dụng một số ứng dụng tiện ích hoàn toàn nằm ngoài phạm vi của văn bản này.

00000000000000000000011111111111111111111110000000000000000000000000000000000000011111111111111111111111111111100000000000000000 0000000000000111111111111111111111111111111111111110000000000000 0000000000011111111111111111111111111111111111111111100000000000 0000000001111111111111111111111111111111111111111111111000000000 0000000111111111111111111111111111111111111111111111111110000000 0000011111111111111111111111111111111111111111111111111111100000 0000111111111111111111111111111111111111111111111111111111110000 0001111111111111111111111111111111111111111111111111111111111000 0011111111111111111111111111111111111111111111111111111111111100 0111111111111111000000011111111111111111100000001111111111111110 0111111111110000000000000001111111111000000000000000111111111110 1111111111000000001111000000001111000000001111000000001111111111 1111111110000011111111111100000110000011111111111100000111111111 1111111100000111111111111111000000001111111001111110000011111111 1111111100001111100000011111100000011111100000011111000011111111 1111111100001111100000011111100000011111100000011111000011111111 1111111100000111111111111111000000001111111001111110000011111111 1111111110000011111111111100000110000011111111111100000111111111 1111111111000000001111000000001111000000001111100000001111111111 0111111111110000000000000000111111110000000000000000111111111110 0111111111111111000000001111111111111111000000001111111111111110 0011111111111111111111111111111111111111111111111111111111111100 0001111111111111111111111111111111111111111111111111111111111000 0000111111111111111111111111111111111111111111111111111111110000 0000011111111111111111111111111111111111111111111111111111100000 0000000111111111111111111111111111111111111111111111111110000000 0000000011111111111111111111111111111111111111111111111100000000 0000000000011111111111111111111111111111111111111111100000000000 0000000000000111111111111111111111111111111111111110000000000000 0000000000000000111111111111111111111111111111110000000000000000 0000000000000000000001111111111111111111111000000000000000000000

Bây giờ chúng ta nên chia mỗi dòng cho 8, đại diện cho một byte và lưu trữ chúng trong một mảng như dưới đây:

static const unsigned char PROGMEM arduino_logo = {

B00000000, B00000000, B00000111, B11111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, // tiếp tục lên đến cuối hình ảnh;

Sau đó, chúng ta có thể vẽ nó trên màn hình bằng cách gọi hàm drawBitmap.

display.drawBitmap (32, 16, arduino_logo, 64, 32, WHITE);

Bước 11: Khắc phục sự cố

Đây là một hướng dẫn dài và vì vậy rất có thể xảy ra sự cố. Dưới đây là danh sách một số lỗi phổ biến mà bạn có thể gặp phải khi thiết lập mô-đun màn hình OLED cho dự án của mình (một số lỗi đã xảy ra với tôi khi chuẩn bị hướng dẫn này).

Không có gì được hiển thị cả

Điều này có thể xảy ra vì nhiều lý do, vì vậy tôi khuyên bạn nên kiểm tra danh sách sau theo thứ tự có thể xảy ra trong dự án của bạn:

Địa chỉ I2C có thể sai

Đảm bảo rằng bạn đã đặt địa chỉ mà bạn có trong mã i2c-scanner trong hàm display.begin () khi thiết lập đối tượng hiển thị của mình.

SCL và SDA được kết nối sai cách

Điều này thực sự đã xảy ra đối với tôi. Nếu bạn đang sử dụng Arduino Uno thì bạn phải kiểm tra lại các kết nối của mình để đảm bảo chúng được kết nối giống như của tôi. Nếu bạn đang sử dụng phiên bản Arduino khác (ví dụ: Mega, Leonardo, v.v.), bạn phải biết rằng họ có thể đã đặt I2C thành các chân khác. Bạn có thể kiểm tra nó tại tài liệu của thư viện Wire.

Bạn đang vẽ thứ gì đó ra khỏi vùng có thể nhìn thấy

Đây là một vấn đề phần mềm. Nó rất phổ biến khi sử dụng các hàm vẽ để tính toán sai một số tọa độ và do đó, bản vẽ của bạn sẽ bị biến dạng hoặc trong trường hợp xấu nhất, nó có thể hoàn toàn ra khỏi khung cảnh. Xem lại các phép tính của bạn và thử vẽ từng bước một để xem điều gì đang xảy ra.

Văn bản hoàn toàn không được hiển thị

Bạn quên đặt màu văn bản hoặc đặt sai giá trị

Bạn cần gọi setTextColor trước khi vẽ văn bản. Nếu không, bạn không có lỗi, nhưng bạn sẽ không thấy gì trên màn hình. Ngoài ra, bạn có thể đã đặt màu văn bản giống màu nền.

Bạn đang sử dụng một phông chữ rất lớn

Nếu bạn đặt kích thước văn bản thành một giá trị rất lớn, có thể các ký tự nằm hoàn toàn ra khỏi vùng hiển thị.

Có lỗi biên dịch về kích thước hiển thị

Điều này cũng đã xảy ra với tôi và tôi nghĩ nó sẽ xảy ra với hầu hết các bạn. Đó là do các giá trị hằng số kích thước hiển thị được xác định bên trong tệp tiêu đề Adafruit_SSD1306.h mà chúng tôi đưa vào đầu tập lệnh của mình. Tệp này nằm tại {your-project-folder} architects / Adafruit_SSD1306 / Adafruit_SSD1306.h. Nếu bạn mở tệp này, bạn sẽ nhận thấy rằng có một phần nhận xét như bên dưới, trong đó nó mô tả rằng bạn chỉ cần bỏ ghi chú hằng số đại diện cho kích thước mô-đun màn hình OLED của bạn. Đối với mô-đun màn hình 128x64, dòng #define SSD1306_128_64 sẽ được bỏ ghi chú.

/*=====================================================================

Màn hình SSD1306 ------------------------------------------------ ---------------------- Trình điều khiển được sử dụng trong nhiều màn hình (128x64, 128x32, v.v.). Chọn màn hình thích hợp bên dưới để tạo bộ đệm khung có kích thước thích hợp, v.v. SSD1306_128_64 Màn hình 128x64 pixel SSD1306_128_32 Màn hình 128x32 pixel SSD1306_96_16 --------------------------- -------------------------------------------- * / #define SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 / * ========================================= =============================== * /

Bước 12: Làm gì tiếp theo?

Màn hình OLED như một mô-đun đầu ra có thể mang đến cho bạn cơ hội tuyệt vời để cung cấp giao diện chuyên nghiệp cho các dự án sở thích của bạn. Bạn có thể thử làm theo các ý tưởng như một điểm khởi đầu để hiển thị dữ liệu có ý nghĩa trên đó hoặc giúp người dùng biết điều gì đang xảy ra hoặc liệu họ có cần làm điều gì đó hay không. Người dùng đọc thông báo trên màn hình sẽ rõ ràng hơn nhiều so với việc diễn giải trạng thái của một dự án / thiết bị thông qua một số đèn LED.

Những gì bạn có thể làm khi bắt đầu có thể là:

• Đọc giá trị cảm biến nhiệt độ và hiển thị nó trên mô-đun OLED. Bạn có thể thêm cảm biến áp suất hoặc độ ẩm vào nó và tạo một dự án trạm thời tiết đầy đủ chức năng.
• Cố gắng vẽ thứ gì đó trên mô-đun màn hình bằng cách sử dụng mô-đun cần điều khiển làm thiết bị đầu vào.
• Cố gắng vẽ hoạt ảnh trên màn hình bằng chuỗi lệnh vẽ / trì hoãn lệnh gọi hàm hoặc ngắt Arduino
• Hiển thị biểu trưng tùy chỉnh của bạn khi khởi động hệ thống (thay vì Biểu trưng Adafruit)

Đừng quên cho tôi biết về nhận xét, bạn sẽ làm gì (hoặc bạn đã làm) bằng cách sử dụng mô-đun màn hình OLED.