PIC Interrupçao usando o timer0 com PIC no CCS

Poseidon. · 1 de agosto de 2023

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); 
   
     }}}

.if · 2 de agosto de 2023

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...

Poseidon. · 3 de agosto de 2023

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

.if · 3 de agosto de 2023

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

Poseidon. · 3 de agosto de 2023

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.

.if · 4 de agosto de 2023

14 horas atrás, Poseidon. disse:

já recebi 4,0 ms overflow em 32MHz

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...

Poseidon. · 4 de agosto de 2023

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.

.if · 5 de agosto de 2023

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...

Em 03/08/2023 às 18:32, Poseidon. disse:

mas valeu pela tentativa.

e isso...

21 horas atrás, Poseidon. disse:

pela intenção.

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...

21 horas atrás, Poseidon. disse:

#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);

#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
	}
}

Poseidon. · 6 de agosto de 2023

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.

.if · 6 de agosto de 2023

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:

if (segundo > 59 ) 
	{
	segundo = 0;
	minuto++; 
	if (minuto>19) {minuto=0;output_toggle(pin_a1);} //outro pino
	}

Alterna o pino a cada 20 minutos... Altere pra fazer outra coisa.

*Desc... Não consegui evitar...

Poseidon. · 6 de agosto de 2023

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.

.if · 7 de agosto de 2023

ok... mas não vou desistir de você. Mais tarde vou tentar simular pra gente...

t+...

.if · 7 de agosto de 2023

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ída

1/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.

Poseidon. · 7 de agosto de 2023

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ída
1/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.

.if · 8 de agosto de 2023

Aqui deu certinho...

https://i.imgur.com/yJRGepc.mp4

O fonte:

//programa com pic12f1822 timer 20 minutos
//V0.0 : desafio apenas
//#include <xc.h>
#include <pic.h>

//#pragma config WDTE = OFF
//#pragma config MCLRE = OFF
//#pragma config CP = OFF

#define SH595 RA0
#define DS595 RA1
#define ST595 RA2
#define led_S RA4
#define led_min RA5

__CONFIG(FOSC_INTOSC & WDTE_OFF & MCLRE_OFF);

unsigned char _1seg,segundo=55,minuto=19;
static void interrupt tmr0(void)
{
TMR0IF=0;
TMR0=130;
if (_1seg++>250) 	{segundo++;_1seg=0;led_S^=1;}
if (segundo>59) 	{segundo=0;minuto++;}
}

void main (void)
{
unsigned int saida16=0x8000;
WDTCON=0b00000000;//dis wdog
OPTION_REG=0b00000111; //pullup, timer0/256
CM1CON0=CM1CON1=0;
ANSELA=0; //digital
TRISA=0;
led_S=0;
led_min=0;
INTCON=0b11100000;
OSCCON=0b11110000;//PLL ON 32MHz
TMR0=130;

for (;;)
{
if (minuto>19) {led_min^=1;minuto=0;}
}

};

O .hex se quiser ver:

O pulo do gato é sair do conforto, ler o d.s. , entender e ajustar os registros na unha. Rapadura é doce mas num é mole não . Qualquer momento testo no https://www.microchip.com/en-us/tools-resources/develop/mplab-xpress

Esta outra brincadeira que fiz também tive sucesso: o desafio foi usar 1 pino só do mc pra escrever nos 4 displays.

A ideia do desafio também foi exercitar o tico e teco e usar os poderes quase mágicos de uma porta inversora schmitt trigger . Qualquer momento publico detalhes e fontes.. caso eu sinta vontade e/ou alguém insista muito .. mas antes.. vou usar um pic10f200 pois este daí é muito caro pra deixar aí na sua tela

Ei-lo com pic10f200. É um timerzinho bobinho conceitual e teórico pra 99 segundos.

O vídeo:

https://i.imgur.com/QaGrLjb.mp4

De novo: a ideia foi testar os conceitos da interface "1wire" totalmente original de minha autoria - não inútil p.ex. pra quando se tem apenas 1 pino do mc sobrando e precisa-se acionar mais dispositivos - e o uso de uma das mais sinistras e perturbadoras entidades do c : struct & union bem como o uso de macros. E claro, explorar o uso do minimalismo de mc's de baixa a baixíssima capacidade. Pode não vos ser totalmente inútil.

+ 1 vidinho efêmero

https://imgur.com/y0oBSq7

deste esquema...

Tenho o fonte completo... vai ter que me pedir.

aphawk · 10 de agosto de 2023

@.if ,

Muito legal ver o sinal que sai do Pic e como são derivados os 3 sinais de controle do 595 ! Parabéns pela ideia, vai deixar nego doido prá entender como os outros 3 sinais são derivados de uma só saída kkkkkkk !

Por outro lado, poderia trocar tudo o que vem depois do PIC10F322 por um PIC16F676, "decodificar" o sinal que vem do pr1meiro PIC, e fazer a separação dos 3 sinais por software e alimentar direto o display !

Neste caso também poderia criar um "protocolo" para simplificar, tipo quando a saída do primeiro PIC vai para zero por mais de 10 mseg, segue uma sequencia que nada mais é do que os dois caracteres hexa que você quer que apareçam no display, e finalizar com um sinal em nível 1 por 10 mseg ..... fica fácil de se achar e com muito menos trabalho né !

Paulo

.if · 11 de agosto de 2023

Sua soma é válida sim amigo. Duas cabeças pensam melhor que uma kk. Trocadilhamente... no caso do projetinho uma cabeça pensa melhor e mais rápido que duas kk. A proposta foi elevar meu tradicional minimalismo a um outro patamar portanto bastou um mc apenas. E tem + : se prestar atenção vai ver que o sinal dele é praticamente na faixa de áudio o que em teoria pode ser transmitido p.ex. num transmissorzinho fm e recebido num radinho. O 'som' do a.f. poderia ser aplicado direto no 40106 ... e pra variar... já fiz algo assim só com lógicos no passado.

3 horas atrás, aphawk disse:

criar um "protocolo" para simplificar,

Pra elevar também o simplificar a um novo nível, poderia ser um simples bit banging. Acredite se quiser mas já fim um em assembly sem manual pra um neandertal mc 8049 com janela (ainda tenho ele) lá nos 80...90. e com uso prático: um terminal num lcd. Aprendi o assembly dele apenas debugando o assembler .exe e deduzindo as palavras chave. Uma (01) das coisas + doidas que fiz quando com hormônios à flor da pele kk.

A qualquer momento planejo criar um tópico sobre minhas descobertas recentes sobre alguns temas. A ideia é perpetuar ideias e como gosto de dizer, não totalmente inúteis pra incautos navegantes errantes do futuro .. Sabe-se lá quanto tempo estaremos por aqui, né?

abç e tmj

Poseidon. · 13 de agosto de 2023

      #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); 
   
     }}}