xalib.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    xalib.c
 *  @brief   Front-end de la bibliothèque
 *  @author  Francois Fevotte <francois.fevotte@ensta.org>
 *  $Revision: 28 $
 *  $Date: 2007-03-22 13:48:33 +0100 (jeu, 22 mar 2007) $
 */

/* $Id: xalib.c 28 2007-03-22 12:48:33Z franceso $ */

#define XALIB_C

#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include "xalib.h"
#include "statique.h"
#include "messages.h"
#include "os_dep_usb.h"    /* Fonctions spécifique pour la communication avec le port USB */
#include "os_dep_serial.h" /* Fonctions spécifique pour la communication avec le port série */
#include "codes.h"         /* Codes de fonctions et de valeurs de retour */

#define SOURCE_ERREUR "xalib"
#include "erreur.h"

/* Buffers */
int lastget=0;             /** Le dernier caractère lu dans le buffer Rec_buffer */




/*constantes*/
int npre = 50, carpre = 240, npre_start = 5;

/*variables globales*/
char *XA_adrip;
/*thandle fhandle; */


/** Ouverture d'un pack
    @param typepack le code du pack à ouvrir
    @param ncom numéro du port série (le cas échéant)
    @param baudrate la vitesse de transmission dans le cas d'un port série
    @return le code de retour correspondant (Cf. table des codes de retour)
    @li 0: pas de problème
    @li 102: erreur d'ouverture
    @remarks le code de retour est copié dans la variable globale 'coderr'
*/
int XA_open (int typepack, int ncom, int baudrate)
{
  XA_typepack = typepack;
        
  switch( XA_typepack )
    {
    case 0 : /* USB */
      if( usb::open() )
        {
          coderr = 102;
          return coderr;
        }
      break;

    case 1 :
    case 2 :  /* série */
      if( serial::open(XA_typepack) )
        {
          coderr = 102;
          return coderr;
        }
      break;
                
      /* Ajouter ici les autres types de packs */
                
    default : /* Type de pack inconnu */
      {
        char message[1024];
        sprintf(message, "XA_open : type de pack inconnu (typepack=%d)", typepack);
        erreur::fatale( message );
        coderr = 102;
        return coderr;
      }
    }
        
  XA_opendone = 1;
  coderr = 0;
  return coderr;
}


/** Fermeture du pack courant
 *  @return Cf. table des codes de retour:
 */
int XA_close ()
{
  switch( XA_typepack )
    {
    case 0: /* USB */
      usb::close();
      break;
    case 1:
    case 2: /* série */
      serial::close();
      break;
    default : /* Type de pack inconnu */
      {
        char message[1024];
        sprintf(message, "XA_close : type de pack inconnu (typepack=%d)", XA_typepack);
        erreur::fatale( message );
        coderr = 102;
        return coderr;
      }
    }
  
  XA_opendone = 0;
  return 0;
}

int XA_coderr ()
{
  return coderr;
}

int XA_getB ()
{
  int res = Rec_buffer[XA_ptrget];
  lastget = res;
        
  if (XA_ptrget < 255)
    XA_ptrget++;
        
  return res;
}

long XA_lastgetB ()
{
  return lastget;
}

unsigned int XA_getW () {
  unsigned int mot;
     
  mot = Rec_buffer[XA_ptrget];
  if (XA_ptrget < 255) XA_ptrget++;

  mot = (mot << 8) + Rec_buffer[XA_ptrget];
  if (XA_ptrget < 255) XA_ptrget++;

  return mot;
}


long XA_getL () {
  long Long = Rec_buffer[XA_ptrget];
  int i;

  for (i=0;i<3;i++) {
    if (XA_ptrget < 255)
      XA_ptrget++;
    Long = (Long << 8) + Rec_buffer[XA_ptrget];
  }
  if (XA_ptrget < 255)
    XA_ptrget++;
  return Long;
}


unsigned char hi (int a)
{
  return (a >> 8) & 0xFF;
}


