Étiquette : C

Tutoriels

Apprendre les bases de l’Arduino

Arduino est une plateforme matérielle et logicielle open source populaire utilisée pour le développement de projets électroniques, notamment pour la création de prototypes, de dispositifs interactifs et de systèmes embarqués.

Arduino comprend un microcontrôleur, un environnement de développement intégré (IDE) et une bibliothèque de logiciels qui facilitent la programmation et le contrôle de composants électroniques. Arduino est une plateforme de prototypage électronique qui simplifie le développement de projets électroniques interactifs, en offrant une approche conviviale pour la programmation et le contrôle de composants électroniques. Il est couramment utilisé dans l’éducation, le bricolage, la robotique, l’automatisation domestique et de nombreux autres domaines, ou pour s’amuser :).

Comment ce présente une carte Arduino ?

Il existe plusieurs types de cartes Arduino (Arduino UNO, Arduino Nano, Arduino Due, Arduino Mega, Arduino Leonardo …) qui appartinrent à de nombreuse gammes, chacune de ces gammes est spécifiques, plus ou moins puissante, et a différentes utilisations. Pour cet présentation j’utiliserais comme base une carte Arduino UNO pour présenté les pins présent et leurs utilité car c’est l’une des plus commune et les plus utilisé pour sa taille et sa polyvalence.

Premièrement voici à quoi ressemble un carte Arduino UNO :

Cela peut paraitre assez compliquer et assez brouillon à première vue mais en réalité plusieurs de ces pin on la même utilité et certains sont rarement utilisé.

En rouge ici nous avons le bouton reset, le bouton de réinitialisation (reset) sur une carte Arduino est utilisé pour redémarrer le programme en cours d’exécution sur le microcontrôleur. Lorsque l’on appuie sur le bouton de réinitialisation, cela a pour effet d’arrêter momentanément l’exécution du programme en cours sur la carte Arduino et de recommencer depuis le début.

En bleu la prise USB , elle sert à plusieurs fins importantes, notamment la programmation, la communication série, et parfois même l’alimentation. C’est grâce à cet prise USB que l’ont transfèrera les programmes.

En vert La prise ronde d’alimentation sur une carte Arduino est un connecteur de type barrel jack. Ce connecteur est utilisé pour fournir une alimentation externe à la carte Arduino.

En rouge les broches numériques (digital pins) sur une carte Arduino sont des broches d’entrée/sortie qui peuvent être configurées pour fonctionner en mode numérique. Elles peuvent être utilisées pour lire des signaux numériques (0 ou 1) ou pour envoyer des signaux numériques (c’est comme cela que nous allons les utilisé pour le reste de ce tutoriel). Voici les différentes manières dont dont laquelle sont utilisé les broches digitales :

  • Entrées numériques : Les broches numériques peuvent être configurées en tant qu’entrées pour lire des signaux numériques. Elles sont souvent utilisées pour détecter l’état logique d’un dispositif externe, tel qu’un capteur de lumière, un interrupteur ou un capteur de mouvement.
  • Sorties numériques : Les broches numériques peuvent être configurées en tant que sorties pour envoyer des signaux numériques. Elles peuvent être utilisées pour contrôler des dispositifs tels que des LED, des relais, des moteurs ou d’autres composants qui réagissent à des signaux logiques.
  • Communication série : Les broches numériques peuvent être utilisées pour la communication série. Par exemple, les broches RX (réception) et TX (transmission) permettent la communication série asynchrone avec d’autres dispositifs, tels qu’un ordinateur via le port USB.
  • Communication I2C et SPI : Certains broches numériques sont spécifiquement dédiées à la communication sur les bus I2C et SPI. Ces protocoles sont souvent utilisés pour interconnecter des composants tels que des capteurs, des écrans, des mémoires, etc.
  • Pulse Width Modulation (PWM) : Certains pins numériques peuvent être configurés en mode PWM, permettant de générer des signaux analogiques simulés. Cette fonction est couramment utilisée pour contrôler l’intensité lumineuse des LED ou la vitesse des moteurs.

