Poseidon.

#include <sexta1.h> int16 minuto = 0; int16 segundo = 0; #fuses NOMCLR INTRC_IO PLL_SW #use delay(clock=32000000) #use fast_io(A) int32 cnt = 0; #INT_RA void RA_isr(void) { clear_interrupt(INT_RA3); if(input(PIN_A3)) { cnt++; } if (cnt >= 60 ) { cnt = } } //*************************************************************************************************************** void main(){ setup_oscillator(OSC_8MHZ | OSC_PLL_ON); set_tris_a (0b00011110 ); output_high(pin_a0); output_low(pin_a5); enable_interrupts(GLOBAL); enable_interrupts(INT_RA3); clear_interrupt(INT_RA3); while(TRUE) { if (segundo >= 60 ) { segundo=0; minuto ++; } if (minuto < 20 ) { output_high(pin_a5); } if (minuto>=20 ) { output_low(pin_a5); }}}

/***************************************************** WDTCON=0b00000000;//dis wdog = ok, desabilitado OPTION_REG=0b00000000; //pullup = ok CM1CON0=CM1CON1=0; = ok, desabilitado ANSELA=0; //pinos IO digital = ok, pinos IO digital TRISA=0; //tudo saída = ok, tudo saída CONFIG(FOSC_INTOSC & WDTE_OFF & MCLRE_OFF) = Ok *******************************************************/ #include <sexta1.h> int16 minuto = 0; int16 segundo = 0; #fuses NOMCLR INTRC_IO PLL_SW //#device ADC = 10 #use delay(clock=32000000) #use fast_io(A) int32 cnt = 0; //************************************************************************************************************* #INT_TIMER0 void TIMER0_isr(void) { clear_interrupt(INT_TIMER0); cnt++; set_timer0(130); if(cnt >= 125) { cnt = 0; segundo++; } } // ************************************************************************************************************ void main() { set_timer0(130); // setup_adc_ports(sAN1|sAN2|sAN3); // setup_adc(ADC_CLOCK_INTERNAL); setup_oscillator(OSC_8MHZ | OSC_PLL_ON); setup_timer_0(RTCC_INTERNAL|RTCC_DIV_2|RTCC_8_bit); set_tris_a (0b00000000 ); enable_interrupts(INT_TIMER0); enable_interrupts(GLOBAL); clear_interrupt(int_timer0); output_low(pin_a1); output_low(pin_a5); while(TRUE) { if (segundo > 59 ) { segundo = 0; minuto ++; } if (minuto > 19 ) { output_toggle(pin_a1); minuto = 0 }}} Aumentou muito a frequência com essas mudanças.

Infelizmente não estamos na mesma frequência de sintonia, não estamos falando a mesma língua, desde o inicio estou batendo na mesma tecla sobre o tempo não bater, e você não conseguiu captar isso, se eu colocar um LED nesse pino a1 ele não vai alternar nesse tempo que está definido de 20 minutos, a culpa é minha, eu devia ser mais específico nas minhas postagens, como você mesmo disse devemos respeitar os limites de cada um.

Boa noite, o código no início dessa postagem foi baseado nisso mesmo, 4ms x 125 para dar 500ms ou 4ms x 250 para dar 1000ms (1segundo) o problema é que aqui #INT_TIMER0 void TIMER0_isr(void) { clear_interrupt(INT_TIMER0); // Clear timer0 interrupt flag bit cnt++; if(cnt == 125) { cnt = 0; segundo++; // output_toggle(PIN_A0); } } funciona aparentemente bem, mas aqui while(TRUE) { if (segundo >= 60 ) { segundo = 0; minuto ++; output_toggle(pin_a0); não funciona. Fiz usando o timer1 como tinha sugerido e deu o mesmo problema, #INT_TIMER1 void TIMER1_isr(void) { clear_interrupt(INT_TIMER1); cnt++; set_timer1(15536); //65.536ms -15.536ms = 50.000ms vezes 10 ou 20 resultando em 0,5 seg. ou 1 segundo //set_timer1( 15536+ get_timer1()); //if(cnt >= 20) //1 segundo em nível alto e 1 segundo em nível baixo if(cnt >= 10) //0,5 segundo em nível alto e 0,5 segundo em nível baixo { cnt = 0; segundo++; // output_toggle(PIN_A0); } funciona bem aqui mas depois do while(TRUE) não funciona, parte do código usando o timer1 está abaixo while(TRUE){ if (segundo >= 60 ) { segundo = 0; minuto ++; output_toggle(pin_a0); } if (minuto < 2 ) { output_high(pin_a5); } if (minuto>=2 ) { output_low(pin_a5); }}} Obrigado pela intenção.

Boa noite, sobre isso "parece que você divide os 8MHz que entra no prescaler portanto aplica 62500Hz no timer" não entendi bem, como eu disse, na configuração que fiz já recebi 4,0 ms overflow em 32MHz, sobrando só incrementar variáveis pra conseguir o tempo que pretendia, mas não bateu com o esperado. sobre usar isso "cristal externo com freq multipla de base 2", infelizmente não posso usar, porque todos os pinos estão sendo usado, mas valeu pela tentativa.

Boa noite, não deu certo aqui, mas valeu pela intenção, 1 /250seg resultaria em 4ms correto? Boa noite, não deu certo aqui, mas valeu pela intenção, 1/250seg. resulta em 4,0 ms overflow certo? com essa mudança que fiz resultou em 4ms, igual o meu código, e com resultado iguais nessa parte { clear_interrupt(INT_TIMER0); // Clear timer0 interrupt flag bit //set_timer0(130); cnt++; if(cnt == 125) { cnt = 0; segundo++; //output_toggle(PIN_A0); } set_timer0( 130 + get_timer0());// set_timer0(130); deu diferença na parte depois while(TRUE) eu esperava 60 segundos resultou em 51 segundos, segui passo a passo o que foi passado, não sei onde está o erro. Esse é o meu no teste feito aqui no proteus funcionou incrementando em segundos, o problema é que funcionou sem lógica, clear_interrupt(INT_TIMER0); // cnt++; if(cnt == 83) { // Com cnt ==83 (+ou- 83) o resultado depois do while(TRUE) saiu melhor, cnt = 0; // Não entendo porque deu esse resultado, porque cnt==83 resultou em segundo++; // 336ms em nível alto e 336ms em nível baixo e com cnt ==125 resultou output_toggle(PIN_A0); } // em 510ms em nível alto e 510ms em nível baixo, resumindo, // Resultado depois do while(TRUE) com cnt==83 resultado +ou- 1 segundo ; com cnt==125 resultado +ou- 1,5 segundo. Só lembrando que estou usando como referencia isso 4,0 ms overflow que veio quando configurei o CCS C COMPILER. setup_timer_0(RTCC_INTERNAL|RTCC_DIV_128|RTCC_8_bit); //4,0 ms overflow (Uso do timer0) EM 32MHz

Olá pessoal, se alguém puder me ajudar, preciso desligar um relé depois de 20 minutos usando o TIMER0, com 4,0 ms overflow (uso do TIMER0 EM 32MHz) x 125 daria 500ms em nível alto e 500ms em nível baixo, fiz o código mas não bate com o esperado, pic usado foi 12f1822. #include <sexta1.h> //int16 analogico1 = 0; //int16 analogico2 = 0; //int16 analogico3 = 0; int16 minuto = 0; int16 segundo = 0; #fuses NOMCLR INTRC_IO PLL_SW #device ADC = 10 #use delay(clock=32000000) #use fast_io(A) int32 cnt = 0; int32 liga = 0; int32 li = 0; //************************************************************************************************************* #INT_TIMER0 void TIMER0_isr(void) { clear_interrupt(INT_TIMER0); // Clear timer0 interrupt flag bit cnt++; if(cnt == 125) { cnt = 0; segundo++; // output_toggle(PIN_A0); } } //************************************************************************************************************ #INT_RA // interrupção RA. //------------------------------------------------------------------------ void RA_isr(void) // interromper a rotina de serviço { clear_interrupt(INT_RA3); if(input(PIN_A3)) // Se RA3 for HIGH { liga++; } if (liga > 3599 ) { liga = 0; li++; } } //*************************************************************************************************************** void main() { setup_adc_ports(sAN1|sAN2|sAN3); setup_adc(ADC_CLOCK_INTERNAL); setup_oscillator(OSC_8MHZ | OSC_PLL_ON); // Set internal oscillator to 32MHz (8MHz and PLL) setup_timer_0(RTCC_INTERNAL|RTCC_DIV_128|RTCC_8_bit); //4,0 ms overflow (Uso do timer0) EM 32MHz set_tris_a (0b00011110 ); //(0b00011110); // HEX 1E RA Tris 76543210 0X1E enable_interrupts(INT_TIMER0); enable_interrupts(GLOBAL); clear_interrupt(int_timer0); output_high(pin_a0); output_low(pin_a5); enable_interrupts(GLOBAL); // Enable global interrupts enable_interrupts(INT_RA3); clear_interrupt(INT_RA3); // Clear RA IOC flag bit while(TRUE) { if (segundo >= 60 ) { segundo = 0; minuto ++; output_toggle(pin_a0); } if (minuto < 20 ) { output_high(pin_a5); } if (minuto>20 ) { output_low(pin_a5); }}}

https://storage.ning.com/topology/rest/1.0/file/get/9458559075?profile=original

Tinha um curto em R1 no esquema anterior porque estava sendo testado em 24 volts, vou postar o novo esquema corrigido e não tem resistor na base de Q1 no esquema postado porque é um transistor de código A8C com resistor de 47k integrado em sua base e outro na base e emissor de 47k.

Como mencionado a carga conectada aos contatos do relé na comutação cruzando zero não faz sentido, porque há muito tempo de atraso entre a ativação da bobina do relé e o fechamento do contato do relé. O tempo não é muito preciso e varia com o tempo, remanência, envelhecimento, porém vejo circuito usando relé e fico sem entender, como exemplo de um circuito com C.I.CD4013 que vou postar com os dizeres “Exclusivo sistema de comutação próximo ao zero da rede (senóide) aumentando a vida útil da carga e do relé,” quem trabalha com elétrica já teve oportunidade de ver várias fotocélulas desse tipo.

Para acionar o relé usa o RA5, RA0 quando em nível lógico alto polariza a base de Q1, fazendo com o diodo Z3 fique em curto, tendo portando uma tensão de +ou- 24 volts ou 56 volts depedendo do nível lógico em Q1, não sei se é para compensar a carga (relé), ou seja, usa 56 volts com relé acionado e 24 com relé desacionado, por ser uma fonte sem trafo qualquer carga dá uma queda grande de corrente. Vou mandar os esquemas simulando Q1 no corte e na saturação usando Push Button (Chave Táctil) colocando em curto D7.

É isso mesmo o pino RA4 fornece A BASE DE TEMPO (1h, 2h, 3h, 4h, 6h, 8h, 10h, 12h),os pinos RA1 e RA2 trabalham juntos, RA0 e RA5 do transistores, só sobrou o pino RA3 para fazer a detecção sinal de zero crossing, como você mencionou a carga está conectada aos contatos do relé, nesse caso, a comutação cruzando o zero da rede não faz sentido, porque há muito tempo de atraso entre a ativação da bobina do relé e o fechamento do contato do relé. O tempo não é muito preciso e varia com o tempo, remanência, envelhecimento, etc, será que o responsável não pensou nisso ou fez o programa já pensando nesse atraso?

#include <main.h> //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; //int16 minuto = 0; #fuses NOMCLR INTRC_IO PLL_SW #device ADC = 10 #use delay(clock=32000000) //#use fast_io(a) //int32 cnt = 0; #INT_TIMER1 void TIMER1_isr(void) { clear_interrupt(int_timer1); set_timer1(15536); // 0,05 segundo para 32MHZ //set_timer1(3036); // 0,5 segundo para 4MHZ //cnt++; //if(contador==1) //output_toggle(pin_a5); //min++; //;;;;;;;;;;;;;;;;;;;;;;;;;;; //contador = 0; //contador++; //set_timer1(15536); // 0,05 segundo para 32MHZ //set_timer1(3036); // 0,5 segundo para 4MHZ //clear_interrupt(int_timer1); } void main() { port_A_pullups(0x08); setup_adc_ports(sAN1|sAN2|sAN3); setup_adc(ADC_CLOCK_INTERNAL); setup_timer_1(T1_INTERNAL|T1_DIV_BY_8); //524 ms overflow set_timer1(15536); // 0,05 segundo para 32MHZ //set_timer1(3036); // 0,5 segundo para 4MHZ setup_oscillator(OSC_8MHZ | OSC_PLL_ON); // Set internal oscillator to 32MHz (8MHz and PLL) // set_tris_a (0b00011110 ); //(0b00011110); // HEX 1E RA Tris 76543210 0X1E //set_tris_a (0x1E); clear_interrupt(int_timer1); enable_interrupts(INT_TIMER1); enable_interrupts(GLOBAL); output_high(pin_a0); output_low(pin_a5); while(TRUE){ if (!input(pin_a3) ) { output_high(pin_a5); //output_toggle(pin_a5); } else { output_low (pin_a5); } } } /* { if (cnt >= 1200 ) //passou 1 minuto { cnt = 0; minuto++; } if (!input(pin_a3) ) && (minuto < 10) { output_high(pin_a5); } if (!input(pin_a3) ) && (minuto >= 10) { output_low(pin_a5); } if(minuto >= 20) { minuto = 0; } } } */ Boa noite, não tinha pensado nisso "E claro, a própria mecânica do relé vai causar mais atraso no acionamento" O que te impede de usar um moc zero crossing? Porque a placa estão prontas, são algumas fotocélulas com defeito que caíram em minhas mãos. O esquema postado até o momento foi corrigido por colega porque o meu estava uma desordem, vou postar o meu esquema e as formas de ondas e o código usado nos testes, habilitando port_A_pullups(0x08) ; teve uma mudança na forma de onda, lembrando que essa fotocélula liga próximo ao zero da rede.

Boa noite, a dúvida é como foi feita a detecção da passagem por zero nessse circuito, esse é o esquema do mesmo, foram usados poucos componentes para a tal função, uma correção, o trimpot RV1 e RV2 é de 100k, capacitor C2 é de 5nF e diodo zener Z1 24 volts, Z3 56 volts Z2 5 volts.