Wikifab - Contributions de l’utilisateur [fr]

Utiliser 2 Arduinos en série

2016-10-26T15:18:27Z

Letmeknow :

{{Tuto Details
|Type=Technique
|Area=Électronique
|Description=Le but de ce montage est d’ allumer une LED connectée à un Arduino en la commandant depuis le second Arduino. Ce montage va utiliser le réseau I2C du Arduino.
|Difficulty=Très facile
|Cost=20
|Currency=EUR (€)
|Duration=1
|Duration-type=heure(s)
|Licences=Attribution (CC BY)
|Main_Picture=Utiliser_2_Arduinos_en_s_rie_Final.jpg
}}
{{Introduction}}
{{Materials
|Material=* 2 Arduino
* 1 LED
* 1 résistance (Optionnel)
* Une Breadboard
* Des fils de connexion
|Step_Picture_00=Utiliser_2_Arduinos_en_s_rie_composants1.jpg
}}
{{Separator}}
{{Tuto Step
|Step_Title=Schema
|Step_Content=Pour mettre en réseau les 2 Arduinos, nous allons utiliser l’interface I2C du Arduino. Le réseau I2C fonctionne sur le principe Maître / Esclave. Il peut y avoir un seul maître par réseau et plusieurs esclaves (chaque esclave a un identifiant). Cette interface nécessite 2 fils le SDA (Broche Analog A4) et SCL (Broche Analog A5). Grâce au réseau I2C, il est possible de connecter différentes cartes électroniques ou simple circuit intégré (« puce ») facilement comme le montre le schéma ci-contre.

{{Info|Text=On voit sur ce schéma que pour fonctionner les éléments du réseau doit être alimenté par la même alimentation. Pour simplifier ceci, nous allons alimenter le Arduino donnant la commande (qui sera le maître) avec le Arduino allumant la LED (qui sera l’esclave).}}
|Step_Picture_00=Utiliser_2_Arduinos_en_s_rie_schema-i2c.jpg
}}
{{Tuto Step
|Step_Title=Principe du montage
|Step_Content=Le montage va cette fois-ci se décomposer en 2 parties :

* Le Arduino esclave: Le Arduino esclave aura une LED et sa résistance câblée entre sa sortie digital 2 et le GND. Il utilisera sa sortie 5V pour alimenter le Arduino maître.
* Le Arduino maître : Le Arduino maître reçoit son alimentation du Arduino esclave sur son entrée Vin.

Pour terminer la bonne connexion de l’alimentation, il reste à connecter entre eux les GND des 2 arduinos.

Pour établir la connexion entre ces 2 Arduinos, il va être nécessaire de raccorder les signaux SDA/SCL:

* Entre la borne Analog 4 (SDA) du Arduino maître et la borne Analog 4 du Arduino esclave
* Entre la borne Analog 5 (SCL) du Arduino maître et la borne Analog 5 du Arduino esclave
|Step_Picture_00=Utiliser_2_Arduinos_en_s_rie_2-arduino-en-serie_sce_ma.jpg
}}
{{Tuto Step
|Step_Title=Réalisation du montage
|Step_Content=Pour le Arduino esclave, ce montage est le même que le montage « Allumer une LED »

Pour le Arduino maître, uniquement des connexions avec le Arduino esclave.
|Step_Picture_00=Utiliser_2_Arduinos_en_s_rie_2-arduino-en-serie_bb.jpg
|Step_Picture_01=Utiliser_2_Arduinos_en_s_rie_Montage.jpg
}}
{{Tuto Step
|Step_Title=Programmation du montage
|Step_Content=La programmation de ce montage s’appuie sur la librairie Wire. Comme c’est une librairie, pour utiliser ces fonctions, il faudra écrire «Wire.nomdelafonction » .Elle contient les fonctions suivantes :

* '''begin(X)''' : Initialise la liaison I2C. Se place dans la section « setup ». Le paramètre X est l’adresse de la carte esclave. Pour le maître le paramètre reste vide.
* '''RequestFrom(X, Y)''' : Commande utilisée par le maître pour demander des informations aux esclaves (requête). Le paramètre X est l’adresse de l’esclave. Le paramètre Y est le nombre d’octets demandé.
* '''beginTransmission(X)''' : Commande utilisée par le maître pour démarrer une transmission avec l’esclave de l’adresse X.
* '''endTransmission()''' : Commande utilisée par le maître pour clore une transmission.
* '''Write(X)''' : Commande utilisée par l’esclave pour répondre le message X à une demande du maître.
* '''Available()''' : Renvoi le nombre d’octet disponible pour la lecture. C’est une fonction très intéressante pour savoir s’il y a des messages en attente de lecture.
* '''Read()''' : Lit les message en attente sur le bus. Attention : La fonction read lit caractère par caractère.
* '''OnReceive(X)''' : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a des messages à lire la fonction X.
* '''onRequest()''' : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a une requête du maître.

Le programme va lui aussi être coupé en 2, un pour chaque Arduino.

{{Caution|Text=ATTENTION : Il faut déconnecter les Arduinos durant la programmation !}}
}}
{{Tuto Step
|Step_Title=Programme du Arduino Esclave
|Step_Content=Le Arduino esclave définit qu’il a une sortie sur digital 2. Il dit que son adresse est la numéro 4. Il va attendre de recevoir le chiffre 1 sur l’interface I2C pour allumer la LED. Quand il reçoit 0 il éteint la LED.

#include <Wire.h> // Librairie pour la communication I2C

const int L1 = 2; // broche 2 du micro-contrôleur se nomme maintenant : L1

void setup()
{
Wire.begin(4); // Rejoindre le bus à l'adresse #4
Wire.onReceive(receiveEvent); // Preparer une fonction spécifique a la reception de donnee
Serial.begin(9600); // Demarrer la liaison serie avec le PC
pinMode(L1, OUTPUT); // L1 est une broche de sortie
}

void loop()
{
delay(100);
}

// Fonction qui s execute si quelque chose est present sur l interface
void receiveEvent(int howMany)
{
int x = Wire.read(); // recevoir un chiffre
Serial.println(x); // afficher ce chiffre sur l'interface serie
if(x == 1)
{
digitalWrite(L1, HIGH); // allumer L1
}
if(x == 0)
{
digitalWrite(L1, LOW); // eteindre L1
}
}
}}
{{Tuto Step
|Step_Title=Programme du Arduino Maître
|Step_Content=Le Arduino maître envoie un 1 sur l’interface I2C, attend 1 seconde, envoi un 0 sur l’interface I2C, attend 2 secondes et recommence à l’infini.

#include <Wire.h>

void setup()
{
Wire.begin(); // Rejoindre le bus I2C (Pas besoin d adresse pour le maitre)
}

void loop()
{
//contenu du programme
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(1); // Envoi un 1
Wire.endTransmission(); // Arreter la transmission
delay(1000); // Attendre 1s
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(0); // Envoi un 0
Wire.endTransmission(); // Arreter la transmission
delay(2000); // Attendre 2s
}
}}
{{Tuto Step
|Step_Title=Fini !
|Step_Content=Il reste à brancher le Arduino pour compiler le programme et le téléverser.

Une fois terminé cela nous donne :

* Photo 1 : LED éteinte
* Photo 2 : LED allumé

'''Pour aller plus loin :'''
Il est possible de rendre autonome le montage en lui ajoutant un coupleur de pile. Il est aussi possible de modifier les temps allumés et éteints. On peut remplacer les temps par un bouton poussoir ce qui ferait un système de bouton déporté.
|Step_Picture_00=Utiliser_2_Arduinos_en_s_rie_led-OFF.jpg
|Step_Picture_01=Utiliser_2_Arduinos_en_s_rie_led-ON.jpg
|Step_Picture_02=Utiliser_2_Arduinos_en_s_rie_se_rie.png
}}
{{Notes}}
{{Tuto Status
|Complete=Cochez cette case si vous considérez ce tutoriel terminé
}}

