1. Introduction

1.1 Contexte

Au Gymnase Provence, il y a dans chaque classe un moniteur général, qui doit chaque jour aller au secrétariat pour voir s’il y a des documents à prendre. Le problème, c’est que neuf fois sur dix, rien ne s’y trouve, et la seule fois du mois qu’on ne vérifie pas, il y a quelque chose, puis il se fait crier dessus. Il faudrait par conséquent mettre en place un système d'alerte au cas où il y aurait des documents. Pour ceci, il existe plusieurs solutions, comme un senseur de proximité, un laser, des ultra-sons; mais comme ces derniers sont relativement difficiles à obtenir, la solution proposée est un senseur de luminosité. L’idée est donc de placer un système avec un senseur lumineux dans le bac, qui détecte la présence de papier. Il devra ensuite envoyer un e-mail à la personne en question.
Ce travail tourne autour de la programmation (et la connexion à un réseau) et de la mise en place d'un système simple mais utile, et consiste donc à faciliter la tâche de cette personne. C'est, certes, un pas de plus vers le fainéant, mais dans la société moderne, c'est tout à fait justifiable.

2. Matériel et méthodes

2.1 Matériel

  • Micro-contrôleur Arduino
  • (Support Ethernet si possible, sinon Led supplémentaire)
  • 2 LEDs
  • Senseur de luminosité
  • Miroir

2.2 Circuit

Le principe est le suivant. Une LED clignote avec une fréquence constante (à déterminer, mais prenons une fois toutes les 30 minutes). Les pulsations de cette lumière sont réfléchies sur un miroir se trouvant sur la surface où seront déposés d'éventuels documents, puis envoyées sur sur le senseur lumineux. Cette configuration a été adoptée pour que le système puisse être attaché au dessus des papiers, pour gêner le moins possible. Il y a une séparation entre la Led est le senseur pour que le faisceau doive passer par le miroir et non pas directement, causant des erreurs. Voici les schémas du montage: Capture_d_ecran_2014-02-17_a_13.33.19.png Capture_d_ecran_2014-02-17_a_13.33.33.png

S'il n'y a pas d'obstruction, rien ne se produira (image du haut), mais s'il y a obstruction, le senseur ne détectera pas le taux normal de luminosité (image du bas), et par conséquent enverra un e-mail à qui cela concerne. Pour la pratique, toutefois, si le senseur détecte une obstruction, il allumera une LED à côté.
Le circuit a été construit de la manière suivante: Circuit_projet.png Le produit final est schématisé da la façon suivante: Screen_Shot_2014-02-18_at_9.13.55_PM.png Le schéma ne le montre pas, mais dedans sont la Led et le senseur comme mis plus haut. Il y a donc dans cette boîte deux trous inclinés de façon à ce que le faisceau de lumière de la Led se réfléchisse pour parvenir au senseur. Tous deux sont bien enfoncés dans la boîte pour que celle-ci fasse office de séparation.

2.3 Code

Le code utilisé pour faire fonctionner est basé sur le code de base pour le senseur lumineux (photocell). Quelques modifications ont été apportées pour inclure la Led clignotante, et la Led qui s'allume lors de l'interruption. Le voici:

int etatEmail = 0;
const int sensorPin = 0;
const int ledPin = 9;
const int led2 = 7;

int lightLevel, high = 0, low = 1023;

void setup()
{
  Serial.begin(9600);
  
  pinMode(ledPin, OUTPUT);
  pinMode(led2, OUTPUT);
  
  delay(3000);
}

void loop()
{
  autoTune();
  delay(1000); 

  analogWrite(ledPin, 255);
  delay(100);
  
  lightLevel = analogRead(sensorPin);  
   
  digitalWrite(ledPin, LOW);
  delay(900);
  
if (lightLevel > 200) {
  if (etatEmail == 0)
    digitalWrite(led2, HIGH);
    etatEmail = 1;
  }
  
  
   Serial.println(lightLevel);
   
}


void autoTune()
{
   
  if (lightLevel < low)
  {
    low = lightLevel;
  }
  
  if (lightLevel > high)
  {
    high = lightLevel;
  }
    
  lightLevel = map(lightLevel, low+30, high-30, 0, 255);
  lightLevel = constrain(lightLevel, 0, 255);
  
  
}

La fonction "autoTune" n'a pas été touchée, mais la fonction "manualTune" a été supprimée, car la première prenait déjà en charge ce qui nous intéressait: la lecture des valeurs lumineuses. Dans le "loop", il n'y avait à la base que la fonction de lecture de données du senseur. Le contrôle des Leds ont donc également été insérées, sans oublier dans le "setup" et les "define".

Le code qu'il suffit d'insérer au lieu de l'allumage de la Led2 est le suivant pour envoyer un e-mail. Il n'a pas été inclus parce que l'appareil auquel le mail doit être envoyé peut changer, mais aussi parce qu'il faut une sortie ethernet, quelque chose que l'Arduino ne possède pas, et qu'il faut se procurer. Mais si d'aventure il pouvait être obtenu, voici le code à utiliser:

#include <SPI.h>
#include <Ethernet.h>


byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x59, 0x67 };  
IPAddress ip( 192, 168, 2, 2 );    
IPAddress gateway( 192, 168, 2, 1 );
IPAddress subnet( 255, 255, 255, 0 );

char server[] = "email.yourdomain.com";

EthernetClient client;

void setup()
{
  Serial.begin(9600);
  pinMode(4,OUTPUT);
  digitalWrite(4,HIGH);
  Ethernet.begin(mac, ip, gateway, gateway, subnet); 
  delay(2000);
  Serial.println(F("Ready. Press 'e' to send."));
}

void loop()
{
  byte inChar;

  inChar = Serial.read();

  if(inChar == 'e')
  {
      if(sendEmail()) Serial.println(F("Email sent"));
      else Serial.println(F("Email failed"));
  }
}

byte sendEmail()
{
  byte thisByte = 0;
  byte respCode;

  if(client.connect(server,25)) {
    Serial.println(F("connected"));
  } else {
    Serial.println(F("connection failed"));
    return 0;
  }

  if(!eRcv()) return 0;
  Serial.println(F("Sending helo"));

  client.println(F("helo 1.2.3.4"));

  if(!eRcv()) return 0;
  Serial.println(F("Sending From"));

  client.println(F("MAIL From: <me@mydomain.com>"));

  if(!eRcv()) return 0;

  Serial.println(F("Sending To"));
  client.println(F("RCPT To: <you@yourdomain.com>"));

  if(!eRcv()) return 0;

  Serial.println(F("Sending DATA"));
  client.println(F("DATA"));

  if(!eRcv()) return 0;

  Serial.println(F("Sending email"));

  client.println(F("To: You <you@yourdomain.com>"));

  client.println(F("From: Me <me@mydomain.com>"));

  client.println(F("Subject: Arduino email test\r\n"));

  client.println(F("This is from my Arduino!"));

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

  if(!eRcv()) return 0;

  Serial.println(F("Sending QUIT"));
  client.println(F("QUIT"));

  if(!eRcv()) return 0;

  client.stop();

  Serial.println(F("disconnected"));

  return 1;
}

byte eRcv()
{
  byte respCode;
  byte thisByte;
  int loopCount = 0;

  while(!client.available()) {
    delay(1);
    loopCount++;

    if(loopCount > 10000) {
      client.stop();
      Serial.println(F("\r\nTimeout"));
      return 0;
    }
  }

  respCode = client.peek();

  while(client.available())
  {  
    thisByte = client.read();    
    Serial.write(thisByte);
  }

  if(respCode >= '4')
  {
    efail();
    return 0;  
  }

  return 1;
}


void efail()
{
  byte thisByte = 0;
  int loopCount = 0;

  client.println(F("QUIT"));

  while(!client.available()) {
    delay(1);
    loopCount++;

    if(loopCount > 10000) {
      client.stop();
      Serial.println(F("\r\nTimeout"));
      return;
    }
  }

  while(client.available())
  {  
    thisByte = client.read();    
    Serial.write(thisByte);
  }

  client.stop();

  Serial.println(F("disconnected"));
}

Il suffit de remplacer les informations concernant le mail, le destinataire, quel réseau, etc.

3. Résultats

Les résultats ont étés très différents d'un stage à l'autre du projet. Plus souvent que pas, lorsque le code était téléversé, rien ne se passait du tout, d'autres fois, le comportement était relativement aléatoire. Mais à la fin, tout a commencé à se concrétiser; les Leds commençaient à obéir aux ordres. Le résultat final est parfaitement ce qui a été prévu: la Led2 s'allume lorsque le niveau de lumière baisse suite à la mise d'un papier dans le bac.

4. Discussion

La partie facile a été la mise en place du système physique, vu que ça ne son que connexions simples. Ce qui a posé le plus de problèmes, toutefois, c'est le code Arduino. La syntaxe en elle même est assez simple, mais il faut savoir quoi utiliser et quand et comment. Ceci est donc la plus grande source des difficultés. A chaque fois que quelque chose ne fonctionnait pas, c'était parce qu'un fragment de code n'était pas au bon endroit, ou parce qu'il manquait un "delay" ou il fallait utiliser du "analog" au lieu de "digital", etc. L'orde est primordial. En effet, au premier essai de la lecture des valeurs de la lumière de la Led clignotante, il a fallu attendre un bon moment pour réaliser qu'il fallait le mettre juste après qu'elle s'allume. Ce qui se passait, c'était que la Led l'allumait, s'éteignait, puis seulement alors commençait le senseur à mesurer la valeur de la lumière (intelligent). La majorité des fautes étaient de cette nature.

Ce projet a apporté plusieurs choses: l'apprentissage de quelques notions en Arduino comme le "digital", le "analog", les conditions (parfois inutiles mais intéressantes à observer les résultats), sa syntaxe, sa logique, et le fait qu'il faut être précis lors de l'écriture d'un code.

5. Conclusion

Et maintenant, amusons-nous! Ce projet peut être pratique pour les boîtes aux lettres et les choses du même genre, mais le potentiel d'un système comme celui-ci est énorme. D'abord, il serait intéressant de mettre plusieurs casiers distincts sur un circuit Arduino, où il doit savoir lequel est lequel. Avec plus de temps, le senseur pourrait être remplacé par un système qui lit le document puis détermine son degré d'urgence, et le préciser dans le mail envoyé à la personne. Ou il pourrait être remplacé par un senseur de proximité ou laser pour détecter la présence non voulue de quelqu'un. Il existe des milliers d'applications possibles. Comparée à toutes les autres, celle-ci est probablement la plus facile, mais il faut bien commencer avec quelque chose pour élaborer par la suite.