אפיק I2C

9.1 מאפייני האפיק (Bus Features)

האפיק I2C הוא שני חוטים בלבד: חוט הנתונים SDA וחוט השעון SCL. עליהם מחובר התקן ראשי (Master, בקר ראשי), שהוא הבקר שלנו, ועוד הרבה התקני עבד (Slave). רק הראשי מייצר את השעון ופותח כל שיחה, וכל עבד שותק עד ששומע את הכתובת שלו.

מספר הכתובות נראה גדול, 2⁷ = 128, אבל חלקן שמורות. והמרחק קצר: האפיק תוכנן לעבוד בתוך המכשיר, על הלוח עצמו או בחוטים קצרים.

9.2 נגדי משיכה (Pull-up Resistors)

אין באפיק שבב שדוחף את החוט למעלה. כל שבב יכול דבר אחד: לחבר את החוט לאדמה, או לעזוב אותו. זה נקרא ניקוז פתוח (Open Drain). אז מי מעלה את החוט כשכולם עוזבים אותו? נגד המשיכה (Pull-up) המחובר להזנה. יש בכך יתרון גדול: אם שני שבבים טעו ודיברו יחד, אף אחד מהם לא מתנגש בשני, החוט פשוט נשאר נמוך ושום דבר לא נשרף.

מה צריך להיות ערכם? יש להם שני גבולות. נגד קטן מדי מעמיס על השבב זרם שהוא לא מסוגל למשוך. נגד גדול מדי מאט את עליית החוט, כי לחוט יש קיבול C_b. מפרט האפיק UM10204 נותן את שני היחסים האלה:

9.3 התחלה, Acknowledge וסיום (A Bus Transaction)

הכלל הבסיסי: SDA משתנה רק כש-SCL נמוך, ונקרא כשהוא גבוה. לכלל הזה יש שני יוצאים מן הכלל, והם בדיוק מה שמסמן את גבולות השיחה:

• תנאי התחלה: SDA יורד בזמן ש-SCL גבוה. כל השבבים רואים זאת ונעשים קשובים.
• בית הכתובת: שבע סיביות כתובת, ואחריהן סיבית הכיוון: 0 לכתיבה ו-1 לקריאה. הסיבית הכבדה ביותר ראשונה, בניגוד ל-UART.
• אישור (Acknowledge): אחרי כל בית המשדר עוזב את החוט, והמקלט מושך אותו למטה לפולס שעון אחד: "קיבלתי". אם הוא נשאר גבוה, אף אחד לא ענה.
• נתונים: בית אחרי בית, ואחרי כל בית אישור.
• תנאי עצירה: SDA עולה בזמן ש-SCL גבוה, והאפיק משתחרר.

9.4 כתובת וסריקת האפיק (Scanning the Bus)

מפרק 6 אנחנו מכירים את הפונקציה board.i2c(), שמכוונת את האפיק ל-400 kHz. זה מתאים לממיר ADS1115. אבל גיליונות הנתונים של PCF8574 ו-DS1307 מגדירים רק 100 kHz. לכן בפרק הזה יוצרים את האפיק בעצמנו, במהירות של השבב האיטי ביותר עליו, ועם שמות ההדקים מ-board. השורה הזאת עובדת בשני הלוחות:

from machine import I2C, Pin
import board

i2c = I2C(0, scl=Pin(board.SCL), sda=Pin(board.SDA), freq=100000)
found = i2c.scan()
print("found", len(found), "chips")
for addr in found:
    print("0x%02X" % addr)

found 3 chips
0x20
0x48
0x68

מה אם השבב לא עונה? writeto נעצר בשגיאה מסוג OSError, ותוכנית בלי טיפול תיעצר כאן. כך תופסים אותה:

from machine import I2C, Pin
import board

i2c = I2C(0, scl=Pin(board.SCL), sda=Pin(board.SDA), freq=100000)
try:
    i2c.writeto(0x27, bytes([0]))
    print("ACK from 0x27")
except OSError:
    print("no answer from 0x27")
print("the program goes on")

no answer from 0x27
the program goes on

9.5 התנסות ב-PCF8574 (I/O Expander)

השבב PCF8574 הוא מרחיב הדקים: שמונה הדקים P0–P7 שכותבים אליהם וקוראים מהם דרך האפיק. אין אוגרים: כותבים בית אחד ושמונת ההדקים משתנים, וקוראים בית אחד ומקבלים את מצבם.

