le Makerspace au Sénégal 1

Programmation Arduino
et conception de projet

Guide d'apprentissage pratique

pour les débutants

Yongsoo HAN

@2024 KPC Consourcium or its affiliates, All rights reserved.

This educational material is the result of the KOICA project “Establishing a start-up incubating
center and Makerspace in Senegal(2021-2026)”.
 le Makerspace au Sénégal 2

Contenu

Exercise 1. Introduction du cours ································· Erreur ! Signet non défini.

Exercise 2. Comprendre Arduino ·································································· 1
Exercise 3. Configuration de l'environnement de programmation Arduino ·················· 9
Exercise 4. Clignotant d'une LED intégrée····················································· 14
Exercise 5. Faire clignoter une LED externe ··················································· 20
Exercise 6. Utilisation d'un bouton comme entrée numérique ······························· 23
Exercise 7. Réglage de la luminosité des LED à l'aide d'un potentiomètre (entrée
analogique) 27
Exercise 8. Affichage du texte sur l'écran LCD I2C (écran) ·· Erreur ! Signet non défini.
Exercise 9. Détection de température avec un capteur analogique (AnalogRead) · Erreur !
Signet non défini.
Exercise 10. Détection de la lumière avec une photorésistance (capteur analogique)Erreur !
Signet non défini.
Exercise 11. Détection de mouvement avec un capteur PIR (capteur numérique) ·· Erreur !
Signet non défini.
Exercise 12. Contrôle d'un servomoteur (sortie PWM)·········· Erreur ! Signet non défini.
Exercise 13. Considération du projet Arduino ···················· Erreur ! Signet non défini.
 le Makerspace au Sénégal 1

Exercise 1. Comprendre Arduino

Les participants apprennent à distinguer et à utiliser différents types de cartes Arduino. Grâce à cela,
ils comprendront les critères de sélection des tableaux à utiliser pendant le processus d'apprentissage
et en tant que produits.

■ Principaux types et caractéristiques de la carte Arduino

Caractéristiques : La carte de base la plus
utilisée.
Spécifications:
Microcontrôleur ATmega328P.
14 broches d'E/S numériques (dont 6 broches
Arduino Uno PWM).
6 broches d'entrée analogiques.
Utilisation : Pour l'apprentissage des débutants,
projets simples.
Exemples : LED clignotante, détection d'entrée
de bouton.
Caractéristiques : Planche de taille compacte.
Spécifications :
Microcontrôleur ATmega328.
Arduino 14 broches d'E/S numériques.
Nano 8 broches d'entrée analogiques.
Utilisation : Projets à espace restreint, systèmes
embarqués.
Exemples : contrôle de petits robots, dispositifs
portables.
Caractéristiques : Fournit de nombreuses
broches d'E/S et de la mémoire.
Spécifications :
Microcontrôleur ATmega2560.
54 broches d'E/S numériques (dont 15
Arduino
broches PWM).
Mega
16 broches d'entrée analogiques.
Utilisation : Projets à grande échelle, systèmes
IoT, enregistrement de données. Exemple :
système de maison intelligente, réseau de
capteurs complexe.
Caractéristiques : Fournit la fonctionnalité USB
HID (Human Interface Device).
Spécifications :
Arduino Microcontrôleur ATmega32u4.
Leonardo 20 broches d'E/S numériques.
12 broches d'entrée analogiques.
Utilisation : Clavier, émulation de souris.
Exemple : Création de périphériques d'entrée
utilisateur

Page 1
 le Makerspace au Sénégal 2

Caractéristiques : Utilise un microcontrôleur 32

bits haute performance.
Spécifications :
ATSAM3X8E processeur ARM Cortex-M3.
Arduino Due
54 broches d'E/S numériques.
12 broches d'entrée analogiques.
Utilisation : Projets exigeants et performants.
Exemples : imprimantes 3D, traitement de
données en temps réel.

■ Différence entre les modules Arduino verts et bleus

Module Vert (Arduino Officiel)
Fabriqué par [Link] (produit officiel).
Module Vert
Haute qualité, stable et fiable.
(Arduino
Plus cher mais idéal pour les projets à long
Officiel)
terme.

Fabriqué par des fabricants tiers (non officiel).

Moins cher mais peut avoir une qualité
Module bleu
inférieure.
(clone
Peut nécessiter des pilotes supplémentaires
Arduino)
(par exemple, CH340/CH341).
Recommandation:

Page 2
 le Makerspace au Sénégal 3

■ Nom de la pièce Arduino Uno

Article Description But