unsigned char lo(int x)
{
  return (x & 0xFF);
}


long XA (char send, long fonction, long adrmod, long arg1, long arg2, long arg3, long arg4, long arg5)
{
  int foncbyte, entier, res;
        
  coderr = 255;
  res = coderr ;
  foncbyte = fonction & 255;
  
  /* Fonctions sans arguments */
  if( ((foncbyte >0)&&(foncbyte<20)) || (foncbyte==204) || (foncbyte==205) || (foncbyte==207) )
    {
      XA_build(adrmod,foncbyte,1);
      if(send) res = XA_send();
    }
  
  /* Fonctions avec 1 caractère */
  if (((foncbyte >=20)&&(foncbyte<30)) || (foncbyte == 80))
    {
      XA_build(adrmod,foncbyte,1);
      XA_insertB(arg1);
      if(send) res = XA_send();
    }
        
  /* Fonctions avec 1 mot */
  if ((foncbyte >=30)&&(foncbyte<40))
    {
      XA_build(adrmod,foncbyte,1) ;
      XA_insertB(hi(arg1));
      XA_insertB(lo(arg1));
      if(send) res = XA_send();
    }
        
  /* Fonctions avec 1 long */
  if ((foncbyte >=40)&&(foncbyte<50))
    {
      XA_build(adrmod,foncbyte,1) ;
      entier = arg1 >> 16 ;
      XA_insertB(hi(entier));
      XA_insertB(lo(entier));
      XA_insertB(hi(arg1));
      XA_insertB(lo(arg1));
      if(send) res = XA_send();
    }
        
  /* Fonctions avec 2 caractères */
  if ((foncbyte >=50)&&(foncbyte<60))
    {
      XA_build(adrmod,foncbyte,1);
      XA_insertB(arg1);
      XA_insertB(arg2);
      if(send) res = XA_send();
    }
        
  /* Fonctions avec 1 caractère et 1 mot */
  if ((foncbyte >=60)&&(foncbyte<70))
    {
      XA_build (adrmod, foncbyte, 1) ;
      XA_insertB (arg1) ;
      XA_insertB (hi (arg2)) ;
      XA_insertB (lo (arg2)) ;
      if(send) res = XA_send();
    }
        
  /* Fonctions avec 1 caractère et 1 long */
  if ((foncbyte >=70)&&(foncbyte<80))
    {
      XA_build(adrmod,foncbyte,1);
      XA_insertB(arg1);
      entier = arg2 >> 16;
      XA_insertB(hi(entier));
      XA_insertB(lo(entier));
      XA_insertB(hi(arg2));
      XA_insertB(lo(arg2));
      if(send) res = XA_send();
    }

  /* Lectures  simples de N octets */
  if ((foncbyte >=100)&&(foncbyte<=115))
    {
      XA_build(adrmod,foncbyte,(foncbyte-98));
      if(send) res = XA_send();
    }
        
  /* Ecriture 1 caractere et lecture N octets */
  if ((foncbyte >=120)&&(foncbyte<=135))
    {
      XA_build(adrmod,foncbyte,(foncbyte-118));
      XA_insertB(arg1);
      if(send) res = XA_send();
    }
        
  /* Fonction spéciale DSI */
  if (foncbyte == 140)
    {
      XA_build(adrmod,foncbyte,1);
      XA_insertB(hi(arg2));
      XA_insertB(lo(arg2));
      XA_insertB(hi(arg3));
      XA_insertB(lo(arg3));
      XA_insertB(hi(arg4));
      XA_insertB(lo(arg4));
      XA_insertB(hi(arg5));
      XA_insertB(lo(arg5));
      XA_insertB(arg1);
      if(send) res = XA_send();
    }
        
  /* Fonction spéciale d'ouverture du pack */
  if (foncbyte == 200)
    res = XA_open(adrmod,arg1,arg2);
        
  /* Fonction spéciale de fermeture du pack */
  if (foncbyte == 201)
    res = XA_close();

  /* Fonction spéciale de changement d'adresse du pack */
  if (foncbyte == 202)
    XA_adrpack = adrmod;

  /* Fonction spéciale de réadressage du module */
  if (foncbyte == 203)
    {
      XA_build(adrmod,foncbyte,1);
      XA_insertB(arg1);
      if(send) res = XA_send();
    }
        
  /* Lecture version */
  if (foncbyte == 206)
    {
      XA_build(adrmod,foncbyte,3);
      if(send) res = XA_send();
    }
        
        
        
        
  /* Ecritures I2C pures */
        
  /* 1 caractère */
  if (foncbyte == 210)
    {
      XA_createmsg(adrmod,0);
      XA_insertB(arg1);
      if(send) res = XA_send();
    }

  /* 1 mot */
  if (foncbyte == 211)
    {
      XA_createmsg(adrmod,0);
      XA_insertB(arg1);
      XA_insertB(arg2);
      if(send) res = XA_send();
    }
        
  /* 1 mot */
  if (foncbyte == 212)
    {
      XA_createmsg(adrmod,0);
      XA_insertB(arg1);
      XA_insertB(arg2);
      XA_insertB(arg3);
      if(send) res = XA_send();
    }
        
  /* 1 mot */
  if (foncbyte == 213)
    {
      XA_createmsg(adrmod,0);
      XA_insertB(arg1);
      XA_insertB(arg2);
      XA_insertB(arg3);
      XA_insertB(arg4);
      if(send) res = XA_send();
    }
        
  /* 1 mot */
  if (foncbyte == 214)
    {
      XA_createmsg(adrmod,0);
      XA_insertB(arg1);
      XA_insertB(arg2);
      XA_insertB(arg3);
      XA_insertB(arg4);
      XA_insertB(arg5);
      if(send) res = XA_send();
    }
        
  /* Lecture I2C pure */
  if (foncbyte == 220)
    {
      XA_createmsg(adrmod,1);
      XA_insertB(arg1);
      if(send) res = XA_send();
    }
        
  return res;
}


long XAN_str (long fonction, long adrmod, char *chaine, long arg)
{
  int ncar;
  int res;
        
  coderr = 255;
  res = coderr;
        
  switch (fonction)
    {
    case 81 :
      XA_build(adrmod,81,1);
      if (*chaine)
        {
          for( ncar=0; chaine[ncar]; ncar++ )
            XA_insertB(((int)(chaine[ncar])));
          res = XA_send();
        }
      break;
    case 202 :
      coderr = 0;
      XA_adrip = chaine;
      break;
    default :
      break;
    }
        
  res = coderr;
  return res;
}

void XA_startup()
{
  /* ouverture du fichier de log d'erreur */
  erreur::openlog();

  /* message d'initialisation */
  fprintf( stdout,  "Initialisation de la bibliothèque XA\n" );
  fprintf( stdout,  "\t$HeadURL: https://libextralink.svn.sourceforge.net/svnroot/libextralink/trunk/xalib.c $\n\t$Revision: 28 $\n\n" );
  fprintf( logfile, "Initialisation de la bibliothèque XA\n" );
  fprintf( logfile, "\t$HeadURL: https://libextralink.svn.sourceforge.net/svnroot/libextralink/trunk/xalib.c $\n\t$Revision: 28 $\n\n" );

  /* ouverture */
  XAN( OPEN,   1, 0,0,0,0,0 );
  
  /* clignotement de la LED pour tester */
  XAN( LEDON,  8, 0,0,0,0,0 );
  usleep( 200000 );
  XAN( LEDOFF, 8, 0,0,0,0,0 );
  usleep( 200000 );
  XAN( LEDON,  8, 0,0,0,0,0 );
  usleep( 200000 );
  XAN( LEDOFF, 8, 0,0,0,0,0 );
}

void XA_cleanup()
{
  /* fermeture de la connexion */
  XAN( CLOSE, 1, 0,0,0,0,0 );

  /* fermeture du fichier de log d'erreur */
  erreur::closelog();

}

---