[Tuto KiCad] Concevoir un circuit imprimé partie 1: le schéma

Salut les poilus!

Il y a un bon moment ce ça (oh la vache oui, été 2012), j’avais écrit cet article sur Fritzing.

C’est vrai que Fritzing c’est bien. Mais dès qu’on doit utiliser des composants qui ne sont pas dans sa bibliothèque, c’est vite TRÈS lourd. Il faut créer le composant, créer son empreinte au format SVG, et disons-le franchement: les interfaces de création ne sont pas géniales et j’ai autre chose à faire que de passer une heure à créer un relais ou quoi que ce soit d’autre.

J’avais testé vite fait KiCad et j’avais vite abandonné car pour le coup, Fritzing était plus facile à prendre en main. Mais frustrant. Mais plus facile à prendre en main. Alors bon.

Récemment j’ai attaqué la conception d’un circuit imprimé sur lequel sont implantés:

  • Une Teensy 3.2
  • Un lecteur de carte MicroSD
  • Un écran OLED

Et connaissant Fritzing et ses limitations, je n’ai même pas osé le démarrer et je me suis mis sérieusement à KiCad.

Héééé ben franchement je vais vous dire:

  1. ce n’est pas si compliqué
  2. je relègue définitivement Fritzing au placard, en le remerciant pour les services qu’il m’a rendus.

Avec KiCad, on a un véritable outil de conception de circuits imprimés, avec aussi sa bibliothèque de composants (fatalement limitée), mais quel plaisir de pouvoir créer un nouveau composant en 5 minutes s’il n’existe pas dans la bibliothèque de base!

Le truc avec KiCad, c’est que la prise en main n’est pas hyper intuitive au tout départ. Mais une fois qu’on a pris le temps de comprendre les quelques concepts de base, c’est tellement bon… Et c’est ce que je vais vous expliquer ici.

Pour aller plus loin évidemment, il y a la documentation officielle de KiCad

Créer un projet

KiCad manipule plusieurs types de fichiers, selon la tâche à effectuer (typiquement les schémas électroniques et les implantations physiques de composants). Tous ces fichiers sont regroupés dans un répertoire de projet.

La première étape, quand on veut concevoir un circuit, et donc de créer un projet: Fichier/Nouveau projet/Nouveau projet, et nous l’appelerons tuto-dm.

Dans le répertoire, il crée automatiquement 3 fichiers: tuto-dm.pro, tuto-dm.sch et tuto-dm.kicad_pcb.

Créer le schéma électronique

Pour ce tuto, nous allons créer un circuit imprimé contenant un atmega128 (DIP), un driver de moteur pas à pas Pololu A4988, et disons une LED et sa résistance. Le but de ce tutoriel n’est pas de réaliser un projet fonctionnel, mais d’apprendre les bases de la conception dans KiCad.

On va donc maintenant rentrer dans le dur, et créer notre schéma. Pour cela, dans KiCad, double-cliquons sur tuto-dm.sch

Nous avons droit à un bel écran de dessin technique, avec un cartouche en bas (spéciale dédicace aux cours de techno du collège).

Deux barres d’outils : à gauche, des options d’affichage (j’ai envie de dire: rien à péter pour l’instant); à droite, ce qui va nous intéresser: la barre d’outils de dessin.

Parmi les outils, trois vont nous intéresser:

  • le triangle avec les signes + et – (oui, c’est un ampli op! Bonne réponse de l’amiral) permet de placer des composants sur le schéma.
  • le symbole de masse nous permet de placer des symboles de type « power », c’est à dire tout ce qui est relatif à l’alimentation.
  • le segment vert permet de placer des fils, autrement dit de relier les composants entre eux.

Petite note sur le déplacement dans la vue:

  • Clic milieu + déplacement de la souris: panning
  • Molette : zoom

Placement des composants

Cliquons sur l’icône « placer un composant », puis quelque part sur le dessin. Une fenêtre s’ouvre, pour nous demander quel composant insérer.

Dans le champ de filtre, nous allons taper ATMEGA328, et sélectionner le premier de la liste (ATMEGA328-AU) en double-cliquant dessus. On peut positionner le microcontrôleur avec la souris, et cliquer pour valider.

Plaçons maintenant notre led et sa résistance. KiCad est encore en mode « placer un composant », donc il suffit de cliquer quelque part sur le schéma pour rouvrir la fenêtre de sélection de composant.

