Blog do Miklos

DRAWBOT ROBÔ DESENHISTA

2012-03-28T11:44:00.000-02: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-26T10:37:00.001-02: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-12T14:09:00.009-02: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-03T12:05:00.021-02: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-29T09:40:00.002-02: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-24T21:47:00.011-02: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-14T11:26:00.001-02: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-14T13:46:00.006-02: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-30T18:33:00.006-02: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/

ARDUINO + 5 X 7 DOT MATRIX DISPLAY

2010-07-26T14:31:00.053-02:00

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 ( 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

125Khz RFID module - UART - RDM 630

2010-06-29T20:57:00.013-02: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-25T11:12:00.007-02: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-13T13:57:00.019-02: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-06T19:54:00.010-02: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-30T22:58:00.005-02: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-26T13:55:00.012-02: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:

ARDUINO LASER TRIPWIRE - ARMADILHA LASER

2010-05-22T21:24:00.007-02:00

No post passado eu estava analisando o uso de um LDR para produzir sons com a arduino, como já estava com o setup montado resolvi fazer a experiência da armadilha de laser dessas de filme de roubo de jóias ou obras de arte aonde os bandidos tem que passar pelos alarmes de laser para conseguir seu objetivo. Minha filha brincou um bocado tentado passar pelo raio do laser sem ser "detectada".

Estes são os elementos que usei:

1 Apontador laser barato - R$ 3,00
1 LDR de 5 mm
1 Alto-falante de 8 oms pequeno

O apontador laser é alimentado por 3 baterias botão bem pequenas, por isso tive que liga-lo a uma bateria mais potente, as baterias originais não aguentaram nem 5 minutos ligadas. Coloquei duas baterias de telefone sem fio de 2.4 volts NiMH ligadas em paralelo para obter 4.8 volts.

Soldei o positivo na carcaça de metal do apontador e o terra na mola que segura as baterias. Desta forma consegui uma fonte de laser bem forte e contante, isso é importante porque para fazer o alarme temos que medir a variação de voltagem vinda do sensor LDR.

No meu caso o valor da leitura do sensor na porta analógica 0 com iluminação ambiente foi de 300 e com o laser foi de 1000. Coloquei no código um valor de 800 para o disparo do alarme.

A montagem é a seguinte:

1. Alto falante com o fio vermelho ligado a porta digital 8 e o preto ao ground;
2. LDR com uma "perna" ligada a 5 volts e a outra ao ground por meio de um resistor de 10 kOhms ( marrom/preto/laranja/dourado) e a porta analógica 0. Existem muitos exemplos de montagem de LDR como estes

Neste exemplo estou usando a TATUINO NANO que é uma placa ótima para todos que querem experimentar com a IDE do arduino, ela pode ser conectada diretamnete na breadbord:

O código é muito simples:

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

/*
 claudio miklos 16/05/2010
 
 */


void setup() {
Serial.begin(9600); 
}

void loop()
{
Serial.print("Analog reading = ");
Serial.println(analogRead(0)); // the raw analog reading
  
if(analogRead(0) <= 800){
  
tone(8, 1000, 10);
}

}

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

Foi interessante conmhecer o TONE do arduino, no entanto tive problemas na comunicação serial, me parece que a comunicação serial interfere no comando tone.

ARDUINO TONE PITCH FOLLOWER

2010-05-11T21:48:00.000-02:00

Para continuar meus experimentos com o osciloscópio, resolvi montar o exemplo do site arduino.cc chamado TonePitchFollower, neste exemplo é utilizado ama fotocélula ou light-dependent resistors (LDR), para gerar variações de voltagem que são transformadas em tons divertidos e interessantes.

O código ensina como usar o comando tone para gerar notas ou barulhos .. um alarme ou outras coisas.

No vídeo eu tento mostrar a saída da leitura do osciloscópio na tela do PC.

Depois vou tentar montar um jogo de dardos de luz com esses apontadores laser baratos que vende na Santa Efigênia. Fica para o próximo fim de semana.

Osciloscópio com Microcontroladores

2010-05-08T21:46:00.011-02:00

Neste projeto estou utilizando o osciloscópio descrito abaixo para verificar a variação de voltagem de um sensor de temperatura LM35 que já tem sua postagem neste blog. No vídeo, tento mostrar que quando coloco a mão no sensor a temperatura aumenta e a voltagem sobe em incrementos que podem ser vistos na tela do PC.

Este post mostra como utilizei a controladora Axon para montar um osciloscópio conectado ao PC pela porta USB. A controladora Axon é desenvolvida pela Sor-Society of robots, o site Sor é muito interessante e é um misto de site caseiro e profissional. O fórum é muito bom apra resolver dúvidas sobre os mais diversos assuntos. A base do site da Sor é a montagem de um robot por USD 50, veja os vídeos e divirta-se com as experiências do John Palmisano e com seu conceito interessante de que fazer um robô é muito simples.. mas programar é outra história. O Sor é exatamente o contrário da arduino, nada IDE e suporte .. programação em C direta e você que se vire. Hoje a Axon é vendida em vários site como Robotshop.

Primeiro segui o tutorial e montei o robô de 50 dólares, é bastante divertido e instrutivo, porém, se eu soubesse da arduino não teria perido tempo com isso. Serviu para conhecer os processadores Atmel e a IDE de programação Avr Studio o que me abriu a possibilidade de entender mais profundamente a arduino.

Axon e AxonII são controladoras montadas em cima do processador Atmel Atmega640, esta placa oferece realmente recursos mais fáceis do que a arduino para quem vai montra robôs com vários servos, ela é desenvolvida para isso e tem muitos pinos para conexão de sensores, aliás sobram pinos para todo o lado.

A programação pode ser feita por USB com um programa em código aberto de linha de comando e também por programadores de hardware como STK500 e compatíveis como este vendido pela Sparkfun. A controladora Axon é muito sólida e bem construída, tem boas proteções elétricas e é uma excelente opção para que quer se aprofundar na programação e técnica.

Veja uma imagem da placa :

No site da Sor existe para download gratuíto o software SorScope, com ele é possível montar um osciloscópio com até 16 canais , resolução de 10 bits e 1.5 ks/s.

Fica claro (na foto acima) que não se trata de um sistema profissional, é comparável aos osciloscópios USB do mercado. Existem mais baratos que são conectados as portas de áudio do PC . A vantagem de usar uma placa controladora é que você não fica com um mais um produtto que serve só a um propósito. Tabém é possível montra um osciloscópio com a arduino e com as mesmas características como neste exemplo ou neste exemplo, como eu já tinha uma Axon resolvi montá-la em uma caixa e fazer um osciloscópio "portátil" com o que eu tinha a mão.

Montar um osciloscópio como este pode ensinar bastante sobre o funcionamento de sensores analógicos e outros sinais e também ajudar quando se tem problemas com um novo projeto.

SENSOR DE TEMPERATURA LM35 + LCD SERIAL

2010-05-02T17:45:00.013-02:00

Continuando com as experiências com o LCD serial resolvi montar um termômetro usando o sensor LM35 que é um pequeno chip que gera corrente variável de acordo com a temperatura. Segundo os dados do fabricante este sensor gera uma voltagem de + 10.0 mV/°C , logo ele gera 0 V s para 0°C celsius e + 1 V para 100 °C graus celsius com uma precisão de 0.5 °C.

Este sensor pode ser encontrado facilmente em qualquer loja de componentes e existem também várias placas ( shields) para o arduino com este sensor já montado e pronto para conexão no arduino.

A alimentação do sensor pode ser feita com 5.0 volts a partir do própria placa arduino, assim como o ground. Segue esquema da ligação abaixo:

Código

O código abaixo toma as leituras da porta analógica 0 da arduino 2009 geradas pelo LM35 e apresenta estas leituras após transformação ( veja abaixo) no LCD serial. Apresenta também as leituras de mínima e máxima. Para ver o exemplo da conexão do LCD serial procure o post sobre ele neste blog.

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

// Claudio miklos 05/2010 based on:

// http://www.arduino.cc/playground/Learning/SparkFunSerLCD

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

#include <SoftwareSerial.h>
#define txPin 2
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;
SoftwareSerial LCD = SoftwareSerial(0, txPin);

// referencia - http://www.arduino.cc/playground/Learning/SparkFunSerLCD

void setup()
{
pinMode(txPin, OUTPUT);
LCD.begin(2400);
clearLCD();
clearCURSOR();
}

void loop()

{

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

samples[i] = ( 5.0 * analogRead(pin) * 100.0) / 1024.0;
tempc = tempc + samples[i];
delay(100);

}

tempc = tempc/8.0; // better precision
tempf = (tempc * 9)/ 5 + 32; // converts to fahrenheit

if(tempc > maxi) {maxi = tempc;} // set max temperature
if(tempc < mini) {mini = tempc;} // set min temperature

selectLineOne();
delay(100);
LCD.print(maxi,DEC); LCD.print(" Max "); LCD.print(mini,DEC); LCD.print(" Min ");
selectLineTwo();
delay(100);
LCD.print(tempc,DEC); LCD.print(" Celsius");LCD.print(" P0=");LCD.print(analogRead(pin));
delay(100);

tempc = 0;

delay(1000); // delay before loop
}

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);
}

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

Considerações sobre as leituras do LM35 e o código :

// samples[i] = ( 5.0 * analogRead(pin) * 100.0) / 1024.0; //

Se você está utilizando a alimentação do arduino com 5 v e conectando o sensor diretamente a porta analógica 0, será necessários utilizar a fórmula acima para converter a leitura de 10 bit do sensor na temperatura em graus celsius.

Exemplo:

Leitura = 48 mV

5.0 ( 5 VOLTS DE REFERENCIA) x 48 ( LEITURA EM MILIVOLTS ) x 100 / 1024 ( SAMPLES DA PORTA ANALOGICA) = 23,4375 °C

Resultado a ser apresentado no LCD = 23°C

Links de referênciahttp://www.ladyada.net/learn/sensors/tmp36.html

http://www.instructables.com/id/Waterproof-a-LM35-Temperature-Sensor/

http://pscmpf.blogspot.com/2008/12/arduino-lm35-sensor.html

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

LCD SERIAL

2010-04-30T23:01:00.007-02:00

Acabou de chegar o LCD serial da Tato.ind.br que eu pedi a somente dois dias. Eles enviarm rápido e sem problemas. O display é bem comum (ESCRITO ATRÁS ESTÁ: TECH1602B-RN-GBS-8) ele tem 2 x 16 posições e pode ser encontrado facilmente nas lojas da Santa Efigênia em Sampa sem o módulo serial que é fabricado pela Tato.

