Décryptage protocole sonde de température piscine sans fil

La section dédiée aux Raspberry Pi (tous modèles); Comment on l'installe; Comment on ajoute des capteurs; Ce qu'on peut en faire ...

Décryptage protocole sonde de température piscine sans fil

Messagede molpetrus » 13 Avr 2016, 16:43

Mon projet est de réaliser un automatisme afin de gérer une piscine avec un raspberry.
La température de l'eau de la piscine est un des paramètres à prendre en compte. En particulier, la durée de filtration dépend de ce facteur.
Elle doit être prise dans le bassin et non au niveau de l'installation de filtration car lorsque celle-ci est à l'arrêt , sa température n'est pas représentative.
Je me suis donc orienté vers une sonde sans fil flottante et j'ai trouvé celle-ci sur Amazon.
Nueva-llegada-profesional-WD1228A-Digital-inalámbrico-piscina-SPA-temperatura-del-termómetro-con-3-canales.jpg_640x640.jpg
Nueva-llegada-profesional-WD1228A-Digital-inalámbrico-piscina-SPA-temperatura-del-termómetro-con-3-canales.jpg_640x640.jpg (53.08 Kio) Vu 7371 fois

Cet ensemble est relativement bon marché (18€). Un avis sur Amazon indique qu'il est compatible avec le RFXcom 433MHz. Le fabricant est Sonline et sa référence est WD1228A. A l'usage, il fonctionne bien pour peu qu'on prenne la précaution de mettre un peu de graisse au silicone sur le joint torique de la sonde. La portée est d'au moins 30 mètres entre la sonde et l'afficheur livré.

Grâce au tuto remarquable de cha ( http://www.touteladomotique.com/forum/viewtopic.php?f=118&t=15760) voici ce que j'ai trouvé !

La sonde envoie un message toutes les 57 secondes.
Ce message est composé de 12 trames identiques.
Chaque trame comporte 37 impulsions d'une durée d'environ 500 microsecondes.
La durée des intervalles entre les impulsions varie selon le principe suivant:
- le double d'une durée d'impulsion soit environ 1000 microsecondes représente un bit 0,
- le quadruple d'une durée d'impulsion soit environ 2000 microsecondes représente un bit 1,
- les trames sont séparées par des intervalles d'environ 4000 microsecondes.

Chaque trame est composée donc de 36 bits c'est à dire 9 quartets.

Voici le résultat de plusieurs transmissions :
7 E8 0B EF 0D = 19,9°C
7 E8 09 CF 0E = 15,6°C
7 E8 09 1F 08 = 14,5°C
7 E8 08 7F 08 = 13,5°C
7 E8 07 EF 09 = 12,6°C
7 E8 06 5F 0A = 10,1°C
7 E8 FF AF 0E = -0,6°C
7 E8 FA EF 11 = -8,2°C
7 E8 F6 FF 13 = -14,5°C

Les deux premiers quartets sont constants et représentent l'identificateur de la sonde initialisé à sa mise sous tension.
Les deux bits de poids faible du troisième quartet représente le canal de transmission - 1 et son bit de poids fort est toujours égal à 1. Ce quartet est donc égal à 8 pour le canal 1, 9 pour le canal 2, A pour le canal 3.
(Il est à noter que l'on peut changer le canal d'émission de la sonde car elle comporte deux poussoirs bleus à l'intérieur, l'un pour changer l'unité de mesure °C/°F, l'autre pour changer de canal)
Les trois quartets suivants représentent la température en degrés Celsius multiplié par 10 sous la forme d'un entier signé de 12 bits.
Le suivant semble constant Ă©gal Ă  F.
Les deux derniers auraient dĂ» ĂŞtre la checksum.
Mais après plus de 200 réceptions et essais d'émission sur les divers canaux, voici mes constatations:
La supposée checksum ne dépend que de la température.
Toutefois elle peut être identique pour plus d'une vingtaine de températures juxtaposées (par exemple de 5,1 à 7,5°C).
Le récepteur livré avec la sonde se met en phase d'acceptation d'une sonde pendant 3 minutes. Pendant ce temps, il accepte toutes les émissions respectant le protocole quelque soit la supposée checksum. Ensuite, il n'accepte qu'une sonde précédemment identifiée sur le canal correspondant.

J'ai élaboré un programme en C++ en m'inspirant de celui de cha. Il est valable pour une sonde ayant comme identificateur 7E sur le canal 1. Je n'en suis pas un spécialiste. Je vous joins le code source.
Code: Tout sélectionner
/*
Ce programme récupère les informations du signal radio émis par la sonde de température piscine reçu par le raspberry PI et le décode.

Vous pouvez compiler cette source via la commande :
   g++ decodeur.cpp -o decodeur -lwiringPi
   
N'oubliez pas d'installer auparavant la librairie wiring pi ainsi que l'essentiel des paquets pour compiler

Rendez le programme exécutable par
   sudo chmod 777 decodeur

Vous pouvez lancer le programme via la commande :
   ./decodeur 2
le premier paramètre est le numéro de pin wiringPi d'entrée
*/


#include <wiringPi.h>
#include <iostream>
#include <stdio.h>
#include <sys/time.h>
#include <time.h>
#include <stdlib.h>
#include <sched.h>
#include <sstream>
#include <vector>
#include <algorithm>
            
using namespace std;

//Fonction de log
void log(string a)
{
   //DĂ©commenter pour avoir les logs
   //cout << a << endl;
}

//Fonction de passage du programme en temps réel (car la reception se joue a la micro seconde près)
void scheduler_realtime()
{
   struct sched_param p;
   p.sched_priority = sched_get_priority_max(SCHED_RR);
   if( sched_setscheduler( 0, SCHED_RR, &p ) == -1 ) perror("Failed to switch to realtime scheduler.");
}
//Fonction de remise du programme en temps standard
void scheduler_standard()
{
   struct sched_param p;
   p.sched_priority = 0;
   if( sched_setscheduler( 0, SCHED_OTHER, &p ) == -1 ) perror("Failed to switch to normal scheduler.");
}

//Fonction de différence entre 2 temps en microsecondes
long deltat(timeval ta, timeval tb)
{
        long diff;
   if(ta.tv_sec > tb.tv_sec) diff = 1000000L; else diff = 0;
   diff += (ta.tv_usec - tb.tv_usec);
   return diff;
}

//Programme principal
int main (int argc, char** argv)
{
   struct timeval t0, t1, t2;
   int pinI;
   bool v0, v1, v2;
   unsigned long long s;
   std::vector<unsigned long long> message;
   float t;
   unsigned int i, j, minimum, maximum, m;
   unsigned int n[12];

   //Valeurs minimales infĂ©rieures de 20% aux valeurs moyennes
   long dpmin = 400;
   long dimin = 800;
   long dimoy = 1600;
   long dimax = 3200;
   long delai = 6400;

   //On passe en temps rĂ©el
   scheduler_realtime();
   

   log("Demarrage du programme");
   //on rĂ©cupere l'argument qui est le numĂ©ro de Pin GPIO auquel est connectĂ© le recepteur radio
   pinI = atoi(argv[1]);
   //Si on ne trouve pas la librairie wiringPI, on arrĂŞte l'execution
   if(wiringPiSetup() == -1)
   {
   log("Librairie Wiring PI introuvable, veuillez lier cette librairie...");
   return -1;
   }else log("Librairie WiringPI detectee");
   pinMode(pinI, INPUT);
   log("Attente d'un signal du transmetteur ...");
      
   //On boucle pour Ă©couter les signaux
   while(1)
   {
      //On recherche la première impulsion du message : les impulsions trop courtes sont considĂ©rĂ©es comme des parasites et Ă©liminĂ©es
      gettimeofday(&t0, NULL);
      v0 = digitalRead(pinI);
      for (;;)
      {
         gettimeofday(&t1, NULL);
         v1=digitalRead(pinI);
         if(v1 == v0) continue;
         if (v1)
         {
            t0 = t1;
            v0 = v1;
            continue;
         }
         if (deltat(t1, t0) > dpmin) break;
         v0 = 0;
      }
      log ("première impulsion trouvĂ©e ");
      //Boucle d'Ă©coute des couples intervalle-impulsion
      s = 0;
      for(;;)
      {
         //Validation de l'intervalle minimun et d'un bit 0 : les intervalles trop courts sont considĂ©rĂ©s comme des parasites et Ă©liminĂ©s
         for (;;)
         {
            gettimeofday(&t2, NULL);
            v2 = digitalRead(pinI);
            if(v2)
            {
               t1 = t2;
               continue;
            }
            if (deltat(t2, t1) > dimin)
            {
               s <<= 1;
               break;
            }
         }
         //Si intervalle plus long, validation d'un bit 1
         for (;;)
         {
            gettimeofday(&t2, NULL);
            v2 = digitalRead(pinI);
            if(v2) goto fincouple;
            if(deltat(t2, t1) > dimoy)
            {
               s += 1;
               break;
            }
         }
         //Si intervalle plus long validation trame
         for (;;)
         {
            gettimeofday(&t2, NULL);
            v2 = digitalRead(pinI);
            if(v2) goto fincouple;
            if(deltat(t2, t1) > dimax)
            {
               s >>= 1;
               message.push_back(s);
               s = 0;
               break;
            }
         }
         log ("validation trame  ");
         //Si intervalle plus long sortie du message
         for (;;)
         {
            gettimeofday(&t2, NULL);
            v2 = digitalRead(pinI);
            if(v2) goto fincouple;
            if(deltat(t2, t1) > delai) goto finmess;
         }
         //Validation impulsion : les impulsions trop courtes sont considĂ©rĂ©es comme des parasites et Ă©liminĂ©es
fincouple:      t0 = t2;
         v0 = 1;
         for (;;)
         {
            gettimeofday(&t1, NULL);
            v1 = digitalRead(pinI);
            if (v1) continue;
            if (deltat(t1, t0) > dpmin) break;
            v0 = 0;
         }
      }
      //Traitement du message
finmess:   log ("traitement message ");
      //VĂ©rification conformitĂ© trame par trame
      for (i = 0; i < message.size(); i++)
      {
         //VĂ©rification du troisième octet qui doit ĂŞtre F
         if ((message[i] & 0xF00) == 0xF00)
         {
            //Elimination des trois quartets de droite
            message[i] >>= 12;
            //Elimination de l'entĂŞte
            message[i] &= 0xFFF;
            continue;
         }
         //Efface la trame non conforme
         message.erase(message.begin() + i);
         i -= 1;
      }
      //Le message ne comporte dĂ©sormais que des trames de trois quartets reprĂ©sentant des tempĂ©ratures
      //Faute d'avoir dĂ©chiffrĂ© la checksum, on choisit la trame rĂ©pĂ©tĂ©e le plus grand nombre de fois dans le message
      //Tri
      std::sort(message.begin(), message.end());
      //comptage et Ă©limination des doublons
         log ("comptage");
      maximum = 1;
      m = 1;
      for (i = 0; i < message.size(); i++)
      {
         n[i] = 1;
         for (j = i + 1; j < message.size(); j++)
         {
            if (message[j] == message[i])
            {
               n[i] += 1;
               if (n[i] > maximum)
               {
                  maximum = n[i];
                  m = i;
               }
               message.erase(message.begin() + j);
               j -= 1;
            }
         }
      }
      //on ne retient la trame rĂ©pĂ©tĂ©e le plus grand nombre de fois que si elle l'a Ă©tĂ© au moins une fois
      if (maximum > 1)
      {
         //La trame retenue est message[m]; si negatif on complète les 4 bits avant la conversion en short integer
         if (message[m] & 0x800) t = float(short(0xF000 | message[m])) / 10.; else t = float(short(message[m])) / 10.;
         // on passe en temps standard pour sortir la tempĂ©rature
         scheduler_standard();
         cout << "t = " << t << endl;
         scheduler_realtime();
      }
      message.clear();
   }
}


L'algorithme d'exploitation des trames reçues est assez complexe en raison de l'absence d'exploitation de la checksum. Il consiste à retenir la trame qui est transmise à l'identique le plus grand nombre de fois dans le message et au moins deux fois.

Dans un prochain article, je présenterai un programme d'automatisation de la filtration en fonction de la température.
Dernière édition par molpetrus le 08 Sep 2016, 21:32, édité 4 fois.
molpetrus
Membre un peu timide !
 
Messages: 4
Inscription: 26 Mar 2016, 10:17

Re: Décryptage protocole sonde de température piscine sans f

Messagede skydiveboy » 23 Juil 2016, 06:01

Bonjour,

J'essaye aussi de réaliser un montage via le même matériel que vous , avez vous progresser ?

je dois simplement récupérer le signal radio , pour ensuite le transcrire sur un lcd 16x2 via un arduino .

Je receptionne bien le signal d'une telecommande chacon mais pas le signal des emeteurs piscine et spa ... j'ai louper un truc ?

Bonne journée.
skydiveboy
Membre un peu timide !
 
Messages: 4
Inscription: 13 Juil 2016, 15:38

Re: Décryptage protocole sonde de température piscine sans f

Messagede molpetrus » 25 Juil 2016, 11:05

Bonjour,
Je suis en train d'optimiser le fonctionnement de l'automate. En effet, le battement de la mesure de température peut provoquer des mises en service ou arrêts intempestifs de la filtration. J'en profite pour économiser le fonctionnement du microprocesseur. Celui-ci en effet scrute en permanence la sonde de température. L'idée serait de le mettre en sommeil pendant la période d'arrêt ou de fonctionnement de la filtration.
Sinon, l'algorithme que j'ai présenté n'est valable que pour la sonde présentée. Par ailleurs, il est nécessaire de souder sur le récepteur une antenne de longueur ad hoc et une résistance afin d'éliminer les parasites comme indiqué dans le fil de discussion de cha.
Cordialement
molpetrus
Membre un peu timide !
 
Messages: 4
Inscription: 26 Mar 2016, 10:17

Re: Décryptage protocole sonde de température piscine sans f

Messagede skydiveboy » 29 Juil 2016, 07:50

Bonjour, j'ai exactement les mêmes flotteur que l'image representée en photo par vous même , j'ai un arduino uno et un arduino nano , et le recepteur est un recepteur commandé en chine ... donc vous dite que si je soude la resistance je capterais enfin quelque chose car la je ne capte que le signal d'une telecommande standard pour prise electrique et meme en mettant le flotteur a cote du recepteur le recepteur ne percoit rien ... j'utilise l'exemple Receive_Demo_Advanced de chez arduino il n'y a que celui la qui capte quelque chose ... au niveau de mon materiel dois je acheter un autre recepteur ou tout est correct ?

Bien Ă  vous,
skydiveboy
Membre un peu timide !
 
Messages: 4
Inscription: 13 Juil 2016, 15:38

Re: Décryptage protocole sonde de température piscine sans f

Messagede molpetrus » 20 AoĂ» 2016, 20:31

Bonsoir
Desolé de répondre si tardivement mais je n'ai pas eu d'alerte...
Pour la reception voir les conseils de Zescientist dans le fil de discussion viewtopic.php?f=118&t=15760#p125421
A+
molpetrus
Membre un peu timide !
 
Messages: 4
Inscription: 26 Mar 2016, 10:17

Re: Décryptage protocole sonde de température piscine sans f

Messagede michaeladdam » 21 AoĂ» 2016, 14:02

Tout d'abord pour une question de confort de nage. Avec un thermomètre sans fil, on peut s'apercevoir avant de plonger dans notre piscine qu'on avait oublié de mettre en route le système de chauffage ! Et même, grâce à un thermomètre sans fil, on peut vérifier à tout moment que le système de chauffage de notre piscine (qu'il s'agisse d'un chauffage électrique, solaire ou autre) http://www.afrimesure.com/categorie/ins ... ctronique/ fonctionne correctement, et que notre programmation est bien adéquate.

Ensuite, pour une question d'entretien et d'hygiène. En effet, s'il est assez désagréable de se baigner dans une eau trop froide, il n'est pas bon que la température de l'eau de notre piscine soit trop chaude. Parce qu'une eau trop chaude, c'est une eau qui sera moins réactive à nos produits d'entretien (chlore, etc), et donc plus difficile à traiter et à garder équilibrée. Avec un thermomètre sans fil, on peut s'assurer à tout moment que la température de l'eau reste correcte, et que nos produits de traitement de l'eau vont rester efficaces.
Avatar de l’utilisateur
michaeladdam
Membre Actif
 
Messages: 13
Inscription: 01 Mai 2016, 15:57

Re: Décryptage protocole sonde de température piscine sans f

Messagede molpetrus » 06 Sep 2016, 19:58

J'ai fait une mise à jour du message initial car l'entête du message est initialisée à la mise sous tension de la sonde !
Le programme a été modifié afin de prendre en compte cet aspect.
molpetrus
Membre un peu timide !
 
Messages: 4
Inscription: 26 Mar 2016, 10:17

Re: Décryptage protocole sonde de température piscine sans f

Messagede skydiveboy » 28 Jan 2017, 09:15

Voila , je met pour ma part mes recherches , je voulais décoder le signal radio envoyer via les sonde piscine décrite plus haut et récupérer leurs températures et leurs chaines ...
Chose faite grâce au info de molpetrus . Ce programme fonctionne sur Arduino avec les récepteurs même chinois et sans aucune modification de ceux-ci via une résistance ou autre , et nous captons sans aucune interferance les sondes .

CODE ARDUINO RECEPTEUR SONDE

Code: Tout sélectionner
/* Convertion d'un signal RF sonde piscine en bits.
* Ecrit par : Skydiveboy avec l'aide de Molpetrus
*/

// la taille du tampon du buffer doit ĂŞtre assez grande pour s'adapter
// aux données entre deux signaux de synchronisation successifs

#define RING_BUFFER_SIZE  256 // dĂ©finition de la taille du buffer

#define SYNC_LENGTH  4000 // temps de sĂ©paration de trame
#define SEP_LENGTH   500  // temps entre les impulsions dans les trames
#define BIT1_LENGTH  2000 // temps de validation d'un bit 1
#define BIT0_LENGTH  1000 // temps de validation d'un bit 0

#define DATAPIN  3  // D3 la pin  de l'arduino ou on connecte le recepteur RF

String data_txt, Val1, Val2, Val3, Val4, Val5, Val6, Val7, Val8, Val9; // permet de retenir la decoupedes 9 groupes de 4bit (36bit au total)

unsigned long timings[RING_BUFFER_SIZE];
unsigned int syncIndex1 = 0;  // index of the first sync signal
unsigned int syncIndex2 = 0;  // index of the second sync signal
bool received = false;

// Détecter si un signal de synchronisation est présent
bool isSync(unsigned int idx) {
  unsigned long t0 = timings[(idx+RING_BUFFER_SIZE-1) % RING_BUFFER_SIZE];
  unsigned long t1 = timings[idx];

  if (t0>(SEP_LENGTH-100) && t0<(SEP_LENGTH+100) &&
    t1>(SYNC_LENGTH-1000) && t1<(SYNC_LENGTH+1000) &&
    digitalRead(DATAPIN) == HIGH) {
    return true;
  }
  return false;
}

/* Interrupt 1 handler */
void handler() {
  static unsigned long duration = 0;
  static unsigned long lastTime = 0;
  static unsigned int ringIndex = 0;
  static unsigned int syncCount = 0;

  // Ignorer si nous n'avons pas traitĂ© le signal reçu prĂ©cĂ©dent
  if (received == true) {
    return;
  }
  // On calcule le timing si il est egal au dernier signal
  long time = micros();
  duration = time - lastTime;
  lastTime = time;

  // On met les donnees dans une chaine
  ringIndex = (ringIndex + 1) % RING_BUFFER_SIZE;
  timings[ringIndex] = duration;

  // On detect un signal synchroniser avec nos parametres
  if (isSync(ringIndex)) {
    syncCount ++;
    // Premier signal synchrone on l'enregistre dans la mĂ©moire tampon.
    if (syncCount == 1) {
      syncIndex1 = (ringIndex+1) % RING_BUFFER_SIZE;
    }
    else if (syncCount == 2) {
      // Deuxieme signal synchrone on commence a le convertir en Bit.
      syncCount = 0;
      syncIndex2 = (ringIndex+1) % RING_BUFFER_SIZE;
      unsigned int changeCount = (syncIndex2 < syncIndex1) ? (syncIndex2+RING_BUFFER_SIZE - syncIndex1) : (syncIndex2 - syncIndex1);
      // changeCount ,a la valeur 74 car on veut trier un message de 36bit donc -- 36 bits x 2 + 2  = 74 pour la synchro
      if (changeCount != 74) {
        received = false;
        syncIndex1 = 0;
        syncIndex2 = 0;
      }
      else {
        received = true;
      }
    }

  }
}