En bleu le pin GND (Ground) sur une carte Arduino est la broche de mise à la terre, il est essentiel pour établir une référence commune de tension, fournir une mise à la terre pour les composants du circuit, et assurer des connexions électriques appropriées. Il est souvent utilisé en conjonction avec les broches d’alimentation (VCC) pour créer un circuit complet.

En jaune le pin AREF (Analog REFerence) est utilisé pour définir une tension de référence pour les mesures analogiques effectuées par les broches analogiques de la carte. Il permet de spécifier la plage de tension à laquelle les valeurs analogiques seront comparées lors de la conversion analogique-numérique (CAN). Dans ce tutoriel nous n’utiliserons pas ce pin.

En violet le pin SDA sur une carte Arduino est une broche utilisée dans les communications I2C (Inter-Integrated Circuit). I2C est un protocole de communication série à deux fils utilisé pour connecter différents composants électroniques sur un même bus. La signification de l’acronyme SDA est « Serial Data Line » (Ligne de Données Série). La broche SDA est utilisée pour transférer les données entre les différents composants connectés sur le bus I2C. Dans ce tutoriel nous n’utiliserons pas ce pin.

En orange le pin SCL (Serial Clock Line) sur une carte Arduino est utilisé dans le cadre du protocole de communication I2C (Inter-Integrated Circuit). Le bus I2C est un protocole de communication série à deux fils qui permet la connexion de plusieurs composants électroniques sur un même circuit. Le pin SCL est utilisé pour transmettre l’horloge synchronisant les échanges de données entre les différents composants connectés au bus I2C. Dans ce tutoriel nous n’utiliserons pas ce pin.

En vert le port ICSP (In-Circuit Serial Programming) est un ensemble de broches destinées à la programmation du microcontrôleur à l’aide d’un programmateur ISP (In-System Programmer). Ce port permet de reprogrammer le microcontrôleur sans avoir besoin de retirer le microcontrôleur de la carte. il y a 12 des ces ports sur la carte Arduino répartis en deux groupes de 6 à différentes endroits de la carte. Dans ce tutoriel nous n’utiliserons pas ce pin.

En rouge les broches « Analog In » (entrées analogiques) sur une carte Arduino permettent de mesurer des tensions analogiques. Contrairement aux broches numériques (digitales) qui peuvent prendre des valeurs logiques (0 ou 1), les broches analogiques peuvent mesurer une plage continue de tensions, généralement entre 0 et la tension de référence (par exemple, entre 0 et 5 volts sur une Arduino standard). Voici quelques utilisations et fonctionnalités des broches Analog In :

  • Lecture de capteurs analogiques : Les broches Analog In sont couramment utilisées pour lire les signaux provenant de capteurs analogiques tels que des capteurs de lumière, des capteurs de température, des potentiomètres, des capteurs de pression, etc. Ces capteurs fournissent des informations analogiques qui peuvent être lues avec précision à l’aide des broches Analog In.
  • Conversion analogique-numérique (CAN) : Les broches Analog In sont équipées de convertisseurs analogique-numérique (CAN) qui convertissent la tension analogique mesurée en une valeur numérique que le microcontrôleur de la carte Arduino peut comprendre et traiter.
  • Lecture de signaux analogiques externes : Les broches Analog In peuvent également être utilisées pour mesurer des signaux analogiques externes provenant d’autres dispositifs électroniques.
  • Tension de référence : La carte Arduino utilise généralement la tension d’alimentation (VCC) comme référence par défaut pour les mesures analogiques. Cependant, il est possible de configurer une tension de référence différente en utilisant le pin AREF (Analog REFerence).
  • Pulse Width Modulation (PWM) : Bien que les broches Analog In soient principalement conçues pour la lecture de signaux analogiques, certaines d’entre elles peuvent également être utilisées en mode de sortie PWM (Pulse Width Modulation) pour contrôler la luminosité des LED ou la vitesse des moteurs.

En vert le pin « Vin » est l’entrée d’alimentation. Il est conçu pour recevoir une tension d’alimentation externe qui peut être utilisée pour alimenter la carte. « Vin » signifie « Voltage In », ce qui indique que c’est l’endroit où l’on fournie une tension d’alimentation à la carte. Dans ce tutoriel nous n’utiliserons pas ce pin.

En bleu ce sont encore des pin GND (grounds) qui ont la même utilité que ceux déjà présenté.

En rouge foncé le pin 5V (5 volts) sur une carte Arduino est une sortie qui fournit une tension de 5 volts. Il peut être utilisé pour alimenter des composants externes tels que des capteurs, des modules, des écrans ou d’autres dispositifs qui nécessitent une alimentation de 5 volts. Cela permet de simplifier le câblage en utilisant la source d’alimentation de la carte Arduino.

En jaune le pin 3.3V (3,3 volts) sur une carte Arduino est une sortie qui fournit une tension de 3,3 volts. Certains capteurs, modules et dispositifs électroniques fonctionnent avec une tension d’alimentation de 3,3 volts. Le pin 3.3V permet d’alimenter ces composants spécifiques sans nécessiter de conversion de tension externe.

En orange le pin RESET sur une carte Arduino est utilisé pour réinitialiser le microcontrôleur de la carte. Lorsqu’une impulsion basse (un passage de l’état haut à bas) est appliquée au pin RESET, le microcontrôleur de la carte Arduino est réinitialisé. Cette réinitialisation force le microcontrôleur à recommencer l’exécution du programme à partir du début. Ce pin est équivalent au bouton reset. Dans ce tutoriel nous n’utiliserons pas ce pin.

En blanc le pin IOREF (Input/Output REFerence) sur une carte Arduino sert à indiquer le niveau de tension de référence utilisé par les broches d’entrée/sortie de la carte. C’est généralement une broche de sortie qui fournit une indication de la tension de référence actuellement utilisée par les broches I/O (E/S) de la carte. Dans ce tutoriel nous n’utiliserons pas ce pin.

Enfin, il y a un dernier pin que je n’ai pas présenté, sur certaines cartes Arduino, à côté du pin IOREF, il peut y avoir un pin marqué « Reserved » (réservé) ou « Not Connected » (non connecté). Ce pin n’a pas de fonctionnalité ou d’utilisation standard spécifique définie par le schéma officiel de la carte Arduino. Son but est souvent de prévoir des options d’extension pour des fonctionnalités futures ou de permettre aux concepteurs de cartes d’ajouter des fonctionnalités personnalisées.

Installation et fonctionnement de l’IDE Arduino

Premièrement, il faudra se rendre sur le site d’Arduino, sur la page de téléchargement. Ensuite, une fois arrivé sur cette page, il faudra cliquer sur le système d’exploitation sur lequel vous êtes. Dans mon cas, je cliquerais sur Windows.

Une fois cela fait, vous arriverez sur cette page qui vous propose de faire une donation. Si vous en avez l’envie, vous pouvez le faire. Pour passer et continuer le téléchargement, il suffira de cliquer sur « JUST DOWNLOAD ».

Ensuite, vous arriverez sur cette page qui vous propose de vous inscrire à leur newsletter. Si vous le voulez, faites-le, mais dans notre cas, nous allons nous contenter de continuer le téléchargement en appuyant sur « JUST DOWNLOAD ».

Normalement, le téléchargement va se lancer, et une fois fini, je vous invite à « Extraire tout » du dossier dans un dossier approprié de votre ordinateur.

Une fois cela fait, nous allons nous retrouver avec tous ces fichiers. Il suffira simplement d’exécuter le fichier nommé « Arduino IDE.exe ». Pour y accéder plus facilement, je vous invite à créer un raccourci sur votre Bureau.

Et voilà, vous venez de terminer l’installation de l’IDE Arduino. Maintenant, il va falloir comprendre comment il fonctionne. Voici comment il se présente.

Premièrement, si l’on regarde en haut à gauche de l’IDE, on trouve trois boutons. Le premier (✓) sert à compiler le code que l’on insère afin de vérifier s’il fonctionne avant de l’envoyer dans la carte. Le second (➔) est celui qui sert à transférer le code dans la carte, et le dernier sert au débogage. En ce qui concerne la fenêtre où il y a écrit « Select Board », c’est ici que nous allons sélectionner notre carte pour y transférer le code.

Une fois cliqué sur « Select Board », vous pouvez choisir votre carte. Bien sûr, il faut qu’elle soit branchée à votre ordinateur et bien détectée. Personnellement, dans l’exemple ci-dessous, cela me propose les deux cartes qui sont branchées sur mon ordinateur avec les bons ports COM. Il faut faire attention à ce que ce soit bien les bons ports COM.

Sur le reste de l’écran, vous avez la zone de programmation où vous allez entrer votre code.

En bas de l’écran, vous avez la console qui vous indiquera les erreurs que vous faites lors de la compilation de votre code.

Et en haut à droite de votre écran, vous avez un petit symbole qui ressemble à une loupe, c’est le Serial Monitor. Il vous servira à voir certaines informations (il sera utile lorsque l’on utilisera le capteur à ultrason).

Ce ne sont pas toutes les fonctionnalités de l’IDE Arduino ; il y en a bien plus encore. Cependant, pour le moment, c’est de ces fonctionnalités que nous allons nous contenter.

Les composants de base et leurs fonctionnements

Nous allons donc voir quelques composants de base qui servent particulièrement lorsque l’on utilise l’Arduino. Je vous expliquerai leur fonctionnement, à quoi ils servent, et où les procurer.

La Platine d’expérimentation ou Breadboard

Voici une platine d’expérimentation, et comme son nom l’indique, elle sert à faire nos expériences. C’est donc sur cet objet que nous allons réaliser nos branchements. Cela peut paraître compliqué à première vue, mais son fonctionnement est très simple. Voici à quoi ressemble l’interrupteur d’une platine.

Les lignes bleues représentent la masse ou GND, comme nous l’avons vu précédemment. Quant aux lignes rouges, elles représentent l’alimentation. En ce qui concerne les lignes vertes, c’est ici que nous allons brancher nos composants pour les relier entre eux.

Les câbles

Ils permettent de réaliser des branchements entre différents composants. On les insère dans les trous prévus sur la carte et ceux dans la platine d’expérimentation pour faire circuler le courant électrique.

Les résistances

Les résistances sont des composants électroniques qui limitent le courant électrique dans un circuit en opposition à sa circulation. La principale fonction d’une résistance est de limiter le courant électrique qui circule dans un circuit. Elle agit comme un obstacle au passage du courant, ce qui permet de contrôler la quantité de courant circulant dans une partie spécifique du circuit. Les résistances sont souvent utilisées pour protéger d’autres composants électroniques, tels que les LED, en limitant le courant qui les traverse. Cela empêche ces composants de recevoir un courant excessif et de s’endommager. Il existe différents types de résistances, plus ou moins puissantes. On peut reconnaître leur valeur grâce au code couleur (les petites traits) qui se trouve sur elles, et cela permet de connaître leur valeur en ohms. Une résistance est généralement représentée par le symbole suivant :

Les LED

Les LED (Light Emitting Diode) sont des diodes électroluminescentes qui émettent de la lumière lorsqu’un courant électrique les traverse. Elles sont largement utilisées dans l’électronique pour diverses applications en raison de leur efficacité énergétique, de leur longue durée de vie et de leur faible consommation d’énergie. Dans ce tutoriel, nous les utiliserons beaucoup, car c’est un élément très visuel qui permet de facilement constater des changements. Une des précautions qu’il faut prendre avec les LED est qu’elles ont un sens. Les grandes pattes de la LED représentent le + et la petite patte le -. Si elles sont mal positionnées, la LED peut griller. Une LED est représentée par le symbole suivant :

Et voici un petit circuite qui nous permet d’expérimenter une LED :

void setup() { // pour ce qui font du python "void setup" est assimilable à "def __init__"
  pinMode(8, OUTPUT); //on déclare le pin que l'on utilise
}

void loop() { // la fonction "void loop" est une boucle
  digitalWrite(8, HIGH); //on allume la LED
  delay(1000); // attendre 1000 millisecond(s)
  digitalWrite(8, LOW); // on etteint la LED
  delay(1000); // attendre 1000 millisecond(s)
}

Pour résumer le fonctionnement du circuit précédent, on envoie de l’électricité dans le fil rouge qui passe par la résistance (220Ω) pour réduire l’intensité du courant, puis qui arrive à la LED et l’allume. Enfin, on ferme le circuit en arrivant au GND. Et tout cela avec des intervalles d’une seconde.

