Pour que cet amplificateur soit d'utilisation la plus large possible, il convient de lui adjoindre une selection des système de haut-parleurs. Sur un amplificateur à transistors, sortant sans transformateur,  cela ne pose aucune espèce de problème. En revanche, sur un amplificateur fonctionnant en haute impédance, il ne faut jamais commuter les systèmes de sortie en fonctionnement sous peine de destruction des transformateurs de sortie. En effet, le secondaire du transformateur ayant une impédance infinie, il se transforme en inductance quasiment pure et peut rapidement entrer dans une oscillation destructrice. J'ai mesuré il y a quelque temps les inductances de transformateurs EI de sortie au pont RLC et j'ai obtenu des valeurs de l'ordre de 100 à 150 H. Une paille !

J'aborderai plus loin une manière de protéger ces transformateurs de sortie contre ces suroscillations. Je m'attarderai ici uniquement à la gestion de la commutation de deux systèmes de haut-parleurs nommés A et B. Encore une fois, cette tâche sera dévolu à une machine à état entièrement définie. Un tel automate est robuste et efficace.

Les variables d'entrée sont dans l'ordre :

• présence haut-parleurs système B ;
• présence haut-parleurs système A ;
• interrupteur général ;
• sélection système B ;
• sélection système A ;
• présente basse tension ;
• présence haute tension.

Les sorties de la machine de Moore sont les suivantes :

• test de la présence des haut-parleurs ;
• arrêt de la haute tension ;
• commande du système B ;
• commande du système A.

La haute tension est bloquée par un transistor MOSFET dans le circuit de cathode des tubes de puissance le temps de la commutation des systèmes de haut-parleurs. Quant au test de présence des haut-parleurs, il consiste à envoyer un petit signal à quelques centaines de Hertz pour vérifier qu'il y a bien une impédance en bout de ligne.

Avec ces notations, la machine à état est la suivante :

Fig. 1 : machine à état

La mise en équations dans un prochain billet.

Le routage de la carte de gestion des alimentations n'a pas été simple mais il est achevé. Comme contrainte, je voulais une carte contenant la partie filtrage du secteur, alimentation isolée, régulation et la logique séquentielle. Je voulais aussi avoir des voyants indiquant l'état des différents registres.

Le circuit complet tient sur un PCB de quatre couches FR4 35µm pour toutes les couches de dimension 40cm par 18cm. J'aurais pu le faire plus petit en prenant des composants CMS, mais cela aurait nécessité l'intervention d'un câbleur professionnel, ce qui, pour de très petites séries, a un coût prohibitif.

Fig. 1 : vue d'ensemble

On voit mal de loin, alors voici une vue de plus près. Il y a du monde. Les pistes de signal font 0,254 mm (10 mils).

Fig. 2 : détail

Cette carte sera fabriquée par Safe-PCB. Je travaille de longue date avec eux, ils font un excellent travail sur des cartes huit couches avec des pistes de 5 mils. Cela ne devrait donc pas leur poser de problème.

Une dernière image pour la route, une vue 3D. Je n'ai pas tous les modèles de composants, certaines empreintes sont vides mais cela donne une bonne idée du résultat.

Fig. 3 : vue 3D de la carte de gestion des alimentations

Naturellement, les normes CE ont été respectées durant le routage. Le logo n'est pas usurpé.

Je vois que personne n'a vu l'erreur signalée dans le dernier article. Le problème était simple, il fallait réinitialiser le compteur lors de la transition extinction vers HT. En effet, l'état extinction impose la présence de la basse tension, mais la haute tension est coupée. Lorsque cette haute tension est rallumée, son temps de montée n'est pas nul. Il faut donc passer par l'état HT qui ne vérifie pas la présence de la haute tension avant de passer en défaut ou en maintien. Or la transition depuis extinction vers HT se fait avec un compteur dans un état indéfini alors que l'arrivée à l'état HT suppose un compteur nul.

Fig. 1 : la même chose en grand

Les quatre états au bas du schéma sont des états normalement inaccessibles. Ils ont été rajoutés pour que tous les états soient déterminés et que le système passe en protection en cas de présence d'un état indéterminé.

Les nouvelles sorties de la machine sont maintenant :

Tab. 1 : allumage de la basse tension

B=Q₃'(Q₂'(Q₀+Q₁)+Q₂Q₁')+Q₀(Q₁ xor Q₂)

Tab. 2 : allumage de la haute tension

H=Q₃'(Q₂Q₁'Q₀'+Q₂'Q₁Q₀)

Tab. 3 : blocage du compteur à zéro

R=Q₁(Q₂+Q₃)+Q₃'Q₁'Q₀'+Q₃(Q₂ xor Q₀)

Tab. 4 : indicateur d'erreur

E=Q₂Q₁+Q₃Q₀'(Q₂+Q₁)

Fig. 2 : circuit de sortie de la machine (en grand)

Tab. 5 : transitions de l'automate

La réduction des quines et le schéma de câblage suivront au prochain épisode. Après tout, nous sommes dimanche.

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'PBTC15(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 ?

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 :

Tab. 1 : transitions de l'automate