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

[ganq]

oui, cela est ok. Tu peux aussi tester la décharge dans une diode et une résistance de 100 ohm et cela te donnera une idée de la capacité réelle de la batterie. De plus si tu mets 2 batteries en parallèle, seule la plus petite capacité est utilisée. mais bon, rien ne vaut les tests au multimètre

[oefut]

...
Ton arduino est reconnu ?
Tu as réussi à y charger le sketch isp ?
Si non pas la peine de câbler l'attiny..

C'est quoi ceci ? Pas dans le tuto..

Using Programmer : stk500v1

Réponses à Vildriver:
Merci de toute ton aide.
L'arduino "Chinois" est reconnu
Je peux charger le Sketch , le modifier pour donner les codes et enregistrer
L'adruino a cramé (défetueux), j'en ai commandé un "VRAI" et je testerai avec des nouveaux Attiny's.
Merci
---------------
Bonjour à tous,

alors un petit point qq jours plus tard.
Je me suis rendu chez une personne qui a répondu à ma demande de programmation de mes Attiny's.
Les deux attiny sont programmés et fonctionnent:
- L'un sur un PCB qu'il m'a gentiment donné
- L'autre sur ma Breadboard (avec Condo et Résistance)

Je suis quand même content après toutes ces batailles d'arriver à faire qq chose!

Evidemment cela ne pouvait pas être sans encore quelques "résistances"!
Depuis hier soir mon alimentation s'est vidée en à peine 3 heures (3 accus de type AA de 1.2v 2900mA)
Je les ai remplacés ce matin (je suis la décharge)
Sur la Breadboard, j'ai mis un LiPo de 3.7v - 800mA, c'est pas lourd mais je vais suivre.

Est ce que la décharge est due à la résistance qui ne correspond pas à ce qui est demandé dans le Tuto?
26/11 MAJ: Pour l'instant pas de décharge rapide (100%)

Merci d'avance, et surtout un grand merci à mon nouvel Ami Toulousain qui se reconnaîtra!





L'Oefut

[victor81]

bonjour
j'ai deja une sonde v1, nommé 2DDC,en fonctionnement avec dht22+detecteur de luminosité...elle fonctionne tres tres bien .
aujourd'hui, jour de pluie, je me decide a realiser d'autres sondes...

je precise tout d'abord que n'ayant pas encore recu mes boitier a pile, je fait avec un chargeur de portable nokia 5.3v, 500 mA
peut etre que le probleme vient de la, je n'ai pas la possiblité de verifier autrement...

donc mes autres sondes, je veut les faire..complete, pour en disposer une par piece kifétout.
je decommente donc dht22, ldr, et switch A, je change aussi le nom 00xAB
le sketch est ok, l'attiny a televerser completement.
je met attiny sur plaque d'essai; fait les branchement adequat, branche au secteur et...

la dht est reconnu, pas la luminosité ni le pir
je debranche rebranche cette fois le pir est reconnu, pas la luminosité et la valeur dht n'a pas bougé
je debranche rebranche ...et ainsi de suite, a chaque fois un des capteur n'est pas reconnu et la luminosité...nada.
du coté de la luminosité, j'ai remarque que depuis que je fais les tests ( ce matin 10 heure), la valeur luminosité de mon capteur V1deja installé est perturbé, elle passe a 1 lux, puis 700, puis 800 puis retombe a 1 800 400 700 1 ....enfin vous avez compris le truc.

d'ou mes questions du jour....
-mon chargeur est il assez puissant?
-peut mettre dht+lrd+pir ensemble?
-et est on limité a un seul capteur avec module luminosité?

j'ai remarque que mon device luminosité "0008" deja installé n'a pas le meme nom que ma sonde dht "2DAA" ( qui elle comporte les deux lettres AA que j'ai entrée)
aije oublié de changer un truc dans le sketch?

du coup, j'ai debranche sur la plaque d'essai le compteur lrd, le pir depuis une petite heure et mon capteur V1 en place a retrouvé sa ligne d'origine...
le capteur dht22 meme si j'ai decommenté l'envoi de toutes les valeurs, n'envoie que aleatoirement une valeur ( exemple, la, cela fait presque une demi heure que je n'ai rien recu...)
help...:/

[Neutrino]

Bonjour
A mon humble avis, ta nouvelle sonde doit émettre avec les mêmes codes que ton ancienne.
Voici les lignes à modifier : (les valeurs sont données à titre d'exemple, elles ont juste besoin d'être différentes entre chaque sonde)

Code : Tout sélectionner

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

#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          // code unite du capteur analogique

[victor81]

merci d'avoir repondu si vite
donc si je te suis bien:
il me faut modifier
l'identifiant unique de la sonde, ca c'est deja fait en 0xAA
et les identifiant maison et unit
je vais mettre J pour la maison et garder les meme unit
je vais en profiter pour rajouter un code maison pour le capteur analogique:
#define PHOTORES_HOUSE_CODE 8
je fais ca et vous tiens au courant

[victor81]

bon, ca ne fonctionne pas...je met le code que j'ai, j'ai changé le code maison originel par J, je n'ai pas touché au code unité, et j'ai rajouté un codemaison pour le detecteur de luminosité
dans les dispositifs, toujours une perturbation du detectecteur de lux deja en place et le code est toujours en 0008, une remontée de temperature au branchement, pas de detection de presence

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   2|       |7   LDR (optionel)
      TX 433   3|       |6   Switch B (optionel)
         (-)   4|       |5   Switch A (optionel)
                +-------+ 

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


#define NODE_ID 0xAA              // 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 DHT11
#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 'J'        // code maison du capteur A
#define SWITCH_A_UNIT_CODE 6           // code unite du capteur A
#define SWITCH_B_HOUSE_CODE 'J'        // code maison du capteur B
#define SWITCH_B_UNIT_CODE 7           // code unite du capteur B
#define PHOTORES_UNIT_HOUSE_CODE 'J'
#define PHOTORES_UNIT_CODE 8

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


#define DATA_PIN 3                // pin 2 // 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_PIN); // Création de l'objet OneWire ds
#else
  #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 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
#ifdef DS18B20
  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) 
{
  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 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 DS18B20
  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 DS18B20
    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
}
 
/******************************************************************/
/******************************************************************/


// Fonction récupérant la température
// Retourne true si tout va bien, ou false en cas d'erreur
boolean getTemperature(float *temp){

#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;
#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
#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();  
 
#ifdef DS18B20  
  // 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, NODE_ID);

  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)) {


          // 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));
              
              #ifndef DS18B20
                // Set Humidity
                setHumidity(OregonMessageBuffer, DHT.humidity);
                //setHumidity(OregonMessageBuffer, round((photo/1024)*100));

              #endif
                
              // 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();
             }   
      }
      #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();
}

je ferai un circuit soudé demain, j'ai peut etre de faux contacts

[Neutrino]

Je ne sais pas où tu as été pêcher cette ligne :

Code : Tout sélectionner

#define PHOTORES_UNIT_HOUSE_CODE 'J'

Change plutot le #define PHOTORES_UNIT_CODE 8
en #define PHOTORES_UNIT_CODE 9
Et je ne sais pas si J fonctionne vraiment, je me serais plutot cantonner à l'hexa décimal ( de 0 à F).

[victor81]

olalala le boulet.....
oki je choisi des valeur de 0 a F..je regarde ca

[victor81]

bizarre...non, ca ne fonctionne pas, je verrai demain a tete reposé, merci de m'avoir donné des pistes

[victor81]

nouveaux essais ce soir: j'avais un doute sur mon attiny, du coup j'ai recommebté le swtch a et refais un sketch juste avec dht22 et lrd...cette configuration fonctionne... j'ai ensuite ressayé pir+ lrd, cela fonctionne aussi, et pir+dht, ca ne fonctionne plus (juste les valeurs pir, la dht envoie une info au demarrage puis devient muette...)
je precise que j'ai verifié et changé la resistance 4.7kohm et changé la dht22..meme resultat
du coup, le probleme viendrai du pir si je le met en meme temps que les 2 autres
j'ai un modele comme cela:
https://www.banggood.com/Wholesale-Mini ... rehouse=CN
doije mettre une resistance quelconque avant branchement? et si oui, de quelle valeurs?
dans tous les cas, j'ai un serieux doute sur mon chargeur, on dirai qu'il n'a pas suffisament d'energie pour alimenter les 3 sondes en meme temps,..