Formation Arduino
Samir EL OTEBY
Ingénieur et professeur agrégé de mécanique
e-mail : [email protected]
Chaînes d’énergie et d’information
2
De la mesurande au signal
3
First Step
La broche la plus longe de la LED
(Cathode, +) est liée à une sortie
Digital ou Analog de la carte Arduino.
La deuxième broche (Anode, -) est liée
à la masse de la carte à travers une
résistance 220 ohm pour limiter le
courant de ligne.
4
First Step
// C++ code
//
#define LED_BUILTIN 8
void setup()
{
pinMode(LED_BUILTIN, OUTPUT);
}
void loop()
{
digitalWrite(LED_BUILTIN, HIGH);
delay(1000); // Wait for 1000 millisecond(s)
digitalWrite(LED_BUILTIN, LOW);
delay(1000); // Wait for 1000 millisecond(s)
}
Simulation : Le code
Tinkercard
5
Capteur de température : TMP36
TMP3
6
Caractéristiques
Taille: boîtier TO-92 à 3 broches (similaire à
un transistor)
Gamme de température: -40°C a 150°C
Tension de sortie: 0.1V (-40°C) to 2.0V
(150°C)
Tension d’alimentation: 2.7V a 5.5V
6
Capteur de température : TMP36
int Reading;
float celsius;
void setup() {
pinMode(A0, INPUT);
Serial.begin(9600); // ouvre le port série
}
void loop() {
Reading = analogRead(A0) ;
float voltage = Reading * 5.0 / 1024;
celsius = (voltage – 0.5) * 100
Serial.println(celsius);
delay(1000); // attend une seconde
}
Le code
Le
montage
7
Capteur DHT11
Alimentation : 5V
Plage de mesure :
Température : 0°C à 50°C
Humidité : 20% à 90% RH
Précision :
Température : 2°C
Humidité : 5% RH
Sorties : S, Vcc, GND
Dimension : 23x17x9 mm
Capteur de
température
et d’humidité
8
Capteur DHT11
On câble le Vcc du capteur sur la
broche 5V de l’Arduino, la broche GND
du capteur sur la broche de la masse
de l’Arduino, la broche des données du
capteur sur une broche numérique de
l’Arduino
9
Capteur DHT11
10
Capteur DHT11
Résultat
Cod
e
11
Mesure de distance : HC-SR04
HC-
SR04
12
Mesure de distance : HC-SR04
Pour commencer :
Connecter la broche Vcc du capteur
à la broche 5V de la carte Arduino.
Câbler la broche GND avec la masse
de la carte.
Connecter le broche Trig du capteur
à une broche numérique d’Arduino.
Connecter la broche Echo du capteur
à une autre broche numérique de la
carte.
Le
montage
13
Mesure de distance : HC-SR04
// defines pins numbers
const int trigPin = 12;
const int echoPin = 11; // defines variables
long duration;
int distance;
void setup()
{
pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
pinMode(echoPin, INPUT); // Sets the echoPin as an Input
Serial.begin(9600); // Starts the serial communication
}
void loop()
{
// Clears the trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
Le
digitalWrite(trigPin, LOW); résultat
duration = pulseIn(echoPin, HIGH); // Calculating the traveling
duration in microseconds
distance = duration * 0.034 / 2; // Calculating the distance in cm
Serial.print("Distance (cm): ");
Serial.println(distance); }
Le
code
14
Commander un actionneur : MCC
Méthodologie d’inversion de sens de rotation :
Pont en H
Câblag
τ
e U moy =
T
U max ⇒ Ω =f ( α , U max )
15
Commander un actionneur : MCC
//Ports de commande du moteur B void loop() {
int motorPin1 = 8; if (Serial.available() > 0){
int motorPin2 = 9; state = Serial.parseInt();
int enablePin = 5; if (state > 0) // avant
{
// Vitesse du moteur digitalWrite(motorPin1, HIGH);
int state = 0; digitalWrite(motorPin2, LOW);
Serial.print("Avant ");
void setup() Serial.println(state);
}
{ else if (state < 0)
// Configuration des ports en mode "sortie" {
pinMode(motorPin1, OUTPUT); digitalWrite(motorPin1, LOW);
pinMode(motorPin2, OUTPUT); digitalWrite(motorPin2, HIGH);
pinMode(enablePin, OUTPUT); Serial.print("Arriere ");
Serial.println(state);
// Initialisation du port série }
Serial.begin(9600); else // Stop (freinage)
} {
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, HIGH);
Serial.println("Stop");
}
// Vitesse du mouvement
analogWrite(enablePin, abs(state));
}
delay(100);}
Cod
e
16
Commander un actionneur : MCC
v
17
Commander un actionneur : MCC
int MA = 8, MB = 9; // Initialisation des pins (MA etMB)
int enablePin = 5;
const float Pas = 255/3;
void setup()
{
Serial.begin(9600);
pinMode(MA, OUTPUT);
pinMode(MB, OUTPUT);
}
void loop()
{
for(int PWM = 0; PWM <=255; PWM = PWM + Pas){
digitalWrite(MA, HIGH);
digitalWrite(MB, LOW);
analogWrite(enablePin, PWM);
delay(1000);
}
delay(5000);
for(int PWM = 255; PWM >= 0; PWM = PWM - Pas){
digitalWrite(MA, HIGH);
digitalWrite(MB, LOW);
analogWrite(enablePin, PWM);
delay(1000);
}
delay(1000);
}
18
Commander un actionneur : ServoMoteur
Caractéristi
ques
Alimentation : 4.5 Và6V
Couple : 1.2 kg/cm sous 4.5 V – 1.4 kg/cm
sous 6 V
Vitesse : 0.10 sec/60° sous 4.5 V – 0.12
sec/60° sous 6 V
Rotation : 180° Câblag
e et la broche GND à
On relie la broche 5V
une alimentation externe, même que celle
de la carte.
On relie la broche Signal à un pin Digital
ServoMot de la carte.
eur
19
Commander un actionneur : ServoMoteur
// C++ Code
#include <Servo.h> // importation de la
librairie
Servo monServo; // Création de l’objet
monServo
void setup()
{
monServo.attach(10); // Définition de pin
de contrôle
monServo.write(0); // Remise à zero du
Servo
}
void loop()
{
monServo.write(90); // Servo à 90°
delay(1000);
monServo.write(0); // Servo à 0°
Simulation : delay(1000); Cod
}
Tinkercard e
20
Commander un actionneur : ServoMoteur
int MA = 10, MB = 11; // Initialisation des pins (MA et MB)
int enablePin = 5;
const byte pinPotVitesse = A0;
const int minPotVitesse = 0;
const int maxPotVitesse = 255;
void setup()
{
Serial.begin(9600);
pinMode(MA, OUTPUT);
pinMode(MB, OUTPUT);
pinMode(pinPotVitesse, INPUT);
}
void loop()
{
int vitesseMoteur = map(analogRead(pinPotVitesse),
minPotVitesse, maxPotVitesse, 0, 255);
digitalWrite(MA, HIGH);
digitalWrite(MB, LOW);
analogWrite(enablePin, vitesseMoteur);
Simulation : Cod
Tinkercard e
21
Commander un actionneur : ServoMoteur
// C++ code
#include <Servo.h> // importation de la
librairie
Servo monServo; // Création de l’objet
monServo
void setup()
{
monServo.attach(10); // Définition de pin
de contrôle
monServo.write(0); // Remise à zero du
Servo
}
void loop() {
for(int position = 0; position <= 180;
position ++){
monServo.write(position); // Servo à
position
delay(20);
Simulation : } Cod
Tinkercard e position >= 0;
for(int position = 180;
position --){
monServo.write(position); // Servo à
position
22
Commander un actionneur : Stepper Nema 17
23
Commander un actionneur : Stepper Nema 17
Montage
Les broches de l’A4988 :
VMOT / GND : Alimentation du 2B/2A/1A/1B : Les broches du connexion STEP : Broche de contrôle des
moteur. avec le moteur. steps
VDD/ GND : Alimentation du MS1/MS2/MS3 : Microstep pins (full, Half, Quarter, DIR : Broche de contrôle de
moteur. Eighth, Sixteenth).
direction .
24
Commander un actionneur : ServoMoteur
// Define pin connections & motor's steps per revolution void loop()
const int dirPin = 2; {
const int stepPin = 3; digitalWrite(dirPin, HIGH);
const int stepsPerRevolution = 200;
// Spin motor slowly
void setup() for(int x = 0; x < stepsPerRevolution; x++)
{ {
pinMode(stepPin, OUTPUT); digitalWrite(stepPin, HIGH);
pinMode(dirPin, OUTPUT); delayMicroseconds(2000);
} digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
delay(1000); // Wait a second
// Set motor direction counterclockwise
digitalWrite(dirPin, LOW);
// Spin motor quickly
for(int x = 0; x < stepsPerRevolution; x++)
{
digitalWrite(stepPin, HIGH);
delayMicroseconds(1000);
digitalWrite(stepPin, LOW);
delayMicroseconds(1000);
}
delay(1000); // Wait a second
}
25
Asservissement en position MCC
Composante
1)Potentiomètre
2)Différenciateur
3)Dispositif de
commande (Arduino +
Hacheur)
4)Moteur à courant
continu
5)Codeur incrémental.
26
Asservissement en position MCC
Les signaux de sortie de
l’encodeur
27
Asservissement en position MCC
La correction adoptée :
PID
1)Proportionnel :
U ( t )= K e ( t )
p p
2)Dérivateur :
U ( t )=K
de ( t )
d d
dt
3)Intégrateur : ∫ e ( t ) dt
U ( t )=K
I i
4)
La tension
d’alimentation
U ( t )=U : ( t ) +U ( t ) +U
p d I (t)
28
Asservissement en position MCC
// Déclaration des pins de l’encodeur void setup() {
#define ENCBA 9 Serial.begin(9600);
#define ENCBB 10
// Définition des pins de direction et de vitesse
// Déclaration des pins Dir et PWM du Driver pinMode(dirB_1, OUTPUT);
int dirB_1 = 2; pinMode(dirB_2, OUTPUT);
int dirB_2 = 3; pinMode(pwmB, OUTPUT);
int pwmB = 5;
// Définition des pins de lecture de l’encodeur
// Déclaration des variables pinMode(ENCBA, INPUT);
int posB = 0; pinMode(ENCBB, INPUT);
long prevT = 0;
float target_compteur; // Définition de l’interruption.
float target_en_cm; attachInterrupt(digitalPinToInterrupt(ENCBA), readEncoderB,
const float Pi = 3.14159; RISING);
int Compteur = 0; attachInterrupt(digitalPinToInterrupt(ENCBB), readEncoderB,
float eprevB = 0; RISING);
float eintegralB = 0; }
float kpB = 10;
float kiB = 0.05;
float kdB = 0.05;
29
Asservissement en position MCC
void loop() { setMotorB(directionvalB, pwrB);
// Lecture de la consigne eprevB = eB;
if(Serial.available()){ prevT = currT;
target_en_cm = Serial.parseFloat(); float Position_en_cm = posB*Pi*10/(24*98.7779);
float nombre_de_tour = target_en_cm/(Pi*10); Serial.print(target_en_cm);
float nombre_de_tour_moteur = nombre_de_tour*98.7779; Serial.print(" ");
targetB = nombre_de_tour_moteur*24; Serial.println(posB);
} void setMotorB(int cmd, int pwmval){
}
if (cmd > 0) {
void readEncoderB(){
// Calcul de l’erreur, sa dérivée et son integral. digitalWrite(dirB_1, HIGH);
int b1 = digitalRead(ENCBA);
long currT = micros(); digitalWrite(dirB_2, LOW);
int b2 = digitalRead(ENCBB);
float deltaT = ((float)(currT - prevT))/1.0e6; }
if(b1 == 0 & b2 == 1){
int eB = posB - targetB; else {
posB++;
float dedtB = (eB-eprevB)/(deltaT); digitalWrite(dirB_1, LOW);
}
eintegralB = eintegralB + eB*deltaT; digitalWrite(dirB_2, HIGH);
if(b1 == 1 & b2 == 0){
float uB = kpB*eB + kdB*dedtB + kiB*eintegralB; }
posB--;
float pwrB = fabs(uB); analogWrite(pwmB,abs(pwmval));}
}
if(pwrB>255){ }
pwrB = 255;
}
// Commande du moteur
int directionvalB = 1;
if(uB<0){
directionvalB = -1;
}
30
Merci !
31
