Fil rouge : Différence entre versions

De FunLab Documentation
Aller à : navigation, rechercher
(Page créée avec « Rendre sa maison intelligente... Suivre sa consommation électrique, ou une interface avec un réseau 833Mhz, asservissement prise de courant, Interface WEB de pilotage,... »)
 
(Aucune différence)

Version actuelle datée du 20 avril 2017 à 14:05

Rendre sa maison intelligente... Suivre sa consommation électrique, ou une interface avec un réseau 833Mhz, asservissement prise de courant, Interface WEB de pilotage, Interface SMS de notification..Detection panne de courant…


Cours du mardi 04/11/2014:

Matériels

  • 1 Arduino Méga 2560 Réf. :20-011-910
  • 1 Shield ethernet W5100 Réf. :20-011-903
  • 1 Capteur de température LM35DZ
  • 1 Capteur de température DS18B20
  • 1 Capteur de température sonde étanche Ds18B20
  • 1 Module 8 relais 5v/220v 10A(mini) Réf. :20-018-102

Ressources

Présentation débutants Arduino capteurs et relais -1-

Voir le Quiz— –Et les réponses

- Ci-dessous un exemple de code pour Arduino Mega -

Relais et capteur de température

relais_celsius.ino
 
#Define RELAY_1 2
//Le compilateur remplacera toute mention de RELAY_1   avec la valeur 2  au moment de la compilation.
//Cette ligne n'utilise pas de mémoire programme

#Define RELAY_2 3
int analogPin = 0;
float temp = 0;
void setup()
{
  Serial.begin(9600);
 analogReference(INTERNAL1V1);
 pinMode(RELAY_1, OUTPUT);
 pinMode(RELAY_2, OUTPUT);

}
void loop()
{
temp = ((analogRead(analogPin)*1.1/1024)*100);
  Serial.print("valeur entre 0 et 1023 =  ");
  Serial.println(analogRead(analogPin));/* représente la tension entre 0 et 5v en sortie du capteur de température */
  Serial.print("Temperature :  ");
  Serial.print(temp);                   /* affiche la température positive */
  Serial.println("  Degres celsius ");
  Delay(1000);
 AM_relais( RELAY_1, temp);
 }

void AM_relais(int pin, float temper) {

 if (temper <= 18){
    digitalWrite(pin, LOW);
   }
 if ( temper >= 25) {
     digitalWrite(pin, HIGH);
 }
}

Présentation avancés Arduino Sheild Réseau W5100 par Jean-François

Présentation avancés Arduino Shield Réseau W5100 par Jean-François

Exemple webserver arduino

- code pour tester la fonction de serveur sur Arduino à prendre dans les exemples de son IDE :

Exemple –> Ethernet —> WebServer

si vous branchez votre carte ethernet arduino en direct sur votre PC , il vous faut passer votre adresse ip en fixe sur le PC et sur la carte ethernet arduino dans le même réseau exemple : 192.168.3.1 sur le pc et 192.168.3.2 sur la carte ethernet arduino

Le but de cet exemple c'est de voir les valeurs aléatoires des broches analogiques de A0 à A5 sur le client web en se connectant sur l'adresse 192.168.3.2

exemple_webserver.ino
/*   Web Server 
 A simple web server that shows the value of the analog input pins. 
 using an Arduino Wiznet Ethernet shield.   
 Circuit:  
* Ethernet shield attached to pins 10, 11, 12, 13  
* Analog inputs attached to pins A0 through A5 (optional)
    created 18 Dec 2009  by David A. Mellis  modified 9 Apr 2012  by Tom Igoe    */

#Include <SPI.h>
#Include <Ethernet.h>

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
};
IPAddress ip(192, 168, 1, 177);

// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {; // wait for serial port to connect. Needed for Leonardo only
  }

  // start the Ethernet connection and the server:
  Ethernet.begin(mac, ip);
  server.begin();
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}

void loop() {
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    Serial.println("new client");
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c);
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: close");  // the connection will be closed after response
          client.println("Refresh: 5");  // refresh the page automatically every 5 sec
          client.println();
          client.println("&lt;!DOCTYPE HTML&gt;");
          client.println("&lt;html&gt;");
          // output the value of each analog input pin
          for (int analogChannel = 0; analogChannel &lt;6; analogChannel++) {
            int sensorReading = analogRead(analogChannel);
            client.print("analog input ");
            client.print(analogChannel);
            client.print(" is ");
            client.print(sensorReading);
            client.println("&lt;br /&gt;");
          }
          client.println("&lt;/html&gt;");
          break;
        }
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection:
    client.stop();
    Serial.println("client disconnected");
  }
}

Test dhcp

- Code à prendre dans les exemples IDE arduino :

Exemple –> Ethernet —> DhcpAdressPrint

il faut brancher votre pc sur votre Box internet et mettre une adresse IP fixe dans votre carte ethernet arduino compatible avec le reseau

DhcpAdressPrint.ino
/*   DHCP-based IP printer    
This sketch uses the DHCP extensions to the Ethernet library.
It get an IP address via DHCP and print the address obtained.
It uses an Arduino Wiznet Ethernet shield.   
 Circuit:  
* Ethernet shield attached to pins 10, 11, 12, 13    
created 12 April 2011  modified 9 Apr 2012  by Tom Igoe    */

#Include <SPI.h>
#Include <Ethernet.h>

// Enter a MAC address for your controller below.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
byte mac[] = {
  0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02
};

// Initialize the Ethernet client library
// with the IP address and port of the server
// that you want to connect to (port 80 is default for HTTP):
EthernetClient client;

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  // this check is only needed on the Leonardo:
  while (!Serial) {; // wait for serial port to connect. Needed for Leonardo only
  }

  // start the Ethernet connection:
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // no point in carrying on, so do nothing forevermore:
    for (;;);
  }
  // print your local IP address:
  Serial.print("My IP address: ");
  for (byte thisByte = 0; thisByte &lt;4; thisByte++) {
    // print the value of each byte of the IP address:
    Serial.print(Ethernet.localIP()[thisByte], DEC);
    Serial.print(".");
  }
  Serial.println();
}

void loop() {

}

Cours du mardi 02/12/2014

Ressources

Présentation débutants Arduino Introduction reseau Arduino -2-

Test du shield

Attention.png

test_shield.ino
 
# Include  // librairie SPI - obligatoire avec librairie Ethernet
# Include  // librairie Ethernet

//--- l'adresse mac = identifiant unique du shield
// à fixer arbitrairement ou en utilisant l'adresse imprimée sur l'étiquette du shield
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x1A, 0x71 };

//----- l'adresse IP fixe à utiliser pour le shield Ethernet ---
IPAddress ipLocal(192,168,1,3); // l'adresse IP locale du shield Ethernet

void setup() { // debut de la fonction setup()

Serial.begin(115200); // Initialise la connexion Série ( ne pas oublier de la modifier dans l'IDE arduino )

//Ethernet.begin(mac); // forme pour attribution automatique DHCP - utilise plus de mémoire Flash (env + 6Ko)
Ethernet.begin(mac, ipLocal); // forme conseillée pour fixer IP fixe locale
//Ethernet.begin(mac, ipLocal, serverDNS, passerelle, masque); // forme Complète

delay(1000); // donne le temps à la carte Ethernet de s'initialiser
Serial.print("L'adresse IP du shield Ethernet est :" ); Serial.println(Ethernet.localIP()); } // fin de la fonction setup() void loop(){ // debut de la fonction loop() while(1); // stop loop } // fin de la fonction loop()

Présentation débutants Arduino Introduction Serveur_html Arduino -2-

intro_serveur_html.ino
 
// --- Inclusion des librairies ---

# Include  // librairie SPI - obligatoire avec librairie Ethernet
# Include  // librairie Ethernet

// --- Déclaration des variables globales ---
//--- l'adresse mac = identifiant unique du shield
// à fixer arbitrairement ou en utilisant l'adresse imprimée sur l'étiquette du shield
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x1A, 0x71 };
//----- l'adresse IP fixe à utiliser pour le shield Ethernet ---
IPAddress ipLocal(192,168,1,150); // l'adresse IP locale du shield Ethernet
// ATTENTION : il faut utiliser une adresse hors de la plage d'adresses du //routeur DHCP
// pour connaitre la plage d'adresse du routeur : s'y connecter depuis un// //navigateur à l'adresse xxx.xxx.xxx.1
// par exemple : sur livebox : plage adresses DHCP entre .10 et .50 => on peut
//utiliser .100 pour le shield ethernet
// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---
//--- création de l'objet serveur ----
EthernetServer serveurHTTP(80); // crée un objet serveur utilisant le port 80 //=port HTTP
String chaineRecue=""; // déclare un string vide global pour réception chaine //requete
int comptChar=0; // variable de comptage des caractères reçus