Dans le filtre, tapons R, et double-cliquons sur le 1er résultat :R [Resistor]. Avant de positionner la résistance, on peut la faire pivoter en appuyant sur la touche R du clavier (Rotate). Mettons-la à l’horizontale, et plaçons la à côté de la pin PB1 de l’ATMEGA328.

Même topo pour placer la LED (LED_GENERIC), et nous allons la positionner à côté de la résistance. Si vous avez déjà placé un composant et que son sens n’est pas bon, pas de problème! Il suffit de positionner le curseur de la souris au-dessus (pas besoin de cliquer) et d’appuyer sur la touche R du clavier jusqu’à obtenir l’orientation correcte.

Normalement on devrait en être là:

Placement des alimentations

Pour KiCad, une alimentation est un composant spécial, accessible avec le bouton

On va commencer par placer les masses à côté de la led, et l’ATMEGA328.
Cliquer sur [], et chercher GND dans la liste. Placer les différentes masses, et répéter l’opération pour le 5V sur l’ATMEGA328.

Votre schéma ressemble à ça? Très bien.

Création de composants personnalisés

Ok, donc il ne nous manque plus que le Pololu A4988. Cliquons sur le schéma, puis dans le filtre: POLO… Ah non. A49… Non plus.
Aha, je vous ai bien eus hein 😀

Ce serait trop facile…

Bon, hé bien il ne reste plus qu’à le créer puisqu’il n’existe pas en standard! z’allez voir, ça n’a rien de méchant.

On va commencer par cliquer, dans la barre d’outils du haut, sur le bouton « Editeur de librairie – créer et éditer des composants »

Arrive une page blanche, sur laquelle nous allons pouvoir dessiner notre Pololu A4988 dans sa version schématique.

Cliquons sur le bouton « Créer un nouveau composant »

  • Nom du composant »: POLOLU_A4988
  • Référence par défaut: DRV (Totalement arbitraire. DRV = Driver)

Laissons les autre champs tels quels et cliquons sur OK.

A l’écrans, nous avons maintenant deux blocs de texte superposés, que nous allons arranger un peu.

C’est l’occasion d’apprendre comment déplacer des éléments dans KiCad!
Il suffit de placer la souris au-dessus du texte, et appuyer sur la touche M. A partir de là, on peut déplacer le composant avec la souris, et quand c’est bon, on clique. C’est tout 🙂

Avant de créer les connexions, on va juste ajuster la grille avec un clic droit, Sélection grille, et sélectionner 2.54mm.

Ok, maintenant créons les 16 connexions de notre A4988, en commençant par la rangée de gauche(de haut en bas), puis la rangée de droite(de bas en haut). Pour rappel, voici un Pololu A4988 dans son milieu naturel:

http://www.arduino-projekte.de

Sur la barre d’outils de droite, cliquons sur le bouton Ajouter des pins au composant , puis quelque part sur la page. Pas d’inquiétude pour le positionnement du composant par rapport à l’origine, on pourra le replacer plus tard.

Après avoir cliqué sur la page, une fenêtre s’ouvre et nous demande plus d’informations sur la pin à créer.
La première s’appelle ENABLE avec une barre au-dessus (pour dire que le driver est activé si elle est à zéro volt). Dans le champ nom pin, tapons ~ENABLE~, les ~ servant à afficher la barre au-dessus du texte.

Numéro de pin: 1
Orientation: Droite
Type: Entrée

Clic sur OK, clic sur la page et hop! La première pin est créée.
Et on enchaine avec les suivantes:

Nom: MS1
Numéro de pin 2

Nom: MS2
Numéro de pin 3

Nom: DIR
Numéro de pin 8

C’est bon?

Alors avant de tout casser, nous allons sauver ce composant.
Il faut d’abord créer une librairie qui va le contenir: cliquons sur « Sauver le composant dans une nouvelle librairie ». On va parcourir le disque jusqu’à trouver le répertoire de notre projet et sauver sous le nom « pololu_a4988.lib ». Au message qui suit, répondons OK, puis allons dans le menu Préférences/Librairies de composants. Dans la liste du haut, cliquer sur Ajouter, et sélectionner le fichier pololu_a4988.lib fraichement créé. Bien!

Cliquons enfin sur « Sélection de la librairie de travail », et dans le filtre: pololu. Valider en double cliquant sur pololu_a4988.

Là, on est bien!

Allez, on va créer les 8 pins de droite en commençant par en bas. Plus aucune difficulté maintenant! Pensez juste à changer l’orientation des pins 😉