Un port pour connecter Arduino à Téléchargement du code et
USB Port
un ordinateur alimentation électrique.
Contrôler des appareils numériques tels
Broches pour la réception ou
Digital Pin que des LED ou détecter les entrées de
l'émission de signaux numériques
boutons.
Traitement de données analogiques
Broches pour la réception de
Analog Pin provenant de capteurs tels que des
signaux analogiques
capteurs de lumière ou de température.
Broches d'alimentation (3.3V, 5V) Alimentation des capteurs ou des
Power Pins
et masse (GND), Vin modules et mise à la terre du circuit.
Vérification de l'état de la
LED indiquant la transmission et la
TX, RX LED communication entre Arduino et un
réception de données
ordinateur.
Un bouton pour réinitialiser la carte Redémarrer la carte lorsque le
Reset Button
à son état initial programme fonctionne mal ou se fige.
Installation d'un bootloader ou
Broche de programmation série en
ICSP Pin programmation directe (rarement
circuit
utilisé par les débutants).
L'unité de contrôle centrale de la Exécution de code et contrôle
Microcontroller
carte Arduino d'appareils externes.
Une LED indiquant l'état de Vérifier que la carte est correctement
Power LED
l'alimentation de la carte alimentée.

Page 3
 le Makerspace au Sénégal 4

Un générateur de signaux d'horloge

Crystal Garantit un chronométrage précis et
contrôlant la vitesse de
Oscillator une exécution fiable du code.
fonctionnement du microcontrôleur

■ Configuration des broches GPIO Arduino

Les broches Arduino GPIO (General-Purpose Input/Output) sont des broches numériques et
analogiques polyvalentes sur une carte Arduino qui vous permettent de vous interfacer avec
des composants externes tels que des capteurs, des actionneurs et d'autres appareils. Voici
une explication de leur fonctionnalité :

(1) Broches GPIO numériques

Numérotation : Généralement étiqueté comme D0, D1, ..., Dn (par exemple, D0-D13 sur
Arduino Uno).
Fonctionnalité :
✓ Peut être configuré comme INPUT ou OUTPUT à l'aide de la fonction pinMode().
✓ INPUT : Lit l'état d'une broche (HIGH ou LOW). Utile pour les boutons, les capteurs,
etc.
✓ OUTPUT : Définit l'état d'une broche sur HIGH (ON) ou LOW (OFF). Utile pour les
LED, les relais, etc.
Niveaux de tension :

Page 4
 le Makerspace au Sénégal 5

✓ HIGH : Généralement 5V (ou 3,3V pour certaines cartes comme Arduino Due).
✓ LOW: 0V (masse).
Exemple d'utilisation :
---------------
pinMode (13, OUTPUT); // Configure le pin 13 en OUTPUT
digitalWrite(13, HIGH); // Réglez la broche 13 sur HIGH (allumez la LED)
---------------

2. Broches PWM (modulation de largeur d'impulsion)

Définition : Un sous-ensemble de broches numériques (marquées d'un ~ sur la plupart des
cartes, comme ~3, ~5, ~6) qui peuvent simuler une sortie analogique.
Fonctionnalité :
✓ Émet une onde carrée avec des rapports cycliques variables, fournissant efficacement
une sortie « pseudo-analogique ».
✓ Utilisé pour contrôler des appareils tels que des servomoteurs, des LED sombres ou
ajuster la vitesse du moteur.
Exemple d'utilisation:
---------------
analogWrite(6, 128) ; Réglez le PWM sur la broche 6 à 50 % du rapport cyclique (128
sur 255)
---------------

3. Broches GPIO analogiques

Numérotation: étiqueté comme A0, A1, ..., An (par exemple, A0-A5 sur Arduino Uno).
Fonctionnalité:
✓ Utilisé pour lire des signaux analogiques à partir de capteurs (par exemple, des
potentiomètres, des capteurs de température).
✓ Convertit les signaux analogiques (0-5V) en valeurs numériques (0-1023 sur un CAN
10 bits).
✓ Certaines broches analogiques peuvent également fonctionner comme des broches
numériques.
Exemple d'utilisation :
---------------
int sensorValue = analogRead(A0) ; Lire la valeur analogique à partir de la broche A0
---------------

4. Broches GPIO spéciales

Broches de communication série :
✓ RX (D0) : Reçoit les données série.
✓ TX (D1) : Transmet les données série.
✓ Utilisé pour la communication avec d'autres appareils (par exemple, ordinateurs,
modules).
Broches I2C :
✓ SDA : Ligne de données.

Page 5
 le Makerspace au Sénégal 6

✓ SCL : Ligne d'horloge.

✓ Utilisé pour connecter des appareils I2C tels que des écrans ou des capteurs.
Broches SPI :
✓ MOSI, MISO, SCK, SS : Utilisé pour la communication SPI avec des modules tels
que des cartes SD, des écrans, etc.
✓ AREF (broche de référence analogique) :
✓ Fournit une tension de référence externe pour l'ADC.

5. Limites GPIO
Limites de courant :
Courant maximum par broche : ~20mA (40mA absolu maximum pour la plupart des cartes).
Le dépassement des limites peut endommager la planche.
Niveaux de tension :
Assurez-vous que les appareils connectés correspondent à la tension de fonctionnement de la
carte (5 V ou 3,3 V).

6. Applications GPIO courantes