Soldado atrás do display está o módulo serial baseado em um chip PIC16F628A, o módulo apresenta as seguintes conexões:

1. +5V

2. TTL (para conexão com arduino ou outros)

3. RS232 (para conexão com porta serial do pc)

4. GND

A conexão com a placa arduino 2009 é feita com o pino TTL do módulo ligado a porta TX (digital 1) ou com outra porta digital, dependeno da biblioteca utilizada. A alimentação é de 5 v logo é possível conectar diretamente ao na porta de alimentação de 5v e ground da própria placa arduino.

Para comunicação serial eu utilizei os exemplos do site arduino.cc:

http://www.arduino.cc/playground/Learning/SparkFunSerLCD

Existem duas opções, utilizar a comunicação serial direta pela porta TX ou definir outra porta digital qualquer com o uso da biblioteca SoftwareSerial.h . Com o uso desta biblioteca é possível liberar as portas TX e RX do arduino para outras funções.

Segue abaixo o exemplo do código que utilizei para apresentar no display o resultado do contador Milis, que conta o tempo em milissegundos desde que a placa arduino foi iniciada

Segue o código com a biblioteca SoftwareSerial:

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

#include // inclui a biblioteca

#define txPin 2 // define o pino digital 2 como TX

SoftwareSerial LCD = SoftwareSerial(0, txPin); // cria a instância LCD

// referencia - http://www.arduino.cc/playground/Learning/SparkFunSerLCD

void setup()

{

pinMode(txPin, OUTPUT); // define como output

LCD.begin(2400); // define 2400 de taxa de transferência para o LCD

clearLCD(); // veja abaixo o código para limpar o lcd no início

clearCURSOR(); // veja abaixo o código para tirar o cursor

}

void loop()

{

selectLineOne(); // define a posição do inicio do milis na linha 1

delay(100);

LCD.print(millis()); // apresenta p milis no lcd

selectLineTwo(); // define a posição do inicio do milis na linha 2

delay(100);

LCD.print("Mostrando MILIS"); // escreve na linha 2

delay(100);

}

void selectLineOne(){ //puts the cursor at line 0 char 0.

LCD.print(0xFE, BYTE); //codigo para inserão de comandos

LCD.print(134, BYTE); // posição na linha 1

}

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);

}
--------------------------------------------------------------------------------------------

Esquema da fiação: