Portes primitives

Les portes primitives on la particularité d'utiliser du code en Scheme pour établir la relation entre les entrées et les sorties. A l'inverse, les portes assemblée sont construites en fabriquant un module reliant de manière interne des portes et des connexions.

La porte la plus simple que nous puissions définir réalise la fonction NON : si son entrée vaut 1, elle place sur sa sortie la valeur 0, et vice et versa.

Le constructeur de l'inverseur peut être définit par :

(define (porte:not agenda entrée sortie)
 ; procédure interne de calcul
 (define (action:not)
  (let ([valeur (connexion:lire entrée)])
    (agenda:retarder agenda
                     1
                     (lambda ()
                       (connexion:changer! 
                        sortie
                        (if (zero? valeur)
                            1
                            0))))))
 (connexion:brancher! entrée action:not))

C'est une procédure dont les paramètres sont un agenda, une connexion en entrée et une connexion en sortie.

On définit alors une fonction de calcul interne : Cette procédure lit la valeur sur la connexion en entrée, et place avec un retard unitaire, la valeur inverse sur la sortie, à l'aide d'une procédure lambda. Le constructeur associe alors cette fonction de calcul interne à la connexion en entrée.

Toute la dynamique du calcul sera activée par les connexions en entrée et en sortie, qui vont activer la procédure interne de calcul, ce qui a pour effet de modifier la valeur de la connexion en sortie.

La seconde porte primitive que nous définissons et la porte ET à deux entrées et une sortie :

(define (porte:and agenda entrée-1
                          entrée-2
                          sortie)
 (define (action:and)
  (let ([v-1 (connexion:lire entrée-1)]
        [v-2 (connexion:lire entrée-2)])
    (agenda:retarder agenda
                     2
                     (lambda ()
                      (connexion:changer! 
                       sortie
                       (if (or (zero? v-1)
                               (zero? v-2))
                           0
                           1))))))
 (connexion:brancher! entrée-1 action:and)
 (connexion:brancher! entrée-2 action:and))

Ce constructeur à la même structure que le constructeur du NON mis à part le fait qu'il doive prendre en compte les deux entrées.

La porte est identique à la porte ET mis à part que le test est :

(define (porte:or agenda entrée-1
                         entrée-2
                         sortie)
 (define (action:or)
  (let ...
                       (if (and (zero? v-1)
                                (zero? v-2))
                           0
                           1))))))
  ...
 (connexion:brancher! entrée-1 action:or)
 (connexion:brancher! entrée-2 action:or))

La dernière porte primitive définie est la sonde. Branchée à une connexion, elle permet d'afficher les différentes valeurs circulant sur cette connexion :

(define (porte:sonde agenda nom connexion)
 (define (action:sonde)
  (display (agenda:aujourd-hui agenda))
  (display #\space)
  (display nom)
  (display ": ")
  (display (connexion:lire connexion))
  (newline))
 (connexion:brancher! connexion
                      action:sonde))

Le constructeur a comme paramètres un agenda, un nom qui servira à identifier la sonde et une connexion. De la même manière que pour les autres portes primitives, on associe une procédure à la connexion donnée en argument.