Protocoles Oregon Scientific et Arduino : Encodage

Maintenant que l’on décode les protocoles Oregon Scientific (le v2 du moins car n’ayant pas de sonde en v3, je n’ai pas pu tester mais certains commentaires laissent à penser que ça fonctionne 🙂 ), on va s’attaquer à l’émission de trames Oregon Scientific v2 depuis un arduino. Je pense que ça va en intéresser plus d’un et vous aurez compris l’idée derrière cela … réaliser des sondes pas chères et surtout compatibles avec les équipements du marché tel que le RFXCom ou la Zibase.
MAJ 10/02/2013 : suite à un problème avec l’éditeur de wordpress, le code était foireux à la ligne 264, c’est corrigé. Merci à catalin.

Note: Je parle de protocole version 2, il s’agit du 2.1 à réalité.

[adsGrandRectangleTexte]

Le protocole Oregon Scientific v2

Codage

Je suis parti des specs que l’on trouve ici: http://wmrx00.sourceforge.net/Arduino/OregonScientific-RF-Protocols.pdf.

Note : Il y a des différences entre la spec et ce que fait le décodeur des articles précédant, notamment au niveau des ID des sondes.
En effet, si on prend l’exemple d’une sonde THN132N, la spec indique qu’elle renvoie 0xEC40 comme ID, alors que nous on attend 0xEA4C. le « A » de 0xEA4C semble venir en fait de 4bits de syncho envoyés par toutes les sondes. Du coup, même si le décodeur fonctionne, je pense qu’il ne doit pas reconnaitre toutes les sondes correctement (à tester, maintenant que l’on peut simuler n’importe qu’elle sonde).

Les protocoles 2 et 3 transmettent à un débit d’environ 1024Hz et utilisent un codage manchester. Un bit 0 est représenté par une transition du niveau bas vers le niveau haut et un bit 1 par une transition du niveau haut vers le niveau bas. La transition se produit au milieu d’une pulsation.

Particularités du protocole Oregon Scientific 2

La version 2 du protocole Oregon Scientific présente quelques particularités. Chaque bit est envoyé 4 fois. D’abords, les bits sont doublés. Pour un bit 1, on envoie « 01 » et pour un bit 0, « 10 ». Puis le message complet est envoyé 2 fois.

Structure d’une trame Oregon Scientific

Les protocoles v2 et v3 ont une structure similaire :

[ Préambule (16/24) ] [ Sync (4) ] [ Data (taille variable) ] [ Postambule (taille variable) ]

1. Un préambule qui permet de reconnaitre une trame Oregon. Elle consiste en une série de 24bits « 1 » pour la version 3 et 16bits « 1 » pour la version 2. N’oubliez pas que dans la version 2, chaque bit est doublé par son inverse. On se retrouve donc pour la v2 avec 32bits « 01010101… » .
2. 4 bits de synchronisation : 0101, le fameux « A » (voir note plus haut). Les bits sont envoyés bit de poids faible en premier (A = 1010 -> tramis à l’envers : 0101). Pour la v2 : 10011001, Vous suivez toujours ?
3. Les datas (voir plus bas)
4. un postambule variable.

Analyse de la trame à « l’oscilloscope »

Forcement, ça n’a pas fonctionné du premier coup et pour vérifier ce que mon émetteur envoyait et le comparer avec une vrai sonde un oscilloscope aurait été bien pratique. Il y a plusieurs méthodes pour se dépatouiller sans oscillo.

On peut brancher un récepteur RF433 sur l’entrée ligne d’une carte son et utiliser un soft comme audacity pour afficher le signal comme le « ferait » un oscillo. Malheureusement je n’ai pas d’entrée ligne sur mon portable.

J’ai trouvé une autre méthode à base d’arduino : xoscillo. C’est un oscilloscope logiciel. Le signal reçu par un Arduino équipé d’un récepteur RF est envoyé via l’USB sur le PC qui fait tourner le soft xoscillo et qui affiche une représentation graphique du signal. Ca ne remplace pas un vrai oscillo bien sûr mais dans notre cas c’est suffisant et en tout cas, ça m’a bien dépanné 🙂

Sur l’image, une trame Oregon complète (le deuxième envoi) en haut. En bas, On voit clairement les 16 bits du préambule par exemple et les 4bits de synchro.

Simulation d’une sonde Oregon Scientific V2 avec un Arduino

Le sketch ci dessous permet de simuler une sonde de température Oregon Scientific THN132N ou une sonde de température/humidité THGR2228N.

Le code envoie la même trame toutes les 30 secondes. Libre à vous ensuite d’ajouter un capteur de température et/ou d’humidité pour envoyer de vrais informations.