Fichier:Utiliser 2 Arduinos en s rie se rie.png

2016-10-26T15:18:23Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser 2 Arduinos en s rie led-ON.jpg

2016-10-26T15:18:21Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser 2 Arduinos en s rie led-OFF.jpg

2016-10-26T15:18:16Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser 2 Arduinos en s rie Montage.jpg

2016-10-26T15:17:54Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser 2 Arduinos en s rie 2-arduino-en-serie bb.jpg

2016-10-26T15:17:48Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser 2 Arduinos en s rie 2-arduino-en-serie sce ma.jpg

2016-10-26T15:17:26Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser 2 Arduinos en s rie schema-i2c.jpg

2016-10-26T15:17:20Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser 2 Arduinos en s rie composants1.jpg

2016-10-26T15:17:09Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Utiliser 2 Arduinos en série

2016-10-26T15:02:17Z

Letmeknow :

{{Tuto Details
|Type=Technique
|Area=Électronique
|Description=Le but de ce montage est d’ allumer une LED connectée à un Arduino en la commandant depuis le second Arduino. Ce montage va utiliser le réseau I2C du Arduino.
|Difficulty=Très facile
|Cost=20
|Currency=EUR (€)
|Duration=1
|Duration-type=heure(s)
|Licences=Attribution (CC BY)
|Main_Picture=Utiliser_2_Arduinos_en_s_rie_Final.jpg
}}
{{Introduction}}
{{Materials
|Material=* 2 Arduino
* 1 LED
* 1 résistance (Optionnel)
* Une Breadboard
* Des fils de connexion
}}
{{Separator}}
{{Tuto Step
|Step_Title=Schema
|Step_Content=Pour mettre en réseau les 2 Arduinos, nous allons utiliser l’interface I2C du Arduino. Le réseau I2C fonctionne sur le principe Maître / Esclave. Il peut y avoir un seul maître par réseau et plusieurs esclaves (chaque esclave a un identifiant). Cette interface nécessite 2 fils le SDA (Broche Analog A4) et SCL (Broche Analog A5). Grâce au réseau I2C, il est possible de connecter différentes cartes électroniques ou simple circuit intégré (« puce ») facilement comme le montre le schéma ci-contre.

{{Info|Text=On voit sur ce schéma que pour fonctionner les éléments du réseau doit être alimenté par la même alimentation. Pour simplifier ceci, nous allons alimenter le Arduino donnant la commande (qui sera le maître) avec le Arduino allumant la LED (qui sera l’esclave).}}
}}
{{Tuto Step
|Step_Title=Principe du montage
|Step_Content=Le montage va cette fois-ci se décomposer en 2 parties :

* Le Arduino esclave: Le Arduino esclave aura une LED et sa résistance câblée entre sa sortie digital 2 et le GND. Il utilisera sa sortie 5V pour alimenter le Arduino maître.
* Le Arduino maître : Le Arduino maître reçoit son alimentation du Arduino esclave sur son entrée Vin.

Pour terminer la bonne connexion de l’alimentation, il reste à connecter entre eux les GND des 2 arduinos.

Pour établir la connexion entre ces 2 Arduinos, il va être nécessaire de raccorder les signaux SDA/SCL:

* Entre la borne Analog 4 (SDA) du Arduino maître et la borne Analog 4 du Arduino esclave
* Entre la borne Analog 5 (SCL) du Arduino maître et la borne Analog 5 du Arduino esclave
}}
{{Tuto Step
|Step_Title=Réalisation du montage
|Step_Content=Pour le Arduino esclave, ce montage est le même que le montage « Allumer une LED »

Pour le Arduino maître, uniquement des connexions avec le Arduino esclave.
}}
{{Tuto Step
|Step_Title=Programmation du montage
|Step_Content=La programmation de ce montage s’appuie sur la librairie Wire. Comme c’est une librairie, pour utiliser ces fonctions, il faudra écrire «Wire.nomdelafonction » .Elle contient les fonctions suivantes :

* '''begin(X)''' : Initialise la liaison I2C. Se place dans la section « setup ». Le paramètre X est l’adresse de la carte esclave. Pour le maître le paramètre reste vide.
* '''RequestFrom(X, Y)''' : Commande utilisée par le maître pour demander des informations aux esclaves (requête). Le paramètre X est l’adresse de l’esclave. Le paramètre Y est le nombre d’octets demandé.
* '''beginTransmission(X)''' : Commande utilisée par le maître pour démarrer une transmission avec l’esclave de l’adresse X.
* '''endTransmission()''' : Commande utilisée par le maître pour clore une transmission.
* '''Write(X)''' : Commande utilisée par l’esclave pour répondre le message X à une demande du maître.
* '''Available()''' : Renvoi le nombre d’octet disponible pour la lecture. C’est une fonction très intéressante pour savoir s’il y a des messages en attente de lecture.
* '''Read()''' : Lit les message en attente sur le bus. Attention : La fonction read lit caractère par caractère.
* '''OnReceive(X)''' : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a des messages à lire la fonction X.
* '''onRequest()''' : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a une requête du maître.

Le programme va lui aussi être coupé en 2, un pour chaque Arduino.

{{Caution|Text=ATTENTION : Il faut déconnecter les Arduinos durant la programmation !}}
}}
{{Tuto Step
|Step_Title=Programme du Arduino Esclave
|Step_Content=Le Arduino esclave définit qu’il a une sortie sur digital 2. Il dit que son adresse est la numéro 4. Il va attendre de recevoir le chiffre 1 sur l’interface I2C pour allumer la LED. Quand il reçoit 0 il éteint la LED.

#include <Wire.h> // Librairie pour la communication I2C

const int L1 = 2; // broche 2 du micro-contrôleur se nomme maintenant : L1

void setup()
{
Wire.begin(4); // Rejoindre le bus à l'adresse #4
Wire.onReceive(receiveEvent); // Preparer une fonction spécifique a la reception de donnee
Serial.begin(9600); // Demarrer la liaison serie avec le PC
pinMode(L1, OUTPUT); // L1 est une broche de sortie
}

void loop()
{
delay(100);
}

// Fonction qui s execute si quelque chose est present sur l interface
void receiveEvent(int howMany)
{
int x = Wire.read(); // recevoir un chiffre
Serial.println(x); // afficher ce chiffre sur l'interface serie
if(x == 1)
{
digitalWrite(L1, HIGH); // allumer L1
}
if(x == 0)
{
digitalWrite(L1, LOW); // eteindre L1
}
}
}}
{{Tuto Step
|Step_Title=Programme du Arduino Maître
|Step_Content=Le Arduino maître envoie un 1 sur l’interface I2C, attend 1 seconde, envoi un 0 sur l’interface I2C, attend 2 secondes et recommence à l’infini.

#include <Wire.h>

void setup()
{
Wire.begin(); // Rejoindre le bus I2C (Pas besoin d adresse pour le maitre)
}

void loop()
{
//contenu du programme
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(1); // Envoi un 1
Wire.endTransmission(); // Arreter la transmission
delay(1000); // Attendre 1s
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(0); // Envoi un 0
Wire.endTransmission(); // Arreter la transmission
delay(2000); // Attendre 2s
}
}}
{{Tuto Step
|Step_Title=Fini !
|Step_Content=Il reste à brancher le Arduino pour compiler le programme et le téléverser.

Une fois terminé cela nous donne :

* Photo 1 : LED éteinte
* Photo 2 : LED allumé

'''Pour aller plus loin :'''
Il est possible de rendre autonome le montage en lui ajoutant un coupleur de pile. Il est aussi possible de modifier les temps allumés et éteints. On peut remplacer les temps par un bouton poussoir ce qui ferait un système de bouton déporté.
}}
{{Notes}}
{{Tuto Status
|Complete=Cochez cette case si vous considérez ce tutoriel terminé
}}

Utiliser 2 Arduinos en série

2016-10-26T15:00:46Z

Letmeknow :

{{Tuto Details
|Type=Technique
|Area=Électronique
|Description=Le but de ce montage est d’ allumer une LED connectée à un Arduino en la commandant depuis le second Arduino. Ce montage va utiliser le réseau I2C du Arduino.
|Difficulty=Très facile
|Cost=20
|Currency=EUR (€)
|Duration=1
|Duration-type=heure(s)
|Licences=Attribution (CC BY)
|Main_Picture=Utiliser_2_Arduinos_en_s_rie_Final.jpg
}}
{{Introduction}}
{{Materials
|Material=* 2 Arduino
* 1 LED
* 1 résistance (Optionnel)
* Une Breadboard
* Des fils de connexion
}}
{{Separator}}
{{Tuto Step
|Step_Title=Schema
|Step_Content=Pour mettre en réseau les 2 Arduinos, nous allons utiliser l’interface I2C du Arduino. Le réseau I2C fonctionne sur le principe Maître / Esclave. Il peut y avoir un seul maître par réseau et plusieurs esclaves (chaque esclave a un identifiant). Cette interface nécessite 2 fils le SDA (Broche Analog A4) et SCL (Broche Analog A5). Grâce au réseau I2C, il est possible de connecter différentes cartes électroniques ou simple circuit intégré (« puce ») facilement comme le montre le schéma ci-contre.

{{Info|Text=On voit sur ce schéma que pour fonctionner les éléments du réseau doit être alimenté par la même alimentation. Pour simplifier ceci, nous allons alimenter le Arduino donnant la commande (qui sera le maître) avec le Arduino allumant la LED (qui sera l’esclave).}}
}}
{{Tuto Step
|Step_Title=Principe du montage
|Step_Content=Le montage va cette fois-ci se décomposer en 2 parties :

* Le Arduino esclave: Le Arduino esclave aura une LED et sa résistance câblée entre sa sortie digital 2 et le GND. Il utilisera sa sortie 5V pour alimenter le Arduino maître.
* Le Arduino maître : Le Arduino maître reçoit son alimentation du Arduino esclave sur son entrée Vin.

Pour terminer la bonne connexion de l’alimentation, il reste à connecter entre eux les GND des 2 arduinos.

Pour établir la connexion entre ces 2 Arduinos, il va être nécessaire de raccorder les signaux SDA/SCL:

* Entre la borne Analog 4 (SDA) du Arduino maître et la borne Analog 4 du Arduino esclave
* Entre la borne Analog 5 (SCL) du Arduino maître et la borne Analog 5 du Arduino esclave
}}
{{Tuto Step
|Step_Title=Réalisation du montage
|Step_Content=Pour le Arduino esclave, ce montage est le même que le montage « Allumer une LED »

Pour le Arduino maître, uniquement des connexions avec le Arduino esclave.
}}
{{Tuto Step
|Step_Title=Programmation du montage
|Step_Content=La programmation de ce montage s’appuie sur la librairie Wire. Comme c’est une librairie, pour utiliser ces fonctions, il faudra écrire «Wire.nomdelafonction » .Elle contient les fonctions suivantes :

* '''begin(X)''' : Initialise la liaison I2C. Se place dans la section « setup ». Le paramètre X est l’adresse de la carte esclave. Pour le maître le paramètre reste vide.
* '''RequestFrom(X, Y)''' : Commande utilisée par le maître pour demander des informations aux esclaves (requête). Le paramètre X est l’adresse de l’esclave. Le paramètre Y est le nombre d’octets demandé.
* '''beginTransmission(X)''' : Commande utilisée par le maître pour démarrer une transmission avec l’esclave de l’adresse X.
* '''endTransmission()''' : Commande utilisée par le maître pour clore une transmission.
* '''Write(X)''' : Commande utilisée par l’esclave pour répondre le message X à une demande du maître.
* '''Available()''' : Renvoi le nombre d’octet disponible pour la lecture. C’est une fonction très intéressante pour savoir s’il y a des messages en attente de lecture.
* '''Read()''' : Lit les message en attente sur le bus. Attention : La fonction read lit caractère par caractère.
* '''OnReceive(X)''' : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a des messages à lire la fonction X.
* '''onRequest()''' : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a une requête du maître.

Le programme va lui aussi être coupé en 2, un pour chaque Arduino.

{{Caution|Text=ATTENTION : Il faut déconnecter les Arduinos durant la programmation !}}
}}
{{Tuto Step
|Step_Title=Programme du Arduino Esclave
|Step_Content=Le Arduino esclave définit qu’il a une sortie sur digital 2. Il dit que son adresse est la numéro 4. Il va attendre de recevoir le chiffre 1 sur l’interface I2C pour allumer la LED. Quand il reçoit 0 il éteint la LED.

#include <Wire.h> // Librairie pour la communication I2C

const int L1 = 2; // broche 2 du micro-contrôleur se nomme maintenant : L1

void setup()
{
Wire.begin(4); // Rejoindre le bus à l'adresse #4
Wire.onReceive(receiveEvent); // Preparer une fonction spécifique a la reception de donnee
Serial.begin(9600); // Demarrer la liaison serie avec le PC
pinMode(L1, OUTPUT); // L1 est une broche de sortie
}

void loop()
{
delay(100);
}

// Fonction qui s execute si quelque chose est present sur l interface
void receiveEvent(int howMany)
{
int x = Wire.read(); // recevoir un chiffre
Serial.println(x); // afficher ce chiffre sur l'interface serie
if(x == 1)
{
digitalWrite(L1, HIGH); // allumer L1
}
if(x == 0)
{
digitalWrite(L1, LOW); // eteindre L1
}
}
}}
{{Tuto Step
|Step_Title=Programme du Arduino Maître
|Step_Content=Le Arduino maître envoie un 1 sur l’interface I2C, attend 1 seconde, envoi un 0 sur l’interface I2C, attend 2 secondes et recommence à l’infini.

#include <Wire.h>

void setup()
{
Wire.begin(); // Rejoindre le bus I2C (Pas besoin d adresse pour le maitre)
}

void loop()
{
//contenu du programme
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(1); // Envoi un 1
Wire.endTransmission(); // Arreter la transmission
delay(1000); // Attendre 1s
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(0); // Envoi un 0
Wire.endTransmission(); // Arreter la transmission
delay(2000); // Attendre 2s
}
}}
{{Tuto Step
|Step_Title=Fini !
|Step_Content=Il reste à brancher le Arduino pour compiler le programme et le téléverser.

Une fois terminé cela nous donne :

* Photo 1 : LED éteinte
* Photo 2 : LED allumé

'''Pour aller plus loin :'''
Il est possible de rendre autonome le montage en lui ajoutant un coupleur de pile. Il est aussi possible de modifier les temps allumés et éteints. On peut remplacer les temps par un bouton poussoir ce qui ferait un système de bouton déporté.
}}
{{Notes}}
{{Tuto Status
|Complete=Cochez cette case si vous considérez ce tutoriel terminé
}}