Nous n’avons plus qu’à dessiner un rectangle autour du Pololu, ramener les textes à côté avec la touche M, sauver avec un petit Ctrl+S et hop! C’est terminé.

On peut fermer l’éditeur de composant et revenir à notre schéma principal. Maintenant, si on clique sur « Placer un composant », dans la liste nous trouverons notre Pololu A4988. Plaçons-le à côté de l’ATMEGA328, sa pin 8 faisant face à la pin 11 de l’ATMEGA328.

N’oubliez pas d’alimenter le Pololu avec +5V et GND.

Liaison des composants

Bien! Nous avons placé nos composants, il faut maintenant câbler le schéma.

Commençons par cliquer sur le segment vert dans la barre d’outils de droite (placer un fil).
Le fonctionnement est simple: clic 1 sur la pin 1, clic 2 sur la pin 2. Les clics intermédiaires permettent d’ajouter des coudes au fil.

On va relier comme ça la résistance à la pin 13, la résistance à la LED, et les alimentations.

Assignation de valeurs aux composants

En regardant le schéma, on se rend compte que la valeur de la résistance n’a pas été définie. Nous allons placer la souris au-dessus de la résistance, et appuyer sur E (Edition).
Une fenêtre s’ouvre et nous propose (entre autres) de donner une valeur au composant.

Si jamais un menu « Clarification sélection » s’affiche, sélectionner « Champ valeur » et indiquer 220.

Bilan

Et voilà, après avoir raccordé le pololu à l’ATMEGA328, vous devriez avoir un schéma similaire à celui-ci.

Allez, ça ira pour l’instant 🙂

Prochaine étape: le circuit imprimé!

Produire un circuit imprimé avec des zones de Voronoï

Je voulais faire un circuit imprimé pour le CoreXY, pour pouvoir ranger mon petit bazar dans un boitier propre et libérer ma plaque d’essais.

Le truc, c’est que ma fraiseuse CNC souffre d’imprécision… Et comme je dois tracer des pistes et pastilles pour les Pololu (connecteurs espacés de 2.54mm), j’ai un peu peur du résultat…

Et je n’ai toujours pas envie d’utiliser des produits chimiques.

Alors j’ai investigué et j’ai trouvé une technique redoutable de production de PCB, qui devrait être capable de compenser l’imprécision de la machine : les diagrammes de Voronoï.

L’idée est, plutôt que de tracer les contours précis de chaque piste et pastille, d’aller « au plus large », et isoler uniquement les zones nécessaires. Un dessin vaut mieux qu’une longue histoire:

voronoi pcb
Le circuit à graver

Les lignes fines qu’on voit entre les pistes sont celles qui vont être fraisées. Après tout, on n’a pas besoin de faire le tour de toutes les pistes avec précision pour les isoler les unes des autres.

1. Conception du circuit

J’ai tout d’abord conçu mon petit montage avec Fritzing.fritzingJ’y ai mis mes deux pololu, des connecteurs pour les moteurs, les alimentations et le signal.

On bascule en mode « circuit imprimé », simple couche. Avec l’autoroutage (ou pas… mon circuit était autorouté d’une façon très bizarre), on met en place les pistes de cuivre.

fritzing-pcb
Je n’ai pas pu éviter un jumper…

2. Export au format Gerber

Depuis le menu fichier>exporter pour la production>gerber étendu, nous pouvons exporter le circuit imprimé au format Gerber. On obtient un répertoire avec une tapée de fichiers, dont deux nous intéressent particulièrement : pcb_corexy_copperBottom.gbl et pcb_corexy_drill.txt.

Le premier contient les traces du circuit imprimé, et le second les coordonnées des trous à percer (en pouces… sympa les gars).

3. Traitement du fichier Gerber avec Visolate

Traumflug, un membre très actif de la communauté Reprap et coauteur de Teacup, a écrit un programme en java qui permet de générer des zones de Voronoi à partir d’un fichier Gerber.

Après avoir téléchargé Visolate, ouvrons notre fichier gbl.

visolate-1

Les pistes et les pastilles apparaissent, avec des couleurs j’te dis même pas. Bariolées. Chaque couleur correspondra à une zone de Voronoi. La première étape est donc de réunir ce qui doit être réuni, avec le bouton « fix topology ». Avant de cliquer, il faut zoomer un peu avec le slider « dpi ». Le programme va scanner le circuit et réunir les zones de notre circuit imprimé.

visolate-2Cool! Maintenant, cliquons sur « make toolpaths »: Visolate génère les parcours d’outil pour fraiser les zones de Voronoi. Il n’y a plus qu’à enregistrer le fichier avec « save G-Code » et on est paré. Enfin presque.

visolate-3

4. Génération du G-Code de perçage

Comme je le disais au-dessus, Fritzing génère les coordonnées des perçages en pouces. Il faut faire la conversion en mm. Ou basculer la machine en mode pouces. J’ai opté pour la conversion en mm.

Le fichier des perçages a cette allure:

[code]

; NON-PLATED HOLES START AT T1
; THROUGH (PLATED) HOLES START AT T100
M48
INCH
T100C0.038000
T101C0.041667
T102C0.035000
%
T100
X015681Y004991
X017681Y012991
X015681Y014991
X017681Y009991
X015681Y005991
X017681Y013991
X015681Y015991

etc.

[/code]

J’ai fait un programme qui convertit cette suite de coordonnées en G-Code, et en millimètres s’il vous plait : GerberDrill.

Désolé pour l’interface utilisateur toute pourrie… Le principe est simple: parcourir pour aller chercher le fichier drill.txt, définir le code à générer pour chaque trou et cliquer sur « Process drill file ». Le programme génère du G-Code pour se rendre à l’emplacement du trou, et percer à la profondeur indiquée.

5. Concaténation des deux fichiers G-Code et miroir

Je voulais tout faire d’une traite, c’est à dire fraiser les zones de Voronoi et marquer les points de perçage (puis percer à la main avec une mèche de 1mm avec la Dremel).

Donc dans un fichier texte, j’ai mis à la suite le G-Code généré par Visolate et celui généré par mon programme GerberDrill.

Etape importante : il faut mettre un effet miroir sur le G-Code, car la gravure va se faire sur la face inférieur du circuit. Pour cela, dans le fichier G-Code, remplacer tous les « X » par « X-« .

On enregistre le fichier et zou! balance la purée papa!

Le jeu de ma machine se remarque particulièrement au niveau des points de perçage, lorsqu’ils sont près d’une trace. J’ai dû les arranger à la cochon en en élargissant quelques uns… Hélas je n’ai pas pris de photo de la plaque juste après la gravure, mais voici la vue de dessous une fois les éléments soudés:

Désolé pour les soudures dégueulasses...
Désolé pour les soudures dégueulasses…

La prochaine fois je pense que je marquerai les perçages avant de faire les isolations. En tout cas j’ai bien contrôlé au multimètre et ça a l’air bon.

PCB CoreXY
Les connecteurs soudés
PCB CoreXY avec drivers
Les pololu montés

On peut voir à gauche les connecteurs pour les signaux step et direction. A droite les deux connecteurs de moteurs, et les deux connecteurs d’alimentation (5V en haut pour la logique, et 12V en bas pour les moteurs).

Il n’y a plus qu’à connecter la carte, mettre le jus et en avant!

Découverte du microcontrôleur ATTINY45

Je viens de recevoir une commande de chez Farnell : deux microcontrôleurs Atmel ATTINY45, deux modules XBee, et une caméra pour brancher sur mon Raspberry Pi.

Depuis un certain temps, je réfléchissais à une façon de faire pour programmer un microcontrôleur et l’utiliser dans un projet sans pour autant acheter à chaque fois une carte Arduino.
En fait, on peut utiliser toute une gamme de microcontrôleurs Atmel « nus », les programmer à l’aide d’une Arduino et les utiliser tels quels!

Pour les curieux, voici tous les produits fabriqués par Atmel (ça ne s’arrête pas aux microcontrôleurs).

Bref! Voyons comment utiliser notre carte Arduino Uno pour programmer le ATTINY45. La mise en place est relativement rapide.

D’abord, un grand merci à HighLowTech pour cet article.

L’idée de base, c’est d’utiliser une Arduino (dans mon cas, Uno) qui va servir d’interface entre le PC et l’ATTINY45. Manque de bol, depuis la version 1.0 de l’IDE Arduino, les puces ATTINY ne sont plus au menu :

Pour pouvoir les utiliser, il faut aller chercher ici (pour la version 1.0 ou 1.5, selon la version de l’IDE).

Une fois le zip récupéré, il faut créer un répertoire hardware dans votre dossier de sketches (donc pour moi, C:UsersnicoDocumentsArduinohardware). Dans ce dossier hardware, copier le dossier tiny trouvé dans le zip. On y est presque.

Dans le dossier tiny, il y a un fichier nommé Prospective Boards.txt. Renommons-le en boards.txt tout court.

