Dieses Tutorial beschreibt die MSP430 UART-Schnittstelle anhand eines Beispiels am Launchpad EXP430G2 (MSP430G2553 wird benutzt). Wer die UART-Funktion beim MSP430G2553 verstanden hat, kann leicht das Wissen bei allem Mikrocontroller der MSP430-Serie einsetzen, da die Bezeichnung sich sehr ähnelt.

Zuerst werden Anhand des Datenblattes und User’s Guide kurz die Grundlagen der UART-Schnittstelle erklärt, daraufhin wird auf die Pin-Beschreibung der MSP430-Serie eingegangen, um zuletzt mit einer Beispielanwendung Daten Seriell zwischen PC und MSP430G2553 auszutauschen.

Was für das MSP430 UART-Tutorial benötigt wird

Um das Tutorial nachzuvollziehen werden folgende Informationen (Links dazu) benötigt:

EXP430G2-Launchpad (Link zu TI)
User’s Guide MSP-EXP430G2 Launchpad (SLAU318G.pdf)
Datenblatt MSP430G2553 (SLAS735J.pdf)
User’s Guide MSP430x2xxx (SLAU144J.pdf)
ZIP mit Beispielcode von TI (SLAC485h.zip)
Hyperterm oder Putty (Link zu H-Term)

MSP430 UART Grundlagen

Die MSP430-Kontroller bieten nicht das ganze Spektrum an Möglichkeiten bezüglich der UART-Schnittstelle an, dies tuen generell aber auch nur die wenigsten Mikrocontroller und ist auch nicht weiter schlimm. UART wird typischer weise nur für 2 Teilnehmer genutzt (kein Master/Slave-System) und es werden dazu nur 3 Leitungen benötigt:

TX Sendeleitung
RX Empfangsleitung
GND gemeinsame erde

Zu beachten ist das beide Teilnehmer eine gemeinsame Erde und das gleiche Spannungsniveau von 3,3 V aufweisen. Viele ICs benötigen jedoch einen 5 V-Pegel. Wenn 5 V direkt am MSP430 anliegen, kann es sein, dass der Pin oder gar der ganze Mikrocontroller zerstört werden. Abhilfe verschafft man sich indem eine 5 V zu 3,3 V Spannungsteiler zwischen den Teilnehmern auf der RX-Leitung des MSP430 eingesetzt wird.

Zunächst wird das User’s Guide benötigt, Kapitel 18; Seiten 474 bis 492. Ein typisches UART-Beispielsignal kann in der nächsten Abbildung betrachtet werden. Das Signal ist Inactive High, was so viel heißt, dass das Signal auf den High-Pegel (etwa 3,3 V) ruht. Vergleiche dazu auch die nachfolgende Abbildung, bei der als Beispiel (21)₁₀ oder auch (15)_H gesendet wird.

Abb. 1: UART Beispielsignal

Start Bit: Ein Frame beginnt immer mit einem Startbit (1 Bit), dies dient dazu damit der Kommunikationspartner, nach einer Pause erkennt, wann die Kommunikation startet.

Daten: Der tatsächliche Datensatz ist bei TI immer 7 oder 8 Bit lang. Dabei wird zuerst das LSB (Lost Significant Byte) gesendet, also das niederwertigste Bit.

Beispiel: Über UART wird der Datensatz 3 als LSB gesendet

(3)₁₀ = (0000 0011)₂, Das Niederwertigste Bit beginnt rechts, es wird gesendet:

1 1 0 0 0 0 0 0

Parität: Das Paritätsbit wird als Kontrolle eingesetzt um mögliche Übertragungsfehler abzufangen. Es Kann zwischen keine (kein Paritätsbit genutzt), gerade (in Eng. Even, die Summe der Einsen im Datensatz ergibt eine gerade Zahl) oder ungerade (in Eng. Odd, die Summe der Einsen im Datensatz ergibt eine ungerade Zahl) gewählt werden.

Beispiel: UART wird auf Odd eingestellt und Datensatz 3 gesendet.

(3)₁₀ = (0000 0011)₂ = 2 Einsen als Odd, daher die Summe der Einsen im Datensatz ergibt eine gerade Zahl, daher Bit auf 1.

Beispiel: UART wird auf Even eingestellt und Datensatz 3 gesendet.

