18+ Arduino Projects - French

Machine Translated by Google
Table des matières
Pièces nécessaires .................................................. .................................................. .....................6
Présentation de l'Arduino .................................................................. .................................................. ......8
Feux de circulation ................................................ .................................................. .......................16
Luminosité des LED sur un écran LCD 16x2 ......................................... ...............................................22
Guide complet pour le capteur à ultrasons HCSR04 avec Arduino.....................................27
Capteur de stationnement................................................ .................................................. ....................34
Geste Slider Swiper .................................................. . .................................................. ........39
Arduino avec capteur de mouvement PIR ................................................ .......................................46
Contrôler les LED avec la télécommande IR…………………………………………………………….……… 49
Teensy/Arduino Jeu de mémoire............................................ .......................................58
Guide pour le capteur de gaz/fumée MQ2 avec Arduino ...................................... ....................66
Guide pour 8×8 Dot Matrix MAX7219 + Jeu Pong .................................. ................72
Accès de sécurité à l'aide du lecteur RFID MFRC522 avec Arduino ...................................... 86
Système de pointage Arduino avec RFID ................................................ .......................93
Enregistreur de données de température Arduino avec module de carte SD .................................................. 111
Application Android – LED RVB avec Arduino et Bluetooth......................................... ....... 118
Contrôler le moteur à courant continu via Bluetooth.............................................. ....................................... 128
Demander les données du capteur par SMS.............................................. .................................................. 133
Veilleuse de nuit avec Arduino .................................................. ................................ 149
Serveur Web Ethernet avec relais.............................................. ....................................... 154
Ressources................................................. .................................................. ....................... 163
Emballer................................................ .................................................. .................... 165
Cours de projets étape par étape Arduino .................................................. ........................ 166
Télécharger d'autres produits RNT.................................................. ............................................. 168
Comme Arduino ? Obtenez 25 cours de projets Arduino étape par étape
Clause de nonresponsabilité
Cet eBook a été rédigé à des fins d'information uniquement. Tous les efforts ont été faits pour rendre cet
eBook aussi complet et précis que possible.
Le but de cet eBook est d'éduquer. L'auteur (Rui Santos) ne garantit pas que les informations contenues
dans cet eBook sont complètes et décline toute responsabilité en cas d'erreur ou d'omission. L'auteur (Rui
Santos) n'assume aucune responsabilité envers toute personne ou entité en ce qui concerne toute perte
ou tout dommage causé ou prétendument causé directement ou indirectement par cet eBook.
Cet eBook contient des exemples de code que vous pouvez utiliser sur vos propres projets, sauf indication
contraire.
Vous ne pouvez pas redistribuer cet eBook.
Cet eBook est uniquement disponible en téléchargement gratuit sur :
• http://randomnerdtutorials.com/download
Veuillez envoyer un email à l'auteur (Rui Santos hello@ruisantos.me), si vous trouvez cet eBook ailleurs.
Introduction
Cet eBook est une compilation de certains de mes projets Arduino les plus populaires. Pour
plus de projets Arduino, jetez un œil au dépôt de notre projet Arduino.
Je vous encourage à regarder certaines des démonstrations vidéo. Certains de mes projets sont plus
faciles à comprendre si vous pouvez voir le circuit en action.
Cet eBook a pour but de vous inspirer à créer quelque chose d'incroyable avec l'électronique et la
programmation. Après avoir créé quelque chose de cool, j'espère que vous le partagerez avec d'autres.
C'est tout l'objectif de cette formidable communauté.
A tous mes lecteurs, merci de l'intérêt que vous portez à mon travail. J'apprécie vraiment cela!
Amusezvous avec vos projets,
Rui Santos
PS Assurezvous de visiter mon site Web pour voir les derniers projets!
http://RandomNerdTutorials.com
Connectezvous avec Rui
Si vous avez des questions, n'hésitez pas à me contacter. Voici quelques façons de rester en contact.
Visitez mon site web
(http://RandomNerdTutorials.com)
Abonnezvous sur YouTube
(https://www.youtube.com/user/RandomNerdTutorials)
Comme sur facebook
(https://www.facebook.com/RandomNerdTutorials)
Suis moi sur Twitter
(https://twitter.com/RuiSantosdotme)
Fork moi sur GitHub
(https://github.com/RuiSantosdotme)
Suivezmoi sur Instagram
(https://www.instagram.com/ruisantosme/)
Pièces requises
Pour créer des projets Arduino, vous avez besoin de composants électroniques à côté de la carte Arduino
nue. Dans chaque projet, nous fournissons une liste complète des pièces nécessaires et des liens vers
Maker Advisor, afin que vous puissiez trouver les pièces que vous cherchez sur votre magasin préféré
au meilleur prix.
Si vous achetez vos pièces via les liens Maker Advisor, nous gagnerons une petite commission d'affiliation
(vous ne paierez pas plus pour cela). En obtenant vos pièces via nos liens d'affiliation, vous soutenez
notre travail. Si vous recherchez un composant ou un outil, nous vous conseillons de jeter un œil à nos
outils et pièces préférés ici.
De quoi avezvous besoin pour commencer ?
À notre avis, la meilleure façon de démarrer avec l'Arduino est d'obtenir un kit de démarrage Arduino qui
contient tous les composants dont vous avez besoin pour apprendre les bases et commencer à faire des
projets.
Kit de démarrage complet Elegoo Arduino UNO R3
Il existe une grande variété de kits de démarrage Arduino. Le meilleur kit pour vous dépend de ce que
vous voulez faire et du montant que vous êtes prêt à dépenser. Nous vous recommandons de lire l'article
suivant sur les meilleurs kits de démarrage Arduino pour débutants :
• Meilleurs kits de démarrage Arduino Guide d'achat
Il existe également d'autres outils que nous vous recommandons de vous procurer, comme un multimètre
et un fer à souder.
Nous avons quelques articles pour vous aider à choisir le meilleur multimètre et fer à souder pour débutant :
• Meilleurs fers à souder pour débutants et amateurs • Meilleurs
multimètres à moins de 50 $
Vous trouverez peutêtre également utile de consulter l'article suivant qui vous donne des conseils pour
créer votre propre laboratoire d'électronique amateur :
• Comment configurer un laboratoire d'électronique : outils et équipement
Présentation de l'Arduino
L'Arduino est un petit ordinateur que vous pouvez programmer pour lire les informations du monde qui
vous entoure et envoyer des commandes au monde extérieur. Tout cela est possible car vous pouvez
connecter plusieurs appareils et composants à l'Arduino pour faire ce que vous voulez.
Vous pouvez réaliser des projets incroyables avec, il n'y a pas de limite à ce que vous pouvez faire et
en utilisant votre imagination, tout est possible !
Qu'estce qu'un Arduino ?
L'Arduino est la carte illustrée dans la figure cidessous.
Carte Arduino UNO R3 avec ATmega328P
Fondamentalement, il s'agit d'une petite carte de développement avec un cerveau (également appelé
microcontrôleur) que vous pouvez connecter à des circuits électriques. Cela facilite la lecture des
entrées lire les données de l'extérieur et contrôler les sorties envoyer une commande à l'extérieur.
Le cerveau de cette carte (Arduino Uno) est une puce ATmega328p où vous pouvez stocker vos
programmes qui diront à votre Arduino quoi faire.
Explorer la carte Arduino Uno
Dans la figure cidessous, vous pouvez voir une carte Arduino étiquetée. Voyons ce que chaque partie
fait.
• Microcontrôleur : l' ATmega328p est le cerveau Arduino. Tout sur la carte Arduino est destiné à
prendre en charge ce microcontrôleur. C'est là que vous stockez vos programmes pour dire à
l'Arduino quoi faire. • Broches numériques : Arduino dispose de 14 broches numériques, étiquetées
de 0 à 13 qui peuvent servir d'entrées ou de sorties. o Lorsqu'elles sont définies comme entrées, ces
broches peuvent lire la tension. Ils savent seulement lire
deux états : HIGH ou LOW.
o Lorsqu'elles sont définies comme sorties, ces broches peuvent appliquer une tension. Ils ne peuvent postuler que
5V (ÉLEVÉ) ou 0V (BAS).
• Broches PWM : il s'agit de broches numériques marquées d'un ~ (broches 11, 10, 9, 6, 5 et 3).
PWM signifie «modulation de largeur d'impulsion» et permet aux broches numériques de produire
de «fausses» quantités variables de tension. Vous en apprendrez plus sur PWM plus tard. •
Broches TX et RX : broches numériques 0 et 1. Le T signifie « émission » et le R signifie « réception
». L'Arduino utilise ces broches pour communiquer avec d'autres appareils électroniques via série.
Arduino utilise également ces broches pour communiquer avec votre ordinateur lors du
téléchargement d'un nouveau code. Évitez d'utiliser ces broches pour d'autres tâches que la
communication série, sauf si vous manquez de broches.
• LED attachée à la broche numérique 13 : Ceci est utile pour un débogage facile du
Esquisses Arduino.
• LED TX et RX : ces LED clignotent lorsqu'il y a des informations en cours d'envoi
entre l'ordinateur et l'Arduino.
• Broches analogiques : les broches analogiques sont étiquetées de A0 à A5 et sont souvent utilisées
pour lire des capteurs analogiques. Ils peuvent lire différentes quantités de tension entre 0 et 5V.
De plus, ils peuvent également être utilisés comme broches de sortie/entrée numériques comme
les broches numériques.
• Broches d'alimentation : l'Arduino fournit 3,3 V ou 5 V via ces broches. Ceci est très utile car la plupart
des composants nécessitent 3,3 V ou 5 V pour fonctionner. Les broches étiquetées "GND" sont les
broches de masse. • Bouton de réinitialisation : lorsque vous appuyez sur ce bouton, le programme
en cours d'exécution dans votre Arduino redémarre. Vous avez également une broche de réinitialisation
à côté des broches d'alimentation qui sert de bouton de réinitialisation. Lorsque vous appliquez une
petite tension à cette broche, cela réinitialisera l'Arduino. • LED Power ON : s'allume dès que
l'alimentation est appliquée à l'Arduino. • Prise USB : vous avez besoin d'un câble USB A mâle vers
USB B mâle (illustré dans la figure cidessous) pour télécharger des programmes de votre ordinateur
vers votre carte Arduino. Ce câble alimente également votre Arduino.
• Prise d'alimentation : vous pouvez alimenter l'Arduino via la prise d'alimentation. La tension d'entrée
recommandée est de 7V à 12V. Il existe plusieurs façons d'alimenter votre Arduino : piles
rechargeables, piles jetables, verrues murales et panneau solaire, par exemple. Pour plus
d'informations sur ce sujet, vous pouvez lire cet article de blog sur Random Nerd Tutorials Arduino
5 Ways to Power Up your Arduino.
Remarque : Pour plus d'informations sur les pièces matérielles Arduino, visitez la page Web officielle
d'Arduino.
dix
Téléchargement de l'IDE Arduino
L'IDE Arduino (environnement de développement intégré) est l'endroit où vous développez vos programmes qui diront
à l'Arduino quoi faire.
Vous pouvez charger de nouveaux programmes sur la puce principale, l'ATmega328p, via USB à l'aide de l'IDE
Arduino. Pour télécharger l'IDE Arduino, veuillez cliquer sur le lien suivant : https://www.arduino.cc/en/Main/Software.
Sélectionnez le système d'exploitation que vous utilisez et téléchargezle. Ensuite, suivez simplement l'assistant
d'installation pour installer le
EDI Arduino
Lorsque vous ouvrez l'IDE Arduino pour la première fois, vous devriez voir quelque chose de similaire à la figure
dessous:
11
Connecter votre Arduino
Connectez votre Arduino UNO à votre ordinateur via USB.
Après avoir connecté votre Arduino avec un câble USB, vous devez vous assurer que l'IDE
Arduino a sélectionné la bonne carte.
Dans notre cas, nous utilisons Arduino Uno, nous devons donc aller dans Outils Carte :
Arduino/Genuino Uno.
Ensuite, vous devez sélectionner le port série auquel votre Arduino est connecté. Allez dans
Outils Port et sélectionnez le bon port.
12
Télécharger un croquis Arduino
Pour vous montrer comment télécharger du code sur votre carte Arduino, nous allons vous montrer un exemple
simple. C'est l'un des exemples les plus basiques il consiste à faire clignoter la LED embarquée ou la broche
numérique 13 toutes les secondes.
1. Ouvrez votre IDE Arduino.
2. Allez dans Fichier Exemples 01.Bases Clignotement
Par défaut, l'IDE Arduino est préconfiguré pour l'Arduino UNO. Cliquez sur le bouton Télécharger et attendez
quelques secondes.
13
Après quelques secondes, vous devriez voir un message de téléchargement terminé .
Ce code fait simplement clignoter la LED intégrée sur votre Arduino UNO (surlignée en rouge). Vous devriez voir la petite LED
s'allumer pendant une seconde, et s'éteindre pendant une autre seconde à plusieurs reprises.
Contrôler une sortie et lire une entrée
Une carte Arduino contient des broches numériques, des broches analogiques et des broches PWM.
Différence entre numérique, analogique et PWM Dans les broches
numériques, vous n'avez que deux états possibles, qui sont activés ou désactivés. Ceuxci peuvent également être appelés
High ou Low, 1 ou 0 et 5V ou 0V.
Par exemple, si une LED est allumée, son état est High ou 1 ou 5V. S'il est éteint, vous aurez Low, ou 0 ou 0V.
Dans les broches analogiques, vous avez un nombre illimité d'états possibles entre 0 et 1023. Cela vous permet de lire les
valeurs des capteurs. Par exemple, avec un capteur de lumière, s'il fait très sombre, vous lirez 1023, s'il est très clair, vous lirez
0 S'il y a une luminosité entre sombre et très clair, vous lirez une valeur comprise entre 0 et 1023 .
14
Les broches PWM sont des broches numériques, elles produisent donc 0 ou 5V. Cependant, ces broches
peuvent produire de "fausses" valeurs de tension intermédiaire entre 0 et 5V, car elles peuvent effectuer une
"modulation de largeur d'impulsion" (PWM). PWM permet de "simuler" différents niveaux de puissance en
faisant osciller la tension de sortie de l'Arduino.
Contrôler une sortie Pour
contrôler une sortie numérique, vous utilisez la fonction digitalWrite() et entre parenthèses vous écrivez, la
broche que vous souhaitez contrôler, puis HIGH ou LOW.
Pour contrôler une broche PWM, vous utilisez la fonction analogWrite () et entre parenthèses, vous écrivez la
broche que vous souhaitez contrôler et un nombre compris entre 0 et 255.
Lecture d'une entrée
Pour lire une entrée analogique on utilise la fonction analogRead() et pour une entrée numérique on utilise
digitalRead().
La meilleure façon pour vous d'apprendre Arduino est de pratiquer. Alors, choisissez un projet et commencez à
construire quelque chose.
15
Feux de circulation
Afficher le code sur GitHub Cliquez ici
Introduction
Dans ce projet, vous allez construire un système de feux de circulation :
• Il y a 3 LED de couleurs différentes (vert, jaune et rouge) pour imiter les feux de circulation pour
les voitures • Il y a 2 LED de couleurs différentes (vert et rouge) pour imiter le trafic
feux pour les piétons
• Il y a un bouton poussoir pour imiter ceux des feux piétons
16
Pièces requises
Prenez tous les composants nécessaires pour ce projet.
• 1x planche à pain
• Arduino UNO – lire les meilleurs kits de démarrage Arduino
• 3 LED de 5 mm (1x rouge, 1x jaune, 1x vert) • 2x LED
3mm (1x rouge, 1x vert) • 5x résistance 220Ohm
• 1x résistance 10kOhms
• 1x bouton poussoir •
Fils de cavalier
J'utilise des LED de tailles différentes mais si vous n'avez pas de LED de tailles différentes, ça va.
Le projet fonctionne toujours.
17
Schémas
Assemblez toutes les pièces en suivant les schémas cidessous.
Code
Vous n'avez besoin d'aucune bibliothèque pour ce code. Le code est très simple. Voici quelques
conseils pour mieux comprendre ce qui se passe.
• Le feu de voiture est toujours vert, et donc le feu de piéton est toujours rouge à moins que
quelqu'un appuie sur le bouton.
• Lorsque quelqu'un appuie sur le bouton voici ce qui se passe : • Le feu
de la voiture passe au jaune puis au rouge • Le feu piéton passe au vert
18
• Les lumières sont dans cet état pendant un certain temps (dans le code, cette fois est la
temps de croisement variable)
• Le feu vert piéton clignote et passe au rouge • Le feu voiture passe
du rouge au vert
Toutes ces actions seront à l'intérieur de la fonction changeLights(). Chaque fois que vous voulez changer
les lumières, il vous suffit d'appeler la fonction changeLights() .
Copiez le code suivant dans votre IDE Arduino et téléchargezle sur votre carte Arduino.
Assurezvous d'avoir sélectionné la bonne carte et le bon port COM.
Afficher le code sur GitHub
/*
* Rui Santos
* Détails complets du projet http://randomnerdtutorials.com
*/
int voiture rouge = 13 ;
int yellowCar = 12 ;
int voiture verte = 11 ;
int vertPed = 2 ;
int redPed = 3 ;
bouton int = 7 ;
int crossTime = 2000 ;
changeTime long non signé ;
annuler la configuration() {
// initialise le temporisateur
changeHeure = millis();
// Ici, nous initialisons nos broches en tant que sorties
pinMode(redCar, OUTPUT);
pinMode(voiturejaune, SORTIE);
pinMode(greenCar, SORTIE);
pinMode(redPed, OUTPUT);
pinMode(greenPed, SORTIE);
pinMode (bouton, ENTRÉE);
// allume le feu vert
digitalWrite(greenCar, HIGH);
digitalWrite(redPed, HIGH);
digitalWrite(rougeCar, BAS);
digitalWrite(yellowCar, LOW);
digitalWrite(greenPed, LOW);
19
Série.begin(9600);
boucle vide () {
// cette variable nous dira si le bouton est appuyé
int state = digitalRead(bouton);
Serial.println(état);
// si le bouton est appuyé et s'il s'est écoulé 5 secondes depuis le dernier appui sur le bouton
si (état == ÉLEVÉ && (millis() changeTime) > 5000) {
// appelez la fonction pour changer les lumières
changeLumières();
void changeLights() {
digitalWrite(greenCar, LOW); digitalWrite(yellowCar, // la LED verte s'éteindra
HIGH); // la LED jaune s'allumera pendant 2 secondes
retard (2000);
digitalWrite(yellowCar, LOW); // la LED jaune s'éteindra
digitalWrite(rougeCar, ÉLEVÉ); // la LED rouge s'allumera pendant 5 secondes
digitalWrite(redPed, LOW); digitalWrite(greenPed,
HIGH);
retard(crossTime);
// fait clignoter le ped vert
pour (int x=0; x<10; x++) {
retard(100);
digitalWrite(greenPed, HIGH);
retard(100);
digitalWrite(rougeCar, BAS);
digitalWrite(redPed, HIGH);
digitalWrite(greenCar, HIGH);
changeHeure = millis();
20
Manifestation
Lorsque vous appuyez sur le bouton, le feu des voitures passe du vert au rouge et le feu
des piétons passe du rouge au vert.
Après le temps de traversée, la led verte piéton clignote et passe au rouge. Le feu des
voitures passe du rouge au vert.
Emballer
Si vous débutez avec l'Arduino, un bon exercice consiste à modifier la valeur de certaines
variables telles que crossTime et changeTime et à voir ce qui se passe.
Si vous voulez quelque chose d'un peu plus difficile, essayez d'imiter ce qui se passe dans
un carrefour, avec plusieurs feux pour plusieurs voitures et piétons.
21
Luminosité LED sur un écran LCD 16x2
Voir le projet sur les didacticiels Random Nerd Cliquez ici
Regarder sur YouTube Cliquez ici
Introduction
Il s'agit d'un projet pour débutant dans lequel vous utiliserez un écran LCD 16 × 2 pour afficher la luminosité des LED.
Bientôt, dans ce projet, nous allons contrôler la luminosité d'une LED à l'aide d'un potentiomètre. La luminosité de la
LED sera affichée sur l'écran LCD à l'aide d'une barre de progression
22
Regardez la vidéo cidessous
Regarder sur YouTube : http://youtu.be/sAklcqiywPw
Présentation de l'écran LCD
Le moyen le plus simple et le moins coûteux d'afficher des informations consiste à utiliser un écran LCD
(affichage à cristaux liquides). Ceuxci se trouvent dans les appareils électroniques de tous les jours tels
que les distributeurs automatiques, les calculatrices, les parcomètres, les imprimantes, etc. Elles sont
idéales pour afficher du texte ou de petites icônes. La figure cidessous montre un écran LCD 16 × 2 avant et arrière
voir.
Cet écran LCD a 2 lignes, et chaque ligne peut afficher 16 caractères. Il dispose également d'un
rétroéclairage LED pour régler le contraste entre les caractères et l'arrièreplan.
23
Pièces requises
Pour ce projet, vous avez besoin des pièces suivantes :
• 1x ACL 16×2
• 2x potentiomètres 10k Ohm
• 1 DEL de 5 mm
• 1x résistance 220 Ohms
• Fils de liaison
Schémas
Câblez toutes les pièces en suivant le diagramme schématique suivant.
24
Le tableau suivant montre une brève description de chaque broche de l'écran LCD. Assurezvous que votre
écran LCD utilise le même brochage.
Code
Copiez le code suivant et téléchargezle sur votre carte Arduino. Le code est bien commenté afin que vous
puissiez facilement comprendre son fonctionnement et le modifier pour l'inclure dans vos propres projets.
/*
Réalisé par Rui Santos
Toutes les ressources pour ce projet : http://
randomnerdtutorials.com/
Basé sur quelques exemples de code Arduino */
// inclut le code de la bibliothèque #include
<LiquidCrystal.h>
// initialise la bibliothèque avec les numéros des broches de l'interface
LCD LiquidCrystal (12, 11, 5, 4, 3, 2); int potPin = A0 ; int
ledPin = 6; int potValue = 0 ; potentiomètre
// Broche
int
alnalogique
uminosité 0 pour le potentiomètre de luminosité LED
= 0 ; int pBari = 0 ; int je = 0 ; // Broche numérique LED avec PWM
// variable pour stocker la valeur provenant de la
// convertit le potValue en luminosité // barre de progression //
boucle de plancher
//caractère de barre de progression pour l'octet de luminosité
pBar[8] = {
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
25
B11111,
} ;
// configurez notre led en tant que OUTPUT
pinMode (ledPin, OUTPUT); // configure le nombre
de colonnes et de lignes du LCD : lcd.begin(16, 2); // Affiche un message sur
l'écran LCD lcd.print(" LED Brightness"); //Crée le caractère de la barre de
progression lcd.createChar(0, pBar);
boucle vide () {
// efface l'écran LCD
lcd.clear(); // Affiche
un message sur l'écran LCD lcd.print(" LED
Brightness"); // place le curseur sur la ligne numéro
2 lcd.setCursor(0,1); // lit la valeur du potentiomètre
potValue = analogRead(potPin); // transforme le potValue
en une luminosité pour la LED bright=map(potValue, 0, 1024, 0,
255); // allume la LED en fonction de la luminosité analogWrite(ledPin,
bright); // transforme la luminosité en pourcentage pour la barre pBari=map(brightness,
0, 255, 0, 17); //imprime la barre de progression pour (i=0; i<pBari; i++)
{
lcd.setCursor(i, 1);
lcd.write(octet(0));
} // retarde 750 ms
delay(750);
}
26
Guide complet pour les ultrasons
Capteur HCSR04 avec Arduino
Cliquez ici
Cliquez ici
Ce projet concerne le capteur à ultrasons HC – SR04. Nous expliquerons comment cela fonctionne,
montrerons certaines fonctionnalités et partagerons un exemple de projet Arduino. Nous fournissons un
diagramme schématique sur la façon de câbler le capteur à ultrasons et un exemple de croquis à utiliser
avec votre Arduino.
Description
Le capteur à ultrasons HCSR04 utilise un sonar pour déterminer la distance à un objet comme le font les
chauvessouris. Il offre une excellente détection de plage sans contact avec une grande précision et des
lectures stables dans un boîtier facile à utiliser. De 2 cm à 400 cm ou 1" à 13 pieds. Son fonctionnement
n'est pas affecté par la lumière du soleil ou les matériaux noirs comme le sont les télémètres pointus (bien
que les matériaux acoustiquement doux comme le tissu puissent être difficiles à détecter). Il est livré avec un
module émetteur et récepteur à ultrasons.
27
Caractéristiques
• Alimentation : +5V DC • Courant
de repos : <2mA • Courant de travail :
15mA • Angle effectif : <15° • Distance
de portée : 2cm – 400 cm/1″ – 13ft •
Résolution : 0,3 cm
• Angle de mesure : 30 degrés • Largeur
d'impulsion d'entrée de déclenchement : 10 uS
Comment ça marche?
Le capteur à ultrasons utilise un sonar pour déterminer la distance à un objet. Voici ce qui se passe :
1. L'émetteur (trig pin) envoie un signal : un son à haute fréquence ; 2. Lorsque le signal
trouve un objet, il est réfléchi et…
3. L'émetteur (broche d'écho) le reçoit.
Le temps entre l'émission et la réception du signal nous permet de calculer la distance à un objet. Ceci est
possible car nous connaissons la vitesse du son dans l'air.
28
Broches du capteur
• VCC : +5 VCC
• Trig : Déclenchement (INPUT)
• Echo : Echo (OUTPUT)
• TERRE : TERRE
Où acheter?
Vous pouvez vérifier le capteur Ultrasonic Sensor HCSR04 sur Maker Advisor et trouver le
meilleur prix.
Arduino avec capteur HCSR04
Dans ce projet, le capteur à ultrasons lit et écrit la distance à un objet dans le
Moniteur série.
Le but de ce projet est de vous aider à comprendre le fonctionnement de ce capteur. Ensuite, vous pouvez utiliser
cet exemple dans vos propres projets.
Remarque : Il existe une bibliothèque Arduino appelée NewPing cela peut vous faciliter la vie lorsque vous utilisez
ce capteur.
29
Pièces requises
• Capteur à ultrasons (HCSR04)
• Planche à pain
• Fils de liaison
Schémas
Suivez le diagramme schématique suivant pour câbler le capteur à ultrasons HCSR04 au
Arduino.
Le tableau suivant indique les connexions que vous devez effectuer :
Capteur à ultrasons HCSR04 Arduino
VCC 5V
Trigonométrie
Broche 11
Écho Broche 12
Terre Terre
30
Code
Téléchargez le code suivant dans votre IDE Arduino.
/*
* créé par Rui Santos, http://randomnerdtutorials.com
*
* Guide complet pour le capteur à ultrasons HCSR04
*
Broches du capteur à ultrasons :
VCC : +5 VCC
Déclenchement : Déclenchement (ENTRÉE) Pin11
Écho : Écho (SORTIE) Broche 12
GND : GND
*/
int trigPin = 11 ; //Trig pull vert
int echoPin = 12 ; //Echo Pull jaune
longue durée, cm, pouces ;
// Début du port série
Serial.begin (9600);
//Définir les entrées et les sorties
pinMode(trigPin, SORTIE);
pinMode(echoPin, INPUT);
}
boucle vide ()
{
// Le capteur est déclenché par une impulsion HIGH de 10 microsecondes ou plus.
// Donnez une courte impulsion BASSE au préalable pour assurer une impulsion HAUTE propre :
digitalWrite(trigPin, LOW);
retardMicrosecondes(5);
digitalWrite(trigPin, HIGH);
// Lecture du signal du capteur : une impulsion HIGH dont
31
// la durée est le temps (en microsecondes) depuis l'envoi
// du ping à la réception de son écho d'un objet.
durée = pulseIn(echoPin, HIGH);
// convertit le temps en distance
cm = (durée/2) / 29,1 ;
pouces = (durée/2) / 74 ;
Serial.print(pouces);
Serial.print("dans, ");
Serial.print(cm);
Serial.print("cm");
Serial.println();
retard(250);
}
Coder avec NewPing
Vous pouvez également utiliser la bibliothèque NewPing. Téléchargez la bibliothèque ici. Après avoir
installé la bibliothèque NewPin, vous pouvez télécharger le code fourni cidessous.
/*
* Publié sur http://randomnerdtutorials.com * créé par http://
playground.arduino.cc/Code/NewPing */
#include <NouveauPing.h>
#define TRIGGER_PIN 11 #define
ECHO_PIN 12 #define
MAX_DISTANCE 200
Sondeur NewPing(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // Configuration NewPing des broches et de la distance
maximale.
void setup()
{ Serial.begin(9600);
}
void loop()
{ retard(50); int
non signé uS = sonar.ping_cm(); Serial.print(uS);
Serial.println("cm");
32
Dépannage
REMARQUE : "Si le HCSR04 ne reçoit pas d'écho, la sortie ne passe jamais
faible. Les capteurs Devantec et Parallax expirent après 36 ms et je pense 28 ms
respectivement. Si vous utilisez Pulsin comme cidessus, sans écho de retour, le programme se bloquera pendant
1 seconde, ce qui est le délai d'attente par défaut pour Pulsin. Vous devez utiliser le paramètre timeout.
http://arduino.cc/en/Reference/PulseIn Le HC
SR04 fonctionne à peine à 10 pieds, ce qui donne une longueur totale de trajet de 20 pieds et un temps de
trajet d'environ 20 ms, alors réglez le délai d'attente sur quelque chose audessus de cela, disons 25 ou 30 ms.
Si vous mettez une résistance, disons 2k2 entre E et T, puis connectezvous uniquement à T, vous pouvez utiliser
le HCSR04 à partir d'une seule broche Arduino. Rechercher le fonctionnement à une seule broche des ultrasons
capteurs.
De plus, si vous utilisez un HCSR04 avec un PicAxe, vous devez augmenter la vitesse d'horloge à au moins 8
MHz, sinon ils ne voient pas le début de l'impulsion d'écho, donc la pulsine ne démarre jamais. Le HCSR04
fonctionne bien avec un BS2. par David Buckley
Emballer
Dans cet article, nous vous avons montré comment fonctionne le capteur à ultrasons HCSR04 et comment vous
pouvez l'utiliser avec Arduino. Si vous êtes un débutant à l'Arduino, nous vous recommandons de suivre notre
cours Arduino Mini cela vous aidera à démarrer rapidement avec cette planche étonnante.
33
Capteur de stationnement
Introduction
Dans ce projet, nous avons un capteur à ultrasons qui mesure la distance et un graphique à barres LED qui
s'allume en fonction de notre distance par rapport au capteur. Au fur et à mesure que nous nous rapprochons
du capteur, le buzzer émet un bip différent. Ce circuit peut fonctionner comme un capteur de stationnement.
34
Pièces requises
• 1x 74HC595 8 Bit Shift Register • 1x
Breadboard
• 8x LED (par exemple : 3x rouges, 3x jaunes, 2x vertes) • 9
résistances 220 ohms
• 1x sonnerie
• 1x capteur à ultrasons (par exemple : HCSR04) • Fils
de cavalier
Schémas
Assemblez le circuit en suivant le schéma de principe suivant :
35
Code
Téléchargez le code suivant sur votre carte Arduino :
/*
* créé par Rui Santos, http://randomnerdtutorials.com
* Capteur à ultrasons avec graphique à barres LED et buzzer
*/
int tonePin = 4 ; //Tone Pull rouge
int trigPin = 9 ; //Trig cavalier violet int echoPin =
10 ; //Echo cavalier jaune int clockPin = 11 ; //IC Pin 11 cavalier blanc
int latchPin = 12 ; //IC Pin 12 Cavalier bleu int dataPin = 13 ; // IC Pin 14
Cavalier vert
octet possible_patterns[9] = {
B00000000,
B00000001,
B00000011,
B00000111,
B00001111,
B00011111,
B00111111,
B01111111,
B11111111,
} ;
int proximité=0 ;
int durée ;
distance entière ;
//Port série
Serial.begin (9600);
pinMode(trigPin, SORTIE);
pinMode(horlogePin, SORTIE);
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(tonePin, SORTIE);
}
36
boucle vide () {
digitalWrite(latchPin, LOW);
digitalWrite(trigPin, HIGH);
durée = pulseIn(echoPin, HIGH);
distance = (durée/2) / 29,1 ;
/*si (distance >= 45 || distance <= 0){
Serial.println("Hors plage");
}
autre {
Serial.print(distance);
Serial.println(" cm");
}*/
proximité=carte(distance, 0, 45, 8, 0); //Serial.println(proximité);
si (proximité <= 0){
proximité=0 ;
}
sinon si (proximité >= 3 && proximité <= 4){
ton(tonePin, 200000, 200);
ton(tonePin,5000, 200);
ton(tonePin, 1000, 200);
shiftOut(dataPin, clockPin, MSBFIRST, possible_patterns[proximity]); digitalWrite(latchPin, HIGH);
retard (600);
pas de ton(tonePin);
37
Regardez la vidéo de démonstration
Regarder sur YouTube : http://youtu.be/7ZPc__5tL3c
38
Glissière de curseur de geste
Dans ce projet, vous allez apprendre à configurer une carte Arduino UNO en tant que clavier USB HID et à
utiliser des gestes pour balayer les diapositives lors d'une présentation.
Remarque : Ce projet a été écrit par Emmanuel Odunlade et édité par Rui Santos.
39
Arduino UNO ou Mega comme clavier USB HID
L'Arduino peut être configuré pour émuler un clavier et effectuer des tâches utiles.
En attachant un boutonpoussoir à une broche numérique Arduino et en appuyant sur un bouton, vous
pouvez écrire un mot de passe, copier+coller, volume haut/bas, luminosité écran haut/bas, etc…
Bien que les cartes comme l'Arduino UNO ne puissent pas le faire par défaut si vous flashez un nouveau
chargeur de démarrage, vous pouvez transformer la carte Arduino UNO en un clavier USB HID.
Un Arduino Uno/Mega possède deux microcontrôleurs : ATmega328 et 16u2. Le 16u2 est normalement
utilisé pour la communication USB vers série. Nous pouvons également l'utiliser comme microcontrôleur
AVR autonome avec (ou sans) fonctions USB.
HoodLoader2 vous donne la possibilité de reprogrammer le 16u2 d'un Arduino Uno/Mega R3 normal avec
des croquis personnalisés. Cela signifie que vous pouvez utiliser le 16u2 comme un AVR USB normal
comme une carte Arduino Leonardo. Vous disposez d'un noyau USBHID entièrement compatible.
Vous pouvez préparer votre Arduino UNO ou Arduino Mega pour qu'il agisse comme un clavier avec le
HoodLoader2 bootloader en suivant les instructions de leur page Wiki officielle.
• Cartes Arduino prises en charge utilisant Arduino IDE 1.6.7 ou supérieur : • Uno
(nécessite le chargeur de démarrage HoodLoader2)
• Mega (nécessite le bootloader HoodLoader2) •
Leonardo
• (Pro) Micro
40
Pièces requises
Voici une liste complète des composants dont vous avez besoin pour ce projet :
• Arduino UNO, Mega, Leonardo, ProMicro ou toute autre carte compatible
8u2/16u2/at90usb8/162/32u2/32u4
• 2x capteur à ultrasons HCSR04
• 2x LED
• 2 résistances de 220 ohms
• Planche à pain
• Fils de liaison
Code
Pour utiliser votre Arduino comme clavier, vous devez installer la bibliothèque HID.
Installation de la bibliothèque HID
1. Cliquez ici pour télécharger le HID bibliothèque. Vous devriez avoir un dossier .zip dans votre
Dossier de téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir le dossier HIDmaster
3. Renommez votre dossier de HIDmaster en HID 4. Déplacez le dossier HID
dans le dossier des bibliothèques d'installation de votre IDE Arduino 5. Enfin, rouvrez votre
IDE Arduino
41
Copiez le code suivant dans votre IDE Arduino et chargezle sur votre carte Arduino :
/*
* Auteur : Emmanuel Odunlade
*/
#include <HID.h>// inclure la bibliothèque
int swipe = 0;//slide
booléen gauche = faux ;
booléen droit = faux ;
int maxD = 5;//(en cm) distance maximale des ultrasons à laquelle l'obstruction sera considérée comme un geste
int long lastTouch = 1 ;
int resetAfter = 1000;//ms
int afterslideDelay = 500;// int slideleft_Begin = 1;
int slideNone = 0;
int slideright_Begin =1 ;
//Déclaration des broches connectées
int lLed = 7 ;
int rLed = 6 ;
const int lEcho = 2;
const entier lTrig = 3 ;
const int rEcho = 4 ;
const entier rTrig = 5 ;
annuler la configuration(){
pinMode(lLed,OUTPUT);
pinMode(rLed,SORTIE);
pinMode(rEcho,ENTRÉE);
pinMode(rTrig,OUTPUT);
pinMode(lEcho,INPUT);
pinMode(lTrig,OUTPUT);
// Envoie un rapport propre à l'hôte. Ceci est important car
// le 16u2 de l'Uno/Mega n'est pas éteint pendant la programmation // donc vous voulez commencer avec un rapport
propre pour éviter des bogues étranges après
réinitialiser.
42
pressRawKeyboard(0, 0);
}
// obtenir la distance //
l'écho est entré, le déclencheur est sorti
unsigned long measureD (entrée int , sortie int ) {
digitalWrite(sortie, HIGH);
digitalWrite(sortie, BAS);
longue portée = pulseIn (entrée, HIGH);
int distance= range / 29 / 2;// pour obtenir la distance en cm
distance de retour ;
//
acte booléen ( entrée int , sortie int , led int ) {
int d = mesureD(entrée,sortie);
booléen pinActivated = faux ;
si (d < maxD){
digitalWrite(led,HIGH);
pinActivé = vrai ;
}
autre{
digitalWrite (led, FAIBLE);
pinActivé = faux ;
}
broche de retour activée ;
}
void slideNow(char directn){
si ('R' == directn)
// appuyez sur la touche de droite
//Serial.println("F");
pressRawKeyboard(0,RAW_KEYBOARD_RIGHT_ARROW); //modificateurs + touche pressRawKeyboard(0,
0); // libérer! Important
}
si ('L' == directn)
//appuyez sur la flèche gauche
//Serial.println("B"); pour le débogage
pressRawKeyboard(0,RAW_KEYBOARD_LEFT_ARROW); // //modificateurs + touche pressRawKeyboard(0,
0); // libérer! Important
43
retard(afterslideDelay);
glisser = slideNone ;
}
void pressRawKeyboard ( modificateurs uint8_t, clé uint8_t ){
uint8_t clés[8] = {
modificateurs, 0, clé, 0, 0, 0, 0, 0 } ; //modificateurs, réservés, clé[0]
HID_SendReport(HID_REPORTID_KeyboardReport, keys, sizeof(keys));
}
boucle vide (){
gauche = act(lEcho,lTrig,lLed);
droite = agir ( rEcho , rTrig , rLed ) ;
si (gauche || droite){
lastTouch = millis();
if (millis() lastTouch > resetAfter){
glisser = 0 ;
//serial.println(@reset slide& timer);
}
if (swipe >= slideNone){
si ((gauche)&&(!droite)){
glisser = slideright_Begin ;
}
if ((right)&&(swipe == slideright_Begin)){
slideNow('R');
if (swipe <= slideNone ){
si ((droite)&&(!gauche)){
glisser = slideleft_Begin ;
}
si ((gauche) && (glisser == slideleft_Begin)){
slideNow('L');
retard(50);
}
44
Schémas
Câblez votre circuit conformément au schéma cidessous :
Maintenant, si vous déplacez une main devant le capteur à ultrasons gauche, votre Arduino envoie une
commande clavier gauche entraînant le déplacement de la présentation vers la diapositive précédente.
Emballer
J'ai toujours été fasciné par les interfaces utilisateur naturelles, l'idée de choses comme le sixième sens
(sur lequel j'espère partager un tutoriel un jour) et généralement toutes les choses qui font de la
télékinésie une possibilité.
Ainsi, je pense que plusieurs mises à jour pourraient être apportées à ce projet. Au lieu d'utiliser des
capteurs à ultrasons et de contrôler les côtés, que se passetil si nous attachons un casque
d'électroencéphalogramme (EEG), puis faisons des choses plus complexes comme dessiner des formes
et réaliser tout cela dans le cadre de simplicité fourni par Arduino.
Les possibilités sont donc infinies. Hackezle !
45
Arduino avec capteur de mouvement PIR
Dans ce projet, nous allons créer un circuit simple avec un mouvement Arduino et PIR
capteur capable de détecter un mouvement.
Regarder sur YouTube : http://youtu.be/vJgtckLzoKM
46
Pièces requises
• 1x capteur de mouvement PIR (HCSR501)
• 1x DEL
• Fils de liaison
Schémas
Assemblez toutes les pièces en suivant le schéma cidessous.
47
Code
Téléchargez le code suivant sur votre carte Arduino.
/*
Arduino avec capteur de mouvement PIR
Modifié par Rui Santos basé sur le capteur PIR de Limor Fried
*/
s
led int = 13 ; // la broche à laquelle la LED est attachée // la broche à laquelle le
int capteur = 2 ; capteur est attaché // par défaut, aucun mouvement détecté // variable pour
état entier = BAS ; stocker l'état du capteur (valeur)
valeur entière = 0 ;
void setup() { pinMode(led,
OUTPUT); pinMode(capteur, INPUT); // initialise la LED en tant que sortie // initialise le capteur
Série.begin(9600); en tant qu'entrée // initialise la série
boucle vide (){
val = digitalRead(capteur); // lit la valeur du capteur // vérifie si le capteur est HIGH if (val ==
HIGH) {
digitalWrite (led, HIGH); // allume le délai LED(100);
// retard de 100 millisecondes
si (état == BAS) {
Serial.println("Mouvement détecté!");
état = ÉLEVÉ ; // met à jour l'état de la variable à HIGH
}
}
sinon {
digitalWrite(led, LOW); // éteint le délai LED (200);
// retard de 200 millisecondes
if (state == HIGH)
{ Serial.println("Mouvement arrêté !");
état = BAS ; // met à jour l'état de la variable à LOW
}
}
}
Emballer
Ce projet montre un exemple simple sur la façon d'utiliser le capteur de mouvement PIR avec l'Arduino.
Désormais, vous pouvez utiliser le capteur de mouvement PIR dans des projets plus avancés. Par
exemple, vous pouvez créer un projet Night Security Light.
48
Contrôlez les LED avec la télécommande IR
Cliquez ici
Cliquez ici
Introduction
Dans ce projet, vous utiliserez un récepteur infrarouge (IR) pour contrôler 3 LED avec une télécommande.
Vous les allumerez et les éteindrez avec les boutons de votre télécommande. Il s'agit d'un bon projet pour
débutant pour vous familiariser avec le récepteur infrarouge.
Ce projet est divisé en deux parties :
• Vous décoderez les signaux IR transmis par votre télécommande • Vous utiliserez
ces informations pour effectuer une tâche avec votre Arduino (contrôlez 3 LED)
49
Récepteur infrarouge (IR)
Le récepteur infrarouge est le composant de la figure cidessous. Il s'agit du TSOP4838.
Comme vous pouvez le voir, il a trois broches :
• OUT (SORTIE) •
GND (Terre)
• VCC (source de tension)
Lorsque vous appuyez sur votre télécommande, celleci envoie des signaux infrarouges modulés. Ces
signaux contiennent des informations collectées par votre récepteur.
50
Chaque bouton envoie des informations spécifiques. Ainsi, nous pouvons attribuer ces informations à un bouton
spécifique.
Pièces requises
Pour ce projet, vous aurez besoin d'une télécommande. Si vous n'avez pas de télécommande à la maison, vous
devez en acheter une.
N'importe quelle télécommande fera l'affaire, même si c'est une très ancienne que vous n'utilisez pas. En fait, si
c'est un vieux qui traîne, c'est parfait. C'est un nouveau but pour quelque chose d'ancien.
• 1x Télécommande
• 1x récepteur IR (j'utiliserai TSOP4838)
• 3x LED
• 4x résistances 220ohm
• Câbles de démarrage
51
1. Décodez les signaux IR
Dans cette partie du projet, vous devez décoder les signaux IR associés à chaque
bouton.
Schémas
Connectez le récepteur IR conformément aux schémas cidessous.
Code
Pour contrôler le récepteur IR, vous devez installer la bibliothèque IRremote dans l'IDE Arduino.
Installation de la bibliothèque IRremote
1. Cliquez ici pour télécharger la bibliothèque IRremote. Vous devriez avoir un dossier .zip dans vos
téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir le dossier IRremotemaster
3. Renommez votre dossier IRremotemaster en IRremote 4. Déplacez le dossier
IRremote dans le dossier des bibliothèques d'installation de votre IDE Arduino 5. Enfin, rouvrez
votre IDE Arduino
52
Remarque : cette bibliothèque est en conflit avec la bibliothèque RobotIRremote. Ainsi, pour l'utiliser, vous
devez déplacer temporairement la bibliothèque RobotIRremote hors du dossier des bibliothèques de l'IDE
Arduino. Si vous ne le faites pas, le code ne compilera pas !
Assurezvous que vous avez sélectionné la bonne carte et le bon port COM.
/*
* IRremote : IRrecvDemo démontre la réception de codes IR avec IRrecv * Un détecteur/démodulateur IR
doit être connecté à l'entrée RECV_PIN.
* Version 0.1 juillet 2009 * Copyright
2009 Ken Shirriff * http://arcfn.com */
#include <IRremote.h>
entier RECV_PIN = 11 ;
IRrecv irrecv(RECV_PIN);
résultats decode_results ;
annuler la configuration()
{
irrecv.enableIRIn(); // Démarre le récepteur
}
void loop() { if
(irrecv.decode(&results)) {
Serial.println(results.value, HEX); irrecv.resume(); //
Reçoit la valeur suivante
}
retard(100);
}
Ouvrez le moniteur série à un débit en bauds de 9600.
53
Dans ce projet, vous souhaitez contrôler 3 LED. Choisissez 6 boutons pour les tâches suivantes :
1. LED1 – ALLUMÉE
2. DEL1 – ÉTEINTE
4. LED2 – ÉTEINTE
6. LED3 – ÉTEINTE
Appuyez sur le bouton numéro 1. Vous devriez voir un code sur le moniteur série. appuie sur le
plusieurs fois sur le même bouton pour vous assurer que vous avez le bon code pour ce bouton. Si vous voyez quelque chose
comme FFFFFFFF, ignorezle, c'est une poubelle.
Faites de même pour les autres boutons.
Notez le code associé à chaque bouton, car vous en aurez besoin
informations plus tard.
2. Construire le circuit final
Dans cette partie, vous construirez le circuit avec trois LED qui seront contrôlées à l'aide de votre télécommande. Assemblez toutes
les pièces en suivant les schémas cidessous.
54
Code
Maintenant, récupérez les codes que vous avez capturés à l'étape précédente. Vous devez convertir votre
codes de l'hexadécimal au décimal.
Pour cela, vous pouvez utiliser le site Web suivant : www.binaryhexconverter.com/hexto
convertisseur décimal
Voici un exemple de conversion pour l'un de mes codes :
Répétez ce processus pour toutes vos valeurs hexadécimales et enregistrez les valeurs décimales. Ce sont
ceux que vous devez remplacer dans le code cidessous.
Copiez le croquis suivant dans votre IDE Arduino. Écrivez vos propres valeurs décimales dans le croquis fourni
dans les lignes de cas et téléchargezle sur votre carte Arduino. Assurezvous que vous avez sélectionné la
bonne carte et le bon port COM.
/*
* Modifié par Rui Santos, http://randomnerdtutorialscom
* basé sur la bibliothèque IRremote Ken Shirriff
*/
#include <IRremote.h>
int IR_Recv = 11 ; // Récepteur IR Broche 3
int bluePin = 10 ;
int greenPin = 9;
int jaunePin = 8 ;
IRrecv irrecv(IR_Recv); résultats
decode_results ;
annuler la configuration(){
Série.begin(9600); //démarre la communication série
irrecv.enableIRIn(); // Démarre le récepteur
pinMode(bluePin, OUTPUT); // définit la broche numérique comme sortie
55
pinMode(greenPin, SORTIE); // définit la broche numérique comme sortie
pinMode(jaunePin, SORTIE); // définit la broche numérique comme sortie
boucle vide (){
// décode l'entrée infrarouge
si (irrecv.decode(&résultats)){
long int decCode = résultats.valeur ;
Serial.println(results.value);
// changer de casse pour utiliser le bouton de télécommande sélectionné
switch (results.value){
cas 551520375 : //lorsque vous appuyez sur le bouton 1
digitalWrite(bluePin, HIGH);
casser;
digitalWrite(bluePin, LOW);
casser;
digitalWrite(greenPin, HIGH);
casser;
digitalWrite(greenPin, LOW);
casser;
digitalWrite(jaunePin, HIGH);
casser;
digitalWrite(jaunePin, BAS);
casser;
irrecv.resume(); // Reçoit la prochaine valeur du bouton sur lequel vous appuyez
}
retard(10);
}
56
Manifestation
Vous pouvez maintenant contrôler chaque LED individuellement à l'aide des boutons de votre télécommande.
Emballer
C'est un excellent projet pour en savoir plus sur le récepteur IR. Il existe une infinité de possibilités pour ce
que vous pouvez en faire.
Par exemple, vous pouvez remplacer ces LED par un relais pour contrôler vos appareils électroménagers.
Cela peut être particulièrement utile car certaines télécommandes ont un tas de boutons que vous n'utilisez
jamais. Alors, pourquoi ne pas les utiliser pour faire quelque chose ?
PS Je dois vous avertir que j'ai trouvé quelques problèmes avec la bibliothèque IRremote. Par exemple, j'ai
constaté que cette bibliothèque est en conflit avec la fonction arduino analogwrite().
57
Teensy/Arduino Jeu de mémoire
Introduction
Dans ce projet, vous allez créer un jeu simple pour tester votre mémoire.
58
J'utiliserai une carte Teensy 3.0. Si vous voulez en savoir plus sur ce tableau, cliquez ici pour lire un guide de
démarrage. Ce projet est également 100% compatible avec l'Arduino.
Regarder sur YouTube : http://youtu.be/cDEmH0iguMw
Pièces requises
Voici une liste des pièces nécessaires pour construire ce projet :
• 1x Teeny 3.0 • (ou
Arduino UNO – lire les meilleurs kits de démarrage Arduino)
• 8x résistance de 220 ohms
• 4x LED
• 4x boutons poussoirs
• 1x sonnerie
59
Schémas
Suivez l'un des diagrammes schématiques suivants.
Teeny
Arduino
60
Code
Ce code fonctionne à la fois avec Teensy et Arduino.
/*
Jeu de mémoire avec Arduino
D'après un projet de Jeremy Wilson
Modifié par Rui Santos
Visitez: http://randomnerdtutorials.com
*/
// Constantes
const int bouton1 = 2 ; // Le 1er bouton contrôle la LED bleue
const int bouton2 = 3 ; // Le 2ème bouton contrôle la LED jaune
const int bouton3 = 4 ; // Le 3ème bouton contrôle la LED verte
const int bouton4 = 5 ; // Le 4ème bouton contrôle la LED rouge
const int led1 = 7 ; // DEL bleue
const int led2 = 8 ; // DEL jaune
const int led3 = 9 ; // DEL verte
const int led4 = 10 ; // DEL rouge
const entier buzzer = 12 ; // Sortie du buzzer
const int tons[] = {1915, 1700, 1519, 1432, 2700} ; // tonalités lorsque vous appuyez sur les LED la dernière est lorsque vous
échouez.
//Variables
int buttonState[] = {0,0,0,0} ; // état actuel du bouton
int lastButtonState[] = {0,0,0,0} ; // état précédent du bouton
int boutonPushCounter[] = {0,0,0,0} ;
void playTone(int ton, int durée) {
for (long i = 0; i < durée * 1000L; i += ton * 2) {
digitalWrite(buzzer, HIGH);
retardMicrosecondes(tonalité);
digitalWrite(buzzer, LOW);
retardMicrosecondes(tonalité);
}
// initialise les entrées :
randomSeed(analogRead(0));
61
pinMode(bouton1, ENTRÉE);
// initialise les sorties :
pinMode(led1, SORTIE);
pinMode(buzzer, SORTIE);
// initialise la communication série pour le débogage : //Serial.begin(9600);
int game_on = 0 ;
int attente = 0 ;
int niveaucourant = 1 ; // C'est le niveau (également le nombre d'appuis sur le bouton pour passer au niveau suivant)
long num_rand = 0 ; // initialise la variable longue pour un nombre aléatoire de 0 à 100. entier aléatoire = 0 ; // initialise un entier aléatoire
pour loopgame_on. Sera du 1 au 4
plus tard.
int maisattendre = 500 ; // temps d'attente pour la prochaine entrée du bouton (ghetto de rebond)
int ledtime = 500 ; // durée pendant laquelle chaque LED clignote lorsque le bouton est enfoncé
entier n_niveaux = 10 ; // nombre de niveaux jusqu'à ce que le jeu soit gagné
int pinandtone = 0 ; //Cet entier est utilisé lors de l'affichage de la séquence
entier droit = 0 ; //Cette variable doit valoir 1 pour passer au niveau suivant
int speedfactor = 5 ; // C'est la vitesse finale des lumières et des sons pour le dernier niveau. Cela augmente à mesure que plus de jeux sont
gagnés
int leddelay = 200 ; //Temps d'initialisation pour la LED. Cela diminuera à mesure que le niveau augmentera
boucle vide () {
entier n_tableau[n_niveaux] ; int
u_array[n_levels] ;
int je ;
//efface les tableaux "n_array" et "u_array" et démarre une nouvelle partie if (game_on == 0){ for(i=0; i<n_levels; i=i+1)
{ n_array[i]=0; u_tableau[i]=0 ; num_rand = aléatoire(1 200); si (num_rand <= 50)
62
aléatoire=0 ;
sinon si (num_rand>50 && num_rand<=100)
aléatoire=1 ;
sinon si (num_rand>100 && num_rand<=150)
aléatoire=2 ;
sinon si (rand_num<=200)
aléatoire=3 ;
// enregistre un nombre aléatoire dans notre n_array
n_array[i]=rando;
}
game_on = 1 ;
// montre à l'utilisateur la séquence en cours
si (attendre == 0){
retard (200);
je = 0 ;
pour (i = 0 ; je < niveau actuel ; je= je + 1){
leddelay = ledtime/(1+(speedfactor/n_levels)*(currentlevel 1));
en surbrillance = n_tableau[i] ;
digitalWrite(pinandtone+7, HIGH);
playTone(tones[pinandtone], leddelay);
digitalWrite(pinandtone+7, LOW);
délai (100/facteur de vitesse) ;
}
attendre = 1 ;
je = 0 ;
changement de bouton int = 0 ;
entier j = 0 ; // Ceci est la position actuelle dans la séquence
tandis que (j < niveau actuel){
tandis que (changement de bouton == 0){
pour (je = 0; je < 4; je = je + 1){
buttonState[i] = digitalRead(i+2);
changement de bouton = changement de bouton + état de bouton[i] ;
}
pour (je = 0; je < 4; je = je + 1){
si (étatbouton[i] == ÉLEVÉ) {
digitalWrite(i+7, HIGH);
playTone(tones[i], ledtime);
63
digitalWrite(i+7, LOW);
attendre = 0 ;
u_tableau[j]=i ;
boutonState[i] = BAS ;
changement de bouton = 0 ;
}
si (u_tableau[j] == n_tableau[j]){
j++;
droite = 1 ;
}
autre{
droite = 0 ;
je = 4 ;
j = niveau actuel ;
attendre = 0 ;
si (droite == 0){
retard(300);
je = 0 ;
game_on = 0 ;
niveauactuel = 1 ;
pour (je = 0; je < 4; je = je + 1){
}
playTone(tonalités[4], ledtime);
pour (je = 0; je < 4; je = je + 1){
}
retard (200);
pour (je = 0; je < 4; je = je + 1){
}
playTone(tonalités[4], ledtime);
pour (je = 0; je < 4; je = je + 1){
}
retard (500);
game_on = 0 ;
64
// si vous insérez la bonne séquence, il monte de niveau
si (droite == 1){
niveauactuel++ ;
attendre = 0 ;
}
//si vous finissez le jeu
if (currentlevel == n_levels){ delay(500);
// Voici le son de la victoire :
int notes[] = {2, 2, 2, 2, 0, 1, 2, 1, 2} ;
int note = 0 ;
int temps[] = {200, 200, 200, 400, 400, 400, 200, 200, 600} ;
int pauses[] = {100, 100, 100, 200, 200, 200, 300, 100, 200} ;
pour (je = 0; je < 9; je = je + 1){
note = notes[i] ;
digitalWrite (note + 7, HIGH);
playTone(tonalités[note], tempo[i]);
digitalWrite(note+7, LOW);
retard(pause[i]);
}
//met game_on à 0, donc il redémarre un nouveau jeu game_on = 0;
niveauactuel = 1 ;
n_niveaux = n_niveaux + 2 ;
facteur de vitesse = facteur de vitesse + 1 ;
}
65
Guide pour le capteur de gaz/fumée MQ2 avec Arduino
Ce guide montre comment construire un détecteur de fumée qui émet un bip lorsqu'il détecte un gaz
inflammable ou de la fumée.
Le capteur de gaz MQ2
Le détecteur de fumée MQ2 est sensible à la fumée et aux gaz inflammables suivants :
• GPL
• Butane
• Propane
• Méthane
• Alcool
• Hydrogène
66
La résistance du capteur est différente selon le type de gaz.
Le détecteur de fumée possède un potentiomètre intégré qui vous permet de régler le seuil de sortie
numérique du détecteur (D0). Ce seuil définit la valeur audessus de laquelle la broche numérique
émettra un signal HIGH.
Comment ça marche?
La tension émise par le capteur change en fonction du niveau de fumée/gaz qui existe dans l'atmosphère.
Le capteur délivre une tension proportionnelle à la concentration de fumée/gaz.
En d'autres termes, la relation entre la tension et la concentration de gaz est la suivante :
• Plus la concentration de gaz est élevée, plus la tension de sortie est élevée • Plus la
concentration de gaz est faible, plus la tension de sortie est faible
67
La sortie peut être un signal analogique (A0) qui peut être lu avec une entrée analogique de l'Arduino ou
une sortie numérique (D0) qui peut être lue avec une entrée numérique de l'Arduino.
Câblage des broches
Le capteur MQ2 a 4 broches.
Broche
Câblage à Arduino Uno
A0 Broches analogiques
D0 Broches numériques
Terre Terre
VCC 5V
Exemple : Capteur de gaz avec Arduino
Dans cet exemple, vous lirez la tension de sortie analogique du capteur et lorsque la fumée atteindra un
certain niveau, il fera retentir un buzzer et une LED rouge s'allumera. Quand
la tension de sortie est inférieure à ce niveau, une LED verte s'allume.
Pièces requises
Pour cet exemple, vous aurez besoin des pièces suivantes :
68
• 1 capteur de gaz MQ2 •
Arduino UNO – lire les meilleurs kits de démarrage Arduino
• 1 LED rouge
• 1 LED verte
• 1 sonnerie
• 3 résistances 220Ω
• Fils de liaison
Schémas
Suivez ces diagrammes schématiques pour terminer le projet :
69
Code
Téléchargez le croquis suivant sur votre carte Arduino (n'hésitez pas à ajuster la variable sensorThres
variable avec une valeur de seuil différente) :
/*******
Toutes les ressources pour ce projet : http://
randomnerdtutorials.com/
*******/
int led rouge = 12 ;
int led verte = 11 ; int buzzer
= 10 ;
int smokeA0 = A5 ;
// Votre valeur seuil
int sensorThres = 400 ;
void setup()
{ pinMode(redLed, OUTPUT);
pinMode(greenLed, OUTPUT);
pinMode(buzzer, SORTIE); pinMode(smokeA0,
INPUT); Série.begin(9600);
boucle vide () {
int analogSensor = analogRead(smokeA0);
Serial.print("Broche A0 : ");
Serial.println(analogSensor); // Vérifie s'il a atteint
la valeur seuil
if (analogSensor > sensorThres) {
digitalWrite(redLed, HIGH);
digitalWrite(greenLed, LOW); tonalité (sonnerie,
1000, 200);
}
autre
{
digitalWrite(redLed, LOW);
digitalWrite(greenLed, HIGH); noTone(buzzer);
} retard(100);
}
70
Démonstration vidéo
Regardez cette démonstration vidéo rapide pour voir ce projet en action :
Regarder sur YouTube : https://youtu.be/_mEUszHqWDg
71
Guide pour matrice de points 8 × 8 MAX7219 +
Jeu de Pong
Cliquez ici
Cliquez ici
Introduction
La matrice de points que nous allons utiliser dans ce projet est une matrice 8 × 8, ce qui signifie qu'elle a 8
colonnes et 8 lignes, elle contient donc un total de 64 LED. Le MAX7219
puce facilite le contrôle de la matrice de points en utilisant seulement 3 broches numériques du
Carte Arduino.
La meilleure option est d'acheter la matrice de points avec la puce MAX7219 en tant que module, cela
simplifiera le câblage. Vous pouvez vérifier la matrice de points sur Maker Advisor et trouver le meilleur prix.
72
Vous pouvez contrôler plus d'une matrice à la fois. Pour cela, il vous suffit de les connecter les uns aux
autres. Ils ont des broches des deux côtés pour étendre la matrice de points.
Pièces requises
Pour ce guide, vous aurez besoin des pièces suivantes :
• 1x matrice de points 8 × 8 avec MAX7219
• 1 potentiomètre 1k ohms
• Fils de liaison
Vous devez connecter 5 broches de la matrice de points à votre carte Arduino. Le câblage est assez simple :
Broche à matrice de points Câblage à Arduino Uno
Terre Terre
VCC 5V
DEPUIS
Broche numérique
CS Broche numérique
CLK Broche numérique
73
Comment contrôler la matrice de points avec Arduino
Pour faciliter le contrôle de la matrice de points, vous devez télécharger et installer dans votre IDE Arduino
la bibliothèque LedControl . Pour installer la bibliothèque, procédez comme suit :
1. Cliquez ici pour télécharger la bibliothèque LedControl. Vous devriez avoir un dossier .zip dans vos
téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir le dossier LedControlmaster 3.
Renommez votre dossier de LedControlmaster en LedControl 4. Déplacez le dossier
LedControl dans le dossier des bibliothèques d'installation de votre IDE Arduino 5. Enfin, rouvrez
votre IDE Arduino
Utilisation des fonctions de la bibliothèque LedControl
La manière la plus simple d'afficher quelque chose sur la matrice de points est d'utiliser les fonctions
setLed(),setRow() ou setColumn(). Ces fonctions vous permettent de contrôler une seule led, une ligne ou
une colonne à la fois. Voici les paramètres de chaque fonction :
setLed (adresse, ligne, colonne, état)
• addr est l'adresse de votre matrice, par exemple, si vous n'avez qu'une seule matrice, l'int
addr sera égal à zéro.
• row est la ligne où se trouve la led
• col est la colonne où se trouve la led
• état
o C'est vrai ou 1 si vous voulez allumer la led o C'est faux
ou 0 si vous voulez l'éteindre
setRow(adresse, ligne, valeur)
setCol(adresse, colonne, valeur)
74
Indice
Comme indiqué précédemment, cette matrice comporte 8 colonnes et 8 lignes. Ceuxci sont
indexés de 0 à 7. Voici un chiffre pour mieux comprendre :
Si vous souhaitez afficher quelque chose dans la matrice, il vous suffit de noter les LED qui sont
allumées ou éteintes sur la matrice. Par exemple, si vous souhaitez afficher un visage souriant,
voici ce que vous devez faire :
75
Code
Voici un croquis simple qui affiche trois types de visages : un visage triste, un visage neutre et un visage
heureux. Téléchargez le code suivant sur votre tableau :
/*
Réalisé par Rui Santos
Toutes les ressources pour ce projet :
http://randomnerdtutorials.com/
*/
#include "LedControl.h"
#include "binaire.h"
/*
DIN se connecte à la broche 12
CLK se connecte à la broche 11
CS se connecte à la broche 10
*/
LedControl lc=LedControl(12,11,10,1);
// temps de retard entre les visages
délai long non signé =1000 ;
// mine réjouie
octet hf[8]=
{B00111100,B01000010,B10100101,B10000001,B10100101,B10011001,B01000010,B001111 00} ;
// visage neutre
octet nf[8]={B00111100,
B01000010,B10100101,B10000001,B10111101,B10000001,B01000010,B00111100} ;
// visage triste
octet sf[8]=
{B00111100,B01000010,B10100101,B10000001,B10011001,B10100101,B01000010,B001111 00} ;
lc.shutdown(0,faux);
// Règle la luminosité sur une valeur moyenne
lc.setIntensity(0,8);
// Effacer l'affichage
lc.clearDisplay(0);
76
void drawFaces(){
// Affiche un visage triste
lc.setRow(0,0,sf[0]);
retard (délai);
// Afficher le visage neutre
lc.setRow(0,0,nf[0]);
retard (délai);
// Affiche un visage souriant
lc.setRow(0,0,hf[0]);
retard (délai);
}
boucle vide (){
drawFaces();
77
Au final, vous aurez quelque chose comme ça :
Jeu de Pong
Le jeu de pong que vous êtes sur le point d'essayer a été créé par Alessandro Pasotti.
Pour le jeu pong, il suffit d'ajouter un potentiomètre 1k ohm au schéma précédent. Assemblez le
nouveau circuit comme indiqué dans le schéma cidessous :
78
Code
/*
* Jouez au pong sur une matrice 8x8 projet de itopen.it
*/
#include "LedControl.h"
#include "Timer.h"
#define POTPIN A5 // Potentiomètre
#define PADSIZE 3
#define BALL_DELAY 200 #define
GAME_DELAY 10 #define
BOUNCE_VERTICAL 1 #define
BOUNCE_HORIZONTAL 1 #define
NEW_GAME_ANIMATION_SPEED 50 #define HIT_NONE
0 #define HIT_CENTER 1 #define HIT_LEFT 2 #define
HIT_RIGHT 3
//#définir DEBUG 1
octet triste[] = {
B00000000,
B01000100,
B00010000,
B00010000,
B00000000,
B00111000,
B01000100,
B00000000
} ;
octet smile[] = {
B00000000,
B01000100,
B00010000,
B00010000,
79
B00010000,
B01000100,
B00111000,
B00000000
} ;
Heures heures;
LedControl lc = LedControl(12,11,10,1);
direction des octets ; // Rose des vents, 0 est nord
int xball;
int yball ;
int yball_prev;
octet xpad ;
int ball_timer ;
void setSprite(byte *sprite){
for(int r = 0; r < 8; r++){
lc.setRow(0, r, sprite[r]);
}
void newGame() {
// position initiale
xball = aléatoire(1, 7);
yball = 1 ;
direction = aléatoire(3, 6); // Va au sud
for(int r = 0; r < 8; r++){
for(int c = 0; c < 8; c++){
lc.setLed(0, r, c, HIGH);
retard(NEW_GAME_ANIMATION_SPEED);
}
setSprite(sourire);
retard(1500);
}
void setPad() {
xpad = map(analogRead(POTPIN), 0, 1020, 8 PADSIZE, 0);
}
80
void debug(const char* desc){
#ifdef DEBUG
Serial.print(desc);
Serial.print(" XY : ");
Serial.print(xball);
Serial.print(", ");
Serial.print(yball);
Serial.print(" XPAD : ");
Serial.print(xpad);
Serial.print(" DIR : ");
Serial.println(direction);
#fin si
int checkBounce() {
if(!xball || !yball || xball == 7 || yball == 6){
int rebond = (yball == 0 || yball == 6) ? REBOND_HORIZONTAL :
BOUNCE_VERTICAL ;
#ifdef DEBUG
debug(rebond == BOUNCE_HORIZONTAL ? "HORIZONTAL" : "VERTICAL");
#fin si
rebond de retour ;
renvoie 0 ;
int getHit() {
if(yball != 6 || xball < xpad || xball > xpad + PADSIZE){
renvoie HIT_NONE ;
}
if(xball == xpad + PADSIZE / 2){
retourner HIT_CENTER ;
}
retourner xball < xpad + PADSIZE / 2 ? COUP_GAUCHE : COUP_DROITE ;
}
bool checkLoose() {
return yball == 6 && getHit() == HIT_NONE;
}
void moveBall() {
debug("MOVE");
81
int rebond = checkBounce();
si (rebondir) {
interrupteur (direction){
cas 0 :
orientation = 4 ;
casser;
cas 1 :
direction = (rebond == BOUNCE_VERTICAL) ? 7 : 3 ;
casser;
cas 2 :
orientation = 6 ;
casser;
cas 6 :
orientation = 2 ;
casser;
cas 7 :
casser;
cas 5 :
casser;
cas 3 :
casser;
cas 4 :
orientation = 0 ;
casser;
débogage(">");
}
// Vérifier le hit : la direction de modification est à gauche ou à droite
basculer(getHit()){
cas HIT_LEFT :
si(sens == 0){
orientation = 7 ;
} sinon si (sens == 1){
orientation = 0 ;
casser;
cas HIT_RIGHT :
si(sens == 0){
orientation = 1 ;
82
} sinon si(direction == 7){
orientation = 0 ;
casser;
// Vérifier les directions orthogonales et les bordures ...
if((direction == 0 && xball == 0) || (direction == 4 && xball == 7)){
orientation++ ;
si(direction == 0 && xboule == 7){
orientation = 7 ;
si(direction == 4 && xboule == 0){
orientation = 3 ;
si(direction == 2 && yboule == 0){
orientation = 3 ;
orientation = 1 ;
orientation = 5 ;
orientation = 7 ;
// Cas "coin"
if(xball == 0 && yball == 0){
orientation = 3 ;
si(xboule == 0 && yboule == 6){
orientation = 1 ;
orientation = 7 ;
orientation = 5 ;
83
yball_prev = yball;
si(2 < sens && sens < 6) {
yball++;
} sinon si(direction != 6 && direction != 2) {
yball ;
si(0 < sens && sens < 4) {
xball++;
} sinon si(direction != 0 && direction != 4) {
xball;
xball = max(0, min(7, xball));
yball = max(0, min(6, yball));
debug("APRÈS LE DÉPLACEMENT");
annuler gameOver() {
setSprite(triste);
retard(1500);
void drawGame() {
if(yball_prev != yball){ lc.setRow(0,
yball_prev, 0);
}
lc.setRow(0, yball, byte(1 << (xball)));
octet padmap = byte(0xFF >> (8 PADSIZE) << xpad) ;
#ifdef DEBUG
//Serial.println(padmap, BIN);
#fin si
lc.setRow(0, 7, padmap);
// Le MAX72XX est en mode d'économie d'énergie au démarrage, // nous devons faire un
appel de réveil
pinMode(POTPIN, ENTRÉE);
lc.shutdown(0,faux);
// Réglez la luminosité sur des valeurs moyennes
lc.setIntensity(0, 8); // et efface l'affichage
84
randomSeed(analogRead(0));
#ifdef DEBUG
Serial.println("Pong");
#fin si
nouveau jeu();
ball_timer = timer.every(BALL_DELAY, moveBall);
}
boucle vide () {
minuterie.mise à jour();
// Déplacer le pavé
setPad();
#ifdef DEBUG
Serial.println(xpad);
#fin si
// Écran de mise à jour
drawGame();
if(checkLoose()) {
debug("LOOSE");
jeu terminé();
nouveau jeu();
retard(GAME_DELAY);
}
Manifestation
Voici la démonstration finale de moi jouant au jeu de pong. Amusezvous!
85
Accès sécurisé à l'aide de la RFID MFRC522
Lecteur avec Arduino
Ce projet montre un exemple simple sur la façon d'utiliser le lecteur RFID MFRC522. Je vais faire un bref
aperçu des spécifications et montrer un exemple de projet à l'aide d'un
Arduino.
Description
RFID signifie identification par radiofréquence. La RFID utilise des champs électromagnétiques pour
transférer des données sur de courtes distances. La RFID est utile pour identifier les personnes, effectuer
des transactions, etc…
Vous pouvez utiliser un système RFID pour ouvrir une porte. Par exemple, seule la personne ayant les
bonnes informations sur sa carte est autorisée à entrer. Un système RFID utilise :
86
• étiquettes attachées à l'objet à identifier, dans cet exemple nous avons un porteclés et une carte
électromagnétique. Chaque balise a sa propre identification (UID).
• émetteurrécepteur radio bidirectionnel, le lecteur, qui envoie un signal au
tag et lire sa réponse.
Spécifications •
Tension d'entrée : 3,3 V •
Prix : environ 3 $ (vérifiez le meilleur prix sur Maker Advisor)
• Fréquence : 13,56 MHz
Téléchargement de la bibliothèque
Voici la bibliothèque dont vous avez besoin pour ce projet :
1. Cliquez ici pour télécharger la bibliothèque RFID. Vous devriez avoir un dossier .zip dans votre
Téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir le dossier RFID
master 3. Renommez votre dossier RFIDmaster en RFID 4. Déplacez le
dossier RFID dans le dossier des bibliothèques d'installation de votre IDE Arduino 5.
Enfin, rouvrez votre IDE Arduino
87
Broche
Câblage à Arduino Uno
SDA Numérique 10
SCK Numérique 13
FUMÉE Numérique 11
MISO Numérique 12
IRQ Ne vous connectez pas
Terre Terre
TVD Numérique 9
3.3V 3.3V
Schématique
Câblez le lecteur RFID à l'Arduino comme indiqué dans le schéma suivant :
88
Lecture des données d'une étiquette RFID
Après avoir préparé le circuit, allez dans Fichier Exemples MFRC522 DumpInfo et téléchargez

le code. Ce code est disponible dans votre IDE Arduino après l'installation de la bibliothèque RFID.
Ensuite, ouvrez le moniteur série. Vous devriez voir quelque chose comme la figure cidessous :
Rapprochez la carte RFID ou le porteclés du lecteur. Laissez le lecteur et le tag se rapprocher jusqu'à
ce que toutes les informations soient affichées.
89
Il s'agit des informations que vous pouvez lire sur la carte, y compris l'UID de la carte qui est surligné en
jaune. Les informations sont stockées dans la mémoire qui est divisée en segments et en blocs comme vous
pouvez le voir sur l'image précédente.
Vous disposez de 1024 octets de stockage de données divisés en 16 secteurs. Notez votre carte UID car
vous en aurez besoin plus tard.
Code
/*
*
* Toutes les ressources pour ce projet : http://randomnerdtutorials.com/
* Modifié par Rui Santos
*
* Créé par FILIPEFLOP
*
*/
#include <SPI.h>
#include <MFRC522.h>
# définir SS_PIN 10 # définir
RST_PIN 9 MFRC522
mfrc522 (SS_PIN, RST_PIN); // Créer une instance MFRC522.
annuler la configuration()
Série.begin(9600); // Initier une communication série
SPI.begin(); // Initier le bus SPI
mfrc522.PCD_Init(); // Lancer MFRC522
Serial.println("Rapprochez votre carte du lecteur...");
Serial.println();
boucle vide ()
{
// Rechercher de nouvelles cartes
si ( ! mfrc522.PICC_IsNewCardPresent())
{
90
retour;
// Sélection d'une des cartes
si ( ! mfrc522.PICC_ReadCardSerial())
{
retour;
// Afficher l'UID sur le moniteur série
Serial.print(" Balise UID :");
Contenu de la chaîne = "" ;
lettre d'octet ;
pour (octet i = 0; i < mfrc522.uid.size; i++)
{
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
Serial.print(mfrc522.uid.uidByte[i], HEX);
content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ") );
content.concat(String(mfrc522.uid.uidByte[i], HEX));
}
Serial.println();
Serial.print("Message : ");
content.toUpperCase();
if (content.substring(1) == "BD 31 15 2B") //modifier ici l'UID du
carte/cartes auxquelles vous souhaitez donner accès
{
Serial.println(" Accès autorisé");
Serial.println();
retard (3000);
}
sinon {
Serial.println(" Accès refusé");
retard (3000);
}
Dans le code, vous devez modifier la ligne suivante avec la carte UID que vous avez trouvée
précédemment.
if (content.substring(1) == "REPLACE WITH YOUR UID")
91
Manifestation
Ouvrez le moniteur série à un débit en bauds de 115 200.
Regarder sur YouTube : https://youtu.be/mpLzcBDBl1U
Rapprochezvous de la carte que vous avez choisie pour donner accès et vous verrez :
Si vous rapprochez un tag d'un autre UID, le message de refus s'affichera :
92
Système de pointage Arduino avec RFID
Introduction
Dans ce projet, vous allez construire un système de pointage avec le lecteur RFID MFRC522 et Arduino.
Lorsque vous glissez une étiquette RFID à côté du lecteur RFID, cela enregistre l'UID de l'utilisateur et
l'heure sur une carte SD. Il indique également si vous êtes en retard ou à l'heure en fonction d'une heure et
d'une minute prédéfinies.
93
Regardez la vidéo d'introduction
Regarder la vidéo sur Youtube : https://youtu.be/b01k6YlaHfA
Aperçu du projet
Avant de commencer, il est important de mettre en page les principales fonctionnalités du projet :
• Il contient un lecteur RFID qui lit les étiquettes RFID ; • Notre
configuration dispose d'un module d'horloge en temps réel pour garder une trace du
temps ; • Lorsque le lecteur RFID lit une étiquette RFID, il enregistre l'heure actuelle et le
UID du tag dans une carte SD ;
• L'Arduino communique avec la carte SD à l'aide d'un module de carte SD ; • Vous pouvez définir
une heure d'enregistrement pour comparer si vous êtes à l'heure ou en retard ; • Si vous êtes à
l'heure, une LED verte s'allume ; si vous êtes en retard, une LED rouge s'allume ; • Le système dispose
également d'un avertisseur sonore qui émet un bip lorsqu'une étiquette est lue.
Pièces requises
94
Voici une liste des composants requis pour ce projet :
• Lecteur RFID MFRC522 + étiquettes
•Module de carte SD
• Carte Micro SD
• Module RTC SD1307
• 2x LED (1x rouge + 1x verte)
• 2 résistances 220 Ohms
• Planche à pain
• Fils de liaison
Lecteur RFID MFRC522
Dans ce projet, nous utilisons le lecteur RFID MFRC522 et c'est celui que nous vous recommandons d'obtenir.
RFID signifie identification par radiofréquence. La RFID utilise des champs électromagnétiques pour transférer
des données sur de courtes distances et est utile pour identifier des personnes, effectuer des transactions, etc.
Un système RFID a besoin d'étiquettes et d'un lecteur :
• Des étiquettes sont attachées à l'objet à identifier, dans cet exemple nous avons un porteclés et une carte
électromagnétique. Certains magasins utilisent également des étiquettes RFID dans les étiquettes de
leurs produits pour les identifier. Chaque balise a sa propre identification unique (UID).
95
• Reader est un émetteurrécepteur radio bidirectionnel qui envoie un signal au tag et lit sa réponse.
Le lecteur RFID MFRC522 fonctionne à 3,3 V et peut utiliser la communication SPI ou I2C.
La bibliothèque nous allons utiliser pour contrôler le lecteur RFID qui ne prend en charge que SPI, c'est
donc le protocole de communication que nous allons utiliser.
Pour en savoir plus sur le lecteur RFID avec l'Arduino, lisez : Security Access using
Lecteur RFID MFRC522 avec Arduino
Installation de la bibliothèque MFRC522
Ce projet utilise la bibliothèque MFRC522.h pour contrôler le lecteur RFID. Cette bibliothèque n'est pas
installée par défaut dans l'IDE Arduino, vous devez donc l'installer. Accédez à Sketch Inclure la
bibliothèque Gérer les bibliothèques et recherchez MFRC522 ou suivez les étapes suivantes :
1. Cliquez ici pour télécharger la bibliothèque MFRC522. Vous devriez avoir un dossier .zip dans votre
dossier Téléchargements.
2. Décompressez le dossier .zip et vous devriez obtenir le dossier RFIDmaster
3. Renommez votre dossier RFIDmaster en RFID 4. Déplacez le dossier RFID
dans le dossier des bibliothèques d'installation de votre IDE Arduino 5. Enfin, rouvrez votre
IDE Arduino
96
Brochage du lecteur RFID MFRC522
Le tableau suivant montre le brochage du lecteur pour référence future :
BROCHE CÂBLAGE VERS ARDUINO UNO
SDA Numérique 10
SCK Numérique 13
MISO Numérique 12
IRQ Ne vous connectez pas
Terre Terre
TVD Numérique 9
3.3V 3.3V
Remarque : différentes cartes Arduino ont des broches SPI différentes. Si vous utilisez un autre
Carte Arduino, consultez la documentation Arduino .
Module de carte SD
Lorsqu'une balise est lue, son UID et son heure sont enregistrés sur une carte SD afin que vous puissiez suivre les enregistrements.
Il existe différentes façons d'utiliser une carte SD avec l'Arduino. Dans ce projet, nous utilisons le module de carte SD illustré dans
la figure cidessous il fonctionne avec
carte Micro SD.
97
Il existe différents modèles de différents fournisseurs, mais ils fonctionnent tous de la même manière, en utilisant le protocole de
communication SPI. Pour communiquer avec la carte SD, nous allons utiliser une bibliothèque appelée SD.h qui est déjà installée
dans l'IDE Arduino par défaut. Pour en savoir plus sur le module de carte SD avec l'Arduino, lisez : Guide de
Module de carte SD avec Arduino
Brochage du module de carte SD
Le tableau suivant montre le brochage du module de carte SD pour référence future :
BROCHE CÂBLAGE VERS ARDUINO UNO
VCC 3.3V
CS Numérique 4
CLK Numérique 13
MISO Numérique 12
Terre Terre
Remarque : différentes cartes Arduino ont des broches SPI différentes. Si vous utilisez un autre
Carte Arduino, consultez la documentation Arduino .
Préparation de la carte SD
La première étape lors de l'utilisation du module de carte SD avec Arduino consiste à formater la carte SD en FAT16 ou FAT32.
Suivez les instructions cidessous.
1) Pour formater la carte SD, insérezla dans votre ordinateur. Allez dans Poste de travail et faites un clic droit sur la carte SD.
Sélectionnez Format comme indiqué dans la figure cidessous.
98
2) Une nouvelle fenêtre apparaît. Sélectionnez FAT32, appuyez sur Démarrer pour initialiser le processus
de formatage et suivez les instructions à l'écran.
Test du module de carte SD
Cette étape est facultative. Il s'agit d'une étape supplémentaire pour s'assurer que le module de carte SD
fonctionne correctement. Insérez la carte SD formatée dans le module de carte SD et connectez le module
de carte SD à l'Arduino comme indiqué dans le schéma de circuit cidessous ou vérifiez
la table de brochage.
99
Remarque : selon le module que vous utilisez, les broches peuvent être placées à un emplacement
différent.
Téléchargement de l'esquisse CardInfo
Pour vous assurer que tout est correctement câblé et que la carte SD fonctionne correctement, dans la
fenêtre de l'IDE Arduino, accédez à Fichier Exemples SD CardInfo.
Téléchargez le code sur votre carte Arduino. Assurezvous d'avoir sélectionné la bonne carte et le bon
port COM.
Ouvrez le moniteur série à un débit en bauds de 9600 et les informations de la carte SD seront affichées.
Si tout fonctionne correctement, vous verrez un message similaire sur le numéro de série
moniteur.
Module RTC (horloge en temps réel)
Pour garder une trace du temps, nous utilisons le module SD1307 RTC. Cependant, ce projet fonctionne
très bien avec le DS3231, qui est très similaire. Une des principales différences entre eux est la
précision. Le DS3231 est beaucoup plus précis que le DS1307. La figure cidessous montre le modèle
SD1307.
100
Le module a une batterie de secours installée. Cela permet au module de conserver l'heure, même lorsqu'il n'est pas
sous tension.
Ce module utilise la communication I2C et nous utiliserons la bibliothèque RTCLib.h pour lire l'heure du RTC.
Pour en savoir plus sur l'horloge temps réel DS1307 avec l'Arduino, lisez : Guide pour
Module d'horloge en temps réel (RTC) avec Arduino (DS1307 et DS3231)
Brochage du module RTC
Le tableau suivant montre le brochage du module RTC pour référence future :
Broche
Câblage sur arduino uno
SCL A5
SDA A4
VCC 5V (vérifiez la fiche technique de votre module)
Terre Terre
Remarque : différentes cartes Arduino ont différentes broches I2C. Si vous utilisez une autre carte Arduino, consultez
la documentation Arduino.
101
Installation de la bibliothèque RTCLib
Pour installer RTCLib.h, accédez à Sketch Inclure la bibliothèque Gérer les bibliothèques et
recherchez RTCLib ou suivez les étapes suivantes :
1. Cliquez ici pour télécharger la bibliothèque RTCLib. Vous devriez avoir un dossier .zip dans votre
dossier Téléchargements.
2. Décompressez le dossier .zip et vous devriez obtenir le dossier RTCLibmaster
3. Renommez votre dossier RTCLibmaster en RTCLib 4. Déplacez le dossier
RTCLib dans le dossier des bibliothèques d'installation de votre IDE Arduino 5. Enfin,
rouvrez votre IDE Arduino
Schémas
Le circuit de ce projet est illustré dans les schémas de circuit cidessous. Dans ce circuit, il y a des
appareils 3,3 V et 5 V, assurezvous de les câbler correctement. De plus, si vous utilisez différents
modules, vérifiez la tension recommandée avant d'alimenter le circuit.
102
Code
Téléchargez le code suivant sur votre Arduino. Assurezvous d'avoir le bon tableau et
Port COM sélectionné.
/*
* Rui Santos
*/
#include <MFRC522.h> // pour la RFID
#include <SPI.h> // pour le module RFID et carte SD
#include <SD.h> // pour la carte SD
#include <RTClib.h> // pour le RTC
// définir les broches pour la RFID
#définir CS_RFID 10 #définir
RST_RFID 9
// définir la broche de sélection pour le module de carte SD
#define CS_SD 4
// Crée un fichier pour stocker les données
Fichier monFichier ;
// Instance de la classe pour RFID
MFRC522 rfid(CS_RFID, RST_RFID);
// Variable pour contenir l'UID de la balise
Chaîne uidString ;
// Instance de la classe pour RTC
RTC_DS1307 rtc ;
// Définir l'heure d'arrivée
const int checkInHour = 9;
const int checkInMinute = 5;
//Variable pour maintenir l'enregistrement de l'utilisateur
int userCheckInHour ;
int userCheckInMinute ;
103
// Pins pour LEDs et buzzer
const int LED rouge = 6 ;
const int LED verte = 7 ;
const entier buzzer = 5 ;
// Définir les LED et le buzzer comme sorties
pinMode (LED rouge, SORTIE);
pinMode (LED verte, SORTIE);
// Initialiser le port série
tandis que (!Série); // pour Leonardo/Micro/Zéro
// Init bus SPI
SPI.begin();
// Init MFRC522
rfid.PCD_Init();
// Configuration de la carte SD
Serial.print("Initialisation de la carte SD...");
si(!SD.begin(CS_SD)) {
Serial.println("l'initialisation a échoué !");
retour;
Serial.println("initialisation terminée.");
// Configuration pour le RTC
si(!rtc.begin()) {
Serial.println("Impossible de trouver RTC");
tandis que(1);
sinon {
// la ligne suivante définit le RTC sur la date et l'heure à laquelle cette esquisse a été compilée
rtc.adjust(DateHeure(F(__DATE__), F(__TIME__)));
}
if(!rtc.isrunning()) {
Serial.println("RTC n'est PAS en cours d'exécution !");
104
boucle vide () {
//recherche de nouvelles cartes
if(rfid.PICC_IsNewCardPresent()) {
lireRFID();
logCarte();
vérifierCheckIn();
}
retard(10);
}
annuler readRFID() {
rfid.PICC_ReadCardSerial(); Serial.print("Tag
UID : ");
" "
uidString = Chaîne(rfid.uid.uidByte[0]) + + Chaîne(rfid.uid.uidByte[1])
+ " " +
" "
Chaîne(rfid.uid.uidByte[2]) + + Chaîne(rfid.uid.uidByte[3]);
Serial.println(uidString);
// Faire retentir le buzzer lorsqu'une carte est lue
tonalité (buzzer, 2000);
retard(100);
noTone(buzzer);
retard(100);
}
void logCard() {
// Active la broche de sélection de la puce de la carte SD
digitalWrite(CS_SD,LOW);
// Fichier ouvert
monFichier=SD.open("DATA.txt", FILE_WRITE); // Si le fichier s'est
bien ouvert, écrivezy if (myFile) {
Serial.println("Fichier ouvert ok");
monFichier.print(uidString);
monFichier.print(", ");
// Gain de temps sur carte SD
DateTime now = rtc.now();
monFichier.print(now.year(), DEC); monFichier.print('/');
monFichier.print(maintenant.mois(), DEC);
monFichier.print('/');
105
monFichier.print(maintenant.jour(), DEC);
monFichier.print(',');
monFichier.print(maintenant.heure(), DEC);
monFichier.print(':');
monFichier.println(maintenant.minute(), DEC);
// Impression de l'heure sur le moniteur série
Serial.print(now.year(), DEC);
Serial.print('/');
Serial.print(maintenant.mois(), DEC);
Serial.print('/');
Serial.print(now.day(), DEC);
Serial.print(' ');
Serial.print(now.hour(), DEC);
Serial.print(':');
Serial.println(maintenant.minute(), DEC);
Serial.println(" écrit avec succès sur la carte SD");
monFichier.close();
// Enregistrer l'heure d'enregistrement ;
userCheckInHour = now.hour();
userCheckInMinute = now.minute();
sinon {
Serial.println("erreur lors de l'ouverture de data.txt");
// Désactive la broche de sélection de la puce de la carte SD
digitalWrite(CS_SD,HIGH);
}
annuler verifyCheckIn(){
if((userCheckInHour < checkInHour)||((userCheckInHour==checkInHour) &&
(userCheckInMinute <= checkInMinute))){
digitalWrite (LED verte, ÉLEVÉ);
retard (2000); écriture
numérique (LED verte, FAIBLE); Serial.println("De
rien !");
autre{
digitalWrite (LED rouge, ÉLEVÉ);
retard (2000);
écriture numérique (LED rouge, FAIBLE);
Serial.println("Vous êtes en retard...");
106
Comment fonctionne le code
Continuez à lire pour savoir comment fonctionne le code.
Importation de
bibliothèques Le code commence par importer les bibliothèques nécessaires. Le MFRC522 pour le lecteur
RFID, le SD pour le module carte SD et le RTClib pour le RTC. Vous incluez également
la bibliothèque SPI pour la communication SPI avec le module RFID et carte SD.
#include <MFRC522.h> // pour la RFID
#include <SPI.h> // pour le module RFID et carte SD
#include <SD.h> // pour la carte SD
Préparation du lecteur RFID, de la carte SD et du RTC
Ensuite, vous définissez les broches pour le lecteur RFID et le module de carte SD. Pour le RFID, la broche
SCK (CS_RFID) est connectée à la broche 10 et la broche RST (RST_RFID) est connectée à la broche 9.
Pour le module de carte SD, la broche Chip Select (CS_SD) est connectée à la broche 4.
// définir les broches pour la RFID
#define CS_RFID 10
#define RST_RFID 9
// définir la broche de sélection de puce pour le module de carte SD
#define CS_SD 4
Vous créez un fichier appelé myFile pour stocker vos données.
Ensuite, vous créez une instance pour le RFID et pour le RTC :
// Instance de la classe pour RFID
MFRC522 rfid(CS_RFID, RST_RFID);
// Instance de la classe pour RTC
RTC_DS1307 rtc ;
variables
Vous créez une variable de chaîne uidString qui contient les balises UID.
Chaîne uidString ;
107
Les lignes suivantes créent des variables pour définir l'heure et la minute d'enregistrement. Dans ce cas, nous
définissons l'heure d'enregistrement à 9h05. Vous pouvez modifier l'heure d'enregistrement en modifiant ces
valeurs :
// Définir l'heure d'arrivée
const int checkInHour = 9;
const int checkInMinute = 5;
Vous devez également créer des variables pour conserver l'heure de vérification de l'utilisateur. Ces variables
enregistrera l'heure à laquelle une certaine étiquette UID a été lue. Les variables suivantes contiennent
l'heure d'enregistrement et la minute d'enregistrement.
//Variable pour maintenir l'enregistrement de l'utilisateur
int userCheckInHour ;
int userCheckInMinute ;
Enfin, vous attribuez les numéros de broches aux LED et au buzzer.
// Pins pour LEDs et buzzer
const int LED rouge = 6 ;
const int LED verte = 7 ;
const entier buzzer = 5 ;
installation()
Ensuite, dans setup(), vous définissez les LED et le buzzer comme sorties.
// Définir les LED et le buzzer comme sorties
pinMode (LED rouge, SORTIE);
pinMode (LED verte, SORTIE);
Après cela, chaque module est initialisé.
Les fonctions
Dans ce code, vous créez 3 fonctions : readRFID(), logCard() et verifyCheckIn().
La fonction readRFID() lit l'UID de la balise, l'enregistre dans la variable uidString et l'affiche sur le moniteur série.
De plus, lorsqu'il lit l'étiquette, le buzzer émet un bip sonore.
La fonction logCard() crée un fichier sur votre carte SD appelé DATA.txt. Vous pouvez modifier le nom du fichier,
si vous le souhaitez, sur la ligne suivante.
108
monFichier=SD.open("DATA.txt", FILE_WRITE);
Ensuite, il enregistre le uidString (qui contient l'UID de la balise) sur la carte SD et le
heure actuelle.
monFichier.print(uidString);
// Gain de temps sur carte SD
DateTime now = rtc.now();
monFichier.print(now.year(), DEC);
monFichier.print(maintenant.mois(), DEC);
monFichier.print(maintenant.jour(), DEC);
monFichier.print(',');
monFichier.print(maintenant.heure(), DEC);
monFichier.print(':');
monFichier.print(maintenant.minute(), DEC);
Il enregistre également l'heure et la minute d'enregistrement de l'utilisateur dans les variables suivantes pour une
comparaison ultérieure avec l'heure d'enregistrement prédéfinie.
userCheckInHour = now.hour();
userCheckInMinute = now.minute();
La fonction verifyCheckIn() compare simplement l'heure d'enregistrement de l'utilisateur avec l'heure
d'enregistrement prédéfinie et donne un retour en conséquence. Si l'utilisateur est en retard, la LED rouge
s'allume ; si l'utilisateur est à l'heure, la LED verte s'allume.
boucle()
Après avoir étudié les fonctions créées, la boucle () est assez simple à
comprendre.
Tout d'abord, le code vérifie si une étiquette RFID a été glissée. Si oui, il lira l'UID RFID, enregistrera l'UID et
l'heure sur la carte SD, puis il donnera un retour à l'utilisateur en allumant l'une des LED.
Saisir les données de la carte SD
Pour vérifier les données enregistrées sur la carte SD, retirezla du module de carte SD et
insérezle sur votre ordinateur.
109
Ouvrez le dossier de la carte SD et vous devriez avoir un fichier appelé DATA.txt.
Ouvrez le fichier à l'aide d'un éditeur de texte. Vous aurez quelque chose comme suit :
Notez que chaque valeur est séparée par des virgules. Cela facilite la tâche si vous souhaitez importer ces
données dans Excel, Google Sheets ou un autre logiciel de traitement de données.
Emballer
Dans ce projet, vous avez appris à utiliser un lecteur de carte RFID et le module de carte SD avec Arduino.
Vous pouvez modifier ce projet selon vos propres besoins ou vous pouvez utiliser les fonctions créées ici dans
d'autres projets qui nécessitent l'enregistrement de données ou la lecture d'étiquettes RFID.
Vous pouvez aller plus loin dans ce projet et ajouter un affichage pour donner un retour d'information
supplémentaire à l'utilisateur. Vous pouvez associer un nom à chaque UID et afficher le nom d'utilisateur lors
de la lecture de la balise. Vous voudrez peutêtre jeter un œil à quelques tutoriels avec l'Arduino en utilisant
des écrans :
• Guide pour écran OLED 0,96 pouces avec Arduino • Écran
Nextion avec Arduino Mise en route
Ceci est un extrait de notre cours "Projets pas à pas Arduino". Si vous aimez Arduino et que vous souhaitez
réaliser plus de projets, nous vous recommandons de télécharger notre cours : Projets Arduino étape par étape.
110
Enregistreur de données de température Arduino avec
module de carte SD
Ce projet vous montre comment créer un enregistreur de données de température Arduino. Nous utiliserons
le DHT11 pour mesurer la température, le module d'horloge en temps réel (RTC) pour prendre les
horodatages et le module de carte SD pour enregistrer les données sur la carte SD.
Ressources recommandées :
• Guide du module d'horloge temps réel (RTC) avec Arduino (DS1307 et DS3231)
• Guide complet pour le capteur d'humidité et de température DHT11/DHT22 avec
Arduino
• Guide du module de carte SD avec Arduino
111
Pièces requises
Voici une liste complète des pièces requises pour ce projet :
•Module de carte SD
• Carte Micro SD
• Capteur de température et d'humidité DHT11 • Module
RTC
• Planche à pain
• Fils de liaison
Remarque : à la place du module de carte SD, vous pouvez utiliser un bouclier d'enregistrement de données.
Le bouclier d'enregistrement de données est livré avec un RTC intégré et une zone de prototypage pour les
connexions à souder, les capteurs, etc.
112
Schémas
La figure suivante montre les schémas du circuit pour ce projet.
Remarque : assurezvous que votre carte SD est formatée et fonctionne correctement. Lisez "Guide du module de carte
SD avec Arduino".
Installation de la bibliothèque de capteurs DHT
Pour ce projet, vous devez installer la bibliothèque DHT pour lire à partir du capteur DHT11.
1. Cliquez ici pour télécharger la bibliothèque de capteurs DHT. Vous devriez avoir un dossier .zip
dans votre dossier Téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir le dossier DHTsensorlibrarymaster 3. Renommez votre
dossier de DHTsensorlibrarymaster en DHT 4. Déplacez le dossier DHT vers le dossier des bibliothèques
d'installation de votre IDE Arduino 5. Enfin , rouvrez votre IDE Arduino
Installation de la bibliothèque Adafruit_Sensor
Pour utiliser le capteur de température et d'humidité DHT, vous devez également installer la bibliothèque Adafruit_Sensor.
Suivez les étapes suivantes pour installer la bibliothèque dans votre IDE Arduino :
1. Cliquez ici pour télécharger la bibliothèque Adafruit_Sensor. Vous devriez avoir un dossier .zip dans votre dossier
Téléchargements 2. Décompressez le dossier .zip et vous devriez obtenir le dossier Adafruit_Sensormaster 3.
Renommez votre dossier Adafruit_Sensormaster en Adafruit_Sensor
113
4. Déplacez le dossier Adafruit_Sensor vers vos bibliothèques d'installation Arduino IDE
dossier
5. Enfin, rouvrez votre IDE Arduino
Code
/*
* Rui Santos
* Détails complets du projet http://randomnerdtutorials.com */
#include <SPI.h> //pour le module de carte SD
#include <SD.h> // pour la carte SD #include <DHT.h> //
pour le capteur DHT
// définir la broche DHT #
définir DHTPIN 2 // à quelle broche nous sommes connectés
// décommentez le type que vous utilisez #define DHTTYPE
DHT11 // DHT 11
//#define DHTTYPE DHT22 //DHT 22 (AM2302) //#define DHTTYPE
DHT21 //DHT 21 (AM2301)
// initialise le capteur DHT pour Arduino 16 mhz normal
DHT dht(DHTPIN, DHTTYPE);
// changez ceci pour correspondre à votre bouclier ou module SD ;
// Blindage et modules Ethernet Arduino : broche 4
// Boucliers et modules SD d'enregistrement de données : broche 10
// Bouclier SD Sparkfun : broche 8 const int
chipSelect = 4 ;
// Crée un fichier pour stocker les données
// RTC
RTC_DS1307 rtc ;
void setup() { //
initialisation du capteur DHT dht.begin();
// initialisation du moniteur série Serial.begin(9600);
114
// configuration pour le RTC while(!
Serial); // pour Leonardo/Micro/Zero if(! rtc.begin()) {
Serial.println("Impossible de trouver RTC"); tandis que (1);
}
sinon {
// la ligne suivante définit le RTC sur la date et l'heure de compilation de cette esquisse rtc.adjust(DateTime(F(__DATE__),
F(__TIME__)));
}
if(! rtc.isrunning()) { Serial.println("RTC
n'est PAS en cours d'exécution !");
}
// configuration pour la carte SD
Serial.print("Initializing SD card...");
if(!SD.begin(chipSelect)) {
Serial.println("l'initialisation a échoué !");
retour;
}
Serial.println("initialisation terminée.");
//ouvre le fichier
monFichier=SD.open("DATA.txt", FILE_WRITE);
// si le fichier s'est ouvert correctement, écrivezy : if (monFichier)
{ Serial.println("Fichier ouvert ok"); // imprime les entêtes de nos
données monFichier.println("Date,Heure,Température ºC");
}
monFichier.close();
}
void loggingTime() { DateTime
now = rtc.now(); monFichier =
SD.open("DATA.txt", FILE_WRITE); if (myFile) { myFile.print(now.year(),
DEC); monFichier.print('/'); monFichier.print(maintenant.mois(), DEC);
monFichier.print('/'); monFichier.print(maintenant.jour(), DEC);
monFichier.print(','); monFichier.print(maintenant.heure(), DEC);
monFichier.print(':'); monFichier.print(maintenant.minute(), DEC);
monFichier.print(':'); monFichier.print(now.second(), DEC);
monFichier.print(",");
115
}
Serial.print(now.year(), DEC); Serial.print('/');
Serial.print(maintenant.mois(), DEC); Serial.print('/');
Serial.println(now.day(), DEC); Serial.print(now.hour(),
DEC); Serial.print(':'); Serial.print(maintenant.minute(),
DEC); Serial.print(':'); Serial.println(now.second(), DEC);
monFichier.close(); retard(1000);
void loggingTemperature() {
// La lecture de la température ou de l'humidité prend environ 250 millisecondes !
// Les lectures du capteur peuvent également être "anciennes" jusqu'à 2 secondes (c'est un capteur très lent)
// Lit la température en Celsius float t =
dht.readTemperature(); // Lire la température en
Fahrenheit //float f = dht.readTemperature(true);
// Vérifiez si des lectures ont échoué et quittez plus tôt (pour réessayer). si (n'est pas(t) /*|| n'est pas(f)*/) {
Serial.println("Échec de la lecture du capteur DHT !");
retour;
}
//à des fins de débogage
Serial.print("Temperature : "); Serial.print(t);
Serial.println(" *C"); //Serial.print(f); //Serial.println("
*F\t");
monFichier = SD.open("DATA.txt", FILE_WRITE); si (monFichier) {
Serial.println("ouvrir avec succès"); monFichier.print(t);
monFichier.println(",");
} monFichier.close();
}
void loop()
{ loggingTime();
loggingTemperature(); retard (5000);
116
Dans ce code, nous créons deux fonctions qui sont appelées dans la boucle() :
• loggingTime() : consigne l'heure dans le fichier DATA.txt de la carte SD •
loggingTemperature() : consigne la température dans le fichier DATA.txt de la carte SD.
Ouvrez le moniteur série à un débit en bauds de 9600 et vérifiez si tout fonctionne correctement.
Obtenir les données de la carte SD
Laissez ce projet fonctionner pendant quelques heures pour collecter une quantité décente de données, et lorsque
vous êtes satisfait de la période d'enregistrement des données, éteignez l'Arduino et retirez la carte SD du module
de carte SD.
Insérez la carte SD dans votre ordinateur, ouvrezla et vous devriez avoir un fichier DATA.txt
avec les données collectées.
Vous pouvez ouvrir les données avec un éditeur de texte ou utiliser une feuille de calcul pour analyser et manipuler
vos données.
Les données sont séparées par des virgules et chaque lecture est dans une nouvelle ligne. Dans ce format, vous
pouvez facilement importer des données vers Excel ou un autre logiciel de traitement de données.
117
Application Android – LED RVB avec
Arduino et Bluetooth
Télécharger les fichiers .apk Cliquez ici
Télécharger les fichiers .aia Cliquez ici
Dans ce projet, vous allez créer une application Android pour contrôler la couleur d'une LED RVB avec un smartphone via
Bluetooth.
Vous allez créer l'application Android à l'aide d'un logiciel Web gratuit appelé MIT App Inventor 2. Il s'agit d'un excellent
projet pour apprendre à interfacer l'Arduino avec un smartphone.
Si vous n'êtes pas familier avec les LED RVB, lisez le post suivant : Comment fonctionnent les LED RVB ?
118
Pièces requises
• Module Bluetooth HC04 ou HC05 ou HC06
• LED RVB (anode commune)
• 3 résistances de 220 Ohms
• Planche à pain
• Fils de liaison
De plus, vous avez également besoin d'un smartphone avec Bluetooth.
Création de l'application Android
L'application Android sera créée à l'aide d'une application Web gratuite appelée MIT App Inventor. MIT App
Inventor est un excellent endroit pour démarrer avec le développement Android, car il vous permet de créer
des applications simples par glisserdéposer.
Vous avez besoin d'un compte Google pour vous inscrire à MIT App Inventor et voici la page de connexion :
http://ai2.appinventor.mit.edu.
119
Après vous être connecté, allez dans Projets Importer un projet (.aia) depuis mon ordinateur et téléchargez le
fichier .aia. Cliquez ici pour télécharger le fichier .aia.
Après avoir téléchargé le fichier .aia. Vous verrez l'application sur le logiciel MIT App Inventor.
Designer
Avec MIT App Inventor, vous avez 2 sections principales : concepteur et blocs.
Le concepteur est ce qui vous donne la possibilité d'ajouter des boutons, d'ajouter du texte, d'ajouter des écrans et
de modifier l'apparence générale de l'application. Dans le logiciel App Inventor, l'application ressemble à ceci :
120
L'application est différente dans le logiciel et dans votre smartphone. Voici à quoi ressemble l'application
sur notre smartphone :
Blocs
Vous avez également la section des blocs. Les sections de blocs sont ce qui permet de créer
fonctionnalité personnalisée pour votre application, donc lorsque vous appuyez sur les boutons, il fait
réellement quelque chose avec ces informations. Voici les blocs pour cette application visitez la page du
projet pour une figure haute résolution :
121
Installation de l'application
Pour installer l'application sur votre smartphone, accédez à l'onglet Construire.
Vous pouvez soit générer un code QR que vous pouvez scanner avec votre smartphone et installer
automatiquement l'application sur votre smartphone.
Ou vous pouvez télécharger le fichier .apk, connectez votre smartphone à votre ordinateur et déplacez le
fichier .apk vers le téléphone.
Suivez simplement l'assistant d'installation pour installer l'application et c'est fait !
Code
Assurezvous d'avoir sélectionné la bonne carte et le bon port COM.
Remarque : avant de télécharger le code, assurezvous d'avoir les broches TX et RX
déconnecté du module bluetooth !
/*
* Rui Santos
*/
#define max_char 12 char
message[max_char] ; char r_char; // stocke votre message
indice d'octet = 0 ; // lit chaque caractère
// définit la position dans votre tableau
int je ;
int redPin = 11 ; // Broche RVB rouge > D11
int greenPin = 10 ; // Broche RVB verte > D10
int bluePin = 9; // Broche RVB bleue > D9
int valeurrouge = 255 ; // Broche RVB rouge > D11
valeur verte int = 255 ; // Broche RVB verte > D10
int blueValue = 255; // Broche RVB bleue > D9
122
Chaîne redTempValue ; // Broche RVB rouge > D11
Chaîne greenTempValue ; // Broche RVB verte > D10
Chaîne blueTempValue ; // Broche RVB bleue > D9
drapeau int = 0 ;
char couleurcourante ;
pinMode(redPin,OUTPUT);
pinMode(bluePin,OUTPUT);
pinMode(greenPin, SORTIE);
// initialise la communication série à 9600 bits par seconde :
}
boucle vide () {
//pendant la lecture du message
while(Serial.available() > 0){
drapeau = 0 ;
//le message peut avoir jusqu'à 12 caractères
if(index < (max_char1)){ r_char =
Serial.read(); // Lit un caractère
message[index] = r_char ; si(r_char=='R') // Stocke le caractère dans le tableau de message
{
couleurcourante = 'R';
valeurTemprouge = "" ;
}
sinon si(r_char=='G'){
couleurcourante = 'G';
greenTempValue = "" ;
}
sinon si(r_char=='B'){
CouleurCourante = 'B';
blueTempValue = "" ;
}
if(currentColor == 'R' && r_char!='R'){
redTempValue += r_char ;
}
sinon si(currentColor == 'G' && r_char!='G'){
greenTempValue += r_char ;
}
sinon si(currentColor == 'B' && r_char!='B'){
blueTempValue += r_char ;
}
indice++ ; // Incrémenter la position
message[indice] = '\0' ; // Supprimer la dernière position
123
si(drapeau == 0){
analogWrite(redPin, 255redTempValue.toInt());
analogWrite(greenPin, 255greenTempValue.toInt());
analogWrite(bluePin, 255blueTempValue.toInt());
/*Serial.print('R');
Serial.println(redTempValue);
Serial.print('G');
Serial.println(greenTempValue);
Serial.print('B');
Serial.println(blueTempValue);
Serial.print("MESSAGE ");*/
Serial.println(message);
drapeau=1 ;
pour(je=0; je<12; je++){
message[je] = '\0' ;
}
//repose l'index
indice=0 ;
Schémas
Suivez le schéma de principe de la figure suivante pour câbler votre circuit.
124
Remarque : Si vous utilisez une cathode commune à LED RVB, vous devez connecter le câble le plus
long à GND.
Important : Voici les connexions du module Bluetooth à l'Arduino :
• Le module Bluetooth TX se connecte à Arduino RX
• Le module Bluetooth RX se connecte à Arduino TX
Voici à quoi devrait ressembler votre circuit :
Lancement de l'application
Si vous n'avez pas généré le fichier .apk lors d'une étape précédente, vous pouvez cliquer ici pour
télécharger le fichier .apk (qui est le fichier d'installation de l'application Android). Déplacez ce fichier sur
votre smartphone et ouvrezle. Suivez l'assistant d'installation pour installer l'application.
Activez le Bluetooth de votre smartphone.
125
Assurezvous de coupler votre smartphone avec le module Bluetooth recherchez les appareils couplés dans les
paramètres Bluetooth de votre smartphone.
Ensuite, ouvrez l'application nouvellement installée. Appuyez sur le bouton Connect Bluetooth pour vous connecter
via Bluetooth au module Bluetooth Arduino.
Sélectionnez votre module Bluetooth (il devrait s'appeler linvor).
Maintenant, il est prêt à l'emploi ! Déplacez les curseurs et cliquez sur CHANGER LA COULEUR pour définir votre
Couleur LED RVB.
126
Dépannage
1. Je ne peux pas télécharger de code sur ma carte Arduino.
Vérifiez si les câbles TX et RX du module Bluetooth sont déconnectés.
Lorsque vous téléchargez du code sur votre Arduino, vous devez déconnecter les câbles TX et RX du module
Bluetooth. Ces broches sont nécessaires pour la communication série entre l'Arduino et votre ordinateur.
2. Je ne trouve pas mon périphérique de module Bluetooth.
Assurezvous d'avoir appairé votre smartphone avec votre module Bluetooth. Accédez à vos paramètres
Bluetooth et recherchez les appareils disponibles. Votre périphérique module bluetooth devrait apparaître (il
est souvent appelé : linvor, HC06, HC04, HC05 …). Associezle. S'il demande un mot de passe, c'est 1234.
3. L'application n'interagit pas avec l'Arduino.
Si votre application Android est connectée à votre module Bluetooth, elle devrait afficher le message
« Connecté » (comme indiqué cidessous). Sinon, appuyez sur "Connecter Bluetooth"
pour établir une communication Bluetooth.
Vérifiez les connexions de votre module Bluetooth :
• Le module Bluetooth TX se connecte à Arduino RX
• Le module Bluetooth RX se connecte à Arduino TX
4. Mon module Bluetooth demande un mot de passe.
Si votre module bluetooth vous demande un mot de passe, tapez 1234.
Emballer
Dans ce projet, vous avez appris à contrôler la couleur d'une LED RVB avec une application Android
construite avec le logiciel MIT App Inventor 2.
Maintenant, n'hésitez pas à changer l'apparence de l'application et à lui donner plus de fonctionnalités. Si
vous aimez ce projet, assurezvous de consulter notre cours : Applications Android pour Arduino avec MIT
App Inventor 2.
127
Contrôler le moteur à courant continu via Bluetooth
Introduction
Dans ce projet, nous allons contrôler un moteur à courant continu avec un smartphone via Bluetooth. Ce
projet est idéal pour en savoir plus sur :
• Moteurs à courant continu
• Interfacer Arduino avec votre smartphone
• Bluetooth
• CI L293D
128
Pièces requises
• 1x Module Bluetooth (par exemple : HC05 ou 06) • 1x Smartphone (n'importe
quel Android fonctionnera) • Application BlueTerm
• 1 circuit intégré L293D
• 1x moteur à courant continu
129
Schémas
Câblez le circuit en suivant le schéma suivant.
Vous ne pouvez connecter les câbles TX et RX à votre Arduino qu'après avoir téléchargé le code.
Deux erreurs courantes
1. Vous devez retirer les câbles RX et TX lorsque vous téléchargez le croquis sur votre Arduino.
2. Parfois, les gens connectent le TX du module Bluetooth au TX de l'Arduino... c'est faux et
cela ne fonctionnera pas. Assurezvous de le connecter correctement,
le TX dans RX et le RX dans le TX.
Note
Si le module Bluetooth HC05 demande un mot de passe, c'est '1234'.
130
Code
Assurezvous de retirer les fils de RX et TX, sinon le code ne sera pas téléchargé correctement !
/*
* Contrôler le moteur DC avec Smartphone via Bluetooth * créé par Rui
Santos, http://randomnerdtutorials.com */
int motorPin1 = 3 ; // broche 2 sur L293D IC int motorPin2 =
4 ; // broche 7 sur L293D IC int enablePin = 5 ; // broche 1
sur l'état int L293D IC ; drapeau entier =0 ;
// s'assure que le numéro de série ne s'imprime qu'une fois l'état
void setup() { // définit
les broches comme sorties :
pinMode(motorPin1, OUTPUT);
pinMode(moteurPin2, SORTIE);
pinMode(enablePin, OUTPUT); // définit
enablePin haut pour que le moteur puisse s'allumer : digitalWrite(enablePin,
HIGH); // initialise la communication série à 9600 bits par seconde :
Serial.begin(9600);
void loop() { //si une
date est envoyée, la lit et l'enregistre dans l'état if(Serial.available() > 0){ state
= Serial.read(); drapeau=0 ;
} // si l'état est '0', le moteur à courant continu s'éteindra if (state == '0')
{ digitalWrite(motorPin1, LOW); // définit la broche 2 sur L293D low
digitalWrite(motorPin2, LOW); // définit la broche 7 sur L293D bas if(flag == 0){
Serial.println("Moteur : éteint"); drapeau=1 ;
} // si l'état est '1' le moteur tournera à droite sinon if (state == '1')
{ digitalWrite(motorPin1, LOW); // définit la broche 2 sur L293D low
digitalWrite(motorPin2, HIGH); // place la broche 7 sur L293D à l'état haut if(flag == 0)
{ Serial.println("Motor: right"); drapeau=1 ;
} // si l'état est '2' le moteur tournera à gauche sinon if (state == '2')
{ digitalWrite(motorPin1, HIGH); // définit la broche 2 sur L293D high
digitalWrite(motorPin2, LOW); // définit la broche 7 sur L293D bas if(flag == 0){
131
Serial.println("Moteur : gauche"); drapeau=1 ;
}
}
}
Pour la communication android avec le module bluetooth j'ai utilisé le BlueTerm
application. C'est entièrement gratuit, il vous suffit donc d'aller sur "Play Store" et de le télécharger.
Ensuite, vous connectez votre smartphone avec le module Bluetooth. N'oubliez pas de retirer les câbles TX et
RX. (vous pouvez voir dans la vidéo youtube cidessous comment cela se fait).
Je n'ai défini que 3 commandes pour contrôler le moteur à courant continu :
• '0' Éteint le moteur à courant continu
• '1' Le moteur CC tourne vers la droite •
'2' Le moteur CC tourne vers la gauche
Regarder sur YouTube : http://youtu.be/nXymP6ttxD4
132
Demander les données du capteur par SMS
Dans ce projet, nous allons vous montrer comment demander des données de capteur par SMS avec
l'Arduino. A titre d'exemple, nous allons demander la température et l'humidité d'un capteur DHT11. Pour
envoyer et recevoir des SMS avec l'Arduino, nous allons utiliser le bouclier GSM SIM900. Lorsque vous
envoyez un SMS à l'Arduino avec le message "STATE", il répond avec les dernières lectures de température
et d'humidité.
Avant de poursuivre ce didacticiel, nous vous recommandons les ressources suivantes :
• Guide du bouclier SIM900 GSM GPRS avec Arduino
• Guide pour le capteur d'humidité et de température DHT11/DHT22 avec Arduino
• Inscrivezvous à notre minicours Arduino gratuit
133
Regarder sur YouTube : https://youtu.be/2Cz1GOvEbrw
Bouclier GSM SIM900
Il existe plusieurs modules que vous pouvez utiliser pour envoyer et recevoir des SMS avec l'Arduino.
Nous avons réalisé ce projet en utilisant le bouclier GSM SIM900 et c'est le bouclier que nous vous
recommandons d'obtenir.
Le bouclier GSM SIM900 est illustré dans la figure cidessous :
Pour une introduction au bouclier GSM et comment le configurer, lisez le Guide de
Bouclier SIM900 GSM GPRS avec Arduino.
134
Pièces requises
Voici une liste de tous les composants nécessaires pour ce projet :
• Bouclier GSM SIM900
• Adaptateur secteur 5V 2A •
Programmeur FTDI (facultatif)
• Carte SIM
• DHT11 ou DHT22 Capteur de température et d'humidité
• Résistance de 10 kOhms
• Planche à pain
• Fils de cavalier
Étapes préliminaires
Avant de commencer avec votre module GSM SIM900, vous devez prendre en compte certains aspects
concernant la carte SIM et l'alimentation du blindage.
135
Carte SIM prépayée
Nous vous recommandons d'utiliser un forfait prépayé ou un forfait avec SMS illimités à des fins de test. Sinon, en
cas de problème, vous devrez peutêtre payer une facture énorme pour des centaines de SMS envoyés par erreur.
Dans ce tutoriel, nous utilisons un forfait prépayé avec SMS illimités.
Le bouclier utilise la taille de la carte SIM d'origine, pas micro ou nano. Si vous avez un micro ou un nano, vous
pouvez envisager de vous procurer un adaptateur de la taille d'une carte SIM.
Désactiver le verrouillage par code PIN
Pour utiliser la carte SIM avec le bouclier, vous devez désactiver le verrouillage par broche. Pour ce faire, le moyen
le plus simple consiste à insérer la carte SIM dans votre smartphone et à désactiver le verrouillage par code PIN
dans les paramètres de sécurité du téléphone.
Dans mon cas, je dois passer par : Paramètres Paramètres avancés Sécurité Verrouillage SIM et désactiver
le verrouillage de la carte sim avec le code PIN.
136
Obtenir la bonne alimentation électrique Le
bouclier a une prise CC pour l'alimentation, comme indiqué dans la figure cidessous.
À côté de la prise d'alimentation, il y a un interrupteur à bascule pour sélectionner la source d'alimentation. À côté
de l'interrupteur à bascule sur la carte, il y a une flèche indiquant la position de bascule pour utiliser une alimentation
externe déplacez l'interrupteur à bascule pour utiliser l'alimentation externe comme indiqué cidessus.
Pour alimenter le shield, il est conseillé d'utiliser une alimentation 5V pouvant fournir 2A comme celle présentée ci
dessous.
137
Vous pouvez trouver le bon adaptateur secteur pour ce bouclier ici. Assurezvous de sélectionner le modèle
avec 5V et 2A.
Configuration du bouclier GSM SIM900
Les étapes suivantes vous montrent comment configurer le shield GSM SIM900.
1) Insérez la carte SIM dans le support de carte SIM. Vous avez besoin d'une carte SIM de taille standard. Le
bouclier n'est pas compatible avec les cartes micro ou nano SIM. Si vous en avez besoin, vous pouvez obtenir
un adaptateur de taille de carte SIM. Aussi, il est conseillé d'utiliser une carte SIM avec un forfait prépayé ou
des SMS illimités.
2) Vérifiez que l'antenne est bien connectée.
3) Sur le port série sélectionné, assurezvous que le capuchon du cavalier est connecté comme indiqué dans
la figure cidessous pour utiliser le logiciel série.
138
4) Alimentez le bouclier à l'aide d'une alimentation externe 5V. Vérifiez que vous avez sélectionné la source
d'alimentation externe comme nous l'avons mentionné précédemment.
5) Pour allumer/éteindre le bouclier, appuyez sur la touche d'alimentation pendant environ 2 secondes.
6) Ensuite, la LED d'état s'allumera et la LED NetLight clignotera toutes les 800 ms jusqu'à ce qu'elle trouve le réseau.
Lorsqu'il trouve le réseau, le voyant NetLight commence à clignoter toutes les trois secondes.
7) Vous pouvez tester si le bouclier fonctionne correctement en envoyant des commandes AT depuis l'IDE Arduino à
l'aide d'un programmeur FTDI comme indiqué cidessous.
139
Tester le bouclier avec le programmeur FTDI
Vous n'avez pas besoin de faire cette étape pour que le bouclier fonctionne correctement. Il s'agit d'une
étape supplémentaire pour vous assurer que vous pouvez communiquer avec votre bouclier GSM et
envoyer des commandes AT à partir du moniteur série Arduino IDE. Pour cela, vous avez besoin d'un
programmeur FTDI comme celui illustré dans la figure cidessous.
1) Connectez le programmateur FTDI au blindage GSM comme indiqué sur la figure cidessous.
2) Ouvrez l'IDE Arduino et sélectionnez le bon port COM.
140
3) Ouvrez le moniteur série.
4) Sélectionnez un débit en bauds de 19200 le réglage par défaut du blindage est de 19200 et un retour chariot.
Écrivez AT dans la case surlignée en rouge, puis appuyez sur Entrée. Voir la figure cidessous.
5) Le bouclier répondra par OK, si tout fonctionne correctement.
Maintenant que vous savez que le bouclier fonctionne correctement, vous êtes prêt à commencer à construire le
projet.
141
Schémas
La figure cidessous montre les schémas de circuit pour ce projet. Vous devez connecter le blindage GSM SIM900 et le
capteur de température et d'humidité DHT11 à l'Arduino comme indiqué dans la figure cidessous.
Installation de la bibliothèque DHT
Pour lire à partir du capteur DHT, vous devez avoir installé la bibliothèque DHT. Si la bibliothèque DHT n'est pas installée,
suivez les instructions cidessous :
1. Cliquez ici pour télécharger la bibliothèque de capteurs DHT. Vous devriez avoir un dossier .zip
dans votre dossier Téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir le dossier DHTsensorlibrarymaster 3. Renommez votre
dossier de DHTsensorlibrarymaster en DHT 4. Déplacez le dossier DHT vers le dossier des bibliothèques
d'installation de votre IDE Arduino 5. Enfin , rouvrez votre IDE Arduino
142
Installation de la bibliothèque Adafruit_Sensor
Pour utiliser le capteur de température et d'humidité DHT, vous devez également installer la bibliothèque
Adafruit_Sensor. Suivez les étapes suivantes pour installer la bibliothèque dans votre IDE Arduino :
6. Cliquez ici pour télécharger la bibliothèque Adafruit_Sensor. Vous devriez avoir un dossier .zip dans
votre dossier Téléchargements 7. Décompressez le dossier .zip et vous devriez obtenir le dossier
Adafruit_Sensormaster 8. Renommez votre dossier Adafruit_Sensormaster en Adafruit_Sensor 9.
Déplacez le dossier Adafruit_Sensor vers vos bibliothèques d'installation Arduino IDE
dossier
10.Enfin, rouvrez votre IDE Arduino
Code
Le code suivant lit la température et l'humidité du capteur DHT et les envoie par SMS lorsque vous envoyez
un SMS à l'Arduino avec le message
"ÉTAT".
Vous devez modifier le code fourni avec le numéro de téléphone auquel votre Arduino doit répondre aux
lectures. Le code est bien commenté pour que vous compreniez le but de chaque ligne de code.
Ne téléchargez pas le code maintenant. Faites défiler vers le bas et lisez l'explication sous le code.
/*
* Rui Santos
* Détails complets du projet http://randomnerdtutorials.com */
// Inclure la bibliothèque DHT et la bibliothèque de capteurs Adafruit #include
"DHT.h"
#include <Adafruit_Sensor.h> //Include la
bibliothèque série logicielle pour communiquer avec GSM #include <SoftwareSerial.h>
// La broche DHT est connectée à
#définir DHTPIN 2
// Décommentez le type de capteur que vous utilisez #define DHTTYPE
DHT11 // DHT 11
143
//#define DHTTYPE DHT22 //DHT 22 (AM2302) //#define DHTTYPE
DHT21 //DHT 21 (AM2301)
// Initialiser le capteur DHT pour Arduino 16 mhz normal
// Crée des varibales globales pour stocker la température et l'humidité float t; // température en
degrés Celsius float f ; // température en Fahrenheit float h; // humidité
// Configurer le port série du logiciel
LogicielSerial SIM900(7, 8);
// Créer une variable pour stocker les caractères SMS entrants char entrantChar ;
void setup() { dht.begin();
SIM900.begin(19200);
// Donnez du temps à votre bouclier GSM pour vous connecter au délai du réseau
(20000); Serial.print("SIM900 prêt...");
// Commande AT pour mettre SIM900 en mode SMS
SIM900.print("AT+CMGF=1\r"); retard(100); //
Définir le module pour envoyer les données
SMS à la sortie série dès réception SIM900.print("AT+CNMI=2,2,0,0,0\r"); retard(100);
boucle vide (){
si (SMSRequest())
{ si(readData()){
retard(10);
// REMPLACER LES X PAR LE NUMERO DE MOBILE DU DESTINATAIRE
// UTILISER LE CODE DE FORMAT INTERNATIONAL POUR LES
NUMEROS MOBILES SIM900.println("AT + CMGS = \"+XXXXXXXXXX\"");
retard(100); // REMPLACER PAR VOTRE PROPRE CONTENU DE
MESSAGE SMS
Chaîne dataMessage = ("Température : " + Chaîne(t) + "*C " + " Humidité:
" + Chaîne(h) + "%" );
// Décommenter pour changer le message avec la température farenheit
+ "
// Chaîne dataMessage = ("Température : " + Chaîne(f) + "*F "
Humidité: " + Chaîne(h) + "%" );
// Envoie le message texte SMS
SIM900.print(dataMessage);
144
retard(100); // Fin
de la commande AT avec un ^Z, code ASCII 26 SIM900.println((char)26);
retard(100); SIM900.println(); // Donne au module le temps d'envoyer un
SMS delay(5000);
}
}
retard(10);
}
booléen readData() { //Lire
l'humidité h =
dht.readHumidity(); // Lire la température
en degrés Celsius t = dht.readTemperature(); // Lire
la température en Fahrenheit f =
dht.readTemperature(true);
// Calcule les valeurs de température en Celsius t =
dht.computeHeatIndex(t,h,false);
// Décommentez pour calculer les valeurs de température en Fahrenheit //f =
dht.computeHeatIndex(f,h,false);
// Vérifiez si des lectures ont échoué et quittez plus tôt (pour réessayer). if (isnan(h) || isnan(t) ||
isnan(f)) { Serial.println("Échec de la lecture du capteur DHT !");
retourner faux ;
}
Serial.print("Humidité : "); Serial.print(h);
Serial.print(" %\t"); Serial.print("Température :
"); Serial.print(t); Serial.print(" *C "); //
Décommenter pour imprimer la température en
Farenheit //Serial.print(f); //Serial.print(" *F\t");
retourner vrai ;
}
booléen SMSRequest()
{ if(SIM900.available() >0) {
entrantChar=SIM900.read();
if(incomingChar=='S') { retard(10);
Serial.print(incomingChar);
entrantChar=SIM900.read(); if(incomingChar
=='T') { retard(10);
145
entrantChar=SIM900.read(); if(incomingChar=='A')
{ retard(10); Serial.print(incomingChar);
entrantChar=SIM900.read();
if(incomingChar=='T') { retard(10);
entrantChar=SIM900.read(); if(incomingChar=='E')
{ retard(10); Serial.print(incomingChar);
Serial.print("...Demande reçue \n");
retourner vrai ;
}
}
}
}
}
}
retourner faux ;
}
Importation de bibliothèques
Tout d'abord, vous incluez les bibliothèques nécessaires à ce projet : la bibliothèque DHT pour lire à partir du
capteur DHT et la bibliothèque SoftwareSerial pour communiquer avec le SIM900.
Module GSM.
#include "DHT.h"
#include <Adafruit_Sensor.h>
#include <SoftwareSerial.h>
Capteur DHT
Ensuite, vous dites à l'Arduino que la broche de données DHT est connectée à la broche 2, sélectionnez le
type de capteur DHT et créez une instance dht. Le code est compatible avec d'autres capteurs DHT tant que
vous définissez celui que vous utilisez dans le code.
#définir DHTPIN 2
#define DHTTYPE DHT11
Vous créez également des variables flottantes pour stocker les valeurs de température et d'humidité.
flotter t ; // température en degrés Celsius
flottant f ; // température en Fahrenheit
146
flottant h ; // humidité
Bouclier GSM
La ligne suivante configure la série logicielle sur les broches 7 et 8. La broche 7 est configurée comme RX
et la broche 8 comme TX.
LogicielSerial SIM900(7, 8);
Vous créez également une variable char pour stocker les caractères SMS entrants.
char entrantChar ;
installation()
Dans le setup(), vous commencez le DHT et le shield SIM900. Le bouclier SIM900 est réglé sur le mode
texte et vous configurez également le module pour envoyer les données SMS au moniteur série lorsqu'il les
reçoit. Cela se fait avec les deux lignes suivantes, respectivement :
SIM900.print("AT+CMGF=1\r");
SIM900.print("AT+CNMI=2,2,0,0,0\r");
Les fonctions
Nous créons une fonction pour lire la température et l'humidité appelée readData(). Cette fonction stocke
les valeurs sur les variables t et h. Le code utilise la température en Celsius, mais il est préparé si vous
voulez plutôt Fahrenheit le code est commenté sur l'endroit où vous devez apporter les modifications.
Nous créons également une fonction qui vérifie si le message entrant est égal à STATE la fonction
SMSRequest() . Cette fonction renvoie true si l'Arduino reçoit un message avec le texte STATE et false
sinon. Vous lisez les caractères SMS entrants en utilisant :
entrantChar = SIM900.read();
boucle()
Dans la boucle (), vous vérifiez s'il y a eu une demande SMS avec la fonction SMSRequest () vous vérifiez
si l'Arduino a reçu un message STATE. Si c'est vrai, il lira la température et l'humidité et vous l'enverra par
SMS.
Le numéro auquel l'Arduino répond est défini à la ligne suivante :
SIM900.println("AT + CMGS = \"XXXXXXXXXXXX\"");
Remplacez XXXXXXXXXXXX par le numéro de téléphone du destinataire.
147
Remarque : vous devez ajouter le numéro selon le format des numéros de téléphone internationaux.
Par exemple, au Portugal, le numéro est précédé de +351XXXXXXXXX.
Ensuite, vous stockez le message que vous souhaitez envoyer dans la variable dataMessage. Enfin,
vous envoyez le SMS en utilisant :
SIM900.print(dataMessage);
Manifestation
Lorsque vous envoyez le message STATE à l'Arduino, il répond avec les données du capteur.
Regardez la vidéo au début du projet pour une démonstration plus approfondie du projet.
Emballer
Il s'agit d'un excellent projet pour vous aider à démarrer avec le bouclier GSM SIM900. Vous avez appris
à lire et à envoyer des SMS avec l'Arduino.
Vous pouvez appliquer les concepts appris dans à peu près n'importe quel projet. Voici quelques idées
de projets :
• Système de surveillance qui envoie un SMS lorsqu'il détecte un mouvement •
Contrôler un relais par SMS • Demander des données de capteur spécifiques à partir
d'une collection de capteurs en ajoutant plus de conditions au code
148
Veilleuse de nuit avec Arduino
Introduction
Dans ce projet, vous allez construire une veilleuse de nuit avec un module relais, une photorésistance et un
Arduino.
Une veilleuse de nuit ne s'allume que lorsqu'il fait noir et lorsqu'un mouvement est détecté.
Voici les principales caractéristiques de ce projet :
• la lampe s'allume lorsqu'il fait sombre ET qu'un mouvement est détecté ; •
lorsqu'un mouvement est détecté, la lampe reste allumée pendant 10 secondes ; •
lorsque la lampe est allumée et détecte un mouvement, elle commence à compter 10 secondes
encore;
• lorsqu'il y a de la lumière, la lampe est éteinte, même lorsqu'un mouvement est détecté.
149
Ressources recommandées
Les ressources suivantes incluent des guides sur la façon d'utiliser le module de relais et le capteur de mouvement
PIR avec l'Arduino, ce qui pourrait être utile pour ce projet.
• Guide du module relais avec Arduino
• Arduino avec capteur de mouvement PIR
Pièces requises
• Capteur de mouvement PIR
• Photorésistance
• Résistance 10kOhms
• Module relais • Jeu
de cordons de lampe (voir sur eBay)
• Planche à pain
• Fils de liaison
Outre ces composants électroniques, vous avez également besoin d'une prise mâle CA, d'un fil CA et d'un
support d'ampoule de lampe (un jeu de cordons de lampe) comme indiqué dans la figure cidessous.
150
Code
Attention : ne chargez pas un nouveau code sur votre carte Arduino tant que votre lampe est connectée
au secteur. Vous devez débrancher la lampe de la tension secteur avant de télécharger un nouveau
croquis sur votre Arduino.
/*
* Rui Santos
*/
// La broche relais est contrôlée avec D8. Le fil actif est connecté à normalement fermé et commun
int relais = 8 ;
octet volatile relayState = LOW ;
// Le capteur de mouvement PIR est connecté à D2.
int PIRInterrupt = 2 ;
// La broche LDR est connectée à Analog 0
entier LDRPin = A0 ;
// La valeur LDR est stockée lors de la lecture LDR
151
int LDRLecture ;
// Valeur seuil LDR
int LDRThreshold = 300 ;
// Variables de minuterie
long lastDebounceTime = 0 ;
long debounceDelay = 10000 ;
// Broche pour le module de relais défini comme sortie
pinMode(relais, SORTIE);
digitalWrite(relais, HIGH);
// Capteur de mouvement PIR défini comme entrée
pinMode(PIRInterrupt, INPUT);
// Déclenche la fonction detectMotion en mode montant pour activer le relais, si
la condition est remplie
attachInterrupt(digitalPinToInterrupt(PIRInterrupt), detectMotion, RISING); // Communication série à des fins de débogage
boucle vide () {
// Si 10 secondes se sont écoulées, le relais est désactivé
if((millis() lastDebounceTime) > debounceDelay && relayState == HIGH){
relaisState = BAS ;
Serial.println("OFF");
}
retard(50);
}
void detectMotion() {
Serial.println("Mouvement");
LDRReading = analogRead(LDRPin);
// La valeur de lecture LDR est imprimée sur le moniteur série, utile pour obtenir votre
Seuil LDR
//Serial.println(LDRLecture);
// Active uniquement le relais si la lecture LDR est supérieure à la
Seuil LDR
if(LDRReading > LDRThreshold){
if(relayState == LOW){
digitalWrite(relais, BAS);
}
relaisState = HIGH ;
152
Serial.println("ON");
lastDebounceTime = millis();
Schémas
Voici les schémas de ce projet.
Remarque : si vous avez une connexion de terre (GND) dans le câble de tension secteur
un câble jaune et vert elle doit sortir du module de relais, comme le fil bleu (neutre).
153
Serveur Web Ethernet avec relais
Introduction
Ce projet montre comment construire un serveur Web Ethernet Arduino qui contrôle un relais qui est attaché
à une lampe. Vous pouvez accéder à votre serveur Web avec n'importe quel appareil qui
a un navigateur et il est connecté au même réseau.
Ressources recommandées :
• Guide du module relais avec Arduino
• Arduino – Serveur Web avec Arduino + Ethernet Shield
• Serveur Web ESP8266 avec Arduino IDE
• Tutoriel du serveur Web ESP8266
Remarque : si vous n'êtes pas à l'aise avec la tension secteur, vous pouvez toujours essayer ce projet en
remplaçant le module de relais par une LED, par exemple.
154
Bouclier Ethernet
Le blindage Ethernet Arduino connecte votre Arduino à Internet de manière simple.
Montez simplement ce module sur votre carte Arduino, connectezle à votre réseau avec un câble RJ45 et
suivez quelques étapes simples pour commencer à contrôler vos projets via le Web.
Remarque : vous devez connecter un câble Ethernet de votre routeur à votre blindage Ethernet, comme
indiqué dans la figure suivante.
Utilisation des broches
Lorsque l'Arduino est connecté à un blindage Ethernet, vous ne pouvez pas utiliser les broches numériques
de 10 à 13, car elles sont utilisées pour établir une communication.
entre l'Arduino et le blindage Ethernet.
155
Module relais
Un relais est un interrupteur à commande électrique. Cela signifie qu'il peut être allumé ou
éteint, en laissant passer ou non le courant. Le module de relais est illustré dans la figure ci
dessous.
Ce module de relais particulier est livré avec deux relais (ces cubes bleus).
Concernant la tension secteur, les relais ont 3 connexions possibles :
• COM : broche commune
• NO : normalement ouvert – il n'y a pas de contact entre la broche commune et la broche
normalement ouverte. Ainsi, lorsque vous déclenchez le relais, il se connecte à la broche COM
et l'alimentation est fournie à la charge (une lampe, dans notre cas).
• NC : normalement fermé – il y a contact entre la broche commune et la broche normalement
fermée. Il y a toujours contact entre les broches COM et NC,
156
même lorsque le relais est éteint. Lorsque vous déclenchez le relais, le circuit est ouvert et
aucune alimentation n'est fournie à la charge.
Concernant ce projet, il est préférable d'utiliser un circuit normalement ouvert, car nous voulons allumer
la lampe de temps en temps. Lire ce tutoriel pour en savoir plus sur l'utilisation d'un relais
module avec la carte Arduino.
Les connexions entre le relais et l'Arduino sont vraiment simples :
• GND : passe à la masse •
IN1 : commande le premier relais. Doit être connecté à une broche numérique Arduino • IN2 :
contrôle le deuxième relais. Doit être connecté à une broche numérique Arduino • VCC : passe à
5V
Pièces requises
• Voici une liste complète des composants dont vous avez besoin pour ce projet :
• Blindage Ethernet
• Module relais • Jeu
de cordons de lampe (voir sur eBay) •
Planche à pain
• Fils de cavalier
157
Code
Copiez le code suivant sur votre IDE Arduino et avant de le télécharger sur votre carte Arduino, lisez la
section "Configuration de votre réseau" cidessous.
/*
* Rui Santos
*/
#include <SPI.h>
#include <Ethernet.h>
// Entrez une adresse MAC et une adresse IP pour votre contrôleur cidessous.
// L'adresse IP dépendra de votre réseau local :
octet mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED } ;
Adresse IP ip(192,168,1, 111);
// Initialise la bibliothèque du serveur Ethernet
// avec l'adresse IP et le port que vous souhaitez utiliser // (le port 80 est par
défaut pour HTTP) :
serveur EthernetServer (80);
// État et broche du relais
String relay1State = "Off" ;
const int relais = 7 ;
// Variables clientes
char linebuf[80] ;
int charcount=0 ;
// Module relais préparé
pinMode(relais, SORTIE);
// Ouvrir la communication série à un débit en bauds de 9600 Serial.begin(9600);
// démarre la connexion Ethernet et le serveur :
158
Ethernet.begin(mac, ip);
serveur.begin();
Serial.print("le serveur est à ");
Serial.println(Ethernet.localIP());
}
// Affiche la page du tableau de bord avec le bouton on/off pour le relais
// Il imprime également la température en C et F
void dashboardPage(EthernetClient &client) {
client.println("<!DOCTYPE HTML><html><head>");
client.println("<méta initial nom=\"fenêtre\" content=\"width=devicewidth,
scale=1\"></head><body>" );
client.println("<h3> Serveur Web Arduino <a href=\"/\">Actualiser</a></h3>"); // Génère des boutons pour contrôler le relais
client.println("<h4>Relais 1 Etat : " + relay1State + "</h4>" );
// Si le relais est éteint, il affiche le bouton pour activer la sortie
if(relay1State == "Off"){
client.println(" <a href=\"/relay1on\"> <button>ON</button></a>");
}
// Si le relais est activé, il affiche le bouton pour désactiver la sortie
sinon if(relay1State == "On"){
client.println("<a
href=\"/relay1off\"><bouton>OFF</bouton></a>" );
client.println("</body></html>");
}
boucle vide () {
// écoute les clients entrants
client EthernetClient = serveur.disponible();
si (client) {
Serial.println("nouveau client");
memset(linebuf,0,sizeof(linebuf));
charcount=0 ;
// une requête http se termine par une ligne vide
booléen currentLineIsBlank = true ;
tandis que (client.connecté()) {
si (client.disponible()) {
char c = client.read();
// lit la requête HTTP caractère par caractère
159
linebuf[charcount]=c;
if (charcount<sizeof(linebuf)1) charcount++ ;
// si vous êtes arrivé à la fin de la ligne (reçu un saut de ligne // caractère) et que la ligne est vide, la
requête http est terminée, // vous pouvez donc envoyer une réponse
if (c == '\n' && currentLineIsBlank) {
tableau de bordPage(client);
casser;
si (c == '\n') {
si (strstr(linebuf,"GET /relay1off") > 0){
relay1State = "Off" ;
}
sinon si (strstr(linebuf,"GET /relay1on") > 0){
digitalWrite(relais, BAS);
relay1State = "On" ;
}
// vous commencez une nouvelle ligne
currentLineIsBlank = true ;
memset(linebuf,0,sizeof(linebuf));
charcount=0 ;
sinon si (c != '\r') {
// vous avez un caractère sur la ligne courante
currentLineIsBlank = false ;
// donne au navigateur web le temps de recevoir les données
retard(1);
// ferme la connexion :
client.stop();
Serial.println("client déconnecté");
}
Configuration de votre réseau
Jetez un œil à la configuration de l'extrait de code de votre réseau :
octet mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED } ;
160
Adresse IP ip(192,168,1,XXX);
Important : vous devrez peutêtre remplacer cette variable surlignée en rouge par des valeurs
appropriées adaptées à votre réseau, sinon votre Arduino n'établira pas de connexion avec votre
réseau.
Remplacez la ligne suivante par une adresse IP disponible et adaptée à votre réseau :
Adresse IP ip(X, X, X, X);
Dans mon cas, ma plage IP est 192.168.1.X et avec le logiciel Angry IP Scanner Je sais que l'IP
192.168.1.111 est disponible sur mon réseau, car il n'y a aucun périphérique actif sur mon réseau
avec exactement la même adresse IP :
Adresse IP IP(192, 168, 1, 111);
Schémas
Câblez votre circuit conformément au schéma cidessous :
161
Manifestation
Votre serveur Web Arduino ressemble à la figure cidessous :
Voici une démonstration montrant ce que vous avez à la fin de ce projet :
Emballer
Avec ce projet, vous avez construit un serveur Web Arduino qui active et désactive un relais.
Maintenant, vous pouvez utiliser ce projet pour contrôler n'importe quel appareil électronique que vous voulez.
Ce projet est une version simplifiée de l'un de nos projets dans les projets Arduino étape par étape . Si
vous avez aimé ce projet, assurezvous de consulter le cours qui comprend 25 projets Arduino.
162
Ressources
Brochage Arduino
163
Code couleur de la résistance
164
Emballer
Si vous êtes arrivé jusqu'ici, merci beaucoup !
Sérieusement, merci de l'intérêt que vous portez à mes projets. C'est pourquoi je continue à partager de
nouveaux projets. Vous pouvez donc les lire et vous amuser à les construire.
Enfin, j'espère que vous avez apprécié cet eBook autant que j'ai aimé le créer ! Si vous l'avez fait, partagez
l'un de mes projets avec vos amis ! Ou vous pouvez leur envoyer le lien cidessous, afin qu'ils puissent
également télécharger nos ressources gratuites :
http://RandomNerdTutorials.com/download
Merci encore et amusezvous avec vos projets,
Rui Santos.
PS Assurezvous de visiter mon site Web pour voir les derniers projets!
http://RandomNerdTutorials.com
165
Projets Arduino étape par étape
Cours
Ce cours Arduino est une compilation de 25 projets divisé en 5 modules que vous pouvez construire en
suivant des instructions claires étape par étape avec des schémas et du code téléchargeable.
Projets inclus :
Module #1 : Lumières et LED • Feux
de signalisation • Luminosité des
LED sur l'écran LCD • LED
sensibles à la lumière
• LED télécommandées
• Support de moniteur avec lumière ambiante •
Lumière de sécurité nocturne
Module #2 : Projets de capteurs
• Alarme détecteur de fumée
• Capteur de stationnement
166
• Station météo Arduino (AWS) avec température, humidité, pression, date
et le temps
• Station météo Enregistrement des données vers Excel
• Demander les données du capteur par SMS
Module #3 : Projets sonores
• Pseudothérémine
• Lumières sensibles au son •
Clavier de piano
Module #4 : Création d'applications •
Application Android Bluetooth •
Application relais à commande vocale
• Serveur Web Ethernet Arduino (relais + température)
• LED contrôlée par secousse
• Détecteur d'intrusion avec notifications
Module #5 : Projets divers • Chronomètre
Arduino • Lanceur de dés électronique
• Jeu de mémoire •
Robot suiveur de lumière •
Robot télécommandé Bluetooth
• Système de pointage avec RFID
167
Télécharger d'autres produits RNT
Tutoriels Nerd aléatoires est une ressource en ligne avec des projets électroniques, des tutoriels et des
critiques. Créer et publier de nouveaux projets prend beaucoup de temps. À l'heure actuelle, Random
Nerd Tutorials propose plus de 200 articles de blog gratuits avec des didacticiels complets utilisant du
matériel open source que tout le monde peut lire, remixer et appliquer à ses propres projets. Pour
garder les tutoriels gratuits à venir, il y a aussi du "contenu premium". Pour prendre en charge les
didacticiels Random Nerd, vous pouvez télécharger du contenu premium ici.
Apprendre ESP32 avec Arduino IDE
Il s'agit d'un cours pratique où vous apprendrez à tirer le meilleur parti de l'ESP32 à l'aide de l'IDE
Arduino. Ceci est notre guide complet pour programmer l'ESP32 avec Arduino IDE, y compris des
projets, des conseils et des astuces ! Lire la description du produit.
Applications Android pour Arduino avec MIT App Inventor 2
Cet eBook est notre guide étape par étape pour vous permettre de créer des applications Android pour
Arduino, même sans expérience préalable ! Vous allez créer 8 applications Android pour interagir avec
l'Arduino. Lire la description du produit.
168
20 projets Raspberry Pi faciles
Le livre 20 Easy Raspberry Pi Projects est une collection de projets électroniques
adaptés aux débutants utilisant le Raspberry Pi. Ce livre était une collaboration
avec NoStarch Press Publisher et il est
disponible en format broché. Lire la description du produit.
Construire un système domotique pour 100 $
Apprenez Raspberry Pi, ESP8266, Arduino et NodeRED. Il s'agit d'un cours premium étape par étape
pour vous permettre de créer un système domotique réel à l'aide de matériel et de logiciels open source.
Lire la description du produit.
Domotique avec ESP8266 (3e édition)
Ce cours est un guide étape par étape conçu pour vous aider à démarrer avec l'ESP8266. Si vous êtes
nouveau dans le monde de l'ESP8266, cet eBook est parfait pour vous. Si vous avez déjà utilisé
l'ESP8266 auparavant, je suis sûr que vous apprendrez également quelque chose de nouveau.
Lire la description du produit.
169

18+ Arduino Projects - French

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

18+ Arduino Projects - French

Transféré par

Droits d'auteur :

Formats disponibles

Machine Translated by Google

Machine Translated by Google

Enregistreur de données de température Arduino avec module de carte SD .................................................. 111

Veilleuse de nuit avec Arduino .................................................. ................................ 149

Cours de projets étape par étape Arduino .................................................. ........................ 166

2. Allez dans Fichier Exemples 01.Bases Clignotement

Après avoir préparé le circuit, allez dans Fichier Exemples MFRC522 DumpInfo et téléchargez

Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");

content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ") );

Dans mon cas, je dois passer par : Paramètres Paramètres avancés Sécurité Verrouillage SIM et désactiver

client.println("<méta initial nom=\"fenêtre\" content=\"width=devicewidth,

client.println("<h4>Relais 1 Etat : " + relay1State + "</h4>" );

Vous aimerez peut-être aussi

18+ Arduino Projects - French

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

18+ Arduino Projects - French

Transféré par

Droits d'auteur :

Formats disponibles

Machine Translated by Google

Machine Translated by Google

Enregistreur de données de température Arduino avec module de carte SD .................................................. 111

Veilleuse de nuit avec Arduino .................................................. ................................ 149

Cours de projets étape par étape Arduino .................................................. ........................ 166

2. Allez dans Fichier Exemples 01.Bases Clignotement

Après avoir préparé le circuit, allez dans Fichier Exemples MFRC522 DumpInfo et téléchargez

Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");

content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ") );

Dans mon cas, je dois passer par : Paramètres Paramètres avancés Sécurité Verrouillage SIM et désactiver

client.println("<méta initial nom=\"fenêtre\" content=\"width=device­width,

client.println("<h4>Relais 1 ­ Etat : " + relay1State + "</h4>" );

Vous aimerez peut-être aussi

client.println("<méta initial nom=\"fenêtre\" content=\"width=devicewidth,

client.println("<h4>Relais 1 Etat : " + relay1State + "</h4>" );