Détecteur de reves REM

[heinekeken]

Bonjour à tous.

Je fais appel à vos connaissances car j ai besoin d aide pour terminer mon projet.
J utilise un réveil ZEO (réveil qui détecte les différentes phases de sommeil : sommeil léger /sommeil profond/ phase éveillée / phase REM (reve) ) couplé à un arduino + waveshield.

Grace à tout ça, je peux paramétrer l arduino / waveshield pour qu' il lance une sonnerie quand je suis en train de rever.

Je souhaite ajouter des leds à mon projet mais le problème c' est que je voudrais qu' elles s alument sans etre connectées directement à l' arduino. (par ex : leds fixées sur des lunettes)

Serait-ce possible avec le Kit d'émission et réception infra rouge ?

[Lionel]

Bonjour,

Avec l'IR, le récepteur et l'emetteur doivent être "alignés" (dans le champ de vision l'un de l'autre) pour communiquer, donc, si les lunettes sont sur vous (mais ai-je bien compris l'install ??) il risque d'être difficile d'assurer l'alignement
Dans ce cas, il vaut mieux se tourner vers de la radio fréquence (onde radio fréquence 315 ou 434MHz), nous n'en avons pas en catalogue, mais décrivez nous un peu plus votre projet (dans quel cadre ? y'a il un objectif ? quel est le matériel utilisé et comment ?) et on va peut être vous trouver une solution...

Lionel

[heinekeken]

Le but du projet est de parvenir à faire des reves lucides .
Un rêve lucide est un rêve qui se distingue par le fait que le rêveur a conscience d'être en train de rêver (wikipedia)
Je précise que le reve lucide n' est pas une étrangeté ésotérique mais existe bel et bien.
Dans un reve lucide, l' intéret est que vous pouvez controler votre reve...

Donc la base du projet est d' utiliser un réveil ZEO :

Grace à un bandeau pourvu de capteur, ce réveil analyse vos ondes électro encéphales afin de déterminer dans quel stade de sommeil vous etes.

Le reve a une partiularité, votre corps ne bouge presque pas, votre cerveau émet un certain type d' ondes (ondes lentes ) et vos yeux bougent rapidement sous vos paupieres . C' est ainsi que la phase du sommeil ou vous revez est appelée phase REM (rapid eyes mouvements) ou encore phase paradoxale.

Ce réveil est donc capable de détecter cette phase.

Certains dispositifs permettent d envoyer un signal lumineux pendant votre phase de reve , sans vous réveiller, afin que vous puissiez vous rendre compte que vous revez.

exemple: REM DREAMER / NOVA DREAMER :


ces masques de sommeil n' utilisent pas les ondes cérébrales mais détectent les mouvement occulaires.
Quand ils les détectent, ils vous envoient des signaux lumineux selon les parametres que vous aurez réglés au préalable.

Le problème de ces masques c' est qu'ils ne sont pas trés agréables à porter la nuit.

Ce que je souhaite donc faire, c' est d utiliser le réveil ZEO et ajouter la meme fonction que les masques ci dessus.


J utilise donc un arduino et un waveshield connectés au réveil ZEO.
J entre des paramètres dans l arduino de sorte à ce qu il analyse les informations détectées par le réveil et envoie une sonnerie par exemple aprés 5 mn consécutives de phase de reve.

Jusqu' à ce point la, tout est fonctionnel.

Ce que je voudrais ajouter c' est la fonction d' indices lumineux à l' aide de leds rouge. que je fixeraient sur un masque de nuit plus confortable que les systemes deja existants.
Mais le probleme c est que je ne veux pas que les leds soient reliées directement à l arduino auquel cas il me faudra eviter de bouger pendant mon sommeil !

Une autre chose que je souhaiterais jouter:
Pour l instant, les paramétrages de l arduino se font par le biais de mon ordi en changeant le code.
Je voudrais aussi savoir si il serait possible de modifier directement le code en ajoutant un ecran LCD et quelques boutons à l arduino et donc ne plus avoir besoin du pc

[Lionel]

Bonjour,

Amusant projet d'exploration du monde onirique

Concernant vos désirs d'évolution, plusieurs pistes sont envisageables :
- pour le masque de sommeil :
Arduino : un arduino mini light et son adaptateur de prog pour une légèreté élevée.
Liaison sans fil : une paire d'emetteur/récepteur RF (un pour la base, un pour le masque)
nous en avons qques échantillons, et nous sommes prêts a sponsoriser votre projet en vous offrant ces pièces de liaison radios en échange de la publication des infos de votre installation (code / câblage / éléments mis en oeuvre) sur notre forum/forum arduino et/ou blog.
Reste le problème de l'alimentation pour la portabilité, je vous laisse chercher ?!

- pour l'afficheur : ici aussi, plusieurs possibilités sont envisageables
Vous achetez un écran LCD 2x16 caractères et vous cablez vous même l'écran, arduino + lcd dans google
Vous achetez un shield LCD ( Ca tombe bien le notre sort la semaine prochaine ) en avant première une preview (un snootleak)

Snootleaks....

IMG_0203.JPG (95.53 Kio) Vu 10007 fois

(attention, l'écran est blanc sur bleu en contraste inversé ! de la bombe ... ) et il y a un joystick 5 positions 4 directions + select pour naviguer dans les menus que vous aurez codé pour modifier vos paramètres sans ordinateur le tout alimenté par un petit transfo !!!! whooooooooooooo

[heinekeken]

merci pour toutes ces informations !

Pour votre offre, c 'est vraiment gentil ! mais je suis un gros débutant, donc ça m embêterai que vous me postiez des pieces et que je n arrive pas à les utiliser. Surtout que je n' ai aucune idée du fonctionnement d un module RF ! j essaie de me renseigner et je vous tiens au courant,

je vous commande le nécessaire, mais est ce que vous etes deja en possession des LCD ? si oui y a moyen de commander ?

[Lionel]

Pas de souci vous choisissez bien sûr

Néanmoins, pour les modules RF ils sont extrêmement simples à utiliser à l'aide de la bibliothèque virtualwire (doc pdf)

Lib à télécharger ici : http://www.open.com.au/mikem/arduino/ pour info
il y a des exemples d'utilisation.

N'hésitez pas si vous avez des questions, nous avons expérimenté avec ces modules !

Et quelle que soit la solution choisie, continuez de nous faire profiter des avancées de votre installation, nous sommes curieux

merci à vous.

[heinekeken]

Bon c' est tout bon, j accepte avec grand plaisir votre offre !
Je viens de commander tout le nécessaire.
Je commence de poster tout le projet complet aprés avoir réussi à obtenir au moins l affichage des données du ZEO sur l afficheur LCD de l arduino.

Encore merci

[Lionel]

Avec plaisir,
merci a vous, nous ajoutons les modules a votre colis et nous sommes impatients de voir la suite !!

A bientôt

[heinekeken]

J ai cherché un peu pour une solution minimale en terme d' espace pour alimenter l arduino mini+recepteur+2 leds.
Je pense me tourner vers les piles bouton

Elles ont une capacité de 3v.
Je n ai cependant pas trouver le boitier nécessaire pour y clipser 3 piles.
Je n' en ai trouvé que pour une


ou deux max


Pensez vous que 6volt seraient suffisants ?

( au pire des cas je pourais toujours brancher les 3 réceptacles 1 pile ou encore 1 receptacle 2 piles + 1 receptacle 1pile en série pour otenir les 9volt )

si 6volt suffisent, j ai meme trouvé mieu... des réceptacles verticaux pour gagner quelques milimetres en épaiceur

[heinekeken]

en attendant que tout le matériel arrive, j' ai bossé un peu sur le code...
Et je suis confronté à mon premier problème:

tout fonctionne
une fois la phase souhaitée détectée, la musique se lance ( vib.wav) , la led s allume ( redled ) mais impossible de la faire clignoter pendant la lecture du fichier.

voila le code :

Code: Tout sélectionner

#include "SdReader.h"
#include "FatReader.h"
#include "WaveHC.h"
#include <avr/pgmspace.h>
#include "WaveUtil.h"
SdReader card;
FatVolume vol;
FatReader root;
FatReader f;
WaveHC wave;     
#define redled 9
int incomingByte = 0;   
byte header[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int NOMBRE = 0; // COMPTEUR
int SIZE = 0;
int *DATA;
int val;
int REMnombre = 0;
unsigned long digit = 0;
#define redled 10

void setup() {
 
  Serial.begin(38400);  // ouverture du port serial du ZEO, regle le debit donnees à 38400 bps
 
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
pinMode(redled, OUTPUT);

 
  if (!card.init()) {
    putstring_nl("initialisation SD : erreur !"); return;
  }
  if (!vol.init(card)) {
    putstring_nl("Pas de partition !"); return;
  }
  if (!root.openRoot(vol)) {
    putstring_nl("Impossible de trouver le fichier !"); return;
  }
  putstring_nl("Indice audio de lucidite :");
 
  ls();
}
void loop() {
        // attend les informations
        if (Serial.available() > 0) {
                // lecture des donnees :
                incomingByte = Serial.read();
                if ( incomingByte == 65 ) { holeHeader(); }  // nouvelles informations arrivent
                digitalWrite(redled, LOW);
        }
}
void holeHeader() {
  NOMBRE = 0;
  while ( NOMBRE < 10 ) {
        if (Serial.available() > 0) {
                header[NOMBRE] = Serial.read();
                NOMBRE++;
        }
  }
  SIZE = (( header[3] * 256 ) + header[2]);
  if ( SIZE > 20 ) { SIZE = 1; } // dont read long raw waveform packages
  if ( header[3] + header[5] == 255 & header[2] + header[4] == 255 ) { holeDaten(SIZE); }
  else { Serial.println(" CAPTEURS = AUCUNES INFORMATIONS DETECTEES ");}
  }
void holeDaten(int SIZE) {
DATA = (int*)calloc(1, SIZE * sizeof(int));
NOMBRE = 0;
while ( NOMBRE < SIZE ) {
  if (Serial.available() > 0) {
    DATA[NOMBRE] = Serial.read();
    NOMBRE++;
  }
}
if ( DATA[0] == 157 ) { Serial.print("Phase de sommeil ");
                       if (DATA[1] == 0) { Serial.println(": INCONNUE //phase cible// "); REMnombre++; }
                       if (DATA[1] == 1) { Serial.println(": EVEIL"); REMnombre = 0 ; }
                       if (DATA[1] == 2) { Serial.println(": REM"); REMnombre = 0 ; }
                       if (DATA[1] == 3) { Serial.println(": LEGER"); REMnombre = 0; }
                       if (DATA[1] == 4) { Serial.println(": PROFOND"); REMnombre = 0; }
                       Serial.print("numero = "); Serial.println(REMnombre);
                      }
if ( REMnombre > 1 ) { playcomplete("vib.WAV"); REMnombre = 0; } // si la phase cible est superieure à 2 lectures (1 min) jouer vib WAV. repeter toutes les 1 mn jusqu au changement de phase.
free(DATA);
}
void printName(dir_t &dir)
{
  for (uint8_t i = 0; i < 11; i++) {
    if (dir.name[i] == ' ')continue;
    if (i == 8) Serial.print('.');
    Serial.print(dir.name[i]);
  }
  if (DIR_IS_SUBDIR(dir)) Serial.print('/');
}
void ls() {
  dir_t d;
  root.rewind();
  while (root.readDir(d) > 0) {
    printName(d);
    Serial.println();
  }
}
void playcomplete(char *name) {
  playfile(name);
  while (wave.isplaying) {

   
    digitalWrite(redled, HIGH);
    delay(1000);
    digitalWrite(redled, LOW);
    delay(1000);
   }
 
}







void playfile(char *name) {
  if (wave.isplaying) {// deja en train de jouer quelque chose, donc stop !
    wave.stop(); // stop
  }
  if (!f.open(root, name)) {
    putstring("Impossible d ouvrir le fichier "); Serial.print(name); return;
  }
  if (!wave.create(f)) {
    putstring_nl("WAV non valide"); return;
  }
  // lecture !
  wave.play();

}

[Lionel]

Bonjour,

Attention, vous définissez deux fois la pin affectée a led
#define redled 9
#define redled 10

je vous propose d'utiliser plutôt la méthode issue de l'ex "blink without delay", mais bon, c'est en aveugle


dans les déclarations

Code: Tout sélectionner

//LED stuff
long interval = 1000;
int ledPin = 9; // the number of the LED pin

int ledState = LOW; // ledState used to set the LED
long previousMillis = 0; // will store last time LED was updated

dans le setup ajouter

Code: Tout sélectionner

pinMode(ledPin, OUTPUT);

dans les fonctions, ajouter la fonction blink (sans utilisation de la fonction delay())

Code: Tout sélectionner

void makeLEDsblink() {
unsigned long currentMillis = millis();
if(currentMillis - previousMillis > interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
if (ledState == LOW){
ledState = HIGH; }
else {
ledState = LOW;
}

// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}

changer votre fonction playcomplete par

Code: Tout sélectionner

void playcomplete(char *name) {
playfile(name);
while (wave.isplaying) {
makeLEDsblink();
}

}


A tenter donc...

[heinekeken]

ok, merci du conseil, je ne connaissais pas ! désolé je débute.
merci de votre aide. Je vais faire d autres essais

[Lionel]

Ne soyez pas désolé, pas de souci, on débute tous un jour et puis c'est a tester hein, c'est pas garanti !

[heinekeken]

Bon, j ai un petit souci avec le zeo...le port qui envoie les données a cramé...mauvaise manip, donc envoyé en réparation, retour prévu le 14 ou le 15.
En attendant, je vais bosser sur le code, le module rf et le programme pilotable avec le LCD DEULIGNE

[heinekeken]

Le réveil arrive demain.
Je pourrais donc commencer la description du sujet dés demain.
Par contre, il a fallu que je commande d' autres pieces:

arduino pro mini 3.3v
nouveau recepteur rf RR8-433 faible consommation 3V

avec ces nouveaux composants je pourrais baisser le voltage nécessaire au fonctionnement du module récepteur

[Lionel]

Bonjour,

ce serait a tester car je ne l'ai pas validé mais il me semble que le récepteur que nous vous avons fournir est capable de fonctionner jusqu'a 2,8V d'alimentation

[heinekeken]

j avais essayé en 3v mais le signal n' était pas trés stable et le module peinait à recevoir les informations
Mais peut etre que ça venait des mes accus qui ne sont pas de bonnes qualités. J en ai commandé des meilleurs

[heinekeken]

J ai pas mal avancé...

Ce qui fonctionne:

-menu avec affichage lcd :

.gauche : rien pour le moment
.droite : rien pour le moment
.bas : test émetteur récepteur ( envoie 4 signaux, permettant de voir si le recepteur fonctionne )



.select : lancement du programme REM DETECTOR ( analyse des données ZEO avec signaux sonores / lumineux quand la phase
recherchée est détectée )


-en cours :

.haut : test réception de données du ZEO ( vérifie le bon fonctionnement de la réception des données du ZEO par le port Rx)




Je reçois le matériel qui me manque demain , je ferais alors une petite vidéo + expliquation dés que possible



code en l' état actuel :

Code: Tout sélectionner

/*Projet ZEO-reves lucides
 *
 *Merci à EOK des forums ZEO pour son partage de code
 *
 *Merci à Lionel de SNOOTLAB pour son aide
 *
 *UTILISATION DES DONNEES TRANSMISES DEPUIS ZEO
 *AFIN DE PRODUIRE DES INDICES LUMINEUX / SONORES
 *A x MN DE y PHASE 
 */
 


#include <VirtualWire.h>
#include <LiquidCrystal.h>
#include <Wire.h> //
#include <Deuligne.h> //

#include "SdReader.h"
#include "FatReader.h"
#include "WaveHC.h"
#include <avr/pgmspace.h>
#include "WaveUtil.h"
SdReader card;
FatVolume vol;
FatReader root;
FatReader f;
WaveHC wave;   

//LED
long interval = 1000;
int ledPin = 9; //

int ledState = LOW; //
long previousMillis = 0; //


int incomingByte = 0;   
byte header[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int NOMBRE = 0; // COMPTEUR
int SIZE = 0;
int *DATA;
int val;
int REMnombre = 0;
unsigned long digit = 0;


Deuligne lcd; //

//Key message
char msgs[5][15] = {
  "MENU DROITE  ",
  "TEST INFO ZEO",
  "Test EMETTEUR",
  "MENU GAUCHE  ",
  "ZEO ANALYSEUR" };

int key=-1;
int oldkey=-1;

//Barre de chargement
byte smiley1[8] = {
        B00011,
   B00100,
   B01000,
   B01000,
   B01000,
   B01000,
   B00100,
   B00011,
};

byte smiley2[8] = {
        B11000,
   B00100,
   B00010,
   B00010,
   B00010,
   B00010,
   B00100,
   B11000,
};

byte smiley3[8] = {
        B00011,
   B00100,
   B01100,
   B01100,
   B01100,
   B01100,
   B00100,
   B00011,
};

byte smiley4[8] = {
        B00011,
   B00110,
   B01110,
   B01110,
   B01110,
   B01110,
   B00110,
   B00011,
};

byte smiley5[8] = {
        B00011,
   B00111,
   B01111,
   B01111,
   B01111,
   B01111,
   B00111,
   B00011,
};

byte smiley6[8] = {
        B11000,
   B10100,
   B10010,
   B10010,
   B10010,
   B10010,
   B10100,
   B11000,
};

byte smiley7[8] = {
        B11000,
   B11100,
   B11010,
   B11010,
   B11010,
   B11010,
   B11100,
   B11000,
};

byte smiley8[8] = {
        B11000,
   B11100,
   B11110,
   B11110,
   B11110,
   B11110,
   B11100,
   B11000,
};



void setup()
{
  lcd.clear();
  pinMode(13, OUTPUT); 
  Wire.begin(); //
  lcd.init(); //
Serial.begin(9600);

 
  // Initialisation IO et ISR
    vw_set_ptt_inverted(true); // Required for DR3100
    vw_setup(2000);    // Bps
 
  lcd.setCursor(2,0); lcd.print("REM DETECTOR");
  lcd.createChar(1,smiley1);
     lcd.createChar(2,smiley2);
     lcd.createChar(3,smiley3);
     lcd.createChar(4,smiley4);
     lcd.createChar(5,smiley5);
     lcd.createChar(6,smiley6);
     lcd.createChar(7,smiley7);
     lcd.createChar(8,smiley8);
 
   
          lcd.setCursor(0,1);
          lcd.write(1);lcd.write(2);
          lcd.write(1);lcd.write(2);
          lcd.write(1);lcd.write(2);
          lcd.write(1);lcd.write(2);
          lcd.write(1);lcd.write(2);
          lcd.write(1);lcd.write(2);
          lcd.write(1);lcd.write(2);
          lcd.write(1);lcd.write(2);
         
          delay(2000);
         
          lcd.setCursor(0,1); lcd.write(3);delay(100);lcd.setCursor(0,1); lcd.write(4);delay(100); lcd.setCursor(0,1); lcd.write(5);
          lcd.setCursor(1,1); lcd.write(6);delay(100);lcd.setCursor(1,1); lcd.write(7);delay(100); lcd.setCursor(1,1); lcd.write(8);
          delay(100);
          lcd.setCursor(2,1); lcd.write(3);delay(100);lcd.setCursor(2,1); lcd.write(4);delay(100); lcd.setCursor(2,1); lcd.write(5);
          lcd.setCursor(3,1); lcd.write(6);delay(100);lcd.setCursor(3,1); lcd.write(7);delay(100); lcd.setCursor(3,1); lcd.write(8);
          delay(100);
          lcd.setCursor(4,1); lcd.write(3);delay(100);lcd.setCursor(4,1); lcd.write(4);delay(100); lcd.setCursor(4,1); lcd.write(5);
          lcd.setCursor(5,1); lcd.write(6);delay(100);lcd.setCursor(5,1); lcd.write(7);delay(100); lcd.setCursor(5,1); lcd.write(8);
          delay(100);
          lcd.setCursor(6,1); lcd.write(3);delay(100);lcd.setCursor(6,1); lcd.write(4);delay(100); lcd.setCursor(6,1); lcd.write(5);
          lcd.setCursor(7,1); lcd.write(6);delay(100);lcd.setCursor(7,1); lcd.write(7);delay(100); lcd.setCursor(7,1); lcd.write(8);
          delay(100);
          lcd.setCursor(8,1); lcd.write(3);delay(100);lcd.setCursor(8,1); lcd.write(4);delay(100); lcd.setCursor(8,1); lcd.write(5);
          lcd.setCursor(9,1); lcd.write(6);delay(100);lcd.setCursor(9,1); lcd.write(7);delay(100); lcd.setCursor(9,1); lcd.write(8);
          delay(100);
          lcd.setCursor(10,1);lcd.write(3);delay(100);lcd.setCursor(10,1);lcd.write(4);delay(100); lcd.setCursor(10,1); lcd.write(5);
          lcd.setCursor(11,1);lcd.write(6);delay(100);lcd.setCursor(11,1);lcd.write(7);delay(100); lcd.setCursor(11,1); lcd.write(8);
          delay(100);
          lcd.setCursor(12,1);lcd.write(3);delay(100);lcd.setCursor(12,1);lcd.write(4);delay(100); lcd.setCursor(12,1); lcd.write(5);
          lcd.setCursor(13,1);lcd.write(6);delay(100);lcd.setCursor(13,1);lcd.write(7);delay(100); lcd.setCursor(13,1); lcd.write(8);
          delay(100);
          lcd.setCursor(14,1);lcd.write(3);delay(100);lcd.setCursor(14,1);lcd.write(4);delay(100); lcd.setCursor(14,1); lcd.write(5);
          lcd.setCursor(15,1);lcd.write(6);delay(100);lcd.setCursor(15,1);lcd.write(7);delay(100); lcd.setCursor(15,1); lcd.write(8);
         
          delay(2000);
         
         
         
  delay(1000);
 
  lcd.clear();
  lcd.print("MENU");
 
}

void loop() {

 
 

  key = lcd.get_key();              // read the value from the sensor & convert into key press

  if (key != oldkey)                // if keypress is detected
  {
    delay(50);      // wait for debounce time
    key = lcd.get_key();      // read the value from the sensor & convert into key press
    if (key != oldkey)            
   {         
      oldkey = key;
     
/////////////////////////////////////////////////////////////////////////////////
     {         
      oldkey = key;
      // 0: Right Key
      if (key ==0 ){
        // set the cursor to column 0, line 1
        // (note: line 1 is the second row, since counting begins with 0):
         lcd.clear();lcd.setCursor(0, 0);lcd.print(msgs[key]);
      }}
/////////////////////////////////////////////////////////////////////////////////
 {         
      oldkey = key;
      // 1: Up Key
      if (key ==1 ){
        // set the cursor to column 0, line 1
        // (note: line 1 is the second row, since counting begins with 0):
         lcd.clear();lcd.setCursor(0, 0);lcd.print(msgs[key]);
      }}
     
/////////////////////////////////////////////////////////////////////////////////
{         
      oldkey = key;
       // 2: Down Key
       if (key ==2 ){
        // set the cursor to column 0, line 1
        // (note: line 1 is the second row, since counting begins with 0):
         
         lcd.clear();lcd.setCursor(0, 0);lcd.print(msgs[key]);delay(1000);
         
         lcd.setCursor(0, 1);
         lcd.print("Debut du test    ");delay(1000);
         lcd.setCursor(0, 1);lcd.print("3            ");delay(1000);
         lcd.setCursor(0, 1);lcd.print("2            ");delay(1000);
         lcd.setCursor(0, 1);lcd.print("1            ");delay(1000);
         lcd.setCursor(0, 1);lcd.print("TEST            ");
         
         const char *msg = "hello";

    digitalWrite(13, true); // Flash a light to show transmitting
    vw_send((uint8_t *)msg, strlen(msg));
    vw_wait_tx(); // Wait until the whole message is gone
    digitalWrite(13, false);
    delay(200);
         
    digitalWrite(13, true); // Flash a light to show transmitting
    vw_send((uint8_t *)msg, strlen(msg));
    vw_wait_tx(); // Wait until the whole message is gone
    digitalWrite(13, false);
    delay(200);     
         
    digitalWrite(13, true); // Flash a light to show transmitting
    vw_send((uint8_t *)msg, strlen(msg));
    vw_wait_tx(); // Wait until the whole message is gone
    digitalWrite(13, false);
    delay(200);
   
    digitalWrite(13, true); // Flash a light to show transmitting
    vw_send((uint8_t *)msg, strlen(msg));
    vw_wait_tx(); // Wait until the whole message is gone
    digitalWrite(13, false);
    delay(200);     
         
         lcd.print("Fin du test  ");delay(1000);
         lcd.setCursor(0, 1);lcd.print("             ");
      } }
/////////////////////////////////////////////////////////////////////////////////
      {         
      oldkey = key;
      // 3: Left Key
      if (key ==3 ){
        // set the cursor to column 0, line 1
        // (note: line 1 is the second row, since counting begins with 0):
        lcd.clear();lcd.setCursor(0, 0);lcd.print(msgs[key]);
      }}
     
/////////////////////////////////////////////////////////////////////////////////
       {         
      oldkey = key;
      // 4: Select Key
      if (key ==4 ){
     
        {lcd.clear();lcd.setCursor(0, 0);lcd.print("ZEO ANALYSEUR");delay(1000);
        // attend les informations
        if (Serial.available() > 0) {
                // lecture des donnees :
                incomingByte = Serial.read();
                if ( incomingByte == 65 ) { holeHeader(); }  // nouvelles informations arrivent
               }
             else { lcd.setCursor(0, 1);lcd.print("   en attente");}
}
     
     
      }}
     
/////////////////////////////////////////////////////////////////////////////////

    }
  }

  //delay(1000);
}

void holeHeader() {
  NOMBRE = 0;
  while ( NOMBRE < 10 ) {
        if (Serial.available() > 0) {
                header[NOMBRE] = Serial.read();
                NOMBRE++;}
              }
  SIZE = (( header[3] * 256 ) + header[2]);
  if ( SIZE > 20 ) { SIZE = 1; } // dont read long raw waveform packages
  if ( header[3] + header[5] == 255 & header[2] + header[4] == 255 ) { holeDaten(SIZE); }
  else { Serial.println(" CAPTEURS = AUCUNES INFORMATIONS DETECTEES ");}
  }
 
 
void holeDaten(int SIZE) {
DATA = (int*)calloc(1, SIZE * sizeof(int));
NOMBRE = 0;
while ( NOMBRE < SIZE ) {
  if (Serial.available() > 0) {
    DATA[NOMBRE] = Serial.read();
    NOMBRE++;
  }
}
if ( DATA[0] == 157 ) { Serial.print("Phase de sommeil ");
                       if (DATA[1] == 0) { Serial.println(": INCONNUE //phase cible// "); REMnombre++; }
                       if (DATA[1] == 1) { Serial.println(": EVEIL"); REMnombre = 0 ; }
                       if (DATA[1] == 2) { Serial.println(": REM"); REMnombre = 0 ; }
                       if (DATA[1] == 3) { Serial.println(": LEGER"); REMnombre = 0; }
                       if (DATA[1] == 4) { Serial.println(": PROFOND"); REMnombre = 0; }
                       Serial.print("numero = "); Serial.println(REMnombre);
                      }
if ( REMnombre > 1 ) { playcomplete("vib.WAV"); REMnombre = 0; } // si la phase cible est superieure à 2 lectures (1 min) jouer vib WAV. repeter toutes les 1 mn jusqu au changement de phase.
free(DATA);
}




void printName(dir_t &dir)
{
  for (uint8_t i = 0; i < 11; i++) {
    if (dir.name[i] == ' ')continue;
    if (i == 8) Serial.print('.');
    Serial.print(dir.name[i]);
  }
  if (DIR_IS_SUBDIR(dir)) Serial.print('/');
}


void makeLEDsblink() {
unsigned long currentMillis = millis();
if(currentMillis - previousMillis > interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
if (ledState == LOW){
ledState = HIGH; }
else {
ledState = LOW;
}

// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}



void ls() {
  dir_t d;
  root.rewind();
  while (root.readDir(d) > 0) {
    printName(d);
    Serial.println();
  }
}



void playcomplete(char *name) {
playfile(name);
while (wave.isplaying) {
makeLEDsblink();
}

}





void playfile(char *name) {
  if (wave.isplaying) {// deja en train de jouer quelque chose, donc stop !
    wave.stop(); // stop
  }
  if (!f.open(root, name)) {
    putstring("Impossible d ouvrir le fichier "); Serial.print(name); return;
  }
  if (!wave.create(f)) {
    putstring_nl("WAV non valide"); return;
  }
  // lecture !
  wave.play();

}



[heinekeken]

voila, je viens de finir le premier prototype .




Le but de ce module est de recevoir les infos de l arduino et de déclencher une série de flash lumineux à l' aide de 2 led
Je l alimente actuellement à l aide de 3 accus 1.2v
l' alimentation peut etre coupée par un interupteur ( situé au dessus du module)

[heinekeken]

Je viens de terminer mon premier module : celui qui decrypte les information du ZEO et envoie un message par RF au module de signaux lumineux.
Grace à l arduino mini pro 3.3v, je peut l alimenter directement avec le ZEO

Pour le module de signaux lumineux, j attend de recevoir mes pieces "LILYPAD"...
Je commence à abandonner l' idée d' un support sur un masque de nuit ou bandeau contre celle d un petit boitier que je garderai prés de moi... ce qui supprimerait définitivement l' inconfort d'un masque de nuit...

En attendant le reste du matériel j ai fait de mon emetteur un module qui analyse les données du zeo, et envoie une série de flash quand la phase de sommeil cible est détectée. :