Blog do Miklos

MIKLOS DESIGN - https://miklosdesign.com.br

2018-08-19T12:05:00.002-03:00

Visite o site de meu estúdio de design de luminárias.
Visit my website miklosdesign and know my creations in lighting

https://miklosdesign.com.br
https://www.facebook.com/miklosdesign/

Máquina de corte a laser que eu montei usando arduíno e CNC Shield.

STAR TREK TOY (CHIME)

2017-01-02T09:24:00.000-02:00

Faz um tempo que estou de olho neste brinquedo com efeitos de som da série start trek TOS, mas como sempre o valor de frete e impostos torna este tipo de compra uma dor de cabeça.

Então resolvi fazer um brinquedo similar e aproveitar a diversão de forma completa, melhorando e customizando o mesmo. Usei uma arduino uno conectada a um módulo de Sd, um sensor pir e led rgb. O principal é a biblioteca Arduino library for asynchronous playback of PCM/WAV files direct from SD card ( https://github.com/TMRh20/TMRpcm) que faz o trabalho de executar os sons com intereção dos sensores e botões. Seguem dois vídeos :

PADAVAN FIRMWARE NO ROTEADOR ASUS RT-AC51U

2016-11-17T10:43:00.002-02:00

Se você caiu na bobagem de comprar este roteador e esta desapontado com a instabilidade do software da ASUS (que é uma bomba) te sugiro utilizar o firmware alternativo PADAVAN:

https://bitbucket.org/padavan/rt-n56u

No meu caso pelo menos salvou um equipamento que eu já estava colocando na bacia das almas (mercado livre).

Com este firmware e um modem HUAWEI E173 eu consegui fazer um sistema com dual wan que funciona.

Melhor ainda que estou usando um chip da TIM no plano TIM BETA LAB que te dá 10 gb de franquia mensal.

Agora.... não para por ai, além de ter recursos muito bons, você ainda pode acessar o SSH do roteador e dar comandos AT para o modem... enviar e recuperar SMS por exemplo.

Segue um tutorialzinho:

1. ACESSE O ROTEADOR POR SSH
2. DE O SEGUINTE COMANDO PARA ACESSAR O MODEM

microcom -s 115200 /dev/ttyUSB2

Obs: mude a porta se necessário o meu pegou de USB0 a USB2.

3. SE O SEU MODEM APRESENTAR AS MENSAGENS DE DSFLOWRPT DE O COMANDO A SEGUIR PARA INTERROMPER ESTAS MENSAGENS E PODER TRABALHAR EM PAZ:

AT^CURC=0

obs - mude para 1 para religar

4. depois é só usar o modem normalmente com os comandos AT padrão mesmo:

LER SMS

AT+CMGF=1
OK
AT+CMGL="ALL"
+CMGL: 1,"REC UNREAD","+31628870634",,"11/01/09,10:26:26+04"
This is text message 1
+CMGL: 2,"REC UNREAD","+31628870634",,"11/01/09,10:26:49+04"
This is text message 2
OK
AT+CMGD=1
OK
AT+CMGD=2
OK

ENVIAR SMS

Sending SMS
Using AT commands you can easily send an SMS message from your device. (Note that SMS may incur additional charges.)
Starting from your screen session connection to the modem:

Send AT
Switch into text SMS mode (easier than the other mode) by sending AT+CMGF=1
Prepare the message by sending AT+CMGW="+<phone number>" The phone number includes the country code so to send an SMS to the US number 773-555-1234 you would send the command AT+CMGW="+17735551234". If it worked, you should get a > prompt.
Type in your message at the prompt and hit Ctrl+Z to end the message.
After you hit Ctrl+Z you should get a message back in the format +CMGW: X where X is a number. This number is needed in the next step.
Send AT+CMSS=X where X was the number from the previous step.
If all goes well you should get a +CMSS response followed by an OK. Your SMS should have sent!

É isso ai!

ARDUINO + 5 X 7 DOT MATRIX DISPLAY

2013-09-29T13:31:00.000-03:00

Visite meu site pessoal !!! ---Visit my personal website!!

Como uma coisa que parece simples pode ser tão complicada.... neste post vou registrar minha experiência para conectar um display de pontos (dot / led matrix) ao arduino.

Na maior parte dos sites ( assim como no arduino.cc) ou a conexão é direta nas portas digitais ou usando o chip MAX 7219/7221 que já tem até uma biblioteca na IDE do Arduino. O problema é que não achei matriz de leds de 8x8 em lugar nehum... logo resolvi usar os de 5x7 mesmo que são fáceis de achar e baratos, os shift registers 74HC595 que eu já tinha então resolvi trabalhar com eles

A matriz que está no vídeo é bem grande e vermelha ( 11 cm x 17,5 cm com pontos de 1 cm) e divertida de trabalhar porque o efeito é mais interessante mas o preço é alto, R$ 20,00. Nomalmente as´pequenas não custam mais que R$ 2,00.

Segue a lista de produtos para montar esta experiência:
1 x Matrix de pontos 5 x7 ( ou outra com até 8 linhas x 8 colunas)
5 x BC548 NPN transistors
2 x 74HC595 ( um para as linhas e outro para as colunas)
1 x arduino
Fios para conexão
Resistores para proteger os leds ( na minha não usei porque minha matriz é 5v como o arduino) pois a voltagem do arduino é alta para a maioria das matrizes
1 x breadboard

Para esta montagem eu usei o exemplo de um dos melhores sites instrutivos sobre o arduino:

http://tronixstuff.wordpress.com/2010/06/06/getting-started-with-arduino-%e2%80%93-chapter-nine/

A matriz de pontos que usei é esta BM-40657ND (datasheet):

Segue esquema de montagem:

Como você vai ver nos exemplos por ai, as matrizes de 8x8 tem conexões bem simples, um pino para cada linha ou coluna, isto torna o trabalho mais fácil. Em uma matriz de 5 x7 existem pinos duplicados e a sequência dos pinos é bem chata de entender. Na parte inferior da esquerda para a direita estão os pinos 1 a 7 e na parte superior da direita para a esquerda estão os pinos 8 a 14.

Note ainda que cada led ou diodo tem um polo negativo e um positivo, na ilustração acima cada seta com uma barra no topo representa um led, ( este é o símbolo eletrônico do diodo) a ponta da seta com a barra é a parte negativa ou terra e a base da seta a parte positiva. Veja que os negativos são todos conectados nas colunas e os positivos nas linhas. Por isso trata-se de uma matriz com colunas catodo (negativo) comum.

Na ilustração acima você pode ver que a terceira linha de baixo para cima é ativada pelo pino 1, a segunda linha de baixo para cima é ativada pelo pino 7... e assim por diante. Note que existem dois pinos que não estão representados na ilustração, os pinos 5 e 12 sao relativos a quarta linha de baixo para cima e os pinos 4 e 11 são relativos a terceira coluna. Confuso não é? Em minha montagem descobri que não é necessário conectar todos os pinos... escolha um para a linha (5 ou 12) e um para a coluna (4 ou 11) e pronto.... funciona assim mesmo.

Basicamente o esquema funciona da seguinte forma:

1. Os shift registers 74HC595 recebem os dados da arduino em forma decimal usando o comando ShiftOut e transformam em bytes, no caso da matriz com 5 x7 eu envio no máximo 31 para as linhas (00011111) e no máximo 127 para as colunas (01111111) isso ligaria todos os pontos da matriz:

digitalWrite(latchpin, LOW);
shiftOut(datapin, clockpin, MSBFIRST, 31); // para as linhas: catodos : negativo/terra
shiftOut(datapin,clockpin, MSBFIRST, 127); // para as colunas: anodos : positivo
digitalWrite(latchpin, HIGH);

3. O shift register 1 está conectado nas linhas (positivo/anodo) e o 2 nas colunas (negativo/catodo), quando o shift register 1 é ativado ele permite a passagem de corrente para os pinos positivos da matriz.2. Os shit register não podem dar saída para o terra eles simplesmente ligam ou desligam as portas com 5v, é ai que entram os transistores, quando o transistor recebe uma voltagem no pino base ele conecta o pino coletor ao emissor. Como o pino coletor está conectado na matriz e o emissor no terra ( e o base nos pinos do shift register) , quando o shif register 2 é ativado ele conecta as colunas ao terra.

4. Desta forma se fecha o circuito e qualquer que seja a combinação de leds obtida com a combinação das portas dos shift registers ativados ... se acende.

Leve em consideração que o shift register 1 controla as linhas que terão corrente e o 2 as colunas que serão conectadas ao terra e isto não permite que você desenhe caracteres ou números... o máximo que você consegue são pontos ou conjuntos de pontos como linhas ou quadrados ... para desenhar os caracteres é necessário fazer uma varredura rápida das colunas e linhas uma por vez, de forma que nosso olho não perceba quando se apagam ou acendem, isto se chama de persistência de visão.

Quando os caracteres estão em movimento isso é bem claro... quando se trata de um número ou letra parado é mais difícil de entender mas o princípio é o mesmo. Esta "jogada" de acender e apagar os leds em colunas individuais em squencia rápida é feita no momento da programação e não tem nada a ver com a montagem física. O comando shiftOut é alimentado com os parâmetros necessários por meio de loops, eu demorei um bocado para entender, tomara que você seja mais rápido(a).

Neste link você encontra uma tabela que usei como exemplo para calcular o desenho das letras e números.

Segue o código para a animação do vídeo nesta página:

--------------------------------------------------------------------------------------------------------

/*
Claudio Miklos 25/07/2010 baseado em : http://tronixstuff.com/tutorials > Chapter 9
*/

int latchpin = 8; // connect to pin 12 on the '595
int clockpin = 7; // connect to pin 11 on the '595
int datapin = 10; // connect to pin 14 on the '595
int seq[] = {0,0,0,0,0, // VAZIO
127,73,73,73,65,        // E
0,0,126,1,1,1,126,      // U
0,0,60,66,33,66,60,     // CORACAO
0,0,63,68,68,68,63,     // A
0,0,127,72,76,74,49,    // R
0,0,127,65,65,65,62,    // D
0,0,126,1,1,1,126,      // U
0,0,65,127,65,          // I
0,0,127,16,8,4,127,     // N
0,0,62,65,65,65,62,     // O
0,0,0,33,127,1,         // 1
0,0,0,33,67,69,73,49,   // 2
0,0,34,65,73,73,54,     // 3
0,0,64,32,16,8,4,2,1,   // ONDA DESCE
2,4,8,16,32,64,0,0,     // ONDA SOBE
127,62,28,8,            // SETA DIREITA
0,0,0,0,0};             // VAZIO

void setup()
{
   Serial.begin(9600);
   pinMode(latchpin, OUTPUT);
   pinMode(clockpin, OUTPUT);
   pinMode(datapin, OUTPUT);
}

void movealienfromleft(int duration)

{
   int colbin=0;
   for (int xx=0; xx<=113; xx++)
   {
      for (int dd=0; ddfor (int q=0; q<5; q++)
         {
           colbin=(xx*1)+q;
           columndisplay(seq[colbin], q,0);
         }
      }
   }
}

void columndisplay(int coldata, int column, int holdtime)

{
   int matrixcolumn[5] = {
     1,2,4,8,16};
   digitalWrite(latchpin, LOW);
   shiftOut(datapin, clockpin, MSBFIRST, matrixcolumn[column]);
   shiftOut(datapin, clockpin, MSBFIRST, coldata);
   digitalWrite(latchpin, HIGH);
   delay(holdtime);
}

void loop()
{
   movealienfromleft(30);
}

-------------------------------------------------------------------------------------------------------------------

Pesquisa:

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1266267785

http://dotmatrixdesign.tumblr.com/

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1267391793/7

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1203747843/22

http://forum.sparkfun.com/viewtopic.php?t=3811amp;sid=48fda56bd551ee455954a7c2ea44320e

http://www.bryanchung.net/?p=177

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/step8/Project-3pt-2-2-Wire-4x4-led-matrix-display/

Documentação:

http://www.paralight.us/uploads/pdf/A-5570SR.pdf

http://www.paralight.us/products/details.php?g=cGNfaWQlM0QyMyUyNnBfaWQlM0Q4Mg==

Montagem:

http://tronixstuff.wordpress.com/2010/07/09/review-maxim-max7219-led-display-driver-ic/

http://www.digisoft.com.pk/Projects/5-x-7-dotmatrix-led-display

http://tronixstuff.wordpress.com/2010/06/06/getting-started-with-arduino-%e2%80%93-chapter-nine/

Material:

http://datasheets.ru/datasheets/572326/data-BM-40657ND.html
http://www.datasheetcatalog.org/datasheet/fairchild/BC548.pdf

1K ohm, 1/4 watt resistor

marrom, preto, vermelho, dourado.

560 ohm, 1/4 watt resistor

verde, azul, marrom, dourado.

470 ohm, 1/4 watt resistor

amarelo, violeta, marrom, dourado

BC548 NPN transistors
74HC595

http://forum.sparkfun.com/viewtopic.php?t=14212&start=15
http://www.thebox.myzen.co.uk/Tutorial/Power_Examples.html
http://www.sparkfun.com/commerce/product_info.php?products_id=733
http://www.sparkfun.com/commerce/product_info.php?products_id=312
http://members.ziggo.nl/electro1/avr/dotmatrix.htm

http://www.bitartist.org/2009/02/led-flower-vase-supplementary-note.html

http://kennethfinnegan.blogspot.com/2010/02/dot-matrix-arduino-clock.html

http://www.bitartist.org/2008/06/gif2led-released-and-with-my-led-egg.html

http://www.jacobpierce.com/blog/2009/10/11/arduino-hello-world-with-384-leds/

http://kalshagar.wikispaces.com/Arduino+and+a+Dot+Matrix

http://blog.bsoares.com.br/tag/arduino

http://www.arduino.cc/playground/Main/DirectDriveLEDMatrix

http://www.instructables.com/id/LED-Dot-Matrix-Display/

http://www.best-microcontroller-projects.com/led-dot-matrix-display.html

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1271447565

http://www.arduino.cc/playground/Main/MAX72XXHardware#WiringLedMatrix

http://forums.parallax.com/forums/default.aspx?f=25&m=453532

relogio:

http://www.maxim-ic.com/datasheet/index.mvp/id/4984
termometro:
http://www.nozebac.net/index.php?page=thermometer#expand2

2013-08-22T12:45:00.000-03:00

Physical Computing & Electronic Sketching"Physical (or embedded) computing, in the broadest sense, means building interactive physical systems by the use of software and hardware that can sense and respond to the analog world... a creative framework for understanding human beings' relationship to the digital world. In practical use, the term most often describes handmade art, design or DIY hobby projects that use sensors and microcontrollers to translate analog input to a software system, and/or control electro-mechanical devices such as motors, servos, lighting or other hardware." Wikipedia

Este blog trata de um novo conceito de computação que permite sair da frente do computador e interagir com o mundo real e que tem me proporcionado muitas horas de diversão e descobertas. Criar objetos eletrônicos que percebam o mundo ao redor, o movimento, as luzes, as cores e criar interações e reações com e para tudo isso. Este conceito é chamado de Physical Computing. Estou documentando estas experiências e estudos como uma forma de criar um arquivo de referência, espero que este arquivo seja útil para você também. (ao lado meu robô La*Ta)

PLATAFORMA ARDUÍNO
"Arduino can sense the environment by receiving input from a variety of sensors and can affect its surroundings by controlling lights, motors, and other actuators. The microcontroller on the board is programmed using the Arduino programming language (based on Wiring) and the Arduino development environment (based on Processing). Arduino projects can be stand-alone or they can communicate with software on running on a computer" (e.g. Flash, Processing, Max/MSP).

A plataforma microprocessada que estou utilizando é chamada de Arduíno, é uma concepção de designers Italianos e inclui a parte física (placa de circuito) a a parte lógica (softwares) utilizando uma versão simplificada da linguagem C chamada de Wiring, desenvolvida específicamente para utilização em eletronic sketching (mais ou menos - rabiscar com eletrônica).

Este conjunto de hardware e software foi criado para tirar o uso dos microprocessadores dos corredores das indústrias e universidades e colocá-lo a disposição de pessoas como eu e você, designers , artistas, curiosos, hobistas e muitos outros com vontade de aprender criar e se divertir.

Com esta plataforma e muitas outras você pode criar desde um conjunto de luzes de natal que acendem e apagam como você desejar até um robot que evite paredes e objetos, só depende da sua vontade e de um pouco de dinheiro, lógicamente.

Você deve estar pensando agora, ok mas e dai? o que é esse tal microprocessador e o que ele faz e como eu posso fazer tudo isso?

Um microprocessador é um computador dentro de um chip, todos (todos mesmo) os produtos que você tem em casa, desde sua televisão até sua máquina de lavar roupa, usam microprocessadores para executar as funções a que se destinam. Por exemplo, todas as vezes que você muda o canal de sua televisão um sinal infravermelho (IR) é emitido pelo controle remoto e transmitido para um receptor na tv. Este receptor passa o sinal para o microcontrolador dentro da tv e este envia os comando necessários para que a parte eletrônica ( transistores, switches, e mil outras coisas) mudem seus estados de tensão elétrica e a mudança de canal aconteça.

Dentro do microprocessador existe um software (assim como no hd do seu pc) que roda em um pequeno espaço de memória (chip especial chamado eprom - memória permanente) e que controla tudo isso.

A idéia aqui é que você possa fazer a mesma coisa (não uma TV!) controlando com seu próprio software e hardware os equipemntos que quizer e conseguindo que eles façam o que vc desejar. Divertido não é?

Veja alguns exemplos:

SITE INSTRUCTABLES - Criações de pessoas de todo o mundo

A plataforma arduíno tem muitos modelos diferentes de placas e microprocessadores e é uma plataforma aberta que pode ser montada e vendida por qualquer um (existem mil tipos e nomes: freeduino, robotduino...) , atualmente o microprocessador utilizado é o ATMEGA328 (arduino duemilenove).

Veja um esquema da placa da arduino duemilenove :

O microprocessador é montado em uma placa de circuito que dá acesso a suas portas (como as portas de um PC , usb, serial...) mas, com funções bem mais simples como enviar pulsos elétricos aos motores ou receber estes pulsos e sinais de sensores para ler o mundo a volta.

Vamos ver mais de perto:

Para conseguir usar estas plataformas não é necessário conhecer a fundo como funciona o microprocessador (apesar de que você certamente vai querer saber), tudo é pensado para que os conceitos mais complexos fiquem atrás da linguagem Wiring. Porém não se trata de uma interface gráfica bonitinha (apesar de existirem ) , é uma linguagem de programação que tem que ser aprendida.

Um exemplo da linguagem Wiring aonde se lê sinais de sensores de luz para fazer um robot ir atrás da luz ou evitá-la:

---------------------------------------------------------------

void loop()

{

digitalWrite(ledPin, HIGH); // sets the LED on

sensor_left = analogRead(0); // reads the value of the left photoresistor (value between 0 and 1023)

sensor_right = analogRead(1); // reads the value of the right photoresistor (value between 0 and 1023)

-----------------------------------------------------------------

O mais importante é aprender os conceitos de utilização dos equipamentos que podem ser ligados a ela e como utiliza-los e controlar a linguagem para conseguir realizar as idéias que você tem.

Como existem centenas de tipos de sensores, motores e outros tipos de equipamentos que é possível utilizar, o caminho é longo e a cada passo um novo desafio aparece.

É isto mesmo que eu estou fazendo agora, experimentando, aprendendo e me divertindo. Espero que as informações do meu blog ajudem um pouco e que você também participe.

claudio@miklos.com.br

TEDx Tubarão

2012-11-11T10:15:00.002-02:00

Estive ontem (10/11/2012) participando do evento TEDx Tubarão.

Falei sobre hardware livre e apropriação de tecnlogia..além das oficianas 100 noção.

Foi um prazer participar e a organozação está de parabéns.

Preparei um vídeo para o evento:

DRAWBOT ROBÔ DESENHISTA

2012-03-28T10:44:00.000-03:00

Estou montando um robô desenhista baseado no projeto DrawBot :

https://github.com/i-make-robots/drawbot

Com isto estou aprendendo um pouco sobre os Gcodes e uso de máquinas de CNC, como eu já tinha dois motores stepper NEMA 23 - SM1.8-B2SB-SE e o Adafruit stepper motor shield foi somente montar a estrutura em um cavalete de pintura antigo que estava num canto e ajustar.
A parte mais difícil foi a conexão dos motores e os ajustes finos (que não acabai ainda), encontrar uma forma de prender a caneta também demorou e acabei usando um suporte de microfone de um gravador velho e um clip de papel.

Palestra "Futebol de Robôs" no Garoa Hacker Clube

2012-02-26T09:37:00.001-03:00

Neste sábado dia 25/02/2012 recebemos o Prof. Flávio Tonindandel da FEI no Garoa Hacker Clube para uma palestra sobre robótica. O Flávio fez uma apresentação sobre futebol de robôs que deixou o pessoal atento e participando por mais de 2 horas.

O Flávio, além de ser professor da FEI é também o Coordenador da Comissão de robótica da SBC.

O flávio Tonindandel durante a palestra.

Robô desenvolvido pelo grupo da FEI para as competições internacionais de futebol de robôs.

Oficina Arduino 100 Noção no Caderno Link do Estadão

2012-02-13T08:00:00.001-02:00

A oficina Arduino 100 noção saiu com destaque na capa do caderno link do estadão em 13/02/2012

O link para a matéria é: http://blogs.estadao.com.br/link/esse-tal-de-arduino/

Segue print da tela para registro:

Oficina Arduino 100 Noção na CPBr 2012

2012-02-12T10:52:00.000-02:00

No dia 08/02/2012 foi realizada na Campus Party 2012 uma edição da Oficina Arduino 100 Noção, a oficina contou com a ajuda do Garoa Wagner Sartori e teve a participação de aproximadamente 30 pessoas e mais público que acompanhou sem participar devido a falta de material.

A organização da CPBr adquiriu os materiais para a oficina de forma correta e em tempo, e doou os mesmos para o Garoa Hacker Clube após a oficina.

Realizar este tipo de oficina na Campus Party é bastante difícil devido ao barulho de diversos eventos acontecendo simultaneamente e a dificuldade de atender cada pessoa individualmente. O objetivo de propos a oficina foi alcançado pois o maior gol era divulgar o Garoa Hacker Clube além de demonstrar que é possível mesmo para aqueles que moram em regiões remotas do país montar uma palca arduino na protoboard e levar a frente os conceitos de hardware e software livre.

A bancada do garoa durante o evento foi movimentada e todos colaboraram para o sucesso e divulgação do clube. Foi marcante a palestra sobre impressão 3D que é a febre do momento.

O crachá do evento para não perder a lembrança.

Destaque no site da CPBr 2012

NOVA PLACA ARDUINO 100 NOÇÃO

2012-02-05T09:15:00.001-02:00

No dia 04/02/2012 a oficina "Arduino 100 noção" foi realizada com uma nova montagem utilizando LED RGB e potenciômetro, esta nova montagem apresentou vantagens para os participantes pois foi possível apresentar de uma forma prática a noção de resistividade e lei de Ohm.

Radar com Ping e Processing

2011-10-12T13:09:00.009-03:00

Neste post estou mostrando minha adaptação do trabalho do Luckylarry para uso com o sensor ping ao invés do SRF-05.

Ao Lado o sensor da Seeedstudio que é uma versão do sensor ping da Parallax, este sensor funciona baseado na emissão e captação de sinais sonoros.

O pricípio de funcionamento é a relação de tempo entre a emissão e a captação do som, baseado no fato de que o som tem uma velocidade constante é possível calcular a distância quando o intervalo entre a emissão e a captação é conhecido.

A montagem do sistema utiliza as seguintes portas do arduino:

- Digital 7 para o sensor ping
- Digital 9 (pmw) para o servo

Os dados recebidos no arduino na porta 7 são pulsos eletrícos que são convertidos em medidas de distância por uma formula simples e enviados para a porta serial para processamento do Processing.

A fórmula de conversão é baseada no fato de que velocidade do som é de 340 m/s ou 29 microssegundos por centímetro, logo se o sinal do sensor (pulsos em microssegundos) for dividido por 29 e depois novamente dividido por 2 ( o som é emitido e volta por isso temos que dividir por 2) teremos a distância em centimetros: microseconds / 29 / 2.

Foram necessárias poucas mudanças no código do arduino, o do processing é igual.

---------------------------------------------------------------------------------------------------------

Código Arduino:

/*
ARDUINO - RADAR COM PING E PROCESSING
ADAPTADO POR CLÁUDIO MIKLOS - WWW.MIKLOS.BLOG.BR - PARA USO COM SENSOR PING
CERDITOS ORIGINAIS:
luckylarry.co.uk
Radar Screen Visualisation for SRF-05
Sends sensor readings for every degree moved by the servo
values sent to serial port to be picked up by Processing
*/

#include <Servo.h>             // include the standard servo library
Servo leftRightServo;         // set a variable to map the servo
int leftRightPos = 0;         // set a variable to store the servo position
const int numReadings = 10;   // set a variable for the number of readings to take
int index = 0;                // the index of the current reading
int total = 0;                // the total of all readings
int average = 0;              // the average
int pingPin = 7;              // the PING pin
unsigned long duration = 0;  // variable for reading the pulse
unsigned long distance = 0;   // variable for storing distance
 
/* setup the pins, servo and serial port */
void setup() {
  leftRightServo.attach(9);
  Serial.begin(9600);
}
 
/* begin rotating the servo and getting sensor values */
void loop() {
  for(leftRightPos = 0; leftRightPos < 180; leftRightPos++) {  // going left to right.
    leftRightServo.write(leftRightPos);
      for (index = 0; index<=numReadings;index++) {            // take x number of readings from the sensor and average them
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);
        distance = duration / 29 / 2;                            // convert to centimetres
        total = total + distance;                              // update total
        delay(10);
      }
    average = total/numReadings;                               // create average reading
 
    if (index >= numReadings)  {                               // reset the counts when at the last item of the array
      index = 0;
      total = 0;
    }
    Serial.print("X");                                         // print leading X to mark the following value as degrees
    Serial.print(leftRightPos);                                // current servo position
    Serial.print("V");                                         // preceeding character to separate values
    Serial.println(average);                                   // average of sensor readings
  }
  /*
  start going right to left after we got to 180 degrees
  same code as above
  */
  for(leftRightPos = 180; leftRightPos > 0; leftRightPos--) {  // going right to left
    leftRightServo.write(leftRightPos);
    for (index = 0; index<=numReadings;index++) {
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);
        distance = duration / 29 / 2;                            // convert to centimetres
        total = total + distance;                              // update total
      delay(10);
    }
    average = total/numReadings;
    if (index >= numReadings)  {
      index = 0;
      total = 0;
    }
    Serial.print("X");
    Serial.print(leftRightPos);
    Serial.print("V");
    Serial.println(average);

   }

}

