B.8  Aufgaben aus Kapitel 8

1.
Wie ist der Begriff Baudrate definiert? Was bezeichnet er?
Die Baudrate ist ein Begriff der Nachrichtentechnik und bezeichnet die Datenrate auf einem Datenkanal. Sie ist definiert als die Anzahl der Symbole pro Sekunde. Bei einer einfachen binären 1-Draht-Schnittstelle ist das Symbol 1 Bit.

 
 

2.
Wie lautet die Pinbelegung einer 25-poligen SUB-D-Buchse der RS232-Schnittstelle? Was ist dabei besonders zu beachten?
 




Name Pin 25-pol.Pin 9-pol.




Common Ground Pin 1




TxD Transmit Data Pin 2 Pin 3




RxD Receive Data Pin 3 Pin 2




RTS Request to Send Pin 4 Pin 7




CTS Clear to Send Pin 5 Pin 8




DSR Dataset Ready Pin 6 Pin 6




GND Ground Pin 7 Pin 5




DCD(Data) Carrier Detect Pin 8 Pin 1




DTRData Terminal Ready Pin 20 Pin 4




RI Ring Indicator Pin 22 Pin 9





 
Besonders tückisch ist die genau reziproke Belegung der TxD/RxD-Leitungen. Hier vertut man sich leicht.

 
 

3.
Was sind die wesentlichen Unterschiede zwischen RS232, SPI und I2C?
RS232:
  • Zwei Datenleitungen: send und receive, keine Taktleitung
  • invertierte Logikpegel: HIGH: -12V, LOW: +12V
  • Datenrahmen: Start-Bit, 7 oder 8 Datenbits, Parity-Bit, 1, 1.5 oder 2 Stopp-Bits

I2C:

  • Eine Datenleitung zur bidirektionalen Übertragung, eine Taktleitung
  • Übertragung in 8-Bit-Blöcken, Bestätigung durch Acknowledge-Signale
  • Slave-Auswahl durch Adresse

SPI:

  • zwei Datenleitungen (MOSI, MISO), eine Taktleitung
  • Übertragung beliebiger Bitfolgen
  • Auswahl durch CS-Leitung
  • 4 SPI-Moden, bestimmt durch Clock-Polarität und -Phase

 
 

4.
Welche Schnittstellen hat der MSP430F2013?
ein Universal-Serial-Interface (USI) für SPI and I2C.

 
 

5.
Wie kann eine RS232-Schnittstelle mit dem EzMSP430-Kit realisiert werden? Schreibe hierfür ein Programm.
Der im Starterkit verwendete MSP430F2013 hat keine vom Prozessor unterstützte RS232-Schnittstelle. Man kann sich aber eine solche mit einem digitalen Portpin auch ”zu Fuß” selbst programmieren. Von Texas Instruments gibt es hier auch schon eine fertig programmierte Lösung in einer Application-Note (slaa307a.pdf).

 
 

6.
Schreibe ein Programm, das eine RS232-Implementierung realisiert, bei der Senden und Empfangen ohne eine Blockierung des Programmflusses erfolgt. Nutze dafür Interrupt-Routinen.
#include <msp430x16x.h> 
 
// Sende- und Empfangsstring müssen global sein 
volatile char sendString[20]; 
volatile char receiveString[20]; 
 
#pragma vector=USART0TX_VECTOR 
__interrupt void USART0_Ausgang (void) 
{ 
   // sende nächstes Byte von sendString 
} 
 
#pragma vector=USART0RX_VECTOR 
__interrupt void USART0_Eingang (void) 
{ 
   //schreibe empfangenes Byte in receiveString 
} 
 
int main ( void ) 
{ 
   ... 
 
   P3SEL  = BIT4+BIT5;          // Ports konfigurieren 
   P3DIR  = BIT4; 
                                // SWRST setzen um Schnittstelle 
   U0CTL  = SWRST;              // konfigurieren zu können 
   U0CTL |= CHAR;               // 8 Bit pro Datenbyte 
   U0TCTL = SSEL1 | TXEPT;      // wähle ACLK und setze TXEPT 
   U0BR0  = 0x68;               // stelle Baudrate ein 
   U0BR1  = 0x00; 
   U0MCTL = 0x04; 
   ME1    |= UTXE0+URXE0;       // Schnittstelle aktivieren 
   U0CTL &= ~SWRST; 
 
   IFG1 &=~ URXIE0+UTXIE0; 
   IE1  |= URXIE0+UTXIE0;       //Interrupts aktivieren 
   _enable_interrupts(); 
 
   //sende erstes Byte von sendString 
   U0TXBUF = sendString[0]; 
   while(1); 
 
}
7.
Schreibe eine Interface-Routine zum RTC-Baustein (Realtime-Clock) PCF 8583, mit der die Uhrzeit ausgelesen und gestellt werden kann.
#include <msp430x16x.h> 
 
