ARDUINO : LES CAPTEURS ET ACTIONNEURS EN GROVE

Porteur(s) du projet : Julien Warin (03/05/2017). Modifié par Damien MUTI DESGROUAS

Date : 15/03/2020

Licence : libre !

Contexte : Apprentissage

fournisseurs :

https://www.gotronic.fr/cat-capteurs-1114.htm

https://www.sparkfun.com/categories/23?page=all

https://boutique.semageek.com/fr/ (13140 MIRAMAS)

introduction

Dans ce tutoriel, vous pourrez trouver divers codes afin de programmer sur Arduino des capteurs tels que des potentiomètres, de distances, de slide, de gestes, de switch, etc. N'hésitez pas à ajouter d'autres capteurs afin de faciliter la vie d'autrui ! Afin d'utiliser les capteurs, il vous faudra vous munir généralement d'un grove shield pour votre carte arduino Uno :

ou encore d'un seeeduino :

Capteurs

Résistances

La résistance électrique traduit la propriété d'un composant à s'opposer au passage d'un courant électrique (l'une des causes de perte en ligne d'électricité). Elle est souvent désignée par la lettre R et son unité de mesure est l'ohm (symbole : Ω). Elle est liée aux notions de résistivité et de conductivité électrique (Source Wikipedia). Un dipole électrique uniquement résistif est appelé “conducteur ohmique” et par abus de langage, le terme “résistance”, qui est la grandeur physique associée au conducteur ohmique, sera employé pour qualifier ce dernier.

D'après la loi d'Ohm, il existe une relation de proportionnalité entre la tension aux bornes du conducteur ohmique et l'intensité qui le traverse. Le facteur de proportionnalité est, par définition, la valeur de la résistance :

U = R * I,
où U est la tension bornes du conducteur ohmique,
I, l'intensité qui le traverse
et R la résistance du conducteur ohmique en Ω.

Dans tout cet article un certain nombre de résistances seront utilisées pour mesurer des tensions ou des intensités via les entrées analogiques de la carte Arduino ou pour protéger des composant comme des LED.

De manière pratique, la valeur d'une résistance peut se lire grâce à un multimètre réglé en ohm-mètre. Il est aussi possible de lire la valeur de la résistance grâce au code couleur des résistances. Il existe plusieurs sites permettant de lire ce code couleur. Un des plus pratique est le suivant :

Code Couleur des Résistances

Capteur de distance Ultrason Grove

Présentation

Ce capteur de distance ultrason est basé sur le principe physique de l’écho. Il est composé d'un émetteur et d'un récepteur ultrason. L'émetteur envoie une salve d'ultrason qui se réfléchit sur l'obstacle dont on veut connaitre la distance par rapport au capteur. Le signal réfléchi est ensuite capté par le récepteur (microphone) d'ultrason. La figure suivante illustre le système:

source : http://clemence-melissa.e-monsite.com/pages/i-l-echographie-3d/principe-de-l-echographie.html

Connaissant la vitesse du son dans l'air “v(son) en en mesurant le temps “t(A/R”) d'un Aller-Retour de la salve, on en déduit la distance “d” entre l'émetteur et l'obstacle: d = v(son)*t(A/R)/2.

Le capteur de distance à ultrason en grove est le suivant :

Il s'agit du Grove - Ultrasonic Ranger :

https://www.gotronic.fr/art-telemetre-a-ultrasons-grove-101020010-18976.htm

Toutes les spécifications, schéma de câblage, et programme Arduino sont disponibles sur le lien suivant :

http://wiki.seeedstudio.com/Grove-Ultrasonic_Ranger/

Montage

Le schéma de câblage est le suivant:

Il est nécessaire de brancher la connexion Grove sur l'entrée D7 de la carte Seeeduino ou du module Grove. En effet, le programme suivant définit la broche de communication entre le capteur et la carte sur la broche D7. Ceci peut être modifié.

Pour faire tourner le code Arduino associé au capteur, il est nécessaire d'installer la librairie “UltrasonicRanger.h” qui s'installe à partir du lien suivant : https://github.com/Seeed-Studio/Grove_Ultrasonic_Ranger/archive/master.zip

Programme

Le code Arduino est le suivant :

#include "Ultrasonic.h"
Ultrasonic ultrasonic(7);
void setup()
{
Serial.begin(9600);
}
void loop()
{
long RangeInCentimeters;
RangeInCentimeters = ultrasonic.MeasureInCentimeters(); // two measurements should keep an interval
Serial.print(RangeInCentimeters);//0~400cm
Serial.println(" cm");
delay(250);
}

Ce programme permet d'effectuer la mesure de distance entre le capteur et un obstacle et de le faire afficher sur la console de l'IDE d'Arduino via le port série.

Application : dialogue avec l'Application Processing

Une application possible est de pouvoir récupérer la mesure d'une distance pour générer du graphisme sous le logiciel Processing. Voici un exemple :

COMMENT ENVOYER DES DONNÉES DE TYPE FLOAT, DOUBLE OU INT SUPÉRIEUR 255 VIA LE PORT SÉRIE

Capteur de pulsations cardiaques

Présentation

Un des systèmes les plus facile à utiliser est un capteur de pulsation cardiaque qui renvoie une tension proportionnelle à la pression artérielle laquelle traduit l'activité cardiaque. Le capteur est le suivant :

Il renvoie un signal du type :

Une documentation très complète du capteur est accessible sur ce lien : https://pulsesensor.com/.

Montages et Programmes

Il existe des programmes Arduino permettant de :

visualiser le signal électrique renvoyé par le capteur via l'IDE d'Arduino ou via un programme Processing : https://pulsesensor.com/pages/getting-advanced

de mesurer la fréquence cardiaque,

d'émettre un son à chaque battement cardiaque : https://pulsesensor.com/pages/pulse-sensor-speaker-tutorial

de contrôler l'angle d'un servomoteur à partir su signal analogique reçu via le capteur de pulsation cardiaque :https://pulsesensor.com/pages/pulse-sensor-servo-tutorial

Applications

Un projet de T-Shirt interactif comportant un cœur dessiné en LED associé à un capteur de pulsation cardiaque a été réalisé par 3 étudiante de DN MADE Mode. Le compte rendu du projet est accessible sur ce lien : https://docs.google.com/document/d/1VzyUjJWS05Z7IXFyhpkbK4cTLHwnxXeTiSyMmoGb9xw/edit?usp=sharing

Accéléromètre

Présentation du capteur Grove 3-Axix Digital Accelerometer(±16g)

le capteur Grove 3-Axix Digital Accelerometer(±16g) est disponible chez seeed.com. La documentation associée est disponible sur ce lien : Wiki_Seeeduino.

L'accéléromètre permet de mesurer les accélération ax, ay et az suivant les axes (Ox), (Oy) et (Oz) lié à la plaquette du capteur (voir image ci-dessus). (Ox) et (Oy) sont colinéaires au plan du capteur et (Oz) est perpendiculaire à ce plan.

Les valeurs de ax, ay et az sont donnés en “g”. Il s'agit donc d'un facteur multiplicatif de la gravité terrestre g=9.81m*s-².

Montage

Ce capteur Grove se connecte sur l'entrée I2C du Shield Arduino ou de la carte Seeeduino :

Installer la librairie associée au capteur

L'installation de la librairie associée au capteur s'effectue grâce à l'outil de Gestion des bibliothèque d'Arduino. Aller dans Outil> Gérer les Bibliothèques :

Taper le nom de l'accéléromètre dans le moteur de recherche (les références du capteurs se lisent généralement sur l'emballage). Ici, taper “accelerometer ADXL-345” :