------------------------------------------------------------------------

Código Processing

/*
ARDUINO - RADAR COM PING E PROCESSING
ADAPTADO POR CLÁUDIO MIKLOS - WWW.MIKLOS.BLOG.BR - PARA USO COM SENSOR PING
CERDITOS ORIGINAIS:
luckylarry.co.uk
Radar Screen Visualisation for SRF-05
Maps out an area of what the SRF-05 sees from a top down view.
Takes and displays 2 readings, one left to right and one right to left.
Displays an average of the 2 readings
Displays motion alert if there is a large difference between the 2 values.
*/
import processing.serial.*;     // import serial library
Serial arduinoport;                  // declare a serial port
float x, y;                       // variable to store x and y co-ordinates for vertices   
int radius = 350;               // set the radius of objects
int w = 300;                    // set an arbitary width value
int degree = 0;                 // servo position in degrees
int value = 0;                  // value from sensor
int motion = 0;                 // value to store which way the servo is panning
int[] newValue = new int[181];  // create an array to store each new sensor value for each servo position
int[] oldValue = new int[181];  // create an array to store the previous values.
PFont myFont;                   // setup fonts in Processing
int radarDist = 0;              // set value to configure Radar distance labels
int firstRun = 0;               // value to ignore triggering motion on the first 2 servo sweeps

/* create background and serial buffer */
void setup(){
// setup the background size, colour and font.
size(750, 450);
background (0); // 0 = black
myFont = createFont("verdana", 12);
textFont(myFont);
// setup the serial port and buffer
arduinoport = new Serial(this, Serial.list()[0], 9600);

}

/* draw the screen */
void draw(){
fill(0);                              // set the following shapes to be black
noStroke();                           // set the following shapes to have no outline
ellipse(radius, radius, 750, 750);    // draw a circle with a width/ height = 750 with its center position (x and y) set by the radius
rectMode(CENTER);                     // set the following rectangle to be drawn around its center
rect(350,402,800,100);                // draw rectangle (x, y, width, height)
if (degree >= 179) {                  // if at the far right then set motion = 1/ true we're about to go right to left
motion = 1;                         // this changes the animation to run right to left
}
if (degree <= 1) {                    // if servo at 0 degrees then we're about to go left to right
motion = 0;                         // this sets the animation to run left to right
}
/* setup the radar sweep */
/* 
We use trigonmetry to create points around a circle.
So the radius plus the cosine of the servo position converted to radians
Since radians 0 start at 90 degrees we add 180 to make it start from the left
Adding +1 (i) each time through the loops to move 1 degree matching the one degree of servo movement
cos is for the x left to right value and sin calculates the y value
since its a circle we plot our lines and vertices around the start point for everything will always be the center.
*/
strokeWeight(7);                      // set the thickness of the lines
if (motion == 0) {                    // if going left to right
for (int i = 0; i <= 20; i++) {     // draw 20 lines with fading colour each 1 degree further round than the last
stroke(0, (10*i), 0);             // set the stroke colour (Red, Green, Blue) base it on the the value of i
line(radius, radius, radius + cos(radians(degree+(180+i)))*w, radius + sin(radians(degree+(180+i)))*w); // line(start x, start y, end x, end y)
}
} else {                              // if going right to left
for (int i = 20; i >= 0; i--) {     // draw 20 lines with fading colour
stroke(0,200-(10*i), 0);          // using standard RGB values, each between 0 and 255
line(radius, radius, radius + cos(radians(degree+(180+i)))*w, radius + sin(radians(degree+(180+i)))*w);
}
}
/* Setup the shapes made from the sensor values */
noStroke();                           // no outline
/* first sweep */
fill(0,50,0);                         // set the fill colour of the shape (Red, Green, Blue)
beginShape();                         // start drawing shape
for (int i = 0; i < 180; i++) {     // for each degree in the array
x = radius + cos(radians((180+i)))*((oldValue[i])); // create x coordinate
y = radius + sin(radians((180+i)))*((oldValue[i])); // create y coordinate
vertex(x, y);                     // plot vertices
}
endShape();                           // end shape
/* second sweep */
fill(0,110,0);
beginShape();
for (int i = 0; i < 180; i++) {
x = radius + cos(radians((180+i)))*(newValue[i]);
y = radius + sin(radians((180+i)))*(newValue[i]);
vertex(x, y);
}
endShape();
/* average */
fill(0,170,0);
beginShape();
for (int i = 0; i < 180; i++) {
x = radius + cos(radians((180+i)))*((newValue[i]+oldValue[i])/2); // create average
y = radius + sin(radians((180+i)))*((newValue[i]+oldValue[i])/2);
vertex(x, y);
}
endShape();
/* if after first 2 sweeps, highlight motion with red circle*/
if (firstRun >= 360) {
stroke(150,0,0);
strokeWeight(1);
noFill();
for (int i = 0; i < 180; i++) {
if (oldValue[i] - newValue[i] > 35 || newValue[i] - oldValue[i] > 35) {
x = radius + cos(radians((180+i)))*(newValue[i]);
y = radius + sin(radians((180+i)))*(newValue[i]);
ellipse(x, y, 10, 10); 
}
}
}
/* set the radar distance rings and out put their values, 50, 100, 150 etc.. */
for (int i = 0; i <=6; i++){
noFill();
strokeWeight(1);
stroke(0, 255-(30*i), 0);
ellipse(radius, radius, (100*i), (100*i)); 
fill(0, 100, 0);
noStroke();
text(Integer.toString(radarDist+50), 380, (305-radarDist), 50, 50);
radarDist+=50;
}
radarDist = 0;
/* draw the grid lines on the radar every 30 degrees and write their values 180, 210, 240 etc.. */
for (int i = 0; i <= 6; i++) {
strokeWeight(1);
stroke(0, 55, 0);
line(radius, radius, radius + cos(radians(180+(30*i)))*w, radius + sin(radians(180+(30*i)))*w);
fill(0, 55, 0);
noStroke();
if (180+(30*i) >= 300) {
text(Integer.toString(180+(30*i)), (radius+10) + cos(radians(180+(30*i)))*(w+10), (radius+10) + sin(radians(180+(30*i)))*(w+10), 25,50);
} else {
text(Integer.toString(180+(30*i)), radius + cos(radians(180+(30*i)))*w, radius + sin(radians(180+(30*i)))*w, 60,40);
}
}
/* Write information text and values. */
noStroke();
fill(0);
rect(350,402,800,100);
fill(0, 100, 0);
text("Degrees: "+Integer.toString(degree), 100, 380, 100, 50);         // use Integet.toString to convert numeric to string as text() only outputs strings
text("Distance: "+Integer.toString(value), 100, 400, 100, 50);         // text(string, x, y, width, height)
text("Radar screen code at luckylarry.co.uk", 540, 380, 250, 50);
fill(0);
rect(70,60,150,100);
fill(0, 100, 0); 
text("Screen Key:", 100, 50, 150, 50);
fill(0,50,0);
rect(30,53,10,10);
text("First sweep", 115, 70, 150, 50);
fill(0,110,0);
rect(30,73,10,10);
text("Second sweep", 115, 90, 150, 50);
fill(0,170,0);
rect(30,93,10,10);
text("Average", 115, 110, 150, 50);
noFill();
stroke(150,0,0);
strokeWeight(1);
ellipse(29, 113, 10, 10); 
fill(150,0,0);
text("Motion", 115, 130, 150, 50);
}

