TONER KEBAB WIKI

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== 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 :

{{ :wiki:tutoriels:arduino-capteurs:shield_groove_arduino_uno.png?400 |}}
ou encore d'un seeeduino :

{{ :wiki:tutoriels:arduino-capteurs:seeeduino.png?400 |}}

===== 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 [[https://fr.wikipedia.org/wiki/R%C3%A9sistance_(%C3%A9lectricit%C3%A9)|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 :

<code>
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 Ω.
</code>

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 :

  * [[https://www.dcode.fr/code-couleur-resistance|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:

{{ :wiki:tutoriels:arduino-capteurs:principe_echographie.png?400 |}}

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 :

{{ :wiki:tutoriels:arduino-capteurs:capteur_distance_ultrason_grove.png?300 |}}

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:

{{ :wiki:tutoriels:arduino-capteurs:capteur_dist_ultrason_arduino_connection_grove.jpg?400 |}}

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 :
<code>
#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);
}

</code>

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 :
  * [[wiki:tutoriels:arduino:evoyer_float_via_port_serie|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 :

{{ :wiki:tutoriels:arduino-capteurs:pulsesensorampedfinger.png?300 |}}

Il renvoie un signal du type :
{{ :wiki:tutoriels:arduino-capteurs:gettingstarted_serialplotter_grande.png?400 |}}



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) ===

{{ :wiki:tutoriels:arduino-capteurs:3axisaccelerometer16g_02.jpg?200 |}}
{{ :wiki:tutoriels:arduino-capteurs:okwy4jsso0pn3moqgzdvsgbh.jpg?200 |}}

le capteur Grove 3-Axix Digital Accelerometer(±16g) est disponible chez seeed.com. La documentation associée est disponible sur ce lien : [[http://wiki.seeedstudio.com/Grove-3-Axis_Digital_Accelerometer-16g/|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 :

{{ :wiki:tutoriels:arduino-capteurs:grove_-_3-axis_digital_accelerometer_adxl345_connect_photo.jpg?400 |}}

{{ :wiki:tutoriels:arduino-capteurs:grove_-_3-axis_digital_accelerometer_adxl345_connect_photo_seeduino.jpg?400 |}}

=== 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** :

{{ :wiki:tutoriels:arduino-capteurs:gestion_bibliotheque.jpg?400 |}}

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**" :

{{ :wiki:tutoriels:arduino-capteurs:procedure_install_librairie.png?600 |}}

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 : [[http://wiki.seeedstudio.com/How_to_install_Arduino_Library/|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" :

{{ :wiki:tutoriels:arduino-capteurs:exemple_code.jpg?400 |}}

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

<code>
#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);
 
}
</code>

=== 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 :

<code>
Σ(F→) = m * (a→)
</code>
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é :
<code>
a = √(ax²+ay²+az²)
</code>

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 :

{{ :wiki:tutoriels:arduino-capteurs:donnees_accelerometre.jpg?800 |}}

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 :
<code>
 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
</code> 

__**Programme**__

Le code Arduino est le suivant : 

  * {{ :wiki:tutoriels:arduino-capteurs: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 [[https://www.scilab.org/|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  [[https://www.arduino.cc/reference/en/language/functions/communication/serial/println/|Serial.println()]] envoie des paquet d'un seul octet à la fois alors qu'une variable de type //[[https://www.arduino.cc/reference/en/language/variables/data-types/float/|float]]//  et qu'une variable de type //[[https://www.arduino.cc/reference/en/language/variables/data-types/double/|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 //[[https://www.arduino.cc/reference/en/language/variables/data-types/stringobject/|float()]]//,
  * et on envoie cette chaine de caractère sur le port série via la fonction //Serial.println()//.

Le code est le suivant : {{ :wiki:tutoriels:arduino-capteurs: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 //[[https://processing.org/reference/libraries/serial/Serial_readStringUntil_.html|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 //[[https://www.processing.org/reference/floatconvert_.html|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 : {{ :wiki:tutoriels:arduino-capteurs:lecture_enregistrement_donnees_string_direct_3.zip |}}


----

==== Capteur de geste  ====

{{ :wiki:tutoriels:arduino-capteurs:capteur_de_geste.png?200 |}}

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 :

<code>
#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);
}

</code>

----
==== Potentiomètre  ====

{{ :wiki:tutoriels:arduino-capteurs:potentimetre_grove.png?200 |}}

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 !

<code>
// 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);
    }
  }
}    
</code>


----

==== Slider  ====
{{ :wiki:tutoriels:arduino-capteurs:sliding1.jpg?200 |}}
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 !

<code>
// 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);
      }
    }
}
</code>

----

==== Switch  ====

{{ :wiki:tutoriels:arduino-capteurs:switch_p.jpg?300 |}}

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.

<code>
// 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");
    }
  }
}
</code>

----



==== Bouton poussoir  ====

{{ :wiki:tutoriels:arduino-capteurs:bouton-poussoir-grove.jpg?200 |}}

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 !

<code>
// 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");
    }
  }  
}
</code>

