[Linux] Initialisierung eines Serial-Ports

[Alex44 (Gast)]

Hallo,

ich versuche gerade auf meinem Linuxrechner ein kleines C-Prog zu 
schreiben, mir dem ich einen Seriellen Port auslesen kann (nur Rx und Tx 
angeschlossen!)

Ich vermute, dass ich Probleme bei der Konfiguration des Ports habe, 
denn immer wenn im Hintergrund GTK-Term läft, empfängt auch mein 
Programm. Schalte ich GTK-Term ab - steht auch mein Prog wieder.

Was macht GTK-Term, was ich nicht mache?

Hier der Code

/*
 * Im Folgenden soll versucht werden auf eine serielle Schnittstelle zu
 * schreiben.
 *
 * Dafür wird ein USB auf Seriell Konverterkabel verwendet, welcher über
 * die Gerätedatei /dev/ttyUSB0 erreichbar ist.
 */

 #include <stdio.h>     // Standard input/output Definitionen
 #include <string.h>    // String Funktionen Definitionen
 #include <unistd.h>    // UNIX Standard Funktionen Definitionen
 #include <fcntl.h>     // File control Definitionen
 #include <errno.h>     // Error number definitionen
 #include <termios.h>   // POSIX terminal control Definitionen
 #include <inttypes.h>  // Spezielle int-Datentypen

#define DEVICE "/dev/ttyUSB0"

/* mögliche Baudraten
 * 
 *      CBAUD      Bit mask for baud rate
 * 
 *      B0          0 baud (drop DTR)
 *      B50         50 baud
 *      B75          75 baud
 *      B110      110 baud
 *      B134      134,5 baud
 *      B150      150 baud
 *      B200      200 baud
 *      B300      300 baud
 *      B600      600 baud
 *      B1200      1.200 baud
 *      B1800      1.800 baud
 *      B2400      2.400 baud
 *      B4800      4.800 baud
 *      B9600      9.600 baud
 *      B19200      19.200 baud
 *      B38400      38.400 baud
 *      B57600      57.600 baud
 *      B76800      76.800 baud
 *      B115200     115.200 baud
 */
#define BAUDRATE_ein B115200
#define BAUDRATE_aus B115200

/*
 * Einstellungen für das Datenformat
 */
#define D_FORMAT _8N2

/*
 *  dazu fordefinierte Makros
 */
#if (D_FORMAT == _8N1)  // No parity (8N1):
  #define SETZE_FORMAT() {     \
    options.c_cflag &= ~PARENB;  \
      options.c_cflag &= ~CSTOPB;  \
      options.c_cflag &= ~CSIZE;  \
      options.c_cflag |= CS8;    \
     }

#elif (D_FORMAT== _8N2)  // No parity (8N2):
  #define SETZE_FORMAT() {     \
    options.c_cflag &= ~PARENB;  \
      options.c_cflag |= CSTOPB;  \
      options.c_cflag &= ~CSIZE;  \
      options.c_cflag |= CS8;    \
     }

#elif (D_FORMAT== _7E1)  // Even parity (7E1):
  #define SETZE_FORMAT() {     \
      options.c_cflag |= PARENB;  \
      options.c_cflag &= ~PARODD;  \
      options.c_cflag &= ~CSTOPB;  \
      options.c_cflag &= ~CSIZE;  \
      options.c_cflag |= CS7;    \
     }

#elif (D_FORMAT== _7O1)  // Odd parity (7O1):
  #define SETZE_FORMAT() {     \
      options.c_cflag |= PARENB;  \
      options.c_cflag |= PARODD;  \
      options.c_cflag &= ~CSTOPB;  \
      options.c_cflag &= ~CSIZE;  \
      options.c_cflag |= CS7;    \
     }

#elif (D_FORMAT== _7S1)  // Even parity (Space parity (gleich wie No parity (7S1)):
  #define SETZE_FORMAT() {     \
      options.c_cflag &= ~PARENB;  \
      options.c_cflag &= ~CSTOPB;  \
      options.c_cflag &= ~CSIZE;  \
      options.c_cflag |= CS8;    \
     }
#endif



/*
 * Das vom Sensor gesendete Paket beinhaltet 2 char-Bytes ('u''s') zur
 * Kalibrierung und die Höhe in der Länge von 2 Byte
 */
struct us_data
{
  char u;
  char s;
  uint16_t ush; 
} us_data;


/*
 * öffnet den oben angegebenen Port und gibt die Adresse zurück
 */
FILE *open_port(int *ifd)
{
    FILE *port;
    port = fopen(DEVICE, "rw");
  *ifd = open(DEVICE, O_RDWR | O_NOCTTY | O_NDELAY);

  if ((*ifd == -1)||(port == NULL))
  {
    perror("open_port: "DEVICE" konnte nicht geöffnet werden");
    _exit(ENODEV);
  }
    else
  {
    fcntl(*ifd, F_SETFL, 0);
  }
        
    return port;
}

/*
 *  Konfiguriere Port
 */
int config_port(int ifd)
{
  struct termios options;

    /*
     * Hohle aktuelle Optionen des Ports...
     */
    tcgetattr(ifd, &options);

    /*
     * Setze die Baudraten...
     */
    cfsetispeed(&options, BAUDRATE_ein);
    cfsetospeed(&options, BAUDRATE_aus);

    /*
     * Setze das Übertragungsformat...
     */
  SETZE_FORMAT()

    /*
     * Enable the receiver and set local mode...
     */
    options.c_cflag |= (CLOCAL | CREAD);

    /*
     * Setze die neuen Portoptionen...
     */
    tcsetattr(ifd, TCSANOW, &options);

  return 0;
}


/*
 * schreibt buf auf fd mit einer Länge von nbyte
 */
int write_n (FILE* fd, const void* buf, size_t nbyte)
{
    fwrite(buf, nbyte, 1 , fd);
    return 0;
}

/*
 * liest buf aus fd mit einer Länge von nbyte ein
 */
int read_n (FILE* fd, void* buf, size_t nbyte)
{
  fread(buf, nbyte, 1 , fd);
    return 0;
}

/*
 *  Synchronisiert den Eingangstrom indem nach dem 's' des Eingangsstroms
 *  gesucht und dann zwei Bytes (Höhenbytes) ausgelesen werden. So wird der
 *  nächste Lesevorgang vorraussichtlich bei 'u' beginnen.
 */
void read_sync (FILE* fd)
{
  char ein = 0;
  while (ein!='s')
  {
    read_n(fd, &ein, 1);
  }
  read_n(fd, &ein, 1);
  read_n(fd, &ein, 1);
}

/*
 *  liest Daten des US-Sensors vom Port ein und selektiert die Höhenwerte
 */
int read_us(FILE* fd)
{
  read_n(fd, &us_data, 4);
  return (int)us_data.ush;
}


int main (void)
{

  int ifd;
    FILE *fd; /* File descriptor für den Port */
    printf("öffne "DEVICE);
    fflush(stdout);
    fd = open_port(&ifd);
    printf(" - fertig\n");
    
    printf("Konfiguriere "DEVICE);
    fflush(stdout);
  config_port(ifd);
    printf(" - fertig\n");

    int i,n;

//  read_sync(fd);  
  
    for(i = 0 ; i <= 512 ; i++)
    {
 //       printf("\rSchicke: %3i", i);
 //       fflush(stdout);

//        n = write_n(fd, &i, 8);
//        n = read_n(fd, &us_data, 1);
//        printf("lese(%i): %c\n", i,us_data);
 
     n=0;
        printf("%i\n",read_us(fd));
        fflush(stdout);
        
        if(n < 0)
        {
            fputs("write() of 8 bytes failed!\n", stderr);
        }
        
    }
    
    printf("Schließe "DEVICE);
    fflush(stdout);
    close(ifd);
    fclose(fd);
    printf(" - fertig\n");
    
    printf("\nEnde\n");
    return 0;
}

Falls sich jemand wundert, warum ich zwei Filedeskriptoren habe - das 
tue ich auch. Denn open() kann mit FILE* nichts anfangen und read() 
nichts mit int.

Ich hoffe, mir kann einer einen Tipp geben.

Danke und Gruß
Alex

[Klaus W. (mfgkw)]

1. Deine Fehlerbehandlung ist nicht zielführend; z.B. kannst du nicht 
unterscheiden welches Öffnen nicht geklappt hat, geschweige denn warum

2. Das Device zweimal zu öffnen wird nicht klappen. Stattdessen solltwst 
du nur das low level io-device öffnen (open()) und dann zu diesem file 
descriptor ein FILE* holen mit fdopen().
Oder umgekehrt fopen(), und dann dessen fd ermitteln.

3. Das mit den Makros erscheint mir nicht geschickt. Ist deine Sache, 
aber schwer zum Fehlersuchen, damit ist die Fehlersuche halt auch deine 
Sache :-)

(evtl. noch mehr Fehler. aber so wird es sicher nichts...)

[Alex44 (Gast)]

Hallo,

danke erst einmal für die Anmerkungen. Und ja, die Fehlerbehandlung muss 
noch überdacht werden.

Trotz allem lag der Fehler in der Porteinrichtung und das konnte behoben 
werden, in dem man den Quellcode offener Terminals liest. (hier war mir 
besonders cutecom eine große Hilfe)

/*
 * Im Folgenden soll versucht werden auf eine serielle Schnittstelle zu
 * schreiben.
 *
 * Dafür wird ein USB auf Seriell Konverterkabel verwendet, welcher über
 * die Gerätedatei /dev/ttyUSB0 erreichbar ist.
 */

 #include <stdio.h>     // Standard input/output Definitionen
 #include <string.h>    // String Funktionen Definitionen
 #include <unistd.h>    // UNIX Standard Funktionen Definitionen
 #include <fcntl.h>     // File control Definitionen
 #include <errno.h>     // Error number definitionen
 #include <termios.h>   // POSIX terminal control Definitionen
 #include <inttypes.h>  // Spezielle int-Datentypen

/*
 *  Korrekturwerte für die Messwerte
 */
#define KORREKTURTEILER 25600.0f  //Korrekturfaktor, der ein Teiler ist
#define KORREKTURAW 0.01f      // Offset

/*
 *  Serielle Portadresse
 */
#define DEVICE "/dev/ttyUSB0"

/*
 *  Handshake
 */
#define SOFTWAREHANDSHAKE 0
#define HARDWAREHANDSHAKE 0

/* mögliche Baudraten
 * 
 *      CBAUD      Bit mask for baud rate
 * 
 *      B0          0 baud (drop DTR)
 *      B50         50 baud
 *      B75          75 baud
 *      B110      110 baud
 *      B134      134,5 baud
 *      B150      150 baud
 *      B200      200 baud
 *      B300      300 baud
 *      B600      600 baud
 *      B1200      1.200 baud
 *      B1800      1.800 baud
 *      B2400      2.400 baud
 *      B4800      4.800 baud
 *      B9600      9.600 baud
 *      B19200      19.200 baud
 *      B38400      38.400 baud
 *      B57600      57.600 baud
 *      B76800      76.800 baud
 *      B115200     115.200 baud
 */
#define BAUDRATE_ein B115200
#define BAUDRATE_aus B115200

/*
 * Einstellungen für das Datenformat
 */
#define D_FORMAT _8N2

/*
 *  dazu fordefinierte Makros
 */
#if (D_FORMAT == _8N1)  // No parity (8N1):
  #define SETZE_FORMAT() {     \
    optionen.c_cflag &= ~PARENB;  \
      optionen.c_cflag &= ~CSTOPB;  \
      optionen.c_cflag &= ~CSIZE;  \
      optionen.c_cflag |= CS8;    \
     }

#elif (D_FORMAT== _8N2)  // No parity (8N2):
  #define SETZE_FORMAT() {     \
    optionen.c_cflag &= ~PARENB;  \
      optionen.c_cflag |= CSTOPB;  \
      optionen.c_cflag &= ~CSIZE;  \
      optionen.c_cflag |= CS8;    \
     }

#elif (D_FORMAT== _7E1)  // Even parity (7E1):
  #define SETZE_FORMAT() {     \
      optionen.c_cflag |= PARENB;  \
      optionen.c_cflag &= ~PARODD;  \
      optionen.c_cflag &= ~CSTOPB;  \
      optionen.c_cflag &= ~CSIZE;  \
      optionen.c_cflag |= CS7;    \
     }

#elif (D_FORMAT== _7O1)  // Odd parity (7O1):
  #define SETZE_FORMAT() {     \
      optionen.c_cflag |= PARENB;  \
      optionen.c_cflag |= PARODD;  \
      optionen.c_cflag &= ~CSTOPB;  \
      optionen.c_cflag &= ~CSIZE;  \
      optionen.c_cflag |= CS7;    \
     }

#elif (D_FORMAT== _7S1)  // Even parity (Space parity (gleich wie No parity (7S1)):
  #define SETZE_FORMAT() {     \
      optionen.c_cflag &= ~PARENB;  \
      optionen.c_cflag &= ~CSTOPB;  \
      optionen.c_cflag &= ~CSIZE;  \
      optionen.c_cflag |= CS8;    \
     }
#endif



/*
 * Das vom Sensor gesendete Paket beinhaltet 2 char-Bytes ('u''s') zur
 * Kalibrierung und die Höhe in der Länge von 2 Byte
 */
struct us_data
{
  char u;
  char s;
  uint16_t ush; 
} us_data,   alt_us_data;


/*
 * öffnet den oben angegebenen Port und gibt die Adresse zurück
 */
FILE *open_port(int *ifd)
{
    FILE *port;
    port = fopen(DEVICE, "rw");
  *ifd = open(DEVICE, O_RDWR | O_NOCTTY | O_NDELAY);
  
  if ((*ifd == -1)||(port == NULL))
  {
    perror("open_port: "DEVICE" konnte nicht geöffnet werden");
    _exit(ENODEV);
  }
    else
  {
    fcntl(*ifd, F_SETFL, 0);
  }
        
    return port;
}

/*
 *  Konfiguriere Port
 */
 
int config_port(int ifd)
{
  struct termios optionen;

    // Hohle aktuelle Optionen des Ports...
  if (tcgetattr(ifd, &optionen)!=0)
  {
    perror("tcgetattr() 3 failed\n");
  }

    // Setze die Baudraten...
    cfsetispeed(&optionen, BAUDRATE_ein);
    cfsetospeed(&optionen, BAUDRATE_aus);

    // Setze das Übertragungsformat...
  SETZE_FORMAT()

    // Enable the receiver and set local mode...
    optionen.c_cflag |= (CLOCAL | CREAD);
    
    //hardware handshake
  optionen.c_cflag &= ~CRTSCTS;
  
//  optionen.c_iflag=IGNPAR | IGNBRK;
  optionen.c_iflag=IGNBRK;
//  optionen.c_iflag=IGNPAR;

  if (SOFTWAREHANDSHAKE)
  {
    optionen.c_iflag |= IXON | IXOFF;
  }
  else
  {
    optionen.c_iflag &= ~(IXON|IXOFF|IXANY);
  }
  
  //hardware handshake
  if (HARDWAREHANDSHAKE)
  {
    optionen.c_cflag |= CRTSCTS;
  }
  else
  {
    optionen.c_cflag &= ~CRTSCTS;
  }

  optionen.c_lflag=0;
  optionen.c_oflag=0;

  optionen.c_cc[VTIME]=1;
  optionen.c_cc[VMIN]=60;

    // Setze die neuen Portoptionen...
  if (tcsetattr(ifd, TCSANOW, &optionen)!=0)
  {
    perror("tcsetattr() 1 failed\n");
  }

  return 0;
}


/*
 * schreibt buf auf fd mit einer Länge von nbyte
 */
int write_n (FILE* fd, const void* buf, size_t nbyte)
{
    fwrite(buf, nbyte, 1 , fd);
    return 0;
}

/*
 * liest buf aus fd mit einer Länge von nbyte ein
 */
int read_n (FILE* fd, void* buf, size_t nbyte)
{
  fread(buf, nbyte, 1 , fd);
    return 0;
}

/*
 *  Synchronisiert den Eingangstrom indem nach dem 's' des Eingangsstroms
 *  gesucht und dann zwei Bytes (Höhenbytes) ausgelesen werden. So wird der
 *  nächste Lesevorgang vorraussichtlich bei 'u' beginnen.
 */
void read_sync (FILE* fd)
{
  char ein = 0;
  while (ein!='s')
  {
    read_n(fd, &ein, 1);
  }
  read_n(fd, &ein, 1);
  read_n(fd, &ein, 1);
}