/* get values from serial port */
void serialEvent (Serial arduinoport) {
String xString = arduinoport.readStringUntil('\n');  // read the serial port until a new line
if (xString != null) {  // if theres data in between the new lines
xString = trim(xString); // get rid of any whitespace just in case
String getX = xString.substring(1, xString.indexOf("V")); // get the value of the servo position
String getV = xString.substring(xString.indexOf("V")+1, xString.length()); // get the value of the sensor reading
degree = Integer.parseInt(getX); // set the values to variables
value = Integer.parseInt(getV);
oldValue[degree] = newValue[degree]; // store the values in the arrays.
newValue[degree] = value;  
/* sets a counter to allow for the first 2 sweeps of the servo */
firstRun++;
if (firstRun > 360) {
firstRun = 360; // keep the value at 360 
}
}
}

Most Useless Machine - Caixa Teimosa

2011-07-03T11:05:00.021-03:00

Neste post estou apresentando um projeto simples e ao mesmo tempo muito divertido, uma caixa que se desliga sozinha. Este projeto ensina alguns princípios básicos como o uso de chave DPDT e microswitches e especialmente os conceitos de montagem mecânica que são sempre o mais interessante quando se quer uma atividade que prenda a atenção das crianças (no meu caso, minha filha de 11 anos que criou a pintura com cara de monstro para a caixa).

Existem centenas de vídeos e páginas com este projeto e até mesmo kits prontos para montar como é o caso deste da solarbotics.

Os materiais para montagem são:

1. Uma caixa de qualquer material rígido e fácil de furar, comprei uma de madeira em uma loja de artesanato por R$ 4,00;

2. Um microswitch e um switch DPDT que podem ser encontrado em qualquer loja de componentes eletrônicos;

3. Um motor, eu utilizei um de 33 rpm com alimentação de 6 volts, testei alguns mais rápidos mas a caixa saiu de controle :-);

4. Um poco de arame e criatividade para montar e adaptar o braço mecanico;

5. Uma fonte de alimentação, no meu caso foi uma bateria de 6 v chumbo ácido que eu tinha aqui mas pode ser com pilhas ou outra fonte.

O esquema de montagem é o seguinte:

Segue um vídeo com o funcionamento interno:

Quando liga-se o switch, o braço move-se na direção para desligá-lo, quando o braço desliga o switch a direção do motor é invertida.
Quando o braço chega ao fim do curso, aciona o microswitch que desliga todo o sistema. Divirta-se!

Som na Caixa!

Estou pesquisando uma forma de incluir som quando o botão da caixa é ligado.

seguem alguns links para minha pesquisa com o chip LM386:

http://josepino.com/audio/mini_amplifier_lm386

http://www.instructables.com/id/Audio-Amplifier

http://www.instructables.com/id/Know-Your-IC-LM386/step4/Project-layout/

Ethernet Shield enviando dados para web

2011-06-29T08:40:00.002-03:00

Neste post estou usando o ethernet shield do arduino para enviar as leituras de temperatura de um sensor LM35 para o site ThingSpeak e exibir estas leituras em forma de gráfico no blog. O site ThingSpeak permite que o usuário envie diversos tipos de dados e acesse estes dados de diversas formas com uma api para inclusão em outros meios como web, twitter ou o que mais você quiser.

No exemplo abaixo estou enviando estas leituras para um pequeno gráfico que pode ser visto em todas as páginas deste blog, esta mesma idéia pode ser usada para enviar outros tipos de leituras e existem ainda formas de fazer com que esta função tenha duas vias para controlar equipamentos e fazer automação doméstica.

Na imagem acima o sensor está conectado na porta analógica 0 e alimentado por 5V a partir da própria placa Ethernet. As leituras analógicas são convertidas para apresentar a temperatura em graus centígrados antes do envio.

(imagem estática de exemplo)

O código para exibição no blog é simples e pode ser encontrado no endereço https://www.thingspeak.com/channels/261 que é o endereço do canal destes dados no site ThingSpeak.

----------------------------------------------------------------------------------------------------

/*

 ThingSpeak Client to Update Channel Feeds
 
 The ThingSpeak Client sketch is designed for the Arduino + Ethernet Shield.
 This sketch updates a channel feed with an analog input reading via the
 ThingSpeak API (http://community.thingspeak.com/documentation/)
 using HTTP POST.
 
 Getting Started with ThingSpeak:
 
    * Sign Up for New User Account - https://www.thingspeak.com/users/new
    * Create a New Channel by selecting Channels and then Create New Channel
    * Enter the Write API Key in this sketch under "ThingSpeak Settings"
 
 Created: January 25, 2011 by Hans Scharler (http://www.iamshadowlord.com)
 
 Additional Credits: Example sketches from Tom Igoe and David A. Mellis
 
*/

#include <SPI.h>
#include <Ethernet.h>

int pin = 0; // analog pin
int tempc = 0,tempf=0; // temperature variables
int samples[8]; // variables to make a better precision
int maxi = -100,mini = 100; // to start max/min temperature
int i;

// Local Network Settings
byte mac[]     = { 0xD4, 0x28, 0xB2, 0xFF, 0xA0, 0xA1 }; // Must be unique on local network
byte ip[]      = { 192, 168,   1,  13 };                // Must be unique on local network
byte gateway[] = { 192, 168,   1,   1 };
byte subnet[]  = { 255, 255, 255,   0 };

// ThingSpeak Settings
byte server[]  = { 184, 106, 153, 149 }; // IP Address for the ThingSpeak API
String writeAPIKey = "sua chave vai aqui";    // Write API Key for a ThingSpeak Channel
const int updateInterval = 10000;        // Time interval in milliseconds to update ThingSpeak   
Client client(server, 80);

// Variable Setup
long lastConnectionTime = 0; 
boolean lastConnected = false;
int resetCounter = 0;

void setup()
{
  Ethernet.begin(mac, ip, gateway, subnet);
  Serial.begin(9600);
  delay(1000);
}

void loop()
{
  
  tempc = ( 5.0 * analogRead(pin) * 100.0) / 1024.0;

  String analogPin0 = String(tempc);
  
  // Print Update Response to Serial Monitor
  if (client.available())
  {
    char c = client.read();
    Serial.print(c);
  }
  
  // Disconnect from ThingSpeak
  if (!client.connected() && lastConnected)
  {
    Serial.println();
    Serial.println("...disconnected.");
    Serial.println();
    
    client.stop();
  }
  
  // Update ThingSpeak
  if(!client.connected() && (millis() - lastConnectionTime > updateInterval))
  {
    updateThingSpeak("field1="+analogPin0);
  }
  
  lastConnected = client.connected();
}

void updateThingSpeak(String tsData)
{
  if (client.connect())
  { 
    Serial.println("Connected to ThingSpeak...");
    Serial.println();
        
    client.print("POST /update HTTP/1.1\n");
    client.print("Host: api.thingspeak.com\n");
    client.print("Connection: close\n");
    client.print("X-THINGSPEAKAPIKEY: "+writeAPIKey+"\n");
    client.print("Content-Type: application/x-www-form-urlencoded\n");
    client.print("Content-Length: ");
    client.print(tsData.length());
    client.print("\n\n");

    client.print(tsData);
    
    lastConnectionTime = millis();
    
    resetCounter = 0;
    
  }
  else
  {
    Serial.println("Connection Failed.");   
    Serial.println();
    
    resetCounter++;
    
    if (resetCounter >=5 ) {resetEthernetShield();}

    lastConnectionTime = millis(); 
  }
}

void resetEthernetShield()
{
  Serial.println("Resetting Ethernet Shield.");   
  Serial.println();
  
  client.stop();
  delay(1000);
  
  Ethernet.begin(mac, ip, gateway, subnet);
  delay(1000);
}

----------------------------------------------------------------------------

Controle Remoto - TV-B-Gone Arduino

2011-04-24T20:47:00.011-03:00

O projeto TV-B-Gone foi idealizado pela Adafruit e é vendido como um kit completo para montagem em casa, o objetivo é desligar qualquer TV que esteja atrapalhando seu almoço ou leitura em lugares públicos.

No kit original o processador utilizado é o ATtiny85, mas o projeto foi portado para a IDE arduino e para o processador ATMega 328 por Ken Shirriff em seu blog (informações e códigos no link).

O esquema de montagem é bastante simples e eu fiz um pequeno esquema que está abaixo:

Este fim de semana me diverti bastante perturbando os amigos e o pessoal em casa, o led ir tem que ser forte, usei um de 8 mm (tirado de um controle remoto velho) para ter um alcance maior. No esquema do autor você vai ver que é sugerido o uso de transistors para controlar até uma série de leds em linha e aumentar muito o alcance.

O projeto pode ser montado com uma placa arduino UNO ou outras clones, eu resolvi montar uma arduino na breadboard pequena para fazer um aparelho que pudesse esconder no bolso. A força vem de 3 pilhas AA ligadas diretamente na placa e colocadas em um container com liga e desliga incorporado. Não usei o botão de reset que tem no esquema acima. O bootloader foi carregado no chip usando o esquema arduino ISP.

.

TUIO E PROCESSING

2011-03-14T10:26:00.001-03:00

Estive fazendo alguns experimentos com o processing e a biblioteca TUIO, o tuio é um software que recnhece marcadores e tambem é usado para mesas multitoque. Para conhecer e baixar acesse http://www.tuio.org/.

No vídeo acima eu modifiquei o exemplo que vem com a biblioteca e criei um sketch com um fundo em jpg e duas imagens que são apresentadas na tela dependendo do marcador exibido na webcam.

Segue o código abaixo:

----------------------------------------------------------------------------------------

/*

    TUIO processing demo - part of the reacTIVision project

    http://reactivision.sourceforge.net/



Modificado por Miklos em 13/03/2011 - www.miklos.blog.br

*/



// we need to import the TUIO library

// and declare a TuioProcessing client variable

import TUIO.*;

TuioProcessing tuioClient;



// these are some helper variables which are used

// to create scalable graphical feedback

float cursor_size = 15;

float object_size = 120;

float table_size = 760;

float scale_factor = 1;

PFont font;

PImage bg;

PImage p0;

PImage p1;



void setup()

{

  

  size(800,600);

  bg = loadImage("fundo_teste.gif");

  p0 = loadImage("quad_teste.gif");

  p1 = loadImage("circ_teste.gif");

  

  //size(screen.width,screen.height);

 // size(640,480);

 // noStroke();

 // fill(0);

  

  loop();

  frameRate(30);

  //noLoop();

  

  hint(ENABLE_NATIVE_FONTS);

  font = createFont("Arial", 18);

  scale_factor = height/table_size;

  

  // we create an instance of the TuioProcessing client

  // since we add "this" class as an argument the TuioProcessing class expects

  // an implementation of the TUIO callback methods (see below)

  tuioClient  = new TuioProcessing(this);

}



// within the draw method we retrieve a Vector (List) of TuioObject and TuioCursor (polling)

// from the TuioProcessing client and then loop over both lists to draw the graphical feedback.

void draw()

{

  //background(255);

  background(bg);

  textFont(font,18*scale_factor);

  float obj_size = object_size*scale_factor; 

  float cur_size = cursor_size*scale_factor; 

   

  Vector tuioObjectList = tuioClient.getTuioObjects();

  for (int i=0;isize();i++) {

     TuioObject tobj = (TuioObject)tuioObjectList.elementAt(i);

      String simb = "" + tobj.getSymbolID();

     if( simb.equals("1") ){

     stroke(0);

     fill(0);

     pushMatrix();

     translate(tobj.getScreenX(width),tobj.getScreenY(height));

     rotate(tobj.getAngle());

    // rect(-obj_size/2,-obj_size/2,obj_size,obj_size);

     image(p0,-obj_size/2,-obj_size/2,obj_size,obj_size);

     popMatrix();

     fill(255);

     text(""+tobj.getSymbolID(), tobj.getScreenX(width), tobj.getScreenY(height));

     }

     if( simb.equals("2") ){

     stroke(0);

     fill(0);

     pushMatrix();

     translate(tobj.getScreenX(width),tobj.getScreenY(height));

     rotate(tobj.getAngle());

    // rect(-obj_size/2,-obj_size/2,obj_size,obj_size);

     image(p1,-obj_size/2,-obj_size/2,obj_size,obj_size);

     popMatrix();

     fill(255);

     text(""+tobj.getSymbolID(), tobj.getScreenX(width), tobj.getScreenY(height));

        } 

   }

/*  

   Vector tuioCursorList = tuioClient.getTuioCursors();

   for (int a=0;a

      TuioCursor tcur = (TuioCursor)tuioCursorList.elementAt(a);

      Vector pointList = tcur.getPath();

      

      if (pointList.size()>0) {

        stroke(0,0,255);

        TuioPoint start_point = (TuioPoint)pointList.firstElement();;

        for (int j=0;j

           TuioPoint end_point = (TuioPoint)pointList.elementAt(j);

           line(start_point.getScreenX(width),start_point.getScreenY(height),end_point.getScreenX(width),end_point.getScreenY(height));

           start_point = end_point;

        }

        

        stroke(192,192,192);

        fill(192,192,192);

        ellipse( tcur.getScreenX(width), tcur.getScreenY(height),cur_size,cur_size);

        fill(0);

        text(""+ tcur.getCursorID(),  tcur.getScreenX(width)-5,  tcur.getScreenY(height)+5);

      }

   }*/

   

}



// these callback methods are called whenever a TUIO event occurs



// called when an object is added to the scene

void addTuioObject(TuioObject tobj) {

  println("add object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+") "+tobj.getX()+" "+tobj.getY()+" "+tobj.getAngle());

}



// called when an object is removed from the scene

void removeTuioObject(TuioObject tobj) {

  println("remove object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+")");

}



// called when an object is moved

void updateTuioObject (TuioObject tobj) {

  println("update object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+") "+tobj.getX()+" "+tobj.getY()+" "+tobj.getAngle()

          +" "+tobj.getMotionSpeed()+" "+tobj.getRotationSpeed()+" "+tobj.getMotionAccel()+" "+tobj.getRotationAccel());

}



// called when a cursor is added to the scene

void addTuioCursor(TuioCursor tcur) {

  println("add cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+ ") " +tcur.getX()+" "+tcur.getY());

}



// called when a cursor is moved

void updateTuioCursor (TuioCursor tcur) {

  println("update cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+ ") " +tcur.getX()+" "+tcur.getY()

          +" "+tcur.getMotionSpeed()+" "+tcur.getMotionAccel());

}



// called when a cursor is removed from the scene

void removeTuioCursor(TuioCursor tcur) {

  println("remove cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+")");

}



// called after each message bundle

// representing the end of an image frame

void refresh(TuioTime bundleTime) { 

  redraw();

}

-----------------------------------------------------------------------

TRICOPTERO COM WII MOTION - MULTIWII

2011-01-28T17:41:00.003-02:00

Neste post estou iniciando as experiências com os multicópteros baseados na arduino. No vídeo acima e nas fotos está minha primeira tentativa, um tricóptero baseado na duemilenove e nos sensores do wii ( wii motion plus e nunchuck) o código é desenvolvido pela comunidade do site MultiWii e foi iniciado por Alexinparis no rcgroups.com. Foi a primeira tentativa e o primeiro acidente, vamos ver se consigo fazer ele voar de verdade...