void setup()

{ // debut de la fonction setup()
// --- ici instructions à exécuter 1 seule fois au démarrage du programme ---
// ------- Initialisation fonctionnalités utilisées -------
Serial.begin(9600); // Initialise connexion Série
//---- initialise la connexion Ethernet avec l'adresse MAC du module Ethernet, //l'adresse IP Locale
//---- +/- l'adresse IP du serveurDNS , l'adresse IP de la passerelle internet et le
//masque du réseau local
//Ethernet.begin(mac); // forme pour attribution automatique DHCP - utilise plus
//de mémoire Flash (env + 6Ko)
Ethernet.begin(mac, ipLocal); // forme conseillée pour fixer IP fixe locale
//Ethernet.begin(mac, ipLocal, serverDNS, passerelle, masque);
// forme complète
delay(1000); // donne le temps à la carte Ethernet de s'initialiser
Serial.print("Shield Ethernet OK : L'adresse IP du shield Ethernet est :" ); Serial.println(Ethernet.localIP()); //---- initialise le serveur ---- serveurHTTP.begin(); Serial.println("Serveur Ethernet OK : Ecoute sur port 80 (http)"); } // fin de la fonction setup() void loop(){ // debut de la fonction loop() // crée un objet client basé sur le client connecté au serveur EthernetClient client = serveurHTTP.available(); if (client) { // si l'objet client n'est pas vide // le test est VRAI si le client existe // message d'accueil dans le Terminal Série
Serial.println ("--------------------------");
Serial.println ("Client present !");
Serial.println ("Voici la requete du client:");

////////////////// Réception de la chaine de la requete //////////////////////////
//-- initialisation des variables utilisées pour l'échange serveur/client
chaineRecue=""; // vide le String de reception
comptChar=0; // compteur de caractères en réception à 0
if (client.connected()) { // si le client est connecté

/////////////////// Réception de la chaine par le réseau ////////////////////////
while (client.available()) { // tant que des octets sont disponibles en lecture
// le test est vrai si il y a au moins 1 octet disponible
char c = client.read(); // l'octet suivant reçu du client est mis dans la variable c
comptChar=comptChar+1; // incrémente le compteur de caractère reçus Série reçue
Serial.print(c); // affiche le caractère reçu dans le Terminal
//--- on ne mémorise que les n premiers caractères de la requete
//--- afin de ne pas surcharger la RAM et car cela suffit pour l'analyse de la requete
if (comptChar<=100) chaineRecue=chaineRecue+c; // ajoute le caractère reçu au String
//pour les N premiers caractères
//else break;
// une fois le nombre de caractères dépassés sort du while
} // --- fin while client.available = fin "tant que octet en lecture"
Serial.println ("Reception requete terminee");

/////////////////// Affichage de la requete reçue //////////////////////
Serial.println(F("------------ Affichage de la requete recue ------------"));
// affiche le String de la requete
Serial.println (F("Chaine prise en compte pour analyse : "));
Serial.println(chaineRecue); // affiche le String de la requete pris en compte pour analyse
/////////////////// Analyse de la requete reçue //////////////////////
Serial.println(F("------------ Analyse de la requete recue ------------")); //analyse le String de
//la requete
//------ analyse si la chaine reçue est une requete GET --------
if (chaineRecue.startsWith("GET")) { // si la chaine recue commence par GET
Serial.println (F("Requete HTTP valide !"));
//-- envoi de la réponse HTTP ---
client.println("HTTP/1.1 200 OK"); // entete de la réponse : protocole HTTP 1.1 et
//exécution requete réussie
client.println("Content-Type: text/html"); // précise le type de contenu de la réponse qui //suit
client.println("Connnection: close"); // précise que la connexion se ferme après la
 //réponse
client.println(); // ligne blanche
//--- la reponse à afficher dans le navigateur
client.println("Reception de la reponse du serveur http !"); // message texte qui
//va //s'afficher dans le navigateur client
//--- envoi en copie de la réponse http sur le port série
Serial.println("La reponse HTTP suivante est envoyee au client distant :");
Serial.println("HTTP/1.1 200 OK");
Serial.println("Content-Type: text/html");
Serial.println("Connnection: close");
Serial.println();

//------ début de la page HTML -------
client.println("<!DOCTYPE html>");
// code HTML pour police jaune sur fond bleu
//
client.print(""); // ">
client.println("
");
// affiche chaines caractères simples
client.print("Coucou !");
client.println("
"); // saut de ligne HTML
client.print("Tu vas bien ? ");
client.println("
"); // saut de ligne HTML
client.print("Arduino fait le serveur pour te servir !! ");
client.println("
"); // saut de ligne HTML
// code HTML pour inclure une image à partir lien web
//

client.println("
");//

client.print("[[Fichier:),client.print(]]"); // ">
client.println("
");//
//-------- fin de la page HTML -------
} // fin if GET
else { // si la chaine recue ne commence pas par GET
Serial.println (F("Requete HTTP non valide !"));
} // fin else
//------ fermeture de la connexion ------
// fermeture de la connexion avec le client après envoi réponse
delay(1); // laisse le temps au client de recevoir la réponse
client.stop();
Serial.println(F("------------ Fermeture de la connexion avec le client------------")); // affiche
//le String de la requete
Serial.println (F(""));
} // --- fin if client connected
} //---- fin if client ----
} // fin de la fonction loop()

Logo arduino new 150.png

Serveur web

  • Un programme à tester de serveur web Arduino proposé par Fernand
Serveur_web_exemple.ino
 
//Ethernet Switch
//
//Intro:
//This will swich on and off outputs trough your mobile device.
//No images or links to images. CSS3 and HTML5 use.
//Though it work with other web browser, we suggest Safari for best experiance.
//
//Version: Web Server Ethernet Switching Version 3.05
//Author: Claudio Vella - Malta
//Initial code from: http://bildr.org/2011/06/arduino-ethernet-pin-control/
//Made lot of comments for beginners.

//ARDUINO 1.0+ ONLY

# Include
# Include

////////////////////////////////////////////////////////////////////////
//CONFIGURE
////////////////////////////////////////////////////////////////////////

  //IP manual settings
  byte ip[] = { 192, 168, 0, 177 }; //Manual setup only
  byte gateway[] = { 192, 168, 0, 254 }; //Manual setup only
  byte subnet[] = { 255, 255, 255, 0 }; //Manual setup only

  // if need to change the MAC address (Very Rare)
  byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

  //Ethernet Port
  EthernetServer server = EthernetServer(80); //default html port 80
 <br>
  //The number of outputs going to be switched.
  int outputQuantity = 8; //when added to outputLowest result should not exceed 10
 <br>
  //The lowest output pin we are starting from
  int outputLowest = 2; //Should be between 2 to 9
////////////////////////////////////////////////////////////////////////

  // Variable declaration
  int outp = 0;
  boolean printLastCommandOnce = false;
  boolean printButtonMenuOnce = false;
  boolean initialPrint = true;
  String allOn = "";
  String allOff = "";
  boolean reading = false;
  boolean readInput[10]; //Create a boolean array for the maximum ammount.

//Beginning of the program
void setup(){
  Serial.begin(9600);

  //Pins 10,11,12 & 13 are used by the ethernet shield
  //Set pins as Outputs
  for (int var = outputLowest; var < outputLowest + outputQuantity; var++) {
            pinMode(var, OUTPUT);
        }
digitalWrite(9, HIGH);//allume la sortie 9 au depart
  //Setting up the IP address. Comment out the one you dont need.
  //Ethernet.begin(mac); //for DHCP address. (Address will be printed to serial.)
  Ethernet.begin(mac, ip, gateway, subnet); //for manual setup. (Address is the one configured above.)

  server.begin();
  Serial.println(Ethernet.localIP());
}

void loop(){

  // listen for incoming clients, and process requests.
  checkForClient();
}

void checkForClient(){

  EthernetClient client = server.available();

  if (client) {

    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    boolean sentHeader = false;

    while (client.connected()) {
      if (client.available()) {

        if(!sentHeader){
         // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connnection: close");
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("");

          // add page title
          client.println("Telecommande Ethernet");
          client.println("");

          // add a meta refresh tag, so the browser pulls again every 5 seconds:
          client.println("");

          // add other browser configuration
          client.println("");
          client.println("");
          client.println("");

//
//-------- debut de la page HTML -------
    client.println("<br>");// <br>
    client.print("[[Fichier:),client.print(]]") ; // " >
client.println("
");//
//-------- fin de la page HTML -------

//
//-------- debut de la page HTML -------
// client.println("
");//

// client.print("[[Fichier:),client.print(]]") ; // " >
//client.println("
");//
//-------- fin de la page HTML -------

          //inserting the styles data, usually found in CSS files.
          client.println("");
          client.println("");
 <br>
          //now printing the page itself
          client.println("");
          client.println("<div>");
          client.println(" <div>");
          client.println(" Telecommandes Ethernet");
          client.println(" </div>");
          client.println("<div>");
          client.println(" Allumez ou Eteignez la sortie .");
          client.println();
 <br>
          //This is for the arduino to construct the page on the fly.
          sentHeader = true;
        }
 <br>
        char c = client.read();

        if(reading && c == ' '){
          reading = false;
          }
 <br>
// Serial.print(c);

        if(c == '?') {
          reading = true; //found the ?, begin reading the info
        }
 <br>

        if(reading){
            if(c == 'H') {outp = 1;}
            if(c == 'L') {outp = 0;}
          Serial.print(c); //print the value of c to serial communication
          //Serial.print(outp);
          //Serial.print('\n');
 <br>
           switch (c) {
            case '2':
              //add code here to trigger on 2
              triggerPin(2, client, outp);
              break;
            case '3':
            //add code here to trigger on 3
              triggerPin(3, client, outp);
              break;
            case '4':
            //add code here to trigger on 4
              triggerPin(4, client, outp);
              break;
            case '5':
            //add code here to trigger on 5
              triggerPin(5, client, outp);
              //printHtml(client);
              break;
            case '6':
            //add code here to trigger on 6
              triggerPin(6, client, outp);
              break;
            case '7':
            //add code here to trigger on 7
              triggerPin(7, client, outp);
              break;
            case '8':
            //add code here to trigger on 8
              triggerPin(8, client, outp);
              break;
            case '9':
            //add code here to trigger on 9
              triggerPin(9, client, outp);
              break;
          }

        }

        if (c == '\n' && currentLineIsBlank){
          printLastCommandOnce = true;
          printButtonMenuOnce = true;
          triggerPin(777, client, outp); //Call to read input and print menu. 777 is used not to update any outputs
          break;
        }
      }
    }
 <br>
    //Set Variables Before Exiting
    printLastCommandOnce = false;
    printButtonMenuOnce = false;
 <br>
    allOn = "";
    allOff = "";
    client.println("\n© Author - Claudio Vella <br> Malta - October - 2012");
    client.println("</div>\n</div>\n\n");
 <br>
    delay(1); // give the web browser time to receive the data
    client.stop(); // close the connection:

  }

}

void triggerPin(int pin, EthernetClient client, int outp){
//Switching on or off outputs, reads the outputs and prints the buttons

  //Setting Outputs
    if (pin != 777){
        if(outp == 1) {
          digitalWrite(pin, HIGH);
         }
        if(outp == 0){
          digitalWrite(pin, LOW);
         }
    }
  //Refresh the reading of outputs
  readOutputStatuses();
 <br>
 <br>
  //Prints the buttons
          if (printButtonMenuOnce == true){
              printHtmlButtons(client);
               printButtonMenuOnce = false;
          }
 <br>
}

//print the html buttons to switch on/off channels
void printHtmlButtons(EthernetClient client){

     //Start to create the html table
     client.println("");
     //client.println("

");
     client.println("");
     client.println("

{|
");
 <br>
     //Start printing button by button
     for (int var = outputLowest; var < outputLowest + outputQuantity; var++) {
 <br>
              //set command for all on/off
              allOn += "H";
              allOn += var;
              allOff += "L";
              allOff += var;
 <br>
 <br>
              //Print begining of row
              client.print("
|-
\N");
 <br>
              //Prints the ON Buttons
              client.print("
| \N");
 <br>
              //Prints the OFF Buttons
              client.print("
| \N");
 <br>
 <br>
              //Print first part of the Circles or the LEDs
              if (readInput[var] == true){
                client.print("
| <div class="green-circle">
</div>\N");
 <br>
              }else
              {
                client.print("
| <div class="black-circle">
</div>\N");
              }
 <br>
 <br>
              //Print end of row
              client.print("\n");
         }
 <br>

              //Prints the ON All Pins Button
              client.print("
|-
\N
| \N");
 <br>
              //Prints the OFF All Pins Button
              client.print("
| \N
| \N\n");
 <br>
              //Closing the table and form
              client.println("
|}

");
              Client.println("");
              //client.println("

");
 <br>
    }

//Reading the Output Statuses
void readOutputStatuses(){
  for (int var = outputLowest; var < outputLowest + outputQuantity; var++) {
            readInput[var] = digitalRead(var);
            //Serial.print(readInput[var]);
       }
 <br>
}

Cours du mardi 13/01/2015

Comment se connecter à distance à son arduino via sa box

1-Création d'un compte No-ip ( http://www.noip.com/ ) pour avoir un nom de domaine ( ex = http://funlabarduino@ddns.net )

qui reconnaissent son adresse IP public noter le login et mot de passe. Vérifier que l'adresse publique de la box et bien celle reconnue par No-IP


2- Dans la plage des adresses libres de la box , mettre une adresse disponible dans l'arduino ex : 192.168.1.215

3- En prenant l'exemple d'une live box play réserver l@ ip de l'arduino dans la plage des adresses en @Ip statique. Ex : 192,168,1,215 créer un zone DMZ avec cette @Ip 192,168,1,215 dans l'onglet DynDns , créer la ligne No-IP avec le nom de domaine demandé sur le compte No-IP et inserer le login mot de passe

4- lancer le programme dans l'arduino, connecter l'arduino sur le réseau.

5- A partir d'une autre connexion internet ( soit en 3G/4G soit sur autre box) dans le navigateur taper le nom de domaine renseigner dans No-IP (ex http://funlanarduino.ddns.net )

Tutoriel création NO-IP www.mon-ip.com

http://www.mon-ip.com/obtenir-une-adresse-ip-fixe.php

Cours du mardi 27/01/2015:

Présentation i2c

Une présentation faite par Herve : Présentation I2C par Herve-1-

Une doc technique sur l'I2C en Anglais : Datasheet i2c-2-

Une doc technique en français sur Wikipédia : Une_doc I2C sur Wikipédia en francais-3-

Mise en pratique : relier 2 Arduinos en I2C

Schéma:


Arduino_I2C










le programme Maitre à télécharger dans l'arduino Maitre:


I2C_MAITRE_LED_001.ino
#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
}


le programme Esclave à télécharger dans l'arduino Esclave  :

I2C_Esclave_LED_001.ino
#include <Wire.h>;

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

Mardi 31 Mars 2015 - Présentation du projet domotique de Christian

Projet domotique Christian


Le diaporama

Le mardi 31/03/2015 Christian nous a présenté son projet domotique qu'il à assemblé avec un arduino , un raspberryPi et des récepteur 433,92 Mhz.

Diaporama de Christian

Le lien vers son site web

le site de Christian

Les codes du projet

Les codes

La suite

Christian nous propose de continuer par des exercices pratiques en nous expliquant pas à pas comment faire fonctionner son projet lors de soirées à venir.

les pistes :

- Charger un raspberryPi avec la distribution Rasbian

- Création du serveur web

- Comment faire dialoguer le raspberry et l'arduino

- Comment faire dialoguer l'arduino et les modules 433

Mardi 16 Juin 2015 - Présentation de la réalisation domotique de jean-Paul

commande à distance maison jean paul

Jean Paul nous à présenté son installation domotique qu'il à réalisé dans sa maison au tout début de sa construction à l'aide d'un Automate Schneider Premium , ensuite il nous a présenté sa solution via RaspberryPI pour surveiller sa consommation électrique.

Son diaporama

Diaporama présenté par Jean-Paul