int main( void ) 
{ 
  ... 
  //Initialisierungen: Frequenz: 100kHz Adresse: A0 
  P3SEL |= 0x0A;             // I2C-Funktion für Port P3 
  // Konfiguration der I2C-Schnittstelle: 
  U0CTL |= I2C + SYNC;       // SYNC. und I2C-Modus 
  U0CTL &=~ I2CEN; 
  I2CTCTL = I2CSSEL1;        // SMCLK 100kHz 
  I2CPSC = 0x00;             // Vorteiler: SMCLK / 1 
  I2CSCLH = 0x03;            // Dauer HIGH-Pegel 
  I2CSCLL = 0x03;            // Dauer LOW-Pegel 
  I2CNDAT = 0x04;            // vier zu übertragene Bytes 
  I2CSA = 0x50;              // Slave-Adresse 
  U0CTL |= I2CEN;            // I2C aktivieren 
 
 
  // Uhrzeit einstellen 
  U0CTL |= MST;                 // Master Modus 
  I2CTCTL|=I2CSTT+I2CTRX+I2CSTP;// Start-Bedingung 
                                // schreibend 
  // automatisches Stopsignal nach I2CNDAT Bytes 
  // sendet automatisch die Adresse: 10100000 (0xA0 + R/W) 
  I2CDRB = 0x02;                // Offset 2 
 
  // Sekunden(0-59), Minuten(0-59), Stunden(0-23) in BCD 
  while ((I2CIFG & TXRDYIFG) == 0); 
  I2CDRB = Sekunden; 
  while ((I2CIFG & TXRDYIFG) == 0); 
  I2CDRB = Minuten; 
  while ((I2CIFG & TXRDYIFG) == 0); 
  I2CDRB = Stunden; 
  while ((I2CDCTL & I2CBUSY) != 0); 
 
  //Uhrzeit auslesen 
  I2CNDAT=0x01;                // ein zu übertragenes Bytes 
  U0CTL |= MST;                // Master-Modus 
  I2CIFG &=~ ARDYIFG;          // Access-Ready-Flag löschen 
  I2CTCTL |= I2CSTT + I2CTRX;  // Startbedingung, schreibend 
  I2CDRB = 0x02;               // Offset 2 
  while ((I2CIFG & ARDYIFG) == 0);// warte bis Byte gesendet 
  I2CNDAT = 0x03;              // drei zu empfangene Bytes 
  I2CTCTL &=~I2CTRX;           // jetzt lesender Zugriff 
  I2CTCTL |= I2CSTT;           // Restart-Bedingung, lesend 
 
  while ((I2CIFG & RXRDYIFG) == 0); 
  Sekunden = I2CDRB; 
  while ((I2CIFG & RXRDYIFG) == 0); 
  Minuten = I2CDRB; 
  while ((I2CIFG & RXRDYIFG) == 0); 
  Stunden = I2CDRB; 
  I2CTCTL |= I2CSTP; 
}
8.
Schreibe ein Programm, das den Wert eines digitalen Potentiometers (z.B. MCP41X1) einstellt.
Das folgende Listing zeigt, wie der Widerstand auf einen von 257 Werten ( 0 bis Rmax) eingestellt werden kann. Dazu muss ein Wert zwischen 0 und 256 in das 9 Bit breite Wiper-Register geschrieben werden. Der zu sendende Befehl besteht aus 16 Bits: - vier Adressbits, hier 0000 für das Wiper-Register - zwei Command-Bits: hier 00 für den Schreibbefehl - zehn Datenbits, von denen nur 9 verwendet werden (0-256)

 
 

  ....              // Initialisierungen 
  P5DIR  |= BIT0;   // wähle PIN5.0 als CS (aktiv LOW) 
 
  // Schnittstelle als SPI initialisieren 
  U1CTL  = SWRST;   // SWRST setzen, um Konfigurationen 
                    // ändern zu können 
  U1CTL  |= CHAR;   // 8 Datenbits 
  U1CTL  |= SYNC;   // SPI-Modus 
  U1CTL  |= MM;    // Controller ist Master 
  U1TCTL  = SSEL1;  // Wähle SMCLK als Taktquelle 
  U1TCTL |= STC+CKPL; // 3-Pin-Modus, CKPH=0, CKPL=1 
  U1BR1   = 0x00;   // SPI-Frequenz einstellen: 
  U1BR0   = 0x28;   // ... 200 kHz 
  U1MCTL  = 0x00;   // Laut MSP-Datenblatt auf 0 setzen 
  ME2     = USPIE1; // SPI-Modul aktivieren 
  U1CTL  &= ~SWRST; // SWRST löschen; Konfiguration ist 
                    // damit abgeschlossen 
 
  wertHIGH=0x01;//lege 9-Bit-Wert fest, hier: Maximalwert 
  wertHIGH &=~ 0xFE;// Bits 1-7 auf LOW 
  wertLOW=0x00; 
  P5OUT &=~BIT0;    // aktivieren 
  ReadWriteSPI (wertHIGH); // Adresse und Wert senden 
  ReadWriteSPI (wertLOW); 
  P5OUT = BIT0;    // deaktivieren