(3)₁₀ = (0000 0011)₂ = 2 Einsen als Even, daher die Summe der Einsen im Datensatz ergibt keine ungerade Zahl, daher Bit auf 0.

Stoppbit: Das Frame wird mit 1 oder 2 Stoppbits, welches ausschließlich zu Synchronisierung der Nachrichten dient, beendet. Im Beispiel wird 1 Stoppbit genutzt.

Baudrate: Abschließend muss noch die Baudrate, also die Geschwindigkeit mit der die Frames übertragen werden, eingestellt werden. TI bietet auf der Seite 486 par typische Baudratenwerte für verschiedene Frequenzen an. Falls jemand eine andere Baudrate benötigt, muss er diese ausrechnen, wie das gemacht wird, wird im Teil der Programmierung erklärt.

Wie erkenne ich die MSP430 UART-Pins?

Dazu reicht ein Blick ins Datenblatt, entweder auf Seite 3 oder 4 wo das Pin-Out zu sehen oder bei den Seiten 6 bis 8 wo die Pin-Bezeichnung zu finden ist. Zu beachten ist, dass die Sende- und Empfange-Pins für UART und SPI die gleichen sind. Beim Programmieren des Moduls gibt TI dem Anwender die Möglichkeit zwischen SPI und UART auszuwählen (mehr dazu im Teil Programmierung).

Abb. 2: Pin-Out vom MSP430G2553

Bei der MSP430-Serie sind die UART-Pins grundsätzlich mit als RXD und TXD gekennzeichnet. Zum Beispiel werden beim MSP430G2553 die UART-Pins als UCA0TXD und UCA0RXD bezeichnet. Wobei der MSP430G2553 nur einen Kanal (den UCA0) für UART zur Verfügung hat. Als alternatives Beispiel der MSP430F2619 welcher 2 Kanäle für UART aufbringen kann (die UCA0 und UCA1). Hier werden die UART-Pins als UCA0TXD, UCA0RXD und UCA1TXD, UCA1RXD gekennzeichnet. Zu beachten ist das TXD zum Senden und RXD zum Empfangen von Daten aus Sicht des Mikrocontrollers steht.

Programmierung

Vorgefertigte TI-Beispiele können auch im ZIP-Ordner von TI (Link dazu) gefunden werden und sind äußerst hilfreich.

Nun wird das User’s Guide benötigt, Kapitel 15 ab Seite 429. Wir müssen die UART-Schnittstelle einstellen bevor wir diese nutzen können. Allgemein müssen:

Initialisierung vom MSP430 UART-Modul
Empfangen von Daten
Senden von Daten

programmiert werden.

Prinzipiell kann folgender Pseudocode für die Initialisierung des UART-Moduls als Vorlage dienen:

// 0. Starte Mikrocontroller, wähle Frequenz
// 1. Wähle Spezialpins für UART
// 2. Konfiguriere UART-Register
// 3. Resete UART-Modul um Einstellungen zu übernehmen
// 4. Aktiviere UART-Interrupts (optional falls erwuchst)

// 0. Starte Mikrocontroller, wähle Frequenz

// 1. Wähle Spezialpins für UART

// 2. Konfiguriere UART-Register

// 3. Resete UART-Modul um Einstellungen zu übernehmen

// 4. Aktiviere UART-Interrupts (optional falls erwuchst)

Als Beispiel nutze ich den TI-Beispielcode von SLAC485h. Folgende Einstellungen: 9600 Baud, 8 Bit, Keine Parität, 1 Stopbit, Empfange Daten per Interrupt)

// 0. Starte Mikrocontroller, wähle Frequenz

WDTCTL = WDTPW + WDTHOLD;     // Stoppe WDT
DCOCTL = 0;                   // Stelle Frequenz ein …
BCSCTL1 = CALBC1_1MHZ;        // …
DCOCTL = CALDCO_1MHZ;         //.-

// 1. Wähle Spezialpins für UART

P1SEL = BIT1 + BIT2 ;         // P1.1 = RXD, P1.2=TXD
P1SEL2 = BIT1 + BIT2 ;        // P1.1 = RXD, P1.2=TXD

// 2. Konfiguriere UART-Register

UCA0CTL1 |= UCSSEL_2;         // Wähle Clock des MCUs, hier Haupt-Clock
UCA0BR0 = 104;                // 1MHz 9600
UCA0BR1 = 0;                  // 1MHz 9600
UCA0MCTL = UCBRS0;            // Modulation UCBRSx = 1

