Développement d’une lampe à messages et envoi de texto en Light Fidelity (LIFI)

Envoyé par le 28 Juin 2017

Développement d’une lampe à messages et envoi de texto en Light Fidelity (LIFI) par Adrien Clotteau, Serigne Diouf et Stanislas Evain.

Le Wi-Fi, protocole de communication sans fil propagé par ondes radio, peut être complété par le Li-Fi. Ce dernier utilise la lumière comme support de propagation en utilisant des LED de puissance, modulées à  très hautes fréquences.

Le but de ce projet est de réaliser un démonstrateur de télégraphe optique automatique utilisant le principe du LIFI. Notre objectif est de transmettre un message SMS d’un téléphone à  un autre via un système constitué d’un émetteur et d’un récepteur qui communiquent par voie optique. Nous avons ajouté cette fonctionnalité à  un objet existant, une lampe torche, tout en conservant sa fonction première.

Une application Android capable de gérer l’émission et la réception des messages fait le lien avec notre télégraphe via Bluetooth (elle joue le rôle d’interface homme machine). Dans chaque lampe, une carte Arduino met en forme le message à  l’émission et module la lumière. Le même Arduino fait le travail inverse à  la réception (démodulation et mise en forme) sur le principe de l’alternat. La performance du lien optique repose sur le choix d’un couple émetteur/récepteur qui offre la meilleure fiabilité : des diodes de forte puissances infrarouge (IR) à  l’émission et un détecteur optimisé pour l’IR à  la réception.

 

L’émetteur du prototype est composé de 8 LED visibles ne servant qu’à  la fonction éclairage de la lampe torche et de 3 LED IR reliées à  une carte Arduino, pour la transmission. L’utilisateur rentre une séquence de caractères via l’application Android. Le message est envoyé à  l’Arduino qui convertit le message sous forme binaire (en ASCII) et l’envoie sous la forme de signaux IR modulés. Un « 1 » correspond à  400 µs en état HIGH et à 200 µs en LOW. Un « 0 » correspond à  200 µs HIGH et 400 µs LOW. Cette forme de modulation a été choisie pour profiter des performances du détecteur.

La partie réceptrice du prototype est composée d’un capteur IR qui détecte le signal optique émis et l’envoie vers la carte Arduino sous la forme d’un courant à  deux niveaux. L’Arduino démodule le signal reçu, le convertit en bit puis en chaîne de caractère et envoie le message à  l’Android en sortie par liaison Bluetooth.

La dernière partie du projet consiste en sa miniaturisation. Le circuit doit tenir dans une lampe torche. Les composant utilisés ont été sélectionnés pour être les plus petits possibles (par exemple, utilisation d’une carte bluno beetle pour l’Arduino et le module Bluetooth, utilisation de shields pour diminuer la taille du montage fonctionnel).

 

 

Programme Arduino des systèmes émetteurs et récepteurs

Code

#include <SoftwareSerial.h>

 

SoftwareSerial moduleBT(5,6); //les pins RX et TX du module Bluetooth
const char ledSortie = 13; // l’emetteur infrarouge
const char LEDCAPTEUR=3; //le capteur infrarouge
String messageEncode= » »; //une chaine binaire 010101… correspondant à l’encodé du message provenant du téléphone et qu’on va envoyer sur le canal optique

 

void setup() {
// put your setup code here, to run once:

 

Serial.begin(9600);
moduleBT.begin(9600);
pinMode(LEDCAPTEUR, INPUT_PULLUP);
pinMode(ledSortie, OUTPUT);
digitalWrite(ledSortie,LOW);
moduleBT.write(« Module Pret »);
Serial.write(« pret pour un message »);
Serial.println( »   « );

}

 

void loop() {
// put your main code here, to run repeatedly:

 

encodage(); // transformer le message reçu par le module Bluetooth en une suite binaire
emission(); // utiliser cette suite binaire pour commander le canal optique
decodage(); // decoder le message provenant du canal optique et l’envoyer au téléphone via le module Bluetooth
/*unsigned long t=0;
unsigned long deb=micros();
while (micros()-deb <400){t++;}
Serial.println(t);
delayMicroseconds(1000);*/

}

//############################################# ENCODAGE ############################################################################################ void encodage(){    

while(moduleBT.available())  // tant que le module Bluetooth est en train de recevoir des donnees,

{

delay(3); // attend qu’il finisse de tout recevoir

String caractere = String(moduleBT.read(), BIN); //transforme chaque caractère du message grace à son code ASCII en binaire

while (caractere.length()<8) // tant que le caractere codé en binaire ne fait pas 8 bits,

{caractere=String(0)+caractere;} // alors compléter avec des ‘0’ au début pour qu’il fasse 8 bits=un octet

Serial.println(caractere);

messageEncode += caractere; //ajoute les 8 bits à ma grande chaine binaire } }

//############################################ EMISSION #############################################################################################

void emission(){

if (messageEncode.length() >0) // s’il y a un message binaire pret à envoyer sur le canal optique,

{

messageEncode = String(« 11111111 »)+messageEncode+String(« 0000 »);

Serial.println(messageEncode);

int smsLength=messageEncode.length();

int index=0;

while (index<smsLength){ // parcourir la chaine binaire

if(messageEncode[index] == ‘1’) //A chaque fois que je tombe sur un bit à ‘1’,

{digitalWrite(ledSortie, HIGH); // alors j’allume la lumière IR pendant 400 microsecondes

delayMicroseconds(400);

digitalWrite(ledSortie, LOW); // puis je l’éteins pendant 200 microsecondes

delayMicroseconds(200);

}

if (messageEncode[index] == ‘0’){//A chaque fois que je tombe sur un bit à ‘0’,

digitalWrite(ledSortie, HIGH);// alors j’allume la lumière IR pendant 200 microsecondes

delayMicroseconds(200);

digitalWrite(ledSortie, LOW);// puis je l’éteins pendant 400 microsecondes

delayMicroseconds(400);

}

index++ ;

}

messageEncode= » »; // à la fin de l’émission, réinitialise la chaine binaire pour un nouvel envoi} }
//########################## DECODAGE avec la lecture des registres #######################################################

void decodage(){

unsigned char nbreCaractere=0;

byte messageDecode[141]; // buffer où je stocke le message provenant du canal optique une fois qu’il est décodé, il doit etre au max de 140 caracteres

if (PIND & B00001000){ //si mon capteur détecte un signal IR,

//Serial.print(« signal détecté pour la premiere fois »);

//unsigned char nbreCaractere=0; //compteur du nombre de bits décodés

Serial.println(« ToutAzéroRegistre »);

//unsigned long PrevLOW=800;

while (nbreCaractere<141){ // tant que le message n’excede pas 140 caracteres,

char caractere=0;

char indexCaractere=0;

//Serial.println(« new octet »);

while (indexCaractere<8){

if (PIND & B00001000){// s il y a un front montant,

unsigned long timeLOW=0; //temps au bout duquel on ne detecte pas de lumiere IR

unsigned long timeHIGH=0; //temps au bout duquel on detecte de la lumiere IR

if (PIND & B00001000){ //si on detecte,

while(PIND & B00001000){

timeHIGH++;

}//prendre un chronometre pour le temps d’allumage}if (!(PIND & B00001000)){ // si on ne detecte pas,

while (!(PIND & B00001000) && (timeLOW<3000) ){

timeLOW++;

}//prendre un chronometre pour le temps d’extinction

}

char BIT= (timeLOW<timeHIGH); //decider du bit décodé en fonction des temps d allumage et d’extinction

//Serial.print(byte(BIT));

caractere=(caractere<<1)+BIT; // ajouter le bit décodé a l octet

indexCaractere++; //passer au bit suivant

}

else{ //si on ne detecte pas un front montant, c’est à dire pas de bit en transmission dans la canal optique

indexCaractere=8;  // alors arrete le decodage bit a bit (et sortir de la boucle)

//Serial.println(« je sors octet »);

}

}

//Serial.println(« je sors caractere »);

if (byte(caractere)>0){

messageDecode[nbreCaractere]=byte(caractere);

nbreCaractere++;}

else{nbreCaractere=141;}

//Serial.println(byte(nbreCaractere));

Serial.print(caractere);

}

Serial.println(« sortie finale »);

}

if ( byte(nbreCaractere)>0)

Serial.print(« sortie finale finale »);

}

Laisser une réponse

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *