FAÇA UM RELÓGIO CONTROLADOR DE 6 CANAIS (VERSÃO PARA DS1307) – COM PIC 16F628A E LCD (REF116)

2

Acionar dispositivos em determinados momentos programados pode ser muito útil em automação. Veja esta nova versão do controlador de 6 canais usando um RTC DS1307 (comunicação I2C)…

Para facilitar para alguns hobistas que estão tendo dificuldade de encontrar o ci DS1302, de protocolo SPI (3 fios), foi adaptado o código para usar o ci DS1307, de protocolo I2c de 2 fios. Com exceção de usar um fio a menos na ligação com o PIC, poucas coisas mudaram no esquema. Veja abaixo como ficou:

Na parte do arquivo ASM, todas as rotinas de SPI foram substituídas por rotinas I2C. O Programa ficou bem inchado com estas modificações, sendo então necessário a substituição de algumas linhas de código repetidas por chamadas de subrotina. Ainda assim, sobraram poucas linhas de código, sem usar, das 2047 existentes na flash do PIC16F628a.
Com respeito ao uso e aplicações, poderá ver os detalhes no artigo ‘FAÇA UM RELÓGIO CONTROLADOR DE 6 CANAIS – COM PIC 16F628A E LCD’, uma vez que só foi mudado o chip RTC de ds1302 para DS1307.
Obs.: Esta montagem é de caráter didático, sendo montada e testada apenas em placa de protoboard, sendo sujeita a bugs ainda não detectados. São fornecidos os arquivos ASM e HEX, que poderão ser modificados conforme as necessidades dos hobistas.

Segue o arquivo ASM:

RELOGIO_CONTROL_DS1307_ASM

Segue o arquivo Hex:

RELOGIO_CONTROL_DS1307_HEX

Em 27/11/14 foi feita revisão, conforme pasta abaixo:

relogio_controlador_v2

Também, em 30/11/14 foi feita esta versão usando compilador “C”, e atualizada em 03/03/2015, com vantagem de recuperar a situação programada, mesmo com falta de energia momentânea. Foi feita uma nova forma de mostrar a programação do calendário e canais, piscando os elementos que estão sob ajustes. Confira na pasta zipada abaixo:

RELOGIO_CONTROL_DS1307_V_4

O Sr. Edmilson Spigolan nos envia gentilmente uma versão com apenas um canal, usando o mesmo esquema, mas sem montar fisicamente os canais 2 a 6. Segue a pasta com o asm e hex:

relogio_controlador 1 canal

Em 09/09/2017 foi feita uma revisão neste relógio de 1 canal, eliminando um ‘bug’ que deixava a segunda linha um pouco instável na apresentação. Segue os arquivos desta nova versão de 1 canal:

RELOGIO_CONTROL_1C_E

Caso deseje a versão com o circuito integrado DS1302 clique aqui.

Em 27/07/2015 foi feita esta versão, com programação também do dia(s) da semana além das horas, minutos e segundos. Por exemplo: Como irrigação de jardim: acionando eletroválvula da água (destas de máquina de lavar roupas). Podemos programar para regar nas segundas, quartas, sextas, ligando no horário xx:xx:xx e desligando yy:yy:yy (a diferença será o tempo de rega). Segue a pasta com os arquivos desta montagem:

RELOGIO_CONTROL_SEM_6CAN

Manuais:

DS1307
PIC 16F628A
LCD
Esquemas curiosos

Curiosidades:

Como usar melhor o tempo?
Coleta da água da chuva — métodos antigos e modernos
O que é a Grande Bacia Artesiana?
O que revela a visão do invisível?
Os ciclos que sustentam a vida
Já que não pode guardá-lo, use-o bem
Dê mais vida à sua casa
Ondas assassinas: mitos e verdades
Já sorriu para um crocodilo?
Navegar em água e em terra
O esplendor da areia

Outros assuntos:
Lidar com sogros
Aprenda a perdoar
Lidar com dívidas
Como disciplinar seu filho adolescente
Por que eu me corto?
Desempenhem bem o papel de pais
Como fazer seu segundo casamento dar certo
O que acontece quando morremos?
Como criar filhos responsáveis
Como administrar o seu dinheiro
Ensine valores morais a seus filhos
Como posso ter ânimo para exercitar
Como posso controlar meu peso?
Adolescentes- O que fazer se estou sofrendo bullying?
Como evitar ferir com palavras?
Como tratar seu cônjuge com respeito?

Até o próximo artigo!!!

2

86 comments

  1. 0

    ola Claudio bom dia muito grato pela alteração do programa, poderia deixar o codigo fonte zipado para poder baixa-lo grato

  2. 0

    Claudio daria para retirar a chave on off do pino 4 e fazer funcionar assim que energizar o circuito obrigado

    1. 0

      Olá Marcos!
      Não testei, mas tente compilar assim:

      /*******************************************************************************
      TEMPORIZADOR CHOC1 SEM CHAVE ON/OFF
      ACIONA SAÍDAS A CADA 3 HORAS POR 1 SEGUNDO (OU MAIS) PARA ATIVAR ENTRADA DE AR
      EM CHOCADEIRAS
      C/ PIC12F675
      AUTOR: CLAUDIO LÁRIOS
      DATA: 13/03/2015
      PINAGEM DO PIC 12F675:
      1-+5V
      2- XTAL (4MHZ)
      3- XTAL
      4- INTERRUPTOR ON/OFF AO GND, COM RESISTOR DE 10K AO VCC (PULL UP)
      5- LED AO GND VIA RESISTOR DE 470 OHMS E OUTRO RESISTOR DE 470 AO GND OU VCC
      (JUMPER DE ESCOLHA 29/19 DIAS)
      6- SAÍDA 1
      7- SAÍDA 2 (OPCIONAL)
      8- GND
      OBS. DEVERÁ SER PREVISTO UMA FONTE DE ALIMENTAÇÃO QUE ALIMENTE O CIRCUITO
      MESMO EM CASO DE FALTA DE ENERGIA ELÉTRICA NA REDE, POR SE TRATAR DE LONGOS
      PERIODOS.
      USO OPCIONAL: VIRAR OVOS
      USO DIDÁTICO
      USE COMPILADOR CCS C
      ESTE ARQUIVO É PARTE INTEGRANTE DO BLOG LARIOS.TECNOLOGIA.WS
      ******************************************************************************/
      #include
      #device adc=8
      #use delay(clock=4000000)
      #fuses NOWDT,HS, NOCPD, NOPROTECT, NOMCLR, PUT, BROWNOUT
      #use fast_io(A)
      #zero_ram
      //BYTE
      #byte GPIO = 0×05
      #byte TRISIO = 0×85
      //BIT
      #bit s1 = 0×5.1// saída 1 pino 6
      #bit s2 = 0×5.0//saída 2 (opcional) pino 7
      #bit led = 0×5.2//saída para led indicador on/off (piscante) pino 5
      #bit tris_led =0×85.2
      //flag
      unsigned int1 f_29d,f_on,f_t,f_s2,f_s1;
      //variavéis globais
      unsigned int32 tempo=0;
      unsigned int32 cnt32=0;
      unsigned int16 tempac=0;
      unsigned int8 cts1=0,cts2=0;
      //definições de funcionamento
      #define ciclo_ac 3 //ciclo (em horas)
      #define v_ts1 1 //em segundos
      #define v_ts2 1 //em segundos
      #define PERIODO_CHOC1 29 //em dias
      #define PERIODO_CHOC2 19 //em dias
      /******************************************************************************
      ROTINA DE INTERRUPÇÃO DO TIMER 0 (CONTA 1 SEGUNDO)
      ******************************************************************************/
      #INT_TIMER0
      void INT_TIMER0_ISR(){
      //gera 1 segundos com metodo de acumulo de erro e pode ser usado
      // para cristais com valores quebrados das mais variadas frequencias
      // ajuste o timer para o prescaller igual abaixo no main
      #define presc 64 // valor do prescaller do timer usado (8 bits)
      #define fator (256*presc*4)
      #define f_xtal 4000000 //frequencia do cristal usado (mesmo do cabeçalho)
      cnt32+=fator;
      if(cnt32>=f_xtal){
      f_t=!f_t;//piscará led on/off
      cnt32-=f_xtal;//subtrai xtal da contagem
      tempo++;//incrementa contador de tempo máximo
      if(cts2){ if(–cts2==0){f_s2=0;} }//decrementa registradores de tempo da saída s2
      if(cts1){ if(–cts1==0){f_s1=0; f_s2=1;cts2=v_ts2;}}//idem, da saída s1
      if(++tempac>=(ciclo_ac*3600)){ //duração de cada ciclo
      tempac=0;//reinicia contagem
      f_s1=1;//saída s1 acionará
      cts1=v_ts1;//carga do tempo que ficará acionado esta saída
      }
      if(f_29d){ //testa se periodo desejado é 19 ou 29 dias
      if(tempo>=(PERIODO_CHOC1*24*3600)){//testa se ciclou por 29 dias e para
      f_on=0; //para a contagem
      }
      }
      else{
      if(tempo>=(PERIODO_CHOC2*24*3600)){//testa se ciclou por 19 dias e para
      f_on=0; //para a contagem
      }
      }
      }
      }
      /******************************************************************************
      ROTINA MAIN
      ******************************************************************************/
      void main() {
      SETUP_ADC_PORTS(NO_ANALOGS);//desabilita conversor analogico/digital
      setup_comparator(NC_NC_NC_NC);//desliga comparadores internos
      setup_counters(RTCC_INTERNAL,RTCC_DIV_64);//prescaller divide por 64
      setup_timer_1(T1_DISABLED);
      setup_vref(FALSE);//desliga voltagem de referencia
      GPIO=0;//idem
      TRISIO=0b111000;//sentido fixo das portas
      enable_interrupts(int_timer0);//liga interrupção do timer 0
      enable_interrupts(global);//mantém desabilitada a geral
      tris_led=1;
      if(led) {f_29d=1;} else {f_29d=0;} //le jump e acerta flag entre 29 ou 19 dias
      tris_led=0;
      f_t=0; f_s1=0;f_s2=0;cts2=0;cts1=0;
      tempo=0; tempac=0; cnt32=0; f_t=1; //reinicia contadores
      f_on=1;
      /******************************************************************************
      LOOP PRINCIPAL DE REPETIÇÃO
      ******************************************************************************/
      for(;;){

      if(f_on){//repassa valores para saidas de led,s1 e s2
      led=f_t;
      s1=f_s1;
      s2=f_s2;
      }
      else{ gpio=0;}
      }//for(;;)
      }//void main()
      /////////////////////////////////////////////////////////////////////////////////////////////

      Cláudio

          1. 0

            Olá Marcos!
            Eu não consigo achar um arquivo com este nome. Acredito que tenha apenas linkado ele a um comentário, mas não estou conseguindo achar. Eu também não me lembro bem do que se tratava. Se puder ajudar relembrando o assunto e a data da ocasião, talvez possa acha-lo.
            Cláudio

      1. 0

        Bom dia Claudio seria essa versão abaixo
        TEMPORIZADOR CHOC1 SEM CHAVE ON/OFF
        29/abril/2016 21:16 horas
        Claudio Larios 29 de abril de 2016 em 16:54
        Olá Marcos!
        Não testei, mas tente compilar assim:
        /*******************************************************************************
        TEMPORIZADOR CHOC1 SEM CHAVE ON/OFF
        ACIONA SAÍDAS A CADA 3 HORAS POR 1 SEGUNDO (OU MAIS) PARA ATIVAR ENTRADA DE AR
        EM CHOCADEIRAS
        C/ PIC12F675
        AUTOR: CLAUDIO LÁRIOS
        DATA: 13/03/2015
        PINAGEM DO PIC 12F675:
        1-+5V
        2- XTAL (4MHZ)
        3- XTAL
        4- INTERRUPTOR ON/OFF AO GND, COM RESISTOR DE 10K AO VCC (PULL UP)
        5- LED AO GND VIA RESISTOR DE 470 OHMS E OUTRO RESISTOR DE 470 AO GND OU VCC
        (JUMPER DE ESCOLHA 29/19 DIAS)
        6- SAÍDA 1
        7- SAÍDA 2 (OPCIONAL)
        8- GND
        OBS. DEVERÁ SER PREVISTO UMA FONTE DE ALIMENTAÇÃO QUE ALIMENTE O CIRCUITO
        MESMO EM CASO DE FALTA DE ENERGIA ELÉTRICA NA REDE, POR SE TRATAR DE LONGOS
        PERIODOS.
        USO OPCIONAL: VIRAR OVOS
        USO DIDÁTICO
        USE COMPILADOR CCS C
        ESTE ARQUIVO É PARTE INTEGRANTE DO BLOG LARIOS.TECNOLOGIA.WS
        ******************************************************************************/
        #include
        #device adc=8
        #use delay(clock=4000000)
        #fuses NOWDT,HS, NOCPD, NOPROTECT, NOMCLR, PUT, BROWNOUT
        #use fast_io(A)
        #zero_ram
        //BYTE
        #byte GPIO = 0×05
        #byte TRISIO = 0×85
        //BIT
        #bit s1 = 0×5.1// saída 1 pino 6
        #bit s2 = 0×5.0//saída 2 (opcional) pino 7
        #bit led = 0×5.2//saída para led indicador on/off (piscante) pino 5
        #bit tris_led =0×85.2
        //flag
        unsigned int1 f_29d,f_on,f_t,f_s2,f_s1;
        //variavéis globais
        unsigned int32 tempo=0;
        unsigned int32 cnt32=0;
        unsigned int16 tempac=0;
        unsigned int8 cts1=0,cts2=0;
        //definições de funcionamento
        #define ciclo_ac 3 //ciclo (em horas)
        #define v_ts1 1 //em segundos
        #define v_ts2 1 //em segundos
        #define PERIODO_CHOC1 29 //em dias
        #define PERIODO_CHOC2 19 //em dias
        /******************************************************************************
        ROTINA DE INTERRUPÇÃO DO TIMER 0 (CONTA 1 SEGUNDO)
        ******************************************************************************/
        #INT_TIMER0
        void INT_TIMER0_ISR(){
        //gera 1 segundos com metodo de acumulo de erro e pode ser usado
        // para cristais com valores quebrados das mais variadas frequencias
        // ajuste o timer para o prescaller igual abaixo no main
        #define presc 64 // valor do prescaller do timer usado (8 bits)
        #define fator (256*presc*4)
        #define f_xtal 4000000 //frequencia do cristal usado (mesmo do cabeçalho)
        cnt32+=fator;
        if(cnt32>=f_xtal){
        f_t=!f_t;//piscará led on/off
        cnt32-=f_xtal;//subtrai xtal da contagem
        tempo++;//incrementa contador de tempo máximo
        if(cts2){ if(–cts2==0){f_s2=0;} }//decrementa registradores de tempo da saída s2
        if(cts1){ if(–cts1==0){f_s1=0; f_s2=1;cts2=v_ts2;}}//idem, da saída s1
        if(++tempac>=(ciclo_ac*3600)){ //duração de cada ciclo
        tempac=0;//reinicia contagem
        f_s1=1;//saída s1 acionará
        cts1=v_ts1;//carga do tempo que ficará acionado esta saída
        }
        if(f_29d){ //testa se periodo desejado é 19 ou 29 dias
        if(tempo>=(PERIODO_CHOC1*24*3600)){//testa se ciclou por 29 dias e para
        f_on=0; //para a contagem
        }
        }
        else{
        if(tempo>=(PERIODO_CHOC2*24*3600)){//testa se ciclou por 19 dias e para
        f_on=0; //para a contagem
        }
        }
        }
        }
        /******************************************************************************
        ROTINA MAIN
        ******************************************************************************/
        void main() {
        SETUP_ADC_PORTS(NO_ANALOGS);//desabilita conversor analogico/digital
        setup_comparator(NC_NC_NC_NC);//desliga comparadores internos
        setup_counters(RTCC_INTERNAL,RTCC_DIV_64);//prescaller divide por 64
        setup_timer_1(T1_DISABLED);
        setup_vref(FALSE);//desliga voltagem de referencia
        GPIO=0;//idem
        TRISIO=0b111000;//sentido fixo das portas
        enable_interrupts(int_timer0);//liga interrupção do timer 0
        enable_interrupts(global);//mantém desabilitada a geral
        tris_led=1;
        if(led) {f_29d=1;} else {f_29d=0;} //le jump e acerta flag entre 29 ou 19 dias
        tris_led=0;
        f_t=0; f_s1=0;f_s2=0;cts2=0;cts1=0;
        tempo=0; tempac=0; cnt32=0; f_t=1; //reinicia contadores
        f_on=1;
        /******************************************************************************
        LOOP PRINCIPAL DE REPETIÇÃO
        ******************************************************************************/
        for(;;){
        if(f_on){//repassa valores para saidas de led,s1 e s2
        led=f_t;
        s1=f_s1;
        s2=f_s2;
        }
        else{ gpio=0;}
        }//for(;;)
        }//void main()
        /////////////////////////////////////////////////////////////////////////////////////////////
        Cláudio

        1. 0

          Olá Marcos!
          Você já tentou compilar este código ou é algum problema? Não estou entendendo exatamente o que deseja, já que tem o código.
          Claudio

          1. 0

            Olá Marcos!
            Parece que ao postar no comentário, acaba apagando o “include 12f675”. Vou ver se acho ele nos arquivos do PC e postarei ele em forma de pasta zipada.
            Cláudio

  3. 0

    Olá Marcos!
    Eu estava pensando no temporizador que você falou, para acionar uma saída a cada 3 horas por 1 segundos. Fiz um programinha abaixo:
    /*******************************************************************************
    TEMPORIZADOR CHOC1
    ACIONA SAÍDAS A CADA 3 HORAS POR 1 SEGUNDO (OU MAIS) PARA ATIVAR ENTRADA DE AR
    EM CHOCADEIRAS
    C/ PIC12F675
    AUTOR: CLAUDIO LÁRIOS
    DATA: 13/03/2015
    PINAGEM DO PIC 12F675:
    1-+5V
    2- XTAL (4MHZ)
    3- XTAL
    4- INTERRUPTOR ON/OFF AO GND, COM RESISTOR DE 10K AO VCC (PULL UP)
    5- LED AO GND VIA RESISTOR DE 470 OHMS E OUTRO RESISTOR DE 470 AO GND OU VCC
    (JUMPER DE ESCOLHA 29/19 DIAS)
    6- SAÍDA 1
    7- SAÍDA 2 (OPCIONAL)
    8- GND
    OBS. DEVERÁ SER PREVISTO UMA FONTE DE ALIMENTAÇÃO QUE ALIMENTE O CIRCUITO
    MESMO EM CASO DE FALTA DE ENERGIA ELÉTRICA NA REDE, POR SE TRATAR DE LONGOS
    PERIODOS.
    USO OPCIONAL: VIRAR OVOS
    USO DIDÁTICO
    USE COMPILADOR CCS C
    ESTE ARQUIVO É PARTE INTEGRANTE DO BLOG LARIOS.TECNOLOGIA.WS
    ******************************************************************************/
    #include
    #device adc=8
    #use delay(clock=4000000)
    #fuses NOWDT,HS, NOCPD, NOPROTECT, NOMCLR, PUT, BROWNOUT
    #use fast_io(A)
    #zero_ram
    //BYTE
    #byte GPIO = 0×05
    #byte TRISIO = 0×85
    //BIT
    #bit sw = 0×5.3 //interruptor on/off pino 4
    #bit s1 = 0×5.1// saída 1 pino 6
    #bit s2 = 0×5.0//saída 2 (opcional) pino 7
    #bit led = 0×5.2//saída para led indicador on/off (piscante) pino 5
    #bit tris_led =0×85.2
    //flag
    unsigned int1 f_29d,f_on,f_t,f_s2,f_s1;
    //variavéis globais
    unsigned int32 tempo=0;
    unsigned int32 cnt32=0;
    unsigned int16 tempac=0;
    unsigned int16 dly=0;
    unsigned int8 cts1=0,cts2=0;
    //definições de funcionamento
    #define v_debounce 10000 //valor para debouce da chave on/off
    #define ciclo_ac 3 //ciclo (em horas)
    #define v_ts1 1 //em segundos
    #define v_ts2 1 //em segundos
    #define PERIODO_CHOC1 29 //em dias
    #define PERIODO_CHOC2 19 //em dias
    /******************************************************************************
    ROTINA DE INTERRUPÇÃO DO TIMER 0 (CONTA 1 SEGUNDO)
    ******************************************************************************/
    #INT_TIMER0
    void INT_TIMER0_ISR(){
    //gera 1 segundos com metodo de acumulo de erro e pode ser usado
    // para cristais com valores quebrados das mais variadas frequencias
    // ajuste o timer para o prescaller igual abaixo no main
    #define presc 64 // valor do prescaller do timer usado (8 bits)
    #define fator (256*presc*4)
    #define f_xtal 4000000 //frequencia do cristal usado (mesmo do cabeçalho)
    cnt32+=fator;
    if(cnt32>=f_xtal){
    f_t=!f_t;//piscará led on/off
    cnt32-=f_xtal;//subtrai xtal da contagem
    tempo++;//incrementa contador de tempo máximo
    if(cts2){ if(–cts2==0){f_s2=0;} }//decrementa registradores de tempo da saída s2
    if(cts1){ if(–cts1==0){f_s1=0; f_s2=1;cts2=v_ts2;}}//idem, da saída s1
    if(++tempac>=(ciclo_ac*3600)){ //duração de cada ciclo
    tempac=0;//reinicia contagem
    f_s1=1;//saída s1 acionará
    cts1=v_ts1;//carga do tempo que ficará acionado esta saída
    }
    if(f_29d){ //testa se periodo desejado é 19 ou 29 dias
    if(tempo>=(PERIODO_CHOC1*24*3600)){//testa se ciclou por 29 dias e para
    f_on=0; //para a contagem
    }
    }
    else{
    if(tempo>=(PERIODO_CHOC2*24*3600)){//testa se ciclou por 19 dias e para
    f_on=0; //para a contagem
    }
    }
    }
    }
    /******************************************************************************
    ROTINA MAIN
    ******************************************************************************/
    void main() {
    SETUP_ADC_PORTS(NO_ANALOGS);//desabilita conversor analogico/digital
    setup_comparator(NC_NC_NC_NC);//desliga comparadores internos
    setup_counters(RTCC_INTERNAL,RTCC_DIV_64);//prescaller divide por 64
    setup_timer_1(T1_DISABLED);
    setup_vref(FALSE);//desliga voltagem de referencia
    GPIO=0;//idem
    TRISIO=0b111000;//sentido fixo das portas
    enable_interrupts(int_timer0);//liga interrupção do timer 0
    disable_interrupts(global);//mantém desabilitada a geral
    /******************************************************************************
    LOOP PRINCIPAL DE REPETIÇÃO
    ******************************************************************************/
    for(;;){
    if((!sw)&&(!dly)) {
    disable_interrupts(global);
    f_on=!f_on;//inverte
    tris_led=1;
    if(led) {f_29d=1;} else {f_29d=0;} //le jump e acerta flag entre 29 ou 19 dias
    tris_led=0;
    if(f_on){ tempo=0; tempac=0; cnt32=0; f_t=1; //reinicia contadores
    enable_interrupts(global);
    }
    else{
    f_t=0; f_s1=0;f_s2=0;cts2=0;cts1=0;
    }
    while(!sw) ;//aguarda soltar interruptor on/off
    dly=v_debounce;//recarga do valor de debounce
    // enable_interrupts(global);
    }
    if(dly)dly–;//decrementa contador de debounce se positivo
    if(f_on){//repassa valores para saidas de led,s1 e s2
    led=f_t;
    s1=f_s1;
    s2=f_s2;
    }
    else{ gpio=0;}
    }//for(;;)
    }//void main()
    /////////////////////////////////////////////////////////////////////////////////////////////
    Não cheguei a testar com 29 dias, pois é muito tempo. Fiz teste com valores menores e depois voltei este valor. Note que esta versão tem uma saída adicional, que aciona logo após a primeira, para acionar um motor cc para um lado e depois para o outro. Ou então aproveita somente uma saída, ligando um ventilador. Você que é o que entende de chocadeiras.
    Veja se funciona e dá um retorno, por favor.

    1. 0

      Olá Marcos!
      Aparentemente é funcional. Faça o teste prático para certificar que tudo corre bem. Na realidade eu não entendo de chocadeiras. Apenas vi alguns artigos na internet.
      Parabéns!
      Cláudio

  4. 0

    Claudio boa tarde teria como eliminar a chave e funcionar diretamente quando energizar o circuito deste novo projeto.

      1. 0

        o artigo timer encubadora com pic 12f675 eliminar a chave liga desliga para quando energizar o circuito ele ja começa a funcionar.

        1. 0

          Olá Marcos!
          Poderia, por favor, pegar o título completo do artigo, pois eu não me lembro de um artigo sobre ‘encubadora’.
          Cláudio

          1. 0

            Olá Marcos!
            Desculpe, mas ainda não sei qual artigo se refere. Você poderia pegar o link ou o nome do artigo completo, por favor?
            Claudio

  5. 0

    Boa noite Claudio ,montei o circuito e para não ficar esperando 3 horas para dar o pulso no motor ,como faço para colocar tempos bem menores para teste.

    1. 0

      Olá Marcos!
      Para alterar o tempo acionado altere no #define v_ts1 1 //em segundos e
      #define v_ts2 1 //em segundos.
      Para o ciclo de 3 horas poderá altera-lo para 1 h ou outro valor também usando o #define ciclo_ac 3 //ciclo (em horas).
      Para valores menores, altere na direto na rotina:

      if(++tempac>=(ciclo_ac*3600)){ //duração de cada ciclo—————> mude para if(++tempac>=400){// para 400 segundos, por exemplo.
      tempac=0;//reinicia contagem
      f_s1=1;//saída s1 acionará
      cts1=v_ts1;//carga do tempo que ficará acionado esta saída
      }

      Para tempo de 1 dia a 29 poderá alterar no ” #define PERIODO_CHOC1 29 //em dias”.
      Para tempos menores terá que alterar direto na rotina, conforme abaixo:

      if(f_29d){ //testa se periodo desejado é 19 ou 29 dias
      if(tempo>=(PERIODO_CHOC1*24*3600)){//testa se ciclou por 29 dias e para ——————–> troque por: if(tempo>=60){ //para tempo de 60 segundos
      f_on=0; //para a contagem
      }
      }
      else{
      if(tempo>=(PERIODO_CHOC2*24*3600)){//testa se ciclou por 19 dias e para ——————–> troque por: if(tempo>=160){ //para tempo de 160 segundos
      f_on=0; //para a contagem
      }

      Claudio

    1. 0

      Olá Marcos!
      Eu estava pensando no temporizador que você falou, para acionar uma saída a cada 3 horas por 1 segundos. Fiz um programinha abaixo:
      /*******************************************************************************

      TEMPORIZADOR CHOC1

      ACIONA SAÍDAS A CADA 3 HORAS POR 1 SEGUNDO (OU MAIS) PARA ATIVAR ENTRADA DE AR
      EM CHOCADEIRAS

      C/ PIC12F675

      AUTOR: CLAUDIO LÁRIOS

      DATA: 13/03/2015

      PINAGEM DO PIC 12F675:
      1-+5V
      2- XTAL (4MHZ)
      3- XTAL
      4- INTERRUPTOR ON/OFF AO GND, COM RESISTOR DE 10K AO VCC (PULL UP)
      5- LED AO GND VIA RESISTOR DE 470 OHMS E OUTRO RESISTOR DE 470 AO GND OU VCC
      (JUMPER DE ESCOLHA 29/19 DIAS)
      6- SAÍDA 1
      7- SAÍDA 2 (OPCIONAL)
      8- GND

      OBS. DEVERÁ SER PREVISTO UMA FONTE DE ALIMENTAÇÃO QUE ALIMENTE O CIRCUITO
      MESMO EM CASO DE FALTA DE ENERGIA ELÉTRICA NA REDE, POR SE TRATAR DE LONGOS
      PERIODOS.
      USO OPCIONAL: VIRAR OVOS

      USO DIDÁTICO

      USE COMPILADOR CCS C

      ESTE ARQUIVO É PARTE INTEGRANTE DO BLOG LARIOS.TECNOLOGIA.WS

      ******************************************************************************/
      #include
      #device adc=8
      #use delay(clock=4000000)
      #fuses NOWDT,HS, NOCPD, NOPROTECT, NOMCLR, PUT, BROWNOUT

      #use fast_io(A)

      #zero_ram
      //BYTE

      #byte GPIO = 0x05
      #byte TRISIO = 0x85

      //BIT

      #bit sw = 0x5.3 //interruptor on/off pino 4
      #bit s1 = 0x5.1// saída 1 pino 6
      #bit s2 = 0x5.0//saída 2 (opcional) pino 7
      #bit led = 0x5.2//saída para led indicador on/off (piscante) pino 5
      #bit tris_led =0x85.2

      //flag
      unsigned int1 f_29d,f_on,f_t,f_s2,f_s1;
      //variavéis globais
      unsigned int32 tempo=0;
      unsigned int32 cnt32=0;
      unsigned int16 tempac=0;
      unsigned int16 dly=0;
      unsigned int8 cts1=0,cts2=0;

      //definições de funcionamento
      #define v_debounce 10000 //valor para debouce da chave on/off
      #define ciclo_ac 3 //ciclo (em horas)
      #define v_ts1 1 //em segundos
      #define v_ts2 1 //em segundos
      #define PERIODO_CHOC1 29 //em dias
      #define PERIODO_CHOC2 19 //em dias
      /******************************************************************************
      ROTINA DE INTERRUPÇÃO DO TIMER 0 (CONTA 1 SEGUNDO)
      ******************************************************************************/
      #INT_TIMER0
      void INT_TIMER0_ISR(){

      //gera 1 segundos com metodo de acumulo de erro e pode ser usado
      // para cristais com valores quebrados das mais variadas frequencias
      // ajuste o timer para o prescaller igual abaixo no main

      #define presc 64 // valor do prescaller do timer usado (8 bits)
      #define fator (256*presc*4)
      #define f_xtal 4000000 //frequencia do cristal usado (mesmo do cabeçalho)

      cnt32+=fator;
      if(cnt32>=f_xtal){
      f_t=!f_t;//piscará led on/off
      cnt32-=f_xtal;//subtrai xtal da contagem
      tempo++;//incrementa contador de tempo máximo

      if(cts2){ if(–cts2==0){f_s2=0;} }//decrementa registradores de tempo da saída s2
      if(cts1){ if(–cts1==0){f_s1=0; f_s2=1;cts2=v_ts2;}}//idem, da saída s1

      if(++tempac>=(ciclo_ac*3600)){ //duração de cada ciclo
      tempac=0;//reinicia contagem
      f_s1=1;//saída s1 acionará
      cts1=v_ts1;//carga do tempo que ficará acionado esta saída
      }

      if(f_29d){ //testa se periodo desejado é 19 ou 29 dias
      if(tempo>=(PERIODO_CHOC1*24*3600)){//testa se ciclou por 29 dias e para
      f_on=0; //para a contagem
      }
      }
      else{
      if(tempo>=(PERIODO_CHOC2*24*3600)){//testa se ciclou por 19 dias e para
      f_on=0; //para a contagem
      }
      }
      }
      }

      /******************************************************************************
      ROTINA MAIN
      ******************************************************************************/

      void main() {
      SETUP_ADC_PORTS(NO_ANALOGS);//desabilita conversor analogico/digital
      setup_comparator(NC_NC_NC_NC);//desliga comparadores internos
      setup_counters(RTCC_INTERNAL,RTCC_DIV_64);//prescaller divide por 64
      setup_timer_1(T1_DISABLED);
      setup_vref(FALSE);//desliga voltagem de referencia
      GPIO=0;//idem
      TRISIO=0b111000;//sentido fixo das portas
      enable_interrupts(int_timer0);//liga interrupção do timer 0
      disable_interrupts(global);//mantém desabilitada a geral

      /******************************************************************************
      LOOP PRINCIPAL DE REPETIÇÃO
      ******************************************************************************/

      for(;;){

      if((!sw)&&(!dly)) {
      disable_interrupts(global);
      f_on=!f_on;//inverte
      tris_led=1;
      if(led) {f_29d=1;} else {f_29d=0;} //le jump e acerta flag entre 29 ou 19 dias
      tris_led=0;

      if(f_on){ tempo=0; tempac=0; cnt32=0; f_t=1; //reinicia contadores
      enable_interrupts(global);
      }
      else{
      f_t=0; f_s1=0;f_s2=0;cts2=0;cts1=0;
      }
      while(!sw) ;//aguarda soltar interruptor on/off
      dly=v_debounce;//recarga do valor de debounce
      // enable_interrupts(global);
      }

      if(dly)dly–;//decrementa contador de debounce se positivo

      if(f_on){//repassa valores para saidas de led,s1 e s2
      led=f_t;
      s1=f_s1;
      s2=f_s2;
      }
      else{ gpio=0;}

      }//for(;;)

      }//void main()
      /////////////////////////////////////////////////////////////////////////////////////////////

      Não cheguei a testar com 29 dias, pois é muito tempo. Fiz teste com valores menores e depois voltei este valor. Note que esta versão tem uma saída adicional, que aciona logo após a primeira, para acionar um motor cc para um lado e depois para o outro. Ou então aproveita somente uma saída, ligando um ventilador. Você que é o que entende de chocadeiras.
      Veja se funciona e dá um retorno, por favor.

      clique aqui para obter pasta zipada com o arquivo.
      Cláudio

  6. 0

    Claudio como ainda estou fazendo testes a primeira coisa que precisaria e´desse circuito que mencionei ai depois irei fazer outros testes .se em um pic menor melhor ainda.

  7. 0

    sim Claudio ira funcionar da seguinte maneira visualizando pelo lcd o controlador ira temporizar por 3 em 3 horas em periodos de 19 ou 29 dias uma das saidas mandando um pulso de duraçao de 1seg onde esse pulso ira acionar um rele que ira acionar um motor para abrir e fechar a encubadora para refrigerar a mesma.

    1. 0

      Olá Marcos!
      Deixa ver seu eu entendi! A sua necessidade é um temporizador com um único canal, que de um pulso de 1 segundo a cada 3 horas , repetindo sempre este ciclo por um período de 19 ou 29 dias, talvez por usar uma chave seletora. Após este período, tudo se desliga. Creio que o melhor seria fazer um novo circuito, mais simples, onde se poderia usar até um pic menor. Mas eu não entendi bem do porque precisa a cada 3 horas refrigerar a sua encubadora, uma vez que provavelmente ela tenha controle automático de temperatura. Seria para renovar o ar ou algo parecido?
      Neste caso, não tem algum arranjo usando ventiladores ou algum tipo de exaustor?
      Cláudio

  8. 0

    Boa tarde amigo Larios ,montei o circuito e quando ajusto o relogio data hora tudo certinho ,e passo pelos canais 1 a 6 sem ajusta-los para nenhuma operação de ligar ou desligar alguma carga. simplesmente o relogio volta a apresentar os pontos de interrogação normal isso acontecer

        1. 0

          Olá Marcos!
          Eu tive alguns problemas parecidos, mas quando usei uma bateria de 3 volts externamente, obtive solução do problema. Mas o simples fato deste terminal ficar desligado pode ser porta de entrada de ruídos. O datasheet aconselha liga-lo ao gnd se não estiver usando a bateria de segurança.
          Cláudio

          1. 0

            ola Claudio estou fazendo alguns testes , e precisaria que esse circuito ficasse funcionando automaticamente da seguinte forma. que quando ligar o controlador ele mandaria um pulso de 1seg em apenas uma das saidas a cada 3 horas por periodos de 19 dias ou 29 dias.para fins de testes em encubadoras.obrigado

          2. 0

            Olá Marcos!
            Terá que alterar bastante coisa no programa, e eliminar outras partes que não usará.
            Poderia falar para nós como isto funcionaria?
            Cláudio

  9. 0

    Esqueci de comentar, os fins de semana poderiam ou não programar pois mesmo sendo raro as vezes temos aulas ao sábado. Pois se ficar direto sem discriminar os dias da semana os vizinhos poderiam ficar chateados. Mas se não for possível ficamos contentes acionando nos horários pre programados. Pensando aqui isso poderia ser usado mesmo até em fabricas para controlar os horários dos funcionários. Mais uma vez obrigado.

  10. 0

    Olá, novamente Claudio, bom estou usando somente uma saída com o código cedido gentilmente pelo Edmilson. Eu trabalho em uma escola municipal e o que acontece que o sinal “sirene” e dado manualmente apertando um interruptor. Eu gostaria de saber se seria possível alterar o código para que o relógio virasse um sinaleiro. Ou seja fosse capaz de acionar o rele 1 em horários diferentes por exemplo “07:00,09:30,09:45,11:15″e a tarde “13:00,15:00,15:15,15:20,15:35 e por fim 17:15 termino horário tarde”, isso com pulso da sirene por 5 segundos. Isso para acabar com as reclamações dos professores pelo fato do “apertador do botão” não ter muito critério com os horários. Eu faria essa alteração se soubesse programação porem não sei, se você puder nos ajudar com esse problema a comunidade escolar ficaria muito grata pois a placa e a caixinha já estarei doando para a escola. Obrigado

    1. 0

      Olá Hemerson!
      Acredito ser uma ideia interessante esta sua sugestão. O problema é tempo para fazer este programa ! Vou anotar no caderninho como sugestão para um futuro artigo.
      Obrigado
      Cláudio

  11. 0

    Cara queria usar uma saída AN para usar um LM35, como faço pra mudar isto? Não manjo mto. Tem como vc adicionar a essa um Lm35? Ficaria nota 10 se tu fizestes isso.

      1. 0

        Entao, o que eu queria é que no display, além de aparecer data e hora, tbm mostrar a temperatura, ficaria mto bom,creio q seja coisa simples, porém não tenho a mesma habilidade q vc

        1. 0

          Olá Superfitness!
          Entendi agora o que deseja. Mas infelizmente, o pic 16f628a não dispõe de conversor analógico/digital, o que impossibilita a leitura de tensão neste projeto.
          Cláudio

  12. 0

    Boa noite,

    Claudio estou fazendo um projeto similar ao seu, estou usando mikroc, seria possível me mostrar como é feita a programação para eu ter uma base e fazer algumas alterações?

    Obrigado e parabens pelo blog.

    1. 0

      Olá Burnys!
      Exatamente em que eu posso ajudar? É a programação do pic ou seja, como carregar o hex no pic? Ou é algo relativo ao programa “c”, como ele funciona?
      Cláudio

  13. 0

    Amigo resoolvi montar o projeto mas quando tento gravar o micro da o seguinte erro :

    EEPROM erro at 0X0001
    Good 0X01
    Bad 0XFF

    sempre no final da gravação o que posso fazer ?

    1. 0

      Olá Liliano!
      Não sei te dizer o porque, mas o teu gravador não está conseguindo gravar a parte final do arquivo hex relativo a pré-programação da eeprom do pic. Consulte o manual do teu programador sobre o que poderia estar ocasionando isto.
      Cláudio

  14. 0

    Olá larios, primeiramente parabéns pelo blog, já fiz vários projetos seus e todos funcionaram perfeitamente, inclusive esse, fiz um para controle de iluminação de aviário, e gostaria de saber se você tem algum projeto para acionamento semanal, pois preciso acionar um motor uma vez por semana e com controle do horário e do dia da semana, para um silo para secagem de milho. você teria algum projeto que me atenda, se possível nesse mesmo projeto porque no inicio da secagem precisa ficar ligado quase direto, apenas uma saída semanal chega.
    OBS: não entendo de programação.

    Desde já muito obrigado

    1. 0

      Olá Adilvan!
      Obrigado por seu comentário apreciativo aos artigos deste blog. No momento, não tenho nada pronto que possa lhe ajudar. Mas quem sabe, futuramente possa analisar esta possibilidade.
      Claudio

  15. 0

    Claudio, boa tarde.
    Descobri seu blog ontem, fiquei muito satisfeito, esse circuito era bem o que estava tentando desenvolver, contudo ainda sou um pouco leigo com PIC, mas já possuo alguma experiência com Arduino.

    Só gostaria de saber se é possível gravar este PIC com um conversor serial FT232 utilizado no Arduino?

    1. 0

      Olá Tiago!
      O conversor FT232 , se eu não estiver enganado é usado para adaptar portas ‘comX’ de PC, usando a entrada ‘USB’ para padrão de portas seriais. Não sei como ele é usado no Arduino e não sou a pessoa mais indicada para te ajudar com Arduino. Mas para programar um pic, precisará de um software de programação ( poderá usar o WINPIC800) mais um hardware ligado na porta serial do computador (como o ‘simples programador‘). Caso teu PC não disponha de porta serial, poderá usar um adaptador de usb/serial comercialmente vendido, ou tentar usar o teu FT232, retirando os sinais dos pinos apropriados (terá que ver os datasheet deste ci). O Winpic800 necessitará do arquivo hex fornecido junto ao artigo para ser gravado no PIC que você usará. Veja exemplos no youtube de uso do winpic800.
      Cláudio

  16. 0

    Olá Claudio,
    Eu continuei testes e se você mantiver o estado das saídas para ser sem poder momentaneamente, mas não é um problema quando o tempo sem poder em muito grandes, algumas saídas que devem ser estabelecidos e outros devem cair, não o fez, desde o retorno para energizar o circuito, manteve o status das saídas como eram quando eles perderam o poder, não correspondendo a agendar horários para 6 canais.
    Por favor, você pode modificar o programa.
    Obrigado pela ajuda.
    Saudações.

    1. 0

      Olá Jandos! Você está usando a versão 3 em código ‘C’? Se não experimente esta. Foi alterada toda a forma de comparação do tempo real com os tempos programados. A versão em ASM já estava com o tamanho muito inchado para se alterar mais. Portanto, optei por uma versão partindo dozero, mas em “C”.
      Cláudio

      Hola Jandos! Está utilizando el código en ‘C’? Si no, intenta-lo. Fue cambiado la forma de comparación de la hora con los tiempos programados. La versión del ASM ya era de tamaño muy hinchado, e no era possible se cambiar más. Entonces opté por un nuevo código, una nueva versión partiendo del zero, pero en “C”.
      Cláudio

      1. 0

        Olá Claudio,
        Eu não estava usando, eu não tinha percebido que você já tinha colocado na página, mas desde que eu carreguei o PIC e ele funciona muito bem.
        Eu realmente gosto do novo formato das mensagens no LCD.
        Nenhuma linguagem C, mas eu vou tentar mudar os dias da semana em espanhol.
        Mais uma vez muito obrigado.
        Saudações.

        Hola Claudio,
        No lo estaba utilizando, no me había fijado que ya lo habías puesto en la página, pero ya lo cargué al PIC y funciona muy bien.
        Me gusta mucho la nueva presentación de los mensajes en el LCD.
        No se de lenguaje C, pero voy a intentar cambiar los días de la semana a español.
        Nuevamente muchas gracias.
        Saludos.

  17. 0

    Bom dia Claudio,
    Eu experimentei o programa e funciona perfeitamente.
    Agradeço a sua atenção.
    Este projeto é muito bom, eu vou usar para programar as luzes da casa quando eu não estou e fingir que alguém está dentro.
    Pode ser dado muitas aplicações.
    Muito obrigado.

  18. 0

    Olá Claudio, eu tenho armado circuito e funcionando bem, no entanto, quando é executado momentaneamente fora de tensão, o circuito já não monta o relé que, de acordo com o programa deve ser montado, ou seja, as saídas não são devolvidos ao seu status que tinha antes deixado sem tensão.
    Você vai apreciar a sua ajuda muito.
    Saudações.
    (Desculpe, eu escrevi tradutor espanhol-Português)

    1. 0

      Olá Jandos!
      Obrigado por trazer atenção este assunto. Assim que tiver um tempo livre, irei montar o circuito e fazer testes. Por favor, aguarde um futuro retorno.
      Cláudio

    2. 0

      Olá Jandos! Por favor, experimente esta versão atualizada do relógio controlador postada no artigo em adição e com link rápido aqui. Nesta versão, a situação de cada saída fica gravada na eeprom, sendo recuperada ao reiniciar o microcontrolador. Será útil apenas para quedas momentâneas de energia, já que os reles, sem energia não funcionam.
      Cláudio

  19. 0

    Olá Cláudio, tudo bem? Parabéns pelo projeto. É extremamente inteligente. Ficou excelente 😀 . Você teria o mesmo com apenas 1 canal na linguagem CCS C? Um abraço e fica com Deus.

  20. 0

    Muito obrigado Edimilson e a você também Claudio. Já vou começar a montar hoje mesmo. Um forte abraço a todos do Blog.

  21. 0

    Olá Claudio, você teria o código modificado para acionar somente o rele 1. Não sei muito de programação para alterar o seu código e usar somente o rele1; se tiver você pode me enviar.Obrigdo

    1. 0

      Olá Hemerson! O Sr. Edmilson cedeu gentilmente o asm e o hex da sua versão de um canal. O link está incorporado ao artigo. Ou clique aqui para obte-lo.
      Cláudio

  22. 0

    Bom dia Cláudio e membros do forum! sou novo aqui!
    Alguém poderia me ajudar em um código C para esse projeto muito bacana? precisaria de menos canais, o ds 1307 com lm 35 na tela inicial e menus para poder adaptar diversas oportunidades como um timmer ou mais e etc.
    Desde já agradeço a todos!!!

    1. 0

      Olá Alison! Este projeto a que faz referência foi escrito apenas em assembly. Eu atambém estou aprendendo a linguagem “c” e ainda tenho muitas limitações no emprego de certas rotinas internas ao compilador. Mas fiquei curioso, pois você vai misturar o DS1307 (relogio) com o LM35 (sensor de temperatura). O que vai sair nesta montagem? Poderia compartilhar? Seria um gravador de temperaturas ambiente?
      Cláudio

  23. 0

    Claudio bom dia,
    Muito obrigado por sua ajuda.
    Se os pinos foram alteradas D4-D5-D7-D6.
    O gerido e funcionou perfeitamente.
    Muito obrigado.
    Saudações.

  24. 0

    Claudio bom dia,
    Parabéns por este excelente trabalho.
    (estou usando o tradutor do Google).
    Eu tenho um problema, eu amei o circuito em um PCB, mas o visor LCD mostra caracteres japoneses, que estão constantemente em movimento.
    Quando eu pressionar os botões se houver mudanças, eu estou usando o JHD162A.
    Gostaria de receber sua ajuda.
    Saudações.
    (Repito meu comentário, porque esta é a única que eu não antes construída)

    1. 0

      Olá Jandos! Creio que possa ser algum pino invertido na ligação entre o microcontrolador e o LCD. Experimente conferir pino a pino, as ligações entre PIC e LCD na sua PCB, para se certificar de algum erro na ligação.
      Cláudio

  25. 0

    Olá cláudio!
    Fiz as modificações nas linhas do programa conforme sugerido, compilei o arquivo e lhe escrevo para informar que o mesmo funcionou perfeitamente. Agora, quando a alimentação do circuito é retirada, os segundos também continuam armazenados normalmente. Obrigado pela atenção.

    1. 0

      Olá Marcelo! Obrigado por retornar com a informação. Fico feliz que tenha tido sucesso! Bons projetos para você!
      Cláudio

  26. 0

    Prezados.
    Montei o circuito e percebi que se desligo e ligo o mesmo, os segundos não são armazenados, ou seja, os segundos sempre começam contando a partir de 00 quando torno a ligar. Alguém saberia como resolver esse problema? Desde já agradeço.

    1. 0

      Olá Marcelo!
      Quando foi feito este projeto, a intenção era de ajusta-lo e mante-lo ligado para controlar as carga, geralmente mais preocupados com minutos e horas. Mas se você necessita desta ‘precisão’ dos segundos ao inicializar o microcontrolador, creio que você terá que alterar a seguinte porção do código, que se encontra no início do programa:

      CLRF BUFFER ;LIGA O OSCILADOR DO DS1307
      MOVLW C_SEC ; C_SEG = 0X00 ou seja, está zerando os segundos visto que estou escrevendo…
      CALL DS_WRITE

      Pois ao inicializar, deve-se certificar de estar ligado o RTC (ds1307). Mas na forma que está o código, também ‘zera’ o contador de segundos do RTC. O bit ‘7’ do registrador ‘0’ é o bit liga e desliga do RTC. Os outros bits são das dezenas de segundos e unidade de segundo (veja datasheet DS1307 pag. 8). O que pode-se pensar em fazer? Ler primeiro a posição ‘0’ da ram , zerar o bit 7 sem alterar os outros bits e escrever novamente para gravar o byte 0 da ram. Esta é uma possibilidade. Creio que poderá haver mais de uma solução. Mas é a que me vem a mente agora. Como o programa está bem ‘inchado’, sobrando poucas linhas na Flash, precisa ver se dará para fazer isto.
      Cláudio

    2. 0

      Olá Cláudio!
      Obrigado pela resposta. Substitui na linha correspondente C_SEC por 0X00,compilei o arquivo conforme muito bem explicado em outro tópico do site, porém não houve alteração. Caso tenha alguma outra susgestão, agradeço.

      1. 0

        Olá Marcelo! Não é apenas substituir uma linha. A idéia seria ler o byte de segundos do RTC e ver se está ligado ou não. Se estiver pula as linhas que ligam.
        Tente fazer a seguinte alteração na porção de código abaixo e recompilar ( não testei):

        INICIO

        BANK1 ;BANCO 1
        CLRF TRISA ;TUDO SAIDA
        CLRF TRISB ;TUDO SAIDA
        CLRF OPTION_REG ;HABILITA PULL UP
        BSF PIE1,0 ;LIGA INTERRUPÇÃO DO TIMER1
        BANK0
        MOVLW .7 ;DESLIGA COMPARADORES
        MOVWF CMCON
        CLRF PORTA ;ZERA SAIDAS
        CLRF PORTB
        CLRF PCAUX
        CLRF PCLATH
        MOVLW 0X21 ;PRESCALLER /4 NO TMR1
        MOVWF T1CON ;LIGA TIMER 1
        MOVLW B’11000000′ ;LIGA INTERRUPÇÃO GERAL E PERIFÉRICOS
        MOVWF INTCON

        CALL LcdInit ;INICIA LCD
        CALL LcdClear
        MOVLW 0XFF
        CALL DELAY_MS
        MOVLW MSG1 ;NOME DO EQUIPAMENTO
        CALL ENV_LCD
        CALL LINHA_2
        MOVLW MSG2 ;BLOG
        CALL ENV_LCD
        MOVLW 0X20 ;TEMPO DA APRESENTAÇÃO
        CALL DELAYW

        CLRF BUFFER ;LIGA O OSCILADOR DO DS1307

        ;aqui tem que ser alterado POR COMENTAR COM ‘;’
        ; MOVLW C_SEC
        ; CALL DS_WRITE

        ;para ler antes de escrever, ACRESCENTE ESTAS LINHAS (ENTRE XXX):

        ;XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

        MOVLW C_SEC ;ler primeiro o byte de segundos do RTC
        CALL DS_READ ;le e temos em ‘w’ a leitura dos segundos do RTC
        MOVWF AUX ;PEGA A LEITURA E COLOCA EM UM REGISTRADOR
        BTFSS AUX,7 ;TESTA O BIT 7 (chave on/off do RTC, sendo ‘0’=ligado e ‘1’= desligado)
        GOTO SEGUE_PROG
        MOVLW C_SEC ;SE FOR ‘1’ ENTÃO LIGA O RTC
        CALL DS_WRITE
        SEGUE_PROG

        ; XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

        CLRF R_MENU

        ;=================================================================================================
        ; PROGRAMA PRINCIPAL
        ;=================================================================================================
        MAIN
        BANK0
        ;=================================================================================================
        ; ATUALIZA CONTADORES DE TEMPO E CALENDÁRIO
        ;=================================================================================================
        …………

        Cláudio

  27. 0

    olá edmilsom e possivel voce me enviar este relogio com a mudança que voce relizou quero montar uma estufa
    e vou precisar apenas de um relé tambem.jose luiz

  28. 0

    Olá Claudio boa tarde valeu pela dica anterior ja coloquei os resistores.Ontem montei o relogio com ds 1307 e minha aplicação para ligar uma maquina de solda requer somente uma saida ai notei que na hora de programar os horarios mesmo que usar somente uma saida tem que passar por todas as outras programações .Então pensa daqui pensa dali acabei apagando no codigo fonte as opções de saida desde dois até seis e mudando de lugar alguns comandos nw é que deu certo agora meu relogio tem somente um programa ligar rele1
    e desligar rele1 apos a mensagem de encerrar ajustes ele volta para o relogio nw passando pelas outras programações e fikou 10 perfeito na verdade eu quis dar um ar de importado ao relogio e mudei os termos todos para ingles tipo on off calendar clock no lugar de canal 1 agora aparece device 1 fikou muito legal .Sei que existe muita literatura sobre programação mas gostaria que vc me indicasse seus livros em asm para eu poder comprar iguais. Mais uma vez sou muito agradecido por vc estar sendo um professor para muitos de nos e que Deus te abençoe . Obrigado Edmilson LS

    1. 0

      Olá Edmilson! É isto mesmo. Altere os programas conforme suas necessidades. Invente, personalize, divirta-se com a eletrônica!
      Claudio

  29. 0

    Claudio tudo bem com vc ? ja montei este relogio e ficou perfeito agora a maquina de solda aqui da empresa deixou de ter um timer analogico e passou a ter um digital agora deixa eu te perguntar uma coisa os resistores de 220r ligados as teclas para ajustes nw podem ser substituidos somente por um ligado ao terra ? afinal de contas pressiona se uma tecla por vez eu fiz assim e esta funcionando normal tbm omiti os resistores de 470r e esta normal.Mais uma vez obrigado por estar ajudando no aprendizado de pessoas como eu parabens e que Deus te ilumine e de bastante saude força e sabedoria para publicar seus projetos.Edmilson LS

    1. 0

      Olá Edmilson! Os pinos ligados as chaves também são ligados aos pinos do LCD. Assim, ora se comportam como entradas, ao ler os interruptores, ora estão fornecendo niveis ‘1’ ou ‘0’ para o LCD, como saídas. Estes resistores servem para limitar a corrente a níveis suportáveis e evitar queimar a saída do PIC em uma situação em que o pino se comporta como saída ‘1’ (quando enviando dado para o LCD) e você aperta o interruptor ligando ao gnd. Sem o resistor, seria um curto. Aconselho a colocar os resistores, para não perder o seu PIC.
      Claudio

Comments are closed.