Cliquer ensuite sur le bouton “Installer” (qui n'est pas représenté sur l'image ci-dessus).

L'installation manuelle de la librairie est expliquée sur ce lien : How to install an Arduino library.

Programme de base

Le code de base associé au capteur se trouve dans les exemples contenue dans la librairie “accelerometer ADXL345” :

le code permettant d'afficher les valeurs de ax, ay, et az dans le moniteur série, est le suivant:

#include <Wire.h>
#include <ADXL345.h>
ADXL345 adxl; //variable adxl is an instance of the ADXL345 library
void setup(){
Serial.begin(9600);
adxl.powerOn();
//set activity/ inactivity thresholds (0-255)
adxl.setActivityThreshold(75); //62.5mg per increment
adxl.setInactivityThreshold(75); //62.5mg per increment
adxl.setTimeInactivity(10); // how many seconds of no activity is inactive?
//look of activity movement on this axes - 1 == on; 0 == off
adxl.setActivityX(1);
adxl.setActivityY(1);
adxl.setActivityZ(1);
//look of inactivity movement on this axes - 1 == on; 0 == off
adxl.setInactivityX(1);
adxl.setInactivityY(1);
adxl.setInactivityZ(1);
//look of tap movement on this axes - 1 == on; 0 == off
adxl.setTapDetectionOnX(0);
adxl.setTapDetectionOnY(0);
adxl.setTapDetectionOnZ(1);
//set values for what is a tap, and what is a double tap (0-255)
adxl.setTapThreshold(50); //62.5mg per increment
adxl.setTapDuration(15); //625us per increment
adxl.setDoubleTapLatency(80); //1.25ms per increment
adxl.setDoubleTapWindow(200); //1.25ms per increment
//set values for what is considered freefall (0-255)
adxl.setFreeFallThreshold(7); //(5 - 9) recommended - 62.5mg per increment
adxl.setFreeFallDuration(45); //(20 - 70) recommended - 5ms per increment
//setting all interrupts to take place on int pin 1
//I had issues with int pin 2, was unable to reset it
adxl.setInterruptMapping( ADXL345_INT_SINGLE_TAP_BIT, ADXL345_INT1_PIN );
adxl.setInterruptMapping( ADXL345_INT_DOUBLE_TAP_BIT, ADXL345_INT1_PIN );
adxl.setInterruptMapping( ADXL345_INT_FREE_FALL_BIT, ADXL345_INT1_PIN );
adxl.setInterruptMapping( ADXL345_INT_ACTIVITY_BIT, ADXL345_INT1_PIN );
adxl.setInterruptMapping( ADXL345_INT_INACTIVITY_BIT, ADXL345_INT1_PIN );
//register interrupt actions - 1 == on; 0 == off
adxl.setInterrupt( ADXL345_INT_SINGLE_TAP_BIT, 1);
adxl.setInterrupt( ADXL345_INT_DOUBLE_TAP_BIT, 1);
adxl.setInterrupt( ADXL345_INT_FREE_FALL_BIT, 1);
adxl.setInterrupt( ADXL345_INT_ACTIVITY_BIT, 1);
adxl.setInterrupt( ADXL345_INT_INACTIVITY_BIT, 1);
}
void loop(){
//Boring accelerometer stuff
int x,y,z;
adxl.readXYZ(&x, &y, &z); //read the accelerometer values and store them in variables x,y,z
// Output x,y,z values
Serial.print("values of X , Y , Z: ");
Serial.print(x);
Serial.print(" , ");
Serial.print(y);
Serial.print(" , ");
Serial.println(z);
double xyz[3];
double ax,ay,az;
adxl.getAcceleration(xyz);
ax = xyz[0];
ay = xyz[1];
az = xyz[2];
Serial.print("X=");
Serial.print(ax);
Serial.println(" g");
Serial.print("Y=");
Serial.print(ay);
Serial.println(" g");
Serial.print("Z=");
Serial.print(az);
Serial.println(" g");
Serial.println("**********************");
delay(500);
}

Application

compteur de pas

Théorie

Comme expliqué précédemment, l'accéléromètre permet de mesurer les accélération ax, ay et az suivant les axes (Ox), (Oy) et (Oz) lié à la plaquette du capteur (voir image du capteur ci-dessus). (Ox) et (Oy) sont colinéaires au plan du capteur et (Oz) est perpendiculaire à ce plan.

Les valeurs de ax, ay et az sont donnés en “g”. Il s'agit donc d'un facteur multiplicatif de la gravité terrestre g=9.81m*s-².

D'après la deuxième loi de Newton, l'accélération mesurée par le capteur est proportionnelle à la résultante des forces qui lui sont appliquées dans le référentiel terrestre supposé galiléen :

Σ(F→) = m * (a→)

dans lequel m est la masse du capteur, (a→) l'accélération du centre de gravité du capteur dans le référentiel terrestre, et Σ(F→) (lire “somme des forces”), la résultante des forces appliquées au capteur.

Mesurer l'accélération revient donc à mesurer l'ensemble des forces appliquées au capteur.

Lorsque le capteur est fixé au pied d'une personne, il subit des chocs répétés à chacun des pas qu'elle effectue. Ces chocs entraînent des variations d'accélération brutale que nous allons détecter.

Pour cela, nous devons calculer la norme de l'accélération (ou tout simplement a valeur de l'accélération) : ||(a→)||=a à un instant donné :

a = √(ax²+ay²+az²)

Lorsqu'une personne marche avec un pas régulier, la variation temporelle de l'accélération est donnée par une courbe de ce type :

Sur cette courbe, on remarque que chaque choc provoqué par un pas provoque un “pic” brutal de l'accélération. Il suffit de détecter un “pic” pour détecter un pas. Ceci peut être effectué à un seuil de détection par exemple fixé ici à la valeur a=1,5g. Ce seuil est représenté sur la figure ci-dessus par la ligne horizontale rouge.

Lorsqu'un choc est détecté, il conviendra ensuite d'attendre un temps “DeltaT” correspondant à la durée du choc avant d'effectuer une nouvelle mesure. Ceci permet d'éviter de détecter un éventuel maximum secondaire de l'accélération du aux oscillations du capteur provoqué par le choc. A titre de comparaison, c'est ce qui est effectué lorsqu'on détecte la pression sur un bouton poussoir : il s'agit du “Debounce”.

Algorithme

L'algorithme de détection est donc le suivant :

A chaque itération de la boucle loop() :
* mesurer ax, ay, az
* calculer l'accélération a = √(ax²+ay²+az²)
* si (a > seuil) alors:
- incrémenter le compteur de pas
- patienter un temps DeltaT correspondant à la durée approximative d'un choc

Programme

Le code Arduino est le suivant :

compteur_pas_seuil_acceleration.zip

Problème connexe : enregistrer des données issues du capteur via Processing

On cherche ici à enregistrer des données de mesure issues du capteur afin de les analyser ultérieurement via un tableur ou un logiciel du type Matlab ou Scilab.

La première difficulté est d'envoyer des nombre de type flottant ou double sur le port série de la carte Arduino. En effet, la fonction Serial.println() envoie des paquet d'un seul octet à la fois alors qu'une variable de type float et qu'une variable de type double sont codées sur 4 octets (sur une Arduino Uno).

La solution choisie est la suivante :

côté Arduino :

On convertit la valeur de l'accélération a (float) en un chaine de caractère (String), grace à la fonction float(),

et on envoie cette chaine de caractère sur le port série via la fonction Serial.println().

Le code est le suivant : compteur_pas_seuil_acceleration_enregistrement_donnees.zip

Côté Processing :

On enregistre la chaine de caractère envoyée via le port série, en récupérant la chaine de proche en proche jusqu'à la détection d'un saut de ligne ('\n'), grace à la méthode readStringUntil() de la classe Serial() : ReadStringUntil('\n').

On convertit ensuite la chaine de caractère précédemment enregistrée, qui représente en réalité un nombre à virgule, en un nombre flottant grace à la méthode float().

On enregistre dans une nouvelle ligne d'un tableau de donnée qui sera enregistré au format .cvs à la fin de la capture.

Le code est le suivant : lecture_enregistrement_donnees_string_direct_3.zip

Capteur de geste

Ce capteur de geste qui peut en comprendre 7, va vous permettre de prototyper simplement sur processing afin de créer des interactions innovantes et ludiques !

Il vous faudra pour l'utiliser un grove shield ainsi qu'une carte arduino ou encore un seeeduino. Mais tout d'abord il va vous falloir certaines choses ! D'abord, il va falloir vous procurer ce capteur. pour cela je vous conseil de vous rendre sur le lien que vous trouverez dans l'onglets “ressources” afin de l'obtenir ! En attendant de le recevoir chez vous, vous pouvez aussi télécharger la librairie du capteur afin de pouvoir l'utiliser directement.

Ensuite, il ne vous restera plus qu'à copier le code ci-dessous afin pouvoir interagir avec le système :

#include <Wire.h>
#include "paj7620.h" //librairie
/*
Notice: When you want to recognize the Forward/Backward gesture or other continuous gestures, your gestures' reaction time must less than GES_REACTION_TIME(0.8s).
You also can adjust the reaction time according to the actual circumstance.
*/
#define GES_REACTION_TIME	80 //reaction du capteur
#define GES_QUIT_TIME	100 //temps avant de répéter l'action = delay
void setup()
{
uint8_t error = 0;
Serial.begin(9600);
Serial.println("\nPAJ7620U2 TEST DEMO: Recognize 15 gestures.");
error = paj7620Init();	// initialize Paj7620 registers
if (error)
{
Serial.print("INIT ERROR,CODE:");
Serial.println(error);
}
else
{
Serial.println("INIT OK");
}
Serial.println("Please input your gestures:");
}
void loop()
{
uint8_t data = 0, data1 = 0, error;
error = paj7620ReadReg(0x43, 1, &data);	// lire Bank_0_Reg_0x43/0x44 pour le résultat de la gestuelle.
if (!error)
{
switch (data)	// Lorsque les différents gestes sont détectés, la variable 'data' sera définie sur différentes valeurs par paj7620ReadReg (0x43, 1, & data).
{
case GES_RIGHT_FLAG:
delay(GES_REACTION_TIME);
paj7620ReadReg(0x43, 1, &data);
if(data == GES_LEFT_FLAG)
{
Serial.println("Right-Left");
}
else if(data == GES_FORWARD_FLAG)
{
Serial.println("Forward");
delay(GES_QUIT_TIME);
}
else if(data == GES_BACKWARD_FLAG)
{
Serial.println("Backward");
delay(GES_QUIT_TIME);
}
else
{
Serial.println("Right");
}
break;
case GES_LEFT_FLAG:
delay(GES_REACTION_TIME);
paj7620ReadReg(0x43, 1, &data);
if(data == GES_RIGHT_FLAG)
{
Serial.println("Left-Right");
}
else if(data == GES_FORWARD_FLAG)
{
Serial.println("Forward");
delay(GES_QUIT_TIME);
}
else if(data == GES_BACKWARD_FLAG)
{
Serial.println("Backward");
delay(GES_QUIT_TIME);
}
else
{
Serial.println("Left");
}
break;
break;
case GES_UP_FLAG:
delay(GES_REACTION_TIME);
paj7620ReadReg(0x43, 1, &data);
if(data == GES_DOWN_FLAG)
{
Serial.println("Up-Down");
}
else if(data == GES_FORWARD_FLAG)
{
Serial.println("Forward");
delay(GES_QUIT_TIME);
}
else if(data == GES_BACKWARD_FLAG)
{
Serial.println("Backward");
delay(GES_QUIT_TIME);
}
else
{
Serial.println("Up");
}
break;
case GES_DOWN_FLAG:
delay(GES_REACTION_TIME);
paj7620ReadReg(0x43, 1, &data);
if(data == GES_UP_FLAG)
{
Serial.println("Down-Up");
}
else if(data == GES_FORWARD_FLAG)
{
Serial.println("Forward");
delay(GES_QUIT_TIME);
}
else if(data == GES_BACKWARD_FLAG)
{
Serial.println("Backward");
delay(GES_QUIT_TIME);
}
else
{
Serial.println("Down");
}
break;
case GES_FORWARD_FLAG:
delay(GES_REACTION_TIME);
paj7620ReadReg(0x43, 1, &data);
if(data == GES_BACKWARD_FLAG)
{
Serial.println("Forward-Backward");
delay(GES_QUIT_TIME);
}
else
{
Serial.println("Forward");
delay(GES_QUIT_TIME);
}
break;
case GES_BACKWARD_FLAG:
delay(GES_REACTION_TIME);
paj7620ReadReg(0x43, 1, &data);
if(data == GES_FORWARD_FLAG)
{
Serial.println("Backward-Forward");
delay(GES_QUIT_TIME);
}
else
{
Serial.println("Backward");
delay(GES_QUIT_TIME);
}
break;
case GES_CLOCKWISE_FLAG:
Serial.println("Clockwise");
break;
case GES_COUNT_CLOCKWISE_FLAG:
Serial.println("anti-clockwise");
break;
default:
paj7620ReadReg(0x44, 1, &data1);
if (data1 == GES_WAVE_FLAG)
{
Serial.println("wave");
}
break;
}
}
delay(10);
}

Potentiomètre

Ce capteur de potentiomètre va vous permettre d'obtenir un ensemble de valeurs afin déclencher certaines actions rien qu'en l'actionnant ou encore de contrôler un volume sonore, la rotation d'un objet, etc. Afin de permettre la réalisation de dispositifs employant le potentiomètre,il va vous falloir vous munir de pièces indispensable.

Il vous faudra tout d'abord du capteur que vous pourrez vous procurer grâce au lien ce trouvant dans l'onglet “ressources” en bas de page, mais aussi d'un grove shield ainsi que d'une carte arduino ou encore un seeeduino.

Ensuite, il ne vous restera plus qu'à copier le code ci-dessous afin pouvoir interagir avec le système !

// Debug
int DEBUG = 1;
//int DEBUG = 0;
// Definition of the IN/OUT PIN
#define POT1 A0
// Pot
int VALUE_POT1 = 0;
int LAST_VALUE_POT1 = 0;
void setup() {
// For serial monitor
Serial.begin(9600);
delay(1000);
// Pot
pinMode(POT1, INPUT);
Serial.println("Ready!");
}
void loop() {
// Update POT value
VALUE_POT1 = analogRead(POT1);
// Pot1 mouvement?
if ( abs(LAST_VALUE_POT1 - VALUE_POT1) >=3) {
LAST_VALUE_POT1 = VALUE_POT1;
map(VALUE_POT1, 0, 1023, 127, 0);
if ( DEBUG == 1) {
Serial.println(VALUE_POT1, DEC);
}
}
}

Slider

Ce capteur de slide va vous permettre d'obtenir un ensemble de données, afin de permettre la réalisation des dispositifs qu'ils soient liés au domaine du son ou encore afin de d'amplifier des visuels/motifs sur processing ou tout autre logiciel de programmation permettant la création de supports interactifs.

Il vous faudra pour l'utiliser un grove shield ainsi qu'une carte arduino ou encore un seeeduino. Afin de préparer votre futur dispositif, il va falloir vous procurer le capteur sur le lien que vous pourrez trouver dans l'onglet “ressources” en bas de la page !

Ensuite, il ne vous restera plus qu'à copier le code ci-dessous afin pouvoir interagir avec le système !

// Debug
int DEBUG = 1;
//int DEBUG = 0;
// Definition of the IN/OUT PIN
#define SLIDE1 A1 //branchement sur le grove shield dans la partie analogie
// Slider
int VALUE_SLIDE1 = 0;
int LAST_VALUE_SLIDE1 = 0;
void setup() {
// For serial monitor
Serial.begin(9600);
delay(1000);
// Slide
pinMode(SLIDE1, INPUT);
Serial.println("Ready!");
}
void loop() {
// Update SLIDE value
VALUE_SLIDE1 = analogRead(SLIDE1); //si écrit analog = branchement analogique sinon si digital = inverse
// Slide1 mouvement?
if ( abs(LAST_VALUE_SLIDE1 - VALUE_SLIDE1) >=3 ) {
LAST_VALUE_SLIDE1 = VALUE_SLIDE1;
map(VALUE_SLIDE1, 0, 1073, 0, 127);
if ( DEBUG == 1) {
Serial.println(VALUE_SLIDE1, DEC);
}
}
}

Switch

Ce capteur va vous permettre de pouvoir changer d'un état à un autre tout simplement !

Il vous faudra pour l'utiliser un grove shield ainsi qu'une carte arduino ou encore un seeduino. Afin de vous procurer ce capteur, allez dans l'onglet “ressources en bas de la page. Ensuite, une fois tout vos éléments réunit, copiez le code ci-dessous afin de le faire fonctionner.

// Library
#include <Bounce2.h>//librairie permettant d'éviter les doublons
// Debug
int DEBUG = 1;
//int DEBUG = 0;
// Definition of the IN/OUT PIN
#define SWITCH 2 //branché sur l'entrée digital n°2
// Create instance Bounce object
Bounce DEBOUNCE_SWITCH = Bounce();
// Interval for debounce - depend of the quality of the switch
int DELAY = 5;
// Switch
int STATE_SWITCH = 0;
int LAST_STATE_SWITCH = 0;
void setup() {
// For serial monitor
Serial.begin(9600);
delay(1000);
// Switch
pinMode(SWITCH, INPUT);
DEBOUNCE_SWITCH.attach(SWITCH);
DEBOUNCE_SWITCH.interval(DELAY);
}
void loop() {
// Update bounce instance and state of button
DEBOUNCE_SWITCH.update();
// Store state of button to variable
int STATE_SWITCH = DEBOUNCE_SWITCH.read();
// SWITCH HIGH?
if ( STATE_SWITCH == HIGH && LAST_STATE_SWITCH == 0) {
LAST_STATE_SWITCH = 1;
if ( DEBUG == 1) {
Serial.println("SWITCH HIGH");
}
}
// SWITCH LOW?
if ( STATE_SWITCH == LOW && LAST_STATE_SWITCH == 1) {
LAST_STATE_SWITCH = 0;
if ( DEBUG == 1) {
Serial.println("SWITCH LOW");
}
}
}

Bouton poussoir

Ce capteur bouton va vous permettre de passé d'un état à un autre ou même de déclencher certaines actions rien qu'en appuyant dessus. Afin de permettre la réalisation de dispositifs employant les boutons comme les jeux par exemple, il va vous falloir vous munir de pièces indispensable.

Il vous faudra tout d'abord du capteur que vous pourrez vous procurer grâce au lien ce trouvant dans l'onglet “ressources” en bas de page, mais aussi d'un grove shield ainsi que d'une carte arduino ou encore un seeeduino. De plus, il vous faudra télécharger la librairie “bounce2” afin de permettre à arduino d'éviter les doublons, que certains signaux ne ce répètent pas.

Ensuite, il ne vous restera plus qu'à copier le code ci-dessous afin pouvoir interagir avec le système !

// Library
#include <Bounce2.h>//librairie permettant d'éviter les doublons
// Debug
int DEBUG = 1;
//int DEBUG = 0;
// Definition of the IN/OUT PIN
#define PUSH1 2 //D2 sur le grove
// Create instance Bounce object
Bounce DEBOUNCE_PUSH1 = Bounce();
// Interval for debounce - depend of the quality of the switch
int DELAY = 5;
// Push button
int STATE_PUSH1 = 0;
int LAST_STATE_PUSH1 = 0;
void setup() {
// For serial monitor
Serial.begin(9600);
delay(1000);
// Push button
pinMode(PUSH1, INPUT);
DEBOUNCE_PUSH1.attach(PUSH1);
DEBOUNCE_PUSH1.interval(DELAY);
Serial.println("Ready!");
}
void loop() {
// Update bounce instance and state of button
DEBOUNCE_PUSH1.update();
// Store state of button to variable
int STATE_PUSH1 = DEBOUNCE_PUSH1.read();
// PUSH 1?
if (STATE_PUSH1 == HIGH && LAST_STATE_PUSH1 == 0) {
LAST_STATE_PUSH1 = 1;
if ( DEBUG == 1 ) {
Serial.println("Button PUSH1 pressed_1");
}
}
if (STATE_PUSH1 == LOW && LAST_STATE_PUSH1 == 1) {
LAST_STATE_PUSH1 = 2;
if ( DEBUG == 1 ) {
Serial.println("Button PUSH1 released_1");
}
}
if (STATE_PUSH1 == HIGH && LAST_STATE_PUSH1 == 2) {
LAST_STATE_PUSH1 = 3;
if ( DEBUG == 1 ) {
Serial.println("Button PUSH1 pressed_2");
}
}
if (STATE_PUSH1 == LOW && LAST_STATE_PUSH1 == 3) {
LAST_STATE_PUSH1 = 0;
if ( DEBUG == 1 ) {
Serial.println("Button PUSH1 released_2");
}
}
}

Module Bluetooth

Un module bluetooth permet une communication entre la carte Arduino et un smartphone ou un ordinateur sans avoir à connecter un cable.

Voir UTILISER UN CAPTEUR BLUETOOTH ET COMMUNIQUER AVEC UN SMARTPHONE

Capteur de flexion Flexomètre

Présentation

Un flexomètre est un capteur relativement cher qui permet de capter le degrès de flexion d'un objet (doigt, page, etc.) :

Matériel

Gotronic

Fabriquer un Flexomètre - DIY

Tutoriel Instructable

Exemples d'utilisation

Studio Objet Augmenté de l'École nationale supérieure des Arts Décoratifs : Flexomatrix

Fabriquer un Flexomètre - DIY

Tutoriel Instructable

Exemples d'utilisation

Studio Objet Augmenté de l'École nationale supérieure des Arts Décoratifs : Flexomatrix

Capteur de Lumière

Un capteur de lumière est constitué généralement d'une photorésistance.

Grove

Un capteur de lumière Grove est le plus simple d'utilisation.

Matériel

Gotronic

Fiche technique

Grove Light Sensor chez Seeeduino

Capteur dipôle

Le plus simple des capteurs de lumière est constitué d'une photorésistance prenant a forme d'un dipôle. Il est plus complexe d'utilisation car nécessite d'être câblé sur une breadboard.

Matériel

Gotronic

Fiche technique

Tutoriel Arduino - site officiel

Capteur de Température (CTN)

Un capteur de température est généralement constitué d'une CTN. La CTN (coefficient de température négatif) est une thermistance, c'est-à-dire un capteur de température passif. Sa résistance varie en fonction de la température : elle diminue de façon uniforme lorsque la température augmente, et inversement.

Matériel

Gotronic

Fiche technique

Grove : https://wiki.seeedstudio.com/Grove-Temperature_Sensor_V1.2/

Dipôle : voir mon cours (Annexes)

Capteur capacitif interne à la carte Arduino

Un capteur capacitif

Un capteur capacitif est capable de détecter le toucher ou la proximité.

Il est possible de créer des capteurs capacitifs à partir de deux ou plusieurs broches digitales de la carte Arduino.

La bibliothèque capacitiveSensor transforme deux ou plusieurs broches Arduino en un capteur capacitif, qui peut détecter la capacité électrique du corps humain. Tout ce dont le capteur a besoin est une résistance moyenne à élevée et un morceau de fil et un petit (à grand) morceau de papier d’aluminium à l’extrémité. À son niveau le plus sensible, le capteur va commencer à détecter une main ou un corps à quelques centimètres du capteur.

La documentation Arduino est la suivante :

Librairie CapacitiveSensor

Documentation de la librairie CapacitiveSensor

Un exemple très simple est proposé sur le site Programminginarduino :

Touchy-feely Lamp

Montage :

Programme :

//Import a library from the Arduino folder
#include <CapacitiveSensor.h>
//Select the two pins that will act as a capacitor
CapacitiveSensor capSensor = CapacitiveSensor(4, 2);
//Insert the minimum value provided by the sensor to detect the touch
int threshold = 1000;
const int ledPin = 12;
void setup() {
Serial.begin(9600);
pinMode(ledPin, OUTPUT);
}
void loop() {
//Read the sensor value
long sensorValue = capSensor.capacitiveSensor(30);
Serial.println(sensorValue);
//Touch detected
if (sensorValue > threshold) {
//Turn on the led
digitalWrite(ledPin, HIGH);
}
//Touch undetected
else {
//Turn off the led
digitalWrite(ledPin, LOW);
}
delay(10);
}

Plusieurs capteurs capacitifs

Il est possible de commander plusieurs capteurs capacitifs sur la carte Arduino. Il suffit de prendre une patte digitale de Référence par rapport à laquelle les autres pattes vont se référer : par exemple D2.

L'exemple suivant s'inspire des exemples de la documentation Arduino sur les capteurs capacitifs internes à la carte Arduino. La librairie correspondante est téléchargeable sur le lien suivant : |CapacitiveSensor Library.

Le montage comprenant 3 capteurs capacitifs est le suivant :

Le programme permettant d'afficher le temps de mesure sur les 3 capteurs et la valeur correspondant à chaque capteur est le suivant: capacitivesensor_test_2.ino.zip

#include <CapacitiveSensor.h>
/*
CapitiveSense Library Demo Sketch
Paul Badger 2008
Uses a high value resistor e.g. 10M between send pin and receive pin
Resistor effects sensitivity, experiment with values, 50K - 50M. Larger resistor values yield larger sensor values.
Receive pin is the sensor pin - try different amounts of foil/metal on this pin
*/
CapacitiveSensor cs_2[] = {CapacitiveSensor(2, 4), // 10M resistor between pins 4 & 2, pin 2 is sensor pin, add a wire and or foil if desired
CapacitiveSensor(2, 6),// 10M resistor between pins 4 & 6, pin 6 is sensor pin, add a wire and or foi
CapacitiveSensor(2, 8)// 10M resistor between pins 4 & 8, pin 8 is sensor pin, add a wire and or foil
};
long total[] = {0, 0, 0};
boolean debug = true;
void setup()
{
cs_2[0].set_CS_AutocaL_Millis(0xFFFFFFFF); // turn off autocalibrate on channel 1 - just as an example
Serial.begin(9600);
}
void loop()
{
long start = millis();
for (int i = 0; i < 3; i++) {
total[i] = cs_2[i].capacitiveSensor(30);
}
if (debug) {
Serial.print(millis() - start); // check on performance in milliseconds
Serial.print("\t"); // tab character for debug windown spacing
for (int i = 0; i < 3; i++) {
Serial.print(total[i]); // print sensor output 1
Serial.print("\t");
}
Serial.println(""); // print sensor output 3
}
delay(10); // arbitrary delay to limit data to serial port
}

Quelques applications

Plantes qui parlent : Justine Gendreau

simuler un clavier :

Tutoriel vidéo : Transformer n'importe quoi en clavier grâce à l'Arduino

Fichiers Github

Librairie Keyboard Arduino. Uniquement valide pour les cartes Leonardo, Esplora, Zero, Due et de la famille MKR comportant un processeur ATmega32u4 et SAMD.

Module RFID

Un lecteur RFID permet de lire des informations stockées sur une carte RFID encore appelé “tag” RFID. Les deux formats les plus classiques de stockage sont : Uart et Wiegand, Wiegand.

