Le programme d'aquisition

      C'est lui qui gère l'acquisition des pixels et notamment la génération correcte des horloges. Nous avons créé deux applications : Un programme sous DOS qui permet un affichage rapide en assembleur car on peut écrire directement dans la RAM vidéo ce qui nous permet de descendre à 3 images par seconde et un autre sous Windows, plus convivial, mais qui ne permet pas de descendre en dessous d' une image par seconde à cause de l'affichage sous Windows.


      Programmation DOS

Ce programme est réalisé en turbo pascal et en partie en assembleur afin d'optimiser au maximum les performances d'acquisition. Malgré tout cela nous n'avons réussi qu'à descendre à 3 images par seconde. Cela est principalement du à la durée de lecture et d'écriture sur un port qui prendre un temps machine assez important (de l'ordre de 2 microsecondes), cela est principalement du à la vitesse du bus ISA. En sachant qu'il faut 145x4+145x218x7 opérations d'E/S par image on a alors un temps de 444ms environ auquel il faut rajouter les opérations de calcul et de déplacement des registres.

Voici le source du programme :

program dakasition_en_assembler;
uses dos,crt,biblio;

type
DACREG = record
      Rouge, Vert, Bleu : BYTE ;
      end;
DACARRAY = array [0..255] of DACREG;

var i,j:integer; {Compteurs de boucle}
      reg:registers; {Registres pour mode vidéo}
      ref: byte; {Valeur du signal de référence}
      c:byte; {Valeur du signal vidéo}
      b:word;
      y:integer; {Boucle de ligne}
      k,x:integer;
      dacbuf:dacarray; {Palette}
      val:byte;

{Génération du la palette graphique en 255 niveaux de gris}
procedure palette(a:integer);
var b:byte;
      code:integer;
begin
      For i:=0 to 255 do
       begin
            Dacbuf[i].bleu:=i;
            Dacbuf[i].vert:=i;
            Dacbuf[i].rouge:=i;
       end;
end;

{Initialisation du mode graphique}
procedure Initialise(buf:Dacarray);
var regs:registers;
begin
      Regs.AX := $1012;
      Regs.BX := 0;
      Regs.CX := 255;
      Regs.ES := seg( Buf );
      Regs.DX := ofs( Buf );
      intr( $10, Regs );
end;

Begin
{Changement du mode vidéo}
ASM {256}
      mov AL,$13
      mov AH,$00
      int $10 END;
      palette(0); {Initialisation de la palette en 255 niveaux de gris}
      initialise(dacbuf); {Initilisation du mode graphique}

{Initialisation de la carte E/S}
asm
      mov ax,0
      mov dx,$301
      out dx,ax end;

{Boucle principal d'aquisition}
repeat
asm
      mov y,145 {La variable y correspond à une ligne}
      @labelo: {Boucle de lecture rapide de la matrice avant aquisition}
      mov ax,10
      mov dx,$301
      out dx,ax {Génération des phases ÆP et ÆM}
      mov ax,0
      mov dx,$301
      out dx,ax {Mise à zéro des phases ÆP et ÆM}
      dec y; jnz
      @labelo
      mov y,145
      @labely: {Boucle d'aquisition pour chaque ligne}
      mov ax,2
      mov dx,$301
      out dx,ax {Génération de ÆM}
      mov ax,0
      mov dx,$301
      out dx,ax {Mise à zéro de ÆM}
      mov cx,218
      @labelx: {Boucle d'aquisition pour chaque pixel}
      mov ax,16
      mov dx,$301
      out dx,ax {Génération de Start Convert}
      mov ax,0
      mov dx,$301
      out dx,ax {Mise à zéro de Start Convert}
      mov dx,$305
      in al,dx; {Lecture des données du CAN pour signal de référence}
      mov ref,al
      mov ax,16
      mov dx,$301
      out dx,ax {Mise a l'état haut de Start Convert}
      mov ax,20
      mov dx,$301
      out dx,ax {Génération de ÆL}
      mov ax,4
      mov dx,$301
      out dx,ax {Mise à zéro de Start Convert}
      mov dx,$305
      in al,dx {Lecture des données du CAN pour signal vidéo}
      mov bl,ref
      sub al,bl {Calcul de la valeur du pixel (signal vidéo-référence)}
      mov c,al
      shr c,2 {Division par 4 de la valeur car affichage en 64 niveaux}
      mov ax,$a000 {Adresse de la mémoire vidéo}
      mov es,ax
      mov ax,y
      mov dx,320 {Décalage d'une ligne}
      mul dx
      add ax,cx {Décalage d'une colonne}
      mov di,ax
      mov ah,c
      mov [es:di],ah {Ecriture du pixel dans la mémoire vidéo}
      loop
      @labelx
      dec y
      jnz @labely
      end;
until keypressed; {Retour au mode vidéo initial}

asm
      mov ax,$03
      int 10h
end;

End.

Ce programme nous affiche l'image à l'écran comme celle-ci :

Image de Matthieu prise avec la caméra

      Programmation Windows

      Le programme sous Windows à été réalisé sous DELPHI. Le programme sous Windows est plus convivial. De plus, nous avons ajouter un certain nombre d'éléments permettant notamment le filtrage des images en temps réel. Nous avons donc ajouter le calcul de l'histogramme qui permet un centrage dynamique de l'image, c'est à dire le calcul du temps d'intégration adéquat. Dans ce principe de centrage dynamique de l'histogramme, on agit sur le temps d'intégration de la matrice en continue afin que le maximum de pixels soient autour de la valeur 127 (car nous avons un CAN 8 bits), ainsi si nous avons un temps de pose trop faible l'histogramme sera décalé vers 0 et si nous sommes en surexposition ou en limite de saturation l'histogramme tendra vers 255.
Le but étant de réagir au plus vite lors que l'on bouge la caméra, pour cela on augmente (ou diminue) le temps d'intégration proportionnellement au décalage de l'histogramme par rapport à 127. Les résultats sont assez surprenants.

De plus, les filtres classiques ont été implémentés comme le filtre passe-bas, passe-haut, Laplacien et les filtres d'érosion et de dilatation. Ceci agissent en temps réel et peuvent avoir des application dans une chaîne de industrielle à titre de vérification de pièces.

Interface du logiciel d'acquisition sous Windows

      Le programme permet aussi de choisir le temps de pose manuellement, de gérer la durée des signaux d'horloges et enregistrer les images sous le format BMP. Une autre partie du programme permet de tester le bon fonctionnement de la carte Entrées/Sorties.
Ainsi, le programme nous signale lorsque celle-ci n'est pas branchée correctement ou n'est pas branché. Pour réaliser ce contrôle, nous utilisons le port 302h en lecture que nous avons configuré à 127 par des jumpers, ainsi le programme teste s'il y a 127 sur ce port, dans le cas contraire, s'il trouve 0 c'est que la carte n'est pas alimentée et s'il trouve 255 c'est que la carte n'est pas reliée à l'ordinateur.

1. Mettre la carte décodage dans le PC.
2. Connecter le câble de 15cm (SUB-D15) du boîtier d'horloge vers la tête de la camera
3. Brancher le boîtier d'alimentation et vérifier que celui-ci est bien éteint avant toute connexion
4. Connecter le câble (SUB-D25 mâle/femelle) du boîtier horloge au boîtier d'alimentation
5. Connecter le câble (SUB-D25 mâle/mâle câble FX) de la carte décodages d'adresse (dans le PC) au boîtier d'alimentation.
6. Attention : il faut toujours allumer l'interrupteur de la carte d'alimentation (Interrupteur de gauche) avant d'allumer celui de la carte E/S (interrupteur de droite)
7. Mettre sous tension le boîtier d'alimentation (interrupteur de gauche), une LED verte doit alors s'allumer
8. Mettre sous tension la carte E/S (interrupteur de droite) l'autre LED verte s'allume
9. Lancer le programme d'acquisition
10. Si le programme indique que la carte PIO ne fonctionne pas correctement, il faut vérifier la connexion de la carte de décodage d'adresse. Pour cela il faut mettre hors tension la carte E/S et relancer le programme. Si le programme indique que la carte PIO n'est pas branchée cela veut dire que la carte décodage d'adresse fonctionne.
11. Retirer le cache de la caméra
12. Cliquer sur l'interrupteur pour lancer l'acquisition
13. Attention le programme fonctionne uniquement sous Windows 98
14. Eteindre d'abord la carte E/S avant la carte alimentation au risque de griller une bascule 3 états