|
|
(78 dazwischenliegende Versionen des gleichen Benutzers werden nicht angezeigt) |
Zeile 1: |
Zeile 1: |
− | == <p style="color: red">Dieses Kapitel wird im Kurs nicht behandelt. Ich beabsichtige dazu einen Vortrag auf einem Elektronik-Stammtisch (1.Montag im Monat) zu halten.</p>==
| |
− | Es würde zu umfangreich werden. Es müssten sonst andere, m.E. interessantere Teile entfallen.
| |
− |
| |
| == Was ist ein UART?== | | == Was ist ein UART?== |
− | UART steht für Universal Asynchronous Receiver Transmitter. Es handelt sich hierbei um die wohl älteste Schnittstelle in der Computerwelt. Sie wurde z.B. schon bei den Fernschreibern eingesetzt. Ursprünglich war sie für de Datenübertragung im Telefonnetz entwickelt worden. | + | UART steht für '''U'''niversal '''A'''synchronous '''R'''eceiver '''T'''ransmitter. Es handelt sich hierbei um die wohl älteste Schnittstelle in der Computerwelt. Sie wurde z.B. schon bei den Fernschreibern eingesetzt. Ursprünglich war sie für die Datenübertragung im Telefonnetz entwickelt worden. |
| <br> | | <br> |
| Es gibt 2 Normen für diese serielle Schnittstelle: | | Es gibt 2 Normen für diese serielle Schnittstelle: |
Zeile 60: |
Zeile 57: |
| |3.000.000 bit/s ||333 ns | | |3.000.000 bit/s ||333 ns |
| |} | | |} |
| + | === Parity-Bit=== |
| + | Das Parity-Bit ist eine einfache Fehlerprüfung. |
| + | ; even |
| + | : das Parity-Bit ergänzt die Anzahl High-Bits zu einer geraden Zahl. |
| + | ; odd |
| + | : das Parity-Bit ergänzt die Anzahl High-Bits zu einer ungeraden Zahl. |
| + | |
| + | |
| === Pegel=== | | === Pegel=== |
| Die Spannungspegel sind wie folgt zugeordnet: | | Die Spannungspegel sind wie folgt zugeordnet: |
Zeile 76: |
Zeile 81: |
| | | |
| == Die Klasse UART in Micropython== | | == Die Klasse UART in Micropython== |
− | Die Klasse UART befindet sich im Modul <code>machine</code>. Sie enthält folgende Methoden: | + | Die Klasse '''UART''' befindet sich im Modul <code>'''machine'''</code>. Sie enthält folgende Methoden: |
| + | <pre> |
| + | >>> dir(machine.UART) |
| + | ['__class__', '__name__', 'any', 'read', 'readinto', 'readline', 'write', '__bases__', '__dict__', 'CTS', 'INV_RX', 'INV_TX', 'RTS', |
| + | 'deinit', 'flush', 'init', 'sendbreak', 'txdone'] |
| + | >>> |
| + | </pre> |
| + | === Eine Instanz erzeugen=== |
| ; machine.UART(id, ...) | | ; machine.UART(id, ...) |
− | : Hiermit wird eie Instanz der Klasse UART erzeugt. Es können folgende Parameter übergeben werden: | + | : Hiermit wird eine Instanz der Klasse UART erzeugt. Es können folgende Parameter übergeben werden: |
− | * baudrate is the clock rate.
| + | ; baudrate |
− | * bits is the number of bits per character, 7, 8 or 9.
| + | : is the clock rate. |
− | * parity is the parity, None, 0 (even) or 1 (odd).
| + | ; bits |
− | * stop is the number of stop bits, 1 or 2.
| + | : is the number of bits per character, 7, 8 or 9. |
| + | ; parity |
| + | : is the parity, None, 0 (even) or 1 (odd). |
| + | ; stop |
| + | : is the number of stop bits, 1 or 2. |
| Weitere Schlüsselwort Parameter sind: | | Weitere Schlüsselwort Parameter sind: |
− | * tx specifies the TX pin to use.
| + | ; tx |
− | * rx specifies the RX pin to use.
| + | : specifies the TX pin to use. |
− | * rts specifies the RTS (output) pin to use for hardware receive flow control.
| + | ; rx |
− | * cts specifies the CTS (input) pin to use for hardware transmit flow control.
| + | : specifies the RX pin to use. |
− | * txbuf specifies the length in characters of the TX buffer.
| + | ; rts |
− | * rxbuf specifies the length in characters of the RX buffer.
| + | : specifies the RTS (output) pin to use for hardware receive flow control. |
− | * timeout specifies the time to wait for the first character (in ms).
| + | ; cts |
− | * timeout_char specifies the time to wait between characters (in ms).
| + | : specifies the CTS (input) pin to use for hardware transmit flow control. |
− | * invert specifies which lines to invert.
| + | ; txbuf |
| + | : specifies the length in characters of the TX buffer. |
| + | ; rxbuf |
| + | : specifies the length in characters of the RX buffer. |
| + | ; timeout |
| + | : specifies the time to wait for the first character (in ms). |
| + | ; timeout_char |
| + | : specifies the time to wait between characters (in ms). |
| + | ; invert |
| + | : specifies which lines to invert. |
| ** 0 will not invert lines (idle state of both lines is logic high). | | ** 0 will not invert lines (idle state of both lines is logic high). |
| ** UART.INV_TX will invert TX line (idle state of TX line now logic low). | | ** UART.INV_TX will invert TX line (idle state of TX line now logic low). |
| ** UART.INV_RX will invert RX line (idle state of RX line now logic low). | | ** UART.INV_RX will invert RX line (idle state of RX line now logic low). |
| ** UART.INV_TX | UART.INV_RX will invert both lines (idle state at logic low). | | ** UART.INV_TX | UART.INV_RX will invert both lines (idle state at logic low). |
− | flow specifies which hardware flow control signals to use. The value is a bitmask.
| |
− | * 0 will ignore hardware flow control signals.
| |
− | * UART.RTS will enable receive flow control by using the RTS output pin to signal if the receive FIFO has sufficient space to accept more data.
| |
− | * UART.CTS will enable transmit flow control by pausing transmission when the CTS input pin signals that the receiver is running low on buffer space.
| |
− | * UART.RTS | UART.CTS will enable both, for full hardware flow control.
| |
| ; UART.init(baudrate=9600, bits=8, parity=None, stop=1, *, ...) | | ; UART.init(baudrate=9600, bits=8, parity=None, stop=1, *, ...) |
| : Ändert die Einstellungen einer vorhandenen Instanz. | | : Ändert die Einstellungen einer vorhandenen Instanz. |
| ; UART.deinit() | | ; UART.deinit() |
| : Schaltet die UART-Instanz aus. Sie lässt sich mit init() nicht wieder einschalten. Sie muss neu angelegt werden. | | : Schaltet die UART-Instanz aus. Sie lässt sich mit init() nicht wieder einschalten. Sie muss neu angelegt werden. |
| + | |
| + | === Datenfluß Kontrolle=== |
| + | '''flow''' gibt an, welche Hardware-Flusssteuerungssignale verwendet werden sollen. Der Wert ist eine Bitmaske. |
| + | ; 0 |
| + | : will ignore hardware flow control signals. |
| + | ; UART.RTS |
| + | : will enable receive flow control by using the RTS output pin to signal if the receive FIFO has sufficient space to accept more data. |
| + | ; UART.CTS |
| + | : will enable transmit flow control by pausing transmission when the CTS input pin signals that the receiver is running low on buffer space. |
| + | ; UART.RTS | UART.CTS |
| + | : will enable both, for full hardware flow control. |
| + | |
| + | === Methoden zum Datentransfer=== |
| + | |
| ; UART.any() | | ; UART.any() |
| : Gibt eine ganze Zahl zurück, die die Anzahl der Zeichen zählt, die ohne Blockierung gelesen werden können. Sie gibt 0 zurück, wenn keine Zeichen verfügbar sind, und eine positive Zahl, wenn es Zeichen gibt. Die Methode kann auch dann 1 zurückgeben, wenn mehr als ein Zeichen zum Lesen verfügbar ist. | | : Gibt eine ganze Zahl zurück, die die Anzahl der Zeichen zählt, die ohne Blockierung gelesen werden können. Sie gibt 0 zurück, wenn keine Zeichen verfügbar sind, und eine positive Zahl, wenn es Zeichen gibt. Die Methode kann auch dann 1 zurückgeben, wenn mehr als ein Zeichen zum Lesen verfügbar ist. |
Zeile 118: |
Zeile 152: |
| ; UART.sendbreak() | | ; UART.sendbreak() |
| : Senden einer Unterbrechungsbedingung auf dem Bus. Dadurch wird der Bus für eine längere Zeit als für die normale Übertragung eines Zeichens erforderlich auf einen niedrigen Pegel gebracht. | | : Senden einer Unterbrechungsbedingung auf dem Bus. Dadurch wird der Bus für eine längere Zeit als für die normale Übertragung eines Zeichens erforderlich auf einen niedrigen Pegel gebracht. |
− | ; UART.irq(trigger, priority=1, handler=None, wake=machine.IDLE) | + | ; UART.flush() |
− | : Erstellen Sie einen Callback, der ausgelöst wird, wenn Daten auf dem UART empfangen werden.<br>Auslöser kann nur UART.RX_ANY sein<br>Prioritätsstufe des Interrupts. Kann Werte im Bereich von 1-7 annehmen. Höhere Werte stehen für höhere Prioritäten.<br>handler eine optionale Funktion, die aufgerufen wird, wenn neue Zeichen eintreffen.<br>wake kann nur machine.IDLE sein.
| + | : Waits until all data has been sent. In case of a timeout, an exception is raised. The timeout duration depends on the tx buffer size and the baud rate. Unless flow control is enabled, a timeout should not occur. |
| + | **Note |
| + | **For the rp2, esp8266 and nrf ports the call returns while the last byte is sent. If required, a one character wait time has to be added in the calling script. |
| + | ; UART.txdone() |
| + | : Tells whether all data has been sent or no data transfer is happening. In this case, it returns True. If a data transmission is ongoing it returns False. |
| + | ** Note |
| + | ** For the rp2, esp8266 and nrf ports the call may return True even if the last byte of a transfer is still being sent. If required, a one character wait time has to be added in the calling script. |
| + | ; UART.irq() |
| + | : ist im Pico nicht implementiert. |
| | | |
| == UART im Raspberry Pi Pico W== | | == UART im Raspberry Pi Pico W== |
Zeile 131: |
Zeile 173: |
| ! TX!! RX | | ! TX!! RX |
| |- | | |- |
− | | 0|| 1 | + | | '''0'''|| '''1''' |
| |- | | |- |
| | 12|| 13 | | | 12|| 13 |
Zeile 143: |
Zeile 185: |
| ! TX!! RX | | ! TX!! RX |
| |- | | |- |
− | | 4|| 5 | + | | '''4'''||'''5''' |
| |- | | |- |
| | 8|| 9 | | | 8|| 9 |
| |} | | |} |
| | | |
− | Die default Einstellungen sind: | + | == Versuchsaufbau mit dem Demoboard== |
| + | Um auf dem Demoboard die serielle UART-Schnittstelle zu testen, muss an den Expansion-Anschlüssen eine Stecker- oder Buchsenleiste eingelötet werden. Dann müssen folgende Anschlüsse miteinander verbinden werden:<br> |
| + | GP 0 -> GP 5<br> |
| + | GP 1 -> GP 4 |
| + | <br> |
| + | [[file:Demoboard_UART.jpg|500px|Demoboard_UART]] |
| + | |
| + | == Eine UART-Instanz erzeugen== |
| + | Die default Einstellungen für UARTs sind: |
| <pre> | | <pre> |
| >>> print(UART(0)) | | >>> print(UART(0)) |
Zeile 165: |
Zeile 215: |
| UART(0, baudrate=115200, bits=8, parity=None, stop=1, tx=0, rx=1, txbuf=256, rxbuf=256, timeout=0, | | UART(0, baudrate=115200, bits=8, parity=None, stop=1, tx=0, rx=1, txbuf=256, rxbuf=256, timeout=0, |
| timeout_char=1, invert=None) | | timeout_char=1, invert=None) |
− | >>> dir(uart)
| |
− | ['__class__', '__next__', 'any', 'read', 'readinto', 'readline', 'write', 'CTS', 'INV_RX', 'INV_TX',
| |
− | 'RTS', 'deinit', 'flush', 'init', 'sendbreak', 'txdone']
| |
| </pre> | | </pre> |
| Wie man oben sieht ist die Initialisierung unter Verwendung der Defaultparameter sehr einfach.<br> | | Wie man oben sieht ist die Initialisierung unter Verwendung der Defaultparameter sehr einfach.<br> |
| + | <br> |
| + | Für unsere weiteren Versuche muss immer zuerst folgender Code ausgeführt werden: |
| + | <pre> |
| + | import machine |
| + | uart0 = machine.UART(0) |
| + | uart1 = machine.UART(1) |
| + | </pre> |
| + | |
| + | == Senden== |
| + | |
| + | Im einfachsten Fall wird einfach ein String zur Übertragung angegeben: |
| + | <pre> |
| + | >>> uart0.write('Hallo!') |
| + | 6 |
| + | </pre> |
| + | Zahlen können nicht so einfach übertragen werden. Sie müssen erst in einen String umgewandelt werden: |
| + | <pre> |
| + | >>> uart0.write(123456) |
| + | Traceback (most recent call last): |
| + | File "<stdin>", line 1, in <module> |
| + | TypeError: object with buffer protocol required |
| + | |
| + | >>> uart0.write(str(123456)) |
| + | 6 |
| + | </pre> |
| + | |
| + | == Empfangen== |
| + | |
| + | |
| + | <pre> |
| + | >>> import machine |
| + | uart0 = machine.UART(0) |
| + | uart1 = machine.UART(1) |
| + | |
| + | >>> uart0.write('Hallo!') |
| + | 6 |
| + | >>> uart1.read() |
| + | b'Hallo!' |
| + | |
| + | # oder: |
| + | >>> uart1.read().decode('utf-8') |
| + | 'Hallo!' |
| + | </pre> |
| + | Für die Übertragung muss der String in eine Bytefolge (Bytestring - b' ') umgewandelt werden. Das macht die .write() Methode intern. Die .read() Methode wandelt diesen aber nicht wieder zurück. |
| + | <br> |
| + | Für die Umwandlung von Bytes zurück in einen String gibt es zwei Wege: |
| + | <pre> |
| + | # mit str() |
| + | >>> str(b'Hallo!', 'utf-8') |
| + | 'Hallo!' |
| + | |
| + | # mit decode() |
| + | >>> b'Hallo!'.decode('utf-8') |
| + | 'Hallo!' |
| + | </pre> |
| + | |
| + | == Bytes in Python== |
| + | Bytes haben in Python, anders als in anderen Programmiersprachen, eine besondere Aufgabe. Sie dienen nur zur Aufbereitung von Werten für die serielle Datenübertragung. Hierbei werden die Werte Byteweise übertragen und die Werte dazu in Bytes zerlegt. |
| + | <br> |
| + | Mit den Funktionen/Methoden '''bytes()''', '''bytearray()''', '''.to_bytes()''', .'''from_bytes()''' oder '''.encode()''' und '''.decode()''' werden Werte in eine Reihe von Bytes übersetzt: |
| + | <!---- |
| + | <pre> |
| + | >>> 'Hallo!'.encode('utf-8') |
| + | b'Hallo!' |
| + | >>> |
| + | |
| + | >>> bytes('Hallo!', 'utf-8') |
| + | b'Hallo!' |
| + | |
| + | >>> bytearray([25]) |
| + | bytearray(b'\x19') |
| + | |
| + | # aber Achtung: |
| + | >>> bytearray([260]) |
| + | bytearray(b'\x04') |
| + | |
| + | >>> bytearray(5) |
| + | bytearray(b'\x00\x00\x00\x00\x00') |
| + | |
| + | # Hier noch etwas zu bytearray: |
| + | >>> b = bytearray(5) |
| + | >>> b |
| + | bytearray(b'\x00\x00\x00\x00\x00') |
| + | >>> b[0] = 25 |
| + | >>> b |
| + | bytearray(b'\x19\x00\x00\x00\x00') |
| + | </pre> |
| + | ----> |
| + | |
| + | Zur Umwandlung von Bytes in String oder Integer stehen die Funktionen '''.decode()''', '''str()''' und '''int.from_bytes()''' zur Verfügung. |
| + | |
| + | <!---- |
| + | <pre> |
| + | >>> enc = 'Hallo!'.encode('utf-8') |
| + | >>> enc |
| + | b'Hallo!' |
| + | >>> enc.decode('utf-8') |
| + | 'Hallo!' |
| + | |
| + | # oder: |
| + | |
| + | >>> str(enc, 'utf-8') |
| + | 'Hallo!' |
| + | |
| + | |
| + | >>> x = bytearray([260]) |
| + | int.from_bytes(x, 'big') |
| + | 4 |
| + | </pre> |
| + | |
| + | === Integer in Bytes und zurück=== |
| + | |
| + | <pre> |
| + | # Integer in bytearray und zurück: |
| + | |
| + | >>> x = 5000 |
| + | >>> y = x.to_bytes(5, 'big') |
| + | >>> y |
| + | b'\x00\x00\x00\x13\x88' |
| + | |
| + | >>> int.from_bytes(y, 'big') |
| + | 5000 |
| + | |
| + | # Liste in bytearray und zurück: (Werte: 0 ... 255) |
| + | >>> x = [1,2,3,4,5] |
| + | >>> y = bytearray(x, 'big') |
| + | >>> y |
| + | bytearray(b'\x01\x02\x03\x04\x05') |
| + | |
| + | >>> list(y) |
| + | [1, 2, 3, 4, 5] |
| + | >>> |
| + | </pre> |
| + | ----> |
| + | '''int.from_bytes()''' hat drei mögliche Parameter. Währen das 2. und 3. in CPython als Keyword-Argument übergeben wird, sind in Micropython '''alle drei Position-Arguments'''. |
| + | <pre> |
| + | >>> bytes = b'\xAA\x00\x00\x00' |
| + | integer = int.from_bytes(bytes, 'little', True) |
| + | print(integer) |
| + | 170 |
| + | </pre> |
| + | |
| + | == Bytes und Strings== |
| + | |
| + | Möglichkeiten Strings in eine Bytefolge zu konvertieren: |
| + | |
| + | <pre> |
| + | >>> text = 'Hallo Micropython auf dem Pico W.' |
| + | |
| + | >>> st1 = bytes(text, 'utf-8') |
| + | >>> st1 |
| + | b'Hallo Micropython auf dem Pico W.' |
| + | |
| + | >>> st2 = bytearray(text, 'utf_8') |
| + | >>> st2 |
| + | bytearray(b'Hallo Micropython auf dem Pico W.') |
| + | |
| + | >>> st3 = text.encode('utf-8') |
| + | >>> st3 |
| + | b'Hallo Micropython auf dem Pico W.' |
| + | </pre> |
| + | |
| + | Von einer Bytefolge zurück zum String: |
| + | <pre> |
| + | >>> rt1 = str(st1, 'utf-8') |
| + | >>> rt1 |
| + | 'Hallo Micropython auf dem Pico W.' |
| + | |
| + | >>> rt2 = st1.decode('utf-8') |
| + | >>> rt2 |
| + | 'Hallo Micropython auf dem Pico W.' |
| + | |
| + | # geht auch vom bytearray: |
| + | >>> rt3 = str(st2, 'utf-8') |
| + | >>> rt3 |
| + | 'Hallo Micropython auf dem Pico W.' |
| + | |
| + | >>> rt4 = st2.decode('utf-8') |
| + | >>> rt4 |
| + | 'Hallo Micropython auf dem Pico W.' |
| + | </pre> |
| + | Wenn String verarbeitet werden muss immer die Codierung angegeben werden! Bei Micropython ist das meist ''''utf-8''''. |
| + | |
| + | == Bytes und Integer== |
| + | '''Integer in Bytearray/Bytes umwandeln.''' |
| + | <pre> |
| + | >>> bytearray(5) |
| + | bytearray(b'\x00\x00\x00\x00\x00') |
| + | |
| + | >>> bytearray([5]) |
| + | bytearray(b'\x05') |
| + | |
| + | >>> bytearray((5,)) |
| + | bytearray(b'\x05') |
| + | |
| + | >>> x = 5 |
| + | |
| + | >>> x.to_bytes(5, 'big') |
| + | b'\x00\x00\x00\x00\x05' |
| + | |
| + | >>> x.to_bytes(1, 'big') |
| + | b'\x05' |
| + | |
| + | >>> 5.to_bytes(1, 'big') |
| + | Traceback (most recent call last): |
| + | File "<stdin>", line 1 |
| + | SyntaxError: invalid syntax for number |
| + | </pre> |
| + | |
| + | '''vom Bytearray zurück zum Integer''' |
| + | |
| + | <pre> |
| + | >>> y = bytearray(5) |
| + | >>> y |
| + | bytearray(b'\x00\x00\x00\x00\x00') |
| + | |
| + | >>> y[0] = 7 |
| + | >>> y |
| + | bytearray(b'\x07\x00\x00\x00\x00') |
| + | |
| + | >>> int.from_bytes(y, 'big') |
| + | 30064771072 |
| + | >>> hex(int.from_bytes(y, 'big')) |
| + | '0x700000000' |
| + | </pre> |
| + | |
| + | == Bytes und Listen== |
| + | |
| + | Liste in bytearray und zurück: (Werte: 0 ... 255) |
| + | |
| + | <pre> |
| + | >>> x = [1,2,3,4,5] |
| + | |
| + | >>> y = bytearray(x, 'big') |
| + | |
| + | >>> y |
| + | bytearray(b'\x01\x02\x03\x04\x05') |
| + | |
| + | >>> list(y) |
| + | [1, 2, 3, 4, 5] |
| + | </pre> |
| + | |
| + | '''Aber Achtung:''' |
| + | |
| + | <pre> |
| + | >>> int.from_bytes(y, 'big') |
| + | 4328719365 |
| + | >>> hex(int.from_bytes(y, 'big')) |
| + | '0x102030405' |
| + | </pre> |
| + | |
| + | Wenn man nicht aufpasst wird aus der Liste eine Zahl! |
| | | |
| == Links:== | | == Links:== |
| * http://docs.micropython.org/en/latest/library/machine.UART.html#machine.UART | | * http://docs.micropython.org/en/latest/library/machine.UART.html#machine.UART |
| * http://docs.micropython.org/en/latest/rp2/quickref.html | | * http://docs.micropython.org/en/latest/rp2/quickref.html |
| + | |
| + | |
| + | ==Navigation== |
| + | [[Micropython_Kurs_2023_-_Teil_2|Zurück zur "Micropython Kurs 2023 Teil 2" Startseite]]<br> |
| + | [[Micropython Kurs 2023|Zurück zur "Micropython Kurs 2023" Startseite]]<br> |
| + | [[Programmieren|Zurück zur Programmieren Startseite]]<br> |
| + | [[Attraktor_Wiki|Zurück zur Wiki Startseite]]<br> |
inzwischen sind diese Normen identisch.
Die Übertragungsgeschwindigkeit wird in Baud (Bits/Sekunde) angegeben.
Das Parity-Bit ist eine einfache Fehlerprüfung.
Die Spannung kann 3...15V betragen.
In der Microcontrollertechnik wird der Aufwand der positiven und negativen Spannungen nicht realisiert. Hier wird die Betriebsspannung (5V, 3V3) als Logisch 1 und GND als Logisch 0 verwendet. Das wird als TTL bezeichnet, in Anlehung an die digitale TTL Famile, die mit 5 Volt arbeitet.
Bei einer synchronen Übertragung werden Daten und Takt parallel übertragen, so dass die Daten immer mit dem Takt synchron sind. Selbst bei langen Übertragungen werden die Daten immer zum richtigen Zeitpunkt abgetastet. Beispiele hier für sind SPI und I2C.
Bei der asynchronen Übertragung wird kein Takt übertragen. Deshalb muss das Timing von Sender und Empfänger sehr genau sein. Da sich ein Auseinanderlaufen des Timings bei Sender und Empfänger nicht vermeiden lässt, muss bei der asynchronen Übertragung immer wieder eine Synchronisierung zwischen Sender und Empfänger stattfinden. Dazu dient das Startbit. Wenn es vom Empfänger dedektiert wird beginnt sein Timing bei Null. Die Übereinstimmung vom Sender- und Empfängertiming muss dann nur noch << 8% sein.
In Microcontrollern sind häufig USART's implementiert. Das sind UART's die auch synchrone Übertragungen ermöglichen.
Es gibt im Pico 2 UARTs, UART0 und UART1. Die möglichen Pins für die UARTs zeigen die Tabellen.
Um auf dem Demoboard die serielle UART-Schnittstelle zu testen, muss an den Expansion-Anschlüssen eine Stecker- oder Buchsenleiste eingelötet werden. Dann müssen folgende Anschlüsse miteinander verbinden werden:
GP 0 -> GP 5
GP 1 -> GP 4
Wie man oben sieht ist die Initialisierung unter Verwendung der Defaultparameter sehr einfach.
Für unsere weiteren Versuche muss immer zuerst folgender Code ausgeführt werden:
Zahlen können nicht so einfach übertragen werden. Sie müssen erst in einen String umgewandelt werden:
Für die Übertragung muss der String in eine Bytefolge (Bytestring - b' ') umgewandelt werden. Das macht die .write() Methode intern. Die .read() Methode wandelt diesen aber nicht wieder zurück.
Für die Umwandlung von Bytes zurück in einen String gibt es zwei Wege:
Bytes haben in Python, anders als in anderen Programmiersprachen, eine besondere Aufgabe. Sie dienen nur zur Aufbereitung von Werten für die serielle Datenübertragung. Hierbei werden die Werte Byteweise übertragen und die Werte dazu in Bytes zerlegt.
Mit den Funktionen/Methoden bytes(), bytearray(), .to_bytes(), .from_bytes() oder .encode() und .decode() werden Werte in eine Reihe von Bytes übersetzt:
Wenn String verarbeitet werden muss immer die Codierung angegeben werden! Bei Micropython ist das meist 'utf-8'.
Liste in bytearray und zurück: (Werte: 0 ... 255)