void setup() {
  Serial.begin(115200); // on initialise la vue port com on peut aussi la mettre a 9600 Baud

  pinMode(3, INPUT); // pin D3 de l'arduino on connecte la pin data du recepteur RF 433Mhz
  attachInterrupt(1, handler, CHANGE);


}

void loop() {
  if (received == true) {

    // dĂ©sactive l'interruption pour Ă©viter que de nouvelles donnĂ©es ne corrompent le tampon
    detachInterrupt(1);
    // boucle sur donnĂ©es tampon
    for(unsigned int i=syncIndex1; i!=syncIndex2; i=(i+2)%RING_BUFFER_SIZE) {
      unsigned long t0 = timings[i], t1 = timings[(i+1)%RING_BUFFER_SIZE];
      if (t0>(SEP_LENGTH-100) && t0<(SEP_LENGTH+100)) {
       if (t1>(BIT1_LENGTH-1000) && t1<(BIT1_LENGTH+1000)) {
         data_txt += "1"; // on insert un 1 dan la chaine
       } else if (t1>(BIT0_LENGTH-1000) && t1<(BIT0_LENGTH+1000)) {
         data_txt += "0"; // on insert un 0 dans la chaine

       } else {
         ////Serial.print("Timing OK");  // Timing OK
       }
       } else {
       ////Serial.print("Timing Inconnu");  // Hors Timing
       }
       
    }




//Serial.print(data_txt); // Vision Total de toute la chaine de n'importe quel sonde sans tri , a decommenter pour voir la chaine recue



//Coupe Chaine 36Bit en partie de 4Bit pour le tri
Val1 = data_txt.substring(0,4);
Val2 = data_txt.substring(4,8);
Val3 = data_txt.substring(8,12);
Val4 = data_txt.substring(12,16);
Val5 = data_txt.substring(16,20);
Val6 = data_txt.substring(20,24);
Val7 = data_txt.substring(24,28);
Val8 = data_txt.substring(28,32);
Val9 = data_txt.substring(32,36);

String Val_Temp = data_txt.substring(12,24); // on ne recupere les 12 bit de la temperature
int Size_Val = data_txt.length(); // obtenir la taille de la chaine logiquement egal a 36 caracteres


if(Size_Val == 36) { // Tri du signal et taille des données sonde reçue si on a 36 caractères dans la chaine on les prends


if(Val3 == "0000") { // Chaine SONDE CH1 reçue
// reste a convertir la chaine Val_Temp de 12Bit par la temperature en decimal et en faire ce que vous voulez.
}

if(Val3 == "0001") { // Chaine SONDE CH2 reçue
// reste a convertir la chaine Val_Temp de 12Bit par la temperature en decimal et en faire ce que vous voulez.
}

if(Val3 == "0010") { // Chaine SONDE CH3 reçue
// reste a convertir la chaine Val_Temp de 12Bit par la temperature en decimal et en faire ce que vous voulez.
}

if(Val3 == "0100") { // Chaine SONDE CH4 reçue
// reste a convertir la chaine Val_Temp de 12Bit par la temperature en decimal et en faire ce que vous voulez.
}

if(Val3 == "1000") { // Chaine SONDE CH5 reçue
// reste a convertir la chaine Val_Temp de 12Bit par la temperature en decimal et en faire ce que vous voulez.
}


 
}

//Serial.println(); // retour a la ligne pour la lecture du port com

data_txt = ""; // On vide la chaine pour lire les suivante reception

// on reset le tout pour une réécoute d'un signal futur.

    received = false;
    syncIndex1 = 0;
    syncIndex2 = 0;

    // on rĂ©active l'ecoute des signaux
    attachInterrupt(1, handler, CHANGE);
  }
}


