Retrouvez cet article dans : Linux Magazine 97

Voici un exemple de mise en pratique de deux précédents articles du hors-série numéro 23 consacré à l’électronique : une carte à relais commandée par le port parallèle du PC. La réalisation sera assistée par ordinateur grâce à l’utilisation du logiciel Kicad.

En domotique, le but est d’automatiser le plus possible la gestion des différents appareillages électriques de la maison. Très souvent, il faut programmer la mise sous et hors tension de ces appareillages et, comme l’organe de commande est, en général, un ordinateur, il faut faire en sorte que celui-ci puisse passer ses ordres à « l’extérieur ».
L’une des méthodes courantes permettant d’accomplir cette tâche est la commande de relais à l’aide du port parallèle d’un PC. Il est alors possible d’obtenir facilement 8 canaux de pilotage (un par ligne de données). Il existe des techniques (démultiplexeurs, microcontrôleurs...) permettant d’augmenter le nombre de relais, mais la mise en œuvre de ces techniques est peut-être un peu compliquée pour un début.
Dans cet article, je vais détailler beaucoup de choses, le but étant que même les ultra newbies du hardware puissent suivre toute la démarche.
Pour concevoir la carte, nous allons utiliser le logiciel Kicad [1]. Ce logiciel a été créé par Jean-Pierre Charras, enseignant-chercheur à Saint-Martin-d’Hères (université de Grenoble). L’interface utilise la bibliothèque wxwidgets.
Au cours du tutoriel, les boutons de l’interface qui vont nous servir sont cerclés de rouge et numérotés pour vous aider à les retrouver. La numérotation est globale et suit l’ordre d’intervention des différents outils et commandes.
Les fichiers concernant le tutoriel Kicad sont librement téléchargeables à l’adresse http://www.arvernux.fr/ressouces/relais8_hardware.tar.bz2 et les fichiers concernant l’interface logicielle à l’adresse http://www.arvernux.fr/ressources/relais8_software.tar.bz2 .

1. Cahier des charges

Quels impératifs techniques pour notre carte ?

• Protection de l’ordinateur : le circuit logique de l’ordinateur doit être isolé électriquement de la partie haute tension. Cette isolation sera réalisée par des opto-coupleurs pour séparer la logique de commande et l’utilisation d’une source continue autonome pour alimenter les relais.
• Coupure de circuits alimentés par le réseau 230 VAC / 50 Hz : Il faut choisir les relais à utiliser. Je vous recommande la relecture de l’article « Pilotez des relais depuis Linux » du hors-série numéro 23 [2]. En utilisant des relais de type 1RT (inverseur), on garde la possibilité de commander des circuits montés en « va-et-vient » ou bien 2 appareils en fonctionnement dual. Personnellement, j’ai choisi des relais de la série 40, très commun donc très faciles à trouver. Pour la bobine, j’ai choisi 12 VDC tout simplement parce que j’ai un adaptateur secteur qui traîne dans un coin et qui me fera une très bonne source auxiliaire.
• Interface logiciel pour commander la commutation des relais. Le contrôle du port parallèle est réalisé grâce à une classe C++ utilisant ppdev.

2. Création du schéma, conception du circuit

Bien, il est temps de passer au travail. Nous allons utiliser le logiciel Kicad pour composer le schéma électrique du montage. L’installation du logiciel se fait en téléchargeant soit les binaires, soit les sources à partir du site de Kicad [1] et en suivant les instructions. Quelques distributions l’ont intégré dans leur logithèque (Gentoo, Debian...), vous savez donc comment faire. La version qui a servi pour ce tutoriel est celle datée 02/07/2007.

Figure 1 : Le gestionnaire de projets

La première fois que vous lancez Kicad, vous allez obtenir la fenêtre de la figure 1. C’est un gestionnaire de projet : l’arborescence de votre projet est présentée en 1.
Commençons par créer notre projet. Cliquez sur le bouton nouveau en 2. Une boîte de dialogue d’enregistrement s’ouvre. Je vous conseille de créer un dossier spécialement pour notre projet. J’ai enregistré le projet sous le nom ~/relais8/relais8.pro. Vous remarquerez que l’arborescence a changé avec l’apparition du nouveau nom pour les fichiers.
Lançons l’éditeur de schéma eeSchema. Cliquez sur le bouton 3. L’éditeur apparaît dans une nouvelle fenêtre (figure 2). Vous allez avoir droit à un message d’avertissement... ignorez-le, cliquez sur valider. Dans cet éditeur, vous avez à droite la barre d’outils et en haut la barre des commandes. L’interface fonctionne beaucoup avec le menu contextuel (clic droit) et les boîtes de dialogue des outils n’apparaissent qu’après un clic sur la zone de dessin.

Figure 2 : L’éditeur de schémas

Commençons par donner un titre au schéma grâce au cartouche en bas à droite de celui-ci. Cliquez sur le bouton Ajustage de la feuille de dessin dans la barre de commandes (en 4). Dans la boîte de dialogue qui s’ouvre, remplissez le champ Titre et validez.

2.1 Avons-nous tous les symboles à disposition ?

Où sont les composants ? Prenez l’outil Ajouter des composants (en 5), puis cliquez sur la feuille. La boîte de dialogue des composants apparaît. Elle sert à sélectionner un composant pour le placer sur la feuille. La sélection peut se faire de différentes manières : par le nom, par une recherche par mot clé ou en visualisant le contenu de la bibliothèque.
Cliquez sur Par Visualisateur libs, une nouvelle boîte de dialogue apparaît (figure 3). Dans cette nouvelle boîte, la liste la plus à gauche contient les bibliothèques de composants. Cliquez sur l’une d’elles, par exemple device. La colonne suivante se remplit du nom des composants contenus dans cette bibliothèque. Cliquez sur l’un d’eux, par exemple PHTRANS (nous en aurons besoin plus tard). Le symbole apparaît dans la partie droite. Cliquez sur Exporter vers schematique (en 6). La boîte se ferme et vous revenez sur la planche de travail d’eeSchema. Le symbole du composant suit la souris. Il suffit de cliquer pour le déposer sur le schéma.

Figure 3 : Le visualisateur de bibliothèques

Prenez le temps de parcourir les bibliothèques pour découvrir la quantité considérable de composants déjà intégrés dans le logiciel. Dans la suite de l’article, je vous indiquerai le composant à sélectionner ainsi : bibliothèque->composant.

Malgré tout, le composant « relais 1RT » n’existe pas. Il y a bien un relais 2RT mais, en plus, il est en norme américaine... Nous allons donc créer notre symbole.

Cliquez sur Appel de l’éditeur de librairies et de composants (en 7, figure 2). La fenêtre qui s’ouvre permet d’éditer un composant existant ou d’en créer d’autres en partant de zéro.

Figure 4 : Le relais 1RT de notre cru

Le composant que nous devons dessiner est représenté en figure 4. Commencez par cliquer sur Nouveau composant (en 8). Une boîte de dialogue s’ouvre. Elle permet de configurer quelques éléments du composant dont son nom et un modèle de référence. Dans le champ Nom, mettez RELAIS-1RT et dans le champ Référence mettez K. Cliquez sur valider.
Sur la zone de travail, il y a le nom et la référence empilés au milieu. Nous allons commencer par les déplacer pour pouvoir travailler. Faites un clic droit sur le texte et sélectionner Déplace Champ. Le texte suit votre souris. Cliquez, c’est posé.
La grille au départ est au pas de 50 mils. Pour les non-initiés, en électronique, on travaille en millièmes de pouces... 1 mil = 0,0254 mm. Tous les outils de dessin (dans la barre verticale à droite de la fenêtre) s’alignent automatiquement sur cette grille. Vous pouvez modifier le pas de la grille en faisant un clic droit et en choisissant Sélection grille dans le menu contextuel. Pour le moment, laissons-le à 50.
Commençons par créer l’organe de commande avec l’outil Addition de rectangle. Dessinez un rectangle de 300 par 200 mils. Maintenant, plaçons les pins (connexions) du composant. Sélectionnez l’outil Addition de pins (en 9). Cliquez sur la zone de travail, une nouvelle boîte de dialogue s’ouvre. Elle permet de régler les propriétés de la connexion. D’abord le nom A1, puis le numéro 1. Le numéro servira à faire la liaison avec l’empreinte de soudage du composant lors de la création du PCB. Réglez la longueur à 400 mils. Ensuite, il faut préciser l’orientation du pin. Choisissez Bas. Ceci veut dire que l’extrémité de connexion du pin au composant se trouve en bas de l’extrémité de connexion électrique. Donc, ce pin sera en haut du composant... un peu déroutant les premières fois. Pour la forme du pin, on ne touche à rien. Les autres formes proposées concernent les composants numériques. Enfin, pour le type électrique, nous choisirons passive. Toutes les propriétés autres que nom et numéro seront identiques pour toutes les autres pins. Cliquez sur valider et positionnez le pin en haut de l’organe de commande. Positionnez le pin A2 (numéro 2) en bas de l’organe de commande.
Dessinons l’inverseur. Commencez par positionner les trois pins :

• nom NC, numéro 3 ;
• nom NO, numéro 5;
• nom COM, numéro 4.

Il reste à tracer les lignes de l’interrupteur avec l’outil Addition de lignes. Pour tracer la petite ligne horizontale, vous aurez besoin de modifier le pas de la grille.
Pour tracer le rectangle extérieur, sélectionnez l’outil Addition de rectangles et faites un rectangle de 950 par 400 mils.
Il ne reste plus qu’à replacer le nom du composant au centre et sa référence, par exemple, sur la gauche.
Maintenant, cliquez sur Éditer les propriétés du composant (en 10). Dans la boîte de dialogue qui s’ouvre, dans l’onglet Options, assurez-vous que la case Nom de pin à l’intérieur est décochée. Validez.

Enregistrons notre composant : Cliquez sur Créer une nouvelle librairie et y sauver le composant (en 11). Vous pouvez enregistrer la bibliothèque soit dans l’arborescence normale de Kicad, soit dans votre dossier personnel. Ici, j’ai choisi de l’enregistrer dans le dossier du projet sous le nom local.lib. Un message vous indique qu’il faut référencer la bibliothèque dans eeSchema pour s’en servir. Fermez l’éditeur de composants, puis, dans eeSchema, cliquez sur Préférenes->Libs et Rep. Cliquez sur Ajouter, sélectionnez la nouvelle bibliothèque, cliquez sur valider. Cliquez sur Sauver config, puis enregistrer. Fermez la boîte de dialogue.

2.2 C’est parti !

L’objectif est de tracer la portion de schéma de la figure 5. Attention, il faut impérativement disposer les composants verticalement pour que tout tienne sur la feuille comme à la figure 6. En effet, il est impossible de faire une rotation sur un bloc.
Commençons par placer un relais. Sélectionnez l’outil Ajouter des composants (en 5) et le composant local->RELAIS-1RT. Faites-le tourner en appuyant sur R, posez-le en haut de la feuille. Alimentons le relais. Prenez l’outil Add Alims (en 12), cliquez sur la feuille. Dans la boîte de dialogue, cliquez sur Lister tous et sélectionnez +12V. Posez l’alimentation au-dessus de la broche A1 du relais. Prenez l’outil Addition de fils de connexion (en 13) et connectez l’alimentation à la broche A1.

DÉPLACER :
Pour déplacer un composant, vous pouvez soit sélectionner le composant en dessinant un rectangle autour avec l’outil de sélection, soit faire apparaître le menu contextuel et sélectionner Déplace composant ou encore appuyer sur la touche M quand le curseur de la souris est au-dessus.

Tous les composants inductifs, comme la bobine qui constitue l’organe de commande d’un relais, doivent être protégés contre les coupures soudaines de courant. Il faut donc placer une diode, dite « de roue libre », pour assurer la décharge de l’énergie électrique stockée dans la bobine. Poser un composant device->DIODE, cathode vers la droite en dessous du relais. Pour faire tourner un composant, vous pouvez appuyer sur R quand celui-ci est sélectionné, mais pas encore posé, ou bien, une fois le composant posé, dans son menu contextuel cliquer sur Oriente composant->Rotation ou bien appuyer sur R quand la souris est au-dessus du composant. Connectez la cathode au fil reliant l’alimentation à la broche A1.

Figure 5 : La portion de circuit correspondant à la commande d’un relais

TRANSFORMER :
Toutes les transformations de dispositions sont accessibles pendant et hors déplacement : Appuyez sur R pour la rotation de 90°, sur X pour le miroir horizontal et sur Y pour le miroir vertical.

L’alimentation du relais sera commandée par un transistor en commutation et ce transistor sera polarisé par le phototransistor. Posez le transistor device->NPN en dessous de la broche A2 du relais. Connectez son collecteur à A2, puis connectez l’anode de la diode sur ce dernier fil. Sélectionnez une alimentation GND et posez-la en dessous de l’émetteur et connectez-les.
Ce qui suit est facultatif. Si on veut faire joli, on peut rajouter une diode électroluminescente pour indiquer l’état du relais. Posez la (device->LED) anode vers le haut, puis placez une résistance (device->R) juste en dessous. Connectez l’anode de la LED au +12V, la cathode à la résistance, puis la deuxième borne de la résistance au collecteur du transistor.
Il est temps de calculer quelques valeurs de composants. Commençons par donner des références aux composants pour pouvoir les repérer plus facilement. Faites un clic droit sur le relais, puis sélectionnez Edite composant->Editer. Le dialogue s’ouvre, dans l’onglet Champs, vérifiez que le champ à éditer est bien Réf, puis saisissez K1 dans la zone Valeur. Cliquez sur valider. Vous pouvez aussi éditer un champ en faisant directement un double clic dessus. De la même manière, nommez la diode D1, la LED D2, la résistance R1 et le transistor Q1.

ÉDITER:
Pour éditer un champ, mis à part le menu contextuel, on peut aussi faire un double-clic sur celui-ci ; pour éditer un composant, de même.

Commençons par choisir le transistor. Nous avons besoin des caractéristiques de la bobine du relais soit grâce à sa datasheet, soit par une mesure à l’ohmmètre. Le relais que j’ai choisi a la référence 40319012 chez Finder et j’ai téléchargé sa datasheet. Elle m’apprend que la puissance dissipée par la bobine est de 650 mW sous une tension de 12 V : ça me donne un courant d’environ 55 mA. Si l’on met la LED, il faut rajouter le courant dont elle a besoin. Pour une LED classique, c’est 10 mA. Donc le courant dans le collecteur du transistor sera de IC = 65 mA. Un classique BC237 fera parfaitement l’affaire. Vous pouvez éditer le transistor et dans le champ valeur mettre le modèle choisi : BC237.
Il faut aussi choisir le modèle de la diode D1. Elle doit juste laisser passer le courant transitoire pendant la décharge de la bobine du relais, c’est-à-dire un courant décroissant qui débute à 55 mA. La très peu coûteuse 1N4148 suffira largement. Éditez le champ valeur de D1 avec 1N4148.
Continuons en calculant la valeur de R1. Il faut d’abord choisir la couleur de la LED pour connaître sa tension de seuil VF. J’ai pris une LED rouge classique, VF = 1,7 V. Il nous faut aussi la tension VCEsat du transistor. Dans la datasheet, on lit au maximum 0,2 V. Donc R1 = (12-(1,7+0,2)/0,01) = 1010 Ω. Nous prendrons 1000 Ω pour rester dans les valeurs normalisées. Éditez le champ valeur de R1 en mettant 1000 ou 1k.
Rajoutons les plots de connexion pour la partie puissance. Posez le composant conn->CONN_3 au-dessus du relais. Éditez son champ réf à K2, puis connectez chacune de ses bornes avec les bornes de l’inverseur du relais.
Placez une résistance (device->R) en dessous de la base du transistor, référence R2. Placez l’opto-coupleur en dessous, l’émetteur du photo-transistor aligné avec la résistance, donnez-lui la référence U1. Connectez l’émetteur du photo-transistor avec R2, R2 avec la base de Q1. Placez une alim +12V au-dessus du collecteur du photo-transistor et connectez-la avec. La base de ce photo-transistor n’est pas connectée. Placez dessus un symbole de non-connexion (outil en 14). Placez une nouvelle résistance R3, en dessous de l’anode de la LED de l’opto-coupleur et connectez-les. La LED de l’opto-coupleur sera alimentée par les lignes de données du port parallèle, sous une tension de +5V donc.
L’opto-coupleur choisi est un 4N25 : ses capacités suffiront pour l’usage que l’on veut en faire. Il faut calculer les valeurs de R2 et R3. Le courant IC de Q1 vaudra 65 mA : on l’a déjà déterminé. Le coefficient d’amplification en courant du BC237 est, en moyenne, de 200. Ça veut dire qu’il nous faut un courant de base IB d’au moins 65/200 = 0,33 mA. L’opto-coupleur a un taux de transmission du courant de 50%. Donc, si R3 vaut 1 kΩ, le courant dans la LED sera d’environ 3 mA et le courant transmis par le photo-transistor sera d’environ 1,5 mA. La résistance R2 sert à limiter le courant maximal dans le photo-transistor. Si on lui donne une valeur de 4,7 kΩ, le courant ne dépassera jamais les 2,5 mA.
Voilà, nous avons terminé notre bloc. Nous devons maintenant le dupliquer pour en obtenir 8. Prenez l’outil sélection. Le principe est simple. Nous allons dessiner un rectangle de sélection englobant notre bloc pour faire une copie du bloc. Positionnez la souris en haut à gauche du bloc, maintenez enfoncée la touche [MAJ] pour passer en mode copie, appuyez sur le bouton gauche de la souris et maintenez-le, étirez le rectangle de sélection jusqu’au coin inférieur droit et relâchez le bouton de la souris, puis la touche [MAJ]. Vous avez maintenant une copie du bloc qui suit votre curseur. Posez cette copie juste à côté du bloc en cliquant. En voilà 2 ! Copiez ces 2, ça en fait 4. Encore une dernière copie et on obtient les 8 blocs identiques.

