Fonction de calcul
fr


adc

Contenu du fichier


/* adc Scicos Analog to Digital Converter block
 * Type 4 simulation function ver 1.0 - scilab-3.0
 * 3 Mars 2006 - INRIA - Author : A.Layec
 */

/* REVISION HISTORY :
 * $Log$
 */

#include <math.h>
#include <stdio.h>
#include "scicos_block.h"

/*based on f2c definition*/
#define d_nint(x) ((x) > 0 ? floor((x)+.5) : -floor(.5 - (x)))

/* Cette fonction de calcul réalise la convertion analogique numérique.
 * Les valeurs de sorties sont des valeurs entières signées ou non-signées.
 *
 * entrée régulière : u[0..nu-1] vecteur des entrées régulières à convertir
 * sortie régulière : y1[0..ny-1] vecteur des sorties converties
 *                    y2[0..ny-1] vecteur des sorties de bruit de quantification
 *
 * entrée évènementielle : Dates de déclenchement
 * sortie évènementeille : néant
 *
 * paramètre entier : ipar[0..nu-1]     : méthode de quantification
 *                                        0 - contre-marche
 *                                        1 - mi-marche
 *                   ipar[nu..2*nu-1]   : Nombre de bits de la valeur entière de sortie
 *                   ipar[2*nu..3*nu-1] : flag code complément à 2
 *                                        0 : nombre entier non signé
 *                                        1 : nombre entier signé
 *                   ipar[3*nu]         : flag calcul bruit de quantification
 *                                        0 : pas de calcul
 *                                        1 : calcul sur sortie régulière 2
 *
 * paramètre réel : rpar[0..nu-1]      : pas (ou quantum)
 *                  rpar[nu..2*nu-1]   : valeur minimale ou débute la conversion
 *                  rpar[2*nu..3*nu-1] : erreur d'offset
 *                  rpar[3*nu..4*nu-1] : erreur fsr
 */

/*
 * adcv_c routine de calcul d'un convertisseur analogique numérique
 *
 * Entrées :
 * n       : taille des vecteurs
 * type    : type de quantification (vecteur)
 *           0 - contre marche
 *           1 - mi-marche
 * nbit    : longueur en bit de la valeur décimale de sortie (vecteur)
 * cc2     : flag code complément à 2 (vecteur)
 *           0 : nombre entier non signé
 *           1 : nombre entier signé
 * qn      : flag calcul bruit de quantification (scalaire)
 *           0 : pas de calcul
 *           1 : calcul sur sortie régulière 2
 * q       : pas de quantification (vecteur)
 * vmin    : valeur minimale du début de la quantification (vecteur)
 * of_er   : erreur d'offset (vecteur)
 * fsr_er  : erreur fsr (vecteur)
 * u       : vecteur d'entrée (vecteur)
 *
 * Sorties :
 * y1      : vecteur de sortie du convertisseur (vecteur)
 * y2      : vecteur de sortie du bruit de quantification (vecteur)
 *
 * Dépendances :
 * math.h
 */
void adcv_c(int *n,int *type,int *nbit, int *cc2,int *qn,double *q,double *vmin,\
            double *of_er, double *fsr_er,double *u,double *y1,double *y2)
{
 /*Déclaration des variables compteurs*/
 int i;

 /*Déclaration de variables auxiliares*/
 double fsr; /*full scale range*/
 double fsr_dec; /*decalage du full scale range*/

 for(i=0;i<(*n);i++)
 {
   /*Calcul échelle maximale*/
   fsr=((double)((1<<nbit[i])-1))*q[i];

   /*Calcul erreur fsr*/
   if (fsr_er[i]!=0.0) fsr_dec=u[i]-u[i]*(vmin[i]+fsr+fsr_er[i])/(vmin[i]+fsr);
   else fsr_dec=0.0;

   /*Réalise quantification*/
   if (type[i]==0)
      /*Calcul pour une quantification à contre-marche*/
      y1[i]=q[i]*(d_nint((u[i]+of_er[i]+fsr_dec)/q[i]-.5));
   else if (type[i]==1)
      /*Calcul pour une quantification à mi-marche*/
      y1[i]=q[i]*(d_nint((u[i]+q[i]/2.0+of_er[i]+fsr_dec)/q[i]-.5));

   /*Test sur la grandeur de sortie(saturation)*/
   if(y1[i]<vmin[i]) y1[i]=vmin[i];
   else if(y1[i]>vmin[i]+fsr) y1[i]=vmin[i]+fsr;

   /*Calcul valeur finale*/
   y1[i]=(double)((int)((y1[i]-vmin[i])/q[i]));

   /*Calcul bruit de quantification*/
   if ((*qn)!=0) y2[i]=(y1[i]*q[i])-vmin[i]-u[i];

   /*Test code complément à 2*/
   if(cc2[i]==1) y1[i]=y1[i]-((double)(1<<(nbit[i]-1)));
 }
 return;
}

/*prototype*/
void adc(scicos_block *block,int flag)
{
  /*Déclaration des variables*/
  double *u,*y1,*y2;

  int nu;

  int type;
  int nbit;
  int cc2;
  int qn;

  double q;
  double vmin;
  double of_er;
  double fsr_er;

  /*Récupération des adresses des ports réguliers*/
  u=(double *)block->inptr[0];
  y1=(double *)block->outptr[0];

  /*Récupération de la taille des ports*/
  nu=block->insz[0];

  /*Récupère le type de quantification*/
  type=block->ipar[0];
  /*Récupère le nombre de bit*/
  nbit=block->ipar[nu];
  /*Récupère le type de code*/
  cc2=block->ipar[2*nu];
  /*Récupère calcul de bruit de quantification*/
  qn=block->ipar[3*nu];

  /*Récupère adresse sortie régulière 2*/
  if (qn!=0) y2=(double *)block->outptr[1];

  /*Récupère le quantum*/
  q=block->rpar[0];
  /*Récupère la grandeur minimale d'entrée*/
  vmin=block->rpar[nu];
  /*Récupère l'erreur d'offset*/
  of_er=block->rpar[2*nu];
  /*Récupère l'erreur d'offset*/
  fsr_er=block->rpar[3*nu];

  /*Appel routine adcv_c*/
  adcv_c(&nu,&type,&nbit,&cc2,&qn,&q,&vmin,&of_er,&fsr_er,&u[0],&y1[0],&y2[0]);
}