os_dep_serial.c

Go to the documentation of this file.

/*  Implémentation Linux de la bibliotheque XADLL de Sidena
 *  Copyright (C) 2005 ENSTAR
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  You can contact us:
 *    Association ENSTAR
 *    Ecole Nationale Superieure de Techniques Avancees
 *    32 boulevard Victor
 *    75739 Paris Cedex 15
 *    FRANCE
 *
 *    enstar@ensta.fr
 */

/** @file    os_dep_serial.c
 *  @brief   Bibliothèque de fonctions de communication avec le port série
 *  @author  Francois Fevotte <francois.fevotte@ensta.org>
 *  $Revision: 60 $
 *  $Date: 2006-03-16 16:55:36 +0100 (Thu, 16 Mar 2006) $
 *
 *  Ce code implémente les fonctions de communications spécifiques à la liaison série (sous LINUX).
 */

/* $Id: os_dep_serial.c 60 2006-03-16 15:55:36Z francois $ */

#define OS_DEP_USB_C

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <time.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <string.h>
#include "xalib.h"
#include "os_dep_serial.h"
#include "statique.h"
#include <errno.h>

/* Gestion des erreurs */
#define SOURCE_ERREUR "os_dep_serial"
#ifdef DEBUG
#define SCREEN_LEVEL 3 // messages de warning a l'ecran
#else
#define SCREEN_LEVEL 2 // pas de messages de warning
#endif
#include "erreur.h"

/* Variables globales */
char XA_comm_init[2] = {0,0}; /* Les ports séries sont-ils initialisés ? */
int  XA_curr_comm;            /* No du port série courant                */
int  XA_comm_port[2];         /* Descripteurs des ports séries ouverts   */

int serial::open(char serial)
{
  struct termios ios;
  char port[32];
  int line_status = 0;

  strcpy( port, "/dev/ttyS0" );

  coderr = 0;

  switch (serial)
    {
    case 1 :
      port[9] = '0';
      if( XA_comm_init[0] ) /* Le port a déjà été initialisé */
        {
          coderr = 8;
          erreur::warning( "open : Le port a déjà été initialisé" );
          return 1;
        }
      break;
    case 2:
      port[9] = '1';
      if( XA_comm_init[1] ) /* Le port a déjà été initialisé */
        {
          coderr = 8;
          erreur::warning( "open : Le port a déjà été initialisé" );
          return 1;
        }
      break;
    default :
      coderr = 12;
      erreur::fatale( "open : Mauvais port série" );
      return 1;
    }
  
  /* Sélection du port courant */
  XA_curr_comm = serial-1;

  /* Ouverture du port */
  XA_comm_port[XA_curr_comm] = ::open( port, O_RDWR | O_NOCTTY | O_NDELAY );
  if( XA_comm_port[XA_curr_comm] == -1 )
    {
      coderr = 7;
      erreur::fatale( "open : erreur à l'ouverture du port" );
      return 1;
    }
  erreur::debug( "Port série ouvert" );

  fcntl(XA_comm_port[XA_curr_comm],F_SETFL,0); // comme l'ENISE...

  /* Configuration des paramètres du port */
  coderr = tcgetattr( XA_comm_port[XA_curr_comm], &ios);

  ios.c_cflag &= ~(PARENB| CBAUD |CSIZE | CRTSCTS);
  ios.c_cflag |= (CS8 | CSTOPB | CREAD | CLOCAL);

  ios.c_iflag = IGNBRK | IGNPAR;

  ios.c_oflag = 0;
  ios.c_lflag = 0;

  ios.c_cc[VTIME] = 0; // intercharacter timer unused
  ios.c_cc[VMIN]  = 0; // blocking read until 1 character is received

  coderr |= cfsetospeed( &ios, B115200 );
  coderr |= cfsetispeed( &ios, B115200 );

  coderr |= tcsetattr( XA_comm_port[XA_curr_comm], TCSANOW, &ios );

  /* Configuration de l'état des pins */
  coderr |= ioctl( XA_comm_port[XA_curr_comm], TIOCMGET, &line_status );
  line_status &= ~TIOCM_DTR; /* DTR bas  */
  line_status |= TIOCM_RTS;  /* TCS haut */
  coderr |= ioctl( XA_comm_port[XA_curr_comm], TIOCMSET, &line_status );

  if( coderr != 0 )
    {
      /* Une erreur s'est produite lors de l'initialisation */
      coderr = 7;
      erreur::fatale( "open : erreur de configuration du port" );
      return 1;
    }
  
  /* Tout s'est bien passé. */
  XA_comm_init[XA_curr_comm]=1;
  erreur::debug( "Port série initialisé" );
  return 0;
}

void serial::close()
{
  if( XA_comm_init[0] )  /* Le port 1 est ouvert */
    {
      ::close( XA_comm_port[0] );
      XA_comm_init[0] = 0;
    }
  if( XA_comm_init[1] )  /* Le port 2 est ouvert */
    {
      ::close( XA_comm_port[1] );
      XA_comm_init[1] = 0;
    }
  erreur::debug( "Ports série fermés" );
}

int serial::write(short length)
{
  if( XA_curr_comm>1 || XA_curr_comm<0 || !XA_comm_init[XA_curr_comm] )
    {
      erreur::fatale( "write : Port série non initialisé" );
      return 0;
    }

  /* Flush du port */
  ioctl( XA_comm_port[XA_curr_comm], TCFLSH, TCIFLUSH );

  /* Ecriture du buffer */
  ::write( XA_comm_port[XA_curr_comm], Out_buffer, length );

#ifdef DEBUG
  {
    char message1[1024];
    char message2[1024];
    int n,i;

    n=snprintf(message1,1023,"%d caractères envoyés :",length );
    snprintf(message2,1023,"%d caractères envoyés :",length );
    for(i=0 ; i<length && n<1024 ; i++)
      {
        snprintf(message1+n,1023-n, " %03d",Out_buffer[i]);
        snprintf(message2+n,1023-n,"  %02X",Out_buffer[i]);
        n+=4;
      }
    erreur::debug( message1 );
    erreur::debug( message2 );
  }
#endif

  return 1;
}

int serial::read(unsigned int *somme)
{
  int lu=0;
  unsigned char c;
  fd_set fd;
  struct timeval tv;

  if( XA_curr_comm>1 || XA_curr_comm<0 || !XA_comm_init[XA_curr_comm] )
    {
      erreur::fatale( "read : Port série non initialisé" );
      return 0;
    }

  FD_ZERO( &fd );
  FD_SET( XA_comm_port[XA_curr_comm], &fd );

  while( 1 )
    {
      int r;

      /* Timeout : 1sec */
      tv.tv_sec  = 1;
      tv.tv_usec = 0;
      
      if( !select( 1+XA_comm_port[XA_curr_comm], &fd, NULL, NULL, &tv ) )
        {
          char message[1024];
          snprintf(message,1023,"read : TIMEOUT ! %d caracteres lus",lu);
          erreur::warning(message);
          break;
        }

      /* data are available on the serial port */
      r = ::read( XA_comm_port[XA_curr_comm], &c, 1 );
      if( r != -1 ) /* all went well */
        {
          Rec_buffer[XA_lastcar_in]+=c;
          if(c!=26) // on a lu un vrai caractere (i.e. pas de transcodage)
            {
              if(c==30) // le message est termine
                {
                  XA_lastcar_in++;
                  lu ++;
                  break;
                }
              else // caractere normal
                {
                  (*somme)+=Rec_buffer[XA_lastcar_in];
                  XA_lastcar_in++;
                  lu ++;
                }
            }
        }
      else /* read failed */
        {
          if( errno != EAGAIN ) /* big problem */
            {
              char err[1024];
              snprintf( err, 1023, "read : read failed (%d)", errno );
              erreur::fatale( err );
              break;
            }
        }
    }

#ifdef DEBUG
 {
   char message1[1024];
   char message2[1024];
   int n,i;

   n=snprintf(message1,1023,"%d caractères lus: ", lu);
   snprintf(message2,1023,"%d caractères lus: ", lu);
   for(i=0 ; i<XA_lastcar_in && n<1024 ; i++)
     {
       snprintf(message1+n,1023-n, " %03d",Rec_buffer[i]);
       snprintf(message2+n,1023-n,"  %02X",Rec_buffer[i]);
       n+=4;
     }
   erreur::debug( message1 );
   erreur::debug( message2 );
 }
#endif

  return lu;
}

---