Décodage des protocoles Oregon Scientific sur Arduino (3/3)

Suite et fin de cette série (Décodage des protocoles Oregon Scientific sur Arduino (1/3), Décodage des protocoles Oregon Scientific sur Arduino (2/3)). Je vous présente aujourd’hui une modification du décodeur lui permettant de traiter les informations de toutes les sondes Oregon v2, on parlera aussi du montage et de sa portée .

[adsGrandRectangleTexte]

Modification du décodeur Oregon Scientific

Dans l’article précédant, nous avons vu comment identifier à quelle sonde nous avons à faire. Nous allons utiliser ceci pour identifier les sondes au plus tôt, c’est à dire pendant la réception des trames. Ceci va nous permettre de savoir de quelle taille devrait être la trame que nous sommes en train de recevoir. On obtient ainsi une condition de sortie du décodeur qui marchera pour toutes les sondes.

Tailles des trames :

J’ai repris le tableau de l’article précédant en y indiquant pour chaque type de sonde, la taille des trames émises :

Par rapport au premier article de la série, nous allons modifier la fonction virtual void gotBit (char value). Pour que le décodeur fonctionne avec toutes les sondes Oregon v2, nous allons détecter à quelle type de sonde la trame en cours de décodage appartient afin de modifier à la volé la condition de sortie du décodeur (trame de longueur variable).
En effet, l’identifiant de sonde étant codé dans les deux premiers octets, il suffit de les lires dès qu’ils sont réceptionnés :

virtual void gotBit (char value) 
{
        if(!(total_bits & 0x01))
        {
            data[pos] = (data[pos] >> 1) | (value ? 0x80 : 00);
        }
        total_bits++;
        pos = total_bits >> 4;
        if(pos == 2)
        {
          // Taille de trame par défaut (utilisée dans la majorité des sondes)
          max_bits = 160;

          // Exceptions :
          if(data[0] == 0xEA)
          {
            if(data[1] == 0x4C) max_bits = 136; // TH132N : 68 * 2
            else if(data[1] == 0x7C) max_bits = 240; // UV138 : 120 * 2
          }
          else if(data[0] == 0x5A)
          {
            if(data[1] == 0x5D) max_bits = 176; // THGR918 : 88 * 2
            else if(data[1] == 0x6D)max_bits = 192; // BTHR918N : 96 * 2
          }
          else if(data[0] == 0x1A  && data[1] == 0x99)
            max_bits = 176; // WTGR800 : 88 * 2
          else if(data[0] == 0xDA  && data[1] == 0x78)
            max_bits = 144; // UVN800 : 72 * 2
          else if((data[0] == 0x8A || data[0] == 0x9A) && data[1] == 0xEC)
            max_bits = 208; // RTGR328N 104 * 2
          else if(data[0] == 0x2A)
          {  
            if(data[1] == 0x19) max_bits = 184; // RCR800 : 92 * 2
            else if(data[1] == 0x1d) max_bits = 168; // WGR918 : 84 * 2
          }
       }

       if (pos >= sizeof data)
       {
            Serial.println("sizeof data");
            resetDecoder();
            return;
       }
       state = OK;
}

Cette trame est elle valide ? … Calcul de la checksum

J’en ai profité pour ajouter le calcul de la checksum et pour être simple Oregon Scientific à choisi des calculs de checksum différents selon les types de sondes … forcement c’est plus drôle … humm :/

Il suffit d’ajouter ces fonctions au sketch précédant et de tester le retour de l’une ou l’autre (suivant le type de sonde) dans la fonction reportSerial(…) :

• checksum(data) pour les sondes de type THN132N
• et checksum2(data) pour les sondes de type THGR228N

byte checksum(const byte* data)
{
  int c = ((data[6]&0xF0) >> 4) + ((data[7]&0xF)<<4);
  int s = ((Sum(6, data) + (data[6]&0xF) - 0xa) & 0xff);
  return s == c; 
}

byte checksum2(const byte* data)
{
  return data[8] == ((Sum(8, data) - 0xa) & 0xff);
}

int Sum(byte count, const byte* data)
{
  int s = 0;

  for(byte i = 0; i<count;i++)
  {
    s += (data[i]&0xF0) >> 4;
    s += (data[i]&0xF);
  }

  if(int(count) != count)
    s += (data[count]&0xF0) >> 4;

  return s;
}

La portée

La portée est très variable selon le matériel utilisé. Dans mon cas, il dépend principalement de deux choses :

• La tension aux bornes du récepteur RF433. Plus il est proche de 5v (pour mon récepteur) meilleure est la portée.
• Au récepteur RF433 lui-même. Certains sont plus sensibles que d’autres au « bruit », d’où les _gros_ écarts de prix.

On peut ensuite jouer sur d’autres points :

• L’antenne. J’avais réalisé quelques tests avec une antenne type Rfxcom et la portée était meilleure, à confirmer.
• l’électronique. On peut ajouter un filtre en entrée du récepteur pour atténuer le bruit (condensateur de découplage).

Pour ma part, j’utilise un récepteur bas de gamme à ~4€. Ci-dessous un tableau récapitulant mes différents tests avec deux cartes Arduino et différentes méthodes d’alimentation. L’antenne utilisée est un simple fil de 17.3cm.

On voit que c’est super sensible, est ce dû à mon récepteur « cheap » ? Avec une bonne alimentation, on atteint quand même déjà de bonnes distances.

J’ai reçu quelques résultats de tests d’un lecteur qui malgré un bon 5v aux bornes du récepteurs obtient une mauvaise portée. si vous faites quelques expérimentations vos résultats m’intéresse, n’hésitez pas à poster un commentaire.

Je mettrai l’article à jour en fonction des éventuels retours et après quelques tests qu’il me reste à faire : meilleur récepteur et meilleure antenne entre autre.

Schéma de montage

Pour réaliser ce montage, il vous faudra un émetteur RF433Mhz (J’utilise personnellement celui-ci). Le schéma de câblage de l’émetteur en lui même est plutôt simple, je vous laisse en juger :

Condensateur de découplage

Le découplage capacitif consiste à mettre des capacités de diverses valeurs en parallèle au point à découpler. Son but est de nettoyer la tension à découpler. Il faut placer le condensateur au plus près du point à découpler, dans notre cas, entre le gnd et le +5v du récepteur. On m’avait conseillé un condensateur de 47nF.

Conclusion

Voila, nous avons tout ce qu’il faut pour réceptionner les informations de nos chères sonde Oregon Scientific :). Avec le code ci-dessus vous devriez récupérer les trames non décodées de toutes les sondes v2.1. Coté décodage j’en suis resté aux sondes THN132N et THGR228N auxquelles j’ai ajouté le calcul de la checksum.

Une librairie propres est en court d’écriture, j’en profiterai pour y ajouter le décodage des autres type de sondes. En attendant, je vous rappelle que vous pouvez trouver tout ce dont vous avez besoin dans les sources de xpl-perl.