Show Posts
Pages: 1 [2] 3 4 5
16  International / Français / [Résolu] virtualWire et TX/RX 433MHz on: December 13, 2013, 03:05:19 am
Bonjour à tous,

J'ai dans un tiroir un Tx/Rx en 433MHz que je suis en train d'essayer.
http://www.belectronique.fr/modules/82-emetteur-recepteur-433mhz-rf.html

Je suis confronté à un souci à la réception des trames qui, au bout d'un moment, sont tronquées sans avoir d'explications :

Voici quelques exemples :

Code:
RX : 143 : //20:30:47/045081708N005494029E044580_ good : 199
RX : 144 : //20:30:48/045081708N005494027E044540_ good : 200
RX : 145 : //20:30:54/045081708N005494027E044420_ good : 202
RX : 146 : //20:30:59/045081708N005494029E044280_ good : 204
RX : 147 : //20:31:00/045081708N005494029E044250_ good : 205
RX : 148 : //20:31:06/045081708N005494031E044170_ good : 206
RX : 149 : //20:31:11/045081708N005494032E044060_ good : 208
RX : 150 : //20:31:12/045081708N005494035E044040_ good : 209
RX : 151 : //20:31:18/045081708N005494038E044040_ good : 211
RX : 152 : //20:31:20/045081708N005494038E044040_ good : 212
RX : 153 : //20:31:23/045081708N005494041E044080_ good : 213
RX : 154 : //20:31:24/045081708N005494043E044110_ good : 214
RX : 155 : //20:31:30/04_ good : 217
RX : 156 : //20:31:32/04_ good : 218
RX : 157 : //20:31:35/04_ good : 219
RX : 158 : //20:31:40/04_ good : 221
RX : 159 : //20:31:44/04_ good : 223
RX : 160 : //20:31:47/04_ good : 224
RX : 161 : //20:31:52/04_ good : 225
RX : 162 : //20:31:54/04_ good : 226
RX : 163 : //20:31:59/04_ good : 228
RX : 164 : //20:32:00/04_ good : 229
RX : 165 : //20:32:03/04_ good : 230
RX : 166 : //20:32:06/04_ good : 231
RX : 167 : //20:32:11/04_ good : 233
RX : 168 : //20:32:12/04_ good : 234


Code:
Tuto VirtualWire
Taille max du tableau : 80
RX : 0 : //20:43:50/045081720N005494071E043640_ buflen : 37_ good : 2
RX : 1 : //20:43:55/045081712N005494073E043640_ buflen : 37_ good : 4
RX : 2 : //20:43:56/045081712N005494073E043640_ buflen : 37_ good : 5
RX : 3 : //20:44:02/045081712N005494073E043640_ buflen : 37_ good : 7
RX : 4 : //20:44:04/045081712N005494073E043640_ buflen : 37_ good : 8
RX : 5 : //20:44:07/045081712N005494073E043640_ buflen : 37_ good : 9
RX : 6 : //20:44:08/045081712N005494073E043640_ buflen : 37_ good : 10
RX : 7 : //20:44:14/045081712N005494073E043640_ buflen : 37_ good : 12
RX : 8 : //20:44:16/045081712N005494073E043640_ buflen : 37_ good : 13
RX : 9 : //20:44:18/045081712N005494073E043640_ buflen : 37_ good : 14
RX : 10 : //20:44:20/045081712N005494073E043640_ buflen : 37_ good : 15
RX : 11 : //20:44:26/045081712N005494073E043640_ buflen : 37_ good : 17
RX : 12 : //20:44:28/045081712N005494073E043640_ buflen : 37_ good : 18
RX : 13 : //20:44:32/045081712N005494073E043640_ buflen : 37_ good : 19
RX : 14 : //20:44:38/045081712N005494073E043640_ buflen : 37_ good : 21
RX : 15 : //20:44:40/045081712N005494073E043640_ buflen : 37_ good : 22
RX : 16 : //20:44:44/045081712N00549407_ buflen : 29_ good : 24
RX : 17 : //20:44:50/045081712N00549407_ buflen : 29_ good : 26
RX : 18 : //20:44:52/045081712N00549407_ buflen : 29_ good : 27
RX : 19 : //20:44:56/045081712N00549407_ buflen : 29_ good : 29
RX : 20 : //20:45:02/045081712N00549407_ buflen : 29_ good : 31
RX : 21 : //20:45:04/045081712N00549407_ buflen : 29_ good : 32
RX : 22 : //20:45:08/045081712N00549407_ buflen : 29_ good : 34
RX : 23 : //20:45:11/045081712N00549407_ buflen : 29_ good : 35
RX : 24 : //20:45:14/045081712N00549407_ buflen : 29_ good : 36
RX : 25 : //20:45:16/045081712N00549407_ buflen : 29_ good : 37
RX : 26 : //20:45:20/045081712N00549407_ buflen : 29_ good : 39
RX : 27 : //20:45:23/045081712N00549407_ buflen : 29_ good : 40
RX : 28 : //20:45:26/045081712N00549407_ buflen : 29_ good : 41

...
RX : 78 : //20:51:58/045081712N00549406_ buflen : 29_ good : 113
RX : 79 : //20:52:00/045081712N00549406_ buflen : 29_ good : 114
RX : 80 : //20:52:03/045081712N00549406_ buflen : 29_ good : 115
RX : 81 : //20:52:08/045081712N00549406_ buflen : 29_ good : 117
RX : 82 : //20:52:10/045081712N00549406_ buflen : 29_ good : 118
RX : 83 : //20:52:12/045081712N00549406_ buflen : 29_ good : 119
RX : 84 : //20:52:15/045081712N00549406_ buflen : 29_ good : 120
RX : 85 : //20:52:20/04_ buflen : 13_ good : 123
RX : 86 : //20:52:22/04_ buflen : 13_ good : 124
RX : 87 : //20:52:24/04_ buflen : 13_ good : 125
RX : 88 : //20:52:27/04_ buflen : 13_ good : 126
RX : 89 : //20:52:32/04_ buflen : 13_ good : 128
RX : 90 : //20:52:34/04_ buflen : 13_ good : 129
RX : 91 : //20:52:39/04_ buflen : 13_ good : 131
RX : 92 : //20:52:44/04_ buflen : 13_ good : 133
RX : 93 : //20:52:46/04_ buflen : 13_ good : 134
RX : 94 : //20:52:51/04_ buflen : 13_ good : 136
RX : 95 : //20:52:56/04_ buflen : 13_ good : 138
RX : 96 : //20:52:58/04_ buflen : 13_ good : 139


Code:
RX : 25 : //07:45:39/045081668N005494081E042270_ buflen : 37_ good : 38
RX : 26 : //07:45:44/045081664N005494082E042190_ buflen : 37_ good : 40
RX : 27 : //07:45:46/045081664N005494082E042110_ buflen : 37_ good : 41
RX : 28 : //07:45:48/045081664N005494082E042110_ buflen : 37_ good : 42
RX : 29 : //07:45:51/045081664N005494084E042080_ buflen : 37_ good : 43
RX : 30 : //07:45:56/045081664N005494085E042010_ buflen : 37_ good : 45
RX : 31 : //07:45:58/045081664N005494085E042000_ buflen : 37_ good : 46
_ INIT_Rx?... _
RX : 32 : //07:46:03/045081668N00549408_ buflen : 29_ good : 48
_ INIT_Rx?... _
_ INIT_Rx?... _
RX : 33 : //07:46:08/045081676N00549409_ buflen : 29_ good : 50
_ INIT_Rx?... _
RX : 34 : //07:46:10/045081676N00549409_ buflen : 29_ good : 51
_ INIT_Rx?... _
_ INIT_Rx?... _
RX : 35 : //07:46:15/045081680N00549409_ buflen : 29_ good : 53
_ INIT_Rx?... _
RX : 36 : //07:46:17/045081680N00549409_ buflen : 29_ good : 54
_ INIT_Rx?... _
RX : 37 : //07:46:20/045081680N00549409_ buflen : 29_ good : 55
_ INIT_Rx?... _
RX : 38 : //07:46:22/045081680N00549408_ buflen : 29_ good : 56
_ INIT_Rx?... _
_ INIT_Rx?... _



Code:
void loop() // Fonction loop()
{
    static int nbreRx = 0;
    // if (vw_wait_rx_max(20)) // Si un message est reçu dans les 200ms qui viennent
    if (vw_have_message())  // Returns true if an unread message is available
    {
        if (vw_get_message(buf, &buflen)) // On copie le message, qu'il soit corrompu ou non
        {
            Serial.print("RX : "); Serial.print(nbreRx++); Serial.print(" : ");
            for (byte i = 0; i < buflen; i++) // Si il n'est pas corrompu on l'affiche via Serial
                Serial.print((char) buf[i]);
            Serial.print("_ buflen : "); Serial.print(buflen);
            Serial.print("_ good : "); Serial.println(vw_get_rx_good());
        }
        if (buflen != 37) {   // 37 est la longueur d'une trame 'normale'
          Serial.println("_ INIT_Rx?... _");
          vw_rx_stop();
          delay(2000);
          vw_rx_start();
        }
    }
}

Le problème arrive au bout d'un certain temps (voire d'un temps certain) qui me semble aléatoire.

J'ai vérifié ce qui est envoyé par le Tx : tout me semble cohérent : les trames sont bien complètes.
Lorsque je redémarre le moniteur tout remprend normalement, ce qui me fait dire que le problème vient du Rx.

Je constate que la longueur de trame se réduit d'un seul coup!
J'ai essayé de réinitialiser la transmission en cours de programme mais je ne suis pas sur que cela se fasse comme cela.

Les plus curieux auront reconnus des données GPS dans la trame transmise et pourront en déduire mon lieu d'habitation.
Le plus perspicasses pourront penser que le GPS m'envoi des données toutes pourries mais ça fera l'objet d'un autre sujet smiley-grin.

Vos idées sur les trames tronquées sont les biens venues.
Olivier



17  International / Français / Re: sprintf on: December 06, 2013, 06:30:01 am
On est bien d'accord. Le cas où j'ai besoin de cumuler ces valeurs est bien mairisé.
18  International / Français / Re: sprintf on: December 06, 2013, 03:42:41 am
Quote
question subsidiaire, est-il vraiment nécessaire d'utiliser un long si seuls les 4 premiers chiffres t'intéresses ?

Oui, j'ai besoin de cumuler des valeurs qui sont dans l'interval [900..2100]. Au bout de 31 valeurs, on arrive à la limite des unsigned int. C'est vrai que dans 99% des cas, je ne dépasserai pas les 2100 mais j'avais pas envie de créer une autre classe juste pour ça...

En tout cas, merci à tous d'avoir pris un peu de votre temps pour vous pencher sur mon problème. Merci à  XavierMiller pour son lien sur le C++, j'ai effectivement quelques lacunes à combler! 20 ans sans programmation C, ça ne se rattrappe pas comme ça...

Olivier
19  International / Français / Re: sprintf on: December 06, 2013, 02:28:55 am
Après une bonne nuit de sommeil, j'ai sorti le code problématique pour le mettre dans le Setup (en dehors de toute classe), et voilà le résultat :

Ce code ne fonctionne pas :
Code:
  char valStr2[20];
  unsigned long V3 = 3456;
  unsigned long V4 = 7654;
  sprintf(valStr2, "Rx: %04d %04d", V3, V4);
  slcd.setCursor(0, 1);
  slcd.print(valStr2);

Celui-ci fonctionne :
Code:
  char valStr2[20];
  unsigned long V3 = 3456;
  unsigned long V4 = 7654;
  sprintf(valStr2, "Rx: %04d %04d", (int) V3, (int) V4);
  slcd.setCursor(0, 1);
  slcd.print(valStr2);

La méthode sprintf attend de l'integer pour fonctionner correctement.
20  International / Français / Re: sprintf on: December 05, 2013, 05:04:08 pm
J'ai bien compris que le code écrit au départ n'était pas propre :
Code:
info recepteur::debug(){
  // Test :
  info wInfo;
//  sprintf(wInfo.ligne0, "Rx: %04d %04d", voie1, voie2);
  sprintf(wInfo.ligne0, "Rx: %04d ", voie1);
  sprintf(wInfo.ligne0, "%s%04d ", wInfo.ligne0, voie2);
//  sprintf(wInfo.ligne1, "    %04d %04d", voie3, voie4);
  sprintf(wInfo.ligne1, "    %04d ", voie3);
  sprintf(wInfo.ligne1, "%s%04d ", wInfo.ligne1, voie4);
  return wInfo;
}

Maintenant, la fonction écrite avec le pointeur sur ma variable externe me semblait plus propre :
Code:
void recepteur::debug2(info* wInfo){
  // Test :
  char valStr1[20];
  sprintf(valStr1, "Rx: %04d %04d", voie1, voie2);
  char valStr2[20];
  sprintf(valStr2, "Rx: %04d %04d", voie1, voie2);
 
  (*wInfo).affecter(valStr1, valStr2);
}

Code:
void info::affecter(char const* wL0, char const* wL1){
  // Test : OK
  memcpy(ligne0, wL0, strlen(wL0)+1);
  memcpy(ligne1, wL1, strlen(wL1)+1);
}


Code:
  recepteur rxNeutre;  // Donnée isuue du récepteur
  info wDebug;
  rxNeutre.voie1 = 1234;
  rxNeutre.voie2 = 4321;
  rxNeutre.voie3 = 5678;
  rxNeutre.voie4 = 9876; 

  rxNeutre.debug2(&wDebug);
  wDebug.affiche(currentLCD);


Toutes les variables utilisées dans les méthodes debug2(), affecter() et affiche() font références au variables principales.
Tout se passe comme si voie2 (et voie4) n'existait pas?
Or voie2, c'est l'objet sur lequel on travaille, c'est this.voie2, c'est rxNeutre.voie2
Je ne comprendrais pas pour quelle raison il serait détruit!!

Bref : pour dire que je ne vois absolument pas où faire une modification pour que cela fonctionne...

21  International / Français / Re: sprintf on: December 05, 2013, 11:49:40 am
Je viens d'essayer ça :

Code:
void recepteur::debug2(info* wInfo){
  // Test :
  char valStr1[20];
  sprintf(valStr1, "Rx: %04d %04d", voie1, voie2);
  char valStr2[20];
  sprintf(valStr2, "Rx: %04d %04d", voie1, voie2);
 
  (*wInfo).affecter(valStr1, valStr2);
}

Avec la méthode :
Code:
void info::affecter(char const* wL0, char const* wL1){
  // Test : OK
  memcpy(ligne0, wL0, strlen(wL0)+1);
  memcpy(ligne1, wL1, strlen(wL1)+1);
}

C'est pas mieux! smiley-cry
22  International / Français / Re: sprintf on: December 05, 2013, 11:37:13 am
Le dernier essai réalisé :

Code:
info recepteur::debug(){
  // Test :
  info wInfo;
  char valStr[20];
  sprintf(valStr, "Rx: %04d %04d", voie1, voie2);
  memcpy(wInfo.ligne0, valStr, strlen(valStr)+1);
  sprintf(valStr, "    %04d %04d", voie3, voie4);
  memcpy(wInfo.ligne1, valStr, strlen(valStr)+1);
  return wInfo;
}

J'ai toujours le même résultat :
Rx: 1504 0000

Pour moi, il ne sais pas mettre l'attribut voie2 à la place du dexième %04d

2 classes plus loin, j'ai le même type de traitement qui fonctionne correctement :
Code:
void voie::description(char * valStr){
  // Test : OK
  //sprintf(valStr, "%3s\n %04d %04d %04d", nom, rx_min, rx_neu, rx_max);
  sprintf(valStr, "%04d %04d %04d", rx_min, rx_neu, rx_max);
}

Je ne sais pas quoi faire!
23  International / Français / Re: sprintf on: December 05, 2013, 09:02:21 am
Mais es-tu sûr que voie2 != 0 ?

Oui puisqu'avec cette méthode :
Code:
  sprintf(wInfo.ligne0, "Rx: %04d ", voie1);
  sprintf(wInfo.ligne0, "%s%04d ", wInfo.ligne0, voie2);

J'obtiens des données cohérentes.
24  International / Français / Re: sprintf on: December 05, 2013, 09:00:43 am
Ce qu'il faudrait faire est décrit dans l'excellent livre "Thinking in c++", disponible gratuitement (volumes 1 et 2).

http://www.drbio.cornell.edu/pl47/programming/TICPP-2nd-ed-Vol-one-html/Chapter11.html

J'ai le Kernighan et Ritchie comme livre de chevet, ça suffit peut-être pas...
25  International / Français / Re: sprintf on: December 05, 2013, 08:56:26 am
Je croyais avoir compris ton explication. J'ai donc modifié ma méthode  :
Code:
void recepteur::debug(info* wInfo){
  // Test :
  sprintf((*wInfo).ligne0, "Rx: %04d %04d", voie1, voie2);
  sprintf((*wInfo).ligne1, "    %04d %04d", voie3, voie4);
}

Et je l'appel de cette façon :
Code:
  info wDebug;
  rxNeutre.debug(&wDebug);
  wDebug.affiche(currentLCD);

Mais je tombe sur le même problème :
Rx: 1504 0000
26  International / Français / Re: sprintf on: December 05, 2013, 07:44:25 am
Oui, voilà la définition :
Code:
char ligne0[20];

