25. Lektion: I2C

Das Protokoll

Das I2C Manual kann von hier heruntergeladen werden.

Der Bus

Der I2C Bus besteht aus 2 Leitungen, SCL uns SDA. SCL ist die Taktleitung (clock) und SDA die Datenleitung. Die I2C Geräte werden paralell an den Bus angeschlossen. Beide Busleitungen müssen mit einem Widerstand an Vcc gelegt werden. Der maximale Ausgangsstrom eines I2C IC's beträgt mindestens 3 mA. Der maximale Eingangsstrom 10 µA. Die Widerstände Rp müssen so gewählt werden, das der maximale Strom von 3 mA nicht überschritten wird.
Der I2C Bus ist ein Master/Slave System. Der Master bestimmt, was auf dem Bus geschieht. Er gibt den Takt vor und adressiert die Clients. Ein Client kann nur aktiv werden, wenn der Master ihn dazu auffordert. Deshalb haben I2C IC's häufig Interrupt Ausgänge mit denen dem Master mitgeteilt werden kann, dass Daten zum Abholen bereit stehen.

Die Datenübertragung

Die Übertragung erfolgt in Dateneinheiten. Eine Dateneinheit besteht aus 8 Datenbits und einem ACK-Bit. Dabei wird zuerst das MSB (most significant bit) also Bit 7 übertragen.

Die erste Dateneinheit enthält die Zieladresse (7 Bit) und das R/W-Flag. Die weiteren Dateneinheiten enthalten die zu übertragenen Daten. Mit dem ACK-Flag kann der Client die weitere Übertragung verzögern, um genügend Zeit für die Verarbeitung der Daten zu haben.

I2C Objekt erzeugen

Wie alles in Micropython ist auch I2C als Klasse implementiert. Deshalb muß für jeden I2C Bus eine Instanz erzeugt werden.
Micropython kennt 2 Arten von I2C Treibern. Einmal den Hardware I2C Treiber und die Software Implementierung.

Hardware I2C

Der Raspberry Pi Pico W enthält 2 Hardware I2C Einheiten (0 und 1). Die default Einstellungen findet man folgendermassen:

from machine import I2C
print(I2C(0))
print(I2C(1))

I2C(0, freq=399361, scl=5, sda=4, timeout=50000)    # timeout in µs
I2C(1, freq=399361, scl=7, sda=6, timeout=50000)

Nun soll eine I2C Instanz erzeugt werden. Dabei können die Defaultwerte oder andere zulässige Werte benutzt werden.

from machine import Pin, I2C

i2c = I2C(0)                    # default assignment
i2c = I2C(1, scl=Pin(3), sda=Pin(2), freq=400_000)

Mit dem so erzeugten I2C-Objekt können wir außer einem Busscan noch nicht viel anfangen.

i2c.scan()                      # scan for peripherals, returning a list of 7-bit addresses

i2c.writeto(42, b'123')         # write 3 bytes to peripheral with 7-bit address 42
i2c.readfrom(42, 4)             # read 4 bytes from peripheral with 7-bit address 42

i2c.readfrom_mem(42, 8, 3)      # read 3 bytes from memory of peripheral 42,
                                #   starting at memory-address 8 in the peripheral
i2c.writeto_mem(42, 2, b'\x10') # write 1 byte to memory of peripheral 42
                                #   starting at address 2 in the peripheral

Die übrigen Methoden werden in Treibermodulen für I2C Geräte benötigt. Ein solches Modul ist z.B. ssd1306.py, das wir uns gleich noch näher ansehen werden.

Software I2C

Ein SoftI2C Objekt wird genauso erzeugt wie ein Hardware I2C Objekt, nur das die Pins und die Frequenz unbedingt angegeben werden müssen. Hier ist man frei in der Wahl der Pins.

from machine import Pin, SoftI2C

i2c = SoftI2C(scl=Pin(5), sda=Pin(4), freq=100_000[, timeout=50000])

i2c.scan()              # scan for devices

i2c.readfrom(0x3a, 4)   # read 4 bytes from device with address 0x3a
i2c.writeto(0x3a, '12') # write '12' to device with address 0x3a

buf = bytearray(10)     # create a buffer with 10 bytes
i2c.writeto(0x3a, buf)  # write the given buffer to the peripheral

Ansonsten gilt das bei Hardware I2C dargestellte.

SSD1306 Display mit I2C benutzen

Auf unserem Demoboard befindet sich ein Display mit einem SSD1306 IC das über den I2C angesteuert wird. Auf dem Board ist SCL = GPIO21 SDA = GPIO20. Das entspricht nicht der default Belegung, aber ist eine mögliche Belegung für I2C0.
Nun wollen wir einen Blick in das Modul ssd1306.py werfen:

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces

from micropython import const
import framebuf


# register definitions
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xA4)
...

class SSD1306(framebuf.FrameBuffer):
    def __init__(self, width, height, external_vcc):
        ...
        self.init_display()

    def init_display(self):
        for cmd in (SET_DISP | 0x00,  ...  SET_DISP | 0x01)
            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
        ...
        self.write_data(self.buffer)

class SSD1306_I2C(SSD1306):
    def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
        ...

    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)

• Display anschließen
  • https://docs.micropython.org/en/latest/esp8266/tutorial/ssd1306.html
  • https://github.com/TimAEllis/ssd1306-py/blob/master/ssd1306.py
  • https://www.grzesina.de/az/blog_robotcar/ssd1306.py

Das SSD1306 IC

SSD1306 Datenblatt

• TCA9548a
  • https://github.com/mcauser/microphyton-tca9548a