Comment remplacer un DS2423 par un ATtiny

Parlez nous de vos projets et de vos idées, imaginez des applications

Comment remplacer un DS2423 par un ATtiny

Message non lude Illico » Dim 23 Fév 2014 21:10

Bonjour à tous,

Afin de réaliser des compteurs d'impulsions pour mesurer ma consommation en eau et en gaz, je souhaite réaliser un montage et récupérer la valeur des compteurs par un bus 1-wire dallas par le GPIO 4 de mon Raspberry.
Ce bus 1-wire est partagé en plus par deux sondes de températures DS18B20.

Le composant idéal pour réaliser cette fonction est un DS2423. Hors celui-ci n'est plus vendu.
Mais en cherchant sur la toile, il est possible de remplacer ce composant par des microcontrôleurs Atmel de type ATtiny (Disponible chez Snootlab ICI)

J'ai donc récupéré un code réalisé par Tobias Müller http://www.tm3d.de/index.php/1-wire-device-mit-avr, qui utilise un ATtiny25 comme cible, mais on peut aussi adapter le code pour un ATtiny85 (Seuls les deux premiers compteurs sont implémentés, la mémoire et les deux autre compteurs ne le sont pas).
Je l'ai compilé et "claqué" avec avrdude sous Raspbian en utilisant le tutorial suivant : http://www.instructables.com/id/Program ... pberry-Pi/

Ensuite sur la console SSH j'ai lancé les commandes suivantes:
Code: Tout sélectionner
sudo modprobe w1-gpio
sudo modprobe w1-therm
sudo modprobe w1-ds2423


sous /sys/devices/w1_bus_master1/
je vois bien les 3 devices:
1d-01000084d9a2 --> DS2423
28-0000055713ff --> DS18B20 N°1
28-000005743b58 --> DS18B20 N°2
Code: Tout sélectionner
pi@illicorasp /sys/devices/w1_bus_master1 $ ls
1d-01000084d9a2  driver     uevent              w1_master_max_slave_count  w1_master_pullup  w1_master_slave_count
28-0000055713ff  power      w1_master_add       w1_master_name             w1_master_remove  w1_master_slaves
28-000005743b58  subsystem  w1_master_attempts  w1_master_pointer          w1_master_search  w1_master_timeout


Les sondes de température fonctionnent bien, mais le ds2423 me renvoie qu'un seul compteur, et celui-ci reste toujours à zéro:

Code: Tout sélectionner
pi@illicorasp /sys/devices/w1_bus_master1/1d-01000084d9a2 $ cat w1_slave
00 00 00 00 00 00 00 00 00 ec e1 ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff crc=YES c=0
ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff crc=NO
ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff crc=NO
ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff crc=NO


Si vous avez des idées je suis preneur biensur.



Le code utilisé est ds2423.c:
Code: Tout sélectionner
//owdevice - A small 1-Wire emulator for AVR Microcontroller
//
//Copyright (C) 2012  Tobias Mueller mail (at) tobynet.de
//
//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 3 of the License, or
// 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, see <http://www.gnu.org/licenses/>.
//
//
//VERSION 1.2 DS2423  for ATTINY2313 and ATTINY25

//FOR MAKE by hand
/*
avr-gcc -mmcu=[attiny25|attiny2313] -O2 -c ow_slave_DS2423.c
avr-gcc.exe -mmcu=[attiny25|attiny2313]  ow_slave_DS2423.o -o ow_slave_DS2423.elf
avr-objcopy -O ihex  ow_slave_DS2423.elf ow_slave_DS2423.hex
*/

/* Datasheet
   http://www.atmel.com/Images/Atmel-2586-AVR-8-bit-Microcontroller-ATtiny25-ATtiny45-ATtiny85_Datasheet.pdf
*/

#include <avr/io.h>
#include <avr/interrupt.h>

// OW_PORT Pin 7  - PB2

