UltraSonic Sensor + Simulino



Vamos simular o UltraSonic Sensor?










Olá, seja bem vindo.

 Hoje irei demonstrar como simular um sensor ultrasônico (UltraSonic Sensor), aquele mesmo que serve para medir distância entre objetos, ou mesmo usado em robôs para que os mesmos não venham à colidir com algum obstáculo, dentre tantas outras aplicações.

Segue imagem do sensor abaixo:



Agora temos nosso sensor simulador no Proteus:




Para quem não conhece ainda este sensor, é bem fácil de entender o seu funcionamento.

Conforme diagrama mais adiante, o que acontece é que este sensor possui um microcontrolador responsável por gerar os pulsos ultrassônicos  que serão emitidos através de um destes transdutores instalados no shield do sensor. E após a emissão deste pulso, ele fica aguardando o retorno do mesmo, para que seja interpretada a distância que este pulso percorreu até o objeto.
Dependendo do tempo entre o pulso emitido e o pulso recebido pelo outro transdutor, o microcontrolador do sensor vai gerar outro pulso chamado de ECHO para a placa de controle.







O segredo está na duração do pulso que o sensor gera para a placa de controle.
Como alguns sensores tem características muito semelhantes, resolvi criar um programa para um microcontrolador (PIC nesta primeira versão) ,a simulação deste pulso de ECHO.




Explicando um pouco sobre  o funcionamento, o sensor Ultrassônico fica aguardando um pulso de Trigger (gatilho) para simular a recepção do pulso e então envia um pulso de ECHO para a placa de controle por um período de tempo. A placa de controle é responsável por interpretar a distância. Então para isto ela efetua a medição da duração do pulso de ECHO, que entra na seguinte fórmula:

Distância em cm = ( Duração do Pulso em microssegundos) / 58

ou

Distância em polegadas = (Duração do Pulso em microssegundos) / 148

Pegando o exemplo da figura acima, vemos que o pulso teve duração de 4,93ms, ou seja, esse pulso corresponde a 4930us. 

Para termos o valor em centímetros, devemos dividir este valor por 58, resultando em: 85 cm

Então alguém me pergunta: "Mas no diagrama não está 84cm?" Responderei: "Sim meu caro Sherlock Holmes!rs", o que acontece é que esta pequena diferença é devido aos erros de aproximação nos cálculos e também pelo fato de que para a medição do pulso de entrada no microcontrolador na placa de controle, existe uma precisão agregada à configuração dos timers internos e também ao sistema de clock do mesmo.
Examinando o programa de exemplo, vemos a seguinte chamada de função:


duration = pulseIn(echoPin, HIGH);

Sendo que para saber qual será o erro agregado ao valor dado pela função "pulseIn", devemos abrir a biblioteca do mesmo e estudar a configuração de timer e clock.



Vamos simular? 




Funcionamento do Sensor Simulado:

Para facilitar o uso deste simulador no Proteus, e para que possamos ajustar a distância do nosso objeto simulado, fiz nesta primeira versão a referência como sendo um valor de tensão ou sinal analógico diretamente acoplado em um dos pinos do microcontrolador PIC16.

Basicamente o que ele faz é transformar a referência em volts para um valor de distância, gerando um pulso de ECHO proporcional na saída. Sendo que para ele emitir esse pulso de ECHO é necessário manter o pino de Trigger em nível alto por pelo menos 10us (microssegundos), conforme sensores comuns.


Para sabermos o valor de tensão que deve ser aplicado, existe uma pequena fórmula:

Valor de tensão em Volts = ( Valor da distância em cm ) / 225,76

Por exemplo, queremos simular uma distância de 5m (metros), que corresponde a 500cm (centímetros).
Para ter-se o valor de tensão, faremos: 500 / 225,76 = 2,21 V (volts)

Ou seja, tem-se que colocar o valor de 2,21V na entrada do pino RA0 (pino 2) do microcontrolador do sensor.
O interessante é que como é um valor analógico, fica fácil de criar diversas configurações de entrada, para simular por exemplo um objeto se afastando ou se aproximando da sua placa de controle ou robô. Que é o mais desejado.

Então, após configurado o valor de tensão para a distância do objeto, basta carregar no microcontrolador PIC16F1936 do sensor o arquivo UltraSonicSensorPIC16F.HEX que está dentro da pasta Source do projeto.
E na placa do simulino, pode ser utilizado o programa de exemplo incluído no projeto, devendo o mesmo ser compilado, ou então utilizado o arquivo UltraSonic_Shield.cpp.hex. Devendo o mesmo ser carregado no microcontrolador ATmega do Simulino.

Logo estarei postando o vídeo tutorial.

Até o próximo post.






LCD Keypad Shield + Simulino


