was successfully added to your cart.
Category

Intermédiaire Arduino

Illustration de l'article "Electronique, approche théorique"

Electronique, approche théorique

By | Intermédiaire Arduino, Intermédiaire Raspberry Pi | No Comments

I- Introduction

Ne vous êtes-vous jamais posé la question de savoir comment ou pourquoi le circuit que vous avez devant les yeux exécute réellement ce que vous lui demandez ? Non ? Parce que nous oui !
En fait, pour comprendre cette science de la théorie, il faut s’intéresser aux phénomènes physiques en jeu et, malheureusement (ou avec joie pour d’autre), il faudra s’intéresser aux outils mathématiques afin de comprendre pleinement ce à quoi nous sommes confrontés.
Si ce tutoriel présentera certaines lois classiques d’électronique comme les lois de Kirchhoff, nous nous intéresserons aussi en détail à l’analyse de l’évolution d’une tension dans un circuit RC (Résistance / Condensateur).
Bien sûr, dans ce tutoriel, finies les contraintes de la vraie vie, nous vivrons dans un monde sans pertes, sans dissipation, bref un monde idéal. En mathématiques ou en physique, on appelle ça un modèle et croyez nous, il vaut mieux pour que nous restions dans ce cadre…
Certaines notions abordées sont étudiées en classes préparatoires scientifiques (maths sup/ maths spé). Nous essaierons de vulgariser au maximum. C’est l’objet de ce tutoriel et nous ferons en sorte que le plus grand nombre puisse comprendre ce que nous expliquons. N’hésitez pas à poser des questions complémentaires en commentaire, ou à nous corriger si des coquilles se glissent dans nos présentations !

II- Lois de Kirchhoff

Avant d’aller plus loin, il nous sera nécessaire de nous baser sur deux principes « fondamentaux » en électronique et sur un principe qui, pour le coup, est considéré comme fondamental pour la physique toute entière. Le premier, c’est celui de la conservation de la charge, il caractérise le fait que dans un système fermé (sans transfert de matière avec l’extérieur), la charge se conserve dans l’ensemble du circuit.
Partant de cette constatation, Kirchhoff, physicien allemand, a établi deux lois majeures en électronique, la loi des nœuds et la loi des mailles.

Loi des noeuds

 

Loi des mailles

III- Quelques formules

Il nous faudra admettre quelques formules pour étudier un système électronique. Je vous propose d’étudier ici les caractéristiques d’un condensateur et d’une résistance (circuit RC). Voyons ensemble quelques formules qui pourraient bien nous être utiles:
  

Pour le condensateur:

q=\frac{di(t)}{dt}
q est la charge du condensateur, i(t) est l’intensité du courant qui le traverse à l’instant t

q=C.u(t)
q est encore la charge du condensateur, C est sa capacité en farad, u(t) la tension à ses bornes à l’instant t

  

Pour la résistance:

u(t)=R.i(t)
u(t) est la tension aux bornes de la résistance à l’instant t, R sa résistance en ohm et i le courant qui la traverse à l’instant t

  

Notion de dérivation mathématiques:

Un outil important qui nous servira tout au long de notre étude est l’utilisation des dérivées en mathématiques. Pour faire simple, c’est un outil qui nous permet d’étudier les variations d’une fonction. En fait, c’est un outil extrêmement puissant dont nous aurions du mal à nous passer en physique comme en mathématiques. Dans nos exemples, nous étudierons l’évolution de la tension aux bornes d’un dipôle et nous devrons donc faire appel aux dérivées. Si nous ne verrons pas vraiment ensemble comment dériver telle ou telle fonction, nous vous donnerons les dérivées dont nous aurons besoin. En réalité, il est nécessaire de connaitre un certain nombre de dérivées de fonctions usuelles et de fonctions composées lorsqu’on travaille dans le monde mathématico-physique. D’un point de vu des notations uniquement, vous devez savoir que les trois notations suivantes sont équivalentes:
\frac{dx}{dt} = \dot{x} = (x)'

Attention cependant, la dernière notation n’est absolument pas rigoureuse dans ce cadre, on symbolise plus régulièrement la dérivation d’une fonction de la manière suivante:
f'(x)

Nous utiliserons très régulièrement à première et la seconde notation, bien moins la dernière, plus utilisées en mathématiques cependant.
Posons donc les bases de notre étude, un petit schéma électronique…

IV- Présentation de l’étude

Présentation de l'étude mathématiques

Schéma du circuit RC étudié par l’approche mathématiques de l’électronique


Le condensateur, est initialement chargé d’une tension u_0

V- Début de l’étude

On a placé nos dipôles en convention générateur. On est face à un circuit RC-Série, le courant dans le circuit est donc constant et on peut écrire, grâce à la loi des mailles:
u_r(t) + u_c(t) = 0
Or, la loi d’Ohm nous donne:
u_r(t) = R.i(t)
Et les formules précédentes sur le condensateur donnent :
u_c(t) = \frac{q(t)}{C}
Alors, finalement il vient:
R.i(t) + \frac{q(t)}{C} = 0
\leftrightarrow \frac{dq}{dt} + \frac{1}{RC}.q(t) = 0

On pose arbitrairement
\tau = R.C
On obtient alors:
\frac{dq}{dt} + \frac{1}{\tau}.q = 0
Autrement dit:
\dot{q}+\frac{1}{\tau}.q = 0  (E)

Cette équation est qualifiée d’équation différentielle du premier ordre, linéaire, sans second membre (donc homogène) et à coefficients constants.
Ouhlaaaa, une grande et vaste notion vient d’être abordée, celle des équations différentielles. Lançons-nous dans la résolution de celle que nous avons ci-dessus. Pour simplifier, une équation différentielle est une équation qui, à la différence d’une équation « algébrique », admettra une solution sous la forme d’une fonction. Si vous n’avez jamais eu de formation scientifique sur ce point, la résolution que nous allons détailler ci-dessous pourra vous sembler un peu complexe. Nous allons essayer d’expliquer chaque point et de détailler chacune des décisions que nous prendrons pour arriver à la résolution. Heureusement pour nous, cette équation est dite homogène, c’est-à-dire que son second membre est nul, et vous ne le savez peut-être pas encore mais cela va largement nous simplifier le travail puisque la solution est simplement une formule, là encore à connaitre par cœur lorsque l’on est en étude scientifique…
En fait, les équations différentielles ne sont pas toutes aussi simples, on a parfois des membres doublements dérivés (équations différentielles du second ordre), avec second membres, ou mêmes les deux à la fois.

VI- Résolution de l’équation différentielle

Rappelons (E):
\dot{q}+\frac{1}{\tau}.q = 0  (E)
Comme nous l’avons vu, cette équation différentielle est plus simple à résoudre. C’est une équation dite « homogène » qui se résout par la simple application d’une formule à connaître si l’on souhaite pouvoir en résoudre soi-même plus tard. Cette formule implique l’utilisation de la fonction exponentielle, nul doute que vous ayez déjà entendu ce mot puisqu’il est largement utilisé pour caractériser une évolution rapide d’un paramètre quelconque. En effet, la courbe caractéristique de la fonction exponentielle est la suivante:

Représentation de la fonction exponentielle

Représentation graphique de la fonction exponentielle tracée à l’aide du logiciel GeoGebra


On comprend alors cette augmentation rapide. Je n’entrerai pas en détail dans l’étude de cette fonction, c’est une fonction très utile, qui est caractérisée par deux points:
\frac{d}{dx}(e^x) = e^x
e^0 = 1
Bien, il est temps de revenir à notre équation différentielle. Cette dernière admet donc comme solutions les fonctions de la forme:
q(t) = A.e^{\frac{-t}{\tau}} , A \in \mathbb{R}

q(t)=Ae^((-t)/τ) ,A∈R
Nous avons bien dit les fonctions car il y en a une infinité en théorie grâce à la constante « A ». Bien sûr, nous allons devoir définir cette constante afin qu’elle caractérise exactement le circuit que nous avons choisi au départ. Pour cela, je vous propose de réinjecter notre solution dans u_c(t). Souvenons-nous d’abord de l’expression de &latex u_c(t)&s=1&bg=f8f8f8$:
q = C.u(t)
\leftrightarrow u_c(t) = \frac{q}{C}
On remplace alors « q » par la solution déterminée ci-dessus, on a alors:
u_c(t) = \frac{A.e^{\frac{-t}{\tau}}}{C}
Maintenant, il faut déterminer « A », pour cela on va utiliser les conditions initiales, en effet, on avait spécifié qu’à t = 0, u_c(t) = u_0, on a alors:
u_c(t=0)=\frac{A}{C}
\leftrightarrow A = C.u_0
Voilà notre constante exprimée, remplaçons « A » dans la solution par cette valeur:
q(t) = C.u_0.e^{-\frac{t}{\tau}}
Voilà, on a désormais l’équation qui régit la variation de la charge dans notre circuit. Mais pour nous, le plus intéressant serait de connaître l’évolution de la tension aux bornes du condensateur. Pour cela, on reprend notre formule de la tension du condensateur:
u_c(t) = \frac{q}{C}
Et on injecte cette fois-ci notre solution finale de l’équation différentielle, on a alors:
u_c(t) = \frac{C.u_0.e^{-\frac{t}{\tau}}}{C}
En simplifiant, il vient:
u_c(t) = u_0.e^{-\frac{t}{\tau}} avec \tau = R.C

Ensuite, on peut rentrer cette formule dans un logiciel qui permet de tracer des courbes, comme Geogebra ou Excel et observer l’effet d’une résistance ou d’une capacité différente.
Pour notre part, avec une résistance de 850 ohms, une capacité de 0,04 Farads et une tension u_0 = 4V, on obtient la courbe suivante:

Evolution de la tension dans un circuit RC

Représentation graphique de l’évolution de la tension aux bornes d’un condensateur dans un circuit RC obtenue à l’aide du logiciel GeoGebra


Le temps, en secondes, est en abscisse et la tension aux bornes du condensateur, en volts, est en ordonnée.

VII- Conclusion

Si vous avez eu le courage de lire en intégralité ce tutoriel, félicitation !
Vous devriez maintenant être en mesure d’étudier d’une manière plus mathématique un circuit électronique relativement simple. Relisez le tutoriel, comprenez chaque étape, posez vos questions et entraînez-vous avec des circuits un poil plus complexe avec deux résistances ou deux condensateurs. Evidemment, dans ce cas, il faudra utiliser les formules pour retrouver la résistance équivalente de deux résistances en série ou de deux condensateurs en série.

Ce tutoriel a été écrit par Fabien Aubret, relu et vulgarisé par Thomas Aubret et Grégoire Aubret.
Une relecture a été effectuée par un professeur de physique diplômé de l’Ecole Normale Supérieure (ENS), un grand merci à lui.

Afficheurs 7 segments et l’Arduino

By | Intermédiaire Arduino | No Comments

Nous nous retrouvons pour un nouveau tutoriel Arduino sur les afficheurs 7 segments.
Vous avez tous déjà vu ou entendu parlé de ces afficheurs.

De quoi s’agit il ? Un afficheur 7 segments est un composant comme celui-ci :

Afficheur 7 Segments

Afficheur 7 Segments

Il est composé de 7 diodes, ici les 7 segments, en forme de « ligne » qui permettent de former des chiffres allant de 0 à 9. Ces afficheurs sont souvent rouges mais on peut en trouver de couleur blanche, bleue, verte …

Pour la réalisation de ce tutoriel, nous allons avoir besoin d’un peu de matériel. Mais comme à notre habitude, je vous transmet une liste de ce dont nous allons utiliser :

Matériel

  • 1 afficheur 7 segments
  • 8 résistances de 330 Ohms
  • 1 carte Arduino

Pour la réalisation de ce tutoriel, je vais utiliser un afficheur à Cathode commune. C’est à dire que l’afficheur possède un GND pour toute les diodes et qu’il suffira d’envoyer 5V dans les pins que nous voulons allumer pour former les chiffres.

Présentation de l’afficheur

L’afficheur que je vais utiliser est similaire à la photo suivante :

Présentation afficheur 7 segments

Présentation afficheur 7 segments

Cet afficheur est composé de 7 segments référencés de A à F de la manière suivante :

Branchements pins

Branchements pins

Références segments

Voici la signification des différents pins :

Significations des pins

Significations des pins

A présent, nous allons réaliser le branchement de l’afficheur. Voici celui que j’ai réalisé :

Schéma de branchement

Schéma de branchement

Vous pouvez voir sur ce schéma que l’on a branché à la masse les pins 3 et 8 et tous les autres pins sont branchés à des sorties de l’Arduino.

Avant de commencer, voici un tableau dans lequel est récapitulé les pins à mettre à l’état 1 pour afficher les caractères suivant :

Caractères

Programmation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
int A = 2;
int B = 3;
int C = 4;
int D = 5;
int E = 6;
int F = 7;
int G = 8;
 
void setup(){
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
 
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
    }
 
void loop(){
  zero();
  delay(1000);
  un();
  delay(1000);
  deux();
  delay(1000);
  trois();
  delay(1000);
  quatre();
  delay(1000);
  cinq();
  delay(1000);
  six();
  delay(1000);
  sept();
  delay(1000);
  huit();
  delay(1000);
  neuf();
  delay(1000);
  }
 
void zero(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, LOW);
    }
 
void un(){
  digitalWrite(A, LOW);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, LOW);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, LOW);
    }
 
void deux(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, LOW);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
    }
 
void trois(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH;
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
  }
 
void quatre(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, LOW);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
  }
 
void cinq(){
  digitalWrite(A, HIGH);
  digitalWrite(B, LOW);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  }
 
void six(){
  digitalWrite(A, HIGH);
  digitalWrite(B, LOW);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  }
 
void sept(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, LOW);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, LOW);
  }
 
void huit(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  }
 
void neuf(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  }

Voila à quoi vous allez arriver :

Projet final

Projet final

A présent vous savez comment utiliser un afficheurs 7-segments. Vous pouvez combiner plusieurs afficheurs pour réaliser une horloge, un compteur ou encore afficher des mots.

Grégoire A.

Image de Une de l'article "réaliser un arduino DIY"

Réaliser un Arduino « maison »

By | Intermédiaire Arduino | No Comments

Bonjour à tous !

Qui n’a jamais rêvé de se mettre dans la peau de Massimo Banzi le créateur de notre cher et tant aimé microcontrôleur Arduino ? Vous pensez que cela est trop compliqué ? Et bien pourtant non ! Et cela ne coûte pas plus de 5€ ! Comme je vous l’avais annoncé dans un précédent tutoriel, nous allons voir comment en réaliser un ensemble.

Matériel nécessaire

Tout d’abord il va falloir s’équiper d’un peu de matériel.

  • Une puce AtMega328 bootloadée pour Arduino ou non (préférez en une bootloadée si vous ne possédez pas d’arduino)
  • Une résistance de 10 kOhm
  • Un quartz de 16 MHz
  • Deux condensateurs de 20 pF (céramiques)
  • Un condensateur de 100 nF (pour le reset)
  • Une breadboard (plaque d’essai)
  • Des fils

Pour ma part j’ai ajouté un ZIF socket 28 pins permettant de monter de démonter les puces sans risquer de tordre les pins afin de coder en série mes microcontrôleurs.

Entrons dans le vif du sujet. Voici un schéma expliquant la correspondance entre les broches de la puce et celles de l’Arduino. Nous allons nous en servir tout au long de la réalisation d’une carte.

Correspondance des broches entre AtMega et Arduino

Correspondance des broches entre AtMega et Arduino

 

Pour vous procurer une puce AtMega328 deux choix s’offrent à vous.

  • Acheter une puce bootloadée pour arduino
  • Acheter une puce vierge qu’il faudra gravée pour pouvoir la programmer avec un Arduino

La première option n’a pas d’intérêt à être expliquée. Vous pouvez passez directement à la partie « créer son arduino ».

Je vais vous expliquer commenter graver (bootloader) la puce.

Bootloader la puce AtMega328

Tout d’abord il faut réaliser le schéma de câblage suivant :

Schéma de câblage pour bootloader une puce AtMega328

Schéma de câblage pour bootloader une puce AtMega328

Maintenant que le câblage est effectué, nous pouvons passer à la partie programmation.

Il va falloir télécharger le bootloader sur le microcontrôleur. Pour cela, lancer l’IDE Arduino puis charger le fichier se trouvant dans « Fichier/Exemples/ArduinoISP« .

Sketch "ArduinoISP" pour télécharger le bootloader

Sketch « ArduinoISP » pour télécharger le bootloader

Dans le menu « Outils/type de carte » sélectionnez « Arduino UNO« . Sélectionnez le port COM de votre arduino puis au niveau « Programmateur » sélectionnez « Arduino as ISP« .

Chargez le programme sur l’arduino.

Dans le menu « Outils« , cliquez sur « Graver la séquence d’initialisation« . Cela peut prendre un peu de temps, puis une message sur l’IDE indiquant que la gravure de la séquence d’initialisation est terminée va s’afficher.

Voila ! Le bootloader est installé sur le microcontrôleur !

Créer son arduino

Voici le câblage de l’arduino DIY que nous allons réaliser.

Schéma de câblage d'un Arduino DIY

Schéma de câblage d’un Arduino DIY

 

Afin de téléverser un Sketch sur cet arduino il vous faudra utiliser un convertisseur USB/Série. Et nous pouvons éviter d’en acheter un condition de posséder un Arduino UNO.

Il va falloir enlever délicatement le microcontrôleur de l’arduino en veillant à ne pas tordre (pour ne pas casser) les pattes. Ensuite brancher les câbles du montage (TX, RX, reset, 5v et gnd) sur les pins de l’Arduino de même nom. Puis faites comme vous en avez l’habitude !

J’ai opté pour une autre option. J’ai acheté une nouvelle carte Arduino UNO, dessoudé le DIP du microcontrôleur et j’ai soudé un ZIF 28 pins. Ce composant me permet d’insérer les AtMega en série pour imaginer faire de la production.

Arduino Uno avec support ZIF 28

Arduino Uno avec support ZIF 28 pour programmer les puces

A présent si vous vous souvenez de la correspondance des broches sur l’AtMega (au tout début de l’article) il est facile de savoir à quel numéro de pin correspond telle broche.

Il ne vous reste plus qu’à souder le tout sur une plaque d’essai ou sur un PCB afin de faire fonctionner votre système.

Je vous conseille de ne pas souder directement l’AtMega sur le PCB mais d’utiliser un DIP28 comme celui-ci afin de ne pas imposer des contraintes thermiques dues au fer à souder qui pourraient endommager la puce. De plus cela permet de récupérer la puce.

Support microcontrôleur AtMega328

Support microcontrôleur AtMega328

 

Thomas A.

Interruption et Arduino

By | Intermédiaire Arduino | No Comments

Nous allons voir ensemble dans ce tutoriel l’utilisation d’interruption dans un programme arduino. Les interruptions vont nous permettre d’obtenir des systèmes beaucoup plus rapide et réactifs.

Une interruption c’est quoi ?

Une interruption est un déclenchement qui arrête l’exécution d’un programme ou d’un bout de code pour exécuter une autre fonction.
C’est typiquement le cas lorsque l’on programme un chronomètre. Le temps s’écoule jusqu’au moment où on décide de stopper le chronomètre afin de lire la valeur inscrite sur l’écran.
Une interruption permet ainsi de stopper ou d’effectuer un programme puis d’en reprendre l’exécution à partir de l’instant où il a été stoppé.
 tableau des interruptions
Pour déclencher une interruption, il existe plusieurs solutions :
  • LOW : Passage à état bas du pin
  • FALLING : Detection d’un front descendant (passage de l’état haut à l’état bas)
  • RISING : Detection d’un front montant (passage de l’état bas à l’état haut)
  • CHANGE : Changement d’état du pin

Création d’une interruption

 La fonction à utiliser est la suivante :
  • attachInterrupt(interrupt, function, mode)
    • interrupt : numéro du pin (0 pour le pin 2 et 1 pour le pin 3)
    • function : fonction à appeler
    • mode : type de déclenchement (LOW // FALLING // RISING // CHANGE)

Utilisation

Contexte : Nous voulons que notre chronomètre se stoppe lorsque l’on appui sur un bouton.
Nous allons appeler une fonction « Pause() » lorsque l’utilisateur appuie sur un bouton branché sur le pin 2.
Ainsi, nous aurons la syntaxe suivante :

1
attachInterrupt(0, Pause, FALLING);

Notez l’absence des parenthèse après l’appel de fonction « Pause ». Vous pouvez coder par exemple la fonction « Pause() » un peu plus loin dans le programme.

Lorsque vous utilisez une interruption, tout le programme se met en « pause » et la fonction appelée dans l’interruption prend le relais. Ainsi, les fonctions de temps « delay() », « millis() » seront également stoppée. Veillez à bien faire attention dans vos programmes pour ne pas avoir de mauvaise surprise !

Exemple

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int pin = 13;
volatile int state = LOW; //déclaration d'une variable volatile
 
void Setup(){
     pinMode(pin, OUTPUT);
     attachInterrupt(0, blink, CHANGE); //attache l'interruption externe n°0 à la fonction "blink"
}
 
void Loop(){
     digitalWrite(pin, state); //la LED reflète d'état de la variable
}
 
void blink(){
     state = !state; //inverse l'état de la variable
}

Grégoire A.

Comment lire les datasheets et utiliser le module SM130

Utilisez les datasheets et découvrez le module SM130

By | Intermédiaire Arduino | No Comments

Bonjour à tous,
Aujourd’hui, nous allons voir ensemble comment lire, comprendre et utiliser la datasheet d’un module que nous venons de recevoir. En fait, la lecture de la datasheet, qui regroupe toutes les données utiles liées à l’utilisation d’un circuit, d’un capteur ou d’un actionneur, doit être la première chose à faire lorsque vous ne réussissez pas à utiliser le matériel que vous venez de recevoir. Il est aussi très intéressant de la consulter lorsque vous utilisez une librairie depuis un certain nombre de temps et que vous souhaitez finalement pouvoir profiter pleinement de toutes les capacités offertes par le matériel que vous venez d’acheter.
La lecture d’une datasheet n’est pas forcément une chose simple. Sa compréhension peut se révéler difficile puisqu’elle contient de nombreux détails qui ne vous seront pas forcément utiles. Cependant, elle est indispensable puisqu’elle permettra, dans de nombreux cas, d’étalonner un capteur ou de comprendre le protocole utilisé par le matériel par exemple.
Dans ce tutoriel, j’aurai pu aborder l’utilisation des datasheets pour l’étalonnage d’un capteur de température mais je préfère aborder une notion plus complexe et sans doute, plus utile, découvrir de A à Z comment communiquer avec un module SM130. Le matériel utilisé dans cet article n’est pas un matériel onéreux, en voici la liste:

Matériel:

  • 1 Arduino UNO
  • Un module SM130 disponible chez Sparkfun
  • Un shield d’évaluation RFID optionnel mais j’en utiliserai un, il est disponible chez Sparkfun
  • 4 câbles M/F

 

Shield Evaluation RFID et module SM130

Ensemble Shield Evaluation RFID Sparkfun et module SM130 soudé

 

Tags RFID

Tags RFID de forme « Jeton »

Puisque nous allons aborder l’utilisation de la datasheet, voici deux liens qui nous seront utiles lors de notre progression:

Bien, nous sommes désormais prêts à comprendre le protocole de communication de notre module.

Dans un premier temps, il va falloir identifier la méthode de communication utilisée par le matériel, c’est-à-dire s’il utilise la liaison Série, I2C, One-Wire ou autre. Sur la première page de la datasheet du module SM130, nous pouvons lire « UART Interface – up to 115200bps ». UART signifie  » Universal Asynchronous Receiver Transmitter » mais est aussi synonyme d’une liaison série. Si on lit la ligne suivante, on observe que le module peut aussi être utilisé via la liaison I2C. Dans cet article, j’utiliserai la liaison Série pour faciliter son utilisation avec l’Arduino.
La seconde étape consiste à identifier la position des pins VCC, GND, Rx et Tx. Pour cela, nous avons une manière simple de procéder pour le SM130 puisqu’à la page 4, nous avons le plan des pinouts du SM130. On note la position de VCC, RFVCC, GND, RFGND, UART RX et UART TX. Pour ceux qui comme moi, auront choisi d’utiliser le shield RFID Evaluation, nous pouvons consulter sa datasheet et remarquer sur le schéma du shield que le Rx du SM130 est relié à la broche D7 et son Tx à la broche D8. VCC et GND sont respectivement liées à +5V et GND.
Pour ceux d’entre vous qui utilisent le module SM130 seul, vous devez relier les pins VCC et RFVCC à la sortie 5V de l’Arduino, les pins GND et RFGND à une masse de l’Arduino (GND). Ensuite, que vous utilisez le module avec ou sans shield, vous devez relier le UART RX à la broche D7 de l’Arduino et le UART TX à la broche D8.

Montage module SM130 et Arduino UNO

Montage du module SM130 relié à un Arduino UNO au moyen de 4 câbles et d’un shield Evaluation RFID

Maintenant, notre module est branché sur notre Arduino et nous n’avons, jusqu’ici, encore eu besoin d’aucune aide extérieur.

Le plus difficile arrive maintenant. Nous ne travaillerons désormais qu’avec la datasheet du module SM130 pour la suite de l’article. Je vous propose d’aller à la page 7/8 de cette datasheet. A la page 7, vous retrouvez l’ensemble des commandes que nous pouvons utiliser sur notre module. Dans la colonne de gauche, vous avez la commande hexadécimale correspondante à la commande du module présentée dans les deux colonnes de droite.
Mais la page 8 est bien intéréssante pour nous, nous allons trouver de nombreuses informations dedans. Tout d’abord, dans le premier paragraphe, nous retrouvons tous les débits Série disponible pour notre module mais il est bien spécifié que le débit par défaut est 19200bps, N, 8, 1 c’est-à-dire une vitesse de 19200bps avec aucun bit de parité, 8 bits de données et 1 bit de stop. Ne tenez pas compte des 3 paramètres N, 8, 1 ils ne sont pas intéressant dans notre cas, notez simplement la vitesse de 19200bps.
Le premier tableau présent sur cette page de la datasheet:

Header Reserved Length Command Data CSUM
1 Byte 1 Byte 1 Byte 1 Byte N Bytes 1 Byte

Nous permet de réellement comprendre le protocole de communication du module. Nous avons ensuite le détail du contenu de chaque bit que je vais rappeler ici:

  • Header: Toujours à 0xFF, il permet d’avertir le module que nous allons lui envoyer des données
  • Reserved: Toujours à 0x00, il est réservé à une utilisation future que le fabricant pourrait en faire
  • Length: C’est une variable qui prend pour valeur le nombre de bit transmis (Command + Data)
  • Command: C’est une variable qui prend pour valeur l’une des commandes présentes sur la page 7
  • Data: C’est une variable qui prend pour valeur les données que l’on souhaite transmettre liées à la commande
  • CSUM: c’est le « checksum », la clé de salage, elle prend pour valeur la somme de tous les bits, sauf de Header

Un retour sur la page 7 nous permet de retrouver le code correspondant à la commande que nous souhaitons. En effet, pour vérifier en permanence la présence d’un tag RFID sur l’antenne du module, nous pouvons utiliser la commande correspondante au code « 0x82 » qui ne prend pas d’argument (Data = 0).

A ce stade du tutoriel, nous sommes capables de formuler notre commande permettant, par exemple, d’attendre la présence d’un module. Ainsi, l’information à envoyer au module se découpe en trois 6 parties:

  • 0xFF = Header
  • 0x00 = Reserved
  • 0x01 = Nombre de bit Commande + Data
  • 0x82 = Command
  • 0x00 = Data
  • 0x83 = CSUM

Nous pouvons donc désormais écrire notre programme. Pour gérer deux liaisons séries via l’Arduino UNO, nous allons utiliser la librairie SoftwareSerial. Voici donc notre script à ce moment du tutoriel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include 
 
SoftwareSerial rfid(7, 8);
 
String readed;
 
void setup() {
  Serial.begin(9600);
  rfid.begin(19200);
 
}
 
void loop() {
  rfid.write((uint8_t)0xFF);
  rfid.write((uint8_t)0x00);
  rfid.write((uint8_t)0x01);
  rfid.write((uint8_t)0x82);
  rfid.write((uint8_t)0x83);
 
  delay(500);
}

Ce script a pour effet de vérifier la présence d’un tag RFID autour de l’antenne du module SM130. J’ai placé un delay(500) afin que le module ait le temps de formuler sa réponse pour la suite du tutoriel.
Ce qui nous intéresse, bien entendu, est d’être en mesure de lire la valeur du tag. Pour cela, je vous propose d’aller à la page 13 de la datasheet du module. Là, nous pouvons voir la nature du message retourné par le module lorsque la présence d’un tag RFID est constatée. Dans le cas où aucun tag n’est présent, nous aurons en retour le message suivant: « ff02824cd0 ». Pour information, j’ai déterminé ce message en ajouter une vérification du retour d’un message à l’aide de rfid.available() puis un Serial.println(String(rfid.read(), HEX)); après le delay(500); du script précédent. J’ai ainsi pu observer la forme de la réponse lors de la présence d’un tag RFID et lorsqu’il n’y en avait pas.
La forme de la réponse est donc:

  • Header, Reserved, Length, Command, Data

Attention, souvenez-vous que Reserved vaut 0x00 et qu’il n’apparaitra donc par dans la trame de données renvoyées. Il est important d’avoir connaissance aussi du fait que notre module renverra une trame de données contenant le retour pour l’exécution de la commande + le retour des données du tag présent lorsqu’il y en aura un, cela sur une seule trame.
Cela signifie que si nous voulons identifier la valeur du tag RFID de notre carte RFID par exemple, nous devrons sélectionner la chaine de caractère débutant au 17ème caractère de la trame jusqu’au 25ème, le 26/27ème correspondant au bit MSB.
En effet, la trame reçue, par exemple, pourrait ressembler à celle-ci:
« ff02924cd0ff0682210fe4e846a », trame dans laquelle on retrouve le tag de la carte, « 10fe4e84 », « 6a » correspondant au bit MSB.

Voilà donc notre script final:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include 
 
SoftwareSerial rfid(7, 8);
 
String readed;
 
void setup() {
  Serial.begin(9600);
  rfid.begin(19200);
 
}
 
void loop() {
  rfid.write((uint8_t)0xFF);
  rfid.write((uint8_t)0x00);
  rfid.write((uint8_t)0x01);
  rfid.write((uint8_t)0x82);
  rfid.write((uint8_t)0x83);
 
  delay(500);
 
  while(rfid.available() > 0){
    readed += String(rfid.read(), HEX);
  }
  if(readed != "ff02824cd0"){
    Serial.println(readed);
    Serial.println(readed.substring(17, 25));
  }
  readed = "";
 
}

Vous êtes désormais capable d’utiliser votre module SM130, en plus d’être capable de lire et de comprendre une datasheet.
A bientôt pour un prochain tutoriel sur Simple-Duino.

Fabien A.

Illustration tutoriel utilisation du DS1307 avec Arduino

Module DS1307 de chez Sparkfun

By | Intermédiaire Arduino | 3 Comments

Salut à tous,

J’espère que vous passez de bonnes vacances et que vous bidouillez bien. Aujourd’hui, je fais un tuto sur l’utilisation du module DS1307 grâce à l’Arduino.

Le module DS1307 est une horloge. En fait, on la programme une fois puis on peut ensuite récupérer l’heure qu’il est puisque le module continue de compter les secondes, minutes, heures, etc… grâce à une petite pile bouton plaquée au dos du module. On communique avec ce module grâce au protocole I2C disponible sur les ports A5 et A4 de l’Arduino UNO.

 

Dans un premier temps, j’ai simplifié le travail puisque j’ai trouvé l’adresse I2C du module grâce au bus pirate. Ce dernier m’a donné ce résultat:  0xD0(0x68 W) 0xD1(0x68 R)

Concrètement, ce résultat signifie: « J’ai trouvé un module sur le premier port avec l’adresse 0x68 et en mode écriture. Ensuite, j’ai continué mes recherches et trouvé un même module sur le second port avec la même adresse mais en mode lecture cette fois-ci »

Je reviendrai sur l’utilisation du bus pirate dans un prochain tutoriel sans doute. On a donc ici connaissance de l’adresse du module (0x68) et on remarque que cette adresse est la même en lecture et en écriture.

Bus Pirate adresse DS1307

 

Lorsque vous aller recevoir votre DS1307, l’heure ne sera pas dessus. Voici un script open-source que j’ai pu récupérer sur internet. Au niveau des branchements, voici comment câbler le module. Les branchements ne changerons pas tout au long du tutoriel :

module —-> Arduino

5V          —-> 5V

GND      —-> GND

SDA      —-> A4

SCL       —-> A5

 

Voici le script permettant d’enregistrer l’heure sur le module:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
/* RTC Control v1.00 
 * by <http://www.combustory.com> John Vaughters
 *
 * THIS CODE IS FREE FOR ANYTHING - There is no Rocket Science here. No need to create some long GPL statement.
 *
 * Credit to:
 * Maurice Ribble - http://www.glacialwanderer.com/hobbyrobotics for RTC DS1307 code
 * BB Riley - Underhill Center, VT <[email protected]> For simplification of the Day of Week and month
 * and updating to Arduino 1.0 
 * peep rada - from Arduino Forum - Found that only 32 registers per I2C connection was possible 
 * 
 * With this code you can set the date/time, retreive the date/time and use the extra memory of an RTC DS1307 chip. 
 * The program also sets all the extra memory space to 0xff.
 * Serial Communication method with the Arduino that utilizes a leading CHAR for each command described below. 
 *
 * Commands:
 * T(00-59)(00-59)(00-23)(1-7)(01-31)(01-12)(00-99) - T(sec)(min)(hour)(dayOfWeek)(dayOfMonth)(month)(year) -
 * T - Sets the date of the RTC DS1307 Chip. 
 * Example to set the time for 25-Jan-2012 @ 19:57:11 for the 4 day of the week, use this command - T1157194250112
 * Q(1-2) - (Q1) Memory initialization (Q2) RTC - Memory Dump 
 * R - Read/display the time, day and date
 *
 * ---------------------------------------------------------
 * Notes:
 * Version 1.0
 * Moving this code to Version 1.0 because this code has been updated to Arduino v1.0 and the features have
 * been well tested and improved in a collaborative effort.
 * - Fixed the issue of not being able to access all the registers - JWV
 * - Added initialization for all non-time registers - JWV
 * - Added Dump of all 64 registers - JWV
 * - Some Date/Time reformatting and cleanup of display, added Day/Month texts - BBR
 * - Made compatible with Arduino 1.0 - BBR
 * - Added Rr command for reading date/time - BBR
 * - Made commands case insensitive - BBR
 * - Create #define varibles to support pre Arduino v1.0 - JWV
 * Version 0.01
 * Inital code with basics of setting time and the first 37 registers and dumping the first 32 registers. 
 * The code was based on Maurice Ribble's original code.
 * 
 */
 
#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68 // This is the I2C address
// Arduino version compatibility Pre-Compiler Directives
#if defined(ARDUINO) && ARDUINO >= 100 // Arduino v1.0 and newer
 #define I2C_WRITE Wire.write 
 #define I2C_READ Wire.read
#else // Arduino Prior to v1.0 
 #define I2C_WRITE Wire.send 
 #define I2C_READ Wire.receive
#endif
// Global Variables
int command = 0; // This is the command char, in ascii form, sent from the serial port 
int i;
long previousMillis = 0; // will store last time Temp was updated
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
byte test;
byte zero;
char *Day[] = {"","Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
char *Mon[] = {"","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
 
// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
 return ( (val/10*16) + (val%10) );
}
 
// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
 return ( (val/16*10) + (val%16) );
}
 
// 1) Sets the date and time on the ds1307
// 2) Starts the clock
// 3) Sets hour mode to 24 hour clock
// Assumes you're passing in valid numbers, Probably need to put in checks for valid numbers.
 
void setDateDs1307() 
{
 
 second = (byte) ((Serial.read() - 48) * 10 + (Serial.read() - 48)); // Use of (byte) type casting and ascii math to achieve result. 
 minute = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
 hour = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
 dayOfWeek = (byte) (Serial.read() - 48);
 dayOfMonth = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
 month = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
 year= (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
 Wire.beginTransmission(DS1307_I2C_ADDRESS);
 I2C_WRITE(zero);
 I2C_WRITE(decToBcd(second) & 0x7f); // 0 to bit 7 starts the clock
 I2C_WRITE(decToBcd(minute));
 I2C_WRITE(decToBcd(hour)); // If you want 12 hour am/pm you need to set
 // bit 6 (also need to change readDateDs1307)
 I2C_WRITE(decToBcd(dayOfWeek));
 I2C_WRITE(decToBcd(dayOfMonth));
 I2C_WRITE(decToBcd(month));
 I2C_WRITE(decToBcd(year));
 Wire.endTransmission();
}
 
// Gets the date and time from the ds1307 and prints result
void getDateDs1307()
{
 // Reset the register pointer
 Wire.beginTransmission(DS1307_I2C_ADDRESS);
 I2C_WRITE(zero);
 Wire.endTransmission();
 
 Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
 
 // A few of these need masks because certain bits are control bits
 second = bcdToDec(I2C_READ() & 0x7f);
 minute = bcdToDec(I2C_READ());
 hour = bcdToDec(I2C_READ() & 0x3f); // Need to change this if 12 hour am/pm
 dayOfWeek = bcdToDec(I2C_READ());
 dayOfMonth = bcdToDec(I2C_READ());
 month = bcdToDec(I2C_READ());
 year = bcdToDec(I2C_READ());
 
 if (hour < 10)
 Serial.print("0");
 Serial.print(hour, DEC);
 Serial.print(":");
 if (minute < 10)
 Serial.print("0");
 Serial.print(minute, DEC);
 Serial.print(":");
 if (second < 10)
 Serial.print("0");
 Serial.print(second, DEC);
 Serial.print(" ");
 Serial.print(Day[dayOfWeek]);
 Serial.print(", ");
 Serial.print(dayOfMonth, DEC);
 Serial.print(" ");
 Serial.print(Mon[month]);
 Serial.print(" 20");
 if (year < 10)
 Serial.print("0");
 Serial.println(year, DEC);
 
}
 
 
void setup() {
 Wire.begin();
 Serial.begin(9600); 
 zero=0x00;
}
 
void loop() {
 if (Serial.available()) { // Look for char in serial que and process if found
 command = Serial.read();
 if (command == 84 || command == 116) { //If command = "Tt" Set Date
 setDateDs1307();
 getDateDs1307();
 Serial.println(" ");
 }
 else if (command == 82 || command == 114) { //If command = "Rr" Read Date ... BBR
 getDateDs1307();
 Serial.println(" ");
 }
 else if (command == 81 || command == 113) { //If command = "Qq" RTC1307 Memory Functions
 delay(100); 
 if (Serial.available()) {
 command = Serial.read(); 
 if (command == 49) { //If command = "1" RTC1307 Initialize Memory - All Data will be set to 
 // 255 (0xff). Therefore 255 or 0 will be an invalid value. 
 Wire.beginTransmission(DS1307_I2C_ADDRESS); // 255 will be the init value and 0 will be considered 
 // an error that occurs when the RTC is in Battery mode.
 I2C_WRITE(0x08); // Set the register pointer to be just past the date/time registers.
 for (i = 1; i <= 24; i++) {
 I2C_WRITE(0Xff);
 delay(10);
 } 
 Wire.endTransmission();
 Wire.beginTransmission(DS1307_I2C_ADDRESS); 
 I2C_WRITE(0x21); // Set the register pointer to 33 for second half of registers. Only 32 writes per connection allowed.
 for (i = 1; i <= 33; i++) {
 I2C_WRITE(0Xff);
 delay(10);
 } 
 Wire.endTransmission();
 getDateDs1307();
 Serial.println(": RTC1307 Initialized Memory");
 }
 else if (command == 50) { //If command = "2" RTC1307 Memory Dump
 getDateDs1307();
 Serial.println(": RTC 1307 Dump Begin");
 Wire.beginTransmission(DS1307_I2C_ADDRESS);
 I2C_WRITE(zero);
 Wire.endTransmission();
 Wire.requestFrom(DS1307_I2C_ADDRESS, 32);
 for (i = 0; i <= 31; i++) { //Register 0-31 - only 32 registers allowed per I2C connection
 test = I2C_READ();
 Serial.print(i);
 Serial.print(": ");
 Serial.print(test, DEC);
 Serial.print(" : ");
 Serial.println(test, HEX);
 }
 Wire.beginTransmission(DS1307_I2C_ADDRESS);
 I2C_WRITE(0x20);
 Wire.endTransmission();
 Wire.requestFrom(DS1307_I2C_ADDRESS, 32); 
 for (i = 32; i <= 63; i++) { //Register 32-63 - only 32 registers allowed per I2C connection
 test = I2C_READ();
 Serial.print(i);
 Serial.print(": ");
 Serial.print(test, DEC);
 Serial.print(" : ");
 Serial.println(test, HEX);
 }
 Serial.println(" RTC1307 Dump end");
 } 
 } 
 }
 Serial.print("Command: ");
 Serial.println(command); // Echo command CHAR in ascii that was sent
 }
 command = 0; // reset command 
 delay(100);
 }
//*****************************************************The End***********************

Voilà pour l’écriture sur le module. Le fonctionnement de ce programme est assez simple, ouvrez le port série de l’Arduino, réglez le sur 9600 bauds puis écrivez    T(sec)(min)(hour)(dayOfWeek)(dayOfMonth)(month)(year) en remplaçant par la date que vous souhaitez.

Maintenant, votre module est tout beau avec l’heure entrée dedans. Mais le plus intéressant, c’est surtout de pouvoir récupérer l’heure stockée. Cette opération peut s’effectuer simplement grâce au programme suivant

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 #include 
 
void setup(){
 Wire.begin();
 Serial.begin(9600);
}
 
void loop(){
 
 //Initialisation du pointeur
 Wire.beginTransmission(0x68);
 Wire.write(0);
 Wire.endTransmission();
 
 //Lecture des 7 octets contenant date et heure
 Wire.requestFrom(0x68, 7);  //On demande 7 octets à l'adresse 0x68 (voir plus haut)
 byte secs = Wire.read(); //Chaque octet reçu est stocké dans une variable qui lui est propre
 byte mins = Wire.read(); //Dans l'ordre, on reçoit les secondes, les minutes, les heures, etc...
 byte hrs = Wire.read();
 byte jour = Wire.read();
 byte date = Wire.read();
 byte mois = Wire.read();
 byte annee = Wire.read();
 
 //Affichage des données
 Serial.print("Heure ");
 if(hrs < 10) Serial.print("0");
 Serial.print(hrs,HEX);
 Serial.print(":");
 if(mins < 10) Serial.print("0");
 Serial.print(mins,HEX);
 Serial.print(":");
 if(secs < 10) Serial.print("0");
 Serial.println(secs,HEX);
 
 Serial.print("Date ");
 if(date <10) Serial.print("0");
 Serial.print(date,HEX);
 Serial.print("-");
 if(mois < 10) Serial.print("0");
 Serial.print(mois,HEX);
 Serial.print("-");
 Serial.print("20");
 if(annee < 10) Serial.print("0");
 Serial.println(annee, HEX);
 Serial.println();
 delay(1000);
}

Ce script vous permettra de récupérer les données d’horloge stockées pour les réutiliser dans un programme. Ici, j’ai décidé de les afficher dans le moniteur série.

Je vous donne en prime une idée d’un projet à effectuer avec ce module, la réalisation d’un réveil avec afficheur digital sur des 7 segments ou un écran LCD par exemple.
Les projets sont infinis !

Voilà pour ce tuto sur le DS1307, j’y regroupe deux programmes des plus utiles lorsque l’on débute avec ce type de module.

Illustration tutoriel utilisation du 74HC595 avec Arduino

[Arduino]Découvrir les 74HC595

By | Intermédiaire Arduino | 3 Comments

Bonjour à tous,

Cela fait pas mal de temps que mon dernier tutoriel est sorti et je vous en propose aujourd’hui un nouveau qui, je l’espère, saura vous intéresser. Vous remarquerez dans le titre la présence de [Arduino], en effet, je traiterai des CI 74HC595 lors de différents tutos avec le bus pirate, l’Arduino et le Raspberry Pi.

Aujourd’hui, nous allons aborder ensemble l’utilisation des Circuits intégrés (J’écrirai CI tout au long de l’article) de type 74HC595 avec comme seul contrôleur, l’Arduino. Nous découperons notre article selon le plan suivant:

1- Que sont les Circuits de type 74HC595 et quelles sont leurs possibles utilisations

2- Principe théorique du fonctionnement des CI 74HC595

3- Mise en pratique et application des connaissances

 

A la fin de ce tutoriel, vous devriez être en mesure de comprendre le fonctionnement de ces circuits et de les utiliser. Avant toutes choses, je souhaiterai aborder la liste du matériel nécessaire:

– 1 pile 6V ou un générateur 5V

– 7 Leds de couleurs quelconques

– 7 résistances de 320 ohms

– 1 Arduino

Une plaque de câblage, quelques straps (fils) et de la patience, c’est le « kit » de l’électronicien non ?

Allez, on y va, c’est parti pour la définition et présentation des circuits intégrés 74HC595.

 

1-   Que sont les circuits de type 74HC595 et quelles sont leurs possibles utilisations

 

Les Circuits Intégrés de type 74HC595 sont appelés « registres à décalage ». Derrière ce nom un peu barbare, se cache en fait l’un des circuits les plus intéressants, notamment pour nous, arduinistes que nous sommes. En effet, il vous est sans doute arrivé, tout comme moi, de manquer de broches sur votre Arduino pour réaliser tel ou tel circuit. Acheter l’Arduino MEGA n’est pas forcément la bonne solution à ce problème, vous allez comprendre pourquoi.

Les 74HC595 permettent, grâce à 3 entrées de contrôler 7 sorties différentes. Enfin… 7, c’est le minimum. En réalité, on peut contrôler 8, 16, 32, 64, 128 etc… Bref, une (presque) infinité de sorties. L’un des projets dans lesquels ces circuits sont les plus utiles est sans doute le cube de led. En effet, il suffit d’un rapide calcul : Un cube de leds de 4 x 4 x 4 leds nécessitera 64 sorties. En réfléchissant un peu, on peut abaisser ce nombre à 32. C’est là que les registres à décalages vont nous aider car, on pourrait supposer en utiliser 4 câblés 2 à 2, c’est-à-dire utilisant un total de 6 sorties de l’Arduino. On passe ainsi de 64 sorties théoriques à utiliser, à 6 ce qui permet d’ajouter des capteurs, etc…

Les utilisations sont donc diverses mais ces Circuits Intégrés restent essentiels dans le domaine de l’électronique sur des platines comme l’Arduino. Sachez pour votre information que les 74HC595 ne permettent pas de « multiplier » le nombre d’entrées disponibles sur l’Arduino, ce sont d’autres circuits qui permettent cela.

 

 2-  Fonctionnement des 74HC595

 

Les Circuits Intégrés de type 74HC595 portent assez bien leur nom de « registre à décalage ». En effet, l’utilisation de ces circuits repose en fait sur l’enregistrement d’un variable puis le décalage d’un cran ensuite. Pour expliquer cela, je vous propose une petite vidéo explicative réalisée grâce à un logiciel de CAO Electronique.

 

 

Ici, j’ai utilisé des boutons pour contrôler le 74HC595 mais nous allons apprendre ensemble à contrôler ces mêmes circuits grâce à l’Arduino.

3-  Mise en pratique et application des connaissances

 

Pour la mise en pratique, avec ce que nous avons appris précédemment, rien de bien compliqué. Voici les branchements à effectuer :

74HC959_right_2

Image tiré du blog bildr.org

 

Et maintenant, le programme commenté en français :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
int SER_Pin = 8;   //pin 14 sur le 75HC595
int RCLK_Pin = 9;  //pin 12 sur le 75HC595
int SRCLK_Pin = 10; //pin 11 sur le 75HC595
//Combien combinez-vous de 74HC595 ? Ne pas toucher si 1 seul
#define number_of_74hc595s 1
//Ne pas toucher
#define numOfRegisterPins number_of_74hc595s * 8
boolean registers[numOfRegisterPins];
void setup(){
pinMode(SER_Pin, OUTPUT);
pinMode(RCLK_Pin, OUTPUT);
pinMode(SRCLK_Pin, OUTPUT);
//Reset tous les pins du 74HC595
clearRegisters();
writeRegisters();
}
//Place tous les pins du 74HC595 à l'état "OFF"
void clearRegisters(){
for(int i = numOfRegisterPins - 1; i >=  0; i--){
registers[i] = LOW;
}
}
//Enregistrer et afficher les valeurs dans le registre
//Executer uniquement APRES que toutes les valeurs aient été programmées
void writeRegisters(){
digitalWrite(RCLK_Pin, LOW);
for(int i = numOfRegisterPins - 1; i >=  0; i--){
digitalWrite(SRCLK_Pin, LOW);
int val = registers[i];
digitalWrite(SER_Pin, val);
digitalWrite(SRCLK_Pin, HIGH);
}
digitalWrite(RCLK_Pin, HIGH);
}
//Place un pin du 74HC595 à l'état HAUT ou BAS
void setRegisterPin(int index, int value){
registers[index] = value;
}
void loop(){
setRegisterPin(2, HIGH);
setRegisterPin(3, HIGH);
setRegisterPin(4, LOW);
setRegisterPin(5, HIGH);
setRegisterPin(7, HIGH);
writeRegisters();  //Doit être exécuté pour appliquer les changements
//Executer seulement une fois que toutes les valeurs ont été enregistrées comme vous le souhaitiez.
}

 

Vous pouvez modifier ce programme pour l’adapter à votre utilisation.

 

Bonne semaine à tous et à bientôt pour un prochain tutoriel sur Simple-Duino.