Fonction de calcul
fr

binreg

Contenu du fichier

/* Modnumlib Scicos interfacing function
 * Copyright (C) 2009 Alan Layec
 *
 * This library 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 library 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 library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
/* binreg Scicos binary right shift register
 * Type 4 simulation function ver 1 - scilab-3.0
 * 14 Mars 2006 - INRIA - Author : A.Layec
 * 20 Mars 2007 - INRIA - Author : A.Layec
 */

/* REVISION HISTORY :
 * $Log$
 */

#include "scicos_block.h"

/* Cette fonction réalise un registre à décalage binaire.
 * A chaque évènement présent sur port évènementiel numéro 1
 * la fonction réalise une acquistion de la valeur présente
 * sur son port d'entrée régulier supposé être de taille
 * nbit*npack puis délivre un paquet de taille nbit sur
 * le port de sortie régulier lorsque un évènement se présente
 * sur son port événementiel 2.
 * A chaque événement 2, un ET logique de nbit bits est réalisé
 * et le registre est décalé de nbit bits vers la droite.
 *
 * Entrée régulière :
 *     - [0..nu-1] vecteur des entiers codés sur nbit*npack
 *
 * Sortie régulière :
 *     - y[0..nu-1] vecteur des entiers codés sur nbit
 *
 * Entrée évènementielle :
 *     - nev=1 Instant d'acquisition du mot en entrée de
 *             taille nbit*npack
 *     - nev=2 Instant de délivrance du mot en sortie de
 *             taille Nbit
 *
 * Sortie évènementielle : néant
 *
 * Paramètres entiers :
 *     - ipar[0..nu-1] flag code complément à 2 en entrée
 *                         0 : nombre entier non signé
 *                         1 : nombre entier signé
 *     - ipar[nu..2*nu-1] flag code complément à 2 en sortie
 *                         0 : nombre entier non signé
 *                         1 : nombre entier signé
 *     - ipar[2*nu..3*nu-1] longueur des paquets du vecteur
 *                            d'entrée (nbit)
 *     - ipar[3*nu..4*nu-1] nombre de paquet à stocker (npack)
 *
 * Etats discrets :
 *      - z[0..nu-1] valeur paquet
 */

/*prototype*/
void binreg(scicos_block *block,int flag)
{
 double *y;
 double *u;
 int nu;

 double *z;

 int nev;

 int *cc2_in;
 int *cc2_out;
 int *nbit;
 int *npack;

 int i,j,k;

 u = (double *)block->inptr[0];
 y = (double *)block->outptr[0];

 nu = block->insz[0];

 z = &block->z[0];

 nev = block->nevprt;

 cc2_in  = &block->ipar[0];
 cc2_out = &block->ipar[nu];
 nbit    = &block->ipar[2*nu];
 npack   = &block->ipar[3*nu];

 /* compute output */
 /* Le flag 1 récupère le paquet à délivrer
  * et délivre sa valeur dans y[]
  * lorsque le port d'activation est 2 ou 3
  */
 if(flag==1 && (nev==2||nev==3)) {
  for(k=0;k<nu;k++) {
   i = (int)z[k];

   j = i & ((1<<nbit[k])-1);

   if (cc2_out[k]==1) {
    j -= 2<<(nbit[k]-2);
    j &= (2<<(nbit[k]-1)) - 1;
    j -= 2<<(nbit[k]-2);
   }

   y[k] = (double)j;

  }
 }

 /* compute discrete state */
 /* Le flag 2 stocke la valeur en entrée dans z[]
  * et la converti en nombre entier non signé lorsque
  * le numéro du port d'activation est 1 ou 3
  */
 else if(flag==2 && (nev==1||nev==3)) {
  for(k=0;k<nu;k++) {

   j = (int)u[k];

   if (cc2_in[k]==1) {
     j &= (2<<((nbit[k]*npack[k])-1)) - 1;
   }

   z[k] = (double)j;
  }
 }

 /* Le flag 2 décale le paquet de nbit vers
  * la droite lorsque le numéro du port
  * d'activation est 1 ou 3
  */
 else if((flag==2) && (nev==2)) {
  for(k=0;k<nu;k++) {
   i = (int)z[k];

   i = i>>nbit[k];

   z[k] = (double)i;
  }
 }
}