// 3. Resete UART-Modul um Einstellungen zu übernehmen

UCA0CTL1 &= ~UCSWRST;         // Resete UART-Modul

// 4. Aktiviere UART-Interrupts (optional falls erwuchst)

IE2 |= UCA0RXIE;              // Aktiviere RX-Interrupt

// 0. Starte Mikrocontroller, wähle Frequenz

WDTCTL = WDTPW + WDTHOLD; // Stoppe WDT

DCOCTL = 0; // Stelle Frequenz ein …

BCSCTL1 = CALBC1_1MHZ; // …

DCOCTL = CALDCO_1MHZ; //.-

// 1. Wähle Spezialpins für UART

P1SEL = BIT1 + BIT2 ; // P1.1 = RXD, P1.2=TXD

P1SEL2 = BIT1 + BIT2 ; // P1.1 = RXD, P1.2=TXD

// 2. Konfiguriere UART-Register

UCA0CTL1 |= UCSSEL_2; // Wähle Clock des MCUs, hier Haupt-Clock

UCA0BR0 = 104; // 1MHz 9600

UCA0BR1 = 0; // 1MHz 9600

UCA0MCTL = UCBRS0; // Modulation UCBRSx = 1

// 3. Resete UART-Modul um Einstellungen zu übernehmen

UCA0CTL1 &= ~UCSWRST; // Resete UART-Modul

// 4. Aktiviere UART-Interrupts (optional falls erwuchst)

IE2 |= UCA0RXIE; // Aktiviere RX-Interrupt

Zu 0: Zunächst (und das gilt für jeden MSP430er) muss der Watchdog gestoppt werden. Sonst verharrt der Mikrocontroller in diesem Zustand und das Programm läuft nicht. Daraufhin sollte die Frequenz eingestellt werden, mit der der Mikrocontroller laufen soll. Hat der Anwender keine ausgewählt, läuft der Mikrocontroller mit seinem Standardwert von 1MHz.

Zu 1: Im Fall vom MSP430G2553 ist es eindeutig, dass wir den UCA0-Kanal (Siehe Pins 1.1 und 1.2 vom Pin-Out der Abbildung 2) für UART nutzen, da kein anderer zur Verfügung steht. Das Spezialregister des Kontrollers spricht man über PxSEL und PxSEL2 an (falls der MCU die Option PxSEL2 anbietet, die meisten verfügen über kein PxSEL2). Aus dem Pin-Out können wir ablesen das wir Port 1 und Pins 1 und 2 nutzen. Daher nutzen wir auch die P1SEL- und P1SEL2-Register. Weitere GPIO-Eistellungen müssen nicht betätigt werden.

Aus dem Pin-Out konnten wir auch auslesen (UCA0RXD und UCA0TXD)welchen UART-Kanal wir nutzen wollen.

Zu 2: Der komplizierteste Teil der Initialisierung. Zunächst wollen wir die Baudrate einstellen. Dazu nutzen wir folgende Formel:

$UCA0BRx=INT(\frac{F_{CPU}}{{BAUD_{SOLL}}})$

In der Formel steht F_CPU für die Frequenz mit dem das UART-Modul läuft. Da wir zuvor UCSSEL_2 als Clock (Hauptclock) ausgewählt haben ist F_CPU = 1 MHz. BAUD_SOLL ist die gewünschte Baudrate mit der UART Informationen senden und empfangen kann. Abschließen soll die INT-Operation dazu sorgen, dass nur Ganzzahlen genutzt werden können. Für unser Beispiel heißt das:

$UCA0BRx=INT(\frac{F_{CPU}}{{BAUD_{SOLL}}})=INT(\frac{1 MHz}{{9600}})=INT(104)=104$

Nun beachte das UCA0BRx Register sich in zwei 8-Bit Register, in Low- und High-Byte, trennt. UCA0BR0 steht für Low und UCA0BR1 für High. Die 8-Bit-Register können nur Zahlen zwischen 0 bis 255 darstellen. Im Beispiel ist 104 rausgekommen (unter 255) also wird nur das Low-Byte UCA0BR0 benötigt. Das UCA0BR1 muss 0 sein.

UCA0BR0 = 104;                // 1MHz 9600 Low-Byte
UCA0BR1 = 0;                  // 1MHz 9600 High-Byte