Le principe de ces lecteur est de créer un champ électromagnétique magnétique variable (une onde) qui va, par induction dans une bobine, créer un courant électrique dans le circuit électronique contenu dans la carte ou le tag RFID. Le circuit électronique va répondre à son tour en envoyant les données numériques qu'il stocke en mémoire. Ces données numériques sont envoyées sous la forme d'une onde électromagnétique (c'est à dire un champs électromagnétique variable) qui est à son tour capté par le lecteur RFID.

Il existe plusieurs fréquences d'émission/réception pour les lecteurs RFID du marché :

125kHz

13,56MHz

Module RFID 125 kHz - Grove

Le lecteur RFID Grove 125 kHz émet une onde électromagnétique en 125MHz.

ATTENTION : Pour le faire fonctionner, ce lecteur RFID nécessite l'utilisation de badges RFID qui émette une fréquence de 125kHz. (voir la référence de Gotronic : Badges RFID 125 kHz).

La documentation Seeeduino est la suivante : Grove - 125KHz RFID Reader

Il faut connecter le câble Grove sur le slot Grove D2 de la carte Seeduino, ou sur le shield Grove de la carte. Nous utilisons dans l'image suivante un shield Grove sur une carte Seeduino Nano :

Le programme est le suivant : rfid_grove_1.ino.zip

/*
link between the computer and the SoftSerial Shield
at 9600 bps 8-N-1
Computer is connected to Hardware UART
SoftSerial Shield is connected to the Software UART:D2&D3
*/
#include <SoftwareSerial.h>
SoftwareSerial SoftSerial(2, 3);
unsigned char buffer[64]; // buffer array for data receive over serial port
int count = 0; // counter for buffer array
void setup()
{
SoftSerial.begin(9600); // the SoftSerial baud rate
Serial.begin(9600); // the Serial port of Arduino baud rate.
}
void loop()
{
// if date is coming from software serial port ==> data is coming from SoftSerial shield
if (SoftSerial.available())
{
while (SoftSerial.available()) // reading data into char array
{
buffer[count++] = SoftSerial.read(); // writing data into array
if (count == 64)break;
}
Serial.write(buffer, count); // if no data transmission ends, write buffer to hardware serial port
//afficheBuffer(buffer,count);
clearBufferArray(); // call clearBufferArray function to clear the stored data from the array
count = 0; // set counter of while loop to zero
}
if (Serial.available()) // if data is available on hardware serial port ==> data is coming from PC or notebook
SoftSerial.write(Serial.read()); // write it to the SoftSerial shield
}
void clearBufferArray() // function to clear buffer array
{
// clear all index of array with command NULL
for (int i = 0; i < count; i++)
{
buffer[i] = NULL;
}
}
void afficheBuffer(byte *buffer, byte count) {
Serial.println("");
Serial.println("Un badge est détecté");
Serial.println(" L'UID du tag est:");
for (byte i = 0; i < count; i++)
{
Serial.print(buffer[i], HEX);
Serial.print(" ");
}
Serial.println();
}

Module RFID - 13,56 MHz - RC522

Le module RFID-RC522 de Joy-it est une carte d'interface compatible Arduino et Raspberry Pi et est utilisée pour lire et écrire sur des cartes ou badges RFID de type Mifare.

La notice d'utilisation et de câblage de chez Gotronic est la suivante : rfid-rc522.

le tableau de câblage est le suivant :

MFRC522 Arduino Arduino Arduino Arduino Arduino
Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
Signal Pin Pin Pin Pin Pin Pin
-----------------------------------------------------------------------------------------
VCC 3,3V 3,3V
GND GND GND
RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
SPI SS NSS 10 53 D10 10 10
SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
IRC .. .. .. .. ..

Le câblage sur la carte Arduino est le suivant :

Pour pouvoir utiliser ce module, la bibliothèque “MFRC522” doit être installée. Ouvrez l’IDE Arduino et aller dans Croquis → Inclure une bibliothèque → Gérer les bibliothèques. Taper dans le moteur de recherche “MFRC522”. Installer la librairie.

Le programme de test de la carte, permettant de lire la valeur d'un tag RFID et de l'afficher dans la console est le suivant : test_rfid_rc522.zip

#include <SPI.h>
#include <MFRC522.h>
// Affectation des broches
#define RST_PIN 9
#define SS_PIN 10
MFRC522 mfrc522(SS_PIN, RST_PIN);
void setup() {
// Initialisation du Module RFID
Serial.begin(9600);
while (!Serial);
SPI.begin();
mfrc522.PCD_Init();
mfrc522.PCD_DumpVersionToSerial();
// Affichage des données de la bibliothèque
Serial.println(F("Scan PICC to see UID, type, and data blocks..."));
}
void loop() {// Attente d'une carte
RFIDif( ! mfrc522.PICC_IsNewCardPresent()) {
return;
}
// Récupération des informations de la carte RFID
if ( ! mfrc522.PICC_ReadCardSerial()) {
return;
}
// Affichagedes informations de la carte RFID
mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
}

Application : Création d'un lecteur MP3 par RFID

Voir l'article suivant : Lancer un lecteur MP3 grâce à des Tag RFID

Application : Contrôle d'accès par badge

Voir l'article suivant : Contrôler exactement le numéro d'un tag RFID

Capteur d'empreinte digitale

Voir le rapport de Thais Ravenel, DNMADE MODE2, 2021-2022

Microphone

Ce produit est proposé chez Adafruit : Adafruit AGC Electret Microphone Amplifier - MAX9814

Ce module d'amplificateur de microphone permet un contrôle automatique du gain intégré. Le contrôle automatique du gain (AGC) dans l'amplificateur signifie que les sons 'forts' à proximité seront atténués pour ne pas surcharger et 'saturer' l'amplificateur, et même les sons faibles et éloignés seront amplifiés.

Cet amplificateur est idéal lorsque vous souhaitez enregistrer ou détecter de l'audio dans un environnement où les niveaux changent et que vous ne voulez pas avoir à ajuster le gain de l'amplificateur en permanence.

La puce au cœur de cet amplificateur est le MAX981. Elle offre quelques options que vous pouvez configurer avec la carte de dérivation. Le 'gain maximal' par défaut est de 60 dB, mais peut être réglé à 40 dB ou 50 dB en reliant la broche de gain à la VCC ou à la terre.

Vous pouvez également changer le rapport d'attaque/libération, du rapport par défaut de 1:4000 à 1:2000 ou 1:500. La sortie de l'amplificateur est d'environ 2Vpp max sur un biais DC de 1,25V, ce qui permet de l'utiliser facilement avec n'importe quel convertisseur analogique/numérique acceptant une entrée jusqu'à 3,3V. Si vous souhaitez le connecter à une entrée de ligne, utilisez simplement un condensateur de blocage de 1uF en série.

Il est nécessaire de souder les connecteurs avant utilisation.Le processus d'assemblage et soudure est disponible sur ce lien : Assemblage et Soudures.

Après avoir branché la patte GND et VCC du Microphone au GND et VCC de la carte Arduino, Il faut brancher la sortie “Out” du Micro à l'entrée Analogique A0 de la carte Arduino : voir le lien suivant Câblage.

Le programme permettant de mesurer le volume sonore à partir du micro est disponible sur ce lien suivant : Mesure du volume sonore.

/****************************************
Example Sound Level Sketch for the
Adafruit Microphone Amplifier
****************************************/
const int sampleWindow = 50; // Sample window width in mS (50 mS = 20Hz)
unsigned int sample;
void setup()
{
Serial.begin(9600);
}
void loop()
{
unsigned long startMillis= millis(); // Start of sample window
unsigned int peakToPeak = 0; // peak-to-peak level
unsigned int signalMax = 0;
unsigned int signalMin = 1024;
// collect data for 50 mS
while (millis() - startMillis < sampleWindow)
{
sample = analogRead(0);
if (sample < 1024) // toss out spurious readings
{
if (sample > signalMax)
{
signalMax = sample; // save just the max levels
}
else if (sample < signalMin)
{
signalMin = sample; // save just the min levels
}
}
}
peakToPeak = signalMax - signalMin; // max - min = peak-peak amplitude
double volts = (peakToPeak * 5.0) / 1024; // convert to volts
Serial.println(volts);
}

Actionneurs

Chenillard à LED

Présentation

Pour réaliser des effets de lumière, il est intéressant de pouvoir réaliser un chenillard à LED. IL convient de contrôler chaque LED indépendamment via les sorties digitales de la carte Arduino Uno. Le nombre de LED est donc limité par le nombre de sorties digitales de D2 à D13 soit 12 sorties. Pour un nombre supérieur de LED, il faudra utiliser un système de LED à adressage.

Montage

Un montage à 3 LED est proposé. Dans le programme, la gestion des pins associées au LED est effectué via un tableau. Le montage sur la carte Arduino Uno est le suivant :

Le montage sur le système Grove est le suivant :

Il suffit de répéter autan de fois la connexion Grove que de LEDs souhaitées. Dans ce cas, le nombre de LED est limité par le nombre de connexion Grove : de D2 à D8, soit 7 sorties.

Programme

Le programme est le suivant :

// déclaration des variables globales
int led[ ] ={2, 3, 4} ;
// ici led[0] = 2, (on commence la numérotation à 0)
// led[1] = 3, …
void setup() {
for (byte i=0; i<3 ; i++){
pinMode(led[i],OUTPUT);
}
} // ici i est de type « byte » (codé sur 1 octet) car on ne compte que jusqu’à 6 donc il est inutile d’utiliser 2 octets (int)
void loop(){
for (byte i = 0; i<3; i++){
// allumer la LED i
digitalWrite(led[i], LOW);
// attendre 1 secondes
delay(1000);
// éteindre la LED i
digitalWrite(led[i], HIGH);
// la LED i+1 sera allumée en même temps que la LED i sera éteinte
}
}

Allumer aléatoirement une chaine de LED

Présentation

On dispose d'une douzaine (N=12) de LED branchées sur la carte Arduino. On cherche à faire allumer à des positions aléatoires K leds parmi les N.

Montage

Le montage à 10 LED est proposé est le suivant :

Programme

Le programme Arduino est le suivant : chaine_de_led_alumer_led_aleatoire_2.ino.zip

//variagles globales
// tableau de LED
byte NLed = 12;
byte* led = NULL;
// tableau de LED clignottante
byte NLedClignotte = 3;
byte* indicesLedClignotte = NULL;
int Ta = 100; // temps d'allumage de la LED sur D13 en ms
int Te = 100; // temps où la LED est éteinte sur D13 en ms
boolean debug = true;
void setup()
{ // réglage de la patte digitale N°13.
// création du tableau de led
led = malloc(NLed * sizeof(byte));
// initialisation de l'indice des LED
for (byte i = 0; i < NLed; i++) {
led[i] = i + 2;
}
// création du tableau de indicesLedClignotte
indicesLedClignotte = malloc(NLedClignotte * sizeof(byte));
// initialisation de l'indice des LED
for (byte i = 0; i < NLedClignotte; i++) {
indicesLedClignotte[i] = led[i];
}
// initialisation des pates de sortie
for (byte i = 0; i < NLed; i++) {
pinMode(led[i], OUTPUT); // ... sortie
}
if (debug) {
Serial.begin(9600);
Serial.println("setup");
Serial.println("indicesLedClignotte");
for (byte i = 0; i < NLedClignotte; i++) {
Serial.println(indicesLedClignotte[i]);
}
Serial.println();
Serial.println("led");
for (byte i = 0; i < NLed; i++) {
Serial.print(led[i]);
Serial.print(" ");
}
Serial.println();
}
}
void loop() {
// sélection d'un nombre aléatoire de led
selectioner_k_aleatoire_parmi_N();
//debug
if (debug) {
Serial.println("loop");
for (byte i = 0; i < NLedClignotte; i++) {
Serial.print(indicesLedClignotte[i]);
Serial.print(" ");
}
Serial.println();
}
// faire clignoter les led aléatoirement sélectionnées
faireClignoterNLed(Ta, Te, indicesLedClignotte);
}
void faireClignoterNLed(int Ta, int Te, byte* indiceLed) {
byte NLed = sizeof(indiceLed) / sizeof(byte);
for (byte i = 0 ; i < NLed ; i++) {
digitalWrite(led[indiceLed[i]], LOW); // alumer la led
delay(Ta); // patienter 500 millisecond(s)
// éteindre la LDE
digitalWrite(led[indiceLed[i]], HIGH); // éteindre la led
delay(Te); // patienter 100 millisecond(s)
}
}
void selectioner_k_aleatoire_parmi_N(void) { // sélectionner aléatoirement k indice aléatoirement dans un tableau d'indice
if (NLedClignotte <= NLed) {
Serial.println("dans la fonction");
for (byte i = 0; i < NLedClignotte; i++) {
byte indiceLed = floor(random(0, NLed));
indicesLedClignotte[i] = indiceLed;
// DEBUG
Serial.print(indiceLed);
Serial.print(" ");
}
Serial.println();// saut de ligne
}
else {
Serial.println("LedClignotte <= NLed");
}
}

Une autre version : chaine_de_led_alumer_led_aleatoire_3.zip

Références

https://www.tubefr.com/scintillement-jusqu-a-6-leds-avec-arduino_4.html

LED RGB

Une LED RGB permet d'émettre, non plus une seule couleur, mais un spectre plus large de longueur d'onde.

Un tutoriel très détaillé est proposé sur ce lien : Utiliser des LEDs RGB avec une carte Arduino / Genuino

LEDs adressables

Présentation

Ruban flexible à LED RGB d'un mètre équipé de 60 leds SK6812 (compatible avec WS2812B). Ces 60 leds sont raccordées en série et communiquent avec un microcontrôleur type Arduino ou compatible via une sortie série 1 broche.

Chaque LED possède un pilote intégré qui vous permet de contrôler la couleur et la luminosité indépendamment des autres Leds.

Matériel

Led Simples - Gotronic

Ruban RGB 50cm 72 leds adressables 2531

Ruban RGB 2m 60 leds adressables 2527

Ruban RGB 1m 60 leds adressables 2529

Plus de choix

Tutoriel

Arduino Passion

Ruban de LED

Présentation

...

Matériel

Gotronic

Tutoriel

...

Servomoteurs

présentation

Un servomoteur (souvent abrégé en « servo », provenant du latin servus qui signifie « esclave ») est un moteur capable de maintenir une opposition à un effort statique et dont la position est vérifiée en continu et corrigée en fonction de la mesure. C'est donc un système asservi. En d'autre termes, en envoyant au servomoteur une tension continue (la commande), on contrôle l'angle de rotation de l'axe du moteur fixée à une valeur donnée entre 0° et 180°.

Le servomoteur intègre dans un même boitier, la mécanique (moteur et engrenage), et l’électronique, pour la commande et l'asservissement du moteur. La position est définie avec une limite de débattement d’angle de 180 degrés, mais également disponible en rotation continue.

Pour plus d'information, voir : https://fr.wikipedia.org/wiki/Servomoteur.

De manière générale, tous les servomoteurs sont contrôlés grâce à la librairie “Servo.h” : https://www.arduino.cc/en/Reference/Servo .

On utilise ici un servomoteur analogique miniature FS0403.

Faire varier l'angle de façon automatique A/R entre 0° et 180° : "sweep"

présentation

Le montage le plus simple permet de faire varier l'angle du servomoteur de façon automatique dans un mouvement d'aller et retour entre 0° et 180°. L'exemple est accessible sur l'IDE d'Arduino dans les exemples en allant sur Servo>Sweep, ou directement sur : https://www.arduino.cc/en/tutorial/sweep.

Montage

Le montage est le suivant :

Programme

Le programme est la suivant :

/* Sweep
by BARRAGAN <http://barraganstudio.com>
This example code is in the public domain.
modified 8 Nov 2013
by Scott Fitzgerald
http://www.arduino.cc/en/Tutorial/Sweep
*/
#include <Servo.h>
Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards
int pos = 0; // variable to store the servo position
void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}
void loop() {
for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
// in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
}

Faire varier l'angle à l'aide d'un potentiomètre: "Knob"

présentation

Ce montage permet de faire varier l'angle d'un servomoteur à l'aide de la mesure d'une tension variable sur une patte analogique, générée à l'aide d'un potentiomètre. Par la suite, le potentiomètre peut être remplacé par un capteur quelconque (distance, température, flexion, battement cardiaque, etc.).

L'exemple est accessible sur l'IDE d'Arduino dans les exemples en allant sur Servo>Knob, ou directement sur : https://www.arduino.cc/en/tutorial/knob.

Montage

Le montage est le suivant :

Programme

Le programme est la suivant :

/*
Controlling a servo position using a potentiometer (variable resistor)
by Michal Rinott <http://people.interaction-ivrea.it/m.rinott>
modified on 8 Nov 2013
by Scott Fitzgerald
http://www.arduino.cc/en/Tutorial/Knob
*/
#include <Servo.h>
Servo myservo; // create servo object to control a servo
int potpin = 0; // analog pin used to connect the potentiometer
int val; // variable to read the value from the analog pin
void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}
void loop() {
val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023)
val = map(val, 0, 1023, 0, 180); // scale it to use it with the servo (value between 0 and 180)
myservo.write(val); // sets the servo position according to the scaled value
delay(15); // waits for the servo to get there
}

Moteur pas-à-pas - Step Motor