הכתובת 0x20 ועוד שלוש הסיביות A2 A1 A0 שקובעים בחיווט, וכך מגיעים לשמונה שבבים על אותו אפיק. לגרסה PCF8574A כתובות אחרות שמתחילות ב-0x38.

הדקי השבב הזה הם חצי דו-כיווניים: הם יכולים למשוך זרם גדול כלפי מטה, עד 25 mA לפי גיליון הנתונים, אבל ברמה הגבוהה הם נותנים זרם חלש מאוד. לכן מחברים את הנורית בין ההזנה להדק, והיא נדלקת ב-0, בניגוד למה שהתרגלנו.

מתחילים בשתי הפקודות הבסיסיות בלי ספרייה, עם לחצן על P4 שמושך אותו למטה:

from machine import I2C, Pin
import board

i2c = I2C(0, scl=Pin(board.SCL), sda=Pin(board.SDA), freq=100000)
i2c.writeto(0x20, bytes([0b11111110]))
value = i2c.readfrom(0x20, 1)[0]
print("P7..P0 = {:08b}".format(value))

P7..P0 = 11101110
[pcf]
fe

עכשיו נכתוב מחלקה קטנה, ונשים לב שהיא לא מייבאת את machine: התוכנית נותנת לה את האפיק מוכן, כמו ב-ads1115.py.

# pcf8574.py - driver for the PCF8574 eight-line I2C port expander.
# ESP32 and Pico: pass a machine.I2C. Raspberry Pi 4/5: pass a pi_i2c.PiI2C.
# (c) 2026 Fahed Ghanem - MIT License - fahed-lab.com


class PCF8574:
    def __init__(self, i2c, addr=0x20):
        self.i2c = i2c
        self.addr = addr
        self.write(0xFF)

    def write(self, value):
        self.state = value & 0xFF
        self.i2c.writeto(self.addr, bytes([self.state]))

    def read(self):
        return self.i2c.readfrom(self.addr, 1)[0]

    def set_pin(self, n, level):
        if level:
            self.write(self.state | (1 << n))
        else:
            self.write(self.state & ~(1 << n))

    def get_pin(self, n):
        return (self.read() >> n) & 1

הפונקציה set_pin משנה הדק אחד, אבל השבב מבין רק בית שלם. לכן הספרייה שומרת את הערך האחרון ב-self.state ולא משנה את שאר ההדקים. עכשיו אור שרץ על ארבע הנוריות:

from machine import I2C, Pin
from pcf8574 import PCF8574
import board
import time

i2c = I2C(0, scl=Pin(board.SCL), sda=Pin(board.SDA), freq=100000)
pcf = PCF8574(i2c, 0x20)

for n in (0, 1, 2, 3, 2, 1, 0):
    pcf.write(~(1 << n))
    print("LED", n, "on")
    time.sleep(0.25)
pcf.write(0xFF)

LED 0 on
LED 1 on
LED 2 on
LED 3 on
LED 2 on
LED 1 on
LED 0 on
[pcf]
ff
fe
fd
fb
f7
fb
fd
fe
ff

from machine import I2C, Pin
from pcf8574 import PCF8574
import board
import time

i2c = I2C(0, scl=Pin(board.SCL), sda=Pin(board.SDA), freq=100000)
pcf = PCF8574(i2c, 0x20)

while True:
    pressed = pcf.get_pin(4) == 0
    pcf.set_pin(0, 0 if pressed else 1)
    print("pressed" if pressed else "released")
    time.sleep(1)

released
pressed
pressed
released
...

9.6 התנסות ב-DS1307 (Real-Time Clock)

השעון של הבקר נעצר כשההזנה מתנתקת. לעומתו שעון זמן אמת (RTC) הוא שבב שסופר שניות בלי הפסקה, עם גביש קטן וסוללה. הכתובת של DS1307 היא תמיד 0x68.

בתוך השבב שבעה אוגרים בקידוד עשרוני בינארי (BCD): כל ספרה עשרונית בארבע סיביות. השנייה 45 נשמרת כ-0100 0101, כלומר 0x45, ולא כ-45 בבינארי רגיל. כך אדם קורא את הערך ישירות בהקסדצימלי.

