DCF77 Analyzer / Clock v2.0

Sobre este projeto

• código totalmente reescrito
• comentou extensivamente, então espero que qualquer pessoa possa entender o que está acontecendo
• adicionou um sensor de movimento PIR para reduzir o consumo de energia
• adicionou o DCF77 Superfilter
• display extra para temperatura ou outro uso (como hora do nascer / pôr do sol)

Demonstração

Construído em 'Relógio de pêndulo'

O Design

Código

• DCF Analyzer / Clock v2.1
• esboço do Superfilter

DCF Analyzer / Clock v2.1 Arduino

 / * ============================================================================================DCF77 Analyzer / Relógio versão 2 ==========================================================================================Este esboço é um software livre; você pode redistribuí-lo e / ou modificá-lo sob os termos da GNU Lesser General Public License conforme publicada pela Free Software Foundation; tanto a versão 2.1 da Licença, ou (por sua opção) qualquer versão posterior. Este esboço é distribuído na esperança de que seja útil, mas SEM NENHUMA GARANTIA; sem mesmo a garantia implícita de COMERCIALIZAÇÃO ou ADEQUAÇÃO A UM DETERMINADO FIM. Consulte a GNU Lesser General Public License para obter mais detalhes. Você deve ter recebido uma cópia da GNU Lesser General Public License junto com esta biblioteca; caso contrário, escreva para Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ========================================================================================Este código C ++ está longe de ser otimizado porque eu mesmo sou um Arduino e novato em C ++. Mas mesmo depois de aprender um pouco mais agora, quero manter o código simples e legível. É por isso que talvez eu tenha super documentado o código para ajudar a entender o que está acontecendo. Erik de Ruiter 2014-2020 Maio 2014 Primeira versão Março 2016 - grande revisão ... Julho 2016 - Comece construindo o 2.0 Clock e adaptando o sketch Versão 2.1 data 2020-01-18 - Função Powersafe corrigida. Versão 2.0 - Este esboço é adaptado para minha versão 2.0 do DCF / Analyzer Clock. Ele usava o Arduino MEGA e o DCF Superfilter por padrão e, para acionar os muitos LEDs separados, agora uso as portas de um Arduino Mega em vez de um chip Maxim 7219. Isso ocorre porque acionar LEDs com muitas especificações diferentes de tensão / corrente é problemático com o chip Maxim. A iluminação de LEDs adicionais para amostra irá influenciar (diminuir) os LEDs já acesos. Como não sou engenheiro eletrônico, minha única solução foi usar as portas extras do Arduino Mega. Claro que você pode usar transistores ou chips extras para acionar os LEDs, mas para mim essa era a solução óbvia. - Removido todo o código de exibição Maxim Common Anode Versão 1.72 - Opção:Use um detector Ebay PIR barato para desligar o display selecionável quando nenhuma atividade for detectada. O retardo para desligar pode ser definido pelo usuário para evitar o desligamento da tela se uma pessoa não estiver se movendo, mas a tela deveria estar ligada. - Agora, o desligamento noturno da exibição pode ser desabilitado tornando ambos os valores 'POWERSAVINGOFFTIME' e 'POWERSAVINGONTIME' zero. - Corrigida a exibição de temperatura não desligando no modo de economia de energia. - O display errorCounter não zera a cada hora - corrigido Versão 1.71 - Opção do usuário para zerar a memória mín. / máx. de temperatura à meia-noite Versão 1.7:- A resolução do display de temperatura é melhorada:de 0,5 a 0,1 graus Celsius Por causa do tempo do sensor DS18B20 precisa converter a temperatura e manter o código limpo, a exibição da temperatura é atualizada uma vez por minuto. - Rotina de verificação de paridade otimizada. - Verificação mais confiável de dados DCF inválidos, evitando a atualização do RTC com dados inválidos. - O erro EoB agora limpa o anel interno do LED como deveria. - O LED DCF OK agora exibe a condição do sinal DCF de forma mais confiável. Desliga imediatamente se ocorrer um erro e só liga quando todos os 3 bits de paridade estão OK. Versão 1.6:- Função de temperatura alterada para calcular apenas uma vez por minuto. Tive erros estranhos antes da mudança porque usei um atraso de 100ms para dar tempo ao sensor DS18B20 para calcular a temperatura. Mas a função de atraso é uma ideia muito ruim na maioria dos códigos C ++, então finalmente me livrei dela. Versão 1.5:- Revisão completa da função scanSignal e do resto do código! Minha primeira tentativa funcionou, mas poderia ser melhorada ... - Os led's rPW e rPT não funcionaram como eu pretendia, então isso está corrigido agora. - A rotina de verificação de erro de Fim de Buffer funciona agora como deveria. - Eu incorporei uma verificação de paridade do sinal DCF de entrada. No sinal, 3 bits de paridade são enviados, então agora eles são verificados e somente se todos os três estiverem OK, a informação de tempo recebida é aceita, o display é atualizado e o RTC sincronizado. se desejar, você pode conectar 3 LEDs extras de duas cores (cátodo comum) para ver se cada um dos 3 bits de paridade está OK ou falhou. - Tornei a fiação (ou troca) muito mais fácil, acho, colocando toda a configuração do PIN em uma tabela fácil de ler - Contanto que você use 1 temp DS18B20. sensor, editei o código para que você não precise mais descobrir o endereço do dispositivo I2C. - Grande limpeza do código ... - Economia de energia desligando os visores (o relógio permanece funcionando normalmente) agora pode ser configurada um pouco mais facilmente editando duas variáveis ​​POWERSAVINGONTIME e POWERSAVINGOFFTIME. - alterou alguns nomes de variáveis:- Instâncias de Maxim 'lc' e 'lc1' agora são MaximCC e MaximCA - Descrição de exibição MaximDcfTime agora é DisplayTempWeek - DCF77SOUNDPIN agora é BUZZERSWITCHPIN - Teste de LED / monitor após a inicialização agora construído em Descrição resumida:Ligar:Depois de ligar, primeiro é executado um teste de LED. Os LEDs e visores iluminam-se sequencialmente para manter o baixo consumo de energia. Em seguida, o relógio começa a receber pulsos DCF e quando uma marca de minuto (intervalo de 2 segundos) é detectada, o LED do marcador de minuto acende e o contador de buffer é zerado. O anel de LED interno agora mostrará os pulsos DCF de entrada que também estão armazenados no buffer. Em 3 momentos durante a recepção de dados, os bits DCF de paridade são verificados para ver se os dados são válidos. Dados válidos recebidos:Quando, no final do minuto, após a marca do minuto ser detectada (LED BF (Buffer Cheio) aceso), todos os três bits de paridade estão OK (LED 'DCF OK' está aceso), as informações do buffer estão usado para extrair informações de hora e data. Em seguida, o relógio RTC é atualizado (o LED 'RTC Synced' acende) e as informações do anel interno do LED são copiadas para o anel externo do LED. As informações de hora, data e semana, LED diurno, verão / inverno e ano bissexto são atualizadas com as novas informações de hora. Sem dados válidos:Quando um ou mais bits de paridade não estão OK devido a um sinal ruidoso, o recebimento de informações DCF é continuado, mas não será usado para atualizar o RTC, display's e LEDs. O anel de LED externo, os LEDs 'RTC sincronizado' e 'DCF OK' serão reiniciados. LED de hora, data, semana, dia, LED verão / inverno e LED de ano bissexto não são afetados e continuam exibindo os últimos valores válidos recebidos. Os LEDs de erro 'Período de tempo' e / ou 'Período com' indicarão o (s) erro (s) e a tela do contador de erros será atualizada. A cada hora, a exibição de erro será definida como zero. O LED EoB, End of Buffer acende quando mais pulsos DCF são recebidos antes que a Marca de Minuto seja detectada devido a um sinal ruidoso. (Quando uma marca de minuto é detectada, não devemos ter mais do que 58 bits / pulsos) Após a detecção da marca de minuto, um novo ciclo é iniciado. Temperatura:Na marca de 30 segundos, o display de temperatura mostrará os valores alto e baixo do período anterior após a última reinicialização. Campainha:Se a chave CHIME estiver ON / HIGH, então no início de cada hora, a campainha (se conectado) soará À noite, um horário definido pelo usuário no próprio código, a campainha é desabilitada. Economia de energia - tela desligada Isso só funcionará SE o botão Economia de energia estiver ALTO:1. DESLIGAMENTO À NOITE Em horários definidos pelo usuário, as telas são desligadas à noite e ligadas pela manhã. Observe as variáveis ​​POWERSAVINGOFFTIME e POWERSAVINGONTIME. Verifique a função  para selecionar QUAIS os visores que deseja desligar à noite. 2. SENSOR PIR Conecte um sensor PIR e ative a opção PIR POWERSAVE_BY_PIR e o atraso em PIR_DELAY_TIME. Cada vez que o detector PIR detecta movimento, um contador de minutos é zerado, mas se nenhum movimento for detectado por mais tempo do que PIR_DELAY_TIME, os visores são desligados. Quando ocorre um movimento, os visores ligam-se imediatamente. Nota:como dito antes, o relógio funcionará normalmente enquanto os visores estiverem desligados. Sinal sonoro DCF:Com um interruptor, conectado ao pino BUZZERSWITCHPIN, você pode ouvir os bits DCF recebidos. A duração do tom é equivalente à largura de pulso dos bits DCF, ou seja, 100 ou 200 ms. Diversos:Quando a bateria RTC está vazia ou uma falha de conexão é detectada, o LED de erro RTC acende. CRÉDITOS:Aprendi muito com o trabalho de Matthias Dalheimer e Thijs Elenbaas que fizeram seus próprios decodificadores DCF77. Sem o trabalho deles, eu não saberia por onde começar. Acabei escrevendo meu próprio código (usando pedaços de suas ideias) para poder entender o que está acontecendo ... Meu código está longe de ser eficiente ou avançado, mas funciona e eu sei o que está acontecendo. Sites interessantes:- Brett Oliver:http://home.btconnect.com/brettoliver1/ - Joop Tap:http://www.jooptap.nl - Thijs Ellenbaas:http://thijs.elenbaas.net/2012/04/ arduino-dcf77-radio-clock-receiver-hardware-2 / - Mathias Dalheimer:https://github.com/roddi/DCF77-Arduino/blob/master/DCF77Servoclock/DCF77.h - DCF77 wikipedia:https:// en .wikipedia.org / wiki / DCF77 - Muito mais informações DCF77:http://www.picbasic.nl/indexes_uk.htm - Meu site do Flickr:https://www.flickr.com/photos/edr1924/albums - Meu Github site:https://github.com/deruiter * /// ----------------------------------- -------------------------------------------------- --------------------- // Bibliotecas // ------------------------ -------------------------------------------------- -------------------------------- // Arduino (novo) Biblioteca de tempo .......... .......................... http://www.pjrc.com/teensy/td_libs_Time.html#include  // Habilite esta linha se estiver usando Arduino Uno, Mega, etc. # include  // uma biblioteca DS1307 básica y que retorna o tempo como um time_t .......... http://www.pjrc.com/teensy/td_libs_DS1307RTC.html#include  // Maxim 7219 exibe a biblioteca ..... .............................. http://playground.arduino.cc/Main/LEDMatrix// !!! NOTA:você deve usar uma versão especial da biblioteca Ledcontrol.h para obter suporte Common Anode // porque o chip Maxim normalmente só é adequado para exibições CATHODE comuns! #Include  // Biblioteca de interface SPI .... ...................................... http://arduino.cc/en/Reference/ SPI # include  // OneWire permite acessar dispositivos de 1 fio feitos por Maxim / Dallas, // como DS18S20, DS18B20, DS1822 ................. ............. http://www.pjrc.com/teensy/td_libs_OneWire.html// A biblioteca DallasTemperature pode fazer todo esse trabalho para você! ... http://milesburton.com/Dallas_Temperature_Control_Library#include  // ----------------------------- -------------------------------------------------- --------------------------- // Conexões do Arduino UNO Pin em uma tabela de fácil leitura //// input - Rx - usado para programação / comunicação com PC // saída - Tx - usado para programação / comunicação com PC # define DCF77PIN 2 // entrada - sinal DCF da antena pcb. O pino deve ser uma entrada de interrupção! #Define PIRDETECTORPIN 3 // entrada - detector PIR:verifique a atividade na sala para ativar os visores # define BUZZERSWITCHPIN 4 // entrada - SWITCH - liga / desliga DCF77 'beep' piezo buzzer / ON =HIGH , OFF =LOW # define CHIMESWITCHPIN 5 // entrada - SWITCH - liga / desliga o som do carrilhão de hora em hora / ON =HIGH, OFF =LOW # define POWERSAVESWITCHPIN 6 // entrada - SWITCH - liga / desliga o recurso de economia de energia para exibir está sempre ligado / LIGADO =ALTO, DESLIGADO =BAIXO # define TEMPSENSORPIN 8 // entrada - Sensor de temperatura Dallas One Wire DS18B20 # define TEMPRESETPIN 9 // entrada - BOTÃO PUSH - redefine a temperatura min / max memória / HIGH =redefine # define MAXIMCCLD 10 // saída - CS / LOAD - conexão pseudo SPI ao chip Maxim 7219 - displays de 7 segmentos # define MAXIMCCCLK 11 // saída - CLOCK - conexão pseudo SPI ao chip Maxim 7219 - displays de 7 segmentos # define MAXIMCCDATA 12 // saída - DATA - conexão pseudo SPI ao chip Maxim 7219 - displays de 7 segmentos // !! Os pinos 22 a 53 devem ser usados ​​apenas para LEDs # define LED_SUNDAY 22 // saída - LED - Domingo # define LED_MONDAY 23 // saída - LED - Segunda-feira # define LED_TUESDAY 24 // saída - LED - Terça # define LED_WEDNESDAY 25 // saída - LED - quarta-feira # define LED_THURSDAY 26 // saída - LED - quinta # define LED_FRIDAY 27 // saída - LED - sexta-feira # define LED_SATURDAY 28 // saída - LED - sábado # define LED_CEST 29 // saída - LED - Summertime CEST #define LED_CET 30 // saída - LED - Horário de inverno CET # define LED_LEAPYEAR 31 // saída - LED - Ano bissexto # define LED_RTCERROR 32 // saída - LED - problema de leitura de dados RTC (bateria vazia / conexão) #define LED_RTCSYNC 33 // saída - LED - Ligado quando o RTC é sincronizado com sucesso com o tempo DCF # define LED_TEMP 34 // saída - LED - temperatura é exibida # define LED_OPTION1 35 // saída - LED - dados opcionais 1 são exibidos # define LED_OPTION2 36 // saída - LED - 2 dados opcionais são exibidos # define LED_ERRORPT 37 // saída - LED - DCF Período Erro de tempo # define LED_ ERRORPW 38 // saída - LED - DCF Período Width erro # define LED_BUFFERFULL 39 // saída - LED - Indicador de buffer cheio, a seguir os dados serão analisados ​​# define LED_MINUTEMARKER 40 // saída - LED - Fim do fluxo de dados DCF detectado antes do buffer está preenchido, os dados estão corrompidos # define LED_BUFFEROVERFLOW 41 // saída - LED - Mais dados recebidos em um minuto do que o esperado devido a sinal ruim # define LED_DCFSTATUS 42 // saída - LED - Ligado quando temos dados DCF bons # define LED_POWERSAVE 43 / / saída - LED - Modo de economia de energia está ativado, alguns visores estão desligados # define LED_PARITY1PASS 44 // saída - LED - Paridade 1 bit está OK # define LED_PARITY1FAIL 45 // saída - LED - Paridade 1 bit FALHA # define LED_PARITY2PASS 46 // saída - LED - Paridade 2 bit está OK # define LED_PARITY2FAIL 47 // saída - LED - Paridade 2 bit FALHA # define LED_PARITY3PASS 48 // saída - LED - Paridade 3 bit está OK # define LED_PARITY3FAIL 49 // saída - LED - Paridade 3 bit FAILED # define LED_PIRMOTION 50 // output - LED - On quando PIR está detectando movimento / / Pinos analógicos # define BUZZER A7 // saída - Buzzer piezo para DCF77 'beep' (para '+' do buzzer) #define SPEAKERVOLPIN A6 // saída - Volume da placa de som - LOW =volume um nível abaixo. SPEAKERVOLUME determina quantas vezes esta saída é ativada após ligar # define CHIMEPIN A5 // output - Chime Ativar - OUTPUT LOW =Ativar Chime no Adafruit Soundboard FX // USADO para DS1307 RTC // I2C DATA - conectar ao Real Time Clock pcb / / USADO para DS1307 RTC // I2C CLOCK - conectar ao relógio em tempo real pcb // -------------------------------- -------------------------------------------------- ------------------------ // Inicialização do DS18B20 // -------------------- -------------------------------------------------- ------------------------------------ OneWire ds (TEMPSENSORPIN); // define a instância Onewire DS // ------------------------------------------ -------------------------------------------------- -------------- // Inicialização do Maxim 7219 Matrix Display // --------------------------- -------------------------------------------------- ----------------------------- / * clearDisplay (int addr) .............. ............................... limpa o display selecionado MaximCC.shutdown (int addr, boolean) ...... .......................... despertar o MAX72XX do modo de economia de energia (true =sleep, false =awake) MaximCC.setIntensity (int addr , valor) .............................. definir um brilho médio para os Leds (0 =min - 15 =max) MaximCC .setLed (int addr, int row, int col, boolean state) .......... liga o led em linha, coluna. lembre-se de que os índices começam em 0! MaximCC.setRow (int addr, int row, byte value) ...................... esta função leva 3 argumentos. exemplo:MaximCC.setRow (0,2, B10110000); MaximCC.setColumn (int addr, int col, valor do byte) ................... esta função leva 3 argumentos. exemplo:MaximCC.setColumn (0,5, B00001111); MaximCC.setDigit (int addr, int dígito, valor do byte, boolean dp) ...... esta função recebe um argumento do tipo byte e imprime o dígito correspondente na coluna especificada. O intervalo de valores válidos vai de 0 a 15. Todos os valores entre 0..9 são impressos como dígitos, valores entre 10..15 são impressos como seu equivalente hexadecimal MaximCC.setChar (int addr, int dígito, char value, boolean dp) ....... exibirá:0 1 2 3 4 5 6 7 8 9 ABCDEFHLP; -. , _  (o caractere em branco ou espaço) POWERSAVESWITCHPIN ***** Por favor, defina o número de dispositivos que você tem ***** Mas o padrão máximo de 8 MAX72XX também funcionará. LedConrol (DATAIN, CLOCK, CS / LOAD, NUMBER OF MAXIM CHIPS) * /// lc é para Maxim displaysLedControl MaximCC =LedControl (MAXIMCCDATA, MAXIMCCCLK, MAXIMCCLD, 7, falso); // Definir pinos para Maxim 72xx e quantos 72xx usamos // ----------------------------------- -------------------------------------------------- --------------------- // Configurações do usuário, variáveis ​​e definições de array // ------------------ -------------------------------------------------- -------------------------------------- // O valor abaixo não é um número PIN, mas um valor para definir quantas vezes a entrada de 'Abaixar o volume' na placa de som é ativada // de modo que o volume da placa de som possa ser diminuído após ligar, se desejado. # define SPEAKERVOLUME 12 // Escolha se você deseja um teste de todos os LEDs e monitores após uma inicialização // '1' =Sim, '0' =Não # define PERFORM_LED_TEST 1 // Atraso entre cada display de 7 segmentos em ms # define LEDTEST_DELAY_DISPLAYS 600 // Atraso entre cada LED no anel de LED e outros LEDs em ms # define LEDTEST_DELAY_LED_RING 20 // Escolha se deseja configurar o sensor de temperatura DS18B20 UMA VEZ para a resolução mais alta.// isso é necessário após usar o sensor para o primeiro primeira vez. Depois de executar o software // com esta configuração ON uma vez, desligue-o.// '1' =ON, '0' =OFF # define CONFIGURE_DS18B20 0 // POWERSAVE TIME - valores OBRIGATÓRIOS! //// para definir o dia e período noturno. Isso é usado para a hora de LIGAR e DESLIGAR a exibição de economia de energia // E para determinar se o sinal sonoro será ativado (durante o dia) .//// APENAS as exibições são desligadas na hora de economia de energia, o relógio permanece totalmente ativo./ / PARA DESATIVAR o desligamento do monitor a qualquer momento, basta definir o botão de economia de energia para OFF //// Botão de economia de energia ON:os monitores serão desligados no período noturno definido // E se a função POWERSAVE_BY_PIR for ativada e lá não há // movimento para o conjunto PIR_DELAY_TIME.// Interruptor de economia de energia DESLIGADO:exibe sempre ligado, toca apenas durante o dia.//// os valores estão no formato 'Hora', então 20h será '20', NÃO 20:00 ou 20h ... # define POWERSAVINGOFFTIME 9 // monitores são ativados # define POWERSAVINGONTIME 22 // monitores são desligados // Opção do usuário:ativar os monitores apenas quando houver atividade na sala // '1' =ON, '0 '=OFF # define POWERSAVE_BY_PIR 1 // atraso em MINUTOS para esperar após nenhuma detecção antes de desligar os visores # define PIR_DELAY_TIME 30 // Opção do usuário para redefinir a temperatura min / memória máxima à meia-noite // '1' =Reinicializar à meia-noite, '0' =Somente reinicialização manual # define TEMPRESET_MIDNIGHT 1 // ---------------------- -------------------------------------------------- ------- // define parâmetros diversos # define DS1307_I2C_ADDRESS 0x68 // define o endereço RTC I2C # define DCF_INTERRUPT 0 // Número de interrupção associado ao pino // definição do número de exibição Maxim 7219 sequência de fiação // primeiro Maxim 7219 em wiring 'daisychain' deve ser '0', próximo '1' etc.// COMMON CATHODE DISPLAYS # define LedRingInner 0 # define LedRingOuter 1 # define DisplayBufferBitError 2 # define DisplayPeriodPulse 3 # define DisplayTempWeek 4 # define DisplayDate 5 # define DisplayTime 6 / / definição dos níveis de brilho do display # define BrightnessLedRingOuter 1 # define BrightnessLedRingInner 1 # define BrightnessDisplayTime 1 # define BrightnessDisplayDate 7 # define BrightnessDisplayTempWeek 15 # define BrightnessDisplayPeriodPulse 2 # define BrightnessDisplayBufferBitError 15 // flanksigned tatic unsigned long trailingEdge =0; unsigned long previousLeadingEdge =0; // usado em  volatile unsigned int DCFSignalState =0; // interromper variáveis ​​SEMPRE precisam de qualificador volátil !! // usado em 
 int previousSecond =0; unsigned int previousSignalState =0; // Buffers DCF e indicadoresstatic int DCFbitBuffer [59]; // aqui, os DCFbits recebidos são armazenadosconst int bitValue [] ={1, 2, 4, 8, 10, 20, 40, 80}; // estes são os valores decimais dos DCFbits recebidos // somente após iniciar em um novo minuto, exibe os bits recebidos no LED interno ringboolean MinuteMarkerFlag =false; int bufferPosition =0; int previousMinute =0; int previousHour =0; // variáveis para verificar se os bits DCF são valdbool dcfValidSignal =false; int dcfP1counter =0; int dcfP2counter =0; int dcfP3counter =0; int dcfParityCheckP1 =0; int dcfParityCheckP2Fcoded3 =0; int dcfParityCheckP1 =0; int dcfParityCheckParityCodificado3 =0; int dcfParityCheckParityCarity3 =0; inint dcfMinute =0; int dcfHour =0; int dcfDay =0; int dcfWeekDay =0; int dcfMonth =0; int dcfYear =0; int dcfDST =0; int leapYear =0; // variáveis ​​usadas para armazenar os valores da semana e do daynumerint dayNumber; int weekNumber; // contador de erros variableint errorCounter =0; boolean errorCondition =false; // variáveis ​​diversasboolean daytimeChange =true; boolean dayTime =false; int dcf77SoundSwitch =0; // temperatura variablesbyte present =0; byte DS18B20Data [12]; int maxTemp =0; int minTemp =0; int lowByte =0; int hi ghByte =0; float tempReading =0; int tempCelsius =0; boolean tempResetButton =false; // variáveis ​​do detector PIRint pirActivity =0; int pirDisplaysState =1; sem sinal int pirTimer =0; sem sinal long previousTimePIR =0; // ==========================================================================================// CONFIGURAÇÃO // ======================================================================================void setup () {// inicializar a comunicação serial Serial.begin (9600); // inicializa as conexões PIN pinMode (DCF77PIN, INPUT); pinMode (TEMPRESETPIN, INPUT); pinMode (BUZZERSWITCHPIN, INPUT); pinMode (CHIMESWITCHPIN, INPUT); pinMode (POWERSAVESWITCHPIN, INPUT); pinMode (PIRDETECTORPIN, INPUT); pinMode (CHIMEPIN, OUTPUT); pinMode (SPEAKERVOLPIN, OUTPUT); // inicializa os pinos de LED 22 - 50 para (int i1 =22; i1 <=50; i1 ++) {pinMode (i1, OUTPUT); } // Inicializar variáveis, displays de LED e inicializar LED (); // Inicializa a interrupção de pulso DCF77 no pino DCF_INTERRUPT, procurando por uma mudança no sinal, // então os pulsos de borda ascendente ou descendente irão acionar o manipulador de interrupção e // executar a função int0handler. attachInterrupt (DCF_INTERRUPT, int0handler, CHANGE); // Inicialize o RTC e defina como SyncProvider. // Posteriormente, o RTC será sincronizado com o horário DCF setSyncProvider (RTC.get); // a função para obter a hora do RTC // verificar se o RTC definiu a hora do sistema if (timeStatus ()! =timeSet) {// Incapaz de sincronizar com o RTC - ativar RTCError LED digitalWrite (LED_RTCERROR, HIGH); } else {// RTC definiu a hora do sistema - dim RTCError LED digitalWrite (LED_RTCERROR, LOW); } // Depois de ligar, defina o volume do alto-falante da placa de áudio Adafruit // inicialize ambos os pinos para BAIXO, que é o estado de saída padrão digitalWrite (SPEAKERVOLPIN, LOW); digitalWrite (CHIMEPIN, LOW); // abaixe o volume padrão da placa de som com etapas de 'SPEAKERVOLUME' para (int i =0; i <=SPEAKERVOLUME; i ++) {digitalWrite (SPEAKERVOLPIN, HIGH); atraso (100); digitalWrite (SPEAKERVOLPIN, LOW); atraso (100); } // A função a seguir deve ser executada apenas uma vez. // É utilizado para configurar a resolução de temperatura do sensor DS18B20 if (CONFIGURE_DS18B20 ==1) {configureDS18B20 (); } // usar para fins de teste e / ou definir a hora RTC manualmente // setTime (23, 59, 40, 31, 12, 13); // RTC.set (now ()); // Solicita a conversão de temperatura calculeTemp (); // verifique se um teste de LED é necessário if (PERFORM_LED_TEST ==1) {// faça um teste de LED ledTest (); } else {// se não estiver fazendo um teste de LED, precisamos esperar um pouco para que o sensor DS18B20 fique pronto delay (750); } // Agora pegue a temperatura do sensor e exiba-a displayTemp (); // ativa a exibição de errorCounter após o teste de LED ledDisplay (DisplayBufferBitError, "R", 0);} // ========================================================================================// LOOP // ======================================================================================void loop () {// verifique primeiro se a direção do pulso é alterada (crescente ou caindo) // caso contrário, continuaríamos avaliando o mesmo pulso if (DCFSignalState! =previousSignalState) {// 'redefinir' estado da variável previousSignalState =DCFSignalState; // avalia o pulso de entrada scanSignal (); } // verifique se os interruptores foram alterados e atue sobre eles checkSwitches (); // verifica o movimento do PIR checkPIR (); // executa tarefas que devem acontecer apenas uma vez a cada segundo, minuto ou hora // --------------------------------- ------------------------------------------- tasksEverySecond (); tasksEveryMinute (); tasksEveryHour ();} // ================================================================================================================================//// Nome da função:processDcfBit // chamado de: //// Objetivo:Avaliar o sinal conforme ele é recebido. Decide se recebemos um "1" ou um "0" // e realiza verificações para ver se o tempo de pulso está dentro dos limites // Parâmetros:nenhum // Valor de retorno:nenhum //// ================================================================================================================================/ * largura de largura de pulso de pulso | - - | | - - | | ----- FIM DO MINUTO marcador:2000ms ----- | ___ _______ ___ ___ _______ | 0 | | 1 | 0 | | 0 | | 1 | | | | | | | | | | | | | | | | | | | | ______ | | _______________ | | ___________ | | ___________________________________ | | _______________ | | __ _ _ _ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ 1000 2100 2000 2200 3000 3100 SEM PULSO 5000 5100 6000 6200 < REJECTED error(LED_ERRORPW); errorCondition =true; } //-------------------------------------------------------------------------------- // CHECK PULSE TIME //-------------------------------------------------------------------------------- // If the detected pulse is too short it will be an incorrect pulse that we shall reject // should be 100 and 200 ms ideally if (((trailingEdge - leadingEdge) <70) || ((trailingEdge - leadingEdge)> 230)) { //rPT - ERROR:Pulse Width too short or too long -> REJECTED error(LED_ERRORPT); errorCondition =true; } // if we had an error return and start over if (errorCondition ==true) { errorCondition =false; // although we have an error, store current rising edge time to compare at the next Rising-Edge. previousLeadingEdge =leadingEdge; Retorna; } //-------------------------------------------------------------------- // no errors found so now we can continue //-------------------------------------------------------------------- // first we turn any error Led's OFF digitalWrite(LED_ERRORPW, LOW); digitalWrite(LED_ERRORPT, LOW); digitalWrite(LED_BUFFERFULL, LOW); // previous BF digitalWrite(LED_BUFFEROVERFLOW, LOW); // previous EoB digitalWrite(LED_MINUTEMARKER, LOW); // previous EoM // END OF MINUTE check, looking for a gap of approx. 2000ms if (leadingEdge - previousLeadingEdge> 1900 &&leadingEdge - previousLeadingEdge <2100) { // end of minute detected:finalizeBuffer(); } // refresh previousLeadingEdge time with the new leading edge time previousLeadingEdge =leadingEdge; //-------------------------------------------------------------------------------- // process DCF bits //-------------------------------------------------------------------------------- // distinguish between long and short pulses if (trailingEdge - leadingEdge <170) { // call processDcfBit function and sent it the value '0' processDcfBit(0); // if switch is HIGH, the DCF pulses are audible if (dcf77SoundSwitch ==1) buzzer(100); } else { // call processDcfBit function and sent it the value '1' processDcfBit(1); // if switch is HIGH, the DCF pulses are audible if (dcf77SoundSwitch ==1) buzzer(200); } } // if (DCFSignalState ==0)} // void scanSignal();//================================================================================================================//// Function name :processDcfBit// called from ://// Purpose :after reception of one good DCF bit, do some checks and save it in the DCFbitBuffer array// Parameters :none// Return value :none////================================================================================================================void processDcfBit(int dcfBit){ //-------------------------------------------------------------------- // display values on the 7 segment displays //-------------------------------------------------------------------- // display bufferPosition, digits 7,6 MaximCC.setChar(DisplayBufferBitError, 7, bufferPosition / 10, false); MaximCC.setChar(DisplayBufferBitError, 6, bufferPosition % 10, false); // display received DCFbit, digit 4 MaximCC.setChar(DisplayBufferBitError, 4, dcfBit, false); //-------------------------------------------------------------------- // display incoming DCF bits on inner LED ring //-------------------------------------------------------------------- // only if we have valid DCF data or after an Minute Mark (EoM) signal // activate the inner LED ring and diplay incoming data if (dcfValidSignal ==true || MinuteMarkerFlag ==true) { // display received bits on inner LED ring MaximCC.setLed(LedRingInner, bufferPosition / 8, bufferPosition % 8, dcfBit); } //-------------------------------------------------------------------- // // Fill DCFbitBuffer array with DCFbit //-------------------------------------------------------------------- DCFbitBuffer[bufferPosition] =dcfBit; //-------------------------------------------------------------------- // Parity check //-------------------------------------------------------------------- // DURING reception of the DCF bits, calculate and display the results of the DCF parity check. // // There is a Parity bit for the minutes, the hours and for the date. // DCF77 works with EVEN parity, this works as follows:// The hours for example have 6 bits plus a paritybit. The bits with value 1 are add up including the paritybit, // 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, // then the result is uneven. source:http://www.picbasic.nl/frameload_uk.htm?http://www.picbasic.nl/info_dcf77_uk.htm if (bufferPosition ==0) { // reset the parity LED's digitalWrite(LED_PARITY1PASS, LOW); digitalWrite(LED_PARITY1FAIL, LOW); digitalWrite(LED_PARITY2PASS, LOW); digitalWrite(LED_PARITY2FAIL, LOW); digitalWrite(LED_PARITY3PASS, LOW); digitalWrite(LED_PARITY3FAIL, LOW); // reset variables dcfP1counter =0; dcfP2counter =0; dcfP3counter =0; dcfParityCheckP1 =0; dcfParityCheckP2 =0; dcfParityCheckP3 =0; } // ---------------------------------------- // First parity check:minute bits // ---------------------------------------- if (bufferPosition ==28) { for (int i =21; i <=27; i++) { // count the number of bits with the value '1' dcfP1counter +=DCFbitBuffer[i]; } // perform P1 parity check. Parity is OK if the sum is an EVEN value if ((DCFbitBuffer[28] + dcfP1counter) % 2 ==0) { // Parity1 PASS LED ON digitalWrite(LED_PARITY1PASS, HIGH); // Parity P1 PASS dcfParityCheckP1 =1; } else { // Parity1 FAIL LED ON digitalWrite(LED_PARITY1FAIL, HIGH); // we have no valid data! dcfValidSignal =false; // Turn DCF OK LED OFF digitalWrite(LED_DCFSTATUS, LOW); } } // ---------------------------------------- // Second parity check:hour bits // ---------------------------------------- if (bufferPosition ==35) { for (int i =29; i <=34; i++) { dcfP2counter +=DCFbitBuffer[i]; } // perform P2 parity check. Parity is OK if the sum is an EVEN value if ((DCFbitBuffer[35] + dcfP2counter) % 2 ==0) { // Parity2 PASS LED ON digitalWrite(LED_PARITY2PASS, HIGH); // Parity P2 PASS dcfParityCheckP2 =1; } else { // Parity2 FAIL LED ON digitalWrite(LED_PARITY2FAIL, HIGH); // we have no valid data! dcfValidSignal =false; // Turn DCF OK LED OFF digitalWrite(LED_DCFSTATUS, LOW); } } // ---------------------------------------- // Third parity check:date bits // ---------------------------------------- if (bufferPosition ==58) { for (int i =36; i <=57; i++) { dcfP3counter +=DCFbitBuffer[i]; } // perform P3 parity check. Parity is OK if the sum is an EVEN value (DCFbitBuffer[58] + dcfP3counter) % 2 ==0 ? dcfParityCheckP3 =1 :dcfParityCheckP3 =0; // Turn Parity2 'PASS' or 'FAIL' LED ON if (dcfParityCheckP3 ==1) { // Parity2 PASS LED ON digitalWrite(LED_PARITY3PASS, HIGH); // Parity P3 PASS dcfParityCheckP3 =1; } else { // Parity2 FAIL LED ON digitalWrite(LED_PARITY3FAIL, HIGH); // we have no valid data! dcfValidSignal =false; // Turn DCF OK LED OFF digitalWrite(LED_DCFSTATUS, LOW); } // ---------------------------------------- // finally, check all Parity bits // ---------------------------------------- dcfParityCheckP1 + dcfParityCheckP2 + dcfParityCheckP3 ==3 ? dcfValidSignal =true :dcfValidSignal =false; } //-------------------------------------------------------------------- // before continuing with the next bit, increment counter //-------------------------------------------------------------------- bufferPosition++; //-------------------------------------------------------------------- // check if we have not received too many pulses? //-------------------------------------------------------------------- if (bufferPosition> 59) { // Buffer Overflow ERROR - we have received more pulses before reaching // the 2 second 'gap' signalling the end of the minute. //This error may be due to a noisy signal giving addition peaks/dcfBits // So clear both DCFbit displays and start again. // Reset buffer counter bufferPosition =0; // clear inner LED ring MaximCC.clearDisplay(LedRingInner); // turn Buffer Overflow Error LED ON error(LED_BUFFEROVERFLOW); // exit return; } //-------------------------------------------------------------------- // everything OK so we wait for next incoming DCFbit //--------------------------------------------------------------------}//================================================================================================================//// Function name :finalizeBuffer// called from ://// Purpose :Process the succesfully received DCF data of one minute// Parameters :none// Return value :none////================================================================================================================void finalizeBuffer(void){ //-------------------------------------------------------------------- // We are here because of the detected 2 second 'gap'. // Now check if it correspondends with the buffer counter // 'bufferPosition' which should be value 59 //-------------------------------------------------------------------- if (bufferPosition ==59 &&dcfValidSignal ==true) { // bufferPosition ==59 so turn Buffer Full LED ON digitalWrite(LED_BUFFERFULL, HIGH); // Turn DCF OK LED ON digitalWrite(LED_DCFSTATUS, HIGH); // Reset inner LED ring (incoming time information) MaximCC.clearDisplay(LedRingInner); // copy 'contents' of inner LED ring to the outer LED ring (current time information) for (int i =0; i <59; i++) { MaximCC.setLed(LedRingOuter, i / 8, i % 8, DCFbitBuffer[i]); } // process buffer and extract data sync the time with the RTC decodeBufferContents(); // set Arduino time and after that set RTC time setTime(dcfHour, dcfMinute, 0, dcfDay, dcfMonth, dcfYear); RTC.set(now()); // activate Synced LED digitalWrite(LED_RTCSYNC, HIGH); // Reset running buffer bufferPosition =0; // Reset DCFbitBuffer array, positions 0-58 (=59 bits) for (int i =0; i <59; i++) { DCFbitBuffer[i] =0; } // reset flag MinuteMarkerFlag =false; } // if (bufferPosition ==59) //-------------------------------------------------------------------- // The buffer is not yet filled although the 2 second 'gap' was detected. // Can be result of a noisy signal, starting in middle of receiving data etc. // Turn 'Minute Mark' LED ON //-------------------------------------------------------------------- else { digitalWrite(LED_MINUTEMARKER, HIGH); // Clear displays MaximCC.clearDisplay(LedRingInner); MaximCC.clearDisplay(LedRingOuter); // Reset running buffer and start afresh. Now we are in sync with the incoming data bufferPosition =0; // Reset DCFbitBuffer array, positions 0-58 (=59 bits) for (int i =0; i <59; i++) { DCFbitBuffer[i] =0; } // set flag so we can display incoming pulsed on the inner LED ring. MinuteMarkerFlag =true; }}//================================================================================================================//// Function name :decodeBufferContents// called from ://// Purpose :Evaluates the information stored in the buffer.// This is where the DCF77 signal is decoded to time and date information// Parameters :none// Return value :none////================================================================================================================void decodeBufferContents(void){ // Buffer is full and ready to be decoded dcfMinute =bitDecode(21, 27); dcfHour =bitDecode(29, 34); dcfDay =bitDecode(36, 41); dcfWeekDay =bitDecode(42, 44); dcfMonth =bitDecode(45, 49); dcfYear =bitDecode(50, 57); //call function to calculate day of year and weeknumber dayWeekNumber(dcfYear, dcfMonth, dcfDay, dcfWeekDay); // Get value of Summertime DCFbit. '1' =Summertime, '0' =wintertime dcfDST =bitDecode(17, 17); // determine Leap Year leapYear =calculateLeapYear(dcfYear);}//================================================================================================================//// bitDecode//// called from //================================================================================================================int bitDecode(int bitStart, int bitEnd){ // reset 'bitValue-array' counter int i =0; int value =0;...This file has been truncated, please download it to see its full contents.

Superfilter sketchArduino

//// This is the Superfilter sketch I use with the DCF Analyzer/Clock 2.0 // Udo Klein did an amazing job with this filter//// Erik de Ruiter/* Arduino Uno pin connections I used for the DCF Analyzer Clock DCF input ................. A5 (19) =dcf77_sample_pin Output DCF Filtered ....... 12 =dcf77_filtered_pin Output DCF Semi Synthesized A2 (16) =dcf77_semi_synthesized_pin Output DCF Synthesized .... 6 =dcf77_synthesized_pin LED DCF output filtered ... A4 (18) =dcf77_monitor_pin =DCF Monitor LED LED 1 Hz pulse ............ 10 =dcf77_second_pulse_pin =Filter Locked LED LED DCF OK ................ 13 =dcf77_signal_good_indicator_pin =Signal Quality LED LED Difference Filtered ... 7 =dcf77_filter_diff_pin \ LED Difference Semi Synth.. A0 =dcf77_semi_synthesized_diff_pin -> =Signal Difference LED LED Difference Synthesized 4 =dcf77_synthesized_diff_pin /*/ //// www.blinkenlight.net//// Copyright 2014, 2015 Udo Klein//// This program is free software:you can redistribute it and/or modify// it under the terms of the GNU General Public License as published by// the Free Software Foundation, either version 3 of the License, or// (at your option) any later version.//// This program is distributed in the hope that it will be useful,// but WITHOUT ANY WARRANTY; without even the implied warranty of// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the// GNU General Public License for more details.//// You should have received a copy of the GNU General Public License// along with this program. If not, see http://www.gnu.org/licenses/#include /*const uint8_t pon_pin =51; // connect pon to ground !!!const uint8_t data_pin =19;const uint8_t gnd_pin =51;const uint8_t vcc_pin =49;*/const uint8_t dcf77_analog_samples =false;const uint8_t dcf77_analog_sample_pin =5;const uint8_t dcf77_sample_pin =19; // A5const uint8_t dcf77_inverted_samples =0;#if defined(__AVR__)#define ledpin(led) (led)#else#define ledpin(led) (led<14? led:led+(54-14))#endifconst uint8_t dcf77_monitor_pin =ledpin(18); // A4const bool provide_filtered_output =true;const uint8_t dcf77_filtered_pin =ledpin(12);const uint8_t dcf77_inverted_filtered_pin =ledpin(11);const uint8_t dcf77_filter_diff_pin =ledpin(7);const bool provide_semi_synthesized_output =true;const uint8_t dcf77_semi_synthesized_pin =ledpin(16);const uint8_t dcf77_inverted_semi_synthesized_pin =ledpin(15);const uint8_t dcf77_semi_synthesized_diff_pin =ledpin(14);const bool provide_synthesized_output =true;const uint8_t dcf77_synthesized_pin =ledpin(6);const uint8_t dcf77_inverted_synthesized_pin =ledpin(5);const uint8_t dcf77_synthesized_diff_pin =ledpin(4);const uint8_t dcf77_second_pulse_pin =ledpin(10);const uint8_t dcf77_signal_good_indicator_pin =ledpin(13);volatile uint16_t ms_counter =0;volatile Internal::DCF77::tick_t tick =Internal::DCF77::undefined;template void set_output(uint8_t clock_state, uint8_t sampled_d ata, uint8_t synthesized_signal){ if (enable) { const uint8_t filtered_output =clock_state  200) :digitalRead(dcf77_sample_pin)); #else dcf77_inverted_samples ^ digitalRead(dcf77_sample_pin); #endif digitalWrite(dcf77_monitor_pin, sampled_data); digitalWrite(dcf77_second_pulse_pin, ms_counter <500 &&clock_state>=Clock::locked); const uint8_t synthesized_signal =tick ==Internal::DCF77::long_tick ? ms_counter <200:tick ==Internal::DCF77::short_tick ? ms_counter <100:tick ==Internal::DCF77::sync_mark ? 0:// tick ==DCF77::undefined --> default handling // allow signal to pass for the first 200ms of each second (ms_counter <=200 &&sampled_data) || // if the clock has valid time data then undefined ticks // are data bits --> first 100ms of signal must be high ms_counter <100; set_output (clock_state, sampled_data, synthesized_signal); set_output (clock_state, sampled_data, synthesized_signal); set_output (clock_state, sampled_data, synthesized_signal); ms_counter+=(ms_counter <1000); scope_1.process_one_sample(sampled_data); scope_2.process_one_sample(digitalRead(dcf77_synthesized_pin)); return sampled_data;}void output_handler(const Clock::time_t &decoded_time) { // reset ms_counter for 1 Hz ticks ms_counter =0; // status indicator --> always on if signal is good // blink 3s on 1s off if signal is poor // blink 1s on 3s off if signal is very poor // always off if signal is bad const uint8_t clock_state =DCF77_Clock::get_clock_state(); digitalWrite(dcf77_signal_good_indicator_pin, clock_state>=Clock::locked ? 1:clock_state ==Clock::unlocked? (decoded_time.second.digit.lo &0x03) !=0:clock_state ==Clock::free ? (decoded_time.second.digit.lo &0x03) ==0:0); // compute output for signal synthesis Internal::DCF77_Encoder now; now.second =BCD::bcd_to_int(decoded_time.second); now.minute =decoded_time.minute; now.hour =decoded_time.hour; now.weekday =decoded_time.weekday; now.day =decoded_time.day; now.month =decoded_time.month; now.year =decoded_time.year; now.uses_summertime =decoded_time.uses_summertime; now.leap_second_scheduled =decoded_time.leap_second_scheduled; now.timezone_change_scheduled =decoded_time.timezone_change_scheduled; now.undefined_minute_output =false; now.undefined_uses_summertime_output =false; now.undefined_abnormal_transmitter_operation_output =false; now.undefined_timezone_change_scheduled_output =false; now.advance_minute(); tick =now.get_current_signal();}void setup_serial() { Serial.begin(115200);}void output_splash_screen() { Serial.println(); Serial.println(F("DCF77 Superfilter 3.0")); Serial.println(F("(c) 2015 Udo Klein")); Serial.println(F("www.blinkenlight.net")); Serial.println (); Serial.print(F("Sample Pin:")); Serial.println(dcf77_sample_pin); Serial.print(F("Inverted Mode:")); Serial.println(dcf77_inverted_samples); #if defined(__AVR__) Serial.print(F("Analog Mode:")); Serial.println(dcf77_analog_samples); #endif Serial.print(F("Monitor Pin:")); Serial.println(dcf77_monitor_pin); Serial.println (); if (provide_filtered_output) { Serial.println(F("Filtered Output")); Serial.print(F(" Filtered Pin:")); Serial.println(dcf77_filtered_pin); Serial.print(F(" Diff Pin:")); Serial.println(dcf77_filter_diff_pin); Serial.print(F(" Inverse Filtered Pin:")); Serial.println(dcf77_inverted_filtered_pin); Serial.println (); } if (provide_semi_synthesized_output) { Serial.println(F("Semi Synthesized Output")); Serial.print(F(" Filtered Pin:")); Serial.println(dcf77_semi_synthesized_pin); Serial.print(F(" Diff Pin:")); Serial.println(dcf77_semi_synthesized_diff_pin); Serial.print(F(" Inverse Filtered Pin:")); Serial.println(dcf77_inverted_semi_synthesized_pin); Serial.println (); } if (provide_synthesized_output) { Serial.println(F("Synthesized Output")); Serial.print(F(" Filtered Pin:")); Serial.println(dcf77_synthesized_pin); Serial.print(F(" Diff Pin:")); Serial.println(dcf77_synthesized_diff_pin); Serial.print(F(" Inverse Filtered Pin:")); Serial.println(dcf77_inverted_synthesized_pin); Serial.println (); } Serial.print(F("Second Pulse Pin:")); Serial.println(dcf77_second_pulse_pin); Serial.print(F("Signal Good Pin:")); Serial.println(dcf77_signal_good_indicator_pin); Serial.println (); Serial.println (); Serial.println(F("Initializing...")); Serial.println();};void setup_pins() { if (provide_filtered_output) { pinMode(dcf77_filtered_pin, OUTPUT); pinMode(dcf77_filter_diff_pin, OUTPUT); pinMode(dcf77_inverted_filtered_pin, OUTPUT); } if (provide_semi_synthesized_output) { pinMode(dcf77_semi_synthesized_pin, OUTPUT); pinMode(dcf77_semi_synthesized_diff_pin, OUTPUT); pinMode(dcf77_inverted_semi_synthesized_pin, OUTPUT); } if (provide_synthesized_output) { pinMode(dcf77_synthesized_pin, OUTPUT); pinMode(dcf77_synthesized_diff_pin, OUTPUT); pinMode(dcf77_inverted_synthesized_pin, OUTPUT); } pinMode(dcf77_monitor_pin, OUTPUT); pinMode(dcf77_signal_good_indicator_pin, OUTPUT); pinMode(dcf77_second_pulse_pin, OUTPUT); pinMode(dcf77_sample_pin, INPUT); digitalWrite(dcf77_sample_pin, HIGH);}void setup_clock() { DCF77_Clock::setup(); DCF77_Clock::set_input_provider(sample_input_pin); DCF77_Clock::set_output_handler(output_handler);}void setup() { setup_serial(); output_splash_screen(); setup_pins(); setup_clock();/* pinMode(gnd_pin, OUTPUT); digitalWrite(gnd_pin, LOW); pinMode(pon_pin, OUTPUT); digitalWrite(pon_pin, LOW); pinMode(vcc_pin, OUTPUT); digitalWrite(vcc_pin, HIGH); */}void loop() { Clock::time_t now; DCF77_Clock::get_current_time(now); if (now.month.val> 0) { Serial.println(); Serial.print(F("Decoded time:")); DCF77_Clock::print(now); Serial.println (); } Serial.print(DCF77_Clock::get_clock_state()); Serial.print(' '); DCF77_Clock::debug(); scope_1.print(); scope_2.print();}

Peças personalizadas e gabinetes

Esquemas