Linux, PC und Hardware Prof. Jürgen Plate

Standard-Schnittstellen

Die serielle Schnittstelle

Die Datenrate wird in Bit pro Sekunde (bps) bzw. Baud (nach dem französischen Ingenieur und Erfinder Jean Maurice Émile Baudot) angegeben. Dabei werden alle Bits (auch Start- und Stoppbit) gezählt und Lücken zwischen den Bytetransfers ignoriert. Deshalb ist die Baudrate der reziproke Wert der Länge eines Bits. Als Datenraten sind folgende Werte üblich:

150, 300, 1200, 2400, 4800, 9600, 19200, 38400, 57600 und 115200

Nach dem Stoppbit kann sofort wieder eine neue Übertragung mit einem Startbit beginnen. Zur Vermeidung von Datenverlusten muss der Empfänger die Datenübertragung anhalten können, wenn keine weiteren Daten mehr verarbeitet werden können. Dieses sogenannte Handshake kann auf zwei Arten realisiert werden:

• Hardware-Handshake: Der Empfänger steuert über entsprechende Leitungen die Handshake-Eingänge des Senders (CTS, DSR) mit seinen Handshake-Ausgängen (DTR, RTS).
• Software-Handshake: Der Empfänger sendet zur Steuerung des Datenflusses spezielle Zeichen an den Sender (z. B. XON, XOFF).

Die serielle PC-Schnittstelle

(1) Bit 7 im Line Control Register = 0}
(2) Bit 7 im Line Control Register = 1}

Im Interruptbetrieb muss für die Schnittstelle auch eine IRQ-Leitung existieren, über die der Interrupt ausgelöst werden kann. Deshalb ist zusätzlich noch eine Programmierung des Interrupt-Controllers 8259 im PC notwendig. Beim Interrupt-Control-Register gilt, dass eine 0 den entsprechenden Interrupt sperrt und eine 1 ihn freigibt. Glücklicherweise wird aber auch dies vom Linux-Schnittstellentreiber erledigt.

1. Empfangspuffer einrichten
2. Baudrate einstellen
3. Interruptvektor (z. B. IRQ4) auf die eigene Interrupt-Routine zeigen lassen
4. Dummy-Read auf das Datenregister ausführen, um ein eventuell gesetztes Interrupt-Bit für "Daten-Empfangen" zu löschen.
5. Am Interrupt-Controller 8259 den Interrupt (z. B. IRQ4) freigeben.
6. Interrupt am Schnittstellenbaustein 8250 freigeben: Bit 0 des Interrupt-Control-Registers auf 1 setzen und den Ausgang OUT2 freischalten.

1. Empfangenes Byte vom 8250 abholen (Datenregister) und im Pufferbereich speichern.
2. "End of Interrupt" an den Interrupt-Controller melden.

Die Übertragungsgeschwindigkeit der seriellen Schnittstelle wird mittels der beiden Baudrate-Register eingestellt. Dabei wird der Teilerwert (1 Word) über die ganzzahlige Division

Teiler = 115200/Baudrate

Den Status der Eingangsleitungen des Bausteins liefern die Statusregister für Modem und Leitungen:

Die RS232C-Schnittstelle (V.24)

Neben der Masseleitung und den Datenleitungen gibt es noch eine ganze Reihe von Leitungen, die den Verkehr zwischen Rechner und Peripherie steuern. Meist interessieren aber nur einige Leitungen, um den Verkehr zwischen Computer und Peripherie oder zwischen zwei Computern aufrechtzuerhalten. Die anderen Leitungen bleiben unbeschaltet oder werden auf einen festen Pegel gelegt. Die wichtigsten Leitungen sind:

• GND bildet das gemeinsame Massepotential für die Datenleitungen.
• TXD führt die Sendedaten des Computers zum Peripheriegerät.
• RXD liefert die Daten vom Peripheriegerät zum Rechner.
• RTS zeigt der Peripherie die Übertragungsbereitschaft des Computers an.
• CTS signalisiert die Bereitschaft der Peripherie, Daten zu empfangen.
• DTR steuert bei Modems das Anschalten an die Telefonleitung.

ITU	DIN	US	25-pol.	9-pol.	Beschreibung	Richt.
101	E 1	-	1	-	Schutzerde	-
102	E 2	GND	7	5	Signalerde (Ground)	-
103	D 1	TXD	2	3	Sendedaten (Transmit Data)
104	D 2	RXD	3	2	Empfangsdaten (Receive Data)
105	S 2	RTS	4	7	Sendeteil einschalten (Request To Send)
106	M 2	CTS	5	8	Sendebereitschaft (Clear To Send)
107	M 1	DSR	6	6	Betriebsbereitschaft (Data Set Ready)
108.2	S 1.2	DTR	20	4	Terminal ist bereit (Data Terminal Ready)
109	M 5	DCD	8	1	Empfangspegel (Data Carrier Detect)
125	M 3	RI	22	9	Ankommender Ruf (Ring Indicator)

Die Richtungsangabe bezieht sich auf die Peripherie ( bedeutet Peripherie nach PC, entsprechend PC nach Peripherie). Werden Peripherie/Modem (DÜE = Datenübertragungseinrichtung) und Computer (DEE = Datenendeinrichtung) miteinander verbunden, verwendet man ein Kabel mit einer 1:1-Verbindung der wichtigsten Leitungen.

Bei der Pegelwandlung von TTL nach RS232 können wir praktischerweise auf einen bewährten integrierten Baustein zurückgreifen, den MAX232 von Maxim, um den sich inzwischen eine ganze Familie von Pegelwandlern mit verschiedenen Gehäusebauformen und unterschiedlichen elektrischen Eigenschaften gebildet hat. Der Baustein kann zwei Leitungen von TTL nach RS232 umsetzen und zwei weitere Leitungen von RS232 nach TTL. Somit kann ein Baustein die Sende- und Empfangsleitung (TXD, RXD) und zwei Handshakeleitungen (z. B. CTS, RTS) umsetzen, was in vielen Fällen ausreicht. Zusätzlich sind im Chip noch zwei Ladungspumpen integriert, welche die benötigten Spannungen von +12 V und -12 V erzeugen. Für diese Spannungswandler werden als externe Beschaltung lediglich vier Kondensatoren benötigt (1-uF-Tantal-Elkos). Im folgenden Bild (nach Maxim-Unterlagen) sind die Innenschaltung des Bausteins, die Beschaltung mit den Kondensatoren sowie das Pin-Layout zu sehen. Sie werden diesen Baustein in etlichen Anwendungen wieder antreffen.

Die RS422-Schnittstelle

Der Empfänger wertet die Differenz-Spannung zwischen beiden Leitungen aus, so dass Gleichtakt-Störungen auf der Übertragungsleitung nicht zu einer Verfälschung des Nutzsignals führen. Durch die Verwendung von abgeschirmten, paarweise verdrillten Cat-5-Kabeln lassen sich Distanzen von bis zu 1200 Metern (bei bis zu 100000 bps) realisieren. RS422-Sender stellen unter Last Ausgangspegel von +/-2 V zwischen den beiden Ausgängen zur Verfügung, die Empfängerbausteine erkennen Pegel von betragsmäßig 200 mV noch als gültiges Signal.

Bei RS422 gibt es also jeweils zwei Leiter für eine Übertragungsrichtung. Also muss das Kabel mindestens vier Adern haben, wobei es günstig ist, wenn jeweils zwei Adern paarweise verdrillt sind. An einen Sender können bis zu zehn Empfänger angeschlossen werden.

Die RS485-Schnittstelle

Die beispielsweise vom DIN-Messbus genutzte 4-Draht-Technik unten) ist für Master/Slave-Anwendungen geeignet. Wie im Bild zu sehen ist, wird der Datenausgang des Masters auf die Dateneingänge aller Slaves verdrahtet. Die Datenausgänge der Slaves sind zusammen auf den Dateneingang des Masters geführt.

Für die Pegelanpassung zwischen TTL und RS485 können wir wieder ein IC von Maxim einsetzen, den MAX485. Dieser Chip hat neben der Spannungsversorgung lediglich je zwei Ein- und Ausgangspins sowie zwei Pins, mit denen die Ein- und Ausgänge aktiviert werden können (wir erinnern uns: es darf nur einen Master geben). Da der PC jedoch keine TTL-Pegel liefert, sondern eine RS232-Schnittstelle besitzt, brauchen wir einen RS232-zu-RS485-Umsetzer - und Sie ahnen es sicher schon: die beiden MAX-Bausteine werden miteinander verheiratet. Die Schaltung ist so auch recht einfach geworden.

Die Stromschnittstelle(TTY)

Die Stromschnittstelle wird auch "20 mA"- bzw. "Current-Loop"-Schnittstelle genannt. Der Name "TTY-Schnittstelle" wurde ihr nach ihrem ersten Anwendungsgebiet verliehen, dem Fernschreibverkehr (Teletype). Heute wird die TTY-Schnittstelle nahezu ausschließlich für den Datenverkehr zur Programmierung und Ankopplung von SPS, elektronischen Waagen, industriellen Großanzeige-Displays und Protokolldruckern verwendet.

Ein weiteres Problem ist die Auslegung der Schnittstelle. Innerhalb jeder Stromschleife darf lediglich ein angeschlossenes Gerät den erforderlichen Schleifenstrom liefern. Sowohl die Sendekomponente als auch der Empfangsteil können aktiv (eingebaute Stromquelle) oder passiv (Schalter/Schalttransistor bzw. Optokoppler-Eingang) ausgelegt sein. Trifft ein passiver Sender auf einen passiven Empfänger, tut sich gar nichts. Ebenso können zwei aktive Komponenten nicht miteinander spielen.

            I = 1.25 / Rg

Programmierung mit C

Um mit einem User-Programm auf die serielle Schnittstelle zugreifen zu können, muss der entsprechende User auch die nötige Schreib- und Leseberechtigung für das Device haben (was normalerweise nicht der Fall ist). In der Regel reicht es, die User, die mit der seriellen Schnittstelle arbeiten, mit in die Gruppe uucp aufzunehmen (ggf. hilft ein Blick auf die Zugriffsrechte der Devices und in die Datei /etc/group). Sinnvoll ist auch das Anlegen eines eigenen (Pseudo-)Users für die Steuerungsprogramme.

Fast alle Veränderungen an den Übertragungsparametern von Terminals oder seriellen Schnittstellen erzielen Sie mit der Struktur termios (Terminal-IO-Settings). Diese Struktur besteht aus fünf Teilen, nämlich vier 32-Bit-Masken für die verschiedenen Flags, der line discipline und dem c_cc-Array, das weitere Parameter, z. B. Wartezeiten nach dem Senden bestimmter Zeichen und die Definition von Steuerzeichen, aufnimmt (adressiert wird es über Präprozessordefinitionen in /usr/include/termbits.h). Sie hat demnach folgendes Aussehen:

struct termios
  {
  /* Bitmaske fuer die Eingabe-Flags */       tcflag_t c_iflag;
  /* Bitmaske fuer die Ausgabe-Flags */       tcflag_t c_oflag;
  /* Bitmaske fuer die Control-Flags */       tcflag_t c_cflag;
  /* Bitmaske fuer lokale Einstellungen */    tcflag_t c_lflag;
  /* line discipline */                       char    __c_line;
  /* Array fuer Sonderzeichen/-funktionen */  cc_t c_cc[NCCS];
  }

int tcgetattr(int filedes, struct termios *termios_p)
/* liefert aktuelle Terminal-Settings */


int tcsetattr(int filedes, int when, const struct termios *termios_p)
/* setzt Terminal-Settings */

TCSANOW:        Einstellungen sofort ändern
TCSADRAIN:      Einstellungen ändern, nachdem alle eventuell noch gepufferten
                Daten gesendet wurden
TCSAFLUSH:      Einstellungen sofort ändern und Eingabepuffer löschen

Alle genannten Funktionen liefern im Erfolgsfall den Wert 0 zurück und im Fehlerfall -1. Die Komplexität des Terminal-IO entsteht durch zahllose Flags, aus denen die vier Bitmasken zusammengesetzt sind. Die Flags und auch die termios-Struktur sind in der Datei /usr/include/termbits.h definiert und unter anderem im Mini-HOWTO dokumentiert.

Normalerweise werden nicht alle Flags benötigt, um die serielle Schnittstelle zum Laufen zu bringen. Deshalb will ich im Folgenden nur die wichtigsten von ihnen behandeln. Beginnen wir mit den Eingabeflags in c_iflag:

IGNBRK   Ignoriere Breaks
BRKINT   Beachte Breaks
IGNPAR   Ignoriere Parität
INLCR    Ersetze NL durch CR
IGNCR    Ignoriere CR
ICRNL    Ersetze CR durch NL
IUCLC    Großbuchstaben in Kleinbuchstaben umwandeln
IXON     XON/XOFF-Flusssteuerung einschalten
IXANY    Ausgabe fortsetzen mit einem beliebigen Zeichen
IXOFF    XON/XOFF-Flusssteuerung ausschalten
IMAXBEL  Klingle, wenn der Puffer voll ist (Zeilenende)

ONLCR    Ersetze NL durch CR
OCRNL    Ersetze CR durch NL
ONOCR    Unterdrücken von CR in Spalte 0
ONLRET   Kein CR senden
OFILL    Füllzeichen NUL senden anstelle einer Pause
OFDEL    Füllzeichen ist DEL statt NUL

B0       hang up       B50      50 bps
B75      75 bps        B110     110 bps
B150     150 bps       B300     300 bps
B600     600 bps       B1200    1200 bps
B1800    1800 bps      B2400    2400 bps
B4800    4800 bps      B9600    9600 bps
B19200   19200 bps     B38400   38400 bps
B57600   57600 bps     B115200  115200 bps

CS5      5 Bit
CS6      6 Bit
CS7      7 Bit
CS8      8 Bit
CSTOPB   2 Stoppbits statt einem
CREAD    Empfangsteil aktivieren
PARENB   Paritätsbit erzeugen
PARODD   ungerade Parität statt gerader
HUPCL    Verbindungsabbruch bei Ende des letzten Prozesses
CLOCAL   Terminal lokal angeschlossen (ignoriere CD)
CRTSCTS  Hardware-Handshake einschalten
CIGNORE  Ignoriere Controlflags

ECHO  	 Einschalten der ECHO-Funktion
ICANON   Zeilenorientierter Eingabemodus (kanonischer Modus)
ISIG  	 Bestimmte Sonderzeichen lösen ein Signal aus (z. B.  Ctrl-C)
XCASE  	 Umwandeln von eingegebenen Groß- in Kleinbuchstaben

• kanonischer Modus: Hier erfolgt das Lesen und Schreiben auf das Device zeilenorientiert. Eine Eingabe wird erst weitergereicht, wenn ein Zeilenabschluss (Linefeed, NL) oder Carriage Return (CR)) übertragen wurde. Für diesen Mode benötigt man die Steuerzeichen des c_cc-Arrays. Ein Programm wartet beim Lesen in diesem Modus so lange, bis tatsächlich eine komplette Zeile empfangen wurde. Wird kein Zeilenabschluss gelesen, so wird für immer und ewig gewartet. Die Aufgabe des Zwischenspeicherns übernimmt der Kernel.

• nichtkanonischer Modus: Hier wird nicht zeilenweise gelesen, sondern entweder auf eine bestimmte Anzahl von Bytes gewartet oder nach einer gewissen Zeit die bis dahin eingetroffenen Bytes abgeliefert. Hierfür müssen zwei Felder des Arrays c_cc gesetzt werden. In c_cc[VTIME] wird die Wartezeit in Zehntelsekunden und in c_cc[VMIN] das Minimum der zu lesenden Bytes angegeben. Die folgenden vier Konstellationen sind denkbar (siehe Tabelle ). Wenn das Programm nicht ewig auf eine Eingabe warten soll, nimmt man also am besten den dritten Fall.

Da es sich bei den seriellen Schnittstellen nicht um normale Dateien handelt, können beim open()-Aufruf gegebenenfalls dateiuntypische Fehler auftreten. So kann zum Beispiel der Treiber den Fehlercode EBUSY zurückmelden, wenn gerade ein anderer Prozess das Device benutzt. Oder er hält das Programm so lange an ("blocking open"), bis die Carrier-Leitung des Modems aktiv wird (was bei direkt angeschlossenen Geräten durch das Fehlen dieser Leitung scheinbar auftritt). Es gibt jedoch einen Mechanismus, um das Blockieren zu umgehen: beim open()-Aufruf muss das Flag O_NDELAY mitgegeben werden. Das sieht folgendermaßen aus:

file_descr = open("/dev/ttyS0", O_RDWR | O_NDELAY | O_NOCTTY);
/*                    Modus:    read      nicht     nicht              */
/*                              write     warten    controlling entity */

int open_port(int port)
  {
  /*
   * Oeffnet seriellen Port
   * Gibt das Filehandle zurueck oder -1 bei Fehler
   * der Parameter port muss 0, 1, 2 oder 3 sein
   *
   * RS232-Parameter
   * - 19200 baud
   * - 8 bits/byte
   * - no parity
   * - no handshake
   * - 1 stop bit
   */
   int fd;
   struct termios options;
   switch (port)
     {
     case 0: fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY); break;
     case 1: fd = open("/dev/ttyS1", O_RDWR | O_NOCTTY | O_NDELAY); break;
     case 2: fd = open("/dev/ttyS2", O_RDWR | O_NOCTTY | O_NDELAY); break;
     case 3: fd = open("/dev/ttyS3", O_RDWR | O_NOCTTY | O_NDELAY); break;
     default: fd = -1;
     }
   if (fd >= 0)
     {
     /* get the current options */
     fcntl(fd, F_SETFL, 0);
     if (tcgetattr(fd, &options) != 0) return(-1);
     bzero(&options, sizeof(options)); /* Structure loeschen, ggf vorher sichern
                                          und bei Programmende wieder restaurieren */

     cfsetspeed(&options, B19200);       /* setze 19200 bps */
     /* Alternativ:                                         */
      * cfsetispeed(&options, B19200);                      *
      * cfsetospeed(&options, B19200);                      */

     /* setze Optionen */
     options.c_cflag &=  PARENB;         /* kein Paritybit */
     options.c_cflag &=  CSTOPB;         /* 1 Stoppbit */
     options.c_cflag &=  CSIZE;          /* 8 Datenbits */
     options.c_cflag |= CS8;
     options.c_cflag |= (CLOCAL | CREAD);/* CD-Signal ignorieren */
     /* Kein Echo, keine Steuerzeichen, keine Interrupts */
     options.c_lflag &=  (ICANON | ECHO | ECHOE | ISIG);
     options.c_oflag &=  OPOST;          /* setze "raw" Input */
     options.c_cc[VMIN]  = 0;            /* warten auf min. 0 Zeichen */
     options.c_cc[VTIME] = 10;           /* Timeout 1 Sekunde */
     tcflush(fd,TCIOFLUSH);
     if (tcsetattr(fd, TCSAFLUSH, &options) != 0) return(-1);

     fcntl(fd, F_SETFL, FNDELAY);
     fcntl(fd, F_SETFL, 0);
     }
  return(fd);
  }

void alarm_handler(void)
  { timeout = 1; }

signal(SIGALRM, alarm_handler);
alarm(60); /* Wartezeit setzen */

...

if (read(file_descr,buffer,1) != 1 && errno == EINTR && timeout)
  {
  fprintf(stderr,"TIMEOUT!\n"); break;
  }
...

alarm(0);  /* Alarm abschalten */

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
main()
  {
  int fd1, fd2; /* input sources 1 and 2 */
  fd_set readfs; /* file descriptor set */
  int maxfd; /* maximum file desciptor used */
  int loop=1; /* loop while TRUE */

  /* open_input_source opens a device, sets the port correctly, and
     returns a file descriptor */
  fd1 = open_input_source("/dev/ttyS0");
  if (fd1<0) exit(0);
  fd2 = open_input_source("/dev/ttyS1");
  if (fd2<0) exit(0);
  maxfd = MAX (fd1, fd2)+1; /* maximum bit entry (fd) to test */

  /* loop for input */
  while (loop)
    {
    FD_SET(fd1, &readfs); /* set testing for source 1 */
    FD_SET(fd2, &readfs); /* set testing for source 2 */
    /* block until input becomes available */
    select(maxfd, &readfs, NULL, NULL, NULL);

    if (FD_ISSET(fd1)) /* input from source 1 available */
    handle_input_from_source1();
    if (FD_ISSET(fd2)) /* input from source 2 available */
    handle_input_from_source2();
    }
  }

int res;
struct timeval Timeout;

/* set timeout value within input loop */
Timeout.tv_usec = 0; /* milliseconds */
Timeout.tv_sec = 1; /* seconds */
res = select(maxfd, &readfs, NULL, NULL, &Timeout);

if (res == 0)
  /* number of file descriptors with input = 0, timeout occurred. */

#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>

int fd = 0;

void SetRTS(int fd)
/* Setzt RTS auf ON */
  {
  int currstat;
  ioctl(fd, TIOCMGET, &currstat);
  currstat |= TIOCM_RTS;
  ioctl(fd, TIOCMSET, &currstat);
  }

void ResetRTS(int fd)
/* Setzt RTS auf OFF */
  {
  int currstat;
  ioctl(fd, TIOCMGET, &currstat);
  currstat &= ~TIOCM_RTS;
  ioctl(fd, TIOCMSET, &currstat);
  }

void SetDTR(int fd)
/* Setzt DTR auf ON */
  {
  int currstat;
  ioctl(fd, TIOCMGET, &currstat);
  currstat |= TIOCM_DTR;
  ioctl(fd, TIOCMSET, &currstat);
  }

void ResetDTR(int fd)
/* Setzt DTR auf OFF */
  {
  int currstat;
  ioctl(fd, TIOCMGET, &currstat);
  currstat &= ~TIOCM_DTR;
  ioctl(fd, TIOCMSET, &currstat);
  }

void ClearSerPins(int fd)
/* Setzt alle Pins der Schnittstelle auf OFF */
  {
  int currstat = 0;
  ioctl(fd, TIOCMSET, &currstat);
  }

int GetRI(int fd)
/* Gibt 1 zurueck, wenn RI gesetzt ist, sonst 0 */
  {
  int  currstat;
  ioctl(fd, TIOCMGET, &currstat);
  return((currstat & TIOCM_RNG)?1:0);
  }

int GetCD(int fd)
/* Gibt 1 zurueck, wenn CD gesetzt ist, sonst 0 */
  {
  int  currstat;
  ioctl(fd, TIOCMGET, &currstat);
  return((currstat & TIOCM_CAR)?1:0);
  }

int GetDSR(int fd)
/* Gibt 1 zurueck, wenn DSR gesetzt ist, sonst 0 */
  {
  int  currstat;
  ioctl(fd, TIOCMGET, &currstat);
  return((currstat & TIOCM_DSR)?1:0);
  }

int GetCTS(int fd)
/* Gibt 1 zurueck, wenn CTS gesetzt ist, sonst 0 */
  {
  int  currstat;
  ioctl(fd, TIOCMGET, &currstat);
  return((currstat & TIOCM_CTS)?1:0);
  }

int GetSerStat(int fd)
/* Gibt den kompletten seriellen Status zurueck *
 * ggf. RTS und DTR ausblenden:                 *
 * currstat &=  (TIOCM_DTR | TOICM_RTS)         */
  {
  int  currstat;
  ioctl(fd, TIOCMGET, &currstat);
  return(currstat);
  }

int main(int argc, char** argv)
  {
  int i, stat;

  /* Parameterprüfung: Das zu verwendende Device muss  */
  /* als erster Parameter angegeben werden.            */
  if(argc != 2)
    {
    printf("Fehler: Ungültige Parameter-Anzahl.\n");
    printf("Aufruf: serpin <device>\n");
    return 1;
    }

  /* Das Device öffnen */
  if((fd = open(argv[1], O_RDWR | O_NDELAY)) < 0)
    {
      printf("Fehler: Device \"%s\" kann nicht geöffnet werden.\n",
      argv[1]);
      return 2;
    }

  /* alles loeschen */
  ClearSerPins(fd);

  /* mit RTS und DTR blinken */
  for(i=0; i<5; i++)
    {
    usleep(300000);
    SetRTS(fd);
    usleep(300000);
    ResetRTS(fd);
    usleep(300000);
    SetDTR(fd);
    usleep(300000);
    ResetDTR(fd);
    }
/* Status abfragen, bis RI gesetzt wird */
  while(!GetRI(fd))
    {
    stat = GetSerStat(fd);
    printf("%6X  ",stat);
    printf("+%d+ ",GetCTS(fd));
    if (stat & TIOCM_RNG) puts("RI ");
    if (stat & TIOCM_CAR) puts("CD ");
    if (stat & TIOCM_DSR) puts("DSR ");
    if (stat & TIOCM_CTS) puts("CTS ");
    printf("\n");
    sleep(1);
    }
  close(fd);
  return 0;
  }

Prinzipiell könnten Sie auch direkt auf den Modem-Port der Schnittstelle schreiben (mittels inb() und outb(), was aber nicht nur wegen der Portabilität unschön ist.

An die Ausgänge lassen sich LEDs direkt anschließen; wenn man Dual-LEDs nimmt, kann man sogar 0 und 1 aktiv anzeigen (z. B. rot-grün - was einen Farbenblinden dann in den Wahnsinn treibt). Einen LED-Strom von 20 mA verkraftet die Schnittstelle normalerweise wunderbar, nur einige Laptops sind manchmal schwach auf der Brust. Der Vorwiderstand wäre dann minimal (12-2)/0.02 = 1000 Ohm. Bei Low-Power-LEDs reicht meist der doppelte Wert.

Schaltet man einen Ausgang auf 1, kann er +12 V für die Eingänge liefern. Die Schnittstelle am PC liefert den Eingangswert 0, wenn der Eingang offen ist. Man kann also vier Taster oder Schalter einseitig mit dem RTS-Ausgang verbinden und die andere Seite dieser Taster/Schalter wieder mit den Eingangspins - und braucht also keinerlei aktive Komponenten.

Diese Tasten bzw. Schalter kann man nun abfragen und im Programm darauf reagieren. Bei der Tastenabfrage muss man die Entprellung per Software durchführen, etwa in der Form:

if (GetRI(fd))          /* Taste RI gedrückt */
  {
  usleep(100*1000);     /* 0,1 s Pause */
  if (GetRI(fd))        /* Wenn immer noch gedrückt... */
    {
    while(GetRI(fd));   /* ... warten auf's Loslassen */
    do_something_awful();
    }
  }

Weiterführende Links

• Serial Port programming in C (PDF)
• Linux Serial-HOWTO

Zum vorhergehenden Abschnitt

Zum Inhaltsverzeichnis

Zum nächsten Abschnitt

Copyright © FH München, FB 04, Prof. Jürgen Plate

Letzte Aktualisierung: 07. Apr 2010