Je me suis inspiré du code de skyduino pour l’envoi de trame blyss. Je l’ai testé sur Arduino Duemilanove et l’IDE 1.0.1 (linux).

/*
 * connectingStuff, Oregon Scientific v2.1 Emitter
 * http://connectingstuff.net/encodage-protocoles-oregon-scientific-sur-arduino/
 *
 * Copyright (C) 2013 olivier.lebrun@gmail.com
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*/

#define THN132N

const byte TX_PIN = 4;

const unsigned long TIME = 512;
const unsigned long TWOTIME = TIME*2;

#define SEND_HIGH() digitalWrite(TX_PIN, HIGH)
#define SEND_LOW() digitalWrite(TX_PIN, LOW)

// Buffer for Oregon message
#ifdef THN132N
  byte OregonMessageBuffer[8];
#else
  byte OregonMessageBuffer[9];
#endif

/**
 * \brief    Send logical "0" over RF
 * \details  azero bit be represented by an off-to-on transition
 * \         of the RF signal at the middle of a clock period.
 * \         Remenber, the Oregon v2.1 protocol add an inverted bit first 
 */
inline void sendZero(void) 
{
  SEND_HIGH();
  delayMicroseconds(TIME);
  SEND_LOW();
  delayMicroseconds(TWOTIME);
  SEND_HIGH();
  delayMicroseconds(TIME);
}

/**
 * \brief    Send logical "1" over RF
 * \details  a one bit be represented by an on-to-off transition
 * \         of the RF signal at the middle of a clock period.
 * \         Remenber, the Oregon v2.1 protocol add an inverted bit first 
 */
inline void sendOne(void) 
{
   SEND_LOW();
   delayMicroseconds(TIME);
   SEND_HIGH();
   delayMicroseconds(TWOTIME);
   SEND_LOW();
   delayMicroseconds(TIME);
}

/**
* Send a bits quarter (4 bits = MSB from 8 bits value) over RF
*
* @param data Source data to process and sent
*/

/**
 * \brief    Send a bits quarter (4 bits = MSB from 8 bits value) over RF
 * \param    data   Data to send
 */
inline void sendQuarterMSB(const byte data) 
{
  (bitRead(data, 4)) ? sendOne() : sendZero();
  (bitRead(data, 5)) ? sendOne() : sendZero();
  (bitRead(data, 6)) ? sendOne() : sendZero();
  (bitRead(data, 7)) ? sendOne() : sendZero();
}

/**
 * \brief    Send a bits quarter (4 bits = LSB from 8 bits value) over RF
 * \param    data   Data to send
 */
inline void sendQuarterLSB(const byte data) 
{
  (bitRead(data, 0)) ? sendOne() : sendZero();
  (bitRead(data, 1)) ? sendOne() : sendZero();
  (bitRead(data, 2)) ? sendOne() : sendZero();
  (bitRead(data, 3)) ? sendOne() : sendZero();
}

/******************************************************************/
/******************************************************************/
/******************************************************************/

/**
 * \brief    Send a buffer over RF
 * \param    data   Data to send
 * \param    size   size of data to send
 */
void sendData(byte *data, byte size)
{
  for(byte i = 0; i < size; ++i)
  {
    sendQuarterLSB(data[i]);
    sendQuarterMSB(data[i]);
  }
}

/**
 * \brief    Send an Oregon message
 * \param    data   The Oregon message
 */
void sendOregon(byte *data, byte size)
{
    sendPreamble();
    //sendSync();
    sendData(data, size);
    sendPostamble();
}

/**
 * \brief    Send preamble
 * \details  The preamble consists of 16 "1" bits
 */
inline void sendPreamble(void)
{
  byte PREAMBLE[]={0xFF,0xFF};
  sendData(PREAMBLE, 2);
}

/**
 * \brief    Send postamble
 * \details  The postamble consists of 8 "0" bits
 */
inline void sendPostamble(void)
{
#ifdef THN132N
  sendQuarterLSB(0x00);
#else
  byte POSTAMBLE[]={0x00};
  sendData(POSTAMBLE, 1);  
#endif
}

/**
 * \brief    Send sync nibble
 * \details  The sync is 0xA. It is not use in this version since the sync nibble
 * \         is include in the Oregon message to send.
 */
inline void sendSync(void)
{
  sendQuarterLSB(0xA);
}

/******************************************************************/
/******************************************************************/
/******************************************************************/

/**
 * \brief    Set the sensor type
 * \param    data       Oregon message
 * \param    type       Sensor type
 */
inline void setType(byte *data, byte* type) 
{
  data[0] = type[0];
  data[1] = type[1];
}

/**
 * \brief    Set the sensor channel
 * \param    data       Oregon message
 * \param    channel    Sensor channel (0x10, 0x20, 0x30)
 */
