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 »);
}
Hello,
Je suis étudiante et je dois actuellement réaliser un projet sur la technologie Li-Fi.
J’a particulièrement été fascinée par ce projet et souhaiterais le reproduire tout en vous mentionnant dans ma recherche.
Mais comme je suis encore une débutante, j’aurais besoin de votre aide et de vos conseils si c’est possible.
Aidez une jeune étudiante à réussir et quelqu’un vous aidera sûrement un jour ou l’autre 🙂
Bonne journée !
SOFIA svp pouviez me contacter mon mail :mohamedhat2b.com
Je suis également intéressé par LI-fi Arduino, c’est ma mimoire de graduation, pouvons-nous coopérer?