//OW Pin
#define OW_PORT PORTB //1 Wire Port
#define OW_PIN PINB //1 Wire Pin as number
#define OW_PORTN (1<<PINB2)  //Pin as bit in registers
#define OW_PINN (1<<PINB2)
#define OW_DDR DDRB  //Pin direction register
#define SET_LOW OW_DDR|=OW_PINN;OW_PORT&=~OW_PORTN;  //set 1-Wire line to low
#define RESET_LOW {OW_DDR&=~OW_PINN;}  //set 1-Wire pin as input
//Pin interrupt   
#define EN_OWINT {GIMSK|=(1<<INT0);GIFR|=(1<<INTF0);}  //enable interrupt
#define DIS_OWINT  GIMSK&=~(1<<INT0);  //disable interrupt
#define SET_RISING MCUCR=(1<<ISC01)|(1<<ISC00);  //set interrupt at rising edge
#define SET_FALLING MCUCR=(1<<ISC01); //set interrupt at falling edge
#define CHK_INT_EN (GIMSK&(1<<INT0))==(1<<INT0) //test if interrupt enabled
#define PIN_INT ISR(INT0_vect)  // the interrupt service routine
//Timer Interrupt
#define EN_TIMER {TIMSK |= (1<<TOIE0); TIFR|=(1<<TOV0);} //enable timer interrupt
#define DIS_TIMER TIMSK  &= ~(1<<TOIE0); // disable timer interrupt
#define TCNT_REG TCNT0  //register of timer-counter
#define TIMER_INT ISR(TIM0_OVF_vect) //the timer interrupt service routine


#define OWT_MIN_RESET 51
#define OWT_RESET_PRESENCE 4
#define OWT_PRESENCE 20
#define OWT_READLINE 3 // 3 for fast master, 4 for slow master and long lines
#define OWT_LOWTIME 3 // 3 for fast master, 4 for slow master and long lines

//Initializations of AVR
#define INIT_AVR CLKPR=(1<<CLKPCE); \
               CLKPR=0; /*8Mhz*/  \
               TIMSK=0; \
               GIMSK=(1<<INT0);  /*set direct GIMSK register*/ \
               TCCR0B=(1<<CS00)|(1<<CS01); /*8mhz /64 couse 8 bit Timer interrupt every 8us*/
               
#define PC_INT_ISR ISR(PCINT0_vect) { /*ATT25 with 0 by PCINT*/ \
               if (((PINB&(1<<PINB3))==0)&&((istat&(1<<PINB3))==(1<<PINB3))) {   Counter0++;   }      \
               if (((PINB&(1<<PINB4))==0)&&((istat&(1<<PINB4))==(1<<PINB4))) {   Counter1++;   }      \
               istat=PINB;}   \
               
#define INIT_COUNTER_PINS /* Counter Interrupt */\
                  GIMSK|=(1<<PCIE);\
                  PCMSK=(1<<PCINT3)|(1<<PCINT4);   \
                  DDRB &=~((1<<PINB3)|(1<<PINB4)); \
                  istat=PINB;\




//#define _ONE_DEVICE_CMDS_  //Commands for only one device on bus (Not tested)

typedef union {
   volatile uint8_t bytes[13];//={1,1,2,0,0,0,0,0,0,0,0,5,5};
   struct {
      uint16_t addr;
      uint8_t read;
      uint32_t counter;
      uint32_t zero;
      uint16_t crc;
   };
} counterpack_t;
counterpack_t counterpack;
volatile uint16_t scrc; //CRC calculation

volatile uint8_t lastcps;
volatile uint32_t Counter0;
volatile uint32_t Counter1;
volatile uint8_t istat;


volatile uint8_t cbuf; //Input buffer for a command
//const uint8_t owid[8]={0x1D, 0xA2, 0xD9, 0x84, 0x00, 0x00, 0x02, 0x37};   
//set your own ID http://www.tm3d.de/index.php/tools/14-crc8-berechnung
const uint8_t owid[8]={0x1D, 0xA2, 0xD9, 0x84, 0x00, 0x00, 0x01, 0xD5};
volatile uint8_t bitp;  //pointer to current Byte
volatile uint8_t bytep; //pointer to current Bit

volatile uint8_t mode; //state
volatile uint8_t wmode; //if 0 next bit that send the device is  0
volatile uint8_t actbit; //current
volatile uint8_t srcount; //counter for search rom

//States / Modes
#define OWM_SLEEP 0  //Waiting for next reset pulse
#define OWM_RESET 1  //Reset pulse received
#define OWM_PRESENCE 2  //sending presence pulse
#define OWM_READ_COMMAND 3 //read 8 bit of command
#define OWM_SEARCH_ROM 4  //SEARCH_ROM algorithms
#define OWM_MATCH_ROM 5  //test number
#define OWM_CHK_RESET 8  //waiting of rising edge from reset pulse
#define OWM_GET_ADRESS 6
#define OWM_READ_MEMORY_COUNTER 7
#define OWM_WRITE_SCRATCHPAD 9
#define OWM_READ_SCRATCHPAD 10

#ifdef _ONE_DEVICE_CMDS_
#define OWM_READ_ROM 50
#endif

//Write a bit after next falling edge from master
//its for sending a zero as soon as possible
#define OWW_NO_WRITE 2
#define OWW_WRITE_1 1
#define OWW_WRITE_0 0



PIN_INT {
   uint8_t lwmode=wmode;  //let this variables in registers
   uint8_t lmode=mode;
   if ((lwmode==OWW_WRITE_0)) {SET_LOW;lwmode=OWW_NO_WRITE;}    //if necessary set 0-Bit
   DIS_OWINT; //disable interrupt, only in OWM_SLEEP mode it is active
   switch (lmode) {
      case OWM_SLEEP: 
         TCNT_REG=~(OWT_MIN_RESET);
         EN_OWINT; //other edges ?
         break;
      //start of reading with falling edge from master, reading closed in timer isr
      case OWM_MATCH_ROM:  //falling edge wait for receive
      case OWM_GET_ADRESS:
      case OWM_READ_COMMAND:
         TCNT_REG=~(OWT_READLINE); //wait a time for reading
         break;
      case OWM_SEARCH_ROM:   //Search algorithm waiting for receive or send
         if (srcount<2) { //this means bit or complement is writing,
            TCNT_REG=~(OWT_LOWTIME);
         } else
            TCNT_REG=~(OWT_READLINE);  //init for read answer of master
         break;
#ifdef _ONE_DEVICE_CMDS_
      case OWM_READ_ROM:
#endif      
      case OWM_READ_MEMORY_COUNTER: //a bit is sending
         TCNT_REG=~(OWT_LOWTIME);
         break;
      case OWM_CHK_RESET:  //rising edge of reset pulse
         SET_FALLING;
         TCNT_REG=~(OWT_RESET_PRESENCE);  //waiting for sending presence pulse
         lmode=OWM_RESET;
         break;
   }
   EN_TIMER;
   mode=lmode;
   wmode=lwmode;
   
}         

   