Lire les capteurs (par exemple, la température, l'humidité).
Contrôle des actionneurs (par exemple, moteurs, relais, LED).
Communication avec d'autres appareils (par exemple, I2C, SPI).
Construire des projets interactifs (par exemple, des robots, des systèmes
d'automatisation).
Les broches GPIO sont fondamentales pour les projets Arduino, permettant l'interaction
entre la carte et le monde physique.

■ Pièces fréquemment utilisées dans Arduino

Arduino est livré avec un kit d'apprentissage qui comprend des capteurs et des appareils permettant
une variété d'expériences. Il existe différentes configurations de packages, des débutants aux
utilisateurs avancés, il est donc recommandé d'utiliser le package approprié.

(1) Capteurs
Nom Modèle Image Description

Capteur de Sortie numérique, le DHT22 a une

DHT11,
température et précision et une portée supérieures à
DHT22
d'humidité celles du DHT11

Capteur de
Sortie analogique, -55°C à 150°C,
température LM35
haute précision
analogique
Capteur de Portée de détection de 2 cm ~ 400
distance à HC-SR04 cm, erreur de ±3 mm, utilisez l'écho
ultrasons ultrasonique

Page 6
 le Makerspace au Sénégal 7

Capteur de
Tranchant Portée de détection de 10 ~ 80 cm,
distance
GP2Y0A21 sortie analogique
infrarouge
Capteur de
Sortie analogique basée sur le
lumière LDR
changement de résistance
ambiante

Capteur de
couleur
TCS3200 RGB 감지, 프로그래머블 출력

Capteurs de Détection de divers gaz (par

MQ-2, MQ-3
gaz exemple CO, alcool, propane),
sorties analogiques et numériques

Capteur de Détection d'émission et de réflexion

détection de Capteur PIR infrarouge, fonction simple
mouvement d'évitement d'obstacles

Capteurs
d'accélération 6 axes (accélération 3 axes +
MPU6050
et gyroscope 3 axes), sortie I2C
gyroscopiques

Capteur de
Utilisation de LED infrarouges et
fréquence MAX30100
rouges, interface I2C
cardiaque

(2) Actionneurs
Nom Modèle Image Description
Rotation de 180 ou 360 degrés,
Servo Moter SG90, MG995 contrôlée par signal PWM

Moteurs à
Vitesse contrôlable, pilotée par
DC Moter courant continu
signal PWM
généraux

Moteurs pas Contrôle de haute précision, 1,8

NEMA 17
à pas degrés/pas

Le signal 5V fournit un contrôle

Modules de
Relais 5V haute tension (220V), une isolation
relais
électrique

Couleurs variées, consommation de

LED LED
courant de 20 mA

Page 7
 le Makerspace au Sénégal 8

Chaque LED peut être contrôlée

individuellement, à l'aide d'une
WS2812 (en seule broche de données
LED RVB
anglais)

L'actif génère des sons simples, le

Buzzer Actif/Passif
passif a une fréquence réglable

Interface I2C ou parallèle

Écran LCD 16x2, 20x4 disponible, rétroéclairage intégré
inclus

Interface I2C, conception petite et

Écran OLED SSD1306 basse consommation

Variateur DC 3-6V, adapté aux

Pompe Mini pompe petits projets, DC 5V/12V, débit
1L/min

Fonctionnement DC 12V, jusqu'à

Électrovanne Vanne 12V
10ba

Fin.

Page 8
 le Makerspace au Sénégal 9

Exercise 2. Configuration de l'environnement de programmation Arduino

Les participants connectent la carte Arduino à un ordinateur, installent l'IDE Arduino et apprennent à
configurer un environnement de programmation de base. Ils vont écrire un simple programme «
Hello, World ! » pour faire clignoter la LED embarquée.

■ Environnement de pratique
PC
Système d'exploitation Windows 10 ou version
Ordinateur ultérieure
1 ou plusieurs ports USB 2.0
7 Go d'espace de stockage ou plus

Arduino Uno R3
Arduino Uno
Câble USB

■ Installation de l'IDE Arduino

Afin d'utiliser les fonctionnalités globales d'Arduino, vous devez créer un programme via
l'environnement de développement intégré (IDE) et le télécharger sur la carte Arduino.
L'environnement de développement intégré fonctionne dans le langage Arduino basé sur C et peut être
téléchargé gratuitement sur le site Web d'Arduino ([Link]

(1) Accédez à la page d'accueil de l'Arduino et sélectionnez le menu du logiciel

Page 9
 le Makerspace au Sénégal 10

(2) Vous pouvez choisir de payer ou de payer.

(3) Vérifiez le fichier téléchargé et procédez à l'installation (à partir de décembre 2024)

arduino-ide_2.3.4_Windows_64bit.exe

✓ Licence Aggrement -> Accepter

✓ Sélectionnez une option d'installation : Tous les utilisateurs de cet ordinateur (tous les
utilisateurs)
✓ Sélectionnez un emplacement d'installation : (accepter le chemin par défaut)

Page 10
 le Makerspace au Sénégal 11

