liaison BT et mot envoyé par app inventor

Bonjour,

Je suis en train de réaliser une horloge murale.

La mise à l’heure s’effectue par bouton (cette partie fonctionne :stuck_out_tongue: )

Je souhaite aussi faire ce réglage par une petite appli que j’ai réalisé avec app inventor.

Suivant le mot (w) reçu sur le port série j’incrémente (ou décrémente) les heures ou les minutes.

sauf que le mot reçu est très aléatoire. Parfois c’est le bon et cela fonctionne, parfois j’ai 128, 190 ou autre et là cela ne fonctionne pas…parfois le mot reste bloqué sur une valeur …

Auriez vous une idée du problème ?

Je met en fichier joint l’image app inventor

Merci par avance de votre aide.

#include <Wire.h>

#include "RTClib.h"    //un fil entre la broche A4 de la carte Arduino et la broche SDA du module,un fil entre la broche A5 de la carte Arduino et la broche SCL du module.
RTC_DS3231 RTC;

#include <SoftwareSerial.h> // permet de lire le port serie pour la laison BT
SoftwareSerial liaisonBTserie(6, 5); // Borne 6 pour Rx et 5 pour Tx et definie le nom de ma laison szerie : "liaisonBTserie" (idem serial)

#include <Adafruit_NeoPixel.h> // librairie pour la gestion du bandeau de led


int hour=0;
int minute=0;
byte w=0;
const byte sortiebandeau=3; // Définition de la sortie pour le bandeau led
int nombredeleds=24; // Définition du nombre de leds sur le bandeau

const byte boutonheure = 12; // Definition entrée bouton pour les heures
byte Etat_entree_heure;

const byte boutonminute = 11; // Definition entrée bouton pour les minutes
byte Etat_entree_minute;

Adafruit_NeoPixel strip = Adafruit_NeoPixel(nombredeleds, sortiebandeau); //Déclaration d'un objet NéoPixel appelé strip, broche 3 contenant 16 pixels et utilisant la configuration NéoPixel implicite (NEO_KHZ800 + NEO_GRB).

uint32_t bleu = 0x0000ff; //definition de la couleur bleu codé en hexa  Réf: http://www.color-hex.com
uint32_t rouge = 0xff0000; // rouge
uint32_t noir = 0x000000;

int MotUneH[] = {0, -1};
int MotDeuxH[] = {1, -1};
int MotTroisH[] = {2,3, -1};
int MotQuatreH[] = {3, -1};
int MotCinqH[] = {4, -1};
int MotSixH[] = {5, -1};
int MotSeptH[] = {6, -1};
int MotHuitH[] = {7, -1};
int MotNeufH[] = {8, -1};
int MotDixH[] = {9, -1};
int MotOnzeH[] = {10, -1};
int MotDouzeH[] = {11, -1};
int MotHeure[] = {12,13,14, -1};
int MotCinqM[] = {15, -1};
int MotDixM[] = {16, -1};
int MotQuinzeM[] = {17, -1};
int MotVingtM[] = {18, -1};
int MotTrenteM[] = {19, -1};
int MotMoinsM[] = {20, -1};
int MotMinutes[] = {21, -1};




void setup() {
   
  Serial.begin(9600); //ouverture port série
  liaisonBTserie.begin(9600); // ouverture port série BT
  Wire.begin(); //Démarrage de la librairie wire.h
  RTC.begin(); //Démarrage de la librairie RTClib.h
  
  //Initialisation bandeau de leds
  strip.begin();
  strip.show(); // Initialise tous les pixels à 'off' (éteint)
  strip.setBrightness(50);
  strip.show();
 
  // configuration entrées-sorties
  pinMode(boutonheure , INPUT); // entrée bouton heures
  pinMode(boutonminute , INPUT); // entrée bouton minutes
  
 
    if (RTC.lostPower()) 
  {
    Serial.println("RTC lost power, lets set the time!");
    RTC.adjust(DateTime(__DATE__, __TIME__)); // MET RTC A L'HEURE DU TELECHARGEMENT
  }
  
    //Cela fonctionne également :
    //RTC.adjust(DateTime("Dec  5 2012","12:00:00")); 
    //RTC.adjust(DateTime(2014, 1, 21, hour, minute, 0));
             }

//************************* sous programme pour lire le mot recu sur le port serie de la liaison BT***********************//

void recevoir()     
{
 if(liaisonBTserie.available()) 
 {
 w=liaisonBTserie.read();
 liaisonBTserie.flush();
 }
}

//************* sous programme pour allumer les leds à un emplacmeent spécifier par les mots défini plus haut*************//

void allumage(int Mot[], uint32_t Couleur)  // allumage des leds du bandeau suivant le mot lu et la couleur (toujours bleu pour nous  à priori)
{
for (int i = 0; i < strip.numPixels()+1; i++)
  { if(Mot[i] == -1) 
       {
    strip.show();
    break;
       }
       
    else 
       {
    strip.setPixelColor(Mot[i], Couleur);
    strip.show();
       }
   } 
}

//**************************************Boucle principale*****************************************************************//

void loop() 

{

DateTime now = RTC.now();

// visualise l'heure sur le port série , inutile à terme...
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();
   
//*****************************************reglage des heures par bouton***************************************************//
  
 Etat_entree_heure=digitalRead(boutonheure); 
 Serial.println(Etat_entree_heure); //inutile, permet juste de verifier la valeur de Etat_entree_heure
 
 if (Etat_entree_heure==1) // si etat bas en entrée, on rentre dans la boucle et on incrémente les heures
 {
   hour==hour++;
      if (hour>24)
        { 
        hour=0;
        }
   delay(500);
    RTC.adjust(DateTime(now.year(),now.month(),now.day(), hour, now.minute(), now.second()));
  }  
  
//*****************************************reglage des minutes par bouton***************************************************//

 Etat_entree_minute=digitalRead(boutonminute); 
 Serial.println(Etat_entree_minute); //inutile, permet juste de verifier la valeur de Etat_entree_minute
 
 if (Etat_entree_minute==1) // si etat bas en entrée, on rentre dans la boucle et on incrémente les minutes
 {
   minute=(minute+5);
    if (minute>=60)
        { 
        minute=0;
        }
   delay(500);
    RTC.adjust(DateTime(now.year(),now.month(),now.day(), now.hour(), minute, now.second()));
 } 
 
  //*************************************Réglage des heures par BT*****************************************//
 
 recevoir();
 Serial.print("w=");
 Serial.println(w);
 

  if (w==1) // si etat bas en entrée, on rentre dans la boucle et on incrémente les heures
 {
   hour==hour++;
      if (hour>24)
        { 
        hour=0;
        }
   delay(500);
    RTC.adjust(DateTime(now.year(),now.month(),now.day(), hour, now.minute(), now.second()));
  }  
  
  if (w==2) // si etat bas en entrée, on rentre dans la boucle et on incrémente les heures
 {
   hour==hour--;
      if (hour<=0)
        { 
        hour=0;
        }
   delay(500);
    RTC.adjust(DateTime(now.year(),now.month(),now.day(), hour, now.minute(), now.second()));
  } 
 
  //*************************************Réglage des minutes par BT*****************************************//
 
  if (w==4) // si etat bas en entrée, on rentre dans la boucle et on incrémente les heures
 {
   minute=minute+5;
      if (minute>59)
        { 
        minute=0;
        }
   delay(500);
    RTC.adjust(DateTime(now.year(),now.month(),now.day(), now.hour(), minute, now.second()));
  }  
  
  if (w==5) // si etat bas en entrée, on rentre dans la boucle et on incrémente les heures
 {
   minute=minute-5;
      if (minute<=00)
        { 
        minute=0;
        }
   delay(500);
    RTC.adjust(DateTime(now.year(),now.month(),now.day(), now.hour(), minute, now.second()));
  } 
    
     allumage(MotHeure, rouge); // a faire aussi pour minutes (car le mot heure et minute toujours éclairé)

Avec la version R3, pensais que cela venait du "flush" mais non même supprimé cela ne change rien...

Re,

J'ai modifié le void recevoir comme cela

void recevoir()     
{
    
    
    cardispo = liaisonBTserie.available();
    
    while(cardispo > 0) //tant qu'il y a des caractères à lire
    {
        w = liaisonBTserie.read(); //on lit le caractère
        Serial.print("w=");
        Serial.println(w); //renvoi pour verification
        cardispo = liaisonBTserie.available(); //on relit le nombre de caractères dispo
    }

}

Mais toujours identique, personne n'a une idée ?

Merci

Non ? personne à une petite idée SVP ?

Bonjour,

Je cherche toujours mon problème…je suis donc reparti sur un petit programme :

int ledPin = 13;
String readString;

#include <SoftwareSerial.h> // permet de lire le port serie pour la laison BT
SoftwareSerial liaisonBTserie(6, 5); // Borne 6 pour Rx et 5 pour Tx et definie le nom de ma laison szerie : "liaisonBTserie" (idem serial)

void setup() {
  Serial.begin(9600);
  liaisonBTserie.begin(9600);
  pinMode(ledPin, OUTPUT); 
  Serial.println("serial on/off test 0021"); // so I can keep track
}

void loop() {
  while (liaisonBTserie.available()) {
    delay(3);  
    char c = liaisonBTserie.read();
    readString += c; 
  }
  if (readString.length() >0) {
    if (readString == "on") {
      Serial.println("switching on");
      digitalWrite(ledPin, HIGH);
    }
    if (readString == "off") {
      Serial.println("switching off");
      digitalWrite(ledPin, LOW);
    }
    readString="";
  } 
}

il fonctionne très bien !

Par contre si j’intègre ce bout de programme dans mon programme principal je ne rentre dans ce programme qu’une fois sur 10 environ…

est ce du au temps de lecture ? faut il faire une interruption pour lire en permanence l’entrée série ?

Je suis perdu, merci de vos éclairages.

Je rajoute au fur et à mesure des mes découvertes :

Sur le programme simple du post #4 lorsque je regarde ce qui arrive sur le port série j'au bien la lettre o puis n donc on est reconnu et actionne la sortie 13.

par contre dans le programme complet j'ai des caractères aléatoires qui arrivent donc rarement o puis n à la suite d'ou l'impossibilité d'avoir "on". Qu'est ce qui fait que lorsque le programme est plus complexe j'ai autre chose qui arrive sur le port série ?

Merci encore

C'est encore moi ! :confused:

J'ai procédé par élimination...et cela fonctionne un peu mieux ! Quand le programme devient plus court je n'est pas l'apparition de caractère aléatoire.

Du coup, j'ai mis un delay(1000) en fin de programme et là cela fonctionne bien mieux, presque plus de caractère aléatoire.

Mais je comprends pas trop pourquoi ? des idées ? est ce d'ailleurs la bonne solution ?! (pas fan des delay)

J'en peu plus...lol :sob: