[Tuto diy] Fabriquer sonde radio Oregon a 5€ pour les nuls V2

les autres capteurs : Sondes Météo, switches
Neutrino
Messages : 1385
Enregistré le : 10 juil. 2015, 15:42
Localisation : Challans (85)
Contact :

Re: [Tuto diy] Fabriquer sonde radio Oregon a 5€ pour les nuls V2

Message par Neutrino »

Oui, c'est possible.
J'ai une sonde avec une ds18b20 et un DHT22.

La modification du code est moche mais il fonctionne.
Il peux largement être optimiser niveau consommation.

Code : Tout sélectionner

/*
 * connectingStuff, Oregon Scientific v2.1 Emitter
 * http://connectingstuff.net/blog/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.
 *
 * V2 par vil1driver
 * 
 * sketch unique pour sonde ds18b20 ou DHT11/22
 * choix de la périodicité de transmission
 * remontée niveau de batterie
 * 
 * ajout d'au capteur pir ou reed ou tilt
 *
*/

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

    emplacement des PIN de la puce ATtiny8
    
                +-------+
Ain0  D5  PB5  1|*      |8   VCC
Ain3  D3  PB3  2|       |7   PB2  D2  Ain1
Ain2  D4  PB4  3|       |6   PB1  D1  pwm1
          GND  4|       |5   PB0  D0  pwm0
                +-------+ 


            cablage a realiser
                
                +-------+
               1|*      |8   (+)
Data Sonde 1W  2|       |7   Data sonde DHT
      TX 433   3|       |6   Switch B (optionel)
         (-)   4|       |5   Switch A (optionel)
                +-------+ 

                              
****************      Confuguration     *******************/


#define NODE_ID 0x02              // Identifiant unique de votre sonde (hexadecimal)
#define NODE_ID2 0x01              // Identifiant unique de votre sonde (hexadecimal)

#define LOW_BATTERY_LEVEL 3400    // Voltage minumum (mV) avant d'indiquer batterie faible
#define WDT_COUNT 5              // Nombre de cycles entre chaque mesure (1 cycles = 8 secondes, 5x8 = 40s)

// decommenter la ligne qui corresponds a votre sonde
#define DS18B20
#define DHT22

// si une mesure est identique a la precedente, elle ne sera pas transmise
// on economise ainsi la batterie
// decommentez la ligne suivante si vous souhaitez transmettre chaque mesure
#define ALWAYS_SEND


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


// decommenter la(les) ligne(s) suivante(s) si vous utilisez un(des) capteur(s) supplementaire(s)
//#define SWITCH_A
//#define SWITCH_B
//#define PHOTORES

#define SWITCH_A_HOUSE_CODE 'F'        // code maison du capteur A
#define SWITCH_A_UNIT_CODE 6           // code unite du capteur A
#define SWITCH_B_HOUSE_CODE 'F'        // code maison du capteur B
#define SWITCH_B_UNIT_CODE 7           // code unite du capteur B
#define PHOTORES_UNIT_CODE 8

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


#define DATA_PIN 3                // pin 2 // data de la sonde
#define DATA_PIN2 2                // pin 1 // data de la sonde
#define TX_PIN 4                  // pin 3 // data transmetteur
#define SWITCH_A_PIN 0            // pin 5 // wake up SWITCH A output
#define SWITCH_B_PIN 1            // pin 6 // wake up SWITCH B output
#define PHOTORES_PIN 1            // pin 7



/***************  Fin de configuration   *****************/


// Chargement des librairies
#include <avr/sleep.h>    // Sleep Modes
#include <avr/wdt.h>      // Watchdog timer
#include <avr/interrupt.h>
#ifdef DS18B20
  #include "OneWire.h"
  #define DS18B20 0x28     // Adresse 1-Wire du DS18B20
  OneWire ds(DATA_PIN2); // Création de l'objet OneWire ds
#endif
#ifdef DHT22
  #include "dht.h"
  dht DHT;
#endif

#if defined(SWITCH_A) || defined(SWITCH_B) || defined(PHOTORES)
  #include  "x10rf.h"
  x10rf myx10 = x10rf(TX_PIN,0,3); // no blink led and send msg three times
#endif

#ifndef cbi
  #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
  #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

#ifdef SWITCH_A
  volatile uint8_t oldValueA = -1; // for x10 switch A
#endif
#ifdef SWITCH_B
  volatile uint8_t oldValueB = -1; // for x10 switch B
#endif  
volatile float lastTemp = 0.0;
volatile float lastTemp2 = 0.0;
volatile int lastPhoto = 0;
volatile int count = 0;
boolean lowBattery = false;
const unsigned long TIME = 512;
const unsigned long TWOTIME = TIME*2;

