Algum tempo sem acrescentar nada, pois estava a preparar mais uma engenhoca. Esta serve de preparação para uma outra, um oscilador LC para calcular o valor de L (bobina), pois em rádio frequência é necessário obter o valor de algumas bobinas e um equipamento para as medir dá sempre jeito.

 

Esta será então a primeira parte.

 

O que sabemos de um conjunto RC?



 

Nos terminais de um condensador, a tensão não varia instantaneamente, tal como numa bobina a corrente não varia de forma instantânea. Um condensador é um reservatório de energia que vai enchendo mais depressa ou mais de vagar, consoante o fluxo de energia que nele entra. Do ponto de vista eléctrico, o tempo de carga de um condensador varia com a corrente que lhe é fornecida. É possível então determinar o tempo de carga e descarga de um condensador, quando dele ou para ele flui uma corrente I.

Um condensador durante a sua carga é bem traduzido por um gráfico logarítmico (tempo x tensão), tal como a sua descarga.

Um breve resumo do que pretendo fazer é ter um circuito RC a oscilar e sabendo a frequência a que oscila assim como a resistência, determino o valor de C.

 

Vamos então começar pelo tempo de carga de um condensador:

[caption id="attachment_62" align="aligncenter" width="623"] Equação do tempo de carga de um condensador[/caption]

 

Agora o tempo de descarga de um condensador:

[caption id="attachment_63" align="aligncenter" width="498"] Equação do tempo de descarga de um condensador[/caption]

 

t - tempo de carga/descarga;

Vc - tensão no condensador no tempo t;

V - tensão a que está a ser sujeito o conjunto RC;

Vi - tensão inicial do condensador;

R - valor da resistência resistência;

C - valor do condensador;

Se o que se pretende é a frequência em que o circuito está a oscilar e sabendo que f=1/T,  então a equação seguinte é intuitiva. O período será o tempo de carga somado ao tempo de descarga de um condensador.

[caption id="attachment_64" align="aligncenter" width="368"] Período = tempo carga + tempo descarga[/caption]

 

Agora que estão dadas algumas noções de circuitos RC (pelo menos as necessárias para o caso) é hora de tentar ver como por isto a fazer "ondinhas" eheheh.
Existem vários circuitos. Uns com transístores, outros com ampops... é quase há vontade do freguês, mas também temos de admitir que uns são mais fáceis de entender do que outros. Os calculos em cima servem mais tarde para deduzir uma fórmula para a construção desde projecto.

O LM311 foi o meu escolhido e é perfeito para estes casos.

 

No seu datasheet pode ser visto na imagem 11 um circuito que modula pulsos numa frequência de 100kHz.

[caption id="attachment_66" align="aligncenter" width="455"] Circuito oscilador com LM311 a 100KHz[/caption]

 

Ok, então e depois? Como raio funciona isto?

Se eu quiser alterar a frequência de forma controlada, qual resistência que devo alterar? Em quanto a devo alterar?

Com calma, a coisa resolve-se!

 

Para se tornar mais simples a explicação, copiei o mesmo circuito para um programa de simulação (PROTEUS).



 

Vamos focar-nos apenas em 2 situações, quando pino 7 está a nível alto e quando ele está a nível baixo e vamos focar-nos também nas resistências R2, R3 e R4.

 

Pino 7 a +12V:

Quando o pino 7 está a +12V (estará um pouco mais abaixo, mas vamos assumir assim) é como se R3 e R4 estivessem em paralelo, formando um divisor de tensão, junto com R2.

Ora R3//R4 = 13.22k, resolvendo o divisor de tensão, obtemos uma tensão de 7.22V no pino 2.

 

Pino 7 a 0V (GND):

Quando o pino 7 está a 0V (vamos assumir assim), R3 e R2 ficam em paralelo, formando desta vez um divisor de tensão com R4.

Então R3//R2 = 13.22k, assim no pino 2, neste caso, estarão 4.77V.

 

Estes valores vão corresponder ao intervalo de tensão onde o condensador se vai manter, ou seja, ele carrega até chegar a 7.22V, depois o ampop (devido ao seu ganho e a estar ligado na sua entrada inversora) baixa de imediato a tensão de saída no pino 7 para 0V (aprox.). O condensador começa então a descarregar até atingir o valor de 4.77V, altura em que novamente o ampop coloca a saída a 12V (aprox) e todo o ciclo de inicia novamente.