קריאה משבב עם אוגרים היא שני צעדים: כותבים את מספר האוגר, והמצביע של השבב עובר אליו, ואז קוראים, והמצביע מתקדם בעצמו. זו התוכנית בלי ספרייה:

from machine import I2C, Pin
import board

i2c = I2C(0, scl=Pin(board.SCL), sda=Pin(board.SDA), freq=100000)
regs = bytes([0, 0x30, 0x59, 0x09, 0x01, 0x02, 0x11, 0x26])
i2c.writeto(0x68, regs)
i2c.writeto(0x68, bytes([0]))
data = i2c.readfrom(0x68, 7)
print(" ".join("%02X" % b for b in data))

30 59 09 01 02 11 26

# ds1307.py - driver for the DS1307 real-time clock, 24-hour mode.
# ESP32 and Pico: pass a machine.I2C. Raspberry Pi 4/5: pass a pi_i2c.PiI2C.
# (c) 2026 Fahed Ghanem - MIT License - fahed-lab.com


def to_bcd(x):
    return ((x // 10) << 4) | (x % 10)


def from_bcd(b):
    return (b >> 4) * 10 + (b & 0x0F)


class DS1307:
    def __init__(self, i2c, addr=0x68):
        self.i2c = i2c
        self.addr = addr

    def set_time(self, year, month, day, hour, minute, second, weekday=1):
        values = (second, minute, hour, weekday, day, month, year - 2000)
        regs = [to_bcd(v) for v in values]
        self.i2c.writeto(self.addr, bytes([0] + regs))

    def now(self):
        self.i2c.writeto(self.addr, bytes([0]))
        r = self.i2c.readfrom(self.addr, 7)
        return (2000 + from_bcd(r[6]), from_bcd(r[5]), from_bcd(r[4]),
                from_bcd(r[2] & 0x3F), from_bcd(r[1]),
                from_bcd(r[0] & 0x7F))

from machine import I2C, Pin
from ds1307 import DS1307
import board
import time

i2c = I2C(0, scl=Pin(board.SCL), sda=Pin(board.SDA), freq=100000)
rtc = DS1307(i2c)
rtc.set_time(2026, 11, 2, 9, 59, 58)

for i in range(4):
    y, mo, d, h, mi, s = rtc.now()
    print("%04d-%02d-%02d %02d:%02d:%02d" % (y, mo, d, h, mi, s))
    time.sleep(1)

2026-11-02 09:59:58
2026-11-02 09:59:59
2026-11-02 10:00:00
2026-11-02 10:00:01

ההבדל מול השעון machine.RTC שבבקר: ההוא נעצר או הולך לאיבוד כשההזנה מתנתקת, וזה נשאר בזכות הסוללה. יש גם דרך שלישית כשיש רשת: לקחת ממנה את הזמן.

9.7 תצוגת LCD 16x2 (Text Display)

מסך הטקסט 16×2 בנוי סביב הבקר HD44780, ובמקור הוא דורש לפחות שישה הדקים. הגשר הקטן שמורכב מאחוריו הוא בסך הכול PCF8574: הוא הופך את מה שכותבים לאפיק להדקי המסך. לכן כל מה שדרוש הוא שני חוטי האפיק. כתובת הגשר הנפוצה היא 0x27, או 0x3F עם PCF8574A, והסריקה אומרת לנו.

הגשר הנפוץ מחבר למסך ארבע סיביות נתונים בלבד. לכן כל בית מפצלים לשני חצאים: ארבע העליונות קודם, ואז התחתונות. ההדק E הוא פקודת "קח עכשיו": המסך קורא את הנתונים ברגע שהוא יורד. ההדק RS מבדיל בין פקודה (0) לתו (1).

קודם נראה איך משתמשים בספרייה i2c_lcd.py, ואחר כך נציץ לתוכה:

from machine import I2C, Pin
from i2c_lcd import LCD
import board
import time

i2c = I2C(0, scl=Pin(board.SCL), sda=Pin(board.SDA), freq=100000)
lcd = LCD(i2c, 0x27)
lcd.line(0, "Hello, I2C")

for n in range(1, 4):
    lcd.line(1, "Count: %d" % n)
    time.sleep(1)
print("done")

done
[LCD]
|Hello, I2C      |
|Count: 3        |

הפונקציה line כותבת שורה שלמה ומשלימה את השאר ברווחים, במקום clear. למה? כי המחיקה מכבה את המסך לרגע והוא מהבהב. גם המהירות חשובה כאן:

זו הספרייה i2c_lcd.py במלואה, כפי שהיא בלוח, ואחריה הסבר הפקודות שלה:

# i2c_lcd.py - HD44780 text display behind a PCF8574 I2C bridge.
# Bridge lines: P0=RS P1=RW P2=E P3=light P4..P7=D4..D7.
# ESP32 and Pico: pass a machine.I2C. Raspberry Pi 4/5: pass a pi_i2c.PiI2C.
# (c) 2026 Fahed Ghanem - MIT License - fahed-lab.com
import time

RS = 0x01
ENABLE = 0x04
LIGHT = 0x08
ROW_START = (0x00, 0x40, 0x14, 0x54)


class LCD:
    def __init__(self, i2c, addr=0x27, cols=16):
        self.i2c = i2c
        self.addr = addr
        self.cols = cols
        self.light = LIGHT
        time.sleep(0.05)
        for high in (0x30, 0x30, 0x30, 0x20):
            self._nibble(high, 0)
            time.sleep(0.005)
        self._send(0x28, 0)
        self._send(0x0C, 0)
        self._send(0x06, 0)
        self.clear()

    def _nibble(self, high, rs):
        out = high | rs | self.light
        self.i2c.writeto(self.addr, bytes([out | ENABLE, out]))

    def _send(self, value, rs):
        self._nibble(value & 0xF0, rs)
        self._nibble((value << 4) & 0xF0, rs)

    def clear(self):
        self._send(0x01, 0)
        time.sleep(0.002)

    def move(self, col, row):
        self._send(0x80 | (ROW_START[row] + col), 0)

    def write(self, text):
        for ch in text:
            self._send(ord(ch), RS)

    def line(self, row, text):
        self.move(0, row)
        self.write((text + " " * self.cols)[:self.cols])

    def backlight(self, on):
        self.light = LIGHT if on else 0
        self.i2c.writeto(self.addr, bytes([self.light]))

9.8 תצוגת OLED (Graphic Display)

מסך OLED קטן, 128×64 נקודות עם השבב SSD1306, שולט בכל נקודה. הכתובת הנפוצה שלו 0x3C, והוא עובד ב-400 kHz, ולכן כאן מספיק לנו board.i2c(). הרעיון: מציירים בזיכרון, ואז שולחים את התמונה כולה בבת אחת. במיקרו-פייתון יש מודול מוכן לציור בזיכרון, framebuf. לכן מספיקה ספרייה קצרה שמעבירה את הזיכרון למסך:

# oled.py - SSD1306 graphic display, 128 x 64, on I2C. MicroPython only.
# Drawing commands come from framebuf: text, line, rect, fill, pixel.
# (c) 2026 Fahed Ghanem - MIT License - fahed-lab.com
import framebuf

WIDTH = 128
HEIGHT = 64
SETUP = (0xAE, 0x20, 0x00, 0xA1, 0xC8, 0xA8, HEIGHT - 1, 0xDA, 0x12,
         0x81, 0x7F, 0x8D, 0x14, 0xAF)


class OLED(framebuf.FrameBuffer):
    def __init__(self, i2c, addr=0x3C):
        self.i2c = i2c
        self.addr = addr
        self.data = bytearray(1 + WIDTH * HEIGHT // 8)
        self.data[0] = 0x40
        pixels = memoryview(self.data)[1:]
        super().__init__(pixels, WIDTH, HEIGHT, framebuf.MONO_VLSB)
        for byte in SETUP:
            self._command(byte)

    def _command(self, byte):
        self.i2c.writeto(self.addr, bytes([0x00, byte]))

    def show(self):
        for byte in (0x21, 0, WIDTH - 1, 0x22, 0, HEIGHT // 8 - 1):
            self._command(byte)
        self.i2c.writeto(self.addr, self.data)

המחלקה OLED ירשה מ-framebuf.FrameBuffer את כל פקודות הציור. וכל כתיבה מתחילה בבית בקרה: 0x00 לפקודות ו-0x40 לנתונים. לכן שמרנו לו את הבית הראשון בזיכרון, ולא מעתיקים את התמונה בשליחה.

from oled import OLED
import board

screen = OLED(board.i2c(), 0x3C)
screen.fill(0)
screen.text("OK", 0, 0)
screen.rect(0, 12, 128, 20, 1)
screen.show()

for y in range(8):
    row = ""
    for x in range(16):
        row += "#" if screen.pixel(x, y) else "."
    print(row)

..####...##..##.
.##..##..##.##..
.##..##..####...
.##..##..###....
.##..##..####...
.##..##..##.##..
..####...##..##.
................

9.9 קשר ל-ADS1115 (Everything on One Bus)

בפרק 6 חיברנו את הממיר ADS1115 לאותו אפיק, והספרייה שלו נכתבה באותה דרך שבה אנחנו כותבים כאן. נחבר את הממיר, השעון והמסך בשלושה אובייקטים שחולקים אפיק אחד. בספריות לא משנים דבר, והמהירות היא מהירות השבב האיטי ביותר:

from machine import I2C, Pin
from ads1115 import ADS1115
from ds1307 import DS1307
from i2c_lcd import LCD
import board
import time

i2c = I2C(0, scl=Pin(board.SCL), sda=Pin(board.SDA), freq=100000)
adc = ADS1115(i2c)
rtc = DS1307(i2c)
lcd = LCD(i2c)
rtc.set_time(2026, 11, 2, 9, 30, 0)

while True:
    y, mo, d, h, mi, s = rtc.now()
    volts = adc.read_volts(0)
    lcd.line(0, "%02d:%02d:%02d" % (h, mi, s))
    lcd.line(1, "A0 = %.3f V" % volts)
    print("%02d:%02d:%02d  %.3f V" % (h, mi, s, volts))
    time.sleep(1)

09:30:00  0.500 V
09:30:01  1.250 V
09:30:02  2.500 V
[LCD]
|09:30:02        |
|A0 = 2.500 V    |
...

רק הכתובת מפרידה בין השבבים, ולכן שני התקנים לא יכולים לחלוק את אותה כתובת. אם דרושים שני התקנים זהים עם כתובת קבועה, משתמשים באפיק שני I2C(1) על שני הדקים אחרים.

9.10 ב-Raspberry Pi

שלוש הספריות pcf8574.py, ds1307.py ו-i2c_lcd.py מבקשות מהאפיק רק writeto ו-readfrom. לכן הן עובדות ב-Pi בלי שינוי, עם הקובץ pi_i2c.py שכתבנו בפרק 6, ועם אותה הכנה. אבל oled.py לא עובדת, כי framebuf הוא חלק ממיקרו-פייתון ואינו קיים בפייתון הרגיל.

import time
from pcf8574 import PCF8574
from pi_i2c import PiI2C

pcf = PCF8574(PiI2C(), 0x20)

for n in range(4):
    pcf.write(~(1 << n))
    print("LED", n, "on")
    time.sleep(0.25)
pcf.write(0xFF)

LED 0 on
LED 1 on
LED 2 on
LED 3 on

עיקרי הפרק:

• שני חוטים לעשרות שבבים: הראשי מייצר את השעון, וכל עבד עונה כששומע את הכתובת שלו.
• השבבים רק מושכים את הקו, ונגדי המשיכה הם שמעלים אותו. בלעדיהם אין אפיק.
• ההתחלה והעצירה הן השינוי היחיד ב-SDA כש-SCL גבוה, והאישור אחרי כל בית אומר לנו שהצד השני שם.
• מתחילים כל שבב חדש בסריקה, והמהירות היא מהירות השבב האיטי ביותר.
• PCF8574 נדלק ב-0, וכדי לקרוא הדק כותבים אליו קודם 1.
• DS1307 שומר ב-BCD, ומסך הטקסט מקבל כל בית בשני חצאים.
• ספרייה שמבקשת מהאפיק רק writeto ו-readfrom עובדת בכל הלוחות.

סיכום הכללים בפרק:

פקודות הפרק:

מילון מונחים:

שאלות לתרגול:

from machine import I2C, Pin
from pcf8574 import PCF8574
import board
import time

i2c = I2C(0, scl=Pin(board.SCL), sda=Pin(board.SDA), freq=100000)
pcf = PCF8574(i2c, 0x20)

for n in range(16):
    pcf.write(~n)
    time.sleep(0.5)
print("done")

def running(rtc):
    rtc.i2c.writeto(rtc.addr, bytes([0]))
    return not rtc.i2c.readfrom(rtc.addr, 1)[0] & 0x80