Fichier:Utiliser 2 Arduinos en s rie Final.jpg

2016-10-26T15:00:22Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Utiliser 2 Arduinos en série

2016-10-26T14:58:42Z

Letmeknow :

{{Tuto Details
|Type=Technique
|Area=Électronique
|Description=Le but de ce montage est d’ allumer une LED connectée à un Arduino en la commandant depuis le second Arduino. Ce montage va utiliser le réseau I2C du Arduino.
|Difficulty=Très facile
|Cost=20
|Currency=EUR (€)
|Duration=1
|Duration-type=heure(s)
|Licences=Attribution (CC BY)
}}
{{Introduction}}
{{Materials
|Material=* 2 Arduino
* 1 LED
* 1 résistance (Optionnel)
* Une Breadboard
* Des fils de connexion
}}
{{Separator}}
{{Tuto Step
|Step_Title=Schema
|Step_Content=Pour mettre en réseau les 2 Arduinos, nous allons utiliser l’interface I2C du Arduino. Le réseau I2C fonctionne sur le principe Maître / Esclave. Il peut y avoir un seul maître par réseau et plusieurs esclaves (chaque esclave a un identifiant). Cette interface nécessite 2 fils le SDA (Broche Analog A4) et SCL (Broche Analog A5). Grâce au réseau I2C, il est possible de connecter différentes cartes électroniques ou simple circuit intégré (« puce ») facilement comme le montre le schéma ci-contre.

{{Info|Text=On voit sur ce schéma que pour fonctionner les éléments du réseau doit être alimenté par la même alimentation. Pour simplifier ceci, nous allons alimenter le Arduino donnant la commande (qui sera le maître) avec le Arduino allumant la LED (qui sera l’esclave).}}
}}
{{Tuto Step
|Step_Title=Principe du montage
|Step_Content=Le montage va cette fois-ci se décomposer en 2 parties :

* Le Arduino esclave: Le Arduino esclave aura une LED et sa résistance câblée entre sa sortie digital 2 et le GND. Il utilisera sa sortie 5V pour alimenter le Arduino maître.
* Le Arduino maître : Le Arduino maître reçoit son alimentation du Arduino esclave sur son entrée Vin.

Pour terminer la bonne connexion de l’alimentation, il reste à connecter entre eux les GND des 2 arduinos.

Pour établir la connexion entre ces 2 Arduinos, il va être nécessaire de raccorder les signaux SDA/SCL:

* Entre la borne Analog 4 (SDA) du Arduino maître et la borne Analog 4 du Arduino esclave
* Entre la borne Analog 5 (SCL) du Arduino maître et la borne Analog 5 du Arduino esclave
}}
{{Tuto Step
|Step_Title=Réalisation du montage
|Step_Content=Pour le Arduino esclave, ce montage est le même que le montage « Allumer une LED »

Pour le Arduino maître, uniquement des connexions avec le Arduino esclave.
}}
{{Tuto Step
|Step_Title=Programmation du montage
|Step_Content=La programmation de ce montage s’appuie sur la librairie Wire. Comme c’est une librairie, pour utiliser ces fonctions, il faudra écrire «Wire.nomdelafonction » .Elle contient les fonctions suivantes :

* '''begin(X)''' : Initialise la liaison I2C. Se place dans la section « setup ». Le paramètre X est l’adresse de la carte esclave. Pour le maître le paramètre reste vide.
* '''RequestFrom(X, Y)''' : Commande utilisée par le maître pour demander des informations aux esclaves (requête). Le paramètre X est l’adresse de l’esclave. Le paramètre Y est le nombre d’octets demandé.
* '''beginTransmission(X)''' : Commande utilisée par le maître pour démarrer une transmission avec l’esclave de l’adresse X.
* '''endTransmission()''' : Commande utilisée par le maître pour clore une transmission.
* '''Write(X)''' : Commande utilisée par l’esclave pour répondre le message X à une demande du maître.
* '''Available()''' : Renvoi le nombre d’octet disponible pour la lecture. C’est une fonction très intéressante pour savoir s’il y a des messages en attente de lecture.
* '''Read()''' : Lit les message en attente sur le bus. Attention : La fonction read lit caractère par caractère.
* '''OnReceive(X)''' : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a des messages à lire la fonction X.
* '''onRequest()''' : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a une requête du maître.

Le programme va lui aussi être coupé en 2, un pour chaque Arduino.

{{Caution|Text=ATTENTION : Il faut déconnecter les Arduinos durant la programmation !}}
}}
{{Tuto Step
|Step_Title=Programme du Arduino Esclave
|Step_Content=Le Arduino esclave définit qu’il a une sortie sur digital 2. Il dit que son adresse est la numéro 4. Il va attendre de recevoir le chiffre 1 sur l’interface I2C pour allumer la LED. Quand il reçoit 0 il éteint la LED.

#include <Wire.h> // Librairie pour la communication I2C

const int L1 = 2; // broche 2 du micro-contrôleur se nomme maintenant : L1

void setup()
{
Wire.begin(4); // Rejoindre le bus à l'adresse #4
Wire.onReceive(receiveEvent); // Preparer une fonction spécifique a la reception de donnee
Serial.begin(9600); // Demarrer la liaison serie avec le PC
pinMode(L1, OUTPUT); // L1 est une broche de sortie
}

void loop()
{
delay(100);
}

// Fonction qui s execute si quelque chose est present sur l interface
void receiveEvent(int howMany)
{
int x = Wire.read(); // recevoir un chiffre
Serial.println(x); // afficher ce chiffre sur l'interface serie
if(x == 1)
{
digitalWrite(L1, HIGH); // allumer L1
}
if(x == 0)
{
digitalWrite(L1, LOW); // eteindre L1
}
}
}}
{{Tuto Step
|Step_Title=Programme du Arduino Maître
|Step_Content=Le Arduino maître envoie un 1 sur l’interface I2C, attend 1 seconde, envoi un 0 sur l’interface I2C, attend 2 secondes et recommence à l’infini.

#include <Wire.h>

void setup()
{
Wire.begin(); // Rejoindre le bus I2C (Pas besoin d adresse pour le maitre)
}

void loop()
{
//contenu du programme
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(1); // Envoi un 1
Wire.endTransmission(); // Arreter la transmission
delay(1000); // Attendre 1s
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(0); // Envoi un 0
Wire.endTransmission(); // Arreter la transmission
delay(2000); // Attendre 2s
}
}}
{{Tuto Step
|Step_Title=Fini !
|Step_Content=Il reste à brancher le Arduino pour compiler le programme et le téléverser.

Une fois terminé cela nous donne :

* Photo 1 : LED éteinte
* Photo 2 : LED allumé

'''Pour aller plus loin :'''
Il est possible de rendre autonome le montage en lui ajoutant un coupleur de pile. Il est aussi possible de modifier les temps allumés et éteints. On peut remplacer les temps par un bouton poussoir ce qui ferait un système de bouton déporté.
}}
{{Notes}}
{{Tuto Status}}