COPIER UN BLOC:
Pour éditer un champ, mis à part le menu contextuel, on peut aussi faire un double-clic sur celui-ci ; pour éditer un composant, de même.

Si vous n’avez pas pensé à enfoncer la touche [MAJ] pendant la sélection, ce n’est pas grave. Après la sélection, lorsque le bloc suit la souris, faites un clic droit et, dans le menu contextuel, sélectionnez Autres commandes bloc->Copie bloc.

Figure 6 : Le schéma terminé

Posez le composant conn->DB25 en bas de la feuille. Donnez-lui la référence J1. Il faut maintenant relier chacune des résistances « R3 » à une ligne de donnée du port parallèle. Ces lignes sont sur les broches 2 à 9 du port. Les cathodes des LED des opto-coupleurs doivent être reliées à la masse du port broches 18 à 25.
Il ne nous reste plus qu’à mettre en place le connecteur pour le +12V. Placez un composant conn->CONN_2 en bas à gauche, placez la souris au-dessus et appuyez sur Y pour exécuter un miroir vertical. Placez ensuite un composant device->CAPAPOL à sa droite, donnez lui 10u comme valeur. Ce condensateur de 10 µF va fournir les pics de courant appelés lors des commutations des relais. Connectez la borne 1 du connecteur au pôle plus du condensateur, la borne 2 au pôle moins. Ajoutez un symbole d’alimentation +12V connecté au pôle plus du condensateur et symbole GND au pôle moins. Il est utile de calculer le courant que devra être capable de débiter l’adaptateur secteur->12 VDC. Chaque module relais + LED + opto-coupleur consomme 55 + 10 + 1,5 = 66,5 mA. Quand les 8 sont en fonctionnement, ça nous donne 8 x 66,5 = 532 mA.
Ultime tâche, numéroter les composants. Cliquez sur la commande Annotation des composants (en 15). Dans l’encadré Sélection de la boîte de dialogue, cliquez sur Tous les composants, puis cliquez sur Numérotation. On vous avertit que la numérotation existante va être écrasée, cliquez sur oui.
Fini ! Enregistrez votre travail. Pour passer à la suite et permettre au logiciel Pcbnew d’importer le schéma pour tracer le typon, il nous faut générer la « netliste ». Cliquez sur Génération de la netliste (en 16). Une boîte de dialogue à plusieurs onglets s’ouvre. Restez dans l’onglet Pcbnew, cliquez sur Netliste. On vous propose d’enregistrer la netliste dans le fichier relais8.net. Cliquez sur Enregistrer.

Remarque :
Si vous possédez les composants et une platine à essais, vous pouvez monter l’un des huit circuits de commande et vérifier son bon fonctionnement.

3. Réalisation du typon

La phase de conception terminée, il faut passer à la réalisation. À partir de là, je vous conseille d’acheter tous les composants. Mieux vaut vérifier la justesse des empreintes avant de graver le circuit imprimé.

3.1 Vous avez vu l’empreinte ?

Bien sûr que non, sinon ce ne serait pas marrant. Il nous manque l’empreinte du relais. Nous allons devoir créer un nouveau module. Ouvrez Pcbnew (en 17). Vous allez encore avoir droit à un message d’avertissement concernant l’existence du fichier relais8.pcb. La fenêtre de Pcbnew est représentée figure 7.
Cliquez sur Ouvrir éditeur de modules (en 18). L’éditeur de module et l’empreinte correspondant au relais que j’ai acheté sont représentés sur la figure 8. Pour créer un nouveau module, cliquez sur Nouveau module (en 19), donnez-lui RELAIS-4031 comme nom. Bien, si, comme ici, le fabricant vous donne les cotes du composant en millimètres, vous devez travailler en millimètres. Il va falloir configurer correctement notre grille. Passez en millimètres (en 20). Puis, allez dans le menu Dimensions->Dim grille utilisateur. Réglez l’espacement vertical et horizontal à 0,5 mm et validez. Sélectionnez la grille user dans le menu contextuel. N’hésitez pas à déplacer les 2 textes placés par le logiciel pour vous libérer l’espace de travail.

Figure 7 : L’éditeur de circuits imprimés Pcbnew

On commence toujours par placer les pastilles de soudage du composant. Configurons le type de pastilles que l’on va utiliser, cliquez sur Caract pads (en 21). La boîte de dialogue Propriétés des pads s’ouvre. Nous allons régler le diamètre de perçage à 1,5 mm, la taille à 3 mm. Dans les couches, nous n’allons garder que Couches cuivre, Sérig cmp et Masque soudure cuivre. Validez. Pour placer les pastilles, prenez l’outil Addition de pins (en 22). Le plus simple, c’est de placer la première à l’origine du repère (là où les 2 lignes en pointillés bleus se croisent) et ensuite de se servir de l’indication de position du curseur dans la barre d’état pour placer les autres aux bonnes cotes. Soyez vigilants sur la numérotation des pastilles : elle doit être identique à celle du composant que nous avons créé dans eeSchema. Pour corriger un numéro, double-cliquez sur la pastille pour l’éditer.

Figure 8 : L’éditeur de modules et l’empreinte pour le relais Finder 4031.

Prenez l’outil Addition de lignes (en 23). Il faut maintenant dessiner le contour du composant. Là encore, servez-vous de la position du curseur pour respecter les cotes du boîtier. Placez-vous, par exemple, à l’angle supérieur gauche du contour et appuyez sur la barre espace, cela déplace l’origine du repère à l’endroit où est le pointeur de la souris. Les coordonnées indiquées dans la barre d’état sont relatives à cette nouvelle origine.
Replacez les textes à l’intérieur du contour du boîtier. Enregistrons le module dans une nouvelle bibliothèque, cliquez sur Créer une nouvelle librairie et y sauver le composant (en 24). Enregistrez-la dans le dossier du projet sous le nom local.mod. Fermez l’éditeur.
Il faut inclure la nouvelle bibliothèque dans le projet : dans Pcbnew, allez dans Préférences->Libs et Rep. Cliquez sur Ajouter et sélectionnez notre bibliothèque. Cliquez sur Sauver config et enregistrez relais8.pro. Fermez la boîte de dialogue.

3.2 Maintenant, il faut router

Avant d’importer la netliste dans Pcbnew, nous allons associer un module (empreinte pour CI) à chaque composant du schéma. Ouvrez Cvpcb (en 25). La fenêtre qui s’ouvre, représentée en figure 9, comporte 2 colonnes. Dans la colonne de gauche, il y a la liste de tous les composants contenus dans notre schéma avec leur référence et leur valeur suivies de deux points. Dans la colonne de droite, il y a la liste de tous les modules disponibles. Cette liste peut être filtrée ou non. Vous passez d’un état à l’autre grâce aux boutons situés en 26.

Figure 9 : Cvpcb, association composant-empreinte

Pour associer un module à un composant, sélectionnez le composant dans la colonne de gauche, double-cliquez sur le module désiré dans la colonne de droite. Le nom du module associé apparaît à la droite des deux points dans la liste de la colonne de gauche (pour bien suivre ces explications, il ne faut pas confondre sa gauche et sa droite ;-). Faites les associations telles qu’indiquées dans le tableau suivant.

