DS2438_DHT22/DS2438_DHT22.c

   1 // Copyright (c) 2015, Tobias Mueller tm(at)tm3d.de
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are
   6 // met:
   7 //
   8 //  * Redistributions of source code must retain the above copyright
   9 //    notice, this list of conditions and the following disclaimer.
  10 //  * Redistributions in binary form must reproduce the above copyright
  11 //    notice, this list of conditions and the following disclaimer in the
  12 //    documentation and/or other materials provided with the
  13 //    distribution.
  14 //  * All advertising materials mentioning features or use of this
  15 //    software must display the following acknowledgement: This product
  16 //    includes software developed by tm3d.de and its contributors.
  17 //  * Neither the name of tm3d.de nor the names of its contributors may
  18 //    be used to endorse or promote products derived from this software
  19 //    without specific prior written permission.
  20 //
  21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32
  33
  34 #define F_CPU 8000000UL
  35 //#define FP_CALC
  36 #include <avr/io.h>
  37 #include <avr/interrupt.h>
  38 #include <util/delay.h>
  39 #include <avr/wdt.h>
  40 #include <avr/sleep.h>
  41
  42 extern void OWINIT();
  43
  44
  45 uint8_t owid[8]={0x26, 0xA2, 0xD9, 0x84, 0x00, 0x00, 0x05, 0x16};/**/
  46 uint8_t config_info[16]={0x01,0x06, 0x05,0x08, 0x04,0x07, 0x00,0x00, 0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
  47
  48
  49 extern uint8_t mode;
  50 extern uint8_t gcontrol;
  51 extern uint8_t reset_indicator;
  52 extern uint8_t alarmflag;
  53
  54 volatile uint8_t wdcounter;
  55
  56
  57 typedef union {
  58 #if  defined(__AVR_ATtiny25__)
  59         volatile uint8_t bytes[16];
  60 #else
  61         volatile uint8_t bytes[64];
  62 #endif
  63         struct {
  64                 uint8_t status;  //1
  65                 int16_t temp;  //2
  66                 uint16_t voltage;  //4
  67                 uint16_t current;  //6
  68                 uint8_t threshold; //8
  69
  70                 uint8_t page1[8]; //9
  71 #if  defined(__AVR_ATtiny25__)
  72 #else
  73                 uint8_t page2[8]; //17
  74                 uint8_t page3[8]; //25
  75                 uint8_t page4[8];  //33
  76                 uint8_t page5[8];  //41
  77                 uint8_t page6[8];  //49
  78                 uint8_t page7[8];  //57
  79                 //uint8_t crc;  //65
  80 #endif
  81         };
  82 } pack_t;
  83 volatile pack_t pack;
  84
  85 #if  defined(__AVR_ATtiny25__)||defined(__AVR_ATtiny45__)  || defined(__AVR_ATtiny85__)
  86
  87 #define DDR_SENSOR   DDRB
  88 #define PORT_SENSOR  PORTB
  89 #define PIN_SENSOR   PINB
  90 #define SENSOR       PB4
  91 #endif
  92
  93 #if  defined(__AVR_ATtiny24__)||defined(__AVR_ATtiny44__)  || defined(__AVR_ATtiny84__) || defined(__AVR_ATtiny24A__)||defined(__AVR_ATtiny44A__)  || defined(__AVR_ATtiny84A__)
  94 #define DDR_SENSOR   DDRA
  95 #define PORT_SENSOR  PORTA
  96 #define PIN_SENSOR   PINA
  97 #define SENSOR       PINA2
  98 #endif
  99
 100
 101
 102 #define SENSOR_sda_out          DDR_SENSOR |= (1 << SENSOR)
 103 #define SENSOR_sda_in                   DDR_SENSOR &= ~(1 << SENSOR);PORT_SENSOR |= (1 << SENSOR) // release sda => hi in consequence of pullup
 104 #define SENSOR_sda_low    PORT_SENSOR &= ~(1 << SENSOR)
 105 #define SENSOR_is_hi                    PIN_SENSOR & (1 << SENSOR)
 106 #define SENSOR_is_low           !(PIN_SENSOR & (1 << SENSOR))
 107
 108 volatile int16_t am2302_temp;
 109 volatile uint16_t am2302_hum;
 110
 111
 112 uint8_t am_wait(uint8_t _time,uint8_t _signal){
 113         TCNT1=0;
 114         while(TCNT1==0);
 115         if (_signal)
 116                 while((SENSOR_is_hi)&&(TCNT1<_time)) {}
 117         else
 118                 while((SENSOR_is_low)&&(TCNT1<_time)) {}
 119
 120                 if (TCNT1>=_time) {return 1;}
 121         return 0;
 122 }
 123
 124 volatile uint8_t am2302_mode=0;
 125 volatile uint8_t timeout=0;
 126
 127
 128
 129 #if  defined(__AVR_ATtiny24__)||defined(__AVR_ATtiny44__)  || defined(__AVR_ATtiny84__) || defined(__AVR_ATtiny24A__)||defined(__AVR_ATtiny44A__)  || defined(__AVR_ATtiny84A__)
 130 ISR(WATCHDOG_vect) {
 131 #else
 132 ISR(WDT_vect) {
 133 #endif
 134         sleep_disable();          // Disable Sleep on Wakeup
 135         am2302_mode++;
 136         if (reset_indicator==1) reset_indicator++;
 137         else if (reset_indicator==2) mode=0;
 138 /*      if (timeout==2) {
 139                 DIS_TIMER;
 140                 EN_OWINT;
 141                 mode=OWM_SLEEP;
 142         }
 143         timeout++;*/
 144         sleep_enable();           // Enable Sleep Mode
 145
 146 }
 147
 148
 149
 150 uint8_t am2302_1() {
 151         int16_t lam2302_temp;
 152         uint16_t lam2302_hum;
 153         uint8_t rSREG;
 154         uint8_t sensor_data[5];
 155 #if  defined(__AVR_ATtiny25__)||defined(__AVR_ATtiny45__)  || defined(__AVR_ATtiny85__)
 156         TCCR1=(1<<CS12); //Clock/8 1µs
 157 #endif
 158
 159 #if  defined(__AVR_ATtiny24__)||defined(__AVR_ATtiny44__)  || defined(__AVR_ATtiny84__) || defined(__AVR_ATtiny24A__)||defined(__AVR_ATtiny44A__)  || defined(__AVR_ATtiny84A__)
 160         TCCR1B=(1<<CS11); //Clock/8 1µs
 161 #endif
 162         SENSOR_sda_out;
 163         SENSOR_sda_low; // MCU start signal
 164         TCNT1=0;while(TCNT1==0);while(TCNT1<250) {}// start signal (pull sda down for min 0.8ms and maximum 20ms)
 165         TCNT1=0;while(TCNT1==0);while(TCNT1<250) {}// start signal (pull sda down for min 0.8ms and maximum 20ms)
 166         SENSOR_sda_in;
 167         if (am_wait(200,1)) return 2;
 168
 169         // AM2302 response signal min: 75us typ:80us max:85us
 170         if (am_wait(100,0)) return 3;
 171         if (am_wait(100,1)) return 4;
 172
 173         for(uint8_t i = 0; i < 5; i++)  {
 174                 uint8_t sensor_byte = 0;
 175                 for(uint8_t j = 1; j <= 8; j++) {// get 8 bits from sensor
 176                         if (am_wait(88,0)) return 5;
 177
 178                         TCNT1=0;while(TCNT1==0);;while(TCNT1<35)                ;
 179                         sensor_byte <<= 1; // add new lower byte
 180                         if (SENSOR_is_hi) {// if sda high after 30us => bit=1 else bit=0
 181                                 sensor_byte |= 1;
 182                                 if (am_wait(45,1)) return 6;// 30us - 75us = 45us
 183                         }
 184                 }
 185                 sensor_data[i] = sensor_byte;
 186         }
 187
 188         // checksum
 189         if ( ((sensor_data[0]+sensor_data[1]+sensor_data[2]+sensor_data[3]) & 0xff ) != sensor_data[4])
 190         {
 191                 // debug output
 192                 //printf("%b %b %b %b %b %b" CR, sensor_data[0], sensor_data[1], sensor_data[2], sensor_data[3], sensor_data[4], ((sensor_data[0]+sensor_data[1]+sensor_data[2]+sensor_data[3]) & 0xff ));
 193                 PORTB&=~(1<<PINB0);
 194                 return 7;
 195         }
 196 #ifdef FP_CALC
 197         double htemp;
 198         if (sensor_data[2]&0x80) { //min
 199                 sensor_data[2]&=~(0x80);
 200                 htemp=-((sensor_data[2]<<8) + sensor_data[3]);
 201         } else
 202                 htemp=((sensor_data[2]<<8) + sensor_data[3]);
 203         double hhum=(1.0546-0.000216*htemp)*((sensor_data[0]<<8) + sensor_data[1]);
 204
 205         lam2302_hum=0.318*hhum +76;
 206         lam2302_temp=htemp*25.6;
 207 #else
 208
 209         if (sensor_data[2]&0x80) { //minus
 210                 sensor_data[2]&=~(0x80);
 211                 lam2302_temp=-((sensor_data[2]<<8) + sensor_data[3]);
 212         } else
 213                 lam2302_temp=((sensor_data[2]<<8) + sensor_data[3]);
 214
 215         lam2302_hum=((sensor_data[0]<<8) + sensor_data[1]);
 216         volatile uint32_t h1=lam2302_temp*lam2302_hum*3/44803;
 217         lam2302_hum=lam2302_hum*16/49-h1+80;
 218         //lam2302_temp=lam2302_temp*128/5;
 219
 220         int16_t h2=lam2302_temp%5;
 221         lam2302_temp=lam2302_temp/5;
 222         lam2302_temp*=128;
 223         lam2302_temp+=h2*128/5;
 224 #endif
 225         rSREG=SREG;
 226         cli();
 227         am2302_hum=lam2302_hum;
 228         am2302_temp=lam2302_temp;
 229         SREG=rSREG;
 230         return 0;
 231 }
 232
 233
 234 uint8_t am2302_2() { //4mhz
 235         int16_t lam2302_temp;
 236         uint16_t lam2302_hum;
 237         uint8_t rSREG;
 238         uint8_t sensor_data[5];
 239         #if  defined(__AVR_ATtiny25__)||defined(__AVR_ATtiny45__)  || defined(__AVR_ATtiny85__)
 240         TCCR1=(1<<CS11)|(1<<CS10); //Clock/8 1µs
 241         #endif
 242
 243         #if  defined(__AVR_ATtiny24__)||defined(__AVR_ATtiny44__)  || defined(__AVR_ATtiny84__) || defined(__AVR_ATtiny24A__)||defined(__AVR_ATtiny44A__)  || defined(__AVR_ATtiny84A__)
 244         TCCR1B=(1<<CS11); //Clock/8 1µs
 245         #endif
 246         SENSOR_sda_out;
 247         SENSOR_sda_low; // MCU start signal
 248         TCNT1=0;while(TCNT1==0);while(TCNT1<250) {}// start signal (pull sda down for min 0.8ms and maximum 20ms)
 249         TCNT1=0;while(TCNT1==0);while(TCNT1<250) {}// start signal (pull sda down for min 0.8ms and maximum 20ms)
 250         SENSOR_sda_in;
 251         if (am_wait(200,1)) return 2;
 252
 253         // AM2302 response signal min: 75us typ:80us max:85us
 254         if (am_wait(100,0)) return 3;
 255         if (am_wait(100,1)) return 4;
 256
 257         for(uint8_t i = 0; i < 5; i++)  {
 258                 uint8_t sensor_byte = 0;
 259                 for(uint8_t j = 1; j <= 8; j++) {// get 8 bits from sensor
 260                         if (am_wait(88,0)) return 5;
 261
 262                         TCNT1=0;while(TCNT1==0);;while(TCNT1<35)                ;
 263                         sensor_byte <<= 1; // add new lower byte
 264                         if (SENSOR_is_hi) {// if sda high after 30us => bit=1 else bit=0
 265                                 sensor_byte |= 1;
 266                                 if (am_wait(45,1)) return 6;// 30us - 75us = 45us
 267                         }
 268                 }
 269                 sensor_data[i] = sensor_byte;
 270         }
 271
 272         // checksum
 273         if ( ((sensor_data[0]+sensor_data[1]+sensor_data[2]+sensor_data[3]) & 0xff ) != sensor_data[4])
 274         {
 275                 // debug output
 276                 //printf("%b %b %b %b %b %b" CR, sensor_data[0], sensor_data[1], sensor_data[2], sensor_data[3], sensor_data[4], ((sensor_data[0]+sensor_data[1]+sensor_data[2]+sensor_data[3]) & 0xff ));
 277                 PORTB&=~(1<<PINB0);
 278                 return 7;
 279         }
 280 #ifdef FP_CALC
 281         lam2302_hum=0.318* ((sensor_data[0]<<8) + sensor_data[1])+76;
 282         if (sensor_data[2]&0x80) { //minus
 283                 sensor_data[2]&=~(0x80);
 284                 lam2302_temp=-((sensor_data[2]<<8) + sensor_data[3])*25.6;
 285         } else
 286                 lam2302_temp=((sensor_data[2]<<8) + sensor_data[3])*25.6;
 287 #else
 288
 289
 290         if (sensor_data[2]&0x80) { //minus
 291                 sensor_data[2]&=~(0x80);
 292                 lam2302_temp=-((sensor_data[2]<<8) + sensor_data[3]);
 293         } else
 294         lam2302_temp=((sensor_data[2]<<8) + sensor_data[3]);
 295
 296         lam2302_hum=((sensor_data[0]<<8) + sensor_data[1]);
 297         volatile uint32_t h1=lam2302_temp*lam2302_hum*3/44803;
 298         lam2302_hum=lam2302_hum*16/49-h1+80;
 299         //lam2302_temp=lam2302_temp*128/5;
 300
 301         int16_t h2=lam2302_temp%5;
 302         lam2302_temp=lam2302_temp/5;
 303         lam2302_temp*=128;
 304         lam2302_temp+=h2*128/5;
 305 #endif
 306
 307
 308         rSREG=SREG;
 309         cli();
 310         am2302_hum=lam2302_hum;
 311         am2302_temp=lam2302_temp;
 312         SREG=rSREG;
 313         return 0;
 314 }
 315
 316
 317 int main(void){
 318     PRR|=(1<<PRUSI)|(1<<PRADC);  //Switch off usi and adc for save Power
 319
 320         OWINIT();
 321
 322         ACSR|=(1<<ACD);  //Disable Comparator
 323         ADCSRB|=(1<<ACME); //Disable Analog multiplexer
 324         MCUCR &=~(1<<PUD); //All Pins Pullup...
 325         MCUCR |=(1<<BODS);
 326         MCUCR &=~(1<<PUD);
 327
 328 #if  defined(__AVR_ATtiny25__)||defined(__AVR_ATtiny45__)  || defined(__AVR_ATtiny85__)
 329
 330         PORTB|=(1<<PINB0)|(1<<PINB1)|(1<<PINB3)|(1<<PINB4)|(1<<PINB5);
 331         DDRB|=(1<<PINB1); //DBLINE
 332 #define SENSON PORTB|=(1<<PINB0);
 333 #define SENSOFF PORTB&=~(1<<PINB0);
 334         DDRB|=(1<<PINB0); //stromversorgung
 335
 336         // Set up Watch Dog Timer for Inactivity
 337         WDTCR |= ((1<<WDCE) | (1<<WDE));   // Enable the WD Change Bit
 338         WDTCR =   (1<<WDIE) |              // Enable WDT Interrupt
 339         (1<<WDP2) | (1<<WDP1);   // Set Timeout to ~2 seconds
 340 #endif
 341
 342 #if  defined(__AVR_ATtiny24__)||defined(__AVR_ATtiny44__)  || defined(__AVR_ATtiny84__) || defined(__AVR_ATtiny24A__)||defined(__AVR_ATtiny44A__)  || defined(__AVR_ATtiny84A__)
 343
 344         //PORTB|=(1<<PINB0)|(1<<PINB1)|(1<<PINB3)|(1<<PINB4)|(1<<PINB5);
 345         //DDRA|=(1<<PINB1);
 346         DDRA|=(1<<PINA1); //stromversorgung
 347 #define SENSON PORTA|=(1<<PINA1);
 348 #define SENSOFF PORTA&=~(1<<PINA1);
 349
 350         // Set up Watch Dog Timer for Inactivity
 351 //      WDTCSR |= (1<<WDCE) ;   // Enable the WD Change Bit
 352 //      WDTCSR =   (1<<WDIE) |              // Enable WDT Interrupt
 353 //      (1<<WDP2) | (1<<WDP1);   // Set Timeout to ~2 seconds
 354 #endif
 355
 356
 357     uint8_t i;
 358         uint8_t err;
 359 #if  defined(__AVR_ATtiny25__)
 360     for(i=0;i<16;i++) pack.bytes[i]=0;
 361 #else
 362         uint8_t pn=1;
 363     for(i=0;i<64;i++) pack.bytes[i]=0;
 364 #endif
 365         //pack.bytes[0]=1;
 366         //pack.bytes[1]=2;
 367         SENSON
 368         _delay_ms(4000);
 369         err =am2302_1();
 370         sei();
 371     while(1)   {
 372                 alarmflag=1;
 373                 if (am2302_mode==2) {
 374                         err=am2302_1();
 375                         if (err!=0) {
 376 #if  defined(__AVR_ATtiny25__)
 377 #else
 378                                 pack.page3[pn]=err;
 379                                 pn=pn+1;if (pn>31) pn=1;
 380 #endif
 381                         }
 382                         SENSOFF
 383                         am2302_mode=3;
 384                 }
 385                 if (am2302_mode>=8) {
 386                         am2302_mode=0;
 387                         SENSON
 388                 }
 389 #if  defined(__AVR_ATtiny25__)||defined(__AVR_ATtiny45__)  || defined(__AVR_ATtiny85__)
 390                         if (((TIMSK & (1<<TOIE0))==0)&& (mode==0))
 391 #endif
 392 #if  defined(__AVR_ATtiny24__)||defined(__AVR_ATtiny44__)  || defined(__AVR_ATtiny84__) || defined(__AVR_ATtiny24A__)||defined(__AVR_ATtiny44A__)  || defined(__AVR_ATtiny84A__)
 393                         if (((TIMSK0 & (1<<TOIE0))==0)&& (mode==0))
 394 #endif
 395                           {
 396 //                      CLKPR=(1<<CLKPCE);
 397         //              CLKPR=(1<<CLKPS2); /*0.5Mhz*/
 398                         //PORTB&=~(1<<PINB1);
 399                         MCUCR|=(1<<SE)|(1<<SM1);
 400                         MCUCR&=~(1<<ISC01);
 401                 } else {
 402                         MCUCR|=(1<<SE);
 403                         MCUCR&=~(1<<SM1);
 404                 }
 405                 asm("SLEEP");
 406    }
 407
 408
 409 }