FRAME DE MADEIRA E ALUMÍNIO

MECANISMO DE CONTROLE DE YAW

CENTRO COM A PLACA E SENSORES

O frame que eu fiz é bem caseiro mas estou animado pois está funcionando.... no início eu achei que era pesado e não ia voar mas como você pode ver no vídeo até levantou vôo ( e quase saiu pela janela). vou fazer novos vídeos dos testes de vôo e postar depois.

RELÓGIO ROLANTE COM MATRIZ 5X7 E RTC DS1307

2010-08-14T12:46:00.006-03:00

Retomando as postagens estou apresentando minha experiência com o chip DS1307 que é um relógio de tempo real. Este chip tem muitas funcionalidades em projetos com arduino como logar tempo e eventos. Neste post conectei o chip para gerar os dados de tempo e apresentá-los na matriz 5x7 que havia montado anteriormente.

Para ver o esquema da montagem da matriz 5x7 e outras informações importantes, use este link. Existe também um post com a matriz como termômetro usando o chip LM35 neste link.

O chip utilizado aqui é o modelo DS1307N que faz parte de uma linha de RTC da Maxim e suporta temperaturas abaixo de zero, exitem outros que só funcionam acima de 0 graus e outros com características como cristal embutido e etc.

Segue esquema de conexão com a arduino ( ATMEGA 328):

É importante conectar o pólo negativo da bateria ao terra do sistema vuntamente ao terra do chip, sem isso a leitura dos dados apresenta problemas.

Neste projeto o mais complicado foi conseguir uma forma de alojar todos os dados na memória do chip ATMEGA 328. Com as limitações que existem, é fácil obter os resultados mais estranhos quando a memória fica cheia. Para evitar isso é necessário usar a memória flash ao invés de utilizar a memória SRAM. Normalmente seria utilizado o comando PROGMEM.

O fato é que o comando PROGMEM é bem complicado e após pesquisar um pouco encontrei o seguinte link: Library to Ease Accessing Flash-based (PROGMEM) Data com uma biblioteca que facilita muito o uso do PROGMEM.

A partir dai consegui armazenar corretamente todos os arrays que formam cada um dos números que representam as leituras de tempo vindas do chip DS1307.

Segue o código (carregue neste link):

--------------------------------------------------------------------------------------------------------------------------------

/*

Claudio Miklos 25/07/2010 -  www.miklos.blog.br

62,65,65,65,62,     // O
0,0,33,127,1,       // 1
33,67,69,73,49,     // 2
34,65,73,73,54,     // 3
12,20,36,127,4,     // 4
114,81,81,81,78,    // 5
30,41,73,73,6,      // 6
64,71,72,80,96,     // 7
54,73,73,73,54,     // 8
48,73,73,74,60,     // 9
0,0,0,20,0,         // :
0,0,112,80,112,     // GRAU
0,0,0,0,0           // VAZIO

*/

#include "Wire.h"
#include "Flash.h"
#define DS1307_I2C_ADDRESS 0x68
int pin = 0;
int tempc = 0;
int tp=0;
int tt=0;
int colbin=0;
int latchpin = 8;
int clockpin = 7;
int datapin = 10;


//-------------------------------- FUNCOES RELOGIO------------------------------------

byte decToBcd(byte val)
{
   return ( (val/10*16) + (val%10) );
}
// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
   return ( (val/16*10) + (val%16) );
}
// 1) Sets the date and time on the ds1307
// 2) Starts the clock
// 3) Sets hour mode to 24 hour clock
// Assumes you're passing in valid numbers
void setDateDs1307(byte second,          // 0-59
byte minute,         // 0-59
byte hour,           // 1-23
byte dayOfWeek,      // 1-7
byte dayOfMonth,     // 1-28/29/30/31
byte month,          // 1-12
byte year)           // 0-99
{
   Wire.beginTransmission(DS1307_I2C_ADDRESS);
   Wire.send(0);
   Wire.send(decToBcd(second));     // 0 to bit 7 starts the clock
   Wire.send(decToBcd(minute));
   Wire.send(decToBcd(hour));
   Wire.send(decToBcd(dayOfWeek));
   Wire.send(decToBcd(dayOfMonth));
   Wire.send(decToBcd(month));
   Wire.send(decToBcd(year));
   Wire.send(0x10); // sends 0x10 (hex) 00010000 (binary) to control register - turns on square wave
   Wire.endTransmission();
}
// Gets the date and time from the ds1307
void getDateDs1307(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
   // Reset the register pointer
   Wire.beginTransmission(DS1307_I2C_ADDRESS);
   Wire.send(0);
   Wire.endTransmission();
   Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
   // A few of these need masks because certain bits are control bits
   *second     = bcdToDec(Wire.receive() & 0x7f);
   *minute     = bcdToDec(Wire.receive());
   *hour       = bcdToDec(Wire.receive() & 0x3f); // Need to change this if 12 hour am/pm
   *dayOfWeek  = bcdToDec(Wire.receive());
   *dayOfMonth = bcdToDec(Wire.receive());
   *month       = bcdToDec(Wire.receive());
   *year        = bcdToDec(Wire.receive());
}

//---------------------------TEMPERATURA-------------------------------


FLASH_ARRAY (int,t0,0,0,0,0,0,62,65,65,65,62,0,62,65,65,65,62,0,112,80,112,0);
FLASH_ARRAY (int,t1,0,0,0,0,0,62,65,65,65,62,0,33,127,1,0,112,80,112,0);
FLASH_ARRAY (int,t2,0,0,0,0,0,62,65,65,65,62,0,33,67,69,73,49,0,112,80,112,0);
FLASH_ARRAY (int,t3,0,0,0,0,0,62,65,65,65,62,0,34,65,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t4,0,0,0,0,0,62,65,65,65,62,0,12,20,36,127,4,0,112,80,112,0);
FLASH_ARRAY (int,t5,0,0,0,0,0,62,65,65,65,62,0,114,81,81,81,78,0,112,80,112,0);
FLASH_ARRAY (int,t6,0,0,0,0,0,62,65,65,65,62,0,30,41,73,73,6,0,112,80,112,0);
FLASH_ARRAY (int,t7,0,0,0,0,0,62,65,65,65,62,0,64,71,72,80,96,0,112,80,112,0);
FLASH_ARRAY (int,t8,0,0,0,0,0,62,65,65,65,62,0,54,73,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t9,0,0,0,0,0,62,65,65,65,62,0,48,73,73,74,60,0,112,80,112,0);

FLASH_ARRAY (int,t10,0,0,0,0,0,33,127,1,0,62,65,65,65,62,0,112,80,112,0);
FLASH_ARRAY (int,t11,0,0,0,0,0,33,127,1,0,0,0,0,33,127,1,0,112,80,112,0);
FLASH_ARRAY (int,t12,0,0,0,0,0,33,127,1,0,0,33,67,69,73,49,0,112,80,112,0);
FLASH_ARRAY (int,t13,0,0,0,0,0,33,127,1,0,34,65,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t14,0,0,0,0,0,33,127,1,0,12,20,36,127,4,0,112,80,112,0);
FLASH_ARRAY (int,t15,0,0,0,0,0,33,127,1,0,114,81,81,81,78,0,112,80,112,0);
FLASH_ARRAY (int,t16,0,0,0,0,0,33,127,1,0,30,41,73,73,6,0,112,80,112,0);
FLASH_ARRAY (int,t17,0,0,0,0,0,33,127,1,0,64,71,72,80,96,0,112,80,112,0);
FLASH_ARRAY (int,t18,0,0,0,0,0,33,127,1,0,54,73,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t19,0,0,0,0,0,33,127,1,0,48,73,73,74,60,0,112,80,112,0);

FLASH_ARRAY (int,t20,0,0,0,0,0,33,67,69,73,49,0,62,65,65,65,62,0,112,80,112,0);
FLASH_ARRAY (int,t21,0,0,0,0,0,33,67,69,73,49,0,0,33,127,1,0,112,80,112,0);
FLASH_ARRAY (int,t22,0,0,0,0,0,33,67,69,73,49,0,0,33,67,69,73,49,0,112,80,112,0);
FLASH_ARRAY (int,t23,0,0,0,0,0,33,67,69,73,49,0,34,65,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t24,0,0,0,0,0,33,67,69,73,49,0,12,20,36,127,4,0,112,80,112,0);
FLASH_ARRAY (int,t25,0,0,0,0,0,33,67,69,73,49,0,114,81,81,81,78,0,112,80,112,0);
FLASH_ARRAY (int,t26,0,0,0,0,0,33,67,69,73,49,0,30,41,73,73,6,0,112,80,112,0);
FLASH_ARRAY (int,t27,0,0,0,0,0,33,67,69,73,49,0,64,71,72,80,96,0,112,80,112,0);
FLASH_ARRAY (int,t28,0,0,0,0,0,33,67,69,73,49,0,54,73,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t29,0,0,0,0,0,33,67,69,73,49,0,48,73,73,74,60,0,112,80,112,0);

FLASH_ARRAY (int,t30,0,0,0,0,0,34,65,73,73,54,0,62,65,65,65,62,0,112,80,112,0);
FLASH_ARRAY (int,t31,0,0,0,0,0,34,65,73,73,54,0,0,33,127,1,0,112,80,112,0);
/*
FLASH_ARRAY (int,t32,0,0,0,0,0,34,65,73,73,54,0,0,33,67,69,73,49,0,112,80,112,0);
FLASH_ARRAY (int,t33,0,0,0,0,0,34,65,73,73,54,0,34,65,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t34,0,0,0,0,0,34,65,73,73,54,0,12,20,36,127,4,0,112,80,112,0);
FLASH_ARRAY (int,t35,0,0,0,0,0,34,65,73,73,54,0,114,81,81,81,78,0,112,80,112,0);
FLASH_ARRAY (int,t36,0,0,0,0,0,34,65,73,73,54,0,30,41,73,73,6,0,112,80,112,0);
FLASH_ARRAY (int,t37,0,0,0,0,0,34,65,73,73,54,0,64,71,72,80,96,0,112,80,112,0);
FLASH_ARRAY (int,t38,0,0,0,0,0,34,65,73,73,54,0,54,73,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t39,0,0,0,0,0,34,65,73,73,54,0,48,73,73,74,60,0,112,80,112,0);

FLASH_ARRAY (int,t40,0,0,0,0,0,12,20,36,127,4,0,62,65,65,65,62,0,112,80,112,0);
FLASH_ARRAY (int,t41,0,0,0,0,0,12,20,36,127,4,0,0,33,127,1,0,112,80,112,0);
FLASH_ARRAY (int,t42,0,0,0,0,0,12,20,36,127,4,0,0,33,67,69,73,49,0,112,80,112,0);
FLASH_ARRAY (int,t43,0,0,0,0,0,12,20,36,127,4,0,34,65,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t44,0,0,0,0,0,12,20,36,127,4,0,12,20,36,127,4,0,112,80,112,0);
FLASH_ARRAY (int,t45,0,0,0,0,0,12,20,36,127,4,0,114,81,81,81,78,0,112,80,112,0);
FLASH_ARRAY (int,t46,0,0,0,0,0,12,20,36,127,4,0,30,41,73,73,6,0,112,80,112,0);
FLASH_ARRAY (int,t47,0,0,0,0,0,12,20,36,127,4,0,64,71,72,80,96,0,112,80,112,0);
FLASH_ARRAY (int,t48,0,0,0,0,0,12,20,36,127,4,0,54,73,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t49,0,0,0,0,0,12,20,36,127,4,0,48,73,73,74,60,0,112,80,112,0);

FLASH_ARRAY (int,t50,0,0,0,0,0,114,81,81,81,78,0,62,65,65,65,62,0,112,80,112,0);
FLASH_ARRAY (int,t51,0,0,0,0,0,114,81,81,81,78,0,0,33,127,1,0,112,80,112,0);
FLASH_ARRAY (int,t52,0,0,0,0,0,114,81,81,81,78,0,0,33,67,69,73,49,0,112,80,112,0);
FLASH_ARRAY (int,t53,0,0,0,0,0,114,81,81,81,78,0,34,65,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t54,0,0,0,0,0,114,81,81,81,78,0,12,20,36,127,4,0,112,80,112,0);
FLASH_ARRAY (int,t55,0,0,0,0,0,114,81,81,81,78,0,114,81,81,81,78,0,112,80,112,0);
FLASH_ARRAY (int,t56,0,0,0,0,0,114,81,81,81,78,0,30,41,73,73,6,0,112,80,112,0);
FLASH_ARRAY (int,t57,0,0,0,0,0,114,81,81,81,78,0,64,71,72,80,96,0,112,80,112,0);
FLASH_ARRAY (int,t58,0,0,0,0,0,114,81,81,81,78,0,54,73,73,73,54,0,112,80,112,0);
FLASH_ARRAY (int,t59,0,0,0,0,0,114,81,81,81,78,0,48,73,73,74,60,0,112,80,112,0);
*/
//-------------------------------HORA--------------------------------------------

FLASH_ARRAY (int,h0,0,0,0,0,0,62,65,65,65,62,0,62,65,65,65,62,0,31,4,31,0);
FLASH_ARRAY (int,h1,0,0,0,0,0,62,65,65,65,62,0,33,127,1,0,31,4,31,0);
FLASH_ARRAY (int,h2,0,0,0,0,0,62,65,65,65,62,0,33,67,69,73,49,0,31,4,31,0);
FLASH_ARRAY (int,h3,0,0,0,0,0,62,65,65,65,62,0,34,65,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h4,0,0,0,0,0,62,65,65,65,62,0,12,20,36,127,4,0,31,4,31,0);
FLASH_ARRAY (int,h5,0,0,0,0,0,62,65,65,65,62,0,114,81,81,81,78,0,31,4,31,0);
FLASH_ARRAY (int,h6,0,0,0,0,0,62,65,65,65,62,0,30,41,73,73,6,0,31,4,31,0);
FLASH_ARRAY (int,h7,0,0,0,0,0,62,65,65,65,62,0,64,71,72,80,96,0,31,4,31,0);
FLASH_ARRAY (int,h8,0,0,0,0,0,62,65,65,65,62,0,54,73,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h9,0,0,0,0,0,62,65,65,65,62,0,48,73,73,74,60,0,31,4,31,0);

FLASH_ARRAY (int,h10,0,0,0,0,0,33,127,1,0,62,65,65,65,62,0,31,4,31,0);
FLASH_ARRAY (int,h11,0,0,0,0,0,33,127,1,0,0,0,0,33,127,1,0,31,4,31,0);
FLASH_ARRAY (int,h12,0,0,0,0,0,33,127,1,0,0,33,67,69,73,49,0,31,4,31,0);
FLASH_ARRAY (int,h13,0,0,0,0,0,33,127,1,0,34,65,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h14,0,0,0,0,0,33,127,1,0,12,20,36,127,4,0,31,4,31,0);
FLASH_ARRAY (int,h15,0,0,0,0,0,33,127,1,0,114,81,81,81,78,0,31,4,31,0);
FLASH_ARRAY (int,h16,0,0,0,0,0,33,127,1,0,30,41,73,73,6,0,31,4,31,0);
FLASH_ARRAY (int,h17,0,0,0,0,0,33,127,1,0,64,71,72,80,96,0,31,4,31,0);
FLASH_ARRAY (int,h18,0,0,0,0,0,33,127,1,0,54,73,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h19,0,0,0,0,0,33,127,1,0,48,73,73,74,60,0,31,4,31,0);

FLASH_ARRAY (int,h20,0,0,0,0,0,33,67,69,73,49,0,62,65,65,65,62,0,31,4,31,0);
FLASH_ARRAY (int,h21,0,0,0,0,0,33,67,69,73,49,0,0,33,127,1,0,31,4,31,0);
FLASH_ARRAY (int,h22,0,0,0,0,0,33,67,69,73,49,0,0,33,67,69,73,49,0,31,4,31,0);
FLASH_ARRAY (int,h23,0,0,0,0,0,33,67,69,73,49,0,34,65,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h24,0,0,0,0,0,33,67,69,73,49,0,12,20,36,127,4,0,31,4,31,0);
FLASH_ARRAY (int,h25,0,0,0,0,0,33,67,69,73,49,0,114,81,81,81,78,0,31,4,31,0);
FLASH_ARRAY (int,h26,0,0,0,0,0,33,67,69,73,49,0,30,41,73,73,6,0,31,4,31,0);
FLASH_ARRAY (int,h27,0,0,0,0,0,33,67,69,73,49,0,64,71,72,80,96,0,31,4,31,0);
FLASH_ARRAY (int,h28,0,0,0,0,0,33,67,69,73,49,0,54,73,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h29,0,0,0,0,0,33,67,69,73,49,0,48,73,73,74,60,0,31,4,31,0);

