SYSTEMES EMBARQUES

Définition: Un système embarqué est une machine ou

appareil électronique équipé d'un microprocesseur.
La plupart des appareils électroniques grand public d'aujourd'hui
contiennent des systèmes embarqués, tels que lecteurs audio, appareils
photo numériques, téléphones portables, consoles de jeux et les
téléviseurs. Les systèmes embarqués sont également utilisés pour des
applications industrielles et professionnelles, comme dans les voitures, les
avions et l'équipement de l'usine.
Contrairement à un PC, l'interface IHM  (Interface Homme machine)  d'un
système embarqué peut être aussi simple qu'une diode
électroluminescente LED( Light Emitter Diode)  qui clignote ou aussi
complexe qu'un système de vision de nuit en temps réel; les afficheurs à
cristaux liquides LCD (Liquid Crystal Display) de structure généralement
simple sont couramment utilisés.
 SYSTEMES EMBARQUES
Les domaines dans lesquels on trouve des systèmes embarqués sont
de plus en plus nombreux :
transport : Automobile, Aéronautique (avionique), etc.
astronautique : fusée, satellite artificiel, sonde spatiale, etc.
militaire : missile
Machines à café, télévision
télécommunication : téléphonie, routeur, pare-feu, serveur de
temps,téléphone portable, etc.
électroménager : télévision, four à micro-ondes
impression : imprimante multifonctions, photocopieur, etc.
informatique : disque dur, Lecteur de disquette, etc.
multimédia : console de jeux vidéo, assistant personnel
guichet automatique bancaire (GAB)
équipement médical
automate programmable industriel
 SYSTEMES EMBARQUES

Autre exemple:
Le système de contrôle des gouvernes de l'Airbus A320 est un
système embarqué dont les exigences sont :
le système doit traduire en ordres de déflection des gouvernes les
ordres de pilotage venant du pilote ou de pilote automatique
(facteur de charge)
Le système doit maintenir l'avion dans son domaine de vol quelles
que soient les commandes du pilote ou du pilote automatique
Compte tenu de la dynamique de l'avion, les ailerons et la
gouverne de direction doivent être asservis à une période
minimale de 10ms
la gouverne de profondeur doit être asservie à une période
minimale de 30ms
La perte de contrôle de la profondeur est catastrophique (taux de
panne de 10-9)
La perte de contrôle des spoilers, des ailerons, de la direction et de
la profondeur ne doit pas être causée par une panne unique
SYSTEMES EMBARQUES
 SYSTEMES EMBARQUES

Architecture générale:
 La carte Arduino

Un module Arduino est généralement construit

autour d’un microcontrôleur ATMEL AVR
(Atmega328 ou Atmega2560 pour les versions
récentes)
La carte
Arduino uno
 Le s principales broches de l’Arduino uno
 Digital pins:
o Pins 0 – 7: (PORT D [0:7])
pin0 et pin1(RX et TX):pour communication série
o Pins 8 – 13: (PORT B [0:5])
La broche 13 (PB5)est connectée à une LED
 Analog pins:
Pins 14 – 19: (PORT C [0:5] )
 Caractéristiques de la carte Arduino uno
 Micro contrôleur : ATmega328
 Tension d'alimentation interne = 5V
 tension d'alimentation (recommandée)= 7 à 12V
 Entrées/sorties numériques : 14 dont 6 sorties PWM
 Entrées analogiques = 6
 Courant max par broches E/S = 40 mA
 Courant max sur sortie 3,3V = 50mA
 Mémoire Flash 32 KB
 Mémoire SRAM 2 KB
 mémoire EEPROM 1 KB
 Fréquence horloge = 16 MHz
 Dimensions = 68.6mm x 53.3mm
La carte s'interface au PC par l'intermédiaire de sa prise USB.
 Pourquoi l’Arduino?
 Pas cher
 Multiplateforme
 Logiciel + matériel open source
 Nombreux exemples en ligne
 librairies permettant de réduire considérablement
le temps développement des systèmes.
 Existence de "shield " (cartes supplémentaires qui se
connectent sur le module)
 La complexité de l’assemblage de fonctions électroniques
et informatique est réduite. Cette simplification permet à
tout un public n’ayant pas les compétences en électronique
et informatique de créer et innover.
 langage Arduino

