Poseidon.
-
Posts
29 -
Cadastrado em
-
Última visita
Tipo de conteúdo
Artigos
Selos
Fabricantes
Livros
Cursos
Análises
Fórum
posts postados por Poseidon.
-
-
6 horas atrás, .if disse:
Olá de novo amigo. Fiz uma minisimulação aqui com este mc pic12f1822 e de fato esbarrei e patinei em alguns detalhes. Depois de dar uma olhadela no d.s. tive algum sucesso.
P.ex. devo desabilitar o wdog, configurar os ports como digital, desab. o comparador e alguns etc. O meu compilador permite acesso direto aos registros
WDTCON=0b00000000;//dis wdog OPTION_REG=0b00000000; //pullup CM1CON0=CM1CON1=0; ANSELA=0; //pinos IO digital TRISA=0; //tudo saída1/2 auto explicativo, também devo configurar os fuses:
__CONFIG(FOSC_INTOSC & WDTE_OFF & MCLRE_OFF);Ve como se faz aí no seu. Por enquanto ve se só tais configs podem te ajudar. A qualquer momento tento fazer o timer0 rodar com o lance dos 20 minutos que teoricamente está correta aquela configuração que fizemos.
Em tempo.. mc meio caro. Provavelmente apenas ele atende seu projeto, certo? Ok.. não é da minha conta mas como sempre a ideia é somar eventualmente ajudando a subtrair custos .. minha especialidade aqui fora.
/***************************************************** 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.
-
5 horas atrás, .if disse:
De boa... Mas a gente evita* dar solução. O que se usa fazer é mostrar alternativas, dicas, nortes e afins. Alguns captam, outros nem tanto. Mas claro a gente respeita o limite de cada um e tenta melhorar cada vez mais. Mas se você prestar atenção, algo me diz que há a solução semicompleta pra tua inquietação nas minhas postagens. Veja se isso torna mais próximo do completo:
#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_128|RTCC_8_bit); set_tris_a (0b00011110 ); 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); }}}
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.
-
23 horas atrás, .if disse:
Se você não usar o botão < code > não tem como interpretar direito. Considere ler isso...
E tem+... Por ser um desafio relativamente simples eu até que poderia tentar te ajudar um pouco mais mas isso...
e isso...
são belos convites para minha despedida pois há impressão de desistência de diálogo. Portanto a dica que dou é melhore o aspecto visual do seu post eventualmente futuro - nos dois sentidos - pra que alguém que te for orientar se sinta mais a vontade. boa sorte.
edit...
#INT_TIMER0 void TIMER0_isr(void) { clear_interrupt(INT_TIMER0); // Clear timer0 interrupt flag bit cnt++; if(cnt > 124) { cnt = 0; segundo++; // output_toggle(PIN_A0); } }funciona aparentemente bem, mas aqui
while(TRUE) { if (segundo > 59 ) { segundo = 0; minuto++; output_toggle(pin_a1); //outro pino } }
Tranquilo, sobre usar o botão "< code >" concordo com você, agora sobre isso "mas valeu pela tentativa", e isso " pela intenção", estou apenas agradeço, agora devo mesmo mudar meu dialogo aqui e o modo de como faço as postagens, porque já é a quarta vez que posto algo aqui e saio sem solução.
-
Em 04/08/2023 às 09:04, .if disse:
Então você tem a faca na mão. Só falta o queijo...
Se seu tic tac é 4mS fica simples você temporizar com o tempo que quiser meu amigo. Digamos que você queira 1segundo. Quantos 0.004 você tem em 1?
você pode fazer algo como:
if (_4ms>250) {_4ms=0;segundo++;}e quantos segundos você tem em 20 minutos? Faça o mesmo:
if (segundo>20*60) {segundo=0;corte_o_queijo();}Tenta e me conta...
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.
-
11 horas atrás, .if disse:
Parece que você divide os 8MHz que entra no prescaler portanto aplica 62500Hz no timer. Refaça as contas. Lembrando que por ser 8bits ele divide no máximo por 256 ao ser alimentado com 0 ou nem ser alimentado.
Lembrando que pra dar mais precisão você precisa usar cristal externo com freq multipla de base 2
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.
-
Em 02/08/2023 às 08:14, .if disse:
Olá amigo. Não conheço este mc e nem o compilador... Eu (eu) prefiro ter uma visão do hw e não me prender apenas ao sw. Apesar de eu não ter achado rapidão a imagem do timer deste mc, ele é tradicional e se assemelha à este...
Você vai ter que usar a imaginação algo como:
32Mhz/4->entra 8MHz no contador prescaler
prescaler/256->31250Hz no contador final TMR0
digamos que eu (eu) queira 250Hz na saída: devo fazer 31250/125=250
Sabendo que ele conta acima e seta o flag na contagem 255...0 devo alimentar o TMR0 com 255-125=130 a cada passagem pela interrupt... Pronto.. agora você tem uma interrupt a cada 1 /250seg. Incremente variáveis pra conseguir o tempo que quiser a partir deste.
Obs1: o timer1 é 16bits o que pode lhe ser mais eficiente
Obs2: tentei escrever devagar pra você entender melhor mas mesmo assim posso ter cometido alguma gafe. Mais tarde dou uma conferida...
Boa noite, não deu certo aqui, mas valeu pela intenção, 1 /250seg resultaria em 4ms correto?
Em 02/08/2023 às 08:14, .if disse:Olá amigo. Não conheço este mc e nem o compilador... Eu (eu) prefiro ter uma visão do hw e não me prender apenas ao sw. Apesar de eu não ter achado rapidão a imagem do timer deste mc, ele é tradicional e se assemelha à este...
Você vai ter que usar a imaginação algo como:
32Mhz/4->entra 8MHz no contador prescaler
prescaler/256->31250Hz no contador final TMR0
digamos que eu (eu) queira 250Hz na saída: devo fazer 31250/125=250
Sabendo que ele conta acima e seta o flag na contagem 255...0 devo alimentar o TMR0 com 255-125=130 a cada passagem pela interrupt... Pronto.. agora você tem uma interrupt a cada 1/250seg. Incremente variáveis pra conseguir o tempo que quiser a partir deste.
Obs1: o timer1 é 16bits o que pode lhe ser mais eficiente
Obs2: tentei escrever devagar pra você entender melhor mas mesmo assim posso ter cometido alguma gafe. Mais tarde dou uma conferida...
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); }}}
-
14 horas atrás, aphawk disse:
Faz um favor se puder :
Poste esse arquivo feito no Proteus para dar uma simulada aqui.
Paulo
Não sei como postar arquivo do proteus para simulação, postei um link, não consegui simular bem o circuito no proteus.
https://storage.ning.com/topology/rest/1.0/file/get/9458559075?profile=original
18 horas atrás, Poseidon. disse: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.
-
22 horas atrás, Poseidon. disse:
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.
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.
-
Em 13/08/2021 às 10:35, aphawk disse:
Eu nem tinha reparado que o acionamento é via relé ! Que coisa mais mal-feita ....
Isso inutiliza todo o processo de zero-crossing, já que existe um tempo que varia com a idade do relé para o acionamento e desacionamento ....
Paulo
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.
-
Em 15/08/2021 às 22:12, aphawk disse:
Para uso de cargas comuns, o relé atende perfeitamente.
A função do pino RA4 é fornecer uma amostra da frequência da rede, a cada passagem de 0 para 1 começa um ciclo de 60 hertz, portanto em cada segundo ocorrem 60 pulsos; em 1 hora a contagem será de 60 x 3600 = 216.000 pulsos.
Assim, basta ir contando esses pulsos, e comparando com o ajuste de RV2, o qual dependendo da tensão nele indica o tempo desejado, por exemplo se rv2 estiver entre 0 e 12,5% do valor dele , a contagem desejada será de 216.000 . Quando for atingida, o relé aciona.
RV1 é o ajuste de luminosidade mínima; quando ela for atingida, inicia-se a contagem dos pulsos de RA4.
Minha opinião é que o tempo é controlado de maneira bem precisa, e o autor do projeto não se preocupou com o acionamento da carga no instante da passagem por zero, ele simplesmente fez o básico...
Só não entendi o porque de usar RA0 e RA5 para acionar o relé .... para mim bastava um só !
Paulo
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.
-
21 horas atrás, aphawk disse:
Pessoal,
Agora que entendi ... o pino RA4 fornece A BASE DE TEMPO, não o sinal de zero crossing .....
Paulo
É 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; } } } */
11 horas atrás, .if disse:O que te impede de usar um moc zero crossing? clique
Seu esquema tá perturbador.. não consigo conectar o gnd à rede...
Este suposto atraso que Paulão menciona é causado por C2. Caso ocorra e seja significativo, você pode diminuir C2 ou removê-lo.
E claro, a própria mecânica do relé vai causar mais atraso no acionamento. Não sei se consegue ver isso no mundo virtual da sua simulação.
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.
-
1
-
-
Em 10/08/2021 às 21:58, aphawk disse:
Esse esquema já foi objeto de uma discussão aqui no CDH fazem vários anos .... nada como uma velha lembrança !
Supondo que R1 seja de 5k :
Corrente de coletor dos optos ignorando Vsat dos optos = 5/5k =1 mA.
Pagina 7 figura 12 do datasheet : para IC= 1 mA, corrente de entrada If no led = 1 mA (aproximado)
portanto ....
se R3 = 100k , para ter corrente sobre ele de 1mA temos que a tensão sobre ele, ignorando Vled, é de 100.000 x 0,001 = 100 Volts.
Portanto, o detetor de passagem por zero sem levar em conta Q1 tem um erro de 100V ... ou seja, seu Triac vai acionar a carga quando a tensão for de 100V sobre ela !!!!.
Mas sua sorte é que existe Q1 no circuito !
Na prática, o Opto vai conduzir antes , porque com cerca de 0,1 mA no Led já existe uma certa corrente de coletor no transistor do opto, e Q1 amplifica essa corrente e entra em saturação, mas náo dá para afirmar o instante exato em que isso ocorre devido à tolerância de todos os componentes.
Se você tiver sorte e seu Q1 tiver ganho alto, tipo 300 , o erro será bem menor.
Mas se tiver em Q1 um transistor com bem menos ganho, tipo 50, o erro pode ser significativo.
Paulo
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.
-
Em 09/08/2021 às 19:23, aphawk disse:
Tive um Deja-vú com esse esquema.... alguém publicou ele fazem alguns meses, duvida era parecida também ....
Sobre o detector de cruzamento por zero, ele serve para sabe o instante em que você deve acionar o Triac, em teoria logo quando a tensão sobre a carga começa a subir, tendo passado por zero volts.
Mas como você consegue ver na simulação do Proteus, existe uma defasagem causada por C1 e RX e também R4/C2, que cria um erro significativo no instante da passagem por zero. Ou seja, quando você acionar a carga, a tensão sobre ela já estará acima de 20V ou até mais, que pode causar um "tranco" na carga, principalmente se ela for indutiva.
Aliás, um bom exercício escolar é entender como aparece esse sinal de cruzamento por zero, em relação ao terra do circuito.....
Paulo
Boa noite, não posso modificar o circuito mas caso modificasse talvez daria certo se fizesse igual esse esquema que usa 2 optoacopladores, como mencionei não posso modificar o circuito e tenho apenas um pino de entrada para detectar a passagem por zero.
-
3 horas atrás, vtrx disse:
O problema é que vai ter que usar interrupção,e se entende pouco de programação vai ser mais difícil para voce,além disso,se vai ser uma adaptação,teria que postar todo o esquema.
Bom dia, esse é o esquema da fotocélula, 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.
-
Em 08/08/2021 às 19:36, vtrx disse:
Tenho um projetoccs dimmer.rar que talvez te ajude.
Boa noite, agradeço sua ajuda, entendo pouco de programação, e para piorar tenho apenas um pino pra usar nessa passagem por zero, não posso alterar nada nela porque a placa já está pronta, é de algumas fotocélulas que está com defeito (sem programa). Vou postar parte do código em ccs c compiler e a forma de onda na entrada e saída do pic 12f1822 sem modificar nada e modificando. Mas não fica legal, quero ligar na passagem do zero, no código que fiz ele liga antes do nível lógico alto passar pelo zero.
#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() { 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; } } } */
-
Olá, pelo que entendi o cruzamento zero é normalmente usado para acionamento suave de cargas, aumentando sua vida útil. Alguém já fez um circuito com pic que permite identificar o momento em que a tensão da rede elétrica AC cruza a linha de zero volt. Preciso ligar um relé e não sei como fazer o código, não usarei amplificadores, optoacopladores. O circuito já está pronto, será usado apenas o pino 4 (RA3) do pic 12f1822 .
-
Code: #include <main.h> int contador = 0; #INT_TIMER1 void TIMER1_isr(void) { contador++; if(contador==1) { output_toggle(pin_a5); contador = 0; } set_timer1(3036); // 0,5 segundo clear_interrupt(int_timer1); } void main() { 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(3036); enable_interrupts(INT_TIMER1); enable_interrupts(GLOBAL); //0,5s = 1us x 8 x(65536- carga TRM1) // carga TRM1 = 65536 - 500000/8us // carga TRM1 = 65536-62500 //carga TRM1 = 3036 while(TRUE) { } }
-
Como configurar o timer0 do pic 12f1822 para piscar um led na frequencia de um segundo usando CCS Compiler?
#include <gf.h> int time = 0;//;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #INT_TIMER0 void TIMER0_isr(void) { time ++;//;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; //} //set_timer0(6); set_timer0(0); clear_interrupt(int_timer0); //set_timer0( 15369 + get_timer0()); //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; //Inicialização da contagem para o proximo ciclo de interrupcao com 15369 //get_timer_0() compensa o tempo de execucao das operacoes do timer ( delay_ms(50) ) } void main() { setup_adc_ports(sAN1|sAN2|sAN3); setup_adc(ADC_CLOCK_INTERNAL); setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256|RTCC_8_bit); //65,5 ms overflow clear_interrupt(int_timer0); //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; enable_interrupts(INT_TIMER0); enable_interrupts(GLOBAL); //set_timer0( 15369); //;;;;;;;;;;;;;;;;;;;;;;;;;;;; //set_timer0(6); set_timer0(0); //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; while(TRUE) { if (time < 7) { output_high(pin_a0); output_high(pin_a5); } if (time > 7) { output_low(pin_a5); output_low(pin_a0); } if (time > 14 ) { time = 0; } } }
-
1
-
-
6 horas atrás, .if disse:
Não entendi muito bem. você quer reprogramar o mc pra tais funções? O produto está com defeito? Melhor publicar fotos, desenhos, esquemas e claro, não te esqueças de ler o manual...
6 horas atrás, .if disse:Não entendi muito bem. você quer reprogramar o mc pra tais funções? O produto está com defeito? Melhor publicar fotos, desenhos, esquemas e claro, não te esqueças de ler o manual...
Boa noite, elas vieram sem programa, não estão funcionando, já passou o tempo de garantia, a única solução e gravar um novo programa ou descartar o pic mexendo na parte eletrônica, deixando ela como se fosse uma fotocélula comum.
-
Boa noite, estou de volta sem sucesso na tentativa de programar uma fotocélula, estou com algumas fotocélua com pic 12f1822 sem programa, e não consigo programar, e estou precisando delas funcionando, se alguém puder me ajudar, pino 2 ( RA5) vai para a base do transistor do rele, pino 3 ( RA4) vem do divisor de tensão um trimpot de 100k ohms que é para temporizar com 8 horários, 1,2 3, 4,6, 8,10 e 12horas, pino 4 (RA3 MCLR) recebe sinal da rede eletrica ( tipo sinal de clock), pino 5 (RA2) vem de outro trimpot 100k ohms com 6 níveis de lux, pino 6 (RA1) vem do LDR, se analisar o esquema durante o dia vai nivel lógico alto pra esse pino (RA1) e a noite nível baixo, pino 7 (RA0) vai para a base do transistor, que quando conduzindo coloca em curto 1 diodo, para economizar energia quando o rele estiver desligado. O problema que encontrei é usar o sinal da rede como sinal de clock no pino 4 (RA3 MCLR) e temporizar naqueles horários usando o timer, com delay não consegui, se alguem puder me ajudar agradeço. Resumindo, é uma fotocélula temporizada que funciona apenas a noite, escureceu ela liga o relé e permanece ligada pelo tempo programado, desligando em seguinda, permanecendo desligada o restande da noite, ligando no próximo escurecer da noite, por exemplo: programei pra 4 horas, escureceu ela liga por 4 horas depois desliga, voltando a ligar só no outro dia quando escurecer ( noite), esse escurecer depende da sessibilidade de RV1 (LUX). Obrigado.
-
1
-
1
-
Sobre o Clube do Hardware
No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais
Direitos autorais
Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais
Interrupçao usando o timer0 com PIC no CCS
em Microcontroladores
Postado