FLASH_ARRAY (int,h30,0,0,0,0,0,34,65,73,73,54,0,62,65,65,65,62,0,31,4,31,0);
FLASH_ARRAY (int,h31,0,0,0,0,0,34,65,73,73,54,0,0,33,127,1,0,31,4,31,0);
FLASH_ARRAY (int,h32,0,0,0,0,0,34,65,73,73,54,0,0,33,67,69,73,49,0,31,4,31,0);
FLASH_ARRAY (int,h33,0,0,0,0,0,34,65,73,73,54,0,34,65,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h34,0,0,0,0,0,34,65,73,73,54,0,12,20,36,127,4,0,31,4,31,0);
FLASH_ARRAY (int,h35,0,0,0,0,0,34,65,73,73,54,0,114,81,81,81,78,0,31,4,31,0);
FLASH_ARRAY (int,h36,0,0,0,0,0,34,65,73,73,54,0,30,41,73,73,6,0,31,4,31,0);
FLASH_ARRAY (int,h37,0,0,0,0,0,34,65,73,73,54,0,64,71,72,80,96,0,31,4,31,0);
FLASH_ARRAY (int,h38,0,0,0,0,0,34,65,73,73,54,0,54,73,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h39,0,0,0,0,0,34,65,73,73,54,0,48,73,73,74,60,0,31,4,31,0);

FLASH_ARRAY (int,h40,0,0,0,0,0,12,20,36,127,4,0,62,65,65,65,62,0,31,4,31,0);
FLASH_ARRAY (int,h41,0,0,0,0,0,12,20,36,127,4,0,0,33,127,1,0,31,4,31,0);
FLASH_ARRAY (int,h42,0,0,0,0,0,12,20,36,127,4,0,0,33,67,69,73,49,0,31,4,31,0);
FLASH_ARRAY (int,h43,0,0,0,0,0,12,20,36,127,4,0,34,65,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h44,0,0,0,0,0,12,20,36,127,4,0,12,20,36,127,4,0,31,4,31,0);
FLASH_ARRAY (int,h45,0,0,0,0,0,12,20,36,127,4,0,114,81,81,81,78,0,31,4,31,0);
FLASH_ARRAY (int,h46,0,0,0,0,0,12,20,36,127,4,0,30,41,73,73,6,0,31,4,31,0);
FLASH_ARRAY (int,h47,0,0,0,0,0,12,20,36,127,4,0,64,71,72,80,96,0,31,4,31,0);
FLASH_ARRAY (int,h48,0,0,0,0,0,12,20,36,127,4,0,54,73,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h49,0,0,0,0,0,12,20,36,127,4,0,48,73,73,74,60,0,31,4,31,0);

FLASH_ARRAY (int,h50,0,0,0,0,0,114,81,81,81,78,0,62,65,65,65,62,0,31,4,31,0);
FLASH_ARRAY (int,h51,0,0,0,0,0,114,81,81,81,78,0,0,33,127,1,0,31,4,31,0);
FLASH_ARRAY (int,h52,0,0,0,0,0,114,81,81,81,78,0,0,33,67,69,73,49,0,31,4,31,0);
FLASH_ARRAY (int,h53,0,0,0,0,0,114,81,81,81,78,0,34,65,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h54,0,0,0,0,0,114,81,81,81,78,0,12,20,36,127,4,0,31,4,31,0);
FLASH_ARRAY (int,h55,0,0,0,0,0,114,81,81,81,78,0,114,81,81,81,78,0,31,4,31,0);
FLASH_ARRAY (int,h56,0,0,0,0,0,114,81,81,81,78,0,30,41,73,73,6,0,31,4,31,0);
FLASH_ARRAY (int,h57,0,0,0,0,0,114,81,81,81,78,0,64,71,72,80,96,0,31,4,31,0);
FLASH_ARRAY (int,h58,0,0,0,0,0,114,81,81,81,78,0,54,73,73,73,54,0,31,4,31,0);
FLASH_ARRAY (int,h59,0,0,0,0,0,114,81,81,81,78,0,48,73,73,74,60,0,31,4,31,0);


//-------------------------------MINUTO--------------------------------------------

FLASH_ARRAY (int,m0,0,0,0,0,0,62,65,65,65,62,0,62,65,65,65,62,0,15,4,15,0);
FLASH_ARRAY (int,m1,0,0,0,0,0,62,65,65,65,62,0,33,127,1,0,15,4,15,0);
FLASH_ARRAY (int,m2,0,0,0,0,0,62,65,65,65,62,0,33,67,69,73,49,0,15,4,15,0);
FLASH_ARRAY (int,m3,0,0,0,0,0,62,65,65,65,62,0,34,65,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m4,0,0,0,0,0,62,65,65,65,62,0,12,20,36,127,4,0,15,4,15,0);
FLASH_ARRAY (int,m5,0,0,0,0,0,62,65,65,65,62,0,114,81,81,81,78,0,15,4,15,0);
FLASH_ARRAY (int,m6,0,0,0,0,0,62,65,65,65,62,0,30,41,73,73,6,0,15,4,15,0);
FLASH_ARRAY (int,m7,0,0,0,0,0,62,65,65,65,62,0,64,71,72,80,96,0,15,4,15,0);
FLASH_ARRAY (int,m8,0,0,0,0,0,62,65,65,65,62,0,54,73,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m9,0,0,0,0,0,62,65,65,65,62,0,48,73,73,74,60,0,15,4,15,0);

FLASH_ARRAY (int,m10,0,0,0,0,0,33,127,1,0,62,65,65,65,62,0,15,4,15,0);
FLASH_ARRAY (int,m11,0,0,0,0,0,33,127,1,0,0,0,0,33,127,1,0,15,4,15,0);
FLASH_ARRAY (int,m12,0,0,0,0,0,33,127,1,0,0,33,67,69,73,49,0,15,4,15,0);
FLASH_ARRAY (int,m13,0,0,0,0,0,33,127,1,0,34,65,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m14,0,0,0,0,0,33,127,1,0,12,20,36,127,4,0,15,4,15,0);
FLASH_ARRAY (int,m15,0,0,0,0,0,33,127,1,0,114,81,81,81,78,0,15,4,15,0);
FLASH_ARRAY (int,m16,0,0,0,0,0,33,127,1,0,30,41,73,73,6,0,15,4,15,0);
FLASH_ARRAY (int,m17,0,0,0,0,0,33,127,1,0,64,71,72,80,96,0,15,4,15,0);
FLASH_ARRAY (int,m18,0,0,0,0,0,33,127,1,0,54,73,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m19,0,0,0,0,0,33,127,1,0,48,73,73,74,60,0,15,4,15,0);

FLASH_ARRAY (int,m20,0,0,0,0,0,33,67,69,73,49,0,62,65,65,65,62,0,15,4,15,0);
FLASH_ARRAY (int,m21,0,0,0,0,0,33,67,69,73,49,0,0,33,127,1,0,15,4,15,0);
FLASH_ARRAY (int,m22,0,0,0,0,0,33,67,69,73,49,0,0,33,67,69,73,49,0,15,4,15,0);
FLASH_ARRAY (int,m23,0,0,0,0,0,33,67,69,73,49,0,34,65,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m24,0,0,0,0,0,33,67,69,73,49,0,12,20,36,127,4,0,15,4,15,0);
FLASH_ARRAY (int,m25,0,0,0,0,0,33,67,69,73,49,0,114,81,81,81,78,0,15,4,15,0);
FLASH_ARRAY (int,m26,0,0,0,0,0,33,67,69,73,49,0,30,41,73,73,6,0,15,4,15,0);
FLASH_ARRAY (int,m27,0,0,0,0,0,33,67,69,73,49,0,64,71,72,80,96,0,15,4,15,0);
FLASH_ARRAY (int,m28,0,0,0,0,0,33,67,69,73,49,0,54,73,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m29,0,0,0,0,0,33,67,69,73,49,0,48,73,73,74,60,0,15,4,15,0);

FLASH_ARRAY (int,m30,0,0,0,0,0,34,65,73,73,54,0,62,65,65,65,62,0,15,4,15,0);
FLASH_ARRAY (int,m31,0,0,0,0,0,34,65,73,73,54,0,0,33,127,1,0,15,4,15,0);
FLASH_ARRAY (int,m32,0,0,0,0,0,34,65,73,73,54,0,0,33,67,69,73,49,0,15,4,15,0);
FLASH_ARRAY (int,m33,0,0,0,0,0,34,65,73,73,54,0,34,65,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m34,0,0,0,0,0,34,65,73,73,54,0,12,20,36,127,4,0,15,4,15,0);
FLASH_ARRAY (int,m35,0,0,0,0,0,34,65,73,73,54,0,114,81,81,81,78,0,15,4,15,0);
FLASH_ARRAY (int,m36,0,0,0,0,0,34,65,73,73,54,0,30,41,73,73,6,0,15,4,15,0);
FLASH_ARRAY (int,m37,0,0,0,0,0,34,65,73,73,54,0,64,71,72,80,96,0,15,4,15,0);
FLASH_ARRAY (int,m38,0,0,0,0,0,34,65,73,73,54,0,54,73,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m39,0,0,0,0,0,34,65,73,73,54,0,48,73,73,74,60,0,15,4,15,0);

FLASH_ARRAY (int,m40,0,0,0,0,0,12,20,36,127,4,0,62,65,65,65,62,0,15,4,15,0);
FLASH_ARRAY (int,m41,0,0,0,0,0,12,20,36,127,4,0,0,33,127,1,0,15,4,15,0);
FLASH_ARRAY (int,m42,0,0,0,0,0,12,20,36,127,4,0,0,33,67,69,73,49,0,15,4,15,0);
FLASH_ARRAY (int,m43,0,0,0,0,0,12,20,36,127,4,0,34,65,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m44,0,0,0,0,0,12,20,36,127,4,0,12,20,36,127,4,0,15,4,15,0);
FLASH_ARRAY (int,m45,0,0,0,0,0,12,20,36,127,4,0,114,81,81,81,78,0,15,4,15,0);
FLASH_ARRAY (int,m46,0,0,0,0,0,12,20,36,127,4,0,30,41,73,73,6,0,15,4,15,0);
FLASH_ARRAY (int,m47,0,0,0,0,0,12,20,36,127,4,0,64,71,72,80,96,0,15,4,15,0);
FLASH_ARRAY (int,m48,0,0,0,0,0,12,20,36,127,4,0,54,73,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m49,0,0,0,0,0,12,20,36,127,4,0,48,73,73,74,60,0,15,4,15,0);

FLASH_ARRAY (int,m50,0,0,0,0,0,114,81,81,81,78,0,62,65,65,65,62,0,15,4,15,0);
FLASH_ARRAY (int,m51,0,0,0,0,0,114,81,81,81,78,0,0,33,127,1,0,15,4,15,0);
FLASH_ARRAY (int,m52,0,0,0,0,0,114,81,81,81,78,0,0,33,67,69,73,49,0,15,4,15,0);
FLASH_ARRAY (int,m53,0,0,0,0,0,114,81,81,81,78,0,34,65,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m54,0,0,0,0,0,114,81,81,81,78,0,12,20,36,127,4,0,15,4,15,0);
FLASH_ARRAY (int,m55,0,0,0,0,0,114,81,81,81,78,0,114,81,81,81,78,0,15,4,15,0);
FLASH_ARRAY (int,m56,0,0,0,0,0,114,81,81,81,78,0,30,41,73,73,6,0,15,4,15,0);
FLASH_ARRAY (int,m57,0,0,0,0,0,114,81,81,81,78,0,64,71,72,80,96,0,15,4,15,0);
FLASH_ARRAY (int,m58,0,0,0,0,0,114,81,81,81,78,0,54,73,73,73,54,0,15,4,15,0);
FLASH_ARRAY (int,m59,0,0,0,0,0,114,81,81,81,78,0,48,73,73,74,60,0,15,4,15,0);

//-----------------------------SEGUNDO---------------------------------------------

FLASH_ARRAY (int,s0,0,0,0,0,0,62,65,65,65,62,0,62,65,65,65,62,0,29,21,23,0);
FLASH_ARRAY (int,s1,0,0,0,0,0,62,65,65,65,62,0,33,127,1,0,29,21,23,0);
FLASH_ARRAY (int,s2,0,0,0,0,0,62,65,65,65,62,0,33,67,69,73,49,0,29,21,23,0);
FLASH_ARRAY (int,s3,0,0,0,0,0,62,65,65,65,62,0,34,65,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s4,0,0,0,0,0,62,65,65,65,62,0,12,20,36,127,4,0,29,21,23,0);
FLASH_ARRAY (int,s5,0,0,0,0,0,62,65,65,65,62,0,114,81,81,81,78,0,29,21,23,0);
FLASH_ARRAY (int,s6,0,0,0,0,0,62,65,65,65,62,0,30,41,73,73,6,0,29,21,23,0);
FLASH_ARRAY (int,s7,0,0,0,0,0,62,65,65,65,62,0,64,71,72,80,96,0,29,21,23,0);
FLASH_ARRAY (int,s8,0,0,0,0,0,62,65,65,65,62,0,54,73,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s9,0,0,0,0,0,62,65,65,65,62,0,48,73,73,74,60,0,29,21,23,0);

FLASH_ARRAY (int,s10,0,0,0,0,0,33,127,1,0,62,65,65,65,62,0,29,21,23,0);
FLASH_ARRAY (int,s11,0,0,0,0,0,33,127,1,0,0,0,0,33,127,1,0,29,21,23,0);
FLASH_ARRAY (int,s12,0,0,0,0,0,33,127,1,0,0,33,67,69,73,49,0,29,21,23,0);
FLASH_ARRAY (int,s13,0,0,0,0,0,33,127,1,0,34,65,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s14,0,0,0,0,0,33,127,1,0,12,20,36,127,4,0,29,21,23,0);
FLASH_ARRAY (int,s15,0,0,0,0,0,33,127,1,0,114,81,81,81,78,0,29,21,23,0);
FLASH_ARRAY (int,s16,0,0,0,0,0,33,127,1,0,30,41,73,73,6,0,29,21,23,0);
FLASH_ARRAY (int,s17,0,0,0,0,0,33,127,1,0,64,71,72,80,96,0,29,21,23,0);
FLASH_ARRAY (int,s18,0,0,0,0,0,33,127,1,0,54,73,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s19,0,0,0,0,0,33,127,1,0,48,73,73,74,60,0,29,21,23,0);

FLASH_ARRAY (int,s20,0,0,0,0,0,33,67,69,73,49,0,62,65,65,65,62,0,29,21,23,0);
FLASH_ARRAY (int,s21,0,0,0,0,0,33,67,69,73,49,0,0,33,127,1,0,29,21,23,0);
FLASH_ARRAY (int,s22,0,0,0,0,0,33,67,69,73,49,0,0,33,67,69,73,49,0,29,21,23,0);
FLASH_ARRAY (int,s23,0,0,0,0,0,33,67,69,73,49,0,34,65,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s24,0,0,0,0,0,33,67,69,73,49,0,12,20,36,127,4,0,29,21,23,0);
FLASH_ARRAY (int,s25,0,0,0,0,0,33,67,69,73,49,0,114,81,81,81,78,0,29,21,23,0);
FLASH_ARRAY (int,s26,0,0,0,0,0,33,67,69,73,49,0,30,41,73,73,6,0,29,21,23,0);
FLASH_ARRAY (int,s27,0,0,0,0,0,33,67,69,73,49,0,64,71,72,80,96,0,29,21,23,0);
FLASH_ARRAY (int,s28,0,0,0,0,0,33,67,69,73,49,0,54,73,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s29,0,0,0,0,0,33,67,69,73,49,0,48,73,73,74,60,0,29,21,23,0);

