quinta-feira, 17 de outubro de 2013

Faltou CCP pro PWM! E agora?

Salve, galera! Estamos aê de pê novamente! Demorei mas trouxe coisa boa!
Se vocês se lembram da aula sobre o PWM, nós usamos o módulo CCP do PIC para gerar o PWM, algo relativamente fácil. Mas suponhamos que você queira controlar um LED RGB com o PIC16F628A. Um LED RGB necessita de três pinos de controle, mas o PIC fornece apenas um CCP. O que fazer? Varredura? OK, boa ideia, mas se o número de canais PWM necessários for grande ou se cada canal exigir um nível diferente de PWM? Ou exigir uma resolução maior que a do PIC? Veremos nessa aula como por quantos canais PWM quisermos em um PIC, "independente" do modelo.

PWM por software

Teoria da coisa 


Lembrando um pouco de teoria, PWM nada mais é que um tipo de controle onde geramos uma onda, de frequência constante, mas variamos o comprimento da onda. Normalmente usado para controlar a velocidade de um motor, brilho de um LED e etc. Como então gerar uma onda de frequência constante e de comprimento variável? Vamos lá!

Para este tipo de programa precisaremos envolver dois conceitos: o Timer do PIC e sua respectiva interrupção. O Timer gerará pulsos de frequência constante, aumentando o valor do registrador respectivo a cada pulso e, quando o registrador chegar ao seu valor máximo estourará, gerando uma interrupção: é ela que nos interessa!
Teremos duas variáveis na rotina do PWM: ciclo e período (o nome das variáveis não importa, pode ser qualquer um). Neste programa a coisa funcionará da seguinte maneira:

1: A cada interrupção a variável período será incrementada (+1);
2: A variável ciclo conterá o valor do PWM;
3: Agora só nos basta comparar as duas: Se período < ciclo então o pino do PWM fica em LOW (0 lógico); senão o pino do PWM fica em HIGH.

Simples não? Como ficaria isso na linguagem do programa? Mais simples ainda:

IF periodo < ciclo THEN 
 PORTA.0=0
ELSE 
 PORTA.0=1
END IF

Tão simples quanto não? Atente apenas que o pino irá a 1 se o período for IGUAL OU MAIOR que o ciclo, e não apenas se for maior.

Mas e como vou saber a frequência do meu PWM? Eu, como um blogger muito legal, deduzi a fórmula pra vocês, ou seja, é pegar e usar! E aqui vai ela:


Onde:
Fpwm é a frequência do PWM em Hertz;
Fosc é a frequência de oscilação do PIC em Hertz;
Resolução é quantos passos terá o PWM;
TMRx é o Timer usado (depende de PIC para PIC).

Se por acaso for configurado um Preescaler pro Timer, basta multiplicar a fórmula por 1/Valor do Preescaler.

Percebe que na primeira temos 256-TMRx e na segunda, 65535-TMRx. Por quê? Pois a primeira fórmula é para Timers configurados em 8 bits e a segunda se ele for configurado em 16 bits. Como no exemplo a seguir usaremos o TMR0 e este apenas opera em 8 bits no PIC16F628A, nossa cobaia, então a fórmula aplicável será a primeira.
A resolução é o seguinte: se a variável Ciclo, que contém o valor do PWM, for configurada como Byte, ela terá apenas 256 valores possíveis, se for Word, 65535; se for longint vai ser maior ainda e por ai vai. Perceba que, quanto maior a resolução, menor a frequência e vice-versa.

Mãos à obra

 Vou passar agora um pequeno exemplo de um código, para o PIC16F628A, que controlará um LED RGB através do PORTB. Perceba que a rotina de interrupção será basicamente padrão para qualquer PIC.


Veja que para gerar PWM nos outros pinos basta criar outras variáveis para cada pino e um novo IF para cada pino. Limite? o número de pinos de E/S do PIC :D
Creio que o código é simples para todos que acompanharam as aulas posteriores, mas ressalto que qualquer dúvida é só perguntar nos comentários.
Circuito? Bem, a unica novidade é que dessa vez precisamos de um oscilador de cristal de 20MHz ligados nos pinos RA6 e RA7 naquele velho esquema conhecido, com os dois capacitores. O LED RGB será ligado nos pinos RB1, 2 e 3, lembrando dos resistores.

É isso pessoal. Chegou hoje um componente muito legal aqui e se der farei mais uma aula falando sobre ele. É um sensor :D
Abração galera e até a próxima.

sexta-feira, 16 de agosto de 2013

Projeto pequeno? Pra que complicar?

Fala galera! Tudo em cima?
Dessa vez, não venho com nenhuma aula, nenhum projeto mas sim com uma boa dica: as vezes fazemos aquele protótipo ou uma montagem simples, que queremos fazer em uma placa mas não queremos confeccionar uma placa ou comprar as já prontas. Se quisermos um acabamento melhor, fica mais difícil ainda, ou melhor, ficava. Vim trazer uma novidade pra vocês e que eu pessoalmente gostei muito, a 2" x 2" Universal Through Hole and Surface Mount Schmartboard™.
Ela é uma pequena placa para prototipagem muito boa, com um acabamento bem profissional e bem simples. Eu havia solicitado um exemplar para ver pessoalmente como é, mas por ela ser feita nos EUA achei que não me enviariam, mas me enviaram. Fiquei surpreso! Bem, resolvi então compartilhar com vocês essa boa ideia.  Vamos às fotos:


Uma pequena carta (:

Aí está ela!


Estes furos bem na borda da placa são usados para unir com outras através de uma "ponte de plástico".

Esta placa custa $3.50 (três dólares e cinquenta cents) e pode ser comprada aqui, que é o site do produto bem como através da Mouser, uma empresa no Brasil que distribui estas placas. A Schmartboard™ também possui alguns outros produtos bem interessantes e bem úteis para pequenos projetos e prototipagem.

Bem é isso pessoal. Espero que este post ajude vocês alguma hora.
Abraços.

Agradecimentos especiais à Schmartboard™ por ter me cedido esta amostra e pelo ótimo atendimento.


segunda-feira, 6 de maio de 2013

Quão rápido isto gira?

Não, não me esqueci de vocês. E pros que estava com saudades, venho com mais uma aula de programação: usando o TMR0 (Timer 0) do PIC para fazer um tacômetro. Nessa aula vou usar o PIC18F4550, mas a teoria se aplica a qualquer microcontrolador que tenha ao menos 1 timer.

O TMR0

Como eu já disse, quanto ao hardware, explicarei aqui para o PIC18F4550. O TMR0 pode operar tanto como contador como timer. Para nós interessará o contador, que pode operar no modo de 8 ou 16 bits. Para cada pulso introduzido no pino T0CKI irá aumentar o valor registrado no TMR0L, responsável pelo TMR0. E isso é tudo que nos interessa por enquanto.

Como usar o TMR0 em um tacômetro?

Primeiramente, pensemos na unidade de medida: o RPM, ou rotações por minuto, ou seja, quantas rotações tenho em um minuto. O tempo podemos "contar" usando o comando delay_ms ou delay_us mas e as rotações? O TMR0. Então, usando um pouco de matemática podemos chegar a uma expressão que nos ajudará a converter um número x de rotações em um tempo t em rotações por minuto. Calculando e quebrando a cabeça pra aliviar pra vocês (até porque nem todos se dão bem com a matemática. OK, tbm não me dou bem) cheguei à seguinte fórmula:

60=P.t.R
 
"Beleza. mas como uso esse troço aí?" Vamos lá:
P= Pulsos por volta. Esse dado varia de caso para caso. Por exemplo: uma ventoinha dessas como as usadas em computador (cooler) gera 2 pulsos por volta, o motor do vídeo mais a seguir gera 8 pulsos. Então você, se não souber, terá que descobrir;
t= Tempo em segundos. Este tempo é o tempo de atualização e que durante este tempo serão contados os pulsos no TMR0;
R= Resolução em RPM. Aqui é a variação em RPM que o circuito mostrará.
"Beleza, mas como aplico?" Vamos a alguns exemplos:

1º: Um cooler que gera 2 pulsos por volta. Quero resolução de 10 RPM. Qual deve ser o tempo entre as leituras?

Vamos lá: 
60=2.t.10 mudando os valores de membro ---> 60/20=t  =>  t=3 segundos

2º: Um motor gera, em sua saída, 5 pulsos por volta, e desejo ter uma suave leitura com atualização de meio segundo. qual será minha resolução?

60=5.0,5.R  mudando os valores de membro --> 60/2,5=R  =>  R=24 RPM

3º: Durante 1 segundo o TMR0 conta os pulsos, com uma resolução de 10 RPM. Quantos pulsos meu motor gera por volta?
 
60=P.1.10  passando pro outro lado ---> 60/10=P  =>  P=6 pulsos por volta.

Passando os cálculos, vamos ao programa.


Teoria na prática

Agora a coisa fica mais simples. Veja esse exemplo:


















Vamos desmontar esse código:
1ª linha: temos a variável rpm sendo declarada como o valor de TMR0L multiplicado por 10, minha resolução (R).
2ª a 9ª linha: extraio os valores de cada casa (unidade, dezena, centena e etc) e escrevo no LCD. Note que o valor é escrito como ch+48: isso pois o LCD recebe caracteres em ASCII, e para se converter um número decimal para ASCII é só adicionar 48 ao valor a ser enviado.
10ª a 13ª linhas: da um espaço (160) e escreve RPM.
14ª linha: zera o TMR0. OBRIGATÓRIO FAZER ISSO, caso contrário, o programa irá somar as RPMs.
15ª linha: dou a pausa de duração t.

Agora vamos lá: apliquemos minha fórmula nesse código para ver se funciona. Meu motor gera 8 pulsos por volta, porém finjamos que não soubéssemos.

60=PtR => 60=P.0,75.10 => 60/7,5=P ==> P=8 pulsos por volta 
Voilá! Funciona =D

Este código exemplificado é apenas parte do programa todo, que não explanarei aqui. Caso hajam dúvidas no resto, me perguntem aqui nos comentários. Lembre-se: sua dúvida pode ser a de outros.
Este fragmento de código DEVE ser inserido dentro de um loop, como While true/Wend, Do/Loop Until 1=0 ou Loop:/goto loop.



Configurando o TMR0 no PIC18F4550

Vou dar uma rápida aqui de como configurar o T0CON, que é o registrador do TMR0. A imagem a seguir é parte do datasheet do PIC18F4550, que trata do TMR0. Quem quiser saber mais sobre o TMR0 e outros módulos dos microcontroladores pode encontrar o datasheet no google.



Vamos lá:
Bit 7: deve ser 1 para habilitar o Timer0;
Bit 6: deve ser 1 para usar o Timer0 no modo de 8-bit;
Bit 5: deve ser 1 para selecionar como fonte o pino T0CKI;
Bit 4: variará conforme a saída do seu sensor;
Bit 3: deve ser 1, pois agora o Prescaler não nos interessa.
Bit 2-0: pode ser qualquer coisa pois não estamos usando o Prescaler. para facilitar, usarei tudo 1.

No programa ficaria:
T0CON=%11111111 ou
T0CON=$FF (deixa o código mais limpo).


Bem, espero que tenha fica bem explicado a teoria. Como já disse, qualquer dúvida pergunte aqui nos comentários. Peço desculpas pela aparência, mas o Blogger está com problemas e não consigo usar recursos importantes. Segue um vídeo demonstrando o funcionamento de um tacômetro com o PIC18F4550. Boa sorte nos estudos e até a próxima.

sexta-feira, 1 de março de 2013

Switch para fontes ATX

Quem acompanha meu blog a um certo tempo já viu que eu uso uma fonte ATX para alimentar meu protoboard. Pode ser que você tenha achado uma boa idéia usar fontes ATX para alimentar seus projetos, pelo fato de encontrar fontes baratas que possam servir tranquilamente (a minha de 200W custou R$37,00!!! Já que não servia pra PCs - embora tenha sido feita para tal - por não ter um circuito de filtragem, resolvi usá-la!) mas não saiba usá-la. Esse circuito que postarei é justamente para isso: ajudá-lo a usar uma fonte ATX. Vamos lá!

O circuito é baseado no CD4013CN, um CI com dois Flip-flops do tipo D. Segue abaixo:




Quando dei a aula sobre flip-flops, postei um circuito bem semelhante.
Funcionamento: Ao ligar a fonte, o circuito será alimentado pelo pino VSB +5V e o capacitor C1 e o resistor R1 farão o circuito começar deixando a fonte desligada. Ao pressionar o botão S1 o circuito inverte a saída Q, e como iniciou em 0, agora a saída Q ficará em 1. Através de R3, o transístor T1 irá saturar conectando, através de R5, o pino PS_ON da fonte ao negativo ligando a fonte. Se as tensões estiverem corretas, a fonte fornecerá 5V no pino PWR_OK, ligando o LED e indicando que tudo esta certo. R4 é um resistor limitador de corrente para o LED, R2 é um resistor de pull-up e C2 é um capacitor de desacoplamento.
IMPORTANTE: no circuito C2 está com o valor de 100nF, porém tive problemas com este valor (o circuito ligava e depois não desligava). Mudei o valor para 22nF e tudo funcionou normalmente. Se quiser, teste em uma protoboard antes para ter certeza que o valor de 100nF funciona (esse valor mais alto melhora a filtragem de ruidos da chave S1).

A placa ficou como segue abaixo:




Veja que a placa possui dimensões reduzidas: apenas ~4,2cm por ~3cm.
Os pontos 1, 2, 3 e 4 são os pontos de ligação dos fios da fonte. A ligação segue a ordem:

-1: VSB +5V;
-2: GND
-3: PS_ON e por fim;
-4: PWR_OK.

Para saber quem é quem em meio a tanto fios e cores, use a seguinte tabela:


Dica: não somente por estética como por segurança, recomendo remover DESSOLDANDO da placa da fonte os fios não usados (cortar os fios pode causar curto-circuitos!). As imagens a seguir mostram como ficou minha montagem (vejam que deixei apenas os fios usados):

Veja que deixei apenas os quatro fios para a protoboard e para a switch.

Um pouco de cola-quente para segurar os fios no lugar =D

Detalhe dos fios.

Localização de algumas partes do circuito.

Veja que o circuito coube com perfeição em uma caixinha de umas balinhas bem conhecidas XD


Como faço pra ligar a fonte na protoboard: um antigo adaptador IDE-SATA fi desmontado ennos fios soldei as bananas. Ficou perfeito (:
Os arquivos do projeto (placa, esquema e algumas imagens) podem ser baixados aqui.

Fechando o post, vou deixar um vídeo meu mostrando o funcionamento. Obrigado por ler mais este post!


sexta-feira, 22 de fevereiro de 2013

Controlando 8 LEDs com 4 pinos do MCU

Fala galerinha! Pra quem leu meu último post, aqui vai a "continuação", ou seja, vou lhes mostrar um exemplo prático do uso de um shift-register junto à um MCU (o PIC18F4550 mas poderá ser usados em outros. O que vale é a teoria).
Sem mais, vamos lá!

O programa.

Como sempre, este programa foi escrito por mim no mikroBasic. Vamos dar uma olhada:























































Simples não? Não entendeu? Vamos por partes:

Logo no início atribuo um nome para cada pino do MCU (symbol), que é o nome do pino do shift-register. Isso evitará que você se perda no meio do programa.
(putz, qual pino mesmo é o do SCLK? deixa eu olhar no esquema!)
Depois, em cada sub procedure eu crio procedimentos padrões, neste caso, procedimentos de controle do 74HC595 que são:

»Clock: gera um pulso no pino de clock. É o primeiro procedimento pois o sub prcedure dados irá usá-lo;

»Dados: aqui usei a variável img como a variável que contém os dados a serem inseridos no shift-register. Observe o SER=img.x: aqui defino que o pino SER terá o valor do bit x da variável img. Perceba também que eu ensiro os dados de trás para a frente. ISSO É OBRIGATÓRIO!;

»Trans: assim como em clock, também gero um pulso, mas dessa vez no pino RCLK. E por fim ;

»Limpa: Idem ao trans, aqui também gero um pulso, mas no pino SCLR.

Seguindo, configuro os PORTs C e B (o B é desnecessário! Pode-se omití-lo) e chamo o procedimento limpa. Fiz isso por dois motivos: primeiro pois o 74HC595, como já explicado, começará com um valor aleatório, e como o quero "zerado", mando o programa limpá-lo e segundo pois quando configure o estado do PORTC, o configurei como PORTC=$00, ou seja, todos os pinos em 0, porém, o pino SCLR deve ser mantido em nível 1 para que funcione (caso contrário, ele ficará apagando cada dado que você inserir), e quando chamo o procedimento, antes dele retornar ao programa principal, ele deixa o pino SCLR em 1.

Crio um loop eterno no WHILE TRUE e neste loop somo o valor $D5 (hexadecimal) à variável img, chamos os procedimentos dados e trans e por fim dou uma pausa de 1/4 de segundo (250 milisegundos).

Se você prestou atenção, viu que chamei meu programa de aleatório, mas veja que ele é pseudo-aleatório. Quando você chega no valor máximo de uma varíavel, caso você exceda seu valor máximo, ela zerará, então coloquei um valor bem alto e ímpar para que ela resete várias vezes e crie um efeito "aleatório". O programa junto com o arquivo .hex pode ser baixado aqui.

O circuito

O circuito não tem "nada" de novo senão a parte do shift-register:

Acredito não ter o que explicar aqui. Infelizmente não consegui gravar um vídeo mostrando o funcionamento :/ Bem, na próxima acho que trarei o uso de um shift register pra controlar um Display de LEDs (7 segmentos).
Boas montagens e até a próxima!

sexta-feira, 15 de fevereiro de 2013

Flip-flops e Shift-registers

Galerinha, certeza que vocês passarão o mesmo dilema que um dia passei: um MCU de 8 pinos é pequeno (poucos pinos de IO) e um de 16 é grande demais para o circuito. Qual a saída? E se eu precisar me lembrar de um bit e não quiser gravá-lo na memória do MCU? O que fazer? Descubra agora nessa aula!

Flip-Flops

Não vou explicar todos os tipos de flip-flops: darei um resumo geral sobre eles e explicarei apenas sobre os flip-flops do tipo D.
Os flip-flops, resumindo, são uma espécie de memória de estado ou bit, ou seja, você insere um dado nele e ele retém até que seja mudado ou apagado. O tipo de Flip-Flop que explicarei aqui é o do tipo D (existem outros, como o JK, RS dentre outros), que é o mesmo do CI4013, bem conhecido até.

Símbolo do Flip-Flop do tipo D
Este aí é o símbolo do Flip-flop do tipo D (o 4013 possui dois dentro). A função dos pinos seguem abaixo:

-Pino D: é a entrada de dados: 0 ou 1 lógico;
-Pino > (ou também referido por C ou CLK): é o clock: um pulso e o dado inserido no pino D é inserido nas saídas;
-Pino Q e Q: são as saídas, onde Q é a saída não-invertida (insere 1 sai 1, insere 0 sai 0) e Q é a invertida (entra 1 sai 0, entra 0 sai 1);
-Pino S: pino SET, quando colocado no nível lógico 1 colocará a saída Q em 1;
-Pino R: pino RESET, quando colocado no nível lógico 1 colocará a saída Q em 0.

No Flip-Flop do tipo RS você não terá os pinos CLK e D, ou seja, você usará os pinos R e S para controlar a saída.

Este é um CI TTL, ou seja, nenhuma entrada deve ser deixada flutuante! Se for ligar um interruptor, por exemplo, você terá que colocar um resistor de pull-up/down dependendo do caso, para quando o interruptor estiver aberto não deixar a entrada flutuante.

Para você entender o funcionamento, colocarei aqui três circuitos práticos para você montar na protoboard e entender:

1. Liga e deliga LED com apenas um botão

OBS: Ligue o pino 16 no positivo (5V) e o 7 no negativo.
O funcionamento é o seguinte: suponhamos que o circuito comece com a saída Q em 1: logo a saída Q estará em 0. Como a saída Q está ligada na entrada D, quando você apertar S1, dando um pulso no clock, o 0 será inserido no pino Q, desligando o LED. Como foi inserido um 0 em Q, Q está agora em 1 e se você der outro pulso de clock, este 1 será inserido em Q e levará Q a 0. "Sacou a jogada?".
R1 é o resistor de pull-down que eu havia falado acima, para não deixar a entrada flutuante e C1 é um capacitor para filtrar os ruídos do chave S1. Perceba que coloquei um transístor para ligar o LED: necessário pois o 4013 não possui grande capacidade de fornecimento.
S e R ficam ligados no negativo.

2. Definindo o estado inicial



Este circuito faz exatamente a mesma coisa que o anterior, mas veja o conjunto C2 e R4: perceba que no nó central deles é ligado o pino R, e apenas S está ligado ao negativo. C2 e R4 gerarão um pulso único pulso positivo no pino R devido ao tempo de carga de C2 (enquanto carrega, sua resistência estará baixa). Após C2 se carregar, R4 colocará o pino R no nível baixo (0).
Qual a utilidade disso? Os flip-flops, ao serem ligados, colocarão um nível aleatório na saída Q, e com esse conjunto (C2 e R4) agora você consegue definir qual será o estado inicial do circuito ao ser ligado, que no nosso caso, fara o LED iniciar desligado. Se quiser que o LED comece ligado, apenas inverta C2 com R4 ou então ligue o RESET (pino R) no negativo e o SET (pino S) no nó central do conjunto C2/R4.

3. Escolhendo o bit



Neste circuito, você poderá selecionar o bit a ser guardado através de S2. Escolha o bit e pressione S1 para transportar o bit para as saídas. Pode-se usar o truque do circuito acima para se definir o estado inicial.


Espero que você tenha entendido (na verdade espero que eu tenha explicado bem) o funcionamento deste flip-flop. Nesta página existem alguns exemplos de circuitos com Flip-Flops (alguns até passivos, ou seja, sem usar flip-flops mas tendo um circuito de mesma função. Achei esta página muito interessante).

Shift-Register

Imagine agora, se você pegar o primeiro circuito e cascatear os flip-flops? Observe o esquema abaixo:

Imagem pega "emprestada" da Wikipedia 
 Veja que todos os clocks estão ligados juntos, e a entrada D do próximo Flip-flop está ligada na saída Q do anterior.
 Suponhamos que inseri o valor 1 em Data In e dei um clock: Q1 ficará em 1 certo? Agora eu coloco 0 em Data In e dou outro clock: Q1 ficará em 0 e agora Q2 ficará em 1, ou seja, desloquei o bit! Como? Observe o esquema novamente: como o pino D do segundo flip-flop está ligado ao pino Q do primeiro, o dado no segundo será o antigo dado inserido no primeiro, pois este estava em Q! E a cada clock, você deslocara o bit: eis um shift-register ou registrador de deslocamento! Pode parecer confuso mas você entenderá.

Existem dois tipos de shift-registers: os SIPO (serial input parallel output) e os PISO (parallel input serial output). O do esquema acima é um SIPO, ou seja, você terá uma entrada serial e uma saída paralela. Os do tipo PISO você terá várias entradas e, a cada clock, você terá o dado de uma entrada na saída, sendo que a cada clock, você terá o dado da próxima saída. Observe:

Outra da wikipedia.
Os do tipo SIPO são geralmente usados para se ampliar o número de saídas de um Microcontrolador, e os PISO, o número de entradas. Nesta postagem, vou me ater apenas aos SIPO, pois este é o que usei até agora (e até porque entendendo um você entenderá o outro).

No nosso caso, usaremos o CI 74HC595, um shift-register bem barato com 8 saídas, ou seja, um byte de saída. Abaixo segue o esquema interno e a pinagem:

Imagem retirada do datasheet da ST. Veja que o esquema real é um pouco mais complexo do que o mostrado no início.


A função dos pinos segue abaixo:

-QA a QH: saídas (8 no total - um byte);
-QH':a saída do último flip-flop (vide esquema interno). Algo "equivalente" à QH (útil quando for feito o "cascateamento" deles);
-SRCLR: limpa os flip-flops de entrada;
-SRCLK: clock de entrada;
-SER: entrada serial de dados;
-RCLK: clock do registrador (transfere os dados dos flip-flops de entrada para os de saída);
-OE (ou G): Habilita as saídas do CI.

O funcionamento é bem simples:
Em SER inserimos o bit, e ao dar um pulso em SRCLK, inserimos esse bit em QA. Ao inserirmos outro bit e dar outro clock, esse bit será inserido em QA e o bit que estava em QA passará para QB. Quando tivermos inseridos o byte completo, ou seja, 8 bits, daremos um pulso em RCLK e transferiremos os bits dos registrados de entrada para os de saída, tendo então os valores agora nas saídas. Se precisarmos limpar os registradores de entrada, basta dar um pulso em SRCLR. Lembrando que ele limpara APENAS o registrador de entrada! Para limpar as saídas, de um pulso em SRCLR e depois em RCLK!
Resumindo:
-SER: bit a ser inserido;
-SRCLK: inserimos o bit de SER em QA;
-RCLK: os bits vão para as saídas correspondentes.

O circuito a seguir exemplifica a ligação do 74HC595 com LEDs:



Este é o circuito básico e pronto para ser ligado em um microcontrolador.
Um rápido exemplo de controle: caso você queira acender apenas o LED 4, você deve enviar o valor $10 (hexadecimal) ou 010000 (binário). Se você quiser acender os LED 7 e 2, enviará $42 ou %01000010. Perceba que os valores aqui serão espelhados: o bit 0 do byte enviado corresponde à saída QH, o bit 1 à QG, o bit 2 à QF e assim por diante. Porquê? Essa eu deixo para que vocês expliquem (isso ajudará a você entender bem a teoria por trás do funcinamento).

Caso você precise ligar mais Shift-Registers, siga o esquema abaixo:


Sempre que precisar mais faça como no esquema: ligue a saída QH' na entrada SER do próximo shift-register.
Agora, como temos dois Shift-registers, precisamos de 2 Bytes (ou 16 bits. No mikrobasic, pode-se usar uma word).

Bem pessoal, espero ter sido útil. O próximo post será um exemplo prático do uso de shift-registers com um PIC. Abraços e até a próxima!


Sim, foi feito com a ajuda de Shift-registers.
Essa "travada" é culpa da câmera!

segunda-feira, 4 de fevereiro de 2013

Sensor Estéreo de Som

Precisando detectar sons? Além de detectá-los ainda precisa saber de onde vem? Este circuito lhe será útil!
O SES (sensor estéreo de som) é um circuito com dois canais de saída e duas entradas (microfones de eletreto).

O Circuito

 Como vocês verão no circuito, são "dois" circuitos idênticos, logo me aterei a explicar apenas metade dele :D

 

O microfone de eletreto é o componente que o Eagle não deu nome aí no circuito (círculo com o símbolo de um capacitor dentro, que alías, não faz sentido, pois na verdade o mic funciona à base de um transistor!)

O Resistor R1 é uma espécie de pull-up, mantendo um nível de tensão quando não houver sinal do mic; C1 é o capacitor responsável por fazer uma "filtragem" do sinal; R2 e R3 formam um divisor de tensão, mantendo uma tensão de referência (Vr), pois o som gerará sinais tanto aumentando quanto diminuindo a Vr (aumentando ou diminuindo cerca de 2V); R4 e R5 ajustam a amplificação (em 34 vezes) feita pelo IC1, um LM358; JP1 é a saída dos sinais e JP2 é a alimentação.

O circuito, como puderam ver, é tão simples quanto a PCI, que segue a figura abaixo:


Vocês provavelmente perceberam que há jumpers cruzando com dois resistores (um de 33K e outro de 1K). Esses jumpers devem ser montados antes dos resistores! Outra observação é quanto o ainhamento dos terminais dos microfones na placa: eles realmente devem ficar desalinhados, pois eles estão "espelhados" na placa (eu me esqueci deste detalhe quando fiz a minha PCI, resultado: tentei alinhar e minha placa ficou torta! Para garantir estética, tive que montar os mics em 90°.) Os Jumpers na placa seguem a seguinte pinagem (de cima para baixo):
-Sinal Direito (R);
-Sinal Esquerdo (L);
-Negativo
-Vcc.

A alimentação usada é de 5V, mas pode ser diferente respeitando os limites do LM358 (vide datasheet).
As fotos abaixo mostram como ficou meu protótipo:



Os jumpers por baixo da placa foram adicionados pois eu havia esquecido de pô-los no desenho da PCI. A versão apresentada já está com a devida correção.
Eu achei que ficou com uma "cara" legal (:

a versão mono montada na protoboard: até aqui a montagem é simples!


Os arquivos do projeto (esquema e PCI para Eagle) podem ser baixados aqui.
Devido a versatilidade do circuito, é possível montar um robô que siga ou fuja do som SEM microcontroladores. Se quiserem, peçam aí em baixo que postarei como fazê-lo. Cuidado ao montar a placa para não trocar os valores dos resistores (use a imagem da PCI do Eagle que pús ai em cima como guia!).



Quanto às aulas de MCU

Pessoal, as aulas ficarão paradas por um tempo pois voltei às aulas, por estar me aplicando a estudar mais sobre eletrônica digital e por não ter observado muito movimento e leitura das aulas. Então, até ter mais tempo OU movimento nas postagens elas ficarão em segundo plano.


Boa montagem e até a próxima.