Automate, suite

par Le Grincheux  

Comme il faut toujours remettre son ouvrage sur le travail, voici la dernière version de l'automate à états finis gérant l'alimentation.

Fig. 1 : dernière version de l'automate (la même chose en grand)

J'espère cette fois-ci n'avoir rien oublié. Ce nouvel automate comporte onze états, donc nécessite quatre bascules au lieu de trois. Il faut donc réétudier les sorties du circuit à l'aide de nouveaux tableaux de Karnaugh.

 B Q1Q0
Q3Q2 00 01 11 10
00 0 1 1 1
01 1 1 0 0
11 X 1 X X
10 0 0 X X

Tab. 1 : allumage de la basse tension

B=Q1'Q2+Q0Q2'Q3'+Q1Q2'

 H Q1Q0
Q3Q2 00 01 11 10
00 0 0 1 0
01 1 0 0 0
11 X 0 X X
10 0 0 X X

Tab. 2 : allumage de la haute tension

H=Q2Q1'Q0'+Q2'Q1Q0

 R Q1Q0
Q3Q2 00 01 11 10
00 1 0 0 0
01 1 0 1 1
11 X 0 X X
10 0 1 X X

Tab. 3 : blocage du compteur à zéro

R=Q3'Q1'Q0'+Q3Q2'Q0+Q2Q1

 E Q1Q0
Q3Q2 00 01 11 10
00 0 0 0 0
01 0 0 1 1
11 X 0 X X
10 0 0 X X

Tab. 4 : indicateur d'erreur

E=Q2Q1

Le schéma des quatre sorties devient alors :

Fig. 1 : câblage des sorties (la même chose en grand)

Reste à écrire la table des transitions et à simplifier les quines.

Entrées

États futurs et
sorties pour les atteindre

Q3 Q2  Q1 Q0 I PBT PHT C15 C255 Q3 Q2 Q1 Q0 J3 K3 J2 K2 J1 K1 J0 K0
0 0 0 0 0 0 0 X X 0 0 0 0 0 X 0 X 0 X 0 X
0 0 0 0 1 X X X X 0 0 0 1 0 X 0 X 0 X 1 X
0 0 0 0 0 1 0 X X 0 1 1 0 0 X 1 X 1 X 0 X
0 0 0 0 0 0 1 X X 0 1 1 0 0 X 1 X 1 X 0 X
0 0 0 0 0 1 1 X X 0 1 1 0 0 X 1 X 1 X 0 X
0 0 0 1 1 X X 0 X 0 0 0 1 0 X 0 X 0 X X 0
0 0 0 1 1 0 X 1 X 0 1 1 1 0 X 1 X 1 X X 0
0 0 0 1 0 X X X X 1 0 0 1 1 X 0 X 0 X X 0
0 0 0 1 1 1 X 1 X 0 0 1 0 0 X 0 X 1 X X 1
0 0 1 0 0 X X X X 1 0 0 1 1 X 0 X X 1 1 X
0 0 1 0 1 1 X X 0 0 0 1 0 0 X 0 X X 0 0 X
0 0 1 0 1 0 X X X 0 1 1 1 0 X 1 X X 0 1 X
0 0 1 0 1 1 X X 1 0 0 1 1 0 X 0 X X 0 1 X
0 0 1 1 X 1 X 0 X 0 0 1 1 0 X 0 X X 0 X 0
0 0 1 1 X 1 1 1 X 0 1 0 0 0 X 1 X X 1 X 1
0 0 1 1 X 0 X X X 0 1 1 1 0 X 1 X X 0 X 0
0 0 1 1 X 1 0 1 X 0 1 1 1 0 X 1 X X 0 X 0
0 1 0 0 1 1 1 X X 0 1 0 0 0 X X 0 0 X 0 X
0 1 0 0 1 1 0 X X 0 1 1 1 0 X X 0 1 X 1  X
0 1 0 0 1 0 1 X X 0 1 1 1 0 X X 0 1 X 1 X
0 1 0 0 1 0 0 X X 0 1 1 1 0 X X 0 1 X 1 X
0 1 0 0 0 X X X X 1 1 0 1 1 X X 0 0 X 1 X
1 1 0 1 X 1 X 0 X 1 1 0 1 X 0 X 0 0 X X 0
1 1 0 1 X 1 X 1 X 0 1 0 1 X 1 X 0 0 X X 0
1 1 0 1 X 0 X X X 0 1 1 0 X 1 X 0 1 X X 1
0 1 0 1 1 X X X X 0 1 0 0 0 X X 0 0 X X 1
0 1 0 1 0 1 0 X 0 0 1 0 1 0 X X 0 0 X X 0
0 1 0 1 0 0 X X X 0 1 1 0 0 X X 0 1 X X 1
0 1 0 1 0 1 1 X X 0 1 1 0 0 X X 0 1 X X 1
0 1 0 1 0 1 0 X 1 1 0 0 1 1 X X 1 0 X X 0
1 0 0 1 X X X X X 1 0 0 0 X 0 0 X 0 X X 1
1 0 0 0 X X 0 0 X 1 0 0 0 X 0 0 X 0 X 0 X
1 0 0 0 X 1 0 1 X 0 1 1 0 X 1 1 X 1 X 0 X
1 0 0 0 X 1 1 X X 0 1 1 0 X 1 1 X 1 X 0 X
1 0 0 0 X 0 1 X X 0 1 1 0 X 1 1 X 1 X 0 X
1 0 0 0 X 0 0 1 X 0 0 0 0 X 1 0 X 0 X 0 X
0 1 1 0 0 X X X X 0 1 1 0 0 X X 0 X 0 0 X
0 1 1 0 1 X X X X 0 1 1 1 0 X X 0 X 0 1 X
0 1 1 1 0 X X X X 0 0 0 0 0 X X 1 X 1 X 1
0 1 1 1 1 X X X X 0 1 1 1 0 X X 0 X 0 X 0

Tab. 2 : transitions de l'automate

Vers une automatisation du calcul des quines

par Le Grincheux  

L'automate doit comporter une bascule de plus. De huit variables, les tables de vérités passent à neuf, soit cinq cent douze états pour huit variables de sorties. Cela commence à faire beaucoup lorsqu'on le fait à la main. J'ai trouvé un outil en mode texte pour réduire les quines : qmc (en version 0.6.3). Il ne reste plus qu'à générer automatiquement un fichier d'entrée pour cet outil directement depuis les tables de transitions.

#!/usr/local/bin/rpl -csp

/*
 * Format du fichier d'entrée :
 * 010X00X
 * *1111111
 * *X000X01
 *
 * Le X correspond à une valeur indifférente. Les entiers binaires
 * spécifiés doivent donner une combinaison vraie. Les lignes
 * commençant par une étoile indiquent un résultat indifférent.
 */

TRANSITIONS
<<
    { "length*(1)" }
    { { "name" "transitions.in" } "sequential" "old"
            "readonly" "flow" }
    open format

    0
    -> F_IN NB_LIGNES
    <<
        while
            F_IN "end of file" inquire not
        repeat
            ""
            do
                F_IN read 1 get
            until
                if
                    dup "\n" same
                    F_IN "end of file" inquire or
                then
                    drop true
                else
                    +
                    false
                end
            end

            if
                dup "" same not
            then
                'NB_LIGNES' incr
            else
                drop
            end

        end

        F_IN close
        NB_LIGNES ->list
    >>

    1
    -> LISTE I
    <<
        do
            LISTE I get ucase
            -> E
            <<
                if
                    E "X" pos dup
                then
                    // Il y a au moins un X
                    -> P
                    <<
                        { "0" "1" } forall J
                            if
                                P 1 same
                            then
                                J E 2 over size sub +
                            elseif
                                P E size same
                            then
                                E 1 over size 1 - sub J +
                            else
                                E 1 P decr sub J +
                                E P incr E size sub +
                            end
                        next

                        LISTE swap I swap put swap
                        1 ->list + 'LISTE' sto
                    >>
                else
                    // Pas de X, on passe au suivant
                    drop
                    'I' incr
                end
            >>
        until
            LISTE size I same
        end

        LISTE l->t << < >> sort
    >>

    forall I
        if
            I "*" pos
        then
            "x" "# " I 2 over size sub + "b" + str-> b->r ->str +
        else
            "# " I + "b" + str-> b->r ->str
        end

        disp
    next
>>

Je concède que c'est un peu sauvage, mais cela fonctionne parfaitement pour mon usage. Cet outil prend le fichier transitions.in et écrit sur la sortie standard un fichier correspondant et attendu par qmc. Le langage RPL/2 est toujours disponible au même endroit.

Simplification des quines

par Le Grincheux  

N'ayant pas encore d'hypercube à ma disposition pour écrire des tableaux de Karnaugh à plus de six variables, il convient d'utiliser les techniques de réduction de Mc Cluskey. Je vous fais grâce des calculs. Pour des raisons de simplicité d'écriture, les apostrophes notent une condition inversée. En voici les résultats :

J2=Q1'Q0'I'PHT+Q1'Q0'I'PBT+Q0IPBT'C15+Q1IPBT'+Q1Q0PBT'+Q1Q0C15

K2=Q0I'PBTPHT'C255+Q1Q0I'

J1=Q2'Q0'I'PHT+Q2'Q0'I'PBT+Q2'Q0IC15+Q2Q0'IPBT'+Q2Q0'IPHT'
        +Q2Q0I'PBT'+Q2Q0I'PHT

K1=Q2'Q0'I'+Q2'Q0PBTPHTC15+Q2Q0I'

J0=Q2'Q1'I+IPBT'+Q2Q1'I'+Q2Q1I+Q1'IPHT'+Q2'IC255

K0=Q2'Q1'I'+Q2'PBTPHTC15+Q2Q1'I+Q2Q1I'+Q1'I'PBT'+Q1'I'C255
        +Q1'I'PHT+Q2'Q1'PBTC15

Comme la vitesse n'est pas critique, il est possible de factoriser quelque peu certaines expressions.

J2=Q1'Q0'I'(PHT+PBT)+PBT'I(Q0C15+Q1)+Q1Q0(PBT'+C15)

K2=Q0I'(PBTPHT'C255+Q1)

J1=Q2'Q0'I'(PBT+PHT)+Q2Q0'I(PBT'+PHT')+Q2Q0I'(PHT+PBT')+Q2'Q0IC15

J0=Q1'(Q2'I+Q2I')+(IPBT')+Q2Q1I+Q1'IPHT'+Q2'IC255

K0=Q2'Q1'(I'+PBTC15)+Q2'PBTPHTC15+Q1'I'(PBT'+C255+PHT)+Q2(Q1'I+Q1I')

J'ai refait deux fois tous les calculs, je pense ne pas m'être trompé. Or une simulation du circuit ne fonctionne pas comme attendue. S'il commande aux différentes tensions jusqu'à l'allumage complet, basse et haute tensions, il indique une erreur lors de l'extinction. J'ai eu un peu de mal à comprendre mon erreur puisqu'elle ne résidait pas dans la réduction des quines mais dans une hypothèse hasardeuse. Bêtement, j'avais considéré que les basse et haute tensions avaient un temps de descente nul !

Il est donc nécessaire de rajouter une temporisation lors de l'extinction des différentes tensions avant de tester les absences de ces tensions.

Derniers raffinements de l'automate

par Le Grincheux  

Il manque à l'automate un dernier raffinement consistant en une transition allant de l'état 000 (repos) vers l'état 110 (défaut appareil éteint). En effet, si une tension de chauffage ou une haute tension apparaît dans le circuit commandé, l'alimentation est en panne et il convient de le signaler. Le nouveau diagramme des états devient alors :

 

Fig. 1 : nouveau diagramme d'états (le même en grand)

Cette nouvelle transition ne change rien aux équations des sorties décrites plus tôt. En revanche, la table des transitions devient :

Entrées Sorties
Q2 Q1 Q0 I PBT PHT C15 C255 Q'2 Q'1 Q'0 J2 K2 J1 K1 J0 K0
0 0 0 0 0 0 X X 0 0 0 0 X 0 X 0 X
0 0 0 0 0 1 X X 1 1 0 1 X 1 X 0 X
0 0 0 0 1 0 X X 1 1 0 1 X 1 X 0 X
0 0 0 0 1 1 X X 1 1 0 1 X 1 X 0 X
0 0 0 1 X X X X 0 0 1 0 X 0 X 1 X
0 0 1 0 X X X X 0 0 0 0 X 0 X X 1
0 0 1 1 X X 0 X 0 0 1 0 X 0 X X 0
0 0 1 1 0 X 1 X 1 1 1 1 X 1 X X 0
0 0 1 1 1 X 1 X 0 1 0 0 X 1 X X 1
0 1 0 0 X X X X 0 0 0 0 X X 1 0 X
0 1 0 1 0 X X X 1 1 1 1 X X 0 1 X
0 1 0 1 1 X X 0 0 1 0 0 X X 0 0 X
0 1 0 1 1 X X 1 0 1 1 0 X X 0 1 X
0 1 1 X 0 X X X 1 1 1 1 X X 0 X 0
0 1 1 X 1 0 1 X 1 1 1 1 X X 0 X 0
0 1 1 X 1 X 0 X 0 1 1 0 X X 0 X 0
0 1 1 X 1 1 1 X 1 0 0 1 X X 1 X 1
1 0 0 1 1 0 X X 1 1 1 X 0 1 X 1 X
1 0 0 1 0 1 X X 1 1 1 X 0 1 X 1 X
1 0 0 1 0 0 X X 1 1 1 X 0 1 X 1 X
1 0 0 1 1 1 X X 1 0 0 X 0 0 X 0 X
1 0 0 0 X X X X 1 0 1 X 0 0 X 1 X
1 0 1 1 X X X X 1 0 0 X 0 0 X X 1
1 0 1 0 1 0 X 1 0 0 0 X 1 0 X X 1
1 0 1 0 1 0 X 0 1 0 1 X 0 0 X X 0
1 0 1 0 0 X X X 1 1 0 X 0 1 X X 1
1 0 1 0 1 1 X X 1 1 0 X 0 1 X X 1
1 1 0 0 X X X X 1 1 0 X 0 X 0 0 X
1 1 0 1 X X X X 1 1 1 X 0 X 0 1 X
1 1 1 1 X X X X 1 1 1 X 0 X 0 X 0
1 1 1 0 X X X X 0 0 0 X 1 X 1 X 1

Tab. 1 : nouvelle table des transitions

Nouvelles transitions

par Le Grincheux  

En gardant les mêmes notations qu'à l'article transitions, la nouvelle table de vérité est la suivante :

Entrées Sorties
Q2 Q1 Q0 I PBT PHT C15 C255 Q'2 Q'1 Q'0 J2 K2 J1 K1 J0 K0
0 0 0 0 X X X X 0 0 0 0 X 0 X 0 X
0 0 0 1 X X X X 0 0 1 0 X 0 X 1 X
0 0 1 0 X X X X  0 0 0 0 X 0 X X 1
0 0 1 1 X X 0 X 0 0 1 0 X 0 X X 0
0 0 1 1 0 X 1 X 1 1 1 1 X 1 X X 0
0 0 1 1 1 X 1 X 0 1 0 0 X 1 X X 1
0 1 0 0 X X X X  0 0 0 0 X X 1 0 X
0 1 0 1 0 X X X 1 1 1 1 X X 0 1 X
0 1 0 1 1 X X 0 0 1 0 0 X X 0 0 X
0 1 0 1 1 X X 1 0 1 1 0 X X 0 1 X
0 1 1 X 0 X X X 1 1 1 1 X X 0 X 0
0 1 1 X 1 0 1 X 1 1 1 1 X X 0 X 0
0 1 1 X 1 X 0 X 0 1 1 0 X X 0 X 0
0 1 1 X 1 1 1 X 1 0 0 1 X X 1 X 1
1 0 0 1 1 0 X X 1 1 1 X 0 1 X 1 X
1 0 0 1 0 1 X X 1 1 1 X 0 1 X 1 X
1 0 0 1 0 0 X X 1 1 1 X 0 1 X 1 X
1 0 0 1 1 1 X X 1 0 0 X 0 0 X 0 X
1 0 0 0 X X X X 1 0 1 X 0 0 X 1 X
1 0 1 1 X X X X 1 0 0 X 0 0 X X 1
1 0 1 0 1 0 X 1 0 0 0 X 1 0 X X 1
1 0 1 0 1 0 X 0 1 0 1 X 0 0 X X 0
1 0 1 0 0 X X X 1 1 0 X 0 1 X X 1
1 0 1 0 1 1 X X 1 1 0 X 0 1 X X 1
1 1 0 0 X X X X 1 1 0 X 0 X 0 0 X
1 1 0 1 X X X X 1 1 1 X 0 X 0 1 X
1 1 1 1 X X X X 1 1 1 X 0 X 0 X 0
1 1 1 0 X X X X 0 0 0 X 1 X 1 X 1

Tab. 1 : table de vérité du nouvel automate

Contrairement à la première table de vérité, les entrées J et K des bascules utilisent maintenant des états indifférents notés « X » qui devraient simplifier d'autant la synthèse du circuit logique.

1 2 ...3 ... 5 ...7 ...8 9