FLASH_ARRAY (int,s30,0,0,0,0,0,34,65,73,73,54,0,62,65,65,65,62,0,29,21,23,0);
FLASH_ARRAY (int,s31,0,0,0,0,0,34,65,73,73,54,0,0,33,127,1,0,29,21,23,0);
FLASH_ARRAY (int,s32,0,0,0,0,0,34,65,73,73,54,0,0,33,67,69,73,49,0,29,21,23,0);
FLASH_ARRAY (int,s33,0,0,0,0,0,34,65,73,73,54,0,34,65,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s34,0,0,0,0,0,34,65,73,73,54,0,12,20,36,127,4,0,29,21,23,0);
FLASH_ARRAY (int,s35,0,0,0,0,0,34,65,73,73,54,0,114,81,81,81,78,0,29,21,23,0);
FLASH_ARRAY (int,s36,0,0,0,0,0,34,65,73,73,54,0,30,41,73,73,6,0,29,21,23,0);
FLASH_ARRAY (int,s37,0,0,0,0,0,34,65,73,73,54,0,64,71,72,80,96,0,29,21,23,0);
FLASH_ARRAY (int,s38,0,0,0,0,0,34,65,73,73,54,0,54,73,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s39,0,0,0,0,0,34,65,73,73,54,0,48,73,73,74,60,0,29,21,23,0);

FLASH_ARRAY (int,s40,0,0,0,0,0,12,20,36,127,4,0,62,65,65,65,62,0,29,21,23,0);
FLASH_ARRAY (int,s41,0,0,0,0,0,12,20,36,127,4,0,0,33,127,1,0,29,21,23,0);
FLASH_ARRAY (int,s42,0,0,0,0,0,12,20,36,127,4,0,0,33,67,69,73,49,0,29,21,23,0);
FLASH_ARRAY (int,s43,0,0,0,0,0,12,20,36,127,4,0,34,65,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s44,0,0,0,0,0,12,20,36,127,4,0,12,20,36,127,4,0,29,21,23,0);
FLASH_ARRAY (int,s45,0,0,0,0,0,12,20,36,127,4,0,114,81,81,81,78,0,29,21,23,0);
FLASH_ARRAY (int,s46,0,0,0,0,0,12,20,36,127,4,0,30,41,73,73,6,0,29,21,23,0);
FLASH_ARRAY (int,s47,0,0,0,0,0,12,20,36,127,4,0,64,71,72,80,96,0,29,21,23,0);
FLASH_ARRAY (int,s48,0,0,0,0,0,12,20,36,127,4,0,54,73,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s49,0,0,0,0,0,12,20,36,127,4,0,48,73,73,74,60,0,29,21,23,0);

FLASH_ARRAY (int,s50,0,0,0,0,0,114,81,81,81,78,0,62,65,65,65,62,0,29,21,23,0);
FLASH_ARRAY (int,s51,0,0,0,0,0,114,81,81,81,78,0,0,33,127,1,0,29,21,23,0);
FLASH_ARRAY (int,s52,0,0,0,0,0,114,81,81,81,78,0,0,33,67,69,73,49,0,29,21,23,0);
FLASH_ARRAY (int,s53,0,0,0,0,0,114,81,81,81,78,0,34,65,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s54,0,0,0,0,0,114,81,81,81,78,0,12,20,36,127,4,0,29,21,23,0);
FLASH_ARRAY (int,s55,0,0,0,0,0,114,81,81,81,78,0,114,81,81,81,78,0,29,21,23,0);
FLASH_ARRAY (int,s56,0,0,0,0,0,114,81,81,81,78,0,30,41,73,73,6,0,29,21,23,0);
FLASH_ARRAY (int,s57,0,0,0,0,0,114,81,81,81,78,0,64,71,72,80,96,0,29,21,23,0);
FLASH_ARRAY (int,s58,0,0,0,0,0,114,81,81,81,78,0,54,73,73,73,54,0,29,21,23,0);
FLASH_ARRAY (int,s59,0,0,0,0,0,114,81,81,81,78,0,48,73,73,74,60,0,29,21,23,0);


//-----------------------------MOVE TEMPERATURA-----------------------------------------

/*

void movetemp(int duration)

{
  
tempc = ( 5.0 * analogRead(pin) * 100.0) / 1024.0;
tp = tempc;

  {

   for (int xx=0; xx<=25; xx++)
   
   {
      for (int dd=0; dd
      
      {
         for (int q=0; q<5; q++)
         
         {
           colbin=xx+q;
           
           switch(tp){
   case 0:
     columndisplay1(t0[colbin], q,0);
      break;
   case 1:
      columndisplay1(t1[colbin], q,0);
      break;
   case 2:
      columndisplay1(t2[colbin], q,0);
      break;
   case 3:
      columndisplay1(t3[colbin], q,0);
      break;
   case 4:
      columndisplay1(t4[colbin], q,0);
      break;
   case 5:
      columndisplay1(t5[colbin], q,0);
      break;
   case 6:
      columndisplay1(t6[colbin], q,0);
      break;
   case 7:
     columndisplay1(t7[colbin], q,0);
      break;
   case 8:
      columndisplay1(t8[colbin], q,0);
      break;
   case 9:
      columndisplay1(t9[colbin], q,0);
      break;
   case 10:
      columndisplay1(t10[colbin], q,0);
      break;
   case 11:
      columndisplay1(t11[colbin], q,0);
      break;
   case 12:
      columndisplay1(t12[colbin], q,0);
      break;
   case 13:
      columndisplay1(t13[colbin], q,0);
      break;
   case 14:
      columndisplay1(t14[colbin], q,0);
      break;
   case 15:
      columndisplay1(t15[colbin], q,0);
      break;
   case 16:
     columndisplay1(t16[colbin], q,0);
      break;
   case 17:
      columndisplay1(t17[colbin], q,0);
      break;
   case 18:
      columndisplay1(t18[colbin], q,0);
      break;
   case 19:
      columndisplay1(t19[colbin], q,0);
      break;
   case 20:
      columndisplay1(t20[colbin], q,0);
      break;
   case 21:
      columndisplay1(t21[colbin], q,0);
      break;
   case 22:
      columndisplay1(t22[colbin], q,0);
      break;
   case 23:
     columndisplay1(t23[colbin], q,0);
      break;
   case 24:
      columndisplay1(t24[colbin], q,0);
      break;
   case 25:
      columndisplay1(t25[colbin], q,0);
      break;
   case 26:
      columndisplay1(t26[colbin], q,0);
      break;
   case 27:
      columndisplay1(t27[colbin], q,0);
      break;
   case 28:
      columndisplay1(t28[colbin], q,0);
      break;
   case 29:
      columndisplay1(t29[colbin], q,0);
      break;
   case 30:
     columndisplay1(t30[colbin], q,0);
      break; 
   case 31:
      columndisplay1(t31[colbin], q,0);
      break;
   }
         }
      }
   }
}
}

void columndisplay(int coldata, int column, int holdtime)

{
   int matrixcolumn[5] = {
     1,2,4,8,16};
   digitalWrite(latchpin, LOW);
   shiftOut(datapin, clockpin, MSBFIRST, matrixcolumn[column]);
   shiftOut(datapin, clockpin, MSBFIRST, coldata);
   digitalWrite(latchpin, HIGH);
   delay(holdtime);
}

*/

//-------------------------------------------------MOVE HORA-----------------------------------------------------------------------------//

void movehora(int duration)

{
 
   byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
   getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
   // tt = (minute, DEC);
    tt = hour;
    
  {

   for (int xx=0; xx<=18; xx++)
   
   {
      for (int dd=0; ddfor (int q=0; q<5; q++)
         
         {
           colbin=xx+q;
           
            switch(tt){
   case 0:
     columndisplay1(h0[colbin], q,0);
      break;
   case 1:
      columndisplay1(h1[colbin], q,0);
      break;
   case 2:
      columndisplay1(h2[colbin], q,0);
      break;
   case 3:
      columndisplay1(h3[colbin], q,0);
      break;
   case 4:
      columndisplay1(h4[colbin], q,0);
      break;
   case 5:
      columndisplay1(h5[colbin], q,0);
      break;
   case 6:
      columndisplay1(h6[colbin], q,0);
      break;
   case 7:
     columndisplay1(h7[colbin], q,0);
      break;
   case 8:
      columndisplay1(h8[colbin], q,0);
      break;
   case 9:
      columndisplay1(h9[colbin], q,0);
      break;
   case 10:
      columndisplay1(h10[colbin], q,0);
      break;
   case 11:
      columndisplay1(h11[colbin], q,0);
      break;
   case 12:
      columndisplay1(h12[colbin], q,0);
      break;
   case 13:
      columndisplay1(h13[colbin], q,0);
      break;
   case 14:
      columndisplay1(h14[colbin], q,0);
      break;
   case 15:
      columndisplay1(h15[colbin], q,0);
      break;
   case 16:
     columndisplay1(h16[colbin], q,0);
      break;
   case 17:
      columndisplay1(h17[colbin], q,0);
      break;
   case 18:
      columndisplay1(h18[colbin], q,0);
      break;
   case 19:
      columndisplay1(h19[colbin], q,0);
      break;
   case 20:
      columndisplay1(h20[colbin], q,0);
      break;
   case 21:
      columndisplay1(h21[colbin], q,0);
      break;
   case 22:
      columndisplay1(h22[colbin], q,0);
      break;
   case 23:
     columndisplay1(h23[colbin], q,0);
      break;
   case 24:
      columndisplay1(h24[colbin], q,0);
      break;
   case 25:
      columndisplay1(h25[colbin], q,0);
      break;
   case 26:
      columndisplay1(h26[colbin], q,0);
      break;
   case 27:
      columndisplay1(h27[colbin], q,0);
      break;
   case 28:
      columndisplay1(h28[colbin], q,0);
      break;
   case 29:
      columndisplay1(h29[colbin], q,0);
      break;
   case 30:
     columndisplay1(h30[colbin], q,0);
      break; 
   case 31:
      columndisplay1(h31[colbin], q,0);
      break;
   case 32:
      columndisplay1(h32[colbin], q,0);
      break;
   case 33:
      columndisplay1(h33[colbin], q,0);
      break;
   case 34:
      columndisplay1(h34[colbin], q,0);
      break;
   case 35:
      columndisplay1(h35[colbin], q,0);
      break;
   case 36:
      columndisplay1(h36[colbin], q,0);
      break;
   case 37:
      columndisplay1(h37[colbin], q,0);
      break;
   case 38:
      columndisplay1(h38[colbin], q,0);
      break;
   case 39:
     columndisplay1(h39[colbin], q,0);
      break;
   case 40:
      columndisplay1(h40[colbin], q,0);
      break; 
   case 41:
      columndisplay1(h41[colbin], q,0);
      break;
   case 42:
      columndisplay1(h42[colbin], q,0);
      break;
   case 43:
      columndisplay1(h43[colbin], q,0);
      break;
   case 44:
      columndisplay1(h44[colbin], q,0);
      break;
   case 45:
      columndisplay1(h45[colbin], q,0);
      break;
   case 46:
      columndisplay1(h46[colbin], q,0);
      break;
   case 47:
     columndisplay1(h47[colbin], q,0);
      break;
   case 48:
      columndisplay1(h48[colbin], q,0);
      break;
   case 49:
      columndisplay1(h49[colbin], q,0);
      break;
   case 50:
      columndisplay1(h50[colbin], q,0);
      break;
   case 51:
      columndisplay1(h51[colbin], q,0);
      break;
   case 52:
      columndisplay1(h52[colbin], q,0);
      break;
   case 53:
      columndisplay1(h53[colbin], q,0);
      break;
   case 54:
      columndisplay1(h54[colbin], q,0);
      break;
   case 55:
      columndisplay1(h55[colbin], q,0);
      break;
   case 56:
     columndisplay1(h56[colbin], q,0);
      break;
   case 57:
      columndisplay1(h57[colbin], q,0);
      break;
   case 58:
      columndisplay1(h58[colbin], q,0);
      break;
   case 59:
      columndisplay1(h59[colbin], q,0);
      break;
   }
         }
      }
   }
}
}

void columndisplay1(int coldata, int column, int holdtime)

{
   int matrixcolumn[5] = {
     1,2,4,8,16};
   digitalWrite(latchpin, LOW);
   shiftOut(datapin, clockpin, MSBFIRST, matrixcolumn[column]);
   shiftOut(datapin, clockpin, MSBFIRST, coldata);
   digitalWrite(latchpin, HIGH);
   delay(holdtime);
}


//-------------------------------------------------MOVE MINUTO-----------------------------------------------------------------------------//

void movemin(int duration)

{
 
   byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
   getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
   // tt = (minute, DEC);
    tt = minute;
    
   {

   for (int xx=0; xx<=18; xx++)
   
   {
      for (int dd=0; ddfor (int q=0; q<5; q++)
         
         {
           colbin=xx+q;
           
            switch(tt){
   case 0:
     columndisplay1(m0[colbin], q,0);
      break;
   case 1:
      columndisplay1(m1[colbin], q,0);
      break;
   case 2:
      columndisplay1(m2[colbin], q,0);
      break;
   case 3:
      columndisplay1(m3[colbin], q,0);
      break;
   case 4:
      columndisplay1(m4[colbin], q,0);
      break;
   case 5:
      columndisplay1(m5[colbin], q,0);
      break;
   case 6:
      columndisplay1(m6[colbin], q,0);
      break;
   case 7:
     columndisplay1(m7[colbin], q,0);
      break;
   case 8:
      columndisplay1(m8[colbin], q,0);
      break;
   case 9:
      columndisplay1(m9[colbin], q,0);
      break;
   case 10:
      columndisplay1(m10[colbin], q,0);
      break;
   case 11:
      columndisplay1(m11[colbin], q,0);
      break;
   case 12:
      columndisplay1(m12[colbin], q,0);
      break;
   case 13:
      columndisplay1(m13[colbin], q,0);
      break;
   case 14:
      columndisplay1(m14[colbin], q,0);
      break;
   case 15:
      columndisplay1(m15[colbin], q,0);
      break;
   case 16:
     columndisplay1(m16[colbin], q,0);
      break;
   case 17:
      columndisplay1(m17[colbin], q,0);
      break;
   case 18:
      columndisplay1(m18[colbin], q,0);
      break;
   case 19:
      columndisplay1(m19[colbin], q,0);
      break;
   case 20:
      columndisplay1(m20[colbin], q,0);
      break;
   case 21:
      columndisplay1(m21[colbin], q,0);
      break;
   case 22:
      columndisplay1(m22[colbin], q,0);
      break;
   case 23:
     columndisplay1(m23[colbin], q,0);
      break;
   case 24:
      columndisplay1(m24[colbin], q,0);
      break;
   case 25:
      columndisplay1(m25[colbin], q,0);
      break;
   case 26:
      columndisplay1(m26[colbin], q,0);
      break;
   case 27:
      columndisplay1(m27[colbin], q,0);
      break;
   case 28:
      columndisplay1(m28[colbin], q,0);
      break;
   case 29:
      columndisplay1(m29[colbin], q,0);
      break;
   case 30:
     columndisplay1(m30[colbin], q,0);
      break; 
   case 31:
      columndisplay1(m31[colbin], q,0);
      break;
   case 32:
      columndisplay1(m32[colbin], q,0);
      break;
   case 33:
      columndisplay1(m33[colbin], q,0);
      break;
   case 34:
      columndisplay1(m34[colbin], q,0);
      break;
   case 35:
      columndisplay1(m35[colbin], q,0);
      break;
   case 36:
      columndisplay1(m36[colbin], q,0);
      break;
   case 37:
      columndisplay1(m37[colbin], q,0);
      break;
   case 38:
      columndisplay1(m38[colbin], q,0);
      break;
   case 39:
     columndisplay1(m39[colbin], q,0);
      break;
   case 40:
      columndisplay1(m40[colbin], q,0);
      break; 
   case 41:
      columndisplay1(m41[colbin], q,0);
      break;
   case 42:
      columndisplay1(m42[colbin], q,0);
      break;
   case 43:
      columndisplay1(m43[colbin], q,0);
      break;
   case 44:
      columndisplay1(m44[colbin], q,0);
      break;
   case 45:
      columndisplay1(m45[colbin], q,0);
      break;
   case 46:
      columndisplay1(m46[colbin], q,0);
      break;
   case 47:
     columndisplay1(m47[colbin], q,0);
      break;
   case 48:
      columndisplay1(m48[colbin], q,0);
      break;
   case 49:
      columndisplay1(m49[colbin], q,0);
      break;
   case 50:
      columndisplay1(m50[colbin], q,0);
      break;
   case 51:
      columndisplay1(m51[colbin], q,0);
      break;
   case 52:
      columndisplay1(m52[colbin], q,0);
      break;
   case 53:
      columndisplay1(m53[colbin], q,0);
      break;
   case 54:
      columndisplay1(m54[colbin], q,0);
      break;
   case 55:
      columndisplay1(m55[colbin], q,0);
      break;
   case 56:
     columndisplay1(m56[colbin], q,0);
      break;
   case 57:
      columndisplay1(m57[colbin], q,0);
      break;
   case 58:
      columndisplay1(m58[colbin], q,0);
      break;
   case 59:
      columndisplay1(m59[colbin], q,0);
      break;
   }
         }
      }
   }
}
}

void columndisplay2(int coldata, int column, int holdtime)

{
   int matrixcolumn[5] = {
     1,2,4,8,16};
   digitalWrite(latchpin, LOW);
   shiftOut(datapin, clockpin, MSBFIRST, matrixcolumn[column]);
   shiftOut(datapin, clockpin, MSBFIRST, coldata);
   digitalWrite(latchpin, HIGH);
   delay(holdtime);
}

//----------------------------------------SEGUNDOS-----------------------------------------------------------------------------------------


void moveseg(int duration)

{
 
   byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
   getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
   // tt = (minute, DEC);
    tt = second;
    
   {

   for (int xx=0; xx<=18; xx++)
   
   {
      for (int dd=0; ddfor (int q=0; q<5; q++)
         
         {
           colbin=xx+q;
           
            switch(tt){
   case 0:
     columndisplay1(s0[colbin], q,0);
      break;
   case 1:
      columndisplay1(s1[colbin], q,0);
      break;
   case 2:
      columndisplay1(s2[colbin], q,0);
      break;
   case 3:
      columndisplay1(s3[colbin], q,0);
      break;
   case 4:
      columndisplay1(s4[colbin], q,0);
      break;
   case 5:
      columndisplay1(s5[colbin], q,0);
      break;
   case 6:
      columndisplay1(s6[colbin], q,0);
      break;
   case 7:
     columndisplay1(s7[colbin], q,0);
      break;
   case 8:
      columndisplay1(s8[colbin], q,0);
      break;
   case 9:
      columndisplay1(s9[colbin], q,0);
      break;
   case 10:
      columndisplay1(s10[colbin], q,0);
      break;
   case 11:
      columndisplay1(s11[colbin], q,0);
      break;
   case 12:
      columndisplay1(s12[colbin], q,0);
      break;
   case 13:
      columndisplay1(s13[colbin], q,0);
      break;
   case 14:
      columndisplay1(s14[colbin], q,0);
      break;
   case 15:
      columndisplay1(s15[colbin], q,0);
      break;
   case 16:
     columndisplay1(s16[colbin], q,0);
      break;
   case 17:
      columndisplay1(s17[colbin], q,0);
      break;
   case 18:
      columndisplay1(s18[colbin], q,0);
      break;
   case 19:
      columndisplay1(s19[colbin], q,0);
      break;
   case 20:
      columndisplay1(s20[colbin], q,0);
      break;
   case 21:
      columndisplay1(s21[colbin], q,0);
      break;
   case 22:
      columndisplay1(s22[colbin], q,0);
      break;
   case 23:
     columndisplay1(s23[colbin], q,0);
      break;
   case 24:
      columndisplay1(s24[colbin], q,0);
      break;
   case 25:
      columndisplay1(s25[colbin], q,0);
      break;
   case 26:
      columndisplay1(s26[colbin], q,0);
      break;
   case 27:
      columndisplay1(s27[colbin], q,0);
      break;
   case 28:
      columndisplay1(s28[colbin], q,0);
      break;
   case 29:
      columndisplay1(s29[colbin], q,0);
      break;
   case 30:
     columndisplay1(s30[colbin], q,0);
      break; 
   case 31:
      columndisplay1(s31[colbin], q,0);
      break;
   case 32:
      columndisplay1(s32[colbin], q,0);
      break;
   case 33:
      columndisplay1(s33[colbin], q,0);
      break;
   case 34:
      columndisplay1(s34[colbin], q,0);
      break;
   case 35:
      columndisplay1(s35[colbin], q,0);
      break;
   case 36:
      columndisplay1(s36[colbin], q,0);
      break;
   case 37:
      columndisplay1(s37[colbin], q,0);
      break;
   case 38:
      columndisplay1(s38[colbin], q,0);
      break;
   case 39:
     columndisplay1(s39[colbin], q,0);
      break;
   case 40:
      columndisplay1(s40[colbin], q,0);
      break; 
   case 41:
      columndisplay1(s41[colbin], q,0);
      break;
   case 42:
      columndisplay1(s42[colbin], q,0);
      break;
   case 43:
      columndisplay1(s43[colbin], q,0);
      break;
   case 44:
      columndisplay1(s44[colbin], q,0);
      break;
   case 45:
      columndisplay1(s45[colbin], q,0);
      break;
   case 46:
      columndisplay1(s46[colbin], q,0);
      break;
   case 47:
     columndisplay1(s47[colbin], q,0);
      break;
   case 48:
      columndisplay1(s48[colbin], q,0);
      break;
   case 49:
      columndisplay1(s49[colbin], q,0);
      break;
   case 50:
      columndisplay1(s50[colbin], q,0);
      break;
   case 51:
      columndisplay1(s51[colbin], q,0);
      break;
   case 52:
      columndisplay1(s52[colbin], q,0);
      break;
   case 53:
      columndisplay1(s53[colbin], q,0);
      break;
   case 54:
      columndisplay1(s54[colbin], q,0);
      break;
   case 55:
      columndisplay1(s55[colbin], q,0);
      break;
   case 56:
     columndisplay1(s56[colbin], q,0);
      break;
   case 57:
      columndisplay1(s57[colbin], q,0);
      break;
   case 58:
      columndisplay1(s58[colbin], q,0);
      break;
   case 59:
      columndisplay1(s59[colbin], q,0);
      break;
   }
         }
      }
   }
}
}

void columndisplay3(int coldata, int column, int holdtime)

{
   int matrixcolumn[5] = {
     1,2,4,8,16};
   digitalWrite(latchpin, LOW);
   shiftOut(datapin, clockpin, MSBFIRST, matrixcolumn[column]);
   shiftOut(datapin, clockpin, MSBFIRST, coldata);
   digitalWrite(latchpin, HIGH);
   delay(holdtime);
}




//----------------------------------------------------------------------------------------------------------------------------------------//



void setup()

{
   byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
   Wire.begin();
   Serial.begin(9600);
   second = 0;
   minute = 0;
   hour = 12;
   dayOfWeek = 3;
   dayOfMonth = 10;
   month = 8;
   year = 10;
   //setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
   pinMode(latchpin, OUTPUT);
   pinMode(clockpin, OUTPUT);
   pinMode(datapin, OUTPUT);  
}

void loop()

{
   
   movehora(20);
   movemin(20);
   moveseg(20);
   // movetemp(20);
 //Serial.print(tt);
 //delay(1000);

}

------------------------------------------------------------------------------------------

Como poderão ver no código existe também a opção de apresentar a temperatura com o uso do chip LM35, neste post eu comentei esta opção para apresentar somente o horário. No momento de apresentar a temperatura existe algum problema que causa confusão na animação da matriz, alguns dos leds se acendem em momentos aleatórios...caso algum dos leitores saiba como resolver por favor me informe.

Como sempre aviso nestes posts, meu código é feito por experimemnação e por isso está longe de ser perfeito ou mesmo razoável. Espero sempre sugetões e correções de outros usuários de arduino.

Pesquisas:

http://pdfserv.maxim-ic.com/en/ds/DS1307.pdf

http://isomk.sdf.org/arduino.html

http://www.newark.com/maxim-integrated-products/ds1307n/ic-rtc-yy-mm-dd-56-x-8-dip-8/dp/60K9237

http://extremeelectronics.co.in/avr-tutorials/interfacing-ds1307-rtc-chip-with-avr-microcontroller/

http://lusorobotica.com/index.php/topic,681.0.html

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1235070596

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1264025351

http://www.sullivan-county.com/ele/arduino_ds1307.htm

http://lusorobotica.com/index.php?topic=681.0

http://www.sparkfun.com/commerce/product_info.php?products_id=99

http://www.glacialwanderer.com/hobbyrobotics/?p=12

http://scratchpad.thisandthose.org/scratchpad/article.php?story=20100126164621223

TERMOMETRO ROLANTE COM MATRIZ 5X7 E LM35

2010-07-30T17:33:00.006-03:00

Neste post continuo com as experiencias com a matriz 5x7 mas desta vez resolvi dar um toque extra usando o setup já montado para exibir a temperatura ambiente com um termometro LM35. O chip LM35 é muito simples de usar e preciso é conectado em uma porta analógica da arduino.

Segue abaixo a ilustração desta montagem:

A explicação sobre a conexão dos shift registers e matriz está nesta página e sobre a conexão do LM35 está nesta página, neste vou somente postar o novo código que montei para calcular a temperatura e apresentar na matriz.

O código abaixo funciona baseado na mudança dos caracteres representados matriz sempre que o termometro informar uma mudança de temperatura, estou utilizando um array (caracts) que contém os nomes dos arrays dos caracteres (t0 a t31) no qual a posição de cada array é exatamente igual ao número obtido com a leitura do termometro. Se tenho 24 graus na leitura do termometro, a posição de número 24 no array geral é o nome do array de caracteres que vai ser carregado na variável (tp)que determina a representação na matriz.

Só fiz as temperaturas de 0 até 31 graus porque se estiver mais ou menos que isto provavelmente não vou querer ficar sabendo....

Segue o código:

----------------------------------------------------------------------------------------

/*

Claudio Miklos 25/07/2010 -  www.miklos.blog.br

62,65,65,65,62,     // O
0,0,33,127,1,       // 1
33,67,69,73,49,     // 2
34,65,73,73,54,     // 3
12,20,36,127,4,     // 4
114,81,81,81,78,    // 5
30,41,73,73,6,      // 6
64,71,72,80,96,     // 7
54,73,73,73,54,     // 8
48,73,73,74,60,     // 9
0,0,112,80,112,     // GRAU
0,0,0,0,0           // VAZIO

*/

int pin = 0;
int tempc = 0;
int i=0;
int tp=0;
int latchpin = 8;
int clockpin = 7;
int datapin = 10;
int t0[] = {0,0,0,0,0,0,62,65,65,65,62,0,112,80,112,0,0,0,0,0};
int t1[] = {0,0,0,0,0,0,0,33,127,1,0,112,80,112,0,0,0,0,0};
int t2[] = {0,0,0,0,0,0,0,33,67,69,73,49,0,112,80,112,0,0,0,0,0};
int t3[] = {0,0,0,0,0,0,34,65,73,73,54,0,112,80,112,0,0,0,0,0};
int t4[] = {0,0,0,0,0,0,12,20,36,127,4,0,112,80,112,0,0,0,0,0};
int t5[] = {0,0,0,0,0,0,114,81,81,81,78,0,112,80,112,0,0,0,0,0};
int t6[] = {0,0,0,0,0,0,30,41,73,73,6,0,112,80,112,0,0,0,0,0};
int t7[] = {0,0,0,0,0,0,64,71,72,80,96, 0,112,80,112,0,0,0,0,0};
int t8[] = {0,0,0,0,0,0,54,73,73,73,54, 0,112,80,112,0,0,0,0,0};
int t9[] = {0,0,0,0,0,0,48,73,73,74,60,0,112,80,112,0,0,0,0,0};
int t10[] = {0,0,0,0,0,0,0,0,33,127,1,0,62,65,65,65,62,0,112,80,112,0,0,0,0,0};
int t11[] = {0,0,0,0,0,0,0,0,33,127,1,0,0,0,0,33,127,1,0,112,80,112,0,0,0,0,0};
int t12[] = {0,0,0,0,0,0,0,0,33,127,1,0,0,33,67,69,73,49,0,112,80,112,0,0,0,0,0};
int t13[] = {0,0,0,0,0,0,0,0,33,127,1,0,34,65,73,73,54,0,112,80,112,0,0,0,0,0};
int t14[] = {0,0,0,0,0,0,0,0,33,127,1,0,12,20,36,127,4,0,112,80,112,0,0,0,0,0};
int t15[] = {0,0,0,0,0,0,0,0,33,127,1,0,114,81,81,81,78,0,112,80,112,0,0,0,0,0};
int t16[] = {0,0,0,0,0,0,0,0,33,127,1,0,30,41,73,73,6,0,112,80,112,0,0,0,0,0};
int t17[] = {0,0,0,0,0,0,0,0,33,127,1,0,64,71,72,80,96,0,112,80,112,0,0,0,0,0};
int t18[] = {0,0,0,0,0,0,0,0,33,127,1,0,54,73,73,73,54,0,112,80,112,0,0,0,0,0};
int t19[] = {0,0,0,0,0,0,0,0,33,127,1,0,48,73,73,74,60,0,112,80,112,0,0,0,0,0};
int t20[] = {0,0,0,0,0,0,0,0,33,67,69,73,49,0,62,65,65,65,62,0,112,80,112,0,0,0,0,0};
int t21[] = {0,0,0,0,0,0,0,0,33,67,69,73,49,0,0,33,127,1,0,112,80,112,0,0,0,0,0};
int t22[] = {0,0,0,0,0,0,0,0,33,67,69,73,49,0,0,33,67,69,73,49,0,112,80,112,0,0,0,0,0};
int t23[] = {0,0,0,0,0,0,0,0,33,67,69,73,49,0,34,65,73,73,54,0,112,80,112,0,0,0,0,0};
int t24[] = {0,0,0,0,0,0,0,0,33,67,69,73,49,0,12,20,36,127,4,0,112,80,112,0,0,0,0,0};
int t25[] = {0,0,0,0,0,0,0,0,33,67,69,73,49,0,114,81,81,81,78,0,112,80,112,0,0,0,0,0};
int t26[] = {0,0,0,0,0,0,0,0,33,67,69,73,49,0,30,41,73,73,6,0,112,80,112,0,0,0,0,0};
int t27[] = {0,0,0,0,0,0,0,0,33,67,69,73,49,0,64,71,72,80,96,0,112,80,112,0,0,0,0,0};
int t28[] = {0,0,0,0,0,0,0,0,33,67,69,73,49,0,54,73,73,73,54,0,112,80,112,0,0,0,0,0};
int t29[] = {0,0,0,0,0,0,0,0,33,67,69,73,49,0,48,73,73,74,60,0,112,80,112,0,0,0,0,0};
int t30[] = {0,0,0,0,0,0,0,34,65,73,73,54,0,62,65,65,65,62,0,112,80,112,0,0,0,0,0};
int t31[] = {0,0,0,0,0,0,0,34,65,73,73,54,0,0,33,127,1,0,112,80,112,0,0,0,0,0};
int* caracts[] = {t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19,t20,t21,t22,t23,t24,t25,t26,t27,t28,t29,t30,t31};

void setup()

{
   Serial.begin(9600);
   pinMode(latchpin, OUTPUT);
   pinMode(clockpin, OUTPUT);
   pinMode(datapin, OUTPUT);
}

void movealienfromleft(int duration)

{
  {
 
    for(i = 0;i <= 7;i++)
 
  {

    tempc = ( 5.0 * analogRead(pin) * 100.0) / 1024.0;
    tp = tempc;
    
   }

   int colbin=0;
   for (int xx=0; xx<=23; xx++)
   
   {
      for (int dd=0; ddfor (int q=0; q<5; q++)
         
         {
           colbin=(xx*1)+q;
           
           columndisplay(caracts[tp][colbin], q,0);
         }
      }
   }
}
}

void columndisplay(int coldata, int column, int holdtime)

{
   int matrixcolumn[5] = {
     1,2,4,8,16};
   digitalWrite(latchpin, LOW);
   shiftOut(datapin, clockpin, MSBFIRST, matrixcolumn[column]);
   shiftOut(datapin, clockpin, MSBFIRST, coldata);
   digitalWrite(latchpin, HIGH);
   delay(holdtime);
}


void loop()

{
   movealienfromleft(30);
   //Serial.print(tp,DEC);
}

------------------------------------------------------------------------------------------

Espero que seja útil e aguardo os comentários e sugestões, estou começando na programação com aduino e meu código certamente não deve estar na melhor forma.

As referências utilizadas foram:

http://www.danielandrade.net/2008/07/05/temperature-sensor-arduino/

http://tronixstuff.wordpress.com/2010/06/06/getting-started-with-arduino-%E2%80%93-chapter-nine/

125Khz RFID module - UART - RDM 630

2010-06-29T19:57:00.013-03:00

Tenho visto várias empresas com acesso por cartões utilizando RFID e fiquei curioso para saber como funciona esta tecnologia. Encontrei no site seedstudio o produto 125Khz RFID Module modelo RDM630 com um preço bem razoável e resolvi testar para entender o funcionamento.

