AK-Automatisierungs und Kommunikationstechnik TI Technische Informatik. NWT Netzwerktechnik

Transkript

1 AA Die serielle Schnittstelle (USB) mit C oder JAVA ansprechen und mit einem Terminalprogramm überprüfen was funktioniert. s.a. Homepage Microcontroller ganz am Schluss Projekte etc. Das folgende Beispiel ist ein bisschen veraltet. Versuchen Sie es auf den USB Standard um zu schreiben. 1) Low Level Sicht: Kern der seriellen Schnittstelle ist der UART Baustein. UART steht für Universal Universal Asynchronous Receiver/Transmitter. Der Urvater der UART Bausteine ist der Die kompatiblen Nachfolger haben die Bezeichnung 16450, 16550, und Ab dem enthalten die UART Bausteine einen internen Buffer, einen FIFO (First In First Out) Speicher. Die Größe dieses Buffers ist 16 Byte beim 16550, 32 Byte beim und 64 Byte beim Die UART Bausteine enthalten 8 Bit Register, die für die Konfiguration, also für die Programmierung oder als Sende und Empfangsregister verwendet werden. Register Name Adresse = BasisAdresse + Offset Zugriffsmode Transmitter Holding Buffer Receiver Buffer Divisor Latch Low Byte Interrupt Enable Register Divisor Latch High Byte Interrupt Identification Register FIFO Control Register Write Read Read/Write Read/Write Read/Write Read Write Line Control Register 3 Read/Write Modem Control Register 4 Read/Write Line Status Register 5 Read Modem Status Register 6 Read Scratch Register 7 Read/Write 1

2 Die Standardeinstellungen eines PCs legen die Port Adressen, also die Basisadresse des Bausteins für die ersten vier seriellen Schnittstellen auf folgende Adressen: Schnittstelle Adresse Interrupt COM1 03F8 4 COM2 02F8 3 COM3 03E8 4 COM4 02E8 3 Das Betriebssystem DOS und auch die Nachfolger Windows 3.1/3.11 bis zu Windows 98 erlaubten jedem Programm den direkten Zugriff auf die Port Adressen und damit auf die Register einer UART. Dadurch ist es möglich, diese Bausteine und damit die serielle Schnittstelle auf "Low Level" Art zu programmieren. C Systeme für DOS stellen Funktionen für den Portzugriff zur Verfügung. Das sind Funktionen um auf eine Portadresse zu schreiben (outport, outportb bei Borland, _outp, _outpw, _outpd bei Microsoft) und Funktionen, mit denen man von einer Portadresse lesen kann (inport, inportb bei Borland, _inp, _inpw, _inpd bei Microsoft). Die zugehörigen Definitionsdateien sind dos.h (Borland) und conio.h (Microsoft). Zusätzlich gibt es die Möglichkeit C Funktionen als Interrupt Routinen zu verwenden. Die ersten beiden Programmbeispiele zeigen das Prinzip dieser Programmiertechnik. 2) High Level Sicht: Windows NT und andere Multitask und Multiuserbetriebssysteme erlauben es einem Programm nicht, direkt mit Portadressen zu arbeiten. Dies ist Sache der Gerätetreiber, die natürlich auch programmiert werden müssen und deren Programmierer wiederum mit diesen Details konfrontiert sind. Der Anwendungsprogrammierer in C oder C++ verwendet API Funktionen oder sogar Klassen und kann auf einer relativ hohen Abstraktionsebene mit der Schnittstelle umgehen. Dies zeigt das Beispiel 3. Links und Literaturhinweise: Aus dieser Quelle stammen die ersten beiden Programmbeispiele. Eine ausgezeichnete Quelle von Information zu allen wichtigen Kommunikationsschnittstellen UART Chip. Ein Beispiel für viele. Eine genaue Beschreibung (PDF Files) der UART Bausteine findet man bei allen Herstellern. Eine Suchmaschine führt rasch zum Ziel. Lange Zeit war das Buch PC intern von Michael Tischer / Bruno Jennrich, Verlag DATA BECKER ein Klassiker für Informationen zum Thema PC, DOS, Windows 95. Kann man von mir ausleihen. 2

3 Es gibt jede Menge Bücher zum Thema Schnittstellen, ein Beispiel: Michael Thieser: PC Schnittstellen, Franzis' Verlag. Programm Beispiele: Um die Beispiele zu testen, muß an die serielle Schnittstelle ein Terminal oder ein zweiter PC angeschlossen werden. Am PC müssen Sie ein Kommunikationsprogramm (Terminalemulation) verwenden. Das Terminal oder der PC muss mit einem sogenannten Nullmodemkabel angeschlossen werden. Das ist ein Kabel mit zwei weiblichen Steckern, das je zwei Leitungen auskreuzt. Terminaleinstellungen: 9600 Baud, 8 Bit, keine Parität, 1 Stopbit, (kein Protokoll) Konfigurieren Sie die Schnittstelle zuerst mit dem Kommandozeilen Befehl Mode: mode COM1 96,n,8,1 und testen Sie die grundsätzliche Funktion der Verbindung mit dem Kommando: dir > COM1 Damit leiten Sie die Ausgaben des dir Befehls auf die COM1 Schnittstelle um. Am angeschlossenen Terminal oder PC muß jetzt der Inhalt des aktuellen Verzeichnissen erscheinen. Beispiel 1: Polling Methode (DOS, auch WIN 95/98, kompiliert mit Visual C++/6.0, LCC Win32) Beispiel 2: Interrupt Methode (DOS, auch WIN 95/98, kompiliert mit Turbo C 2.0) Beispiel 3: Windows API Funktionen (WIN 95/98, Windows NT/2000, kompiliert mit Visual C++/6.0, LCC Win32) 3

4 Die Beispiele 1 und 3 zeigen die Technik des "polling", d.h. der Buffer der Schnittstelle wird periodisch nach anliegenden Zeichen abgefragt. Da moderne UART Bausteine einen internen Buffer von 16 und mehr Byte haben, kann diese einfache Technik oft erfolgreich angewandt werden. Beispiel 1 und 3 implementieren folgenden Algorithmus: Wiederhole Anliegende Zeichen von der serielle Schnittstelle lesen und in Zeichenkette ablegen Zustand der Zeichenkette auswerten, Kontrollausgabe Tastatur abfragen Bis auf der Tastatur ESC eingegeben wird. /* termpoll.c Comment from K. Zeiner: I found this good example program 1997 on the website: The commands _outp (oder outportb) and _inp (inportb) were used under DOS to write to and read from port adresses. These commands were also valid on a WIN95 and WIN98 system, On a Windows NT / 2000 system a program with these commands can not be executed. Written By: Craig Peacock <cpeacock@senet.com.au> */ #include <stdio.h> #include <conio.h> #define PORT 0x3F8 /* COM1 */ 4

5 /* Defines Serial Ports Base Address COM1 0x3F8 COM2 0x2F8 COM3 0x3E8 COM4 0x2E8 */ int main(void) { int checkbuffer; int c; _outp(port + 1, 0); /* Turn off interrupts */ /* PORT Communication Settings */ _outp(port + 3, 0x80); /* SET DLAB ON */ _outp(port + 0, 0x0C); /* Set Baud rate Divisor Latch Low Byte */ /* Default 0x03 = 38,400 BPS */ /* 0x01 = 115,200 BPS */ /* 0x02 = 56,700 BPS */ /* 0x06 = 19,200 BPS */ /* 0x0C = 9,600 BPS */ /* 0x18 = 4,800 BPS */ /* 0x30 = 2,400 BPS */ _outp(port + 1, 0x00); /* Set Baud rate Divisor Latch High Byte */ _outp(port + 3, 0x03); /* 8 Bits, No Parity, 1 Stop Bit */ _outp(port + 2, 0xC7); /* Configure FIFO Control Register */ _outp(port + 4, 0x0B); /* Turn on DTR, RTS, and OUT2 */ printf("\nsample Comm's Program. Press ESC to quit \n"); do { 5

6 checkbuffer = _inp(port + 5); /* Check LSR to see if characters has been received */ if (checkbuffer & 1) { c = _inp(port); /* get the character */ printf("%c", c); /* print character to screen */ if (c == 13) printf("\n"); _outp(port, c); /* write the character to the port */ if (kbhit()) { c = getch(); /* if a key is/was pressed, get character from keyboard */ _outp(port, c); /* send Char to Serial Port */ while (c!=27); /* Quit when ESC (ASCII 27) is pressed */ return 0; Die zweite Technik verwendet Interruptroutinen. Ein einlangendes Zeichen informiert das System mit einem Interrupt. Dieser Interrupt wird vom Betriebssystem dadurch behandelt, dass auf eine bestimmte Programmadresse gesprungen wird. Auf diese Adresse zeigt der Interruptvektor. Man kann nun eine sogenannte Interruptroutine schreiben, die statt dieser Standardbehandlung aufgerufen wird. Die Technik ist im wesentlichen: Interrupt Vektor sichern Interrupt Vektor auf selber geschriebene Interruptroutine legen, welche die Interrupts jetzt verarbeitet. Diese Funktion liest das eingetroffene Zeichen und legt es in einem Buffer ab. Interrupt Vektor wieder auf alten Wert setzen. Das Eintreffen der Zeichen und das Abarbeiten der Zeichen erfolgt nicht im gleichen Takt. Deshalb müssen die Zeichen in einem Buffer zwischengelagert werden. Das Programm verwendet dazu einen Ringbuffer. /* Comment: K. Zeiner You need an old compiler (Turbo C, Microsoft C for DOS <= 7.0) to compile this code. 6

7 You can use the executable only with DOS and with WIN95/WIN98. */ /* Name : Sample Comm's Program 1024 Byte Buffer buff1024.c */ /* Written By : Craig Peacock */ /* Some comments added by Karlheinz Zeiner */ /* Copyright 1997 CRAIG PEACOCK */ /* See */ /* for More Information */ #include <dos.h> #include <stdio.h> #include <conio.h> #define PORT1 0x2E8 /* Port Address Goes Here */ #define INTVECT 0x0B /* Com Port's IRQ here (Must also change PIC setting) */ /* Defines Serial Ports Base Address COM1 0x3F8 COM2 0x2F8 COM3 0x3E8 COM4 0x2E8 */ char ch; char buffer[1025]; /* storage for ring buffer */ int bufferin = 0; /* position for storing the next character */ int bufferout = 0; /* position for reading the next character */ 7

8 void interrupt (*oldport1isr)(); /* Interrupt Service Routine (ISR) for PORT1 This function is called, if the port receives a character */ void interrupt PORT1INT() { int c; do { /* get the content of the LSR (line status register) if Bit 0 of LSR is set, than one or more data bytes are available */ c = inportb(port1 + 5); if (c & 1) { /* check Bit 0 */ buffer[bufferin] = inportb(port1); /* get the character and store it in the buffer */ bufferin++; if (bufferin == 1024) { bufferin = 0; /* ring buffer */ while (c & 1); /* while data ready */ outportb(0x20,0x20); /* clear the interrupt */ void main(void) { int c; outportb(port1 + 1, 0); /* Turn off interrupts Port1 */ oldport1isr = getvect(intvect); /* Save old Interrupt Vector of later recovery */ 8

9 setvect(intvect, PORT1INT); /* Set Interrupt Vector Entry */ /* COM1 0x0C, COM2 0x0B, COM3 0x0C, COM4 0x0B */ /* PORT 1 Communication Settings */ outportb(port1 + 3, 0x80); /* SET DLAB ON */ outportb(port1 + 0, 0x03); /* Set Baud rate Divisor Latch Low Byte */ /* Default 0x03 = 38,400 BPS */ /* 0x02 = 56,700 BPS */ /* 0x06 = 19,200 BPS */ /* 0x0C = 9,600 BPS */ /* 0x18 = 4,800 BPS */ /* 0x30 = 2,400 BPS */ outportb(port1 + 1, 0x00); /* Set Baud rate Divisor Latch High Byte */ outportb(port1 + 3, 0x03); /* 8 Bits, No Parity, 1 Stop Bit */ outportb(port1 + 2, 0xC7); /* FIFO Control Register */ outportb(port1 + 4, 0x0B); /* Turn on DTR, RTS, and OUT2 */ /* Set Programmable Interrupt Controller */ /* COM1, COM3 (IRQ4) 0xEF */ /* COM2, COM4 (IRQ3) 0xF7 */ outportb(0x21,(inportb(0x21) & 0xF7)); outportb(port1 + 1, 0x01); /* Interrupt when data received */ printf("\nsample Comm's Program. Press ESC to quit \n"); do { if (bufferin!= bufferout) { ch = buffer[bufferout]; bufferout++; 9

10 if (bufferout == 1024) {bufferout = 0; printf("%c",ch); if (kbhit()) { c = getch(); outportb(port1, c); while (c!= 27); outportb(port1 + 1, 0); /* Turn off interrupts Port1 */ outportb(0x21, (inportb(0x21) 0x08)); /* MASK IRQ using PIC */ /* COM1 und COM3 (IRQ4) 0x10 */ /* COM2 unf COM4 (IRQ3) 0x08 */ setvect(intvect, oldport1isr); /* Restore old interrupt vector */ Für die Konfiguration des Bausteines über die UART Register, z.b. die Einstellung der Baudrate, benötigt man relativ viel Detailwissen. Auch C System für DOS stellen einige weitere Funktionen zur Verfügung, die etwas einfacher zu handhaben sind. Die Turbo C Bibliothek stellt die Funktion bioscom(int cmd, char abyte, int port); zur Verfügung. Mit dieser Funktion kann man die Schnittstelle konfigurieren und kann Zeichen ausgeben und einlesen. Das dritte Programmbeispiel ist eine Windows32 Konsolanwendung und verwendet API Funktionen. Dieses Programm läuft auch unter WIN NT/2000. Ein Makro PERR wertet eventuelle Fehler aus. API Funktionen liefern meistens als Rückgabewert einen Erfolgs /Fehlerstatus. Nach dem Aufruf einer API Funktion prüft man in der Regel diesen Status. Die Datei error.c enthält die Funktion perr, welche die Auswertung der Fehlerinformationen implementiert. Die Funktion stammt aus der Dokumentation zu Visual C++. 10

11 /* error.c */ #include <windows.h> #include <stdio.h> #include <string.h> #include <stdlib.h> /********************************************************************* * PURPOSE : report API errors. Allocate a new console buffer, display * error number and error text, restore previous console * buffer * INPUT : current source file name, current line number, name of the * API that failed, and the error number * RETURNS : none *********************************************************************/ /* maximum size of the buffer to be returned from FormatMessage */ #define MAX_MSG_BUF_SIZE 512 void perr(pchar szfilename, int line, PCHAR szapiname, DWORD dwerror) { CHAR sztemp[1024]; DWORD cmsglen; CHAR *msgbuf; /* buffer for message text from system */ int ibuttonpressed; /* receives button pressed in the error box */ /* format our error message */ sprintf(sztemp, "%s: Error %d from %s on line %d:\n", szfilename, dwerror, szapiname, line); /* get the text description for that error number from the system */ 11

12 cmsglen = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM FORMAT_MESSAGE_ALLOCATE_BUFFER 40, NULL, dwerror, MAKELANGID(0, SUBLANG_ENGLISH_US), (LPTSTR) &msgbuf, MAX_MSG_BUF_SIZE, NULL); if (!cmsglen) sprintf(sztemp + strlen(sztemp), "Unable to obtain error message text! \n" "%s: Error %d from %s on line %d", FILE, GetLastError(), "FormatMessage", LINE ); else strcat(sztemp, msgbuf); strcat(sztemp, "\n\ncontinue execution?"); MessageBeep(MB_ICONEXCLAMATION); ibuttonpressed = MessageBox(NULL, sztemp, "Console API Error", MB_ICONEXCLAMATION MB_YESNO MB_SETFOREGROUND); /* free the message buffer returned to us by the system */ if (cmsglen) LocalFree((HLOCAL) msgbuf); if (ibuttonpressed == IDNO) exit(1); return; Die Definitionsdatei dazu: /* error.h */ #define PERR(bSuccess, api) {if (!(bsuccess)) perr( FILE, LINE, \ api, GetLastError()); void perr(pchar szfilename, int line, PCHAR szapiname, DWORD dwerror); 12

13 Das eigentliche Programm: /* File: serialcom.c Author: Karlheinz Zeiner Purpose: Sample C program (MS Windows console application) Read from and write to a serial interface with API functions. Platform: WIN95, WIN98, WIN NT,... */ #include <windows.h> #include <stdio.h> #include <conio.h> #include "error.h" #define ESC 27 #define EOL 13 /* end of line */ void main(void) { DCB dcb; /* device control block */ HANDLE hcom; BOOL fsuccess; BOOL blineend; char szline[80]; char ckb; int i; DWORD BytesRead, BytesWrite; COMMTIMEOUTS timeouts; 13

14 int portid; char *ComPort[] = {"COM1","COM2","COM3","COM4","COM5","COM6"; /* DCB and COMMTIMEOUTS are system defined structures, */ /* HANDLE, BOOL, DWORD are predefined simple datatypes (typedef's) */ /* The used constants are also defined in the windows header files */ printf("port Nummer [1..6]: "); scanf("%i", &portid); portid ; hcom = CreateFile(ComPort[portid], GENERIC_READ GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, /* no overlapped I/O */ NULL); /* must be NULL for comm devices */ PERR(hCom!= INVALID_HANDLE_VALUE, "CreateFile"); fsuccess = GetCommState(hCom, &dcb); PERR(fSuccess, "GetCommState"); /* configure the port */ dcb.baudrate = 9600; dcb.bytesize = 8; dcb.parity = NOPARITY; 14

15 dcb.stopbits = ONESTOPBIT; dcb.fdtrcontrol = DTR_CONTROL_DISABLE; dcb.finx = FALSE; fsuccess = SetCommState(hCom, &dcb); PERR(fSuccess, "SetCommState"); fsuccess = GetCommTimeouts (hcom, &timeouts); PERR(fSuccess, "GetCommTimeouts"); /* Only to show the content of the COMMTIMEOUTS structur */ printf("timeout values:\n" "ReadIntervalTimeout = %u\n" "ReadTotalTimeoutMultiplier = %u\n" "ReadTotalTimeoutConstant = %u\n" "WriteTotalTimeoutMultiplier = %u\n" "WriteTotalTimeoutConstant = %u\n", timeouts.readintervaltimeout, timeouts.readtotaltimeoutmultiplier, timeouts.readtotaltimeoutconstant, timeouts.writetotaltimeoutmultiplier, timeouts.writetotaltimeoutconstant); /* Set timeout to 0 to force that: If a character is in the buffer, the character is read, If no character is in the buffer, the function do not wait and returns immediatly */ timeouts.readintervaltimeout = MAXDWORD; 15

16 timeouts.readtotaltimeoutmultiplier = 0; timeouts.readtotaltimeoutconstant = 0; fsuccess = SetCommTimeouts (hcom, &timeouts); PERR(fSuccess, "SetCommTimeouts"); printf( "\n\n \n" "Wait for inputs from the serial port\n" "Gets maximal 70 characters until a EndOfLine character (RETURN) is detected\n\n"); i = 0; blineend = FALSE; do { /* look for a character in the input buffer */ ReadFile ( hcom, &szline[i], 1, &BytesRead, NULL); if (BytesRead > 0) { /* a character was read, show the character and the ASCII Code */ printf("%c<%03u>", szline[i], szline[i]); if (szline[i] == EOL) /* check end of line */ blineend = TRUE; i++; if (blineend i > 70) { szline[ i] = '\0'; printf("\n% s (%3i characters\n)", szline, i); /* Write the string back to the serial port */ 16

17 i = 0; WriteFile( hcom, "\n", 1, &BytesWrite, NULL); while (szline[i]) { WriteFile( hcom, &szline[i++], 1, &BytesWrite, NULL); i = 0; blineend = FALSE; /* give us a chance to end the program with ESC from keyboard */ if (kbhit()) ckb = getch(); while (ckb!= ESC); fsuccess = CloseHandle(hCom); PERR(fSuccess, "CloseHandle"); /* end main */ 17