Le tutoriel sur les moteurs pas à pas est disponible sur le tutoriel suivant : UTILISER UN MOTEUR PAS À PAS.

Utiliser un transistor en interrupteur commandé

Il peut être intéressant d'utiliser des interupteurs commandés par la carte pour asservir les différents actionneurs. Les interupteurs commandés sont généralement des transistors utilisés en mode saturé. L'objectif n'est pas ici d'amplifier un signal (c'est une des utilisation possible d'un transistor), mais d'ouvrir ou de fermer un circuit par une commande de la carte Arduino.

Un tutoriel d'utilisation d'utilisation d'un transistor en interrupteur commandé est disponible sur le lien suivant : UTILISER UN TRANSISTOR EN INTERRUPTEUR COMMANDE

Module Son Grove - MP3 V3

Il est possible de brancher un module son MP3 sur la carte Arduino, en Grove. Le module son présenté ici est le Grove - MP3 V3 de chez Seeduino. Le module est le suivant :

Toute la documentation est accessible sur le lien suivant :

Documentation Grove - MP3 V3

ATTENTION : Le module n'est pas livré avec une carte SD. il est nécessaire d'en avoir une à disposition pour stoker les musiques qui doivent être jouées.

La procédure d'utilisation est la suivante :

Copier l'ensemble des fichiers son au format “mp3” à la racine de la carte sd

Télécharger la librairie réalisée par Seeduino depuis Github : Seeed_Serial_MP3. Arrivé sur la page, cliquer sur Code > Download Zip.

Installer la librairie précédemment téléchargée au format “Zip” en suivant la procédure suivante : How to install an Arduino library. Dans l'IDE d'Arduino, il faut cliquer sur le menu Croquis > Inclure une bibliothèque > Ajouter une bibliothèque au format .ZIP

Relancer l'IDE d'Arduino. Il est possible de tester les sons à l'aide d'un exemple de la librairie “WT2003S_Player.h” en suivant le chemin suivant sur l'IDE d'Arduino : Fichier → Examples → Seeed_Serial_MP3_Player → WT2003S_Terminal_Player.

Le code associé est le suivant :

wt2003s_terminal_player.zip

Il est possible aussi de télécharger une autre librairie développée par Sparkfun :

Documentation Arduino

SparkFun_WT2003S_MP3_Decoder_Arduino_Library

L'exemple suivant peur être utilisé aussi :

Example1_Terminal_MP3_Player

Imprimante thermique

Une imprimante thermique permet d'imprimer des tickets de caisse. Il en existe plusieurs modèles. Nous détaillons ici le modèle “csn-a2-t”.

Des tutoriels sont accessibles sur les liens suivants :

https://www.robotique.tech/tutoriel/controler-une-imprimante-thermique-avec-arduino/

https://wiki.dfrobot.com/Embedded%20Thermal%20Printer%20-%20TTL%20Serial%20SKU%3A%20DFR0503-EN

Montage

Code Arduino

/*------------------------------------------------------------------------
Example sketch for Adafruit Thermal Printer library for Arduino.
Demonstrates a few text styles & layouts, bitmap printing, etc.
IMPORTANT: DECLARATIONS DIFFER FROM PRIOR VERSIONS OF THIS LIBRARY.
This is to support newer & more board types, especially ones that don't
support SoftwareSerial (e.g. Arduino Due). You can pass any Stream
(e.g. Serial1) to the printer constructor. See notes below.
------------------------------------------------------------------------*/
#include "Adafruit_Thermal.h"
#include "adalogo.h"
#include "adaqrcode.h"
// Here's the new syntax when using SoftwareSerial (e.g. Arduino Uno) ----
// If using hardware serial instead, comment out or remove these lines:
#include "SoftwareSerial.h"
#define TX_PIN 6 // Arduino transmit YELLOW WIRE labeled RX on printer
#define RX_PIN 5 // Arduino receive GREEN WIRE labeled TX on printer
SoftwareSerial mySerial(RX_PIN, TX_PIN); // Declare SoftwareSerial obj first
Adafruit_Thermal printer(&mySerial); // Pass addr to printer constructor
// Then see setup() function regarding serial & printer begin() calls.
// Here's the syntax for hardware serial (e.g. Arduino Due) --------------
// Un-comment the following line if using hardware serial:
//Adafruit_Thermal printer(&Serial1); // Or Serial2, Serial3, etc.
// -----------------------------------------------------------------------
const int btnPin = A0; // le bouton est connecté à la broche A0 de la carte Adruino
int btnVal = 0;
void setup() {
pinMode(btnPin,INPUT_PULLUP);
// This line is for compatibility with the Adafruit IotP project pack,
// which uses pin 7 as a spare grounding point. You only need this if
// wired up the same way (w/3-pin header into pins 5/6/7):
pinMode(7, OUTPUT); digitalWrite(7, LOW);
// NOTE: SOME PRINTERS NEED 9600 BAUD instead of 19200, check test page.
mySerial.begin(19200); // Initialize SoftwareSerial
printer.begin(); // Init printer (same regardless of serial type)}
void loop() {
btnVal=analogRead(btnPin);
if(btnVal<200){ // On appuie sur le bouton poussoir
printer.println(F("Arduino")); // L'imprimante imprime le mot "Arduino"
}

Projets associés

Projet Open-Frac2 2018 : Bouquet final

Afficheur LCD Grove

Toute la procédure d'utilisation de l'afficheur “Grove - LCD RGB Backlight” est disponible sur le lien suivant :

https://wiki.seeedstudio.com/Grove-LCD_RGB_Backlight/

Buzzer Grove

Un buzzer Grove est un petit module permettant d'émettre du son. Attention, il ne s'agit pas d'un haut parleur. Pour jouer un son en mp3 il convient plutôt d'utiliser le module MP3 Grove décrit précédemment.

Toute la procédure d'utilisation est disponible sur le lien suivant :

https://wiki.seeedstudio.com/Grove-Buzzer/

Alimentation externe des différents éléments

Chargeur de téléphone et multiprise USB

La carte Arduino est capable de fournir un courant électrique d'intensité maximale de 100mA sous une tension de 5V. Par conséquent, la puissance maximale fournie par la carte est P=U*I = 5V*100mA = 0,5W.

Selon le nombre de capteurs et d'actionneurs qui sont branchés sur la carte, il se peut que cette dernière ne soit pas capable de fournir la puissance suffisante pour alimenter correctement tous les éléments. Il est alors intéressant d'utiliser une alimentation externe pour alimenter séparément ou conjointement les éléments (capteurs et actionneurs) et la carte Arduino.

Suivre le tutoriel suivant pour procéder à une alimentation en externe : UTILISER UNE ALIMENTATION EXTERNE

Ressources

capteur slide : https://www.gotronic.fr/art-potentiometre-a-glissiere-grove-101020036-19012.htm

capteur switch : https://www.gotronic.fr/art-module-interrupteur-grove-101020004-19013.htm

capteur de geste : https://www.gotronic.fr/art-capteur-de-gestes-grove-101020083-23831.htm

capteur de potentiomètre : https://www.gotronic.fr/art-module-potentiometre-grove-101020017-19061.htm

capteur bouton : https://www.gotronic.fr/art-module-bouton-grove-111020000-19010.htm

carte arduino Uno : https://www.gotronic.fr/art-carte-arduino-uno-12420.htm

carte Seeeduino (pas besoin d'un shield si vous achetez un seeeduino : voir pourquoi) : https://www.gotronic.fr/art-carte-seeeduino-lotus-102020001-21998.htm

grove shield : https://www.gotronic.fr/art-module-grove-base-shield-103030000-19068.htm