Na imagem acima está apresentada a montagem que fiz com o módulo em uma breadboard e com a saída da leitura dos cartões ou chaveiros para o LCD serial. A antena é bem frágil e por isso montei dentro de um saco plástico para proteção. Para controlar o sistema utilizei a placa Tatuino nano da tato.ind.br.

Quando o chaveiro RFID é passado a uma distância de no máximo 5 cm da antena os dados do chip são apresentados na tela LCD com o MAC adress e checksum. O código é basicamente para apresentar os dados da porta serial no terminal da IDE do arduino ou em um LCD como eu fiz.

Os dados vem em formato ASCII, segundo modelo abaixo:

02 / 10ASCII Data Characters / Checksum / 03
O módulo é bem simples de montar porque já vem com os pinos soldados e encaixa sem problemas nos furos da breadboard, sendo a montagem que fiz a seguinte:

RDM630 - INTERFACE TTL RS232

P1
PIN 1 TX - Para o RX do arduino
PIN 2 RX - Para o TX do arduino
PIN 3 - Livre
PIN 4 - Ground
PIN 5 - 5 V

P2
PIN1 - Fio vermelho da antena
PIN1 - Fio preto da antena

P3
Para conexão de led- não utilizei

O código usado neste exemplo foi modificado para apresentação dos dados no lcd e foi montado para uso com o leitor de RFID ID-12 vendido na sparkfun:

---------------------------------------------------------------------------------------------------------------------------

// RFID reader ID-12 for Arduino 
// Based on code by BARRAGAN  
// and code from HC Gilje - http://hcgilje.wordpress.com/resources/rfid_id12_tagreader/
// Modified for Arudino by djmatic
// Modified for ID-12 and checksum by Martijn The - http://www.martijnthe.nl/
//
// Use the drawings from HC Gilje to wire up the ID-12.
// Remark: disconnect the rx serial wire to the ID-12 when uploading the sketch

#include <SoftwareSerial.h>

#define txPin 2
SoftwareSerial LCD = SoftwareSerial(0, txPin);

void setup() {
  Serial.begin(9600);                                 // connect to the serial port
  pinMode(txPin, OUTPUT);
  LCD.begin(2400);
  clearLCD();
  clearCURSOR();
}

void loop () {
  byte i = 0;
  byte val = 0;
  byte code[6];
  byte checksum = 0;
  byte bytesread = 0;
  byte tempbyte = 0;

  if(Serial.available() > 0) {
    if((val = Serial.read()) == 2) {                  // check for header 
      bytesread = 0; 
      while (bytesread < 12) {                        // read 10 digit code + 2 digit checksum
        if( Serial.available() > 0) { 
          val = Serial.read();
          if((val == 0x0D)||(val == 0x0A)||(val == 0x03)||(val == 0x02)) { // if header or stop bytes before the 10 digit reading 
            break;                                    // stop reading
          }

          // Do Ascii/Hex conversion:
          if ((val >= '0') && (val <= '9')) {
            val = val - '0';
          } else if ((val >= 'A') && (val <= 'F')) {
            val = 10 + val - 'A';
          }

          // Every two hex-digits, add byte to code:
          if (bytesread & 1 == 1) {
            // make some space for this hex-digit by
            // shifting the previous hex-digit with 4 bits to the left:
            code[bytesread >> 1] = (val | (tempbyte << 4));

            if (bytesread >> 1 != 5) {                // If we're at the checksum byte,
              checksum ^= code[bytesread >> 1];       // Calculate the checksum... (XOR)
            };
          } else {
            tempbyte = val;                           // Store the first hex digit first...
          };

          bytesread++;                                // ready to read next digit
        } 
      } 

      // Output to Serial:

      if (bytesread == 12) {   
       clearLCD();
       clearCURSOR();
       selectLineOne();        // if 12 digit read is complete
       LCD.print("Code:");
        for (i=0; i<5; i++) {
          if (code[i] < 16) LCD.print("0");
           LCD.print(code[i], HEX);
        }
        Serial.println();
        selectLineTwo();
        LCD.print("Check:");
        LCD.print(code[5], HEX);
        LCD.print(code[5] == checksum ? "-passed" : "-error");       
        
      }

      bytesread = 0;
    }
  }
}

void selectLineOne(){  //puts the cursor at line 0 char 0.
   LCD.print(0xFE, BYTE);   //command flag
   LCD.print(128, BYTE);    //position
}
void selectLineTwo(){  //puts the cursor at line 0 char 0.
   LCD.print(0xFE, BYTE);   //command flag
   LCD.print(192, BYTE);    //position
}

void clearCURSOR(){
   LCD.print(0xFE, BYTE);   //command flag
   LCD.print(0xC, BYTE);   //clear command.
}

void clearLCD(){
   LCD.print(0xFE, BYTE);   //command flag
   LCD.print(0x01, BYTE);   //clear command.
}

void serCommand(){   //a general function to call the command flag for issuing all other commands   
  LCD.print(0xFE, BYTE);
}

----------------------------------------------------------------------------------------------------------------------------

Alguns links com outros exemplos:

http://www.gumbolabs.org/2009/10/17/parallax-rfid-reader-arduino/
http://planaheist.com/imagehost/?v=dsc00456.jpg
http://www.trileet.com/node/34
http://kalshagar.wikispaces.com/ARCPO
http://www.arduino.cc/playground/Code/ID12
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1274920778
http://blog.formatlos.de/2008/12/08/arduino-id-12/

STM8S-Discovery & MSP-EXP430G2 LaunchPad

2010-06-25T10:12:00.007-03:00

Duas grandes empresas mundiais estão lançando no mercado placas de desenvolvimento para concorrer no mercado amador com a arduino. Achei interessante registrar este fato pois é a primeira vez que estas big muitinacionais lançam este tipo de produto. A Atmel e a Pic já estão no mercado faz tempo com algumas placas de desenvolvimento mas não são produtos com características tão próximas da arduino como estes.

STM8S-Discovery - http://www.st.com/mcu/contentid-130-113-STM8S_DISCOVERY.html

Uma placa de avaliação do chip STM8S com conexão usb e custo abaixo de USD 10,00 com IDE gratuita.

MSP-EXP430G2 - http://www.ti-estore.com/Merchant2/merchant.mvc?Screen=PROD&Product_Code=MSP-EXP430G2

Aproveite o lançamento deste produto para comprar a placa por USD 4,00 com frete gratis no site da ST. A placa vem com conexão usb, exemplos e IDE gratuita.

SHIFT REGISTER M74HC595 + DISPLAY 7 SEGMENTOS

2010-06-13T12:57:00.019-03:00

Continuando com as experiências com a arduino montada na breadboard, resolvi aprender a usar os chips de shift register que expandem as portas digitais da arduino.

Nos exemplos do comando ShiftOut site arduino.cc existem esquemas e bons exemplos, porém como sempre, não consegui encontrar o chip 74HC595 da philips que é usado em todos os exemplos que encontrei na web. O chip que achei é um clone compatível do fabricante SGS-THOMSON modelo M74HC595F1R.

Mudam os nomes dos pinos e sua posição mas as funcionalidades são exatamente as mesmas. Isso aconteceu também com o display de 7 segmentos que achei, tive que testar todos os pinos para achar qual era aordem correta de conexão, o modelo do display é HS5101AG VERDE - CATODO (COM TERRA COMUM), nao consegui achar nada de documentação deste.

O site mais completo que achei sobre o assunto com exemplos foi :

http://tronixstuff.wordpress.com/2010/04/30/getting-started-with-arduino-%E2%80%93-chapter-four/

Nao tem nehum esquema da montagem no site acima, mas tem explicações sobre o funcionamento do sistema bem feitas. O mais interessante é que a foto do chip que ele usa é a do modelo que encontrei e usei mas o resto das explicações são sobre o chip da philips...

Segue o meu esquema de pinagem:

O chip M74HC595 recebe do microcontrolador por meio do comando ShiftOut um número decimal que é convertido em binário, este número binário representa os pinos que devem ser ligados e desligados para acender ou apagar os leds que formam um certo número ou letra.

São 7 segmentos e um ponto, por tanto, oito leds para serem controlados por uma sequencia de oito zeros e uns.

Veja nos comentários abaixo o número decimal, o binário interpretado pelo chip e o número a ser apresentado no display .

Segue o sketch que montei par apresentar todos os números em série:

--------------------------------------------------------------------------------------------

/*
Claudio Miklos based on work by Carlyn Maw and Tom Igoe
 */



int latchpin = 11; // conecta no pino 14 do M74HC595
int clockpin = 10; // conecta no pino 12 do M74HC595
int datapin = 9; // conecta no pino 11 do M74HC595
void setup()
{
   pinMode(latchpin, OUTPUT);
   pinMode(clockpin, OUTPUT);
   pinMode(datapin, OUTPUT);
}
void loop()
{
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 63); // 111111 = 0
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 6); // 110 = 1
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 91); // 1011011 = 2
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 79); // 1001111 = 3
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 102); // 00000100 = 4
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 109); // 1101101 = 5
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 125); // 1111101 = 6
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 7); // 00000111 = 7
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 127); // 1111111 = 8
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 111); // 1101111 = 9
     digitalWrite(latchpin, HIGH);
     delay(1000);
           digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 128); // 10000000 = DP
     digitalWrite(latchpin, HIGH);
     delay(1000);
                digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 255); // 11111111 = TUDO
     digitalWrite(latchpin, HIGH);
     delay(1000);
 }

-------------------------------------------------------------------------------------------------------  O objetivo agora é fazer um termometro usando o que aprendi nos experiencias anteriores e montar tudo em uma placa de circuito de verdade.

ARDUINO BREADBOARD + ARDUINO ISP

2010-06-06T18:54:00.010-03:00

Este fim de semana montei a arduino em uma protoboard seguindo as instruções do site http://itp.nyu.edu/physcomp/Tutorials/ArduinoBreadboard. O chip ATMEGA328 tive que encomendar do mercado livre porque não encontrei em nenhuma loja na santa efigênia. Somente encontrei o ATMEGA8 em uma loja pequena depois de rodar a manhã de sábado inteira, assim mesmo eram as duas últimas unidades.

O resto dos componentes foi fácil encontrar (tudo nesta loja) , segue abaixo uma lista com os valores que paguei:

Protoboard = R$ 15,00 (unit)
Fios = R$ 2,00 (2 m)
1 x 7805 Regulador de Voltagem= R$ 0,70 (unit)
2 x LED = R$ 0,25 (unit)
2 x 220 Ohm resistor = R$ 0,01 (unit)
1 x 10k Ohm resistor = R$ 0,01 (unit)
2 x 10 uF capacitor = R$ 0,05 (unit)
1 x 16 MHz clock crystal = R$ 0,60 (unit)
2 x 22 pF capacitor = R$ 0,05 (unit)
1 x 0.1 uF capacitor = R$ 0,05 (unit)
1 x Botão Reset = R$ 0,10 (unit)
ATMEGA328 = R$ 19,00
Cabo TTL = R$ 25,00

ARDUINO PROTOBOARD = R$ 23,00 (sem protoboard e cabo)
ARDUINO 2009 ML = R$ 98,00
ARDUINO 2009 legalizada = R$ 136,00 (http://www.multilogica-shop.com/)
Diversão = não tem preço :-)

O que me preocupava mais era queimar o bootloader no chip ATMEGA328. Em geral é necessário ter um programador especial para isso, mas agora na versão 0018 da IDE do Arduino existe a possibilidade de utilizar a própria placa 2009 como programador para os chips ATMEL. Com isso foi fácil conectar as duas placas e programar o chip. Veja instruções neste endereço : http://arduino.cc/en/Tutorial/ArduinoISP.

Para programar, depois de ter queimado o bootloader, eu já tinha um cabo TTL e assim estou utilizando este para transferir os sketches. Somente tive que montar na breadborad uma adaptação com seis pinos conectados nas portas RX e TX e Reset do chip.

O plano agora é transferir a montagem para uma placa de circuito pronta e assim deixar meus projetos mais permanentes.

ARToolKit - Realidade Aumentada

2010-05-30T21:58:00.005-03:00

Já a algum tempo vi no programa Prototype This o uso do software ARToolKit, que permite o uso de realidade aumentada, para o projeto de luta de robôs. Este fim de semana instalei o software no Ubuntu e usei o adaptador USB Easycap ( exemplo no ML) para conectar uma camera Hi8 que tenho a tempos. O mais complicado na verdade foi fazer o adaptador USB funcionar no linux com o driver aberto. Para windows ele tem um software próprio que vem junto no pacote. Depois de muitas idas e vindas com dependências e reboots consegui estabilizar o sistema e fazer o teste com os exemplos que vem no pacote do ARToolKit.

É realmente muito bacana e divertido e os projetos que estão sendo desenvolvidos pelo mundo são sensacionais, desde manuais de montagem de móveis a livros infantis com recursos de realidade aumentada.

Vale a pena conhecer esta tecnologia que está ao alcance de todos sem custo além de uma camera, que pode ser uma webcam barata, e algum esforço de fim de semana.

Outros links

http://www.artag.net/

http://studierstube.icg.tu-graz.ac.at/handheld_ar/stbtracker.php

http://www.cs.ucl.ac.uk/staff/r.freeman/

IR RECEIVER - CONTROLE REMOTO DE TV

2010-05-26T12:55:00.012-03:00

A pouco tempo comprei dois receptores de ir por R$ 0,20 cada e fiquei pensando como utilizá-los com a arduino, depois de pesquisar um bocado entendi como funciona a transmissão dos comandos entre o controle remoto e a TV.

É realmente muito interessante pois a gente percebe como cada fabricante desenvolveu um protocolo próprio para seus sistemas, neste site http://www.ustr.net/infrared/infrared1.shtml existe uma explicação bem detalhada.

Usar um receptor de ir com o arduino é bastante simples, a conexão é feita com uma porta digital, no caso deste que usei a pinagem é a seguinte:

A única informação que achei sobre o sensor acima ( acredito que seja este) está neste link o modelo é 1838b e os detalhes:

Supply voltage: 2.7 to 5.5V
Transmission distance ：18-20m .

No experimento deste post conectei o pino de dados na porta digital 2 e os de força direto nas portas do arduino (alimentando a bradboard). Usei um controle remoto universal programado com os códigos da TV da sony e usei o código abaixo. As possibilidades são muitas, fazer um controle remoto para robôs ou controlar os equipamentos de casa. Imagine entrar em uma sala e ligar automáticamente o som ou a tv no canal ou estação que você mais gosta?

O código analisa os pulsos recebidos pela porta digital e apresenta na saida serial da IDE do arduino usando o comando pulseIn e transforma em números que são os códigos dos controles remotos da sony, com adaptações é possível usar qualquer marca. Este link tem um exemplo sobre como determinar os códigos .

-----------------------------------------------------------------------

/*
Program that reads key presses of a sony remote control
Created by Kurtis Waterston, March 6 2010
Realesed into the public domain
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1267950229
*/

int irDet = 2;
int key = 0;
int data[12];
int state;

void setup() {
Serial.begin(9600);                         //For debugging
pinMode(irDet, INPUT);                      //IR detector connected to digital pin 2
}

void loop() {                                //Main loop
if (pulseIn(irDet, LOW) > 2200) {          //Check for start pulse
   getIRkey();
   Serial.print("Key press is = ");
   Serial.println(key);
}

}

int getIRkey() {                             //Read pulses
data[0] = pulseIn(irDet, LOW);
data[1] = pulseIn(irDet, LOW);
data[2] = pulseIn(irDet, LOW);
data[3] = pulseIn(irDet, LOW);
data[4] = pulseIn(irDet, LOW);
data[5] = pulseIn(irDet, LOW);
data[6] = pulseIn(irDet, LOW);
data[7] = pulseIn(irDet, LOW);
data[8] = pulseIn(irDet, LOW);
data[9] = pulseIn(irDet, LOW);
data[10] = pulseIn(irDet, LOW);
data[11] = pulseIn(irDet, LOW);

for(int x = 0; x <= 11; x++) {              //Decide wether pulses are 1's or 0's
   if(data[x] > 1000) {
     data[x] = 1;
   }
   else {
     data[x] = 0;
   }
}

int result = 0;                            //Convert array into interger
int seed = 1;
for(int i=0;i<11;i++) {
   if(data[i] == 1) {
     result += seed;
   }
   seed = seed * 2;
}
key = result;
return result;
}

---------------------------------------------------------------------------------

Uma imagem do setup: