Électronique et domotique libre : conception d'un module pour le DomoTab avec KiCad

Open Silicium n° 007 | juin 2013 | Nathael Pajani
  • Actuellement 0 sur 5 étoiles
0
Merci d'avoir participé !
Vous avez déjà noté cette page, vous ne pouvez la noter qu'une fois !
Votre note a été changée, merci de votre participation !
La domotique est un vaste sujet dont on nous parle depuis des années, mais les solutions propriétaires se suivent et se ressemblent, et tous les moyens sont bons pour rendre le client captif. Le projet DomoTab a pour objectif de créer la première plateforme de domotique libre, et permettra ainsi à l'utilisateur de reprendre le contrôle de son domicile.

1. Introduction

Le DomoTab est une plateforme ouverte dont la première application est la domotique. Il intègre un processeur ARM CortexA8 (AM3874 de Texas Instruments) doté de très nombreuses interfaces (Dual gigabit Ethernet, SATA, USB, Audio, Vidéo in/out, UART, SPI, I2C, …), qui en font une centrale de contrôle très intéressante. Le DomoTab est accompagné d'une passerelle filaire, le DTPlug, qui permet l'ajout d'extensions supplémentaires et déporte la connectique filaire pour le mode « tablette ».

Le DomoTab et le DTPlug intègrent chacun quatre connecteurs UEXT (format mis dans le domaine public par la société OLIMEX) destinés à accueillir des modules d'interface. Ces modules permettent à l'utilisateur de choisir les interfaces dont il a besoin pour son installation domotique.

Je vais donc vous présenter la marche à suivre pour créer un module simple, qui pourra servir de base pour les tests et le développement d'autres modules, et que vous pourrez personnaliser et adapter à vos besoins. Nous verrons dans un prochain article comment ajouter des éléments pour l'intégrer à une installation domotique.

Le module GPIO Démo

Le format UEXT regroupe les interfaces UART, I2C et SPI utilisées pour la communication avec les modules, facilitant leur création tout en conservant une taille limitée. L'utilisation d'un format ouvert assure la pérennité et la compatibilité avec les modules existants et à venir.

L'élément central de notre module sera un microcontrôleur LPC1224 de NXP. Nous ajouterons un capteur de température, une eeprom I2C (qui servira pour l'identification des modules par le DomoTab et le DTPlug), et un convertisseur USB-to-UART, ce qui transformera notre module en une plateforme de développement autonome.

Le choix du microcontrôleur de la gamme LPC de NXP est motivé par plusieurs éléments : le prix - à partir de 1.8€ à l'unité chez Farnell, le cœur ARM cortex M0, qui nous permettra d'utiliser le langage C et de compiler le code avec un simple gcc pour ARM, et la possibilité de programmer la flash interne du microcontrôleur par la liaison série.

Pour créer notre module, nous utiliserons le logiciel KiCad, un excellent logiciel de CAD électronique, libre (licence GPL), français et intégré à plusieurs distributions (je n'ai testé que la version Debian Sid). C'est ce logiciel qui a servi à créer la carte contrôleur du DTPlug (voir sur notre site) et pour d'autres projets comme le Crazyflie.

2. Préparation

Cet article détaille la prise en main de KiCad, ce qui nous permettra de nous concentrer sur la partie domotique lors des prochains articles. KiCad a évolué depuis la présentation faite il y a 5 ans dans GNU/Linux Magazine n°97, une nouvelle présentation de cet excellent logiciel ne peut pas faire de mal.

Tout d'abord, pour que vous puissiez suivre plus facilement, je vous propose d'installer le logiciel. Normalement, il vous suffit d'utiliser votre gestionnaire de paquets et d'installer le paquet kicad. Pour les utilisateurs n'ayant pas de gestionnaire de paquets, ou ceux intéressés par une version plus récente (j'utilise la version 2012-apr-16-27), une petite visite sur le site officiel (kicad-pcb.org) vous donnera entière satisfaction.

KiCad est en fait une suite logicielle qui regroupe plusieurs outils que nous utiliserons successivement pour créer notre module, et qui inclut aussi un certain nombre de bibliothèques de composants.

Le premier élément de la suite KiCad est Eeschema, l'éditeur de schémas électroniques. Il nous permettra de créer le schéma du module à partir des composants et des connecteurs dont nous aurons besoin.

Le deuxième élément dont nous nous servirons est Cvpcb. Cet outil nous aidera à associer une empreinte à chacun des composants de notre schéma.

Suivra l'étape de placement et de routage, réalisée avec Pcbnew. Cette étape consiste à définir la position des composants sur le circuit imprimé (PCB) final, et à tracer les pistes qui relient les différentes pattes de nos composants, telles que nous les aurons définies à l'aide de l'éditeur de schéma lors de la première étape. C'est aussi ce logiciel qui sert à générer les fichiers de fabrication (gerber), que nous pourrons visualiser avec Gerbview.

Nous aborderons en plus l'utilisation de deux outils très intéressants : l'éditeur de composants et l'éditeur d'empreintes de modules. Ces deux éléments servent à créer les définitions des composants que l'on ne trouve pas dans les bibliothèques de composants que l'on peut récupérer sur le net, ou qui sont intégrées à KiCad, ou à modifier les définitions existantes quand elles ne correspondent pas à nos besoins.

Note

Pour simplifier la lecture de l'article, les raccourcis et la présentation des menus sont regroupés dans l'encart « KiCad Reference Card », dans l'ordre d'apparition. Les références sont notées [RefCard-N.N].

3. Commençons petit

Avec notre objectif en tête, nous pouvons commencer la création du schéma électronique de notre module.

Démarrez KiCad et créez un nouveau projet [RefCard-1.1]. Je vous conseille de créer un répertoire de travail qui contiendra vos différents projets, et un sous-répertoire pour notre projet de module dans lequel iront tous les fichiers du projet. Il sera alors simple de dupliquer notre module pour l'utiliser comme base de développement pour un nouveau module, en copiant simplement ce répertoire sous un autre nom. Dans ce répertoire, créez le fichier Module_GPIO_Demo.pro. Vous pouvez bien entendu choisir un autre nom.

Figure 1 : Gestionnaire de projets

Maintenant que le projet est créé, lancez l'éditeur de schéma (Eeschema : première des six grosses icônes de la fenêtre du projet). Au lancement, une boîte de dialogue vous informe que le fichier Module_GPIO_Demo.sch n'a pas été trouvé, c'est normal, notre projet est encore vierge. Commençons par donner un titre à notre schéma en modifiant les options de la page [RefCard-2.1]. La boîte de dialogue qui s'ouvre nous permet de changer le contenu du cartouche des feuilles de notre schéma (texte en rouge en bas à droite de la feuille de schéma).

En plus du titre (« Module Linux Mag »), profitons-en pour renseigner le champ « Révision » (1.0) et utilisons le champ « Comment 1 » pour indiquer la licence de notre schéma, ici la licence Creative Commons CC BY-NC-SA. Il est possible d'exporter ces champs vers toutes les feuilles du schéma. Cela n'a pas d'intérêt pour l'instant, mais nous servira pour copier directement toutes ces informations vers les autres feuilles que nous créerons par la suite.

3.1 Premiers pas, premières broches ...

Nous sommes désormais devant une grande feuille vide. Pour faciliter la prise en main, commençons par quelques composants simples, dont nous aurons besoin par la suite.

Sélectionnez l'outil de placement de composants [RefCard-2.2], puis cliquez sur la feuille, n'importe où. Dans la boîte de dialogue, choisissez « Sélection par Viewer », qui facilite la recherche du composant. Attaquons par le connecteur UEXT, qui n'est autre qu'un connecteur avec deux rangées de cinq broches. Il se trouve dans la bibliothèque « conn » (première colonne) et porte le nom « CONN_5X2 ». Placez-le sur le circuit [RefCard-2.3] (l'endroit n'a pas de grande importance pour l'instant et il est très simple de déplacer les composants [RefCard-2.4]).

Le « P? » qui se trouve au-dessus du composant correspond à l'annotation ou « référence » du composant. Le point d'interrogation signifie que nous n'avons pas identifié ce composant, et il ne sera pas possible de passer à l'étape suivante (association des empreintes) tant que tous les composants n'auront pas été annotés. KiCad propose une fonction d'annotation automatique [RefCard-2.6], mais il est aussi possible de le faire manuellement [RefCard-2.7]. Attention, dans certains cas, il vous est demandé de clarifier votre sélection, car il est aussi possible d'éditer le champ « Valeur » du composant, qui est actuellement « CONN_5X2 ». Utilisez la méthode que vous préférez (ou testez les différentes méthodes) pour donner la référence « P1 » à notre connecteur UEXT, puis pour remplacer la valeur « CONN_5X2 » par « UEXT ».

3.2 D'autres composants simples

Pour tenir compagnie à notre connecteur UEXT, nous allons continuer à ajouter des composants. Nous ne pourrons pas nous passer des résistances et des condensateurs, allons donc les chercher. Ceux-ci se trouvent dans la bibliothèque « device » et ont des noms facilement reconnaissables : R pour résistance et C pour condensateur. Placez l'un des deux sur le schéma. Pour l'autre, au lieu d'utiliser la « Sélection par Viewer », entrez son nom (« R » ou « C ») dans le champ « Nom » de la boîte de dialogue et validez. Cela vous a (normalement) sélectionné le composant choisi, que vous n'avez plus qu'à positionner sur le schéma. Cette méthode permet de rechercher des composants dont vous connaissez le début du nom. Essayez de saisir « SW » pour trouver un bouton poussoir (switch en anglais), et comme plusieurs choix sont possibles, vous devez alors en sélectionner un. Sélectionnez « SW_PUSH ». (Suggestion pour les développeurs de KiCad : ajouter l'indication de la bibliothèque en plus de la description et des mots-clés, et éventuellement la représentation schématique /Suggestion).

Figure 2 : Quelques composants simples

3.3 Les choses sérieuses

Plutôt que d'essayer de relier tout de suite par des fils nos quelques composants, sans but précis, continuons avec les composants intéressants parmi lesquels figure notre microcontrôleur, le LPC1224.

Sauf que les bibliothèques fournies avec KiCad ne contiennent pas ce composant, ni aucun des microcontrôleurs LPC de NXP (du moins pour la distribution Debian Sid à l'heure ou j'écris ces lignes). Deux solutions s'offrent à nous : trouver une bibliothèque en ligne qui contienne ce composant, ou le créer nous-mêmes avec l'éditeur de bibliothèques de composants. Il existe une page référençant de nombreuses bibliothèques de composants pour KiCad (kicadlib.org), mais celle qui contient des microcontrôleurs LPC de NXP n'a pas la gamme LPC12xx, et les quelques recherches que j'ai faites ne m'ont pas indiqué de bibliothèques existantes.

La deuxième solution consiste à utiliser l'éditeur de bibliothèques de composants [RefCard-2.8]. Dans l'éditeur, il faut créer un nouveau composant [RefCard-3.1], renseigner son nom (LPC1224FBD48), puis ajouter toutes les pattes du composant [RefCard-3.2] avec les bons noms et numéros (se référer à la documentation technique du composant), ajouter un « bord » à notre composant [RefCard-3.3] pour que le schéma reste lisible, puis le sauver dans une nouvelle bibliothèque [RefCard-3.4]. Cette étape étant quelque peu fastidieuse, même s'il est possible de partir d'un composant existant dans une autre bibliothèque, vous pouvez télécharger la bibliothèque de composants du projet DomoTab qui contient le composant LPC1224 (voir lien en fin d'article).

Comme il est important de bien organiser son travail, je vous propose d'enregistrer le fichier dans un répertoire Lib que vous pouvez placer dans le répertoire de travail, au même niveau que le répertoire du module.

Que l'on ait choisi de créer notre composant dans une nouvelle bibliothèque, ou que l'on ait téléchargé une bibliothèque qui l'inclut, il faut l'ajouter à notre projet [RefCard-2.9]. Cette étape n'est bien entendu nécessaire qu'en cas d'ajout d'une nouvelle bibliothèque. Les autres composants que vous créerez pourront être créés dans la même bibliothèque, ce qui permet de se constituer une bibliothèque perso, ou bien une bibliothèque par projet.

Figure 3 : Ajout de bibliothèques

Il faut tout d'abord ajouter le répertoire de travail aux chemins de recherche (partie basse de la fenêtre), puis ajouter la bibliothèque à la liste de bibliothèques du projet (partie haute de la fenêtre).

Insérez le microcontrôleur en utilisant l'une des méthodes présentées précédemment, en cherchant bien entendu dans la nouvelle bibliothèque, ou en utilisant le bon nom pour la recherche.

Note

Il existe aussi une page de création de composants en ligne créée par C. Rohrbacher [1], qui permet de créer le composant assez rapidement. Pour notre microcontrôleur, il faut sélectionner un boîtier PQFP, avec 12 pattes de côté (12 pour les champs W et H), puis sur la page suivante, remplir les noms des 48 signaux de notre composant à partir de sa documentation technique. L'inconvénient de cette méthode est de ne pas pouvoir organiser les pattes du composant comme bon nous semble, bien qu'il soit possible de faire cette modification après coup avec l'éditeur de bibliothèques de composants.

3.4 Il est tout plein de pattes !!

Quarante-huit pattes ça fait beaucoup, certes, mais en procédant avec méthode, on en vient vite à bout.

Lors de la création du composant, j'ai organisé les pattes de façon à faciliter son utilisation (dans une certaine mesure du moins), en mettant les alimentations en haut et les masses en bas. Intéressons-nous à ces éléments. Les alimentations s'ajoutent selon le même principe que les composants, mais avec l'outil adéquat [RefCard-2.10].

La documentation du microcontrôleur nous indique qu'il a besoin d'une tension d'alimentation entre 3,0 et 3,6 Volts (min et max). Le choix des symboles d'alimentation n'a pas réellement d'importance, mais pour plus de lisibilité, nous utiliserons les symboles « +3,3V » (à ajouter au-dessus du microcontrôleur) et « DGND » (pour la masse, à placer en-dessous).

Reliez les symboles d'alimentation au microcontrôleur avec l'outil « Fil », selon le principe représenté sur la figure 4. L'alimentation « +3,3V » doit être connectée aux pattes numérotées 3 (« VREF_CMP »), 44 (« VDD_3V3 ») et 47(« VDD_IO ») du microcontrôleur. Lorsque deux fils sont reliés, une boule verte doit apparaître à l'intersection des fils pour indiquer l'existence d'une liaison. Procédez de la même façon pour relier le symbole « DGND » aux pattes 43 (« VSS ») et 48 (« VSS_IO »).

Figure 4

Pour en finir avec l'alimentation de notre microcontrôleur, nous devons placer des condensateurs de découplage. Ces condensateurs serviront de « réserves d'énergie » pour lisser les variations de la tension d'alimentation et absorber d'éventuels pics de consommation du microcontrôleur que l'alimentation ne saurait pas satisfaire. Il en faut un par patte d'alimentation avec une valeur de 100nF, et un plus important, de 10uF, qui servira pour tout le module. Plutôt que d'ajouter de nouveaux composants, copiez un condensateur déjà placé en utilisant l'une des méthodes de copie de KiCad, qui permettent de copier un composant unique [RefCard-2.12] ou le contenu d'une sélection rectangulaire [RefCard-2.13]. Ces condensateurs doivent être reliés d'un côté à l'alimentation « +3,3V », et de l'autre à la masse dont on peut aussi copier le symbole.

Comme vous l'avez certainement remarqué, nous avons parlé de différentes valeurs de condensateurs (100nF et 10uF), mais tous nos condensateurs se ressemblent étrangement. Nous avons déjà traité le cas de la référence « P? » pour le connecteur UEXT (« C? » pour les condensateurs), et comme nous l'avions évoqué, KiCad offre une fonctionnalité d'annotation automatique, donc nous pouvons laisser les références de côté pour le moment. Nos quatre condensateurs ont un autre « C » affiché, qui correspond au champ « Valeur ». C'est ce champ qu'il faut modifier pour indiquer la capacité des condensateurs.

Il y a cependant deux « écoles » : indiquer la valeur du composant, ou indiquer la taille du boîtier du composant (voir encart). La deuxième solution a pour avantage de ne pas devoir créer de nouvelle version du schéma si les valeurs des résistances, condensateurs et inductances changent lors des tests, mais elle implique d'utiliser un second document (la nomenclature), qui indique la valeur de chaque composant (document souvent appelé BOM, pour Bill Of Materials), ce qui a tout de même pour avantage de faciliter l'étape d'association d'un boîtier à chaque référence. La première solution quant à elle permet de rendre le schéma plus simple à diffuser, les utilisateurs ayant directement accès aux valeurs calculées ou recherchées, et ils pourront donc facilement réutiliser ces informations pour leurs montages.

Personnellement, j'ai choisi une troisième solution. KiCad est assez bien fait et nous permet de renseigner tout de suite les deux champs « Valeur » et « Module ». Pour ce faire, éditez les propriétés d'un des condensateurs de 100nF [RefCard-2.7] et modifiez les champs « Valeur » (100nF) et « Module » (0402). Le champ « Module » n'est pas affiché par défaut, il faut le rendre visible en cochant la case correspondante. Vous pouvez aussi changer la taille des différents textes pour rendre le schéma plus lisible. Pour le condensateur de 10uF, choisissez un boîtier 0603, plus courant pour des condensateurs de cette capacité et plus simple à manipuler.

Pour éviter de devoir faire la même modification sur chaque condensateur que vous avez placé, je vous conseille de faire la modification sur un condensateur, puis de copier ce condensateur pour obtenir les suivants et enfin, supprimer les anciens.

Taille des boîtiers des composants

Pour que notre module tienne dans une taille raisonnable, nous utiliserons des composants CMS, qui se montent en surface de la carte électronique. Ces composants sont beaucoup plus petits et peuvent sembler très complexes à souder, voire impossibles, mais nous verrons plus loin deux techniques permettant de souder ces composants sans aucune difficulté et à moindre frais.

Les tailles des boîtiers des composants CMS de type résistances, condensateurs et inductances sont normalisées, et exprimées en millièmes de pouces. Un boîtier « 0402 » correspond à 40 millièmes de pouces en longueur et 20 millièmes de pouces en largeur ; cela équivaut à peu près à 1mm par 0,5mm. Les boîtiers les plus courants sont « 0402 », « 0603 », « 0805 », « 1206 » et « 1210 ».

Pour plus d'informations : http://wiki.jelectronique.com/cms.

3.5 On continue

Poursuivons avec deux parties essentielles pour un microcontrôleur, sans lesquelles un montage est inutile : les horloges et l'interface de programmation.

L'un des intérêts des microcontrôleurs de la gamme LPC de NXP est leur oscillateur RC interne (12MHz dans notre cas), pour lequel la documentation indique une précision à 1%, et qui peut être utilisé en entrée de PLL pour obtenir la fréquence qui nous intéresse. Cette précision est le plus souvent largement suffisante et nous pourrons donc nous passer d'oscillateur externe, ce qui nous fera gagner de la place. Cependant, pour information, le LPC1224 accepte un oscillateur externe principal entre 1MHz et 25MHz, et un second oscillateur à 32,768kHz pour l'horloge RTC interne.

Figure 5

Nous indiquerons donc que les broches correspondantes (1, 2, 45 et 46) ne seront pas connectées. Cela ce fait en plaçant un symbole de non connexion sur ces pattes [RefCard-2.15], représenté par une petite croix bleue.

Côté interface de programmation, les microcontrôleurs LPC de NXP peuvent être démarrés en mode « ISP » en reliant la patte 27 (« PIO0_12 ») du microcontrôleur à la masse. Pour pouvoir sélectionner ce mode facilement, nous allons utiliser un bouton poussoir connecté à cette patte et relié à la masse, car ce signal est actif « Bas ». Un second bouton poussoir sera relié à la patte « Reset » (28) et à la masse, le reset étant aussi actif « Bas ».

Pour que le microcontrôleur ne soit pas redémarré intempestivement, ou ne démarre pas tout seul en mode ISP, il faut placer des résistances de « Pull-Up » (10kOhms, en boîtiers « 0603 ») entre ses pattes et la tension d'alimentation « +3,3V ».

4. Et notre connecteur dans tout ça ?

Le premier composant que nous avons placé est notre connecteur UEXT, que nous avons négligé depuis. Le format UEXT étant spécifié par la société Olimex, nous n'avons pas beaucoup à réfléchir pour cette partie. Profitons-en pour explorer quelques outils et fonctions supplémentaires : les labels et les outils de tracé et de commentaires (un code bien commenté est un code facile à lire, il en va de même pour un schéma :))

Figure 6 : Connecteur UEXT

Comme pour les variables en programmation, il existe plusieurs types de labels ayant une portée différente. Je n'aborderai pas les labels hiérarchiques, dont je ne me suis jamais servi, et nous verrons donc les labels globaux, partagés par toutes les feuilles de schéma, et les labels locaux, qui n'existent que sur la feuille courante. Au-delà de cette particularité, les deux types de labels fonctionnent de la même façon et une fois placés sur le schéma, ils s'utilisent comme des composants, qu'il faudra relier par des fils.

Note

Les symboles d'alimentation sont en fait un cas particulier des labels globaux, avec une représentation spécifique.

L'utilisation de labels globaux pour affecter les signaux à notre connecteur UEXT a pour avantages de rendre le schéma plus lisible en évitant les fils qui se croisent, et de permettre le découpage en feuilles (en plus, ils sont plus jolis).

Lorsque vous placez un label global [RefCard-2.16], une boîte de dialogue s'ouvre et vous demande de saisir le nom et les attributs du label que vous voulez créer. Les attributs graphiques vous permettent de choisir l'orientation du label, mais aussi le type (entrée/sortie/bidirectionnel) de signal associé qui se traduit par la forme du label, ce qui sera une indication visuelle supplémentaire sur le schéma. Référez-vous à l'illustration de la figure 6 pour obtenir le même résultat pour les broches 3 à 10 du connecteur UEXT. Les noms des signaux n'ont pas d'importance, il suffira de rester cohérent par la suite, mais pensez aux noms de variables et donnez leur du sens !

Pour les pattes 1 et 2, il s'agit simplement des symboles d'alimentation « +3,3V » et « DGND ».

Utilisez l'outil de commentaire [RefCard-2.17] pour ajouter quelques indications à propos de ce connecteur. Le premier commentaire concernera les signaux Rx et Tx qui proviennent de l'hôte, et qui doivent donc être croisés : Rx du connecteur UEXT sur Tx de notre microcontrôleur et Tx sur Rx. Le second commentaire indique de quel côté devra être monté le connecteur selon le genre de connecteur choisi (mâle ou femelle). Pour donner plus de cohérence à ce bloc, j'ai décidé de l'inclure dans un cadre, tracé avec l'outil « Polyligne Graphique », qui permet de tracer des traits.

4.1 UART

Maintenant que nous avons mis un commentaire concernant les signaux Rx et Tx du connecteur, il serait peut-être temps de les relier au microcontrôleur. Attention : le LPC1224 dispose de deux liaisons série. Nous relierons donc les copies de nos labels à l'interface « UART0 », qui est celle utilisée pour programmer le microcontrôleur, et qui se trouve sur les pattes 16 et 17.

4.2 Bus I2C

Le raccord du microcontrôleur au bus I2C est assez simple. Les signaux I2C « SDA » et « SCL » se trouvent sur les pattes 25 et 26, auxquelles doivent être connectés les labels correspondants. Il est nécessaire d'ajouter une résistance de « Pull-Up » de 1,5 kOhms pour chacun des deux signaux.

4.3 Liaison SPI

Et enfin, pour la liaison SPI, il suffit de relier les pattes 29 à 32 aux copies des labels globaux correspondants. Notez qu'il est possible de ne pas faire ce lien si vous ne désirez pas utiliser cette interface, cela facilitera le routage du PCB. Dans ce cas-là, connectez tout de même le signal « SPI_CS » à une entrée du microcontrôleur, car ce signal sert aussi de « Module Select » dans le cas du DomoTab.

5. En avant la musique...

Nous avons interfacé notre microcontrôleur avec le connecteur UEXT, mais il ne sert pas à grand-chose sans les fonctions qui nous intéressent.

5.1 Jeux de lumière

Commençons par un petit ajout simple, toujours sympa et qui nous sera potentiellement très utile pour développer la partie logicielle par la suite : des LED.

Compte tenu du nombre d'entrées-sorties (GPIO) disponibles sur notre microcontrôleur, il serait possible d'ajouter une dizaine de LED tout en conservant suffisamment de GPIO pour la fonction principale du module, au détriment bien entendu du coût et de la place nécessaire sur le PCB.

Pour ma part, j'ai choisi de n'ajouter qu'une LED bicolore (tout de même) que l'on trouve dans la bibliothèque « device » sous le nom de « DOUBLE_LED ». Cette LED sera une KingBright KM-23ESGW en boîtier SOT-23. La cathode commune sera reliée directement à la masse, et les deux anodes seront reliées chacune à une résistance de 100 Ohms, elles-mêmes reliées aux pattes 40 et 41 du microcontrôleur.

Le choix de ces deux GPIO n'est pas dû au hasard, et est en fait le fruit des tentatives de routage successives de plusieurs modules. Lorsque vous êtes confronté à ce type de problématique, la première étape est de lister les GPIO utilisables parmi celles qui ne sont pas nécessaires à d'autres fonctionnalités de votre circuit (certaines fonctions ne sont disponibles que sur certaines GPIO). Notez sur votre schéma les options disponibles, puis choisissez-en une et n'hésitez pas à modifier ce choix si vous constatez lors du routage qu'il n'est pas le plus intéressant.

5.2 La température monte

Poursuivons avec l'ajout d'un capteur de température. Il n'y a aucun risque que notre microcontrôleur surchauffe, mais dans le cadre d'une installation domotique, cela permettra de faire des relevés de température sans devoir ajouter de modules spécifiquement pour cette fonction.

La première étape, et certainement la plus compliquée, est de choisir le composant. Il existe de nombreux types de capteurs, qui s'interfacent de différentes façons. Pour restreindre le choix, nous utiliserons un capteur interfacé en I2C, avec une précision de mesure à +/- 0,5°C qui sera suffisante puisqu'il s'agit de lire la température ambiante d'une pièce.

Figure 7 : Capteur de température

L'un des critères importants est la taille, car plus nous ajouterons de fonctions à notre montage, moins nous aurons de place sur le PCB. En cherchant sur le site de Farnell, j'ai trouvé le TMP101 de Texas Instruments, un capteur en boîtier SOT23-6 qui occupera seulement 3mmx3mm sur la carte. Son prix reste raisonnable, même s'il est plus cher que le TMP100, mais il dispose d'une sortie « Alert » qui permet de générer une interruption lorsque la température franchit un seuil défini, ce qui permettra de « réveiller » notre microcontrôleur en cas de besoin, et de ne consommer que très peu le reste du temps, très intéressant pour une application domotique.

Comme pour le microcontrôleur, il est nécessaire de créer la définition du composant dans notre bibliothèque. Il faudra cependant faire attention, car la documentation donne les indications pour deux versions du composant : le TMP100 et le TMP101, la patte numéro 3 n'ayant pas la même fonction sur les deux versions.

Une fois le composant créé, il faut le placer sur notre schéma (quelque part ou il y a de la place) et le connecter au reste. Un exemple est fourni dans la documentation, mais pour cette fois, nous aurions pu nous en sortir comme des grands. Nous utiliserons les labels globaux pour les connexions au bus I2C, une copie d'un des condensateurs de découplage du microcontrôleur pour le découplage de l'alimentation de notre capteur, et une copie d'une des résistances de « Pull-Up » pour celle nécessaire pour le signal « Alert », tel qu'indiqué dans la note sur le schéma de la documentation.

Il ne nous reste qu'à choisir où connecter le signal « Alert ». Pour pouvoir être réveillé d'une veille profonde par ce signal, la documentation du microcontrôleur indique que nous devons le connecter sur l'une des entrées « PIO0_0 » à « PIO0_11 ». J'ai choisi le signal « PIO0_7 » (patte 22). Pour simplifier la lecture du schéma, j'ai utilisé un label pour ce signal et ainsi évité de faire courir un grand fil à travers tout le schéma.

5.3 Découpage

L'autre avantage lié à l'utilisation d'un label est que notre capteur de température n'est pas relié au reste de notre schéma par des fils. Il va donc être possible de découper le schéma en « feuilles », comme un programmeur découperait un code source en fichiers (chaque « feuille » de schéma est d'ailleurs un fichier séparé). Il faut pour cela que le label du signal « Alert » soit un label global.

Figure 8

Pour découper le schéma, il faut commencer par ajouter une feuille hiérarchique [RefCard-2.18]. Pour chaque feuille, il faut spécifier un nom de fichier et un nom de feuille.

Il faut désormais déplacer notre morceau de schéma sur la nouvelle feuille. Sauvez tous les éléments qui sont rattachés à notre capteur de température [RefCard-2.19], puis passez sur la nouvelle feuille [RefCard-2.20] et collez le morceau de schéma que vous avez sauvé [RefCard-2.21]. Une fois les éléments placés, revenez sur la feuille précédente pour supprimer les éléments que vous avez copiés.

Copie entre projets

Pour copier un élément de schéma entre deux projets, vous pouvez soit passer par une feuille (un fichier) temporaire que vous inclurez dans le nouveau projet, soit utiliser cette méthode de « sauvegarde » : sélectionner le bloc qui vous intéresse, le sauver, ouvrir le schéma de destination, puis coller les éléments sauvegardés comme nous l'avons fait ici.

5.4 On est de sortie

Nous avons créé un module de développement fonctionnel, mais inutilisable comme plateforme de test si l'on n'a pas accès aux GPIO du microcontrôleur.

Figure 9 : Accès aux GPIO

Pour ma part, j'ai décidé de donner accès à six des entrées analogiques (« AD0 » à « AD5 ») et à 18 des autres GPIO, toutes sur le port 0 (PIO0_*) : « 0, 3 à 6, 8, 9 et 19 à 29 ». À tout ceci, j'ai ajouté deux broches à la masse (« DGND »), une broche à « +3,3V » et une broche à « +5V » (en provenance de l'USB). Le tout a été réparti sur deux connecteurs « CONN_1x10 », un connecteur « CONN_1x6 » et un connecteur « CONN_2x1 » (Voir figure 11).

Encore une fois, les labels nous évitent de tracer des tas de fils, mais pour bien les différencier des autres signaux/labels, j'ai choisi des labels locaux. Je dois vous avouer que l'affectation sur les connecteurs a été revue à plusieurs reprises.

Pour permettre une utilisation plus souple des entrées analogiques, j'ai aussi ajouté un jumper (« JP1 » dans la bibliothèque « domotab ») entre la patte « VREF_CMP » (3) du microcontrôleur et l'alimentation, ce qui n'impose pas le « +3,3V » comme tension de référence.

6. Poursuite des festivités

6.1 Versions et sauvegardes

Avant de passer à l'étape suivante, je voudrais aborder rapidement un point important : les sauvegardes et la gestion de versions. En dehors du fait d'enregistrer le schéma en cours de création, KiCad n'offre aucune fonctionnalité spécifique pour la sauvegarde et la gestion de versions. Ceci dit, ce n'est pas son boulot, et KiCad a un avantage énorme sur certains produits qui tentent de le concurrencer, de par l'utilisation de simples fichiers texte à la place des formats de données obscurs.

Cela vous permet de conserver votre outil préféré (remplir avec le nom de votre outil préféré) pour suivre les versions de votre (ou vos) schéma(s), créer des branches, les partager avec d'autres, travailler à plusieurs, bref, les choses de la vraie vie quoi.

6.2 Évitez les étincelles

Notre circuit est théoriquement fonctionnel, mais il est important de le tester ! Toujours en prenant de très grandes précautions bien entendu !

Le circuit présenté dans cet article n'a pas été créé tel quel du premier coup, et la première version n'a pas résisté aux tests. La version originale incluait une partie en lien avec le secteur (220V) qui sera présentée dans un autre article et, outre la création d'un joli stroboscope en essayant de piloter un triac à l'aide d'un montage utilisant un opto-coupleur à la place d'un opto-triac, j'ai aussi transformé une résistance en LED pyrotechnique, d'un beau rouge vif, avec des petites étincelles à la surface.

L'idéal est de pouvoir tester les composants que l'on va réellement utiliser, même lorsqu'il s'agit de composants CMS. Il est parfaitement possible de souder les résistances, condensateurs et autres tout petits composants simples jusqu'à 4 pattes sur des plaques de test en résine avec des pastilles. Pour les composants CMS avec plus de pattes, vous pouvez soit leur souder des « rallonges » avec des morceaux de pattes de résistances ou des fils fins (les fils fins évitent les courts-circuits et évitent de tordre et casser les pattes), soit utiliser des cartes de prototypage de Roth Elektronik, qui propose une gamme complète d'adaptateurs CMS vers broches au pas de 2,54mm, mais à un prix parfois conséquent, entre 10 et 40 euros.

Les tests sont aussi l'occasion de vérifier les valeurs des composants que nous avons choisis. Est-ce qu'un condensateur de 47uF est nécessaire ? Est-ce qu'un condensateur de 22uF ne serait pas suffisant ? Cette résistance de « Pull-Up » est-elle vraiment nécessaire ? Et ce filtre ? Bref, ce sont autant de questions qu'il faut se poser pour tester chaque partie de notre circuit et peut-être le simplifier, ou tout simplement le corriger pour qu'il n'explose pas !

Un appareil qui mesure la consommation est un plus. Si votre circuit consomme 6W quand il devrait en consommer moins d'1, c'est qu'il y a un problème quelque part et que certains composants risquent de vouloir copier ma résistance pyrotechnique.

6.3 Vérification

Pour notre œil humain, notre schéma est terminé (après quelques modifications éventuelles suite aux tests), mais quelques éléments peuvent nous échapper.

KiCad intègre un outil de vérification (tests ERC), qui passe en revue un certain nombre de règles de conception (que l'on peut changer dans l'onglet « Options » de la boîte de dialogue de l'outil). Pour qu'il fonctionne, il est nécessaire d'avoir annoté tous les composants, ce qui peut être fait à la main, ou avec l'outil d'annotation automatique [RefCard-2.6]. Les options de l'outil d'annotation automatique sont assez simples à comprendre et les choix par défaut sont utilisables, je vous laisse donc découvrir les différentes options.

Lors de la première exécution des tests ERC ([RefCard-2.23]), nous obtenons des erreurs « Pin non connectée ». En effet, nous n'avons pas mis de symboles de non connexion sur les pattes non utilisées du microcontrôleur. Cet oubli est vite corrigé en ajoutant des symboles « non connexion » sur les pattes correspondantes.

En relançant la vérification, il ne devrait rester que quelques erreurs de type 3 : “Pin connectée à d'autres pins, mais aucune pin pour la piloter ». Ces erreurs signifient que certaines des pattes de nos composants ne sont pas reliées correctement par rapport à ce que les composants déclarent dans leur définition. Typiquement, cela se produit pour certaines pattes d'alimentation ou de masse (GND) des composants définissant des entrées d'alimentation (« power input ») lorsque nous les relions à des symboles d'alimentation (« DGND », « VCC » …), qui sont eux aussi définis comme des entrées d'alimentation. La solution idéale serait de disposer de composants définissant des sorties d'alimentation, mais le plus simple est de laisser ces erreurs qui ne sont d'ailleurs comptabilisées que comme avertissements dans le compte des erreurs. Attention cependant, ne laissez pas d'autres erreurs et vérifiez pour chacun de ces avertissements que les pattes concernées sont bien reliées correctement à un symbole d'alimentation !

Glossaire

CAD : Computer Assited Design

CMS : Composant Monté en Surface

UART : Universal Asynchronous Receiver and Transmitter (liaison série asynchrone)

PCB : Printed Circuit Board (circuit imprimé)

BOM : Bill Of Materials (nomenclature)

Liens

UEXT : https://www.olimex.com/Products/Modules/UEXT/

KiCad : http://www.kicad-pcb.org/

NXP : http://www.nxp.com/

Techno-Innov : http://www.techno-innov.fr/

Crazyflie : http://www.daedalus.nu/ et http://www.bitcraze.se/

[1] http://kicad.rohrbacher.net/quicklib.php