Très proche du C et du C++

Logiciel
L'environnement de programmation Arduino (IDE)
est une application écrite en Java inspirée du
langage Processing.
L'IDE permet d'écrire, de modifier un programme et
de le convertir en une série d'instructions
compréhensibles pour la carte.
 Le code minimal

le programme est divisé en 2 grosses parties:

void setup () // fonction d’initialisation de la carte

{
…………… // contenu de l’initialisation
}
//*************************************
void loop () // fonction ppale qui s’exécute à l’infini
{
…………… // contenu de votre programme
}
Choix de la carte
Choix de la carte
 Exemple1: clignotement d’une LED

Les étapes à suivre:

Première étape:
définir la broche utilisée du microcontrôleur:
 créer une variable définissant la broche
utilisée;
 définir si cette broche doit être une entrée du
microcontrôleur ou une sortie;
pinMode (nom variable, OUTPUT or INPUT )
Deuxième étape:
digitalWrite(nom variable, LOW or HIGH)
const int led = 2; //définition de la broche 2 de la carte
//en tant que variable
void setup () //fonction d'initialisation de la carte
{
pinMode (led , OUTPUT); //initialisation de la broche 2 comme
// étant une sortie
}
void loop () // fonction principale, elle s’exécute à l'infini
{
digitalWrite (led, HIGH) ; //allumer la LED
//ou digitalWrite (led, 1) ;
delay(1000); // faire une pause de 1 seconde
digitalWrite (led, LOW); // éteindre la LED
//ou digitalWrite (led, 0) ;
delay(1000); // faire une pause de 1 seconde
}
 ARD1

AREF
13
PB5/SCK
12
PB4/MISO
RESET 11
~PB3/MOSI/OC2A
10
~ PB2/SS/OC1B
9
~ PB1/OC1A
8
PB0/ICP1/CLKO

ATMEGA328P-PU
1121

DIGITAL (~PWM)
7
ANALOG IN

PD7/AIN1
6
A0 ~ PD6/AIN0
PC0/ADC0 5
A1 ~ PD5/T1
PC1/ADC1 4
A2 PD4/T0/XCK
PC2/ADC2 3
A3 ~ PD3/INT1
PC3/ADC3 2
A4 PD2/INT0
PC4/ADC4/SDA 1
A5 TX PD1/TXD
PC5/ADC5/SCL 0
RX PD0/RXD
D1
ARDUINO UNO R3 LED-YELLOW
Rappels: clignotement leds-Arduino
 Rappels: clignotement leds-Arduino
Relier une led à la pin 13 et un bouton poussoir à la pin 7
Lorsque la pin reliée au bouton poussoir =1 la led est allumée dans le cas
contraire elle s’éteint. 
int led = 13;
int bp = 7;
int val = 0;
void setup()
{
pinMode(led, OUTPUT); pinMode(bp, INPUT);
}
void loop() { val = digitalRead(bp); //lire etat du BP
if (val == HIGH) { digitalWrite (led, HIGH); }
else { digitalWrite(led, LOW);
}
}
 Rappels: clignotement leds-Arduino
int led1 = 6; int led2 = 7; int led3 = 8;
void setup() {
pinMode(led1, OUTPUT); pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
}
void loop() {
digitalWrite(6, 1);
digitalWrite(7, 1); digitalWrite(8, 1); delay(1000);

digitalWrite(6, 0); digitalWrite(7, 0); digitalWrite(8, 0);

delay(1000); }
//********************chenillard******************
int k; int i;
void setup()
{ for(i=0;i<=12;i++)pinMode(i, OUTPUT);}
void loop()
{
// Extinction de toutes les LED au départ du programme
for ( k = 0 ; k <= 12 ; k++) { digitalWrite (k, LOW) ;
// Boucle pour faire flasher les LED
for ( k= 0 ; k <= 12 ; k++)
{ digitalWrite (k, HIGH) ;
delay (100) ;
digitalWrite (k, LOW) ;
delay (100) ;
}
}
 LCD-ARDUINO

#include <LiquidCrystal.h>
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int i,un,dis;
void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
// Print a message to the LCD.
lcd.print("hello");
}
LCD-ARDUINO
 LCD-ARDUINO