TIMER_INT {
   uint8_t lwmode=wmode; //let this variables in registers
   uint8_t lmode=mode;
   uint8_t lbytep=bytep;
   uint8_t lbitp=bitp;
   uint8_t lsrcount=srcount;
   uint8_t lactbit=actbit;
   uint16_t lscrc=scrc;
   //Ask input line sate
   uint8_t p=((OW_PIN&OW_PINN)==OW_PINN); 
   //Interrupt still active ?
   if (CHK_INT_EN) {
      //maybe reset pulse
      if (p==0) {
         lmode=OWM_CHK_RESET;  //wait for rising edge
         SET_RISING;
      }
      DIS_TIMER;
   } else
   switch (lmode) {
      case OWM_RESET:  //Reset pulse and time after is finished, now go in presence state
         lmode=OWM_PRESENCE;
         SET_LOW;
         TCNT_REG=~(OWT_PRESENCE);
         DIS_OWINT;  //No Pin interrupt necessary only wait for presence is done
         break;
      case OWM_PRESENCE:
         RESET_LOW;  //Presence is done now wait for a command
         lmode=OWM_READ_COMMAND;
         cbuf=0;lbitp=1;  //Command buffer have to set zero, only set bits will write in
         break;
      case OWM_READ_COMMAND:
         if (p) {  //Set bit if line high
            cbuf|=lbitp;
         }
         lbitp=(lbitp<<1);
         if (!lbitp) { //8-Bits read
            lbitp=1;
            switch (cbuf) {
               case 0x55:lbytep=0;lmode=OWM_MATCH_ROM;break;
               case 0xF0:  //initialize search rom
                  lmode=OWM_SEARCH_ROM;
                  lsrcount=0;
                  lbytep=0;
                  lactbit=(owid[lbytep]&lbitp)==lbitp; //set actual bit
                  lwmode=lactbit;  //prepare for writing when next falling edge
                  break;
               case 0xA5:
                  lmode=OWM_GET_ADRESS; //first the master send an address
                  lbytep=0;lscrc=0x7bc0; //CRC16 of 0xA5
                  counterpack.bytes[0]=0;
                  break;
#ifdef _ONE_DEVICE_CMDS_
               case 0xCC:
                  lbytep=0;cbuf=0;lmode=OWM_READ_COMMAND;break;
               case 0x33:
                  lmode=OWM_READ_ROM;
                  lbytep=0;   
                  break;
#endif                                 
               default: lmode=OWM_SLEEP;  //all other commands do nothing
            }      
         }         
         break;
      case OWM_SEARCH_ROM:
         RESET_LOW;  //Set low also if nothing send (branch takes time and memory)
         lsrcount++;  //next search rom mode
         switch (lsrcount) {
            case 1:lwmode=!lactbit;  //preparation sending complement
               break;
            case 3:
               if (p!=(lactbit==1)) {  //check master bit
                  lmode=OWM_SLEEP;  //not the same go sleep
               } else {
                  lbitp=(lbitp<<1);  //prepare next bit
                  if (lbitp==0) {
                     lbitp=1;
                     lbytep++;
                     if (lbytep>=8) {
                        lmode=OWM_SLEEP;  //all bits processed
                        break;
                     }
                  }            
                  lsrcount=0;
                  lactbit=(owid[lbytep]&lbitp)==lbitp;
                  lwmode=lactbit;
               }      
               break;         
         }
         break;
      case OWM_MATCH_ROM:
         if (p==((owid[lbytep]&lbitp)==lbitp)) {  //Compare with ID Buffer
            lbitp=(lbitp<<1);
            if (!lbitp) {
               lbytep++;
               lbitp=1;
               if (lbytep>=8) {
                  lmode=OWM_READ_COMMAND;  //same? get next command
                  
                  cbuf=0;
                  break;         
               }
            }
         } else {
            lmode=OWM_SLEEP;
         }
         break;
      case OWM_GET_ADRESS: 
         if (p) { //Get the Address for reading
            counterpack.bytes[lbytep]|=lbitp;
         } 
         //address is part of crc
         if ((lscrc&1)!=p) lscrc=(lscrc>>1)^0xA001; else lscrc >>=1;
         lbitp=(lbitp<<1);
         if (!lbitp) {   
            lbytep++;
            lbitp=1;
            if (lbytep==2) {
               lmode=OWM_READ_MEMORY_COUNTER;
               lactbit=(lbitp&counterpack.bytes[lbytep])==lbitp;
               lwmode=lactbit;
               lsrcount=(counterpack.addr&0xfe0)+0x20-counterpack.addr;
               //bytes between start and Counter Values, Iam never understanding why so much???
               break;
            } else counterpack.bytes[lbytep]=0;
         }         
         break;   
      case OWM_READ_MEMORY_COUNTER:
         RESET_LOW;
         //CRC16 Calculation
         if ((lscrc&1)!=lactbit) lscrc=(lscrc>>1)^0xA001; else lscrc >>=1;
         p=lactbit;
         lbitp=(lbitp<<1);
         if (!lbitp) {      
            lbytep++;
            lbitp=1;
            if (lbytep==3) {
               lsrcount--;
               if (lsrcount) lbytep--;
               else  {//now copy counter in send buffer
                  switch (counterpack.addr&0xFe0) {
                  case 0x1E0:
                     counterpack.counter=Counter0;
                     break;
                  case 0x1C0:
                     counterpack.counter=Counter1;
                     break;
                  default: counterpack.counter=0;
                  }
               }
            }
            if (lbytep>=13) { //done sending
               lmode=OWM_SLEEP;
               break;         
            }        
            if ((lbytep==11)&&(lbitp==1)) { //Send CRC
               counterpack.crc=~lscrc;
            }         
               
         }               
         lactbit=(lbitp&counterpack.bytes[lbytep])==lbitp;
         lwmode=lactbit;
         
         break;
#ifdef _ONE_DEVICE_CMDS_   
      case OWM_READ_ROM:
         RESET_LOW;
         lbitp=(lbitp<<1);
         if (!lbitp) {      
            lbytep++;
            lbitp=1;
            if (lbytep>=8) {
               lmode=OWM_SLEEP;
               break;         
            }
         }               
         lactbit=(lbitp&owid[lbytep])==lbitp;
         lwmode=lactbit;
         break;
#endif      
      }
      if (lmode==OWM_SLEEP) {DIS_TIMER;}
      if (lmode!=OWM_PRESENCE)  {
         TCNT_REG=~(OWT_MIN_RESET-OWT_READLINE);  //OWT_READLINE around OWT_LOWTIME
         EN_OWINT;
      }
      mode=lmode;
      wmode=lwmode;
      bytep=lbytep;
      bitp=lbitp;
      srcount=lsrcount;
      actbit=lactbit;
      scrc=lscrc;
}