Cliquez sur Sauver netliste et cmp liste (en 27). Enregistrez relais8.net. Cvpcb se ferme. Retournez à Pcbnew. Importons la netliste. Cliquez sur Lire netliste (en 28). Ne changez rien dans la boîte de dialogue. Cliquez simplement sur lire, puis sur fermer. Tous les modules sont entassés dans le coin supérieur gauche de l’espace de travail. Il faut d’abord les séparer. Passez en mode module (en 29). Faites un clic droit sur la zone de travail. Dans le menu contextuel, sélectionnez Move et Place globaux->Déplace tous les modules.
C’est là que les choses se compliquent un peu. Il faut réarranger les modules de manière à respecter 2 impératifs. Nous devons séparer physiquement les différentes parties (230 VAC, +12 V, port parallèle) pour garantir leur isolation (surtout pour le PC). Il faut essayer de faire une carte relativement peu encombrante. Pour déplacer un module, placez la souris au-dessus, appuyez sur M, déplacez-le, appuyez sur R pour le faire tourner et cliquez pour le poser. Remarquez que, lors du déplacement, le logiciel vous indique les liaisons électriques concernant le composant. Ceci est fait pour vous aider à placer celui-ci de manière à ce que les pistes soient les plus faciles possible à tracer par la suite.
Il se peut, au niveau des borniers par exemple, qu’une inversion entre deux bornes permette de simplifier le routage. Pour inverser les bornes, vous devez rééditer le schéma sous eeSchema, faire les modifications, sauvegarder, recréer la netliste, puis, sous Pcbnew, relire la netliste.
Vous avez, à la figure 10, le placement et le routage des pistes tels que je les ai effectués. Il n’existe pas une seule manière de les réaliser : à vous de trouver mieux.
Pour tracer les pistes, vous devez passer en Mode piste (en 30) et utiliser l’outil Ajouter pistes (en 31). La largeur de piste d’origine de 17 mils ira très bien pour toutes les pistes, sauf celles reliant les relais aux borniers. Remarquez que, quand vous cliquez sur une pastille ou une piste existante, le logiciel vous place toutes les pistes et pastilles au même potentiel en surbrillance. Le tracé s’arrête quand vous double-cliquez. Le tracé des pistes s’alignant sur la grille, vous pourrez être amenés à modifier le pas de celle-ci.
Pour modifier la largeur des pistes, sélectionnez dans le menu Dimensions->pistes et vias. Dans la boîte de dialogue qui s’est ouverte, vous pouvez choisir l’épaisseur des pistes et l’espace d’isolation (l’unité ici est le pouce, pas le mil). Vous trouverez sur internet de nombreuses tables vous indiquant des correspondances entre l’intensité qui doit circuler dans une piste et son épaisseur. Mes relais ont un pouvoir de coupure de 10 A. Il me faudrait une piste de 5 mm de large... En fait, je ne les ai faites que de 2,5 mm (100 mils). En les étamant abondamment, ça devrait aller. Pour l’isolation, j’ai augmenté l’espace à 0.5 mm (20 mils). Les pistes nouvellement créées auront la nouvelle épaisseur. Vous pouvez éditer la largeur des pistes existantes par un clic droit dessus, puis en sélectionnant Change largeur->éditer piste. Le logiciel leur affecte alors la largeur indiquée dans la liste déroulante (en 32). Vous pouvez aussi ne modifier qu’un morceau de la piste avec Change largeur->edit segment.
Le logiciel possède des capacités d’auto-placement et d’auto-routage.
Vous pouvez les essayer. Attention, pour fonctionner, ces fonctions ont besoin que le contour du circuit soit tracé. Pour l’auto-placement des modules, passez en Mode module. Si certains des modules ne doivent pas bouger, verrouillez-les : clic droit sur le module à verrouiller, puis Fixe module. Pour lancer l’auto-placement, faites un clic droit en dehors de tout module, puis sélectionnez Move et Place globaux->Autoplace tous les modules. Si vous voulez un résultat acceptable, vous avez intérêt à placer tous les socles de connexion vous-même et à les verrouiller. Personnellement, je ne suis pas friand de ce genre d’outil... en général, en réfléchissant un peu, on peut faire beaucoup mieux.
Pour l’auto-routage, passez en Mode piste. Faites un clic droit, puis sélectionnez Autoroutage global->Sélection couple de couches. Dans la boîte de dialogue, sélectionnez les couches inférieure et supérieure. Pour faire un circuit simple face, sélectionnez deux fois la couche cuivre. Puis, refaites un clic droit et, cette fois, sélectionnez Autoroutage global->Autoroute tous modules. Vous pouvez aussi verrouiller les pistes que vous ne voulez pas router, en faisant un clic droit dessus et en sélectionnant Ajuste flag->Verrou oui. Vous pouvez ne lancer l’auto-routage que sur une seule piste : faites un clic droit sur une pastille non encore connectée et sélectionnez Autoroute net.

Figure 10 : Et voilà le travail !

Après avoir disposé tous les modules et routé toutes les pistes, il reste encore à dessiner les contours de la carte. Passez sur la couche Contours : clic droit, Sélection de la couche de travail. Puis, avec l’outil Addition de lignes (en 33), tracez le contour.
Vous pouvez rajouter des modules 1PIN (outil Addition de modules en 34) pour placer d’éventuels trous de perçage pour monter la carte dans un boîtier, ce que je vous recommande, histoire de ne pas mettre accidentellement les doigts sur une piste alimentée en 230 VAC. (Il faut repasser sur la couche Cuivre)
Vous pouvez également agrémenter l’apparence de votre carte en plaçant des zones de texte. Par exemple, on peut commencer par indiquer le nom du projet sur la carte : Prenez l’outil Ajout de texte (en 35). Cliquez à l’endroit où vous voulez placer le texte. Une boîte de dialogue s’ouvre dans laquelle vous allez écrire le texte, choisir la couche sur laquelle écrire, choisir l’orientation du texte. Fonction intéressante : il y a une option miroir qui permet d’écrire un texte sur la face cuivre, texte qui ne pourra être lu que si le circuit est gravé correctement (genre détrompeur). Validez. Vous pouvez déplacer le texte ou le faire tourner par les mêmes commandes que précédemment.
Vous voulez connaître les dimensions de la carte, aucun souci. Passez sur la Comments et prenez l’outil Addition de cotations (en 36). Cliquez sur le point de départ de la cote, puis cliquez sur le point d’arrivée et cliquez une troisième fois pour placer la cote. La dimension apparaît dans l’unité active.
Amusez-vous et essayer de refaire le typon en me copiant ou non.
Vous avez fini ? Il faut encore tracer le typon pour pouvoir l’imprimer. Cliquez sur la commande Tracer (en 37). Dans la boîte de dialogue, choisissez les couches que vous désirez tracer. Assurez-vous que l’échelle est bien à 1 et le format à postscript. Cliquez sur Tracer. Le logiciel vous crée un fichier Postscript par couche. Ceux qui nous intéressent particulièrement s’appellent relais8-Copper.ps et relais8-Component.ps. Ce sont nos typons (si votre circuit est simple face, seul le premier est utile). Quel peut être l’intérêt de cette méthode indirecte ? Si vous possédez une imprimante dont le pilote sous Linux n’offre pas la résolution maximale, vous pourrez imprimer votre typon sous un autre système mieux doté :-(.

4. Fabrication de la carte

Nous en avons fini avec l’outil informatique. Maintenant, il faut mettre les mains dans le cambouis !
Si vous n’êtes pas un habitué de la réalisation de circuits imprimés, je vous recommande la relecture de l’article concernant ce sujet dans le hors-série numéro 23 [3]. Ici, je vais juste me contenter de reprendre les grandes lignes de la fabrication en y ajoutant quelques retours de ma propre expérience.

4.1 Imprimer le circuit

La première étape est l’impression du typon. J’ai longtemps utilisé l’impression jet d’encre sur papier calque, puis j’ai acquis une imprimante laser et des transparents. Les deux méthodes donnent de bons résultats à une condition : il faut s’assurer que c’est la face encrée du papier qui sera en contact avec la résine photo-sensible.
La deuxième étape est l’insolation de la plaque. Si vous n’avez pas d’insoleuse et que vous n’avez pas envie d’en acheter ou d’en fabriquer une, vous pouvez utiliser une source d’UV gratuite et abondante : le Soleil ! J’ai réalisé mes premiers circuits ainsi. Par contre, cette méthode n’est efficace que quand le soleil est à son zénith et plutôt l’été. Et vous aurez besoin de faire quelques essais pour trouver la bonne durée d’exposition. Sachez qu’en été, les temps sont les mêmes qu’avec une insoleuse.
La troisième étape est la gravure du circuit. Mis à part le traditionnel perchlorure de fer, j’ai testé un mélange d’acide et d’eau oxygénée qui fonctionne très bien : Dans une cuvette en plastique, vous mélangez 3/5 d’eau, 1/5 d’acide chlorhydrique (acheté en droguerie ou en magasin de bricolage) et 1/5 d’eau oxygénée à 130 volumes (achetée en droguerie). Le mélange a une durée de vie très courte. Plongez le circuit, ça fait des bulles, ça chauffe, ça devient vert et ça ronge le cuivre découvert. Durée de gravure entre 30 secondes et 1 minute. Bien sûr, le mélange et chacun des produits utilisés sont très toxiques, corrosifs et dangereux. Il ne faut pas respirer les gaz dégagés pendant la gravure. Après la gravure, le rinçage et le séchage, il peut être utile de vérifier (à l’ohmmètre) que le circuit est correct : continuité des pistes, absence de court-circuits (notamment pour les pistes les plus serrées).
L’avant-dernière étape est l’étamage. Une solution économique que j’utilise est la pâte à souder. Vous la trouverez dans les magasins de bricolage au rayon soudure. C’est un mélange d’étain et de plomb en poudre. Vous la passez sur vos pistes au pinceau (pas la peine d’en mettre des tonnes, même si vous ne le voyez pas, il y a de la poudre déposée). Vous prenez votre fer à souder et vous le passez sur vos pistes pour faire fondre la pâte. Résultat garanti.
Il ne vous reste plus qu’à percer votre circuit (là, je n’ai pas d’astuce :o).

4.2 Souder

Là non plus, il n’y a pas de secret. Il faut juste de la méthode et de la patience. Quelques recommandations pour les débutants :

• Pour plier les pattes des diodes et des résistances, vous pouvez acheter, dans les magasins d’électronique, un gabarit de pliage. Les modules D3 et R4 que nous avons utilisés pour les empreintes de ces composants correspondent aux dimensions de ces gabarits. Par exemple, dans R4, le 4 signifie que les pastilles sont écartées de 4 x 100 mils.
• Écartez les diodes et les résistances de la plaque époxy pour laisser l’air circuler autour. Pour faire un travail soigné, servez-vous d’une cale d’épaisseur, comme un bout de carton, à glisser sous le composant pendant l’assemblage.
• Soudez les composants par ordre d’épaisseur : diodes, résistances, opto-coupleurs (ou supports), transistors, LED, condensateur, borniers, DB25, jack, relais. Pour les pistes allant des relais aux borniers, n’oubliez pas de déposer une bonne couche de soudure pour les épaissir.

Figure 11 : Nos efforts enfin récompensés !

4.3 Tester

Avant de brancher le montage sur le PC, on peut s’assurer qu’il fonctionne correctement. Branchez l’adaptateur secteur->12 VDC. Normalement, rien ne se passe (peut-être un léger clignotement des LED dû à la charge du condensateur). Appliquez +5 VDC sur l’une des LED d’opto-coupleur et le relais correspondant doit basculer (clic) et sa LED s’allumer. Répétez l’opération pour tous les relais. Si tout va bien, nous allons pouvoir brancher le circuit sur l’ordinateur.
Éteignez le PC (impératif pour ne pas endommager le port). D’abord, connectez vos appareils aux borniers, puis le port parallèle. Ne branchez pas l’adaptateur secteur->12 VDC tout de suite. En effet, l’état du port n’est pas défini pendant le démarrage du PC. Vous ne pourrez alimenter la carte que lorsque vous serez sûr de l’état du port, c’est-à-dire après le lancement de notre programme de gestion.

5. Commande logicielle

Le logiciel de commande présenté ici n’est qu’un exemple rudimentaire destiné uniquement à montrer comment faire pour implémenter la commande de la carte. Je m’appuie sur l’interface ppdev du noyau. Les modules suivants doivent être chargés : parport, parport_pc et ppdev. Vous devez avoir un fichier /dev/parport0 dans votre arborescence.
Je vous recommande la relecture de l’article traitant la programmation du port parallèle [4].

5.1 Une classe pour la commande du port

Nous allons créer une classe C++ que j’ai appelée « SPO » pour Simple Parport Output afin de gérer la carte. Nous allons utiliser le mécanisme des exceptions pour protéger l’initialisation du port que nous ferons dans le constructeur. Nous pourrons ainsi facilement interrompre le programme si la prise de contrôle du port parallèle ne se fait pas correctement. Le destructeur de la classe se chargera de libérer le port.
Commençons par déclarer les classes d’exceptions :

class spoError : public std::exception
{
     private:
	int sys_error;
	char * sys_msg;
     public:
	spoError(int code) { sys_error = code; sys_msg = std::strerror(sys_error); }
	const char * what() const throw() { return sys_msg; }
};

class spoFdError : public spoError
{
     public:
	spoFdError(int code) : spoError(code) { }
};

class spoPPError : public spoError
{
     public:
	spoPPError(int code) : spoError(code) { }
};

La classe spoError se contente de stocker le code d’erreur système renvoyé par errno et la description textuelle de celle-ci. J’ai dérivé 2 classes de spoError (l’une pour l’erreur d’initialisation du descripteur de fichier, l’autre pour l’erreur d’initialisation de ppdev), afin d’identifier facilement la source de l’exception pour adapter le traitement à l’erreur.
Le constructeur utilise ces 2 classes :

SPO::SPO(char *pdev)
try
{
	fd = open(pdev, O_RDWR);
	if (fd < 0)
	{
		throw spoFdError(errno);
	}
	if (ioctl(fd, PPEXCL) < 0)
	{
		throw spoPPError(errno);
	}
	if (ioctl(fd, PPCLAIM) < 0)
	{
		throw spoPPError(errno);
	}
	setMask(0);
}
catch(spoFdError & e)
{
	std::cerr << «Erreur d’accès au fichier : « << e.what() << std::endl;
}
catch(spoPPError & e)
{
	std::cerr << «Erreur de prise de contrôle du port : « << e.what() << std::endl;
	if (close(fd))
	{
		std::cerr << «Erreur de fermeture du fichier.» << std::endl;
	}
}

En séparant les 2 types d’erreur, nous pouvons ainsi libérer les ressources précédemment obtenues. Le destructeur de la classe libère tout :

SPO::~SPO(void)
{
           if (fd >= 0)
           {
           setMask(0);
           if (ioctl(fd, PPRELEASE))
           {
		std::cerr << “Erreur de libération du port.» << std::endl;
           }
           if (close(fd))
           {
		std::cerr << “Erreur de fermeture du fichier.” << std::endl;
           }
           }
}

Le reste du code ne présente pas de difficulté particulière. L’écriture sur le port se fait par la méthode SPO::outMask qui ne fait qu’implémenter l’appel à ioctl :

bool SPO::outMask(void)
{
	if (ioctl(fd, PPWDATA, &mask) < 0)
	{
		std::cerr << “Erreur d’écriture.» << std::endl;
		return(false);
	}
	return(true);
}

5.2 Exemple d’interface

L’interface utilisateur proposée est en mode texte et assez rudimentaire.
Nous commençons par récupérer la localisation du système. Ceci n’a qu’un but : obtenir les messages de la libc en français.

locale::global(locale(«»));

Nous appelons le constructeur de notre classe dans un bloc try et c’est fini.

try
{
	port = new SPO(«/dev/parport0»);
}
catch(exception & e)
{
	cout << “Programme arrêté !» << endl;
	exit(EXIT_FAILURE);
}

Le reste du code ne présente pas de difficulté particulière. Après l’initialisation du port, on obtient une ligne de commande où l’on indique le numéro du relais à basculer. Il suffit de rentrer un nombre négatif pour sortir du programme.

6. Et ensuite

Le montage présenté ici était principalement un prétexte au tutoriel sur le logiciel Kicad, mais il représente une bonne base de travail. On peut imaginer augmenter le nombre de sorties commandées en faisant appel à des techniques plus complexes autour de ports comme l’USB ou par l’utilisation d’un bus I2C. Cette carte peut alors servir de sous-unité exécutive dépendant d’une autre carte de gestion.

Figure 12 : La carte en pleine action

L’interface logicielle peut être, elle aussi, grandement perfectionnée. On peut penser créer un démon prenant le contrôle de la carte et permettant sa commande par cron ou interface graphique ou encore par une page web accessible à distance.
Il ne vous reste plus qu’à imaginer la suite.
J’espère que ce tour d’horizon de Kicad vous aura fait apprécier l’ergonomie et les capacités de ce logiciel. Parmi les possibilités que je n’ai pas évoquées plus haut, il y en a une qui peut être intéressante : c’est la visualisation en 3 dimensions de la carte que vous réalisez (dans Pcbnew, menu 3D visu). Il manque le modèle 3D de notre relais et le créer fait appel à un autre logiciel, Wings3D [5].
Vous trouverez des composants, des modules et des modèles 3D supplémentaires sur le site de la communauté. Vous pouvez même participer [6].

Remerciements:
Je tiens à remercier ici et officiellement toute la communauté du logiciel libre pour son travail et le magnifique outil qu’elle procure à l’humanité. Sans l’existence des solutions alternatives aux systèmes propriétaires, j’aurais sans doute arrêté l’informatique il y a 4 ans.
Je remercie particulièrement Jean-Pierre Charras et toute la communauté développant Kicad. Quelle joie de faire de la CAO libre !

Liens et références :

• [1] Laboratoire du LIS à Grenoble, Kicad :
  http://www.lis.inpg.fr/realise_au_lis/kicad/
• [2] BODOR (Denis), « Pilotez des relais depuis Linux », in GNU/Linux Magazine, hors-série numéro 23, page 64.
• [3] BODOR (Denis), « Réalisation de circuits », in GNU/Linux Magazine, hors-série numéro 23, page 18.
• [4] BODOR (Denis), « Programmation du port parallèle », in GNU/Linux Magazine, hors-série numéro 23, page 24.
• [5] Wings 3D : http://www.wings3d.com/
• [6] http://www.kicadlib.org/
  

Retrouvez cet article dans : Linux Magazine 97