----

==== Module Bluetooth ====

{{ :wiki:tutoriels:arduino:twigbt00.jpg?200 |}}

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

Voir [[wiki:tutoriels:arduino:module-bleutooth|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 ===
  * [[https://www.gotronic.fr/art-capteur-de-flexion-74-mm-fs2l055-30852.htm|Gotronic]]


=== Fabriquer un Flexomètre - DIY ===
[[https://www.instructables.com/Arduino-Make-a-Flex-Sensor-for-Robotic-Hand-Cheap-/|Tutoriel Instructable]]

=== Exemples d'utilisation ===
  * [[https://soa.ensad.fr/flexomatrix/| Studio Objet Augmenté de l'École nationale supérieure des Arts Décoratifs : Flexomatrix]]


=== Fabriquer un Flexomètre - DIY ===
[[https://www.instructables.com/Arduino-Make-a-Flex-Sensor-for-Robotic-Hand-Cheap-/|Tutoriel Instructable]]

=== Exemples d'utilisation ===
  * [[https://soa.ensad.fr/flexomatrix/| 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.

{{ :wiki:tutoriels:arduino-capteurs:light_sensor.jpg?200 |}}

== Matériel ==
  * [[https://www.gotronic.fr/art-detecteur-de-lumiere-grove-v1-1-101020173-25114.htm|Gotronic]]

== Fiche technique ==
[[https://wiki.seeedstudio.com/Grove-Light_Sensor/| 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.

{{ :wiki:tutoriels:arduino-capteurs:photoresistance.jpg?200 |}}

== Matériel ==
  * [[https://www.gotronic.fr/art-photoresistance-ldr04-2150.htm|Gotronic]]

== Fiche technique ==
[[https://arduinogetstarted.com/tutorials/arduino-light-sensor| 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.

{{ :wiki:tutoriels:arduino-capteurs:ctn_grove.jpg?200 |}}
{{ :wiki:tutoriels:arduino-capteurs:ctn-10k.jpg?200 |}}


=== Matériel ===
  * [[https://www.gotronic.fr/art-capteur-de-temperature-grove-101020015-18965.htm|Gotronic]] 

=== Fiche technique ===
  * Grove : https://wiki.seeedstudio.com/Grove-Temperature_Sensor_V1.2/
  * Dipôle : [[https://cloud-esdm.yourownnet.fr/s/j5t394FmfrT3xWa|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 :

  * [[https://www.arduino.cc/reference/en/libraries/capacitivesensor/| Librairie CapacitiveSensor]]
  * [[https://playground.arduino.cc/Main/CapacitiveSensor/|Documentation de la librairie CapacitiveSensor]]

Un exemple très simple est proposé sur le site [[https://programminginarduino.wordpress.com/|Programminginarduino]] :
  * [[https://programminginarduino.wordpress.com/2016/03/06/project-14/|Touchy-feely Lamp]]

Montage :
{{ :wiki:tutoriels:arduino-capteurs:touchy-feely-lamp-disec3b1o-de-protoboard.jpg?400 |}}

Programme :

<code>


//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);
}


</code>

=== 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 [[https://playground.arduino.cc/Main/CapacitiveSensor/|documentation Arduino sur les capteurs capacitifs internes à la carte Arduino]]. La librairie correspondante est téléchargeable sur le lien suivant : [[https://github.com/PaulStoffregen/CapacitiveSensor||CapacitiveSensor Library]].

Le montage comprenant 3 capteurs capacitifs est le suivant :
{{ :wiki:tutoriels:arduino-capteurs:montage_capacitif_1_bb.png?800 |}}

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

<code>
#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
}
</code>

===Quelques applications ===
  * Plantes qui parlent : [[wiki:flossmanuals:boitier-interactif-bis:accueil|Justine Gendreau]] 
  * simuler un clavier : 
    * Tutoriel vidéo : [[https://www.youtube.com/watch?v=YqjHdt6SvzA&ab_channel=Abr%C3%A8ge|Transformer n'importe quoi en clavier grâce à l'Arduino]]
    * [[https://github.com/boilingbrains/ClavierCapacitif|Fichiers Github]]
    * [[https://www.arduino.cc/reference/en/language/functions/usb/keyboard/|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 : [[https://fr.wikipedia.org/wiki/UART|Uart]] et  [[https://www.networkingsmith.com/learning-about-rfid-and-wiegand/|Wiegand]], [[http://www.yoctopuce.com/FR/article/interfacer-un-lecteur-rfid-wiegand-par-usb|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. 

{{ :wiki:tutoriels:arduino-capteurs:grove-125khz_rfid_reader.jpg?400 |}}

**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 : [[https://www.gotronic.fr/art-5-badges-rfid-125-khz-19040.htm|Badges RFID 125 kHz]]).

La documentation Seeeduino est la suivante : [[https://wiki.seeedstudio.com/Grove-125KHz_RFID_Reader/|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 [[https://www.gotronic.fr/art-shield-grove-103100124-30913.htm|shield Grove]] sur une carte [[https://www.gotronic.fr/art-carte-seeeduino-nano-102010268-30912.htm|Seeduino Nano]] :
{{ :wiki:tutoriels:arduino-capteurs:montage_rfid125khz_grov_1.jpg?400 |}}

Le programme est le suivant : {{ :wiki:tutoriels:arduino-capteurs:rfid_grove_1.ino.zip |}}

<code>
/*
  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();

}
</code>

=== Module RFID - 13,56 MHz - RC522 ===

Le [[https://www.gotronic.fr/art-module-rfid-13-56-mhz-tag-rc522-25651.htm|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.

{{ :wiki:tutoriels:arduino-capteurs:rfid-rc522.png?200 |}}

La notice d'utilisation et de câblage de chez Gotronic est la suivante : [[https://www.gotronic.fr/pj2-sbc-rfid-rc522-fr-2342.pdf|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 :

{{ :wiki:tutoriels:arduino-capteurs:cablage_rfid-rc522.png?600 |}}

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.
{{ :wiki:tutoriels:arduino-capteurs:librairie_rfid-rc522.png?600 |}}
{{ :wiki:tutoriels:arduino-capteurs:librairie_rfid-rc522_1.png?600 |}}

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 : {{ :wiki:tutoriels:arduino-capteurs:test_rfid_rc522.zip |}}

<code>
#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));
}
</code>

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

Voir l'article suivant : [[wiki:flossmanuals:rfid-lecteur-mp3:accueil|Lancer un lecteur MP3 grâce à des Tag RFID]]

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

Voir l'article suivant : [[ https://www.electronique-mixte.fr/microcontrolleurs/rfid-controle-dacces-par-badge-avec-arduino/| Contrôler exactement le numéro d'un tag RFID]]

==== Capteur d'empreinte digitale ====

{{ :wiki:tutoriels:arduino-capteurs:capteur_empreinte_digitale_418z72dadil._ac_.jpg?200 |}}

Voir le [[https://cloud-esdm.yourownnet.fr/s/pPDWpea9Hno4CKe|rapport de Thais Ravenel, DNMADE MODE2, 2021-2022]]

----
----
===== 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 :
{{ :wiki:tutoriels:arduino-capteurs:chenillard_led.png?600 |}}

Le montage sur le système Grove est le suivant :
{{ :wiki:tutoriels:arduino-capteurs:chenillard_led_grove.png?600 |}}

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 :

<code>
// 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
 }
}
</code>

==== 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 :
{{ :wiki:tutoriels:arduino-capteurs:montage10led.png?700 |}}

=== Programme ===
Le programme Arduino est le suivant : {{ :wiki:tutoriels:arduino-capteurs:chaine_de_led_alumer_led_aleatoire_2.ino.zip |}}
<code>
//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");
  }

}
</code>

Une autre version : {{ :wiki:tutoriels:arduino-capteurs: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.


{{ :wiki:tutoriels:arduino-capteurs:led_rgb.jpg?400 |}}

{{ :wiki:tutoriels:arduino-capteurs:pinout_led_rgb.jpg?400 |}}

Un tutoriel très détaillé est proposé sur ce lien : [[https://www.carnetdumaker.net/articles/utiliser-des-leds-rgb-avec-une-carte-arduino-genuino/|Utiliser des LEDs RGB avec une carte Arduino / Genuino]]
==== LEDs adressables ====
=== Présentation ===

{{ :wiki:tutoriels:arduino-capteurs:leds_adressables.jpg?400 |}}

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 ===
  * [[https://www.gotronic.fr/art-10-leds-rgb-cms-neopixel-nano-ada3484-32215.htm | Led Simples - Gotronic]]
  * [[https://www.gotronic.fr/art-ruban-rgb-50cm-72-leds-adressables-2531-31154.htm | Ruban RGB 50cm 72 leds adressables 2531]]
  * [[https://www.gotronic.fr/art-ruban-rgb-2m-60-leds-adressables-2527-31153.htm | Ruban RGB 2m 60 leds adressables 2527]]
  * [[https://www.gotronic.fr/art-ruban-rgb-1m-60-leds-adressables-2529-31152.htm | Ruban RGB 1m 60 leds adressables 2529]]
  * [[https://www.gotronic.fr/rechercherAntidot.php|Plus de choix]]

=== Tutoriel ===
  * [[https://pecquery.wixsite.com/arduino-passion/la-led-adressable|Arduino Passion]]

----

==== Ruban de LED ====
=== Présentation ===
...
=== Matériel ===
  * [[https://www.gotronic.fr/art-ruban-a-leds-blanches-flex5v-bc-32632.htm | 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°.

{{ :wiki:tutoriels:arduino-capteurs:servomoteur_analogique_miniature_fs90.png?200 |}}

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 [[https://www.gotronic.fr/art-servomoteur-analogique-miniature-fs0403-25825.htm|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 :

{{ :wiki:tutoriels:arduino-capteurs:sweep_bb.png?500 |}}

== Programme ==
Le programme est la suivant :

<code>
/* 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
  }
}


</code>

=== 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 :

{{ :wiki:tutoriels:arduino-capteurs:servo_potentiometre.png?500 |}}

== Programme ==
Le programme est la suivant :

<code>
/*
 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
}


</code>

----

==== Moteur pas-à-pas - Step Motor ====

{{ :wiki:tutoriels:arduino-capteurs:28byj-48-pinout-wirings.png?400 |}}

Le tutoriel sur les moteurs pas à pas est disponible sur le tutoriel suivant : [[wiki:tutoriels:arduino:moteur-pas-a-pas|UTILISER UN MOTEUR PAS À PAS]].

----
==== Utiliser un transistor en interrupteur commandé ====

{{ :wiki:tutoriels:arduino-capteurs:transistor.jpg?400 |}}

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 : [[wiki:tutoriels:arduino:utiliser_un_interrupteur_commande_transistors|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 :

{{ :wiki:tutoriels:arduino-capteurs:grove-mp3-v3.png?400 |}}

Toute la documentation est accessible sur le lien suivant :
  * [[https://wiki.seeedstudio.com/Grove-MP3-v3/ | 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.

{{ :wiki:tutoriels:arduino-capteurs:seeed-107020069-30164995-02.jpg?400 |}}

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 : [[https://github.com/Seeed-Studio/Seeed_Serial_MP3_Player|Seeed_Serial_MP3]]. Arrivé sur la page, cliquer sur Code > Download Zip. {{ :wiki:tutoriels:arduino-capteurs:selectionner_librairie_github.png?400 |}}
  - Installer la librairie précédemment téléchargée au format "Zip" en suivant la procédure suivante : [[https://wiki.seeedstudio.com/How_to_install_Arduino_Library/|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 {{ :wiki:tutoriels:arduino-capteurs:inclure_librairie_format_zip.png?600 |}}
  - 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. {{ :wiki:tutoriels:arduino-capteurs:exemple_librairie_seeeduino_wt2003s_player.png?600 |}}

Le code associé est le suivant :
  * {{ :wiki:tutoriels:arduino-capteurs:wt2003s_terminal_player.zip |}}

Il est possible aussi de télécharger une autre librairie développée par **Sparkfun** :
  * [[https://www.arduino.cc/reference/en/libraries/sparkfun-wt2003s-mp3-decoder-library/|Documentation Arduino]]
  * [[https://github.com/sparkfun/SparkFun_WT2003S_MP3_Decoder_Arduino_Library#readme|SparkFun_WT2003S_MP3_Decoder_Arduino_Library]]

L'exemple suivant peur être utilisé aussi : 
  * [[https://github.com/sparkfun/SparkFun_WT2003S_MP3_Decoder_Arduino_Library/blob/master/examples/Example1_Terminal_MP3_Player/Example1_Terminal_MP3_Player.ino|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".

{{ :wiki:tutoriels:arduino-capteurs:imprimante_thermique.png?400 |}}

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===
{{ :wiki:tutoriels:arduino-capteurs:arduino-thermalprinter.png?600 |}}
=== Code Arduino ===

<code>
/*------------------------------------------------------------------------
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"
}
</code>


=== Projets associés ===

Projet Open-Frac2 2018 : [[wiki:projets:open-frac-2:affiche_tactile|Bouquet final]]


----

==== Afficheur LCD Grove ====

{{ :wiki:tutoriels:arduino-capteurs:afficheur_lcd.jpg?400 |}}

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 ====

{{ :wiki:tutoriels:arduino-capteurs:buzzer_grove.png?300 |}}

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 [[wiki:tutoriels:arduino-capteurs:arduino-capteurs#module_son_grove_-_mp3_v3|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 =====

{{ :wiki:tutoriels:arduino:img_20201111_174732.jpg?400 |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 : [[wiki:tutoriels:arduino:utiliser_une_alimentation_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 : [[wiki:tutoriels:arduino:arduino_systeme_grove|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
TONER KEBAB WIKI

Outils pour utilisateurs

Outils du site

Outils de la page