Já temos mais alguns valores e mais uma parte do circuito compreendida, então vamos substituir os valores nas equações em cima e ver se de facto conseguimos chegar ao valor de 100KHz!

 

Com todos estes valores, conseguimos já reduzir a 2 incógnitas o valor do período.

[caption id="attachment_68" align="aligncenter" width="589"] Período já com valores conhecidos[/caption]

 

A frequência vem então dada por:

[caption id="attachment_69" align="aligncenter" width="170"] Equação reduzida da frequência[/caption]

Adivinhem qual é o valor de f, quando trocamos C por 1.2nF e R por 10K?

f= 100KHz

 

Já tudo parece mais fácil, mas pode ficar mais fácil ainda!

[caption id="attachment_70" align="aligncenter" width="494"] Equação para determinar o valor do condensador[/caption]

 

Qual era mesmo o objetivo deste projecto?

Calcular o valor de um condensador, a partir de uma frequência!

Usei um simulador para testar tudo isto. Reparem com atenção na imagem em baixo.

[caption id="attachment_72" align="aligncenter" width="611"] Experiência em simulador[/caption]

 

Como se pode ver a amarelo (legenda exactamente em cima do ampop), o período é de aproximadamente 183us.

Vamos comprovar todos os cálculos! Se o período é de 183us, qual será o valor do condensador?

[caption id="attachment_73" align="aligncenter" width="311"] Calculo do condensador[/caption]

 

Reparem novamente para a imagem do circuito, e vejam o valor de C1.

C = 22nF = C1

Está resolvido!

 

Passos seguintes:

1º juntar este circuito ao circuito de um MCU e de um LCD;

2º recorrer a um timer no MCU para medir o periodo;

3º efectuar os cálculos simples acima descritos;

4º colocar valor do condensador no LCD;

 

 

Outras aplicações:

Tudo o que possa englobar testes com frequências, é aplicável tudo isto. Quando comparado com o 555, acho esta solução mais fácil de calcular e de entender, assim como mais versátil (tensões de alimentação),...

Este é um dos post's a guardar, para de futuro não tornar a fazer engenharia "reversa".

 

 

Estado do projecto:

Agora que já fiz alguns testes e provei que até se reduz tudo a uma equação facilmente, o próximo passo será substituir a resistência por uma bobina e ver a que conclusões chego.

Após resolver essa parte, seguem-se os testes e ajustes práticos e por último a montagem em PCB devidamente acomodada de todo o circuito de medida.

"Não percam os próximos episódios, porque nós também não" ahahah, esta fase quase que cabia, se em vez do "nós" fosse "eu".

Tinha ali uns motores de passo, tirados de um impressora velha e decidi aproveitar aquilo para ver qual a velocidade que ele atingia.

Mas começando pelo principio...

Motor de passo, o que é?

Um motor de passo é um tipo de motor que como o nome indica, roda em "passos", ou seja em ângulos certos (por norma escrito no próprio motor).

Para fazer um passo, deve-se fazer passar bastante corrente pelas bobinas do motor, de modo a criar um campo magnético e a atrair um dos dentes do eixo.

Também de ter em atenção que quanto maior for a velocidade de rotação, menor é o torque do motor (ver datasheet em baixo).



Informação mais detalhada AQUI.

No meu caso, o motor a utilizar é o M42SP-7T da MITSUMI.

Vemos então que ele utiliza a excitação de 2 fases em simultâneo. Quer isto dizer que dos 4 fios que saem do motor de passo (correspondendo ás 2 bobinas) 2 vão ficar com uma tensão mais elevada e os outros dois com uma mais baixa (neste caso a GND).

AQUI, para mais informações sobre este tipo de excitação.

Driver:

Já falei em cima que é preciso fazer passar bastante corrente pelas bobinas para que criem um campo eléctrico suficientemente forte para atrair a o dente do eixo.

Como podem ver na foto em baixo, a indutância destas bobinas é de 10R, assim quando alimentado a 12V precisa de pelo menos 1,2A.

[caption id="attachment_47" align="aligncenter" width="300"] "Chapa" do motor[/caption]

Para fazer passar toda esse corrente, precisa-se usar uma ponte H, para que um micro possa controlar a velocidade, posição, etc, do motor.

Há 2 soluções. Fazer a ponte H, com os 4 transístores/MOSFET, ou então ver se há algum integrado com uma ponte H que suporte a corrente máxima que se vai usar.
No meu caso, escolhi o L298, para fazer o driver de corrente.

Após identificar as bobinas do motor (com um simples multímetro), bastou ligar tudo como mostra o esquema em baixo.

[caption id="attachment_45" align="aligncenter" width="300"] Esquema de ligações[/caption]

MCU utilizado e programa:

Para este teste usei o microcontrolador PIC16LF1827.

O programa é bastante simples. São accionados 2 pinos simultaneamente é feito um delay e são accionados outro dois pinos e por aí adiante, tal como mostra a seguinte figura:

[caption id="" align="aligncenter" width="329"] Accionamentos[/caption]

Como quero atingir uma grande velocidade, não posso arrancar logo com um tempo muito curto, pois o motor de passo não tem força para arrancar logo aquela velocidade.

Então a cada 4 passos (4*7,5º=30º) o tempo entre cada passo é decrementado. Desta forma, tenho um arranque progressivo e vou conseguir fazer com que ele chegue a uma velocidade maior.

O tempo mínimo que estipulei é de 500uS.

#include "16lf1827.h"

#fuses INTRC_IO, NOLVP, NOWDT, NOMCLR, NOIESO, PUT, NOBROWNOUT

#use delay (internal=8MHz)

void main()
{
int16 tempo;

setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_spi(FALSE);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
setup_oscillator(OSC_8MHZ);

output_A(0);

delay_ms(2000);

   for(tempo=5000;tempo>500; tempo-=5)         //aumenta a velocidade, descresce o tempo
   {
      output_A(0b00001001);
      delay_us(tempo);
      output_A(0b00000101);
      delay_us(tempo);
      output_A(0b00000110);
      delay_us(tempo);
      output_A(0b00001010);
      delay_us(tempo);
   }   

   while(TRUE)                         //velocidade fixa
   {
      output_A(0b00001001);
      delay_us(tempo);
      output_A(0b00000101);
      delay_us(tempo);
      output_A(0b00000110);
      delay_us(tempo);
      output_A(0b00001010);
      delay_us(tempo);
   }

} 

 

Vídeo



Notas finais

Motores deste tipo são bastante usados em equipamentos de precisão que podem facilitar em muito a nossa vida.
Nunca é demais saber trabalhar com um pouco de tudo.

É bastante fácil liga-lo a um varão roscado e fazer de com que de forma programada e sistemática possa mover na vertical um berbequim, por exemplo...

Está a chegar o mês de Agosto e também a chegada do novo rover da NASA, o Curiosity, a Marte.

Mais informações AQUI.

A sua "amartagem" (aterragem está errado, mas não sei se "amartagem" será o certo) está prevista, segundo o site em cima, para Segunda-feira, 6 de Agosto de 2012, 6:31 em Portugal (conversor de Time Zones).

Um vídeo bastante bom, acerca dos 7 minutos de terror, pois é nesses 7 minutos que tudo se decide. Esses são os 7 minutos que demora a "amartagem" e também altura em que não haverá comunicações.



Página para acompanhar a chegada a Marte: http://mars.jpl.nasa.gov/msl/participate/

Hora de escrever algo de jeito.

Tinha um comando de TV, comprado nos chineses há bastante tempo, ali encostado (RM-E86). Não pode ser! Tenho de lhe dar uma utilidade!
Pois bem, daí partiu a mais recente engenhoca. Um circuito receptor de IR, usando um microcontrolador PIC16F88 e o sensor receptor, neste caso retirado de uma televisão velha.

O primeiro passo foi recorrer a um logic analyser e ver o que o sensor recebe quando pressiono a tecla "1".

Depois de guardada esse sequência, pressionei a tecla "2" e guardei a sequência também.

Nisto, voltei a analisar o que corresponde à tecla "1", mas como a janela mal dimensionada, testei novamente. Eis que tive a impressão que embora tenha carregado as 2 vezes na tecla "1", o gráfico lógico não era igual.

Ganhei gratuitamente mais um problema para resolver...

Conclui que o código da tecla "1" era diferente do da tecla "2", mas se carregasse 2 vezes seguidas a tecla "1", este código era exactamente igual ao primeiro da tecla "2".

Xiiii... meu Deus que confusão.
Estive a pesquisar um pouco sobre protocolos de IR para controlos remotos e encontrei este página:

Podem ver vários outros protocolos, pelo menos o principio de funcionamento deles.

Por aquilo que tinha lido, o protocolo da ITT era mais fácil de "manipular" a sua recepção. No site falam em apenas 14 pulsos, etc, etc...

Passo seguinte, encontrar o manual do comando e alterar o código para um equipamento da ITT.

Feito isto, voltava ao ponto de partida. Desta vez carreguei a tecla "1" e "2" várias vezes para confirmar que o código era sempre o mesmo.

Resultou nisto:
Tecla "1" - clique para ver maior

Tecla "2"
Tecla "2" - clique para ver maior

Um bocado diferente do que esperava (os tais 14 pulsos, bla bla bla), mas ok! Sem problema, demora um pouco mais, mas também se faz!

O micro foi programado para quando receber o sinal correspondente à tecla "1" ou "2", acender um led de acordo com o que foi recebido.

O código, compilado em CCS:

#include <16F88.h>
#FUSES INTRC_IO, NOWDT, NOMCLR, PUT, NOBROWNOUT, NOLVP
#USE delay(clock=4000000)
#include <stdlib.h>

#use standard_io(A)
#use standard_io(B)

//usado protocolo ITT

void pic_init()
{
    SETUP_CCP1(CCP_OFF);
    setup_comparator(NC_NC_NC_NC);
    setup_oscillator(OSC_4MHZ);
    SETUP_ADC(ADC_OFF);
    SETUP_ADC_PORTS(NO_ANALOGS);
    SETUP_TIMER_0(T0_DIV_32);                        //incrementa a cada 32uS, overflow 8.19mS
}

void main()
{

    int codigo[32], i;
    const int numum[]={2,2,1,1,1,1,1,2,1,2,1,2,2,2,2,1,2,1,1,1,2,1,1,1,1,2,2,2,1,2,2,2};
    const int numdois[]={2,2,1,1,1,1,1,2,1,2,1,2,2,2,2,1,1,2,1,1,2,1,1,1,2,1,2,2,1,2,2,2};
    
    pic_init();
    
    output_bit(PIN_B0,1);
    output_bit(PIN_B1,1);
    delay_ms(500);
    output_bit(PIN_B0,0);
    output_bit(PIN_B1,0);
    
    while(TRUE)
    {
        
        for(i=0;i<32;i++)                                                //colocar todo o vector a 1's
        {
            codigo[i]=1;
        }
        
        while(input(PIN_A1));                                       //espera pela descida
        while(!input(PIN_A1));                                     //espera pela subida                                    
        while(input(PIN_A1));                                    //espera pela descida
        
        
        for(i=0;i<32;i++)
        {    
            while(!input(PIN_A1));                               //espera pela subida
            set_timer0(0);
            while(input(PIN_A1));                                //espera pela descida
            codigo[i]=get_timer0();                              //tempo em alto
        }
        
        
        for(i=0;i<32;i++)                                               //atribuir valores mais faceis ao vector
        {
            if(codigo[i]>14 && codigo[i]<20)               //se for curto
                codigo[i]=1;
            else
            {    
                if(codigo[i]>45 && codigo[i]<53)           //se for longo
                    codigo[i]=2;
                else codigo[i]=0;                                           //se for José Castelo Branco
            }
        }
                                                                                    //comparar com os vectores originais
        for(i=0;i<32;i++)
        {
            if(codigo[i]!=numum[i])
                goto proximo2;
        }
        
        output_bit(PIN_B0,1);
        output_bit(PIN_B1,0);
        goto proximo3;
        
        proximo2:
            for(i=0;i<32;i++)
            {
                if(codigo[i]!=numdois[i])
                    goto proximo3;
                
            }
            
        output_bit(PIN_B0,0);
        output_bit(PIN_B1,1);
        
        proximo3:
        
        delay_ms(500);                                                  //aguarda o final de ecos
        
    }
}

Um breve descrição do código:

Esta não será a única forma de pôr isto a funcionar e certamente há outras formas.

