DCF77 Analyzer/Clock v2.0

1//
2//  This is the Superfilter sketch I use with the DCF Analyzer/Clock  2.0 
3//  Udo Klein did an amazing job with this filter
4//
5//  Erik de Ruiter
6
7/*
8    Arduino Uno pin connections I used for the DCF Analyzer Clock
9
10    DCF  input ................. A5 (19)  = dcf77_sample_pin
11    Output DCF Filtered .......  12       = dcf77_filtered_pin
12    Output DCF Semi Synthesized A2 (16)  = dcf77_semi_synthesized_pin
13    Output DCF Synthesized ....  6       = dcf77_synthesized_pin
14    LED DCF  output filtered ... A4 (18)  = dcf77_monitor_pin                    = DCF Monitor  LED
15    LED 1 Hz pulse ............ 10       = dcf77_second_pulse_pin               =  Filter Locked LED
16    LED DCF OK ................ 13       = dcf77_signal_good_indicator_pin      = Signal Quality LED
17    LED Difference Filtered ...  7       = dcf77_filter_diff_pin            \     
18    LED Difference Semi Synth.. A0       = dcf77_semi_synthesized_diff_pin   -> = Signal Difference LED
19    LED Difference Synthesized   4       = dcf77_synthesized_diff_pin       /
20*/
21    
22//
23//  www.blinkenlight.net
24//
25//  Copyright  2014, 2015 Udo Klein
26//
27//  This program is free software: you can redistribute  it and/or modify
28//  it under the terms of the GNU General Public License as  published by
29//  the Free Software Foundation, either version 3 of the License,  or
30//  (at your option) any later version.
31//
32//  This program is distributed  in the hope that it will be useful,
33//  but WITHOUT ANY WARRANTY; without even  the implied warranty of
34//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
35//  GNU General Public License for more details.
36//
37//  You should  have received a copy of the GNU General Public License
38//  along with this program.  If not, see http://www.gnu.org/licenses/
39
40#include <dcf77.h>
41/*
42const  uint8_t pon_pin  = 51; // connect pon to ground !!!
43const uint8_t data_pin =  19;
44const uint8_t gnd_pin  = 51;
45const uint8_t vcc_pin  = 49;
46*/
47
48const  uint8_t dcf77_analog_samples = false;
49const uint8_t dcf77_analog_sample_pin =  5;
50const uint8_t dcf77_sample_pin = 19; // A5
51const uint8_t dcf77_inverted_samples  = 0;
52#if defined(__AVR__)
53#define ledpin(led) (led)
54#else
55#define ledpin(led)  (led<14? led: led+(54-14))
56#endif
57
58const uint8_t dcf77_monitor_pin = ledpin(18);  // A4
59
60const bool provide_filtered_output = true;
61const uint8_t dcf77_filtered_pin          = ledpin(12);
62const uint8_t dcf77_inverted_filtered_pin = ledpin(11);
63const  uint8_t dcf77_filter_diff_pin       = ledpin(7);
64
65const bool provide_semi_synthesized_output  = true;
66const uint8_t dcf77_semi_synthesized_pin          = ledpin(16);
67const  uint8_t dcf77_inverted_semi_synthesized_pin = ledpin(15);
68const uint8_t dcf77_semi_synthesized_diff_pin     = ledpin(14);
69
70const bool provide_synthesized_output = true;
71const  uint8_t dcf77_synthesized_pin          = ledpin(6);
72const uint8_t dcf77_inverted_synthesized_pin  = ledpin(5);
73const uint8_t dcf77_synthesized_diff_pin     = ledpin(4);
74
75const  uint8_t dcf77_second_pulse_pin = ledpin(10);
76
77
78const uint8_t dcf77_signal_good_indicator_pin  = ledpin(13);
79
80volatile uint16_t ms_counter = 0;
81volatile Internal::DCF77::tick_t  tick = Internal::DCF77::undefined;
82
83
84template <bool enable, uint8_t threshold,
85          uint8_t filtered_pin, uint8_t inverted_filtered_pin, uint8_t diff_pin>
86void  set_output(uint8_t clock_state, uint8_t sampled_data, uint8_t synthesized_signal)
87{
88    if (enable) {
89        const uint8_t filtered_output = clock_state < threshold?  sampled_data: synthesized_signal;
90        digitalWrite(filtered_pin, filtered_output);
91        digitalWrite(inverted_filtered_pin, !filtered_output);
92        digitalWrite(diff_pin,  filtered_output ^ sampled_data);
93    }
94}
95
96namespace {
97    struct  Scope {
98        static const uint16_t samples_per_second = 1000;
99        static  const uint8_t bins                = 100;
100        static const uint8_t samples_per_bin     = samples_per_second / bins;
101
102        volatile uint8_t gbin[bins];
103        volatile boolean samples_pending = false;
104        volatile uint32_t count  = 0;
105
106        void process_one_sample(const uint8_t sample) {
107            static  uint8_t sbin[bins];
108
109            static uint16_t ticks = 999;  // first pass  will init the bins
110            ++ticks;
111
112            if (ticks == 1000)  {
113                ticks = 0;
114                memcpy((void *)gbin, sbin, bins);
115                memset(sbin, 0, bins);
116                samples_pending = true;
117                ++count;
118            }
119            sbin[ticks/samples_per_bin]  += sample;
120        }
121
122        void print() {
123            uint8_t lbin[bins];
124
125            if (samples_pending) {
126                noInterrupts();
127                memcpy(lbin,  (void *)gbin, bins);
128                samples_pending = false;
129                interrupts();
130
131                // ensure the count values will be aligned to the right
132                for  (int32_t val=count; val < 100000000; val *= 10) {
133                    Serial.print('  ');
134                }
135                Serial.print((int32_t)count);
136                Serial.print(",  ");
137                for (uint8_t bin=0; bin<bins; ++bin) {
138                    switch  (lbin[bin]) {
139                        case  0: Serial.print(bin%10? '-': '+');  break;
140                        case 10: Serial.print('X');              break;
141                        default: Serial.print(lbin[bin]);
142                    }
143                }
144                Serial.println();
145            }
146        }
147    };
148}
149
150Scope scope_1;
151Scope scope_2;
152
153uint8_t sample_input_pin()  {
154    const uint8_t clock_state = DCF77_Clock::get_clock_state();
155    const  uint8_t sampled_data =
156        #if defined(__AVR__)
157        dcf77_inverted_samples  ^ (dcf77_analog_samples? (analogRead(dcf77_analog_sample_pin) > 200)
158                                                      :  digitalRead(dcf77_sample_pin));
159        #else
160        dcf77_inverted_samples  ^ digitalRead(dcf77_sample_pin);
161        #endif
162
163    digitalWrite(dcf77_monitor_pin,  sampled_data);
164    digitalWrite(dcf77_second_pulse_pin, ms_counter < 500 && clock_state  >= Clock::locked);
165
166    const uint8_t synthesized_signal =
167        tick  == Internal::DCF77::long_tick  ? ms_counter < 200:
168        tick == Internal::DCF77::short_tick  ? ms_counter < 100:
169        tick == Internal::DCF77::sync_mark  ? 0:
170                                              //  tick == DCF77::undefined --> default handling
171                                              //  allow signal to pass for the first 200ms of each second
172                                              (ms_counter  <=200 && sampled_data) ||
173                                              // if  the clock has valid time data then undefined ticks
174                                              //  are data bits --> first 100ms of signal must be high
175                                              ms_counter  <100;
176
177    set_output<provide_filtered_output, Clock::locked,
178              dcf77_filtered_pin,  dcf77_inverted_filtered_pin, dcf77_filter_diff_pin>
179              (clock_state,  sampled_data, synthesized_signal);
180
181    set_output<provide_semi_synthesized_output,  Clock::unlocked,
182               dcf77_semi_synthesized_pin, dcf77_inverted_semi_synthesized_pin,  dcf77_semi_synthesized_diff_pin>
183               (clock_state, sampled_data, synthesized_signal);
184
185    set_output<provide_synthesized_output, Clock::free,
186               dcf77_synthesized_pin,  dcf77_inverted_synthesized_pin, dcf77_synthesized_diff_pin>
187               (clock_state,  sampled_data, synthesized_signal);
188
189    ms_counter+= (ms_counter < 1000);
190
191    scope_1.process_one_sample(sampled_data);
192    scope_2.process_one_sample(digitalRead(dcf77_synthesized_pin));
193
194    return sampled_data;
195}
196
197
198
199
200void output_handler(const Clock::time_t  &decoded_time) {
201    // reset ms_counter for 1 Hz ticks
202    ms_counter = 0;
203
204    // status indicator --> always on if signal is good
205    //                      blink  3s on 1s off if signal is poor
206    //                      blink 1s on 3s off  if signal is very poor
207    //                      always off if signal is bad
208    const uint8_t clock_state = DCF77_Clock::get_clock_state();
209    digitalWrite(dcf77_signal_good_indicator_pin,
210                 clock_state >= Clock::locked  ? 1:
211                 clock_state  == Clock::unlocked? (decoded_time.second.digit.lo & 0x03) != 0:
212                 clock_state  == Clock::free    ? (decoded_time.second.digit.lo & 0x03) == 0:
213                                                  0);
214    // compute output for signal synthesis
215    Internal::DCF77_Encoder now;
216    now.second                    = BCD::bcd_to_int(decoded_time.second);
217    now.minute                    = decoded_time.minute;
218    now.hour                      =  decoded_time.hour;
219    now.weekday                   = decoded_time.weekday;
220    now.day                       = decoded_time.day;
221    now.month                     =  decoded_time.month;
222    now.year                      = decoded_time.year;
223    now.uses_summertime           = decoded_time.uses_summertime;
224    now.leap_second_scheduled     = decoded_time.leap_second_scheduled;
225    now.timezone_change_scheduled  = decoded_time.timezone_change_scheduled;
226
227    now.undefined_minute_output                         = false;
228    now.undefined_uses_summertime_output                =  false;
229    now.undefined_abnormal_transmitter_operation_output = false;
230    now.undefined_timezone_change_scheduled_output      = false;
231
232    now.advance_minute();
233    tick = now.get_current_signal();
234}
235
236void  setup_serial() {
237    Serial.begin(115200);
238}
239
240void output_splash_screen()  {
241    Serial.println();
242    Serial.println(F("DCF77 Superfilter 3.0"));
243    Serial.println(F("(c) 2015 Udo Klein"));
244    Serial.println(F("www.blinkenlight.net"));
245    Serial.println();
246    Serial.print(F("Sample Pin:               ")); Serial.println(dcf77_sample_pin);
247    Serial.print(F("Inverted Mode:            ")); Serial.println(dcf77_inverted_samples);
248    #if defined(__AVR__)
249    Serial.print(F("Analog Mode:              "));  Serial.println(dcf77_analog_samples);
250    #endif
251    Serial.print(F("Monitor  Pin:              ")); Serial.println(dcf77_monitor_pin);
252    Serial.println();
253
254    if (provide_filtered_output) {
255        Serial.println(F("Filtered Output"));
256        Serial.print(F("    Filtered Pin:         ")); Serial.println(dcf77_filtered_pin);
257        Serial.print(F("    Diff Pin:             ")); Serial.println(dcf77_filter_diff_pin);
258        Serial.print(F("    Inverse Filtered Pin: ")); Serial.println(dcf77_inverted_filtered_pin);
259        Serial.println();
260    }
261
262    if (provide_semi_synthesized_output)  {
263        Serial.println(F("Semi Synthesized Output"));
264        Serial.print(F("    Filtered Pin:         ")); Serial.println(dcf77_semi_synthesized_pin);
265        Serial.print(F("    Diff Pin:             ")); Serial.println(dcf77_semi_synthesized_diff_pin);
266        Serial.print(F("    Inverse Filtered Pin: ")); Serial.println(dcf77_inverted_semi_synthesized_pin);
267        Serial.println();
268    }
269
270    if (provide_synthesized_output) {
271        Serial.println(F("Synthesized Output"));
272        Serial.print(F("    Filtered Pin:         ")); Serial.println(dcf77_synthesized_pin);
273        Serial.print(F("    Diff Pin:             ")); Serial.println(dcf77_synthesized_diff_pin);
274        Serial.print(F("    Inverse Filtered Pin: ")); Serial.println(dcf77_inverted_synthesized_pin);
275        Serial.println();
276    }
277
278    Serial.print(F("Second Pulse Pin:         ")); Serial.println(dcf77_second_pulse_pin);
279    Serial.print(F("Signal  Good Pin:          ")); Serial.println(dcf77_signal_good_indicator_pin);
280
281    Serial.println();
282
283    Serial.println();
284    Serial.println(F("Initializing..."));
285    Serial.println();
286};
287
288void setup_pins() {
289    if (provide_filtered_output)  {
290        pinMode(dcf77_filtered_pin, OUTPUT);
291        pinMode(dcf77_filter_diff_pin,  OUTPUT);
292        pinMode(dcf77_inverted_filtered_pin, OUTPUT);
293    }
294
295    if (provide_semi_synthesized_output) {
296        pinMode(dcf77_semi_synthesized_pin,  OUTPUT);
297        pinMode(dcf77_semi_synthesized_diff_pin, OUTPUT);
298        pinMode(dcf77_inverted_semi_synthesized_pin,  OUTPUT);
299    }
300
301    if (provide_synthesized_output) {
302        pinMode(dcf77_synthesized_pin,  OUTPUT);
303        pinMode(dcf77_synthesized_diff_pin, OUTPUT);
304        pinMode(dcf77_inverted_synthesized_pin,  OUTPUT);
305    }
306
307    pinMode(dcf77_monitor_pin, OUTPUT);
308    pinMode(dcf77_signal_good_indicator_pin,  OUTPUT);
309    pinMode(dcf77_second_pulse_pin, OUTPUT);
310    pinMode(dcf77_sample_pin,  INPUT);
311    digitalWrite(dcf77_sample_pin, HIGH);
312}
313
314void setup_clock()  {
315    DCF77_Clock::setup();
316    DCF77_Clock::set_input_provider(sample_input_pin);
317    DCF77_Clock::set_output_handler(output_handler);
318}
319
320void setup() {
321    setup_serial();
322    output_splash_screen();
323    setup_pins();
324    setup_clock();
325/*
326    pinMode(gnd_pin, OUTPUT);
327    digitalWrite(gnd_pin, LOW);
328    pinMode(pon_pin,  OUTPUT);
329    digitalWrite(pon_pin, LOW);
330    pinMode(vcc_pin, OUTPUT);
331    digitalWrite(vcc_pin, HIGH);
332    */
333}
334
335void loop() {
336    Clock::time_t  now;
337    DCF77_Clock::get_current_time(now);
338
339    if (now.month.val > 0)  {
340        Serial.println();
341        Serial.print(F("Decoded time: "));
342
343        DCF77_Clock::print(now);
344        Serial.println();
345    }
346
347    Serial.print(DCF77_Clock::get_clock_state());
348    Serial.print(' ');
349    DCF77_Clock::debug();
350
351    scope_1.print();
352    scope_2.print();
353}
354

1/*
2 ================================================================================
3  DCF77 Analyzer / Clock version 2
4 ================================================================================
5  This sketch is free software; you can redistribute it and/or
6 modify it under  the terms of the GNU Lesser General Public
7 License as published by the Free  Software Foundation; either
8 version 2.1 of the License, or (at your option)  any later version.
9 
10 This sketch is distributed in the hope that it will  be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 Lesser General  Public License for more details.
14 
15 You should have received a copy of the  GNU Lesser General Public
16 License along with this library; if not, write to  the Free Software
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18 ================================================================================
19
20  This C++ code is far from optimized because I myself am an Arduino and C++ novice.
21  But even after learning some more now, I want to keep the code simpel and readable.
22  That is why I maybe over-documented the code to help understand what's going on.
23
24  Erik de Ruiter
25 2014-2020
26   
27 
28
29 May 2014 First version
30 March  2016 - big overhaul...
31 July 2016 - Start with building the 2.0 Clock and adapting  the sketch
32
33 Version 2.1 date 2020-01-18
34 - Powersafe function fixed. 
35
36  Version 2.0
37 - This sketch is adapted for my 2.0 version of the DCF/Analyzer  Clock. It used the Arduino MEGA and the DCF Superfilter
38   by default and to  drive the many seperate LED's I now use the ports of an Arduino Mega instead of  a Maxim 7219 chip. 
39   This is because driving LED's with many different Voltage/Current  specs is problematic with the Maxim chip. 
40   Lighting additional LED's for expample  will influence (dim) the LED's already on. As I'm not an electronics engineer
41   my only solution was to use the extra ports of the Arduino Mega. Ofcourse you  can use transistors or extra chips to
42   drive the LED's but for me this was  the obvious solution.
43 - Removed all the Maxim Common Anode display code
44                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
45
46  Version 1.72
47 - Option: Use a cheap Ebay PIR detector to shut off selectable  display's when no activity is detected. 
48   The switch off delay can be set by  the user to prevent the display shutting of if a person
49   is not moving but  the display should be on.
50 - Now the display Night shut-down can be disabled  by making both values 'POWERSAVINGOFFTIME'
51   and 'POWERSAVINGONTIME' zero. 
52  - Fixed temperature display not shutting off at powersave mode.  
53 - errorCounter  display did not reset every hour -fixed
54
55 Version 1.71
56 - User option to  reset temperature min/max memory at midnight
57
58 Version 1.7:
59 - The resolution  of the temperature display is improved: from 0.5 to 0.1 degrees Celsius
60   Because  of the time the DS18B20 sensor needs to convert the temperature and to keep the  code clean, 
61   the temperature display is updates once per minute.
62 - Parity  check routine optimized. 
63 - More reliable check for bad DCF data, preventing  RTC update with invalid data.
64 - EoB error now clears inner LED ring as it should.
65  - The DCF OK LED now displays the condition of the DCF signal more reliably. Turns  off immediately if an error occurs
66   and only turns ON when all 3 parity bits  are OK.
67
68 Version 1.6:
69 - Changed temperature function to only calculate  once per minute. Got strange errors before the change because
70   I used a delay  of 100ms to give the DS18B20 sensor time to calculate the temperature. But the delay  function is
71   a very bad idea in most c++ code so I finally got rid of it.
72
73  Version 1.5:
74 - Complete overhaul of the scanSignal function and the rest of  the code! My first attempt worked but could be improved...
75 - The rPW and rPT  led's did not work as I intended so that is corrected now.
76 - The End of Buffer  error check routine does work now as it should.
77 - I incorporated a Parity check  of the incoming DCF signal. In the signal 3 Parity bits are sent so now these are
78   checked and only if all three are OK, the received time information is accepted,  the display is updated and the RTC synced.
79   if desired, you can attach 3 extra  dual-color LED's (Common Cathode) to see if each of the 3 Parity bits are OK or  Failed.
80 - I made wiring (or changing the wiring) much easier I think by putting  all the PIN config in one easy to read table
81 - As long as you use 1 DS18B20  temp. sensor, I edited the code so you no longer need to figure out the address  of the I2C device.
82 - Big clean-up of the code...
83 - Powersaving by shutting  off the displays (the clock remains functioning as normal)
84   can now be configured  somewhat easier by editing two variables POWERSAVINGONTIME and POWERSAVINGOFFTIME.
85  - changed some variable names:
86   - Maxim instances 'lc' and 'lc1' are now MaximCC  and MaximCA
87   - Display description MaximDcfTime is now DisplayTempWeek 
88   - DCF77SOUNDPIN is now BUZZERSWITCHPIN
89 - LED/Display test after power up  now build in
90 
91
92
93  Short description:
94   
95  Power On:
96    After  power-on, first a LED test is performed. The LED's and displays lite up sequentially  to keep the power consumption low.
97    Then the clock starts receiving DCF pulses  and when a Minute Mark (2 seconds gap) is detected, the Minute Marker LED is lit
98    and the buffer counter is reset. The inner LED ring now will show the incoming  DCF pulses which are also stored in the buffer.
99    At 3 moments during reception  of data the parity DCF bits are checked to see if the data is valid.
100
101  Valid  data received:
102    When, at the end of the minute, after the Minute Mark is detected  (BF (Buffer Full) LED is lit), all three parity bits are OK
103    ('DCF OK' LED  is lit), the buffer information is used to extract time and date information. 
104    Then the RTC clock is updated ('RTC Synced' LED is lit) and the inner LED ring  information is copied to the outer LED ring. 
105    The time, date and week display,  day LED, summer/wintertime and leap year LED information is updated with the new  time information.
106
107  No valid data:
108    When one or more of the parity  bits are not OK because of a noisy signal, receiving of DCF information is continued  but
109    will not be used to update the RTC, display's and LED's. The outer LED  ring, 'RTC synced' and 'DCF OK' LED's will be reset. 
110    Time, date, week, day  LED, summer/wintertime LED and leap year LED are not affected and keep displaying  the last received valid values.
111    The 'Period Time' and/or 'Period With' error  LED's will indicate the error(s) and the error counter display is updated. 
112    Every hour, the error display will bet set to zero. 
113    The EoB, End of  Buffer LED is lit when more DCF pulses are received before the Minute Mark is detected  due to a noisy signal.
114    (When a minute Mark is detected we should have no  more than 58 bits/pulses) 
115    After the detection of the Minute Marker, a new  cycle is started.
116 
117  Temperature:
118    At the 30 second mark, the temperature  display will show the High and Low values of the past period after the last reset.
119  
120  Chime:
121    If the CHIME switch is ON/HIGH, then at the beginning of each  hour, the Chime (if connected) will sound
122    At night time, a time set by the  user in the code itself, the chime is disabled.
123
124  Power saving - display's  shut off
125    This will only work IF the Power Save switch is HIGH:
126    1.  NIGHT SHUT OFF
127       At times set by the user, the displays are shutt off at  night and turned on in the morning.
128       Look at the POWERSAVINGOFFTIME and  POWERSAVINGONTIME variables. 
129       Check the function <turnDisplaysOff> to  select WHICH displays you want to shut off at night.
130    2. PIR SENSOR
131       Connect  a PIR sensor and activate the PIR option POWERSAVE_BY_PIR and the the delay at PIR_DELAY_TIME.
132       Every time the PIR detector senses movement, a minute counter is reset but  if no movement is detected
133       longer than the PIR_DELAY_TIME, the displays  are shut off. 
134       When movement occurs, the displays immediately switch on.  
135    Note: as said before, the clock will function normally while the displays  are shut off. 
136
137  DCF beep:
138    With a switch, connected to pin BUZZERSWITCHPIN,  you can hear the received DCF bits coming in. 
139    The tone duration is equivalent  to pulse width of the DCF bits, so either 100 or 200 ms.
140  
141  Miscelleanous:
142    When the RTC battery is empty or a connection fault is detected, the RTC Error  LED is lit.
143
144
145
146
147 CREDITS:
148 I learned a lot from the work of Matthias  Dalheimer and Thijs Elenbaas who made their own DCF77 decoders.
149 Without their  work I would not have known where to start.
150 I ended up writing my own code (using  bits and pieces of their ideas) so I could understand what is happening...
151 My  code is far from efficient or advanced but it does work and I know what is going  on.
152 
153  Interesting websites:
154
155 - Brett Oliver         : http://home.btconnect.com/brettoliver1/
156  - Joop Tap             : http://www.jooptap.nl
157 - Thijs Ellenbaas      : http://thijs.elenbaas.net/2012/04/arduino-dcf77-radio-clock-receiver-hardware-2/
158  - Mathias Dalheimer    : https://github.com/roddi/DCF77-Arduino/blob/master/DCF77Servoclock/DCF77.h
159  - DCF77 wikipedia      : https://en.wikipedia.org/wiki/DCF77
160 - Much more DCF77  info : http://www.picbasic.nl/indexes_uk.htm
161
162 - My Flickr website    : https://www.flickr.com/photos/edr1924/albums
163  - My Github website    : https://github.com/deruiter
164 
165 */
166
167//----------------------------------------------------------------------------------------------------------
168//  Libraries
169//----------------------------------------------------------------------------------------------------------
170
171//  Arduino (new) Time library .................................... http://www.pjrc.com/teensy/td_libs_Time.html
172#include  <Time.h>
173
174// Enable this line if using Arduino Uno, Mega, etc.
175#include  <Wire.h>
176
177// a basic DS1307 library that returns time as a time_t ..........  http://www.pjrc.com/teensy/td_libs_DS1307RTC.html
178#include <DS1307RTC.h>
179
180//  Maxim 7219 displays library ................................... http://playground.arduino.cc/Main/LEDMatrix
181//  !!! NOTE: you must use a special version of the Ledcontrol.h library to get Common  Anode support
182// because the Maxim chip is normally only suitable for common  CATHODE displays!
183#include <LedControl.h>
184
185//SPI interface library ..........................................  http://arduino.cc/en/Reference/SPI
186#include <SPI.h>
187
188// OneWire lets you  access 1-wire devices made by Maxim/Dallas,
189// such as DS18S20, DS18B20, DS1822  .............................. http://www.pjrc.com/teensy/td_libs_OneWire.html
190//  The DallasTemperature library can do all this work for you! ... http://milesburton.com/Dallas_Temperature_Control_Library
191#include  <OneWire.h>
192
193//----------------------------------------------------------------------------------------------------------
194//  Arduino UNO Pin connections in an easy to read table
195//
196// input  - Rx - used  for programming/communication with PC
197// output - Tx - used for programming/communication  with PC
198#define DCF77PIN 2           // input  - DCF signal from antenna pcb.  Pin must an interrupt input!
199#define PIRDETECTORPIN 3     // input  - PIR detector:  check for activity in the room to activate displays
200#define BUZZERSWITCHPIN 4    // input  - SWITCH - turn on/off DCF77 'beep' piezo buzzer / ON = HIGH, OFF  = LOW
201#define CHIMESWITCHPIN 5     // input  - SWITCH - turn on/off the hourly  chime sound / ON = HIGH, OFF = LOW
202#define POWERSAVESWITCHPIN 6 // input  - SWITCH  - turn on/off the power save feature so display is always on / ON = HIGH, OFF =  LOW
203#define TEMPSENSORPIN 8      // input  - Dallas One Wire DS18B20 temperature  sensor
204#define TEMPRESETPIN 9       // input  - PUSH BUTTON - reset temperature  min/max memory / HIGH = reset
205#define MAXIMCCLD 10         // output - CS/LOAD  - pseudo SPI connection to the Maxim 7219 chip - 7 segment displays
206#define MAXIMCCCLK  11        // output - CLOCK   - pseudo SPI connection to the Maxim 7219 chip - 7  segment displays
207#define MAXIMCCDATA 12       // output - DATA    - pseudo SPI  connection to the Maxim 7219 chip - 7 segment displays
208// !! Pins 22 through  53 are only to be used for LED's
209#define LED_SUNDAY 22         // output - LED  - Sunday
210#define LED_MONDAY 23         // output - LED - Monday
211#define LED_TUESDAY  24        // output - LED - Tuesday
212#define LED_WEDNESDAY 25      // output -  LED - Wednesday
213#define LED_THURSDAY 26       // output - LED - Thursday
214#define  LED_FRIDAY 27         // output - LED - Friday
215#define LED_SATURDAY 28       //  output - LED - Saturday
216#define LED_CEST 29           // output - LED - Summertime  CEST
217#define LED_CET 30            // output - LED - Wintertime CET
218#define  LED_LEAPYEAR 31       // output - LED - Leap year
219#define LED_RTCERROR 32       //  output - LED - problem reading RTC data (empty battery/connection)
220#define LED_RTCSYNC  33        // output - LED - On when RTC is succesfully synced with the DCF time
221#define  LED_TEMP 34           // output - LED - temperature is displayed
222#define LED_OPTION1  35        // output - LED - optional 1 data is displayed
223#define LED_OPTION2  36        // output - LED - optional 2 data is displayed
224#define LED_ERRORPT  37        // output - LED - DCF Period Time error
225#define LED_ERRORPW 38        //  output - LED - DCF Period Width error
226#define LED_BUFFERFULL 39     // output  - LED - Buffer full indicator, next the data will be analized
227#define LED_MINUTEMARKER  40   // output - LED - End of DCF data stream detected before buffer is filled,  data is corrupt
228#define LED_BUFFEROVERFLOW 41 // output - LED - More data received  in one minute than expected due to bad signal
229#define LED_DCFSTATUS 42      //  output - LED - On when we have good DCF data
230#define LED_POWERSAVE 43      //  output - LED - Power save mode is activated, some displays are off
231#define LED_PARITY1PASS  44    // output - LED - Parity 1 bit is OK
232#define LED_PARITY1FAIL 45    // output  - LED - Parity 1 bit FAILED
233#define LED_PARITY2PASS 46    // output - LED - Parity  2 bit is OK
234#define LED_PARITY2FAIL 47    // output - LED - Parity 2 bit FAILED
235#define  LED_PARITY3PASS 48    // output - LED - Parity 3 bit is OK
236#define LED_PARITY3FAIL  49    // output - LED - Parity 3 bit FAILED
237#define LED_PIRMOTION 50      //  output - LED - On when PIR is detecting motion
238
239// Analog pins
240#define  BUZZER A7        // output - Piezo buzzer for DCF77 'beep' (to '+' of the buzzer)
241#define  SPEAKERVOLPIN A6 // output - Sound Board volume - LOW = volume one notch lower.  SPEAKERVOLUME determines how many times this output is activated after power on
242#define  CHIMEPIN A5      // output - Chime Activate - OUTPUT LOW = Activate Chime on Adafruit  Soundboard FX
243// USED for DS1307 RTC   // I2C DATA  - connect to Real Time Clock  pcb
244// USED for DS1307 RTC   // I2C CLOCK - connect to Real Time Clock pcb
245
246//----------------------------------------------------------------------------------------------------------
247//  DS18B20 initialization
248//----------------------------------------------------------------------------------------------------------
249OneWire  ds(TEMPSENSORPIN); // define Onewire instance DS
250
251//----------------------------------------------------------------------------------------------------------
252//  Maxim 7219 Matrix Display initialization
253//----------------------------------------------------------------------------------------------------------
254/*
255  clearDisplay(int addr) ............................................. clears the  selected display
256 MaximCC.shutdown(int addr, boolean) ................................  wake up the MAX72XX from power-saving mode (true = sleep, false = awake)
257 MaximCC.setIntensity(int  addr, value) .............................. set a medium brightness for the Leds  (0=min - 15=max)
258 MaximCC.setLed(int addr, int row, int col, boolean state) ..........  switch on the led in row, column. remember that indices start at 0!
259 MaximCC.setRow(int  addr, int row, byte value) ...................... this function takes 3 arguments.  example: MaximCC.setRow(0,2,B10110000);
260 MaximCC.setColumn(int addr, int col,  byte value) ................... this function takes 3 arguments. example: MaximCC.setColumn(0,5,B00001111);
261  MaximCC.setDigit(int addr, int digit, byte value, boolean dp) ...... this function  takes an argument of type byte and prints the corresponding digit on the specified  column.
262                                                                      The  range of valid values runs from 0..15. All values between 0..9 are printed as digits,
263                                                                      values between  10..15 are printed as their hexadecimal equivalent
264 MaximCC.setChar(int addr,  int digit, char value, boolean dp) ....... will display: 0 1 2 3 4 5 6 7 8 9 A B  C D E F H L P; - . , _ <SPACE> (the blank or space char)
265 POWERSAVESWITCHPIN
266  ***** Please set the number of devices you have *****
267 But the maximum default  of 8 MAX72XX wil also work.
268 LedConrol(DATAIN, CLOCK, CS/LOAD, NUMBER OF MAXIM  CHIPS)
269 */
270
271// lc is for the Maxim displays
272LedControl MaximCC = LedControl(MAXIMCCDATA,  MAXIMCCCLK, MAXIMCCLD, 7, false); // Define pins for Maxim 72xx and how many 72xx  we use
273
274//----------------------------------------------------------------------------------------------------------
275//  User settings, variable and array definitions
276//----------------------------------------------------------------------------------------------------------
277
278//  The value below is not a PIN number but a value to set how many times the 'Lower  volume' input on the sound board is activated
279// so that way the volume of the  sound board can be lowered after power up, if desired.
280#define SPEAKERVOLUME  12
281
282// Choose if you want a test of all LED's and Displays after a startup
283//  '1' = Yes, '0' = No
284#define PERFORM_LED_TEST 1
285// Delay between each 7 segment  display in ms
286#define LEDTEST_DELAY_DISPLAYS 600
287// Delay between each LED  in the LED ring and other LED's in ms
288#define LEDTEST_DELAY_LED_RING 20
289
290//  Choose if you want to configure the DS18B20 temperature sensor ONCE to the highest  resolution.
291// this is needed after using the sensor for the first time. After  running the software
292// with this setting ON one time, shut it off.
293// '1'  = ON, '0' = OFF
294#define CONFIGURE_DS18B20 0
295
296// POWERSAVE TIME - MANDATORY  values!
297//
298// to define day and night time. This is used for power saving  display ON and OFF time
299// AND to determine if the chime will be activated (during  the daytime).
300//
301// ONLY the displays are shut off at power saving time, the  clock remains fully active.
302// TO DISABLE the display power-off at any time,  simply set the Power-save switch to OFF
303//
304// Power save switch ON: displays  will be shutt OFF at the set night time 
305//                       AND if POWERSAVE_BY_PIR  function if activated and there is no 
306//                       movement for  the set PIR_DELAY_TIME.
307// Power save switch OFF: displays always on, chime only  at daytime.
308//
309// values are in 'Hour' format, so 8PM will be '20', NOT 20:00  or 8PM...
310#define POWERSAVINGOFFTIME 9 // displays are activated
311#define POWERSAVINGONTIME  22  // displays are shutt off
312
313// User option: activate the displays only  when there is activity in the room
314// '1' = ON, '0' = OFF
315#define POWERSAVE_BY_PIR  1
316// delay in MINUTES to wait after no detection before shutting off the displays
317#define  PIR_DELAY_TIME 30
318
319// User option to reset temperature min/max memory at midnight
320//  '1' = Reset at midnight, '0' = Only manual reset
321#define TEMPRESET_MIDNIGHT 1
322
323//-------------------------------------------------------------------------------
324//  define miscellaneous parameters
325#define DS1307_I2C_ADDRESS 0x68 // define the  RTC I2C address
326#define DCF_INTERRUPT 0         // Interrupt number associated  with pin
327
328// definition of Maxim 7219 display number wiring sequence
329//  first Maxim 7219 in wiring 'daisychain' must be '0', next '1' etc.
330// COMMON  CATHODE DISPLAYS
331#define LedRingInner 0
332#define LedRingOuter 1
333#define  DisplayBufferBitError 2
334#define DisplayPeriodPulse 3
335#define DisplayTempWeek  4
336#define DisplayDate 5
337#define DisplayTime 6
338
339// definition of display  brighness levels
340#define BrightnessLedRingOuter 1
341#define BrightnessLedRingInner  1
342#define BrightnessDisplayTime 1
343#define BrightnessDisplayDate 7
344#define  BrightnessDisplayTempWeek 15
345#define BrightnessDisplayPeriodPulse 2
346#define  BrightnessDisplayBufferBitError 15
347
348// Pulse flanks
349static unsigned long  leadingEdge = 0;
350static unsigned long trailingEdge = 0;
351unsigned long previousLeadingEdge  = 0;
352
353// used in <Int0handler>
354volatile unsigned int DCFSignalState = 0;  // interrupt variables ALWAYS need volatile qualifier!!
355
356// used in <loop>
357int  previousSecond = 0;
358unsigned int previousSignalState = 0;
359
360// DCF Buffers  and indicators
361static int DCFbitBuffer[59];                         // here,  the received DCFbits are stored
362const int bitValue[] = {1, 2, 4, 8, 10, 20, 40,  80}; // these are the decimal values of the received DCFbits
363
364// only after  start on a new minute, display received bits on inner LED ring
365boolean MinuteMarkerFlag  = false;
366int bufferPosition = 0;
367int previousMinute = 0;
368int previousHour  = 0;
369
370// variables to check if DCF bits are vald
371bool dcfValidSignal =  false;
372int dcfP1counter = 0;
373int dcfP2counter = 0;
374int dcfP3counter = 0;
375int  dcfParityCheckP1 = 0;
376int dcfParityCheckP2 = 0;
377int dcfParityCheckP3 = 0;
378
379//  dcf variables to store decoded DCF time in
380int dcfMinute = 0;
381int dcfHour  = 0;
382int dcfDay = 0;
383int dcfWeekDay = 0;
384int dcfMonth = 0;
385int dcfYear  = 0;
386int dcfDST = 0;
387int leapYear = 0;
388
389// variables used to store weeknumber  and daynumer values
390int dayNumber;
391int weekNumber;
392
393// error counter  variable
394int errorCounter = 0;
395boolean errorCondition = false;
396
397// miscelleanous  variables
398boolean daytimeChange = true;
399boolean dayTime = false;
400int dcf77SoundSwitch  = 0;
401
402// temperature variables
403byte present = 0;
404byte DS18B20Data[12];
405int  maxTemp = 0;
406int minTemp = 0;
407int lowByte = 0;
408int highByte = 0;
409float  tempReading = 0;
410int tempCelsius = 0;
411boolean tempResetButton = false;
412
413//  PIR detector variables
414int pirActivity = 0;
415int pirDisplaysState = 1;
416unsigned  int pirTimer = 0;
417unsigned long previousTimePIR = 0;
418
419//==============================================================================
420//  SETUP
421//==============================================================================
422void  setup()
423{
424  // initialize Serial communication
425  Serial.begin(9600);
426
427  // initialize PIN connections
428  pinMode(DCF77PIN, INPUT);
429  pinMode(TEMPRESETPIN,  INPUT);
430  pinMode(BUZZERSWITCHPIN, INPUT);
431  pinMode(CHIMESWITCHPIN, INPUT);
432  pinMode(POWERSAVESWITCHPIN, INPUT);
433  pinMode(PIRDETECTORPIN, INPUT);
434  pinMode(CHIMEPIN,  OUTPUT);
435  pinMode(SPEAKERVOLPIN, OUTPUT);
436  // initialize LED pins 22 - 50
437  for (int i1 = 22; i1 <= 50; i1++)
438  {
439    pinMode(i1, OUTPUT);
440  }
441
442  // Initialize variables, LED displays and LED's
443  initialize();
444
445  //  Initialize DCF77 pulse interrupt on pin DCF_INTERRUPT, looking for a change of the  signal,
446  // so either rising or falling edge pulses will trigger the interrupt  handler and
447  // execute the int0handler function.
448  attachInterrupt(DCF_INTERRUPT,  int0handler, CHANGE);
449
450  // Initialize RTC and set as SyncProvider.
451  //  Later RTC will be synced with DCF time
452  setSyncProvider(RTC.get); // the function  to get the time from the RTC
453  // check if RTC has set the system time
454  if  (timeStatus() != timeSet)
455  { // Unable to sync with the RTC - activate RTCError  LED
456    digitalWrite(LED_RTCERROR, HIGH);
457  }
458  else
459  {
460    // RTC  has set the system time - dim RTCError LED
461    digitalWrite(LED_RTCERROR, LOW);
462  }
463
464  // After power on, set the speaker volume of the Adafruit Audio Board
465  // initialize both pins to LOW which is the default output state
466  digitalWrite(SPEAKERVOLPIN,  LOW);
467  digitalWrite(CHIMEPIN, LOW);
468
469  // lower soundboard default volume  with 'SPEAKERVOLUME' steps
470  for (int i = 0; i <= SPEAKERVOLUME; i++)
471  {
472    digitalWrite(SPEAKERVOLPIN, HIGH);
473    delay(100);
474    digitalWrite(SPEAKERVOLPIN,  LOW);
475    delay(100);
476  }
477
478  // The following function should run only  once.
479  // It is used to configure the temperature resolution of the DS18B20  sensor
480  if (CONFIGURE_DS18B20 == 1)
481  {
482    configureDS18B20();
483  }
484
485  // use for test purposes and/or setting the RTC time manually
486  // setTime(23,  59, 40, 31, 12, 13);
487  // RTC.set(now());
488
489  // Request the temperature  conversion
490  calculateTemp();
491
492  // check if a LED test is needed
493  if  (PERFORM_LED_TEST == 1)
494  {
495    // do a LED test
496    ledTest();
497  }
498  else
499  {
500    // if not doing a LED test, we need to wait a bit for the DS18B20  sensor to get ready
501    delay(750);
502  }
503
504  // Now get the temperature  from the sensor and display it
505  displayTemp();
506
507  // activate errorCounter  display after LED test
508  ledDisplay(DisplayBufferBitError, "R", 0);
509}
510
511//==============================================================================
512//  LOOP
513//==============================================================================
514void  loop()
515{
516  // check first if pulse direction is changed (rising or falling)
517  // else we would keep evaluating the same pulse
518  if (DCFSignalState != previousSignalState)
519  {
520    // 'reset' state of variable
521    previousSignalState = DCFSignalState;
522
523    // evaluate incoming pulse
524    scanSignal();
525  }
526
527  // check if  switches are changed and act upon it
528  checkSwitches();
529
530  // check for  PIR movement
531  checkPIR();
532
533  // execute tasks that must happen only once  every second, minute or hour
534  //----------------------------------------------------------------------------
535  tasksEverySecond();
536  tasksEveryMinute();
537  tasksEveryHour();
538}
539
540//================================================================================================================
541//
542//  Function name : processDcfBit
543// called from   : <scanSignal>
544//
545// Purpose       : Evaluates the signal as it is received. Decides whether we received a "1"  or a "0"
546//                 and perform checks to see if the pulse timing is  within limits
547// Parameters    : none
548// Return value  : none
549//
550//================================================================================================================
551/*
552       pulse                 pulse
553       width                 width
554       |-  -|               |--   --|           |----- END OF MINUTE marker:2000ms -----|
555        ___                 _______             ___                                     ___                 _______
556       | 0 |               |   1   |           | 0 |                                   | 0 |               |   1   |
557       |   |               |       |           |   |                                   |   |               |       |
558       |   |               |       |           |   |                                   |   |               |       |
559 ______|   |_______________|       |___________|   |___________________________________|   |_______________|       |__ _ _ _
560       ^   ^               ^       ^           ^   ^               ^                   ^   ^               ^       ^
561       1000 2100           2000    2200        3000 3100         NO PULSE              5000 5100           6000    6200         << example millis() value
562                                                                 =  end of Minute indication
563       ^                   ^                   ^                                       ^                   ^
564       DCFbit# 56          DCFbit# 57          DCFbit# 58                               DCFbit# 0           DCFbit# 1  etc...   << DCF bit  received
565       
566       ^                   ^        ^
567       previous            leading  trailing
568       leading edge        edge     edge
569       
570       ^   ^
571       flanktime (rising or falling)
572 
573 */
574
575void scanSignal()
576{
577  //--------------------------------------------------------------------
578  //  Check for Rising-Edge signal and perform checks
579  //--------------------------------------------------------------------
580  if (DCFSignalState == 1)
581  {
582    // store Rising-Edge Time to check later  if the time between two pulses is valid
583    leadingEdge = millis();
584    //  not much to do now so exit.
585    return;
586  }
587
588  //--------------------------------------------------------------------
589  // Check for Falling-Edge signal and perform checks
590  //--------------------------------------------------------------------
591
592  if (DCFSignalState == 0)
593  {
594    // store Trailing-Edge Time to check later  if the Pulse Width is valid
595    trailingEdge = millis();
596
597    // display  period width time on "L"eft side of the 8 digit Maxim 72xx LED display
598    ledDisplay(DisplayPeriodPulse,  "L", (leadingEdge - previousLeadingEdge));
599    // display pulse width time  on the "R"ight side of the 8 digit Maxim 72xx LED display
600    ledDisplay(DisplayPeriodPulse,  "R", (trailingEdge - leadingEdge));
601
602    //--------------------------------------------------------------------------------
603    // Check PERIOD TIME
604    //--------------------------------------------------------------------------------
605    // If this flank UP is detected quickly after previous flank UP this is an incorrect
606    // Period Time (should be 1000ms -or 2000ms after second 58-) that we shall  reject
607    if ((leadingEdge - previousLeadingEdge) < 900)
608    {
609      //  rPW - ERROR: Periode Time (rising flank to rising flank) time is too short -> REJECTED
610      error(LED_ERRORPW);
611      errorCondition = true;
612    }
613    //--------------------------------------------------------------------------------
614    // CHECK PULSE TIME
615    //--------------------------------------------------------------------------------
616    // If the detected pulse is too short it will be an incorrect pulse that we  shall reject
617    // should be 100 and 200 ms ideally
618    if (((trailingEdge  - leadingEdge) < 70) || ((trailingEdge - leadingEdge) > 230))
619    {
620      //rPT  - ERROR: Pulse Width too short or too long -> REJECTED
621      error(LED_ERRORPT);
622      errorCondition = true;
623    }
624
625    // if we had an error return and  start over
626    if (errorCondition == true)
627    {
628      errorCondition =  false;
629      // although we have an error, store current rising edge time to  compare at the next Rising-Edge.
630      previousLeadingEdge = leadingEdge;
631      return;
632    }
633
634    //--------------------------------------------------------------------
635    // no errors found so now we can continue
636    //--------------------------------------------------------------------
637
638    // first we turn any error Led's OFF
639    digitalWrite(LED_ERRORPW, LOW);
640    digitalWrite(LED_ERRORPT, LOW);
641    digitalWrite(LED_BUFFERFULL, LOW);     //  previous BF
642    digitalWrite(LED_BUFFEROVERFLOW, LOW); // previous EoB
643    digitalWrite(LED_MINUTEMARKER,  LOW);   // previous EoM
644
645    // END OF MINUTE check, looking for a gap of  approx. 2000ms
646    if (leadingEdge - previousLeadingEdge > 1900 && leadingEdge  - previousLeadingEdge < 2100)
647    {
648      // end of minute detected:
649      finalizeBuffer();
650    }
651
652    // refresh previousLeadingEdge time with the new leading edge time
653    previousLeadingEdge = leadingEdge;
654
655    //--------------------------------------------------------------------------------
656    // process DCF bits
657    //--------------------------------------------------------------------------------
658    // distinguish between long and short pulses
659    if (trailingEdge - leadingEdge  < 170)
660    {
661      // call processDcfBit function and sent it the value '0'
662      processDcfBit(0);
663      // if switch is HIGH, the DCF pulses are audible
664      if (dcf77SoundSwitch == 1)
665        buzzer(100);
666    }
667    else
668    {
669      // call processDcfBit function and sent it the value '1'
670      processDcfBit(1);
671      // if switch is HIGH, the DCF pulses are audible
672      if (dcf77SoundSwitch  == 1)
673        buzzer(200);
674    }
675  } // if (DCFSignalState == 0)
676} //  void scanSignal();
677
678//================================================================================================================
679//
680//  Function name : processDcfBit
681// called from   : <scanSignal>
682//
683// Purpose       : after reception of one good DCF bit, do some checks and save it in the  DCFbitBuffer array
684// Parameters    : none
685// Return value  : none
686//
687//================================================================================================================
688
689void  processDcfBit(int dcfBit)
690{
691  //--------------------------------------------------------------------
692  // display values on the 7 segment displays
693  //--------------------------------------------------------------------
694  // display bufferPosition, digits 7,6
695  MaximCC.setChar(DisplayBufferBitError,  7, bufferPosition / 10, false);
696  MaximCC.setChar(DisplayBufferBitError, 6, bufferPosition  % 10, false);
697
698  // display received DCFbit, digit 4
699  MaximCC.setChar(DisplayBufferBitError,  4, dcfBit, false);
700
701  //--------------------------------------------------------------------
702  // display incoming DCF bits on inner LED ring
703  //--------------------------------------------------------------------
704  // only if we have valid DCF data or after an Minute Mark (EoM) signal
705  //  activate the inner LED ring and diplay incoming data
706  if (dcfValidSignal ==  true || MinuteMarkerFlag == true)
707  {
708    // display received bits on inner  LED ring
709    MaximCC.setLed(LedRingInner, bufferPosition / 8, bufferPosition  % 8, dcfBit);
710  }
711
712  //--------------------------------------------------------------------
713  //   // Fill DCFbitBuffer array with DCFbit
714  //--------------------------------------------------------------------
715  DCFbitBuffer[bufferPosition] = dcfBit;
716
717  //--------------------------------------------------------------------
718  // Parity check
719  //--------------------------------------------------------------------
720  // DURING reception of the DCF bits, calculate and display the results of the  DCF parity check.
721  //
722  // There is a Parity bit for the minutes, the hours  and for the date.
723  // DCF77 works with EVEN parity, this works as follows:
724  // The hours for example have 6 bits plus a paritybit. The bits with value 1 are  add up including the paritybit,
725  // the result must be an even number. If there  is a bit wrong received, a 0 is as 1, or a 1 is as 0 received,
726  // then the  result is uneven.  source: http://www.picbasic.nl/frameload_uk.htm?http://www.picbasic.nl/info_dcf77_uk.htm
727
728  if (bufferPosition == 0)
729  {
730    // reset the parity LED's
731    digitalWrite(LED_PARITY1PASS,  LOW);
732    digitalWrite(LED_PARITY1FAIL, LOW);
733    digitalWrite(LED_PARITY2PASS,  LOW);
734    digitalWrite(LED_PARITY2FAIL, LOW);
735    digitalWrite(LED_PARITY3PASS,  LOW);
736    digitalWrite(LED_PARITY3FAIL, LOW);
737    // reset variables
738    dcfP1counter  = 0;
739    dcfP2counter = 0;
740    dcfP3counter = 0;
741    dcfParityCheckP1 =  0;
742    dcfParityCheckP2 = 0;
743    dcfParityCheckP3 = 0;
744  }
745
746  //  ----------------------------------------
747  // First parity check: minute bits
748  // ----------------------------------------
749  if (bufferPosition == 28)
750  {
751    for (int i = 21; i <= 27; i++)
752    {
753      // count the number  of bits with the value '1'
754      dcfP1counter += DCFbitBuffer[i];
755    }
756
757    // perform P1 parity check. Parity is OK if the sum is an EVEN value
758    if  ((DCFbitBuffer[28] + dcfP1counter) % 2 == 0)
759    {
760      // Parity1 PASS LED  ON
761      digitalWrite(LED_PARITY1PASS, HIGH);
762      // Parity P1 PASS
763      dcfParityCheckP1 = 1;
764    }
765    else
766    {
767      // Parity1 FAIL  LED ON
768      digitalWrite(LED_PARITY1FAIL, HIGH);
769      // we have no valid  data!
770      dcfValidSignal = false;
771      // Turn DCF OK LED OFF
772      digitalWrite(LED_DCFSTATUS,  LOW);
773    }
774  }
775
776  // ----------------------------------------
777  //  Second parity check: hour bits
778  // ----------------------------------------
779  if (bufferPosition == 35)
780  {
781    for (int i = 29; i <= 34; i++)
782    {
783      dcfP2counter += DCFbitBuffer[i];
784    }
785
786    // perform P2 parity  check. Parity is OK if the sum is an EVEN value
787    if ((DCFbitBuffer[35] + dcfP2counter)  % 2 == 0)
788    {
789      // Parity2 PASS LED ON
790      digitalWrite(LED_PARITY2PASS,  HIGH);
791      // Parity P2 PASS
792      dcfParityCheckP2 = 1;
793    }
794    else
795    {
796      // Parity2 FAIL LED ON
797      digitalWrite(LED_PARITY2FAIL, HIGH);
798      // we have no valid data!
799      dcfValidSignal = false;
800      // Turn  DCF OK LED OFF
801      digitalWrite(LED_DCFSTATUS, LOW);
802    }
803  }
804
805  // ----------------------------------------
806  // Third parity check: date bits
807  // ----------------------------------------
808  if (bufferPosition == 58)
809  {
810    for (int i = 36; i <= 57; i++)
811    {
812      dcfP3counter += DCFbitBuffer[i];
813    }
814    // perform P3 parity check. Parity is OK if the sum is an EVEN value
815    (DCFbitBuffer[58] + dcfP3counter) % 2 == 0 ? dcfParityCheckP3 = 1 : dcfParityCheckP3  = 0;
816
817    // Turn Parity2 'PASS' or 'FAIL' LED ON
818    if (dcfParityCheckP3  == 1)
819    {
820      // Parity2 PASS LED ON
821      digitalWrite(LED_PARITY3PASS,  HIGH);
822      // Parity P3 PASS
823      dcfParityCheckP3 = 1;
824    }
825    else
826    {
827      // Parity2 FAIL LED ON
828      digitalWrite(LED_PARITY3FAIL, HIGH);
829      // we have no valid data!
830      dcfValidSignal = false;
831      // Turn  DCF OK LED OFF
832      digitalWrite(LED_DCFSTATUS, LOW);
833    }
834
835    //  ----------------------------------------
836    // finally, check all Parity bits
837    // ----------------------------------------
838    dcfParityCheckP1 + dcfParityCheckP2  + dcfParityCheckP3 == 3 ? dcfValidSignal = true : dcfValidSignal = false;
839  }
840
841  //--------------------------------------------------------------------
842  //  before continuing with the next bit, increment counter
843  //--------------------------------------------------------------------
844  bufferPosition++;
845
846  //--------------------------------------------------------------------
847  // check if we have not received too many pulses?
848  //--------------------------------------------------------------------
849  if (bufferPosition > 59)
850  {
851    // Buffer Overflow ERROR - we have received  more pulses before reaching
852    // the 2 second 'gap' signalling the end of the  minute.
853    //This error may be due to a noisy signal giving addition peaks/dcfBits
854    // So clear both DCFbit displays and start again.
855
856    // Reset buffer  counter
857    bufferPosition = 0;
858    // clear inner LED ring
859    MaximCC.clearDisplay(LedRingInner);
860    // turn Buffer Overflow Error LED ON
861    error(LED_BUFFEROVERFLOW);
862    //  exit
863    return;
864  }
865
866  //--------------------------------------------------------------------
867  // everything OK so we wait for next incoming DCFbit
868  //--------------------------------------------------------------------
869}
870
871//================================================================================================================
872//
873//  Function name : finalizeBuffer
874// called from   : <scanSignal>
875//
876// Purpose       : Process the succesfully received DCF data of one minute
877// Parameters    : none
878// Return value  : none
879//
880//================================================================================================================
881
882void  finalizeBuffer(void)
883{
884  //--------------------------------------------------------------------
885  // We are here because of the detected 2 second 'gap'.
886  // Now check if it  correspondends with the buffer counter
887  // 'bufferPosition' which should be  value 59
888  //--------------------------------------------------------------------
889  if (bufferPosition == 59 && dcfValidSignal == true)
890  {
891    // bufferPosition  == 59 so turn Buffer Full LED ON
892    digitalWrite(LED_BUFFERFULL, HIGH);
893
894    // Turn DCF OK LED ON
895    digitalWrite(LED_DCFSTATUS, HIGH);
896
897    //  Reset inner LED ring (incoming time information)
898    MaximCC.clearDisplay(LedRingInner);
899
900    // copy 'contents' of inner LED ring to the outer LED ring (current time information)
901    for (int i = 0; i < 59; i++)
902    {
903      MaximCC.setLed(LedRingOuter,  i / 8, i % 8, DCFbitBuffer[i]);
904    }
905
906    // process buffer and extract  data sync the time with the RTC
907    decodeBufferContents();
908
909    // set  Arduino time and after that set RTC time
910    setTime(dcfHour, dcfMinute, 0, dcfDay,  dcfMonth, dcfYear);
911    RTC.set(now());
912
913    // activate Synced LED
914    digitalWrite(LED_RTCSYNC, HIGH);
915
916    // Reset running buffer
917    bufferPosition  = 0;
918
919    // Reset DCFbitBuffer array, positions 0-58 (=59 bits)
920    for  (int i = 0; i < 59; i++)
921    {
922      DCFbitBuffer[i] = 0;
923    }
924
925    // reset flag
926    MinuteMarkerFlag = false;
927
928  } // if (bufferPosition  == 59)
929
930  //--------------------------------------------------------------------
931  // The buffer is not yet filled although the 2 second 'gap' was detected.
932  // Can be result of a noisy signal, starting in middle of receiving data etc.
933  // Turn 'Minute Mark' LED ON
934  //--------------------------------------------------------------------
935  else
936  {
937    digitalWrite(LED_MINUTEMARKER, HIGH);
938
939    // Clear displays
940    MaximCC.clearDisplay(LedRingInner);
941    MaximCC.clearDisplay(LedRingOuter);
942
943    // Reset running buffer and start afresh. Now we are in sync with the incoming  data
944    bufferPosition = 0;
945
946    // Reset DCFbitBuffer array, positions  0-58 (=59 bits)
947    for (int i = 0; i < 59; i++)
948    {
949      DCFbitBuffer[i]  = 0;
950    }
951
952    // set flag so we can display incoming pulsed on the inner  LED ring.
953    MinuteMarkerFlag = true;
954  }
955}
956
957//================================================================================================================
958//
959//  Function name : decodeBufferContents
960// called from   : <finalizeBuffer>
961//
962//  Purpose       : Evaluates the information stored in the buffer.
963//                 This  is where the DCF77 signal is decoded to time and date information
964// Parameters    : none
965// Return value  : none
966//
967//================================================================================================================
968
969void  decodeBufferContents(void)
970{
971  // Buffer is full and ready to be decoded
972  dcfMinute = bitDecode(21, 27);
973  dcfHour = bitDecode(29, 34);
974  dcfDay =  bitDecode(36, 41);
975  dcfWeekDay = bitDecode(42, 44);
976  dcfMonth = bitDecode(45,  49);
977  dcfYear = bitDecode(50, 57);
978
979  //call function to calculate day  of year and weeknumber
980  dayWeekNumber(dcfYear, dcfMonth, dcfDay, dcfWeekDay);
981
982  // Get value of Summertime DCFbit. '1' = Summertime, '0' = wintertime
983  dcfDST  = bitDecode(17, 17);
984
985  // determine Leap Year
986  leapYear = calculateLeapYear(dcfYear);
987}
988
989//================================================================================================================
990//
991//  bitDecode
992//
993// called from <processBuffer>
994//================================================================================================================
995int  bitDecode(int bitStart, int bitEnd)
996{
997  // reset 'bitValue-array' counter
998  int i = 0;
999  int value = 0;
1000
1001  // process bitrange bitStart > bitEnd
1002  while (bitStart <= bitEnd)
1003  {
1004    // check if DCFbit in buffer is '1',  discard when '0'
1005    if (DCFbitBuffer[bitStart] == 1)
1006    {
1007      // DCFbit  in buffer == 1 so append its corresponding value to the variable 'value'
1008      value  = value + bitValue[i];
1009    }
1010    // increment 'bitValue-array' counter
1011    i++;
1012    // increment bit-range counter
1013    bitStart++;
1014  }
1015  return  value;
1016}
1017
1018//================================================================================================================
1019//
1020//  Function name : tasksEverySecond
1021// called from   : <loop>
1022//
1023// Purpose       : perform tasks that must happen once every SECOND
1024// Parameters    :  none
1025// Return value  : none
1026//
1027//================================================================================================================
1028void  tasksEverySecond()
1029{
1030  // check if time is changed
1031  if (second() != previousSecond)
1032  {
1033    // 'reset' variable state
1034    previousSecond = second();
1035
1036    //display  the Real Time Clock Time
1037    displayRtcTime();
1038
1039    // display 'HI' and  'LO' temperature on specific moments
1040    switch (second())
1041    {
1042    case  0:
1043      // hourly chime output: ACTIVATE
1044      if (dayTime == 1 && minute()  == 0 && digitalRead(CHIMESWITCHPIN) == HIGH)
1045      {
1046        digitalWrite(CHIMEPIN,  HIGH);
1047      }
1048
1049      // reset temperature min/max memory at midnight
1050      //
1051      // I did put this in the 'tasks every second' section so
1052      //  that this code is executed at one specific second only...
1053      // Else we would  need an extra variable to prevent this code to run
1054      // every cycle during  the whole '00' hour.
1055      if (TEMPRESET_MIDNIGHT == 1 && (hour() == 00 && minute()  == 00))
1056      {
1057        minTemp = tempCelsius;
1058        maxTemp = tempCelsius;
1059      }
1060      break;
1061    case 2:
1062      // hourly chime output: DEACTIVATE
1063      digitalWrite(CHIMEPIN, LOW);
1064      break;
1065    case 30:
1066      // display  'HI' on display for Hi temperature
1067      MaximCC.setChar(DisplayTempWeek, 5,  ' ', false); // Clear part of the display
1068      MaximCC.setChar(DisplayTempWeek,  4, ' ', false); // Clear part of the display
1069      MaximCC.setChar(DisplayTempWeek,  7, 'H', false); // Display 'H' character. Binary pattern to lite up individual segments  in this order is: .ABCDEFG
1070      MaximCC.setRow(DisplayTempWeek, 6, B00010000);   // Display 'i' character. Binary pattern to lite up individual segments in this  order is: .ABCDEFG
1071      break;
1072    case 31:
1073    case 32:
1074      // display  Max temperature on DCF display LED display
1075      MaximCC.setChar(DisplayTempWeek,  7, (maxTemp / 100), false);
1076      MaximCC.setChar(DisplayTempWeek, 6, (maxTemp  % 100) / 10, true);
1077      MaximCC.setChar(DisplayTempWeek, 5, (maxTemp % 10),  false);
1078      MaximCC.setRow(DisplayTempWeek, 4, B11001110); // Display Degrees  dot and 'C' (Celcius) character. Binary pattern to lite up individual segments in  this order is: .ABCDEFG
1079      // NOTE: I physically rotated digit 4 so when I  activate the decimal dot, this now is the 'degrees dot' in the upper left corner
1080      break;
1081    case 33:
1082      // display 'LO' on display for Low temperature
1083      MaximCC.setChar(DisplayTempWeek, 5, ' ', false); // Clear part of the display
1084      MaximCC.setChar(DisplayTempWeek, 4, ' ', false); // Clear part of the display
1085      MaximCC.setChar(DisplayTempWeek, 7, 'L', false); // Display 'L' character.  Binary pattern to lite up individual segments in this order is: .ABCDEFG
1086      MaximCC.setRow(DisplayTempWeek,  6, B00011101);   // Display 'o' character. Binary pattern to lite up individual  segments in this order is: .ABCDEFG
1087      break;
1088    case 34:
1089    case  35:
1090      // display Min temperature on DCF display LED display
1091      MaximCC.setChar(DisplayTempWeek,  7, (minTemp / 100), false);
1092      MaximCC.setChar(DisplayTempWeek, 6, (minTemp  % 100) / 10, true);
1093      MaximCC.setChar(DisplayTempWeek, 5, (minTemp % 10),  false);
1094      MaximCC.setRow(DisplayTempWeek, 4, B11001110); // Display Degrees  dot and 'C' (Celcius) character. Binary pattern to lite up individual segments in  this order is: .ABCDEFG
1095      // NOTE: I physically rotated digit 4 so when I  activate the decimal dot, this now is the 'degrees dot' in the upper left corner
1096      break;
1097    case 36:
1098      // befor displaying the temperature in the  next second,
1099      // request temperature from DS18B20 sensor, available after  delay of minimal 750 ms (at highest resolution)
1100      calculateTemp();
1101
1102      // display 'CU' on display for Current temperature
1103      MaximCC.setChar(DisplayTempWeek,  5, ' ', false); // Clear part of the display
1104      MaximCC.setChar(DisplayTempWeek,  4, ' ', false); // Clear part of the display
1105      MaximCC.setRow(DisplayTempWeek,  7, B01001110);   // Display 'C' character. Binary pattern to lite up individual  segments in this order is: .ABCDEFG
1106      MaximCC.setRow(DisplayTempWeek, 6,  B00011100);   // Display 'u' character. Binary pattern to lite up individual segments  in this order is: .ABCDEFG
1107      break;
1108    case 37:
1109      // read temperature,  store in min/max memory and display current temperature
1110      // only once per  minute this is done else things go wrong... ;)
1111      displayTemp();
1112      break;
1113    } // switch
1114  } // (second() != previousSecond)
1115} // void tasksEverySecond()
1116
1117//================================================================================================================
1118//
1119//  Function name : tasksEveryMinute
1120// called from   : <loop>
1121//
1122// Purpose       : perform tasks that must happen once every MINUTE
1123// Parameters    :  none
1124// Return value  : none
1125//
1126//================================================================================================================
1127void  tasksEveryMinute()
1128{
1129  // display date, week LED's, week nr etc. if time is  changed
1130  if (minute() != previousMinute)
1131  {
1132    // 'reset' state of variable
1133    previousMinute = minute();
1134
1135    // display date, week LED's, week nr etc.
1136    if (dcfValidSignal == true)
1137    {
1138      displayData();
1139    }
1140
1141    // increase PIR delay counter
1142    pirTimer++;
1143  }
1144}
1145
1146//================================================================================================================
1147//
1148//  Function name : tasksEveryHour
1149// called from   : <loop>
1150//
1151// Purpose       : perform tasks that must happen once every HOUR
1152// Parameters    : none
1153//  Return value  : none
1154//
1155//================================================================================================================
1156void  tasksEveryHour()
1157{
1158  if (hour() != previousHour)
1159  {
1160    // 'reset'  variable state
1161    previousHour = hour();
1162
1163    //--------------------------------------------------------------------
1164    // reset error counter and display every hour
1165    //--------------------------------------------------------------------
1166    errorCounter = 0;
1167    // update error counter display
1168    ledDisplay(DisplayBufferBitError,  "R", errorCounter);
1169
1170    //---------------------------------------------------------------------
1171    // Power saving function, shutting the displays off at night
1172    //---------------------------------------------------------------------
1173
1174    // First, check if the night shut-down function is activated by the user
1175    // simply by adding up both value. If '0', the user has disabled the function
1176    if (POWERSAVINGOFFTIME != 0 && POWERSAVINGONTIME != 0)
1177    {
1178      //  check whether it is Day- or Nighttime
1179      if (hour() >= POWERSAVINGOFFTIME  && hour() <= POWERSAVINGONTIME)
1180      {
1181        // ----------------------------------------
1182        // it's DAYTIME so activate the displays
1183        // ----------------------------------------
1184
1185        // this is used to chime only if it is daytime...
1186        dayTime = 1;
1187
1188        // test variable because daytime routine is needed only once
1189        if  (daytimeChange == 1)
1190        {
1191          // 'reset' variable state
1192          daytimeChange  = 0;
1193
1194          // activate SELECTED displays and status LED's
1195          turnDisplaysOn();
1196        }
1197      }
1198      else
1199      {
1200        // no chime at night...
1201        dayTime = 0;
1202
1203        // ----------------------------------------
1204        // it's NIGHTTIME so time to deactivate displays
1205        // ----------------------------------------
1206        // test variable because nighttime routine is needed only once
1207        if  (daytimeChange == 0)
1208        {
1209          // 'reset' variable state
1210          daytimeChange  = 1;
1211
1212          // deactivate all the displays and status LED's
1213          //  ONLY if the powersafe switch is HIGH
1214          if (digitalRead(POWERSAVESWITCHPIN)  == HIGH)
1215          {
1216            turnDisplaysOff();
1217          }
1218
1219        } // if (daytimeChange == 0)
1220      }   // else
1221    }     // if(POWERSAVINGOFFTIME  + POWERSAVINGONTIME != 0)
1222  }       // if (dcfHour != previousHour)
1223} // void  tasksEveryHour()
1224
1225//================================================================================================================
1226//
1227//  Function name : buzzer
1228// called from   : <scanSignal>
1229//
1230// Purpose       :  generate 'beep' sound
1231// Parameters    : duration in ms
1232// Return value  :  none
1233//
1234//================================================================================================================
1235
1236void  buzzer(int duration)
1237{
1238  tone(BUZZER, 1500, duration);
1239}
1240
1241//================================================================================================================
1242//
1243//  Function name : initialize
1244// called from   : <Setup>
1245//
1246// Purpose       :  initialize variables and displays after power-up
1247// Parameters    : none
1248//  Return value  : none
1249//
1250//================================================================================================================
1251
1252void  initialize(void)
1253{
1254  //---------------------------------------------------
1255  // Initialize Variables
1256  //---------------------------------------------------
1257  leadingEdge = 0;
1258  trailingEdge = 0;
1259  previousLeadingEdge = 0;
1260  bufferPosition  = 0;
1261
1262  digitalWrite(CHIMEPIN, HIGH); // Set Chimepin to default state
1263
1264  // Reset DCFbitBuffer array, positions 0-58 (=59 bits)
1265  for (int i = 0; i  < 59; i++)
1266  {
1267    DCFbitBuffer[i] = 0;
1268  }
1269
1270  //---------------------------------------------------
1271  // Initialize Maxim 72xx 7 segment displays
1272  //---------------------------------------------------
1273  // Maxim Common Cathode displays
1274  for (int i = 0; i < 8; i++)
1275  {
1276    //  display wake up
1277    MaximCC.shutdown(i, false);
1278    // clear display
1279    MaximCC.clearDisplay(i);
1280  }
1281
1282  //---------------------------------------------------
1283  // Set brightness  of Maxim 72xx 7 segment displays
1284  //---------------------------------------------------
1285  // Maxim Common Cathode displays
1286  MaximCC.setIntensity(LedRingOuter, BrightnessLedRingOuter);
1287  MaximCC.setIntensity(LedRingInner, BrightnessLedRingInner);
1288  MaximCC.setIntensity(DisplayTime,  BrightnessDisplayTime);
1289  MaximCC.setIntensity(DisplayDate, BrightnessDisplayDate);
1290  MaximCC.setIntensity(DisplayTempWeek, BrightnessDisplayTempWeek);
1291  MaximCC.setIntensity(DisplayPeriodPulse,  BrightnessDisplayPeriodPulse);
1292  MaximCC.setIntensity(DisplayBufferBitError,  BrightnessDisplayBufferBitError);
1293
1294  //---------------------------------------------------
1295  // Set all Arduino LED outputs to LOW (Led's OFF)
1296  //---------------------------------------------------
1297  for (int i1 = 22; i1 <= 49; i1++)
1298  {
1299    digitalWrite(i1, LOW);
1300  }
1301}
1302
1303//================================================================================================================
1304//
1305//  Function name : int0handler
1306// called from   :
1307//
1308// Purpose       : when  a rising or falling edge is detected on pin 2, this function is called
1309// Parameters    : none
1310// Return value  : none
1311//
1312//================================================================================================================
1313
1314void  int0handler()
1315{
1316  DCFSignalState = digitalRead(DCF77PIN);
1317}
1318
1319//================================================================================================================
1320//
1321//  Function name : turnDisplaysOn
1322// called from   : <tasksEveryHour> and <checkPIR>
1323//
1324//  Purpose       : turn ON selected 7 segment displays and LED's
1325// Parameters    :  none
1326// Return value  : none
1327//
1328//================================================================================================================
1329void  turnDisplaysOn()
1330{
1331  // activate SELECTED displays and status LED's
1332  MaximCC.shutdown(LedRingInner,  false);
1333  MaximCC.shutdown(LedRingOuter, false);
1334  MaximCC.shutdown(DisplayTime,  false);
1335  MaximCC.shutdown(DisplayDate, false);
1336  MaximCC.shutdown(DisplayTempWeek,  false);
1337  MaximCC.shutdown(DisplayPeriodPulse, false);
1338  MaximCC.shutdown(DisplayBufferBitError,  false);
1339}
1340
1341//================================================================================================================
1342//
1343//  Function name : turnDisplaysOff
1344// called from   : <tasksEveryHour> and <checkPIR>
1345//
1346//  Purpose       : turn OFF selected 7 segment displays and LED's
1347// Parameters    : none
1348// Return value  : none
1349//
1350//================================================================================================================
1351void  turnDisplaysOff()
1352{
1353  // below you can select which display's need to be shut  down for the night
1354  // In this case, the time display remains ON
1355
1356  //MaximCC.shutdown(DisplayTime,  true);
1357  MaximCC.shutdown(LedRingInner, true);
1358  MaximCC.shutdown(LedRingOuter,  true);
1359  MaximCC.shutdown(DisplayDate, true);
1360  MaximCC.shutdown(DisplayTempWeek,  true);
1361  MaximCC.shutdown(DisplayPeriodPulse, true);
1362  MaximCC.shutdown(DisplayBufferBitError,  true);
1363}
1364
1365//================================================================================================================
1366//
1367//  Function name : ledDisplay
1368// called from   : <processBuffer>
1369//
1370// Purpose       : display a value on a selected 7 segment display
1371// Parameters    : display  'number 'addr', 'value', "L"eft or "R"ight side.none
1372// Return value  : none
1373//
1374//================================================================================================================
1375
1376//  example: ledDisplay( DisplayBufferBitError, "R", errorCounter )
1377// so display  the 'error counter' value on the RIGHT side of the 8 digit
1378// 7 segment display  number 3
1379
1380void ledDisplay(int addr, String leftOrRight, int value)
1381{
1382  int ones;
1383  int tens;
1384  int hundreds;
1385  int thousands;
1386  int shift;
1387
1388  //break down value in seperate digits for ones, tens, etc
1389  int v = value;  // 'value' is needed later so copy it in 'v'
1390  ones = v % 10;
1391  v = v / 10;
1392  tens = v % 10;
1393  v = v / 10;
1394  hundreds = v % 10;
1395  thousands = v / 10;
1396
1397  //Select which side of the 8 digit display to be used
1398  (leftOrRight == "L"  ? shift = 4 : shift = 0);
1399
1400  //Now print the number digit by digit
1401  //preceding  zero's are removed with tenary operator by 'printing' a space character.
1402  MaximCC.setChar(addr,  3 + shift, ((value < 1000) ? ' ' : thousands), false);
1403  MaximCC.setChar(addr,  2 + shift, ((value < 100) ? ' ' : hundreds), false);
1404  MaximCC.setChar(addr,  1 + shift, ((value < 10) ? ' ' : tens), false);
1405  MaximCC.setChar(addr, 0 + shift,  ones, false);
1406}
1407
1408//================================================================================================================
1409//
1410//  Function name : checkSwitches
1411// called from   : <loop>
1412//
1413// Purpose       :  check if the temperature reset button button is pressed
1414// Parameters    : none
1415//  Return value  : none
1416//
1417//================================================================================================================
1418void  checkSwitches(void)
1419{
1420  //-------------------------------------------------------------
1421  // read state of push button tempResetButton
1422  tempResetButton = digitalRead(TEMPRESETPIN);
1423  // reset temperature min/max values when push-button is pressed
1424  if (tempResetButton  == 1)
1425  {
1426    maxTemp = tempCelsius;
1427    minTemp = tempCelsius;
1428  }
1429
1430  //-------------------------------------------------------------
1431  //read state  of switch BUZZERSWITCHPIN
1432  dcf77SoundSwitch = digitalRead(BUZZERSWITCHPIN);
1433
1434  //-------------------------------------------------------------
1435  //check led  and display's powersafe switch
1436  if (digitalRead(POWERSAVESWITCHPIN) == HIGH)
1437  {
1438    digitalWrite(LED_POWERSAVE, HIGH);
1439  }
1440  else
1441  {
1442    digitalWrite(LED_POWERSAVE,  LOW);
1443    turnDisplaysOn();
1444  }
1445}
1446
1447//================================================================================================================
1448//
1449//  Function name : checkPIR
1450// called from   : <loop>
1451//
1452// Purpose       :  check for PIR detector activity to shut off or activate the displays to save power
1453//  Parameters    : none
1454// Return value  : none
1455//
1456//================================================================================================================
1457void  checkPIR()
1458{
1459  //-------------------------------------------------------------
1460  // Read PIR input, check for movement
1461  // Only check for PIR activity if user  option is '1'
1462  // AND only every second to prevent waisted processor time.
1463  if (POWERSAVE_BY_PIR == 1 && (millis() - previousTimePIR > 1000))
1464  {
1465    //  reset the 'once-per-second timer
1466    previousTimePIR = millis();
1467
1468    //  read the PIR detector PIN
1469    pirActivity = digitalRead(PIRDETECTORPIN);
1470
1471    // turn displays ON or OFF depending on state of pin 'pirActivity'
1472    if  (pirActivity == 1)
1473    {
1474      // PIR activity detected...
1475      // activated  the PIR LED
1476      digitalWrite(LED_PIRMOTION, HIGH);
1477      // Reset the PIR  timer variable (used in <tasksEveryMinue> function) every time
1478      // the PIR  is activated so effectually resetting the shut-off timer.
1479      pirTimer = 0;
1480
1481      // only continue if the display is now OFF
1482      if (pirDisplaysState ==  0)
1483      {
1484        // Toggle variable to prevent executing the following
1485        // code every time the PIR detects activity
1486        pirDisplaysState  = 1;
1487
1488        //displays ON
1489        turnDisplaysOn();
1490      }
1491    }
1492    else
1493    {
1494      // No PIR activity detected...
1495      // turn the PIR  LED off
1496      digitalWrite(LED_PIRMOTION, LOW);
1497      // check the pirTimer  counter in the <tasksEveryMinue> function).
1498      // and if the delaytime has  passed, only continue if the displays are now ON
1499      // else this code would  be executed many times per second
1500      if (pirTimer > PIR_DELAY_TIME && pirDisplaysState  == 1)
1501      {
1502        // Toggle variable to prevent executing the following
1503        // code every time the PIR detects activity
1504        pirDisplaysState  = 0;
1505
1506        //shut off displays ONLY if powersafe switch is HIGH
1507        if  (digitalRead(POWERSAVESWITCHPIN) == HIGH)
1508        {
1509          turnDisplaysOff();
1510        }
1511      }
1512    } // else
1513  }   //  if (POWERSAVE_BY_PIR == 1 &&  (millis() - previousTimePIR > 1000))
1514} // void checkPIR()
1515
1516//================================================================================================================
1517//
1518//  Function name : error
1519// called from   : <scanSignal>
1520//
1521// Purpose       :  turn error LED ON, clear LED ring's and increase error counter display
1522// Parameters    : error LED to turn on
1523// Return value  : none
1524//
1525//================================================================================================================
1526
1527void  error(int errorLed)
1528{
1529  // no valid data
1530  dcfValidSignal = false;
1531
1532  // turn 'dcfValidSignal = false on'
1533  digitalWrite(errorLed, HIGH);
1534
1535  // clear Led's/displays because of error condition
1536  digitalWrite(LED_DCFSTATUS,  LOW);
1537  digitalWrite(LED_RTCSYNC, LOW);
1538  MaximCC.clearDisplay(LedRingOuter);  // clear display
1539
1540  // increase errorCounter and display errorCount
1541  errorCounter++;
1542  ledDisplay(DisplayBufferBitError, "R", errorCounter);
1543  return;
1544}
1545
1546//================================================================================================================
1547//
1548//  Function name : dayWeekNumber
1549// called from   : <decodeBufferContents>
1550//
1551//  Purpose       : calculate the WEEK number according to ISO standard, see comments  in the ARCHIVE below
1552// Parameters    : dcfYear, dcfMonth, dcfDay, dcfWeekDay
1553//  Return value  : weekNumber
1554//
1555//================================================================================================================
1556//Code  from: http://forum.arduino.cc/index.php/topic,44476.0.html
1557
1558int dayWeekNumber(int  y, int m, int d, int w)
1559{
1560  // Number of days at the beginning of the month  in a normal (not leap) year.
1561  int days[] = {0, 31, 59, 90, 120, 151, 181, 212,  243, 273, 304, 334};
1562
1563  // Start to calculate the number of days of the first  two months
1564  if (m == 1 || m == 2)
1565  {
1566    // for any type of year we calculate  the number of days for January or february
1567    dayNumber = days[(m - 1)] + d;
1568  }
1569
1570  // now calculate for the other months
1571  // first, check for a leap  year
1572  else if ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0)
1573  {
1574    //  we have a leap year, so calculate in the same way but adding one day
1575    dayNumber  = days[(m - 1)] + d + 1;
1576  }
1577
1578  else
1579  {
1580    //no leap year, calculate  in the normal way, such as January or February
1581    dayNumber = days[(m - 1)]  + d;
1582  }
1583
1584  // Now start to calculate Week number
1585  if (w == 0)
1586  {
1587    //if it is sunday (time library returns 0)
1588    weekNumber = (dayNumber  - 7 + 10) / 7;
1589  }
1590
1591  else
1592  {
1593    // for the other days of week
1594    weekNumber = (dayNumber - w + 10) / 7;
1595  }
1596
1597  // finished! return with  the week number as an INT value
1598  return weekNumber;
1599}
1600
1601//================================================================================================================
1602//
1603//  Function name : calculateLeapYear
1604// called from   : <decodeBufferContents>
1605//
1606//  Purpose       : determine if a given year is a leap year
1607// Parameters    : year  - the year to test
1608// Return value  : '1' if the year is a leap year, '0' otherwise
1609//
1610//================================================================================================================
1611
1612int  calculateLeapYear(int year)
1613{
1614  if ((year % 4 == 0 && year % 100 != 0) ||  (year % 400 == 0))
1615  {
1616    return 1;
1617  }
1618  else
1619  {
1620    return  0;
1621  }
1622}
1623
1624//================================================================================================================
1625//
1626//  Function name : displayData
1627// called from   : <tasksEveryMinute>
1628//
1629//  Purpose       : display LED's: day of week; status; Winter/Summer time;
1630// Parameters    : none
1631// Return value  : none
1632//
1633//================================================================================================================
1634
1635void  displayData(void)
1636{
1637  // display Day of Week on LED's
1638  // first, clear  all the 'Day' Led's before displaying new value
1639  digitalWrite(LED_SUNDAY, LOW);
1640  digitalWrite(LED_MONDAY, LOW);
1641  digitalWrite(LED_TUESDAY, LOW);
1642  digitalWrite(LED_WEDNESDAY,  LOW);
1643  digitalWrite(LED_THURSDAY, LOW);
1644  digitalWrite(LED_FRIDAY, LOW);
1645  digitalWrite(LED_SATURDAY, LOW);
1646
1647  // switch on the Weekday LED
1648  switch  (dcfWeekDay)
1649  {
1650  case 1:
1651    digitalWrite(LED_MONDAY, HIGH);
1652    break;
1653  case 2:
1654    digitalWrite(LED_TUESDAY, HIGH);
1655    break;
1656  case 3:
1657    digitalWrite(LED_WEDNESDAY, HIGH);
1658    break;
1659  case 4:
1660    digitalWrite(LED_THURSDAY,  HIGH);
1661    break;
1662  case 5:
1663    digitalWrite(LED_FRIDAY, HIGH);
1664    break;
1665  case 6:
1666    digitalWrite(LED_SATURDAY, HIGH);
1667    break;
1668  case 7:
1669    digitalWrite(LED_SUNDAY, HIGH);
1670    break;
1671  }
1672
1673  // display Weeknumber
1674  MaximCC.setChar(DisplayTempWeek, 1, ((weekNumber < 10) ? ' ' : (weekNumber / 10)),  false);
1675  MaximCC.setChar(DisplayTempWeek, 0, weekNumber % 10, false);
1676
1677  // display Date - with dashes between D-M-Y
1678  // for example: 03-08-2015, so  with leading zero's
1679  MaximCC.setChar(DisplayDate, 7, dcfDay / 10, false);
1680  MaximCC.setChar(DisplayDate, 6, dcfDay % 10, false);
1681  MaximCC.setChar(DisplayDate,  5, '-', false);
1682  MaximCC.setChar(DisplayDate, 4, dcfMonth / 10, false);
1683  MaximCC.setChar(DisplayDate, 3, dcfMonth % 10, false);
1684  MaximCC.setChar(DisplayDate,  2, '-', false);
1685  MaximCC.setChar(DisplayDate, 1, dcfYear / 10, false);
1686  MaximCC.setChar(DisplayDate,  0, dcfYear % 10, false);
1687
1688  /* OTHER OPTIONS TO DISPLAY THE DATE:
1689
1690  // display Date - with dots between D.M.Y
1691  // for example: 03.08.15
1692   MaximCC.setChar(DisplayDate,  7, dcfDay / 10, false);
1693   MaximCC.setChar(DisplayDate, 6, dcfDay % 10, true);
1694   MaximCC.setChar(DisplayDate, 5, dcfMonth / 10, false);
1695   MaximCC.setChar(DisplayDate,  4, dcfMonth % 10, true);
1696   MaximCC.setChar(DisplayDate, 3, 2, false);
1697   MaximCC.setChar(DisplayDate,  2, 0, false);
1698   MaximCC.setChar(DisplayDate, 1, dcfYear / 10, false);
1699   MaximCC.setChar(DisplayDate,  0, dcfYear % 10, false);
1700   */
1701
1702  /*
1703  // display Date - moved day to  right if month is <10 
1704  // for example: __3.8.15 or _22.7.15 or 24.12.15 (where  _ is a blank display)
1705   MaximCC.setChar(DisplayDate, 7, ((dcfDay < 10) ? ' '  : ((dcfMonth < 10) ? ' ' : (dcfDay / 10))), false);
1706   MaximCC.setChar(DisplayDate,  6, ((dcfMonth < 10) ? ((dcfDay < 10) ? ' ' : (dcfDay / 10)) : (dcfDay % 10)), ((dcfMonth  < 10) ? false : true));
1707   MaximCC.setChar(DisplayDate, 5, ((dcfMonth < 10) ?  (dcfDay % 10) : (dcfMonth / 10)), ((dcfMonth < 10) ? true : false));
1708   MaximCC.setChar(DisplayDate,  4, dcfMonth % 10, true);
1709   MaximCC.setChar(DisplayDate, 3, 2, false);
1710   MaximCC.setChar(DisplayDate,  2, 0, false);
1711   MaximCC.setChar(DisplayDate, 1, dcfYear / 10, false);
1712   MaximCC.setChar(DisplayDate,  0, dcfYear % 10, false);
1713   */
1714
1715  // display Summer- or Wintertime LED
1716  if (dcfDST == 1)
1717  {
1718    digitalWrite(LED_CEST, HIGH);
1719    digitalWrite(LED_CET,  LOW);
1720  }
1721  else
1722  {
1723    digitalWrite(LED_CET, HIGH);
1724    digitalWrite(LED_CEST,  LOW);
1725  }
1726
1727  // display Leap Year LED
1728  if (leapYear == 1)
1729  {
1730    digitalWrite(LED_LEAPYEAR, HIGH);
1731  }
1732  else
1733  {
1734    digitalWrite(LED_LEAPYEAR,  LOW);
1735  }
1736}
1737
1738//================================================================================================================
1739//
1740//  Function name : displayRtcTime
1741// called from   : <tasksEverySecond>
1742//
1743//  Purpose       : display the Real Time Clock time on the RTC display
1744// Parameters    : none
1745// Return value  : none
1746//
1747//================================================================================================================
1748
1749void  displayRtcTime()
1750{
1751  MaximCC.setChar(DisplayTime, 7, ((hour() < 10) ? ' '  : (hour() / 10)), false);
1752  MaximCC.setChar(DisplayTime, 6, (hour() % 10), false);
1753  // activate only the segments 'a' and 'g' of the 7 segment display, representing  the dots between the digits
1754  // Binary pattern to lite up individual segments  in this order is: .ABCDEFG
1755  MaximCC.setRow(DisplayTime, 5, B00001001);
1756  MaximCC.setChar(DisplayTime,  4, (minute() / 10), false);
1757  MaximCC.setChar(DisplayTime, 3, (minute() % 10),  false);
1758  // activate only the segments 'a' and 'g' of the 7 segment display,  representing the dots between the digits
1759  // Binary pattern to lite up individual  segments in this order is: .ABCDEFG
1760  MaximCC.setRow(DisplayTime, 2, B01001001);
1761  MaximCC.setChar(DisplayTime, 1, (second() / 10), false);
1762  MaximCC.setChar(DisplayTime,  0, (second() % 10), false);
1763}
1764
1765//================================================================================================================
1766//
1767//  Function name : calculateTemp
1768// called from   : <loop>
1769//
1770// Purpose       :  get temperature from DS18B20 sensor and display it
1771// Parameters    : none
1772//  Return value  : none
1773//
1774//================================================================================================================
1775
1776void  calculateTemp()
1777{
1778  // The initialization sequence consists of a reset pulse  transmitted by the bus master
1779  // followed by presence pulse(s) transmitted  by the slave(s).
1780  ds.reset();
1781  // use this command when only 1 sensor is  used to avoid specifying the address!
1782  ds.skip();
1783  // start conversion
1784  ds.write(0x44);
1785  // (!) AFTER THIS we need to wait for a time dependent on  resolution
1786  // CONVERSION TIME:
1787  //  9 bit resolution, 93.75 ms
1788  //  10 bit resolution, 187.5 ms
1789  // 11 bit resolution, 375 ms
1790  // 12 bit resolution,  750 ms
1791  //
1792  // This is done in this sketch by requesting the conversion  first and at minimal 1 second later reading it.
1793}
1794
1795//================================================================================================================
1796//
1797//  Function name : displayTemp
1798// called from   : <loop>
1799//
1800// Purpose       :  get temperature from DS18B20 sensor and display it
1801//                 Earlier  we requested the temperature from the DS18B20 sensor,
1802//                 now  conversion is finished so we get the data
1803// Parameters    : none
1804// Return  value  : none
1805//
1806//================================================================================================================
1807
1808void  displayTemp()
1809{
1810  // The initialization sequence consists of a reset pulse  transmitted by the bus master
1811  // followed by presence pulse(s) transmitted  by the slave(s).
1812  ds.reset();
1813  // use this command when only 1 sensor is  used to avoid specifying the address!
1814  ds.skip();
1815  // Read Scratchpad
1816  ds.write(0xBE); // Read Scratchpad
1817  // we need 9 bytes
1818  for (byte i =  0; i < 9; i++)
1819  {
1820    // Read a Byte a a time
1821    DS18B20Data[i] = ds.read();
1822  }
1823
1824  // We have the data, next convert to actual temperature.
1825  lowByte  = DS18B20Data[0];
1826  highByte = DS18B20Data[1];
1827  // because the result is  a 16 bit signed integer, it should
1828  // be stored to an "int16_t" type, which  is always 16 bits
1829  // even when compiled on a 32 bit processor.
1830  int16_t  tempReading = (highByte << 8) + lowByte;
1831  // tempRaw is 4 digits; 2 integers,  2 fraction. For example: 2115 (= 21.15 degrees Celsius)
1832  int tempRaw = (6 *  tempReading) + tempReading / 4;
1833  // We need 3 digits: 2 integers, 2 fraction.  For example: 216 (= 21.6 degres Celsius)
1834  tempRaw % 10 >= 5 ? tempCelsius =  (tempRaw / 10) + 1 : tempCelsius = tempRaw / 10;
1835
1836  // store min and max temperatures
1837  if (minTemp == 0)
1838    minTemp = tempCelsius;
1839  if (tempCelsius > maxTemp)
1840    maxTemp = tempCelsius;
1841  if (tempCelsius < minTemp)
1842    minTemp = tempCelsius;
1843
1844  // Display temperature on the multi purpose display 'TempWeek'
1845
1846  // Also  light the 'Temp' LED on the front panel
1847  digitalWrite(LED_TEMP, HIGH);
1848  //  Display Digit 3: example: temperature value 216 / 100 = 2
1849  MaximCC.setChar(DisplayTempWeek,  7, (tempCelsius / 100), false);
1850  // Display Digit 2: example: temperature value  216 % 100 / 10 = 1
1851  // also activate decimal dot on display 2
1852  MaximCC.setChar(DisplayTempWeek,  6, (tempCelsius % 100) / 10, true);
1853  // Display Digit 3: example: temperature  value 216 % 10 = 6
1854  MaximCC.setChar(DisplayTempWeek, 5, (tempCelsius % 10),  false);
1855  // Display Degrees dot and 'C' (Celcius)  character. Binary pattern  to lite up individual segments in this order is: .ABCDEFG
1856  // NOTE: I physically  rotated digit 4 7 segement display so when I activate the decimal dot,
1857  // this  now is the 'degrees dot' in the upper left corner of the display...
1858  MaximCC.setRow(DisplayTempWeek,  4, B11001110);
1859}
1860
1861//================================================================================================================
1862//
1863//  Function name : ledTest
1864// called from   : <setup>
1865//
1866// Purpose       :  after a cold start, do a led test.
1867// Parameters    : none
1868// Return value  : none
1869//
1870//================================================================================================================
1871void  ledTest()
1872{
1873  // The displays are lit up sequentially because of the current  draw.
1874  // When all is lit up at the same time, you would need a bigger power  supply.
1875
1876  //---------------------------------------------------------------------
1877  // Outer LED ring
1878  for (int i = 0; i < 59; i++)
1879  {
1880    // LED's ON
1881    MaximCC.setLed(LedRingOuter, i / 8, i % 8, true);
1882    delay(LEDTEST_DELAY_LED_RING);
1883  }
1884
1885  for (int i = 58; i >= 0; i--)
1886  {
1887    // LED's OFF
1888    MaximCC.setLed(LedRingOuter,  i / 8, i % 8, false);
1889    delay(LEDTEST_DELAY_LED_RING);
1890  }
1891  //---------------------------------------------------------------------
1892  // Inner LED ring
1893  for (int i = 0; i < 59; i++)
1894  {
1895    // LED's ON
1896    MaximCC.setLed(LedRingInner, i / 8, i % 8, true);
1897    delay(LEDTEST_DELAY_LED_RING);
1898  }
1899
1900  for (int i = 58; i >= 0; i--)
1901  {
1902    // LED's OFF
1903    MaximCC.setLed(LedRingInner,  i / 8, i % 8, false);
1904    delay(LEDTEST_DELAY_LED_RING);
1905  }
1906  //---------------------------------------------------------------------
1907  // LED's
1908  for (int i = 22; i <= 53; i++)
1909  {
1910    // LED's ON
1911    digitalWrite(i,  HIGH);
1912    delay(LEDTEST_DELAY_LED_RING);
1913  }
1914  // wait before turning  the LED's off
1915  delay(LEDTEST_DELAY_DISPLAYS);
1916  for (int i = 53; i >= 22;  i--)
1917  {
1918    // LED's OFF
1919    digitalWrite(i, LOW);
1920  }
1921  //---------------------------------------------------------------------
1922  // Real Time Clock display
1923  for (int i = 0; i < 8; i++)
1924  {
1925    // LED's  ON
1926    MaximCC.setChar(DisplayTime, i, 8, true);
1927  }
1928  // wait before turning  the LED's off
1929  delay(LEDTEST_DELAY_DISPLAYS);
1930  // clear display
1931  MaximCC.clearDisplay(DisplayTime);
1932  //---------------------------------------------------------------------
1933  //  Date display
1934  for (int i = 0; i < 8; i++)
1935  {
1936    // LED's ON
1937    MaximCC.setChar(DisplayDate,  i, 8, true);
1938  }
1939  // wait before turning the LED's off
1940  delay(LEDTEST_DELAY_DISPLAYS);
1941  // clear display
1942  MaximCC.clearDisplay(DisplayDate);
1943  //---------------------------------------------------------------------
1944  // Temp and Week display
1945  for (int i = 0; i < 8; i++)
1946  {
1947    // LED's  ON
1948    MaximCC.setChar(DisplayTempWeek, i, 8, true);
1949  }
1950  // wait before  turning the LED's off
1951  delay(LEDTEST_DELAY_DISPLAYS);
1952  // clear display
1953  MaximCC.clearDisplay(DisplayTempWeek);
1954  //---------------------------------------------------------------------
1955  // Period-Pulse display
1956  for (int i = 0; i < 8; i++)
1957  {
1958    // LED's  ON
1959    MaximCC.setChar(DisplayPeriodPulse, i, 8, true);
1960  }
1961  // wait before  turning the LED's off
1962  delay(LEDTEST_DELAY_DISPLAYS);
1963  // clear display
1964  MaximCC.clearDisplay(DisplayPeriodPulse);
1965  //---------------------------------------------------------------------
1966  // Buffer-DCFbit-Errors display
1967  for (int i = 0; i < 8; i++)
1968  {
1969    //  LED's ON
1970    MaximCC.setChar(DisplayBufferBitError, i, 8, true);
1971  }
1972  //  wait before turning the LED's off
1973  delay(LEDTEST_DELAY_DISPLAYS);
1974  // clear  display
1975  MaximCC.clearDisplay(DisplayBufferBitError);
1976}
1977
1978//================================================================================================================
1979//
1980//  Function name : configureDS18B20
1981// called from   : <setup>
1982//
1983// Purpose       : ON TIME function to configure the DS18B20 temperature sensor,
1984//                 setting  the desired temperature resolution
1985// Parameters    : none
1986// Return value  : none
1987//
1988//================================================================================================================
1989
1990void  configureDS18B20()
1991{
1992  // This is done ONCE in setup()
1993
1994  // INITIALIZATION
1995  // All transactions on the 1-Wire bus begin with an initialization sequence.
1996  // The initialization sequence consists of a reset pulse transmitted by the bus  master followed by presence pulse(s) transmitted by the slave(s).
1997  // The presence  pulse lets the bus master know that slave devices (such as the DS18B20) are on the  bus and are ready to operate.
1998
1999  // The initialization sequence consists of  a reset pulse transmitted by the bus master followed by presence pulse(s) transmitted  by the slave(s).
2000  ds.reset();
2001
2002  // use this command when only 1 sensor  is used to avoid specifying the address!
2003  ds.skip();
2004
2005  // Select a specific  DS18x20 device
2006  //byte addr[8] = {0x28, 0xF0, 0xEC, 0xE2, 0x04, 0x00, 0x00,  0x47};
2007  //ds.select(addr);
2008
2009  // WRITE SCRATCHPAD
2010  // This command  allows the master to write 3 bytes of data to the DS18B20s scratchpad.
2011  // The  first data byte is written into the TH register (byte 2 of the scratchpad), the  second byte is written into the TL register (byte 3),
2012  // and the third byte  is written into the configuration register (byte 4).
2013  // Data must be transmitted  least significant bit first. All three bytes MUST be written before the master issues  a reset,
2014  // or the data may be corrupted.
2015  ds.write(0x4E);
2016
2017  //  write zero into the alarm register HIGH
2018  ds.write(0);
2019  // write zero into  the alarm register LOW
2020  ds.write(0);
2021  /* Next, write R1 and R2 into the  configuration register to select the precision of the temperature
2022   value |  resolution | conversion time | increments
2023     0   =   9 bits   |   93,75 ms      | 0,5 Celsius
2024     1   =  10 bits   |   187,5 ms      | 0,25
2025     2   =  11 bits   |   375 ms        | 0,125
2026     3   =  12 bits   |   750 ms        |  0,0625
2027   CONFIGURATION REGISTER:
2028   ------ Bit ------
2029   7  6  5  4  3  2  1  0
2030   0  R1 R0 1  1  1  1  1
2031   */
2032  ds.write(B01111111);
2033  //  WRITE SCRATCHPAD DATA TO EEPROM
2034  ds.reset();
2035  // use this command when only  1 sensor is used to avoid specifying the address!
2036  ds.skip();
2037  // Select  a specific DS18x20 device
2038  //ds.select(addr);
2039
2040  // COPY SCRATCHPAD [48h]
2041  // This command copies the contents of the scratchpad TH, TL and configuration  registers (bytes 2, 3 and 4) to EEPROM.
2042  // If the device is being used in parasite  power mode, within 10s (max) after this command is issued the master must
2043  //  enable a strong pullup on the 1-Wire bus for at least 10ms as described in the Powering  the DS18B20 section.
2044  ds.write(0x48);
2045}
2046