■ Fonctions d'environnement de développement intégré

 Verify : le processus de compilation vérifie que le code ne contient pas d'anomalies.

 Upload: Après avoir vérifié le code, téléchargez le code sur le tableau s'il n'y a pas de
problème.
 Debug: interrompez l'exécution pendant un moment pour voir ce qui se passe pour chaque
code de programme.
 Serial Monitor: La communication série entre l'ordinateur et l'Arduino vous permet de
vérifier l'état de votre Arduino sur le moniteur.
 Serial Plotter: Représente graphiquement les données collectées par la série.
 Sketch Editor: Modifiez le code du programme Arduino.

■ Configuration de l'environnement de développement intégré Arduino

L'environnement de développement intégré Arduino spécifie la carte Arduino à utiliser et spécifie
le port de communication pour se connecter à la carte.

(1) Affectation au conseil d'administration :

✓ Outil -> carte -> Arduino AVR Boards -> Sélectionner « Arduino Uno »

Page 11
 le Makerspace au Sénégal 12

(2) Sélection du port

✓ Outil -> Sélection de ports

Page 12
 le Makerspace au Sénégal 13

■ Communication série entre Arduino et PC

La communication série est un moyen pour les équipements informatiques d'envoyer et de recevoir
des informations. Elle est également connue sous le nom de communication série. Il est utilisé pour
créer des programmes sur votre PC et les transférer sur Arduino afin de les exécuter. Il peut également
recevoir des informations sur l'état de fonctionnement de l'Arduino.

La communication série est automatiquement utilisée pendant le processus de téléchargement et

lors de la sélection d'un moniteur série. Étant donné qu'une ligne est utilisée, aucun autre programme
ne peut être utilisé pendant qu'il est utilisé, il est donc nécessaire de vérifier si la communication est
normale à chaque fois.

Dans les environnements IDE, la communication série est généralement spécifiée à 9600 bauds,
mais 115200 est généralement utilisé pour une communication efficace.

Fin.

Page 13
 le Makerspace au Sénégal 14

Exercise 3. Clignotant d'une LED intégrée

Les participants apprendront les informations de base sur la programmation Arduino et exploreront
comment utiliser le code à travers des exemples de programmes.

■ Environnement de pratique
PC
Système d'exploitation Windows 10 ou version
Ordinateur ultérieure
1 ou plusieurs ports USB 2.0
7 Go d'espace de stockage ou plus

Arduino Uno Arduino Uno

Câble USB Câble USB 2.0 de type A/B

■ Assemblage

- Connectez le câble USB au terminal USB de l'ordinateur.

- Connectez le câble USB au port USB Arduino.
- Lorsqu'une connexion normale est terminée, la LED Arduino clignote.

■ Comprendre la structure du code et les fonctions de base

Le programme Arduino a une structure de programme standardisée. Il est divisé en une partie qui
initialise l'environnement d'exploitation Arduino (setup) et une partie qui se répète (loop). Ces deux
parties doivent être spécifiées, et l'IDE ajoute les programmes nécessaires pour exécuter les parties
d'initialisation et de répétition du programme exécutable Arduino.

Page 14
 le Makerspace au Sénégal 15

(1) Fonction setup() :

S'exécute une fois au début du programme.
Utilisé pour les tâches d'initialisation (par exemple, réglage des modes de broches,
initialisation de la communication série).
Exemple :
---------------
pinMode(LED_BUINTIN, OUTPUT);
---------------

(2) Fonction loop() :

Fonctionne en continu après setup().
Utilisé pour des tâches répétitives telles que la lecture des données d'un capteur ou le
contrôle d'une LED.
Exemple :
---------------
digitalWrite(LED_BUINTIN, HIGH);
---------------

■ Syntaxe et règles de base

Les programmes Arduino suivent la syntaxe des programmes C/C++ et utilisent la plupart de
la syntaxe du programme, mais sont plus flexibles que le C/C++ traditionnel dans certaines
façons de gérer les données.
(1) Point-virgule (;) :
Chaque déclaration doit se terminer par un point-virgule (;).
Exemple :
---------------

Page 15
 le Makerspace au Sénégal 16

digitalWrite(13, LOW);
---------------

(2) Sensibilité à la casse :

Les fonctions et les variables sont sensibles à la casse.
Exemple :
---------------
PinMode (Error) vs. pinMode (Correct).
---------------

(4) Utilisation des commentaires :

Ajoutez des commentaires pour expliquer l'objectif et la fonctionnalité de votre code.
Commentaire sur une seule ligne : // Ce code allume la LED.
Commentaire sur plusieurs lignes :
---------------
/*
* Ce code
* contrôle le clignotement d'une LED.
*/
---------------

■ Configuration et utilisation des broches

Les broches d'Arduino ont une variété de fonctions, alors comment les utiliser différemment
pour chaque utilisation. Si nous nous limitons aux sorties de données numériques les plus
couramment utilisées, nous les spécifierons et les utiliserons comme suit.
(1) Réglage des modes de broches :
Définissez les broches numériques comme INPUT ou OUTPUT.
Exemple :
---------------
pinMode(13, OUTPUT);
---------------