void loop() {
int i;
// set the cursor to column 4, line 1 (note: line 1 is the second row)
lcd.setCursor(2, 1);
for( i=0; i<=25;i++)
{
un=i%10; dis= i/10;
lcd.print(dis); lcd.print(un);delay(200);
lcd.setCursor(2, 1);}
}
LCD-ARDUINO
 ADC-LCD-ARDUINO
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() { lcd.begin(16, 2);
lcd.print(“voltage”); }
void loop() {
int valADC = analogRead(A0); // read the input on analog pin 0
// Convert the analog reading (which goes from 0 - 1023)
float voltage = valADC * (512.0 / 1023.0);
lcd.setCursor (4, 1); // set the cursor to column 4, line 1
lcd.print(voltage); } // print out the value you read:
Gestion d’un afficheur 7 segments
 Gestion d’un afficheur 7 segments

char
code7seg[]={0X3F,0X06,0x5B,0x4F,0x66,0x6D,0x7D,0X07,0x7F,0x6F};
char k;
void setup()
{
DDRD=0xFF; PORTD=0;
}
void loop()
{
for(k=0;k<=9;k++)
{PORTD=code7seg[k];delay(800);
}
}
ADC-7seg-ARDUINO
 ADC-7seg-ARDUINO
char code7seg[]={0X3F,0X06,0x5B,0x4F,0x66,0x6D,
0x7D,0X07,0x7F,0x6F};
void setup()
{
DDRD=0xFF; PORTD=0;
}
void loop()
{
int value = analogRead(A2);
value = value * (9.0 / 1023.0); //le .0 est obligatoire
PORTD=code7seg[value];
}
 Communication série
/* Hello World! This is the Hello World! for Arduino.
* It shows how to send data to the computer
*/
void setup()
{
Serial.begin(9600);// set up Serial library at 9600 bps
Serial.println("Hello world!");
}
 void loop()
{
// do nothing!
}
Communication série
Communication série
 Communication série

char value; //initialize variable’value’.

void setup()
{
Serial.begin(9600); //start serial comm with computer at baud rate
9600 baud.
}
void loop()
{
while(Serial.available( )>= 0); // wait for serial data
value=Serial.read(); //read the serial data(ASCII value)
Serial.println(value); //print the value back to the
monitor(computer)
}
N.B : avec char value si on tape au clavier 1 on aura 1 sur le port serie
avec int value si on tape au clavier 1 on aura le code ASCII de 1 c,a,d 49
 Communication série
char data = 0;
void setup()
{ Serial.begin(9600); //data transmission = 9600 bits/s
pinMode(13, OUTPUT);
}
void loop()
{
if(Serial.available() > 0) // Send data only when you receive data:
{
data = Serial.read(); Serial.print(data);
Serial.write(13); //New line
if(data == '1')
{ Serial.print("v avez tape 1"); Serial.write(13);
Serial.print("led allumee");Serial.write(13);
digitalWrite(13, HIGH);Serial.write(13); }
else if(data == '0')
{ Serial.print("v avez tape 0"); Serial.write(13);
Serial.print("led eteinte"); Serial.write(13);
digitalWrite(13, LOW); }
}
}
Communication série
 Tapez au clavier A svp
char K;
void setup()
{ Serial.begin(9600); Serial.println("tapez A s.v.p");
}
void loop()
{
if(Serial.available()>0)
{
K=Serial.read();Serial.print(K); delay(50);

if (K=='A' ){ Serial.println(" OK v, avez compris ");

Serial.end(); }
else
Serial.println("mais non vous vous etes trompes, tapez A SVP ");
}
}
 si on tape au clavier 1 led allumées si on tape 0 led éteintes
int ledPin=4; int ledPin2=5; int d;
 void setup() {
Serial.begin(9600);
pinMode(ledPin,OUTPUT);pinMode(ledPin2,OUTPUT);
digitalWrite(ledPin2, LOW); digitalWrite(ledPin, LOW);
}
void loop () {
if (Serial.available()>0)
{
d= Serial.read()-48;
if ( d == 1 ) { Serial.println("led alumee");
digitalWrite(ledPin2, HIGH); digitalWrite(ledPin, HIGH); }
if ( d == 0 ) { Serial.println("led eteinte");
digitalWrite(ledPin2, LOW); digitalWrite(ledPin, LOW); }
//delay(100);
}
}
ADC-7seg-ARDUINO
 ADC-7seg-ARDUINO
