julian
/
poolclock
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
196 KiB
 
 
Tree: 7f2d49b333
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7f2d49b333'
${ noResults }
poolclock/PoolClockHumidity/main.c

558 lines
17 KiB
Raw Blame History 

  1. #include <stdbool.h>

  2. #include <avr/io.h>

  3. #include <avr/interrupt.h>

  4. #define F_CPU 20000000UL  //20 MHz

  5. #include <util/delay.h>

  6. 

  7. /* 7-Segment display: */

  8. #define NUM_DIGITS 3U  //3 Digits

  9. #define DIGIT_TENS 2U  //left

  10. #define DIGIT_ONES 1U  //middle

  11. #define DIGIT_UNIT 0U  //right

  12. #define SELECT_DIGIT(digit) (1U << digit)

  13. 

  14. /* DHT22 peripherals: */

  15. #define DDR_SENSOR   DDRC

  16. #define PORT_SENSOR  PORTC

  17. #define PIN_SENSOR   PINC

  18. #define SENSOR       PINC3

  19. 

  20. /* DHT22 commands: */

  21. #define SENSOR_sda_out  DDR_SENSOR |= (1 << SENSOR)

  22. #define SENSOR_sda_in   DDR_SENSOR &= ~(1 << SENSOR) // release sda => hi in consequence of pullup

  23. #define SENSOR_sda_low  PORT_SENSOR &= ~(1 << SENSOR)

  24. #define SENSOR_is_hi    PIN_SENSOR & (1 << SENSOR)

  25. #define SENSOR_is_low   !(PIN_SENSOR & (1 << SENSOR))

  26. 

  27. #define MODE_MEASURE        0U

  28. #define MODE_ANIMATION_1    1U

  29. #define MODE_ANIMATION_2    2U

  30. 

  31. #define ANIMATION_DELAY_MS 70U

  32. 

  33. #define ANIMATION_START_DELAY_MS 70U

  34. 

  35. #define BUTTON_THRESHOLD 50 //software debounce

  36. 

  37. /* Symbol indexes: */

  38. #define SYM_n           10U

  39. #define SYM_o           11U

  40. #define SYM_E           12U

  41. #define SYM_R           13U

  42. #define SYM_DEG_CELCIUS 14U

  43. #define SYM_P_P         15U

  44. #define SYM_OFF         16U

  45. #define SYM_DASH        17U

  46. #define SYM_I           18U

  47. #define SYM_SEG_A       19U

  48. #define SYM_SEG_B       20U

  49. #define SYM_SEG_C       21U

  50. #define SYM_SEG_D       22U

  51. #define SYM_SEG_E       23U

  52. #define SYM_SEG_F       24U

  53. #define SYM_SEG_AB      25U

  54. #define SYM_SEG_BCD     26U

  55. #define SYM_SEG_CD      27U

  56. #define SYM_SEG_DE      28U

  57. #define SYM_SEG_DEF     29U

  58. #define SYM_SEG_AEF     30U

  59. #define SYM_SEG_AF      31U

  60. 

  61. /*

  62.  7-Segment Layout:

  63. 

  64.      A

  65.   F     B

  66.      G  

  67.   E     C

  68.      D    P

  69. 

  70.  Pin       7  6  5  4  3  2  1  0

  71.  Segment   A  F  B  E  D  C  G  P

  72. */

  73. static uint8_t g_au8Symbols[32U] =

  74. {

  75. /* 00 */ 0b11111100U, //0 (ABCDEF)

  76. /* 01 */ 0b00100100U, //1 (BC)

  77. /* 02 */ 0b10111010U, //2 (ABDEG)

  78. /* 03 */ 0b10101110U, //3 (ABCDG)

  79. /* 04 */ 0b01100110U, //4 (BCFG)

  80. /* 05 */ 0b11001110U, //5 (ACDFG)

  81. /* 06 */ 0b11011110U, //6 (ACDEFG)

  82. /* 07 */ 0b10100100U, //7 (ABC)

  83. /* 08 */ 0b11111110U, //8 (ABCDEFG)

  84. /* 09 */ 0b11101110U, //9 (ABCDFG)

  85. /* 10 */ 0b00010110U, //n (CEG)      SYM_n

  86. /* 11 */ 0b00011110U, //o (CDEG)     SYM_o

  87. /* 12 */ 0b11011010U, //E (ADEFG)    SYM_E

  88. /* 13 */ 0b00010010U, //r (EG)       SYM_r

  89. /* 14 */ 0b10101101U, //degC (ABCDP) SYM_DEG_CELCIUS

  90. /* 15 */ 0b11110011U, //P. (ABEFGP)  SYM_P_P

  91. /* 16 */ 0b00000000U, //OFF          SYM_OFF

  92. /* 17 */ 0b00000010U, //- (G)        SYM_DASH

  93. /* 18 */ 0b01010000U, //I (EF)       SYM_I

  94. /* 19 */ 0b10000000U, //SegA         SYM_SEG_A

  95. /* 20 */ 0b00100000U, //SegB         SYM_SEG_B

  96. /* 21 */ 0b00000100U, //SegC         SYM_SEG_C

  97. /* 22 */ 0b00001000U, //SegD         SYM_SEG_D

  98. /* 23 */ 0b00010000U, //SegE         SYM_SEG_E

  99. /* 24 */ 0b01000000U, //SegF         SYM_SEG_F

  100. /* 25 */ 0b10100000U, //SegAB        SYM_SEG_AB

  101. /* 26 */ 0b00101100U, //SegBCD       SYM_SEG_BCD

  102. /* 27 */ 0b00001100U, //SegCD        SYM_SEG_CD

  103. /* 28 */ 0b00011000U, //SegDE        SYM_SEG_DE

  104. /* 29 */ 0b01011000U, //SegDEF       SYM_SEG_DEF

  105. /* 30 */ 0b11010000U, //SegAEF       SYM_SEG_AEF

  106. /* 31 */ 0b11000000U  //SegAF        SYM_SEG_AF

  107. };

  108. 

  109. static uint8_t g_u8ButtonCountTop = 0U;           //upper button counter

  110. static uint8_t g_u8ButtonCountBot = 0U;           //lower button counter

  111. static uint8_t g_u8Mode = MODE_MEASURE;      //Current display mode

  112. 

  113. 

  114. uint16_t g_u16Humidity = 0U;

  115. uint16_t g_u16Temperature = 0U;

  116. 

  117. uint8_t g_u8ISRDigitSelect = 0U;

  118. uint8_t g_au8Digits[3U] =

  119. {

  120.     SYM_OFF, //unit

  121.     SYM_OFF, //ones

  122.     SYM_OFF  //tens

  123. };

  124. 

  125. void s_vInit( void );

  126. void s_vSetValue( uint8_t u8Value, uint8_t u8Unit );

  127. void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit );

  128. 

  129. void s_vReadButtons( void );

  130. void s_vShowAnim( uint8_t u8Select );

  131. 

  132. uint8_t s_u8ReadSensor( void );

  133. 

  134. /************************************************************************/

  135. /* Timer1 ISR - show values on display                                  */

  136. /************************************************************************/

  137. ISR ( TIMER1_COMPA_vect )

  138. {

  139.     PORTB = 0;

  140.     PORTD = 0;

  141.     _delay_us(2);

  142.     PORTB = SELECT_DIGIT(g_u8ISRDigitSelect);

  143.     PORTD = g_au8Symbols[g_au8Digits[g_u8ISRDigitSelect]];

  144.     g_u8ISRDigitSelect++;

  145.     if (g_u8ISRDigitSelect > 2U)

  146.     {

  147.         g_u8ISRDigitSelect = 0U;

  148.     }

  149.     

  150.     /* Read and evaluate button status */

  151.     s_vReadButtons();

  152. }

  153. 

  154. /************************************************************************/

  155. /* main()                                                               */

  156. /************************************************************************/

  157. int main(void)

  158. {

  159.     uint8_t u8ErrorCode = 0U;

  160.     uint8_t u8Loop = 0U;

  161. 

  162.     s_vInit();

  163.     

  164.     s_vSetDisplayDigits( SYM_OFF, SYM_OFF, SYM_OFF );

  165.     _delay_ms(10);

  166.     

  167.     s_vSetDisplayDigits( SYM_SEG_A, SYM_OFF, SYM_OFF );

  168.     _delay_ms(300);

  169.     s_vSetDisplayDigits( SYM_SEG_A, SYM_SEG_A, SYM_OFF );

  170.     _delay_ms(300);

  171.     s_vSetDisplayDigits( SYM_SEG_A, SYM_SEG_A, SYM_SEG_A );

  172.     _delay_ms(300);

  173.     

  174.     while ( u8Loop < 5U )

  175.     {

  176.         s_vSetDisplayDigits( SYM_OFF, SYM_SEG_A, SYM_SEG_AB );

  177.         _delay_ms(ANIMATION_START_DELAY_MS);

  178.         s_vSetDisplayDigits( SYM_OFF, SYM_OFF, 7U );

  179.         _delay_ms(ANIMATION_START_DELAY_MS);

  180.         s_vSetDisplayDigits( SYM_OFF, SYM_OFF, SYM_SEG_BCD );

  181.         _delay_ms(ANIMATION_START_DELAY_MS);

  182.         s_vSetDisplayDigits( SYM_OFF, SYM_SEG_D, SYM_SEG_CD );

  183.         _delay_ms(ANIMATION_START_DELAY_MS);

  184.         s_vSetDisplayDigits( SYM_SEG_D, SYM_SEG_D, SYM_SEG_D );

  185.         _delay_ms(ANIMATION_START_DELAY_MS);

  186.         s_vSetDisplayDigits( SYM_SEG_DE, SYM_SEG_D, SYM_OFF );

  187.         _delay_ms(ANIMATION_START_DELAY_MS);

  188.         s_vSetDisplayDigits( SYM_SEG_DEF, SYM_OFF, SYM_OFF );

  189.         _delay_ms(ANIMATION_START_DELAY_MS);

  190.         s_vSetDisplayDigits( SYM_SEG_AEF, SYM_OFF, SYM_OFF );

  191.         _delay_ms(ANIMATION_START_DELAY_MS);

  192.         s_vSetDisplayDigits( SYM_SEG_AF, SYM_SEG_A, SYM_OFF );

  193.         _delay_ms(ANIMATION_START_DELAY_MS);

  194.         s_vSetDisplayDigits( SYM_SEG_A, SYM_SEG_A, SYM_SEG_A );

  195.         _delay_ms(ANIMATION_START_DELAY_MS);

  196.         u8Loop++;

  197.     }

  198.     

  199.     /* Set default value: */

  200.     //s_vSetDisplayDigits( SYM_DASH, SYM_DASH, SYM_DASH );

  201.     

  202.     /* wait 3 seconds for humity sensor */

  203.     //_delay_ms(3000);

  204.     

  205.     /* Set default value: */

  206.     s_vSetDisplayDigits( SYM_OFF, SYM_OFF, SYM_OFF );

  207.     _delay_ms(600);

  208. 

  209.     while ( 1 )

  210.     {

  211.         switch ( g_u8Mode )

  212.         {

  213.             case MODE_MEASURE:

  214.                 if ( SENSOR_is_hi )

  215.                 {

  216.                     SENSOR_sda_out;

  217.                     SENSOR_sda_low;

  218.                     _delay_ms(20);

  219.                     u8ErrorCode = s_u8ReadSensor();

  220.                     if ( 0U == u8ErrorCode )

  221.                     {

  222.                         s_vSetValue( g_u16Humidity / 10, SYM_P_P );

  223.                         //vSetDisplayValues( g_u16Temperature / 10, SYM_DEG_CELCIUS );

  224.                     }

  225.                     else

  226.                     {

  227.                         s_vSetDisplayDigits( SYM_E, u8ErrorCode, SYM_OFF );

  228.                     }

  229.                 }

  230.                 if ( g_u8Mode == MODE_MEASURE )

  231.                 {

  232.                     _delay_ms(500);

  233.                 }

  234.                 break;

  235.             case MODE_ANIMATION_1:

  236.                 s_vShowAnim(g_u8Mode);

  237.                 g_u8Mode = MODE_MEASURE;

  238.                 _delay_ms(200);

  239.                 break;

  240.             case MODE_ANIMATION_2:

  241.                 s_vShowAnim(g_u8Mode);

  242.                 g_u8Mode = MODE_MEASURE;

  243.                 _delay_ms(200);

  244.                 break;

  245.             default:

  246.                 break;

  247.         } //end switch

  248. 

  249.        // _delay_ms(3000); //wait 3 seconds for new measurement

  250.     } //end while(1)

  251. 

  252.     return 0;

  253. }

  254. 

  255. /************************************************************************/

  256. /* Initialize inputs and outputs                                        */

  257. /************************************************************************/

  258. void s_vInit( void )

  259. {

  260.     /* Port D - Pins 0-7: Outputs */

  261.     DDRD = 0b11111111U;

  262.     

  263.     /* Port B - Pins 0-2: Outputs */

  264.     DDRB = 0b00000111U;

  265.     

  266.     /* Port C - Pins 4-5: Inputs with internal Pull-up */

  267.     PORTC = 0b00110000U;

  268.     

  269.     /* Sensor init: */

  270.     DDR_SENSOR &= ~(1 << SENSOR);   // define as input

  271.     PORT_SENSOR &= ~(1 << SENSOR);  // disable pullup

  272.     

  273.     /* 16-bit TIMER1 in CTC mode

  274.      * prescaler = 8

  275.      * 20 MHz / 8 = 2.5 MHz

  276.      * Compare value = 2500 => 1 ms IRQ

  277.      */

  278.     TCCR1A = 0U;

  279.     TCCR1B = (1<<WGM12) | (1<<CS11);

  280.     OCR1A = 2500U;

  281.     TIMSK1 |= (1<<OCIE1A);

  282.     sei();

  283.     

  284.     return; //void

  285. }

  286. 

  287. /************************************************************************/

  288. /* Set new values to be shown on display                                */

  289. /************************************************************************/

  290. void s_vSetValue( uint8_t u8Value, uint8_t u8Unit )

  291. {

  292.     uint8_t u8Tmp = u8Value / 10U;

  293.     s_vSetDisplayDigits(u8Tmp, u8Value - (u8Tmp * 10U), u8Unit);

  294. 

  295.     return; //void

  296. }

  297. 

  298. /************************************************************************/

  299. /* Set display digits individually                                      */

  300. /************************************************************************/

  301. void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )

  302. {

  303.     g_au8Digits[DIGIT_TENS] = u8Tens;

  304.     g_au8Digits[DIGIT_ONES] = u8Ones;

  305.     g_au8Digits[DIGIT_UNIT] = u8Unit;

  306.     

  307.     return; //void

  308. }

  309. 

  310. /************************************************************************/

  311. /* Read button status                                                   */

  312. /************************************************************************/

  313. void s_vReadButtons( void )

  314. {

  315.     if ( !(PINC & (1<<PINC4)) ) //if button '+' pressed

  316.     {

  317.         g_u8ButtonCountTop++;

  318.     }

  319.     else

  320.     {

  321.         g_u8ButtonCountTop = 0U; //reset button counter

  322.     }

  323.     

  324.     if ( !(PINC & (1<<PINC5)) ) //if button '-' pressed

  325.     {

  326.         g_u8ButtonCountBot++;

  327.     }

  328.     else

  329.     {

  330.         g_u8ButtonCountBot = 0U; //reset button counter

  331.     }

  332.     

  333.     if ( g_u8ButtonCountTop > BUTTON_THRESHOLD )

  334.     {

  335.         g_u8ButtonCountTop = 0U; //reset top counter

  336.         g_u8Mode =  MODE_ANIMATION_1;

  337.     }

  338.     else if ( g_u8ButtonCountBot > BUTTON_THRESHOLD )

  339.     {

  340.         g_u8ButtonCountBot = 0U; //reset bottom counter

  341.         g_u8Mode =  MODE_ANIMATION_2;

  342.     }

  343. 

  344.     return; //void

  345. }

  346. /************************************************************************/

  347. /*                                                                      */

  348. /************************************************************************/

  349. void s_vShowAnim( uint8_t u8Select )

  350. {

  351.     s_vSetDisplayDigits( SYM_OFF, SYM_OFF, SYM_OFF );

  352.     _delay_ms(ANIMATION_DELAY_MS);

  353.     switch ( u8Select )

  354.     {

  355.         case MODE_ANIMATION_1: //fade from left to right and from right to left

  356.             s_vSetDisplayDigits( SYM_I, SYM_OFF, SYM_OFF );

  357.             _delay_ms(ANIMATION_DELAY_MS);

  358.             s_vSetDisplayDigits( SYM_E, SYM_OFF, SYM_OFF );

  359.             _delay_ms(ANIMATION_DELAY_MS);

  360.             s_vSetDisplayDigits( 8U, SYM_OFF, SYM_OFF );

  361.             _delay_ms(ANIMATION_DELAY_MS);

  362.             

  363.             s_vSetDisplayDigits( 8U, SYM_I, SYM_OFF );

  364.             _delay_ms(ANIMATION_DELAY_MS);

  365.             s_vSetDisplayDigits( 8U, SYM_E, SYM_OFF );

  366.             _delay_ms(ANIMATION_DELAY_MS);

  367.             s_vSetDisplayDigits( 8U, 8U, SYM_OFF );

  368.             _delay_ms(ANIMATION_DELAY_MS);

  369.             

  370.             s_vSetDisplayDigits( 8U, 8U, 1U );

  371.             _delay_ms(ANIMATION_DELAY_MS);

  372.             s_vSetDisplayDigits( 8U, 8U, 3U );

  373.             _delay_ms(ANIMATION_DELAY_MS);

  374.             s_vSetDisplayDigits( 8U, 8U, 8U );

  375.             _delay_ms(ANIMATION_DELAY_MS);

  376.             

  377.             s_vSetDisplayDigits( 8U, 8U, 8U );

  378.             _delay_ms(ANIMATION_DELAY_MS);

  379.             s_vSetDisplayDigits( 8U, 8U, 3U );

  380.             _delay_ms(ANIMATION_DELAY_MS);

  381.             s_vSetDisplayDigits( 8U, 8U, 1U );

  382.             _delay_ms(ANIMATION_DELAY_MS);

  383.             

  384.             s_vSetDisplayDigits( 8U, 8U, SYM_OFF );

  385.             _delay_ms(ANIMATION_DELAY_MS);

  386.             s_vSetDisplayDigits( 8U, SYM_E, SYM_OFF );

  387.             _delay_ms(ANIMATION_DELAY_MS);

  388.             s_vSetDisplayDigits( 8U, SYM_I, SYM_OFF );

  389.             _delay_ms(ANIMATION_DELAY_MS);

  390.             

  391.             s_vSetDisplayDigits( 8U, SYM_OFF, SYM_OFF );

  392.             _delay_ms(ANIMATION_DELAY_MS);

  393.             s_vSetDisplayDigits( SYM_E, SYM_OFF, SYM_OFF );

  394.             _delay_ms(ANIMATION_DELAY_MS);

  395.             s_vSetDisplayDigits( SYM_I, SYM_OFF, SYM_OFF );

  396.             _delay_ms(ANIMATION_DELAY_MS);

  397.             break;

  398.         case MODE_ANIMATION_2: //fade from left to right and clear

  399.             s_vSetDisplayDigits( SYM_I, SYM_OFF, SYM_OFF );

  400.             _delay_ms(ANIMATION_DELAY_MS);

  401.             s_vSetDisplayDigits( SYM_E, SYM_OFF, SYM_OFF );

  402.             _delay_ms(ANIMATION_DELAY_MS);

  403.             s_vSetDisplayDigits( 8U, SYM_OFF, SYM_OFF );

  404.             _delay_ms(ANIMATION_DELAY_MS);

  405.             

  406.             s_vSetDisplayDigits( 8U, SYM_I, SYM_OFF );

  407.             _delay_ms(ANIMATION_DELAY_MS);

  408.             s_vSetDisplayDigits( 8U, SYM_E, SYM_OFF );

  409.             _delay_ms(ANIMATION_DELAY_MS);

  410.             s_vSetDisplayDigits( 8U, 8U, SYM_OFF );

  411.             _delay_ms(ANIMATION_DELAY_MS);

  412.             

  413.             s_vSetDisplayDigits( 8U, 8U, 1U );

  414.             _delay_ms(ANIMATION_DELAY_MS);

  415.             s_vSetDisplayDigits( 8U, 8U, 3U );

  416.             _delay_ms(ANIMATION_DELAY_MS);

  417.             s_vSetDisplayDigits( 8U, 8U, 8U );

  418.             _delay_ms(ANIMATION_DELAY_MS);

  419.             

  420.             s_vSetDisplayDigits( 3U, 8U, 8U );

  421.             _delay_ms(ANIMATION_DELAY_MS);

  422.             s_vSetDisplayDigits( 1U, 8U, 8U );

  423.             _delay_ms(ANIMATION_DELAY_MS);

  424.             s_vSetDisplayDigits( SYM_OFF, 8U, 8U );

  425.             _delay_ms(ANIMATION_DELAY_MS);

  426.             

  427.             s_vSetDisplayDigits( SYM_OFF, 3U, 8U );

  428.             _delay_ms(ANIMATION_DELAY_MS);

  429.             s_vSetDisplayDigits( SYM_OFF, 1U, 8U );

  430.             _delay_ms(ANIMATION_DELAY_MS);

  431.             s_vSetDisplayDigits( SYM_OFF, SYM_OFF, 8U );

  432.             _delay_ms(ANIMATION_DELAY_MS);

  433.             

  434.             s_vSetDisplayDigits( SYM_OFF, SYM_OFF, SYM_E );

  435.             _delay_ms(ANIMATION_DELAY_MS);

  436.             s_vSetDisplayDigits( SYM_OFF, SYM_OFF, SYM_I );

  437.             _delay_ms(ANIMATION_DELAY_MS);

  438.             s_vSetDisplayDigits( SYM_OFF, SYM_OFF, SYM_OFF );

  439.             _delay_ms(ANIMATION_DELAY_MS);

  440.             break;

  441.         default:

  442.             break;

  443.     } //end switch

  444.     s_vSetDisplayDigits( SYM_OFF, SYM_OFF, SYM_OFF );

  445.     _delay_ms(ANIMATION_DELAY_MS);

  446.     

  447.     return; //void

  448. }

  449. 

  450. /************************************************************************/

  451. /* Read humidity and temperature from DHT22                             */

  452. /************************************************************************/

  453. uint8_t s_u8ReadSensor( void )

  454. {

  455.     uint8_t timeout = 200;

  456.     

  457.     SENSOR_sda_in;

  458. 

  459.     // Bus master has released time min: 20us, typ: 30us, max: 200us

  460.     while ( SENSOR_is_hi )

  461.     {

  462.         _delay_us(1);

  463.         if ( !timeout-- )

  464.         {

  465.             return 2;

  466.         }

  467.     }

  468. 

  469.     // AM2302 response signal min: 75us typ:80us max:85us

  470.     timeout = 85;

  471.     while(SENSOR_is_low)

  472.     {

  473.         _delay_us(1);

  474.         if (!timeout--)

  475.         {

  476.             return 3;

  477.         }

  478.     }  // response to low time

  479. 

  480.     timeout = 85;

  481.     while(SENSOR_is_hi)

  482.     {

  483.         _delay_us(1);

  484.         if (!timeout--)

  485.         {

  486.             return 4;

  487.         }

  488.     }  // response to high time

  489. 

  490. 

  491.     /*

  492.      *            time in us: min typ max

  493.      *    signal 0 high time: 22  26  30     (bit=0)

  494.      *    signal 1 high time: 68  70  75     (bit=1)

  495.      *  signal 0,1 down time: 48  50  55

  496.      */

  497. 

  498.     uint8_t sensor_data[5]={0};

  499. 

  500.     for(uint8_t i = 0; i < 5; i++)

  501.     {

  502.         uint8_t sensor_byte = 0;

  503.     

  504.         // get 8 bits from sensor

  505.         for(uint8_t j = 1; j <= 8; j++)

  506.         {

  507.             // wait for sensor response

  508.             timeout = 55;

  509.             while(SENSOR_is_low)

  510.             {

  511.                 _delay_us(1);

  512. 

  513.                 // if timeout == 0 => sensor do not response

  514.                 if (!timeout--)

  515.                 {

  516.                     return 5;

  517.                 }

  518.             }

  519. 

  520.             // wait 30 us to check if bit is logical "1" or "0"

  521.             _delay_us(30);

  522.             sensor_byte <<= 1; // add new lower bit

  523. 

  524.             // If sda ist high after 30 us then bit is logical "1" else it was a logical "0"

  525.             // For a logical "1" sda have to be low after 75 us.

  526.             if (SENSOR_is_hi)

  527.             {

  528.                 sensor_byte |= 1; // add logical "1"

  529.                 timeout = 45;  // 30us - 75us = 45us

  530. 

  531.                 while(SENSOR_is_hi)

  532.                 {

  533.                     _delay_us(1);

  534.                 

  535.                     if (!timeout--)

  536.                     {

  537.                         return 6;

  538.                     }

  539.                 }

  540.             }

  541.         }

  542. 

  543.         sensor_data[i] = sensor_byte;

  544.     }

  545. 

  546.     // checksum

  547.     if ( ((sensor_data[0] + sensor_data[1] + sensor_data[2] + sensor_data[3]) & 0xff ) != sensor_data[4])

  548.     {

  549.         // debug output

  550.         //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 ));

  551.         return 7;

  552.     }

  553. 

  554.     g_u16Humidity = (sensor_data[0] << 8) + sensor_data[1];

  555.     g_u16Temperature = (sensor_data[2] << 8) + sensor_data[3];

  556. 

  557.     return 0;

  558. }