PC_INT_ISR  //for counting  defined for specific device



int main(void) {
   mode=OWM_SLEEP;
   wmode=OWW_NO_WRITE;
   OW_DDR&=~OW_PINN;
   
   uint8_t i;
   for(i=0;i<sizeof(counterpack);i++) counterpack.bytes[i]=0;
   Counter0=0;
   Counter1=0;

   
   SET_FALLING
   
   INIT_AVR
   DIS_TIMER
   
   INIT_COUNTER_PINS

   sei();
   
   while(1){
      
   }
}   


Le Makefile utilisé est celui-ci:
Code: Tout sélectionner
MCU=attiny85
AVRDUDEMCU=t85
CC=/usr/bin/avr-gcc
CFLAGS=-g -Os -Wall -mcall-prologues -mmcu=$(MCU)
OBJ2HEX=/usr/bin/avr-objcopy
AVRDUDE=/usr/local/bin/avrdude
TARGET=ds2423

all :
   $(CC) $(CFLAGS) $(TARGET).c -o $(TARGET)
   $(OBJ2HEX) -R .eeprom -O ihex $(TARGET) $(TARGET).hex
   rm -f $(TARGET)

install : all
   sudo gpio -g mode 22 out
   sudo gpio -g write 22 0
   sudo $(AVRDUDE) -p $(AVRDUDEMCU) -P /dev/spidev0.0 -c linuxspi -b 10000 -U flash:w:$(TARGET).hex
   sudo gpio -g write 22 1

noreset : all
   sudo $(AVRDUDE) -p $(AVRDUDEMCU) -P /dev/spidev0.0 -c linuxspi -b 10000 -U flash:w:$(TARGET).hex