1 2	UCA0BR0 = 104; // 1MHz 9600 Low-Byte UCA0BR1 = 0; // 1MHz 9600 High-Byte

Um das ganze etwas eindeutiger zu machen, kurz ein zweites Beispiel. Nun soll wiederum 9600 Baud genutzt werden, jedoch soll die Frequenz des Mikrocontrollers 12 MHz sein. Aus der Formel rechnen wir nun:

$UCA0BRx=INT(\frac{F_{CPU}}{{BAUD_{SOLL}}})=INT(\frac{12 MHz}{{9600}})=INT(104)=1250$

Da 1250 größer 255 ist werden beide Bytes benötigt. Das 1250 dezimal ist als Hex etwas besser lesbar und wird zu 0x04E2. Hier können wir sofort erkennen welches das High- und welches das Low-Byte ist. Daher schreiben wir nun:

UCA0BR0 = 0xE2;                // Low-Byte 12MHz 9600 Low-Byte
UCA0BR1 = 0x04;                // High-Byte 12MHz 9600 High-Byte

1 2	UCA0BR0 = 0xE2; // Low-Byte 12MHz 9600 Low-Byte UCA0BR1 = 0x04; // High-Byte 12MHz 9600 High-Byte

In dem zweiten Beispiel kamen direkt Ganzzahlen raus. Öfters ist dies nicht der Fall und muss nachkorrigiert werden. Dies erledigen wir mit dem UCA0MCTL-Register. Der Wert berechnet sich wie folgt:

$UCBRSx=round[(\frac{F_{CPU}}{{BAUD_{SOLL}}}-INT(\frac{F_{CPU}}{{BAUD_{SOLL}}})\cdot8]=round[(\frac{F_{CPU}}{{BAUD_{SOLL}}}-UCA0BRx)\cdot8]$

Der Term Rechts ist der Wert den wir schon oben einmal ausgerechnet haben. Für beide Beispiele wird das Ergebnis 0 sein. Ein Beispiel mit einer krummen Zahl. Wir wollen nun eine Baudrate von 38400 bei 12MHz Clock eintellen. Für UCA0BRx rechnen wir nun den Wert 312 aus. Für UCBRSx rechnen wir wie folgt:

$UCBRSx=round[(\frac{F_{CPU}}{{BAUD_{SOLL}}}-UCA0BRx)\cdot8]=round[(312,5-312)*8]=round(4)=4$

Daher muss UCBRS0 = 4 gesetzt werden. Die Wert kannst du auch mit der Tabelle 15-4 auf Seite 424 des User’s Guide vergleichen.

Anwendungsbeispiel MSP430 UART und Hyperterm

In diesem Beispiel sollen Daten zwischen dem Launchpad EXP430G2 (MSP430G2553 drauf) und dem PC ausgetauscht werden.

Schritt 1: UART-Einstellungen

Zunächst einmal muss willkürlich festgelegt werden, mit welchen Parameter beide UART-Teilnehmer laufen sollen. Es wird festgelegt:

Baudrate 9600 Baud
8 Bit
Keine Parität
1 Stopbit

Schritt 2: Hardware vorbereiten

Nun betrachten wir kurz die Hardware (Launchpad). Wie schon erwähnt sind die Pins 1.1 und 1.2 für UART zuständig. Das Launchpad verfügt über einen USB zu UART Wandler und kann daher direkt mit dem PC verbunden werden. Praktischer weise kann das Versorgungskabel vom Launchpad auch für UART-Kommunikation genutzt werden. Dazu müssen jede glich die Jumper für Hardware-UART eingesteckt sein (vgl. Bild 3 – HW-UART).

MSP430 Tutorial Pin-Out EXP430G2 mit MSP430G2553

Abb. 3: Launchpad EXP430G2 Pin-Out

Schritt 3: MSP430 UART implementieren (Teilnehmer 1 von 2)

Um auf dem MSP430G2553 UART zu implementieren werden folgende Funktionen benötigt:

Initialisiere MSP430 (Watchdog, Frequenz)
Initialisiere UART
Empfange Daten über UART
Sende Daten über UART
Main-Funktion die alles abarbeitet

Der vollständige Code kann unten betrachtet werden:

#include "msp430g2553.h"

// ----------------- Gl. Variablen --------------------------------------------- 

volatile unsigned char rcv;                                                     // Global variable für empfangene Daten per IR aus UART UCA0

// ------------------ PROTOTYPEN -----------------------------------------------

void UART_init(void);                                                           // Initiaisiert UART-Modul UCA0
void UART_send_string(char* str);                                               // Sende String via UCA0
__interrupt void UART_receive_ISR(void);                                        // Empfange char via UCA0-ISR

// -------------------- MAIN ---------------------------------------------------

void main( void )
{
   WDTCTL = WDTPW + WDTHOLD;                                                    // Stoppe WDT
   
   DCOCTL = 0;                                                                  // Lege Frequenz fest ...
   BCSCTL1 = CALBC1_1MHZ;                                                       // ...
   DCOCTL = CALDCO_1MHZ;                                                        // .-
   
   UART_init();                                                                 // Initialisiere UART

   _EINT();                                                                     // Aktiviere globale IRs
   
   while (1)                                                                    // Forever
   { 
     if (rcv == 'a')                                                            //  Habe a empfangen?
     {
       rcv = 0x00;                                                              // Setze Empfangsdaten zurück
       UART_send_string("Hello world");                                         // Sende Begrüßung
     } // if
   } // while
}

// ------------------ FUNKTIONEN -----------------------------------------------

//
// Initialisiert das UART-Modul UCA0 des MSP430G2553. Dazu werden Pins 1.1 und 
// 1.2 für TX und RX eingestellt. Baudrate 9600 bei einer Frequenz von 1MHz.
//
void UART_init(void)
{
  P1SEL = BIT1 + BIT2 ;                                                         // Pezialfunktion UART auswählen P1.1 = RXD, P1.2=TXD ...
  P1SEL2 = BIT1 + BIT2 ;                                                        // .-

  UCA0CTL1 |= UCSSEL_2;                                                         // SMCLK
  UCA0BR0 = 104;                                                                // 1MHz 9600
  UCA0BR1 = 0;                                                                  // 1MHz 9600
  UCA0MCTL = UCBRS0;                                                            // Modulation UCBRSx = 1
  UCA0CTL1 &= ~UCSWRST;                                                         // **Initialize USCI state machine**
  
  UC0IE |= UCA0RXIE;                                                            // Aktiviere USCI_A0 RX-Interrupt
}

//
// Sende einen String über UART-Modul UCA0 des MSP430G2553. 
//
void UART_send_string(char* str)
{
  while (*str != 0)                                                              // Solange nicht das Terminiert-Zeichen kommt ...
  {
    while (!(IFG2 & UCA0TXIFG));		                                 // Warten bis USART0 TX-Puffer frei (leer) ...
    UCA0TXBUF = *str++;                                                          // Zeichen dazufügen.-
  } // while
}

//
// Empfange einen unsigned char per Interrupt über UART-Modul UCA0 des 
// MSP430G2553.
//
#pragma vector=USCIAB0RX_VECTOR
__interrupt void UART_receive_ISR(void)
{
  while (!(IFG2&UCA0RXIFG));                                                    // Warte bis Zeichen empfangen ist ...
  rcv = UCA0RXBUF;                                                              // und ese es aus.-
}

#include "msp430g2553.h"

// ----------------- Gl. Variablen ---------------------------------------------

volatile unsigned char rcv; // Global variable für empfangene Daten per IR aus UART UCA0

// ------------------ PROTOTYPEN -----------------------------------------------

void UART_init(void); // Initiaisiert UART-Modul UCA0

void UART_send_string(char* str); // Sende String via UCA0

__interrupt void UART_receive_ISR(void); // Empfange char via UCA0-ISR

// -------------------- MAIN ---------------------------------------------------

void main( void )

{

WDTCTL = WDTPW + WDTHOLD; // Stoppe WDT

DCOCTL = 0; // Lege Frequenz fest ...

BCSCTL1 = CALBC1_1MHZ; // ...

DCOCTL = CALDCO_1MHZ; // .-

UART_init(); // Initialisiere UART

_EINT(); // Aktiviere globale IRs

while (1) // Forever

{

if (rcv == 'a') // Habe a empfangen?

{

rcv = 0x00; // Setze Empfangsdaten zurück

UART_send_string("Hello world"); // Sende Begrüßung

} // if

} // while

}

// ------------------ FUNKTIONEN -----------------------------------------------

// Initialisiert das UART-Modul UCA0 des MSP430G2553. Dazu werden Pins 1.1 und

// 1.2 für TX und RX eingestellt. Baudrate 9600 bei einer Frequenz von 1MHz.

void UART_init(void)

{

P1SEL = BIT1 + BIT2 ; // Pezialfunktion UART auswählen P1.1 = RXD, P1.2=TXD ...

P1SEL2 = BIT1 + BIT2 ; // .-

UCA0CTL1 |= UCSSEL_2; // SMCLK

UCA0BR0 = 104; // 1MHz 9600

UCA0BR1 = 0; // 1MHz 9600

UCA0MCTL = UCBRS0; // Modulation UCBRSx = 1

UCA0CTL1 &= ~UCSWRST; // **Initialize USCI state machine**

UC0IE |= UCA0RXIE; // Aktiviere USCI_A0 RX-Interrupt

}

// Sende einen String über UART-Modul UCA0 des MSP430G2553.

void UART_send_string(char* str)

{

while (*str != 0) // Solange nicht das Terminiert-Zeichen kommt ...

{

while (!(IFG2 & UCA0TXIFG)); // Warten bis USART0 TX-Puffer frei (leer) ...

UCA0TXBUF = *str++; // Zeichen dazufügen.-

} // while

}

// Empfange einen unsigned char per Interrupt über UART-Modul UCA0 des

// MSP430G2553.

#pragma vector=USCIAB0RX_VECTOR

__interrupt void UART_receive_ISR(void)

{

while (!(IFG2&UCA0RXIFG)); // Warte bis Zeichen empfangen ist ...

rcv = UCA0RXBUF; // und ese es aus.-

}

Schritt 4: Hyperterm oder Putty vorbereiten (Teilnehmer 2 von 2)

Mit Hyperterm (oder alternativ Putty) könnt Ihr die empfangenen Daten visualisieren. Dazu muss Ihr zuerst den Comport auswählen an dem das Launchpad hängt und auch die gleichen UART-Einstellungen aufweisen wie der Mikrocontroller (vgl. Bild 4).

Abb. 4: UART Kommunikation über HTerm

In diesem Fall nutze ich den Comport 4 (Bild 4 – oben links) und die Einstellungen wie im Schritt 1 beschrieben. Da ich String-Werte Senden und Empfangen möchte, bleibt nur das String-Kästchen (Ascii) angeklickt.

Schritt 5: Testen

Dazu öffne das HTerm Programm, stelle die Baudrate auf 9600 ein, wähle den geeigneten Comport aus und sende den String „a“.

Ich habe im Schritt 3 einprogrammiert das die Kommunikation startet, wenn der PC den String-Wert „a“ sendet. Das Launchpad sollte mit „Hello World“ antworten.

Schreibe einen Kommentar Antworten abbrechen

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.

3 Gedanken zu “MSP430 UART Tutorial”

Antwort ↓

Kai R. 12. Dezember 2021 um 19:02 Uhr

Für mich als als MSP430 Einsteiger ist das ein sehr hilfreicher Artikel. Danke dafür. Allerdings hat das Beispiel bei mir so lange nicht funktioniert, bis ich die globale „rcv“ Variable als volatile deklariert habe. Die hat der Compiler immer schön wegoptimiert. Deshalb sollte das Beispiel dahingehend geändert werden.
- Antwort ↓
  
  k.t.evangelos Autor des Beitrags 14. Dezember 2021 um 16:07 Uhr
  
  Hi, vielen Dank für diese Anmerkung! Mit meinem Compiler trat dies nicht auf, deshalb ist es mir nicht aufgefallen. Werde es natürlich heute schon ändern. Falls möglich würde ich gerne wissen mit welchen Compiler und Entwicklungsumgebung dies auftrat.
  
  MfG
  - Antwort ↓
    
    Kai R. 14. Dezember 2021 um 17:02 Uhr
    
    Es war unter PlatformIO
    toolchain-timsp430 1.40603.210219 (4.6.3)
    msp430-gcc.exe
    
    Standard build_flags (is glaube ich -Os).
    
    Was mir noch aufgefallen ist. Im Text ist die Bezeichnung der Paritätsbits (odd/ even) vertauscht. „Odd“ ist ungerade und „even“ ist gerade. Bei deiner Erklärung zum Paritätsbit ist es anders herum beschrieben.

electrodummies

einfach verstehen