CODE ARDUINO EMETEUR SIGNAL SONDE

Code: Tout sélectionner

/* Realisation d'un signal RF sonde piscine en bits.
* Ecrit par : Skydiveboy avec l'aide de Molpetrus
*/

#define RF_DATA_PIN 3 // Pin de connection Data de l'emeteur

#define SHORT_DELAY 417  // Temps entre les impulsions de la trame
#define BIT1_DELAY  1850 // Temps pour un Bit 1
#define BIT0_DELAY  850 // Temps pour un Bit 0
#define SYNC_DELAY  3850  // Temps d'espace entre chaque Trame du signal

void Send_Signal(unsigned long data, int Nbr_Send) {


  for (unsigned char i=0; i<Nbr_Send; i++) { // repetition du signal
   
    for (unsigned char k=0; k<37; k++) { // passer en revue toute la chaine a envoyer

      unsigned long d = ((bitRead(data, 36-k)) == 1 ? BIT1_DELAY : BIT0_DELAY);

      digitalWrite(RF_DATA_PIN, LOW);
      delayMicroseconds(d);
      digitalWrite(RF_DATA_PIN, HIGH); 
      delayMicroseconds(SHORT_DELAY); 

    }

    digitalWrite(RF_DATA_PIN, LOW); 
    delayMicroseconds(SYNC_DELAY);
  }

}



void loop() {

// Exemple d'envoi sur chaine 4 la valeur de 1.0 degre
// On commence toujours la chaine de donnée par "0b0" ensuite on cree nos 36bit a envoyer et imiter le signal des sondes donc :
// la chaine commence par 0000 Val1 dans le code recepteur , 1100 Val2 code recepteur , 0100 Val3 code recepteur et definition de la chaine ici CH4 ensuite :
// la Temperature en Bit = Val4,Val5,Val6 dans code recepteur : exemple 1,0 degre Celsius = a la chaine 000000001010 .
// pour finir nos 36 Bit de donnée on rempli le reste de Zero , donc Val7,Val8,Val9 dans code recepteur = 000000000000.
// Au Final ca donne : 0b0000011000010000000001010000000000000 qu'on envoi via la commance Send_Signal

Send_Signal(0b0000011000010000000001010000000000000, 10); // commande d'envoi signal Element1 la chaine en Bit , Element 2 : Nombre de fois qu'on veut envoyer le signal ici 10 fois.
   
delay(5000);  // Attente de 5 secondes pour relancer l'operation , Si on imite les sondes Mettez 60 Secondes.
 
}

void setup() {

      pinMode(RF_DATA_PIN, OUTPUT);

}




Voila j'espère que sa servira a quelqu'un :)

Maintenant que j'ai reussit a decoder le signal et a le reproduire, pour pouvoir faire plusieurs sonde personnel temperature exterieur ect... car si Val3 nous donne la chaine de la sonde , cela veut dire qu'on nous ne sommes plus limiter on peut très bien créer notre propre chaine de 36bit en modifiant les 4bit de VAL3 et ainsi créer plus de Chaine de sonde ...

A plus.
skydiveboy
Membre un peu timide !
 
Messages: 4
Inscription: 13 Juil 2016, 15:38

Re: Décryptage protocole sonde de température piscine sans f

Messagede domotics » 30 Jan 2017, 20:55

Merci pour ton partage
Domotics
Mon Skype : mr.domotics - Contactez moi pour une démo, des réponses à vos questions, ...
Mon Installation : Eedomus, Zwave, Oregon, Sonos, EnOcean, Chacon, Raspberry Pi, IPX800, WES, RFXTRX, Nas Synology et Cams IP
Mon Conseil : La domotique doit toujours rester simple et demander un minimum de maintenance; Pensez aux autres utilisateurs de la maison ...
Ma Chaine Youtube : https://www.youtube.com/user/tteladomotique/?sub_confirmation=1

Domotics propose ses services via sa société de conseils http://www.id2domotique.com et sa boutique http://laboutiquededomotique.com
Avatar de l’utilisateur
domotics
Administrateur
 
Messages: 5072
Inscription: 15 AoĂ» 2003, 14:38
Localisation: Toulouse

Re: Décryptage protocole sonde de température piscine sans f

Messagede skydiveboy » 15 AoĂ» 2018, 08:10

Bonjour,

Je me permet de déterré le post, Car il semble que les nouvelles sonde qu'on achete actuellement , ont changer de timing et de cryptage
donc mon décodage de l'ancien ne fonctionne plus . une idée ?
voici les images du signal tirée via le logiciel Audacity .

Premiere image montre l'espace entre les deux envoi , il semble separé d'un espace d'environ 30 secondes .
Image

Zoom sur le signal
Image

Zoom sur les 2 signaux recu identique
Image

Vue entre les 2 signaux recu
Image

Une des deux reception de signal complet pour un envoi de temperature de 23,5 degre celsius sur la chaine 1
Image

Vue sur tete d'un des deux signal recu pour la tentative du decodage
Image

Reception de plusieurs signaux différent sur la Chaine 1 comme le debut du signal commence toujours par 8 x 0 et deux espace inconnu :

00000000???????? comme sur les images plus haut

Donc je demarre mes receptions du premier bit 1 les espaces sont vonlontaire pour separer ce qui ne change jamais ???

12,4° = 1010101010 1101 01111100110110000001110011001010000
31,8° = 1010101010 1101 01001100010110000010110001101000110
25,3° = 1010101010 1101 01011011100110000011101110000111100
26,2° = 1010101010 1101 01011010000110000011101000000100100
25,9° = 1010101010 1101 01011011000110000011101100000110100
00,0° = 1010101010 1101 10011011110110000011101100000111100

Tentative d'une meme temperature sur une autre chaine pour determiner ce qui change et isoler la temperature ...

Chaine 1 25,7° = 1010101010 1101 01011011100110000011101110000111100
Chaine 2 25,7° = 1010101010 1101 01011011100101000011011110111111100

La chaine complete comme sur les images avec les 8 bit 0 du debut du signal et les points d'interogations ect... fait 59 bit de long
et juste comme ici au decu dans les receptions j'ai 49 bit de long. si on ajoute les 8 bit 0 et le 2 inconnu 49+8+2 = 59 bit total


Toutes ses chaines de bit son lue a partir de audacity car je n'arrive pas avec mon arduino a receptionner le message comme avec les anciens flotteur soit je me trompe
avec le calcul des millisecondes du message ou je ne sais pas mais je ne receptionne rien ... j'utilise exactement la meme programation que ce que j'ai poster sur le forum dans les message precedent en changent le timing en début de prog mais rien n'y fait .

Une idée du cryptage , du timing pour le code ect.. avant c'etais signal 36 bit temperature en 12 bit , timing 4000 microsec pour une synchro de 500 microsec dont bit1 2000 microsec et bit0 1000 microsec ... mais la je seche :p
skydiveboy
Membre un peu timide !
 
Messages: 4
Inscription: 13 Juil 2016, 15:38


Retourner vers Raspberry Pi

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 1 invité

Copyright © 2011 - Touteladomotique.com - Tous droits rĂ©servĂ©s
Les blogs partenaires : Abavala, Domo-Blog, Domotique34, Maison et Domotique