Halo sobat, hari ini saya ingin menunjukkan SSD1306 dengan Raspberry Pi Pico. Hari ini kami ingin menghubungkan Oled ini ke pico melalui koneksi SPI. Semua kode dan perpustakaan diberikan, jadi jangan khawatir.
Raspberry Pi Pico
Raspberry Pi Pico adalah papan pengembangan yang berjalan terutama di MicroPython. Mirip dengan mikrokontroler lain seperti Arduino, NodeMCU dan lain-lain. Tetapi memiliki lebih banyak fitur dibandingkan dengan mereka. Terbuat dari Rp2040. Ini memiliki 264 KB RAM dan 2 MB ruang flash. Anda juga dapat memprogram PICO di C/C++ menggunakan arduino IDE. Untuk melakukan ini, cukup letakkan tautan ini di opsi Arduino IDE pilihan Anda. Lalu pergi ke Manajer papan dan cari Raspberry pi pico dan unduh Papan ini.
https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index
Anda dapat menggunakan jenis komunikasi seperti SPI (2), I2C (2), UART, serial. Jadi jika Anda pandai Python, coba saja papan ini. Pustaka yang perlu Anda gunakan untuk menginstal sistem operasi di papan mudah dilakukan. Menggunakan Thonny IDE.
Untuk memperbarui sistem operasi atau menginstal, cukup tekan tombol (BOOTSEL) pada PICO dan sambungkan ke pico sambil menekan USB. Setelah papan Anda terdeteksi di Thonny IDE, Anda dapat melepaskan tombolnya. Sekarang klik Instal atau Tingkatkan Firmware di kanan bawah.
Bahan yang dibutuhkan:
- Pico Raspberry
- SSD1306 SPI OLED
- Kabel jumper
- Board
- Thonny IDE diinstal pada sistem
Desain sirkuit:
| PI raspberry | Layar 7-pin lama |
| +5 volt | VCC |
| GND | GND |
| GPIO 18 pin | SCK |
| GPIO 19 pin | SDA |
| GPIO 20 pin | RES |
| GPIO 17 pin | DC |
| GPIO 16 pin | CS |
Pemrograman:
Buka Thonny IDE lalu tempel kode ini ke file baru:
# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
from micropython import const
import framebuf
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xA4)
SET_NORM_INV = const(0xA6)
SET_DISP = const(0xAE)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xA0)
SET_MUX_RATIO = const(0xA8)
SET_COM_OUT_DIR = const(0xC0)
SET_DISP_OFFSET = const(0xD3)
SET_COM_PIN_CFG = const(0xDA)
SET_DISP_CLK_DIV = const(0xD5)
SET_PRECHARGE = const(0xD9)
SET_VCOM_DESEL = const(0xDB)
SET_CHARGE_PUMP = const(0x8D)
class SSD1306(framebuf.FrameBuffer):
def __init__(self, width, height, external_vcc):
self.width = width
self.height = height
self.external_vcc = external_vcc
self.pages = self.height // 8
self.buffer = bytearray(self.pages * self.width)
super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
self.init_display()
def init_display(self):
for cmd in (
SET_DISP | 0x00, # off
# address setting
SET_MEM_ADDR,
0x00, # horizontal
# resolution and layout
SET_DISP_START_LINE | 0x00,
SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
SET_MUX_RATIO,
self.height - 1,
SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
SET_DISP_OFFSET,
0x00,
SET_COM_PIN_CFG,
0x02 if self.width > 2 * self.height else 0x12,
# timing and driving scheme
SET_DISP_CLK_DIV,
0x80,
SET_PRECHARGE,
0x22 if self.external_vcc else 0xF1,
SET_VCOM_DESEL,
0x30, # 0.83*Vcc
# display
SET_CONTRAST,
0xFF, # maximum
SET_ENTIRE_ON, # output follows RAM contents
SET_NORM_INV, # not inverted
# charge pump
SET_CHARGE_PUMP,
0x10 if self.external_vcc else 0x14,
SET_DISP | 0x01,
): # on
self.write_cmd(cmd)
self.fill(0)
self.show()
def poweroff(self):
self.write_cmd(SET_DISP | 0x00)
def poweron(self):
self.write_cmd(SET_DISP | 0x01)
def contrast(self, contrast):
self.write_cmd(SET_CONTRAST)
self.write_cmd(contrast)
def invert(self, invert):
self.write_cmd(SET_NORM_INV | (invert & 1))
def show(self):
x0 = 0
x1 = self.width - 1
if self.width == 64:
# displays with width of 64 pixels are shifted by 32
x0 += 32
x1 += 32
self.write_cmd(SET_COL_ADDR)
self.write_cmd(x0)
self.write_cmd(x1)
self.write_cmd(SET_PAGE_ADDR)
self.write_cmd(0)
self.write_cmd(self.pages - 1)
self.write_data(self.buffer)
class SSD1306_I2C(SSD1306):
def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
self.i2c = i2c
self.addr = addr
self.temp = bytearray(2)
self.write_list = [b"\x40", None] # Co=0, D/C#=1
super().__init__(width, height, external_vcc)
def write_cmd(self, cmd):
self.temp[0] = 0x80 # Co=1, D/C#=0
self.temp[1] = cmd
self.i2c.writeto(self.addr, self.temp)
def write_data(self, buf):
self.write_list[1] = buf
self.i2c.writevto(self.addr, self.write_list)
class SSD1306_SPI(SSD1306):
def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
self.rate = 10 * 1024 * 1024
dc.init(dc.OUT, value=0)
res.init(res.OUT, value=0)
cs.init(cs.OUT, value=1)
self.spi = spi
self.dc = dc
self.res = res
self.cs = cs
import time
self.res(1)
time.sleep_ms(1)
self.res(0)
time.sleep_ms(10)
self.res(1)
super().__init__(width, height, external_vcc)
def write_cmd(self, cmd):
self.spi.init(baudrate=self.rate, polarity=0, phase=0)
self.cs(1)
self.dc(0)
self.cs(0)
self.spi.write(bytearray([cmd]))
self.cs(1)
def write_data(self, buf):
self.spi.init(baudrate=self.rate, polarity=0, phase=0)
self.cs(1)
self.dc(1)
self.cs(0)
self.spi.write(buf)
self.cs(1)
Simpan file ini sebagai ‘ssd1306.py’ ke pico Anda. Ini bukan kode asli, tetapi membantu untuk mengeksekusi kode asli atau dapat dikatakan bahwa itu adalah perpustakaan yang digunakan.
Sekarang kode asli berfungsi seperti ini. Pertama kita masuk ke fungsi SPI dan Pin dari modul mesin. Kemudian impor fungsi SSD1306_SPI dari perpustakaan yang disimpan di atas (gunakan SSD1306_I2C untuk komunikasi I2C). Setelah itu kita masuk ke modul yang berisi semua proses yang kita lakukan untuk menampilkan sesuatu di oled. Kami juga mengimpor beberapa modul waktu untuk menunda program.
from machine import Pin, SPI
from ssd1306 import SSD1306_SPI
import framebuf
from time import sleep
from utime import sleep_ms
Sekarang kita tentukan port SPI mana yang akan kita sambungkan ke OLED, yaitu SPI (0). Pin untuk SPI adalah 18,19,16,17. SCK, MOSI, MISO, CS, masing-masing. Pin dc dan pertama dapat ditentukan secara manual dalam inisialisasi OLED SLE1306. Kami juga membuat objek “oled” yang menyimpan nilai OLED asli kami
spi = SPI(0, 100000, mosi=Pin(19), sck=Pin(18))
oled = SSD1306_SPI(128, 64, spi, Pin(17),Pin(20), Pin(16)) Kemudian pada perulangan while, kita mencoba cara lain untuk melanjutkan perulangan sampai menemukan interupsi keyboard. Jadi layar menampilkan teks ‘HELLO WORLD’ yang bergerak ke bawah dan ke kanan secara bersamaan hingga keyboard berhenti.
Kode:
Berikut kode lengkapnya. Lihat saja dan ingat untuk menyimpannya sebagai “main.py” di pico untuk dijalankan setiap kali pico di-restart atau dihidupkan.
from machine import Pin, SPI
from ssd1306 import SSD1306_SPI
import framebuf
from time import sleep
from utime import sleep_ms
spi = SPI(0, 100000, mosi=Pin(19), sck=Pin(18))
oled = SSD1306_SPI(128, 64, spi, Pin(17),Pin(20), Pin(16))
#oled = SSD1306_SPI(WIDTH, HEIGHT, spi, dc,rst, cs) use GPIO PIN NUMBERS
while True:
try:
for i in range(40):
for j in range(56):
oled.fill(0)
oled.show()
#sleep(1)
oled.text("HELLO WORLD",i,j)
oled.show()
sleep_ms(10)
except KeyboardInterrupt:
break
Dengan ini, kami telah berhasil menyelesaikan pelatihan kami tentang SSD1306 raspberry Pi Pico menggunakan komunikasi SPI. Saya harap Anda menyukainya. Jika Anda memiliki masalah, beri tahu saya di komentar di bawah.