(2) Contrôle numérique des broches :

HIGH : Émet une tension à la broche (allume la LED).
LOW : Arrête la tension à la broche (éteint la LED).
Exemple :
---------------
digitalWrite(13, HIGH);
---------------

(3) Lecture des broches analogiques :

Lit les valeurs du capteur allant de 0 à 1023.
Exemple :
---------------
int sensorValue = analogRead(A0) ;
---------------

Page 16
 le Makerspace au Sénégal 17

■ Variables et types de données

L'Arduino dispose d'une puissance de calcul et peut stocker et récupérer des données
calculées. Le programme appelle cela une variable, et il a une manière différente de stocker
les données en fonction du type de données, de sorte qu'il détermine le type de variable en
fonction du type de données.
(1) Déclaration de variable :
Déclarer les variables pour stocker les valeurs.
Exemple :
---------------
int ledPin = 13 ;
---------------

(2) Types de données :

int : Entier (par exemple, 0, 1, -10).
float : nombre à virgule flottante (par exemple, 3,14, 0,001).
booléen : True (true) ou false (false).

■ Communication série
Il est nécessaire pour l'Arduino d'échanger des informations avec un équipement externe (par
exemple, un PC). Vous pouvez utiliser la communication série pour échanger des
informations. Lors de la phase de préparation à l'utilisation, la méthode de communication
série peut être spécifiée (configuration), et les informations peuvent être transmises ou reçues
de manière répétée dans l'état de fonctionnement (boucle).
(1) Initialisation de la communication série :
Utilisez [Link]() pour démarrer la communication avec le Moniteur Série.
Exemple :
---------------
[Link](9600) ;
---------------

(2) Données d'impression :

Valeurs de sortie vers le moniteur série.
Exemple :
---------------
[Link]("Hello, Arduino!");
---------------

■ Vérification des erreurs et débogage

Vous pouvez utiliser des fautes de frappe ou des commandes mal mémorisées pendant le
processus de programmation. De plus, il y a des moments où des problèmes surgissent
pendant le programme auxquels vous n'avez pas pensé. Si tel est le cas, il y a plusieurs choses
que vous pouvez faire pour déterminer la cause du problème. En voici deux :
(1) Erreurs de compilation :
Cliquez sur le bouton « Vérifier » pour vérifier s'il y a des erreurs dans le code.

Page 17
 le Makerspace au Sénégal 18

Lire et corriger les messages d'erreur.

(2) Utilisation du moniteur série :

Déboguer en affichant les valeurs ou le comportement du programme.
Exemple :
---------------
[Link]("Sensor Value: ");
[Link](sensorValue);
---------------

■ Alimentation électrique et connexions

(1) Connexion USB :
Assurez-vous que la carte Arduino est correctement connectée à l'ordinateur.

(2) Sélection de la carte et du port :

Choisissez la carte et le port appropriés dans l'IDE.
Menu : Outils > Board > Arduino Uno.
Menu : Outils > Port > COMx (port connecté à Arduino).

■ Premier programme (exemple : LED clignotante)

(1) Utilisez des exemples de programmes :
Dans le menu :
Fichier => Exemples => Bases => Cligner des yeux

// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second

Page 18
 le Makerspace au Sénégal 19

■ Compaile et upload
(1) Icône de téléchargement cliquée
Compilez le programme et, une fois qu'il s'est terminé avec succès, téléchargez le fichier exécutable
sur Arduino.

(2) Modifiez le programme et téléchargez-le à nouveau

delay(1000); // wait for a second
Correction du délai de 1 seconde à 0,1 seconde
delay(100); // wait for 0.1 second

(3) Vérification du temps de clignotement

Succès lorsque la LED passe de 1 seconde de clignotement à 0,1 seconde de clignotement

■ Conseils supplémentaires
(1) Enregistrez régulièrement le code :
Évitez la perte de données en cas de fermeture accidentelle de l'IDE ou d'arrêt de l'ordinateur.

(2) Utilisez des exemples de codes :

Utilisez des exemples intégrés dans l'IDE pour apprendre rapidement. (Fichiers > exemples >
[Link])

Fin.

Page 19
 le Makerspace au Sénégal 20

Exercise 4. Faire clignoter une LED externe

Les participants connectent une LED externe et une résistance à la carte Arduino et apprennent à
écrire un programme qui fait clignoter la LED à intervalles réguliers. Cet exercice présente la
configuration de base du circuit et le contrôle de sortie numérique.

■ Environnement de pratique

PC, Windows 10 ou version ultérieure, IDE

PC et Arduino Arduino
Arduino Uno R3

LED LED x 1EA

220 Ω x 1EA
Registre

(3) Planche à pain

Rails d'alimentation : Les rails rouge (+) et bleu (-) des deux côtés sont utilisés pour
l'alimentation électrique. Connectez VCC (3,3 V ou 5 V) à (+) et GND à (-).
Connexions centrales : La section centrale est divisée en deux côtés et les broches de la
même rangée sont connectées électriquement.
Fils de liaison : Utilisez des fils de liaison pour connecter les composants et les broches.
Insertion de composants : Insérez des composants tels que des LED, des résistances et
des boutons dans les trous de la plaque d'essai pour construire votre circuit.
Précautions : Évitez les courts-circuits et assurez-vous que les composants sont
correctement connectés.

Page 20
 le Makerspace au Sénégal 21

■ Connectez-vous avec les LED sur le Bradboard d'Arduino

LED + connectée à la broche 13 via une résistance de 220 ohms.

LED - connectée à GND.

■ Réalisation d'un programme LED

Utilisez l' exemple de programme fourni par l'IDE Arduino.

Menu : Fichier => Exemples => Bases => Cligner des yeux

■ Cliquez sur l'icône Télécharger pour compiler et télécharger.

Page 21
 le Makerspace au Sénégal 22

(1) Télécharger
Cliquez sur le bouton Télécharger l'icône

(2) Vérifiez le programme

Si cela fonctionne normalement, vous pouvez voir la LED clignoter.

(3) Modification de l'heure de clignotement

Modifiez le temps de retard dans le programme de 1000 (1 seconde) à 200 (0,2 seconde).

delay(1000); // wait for a second

delay(1000) => delay(200) 으로변경
delay(200);
✓ Consultez le programme après Uplaod

(4) Changez le code PIN No de « LED_BUILTIN » à « 13 » et testez

pinMode(13, OUTPUT);

digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)

digitalWrite(13, LOW); // turn the LED off by making the voltage LOW

✓ Consultez le programme après Uplaod

✓ Dans le programme Arduino, il est marqué comme LED_BUILTIN à la place du numéro

de broche 13.

Page 22
 le Makerspace au Sénégal 23

Exercise 5. Utilisation d'un bouton comme entrée numérique

Les participants connectent un bouton comme périphérique d'entrée et écrivent un programme qui
allume la LED lorsque le bouton est enfoncé et s'éteint lorsqu'il est relâché. Cela présente les bases du
contrôle d'entrée et de sortie numériques.

■ Environnement de pratique

PC, Windows 10 ou version ultérieure, IDE

PC et Arduino Arduino
Arduino Uno R3

Interrupteur tactile
Bouton
Interrupteur à 4 broches

10 KΩ (옴)
Registre 5 couleurs : marron, noir, noir, rouge, erreur
4 couleurs : marron, noir, rouge, erreur

■ Structure du bouton Tact :

Un bouton tactile (ou bouton tactile) est un petit interrupteur momentané utilisé pour terminer
temporairement un circuit lorsqu'il est enfoncé. Il est couramment utilisé dans les projets
électroniques pour la saisie par l'utilisateur, comme l'allumage/l'extinction d'appareils ou le
déclenchement d'actions.

Caractéristiques principales :
Action momentanée :
Le bouton ne connecte le circuit que lorsqu'il est enfoncé et se déconnecte lorsqu'il est
relâché.
Taille compacte :
Idéal pour les planches à pain et les appareils électroniques compacts.
Quatre goupilles :
Deux broches sont connectées à l'intérieur, ce qui facilite l'utilisation dans les circuits.
Domaines d'application :
Utilisé pour l'entrée dans les projets Arduino, la réinitialisation des appareils ou le
contrôle de petits circuits.

Page 23
 le Makerspace au Sénégal 24

Note:
Connectez toujours une résistance de traction vers le haut ou vers le bas pour assurer des
lectures de signal stables.

■ Connexion par bouton tactile

Vous pouvez simplement le tester comme ceci : Cependant, l'état est instable et peut avoir des
conséquences inattendues précises.

■ pull-up : Maintient le signal allumé normalement .

Si vous utilisez une résistance Pull-Up (10KΩ) sur votre Arduino, vous pouvez lire de manière
fiable l'état des broches d'entrée. La résistance de traction empêche la broche de flotter dans l'état
d'entrée. Cela vous permet d'améliorer la stabilité et la fiabilité de la conception de votre circuit.

Le circuit d'entrée est une résistance connectée à une alimentation, et lorsque l'interrupteur est
ouvert, la tension est appliquée, et lorsque l'interrupteur est fermé, la tension tombe à zéro.

Page 24
 le Makerspace au Sénégal 25

✓ La broche A se connecte à la broche A d'Arduino.

✓ La broche du bouton C se connecte à la broche Arduino 5V.

✓ La broche du bouton D est connectée à la broche GND de l'Arduino via une résistance de
10K ohm.

■ Modification et test du programme de boutons

(1) Utilisez le programme par défaut.

Menu : Fichier => Exemples => [Link]érique => Bouton

Page 25
 le Makerspace au Sénégal 26

(2) Cliquez sur l' icône Télécharger pour compiler et télécharger.

✓ Lorsque le bouton est enfoncé, la LED s'allume

■ Pull-down : Signale normalement OFF.

Sur Arduino, la résistance Pull-Down , par opposition à la résistance Pull-Up, est utilisée pour
définir l'état par défaut de la broche d'entrée sur LOW. Cela empêche les broches d'entrée de devenir
flottantes. Les résistances pull-down peuvent être un choix plus approprié que les résistances pull-up,
en fonction de votre logique de conception.

- La broche B se connecte à la broche D2 d'Arduino.

- La broche du bouton C se connecte à la broche Arduino 5V via une résistance de 10K ohm.
- La broche du bouton D se connecte à la broche GND de l'Arduino.

Utilisez le même programme que vous avez utilisé précédemment et testez-le

✓ LED allumée, qui s'éteint lorsque vous appuyez sur le bouton

Fin.

Page 26
 le Makerspace au Sénégal 27

Exercise 6. Réglage de la luminosité des LED à l'aide d'un potentiomètre

(entrée analogique)
Les participants apprennent à régler la luminosité des LED à l'aide d'un potentiomètre. Ils écrivent un
programme qui modifie la luminosité de la LED en fonction de la position du potentiomètre, en
comprenant l'entrée analogique et la sortie PWM.

■ Environnement de pratique

PC, Windows 10 ou version ultérieure, IDE

PC et
Arduino
Arduino
Arduino Uno R3

LED LED x 1EA

200 Ω
Registre 5 couleurs : rouge, rouge, noir, noir, erreur
4 couleurs : rouge, rouge, marron, erreur

Potentiomètre 10K ~ 50 KΩ

■ Entrée analogique Arduio

L'Arduino Uno dispose de broches d'entrée analogiques qui permettent à la carte de lire différents
niveaux de tension à partir de périphériques externes, tels que des capteurs. Ces entrées sont utilisées
pour capturer des données telles que la température, l'intensité lumineuse ou d'autres signaux
analogiques.

(1) broches analogiques

L'Arduino Uno dispose de 6 broches d'entrée analogiques étiquetées A0 à A5.
Ces broches peuvent mesurer des tensions analogiques allant de 0V à 5V.
En interne, le signal analogique est converti en valeur numérique à l'aide d'un
convertisseur analogique-numérique (CAN).

(2) Spécifications de l'ADC

L'Arduino Uno est équipé d'un CAN 10 bits.
Cela signifie que la plage de tension d'entrée (0–5V) est divisée en 1024 niveaux (2^10 =
1024).
✓ 0V correspond à une valeur numérique de 0.
✓ 5V correspond à une valeur numérique de 1023.
La résolution de l'ADC est la suivante :
✓ Résolution = Plage de tension / Niveaux = 5V / 1024 ≈ 4,88 mV
✓ Chaque étape de la valeur numérique représente environ 4,88 mV.

Page 27
 le Makerspace au Sénégal 28

(3) Lecture des entrées analogiques

Utilisez la fonction analogRead(pin) pour lire la valeur analogique à partir d'une broche.
La fonction renvoie un entier compris entre 0 et 1023.
Exemple :
---------------
int sensorValue = analogRead(A0) ;
---------------

(4) Référence de tension

Par défaut, la tension d'entrée analogique est comparée à la tension de référence 5V
(tension de référence par défaut).
Vous pouvez modifier la tension de référence à l'aide de la fonction analogReference() :
✓ PAR DÉFAUT : 5V (sur la plupart des cartes).
✓ INTERNE : 1,1V (pour des mesures basse tension plus précises).
✓ EXTERNE : Vous permet de fournir une tension de référence personnalisée à la
broche AREF.

(5) Multiplexage
Les broches d'entrée analogiques partagent un seul module ADC.
Un multiplexeur interne commute entre les broches pour lire les valeurs.
La conversion ADC prend environ 100 microsecondes par lecture, de sorte que la
fréquence d'échantillonnage maximale est d'environ 10 000 échantillons par seconde.

(6) 8. Exemple de code

Voici un exemple de lecture d'une entrée analogique et de conversion de celle-ci en tension :
void setup() {
[Link](9600); // Initialize Serial Monitor
}

void loop() {
int sensorValue = analogRead(A0); // Read analog value
float voltage = sensorValue * (5.0 / 1023); // Convert to voltage
[Link](voltage); // Print voltage to Serial Monitor
delay(500); // Wait 500ms
}

Lire la valeur d'une broche (0-1023)

int sensorValue = analogRead(A0);
Convertir la valeur en tension (intervalles de 5V à 1023)
float voltage = sensorValue * (5.0 / 1023)

Page 28
 le Makerspace au Sénégal 29

■ Assemblage du circuit

- Connectez une extrémité du potentiomètre à l'Arduino 5V

- Connectez l'autre extrémité du potentiomètre à l'Arduino GND
- Connectez le fil central du potentiomètre dans l'Arduino A0

■ Édition du programme du potentiomètre

(1) Assurez-vous d'utiliser le programme par défaut.
Menu : Fichier => Exemples => [Link] => AnalogInoput

int sensorPin = A0; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the sensor

void setup() {
// declare the ledPin as an OUTPUT:
pinMode(ledPin, OUTPUT);
}

void loop() {
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
// turn the ledPin on
digitalWrite(ledPin, HIGH);
// stop the program for <sensorValue> milliseconds:
delay(sensorValue);
// turn the ledPin off:
digitalWrite(ledPin, LOW);
// stop the program for <sensorValue> milliseconds:
delay(sensorValue);
}

Page 29
 le Makerspace au Sénégal 30

Description du programme : Lit la valeur de la résistance variable (potentiomètre) et ajuste le

temps de clignotement de la LED entre 0 et 1 seconde

Lire la valeur d'une broche (0-1023)

sensorValue = analogRead(sensorPin);
Convertir la valeur en delay(0-1023)
delay(sensorValue);

(2) Compiler, télécharger et tester

✓ Après une compilation et un téléchargement normaux, la vitesse de clignotement de la
LED peut être ajustée en fonction de la valeur de la résistance. Ajustez le rhéostat Nobe
pour voir si la vitesse de clignotement change.

■ Qu'est-ce que le PWM ?

PWM est l'abréviation de Pulse Width Modulation et c'est une technique utilisée pour contrôler la
luminosité des LED, le contrôle de la vitesse du moteur à courant continu, le contrôle d'un
servomoteur ou lorsque vous devez obtenir une sortie analogique avec des moyens numériques.
Les broches numériques Arduino nous donnent soit 5V (lorsqu'elles sont tournées HIGH) ou 0V
(lorsqu'elles sont tournées LOW) et la sortie est un signal d'onde carrée. Donc, si nous voulons faire
varier l'intensité d'une LED, nous ne pouvons pas obtenir la tension entre 0 et 5V à partir de la broche
numérique, mais nous pouvons modifier l'heure d'allumage et d'extinction du signal. Si nous
changeons l'heure d'allumage et d'arrêt assez rapidement, la luminosité de la LED sera modifiée.

Avant d'aller plus loin, discutons de certains termes associés au PWM.

✓TON (On Time) : C'est le moment où le signal est élevé.
✓TOFF (Off Time) : C'est le moment où le signal est faible.
✓Période : Il s'agit de la somme du temps de marche et du temps de repos.
✓Cycle de service : Il s'agit du pourcentage de temps pendant lequel le signal était élevé
pendant la période de temps.

Ainsi, à un rapport cyclique de 50 % et à une fréquence de 1 Hz, la LED sera haute pendant une
demi-seconde et faible pendant l'autre demi-seconde. Si nous augmentons la fréquence à 50 Hz (50
fois ON et OFF par seconde), la LED sera vue briller à mi-luminosité par l'œil humain.

■ Arduino et PWM
L'IDE Arduino dispose d'une fonction intégrée « analogWrite() » qui peut être utilisée pour générer
un signal PWM. La fréquence de ce signal généré pour la plupart des broches sera d'environ 490 Hz et
nous pouvons donner la valeur de 0 à 255 en utilisant cette fonction.
✓analogWrite(0) signifie un signal de 0% de rapport cyclique.
✓analogWrite(127) signifie un signal de 50% de rapport cyclique.
✓analogWrite(255) signifie un signal de 100% du rapport cyclique.

Page 30
 le Makerspace au Sénégal 31

Sur Arduino Uno, les broches PWM sont 3, 5, 6, 9, 10 et 11. La fréquence du signal PWM sur les
broches 5 et 6 sera d'environ 980 Hz et sur les autres broches sera de 490 Hz.

■ Assemblage de circuits avec LED à PWM

- LED (+) connectée à l'Arduino D9 en connectant des résistances

- Connectez la LED (-) à l'Arduino GND
- Connectez une extrémité du potentiomètre à l'Arduino 5V
- Connectez l'autre extrémité du potentiomètre à l'Arduino GND
- Connectez le fil central du potentiomètre dans l'Arduino A0

Page 31
 le Makerspace au Sénégal 32

■ Modifiez le code pour contrôler la LED avec PWM

int ledPin = 9; // LED connected to digital pin 9

int analogPin = A0; // potentiometer connected to analog pin A0
int sensorValue = 0; // variable to store the read value

void setup() {
pinMode(ledPin, OUTPUT);
}

void loop() {
sensorValue = analogRead(analogPin);
analogWrite(ledPin, sensorValue / 4);

Description du programme : Lit la valeur de la résistance variable (potentiomètre) et ajuste le

temps de clignotement de la LED PWM entre 0 et 255 pas

Lire la valeur d'une broche (0-1023)

sensorValue = analogRead(sensorPin);
Convertir la valeur pour PWM(0-255)
analogWrite(ledPin, sensorValue / 4);
Ou bien
int luminausite = map(sensorValue, 0, 1023, 0, 255);
analogWrite(ledPin, luminausite);

(2) Compiler, télécharger et tester

✓ Après une compilation et un téléchargement normaux, la vitesse de clignotement de la
LED peut être ajustée en fonction de la valeur de la résistance. Ajustez le rhéostat Nobe
pour voir si la vitesse de clignotement change.

Fin.

Page 32