On relance l’IDE, et là :

Yeaaaah baby! En fait, dans le fichier boards.txt, on peut commenter toutes les puces ATTINY dont on ne veut pas se servir, ça évite de polluer cette liste.

Voilà pour la préparation logicielle 🙂

Maintenant, préparons le matériel:

tuto-programmation-des-attiny45-avec-un-arduinoJ’ai honteusement repris le schéma réalisé par Semageek.com. Allez-y, ça vaut le coup!

Voici le schéma de brochage de l’ATTINY45:

Pour le condensateur connecté au reset de l’Arduino Uno, je n’avais pas de 10µF, alors j’ai utilisé un 33µF qui va tout aussi bien.

Prêts? Alors dans l’IDE, chargeons l’exemple ArduinoISP. Nous voulons l’envoyer sur la Uno, donc type de carte > Arduino Uno.

On envoie le programme, et là… Problème de synchronisation. Hé hé hé 🙂 La blague, c’est qu’il faut enlever le condensateur pour pouvoir envoyer un programme 😉

Voilà, l’Arduino Uno est maintenant utilisable comme programmateur pour notre ATTINY!

Nous pouvons reconnecter le condensateur, et dans l’IDE, définir comme type de carte : ATTINY@1MHz, et comme programmateur : Arduino as ISP.

Chargeons un programme d’exemple, disons Fade. On va juste changer le pin de la LED, mettons le sur 0. On upload le programme. Dans les messages de l’IDE Arduino, on peut lire ceci :

En fait, ce message, selon des gens avertis, on peut l’ignorer (je ne sais pas vous, mais moi j’ai bien envie de les croire).

Voici une superbe photo pour illustrer cela!ATTINY45-2J’ai connecté la LED bleue au pin 0 (broche 5) de l’ATTINY45. Et elle clignote en mode ‘fade’ 🙂