Les boutons poussoir

Un bouton-poussoir, également appelé interrupteur à bouton-poussoir, est un composant électronique simple qui permet d’établir ou de couper un circuit électrique lorsqu’on appuie sur son bouton.

Et voici un petit circuite qui nous permet d’expérimenter une LED et un bouton :

void setup() {
  pinMode(8, OUTPUT); //on déclare le pin de la LED que l'on utilise
  pinMode(7, INPUT); //on déclare le pin du bouton que l'on utilise et la déclare comme entré
}

void loop() {
  if (digitalRead(7) == HIGH){ //on applique la condition au "if" qui est si la pin 7 resois un signal 
  	digitalWrite(8, HIGH); // dans ce cas on allume la LED
  }
  else{
    digitalWrite(8, LOW); // sinon est reste éteint
  }
}

Ce qui se passe dans le circuit précédent est que l’on alimente le bouton. Quand on appuie sur le bouton, cela laisse passer l’électricité qui alimente alors la pin 7. Lorsque la pin 7 reçoit un signal, cela valide la condition d’allumage de la LED. La pin 8 envoie alors de l’électricité, et donc la LED s’allume. La LED est toujours protégée par une résistance de 220Ω, et le bouton lui est protégé par une résistance de 10kΩ.

Les buzzer

Un buzzer est un composant électronique qui émet un son lorsqu’il est alimenté en courant. Il est souvent utilisé pour fournir des indications sonores dans divers projets électroniques. Un buzzer est représentée par le symbole suivant :

Et voici un petit circuite qui nous permet d’expérimenter un buzzer :

void setup() {
  pinMode(13, OUTPUT); //on déclare le pin du buzzer que l'on utilise
}

void loop() {
  tone (13, 650); //On utilise "tone" pour activer le buzzer avec comme deuxième paramètre la fréquence émise par le buzzer.
}

Dans ce circuit, on allume le buzzer via la pin 13 avec une tonalité de 650. Il est possible de modifier ce chiffre pour obtenir différentes tonalités.

Les potentiomètre

Un potentiomètre est un composant électronique ajustable qui permet de régler la résistance électrique dans un circuit. Il est également souvent appelé « potar ». Un potentiomètre peut être décrit comme une résistance variable. Il permet de régler la résistance électrique dans un circuit. Le principe de fonctionnement d’un potentiomètre implique de déplacer un curseur le long d’une piste résistive, ce qui modifie la portion de résistance entre le curseur et les bornes fixes. il existe de multiples modèle qui sous tous différent les un des autres. Un potentiomètre est représentée par les symboles suivant :

Et voici un petit circuite qui nous permet d’expérimenter une LED et un potentiomètre :

void setup() {
  Serial.begin(9600); // instanciation 
  pinMode(A0, INPUT); // on définit le pin analog 0 comme pin d'entré
  pinMode(13, OUTPUT); // le pin 13 comme sorti
}

void loop() {
  analogWrite(13, analogRead(A0)/4);// Ici, on dit que la LED va s'éclairer à l'intensité 
									// de "analogRead(A0)", soit ce qui est ressorti par le 
									// potentiomètre. Cependant, cette valeur est dans l'intervalle 
									//[0, 1023], et une LED ne peut prendre que des valeurs entre 
									//[0, 255]. On divise donc "analogRead(A0)" par 4 pour obtenir 
 									//une valeur lisible pour la LED.
}

On définit notre potentiomètre sur la pin A0 et notre LED sur la pin 13. Enfin, dans la fonction loop, on allume notre LED avec comme variable l’intensité résultante du potentiomètre. ( a noté que la résistance utilisé est une résistance de 220Ω)

Les photorésistances

Une photorésistance, également appelée cellule photoconductrice ou résistance photo-sensible, est un composant électronique dont la résistance électrique varie en fonction de l’intensité lumineuse à laquelle elle est exposée. C’est un type de capteur de lumière largement utilisé dans divers projets électroniques. Une photorésistance est représentée par le symbole suivant :

Et voici un petit circuite qui nous permet d’expérimenter une LED et une photorésistance :

void setup() {
  pinMode(A0, INPUT); // on définit le pin analog 0 comme pin d'entré
  pinMode(10, OUTPUT); // le pin 13 comme sorti
}

void loop() {
  if (analogRead(A0) > 400){ // Si la photorésistance ressort une valeur supérieure à 400.
    digitalWrite(10, HIGH); // Alors on allume la LED
  }
  else{ // Sinon
    digitalWrite(10, LOW); // Elle reste éteinte
  }
}

Ici, on branche notre photorésistance sur la pin A0 et notre LED sur la pin 10. Dans la fonction loop, on définit que la condition d’activation de la LED est si la valeur retournée par la photorésistance est supérieure à 400, soit un environnement un peu lumineux. À noter que l’on ne met pas une valeur en dessous de 400, car sinon la LED resterait allumée la plupart du temps en raison de la sensibilité de la photorésistance. (ici la résistance utilisé pour la LED est une résistance de 220Ω, et celle pour la photorésistance est de 10kΩ)

Les capteurs à ultrasons

Un capteur à ultrasons est un dispositif électronique qui utilise des ondes sonores à une fréquence supérieure à la limite supérieure de l’audition humaine (généralement supérieure à 20 kilohertz) pour mesurer la distance entre le capteur et un objet. Ces capteurs fonctionnent sur le principe de l’écholocation, similaire à la façon dont certains animaux utilisent des sons pour évaluer la distance et la position des objets dans leur environnement. dans l’exemple suivant nous utiliserons le capteur à ultra son de référence HC-SR04. Et voici un petit circuite qui nous permet d’expérimenter un capteur à ultrasons :

long temps; // Déclaration de variables pour stocker le temps de retour du signal ultrasonique et la distance calculée.
float distance;

void setup() {
  pinMode(2, OUTPUT); // Configuration des broches : 2 en mode sortie pour envoyer le signal ultrasonique,
  pinMode(3, INPUT); // Configuration des broches : 3 en mode entrée pour recevoir le signal de retour.
  digitalWrite(2, LOW); // Initialisation de la broche 2 à un état bas, prête à émettre le signal ultrasonique.
  Serial.begin(9600); // Initialisation de la communication série à une vitesse de 9600 bauds pour l'affichage des résultats.
}

void loop() {
  digitalWrite(2, HIGH); // Activation de la broche 2 pour émettre une impulsion ultrasonique.
  delayMicroseconds(10); // Attente de 10 microsecondes pour laisser le temps au signal ultrasonique de se propager.
  digitalWrite(2, LOW); // Désactivation de la broche 2 après l'impulsion.
  temps = pulseIn(3, HIGH); // Mesure du temps nécessaire pour que le signal ultrasonique revienne à la broche 3.
  if (temps > 25000) { // Vérification si le temps mesuré est supérieur à 25 000 microsecondes (25 millisecondes).
    Serial.println("Echec de la mesure"); // Affichage d'un message d'échec de mesure sur le moniteur série.
  } else {
    temps = temps / 2; // Utilisation de la moitié du temps mesuré car le signal ultrasonique fait l'aller-retour.
    distance = (temps * 340) / 10000.0; // Calcul de la distance en centimètres en utilisant la vitesse du son (340 m/s).
    Serial.print("Distance: "); // Affichage de la distance mesurée sur le moniteur série.
    Serial.print(distance);
    Serial.println(" cm");
  }
  delay(2000); // Attente de 2 secondes avant de répéter la mesure.
}

Les capteurs sonore

Les capteurs sonores, aussi appelés microphones ou capteurs audio, sont des dispositifs électroniques qui convertissent les variations de pression acoustique (ondes sonores) en un signal électrique. Ces capteurs sont largement utilisés pour capter des signaux sonores dans diverses applications. Et voici un petit circuite qui nous permet d’expérimenter un capteur sonores avec une LED. (malheureusement Tinkercad n’a pas cet élément je suis donc obliger de prendre des photos et donc la qualité sera moindre) :

Pour la connexion du capteur sonore à l’Arduino, j’utilise trois câbles : un gris, un noir, et un blanc. Le câble gris est relié de la broche digitale du détecteur sonore à la broche A2 de la carte. Le câble noir est relié de la broche + du détecteur sonore au 5V de la carte, et le câble blanc est relié de la broche G (ou GND) au pin GND de la carte.