#define SENDHIGH() digitalWrite(TX_PIN, HIGH)
#define SENDLOW() digitalWrite(TX_PIN, LOW)
 
// Buffer for Oregon message

  byte OregonMessageBuffer[8];

  byte OregonMessageBuffer2[9]; 
/**
 * \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) 
{
  SENDHIGH();
  delayMicroseconds(TIME);
  SENDLOW();
  delayMicroseconds(TWOTIME);
  SENDHIGH();
  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) 
{
   SENDLOW();
   delayMicroseconds(TIME);
   SENDHIGH();
   delayMicroseconds(TWOTIME);
   SENDLOW();
   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 an Oregon message
 * \param    data   The Oregon message
 */
void sendOregon2(byte *data, byte size)
{
    sendPreamble();
    //sendSync();
    sendData(data, size);
    sendPostamble2();
}
 
/**
 * \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)
{

  sendQuarterLSB(0x00);

}

/**
 * \brief    Send postamble
 * \details  The postamble consists of 8 "0" bits
 */
inline void sendPostamble2(void)
{

  byte POSTAMBLE[]={0x00};
  sendData(POSTAMBLE, 1);  
}
 
/**
 * \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)
{
    int s = ((Sum(6, data) + (data[6]&0xF) - 0xa) & 0xff);
 
    data[6] |=  (s&0x0F) << 4;     data[7] =  (s&0xF0) >> 4;

}
/**
 * \brief    Calculate checksum
 * \param    data       Oregon message
 */
void calculateAndSetChecksum2(byte* data)
{

    data[8] = ((Sum(8, data) - 0xa) & 0xFF);
}
 
/******************************************************************/
/******************************************************************/


// Fonction récupérant la température
// Retourne true si tout va bien, ou false en cas d'erreur
boolean getTemperature(float *temp,int sonde){
if (sonde<2){
  #ifdef DS18B20  
    byte present = 0;
    byte data[9];
    byte addr[8];
    // data : Données lues depuis le scratchpad
    // addr : adresse du module 1-Wire détecté

    if (!ds.search(addr)) { // Recherche un module 1-Wire
      ds.reset_search();    // Réinitialise la recherche de module
      delay(250);
      //return false;         // Retourne une erreur
    }

    if (OneWire::crc8(addr, 7) != addr[7]) // Vérifie que l'adresse a été correctement reçue
    return false;                        // Si le message est corrompu on retourne une erreur

    if (addr[0] != DS18B20) // Vérifie qu'il s'agit bien d'un DS18B20
    return false;         // Si ce n'est pas le cas on retourne une erreur
  
    ds.reset();             // On reset le bus 1-Wire
    ds.select(addr);        // On sélectionne le DS18B20

    ds.write(0x44, 1);      // On lance une prise de mesure de température
    delay(1000);             // Et on attend la fin de la mesure

    present = ds.reset();             // On reset le bus 1-Wire
    ds.select(addr);        // On sélectionne le DS18B20
    ds.write(0xBE);         // On envoie une demande de lecture du scratchpad

    for (byte i = 0; i < 9; i++) // On lit le scratchpad
    data[i] = ds.read();       // Et on stock les octets reçus

    // Calcul de la température en degré Celsius
    *temp = ((data[1] << 8) | data[0]) * 0.0625; 
  
    // Pas d'erreur
    return true;  
  #endif  
 }
 else
 {
  #ifdef DHT11

    //delay(2000);
    
    int chk = DHT.read11(DATA_PIN);
    
    if (chk == DHTLIB_OK) { // Ok
      // Pas d'erreur
      *temp = DHT.temperature;
      return true;
    }
    else
    {
      return false;
    }
  #else 
    #ifdef DHT22
      //delay(2000);
      
      int chk = DHT.read22(DATA_PIN);
      
      if (chk == DHTLIB_OK) { // Ok
        // Pas d'erreur
        *temp = DHT.temperature;
        return true;
      
      }
      else
      {
        return false;
      }  
    #endif
  #endif
 }
}

 
/******************************************************************/
 
void setup()
{

 CLKPR = (1<<CLKPCE);  
 CLKPR = B00000000;  // set the fuses to 8mhz clock-speed.
 
#ifdef SWITCH_A
   pinMode(SWITCH_A_PIN, INPUT);
   PCMSK |= bit (PCINT0);
#endif   
#ifdef SWITCH_B
   pinMode(SWITCH_B_PIN, INPUT);
   PCMSK |= bit (PCINT1);
#endif 
#if defined(SWITCH_A) || defined(SWITCH_B)   
   GIFR |= bit (PCIF);  // clear any outstanding interrupts
   GIMSK |= bit (PCIE); // enable pin change interrupts 
   sei();               // enable interrupts   
#endif
 
 #if defined(DS18B20) || defined(DHT11) || defined(DHT22) || defined(PHOTORES)
    // initialisation des cycles de reveil
    setup_watchdog(9);
 #endif
 
 pinMode(TX_PIN, OUTPUT); // sortie transmetteur
  SENDLOW();  
 
  // Create the Oregon message for a temperature only sensor (TNHN132N)
  byte ID[] = {0xEA,0x4C};

  // Create the Oregon message for a temperature/humidity sensor (THGR2228N)
  byte ID2[] = {0x1A,0x2D};
 
  setType(OregonMessageBuffer, ID);
  setChannel(OregonMessageBuffer, 0x20);
  setId(OregonMessageBuffer, NODE_ID);
  setType(OregonMessageBuffer2, ID2);
  setChannel(OregonMessageBuffer2, 0x20);
  setId(OregonMessageBuffer2, NODE_ID2);

  delay(2000);

}


// set system into the sleep state 
// system wakes up when wtchdog is timed out
void system_sleep() {
  cbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter OFF
  set_sleep_mode(SLEEP_MODE_PWR_DOWN); // sleep mode is set here
  sleep_mode();                        // Go to sleep
  sbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter ON
}

// 0=16ms, 1=32ms,2=64ms,3=128ms,4=250ms,5=500ms
// 6=1 sec,7=2 sec, 8=4 sec, 9= 8sec
void setup_watchdog(int ii) {
  byte bb;
  int ww;
  if (ii > 9 ) ii=9;
  bb=ii & 7;
  if (ii > 7) bb|= (1<<5);
  bb|= (1<<WDCE);
  ww=bb;

  MCUSR &= ~(1<<WDRF);
  // start timed sequence
  WDTCR |= (1<<WDCE) | (1<<WDE);
  // set new watchdog timeout value
  WDTCR = bb;
  WDTCR |= _BV(WDIE);
}
  
// Watchdog Interrupt Service / is executed when watchdog timed out 
ISR(WDT_vect) {   
  //wake up
  count--;
} 

#if defined(SWITCH_A) || defined(SWITCH_B)
  // PIN Interrupt Service
  ISR(PCINT0_vect) 
  {
      //wake up
      delay(10); // debounce
  }
#endif


//reads internal 1V1 reference against VCC
//return number 0 .. 1023 
int analogReadInternal() {
  ADMUX = _BV(MUX3) | _BV(MUX2); // For ATtiny85
  delay(5); // Wait for Vref to settle
  ADCSRA |= _BV(ADSC); // Convert
  while (bit_is_set(ADCSRA,ADSC));
  uint8_t low = ADCL;
  return (ADCH << 8) | low; 
}

//calculate VCC based on internal referrence
//return voltage in mV
int readVCC() {
  return ((uint32_t)1024 * (uint32_t)1100) / analogReadInternal();
}

int readPhotoResistance() {
  int ldr = analogRead(PHOTORES_PIN)+1;
  return ldr;
}

void loop()
{
#if defined(DS18B20) || defined(DHT11) || defined(DHT22) || defined(PHOTORES)
  if (count <= 0) { // on attend que le nombre de cycle soit atteint
      
      count=WDT_COUNT;  // reset counter
     
      // Get Temperature, humidity and battery level from sensors
      float temp; 
      if (getTemperature(&temp,1)) {


          // we need round temp to one decimal...
          int a = round(temp * 10);
          temp = a / 10.0;
  
          // if temp has changed
          if (temp != lastTemp) {
          
              #ifndef ALWAYS_SEND
                // save temp
                lastTemp = temp;
              #endif  
              
              // Get the battery state
              int vcc = readVCC();
              lowBattery = vcc < LOW_BATTERY_LEVEL;
              
              // Set Battery Level
              setBatteryLevel(OregonMessageBuffer, !lowBattery);  // 0=low, 1=high
              
              // Set Temperature
              setTemperature(OregonMessageBuffer, temp);
              //setTemperature(OregonMessageBuffer,  round((photo/1024)*100));
                
              // Calculate the checksum
              calculateAndSetChecksum(OregonMessageBuffer);
               
              // Send the Message over RF
              sendOregon(OregonMessageBuffer, sizeof(OregonMessageBuffer));
              // Send a "pause"
              SENDLOW();
              delayMicroseconds(TWOTIME*8);
              // Send a copie of the first message. The v2.1 protocol send the message two time 
              sendOregon(OregonMessageBuffer, sizeof(OregonMessageBuffer));
              SENDLOW();
             }   
      }
      // Get Temperature, humidity and battery level from sensors
      delay(5000);
      float temp2; 
      if (getTemperature(&temp2,2)) {


          // we need round temp to one decimal...
          int a = round(temp2 * 10);
          temp2 = a / 10.0;
  
          // if temp has changed
          if (temp2 != lastTemp2) {
          
              #ifndef ALWAYS_SEND
                // save temp
                lastTemp2 = temp2;
              #endif  
              
              // Get the battery state
              int vcc = readVCC();
              lowBattery = vcc < LOW_BATTERY_LEVEL;
              
              // Set Battery Level
              setBatteryLevel(OregonMessageBuffer2, !lowBattery);  // 0=low, 1=high
              
              // Set Temperature
              setTemperature(OregonMessageBuffer2, temp2);
              //setTemperature(OregonMessageBuffer,  round((photo/1024)*100));
              // Set Humidity
              setHumidity(OregonMessageBuffer2, DHT.humidity);
              //setHumidity(OregonMessageBuffer, round((photo/1024)*100));
                
              // Calculate the checksum
              calculateAndSetChecksum2(OregonMessageBuffer2);
              SENDLOW();
              delayMicroseconds(TWOTIME*32);
              
              // Send the Message over RF
              sendOregon2(OregonMessageBuffer2, sizeof(OregonMessageBuffer2));
              // Send a "pause"
              SENDLOW();
              delayMicroseconds(TWOTIME*8);
              // Send a copie of the first message. The v2.1 protocol send the message two time 
              sendOregon2(OregonMessageBuffer2, sizeof(OregonMessageBuffer2));
              SENDLOW();
             }   
      }
      #if  defined(PHOTORES)
             int photo;              
             photo = readPhotoResistance();
             if (photo != lastPhoto) {
             // save temp
                 #ifndef ALWAYS_SEND
                     lastPhoto = photo;
                 #endif
                 delayMicroseconds(TWOTIME*32);
                 myx10.RFXmeter(PHOTORES_UNIT_CODE,0,photo);
                 SENDLOW();
                 delayMicroseconds(TWOTIME*32);
                 myx10.RFXmeter(PHOTORES_UNIT_CODE,0,photo);
                 SENDLOW();
             }
        #endif
  }
#endif

  #ifdef SWITCH_A
    // Get the update value
    uint8_t valueA = (digitalRead(SWITCH_A_PIN)==HIGH ? ON : OFF);
     
    if (valueA != oldValueA) {
       // Send in the new value
       myx10.x10Switch(SWITCH_A_HOUSE_CODE,SWITCH_A_UNIT_CODE,valueA);
       oldValueA = valueA;
    }
  #endif
  #ifdef SWITCH_B
    // Get the update value
    uint8_t valueB = (digitalRead(SWITCH_B_PIN)==HIGH ? OFF : ON);
     
    if (valueB != oldValueB) {
       // Send in the new value
       myx10.x10Switch(SWITCH_B_HOUSE_CODE,SWITCH_B_UNIT_CODE,valueB);
       oldValueB = valueB;
    }
  #endif
    
  system_sleep();
}
Ma maison à plein d'IP ! :mrgreen:
SAV Bonjour. Vous avez vidé le cache ?

mattx38
Messages : 24
Enregistré le : 27 janv. 2020, 22:55

Re: [Tuto diy] Fabriquer sonde radio Oregon a 5€ pour les nuls V2

Message par mattx38 »

Excellent merci.
Dis-moi si j'ai bon :

1 seul #define DS18B20 suffit ?

2 adresses onwire nécessaires ?
#define DS18B20 0x28 // Adresse 1-Wire du DS18B20
OneWire ds(DATA_PIN2); // Création de l'objet OneWire ds

Quelle adresse pour la 2ème sonde DS18B20 du coup ?

Comme j'ai enlevé le #define DHT22 du début, ligne 703, il me dit que "DHT" n'a pas été défini : setHumidity(OregonMessageBuffer2, DHT.humidity);

mattx38
Messages : 24
Enregistré le : 27 janv. 2020, 22:55

Re: [Tuto diy] Fabriquer sonde radio Oregon a 5€ pour les nuls V2

Message par mattx38 »

J'ai aussi pas mal de soucis de réception avec les sondes en RF433.
Je les alimente en 3V avec une pile bouton CR2032 et le module TX est un FS1000a, auquel j'ai rajouté une antenne en cuivre.
A priori, quand j'envoie plus de volts (4,5V) la réception est bien meilleure.

CQFD vous me direz, mais cela m'amène deux questions :
-Comment alimentez vous vos sondes ?
-Comment vais-je pouvoir alimenter correctement la BME280 ?

La sonde BME280 n'acceptant pas plus de 3V, est-ce qu'il faut l'alimenter avec un régulateur de tension en amont et laisser toute la puissance arriver sur le module de transmission en RF433 ?

Merci pour vos conseils et désolé si mes questions sont naïves, mais je suis vraiment débutant en électronique.

vil1driver
Messages : 5303
Enregistré le : 30 janv. 2015, 11:07
Localisation : Rennes (35)

Re: [Tuto diy] Fabriquer sonde radio Oregon a 5€ pour les nuls V2

Message par vil1driver »

Oublie les antennes torsadées.
Les meilleurs résultats sont avec un simple fil de 17 cm
MAJ = VIDER LE CACHE(<-Clicable)
/!\Les mises à jour de Domoticz sont souvent sources de difficultés, ne sautez pas dessus
modules.lua

Un ex domoticzien

mattx38
Messages : 24
Enregistré le : 27 janv. 2020, 22:55

Re: [Tuto diy] Fabriquer sonde radio Oregon a 5€ pour les nuls V2

Message par mattx38 »

Fil de cuivre ?
Multi-brins ou mono-brin ?
Faut-il dénuder le bout du fil ?
:oops:

Neutrino
Messages : 1385
Enregistré le : 10 juil. 2015, 15:42
Localisation : Challans (85)
Contact :

Re: [Tuto diy] Fabriquer sonde radio Oregon a 5€ pour les nuls V2

Message par Neutrino »

Toujours mono-brin.
Tu peux juste dénudé au niveau de la soudure. Le reste peux rester isolé.
Ma maison à plein d'IP ! :mrgreen:
SAV Bonjour. Vous avez vidé le cache ?

vil1driver
Messages : 5303
Enregistré le : 30 janv. 2015, 11:07
Localisation : Rennes (35)

Re: [Tuto diy] Fabriquer sonde radio Oregon a 5€ pour les nuls V2

Message par vil1driver »

ça n'intéressera probablement personne. :D car non communicant
j'ai mis à jour ce message
https://easydomoticz.com/forum/viewtopi ... 504#p66504
avec le sketch utilisé.
MAJ = VIDER LE CACHE(<-Clicable)
/!\Les mises à jour de Domoticz sont souvent sources de difficultés, ne sautez pas dessus
modules.lua

Un ex domoticzien

ogulf
Messages : 252
Enregistré le : 15 juin 2017, 14:41

Re: [Tuto diy] Fabriquer sonde radio Oregon a 5€ pour les nuls V2

Message par ogulf »

Sisi, ça 'intéresse, car pour t'avoir suivi sur la gestion PID via Domoticz (qui marche encore et toujours à l'heure actuelle !), je trouve ta solution autonome très intéressante ;)
Reste peut-être le problème de l'administration à distance, je ne sais pas si c'est possible... Ni si la notion de planning est prévue/possible avec ton tasmota modifié... Mais ça mériterait un autre post... Et que tu restes encore un peu sur le forum... :oops:
Domoticz Stable sur RPi3 + RFPlayer + ZWave+ + RFLink R48 :
- 11 x RF660P (gestion chauffage)
- 1 x FGSD-002 (détecteur fumée)
- 10 x F007TH (sonde Temp/Hygro)
- 5 x Emcoluxr EV1527 (contacteur ouverture porte)
- 4 x NeoCoolCam NAS-PD02Z (PIR + Temp)

vil1driver
Messages : 5303
Enregistré le : 30 janv. 2015, 11:07
Localisation : Rennes (35)

Re: [Tuto diy] Fabriquer sonde radio Oregon a 5€ pour les nuls V2

Message par vil1driver »

;)
non aucune interaction possible avec l'attiny, (un avantage à mon sens)
Il s'oublie totalement du coup
on pourrait ajouter écran et boutons.. (i2c ?)
Pour revoir la conf à l'occasion
Mais rien à distance.

pour tasmota j'ai passé assez de temps dessus et perdu en partie mes cheveux.
je ne ferai rien de plus mais c'est certainement possible
MAJ = VIDER LE CACHE(<-Clicable)
/!\Les mises à jour de Domoticz sont souvent sources de difficultés, ne sautez pas dessus
modules.lua

Un ex domoticzien

Répondre