Poderia ter colocado tudo a funcionar por interrupções, mas não vi necessidade disso pois o objectivo era ligar 2 (ou mais) LEDs apenas. Estes podem ser substituidos por relés, foguetes, aceleradores interestelares, etc..

Para facilitar a leitura e o armazenamento do vector correspondente à tecla "1" e à tecla "2", substitui os tempos (em nivel alto), dados pelo logic analyser por números simples. Ora os pulsos mais curtos (têm todo o mesmo tempo) atribui o valor 1 e os pulsos maiores (parecem ter o dobro dos curtos) atribui o valor 2. Aos restantes que possam eventualmente surgir de erros ou situações inesperadas (outras teclas do comando, por exemplo) é atribuído o valor 0.

Vector tecla "1" - {2,2,1,1,1,1,1,2,1,2,1,2,2,2,2,1,2,1,1,1,2,1,1,1,1,2,2,2,1,2,2,2}

Vector tecla "2" - {2,2,1,1,1,1,1,2,1,2,1,2,2,2,2,1,1,2,1,1,2,1,1,1,2,1,2,2,1,2,2,2}

Agora só tenho de ler o sensor e guardar os valores. Depois fazer uma associação dos tempos, para ter tudo à base de 1's, 2's ou 0's e por último comprar com estes vectores em cima. Se todo o vector for igual, então encontrei a tecla que foi pressionada.
1º espero pela 1ª descida;

2º espero pela 1ª subida;

3º espero pela 2ª descida;

4º espero pela 2ª subida colocando logo em seguida o timer a zero;

5º espero pela 3ª descida e logo em seguida faço a leitura do timer, que é armazenado num vector;

Repete 4º e 5º até que o vector fique cheio (32 posições, correspondentes as 32 pulsos).

6º Associo os valores temporais a 1, 2 ou 0;

7º Comparação numero a número dos vectores, o recebido e o armazenado na memória;

8º Por último liga o LED correspondente;

Um problema que pode surgir é o do micro ficar retido num dos "while", porque foi detectada numa queda e quando pegar no comando e clicar "1", ele não acciona o LED correspondente.

Um problema mas de fácil resolução. O último delay (o de 500ms) faz com que este problema se resolva.

Vamos supor que vários controlos remotos foram accionados perto deste sensor (eu testei e nem deu grandes problemas) e que o micro já encheu metade do vector! Quando eu carregar "1" ele não vai ligar o LED nº1, porque o vector estava cheio de lixo e quando eu carrego "1" acabo de o encher.

Os restantes pulsos que são enviados pelo comando já não são recebidos pelo circuito, pois ele aguarda um tempo para permitir que esses "ecos"/emissões sejam terminadas e só depois retoma o ciclo.

O grande inconveniente? Bem... se estiver num local muito ruidoso (muitas emissões IR) por vezes será necessário carregar duas vezes a tecla "1" ou "2" para ligar o LED que se pretende.
Solução? Sim, há solução para que isso não aconteça, mas para o caso não vale a pena. O objectivo era ligar um LED com o carregar de um botão num controlo remoto. Foi conseguido!

Fotos:

Ora bem, vamos lá ver que tal sai isto!

Este é o primeiro post deste blogue e espero que não seja já o último!

É também este post que vai levar com testes de letras e tudo mais e nem o vou eliminar porque dá muito trabalho e tira muito tempo ao que realmente interessa: as engenhocas!

Aqui vou descrever o melhor possível os vários projectos que vou desenvolvendo, quer a nível pessoal, quer a a nível colectivo.

 

Dúvidas e questões que ou possa tirar, irei fazê-lo com a melhor das satisfações.

Comentários parvos, estúpidos, de seres ignorantes e que procuram unicamente lançar a confusão, serão eliminados de imediato!

 

Deixo também a nota de que os meus textos serão cheios de erros ortográficos, isto ao abrigo do novo acordo! Estimo a língua do meu país, a língua da minha pátria e como não sou a favor deste (des)acordo ortográfico, escreverei como sempre me foi ensinado e  como foi ensinado a várias gerações.

Não me confundam porém com alguém que não está a par do que de melhor e mais recente se faz cá e pelo mundo! Há que ter o discernimento para separar o que vale a pena mudar e o que não vale a pena sequer tentar.

 

 

Divirtam-se e estraguem tudo o que vos apareça pela frente, desde que seja para aprender!