Vamos simular o LCD Keypad Shield?


 Tutorial no Youtube: http://youtu.be/Xzee937xzaE



[DOWNLOAD]

Hoje irei demonstrar mais um modo para simularmos nossos queridos projetos, e em especial aquele shield bem conhecido por nós hobbistas das plataforma Arduino, que é o KEYPAD SHIELD, aquele que possui
um display LCD 16x2 e alguns botões.

Segue imagem do mesmo abaixo:

Para quem explorou seu esquema elétrico, pode perceber que ele é bastante otimizado. Proporcionando uma boa otimização quanto à quantidade de pinos necessárias para seu funcionamento.

 Observando apenas o conjunto do Display LCD, são utilizados apenas 6 pinos, sendo eles o sinal de EN, RS, D7,D6,D5 e D4. Ou seja, ele utiliza 2 pinos para o controle padrão destes displays ( EN e RS), e mais 4 pinos para o envio de dados e comandos, que são:  D7, D6, D5 e D4.

Agora para o conjunto de botões, temos uma implementação bem interessante, pois para a maioria deles é utilizado uma cadeia de divisores de tensão, para assim permitir que seja utilizado apenas "1" pino da nossa placa do Arduino. Ou seja, ao invés de utilizarmos 5 pinos para controlar 5 botões, são necessários apenas 1 pino, tendo como premissa que não estaremos lendo um sinal digital e sim um sinal analógico para podermos indentificar qual foi o botão pressionado.

Mas agora alguém me pergunta: "Mas não existem 6 botões?" Responderei: "Sim meu caro Sherlock Holmes!rs", o que acontece é que o Botão de Reset não pode ser adicionado à estes divisores de tensão, pois ele precisa ir diretamente acoplado no pino de reset, por isso ele se encontra em um pino separado.

Vendo o esquema elétrico, podemos observar isto:



Vamos simular? 



Como este shield é acoplado em nossas placas do Arduino, vamos nos utilizar do nosso simulador do Arduino, o SIMULINO, e dentro deste projeto eu adicionei mais um bloco de circuitos referentes ao Keypad Shield, já com seus botões de controle e LCD.

Segue um exemplo da ligação entre as placas.:


Onde são interconectados os sinais de terra (Gnd), Reset, AN0 (sinal analógico dos botões), e os sinais do Display LCD (EN,RS,D7,D6,D5 e D4).

Foi adicionado um Terminal Serial, para que sejam exibidas nossas mensagens de debug. Ele não precisa ser retirado, e funciona como nosso debug utilizado através da Serial Virtual da nossa IDE (ou plataforma de programação ).


 Dentro do Keypad Shield, nos deparamos com o seguinte esquema:


 Tendo a disposição dos botões parecidas com a que utilizamos em nosso shield, para ficar bem familiar.

Aqui você só precisa controlar conforme  o shield, apertando os botões e verificando o seu funcionamento.

;-----------------------------------------------------------------------------------
 Observação:

Existe um possível "bug" no simulador Proteus, mas tenham calma, é fácil para contorná-lo. 
Ainda estou verificando se acontece em outros microcomputadores ou se é apenas no meu.
O que acontece é que quando iniciamos o simulador, devemos estar com o bloco do Keypad Shield aberto, ou seja, devemos estar dentro da planta do shield, tendo tal visão:

 
Pois se o simulador for aberto fora deste bloco, aparentemente a simulação referente ao Display LCD não funciona de modo à liga-lo. Aparentemente ele não liga se não estivermos vendo ele.
Então é simples, basta iniciar a simulação com esta janela aberta que tudo irá funcionar.
;-----------------------------------------------------------------------------------


Logo estarei fazendo um vídeo para mostrar como fica a simulação.

Os arquivos estão dividos em pastas, com os esquemas e a imagem do Shield.
Dentro da pasta dos fontes (source), foram adicionados dois projetos: um para as placas do Arduino com o compilador padrão dele, onde os arquivos terminam com *.ino , e outro para as placas do Chipkit, pois para o compilador deles a extensão do arquivo é o *.pde .  

Observem bem antes de abri-los. ^^ 

;-----------------------------------------------------------------------------------
 Observação:
 Dentro do código fonte, foram adicionados 3 tipos de configurações de pinos para o shield
porque já me deparei com 3 tipos de pinagens diferentes.
Caso o shield não funcione da primeira vez, tenha calma, provavelmente você precisa
verificar qual é a configuração correta para o seu shield. 
As mais utilizadas já estão dentro do arquivo fonte.    
;-----------------------------------------------------------------------------------


Foram adicionados os *.hex e o *.elf, para quem quiser apenas simular sem compilar, e quem sabe fazer o disassembler do projeto.

Estamos esperando seus comentários. Não deixem de comentar.

Até o próximo post.


  [DOWNLOAD]