Mostrar mensagens com a etiqueta Proj. Relógio. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Proj. Relógio. Mostrar todas as mensagens

Sendo esta uma engenhoca e havendo um concurso de engenhocas, fazia todo o sentido ir participar.
O 1º concurso de muitos que espero ver ser organizados na integra pelo ELECTRUBI!
2 voltímetros com uma nova utilidade - ser um relógio. Sim é uma Engenhoca :)

PS: O relógio ficou em 2º lugar...






Desde o inicio que o voltímetro das horas me chateava um pouco...

A sua não linearidade (barato... :) ) aliada ao meu método tosco de fazer a escala, fez com que o pwm para as horas não fosse calculado com um simples y=mx+b.
Farto disso resolvi fazer uma abordagem mais inteligente.
Acertei os valores de pwm para as 12 horas, de forma a coincidir exactamente o ponteiro com o risco da escala.

Guardei esses valores no vector "horas[posição vector]".
A única certeza após isto é que cada "salto" teria de ser dividido em 60 minutos.
O cálculo para obter o pwm certo para aquela hora e minuto, é dado por:
H - horas lidas no RTC;
M - minutos lidos no RTC;
unsigned int horas[13] = {0,70,160,245,330,415,495,590,680,780,870,970,1024};
pwm = horas[horas_1] - horas[horas_1 -1];
pwm = (pwm * minutos_1)/60;
pwm += horas[horas_1 -1];
Desta forma dou por resolvido o problema com o voltimetro das horas. Já está a funcionar à algumas horas e até ao momento está perfeito.

Já está completa mais uma etapa do relógio.
Começa a ganhar forma finalmente.
Usei o DraftSight para fazer o desenho da caixa. O material usado foi MDF de 3mm de espessura.
As dimensões são cerca de 120x65x55 (mm).

Este é o aspecto final com os voltimetros já montados no painel.

Chegado a este ponto, o relógio está praticamente concluído.
No video podem ver já o acerto das horas e a colocação em funcionamento dos voltímetros através dos 2 módulos de PWM do MCU.
No video também é visível a resposta a cada segundo passado do circuito para o computador com as horas lidas a partir do RTC (Real Time Clock).
Os ponteiros não tremem absolutamente nada, por isso o filtro de 1ª ordem a 5Hz (seguido de um buffer de corrente) corta mais do que bem a frequência de PWM que ronda os 15KHz.

Próxima etapa: colocar tudo dentro de uma caixa :D

PS: O video não tem som.

Uma breve actualização deste projecto.
A vermelho podem ver a PCB com o PIC16F1509, o conjunto de 2 ampops LM358 e o regulador de tensão 7805. Pode-se ainda ver o módulo com o RTC e o suporte para a pilha.
Todos os outros componentes passivos estão soldados por baixo (todos em SMD).

Na foto em baixo já se podem ver os voltímetros, com o novo fundo com escala, ligados à board de controlo.
Os voltimetros foram também alterados para terem iluminação na parte inferior, com 2 leds em cada um.

O tempo não é muito , mas aos poucos vai ficando feito :)

O módulo RTC que comprei já tem o suporte para uma pilha, o que é óptimo! Caso falhe a alimentação do circuito, tudo vai abaixo excepto a temporização do DS1302.
No entanto tem de haver uma simples possibilidade de se poder actualizar as horas sem que o programa fique bloqueado cada vez que a energia falhe.
Para resolver essa questão, implementei o seguinte: o programa inicia e via serial (com um baudrate de 19200) envia uma mensagem a questionar se é pretendida alguma configuração. São activadas então 2 interrupções, uma pelo Timer0 e outra pela chegada de uma caracter à USART.
Numa situação comum de falha de energia e regresso, o Timer0 irá contar 10s e o programa avançará sem que se passe pelo processo de configuração.

Detalhe das 3 possibilidades de iniciação:
* Por overflow do Timer0: na verdade o overflow deste timer irá ocorrer 610 vezes (correspondente a cerca de 10s) antes de uma flag ser colocada a 1 dentro do ISR. Conclui-se com isso que houve uma falha de energia e que ninguém quer actualizar horas.
* Receber um caracter diferente de "S" ou de "s": neste caso é assumido que a pessoa tem o terminal ligado mas simplesmente não pretende fazer qualquer configuração no relógio. A flag é colocada com o valor 2 e no main() segue um rumo semelhante ao 1º caso.

Receber o caracter "S" ou "s": neste caso entende-se que a pessoa deseja configurar o relógio, é colocada a flag com o valor 1 e no main() (ver figura em baixo) é chamada a função que dá inicio à configuração.
Na figura seguinte é visível um pedaço da função de configuração, neste caso apenas correspondente às horas.
Em resumo, são enviadas duas mensagens, uma dá conta da "Etapa de configuração" e a outra dá as instruções de introdução de horas.
Qualquer valor (de 2 números) que não esteja no intervalo 0<horas<13, é descartado e o ciclo repete novamente.
De um modo geral as partes principais da inicialização estão explicadas em cima.
Nas figuras seguintes irão surgir alguns exemplos do que já foi falado, em ambiente de simulação.

* 10s sem actividade na usart

* Introdução de caracter diferente de "S" ou "s"

* Introdução de caracter "S" ou "s"


"Não percam os próximos episódios, ..."

Se a ideia é mostrar horas e minutos, a escala de 5V dos voltímetros, não serve. Tive de adaptar de modo a ficar minimamente perceptível
Eu sei que muitos vão pensar que esta foi uma maneira estranha de fazer as coisas... bem mas foi assim que me lembre de fazer eheheh.
Em 1º lugar, desmontei o painel do voltimetro e tirei uma foto ao mesmo, tentando manter a perpendicular.

O passo seguinte foi, recortar o que realmente importava e num programa de edição de imagem (usei o gimp) fazer algumas limpezas e replicar alguns traços da escala antiga (0-5V).

O 3º e último passo, foi imprimir tudo à escala, num pedaço de papel autocolante e colar no painel, em cima da escala antiga.

No final, penso que nem ficou assim tão mal como pensava, sobretudo devido ao seu reduzido tamanho...
Infelizmente, vou ter que desfazer a escala e fazer tudo novamente para as horas e fazer pela primeira vez a escala dos minutos também. A escala da foto está errada, pois para coincidir com a escala do RTC (DS1302 pagina 9) deverei iniciar em 1h e terminar em 1h novamente, passado pelas 12h. No fundo, olhando para a escala em cima, onde está '0' deverá ficar '1' e onde está '12' ficará '1' ou então fica vazio.

Mais actualizações aproximam-se.
"Não percam os próximos episódios, ..."

Desta é de vez!
Depois do falhanço por completo com os servos, chegou o novo método! Tal como tinha dito, esta engenhoca não ia ficar por aqui e chegaram no outro dia 2 voltímetros analógicos, comprados no ebay.
Os dois ficaram-me em cerca de 6€.
Neste ponto já podem imaginar qual será a estratégia!
Com algum jeito, vou retirar o painel com a escala de 5V e vou substituir por uma escala de 0h a 12h e no outro por 0min a 60min.
Vou usar um PIC16F1509 (que entre muitas outras coisas, tem 4 módulos de PWM com resolução de 10bits, 2 dos quais não posso prescindir para este projecto) para estabelecer a comunicação com o RTC, tal como já tinha explicado AQUI, fazer a comunicação com o utilizador para acertar as horas (no futuro fazer mais coisas) e com 2 dos seus 4 módulos de PWM gerar uma tensão DC com passagem por 2 filtros passa-baixo de 1ª ordem. No final de tudo isso usarei um LM358 como buffer de corrente da saída dos filtros para os voltímetros.
Sobre esta ultima técnica de transformar PWM em tensão DC (variável de acordo com o duty cycle), podem consultar esta excelente Application Note da Microchip, que explica tudo de forma simples e clara.

Este foi um update rápido e geral para demonstrar que esta engenhoca não está parada...
Nos próximos dias irão aparecer mais actualizações sobre os avanços e o estado da mesma.

"Não percam os próximos episódios, ..."

