Un pas de plus vers l'automatisation

par Le Grincheux  

Pour automatiser la réductions des quines, le programme présenté il y a quelques articles est modifié pour générer automatiquement les diverses équations réduites directement du tableau des transitions. La procédure se fait grâce à un premier programme qui transforme le tableau des transitions en autant de fichiers qu'il y a de commandes de bascules :

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

/*
 * Format du fichier d'entrée :
 * abcdefghia'b'c'd'j3k3j2k2j1k1j0k0
 */

TRANSITIONS
<<
    { "length*(1)" }
    { { "name" "transitions.global" } "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 ->table
    >>

    14
    -> L I
    <<
        { "j3" "k3" "j2" "k2" "j1" "k1" "j0" "k0" }
        forall E
            { "length*(*)" }

            "name" "transitions." E +

            if
                dup "existence" inquire
            then
                { "sequential" "replace" "readwrite" "flow" }
            else
                { "sequential" "new" "readwrite" "flow" }
            end

            rot rot 2 ->list 1 ->list swap +
            open format

            -> FICHIER
            <<
                1 L size for K
                    L K 1 ->list get I dup sub
                    -> F
                    <<
                        if
                            F "0" same not
                        then
                            if
                                F "X" same
                            then
                                "*"
                            else
                                ""
                            end
                            L K 1 ->list get 1 9 sub + "\n" +
                                    1 ->list
                            FICHIER write
                        end
                    >>
                next

                FICHIER close
            >>
            'I' incr
        next
    >>
>>

Cette première étape est suivie par une seconde qui transforme l'écriture réduite des états en un fichier compréhensible par qmc-cli :

#!/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.
 */

PRINCIPAL
<<
    { "j0" "k0" "j1" "k1" "j2" "k2" "j3" "k3" }
    forall I
        I TRANSITIONS
    next
>>

TRANSITIONS
<<
    -> E
    <<
        { "length*(1)" }
        "name" "transitions." E + 2 ->list 1 ->list
        { "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

            { "length*(*)" }
            "name" E ".in" +

            if
                dup "existence" inquire
            then
                { "sequential" "replace" "flow" }
            else
                { "sequential" "new" "flow" }
            end

            rot rot 2 ->list 1 ->list swap +
            open format

            -> F_OUT
            <<
                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

                    ->str "\n" + 1 ->list F_OUT write
                next

                F_OUT close
            >>
        >>
    >>
>>

À la fin de la procédure, les huit fichiers j0.in, j1.in, j2.in, j3.in, k0.in, k1.in, k2.in et k3.in sont créés. Reste à les faire passer dans la moulinette qmc-cli pour obtenir la réduction des quines.

Après réduction, les équations deviennent :

j0=q3'q2'((q1 xor i) + iC255)+q3'q2(q1'i'+iPHT)+q3'i(PBT'+q1PHT)
k0=q2'P
BTC15(q1'iPHT'+q3'q1PHT)+q3'q2i'(q1+PHT)+q3q1'(q2'+q0PBT')
        +q3'q2i'PBT'
j1=q3'q2'q0'i'(PBT+PHT)+q3'q0i(PHT+C15)+q3'q2(i(PBT'+PHT')+q0PHT)
        +q3q2'q1'q0'(PHT+PBTC15)+q2q1'q0PBT'
k1=q3'q2'(q1'i'+q0PBTPHTC15)+q3'q2q0i'
j2=q3'q1'(q0'i'(PBT+PHT)+q0iPHT)+q3'q1(i(PBT'+qo'PHT)
        +q0(PBT'+C15))+q3q2'q1'q0'(PHT+PBTC15)+q3'q0iPBT'C15
k2=q3'q0(q1'(i+PBTPHT'C255)+q1i')
j3=q3'q0'i'(q1 xor q2)+q1'i'(q3'q2PBTPHT'C255+q2'q0)
k3=q2'q1'q0'(PHT+C15)+q2q1'q0(PBT'+C15)

Le schéma du circuit de contrôle des alimentations devient alors :

Fig. 1 : schéma de la machine à états (le même en grand)

J'ai pu tester ce circuit dans tous les sens. Il donne presque entièrement satisfaction. Tous les défauts sont bien détectés, les temporisations sont correctes pour les phases d'allumage et d'extinction. Ami lecteur, sauras-tu corriger ce circuit pour qu'il soit parfait ?

Et une erreur de plus, une !

par Le Grincheux  

Il y a toujours une erreur de plus. Confiant, j'avais simplifié les quines et câblé le circuit. Tout fonctionnait normalement jusqu'au test de réallumage de la haute tension depuis la procédure d'extinction. Là, le circuit que j'avais câblé se met en défaut car l'état 4 (haute tension avec test de la présence de la haute tension) suit l'état 5 (haute tension coupée, tension de chauffage présente).

Le fonctionnement est pourtant celui du graphe. En effet, il faut laisser à la haute tension le temps de s'établir avant que le circuit puisse tester sa présence. En cas de réallumage, l'état 3, et non le 4, doit suivre le 5. Voici doncle graphe modifié :

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

La nouvelle table de transition — et j'espère la dernière — est la suivante :

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 0 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 1 X 1 X 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 0 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 0 X 0 0 0 1 0 0 X 0 X X 0 0 X
0 0 1 0 1 X 1 X X 0 1 1 1 0 X 1 X X 0 1 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 0 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 0 1 1 0 X X 1 1 X X 0
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. 1 : transitions de l'automate

Ajout à l'automate d'une surveillance de la haute tension

par Le Grincheux  

Lors de la phase d'allumage, l'automate ne surveillait pas l'absence de haute tension (états 1 et 2). Ce nouvel automate vérifie ce point et indique une erreur en cas de présence de haute tension.

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

La nouvelle table de transition est la suivante :

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 0 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 1 X 1 X 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 0 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 0 X 0 0 0 1 0 0 X 0 X X 0 0 X
0 0 1 0 1 X 1 X X 0 1 1 1 0 X 1 X X 0 1 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 0 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

De la pratique du placebo chez l'idiophile, saison 3

par Le Grincheux  

Je viens de tomber sur des câbles amusants. Regardez bien de vos yeux ébahis :

Fig. 1 : câbles idiophiles

Nous avons donc un câble optique. C'est un fait. Mais ce câble est optimisé pour certains formats de transmission. Là, mon esprit de traiteur du signal chafouin lève un sourcil soupçonneux. Un medium de transmission est un un medium de transmission. N'importe quel support sera suffisant si sa bande passante est assez grande. En plus, ici, les signaux sont des signaux optiques donc numériques.

Le sublime est atteint par l'indication de connecteurs plaqués or à 24 ct.

Ami idiophile, toi qui ne me liras certainement jamais, tu devrais te moquer du connecteur plaqué or. Ton signal est ici optique et il vaudrait bien mieux avoir une fibre optique monomode, bien centrée et une section de la fibre parfaite. Mais rien n'est indiqué quant à ces paramètres pourtant largement plus importants que le placage du connecteur. Quoi qu'il en soit, tu pourras trouver ce genre de câble à vil prix sur Amazon :

Fig. 2 : la même chose en grand

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

1 2 4 ...6 ...7 8 9