Utiliser 2 Arduinos en série

2016-10-26T14:57:48Z

Letmeknow : Enregistré en utilisant le bouton "Sauvegarder et continuer" du formulaire

{{Tuto Details
|Type=Technique
|Area=Électronique
|Description=Le but de ce montage est d’ allumer une LED connectée à un Arduino en la commandant depuis le second Arduino. Ce montage va utiliser le réseau I2C du Arduino.
|Difficulty=Très facile
|Cost=20
|Currency=EUR (€)
|Duration=1
|Duration-type=heure(s)
|Licences=Attribution (CC BY)
}}
{{Introduction}}
{{Materials
|Material=* 2 Arduino
* 1 LED
* 1 résistance (Optionnel)
* Une Breadboard
* Des fils de connexion
}}
{{Separator}}
{{Tuto Step
|Step_Title=Schema
|Step_Content=Pour mettre en réseau les 2 Arduinos, nous allons utiliser l’interface I2C du Arduino. Le réseau I2C fonctionne sur le principe Maître / Esclave. Il peut y avoir un seul maître par réseau et plusieurs esclaves (chaque esclave a un identifiant). Cette interface nécessite 2 fils le SDA (Broche Analog A4) et SCL (Broche Analog A5). Grâce au réseau I2C, il est possible de connecter différentes cartes électroniques ou simple circuit intégré (« puce ») facilement comme le montre le schéma ci-contre.

{{Info|Text=On voit sur ce schéma que pour fonctionner les éléments du réseau doit être alimenté par la même alimentation. Pour simplifier ceci, nous allons alimenter le Arduino donnant la commande (qui sera le maître) avec le Arduino allumant la LED (qui sera l’esclave).}}
}}
{{Tuto Step
|Step_Title=Principe du montage
|Step_Content=Le montage va cette fois-ci se décomposer en 2 parties :

* Le Arduino esclave: Le Arduino esclave aura une LED et sa résistance câblée entre sa sortie digital 2 et le GND. Il utilisera sa sortie 5V pour alimenter le Arduino maître.
* Le Arduino maître : Le Arduino maître reçoit son alimentation du Arduino esclave sur son entrée Vin.

Pour terminer la bonne connexion de l’alimentation, il reste à connecter entre eux les GND des 2 arduinos.

Pour établir la connexion entre ces 2 Arduinos, il va être nécessaire de raccorder les signaux SDA/SCL:

* Entre la borne Analog 4 (SDA) du Arduino maître et la borne Analog 4 du Arduino esclave
* Entre la borne Analog 5 (SCL) du Arduino maître et la borne Analog 5 du Arduino esclave
}}
{{Tuto Step
|Step_Title=Réalisation du montage
|Step_Content=Pour le Arduino esclave, ce montage est le même que le montage « Allumer une LED »

Pour le Arduino maître, uniquement des connexions avec le Arduino esclave.
}}
{{Tuto Step
|Step_Title=Programmation du montage
|Step_Content=La programmation de ce montage s’appuie sur la librairie Wire. Comme c’est une librairie, pour utiliser ces fonctions, il faudra écrire «Wire.nomdelafonction » .Elle contient les fonctions suivantes :

* '''begin(X)''' : Initialise la liaison I2C. Se place dans la section « setup ». Le paramètre X est l’adresse de la carte esclave. Pour le maître le paramètre reste vide.
* '''RequestFrom(X, Y)''' : Commande utilisée par le maître pour demander des informations aux esclaves (requête). Le paramètre X est l’adresse de l’esclave. Le paramètre Y est le nombre d’octets demandé.
* '''beginTransmission(X)''' : Commande utilisée par le maître pour démarrer une transmission avec l’esclave de l’adresse X.
* '''endTransmission()''' : Commande utilisée par le maître pour clore une transmission.
* '''Write(X)''' : Commande utilisée par l’esclave pour répondre le message X à une demande du maître.
* '''Available()''' : Renvoi le nombre d’octet disponible pour la lecture. C’est une fonction très intéressante pour savoir s’il y a des messages en attente de lecture.
* '''Read()''' : Lit les message en attente sur le bus. Attention : La fonction read lit caractère par caractère.
* '''OnReceive(X)''' : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a des messages à lire la fonction X.
* '''onRequest()''' : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a une requête du maître.

Le programme va lui aussi être coupé en 2, un pour chaque Arduino.

{{Caution|Text=ATTENTION : Il faut déconnecter les Arduinos durant la programmation !}}
}}
{{Tuto Step
|Step_Title=Programme du Arduino Esclave
|Step_Content=Le Arduino esclave définit qu’il a une sortie sur digital 2. Il dit que son adresse est la numéro 4. Il va attendre de recevoir le chiffre 1 sur l’interface I2C pour allumer la LED. Quand il reçoit 0 il éteint la LED.

#include <Wire.h> // Librairie pour la communication I2C

const int L1 = 2; // broche 2 du micro-contrôleur se nomme maintenant : L1

void setup()
{
Wire.begin(4); // Rejoindre le bus à l'adresse #4
Wire.onReceive(receiveEvent); // Preparer une fonction spécifique a la reception de donnee
Serial.begin(9600); // Demarrer la liaison serie avec le PC
pinMode(L1, OUTPUT); // L1 est une broche de sortie
}

void loop()
{
delay(100);
}

// Fonction qui s execute si quelque chose est present sur l interface
void receiveEvent(int howMany)
{
int x = Wire.read(); // recevoir un chiffre
Serial.println(x); // afficher ce chiffre sur l'interface serie
if(x == 1)
{
digitalWrite(L1, HIGH); // allumer L1
}
if(x == 0)
{
digitalWrite(L1, LOW); // eteindre L1
}
}
}}
{{Tuto Step
|Step_Title=Programme du Arduino Maître
|Step_Content=Le Arduino maître envoie un 1 sur l’interface I2C, attend 1 seconde, envoi un 0 sur l’interface I2C, attend 2 secondes et recommence à l’infini.

#include <Wire.h>

void setup()
{
Wire.begin(); // Rejoindre le bus I2C (Pas besoin d adresse pour le maitre)
}

void loop()
{
//contenu du programme
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(1); // Envoi un 1
Wire.endTransmission(); // Arreter la transmission
delay(1000); // Attendre 1s
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(0); // Envoi un 0
Wire.endTransmission(); // Arreter la transmission
delay(2000); // Attendre 2s
}
}}
{{Notes}}
{{Tuto Status}}