char
code7seg[]={0X3F,0X06,0x5B,0x4F,0x66,0x6D,0x7D,0X07,0x7
F,0x6F};
int i,unite,diz,c,v,t;
void setup()
{ DDRD=0xFF;DDRC=0x03;PORTD=0; PORTC=0; i=0;t=0; }
void loop()
{ int value = analogRead(A2);
value = value * (80.0 / 1023.0); //le .0 est obligatoire
diz=value/10; unite=value%10;
PORTC=1; PORTD=code7seg[unite];
PORTC=2; PORTD=code7seg[diz];
t++;if (t==10)//pour augm. Vitesse de comptage t<30...
t=0;}
 Mécanismes des interruptions avec l’ARDUINO 
Les interruptions INT0 et INT1
Qu’est ce q’une interruption ?
Une interruption, comme son nom l’indique, consiste à
interrompre momentanément le programme que l’Arduino
exécute pour qu’il effectue un autre travail.Le meilleur exemple
que l’on puisse donner d’une interruption est le scénario suivant :
Lors d’une conversation entre 2 personnes, une 3ème s’approche
et interpelle l’une d’elles attirant ainsi son attention. Cette
demande extérieure peut être traitée de différentes manières.
1/ La 3ème personne peut être complètement ignorée et la
conversation continue.
2/ La conversation est immédiatement interrompue et on
s’intéresse à la 3ème personne.
Dans chaque cas lorsque l’intervention de la 3ème personne sera
terminée la conversation reprendra entre les 2 premières
personnes. Cette scène représente exactement le concept
d’interruption d’un système à MP.
 Mécanismes des interruptions avec l’ARDUINO 
Les interruptions INT0 et INT1

Quand une interruption survient, le programme principal est

interrompu : Le µC finit l'exécution de l'instruction en cours puis il
se branche vers le sous-programme d'interruption (la routine
d'interruption).Quand la routine d'interruption est achevée le µC
retourne au programme principal, à l'endroit exact où il l'avait
quitté.

Les interruptions INT0 et INT1 disposent chacune de leur propre

vecteur d'interruption et peuvent être déclenchées sur un front
montant, descendant, un niveau bas ou un basculement de niveau.
Chaque type de carte dispose d’un nombre bien déterminé
d’interruptions avec leurs broches correspondantes :
 Mécanismes des interruptions avec l’ARDUINO 
Les interruptions INT0 et INT1

l'ATmega328P de l'Arduino Uno comprend deux types

d'interruption : les interruptions « externes » (external
interrupts) et celles sur « changement d'état » (pin change
interrupts).
Ces interruptions peuvent être configurées pour se déclencher sur
front montant (RISING), sur front descendant (FALLING), sur
changement d'état (CHANGE) ou sur l'état bas (LOW) du signal.
Syntaxe:
attachInterrupt (numero, fonction, mode)
Numero: Il s’agira de 0 ou 1 sur un Arduino Uno, ce qui correspond
respectivement aux broches 2 et 3.
Sur un Arduino Mega, les numéros 0 à 5 seront possibles et
correspondent, dans l’ordre, aux broches 21, 20, 19, 18, 2 et 3.
  fonction: routine d’interruption qui sera appelée lorsque