La définition est dans une classe :
Code:
#ifndef INFO_H
#define INFO_H

#include <SerialLCD.h>
#include <SoftwareSerial.h> //this is a must

class info{
public :
  char ligne0[20];
  char ligne1[20];
 
  info();
  void affecter(char const*, char const*);
  void affiche(SerialLCD*);
};
#endif

Et voilà son utilisation :
Code:
info recepteur::debug(){
  // Test :
  info wInfo;
//  sprintf(wInfo.ligne0, "Rx: %04d %04d", voie1, voie2);
  sprintf(wInfo.ligne0, "Rx: %04d ", voie1);
  sprintf(wInfo.ligne0, "%s%04d ", wInfo.ligne0, voie2);
//  sprintf(wInfo.ligne1, "    %04d %04d", voie3, voie4);
  sprintf(wInfo.ligne1, "    %04d ", voie3);
  sprintf(wInfo.ligne1, "%s%04d ", wInfo.ligne1, voie4);
  return wInfo;
}


27  International / Français / sprintf on: December 05, 2013, 07:34:48 am
Bonjour,

J'ai un sprintf qui ne fonctionne pas comme je l'attends :

Code:
  sprintf(wInfo.ligne0, "Rx: %04d %04d", voie1, voie2);
ça me donne :
Rx: 1504 0000
Le problème est que ma variable voie2 (qui est bien numérique) ne contient pas 0!

Pour obtenir ce que je souhaite, je suis obligé d'écrire ceci :
Code:
  sprintf(wInfo.ligne0, "Rx: %04d ", voie1);
  sprintf(wInfo.ligne0, "%s%04d ", wInfo.ligne0, voie2);

Est-ce qu'il y une explication?...

A+
Olivier
28  International / Français / Re: SerialLCD et utilisation de class! on: December 05, 2013, 07:27:09 am
Désolé mais je n'ai pas tout compris!...
Des explications complémentaires sont nécessaire pour mettre en oeuvre cette technique.

A+
Olivier
29  International / Français / Re: SerialLCD et utilisation de class! on: December 05, 2013, 03:35:59 am
Je viens de trouver une solution qui n'est peutêtre pas très élégante, vous me direz...

Puisque je n'arrive pas à déclarer et à utiliser un objet SerialLCD dans ma classe, je me suis dis pourquoi pas utiliser celui déclarer en global en y  faisant référence via son adresse. Et voilà ce que j'ai écris qui semble fonctionner pour les premiers tests effectués :

pour le fichier classX.h :
Code:
#include <SerialLCD.h>
#include <SoftwareSerial.h> //this is a must

class classX{
public:
  SerialLCD* currentLCD;
  int val;

  classX(SerialLCD*);
  void affiche();

};


Pour le fichier classX.cpp :
Code:
#include "classX.h"

classX::classX(SerialLCD* wLCD){
  currentLCD = wLCD;
  val=10;
}

void classX::affiche(){
  (*currentLCD).print("Test Affichage...");
}


Et pour l'appel de tout ça :
Code:
// include the library code:
#include <SerialLCD.h>
#include <SoftwareSerial.h> //this is a must

#include "classX.h"

// initialize the library
SerialLCD slcd(0,1);//this is a must, assign soft serial pins

void setup() {
  // set up :
  slcd.begin();
  // Print a message to the LCD.
  slcd.print("hello, world!");
}

void loop() {
  // Turn off the blinking cursor:
  slcd.noBlink();
  delay(1000);
   // Turn on the blinking cursor:
  slcd.blink();
  delay(1000);
 
  classX XXXX(&slcd);
  slcd.print(XXXX.val);
   
  XXXX.affiche();
 
}

Vos remarques seront les biens venues.

Olivier
30  International / Français / Re: SerialLCD et utilisation de class! on: December 05, 2013, 03:00:42 am
Bin non, comme ça :

Code:
#include <SerialLCD.h>
#include <SoftwareSerial.h> //this is a must

#include "classX.h"

classX::classX(){
  SerialLCD slcd(0,1);//this is a must, assign soft serial pins
  slcd.begin();
  val=10;
}

void classX::affiche(){
  slcd.print("Test Affichage...");

}

J'ai le message suivant à la compil :

classX.cpp: In member function 'void classX::affiche()':
classX.cpp:13: error: 'slcd' was not declared in this scope
smiley-cry
Pages: 1 [2] 3 4 5