Pour être sûr, j’ai tout déconnecté (en me servant juste de la Uno comme alimentation :

ATTINY45-1Et ça marche toujours!

Reste maintenant à trouver des applications pour cette bestiole de 4Ko de mémoire, avec ses 3 entrées analogiques et 2 sorties PWM; je suis certain que ça me viendra 🙂

Un grand merci spécial à Michael, Farnell, Semageek et HighLowTech!

Fritzing, c’est génial

Je me demandais comment créer le schéma du montage pour mon test d’afficheur LCD, et sur le site d’arduino, j’ai trouvé FRITZING.

C’est top! Fritzing permet de concevoir ses schémas et propose 3 vues :

  • Platine d’essai (vue « réaliste »)
  • Schéma électronique
  • Circuit imprimé

Je n’ai pas tout exploré, mais voici donc le branchement pour mon écran LCD.

Attention, derrière mon afficheur, il y a un controleur qui permet d’utiliser seulement 3 fils. Dans la vue, j’ai donc simulé 3 fils (alimentation et fil pour la communication série).

Fabriquer un thermomètre / baromètre / altimètre avec Arduino, 2ème partie

Nous avons câblé le capteur, il ne reste plus qu’à écrire le programme qui nous permettra d’obtenir la température, la pression atmosphérique et l’altitude.

La première chose à faire, c’est de pouvoir communiquer avec le module BMP085. Nous aurons besoin de 2 fonctions de lecture, pour lire respectivement des valeurs de 8 et 16 bits.

Nous sommes à présent capables de lire des valeurs du module. Cool! On va en avoir besoin pour lire les 11 coefficients de calibration, stockés dans l’EEPROM du BMP085. Ces valeurs vont nous permettre de calculer la pression absolue. Il suffit de les lire une seule fois, au début du programme. Nous allons les mettre dans la fonction setup().

 

Une fois que les valeurs de calibration sont lues, il nous faut encore deux variables pour calculer la température et la pression : ut et up. Ce sont les valeurs de température et pression non compensées, notre point de départ pour déterminer les valeurs réelles de température et pression. A chaque fois qu’on veut obtenit la température ou la pression, il faut lire au préalable ces valeurs.

La température non compensée est sur 16 bits (type int), la pression sur 32 bits (type long).

 

Dans ces deux fonctions, nous utilisons la fonction delay() pour laisser le temps au BMP085 de terminer ses traitements.

Le paramètre d’oversampling (OSS) indique au capteur de calculer une moyenne de plusieurs mesures, afin d’avoir une précision accrue. Ici, il est désactivé.

La durée d’attente est le maximum indiqué dans le datasheet du module, mais nous pourrions à la place nous baser sur le pin EOC (End Of Conversion) pour connaitre avec précision le moment où le BMP05 a terminé de lire les données. Tant qu’il travaille, le pin EOC est à l’état LOW, et dès qu’il a terminé, il passe à HIGH.

 

Nous avons toutes les variables requises pour calculer la température et la pression. Dans le datasheet, une formule assez cool nous donne la température, et une autre, beaucoup, beaucoup plus barbue, nous donne la pression.

Merci à Jimbo, chez Sparkfun, d’avoir transcrit tout ça en C, ça fait vraiment plaisir 🙂

 

Bon alors là, on est pas mal ! Encore une fonction pour calculer l’altitude à partir de la pression :

 

 

Calculons tout ça dans la boucle principale, et envoyons les résultats dans le port série:

 

 

Et voilà la sortie, au chalet, par cette soirée de février :

Ce qui est assez réaliste aujourd’hui, puisqu’on estime être à 930 m rééls. Mais selon la météo, on se retrouve dans une fourchette de 870 à 1000 et quelques…

 

Je tiens une fois encore à remercier l’article de SparkFun, dont cet article est essentiellement une traduction. Je vous invite à le lire pour plus de précisions. Sans lui, je me serais tapé la tête contre le lambris… J’y serais probablement arrivé, mais en beaucoup plus de temps 🙂

 

Fabriquer un thermomètre / baromètre / altimètre avec Arduino

Ça y est, j’ai reçu mon Arduino Uno ! Je l’ai commandée chez Lextronic, livrée en 1 semaine et demie.

Dans la foulée, comme ces salopards n’offrent pas les frais de port, même pour une commande de plus de 100€, je me suis équipé en capteurs et composants divers pour amortir lesdits frais de port.

En même temps, me direz-vous, à quoi servirait une carte Arduino sans capteurs et composants divers? A rien. Bon, on est d’accord.

Du coup, j’ai commandé un capteur qui fait thermomètre et baromètre, le BMP085.

Et l’altimètre dans tout ça ? Hé bien il existe une formule qui lie la pression atmosphérique à l’altitude, elle est présentée ici.

Comme on peut le constater, cette formule utilise une pression de référence de 1013,25 hPa au niveau de la mer. Ce qui signifie que l’altitude calculée ne pourra jamais être précise et va inexorablement varier, car nous ne vivons pas dans une bulle avec une pression régulée…

Par beau temps, l’altitude calculée sera inférieure à celle calculée par mauvais temps (anticyclone vs. dépression).

Mais bon, nous ne cherchons pas à connaitre l’altitude au mètre près! Sinon, il faut s’orienter vers un module GPS, qui fournira une information bien plus précise sur l’altitude. Maiiiis pas la température ni la pression atmosphérique. Faut faire des choix dans la vie.

La carte Arduino et le module BMP085 vont discuter selon le protocole I2C, et c’est la classe Wire fournie dans la bibliothèque d’Arduino qui va nous aider dans cette discussion.

Avant tout, je tiens à préciser que les informations proviennent essentiellement du tutorial du BMP085, chez SparkFun. Je me suis hautement appuyé sur eux pour mettre en place ce montage.

Alors en fait, le capteur possède une petite EPROM qui contient des valeurs d’étalonnage. Ces valeurs vont nous servir de référence pour calculer les valeurs réelles de pression et température.

Pour extraire ces valeurs de référence, avec la librairie Wire, on donne l’adresse de la valeur dans l’EPROM, le nombre d’octets à extraire(typiquement 1 ou 2) et hop.

 

Prêt ? on y va.

Alors tout d’abord, commençons par le montage. Il faut alimenter le capteur, mais alors attention: la tension maximale acceptée est de 3.6V ! Utilisons donc la tension régulée à 3.3V fournie par notre carte Arduino. Nous allons donc connecter la masse à la borne GND et le 3.3V à la borne VCC du capteur.

Pour la communication entre la carte Arduino et la bébête, nous allons relier respectivement la borne SDA (Serial DAta) du capteur au pin A4 de l’Arduino (oui oui, dans les entrées analogiques), et la borne SCL (Serial CLock) au pin A5.

Les pins A4 et A5 de l’Arduino sont utilisés par défaut par la classe Wire pour les données et le signal d’horloge.

Pour la faire courte, donc :

VCC -> 3.3V
GND -> masse
SDA -> A4
SCL -> A5

 

Dans le prochain article, je vais vous présenter le programme qui permet d’exploiter l’engin.