Utiliser un bouton poussoir avec un Arduino

2016-10-14T16:32:58Z

Letmeknow : Page créée avec « {{Tuto Details |Type=Création |Area=Électronique |Description=Le but de ce montage est de gérer une LED commandée par à un bouton. Ce montage va s’appuyer sur le mo... »

{{Tuto Details
|Type=Création
|Area=Électronique
|Description=Le but de ce montage est de gérer une LED commandée par à un bouton. Ce montage va s’appuyer sur le montage « Allumer une LED ».
|Difficulty=Facile
|Cost=10
|Currency=EUR (€)
|Duration=20
|Duration-type=minute(s)
|Licences=Attribution (CC BY)
|Main_Picture=Utiliser_un_bouton_poussoir_avec_un_Arduino_Cablage-2.jpg
}}
{{Introduction
|Introduction=Il existe 2 types de boutons :
* Les interrupteurs qui maintiennent leur état. C’est-à-dire que l’on est pas obligé d’appuyer dessus pour qu’il reste ON ou OFF.
* Les boutons poussoirs qui reviennent automatiquement à leur état de base si l’on arrête d’appuyer dessus.
}}
{{Materials
|Material=* 1 Arduino
* 1 LED
* 1 résistance 220 Ohm (R1)
* 1 bouton
* 1 résistance 10kOhm (R2)
* 1 Breadboard
* Des fils de connexion
|Step_Picture_00=Utiliser_un_bouton_poussoir_avec_un_Arduino_Composants1-1024x764.jpg
}}
{{Separator}}
{{Tuto Step
|Step_Title=Principe du montage
|Step_Content=Le montage doit mettre en relation une LED entre une sortie du Arduino (On utilisera la sortie Digital 2) et le GND, un bouton poussoir entre une entrée du Arduino (On utilisera l’entrée Digital 3). On ajoute une résistance entre le 5V et l’entrée Digital 3.

On utilise les mêmes connexions pour l’ensemble LED et résistance que dans le montage « Allumer une LED ». Il est possible de remplacer cette ensemble LED + résistances par 1 LED pour plus de luminosité. Utiliser une LED sans résistance réduit sa durée de vie.

Lorsque le bouton poussoir est appuyé le Arduino verra le 0V sur l’entrée D3 et lorsque le bouton est relâché le Arduino verra 5V sur l’entrée D3.
|Step_Picture_00=Utiliser_un_bouton_poussoir_avec_un_Arduino_bouton_sce_ma.jpg
}}
{{Tuto Step
|Step_Title=Montage des composants sur la Breadboard
|Step_Content=Tout le montage se réalise sur la plaque prévu à cet effet (Breadboard). Comme nous avons plusieurs composants au même potentiel nous allons réaliser des colonnes avec ces différents potentiels :

* 1 colonne 5V avec la résistance R2
* 1 colonne pour l’entrée Digital 3 avec la résistance R2 et le bouton poussoir
* 1 colonne pour la sortie Digital 2 avec l’anode de la LED
* 1 colonne avec la cathode de la LED et la résistance R1
* 1 colonne GND avec la résistance R1 et le bouton poussoir
|Step_Picture_00=Utiliser_un_bouton_poussoir_avec_un_Arduino_Breadboard.jpg
}}
{{Tuto Step
|Step_Title=Câblage de la Breadboard
|Step_Content=On câble ensuite les liens vers le Arduino.
|Step_Picture_00=Utiliser_un_bouton_poussoir_avec_un_Arduino_Cablage1.jpg
|Step_Picture_01=Utiliser_un_bouton_avec_un_Arduino_Cablage-2.jpg
}}
{{Tuto Step
|Step_Title=Programmation
|Step_Content=Le programme doit allumer la LED branchée sur la sortie numérique 2 si il détecte un 1 sur l’entrée numérique 3 sinon elle éteint la LED.

const int L1 = 2; // broche 2 du micro-contrôleur se nomme maintenant : L1
const int BP = 3; // broche 3 du micro-contrôleur se nomme maintenant : BP

void setup() //fonction d'initialisation de la carte
{
//contenu de l'initialisation
pinMode(L1, OUTPUT); //L1 est une broche de sortie
pinMode(BP, INPUT); // BP est une broche d'entree
}

void loop() //fonction principale, elle se répète (s’exécute) à l'infini
{
//contenu du programme
int test = digitalRead(BP); // Lecture de l'entree BP et sockage du résultats dans test

if(test==LOW) // Si test est à l'état bas
{
digitalWrite(L1, HIGH); // Allumer L1
}
else // Sinon
{
digitalWrite(L1, LOW); // Eteindre L1
}
}

Il reste à brancher le Arduino pour compiler le programme et le téléverser.
}}
{{Tuto Step
|Step_Title=Test
|Step_Content=Une fois terminé cela nous donne :

* Photo 1 : ON
* Photo 2 : OFF

'''Pour aller plus loin :'''
Il est possible de rendre autonome le montage en lui ajoutant un coupleur de pile. Il est aussi possible de modifier les séquences pour garder allumer après un appui et éteindre après un autre appui.
|Step_Picture_00=Utiliser_un_bouton_poussoir_avec_un_Arduino_ON.jpg
|Step_Picture_01=Utiliser_un_bouton_poussoir_avec_un_Arduino_OFF.jpg
}}
{{Notes}}
{{Tuto Status
|Complete=Cochez cette case si vous considérez ce tutoriel terminé
}}

Fichier:Utiliser un bouton poussoir avec un Arduino Breadboard.jpg

2016-10-14T16:32:49Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser un bouton avec un Arduino Cablage-2.jpg

2016-10-14T16:32:43Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser un bouton poussoir avec un Arduino Cablage1.jpg

2016-10-14T16:32:39Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser un bouton poussoir avec un Arduino OFF.jpg

2016-10-14T16:32:24Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser un bouton poussoir avec un Arduino ON.jpg

2016-10-14T16:32:17Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser un bouton poussoir avec un Arduino bouton sce ma.jpg

2016-10-14T16:30:09Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser un bouton poussoir avec un Arduino Cablage-2.jpg

2016-10-14T16:30:02Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:Utiliser un bouton poussoir avec un Arduino Composants1-1024x764.jpg

2016-10-14T16:29:52Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Détecteur de présence avec un Arduino

2016-10-04T09:00:00Z

Letmeknow :

{{Tuto Details
|Type=Création
|Area=Électronique
|Description=Créer un détecteur de présence qui allumera une LED en cas de passage de personne. Le montage sera basé sur le capteur de distance à ultrason que l’on utilisera sous forme de seuil. On partira donc du principe que le montage sera installé à un point fixe et que l’on détecte le passage devant le capteur (Comme c’est le cas dans un couloir par exemple).
|Difficulty=Facile
|Cost=15
|Currency=EUR (€)
|Duration=20
|Duration-type=minute(s)
|Licences=Attribution (CC BY)
|Main_Picture=D_tecteur_de_pr_sence_avec_un_Arduino_ON1.jpg
}}
{{Introduction}}
{{Materials
|Material=* Un Arduino
* Un câble USB
* Un capteur de distance à ultrason
* Une LED et sa résistance
* Une Breadboard
* Des fils de connexions
|Step_Picture_00=D_tecteur_de_pr_sence_avec_un_Arduino_Composants1.jpg
}}
{{Separator}}
{{Tuto Step
|Step_Title=Câblage
|Step_Content=Ce montage se basera sur le câblage du capteur ci-contre en lui ajoutant un ensemble LED + résistance sur la Pin Digital 1.

* Digital 12 (Arduino) → Trig (Ultrason)
* Digital 13 (Arduino) → Echo ( Ultrason)
* 5V (Arduino) → VCC (Ultrason)
* GND (Arduino) → GND (Ultrason)
* Digital 1 (Arduino) → LED (Anode)
* LED (cathode) → Résistance
* GND (Arduino) → Résistance
|Step_Picture_00=D_tecteur_de_pr_sence_avec_un_Arduino_Montage.jpg
}}
{{Tuto Step
|Step_Title=Programmation
|Step_Content=Le programme utilise la librairie Ultrasonic. Il faut donc l’installer, c’est-à-dire la copier dans votre répertoire Mes documents / Arduino / librairies.

Le programme va paramétrer le module ultrason grâce au commande de la librairie (Pour plus d’info http://wiki.tetrasys-design.net/HCSR04Ultrasonic), ensuite il compare à une valeur enregistrer si il détecte un objet ou une personne à moins de cette distance on allume la LED sinon on l’éteint.

#include

const int Trig = 12; // pin "Trig" du HC-SR04 connectée à pin 13 de l'Arduino
const int Echo = 13; // pin "Echo" du HC-SR04 connectée à pin 12 de l'Arduino

const int LED = 1; // pin connecté à la LED + resistance

const int green = 10; // LEDs reliées aux pins de l'Arduino via une résistance
const int yellow = 11; // de 150 Ohms.
const int red = 12;

long cm; // variable pour stocker la distance de l'objet en cm

Ultrasonic HCSR04(Trig,Echo);

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

void loop()
{

cm = HCSR04.convert(HCSR04.timing(), 1);

if(cm > 0 && cm < 20) // Il y a une présence { digitalWrite(LED, HIGH); // Allumer la LED delay(10); // Temps de traitement } else if(cm >= 20) // Il n'y a pas de présence
{
digitalWrite(LED, LOW); // Eteindre la LED
delay(10); // Temps de traitement
}
}
}}
{{Tuto Step
|Step_Title=Compiler le programme
|Step_Content=Il reste à brancher le Arduino pour compiler le programme et le téléviser.

Une fois terminé cela nous donne :

* ON : photo 1
* OFF : photo 2
|Step_Picture_00=D_tecter_sence_avec_un_Arduino_ON1.jpg
|Step_Picture_01=D_tecteur_de_pr_sence_avec_un_Arduino_OFF1.jpg
}}
{{Notes
|Notes=Ce tuto est basé sur le post suivant : http://forum.snootlab.com/viewtopic.php?f=38&t=649
}}
{{Tuto Status
|Complete=Cochez cette case si vous considérez ce tutoriel terminé
}}

Détecteur de présence avec un Arduino

2016-10-04T08:56:16Z

Letmeknow :

{{Tuto Details
|Type=Création
|Area=Électronique
|Description=Créer un détecteur de présence qui allumera une LED en cas de passage de personne. Le montage sera basé sur le capteur de distance à ultrason que l’on utilisera sous forme de seuil. On partira donc du principe que le montage sera installé à un point fixe et que l’on détecte le passage devant le capteur (Comme c’est le cas dans un couloir par exemple).
|Difficulty=Facile
|Cost=15
|Currency=EUR (€)
|Duration=20
|Duration-type=minute(s)
|Licences=Attribution (CC BY)
|Main_Picture=D_tecteur_de_pr_sence_avec_un_Arduino_ON1.jpg
}}
{{Introduction}}
{{Materials
|Material=* Un Arduino
* Un câble USB
* Un capteur de distance à ultrason
* Une LED et sa résistance
* Une Breadboard
* Des fils de connexions
|Step_Picture_00=D_tecteur_de_pr_sence_avec_un_Arduino_Composants1.jpg
}}
{{Separator}}
{{Tuto Step
|Step_Title=Câblage
|Step_Content=Ce montage se basera sur le câblage du capteur ci-contre en lui ajoutant un ensemble LED + résistance sur la Pin Digital 1.

* Digital 12 (Arduino) → Trig (Ultrason)
* Digital 13 (Arduino) → Echo ( Ultrason)
* 5V (Arduino) → VCC (Ultrason)
* GND (Arduino) → GND (Ultrason)
* Digital 1 (Arduino) → LED (Anode)
* LED (cathode) → Résistance
* GND (Arduino) → Résistance
|Step_Picture_00=D_tecteur_de_pr_sence_avec_un_Arduino_Montage.jpg
}}
{{Tuto Step
|Step_Title=Programmation
|Step_Content=Le programme utilise la librairie Ultrasonic. Il faut donc l’installer, c’est-à-dire la copier dans votre répertoire Mes documents / Arduino / librairies.

Le programme va paramétrer le module ultrason grâce au commande de la librairie (Pour plus d’info http://wiki.tetrasys-design.net/HCSR04Ultrasonic), ensuite il compare à une valeur enregistrer si il détecte un objet ou une personne à moins de cette distance on allume la LED sinon on l’éteint.

#include

const int Trig = 12; // pin "Trig" du HC-SR04 connectée à pin 13 de l'Arduino
const int Echo = 13; // pin "Echo" du HC-SR04 connectée à pin 12 de l'Arduino

const int LED = 1; // pin connecté à la LED + resistance

const int green = 10; // LEDs reliées aux pins de l'Arduino via une résistance
const int yellow = 11; // de 150 Ohms.
const int red = 12;

long cm; // variable pour stocker la distance de l'objet en cm

Ultrasonic HCSR04(Trig,Echo);

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

void loop()
{

cm = HCSR04.convert(HCSR04.timing(), 1);

if(cm > 0 && cm < 20) // Il y a une présence { digitalWrite(LED, HIGH); // Allumer la LED delay(10); // Temps de traitement } else if(cm >= 20) // Il n'y a pas de présence
{
digitalWrite(LED, LOW); // Eteindre la LED
delay(10); // Temps de traitement
}
}
}}
{{Tuto Step
|Step_Title=Compiler le programme
|Step_Content=Il reste à brancher le Arduino pour compiler le programme et le téléviser.

Une fois terminé cela nous donne :

* ON : photo 1
* OFF : photo 2
|Step_Picture_00=D_tecter_sence_avec_un_Arduino_ON1.jpg
|Step_Picture_01=D_tecteur_de_pr_sence_avec_un_Arduino_OFF1.jpg
}}
{{Notes}}
{{Tuto Status
|Complete=Cochez cette case si vous considérez ce tutoriel terminé
}}

Fichier:D tecteur de pr sence avec un Arduino OFF1.jpg

2016-10-04T08:56:12Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:D tecter sence avec un Arduino ON1.jpg

2016-10-04T08:56:00Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:D tecteur de pr sence avec un Arduino Composants1.jpg

2016-10-04T08:55:49Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:D tecteur de pr sence avec un Arduino Montage.jpg

2016-10-04T08:55:49Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Fichier:D tecteur de pr sence avec un Arduino ON1.jpg

2016-10-04T08:55:40Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload

Détecteur de présence avec un Arduino

2016-10-04T08:54:28Z

Letmeknow : Page créée avec « {{Tuto Details |Type=Création |Area=Électronique |Description=Créer un détecteur de présence qui allumera une LED en cas de passage de personne. Le montage sera basé... »

{{Tuto Details
|Type=Création
|Area=Électronique
|Description=Créer un détecteur de présence qui allumera une LED en cas de passage de personne. Le montage sera basé sur le capteur de distance à ultrason que l’on utilisera sous forme de seuil. On partira donc du principe que le montage sera installé à un point fixe et que l’on détecte le passage devant le capteur (Comme c’est le cas dans un couloir par exemple).
|Difficulty=Facile
|Cost=15
|Currency=EUR (€)
|Duration=20
|Duration-type=minute(s)
|Licences=Attribution (CC BY)
}}
{{Introduction}}
{{Materials
|Material=* Un Arduino
* Un câble USB
* Un capteur de distance à ultrason
* Une LED et sa résistance
* Une Breadboard
* Des fils de connexions
}}
{{Separator}}
{{Tuto Step
|Step_Title=Câblage
|Step_Content=Ce montage se basera sur le câblage du capteur ci-contre en lui ajoutant un ensemble LED + résistance sur la Pin Digital 1.

* Digital 12 (Arduino) → Trig (Ultrason)
* Digital 13 (Arduino) → Echo ( Ultrason)
* 5V (Arduino) → VCC (Ultrason)
* GND (Arduino) → GND (Ultrason)
* Digital 1 (Arduino) → LED (Anode)
* LED (cathode) → Résistance
* GND (Arduino) → Résistance
}}
{{Tuto Step
|Step_Title=Programmation
|Step_Content=Le programme utilise la librairie Ultrasonic. Il faut donc l’installer, c’est-à-dire la copier dans votre répertoire Mes documents / Arduino / librairies.

Le programme va paramétrer le module ultrason grâce au commande de la librairie (Pour plus d’info http://wiki.tetrasys-design.net/HCSR04Ultrasonic), ensuite il compare à une valeur enregistrer si il détecte un objet ou une personne à moins de cette distance on allume la LED sinon on l’éteint.

#include

const int Trig = 12; // pin "Trig" du HC-SR04 connectée à pin 13 de l'Arduino
const int Echo = 13; // pin "Echo" du HC-SR04 connectée à pin 12 de l'Arduino

const int LED = 1; // pin connecté à la LED + resistance

const int green = 10; // LEDs reliées aux pins de l'Arduino via une résistance
const int yellow = 11; // de 150 Ohms.
const int red = 12;

long cm; // variable pour stocker la distance de l'objet en cm

Ultrasonic HCSR04(Trig,Echo);

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

void loop()
{

cm = HCSR04.convert(HCSR04.timing(), 1);

if(cm > 0 && cm < 20) // Il y a une présence { digitalWrite(LED, HIGH); // Allumer la LED delay(10); // Temps de traitement } else if(cm >= 20) // Il n'y a pas de présence
{
digitalWrite(LED, LOW); // Eteindre la LED
delay(10); // Temps de traitement
}
}
}}
{{Notes}}
{{Tuto Status}}

Plante connectée

2016-09-29T16:18:52Z

Letmeknow :

{{Tuto Details
|Type=Création
|Area=Alimentation & Agriculture, Électronique
|Description=Le but de ce montage est de mesurer l’humidité du sol et allumer une LED lorsque la plante doit être arrosée.
|Difficulty=Facile
|Cost=25
|Currency=EUR (€)
|Duration=1
|Duration-type=heure(s)
|Licences=Attribution - Partage dans les Mêmes Conditions (CC BY-SA)
|Main_Picture=Plante_connect_e_Final-01.jpg
}}
{{Introduction
|Introduction='''Caractéristiques:'''
# Ceci est un capteur d’humidité simple qui peut être utilisé pour détecter lorsque qu’un sol est en déficite d’eau (niveau haut) et vice versa (niveau bas). Ce module peut être utilisé pour réaliser des systèmes d’arrosage automatique.
# La sensibilité de ce module est ajustable via un potentiomètre numérique (En bleu sur la photo)
# Tension de fonctionnement : 3,3V-5V
# Module avec 2 sorties: Une analogique et une numérique. La sortie numérique est plus précise.
# Le module comprend des perçages pour faciliter la fixation.
# Taille du PCB: 3cm * 1.6cm
# Indicateur de tension (LED rouge) and Indicateur de sortie numérique (LED verte)
# Le comparateur est basé sur un LM393 (très stable)
}}
{{Materials
|Material=* Un Arduino
* Un câble USB
* Une LED
* Une résistance 220Ohm (Optionnelle)
* Un capteur d’hygrométrie + sa carte associée + ses câbles
* Une breadboard
* Des fils de connections
|Tools=* Tournevis
}}
{{Separator}}
{{Tuto Step
|Step_Title=Branchement de la LED
|Step_Content=Pour le branchement de la LED nous allons réutiliser le principe du montage « Allumer une LED » avec la sortie Digital 3 du Arduino.

{{Info|Text=La programmation du montage est assez proche de celle utilisée avec un simple bouton. On paramètre les entrées (Capteur) et sorties (LED) du Arduino dans la fonction setup. Si l’entrée lue correspondant au capteur est à l’état haut (HIGH) on allume la LED. Si l’entrée lu est à l’état bas, on éteint la LED.}}

<code>
const int L1 = 2; // broche 2 du micro-contrôleur se nomme maintenant : L1
const int plante = 3; // broche 3 du micro-contrôleur se nomme maintenant : plante
void setup() // fonction d'initialisation de la carte
{ // contenu de l'initialisation
pinMode(L1, OUTPUT); // L1 est une broche de sortie
pinMode(plante, INPUT); // plante est une broche d entree
}
void loop() // fonction principale, elle se repete (s execute) a l'infini
{ // contenu du programme
int humide = digitalRead(plante); // Lecture de l etat du capteur
if(humide == HIGH) // Si le capteur est a l etat haut
{
digitalWrite(L1, HIGH); // Allumer L1
}
else // Sinon
{
digitalWrite(L1, LOW); // Eteindre L1
}
delay(1000); // Attendre 1 seconde
}
</code>
}}
{{Tuto Step
|Step_Content=Il reste à brancher le Arduino pour compiler le programme et le téléverser.

Une fois terminé cela nous donne
}}
{{Tuto Step
|Step_Title=Pour aller plus loin
|Step_Content=Essayez de modifier le seuil de déclenchement (le bouton bleu à tourner avec un petit tournevis).
}}
{{Notes}}
{{Tuto Status}}

Plante connectée

2016-09-29T16:16:09Z

Letmeknow : Page créée avec « {{Tuto Details |Type=Création |Area=Alimentation & Agriculture, Électronique |Description=Le but de ce montage est de mesurer l’humidité du sol et allumer une LED lor... »

Fichier:Plante connect e Final-01.jpg

2016-09-29T16:13:28Z

Letmeknow : Fichier téléversé avec MsUpload

Fichier téléversé avec MsUpload