Como mostram as fotos em baixo, a ideia ainda avançou e foram feitos vários testes assim como tentativas de acertar com o movimento.
A má qualidade dos servos fez com que se criasse aqui um enorme problema. A "precisão" ainda se mantinha a quando se iniciava o movimento, mas nas passagens de 60min - 0min ou 24h - 0h nenhum deles retornava à posição inicial a não ser que fosse forçado com a mão...
Alguns truques poderiam ser usados, mas no geral não gostei muito da forma como isto estava a ficar...
Mas o projecto/engenhoca não fica por aqui :D...
A caminho já vem outra coisa pela qual poderei substituir os servos... mas é melhor aguardarem :D.
Para terminar, a última foto mostra uma contagem feita com o RTC, explicada AQUI, que como não podia deixar de ser (ainda por cima neste curto espaço de tempo), acertava na mosca!



Mais um update a esta engenhoca...
Quando se tenta gastar o menos possível a contrapartida é o longo tempo de espera para que algo chegue a casa...
Tal como já tinha dito na parte 1 uma parte principal era o RTC (Real Time Clock, wiki). Os módulos à venda no ebay são extremamente baratos, já possuem um suporte para pilha (caso a energia ao circuito falhe, o relógio não perde os dados) e têm imensas funções, muitas das quais nem sequer vão ser usadas aqui...
Uma rápida procura levou-me à compra de um módulo com um DS1302 da MAXIM, que me custou cerca de 80 cêntimos, tal como podem ver no ebay.
O DS1302 conta segundos, minutos, horas, dias do mês e da semana, etc..., para mais detalhe aconselho uma leitura do datasheet.
Ora, o módulo chegou e o que interessa é colocar isto a fazer o trabalho que lhe é devido... enviar as horas certas quando solicitado.
Este IC usa um protocolo de comunicação chamado 3-wire interface. Muitas confusões são criadas em torno disto... isto funciona como o I2C? Funciona como o SPI?
Muito li em torno disto e fartei-me do que lia pela internet e fui ao único sitio onde isto tinha de estar claro: o datasheet!
Na figura 4 (pag. 8) esta tudo o que é preciso e este protocolo é facilmente implementado em software (explicado em seguida).
A comunicação pode ser dividida em dois tipos: a leitura de um byte e a escrita de um byte para o RTC.
A leitura de um byte do RTC é feita enviando o endereço do byte a ler e nos 8 clock's seguintes irá ser recebida a informação contida nesse byte. Os endereços disponíveis no DS1302 podem ser vistos na tabela 3 do datasheet, tal como as respectivas "respostas".
O RTC guarda o estado do pino I/O (bit 0 ou 1) no flanco ascende do clock e passados 8 flancos, ele já recebeu o endereço completo e nos próximos 8 pulsos, no flanco descendente, irá enviar o byte contigo no endereço.
A escrita de um byte para um endereço do RTC, é feita de forma muito semelhante. São enviados 16 pulsos de clock, os primeiros 8 correspondentes ao endereço e os seguintes correspondentes ao byte a guardar.
Mas melhor que isto,  a figura 4 explica bastante bem como tudo se processa. 
Para colocar o RTC em funcionamento e retirar alguns valores, fiz o seguinte código que com os comentários penso que fica bem explicito o que se passa em cada etapa.
Neste caso, usei um PIC18F46k20 para testar o módulo, embora não seja este que irei usar no circuito final.

Alguns defines importantes para as funções de escrita e leitura:

Função de inicialização:

Função de leitura:

Função de escrita:

Bem... agora que finalmente chegou o RTC e já consegui comunicar com ele é altura de começar a montar tudo.
Não percam os próximos episódicos...

Olá.
Surgiu tempo para fazer mais uma "invenção"... um relógio com 2 ponteiros ligados a 2 servos.
Um dos ponteiros irá apontar as horas e o outro os minutos, como um relógio comum, mas em 2 mostradores diferentes.
Um semi-circulo das horas de 0h a 24h e outro semi-circulo em oposição com os minutos de 0min a 60min.
O tempo será lido, obviamente, a partir de um RTC (Real Time Clock). Consegui um módulo no ebay (ver AQUI) por cerca de 0.70€.
A ideia será usar um pequeno micro para comandar os servos de acordo com o que será lido do RTC. Como este já tem suporte para a pilha, será óptimo, pois mesmo que se desligue da alimentação, não é necessário acertá-lo novamente.
Para acertar as horas, quero fazer algo simples como uma comunicação série, levando a uma interrupção no programa do micro e reescrevendo data e horas no RTC, actualizando os valores.



Pequeno video do primeiro teste, com saltos de 50uS.
Agora é esperar que o módulo com o RTC chegue.