inline void setChannel(byte *data, byte channel) 
{
    data[2] = channel;
}

/**
 * \brief    Set the sensor ID
 * \param    data       Oregon message
 * \param    ID         Sensor unique ID
 */
inline void setId(byte *data, byte ID) 
{
  data[3] = ID;
}

/**
 * \brief    Set the sensor battery level
 * \param    data       Oregon message
 * \param    level      Battery level (0 = low, 1 = high)
 */
void setBatteryLevel(byte *data, byte level)
{
  if(!level) data[4] = 0x0C;
  else data[4] = 0x00;
}

/**
 * \brief    Set the sensor temperature
 * \param    data       Oregon message
 * \param    temp       the temperature
 */
void setTemperature(byte *data, float temp) 
{
  // Set temperature sign
  if(temp < 0)
  {
    data[6] = 0x08;
    temp *= -1;  
  }
  else
  {
    data[6] = 0x00;
  }

  // Determine decimal and float part
  int tempInt = (int)temp;
  int td = (int)(tempInt / 10);
  int tf = (int)round((float)((float)tempInt/10 - (float)td) * 10);

  int tempFloat =  (int)round((float)(temp - (float)tempInt) * 10);

  // Set temperature decimal part
  data[5] = (td << 4);
  data[5] |= tf;

  // Set temperature float part
  data[4] |= (tempFloat << 4);
}

/**
 * \brief    Set the sensor humidity
 * \param    data       Oregon message
 * \param    hum        the humidity
 */
void setHumidity(byte* data, byte hum)
{
    data[7] = (hum/10);
    data[6] |= (hum - data[7]*10) << 4;
}

/**
 * \brief    Sum data for checksum
 * \param    count      number of bit to sum
 * \param    data       Oregon message
 */
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;
}

/**
 * \brief    Calculate checksum
 * \param    data       Oregon message
 */
void calculateAndSetChecksum(byte* data)
{
#ifdef THN132N
    int s = ((Sum(6, data) + (data[6]&0xF) - 0xa) & 0xff);

    data[6] |=  (s&0x0F) << 4;     data[7] =  (s&0xF0) >> 4;
#else
    data[8] = ((Sum(8, data) - 0xa) & 0xFF);
#endif
}

/******************************************************************/
/******************************************************************/
/******************************************************************/

void setup()
{
  pinMode(TX_PIN, OUTPUT);

  Serial.begin(9600);
  Serial.println("\n[Oregon V2.1 encoder]");

  SEND_LOW();  

#ifdef THN132N  
  // Create the Oregon message for a temperature only sensor (TNHN132N)
  byte ID[] = {0xEA,0x4C};
#else
  // Create the Oregon message for a temperature/humidity sensor (THGR2228N)
  byte ID[] = {0x1A,0x2D};
#endif  

  setType(OregonMessageBuffer, ID);
  setChannel(OregonMessageBuffer, 0x20);
  setId(OregonMessageBuffer, 0xBB);
}

void loop()
{
  // Get Temperature, humidity and battery level from sensors
  // (ie: 1wire DS18B20 for température, ...)
  setBatteryLevel(OregonMessageBuffer, 0); // 0 : low, 1 : high
  setTemperature(OregonMessageBuffer, 11.2);

#ifndef THN132N
  // Set Humidity
  setHumidity(OregonMessageBuffer, 52);
#endif  

  // Calculate the checksum
  calculateAndSetChecksum(OregonMessageBuffer);

  // Show the Oregon Message
  for (byte i = 0; i < sizeof(OregonMessageBuffer); ++i)   {     Serial.print(OregonMessageBuffer[i] >> 4, HEX);
    Serial.print(OregonMessageBuffer[i] & 0x0F, HEX);
  }

  // Send the Message over RF
  sendOregon(OregonMessageBuffer, sizeof(OregonMessageBuffer));
  // Send a "pause"
  SEND_LOW();
  delayMicroseconds(TWOTIME*8);
  // Send a copie of the first message. The v2.1 protocol send the
  // message two time 
  sendOregon(OregonMessageBuffer, sizeof(OregonMessageBuffer));

  // Wait for 30 seconds before send a new message 
  SEND_LOW();
  delay(30000);
}

Compatibilité et conclusion

J’ai testé avec succès la réception avec le décodeur des articles précédant et avec un ancien RFXCom USB (2010). J’attends vos retours pour savoir si ça passe bien sur les nouveaux RFXcom ou sur une Zibase, voir sur une station Oregon Scientific directement.

J’avais commencé une librairie Oregon pour Arduino que je vais du coup essayer de terminer et de publier.

[adsGrandRectangleHTexte]