/*
 *  liest Daten des US-Sensors vom Port ein und selektiert die Höhenwerte
 */
float read_us(FILE* fd)
{
//  alt_us_data = us_data;
  read_n(fd, &us_data, 4);
  if (us_data.s!='s')
  {  
    read_sync(fd);
    return (int)alt_us_data.ush;
  }
  else
  {  
    return (float)( ((int)us_data.ush)/KORREKTURTEILER )+KORREKTURAW;
  }
}


int main (void)
{
  alt_us_data.ush = -1;
  int ifd;
    FILE *fd; /* File descriptor für den Port */
//    printf("öffne "DEVICE);
//    fflush(stdout);
    fd = open_port(&ifd);
//    printf(" - fertig\n");
    
//    printf("Konfiguriere "DEVICE);
    fflush(stdout);
//  config_port(ifd);
//    printf(" - fertig\n");

    int i,n;

  read_sync(fd);  
  
    for(i = 0 ; i <= 512 ; i++)
    {
 //       printf("\rSchicke: %3i", i);
 //       fflush(stdout);

//        n = write_n(fd, &i, 8);
//        n = read_n(fd, &us_data, 1);
//        printf("lese(%i): %c\n", i,us_data);
 
     n=0;
        printf("%f\n",read_us(fd));
        fflush(stdout);
        
        if(n < 0)
        {
            fputs("write() of 8 bytes failed!\n", stderr);
        }
        
    }
    
//    printf("\n");
//    printf("Schließe "DEVICE);
//    fflush(stdout);
    close(ifd);
    fclose(fd);
//    printf(" - fertig\n");
    
//    printf("\nEnde\n");
    return 0;
}

[Jörg W. (dl8dtl) (Moderator)]

Alex44 schrieb:
> Was macht GTK-Term, was ich nicht mache?

Möglicherweise den Port in den "raw" mode schalten.  Normalerweise
arbeitet er im "cooked" mode, d. h. die Editierfunktionen für eine
Eingabezeile sind aktiviert (Backspace und dergleichen), und nur
komplette Zeilen werden dann (am Stück) übertragen.

Schau dir mal die man page zur Funktion cfmakeraw(3) an.  Die ist
zwar nicht Posix, aber Linux hat sie offenbar von BSD übernommen.
Das ist eine Helper-Funktion, die alle notwendigen Einstellungen
dafür vornimmt.

[900ss (900ss)]

Hier steht alles gut beschrieben.

http://tldp.org/HOWTO/Serial-Programming-HOWTO/index.html

http://www.easysw.com/~mike/serial/serial.html

Und der Tip von Jörg könnte schon passen.

[Joerg W. (joergwolfram)]

So verwende ich den seriellen Port (bei mir /dev/ttyACM0 für einen 
AVR-CDC) bei meinem R8C Programmer, das O_NONBLOCK brauche ich um einen 
Timeout beim Device zu erkennen:

static struct termios portstate;

int open_serial(char *devicename)
{
  int fd;
  
  struct termios my_port;

  if ((fd = open(devicename, O_RDWR | O_NOCTTY | O_NONBLOCK)) == -1)
  {
    perror("ERROR: open()");
    return 0;
  }
  if (tcgetattr(fd, &portstate) == -1)
  {
    perror("ERROR: tcgetattr()");
    return 0;
  }

  my_port = portstate;

  cfsetispeed(&my_port, B9600);
  cfsetospeed(&my_port, B9600);

  my_port.c_cflag |= CLOCAL | CREAD | CS8;
  my_port.c_cflag &= ~PARENB;
  my_port.c_cflag &= ~CSTOPB;
  my_port.c_oflag = 0;

  if (tcflush(fd, TCIOFLUSH) == -1)
  {
    perror("ERROR: tcflush()");
    return 0;
  }
  if (tcsetattr(fd, TCSANOW, &my_port) == -1)
  {
    perror("ERROR: tcsetattr()");
    return 0;
  }
  return fd;
}

int close_serial(int fd)
{
  tcsetattr(fd, TCSANOW, &portstate);
  if (close(fd) < 0)
  {
    perror("ERROR: close()");
    return 0;
  }
  return 1;
}

Jörg