fuse :
   sudo gpio -g mode 22 out
   sudo gpio -g write 22 0
   sudo $(AVRDUDE) -p $(AVRDUDEMCU) -P /dev/spidev0.0 -c linuxspi -b 10000 -U lfuse:w:0x62:m -U hfuse:w:0xdf:m -U efuse:w:0xff:m
   sudo gpio -g write 22 1

clean :
   rm -f *.hex *.obj *.o
Illico
 
Messages: 6
Inscription: Lun 27 Jan 2014 17:48

Re: Comment remplacer un DS2423 par un ATtiny

Message non lude jmatgou » Lun 24 Fév 2014 19:17

Bonjour Illico,

Je ne connais pas bien le ATtiny, je ne sais pas si on peut le substituer à un DS2423.
Toujours est-il que j'ai tester le DS2423 sur Arduino et sur Raspberry et je peux donc te faire part de mon expérience.

Sur Arduino : pas de problème, il suffi de suivre l'exemple d' HenriLeopold sur le sujet suivant. J'ai tester et ça fonctionne très bien. La seule chose qui n'est pas expliquée c'est comment récupérer l'adresse du composant. Je peux t'aider la dessus.

Sur Raspberry : Il y a des complications. Il n’existe pas de port 1-wire physique sur la RPi. Il faut donc l'émuler par le soft. J'ai moi aussi tester la méthode avec "modprobe w1-ds2423" mais impossible de lire la valeur des compteurs.
Je me suis ensuite tourné vers OWFS (One Wire File System) : http://owfs.org/.
Cela permet de créer un système de fichier s'appuyant sur les composant 1-wire brancher sur le bus.
Code: Tout sélectionner
/mnt/1wire/1D.4BFF0D000000/counters.A
/mnt/1wire/1D.4BFF0D000000/counters.B


en faisant cat /mnt/1wire/1D.4BFF0D000000/counters.A on obtient la valeur du compteur A.

Par contre, j'ai acheté cette carte car j'avais besoin de lire la téléinfo de mes compteurs EDF de conso et de prod, cette carte fournie un port 1-wire physique raccordé à lI2C de la RPi. Ça fonctionne très bien et je parviens bien à lire mes DS2423.

Je suis peut etre un peu hors sujet mais j'espère que ces explications pourront t'aider.
Jean-Mat'
Amateur Arduino et Raspberry pi
Ma centrale de consommation énergétique
Avatar de l’utilisateur
jmatgou
 
Messages: 41
Inscription: Lun 7 Nov 2011 16:19

Re: Comment remplacer un DS2423 par un ATtiny

Message non lude Illico » Lun 24 Fév 2014 19:55

Bonsoir et merci pour ce retour d'expérience. Cela va m'aider.
En effet si tu me dis que la méthode ""modprobe w1-ds2423"" ne fonctionne pas avec un "vrai" ds2423, cela provient probablement du driver ou du raspberry-pi. J'ai donc bon espoir que mon ATtiny85 fonctionne bien pour "cloner" le ds2423.
Je vais donc faire un essai avec le serveur owfs comme tu me l'as indiqué.
Pour l'adresse du périphérique, ce n'est pas un problème puisque c'est moi qui l'indique dans le code ds2423.c
Je connais aussi la carte RPIDOM, mais je l'a trouve un peu chère.
Et puis, je préfère (cela m'amuse) le faire moi même. ;)
J'ai déjà la solution pour le téléinfo EDF, avec une base SQL complétée par un script python et son interface Web en PHP sur le serveur du RaspberryPi.
Je reviens plus tard avec les résultats...merci.
Illico
 
Messages: 6
Inscription: Lun 27 Jan 2014 17:48

Re: Comment remplacer un DS2423 par un ATtiny

Message non lude Illico » Jeu 27 Fév 2014 15:00

Je suis au point mort...

J'ai installé OWFS (One Wire File System), mais malheureusement je vais surement devoir passer par le bus I2C pour adresser le bus 1-wire (avec un ds2482-100), ou bien via un bus USB ( DS9490R ).
En effet, il semblerait que l'on ne puisse pas piloter directement en GPIO (kernel module w1) le bus 1Wire avec OWFS (un bug!).

Quelques liens sur le sujet:
1-wire via GPIO avec modprobe w1-wire, w1-gpio, w1-therm, w1-ds2423(ne fonctionne pas)
http://learn.adafruit.com/adafruits-ras ... g/overview
1-wire via I2C avec OWFS
http://wiki.temperatur.nu/index.php/OWF ... version%29
1-wire via USB avec OWFS
http://www.raspberrypi.org/phpBB3/viewt ... 44&t=27379

Une piste sur le bug du kernel module w1 avec OWFS:
https://github.com/raspberrypi/linux/issues/261

a suivre...
Illico
 
Messages: 6
Inscription: Lun 27 Jan 2014 17:48

Re: Comment remplacer un DS2423 par un ATtiny

Message non lude pascal_m42 » Jeu 15 Mai 2014 07:22

Bonjour
Je viens de tester le DS2423 sur un ATtiny85 en suivant cette méthode, j'utilise OWFS via le bus I2C (avec un ds2482-100).
J’arrive à lire le conteur A avec la commande :
cat /mnt/1wire/1D.4BFF0D000000/counters.A
Celui ci s’incrémente normalement.
Si ça peu aider.
Pascal
pascal_m42
 
Messages: 1
Inscription: Jeu 15 Mai 2014 07:12

Re: Comment remplacer un DS2423 par un ATtiny

Message non lude Illico » Lun 26 Mai 2014 11:06

Désolé pour le retard...

Merci d'avoir fait le test, cela fonctionne bien lorsque l'on passe par un bus USB ou le bus I2C (ds2482-100), mais en direct l'OWFS ne fonctionne pas (bus 1wire du raspberry-pi).

J'ai donc changé ma méthode et j'ai directement crée un code I2C-Slave avec deux compteurs dans l'ATtiny85.
Cela fonctionne bien, je n'ai que le premier compteur qui tourne actuellement (impulsion conso gaz), le second compteur n'est pas câblé, mon compteur d'eau n'a pas d'aimant, je ne peux donc pas compter les impulsions :-( .
Illico
Illico
 
Messages: 6
Inscription: Lun 27 Jan 2014 17:48

Re: Comment remplacer un DS2423 par un ATtiny

Message non lude Dnis » Jeu 18 Juin 2015 21:04

Bonjour Illico,

Avez vous avancé sur ce projet.
Je suis très intéressé par ce sujet. J’ai déjà programmé un ATTINY85 mais les compteurs ne fonctionnent pas.
J’ai toujours FF avec CRC NO.
Avez-vous rencontré ce PB.

Merci d'avance.

Dnis
Dnis
 
Messages: 2
Inscription: Jeu 18 Juin 2015 09:04

Re: Comment remplacer un DS2423 par un ATtiny

Message non lude Illico » Jeu 2 Juil 2015 18:06

Bonjour,

Au final je n'ai pas utilisé le bus 1-wire, j'ai programmer un ATtiny85 pour faire l'équivalent d'un DS2423 mais en bus I2C.
Je n'ai pas réessayé avec les dernières versions d'owfs.
Illico
 
Messages: 6
Inscription: Lun 27 Jan 2014 17:48

Re: Comment remplacer un DS2423 par un ATtiny

Message non lude Dnis » Jeu 2 Juil 2015 21:40

Bonjour,
est-il couplé à un raspberry.
Je cherche la solution d'un compteur d’impulsion pour l'utiliser sur Domoticz via un Raspberry.

Est-ce votre cas?
Si oui, est-il possible d'avoir la méthode et le code?
je débute en domotique, mais je bricole...
Merci d'avance.
Dnis
Dnis
 
Messages: 2
Inscription: Jeu 18 Juin 2015 09:04


Retourner vers Vos projets, vos idées

Qui est en ligne

Utilisateurs parcourant ce forum: Google Feedfetcher et 3 invités