l’interruption surviendra.
mode indique ce qui va provoquer l’interruption:
mode indique ce qui va provoquer l’interruption
Les valeurs possibles pour mode sont :
LOW : l’interruption est déclenchée quand la broche concernée est
LOW
CHANGE : l’interruption est déclenchée quand la broche concernée
change d’état, c’est à dire passe de LOW à HIGH ou bien de HIGH à
LOW.
RISING : l’interruption est déclenchée quand la broche concernée
passe de LOW à HIGH. Il s’agit également d’un événement.
FALLING : l’interruption est déclenchée quand la broche concernée
passe de HIGH à LOW. Il s’agit encore d’un événement.
Int pin = 13;
volatile int state = LOW; //déclaration d'une variable volatile
void setup() { pinMode (pin, OUTPUT);
attachInterrupt(0, blink, CHANGE); }
void Loop()
{
digitalWrite (pin, state);
void blink()
{
state = !state; //inverse l'état de la variable
}
Exercice :
Au départ la valeur affichée sur le Terminal virtuel relié à la
carte Arduino=0. A chaque fois que l’interruption 0 survient
on incrémente cette valeur. Si l’interruption 1 survient on
décrémente celle-ci. Ecrire le programme correspondant.
int i=0;
void setup()
{ DDRB=0xFF;
attachInterrupt(0, segm, FALLING); // 0 pour INT0
attachInterrupt(1, segm1, FALLING); //1 pour INT1
Serial.begin(9600);
PORTB=0;

}
void loop()
{ PORTB=i;}

void segm()

{
i++; Serial.println(i); delay(200); if(i==9)i=0;
}
void segm1()
{
i--;Serial.println(i);delay(200); if(i==-9)i=0;
}
 La modulation de largeur d’impulsions (ou PWM ou
Pulse With Modulation)
 La Modulation de largeur d'Impulsions (MLI, PWM en anglais) est une
succession de différents états logiques, (0 et 1), de différentes durées, à
intervalles réguliers.
Dans le cas de l'Arduino il s'agit de succession de 0/5V, qui permet, en
modifiant la durée de chacun de ces états, de faire que tout se passe comme si
on avait une source de tension continue.
Si l'on fait une MLI avec 20% d'états hauts, on aura 20% de 5V et 80% de 0V :
on aura l'impression d'avoir 1V. La technique PWM est donc une technique
pour obtenir des effets d'allure analogique avec des broches numériques.

La durée du temps du niveau HAUT est appelé largeur d'impulsion, ou encore

"duty cycle"
 Vpin arduino= Vpwm-arduino =t h x Vcc/ T
On appelle rapport cyclique le rapport : α=100xth/T exprimé en pourcentage.

Un appel de la fonction analogWrite(valeur) utilise une valeur

comprise entre 0 et 255, tel que analogWrite(255) utilise 100% du
cycle (toujours au niveau HAUT), et analogWrite(127) utilise 50%
du cycle de travail (la moitié du temps) par exemple. La valeur 0
correspond ainsi à 0% du cycle de travail (duty cycle).
 Interret
Piloter un moteur à courant continu avec Arduino
Quand on veut faire varier la vitesse d’un moteur, la première idée
qui vient à l’esprit est de faire varier la tension aux bornes du
moteur mais on constate que pour des valeurs faibles de la
tension, le moteur ne tourne pas. Le moteur demande une tension
minimale pour démarrer. Si cette dernière est trop basse, les
forces électromagnétiques ne sont pas suffisantes pour vaincre le
frottement. Il devient donc difficile d’ajuster la vitesse de façon
précise. Il suffit de fournir au moteur une tension qui est toujours
la même soit la tension maximale ! Par contre, cette tension ne
sera appliquée que par très courtes périodes de temps. La vitesse
du moteur devient donc proportionnelle à la longueur des
périodes de temps.
int led_pin = 6;
void setup() {

pinMode(led_pin, OUTPUT);
}
void loop() {

for(int i=0; i<255; i++){

analogWrite(led_pin, i);
delay(5);
}
for(int i=255; i>0; i--){
analogWrite(led_pin, i);
delay(5);
}
}
Exemple de programme : Ce programme fait varier la luminosité de la led d’une façon
proportionnelle à la valeur lue par le potentiomètre relié à la pin analogique A3. La led étant
reliée à la sortie PWM 9 de l’arduino.

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

int analogPin = A3; // potentiometer connected to analog pin 3
int val = 0; // variable to store the read value
void setup()
{pinMode(ledPin, OUTPUT); } // sets the pin as output
void loop()
{ val = analogRead(analogPin); // read the input pin
analogWrite(ledPin, val);
}
int pinMoteur=9 ;// une pin PWM
void setup () {
pinMode(pinMoteur,OUTPUT); }
void loop() {
for (int pourcent=0 ; pourcent<=100 ; pourcent+=25)

{ int valeur=map(pourcent,0,100,0,255);
analogWrite(pinMoteur,valeur);
delay (2000) ; // attente de 2 secondes
}
}
 Le driver L298n

Caractéristiques du driver moteur

L298N  :
• Pilote : L298N de type double canal en
pont en H
• Tension logique : 5 VCC
• Tension d'entrainement : 5 à 35 V
• Courant d'entrainement : 2A
• Puissance : 25 W
• Dimensions : 43*43*27 mm
• Câblage : Bornes à vis
Le driver L298n
Le driver L298n
// Moteur 1
int IN1 = 5;int IN2 = 6;
// Moteur 2
int IN3 = 10; int IN4 = 11;
void setup() { pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
void loop() {
// Marche Avant
digitalWrite(IN1, 1); digitalWrite(IN2, 0);
digitalWrite(IN3, 1); digitalWrite(IN4, 0);
// Attente 2s
delay(2000);
// Arrêt des moteurs
digitalWrite(IN1, 0); digitalWrite(IN2, 0); digitalWrite(IN3, 0); digitalWrite(IN4, 0);
// Attente 1s
delay(1000);
// Marche arrière
digitalWrite(IN1, 0); digitalWrite(IN2, 1); digitalWrite(IN3, 0); digitalWrite(IN4, 1);
// Attente 2s
delay(2000);
// Arrêt des moteurs
digitalWrite(IN1, 0); digitalWrite(IN2, 0); digitalWrite(IN3, 0); digitalWrite(IN4, 0);
// Attente 1s
delay(1000); }
 Speed control using PWM

#define ENA 9     // ENA speed pin for left motor

#define IN1 8       // IN1 on Motor controller board
#define IN2 11       // IN2

  // Right motor pins

#define ENB 10     // ENB speed pin for right motor
#define IN3 12       // IN3 on Motor controller board
#define IN4 13       // IN4

  int rightspeed = 150;
  int leftspeed = 150;
void setup() {

  pinMode(ENA, OUTPUT);  //set up left motor

  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);

  pinMode(ENB, OUTPUT);//sets up right motor

  pinMode(IN3, OUTPUT); 
  pinMode(IN4, OUTPUT);

 
 Speed control using PWM

 analogWrite(ENA, leftspeed); //set speed to mid

  analogWrite(ENB, rightspeed); //set speed to mid
}
void loop()  {

  digitalWrite(IN1, HIGH);//left motor forward

  digitalWrite(IN2, LOW);  //

  digitalWrite(IN3, HIGH);//right motor forward

  digitalWrite(IN4, LOW);
}
 
int MOTOR1_FORWARD_PIN=4;
int MOTOR1_BACKWARD_PIN=5;
void setup()
{
pinMode( MOTOR1_FORWARD_PIN , OUTPUT);
pinMode( MOTOR1_BACKWARD_PIN , OUTPUT);
}

void loop() {
// Forward
digitalWrite( MOTOR1_FORWARD_PIN , HIGH );
digitalWrite( MOTOR1_BACKWARD_PIN , LOW ); delay(2000);
//stop
digitalWrite( MOTOR1_FORWARD_PIN , LOW );
digitalWrite( MOTOR1_BACKWARD_PIN , LOW ); delay(2000);
// BACKWARD
digitalWrite( MOTOR1_FORWARD_PIN , LOW );
digitalWrite( MOTOR1_BACKWARD_PIN , HIGH ); delay(2000);
//stop
digitalWrite( MOTOR1_FORWARD_PIN , LOW );
digitalWrite( MOTOR1_BACKWARD_PIN , LOW );
delay(2000);
}
int enb=6;
int MOTOR1_FORWARD_PIN=4;
int MOTOR1_BACKWARD_PIN=5;
void setup() {
pinMode( enb , OUTPUT);
pinMode( MOTOR1_FORWARD_PIN , OUTPUT);
pinMode( MOTOR1_BACKWARD_PIN , OUTPUT);
}
void loop() {
// Forward
analogWrite(enb,70);
digitalWrite( MOTOR1_FORWARD_PIN , HIGH );
digitalWrite( MOTOR1_BACKWARD_PIN , LOW );
delay(2000);
//stop
analogWrite(enb,70);
digitalWrite( MOTOR1_FORWARD_PIN , LOW );
digitalWrite( MOTOR1_BACKWARD_PIN , LOW );
delay(2000);
// BACKWARD
analogWrite(enb,70);
digitalWrite( MOTOR1_FORWARD_PIN , LOW );
digitalWrite( MOTOR1_BACKWARD_PIN , HIGH );
delay(2000);

//stop
analogWrite(enb,70);
digitalWrite( MOTOR1_FORWARD_PIN , LOW );
digitalWrite( MOTOR1_BACKWARD_PIN , LOW );
delay(2000);

}
 Le bus I2C (d'Inter-Integrated Circuit)
Le bus I2C permet de faire communiquer entre eux des
composants électroniques très divers grâce à seulement trois fils :
Un signal de donnée ( SDA ), un signal d’horloge ( SCL ), et un
signal de référence électrique ( Masse ).
Les données sont transmises en série à 100Kbits/s en mode
standard 400Kbits/s en mode rapide et jusqu’à 3,2 Mb/s en mode
très rapide,
chaque périphérique sur le bus I2C est adressable, avec une
adresse unique pour chaque périphérique du bus.
 Crée par Philips dans les années 80, pour permettre de relier
facilement à un microprocesseur divers circuits intégrés.
Il y a des milliers de composants qui utilisent une interface I2C, et les cartes de la
famille Arduino peuvent toutes les contrôler. Les applications sont multiples :
horloges temps réel, potentiomètres numériques, capteurs de température,
boussoles numériques, mémoires, contrôleurs d'afficheur LCD,
accéléromètres…... Vous pouvez connecter plusieurs composants adressables sur
un même bus à tout moment (jusqu'à 112 périphériques I 2C adressables sur un
même bus en théorie).
 transmission synchrone. Pas besoin de spécifier une vitesse de transfert
comme pour la liaison RS232. Ici, le périphérique maître (master) génère le
signal d'horloge qui synchronise et cadence les échanges ;
 la relation entre les périphériques du bus est de type maître-esclave
(master/slave). Le maître est à l'initiative de la transmission et s'adresse à
un esclave (ou tous les esclaves)
 La distance maximale maître-esclave pour un bus I2C est d'environ 1 mètre
et dépend de plusieurs facteurs comme la capacité électrique du bus ou le
débit de transmission.  
 La prise de contrôle du bus
La communication sur le bus est orchestrée de la manière suivante :
 Le maître envoie sur le bus l'adresse du composant avec qui il
souhaite communiquer ; chacun des esclaves ayant une adresse
fixe codée sur 7 bits.
 L'esclave qui reconnaît son adresse répond à son tour par un signal
de confirmation(ACK : acknowledge)puis le maître continue la
procédure de communication...(écriture/lecture).
 La transmission d'un octet
Prise de contrôle du bus :
 Le bus doit être au repos avant la prise de contrôle : SDA=1 et SCL=1.
Pour transmettre des données, il faut surveiller :
La condition de départ(START) : SDA passe à 0 et SCL reste à 1.
La condition d’arrêt(STOP) : SDA passe à 1 et SCL reste à 1.
Le maître transmet le bit de poids fort D7 sur SDA.
Il valide la donnée en appliquant un niveau 1 sur SCL
Lorsque SCL retombe à 0, il poursuit avec D6, et ainsi de suite jusqu’à ce que l’octet soit
transmis.
Il envoie le bit ACK à 1 en scrutant l’état de SDA.
 Envoie des données selon le protocole I2C 
La transmission commence par une condition START (SCL est à l'état HIGH,
SDA bascule à l'état LOW). S'ensuivent les 7 bits de l'adresse du composant
(Slave Address), puis un bit R/W qui vaut ici 0 pour indiquer une opération
d'écriture sur la ligne SDA. Le composant adressé ou esclave doit envoyer un
bit d'acquittement (ACK pour Acknowledgement en abaissant la ligne SDA
pour acquitter de la bonne réception).
Chaque octet de donnée écrit sur la ligne par le maître doit être acquitté par
l'esclave. La transmission s'arrête en finissant par une condition STOP
(tandis SCL est à l'état HIGH, SDA bascule à l'état HIGH).
 lecture des données
Si le bit R/W transmis en même temps que l'adresse est à 1, cela signifie que le maître
veut lire des données issues de l'esclave. C'est toujours le maître qui va générer le signal
d'horloge SCL.
La transmission commence par une condition START (SCL est à l'état HIGH, SDA bascule à
l'état LOW). S'ensuivent 7 bits de l'adresse du composant (Slave Address), puis un bit R/W
qui vaut ici 1 pour indiquer une opération de lecture sur la ligne SDA. Le composant
adressé doit envoyer un bit d'acquittement (ACK pour Acknowledgement, l’ esclave doit
abaisser la ligne SDA pour acquitter de la bonne réception). Chaque octet de donnée
retourné sur la ligne par l'esclave doit être acquitté par le maître. La transmission s'arrête
en finissant par la condition STOP.
L'Arduino Uno possède une liaison I2C (SDA : broche analogique A4 et SCL :
broche analogique A5) et une bibliothèque Wire() permet de gérer les
échanges d'informations entre la carte Arduino et les circuits I2C connectés.
Cette bibliothèque est installée de base dans l'IDE Arduino. Les principales
fonctions de cette bibliothèque sont :
Wire.begin() : initialise la communication sur le bus.
Wire.beginTransmission(adresse) : le maître débute un échange
d'informations avec l'esclave dont l'adresse est spécifiée.
Wire.endTransmission() : arrête l'échange d'informations entre le maître et
l'esclave.
Wire.write(octet) : envoi d'un octet sur le bus.
Wire.requestFrom(adresse, nb_octets) : le maître  demande à l'esclave dont
l'adresse est spécifiée de lui transmettre un nombre d'octets.
Wire.read() :le maître lit des données en provenance d'un esclave.
Wire.available() : renvoie le nombre d'octets présents sur le bus I2C.
 Application:
HORLOGE TEMPS REEL DS1307
 Application:
HORLOGE TEMPS REEL DS1307

€ 0,49 2021
 Application:
HORLOGE TEMPS REEL DS1307
 Application:
HORLOGE TEMPS REEL PCF8583
 Puis on l'initialisera avec Wire.begin()

Application:
Communication en I2C entre une carte Arduino et un capteur de température
DS1621.
Mesure de température (-55 °C à +125 °C par incrément de 0,5 °C), conversion de la
température en mot de 16 bits en moins d'une seconde.
Configuration possible en thermostat (configuration des seuils de température
haut et bas non volatile).
Version en boîtier 8 broches.
La carte Arduino sera dans la situation du maître et le composant connecté au bus
I2C sera en situation d'esclave. De l'Arduino, on peut « écrire » sur la ligne pour
envoyer des données vers un composant, ou « lire » la ligne pour récupérer les
données retournées par celui-ci.
Pour communiquer en suivant le protocole I2C, on inclura une bibliothèque Arduino
dans les croquis, ici nommée Wire, #include <Wire.h> Puis on l'initialisera avec
Wire.begin() à l’interieur de void setup(),
On rappelle que l'adresse d'un composant I2C est codée avec sept bits (A0 à A6). Les bits
de poids faible A0, A1 et A2 peuvent être configurés matériellement, par exemple en
reliant les trois broches A0, A1 et A2 à la référence électrique GND comme sur le schéma
du montage ci-dessus, on les met au niveau logique bas, A0 = A1 = A2 =0. Les bits A3 à
A6 sont fixés par le fabricant du DS1621, ici A3=1, A4=0, A5=0 et A6=1.
Ce qui donne pour l'adresse du composant : 100 1000 = 48Hex

pour lancer une conversion de température, on procède en trois temps :

Wire.beginTransmission(0x48);//adresse du DS1621
//L'adresse est alors écrite sur la ligne de données SDA du bus
Wire.write(0xEE); // 0xEE est la commande Start Convert T
L'octet de données (ici, la commande Start Convert [0xEE] qui permet de lancer la
conversion de température) est ensuite envoyé au DS1621
Une fois la conversion de température terminée, la valeur de température est
stockée dans un format bien précis dans un registre du DS1621. L'Arduino doit donc
préparer le DS1621 à pointer vers ce registre avant de requérir les deux octets
correspondants.