BTS IRIS 2011 à 2014, corrigé.

#include

#include  "header.h"

using namespace std;

error_code        outc(u_char*, int)

{

    return 0 ;

}

error_code        inc(u_char*)

{

    return 0 ;

}

error_code  _os_sleep(int* ticks, int*)

{

    return usleep(*ticks * 10000) ;

}

union acl8112{

typedef struct

    {

        u_int8 counter_8254[3],

        vide1,

        adf,

        adF,

        dif,

        diF,

        vide2[8] ;

    } lecture ;

typedef struct

    {

        u_int8 counter_8254[3], //counter 0, 1 et 2; Base 0,1 et 2

        controle_8254, //8254 Counter control; Base 3

        da0f, //CH1 D/A low byte; Base 4

        da0F, //CH1 D/A hight byte; Base 5

        da1f , //CH2 D/A low byte; Base 6

        da1F, //CH2 D/A hight byte; Base 7

        cir, //Clear Interrupt Request; Base 8

        gain, //A/D Range Control; Base 9

        mux, //Channel MUX; Base 10

        controle, //Mode Control; Base 11

        trigger, //Software A/D trigger; Base 12

        dof, //DO low byte; Base 13

        doF, //DO hight byte; Base 14

        vide ; //Not Used; Base 15

    } ecriture ;

};

/*typedef struct

    {

        u_int8 timer[4],

        ad_da0f,

        ad_da0F,

        di_da1f,

        di_da1F,

        cir,

        gain,

        mux,

        controle,

        trigger,

        dof,

        doF,

        vide ;

    } ;

*/

u_int32 initAcl8112(union acl8112 * carte){

/*La fonction vérifie si l’adresse de la carte est valide (intervalle 0x200/0x3F0 modulo 0x10) ; dans le cas

contraire elle rend une erreur (valeur 1000).

Pour initialiser la carte en mode software trigger, il faut écrire la valeur 1 (S2=0, S1=0, S0=1) dans le

registre en base + 11 (ecriture.controle).

La fonction rend la valeur 0 (pas d’erreur).*/

int ajout;

int comparer;

for (ajout=0x200; ajout<0x3F0; ajout+=0x10){

    if(carte==ajout){

        comparer+=1;

    }

}

if(comparer !=1){

    return 1000;

}

carte->ecriture.controle=1;

return 0;

}

u_int32 litAcl8112(union acl8112 * carte, u_int8 numCanal, u_int16 * valeur){

/*La fonction vérifie si l’adresse de la carte est valide et si le numéro de canal est valide (intervalle 0-15);

dans le cas contraire elle rend une erreur (valeur 1000 si adresse invalide, valeur 1001 si numéro de canal

invalide).

Pour lire une entrée, il faut sélectionner le canal à lire, déclencher la conversion, attendre la fin de

conversion et enfin lire la valeur convertie.

Pour sélectionner le canal à lire, il faut écrire le numéro (de 0 à 15) dans le registre en base + 10

(ecriture.mux).

Pour déclencher la conversion il suffit d’écrire n’importe quelle valeur dans le registre en base + 12

(ecriture.trigger).

Pour attendre la fin de la conversion, il faut lire le registre en base + 5 (lecture.adF) et tester le bit N°4

(DRDY) – on effectue un ET bit à bit avec la valeur 0x10. Si le résultat est différent de zéro, la conversion

n’est pas terminée (il faut donc recommencer à lire le registre et à tester le bit). Si le résultat est égal à

zéro, la conversion est terminée (on peut alors quitter la boucle de test). Si la boucle d’attente s’est

exécutée 0xffff fois, on arrête l’attente et un « temps dépassé (timeout) » sera signalé.

Pour lire le résultat il faut réaliser un mot de 16 bits constitué par les deux octets de la valeur convertie.

Pour cela, il faut lire l’octet de poids fort (registre en base + 5 (lecture.adF)) (avec un masque à 0x0f

car seuls les 4 bits de poids faibles sont utilisés), effectuer un décalage à gauche de 8 bits et faire un OU

bit à bit avec l’octet de poids faible (registre en base + 4 (lecture.adf)). Ensuite, il faut écrire à

l’adresse passée à la fonction (*valeur) la valeur du mot de 16 bits créé.

Si le temps a été dépassé, la fonction rend une erreur (valeur 1003).

La fonction vérifie que la valeur est valide (intervalle 0-4095) ; dans le cas contraire elle rend une erreur

(valeur 1002).

La fonction rend la valeur 0 (pas d’erreur).*/

int ajout;

int comparer=0;

int test;

for (ajout=0x200; ajout<0x3F0; ajout+=0x10){

    if(carte==ajout){

        comparer+=1;

    }

}

if(comparer !=1){

    return 1000;

}

if(numCanal<0||numCanal>15){

    return 1001;

}

carte->ecriture.mux=numCanal;

carte->ecriture.trigger=1;

test=carte->lecture.adF;

}

u_int32 ecrAcl8112(union acl8112 * carte, u_int8 numCanal, u_int16 valeur){

/*La fonction vérifie si l’adresse de la carte est valide, si le numéro de canal est valide (1 ou 2) et si la valeur

à écrire est dans le bon intervalle (0-4095); dans le cas contraire elle rend une erreur (valeur 1000 si

adresse invalide, valeur 1001 si numéro de canal invalide, valeur 1002 si valeur à écrire invalide).

Pour écrire dans une sortie, il faut soit écrire une valeur dans les registres en base + 4 (ecriture.da0f)

et base + 5 (ecriture.da0F) pour le canal numéro 1 soit dans les registres en base + 6

(ecriture.da1f) et base + 7 (ecriture.da1F) pour le canal numéro 2. En raison du « double

buffered », il faut tout d’abord écrire les poids faibles puis les poids forts.

Pour écrire la valeur il faut réaliser deux octets à partir d’un mot de 16 bits. Pour cela, il faut prendre le

mot de 16 bits (valeur) et le ranger dans le registre de poids faibles (le C prend automatiquement les 8

bits de poids faibles du mot de 16 bits) - registre en base + 4 (ecriture.da0f) ou registre en base + 6

(ecriture.da1f). Ensuite, il faut prendre le mot de 16 bits (valeur), effectuer un décalage à droite de 8

bits (les 8 bits de poids forts se trouvent ainsi dans les poids faibles) et ranger la valeur dans le registre de

poids forts (le C prend automatiquement les 8 bits de poids faibles du mot de 16 bits) - registre en base +

5 (ecriture.da0F) ou registre en base + 7 (ecriture.da1F).

La fonction rend la valeur 0 (pas d’erreur).

*/

}