En ce qui concerne le branchement de la LED, c’est un simple branchement où l’on utilise une résistance de 220Ω.

void setup() {
  Serial.begin(9600); // Initialisation de la communication série à une vitesse de 9600 bauds pour l'affichage des résultats.
  pinMode(13, OUTPUT); // Configuration de la broche 13 en mode sortie pour contrôler la LED.
  pinMode(A2, INPUT); // Configuration de la broche A2 en mode entrée pour lire une valeur analogique.
}

void loop() {
  if (analogRead(A2) >= 200) { // Vérification si la valeur lue depuis la broche A2 est supérieure ou égale à 200.
    digitalWrite(13, HIGH); // Allumage de la LED (broche 13) si la condition est vraie.
    delay(1000); // Attente de 1000 millisecondes (1 seconde).
  } else {
    digitalWrite(13, LOW); // Extinction de la LED (broche 13) si la condition n'est pas vraie.
  }
}

Il est important de noter qu’il est souvent nécessaire de calibrer son capteur sonore. Pour cela, il suffit de se munir d’un petit tournevis plat et de faire tourner la petite vis qui se trouve en haut du composant bleu du capteur sonore afin d’augmenter ou de réduire la sensibilité. Pour ma part, elle était grandement trop élevée, c’est donc à vous de régler cette partie. Une fois réglé, à chaque détection sonore, la LED s’allumera pendant 1 seconde.

Comment et ou obtenir du matérielle ?

Magasins en Ligne spécialisés :

Les magasins en ligne offrent une multitude d’options pour acheter des composants Arduino. Des sites tels que Adafruit, SparkFun, et Arduino Store proposent une large sélection de capteurs, de modules, de cartes et d’accessoires. Assurez-vous de vérifier les avis des utilisateurs pour garantir la qualité des produits avant d’effectuer votre achat.

Plateformes de Commerce Électronique :

Des sites comme Amazon, eBay, Temu et AliExpress proposent également une variété de composants Arduino. Cependant, soyez attentif à la provenance des produits et lisez les commentaires des utilisateurs pour éviter les contrefaçons et assurer la fiabilité des composants. La casse lors du transport des composants est plus fréquente, et les frais de transport peuvent être élevés. Cependant, les prix sont en général moins chers.

Recyclage Électronique :

Pour les bricoleurs soucieux de l’environnement, la récupération de composants électroniques à partir d’appareils recyclés peut être une option intéressante. Les vieux ordinateurs, téléphones portables et autres dispositifs électroniques obsolètes peuvent fournir une source abordable de composants. Par exemple, personnellement, en démontant un réveil, j’ai pu récupérer un afficheur de 7 segments à 4 digits, 4 boutons, un haut-parleur et d’autres petits composants.

Magasins Locaux de Bricolage :

Certains magasins de bricolage peuvent proposer une petite sélection de composants électroniques de base, comme des résistances, des transistors ou des diodes. Bien que le choix soit limité, cela peut être une solution pratique pour des besoins simples. Aussi bien qu’ils se fassent rares, il existe encore des magasins physiques de composants électroniques.

N’oubliez pas de vérifier la compatibilité des composants avec votre carte Arduino et de suivre les bonnes pratiques en matière d’électronique pour assurer la réussite de vos projets.

Projet de fin de tutoriel

Pour conclure ce tutoriel, nous allons faire un radars de recule, il comportera 5 LED de couleurs différentes, un buzzer, et un capteurs à ultrasons.

long temps;
float distance;

void setup() {
  pinMode(2, OUTPUT); // Configuration des broches : 2 en mode sortie pour envoyer le signal ultrasonique,
  pinMode(3, INPUT); // Configuration des broches : 3 en mode entrée pour recevoir le signal de retour.
  pinMode(4, OUTPUT); // on définit les pin 4, 5, 6, 7, 8 pour les LED
  pinMode(5, OUTPUT); 
  pinMode(6, OUTPUT); 
  pinMode(7, OUTPUT); 
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT); // on définit le pin 9 pour le buzzer
  digitalWrite(2, LOW); // Initialisation de la broche 2 à un état bas, prête à émettre le signal ultrasonique.
  Serial.begin(9600); // Initialisation de la communication série à une vitesse de 9600 bauds pour l'affichage des résultats.
}

void loop() {
  digitalWrite(2, HIGH); // Activation de la broche 2 pour émettre une impulsion ultrasonique.
  delayMicroseconds(10); // Attente de 10 microsecondes pour laisser le temps au signal ultrasonique de se propager.
  digitalWrite(2, LOW); // Désactivation de la broche 2 après l'impulsion.
  temps = pulseIn(3, HIGH); // Mesure du temps nécessaire pour que le signal ultrasonique revienne à la broche 3.
  if (temps > 25000) { // Vérification si le temps mesuré est supérieur à 25 000 microsecondes (25 millisecondes).
    Serial.println("Echec de la mesure"); // Affichage d'un message d'échec de mesure sur le moniteur série.
  } else {
    temps = temps / 2; // Utilisation de la moitié du temps mesuré car le signal ultrasonique fait l'aller-retour.
    distance = (temps * 340) / 10000.0; // Calcul de la distance en centimètres en utilisant la vitesse du son (340 m/s).
    Serial.print("Distance: "); // Affichage de la distance mesurée sur le moniteur série.
    Serial.print(distance);
    Serial.println(" cm");
    if (distance <= 300 ){
      digitalWrite(4, HIGH); // on allume la LED 4 
      digitalWrite(5, LOW); // on etteint les autres LED
      digitalWrite(6, LOW);
      digitalWrite(7, LOW);
      digitalWrite(8, LOW);
      tone(9, 350); // Activation du buzzer avec une fréquence de 35=50 Hz
    }
    if (distance <= 200 ){
      digitalWrite(4, LOW);// on etteint les autres LED
      digitalWrite(5, HIGH); // on allume la LED 5 
      digitalWrite(6, LOW);
      digitalWrite(7, LOW);
      digitalWrite(8, LOW);
      tone(9, 550); // Activation du buzzer avec une fréquence de 550 Hz
    }
    if (distance <= 50 ){
      digitalWrite(4, LOW);// on etteint les autres LED
      digitalWrite(5, LOW);
      digitalWrite(6, HIGH); // on allume la LED 6 
      digitalWrite(7, LOW);
      digitalWrite(8, LOW);
      tone(9, 750); // Activation du buzzer avec une fréquence de 750 Hz
    }
    if (distance <= 15 ){
      digitalWrite(4, LOW);// on etteint les autres LED
      digitalWrite(5, LOW);
      digitalWrite(6, LOW);
      digitalWrite(7, HIGH);// on allume la LED 7 
      digitalWrite(8, LOW);
      tone(9, 950); // Activation du buzzer avec une fréquence de 950 Hz
    }
    if (distance <= 6 ){
      digitalWrite(4, LOW);// on etteint les autres LED
      digitalWrite(5, LOW);
      digitalWrite(6, LOW);
      digitalWrite(7, LOW);
      digitalWrite(8, HIGH); // on allume la LED 8 
      tone(9, 1050); // Activation du buzzer avec une fréquence de 1050 Hz
    }
  }
  delay(1000); // Attente de 1 seconde avant de répéter la mesure.
}

On se retrouve finalement avec un « radar ». Plus un objet est proche du radar, plus la tonalité du buzzer change, et plus on s’approche, plus les LED vont de la LED bleue vers la LED blanche.

Sources

Conclusion

En conclusion, l’exploration de l’Arduino ne représente qu’une simple plongée dans l’électronique. Ce que je vous ai montré n’est qu’une infime partie de ce que représente Arduino et l’électronique en général. J’ai abordé le fonctionnement de base d’une carte et comment on peut l’utiliser, mais c’est à vous d’imaginer et d’inventer des utilisations pour ces composants. Si vous souhaitez continuer avec Arduino, il peut être difficile de savoir par où commencer. C’est pourquoi il peut être bénéfique d’apprendre à travers des tutoriels, comme celui-ci. Je vous redirige donc vers un tutoriel que j’ai suivi réalisé par le Geek et son Marteau, qui est très bien réalisé et qui vous apprendra à faire un Stream Deck avec Arduino.

Amusez-vous bien !