Arduino Brasil

Capacímetro com Arduino

2010-04-16T19:56:00.000-03:00

Introdução

Um resistor carrega 63,2% de um capacitor em 'TC' segundos, sendo

TC = R x C

TC: chamada de constante de tempo e dada em segundos;
R: resistência elétrica, dada em ohms
C: capacitância, dada em farads

Isto é, a tensão elétrica no capacitor após TC segundos de carga é igual à 63,2% da tensão elétrica de carga.

Na prática, pode-se considerar que o capacitor carrega-se totalmente após cinco constantes de tempo.

Experimento

O esboço abaixo funciona porque os pinos do Arduino podem estar em um dos dois estados abaixo, que são eletricamente bem diferentes:

Estado de entrada
Alta impedância: demanda pouca energia do circuito a ser lido
Bom para ler sensores, mas não para acender LEDs

Estado de saída
Baixa impedância: pode ser fonte de até 40 mA (polaridade positiva) ou drenar 40 mA (polaridade negativa)
Bom para acender LEDs e alimentar outros circuitos, mas não para ler sensores

Além disso, os pinos podem estar em HIGH para carregar o capacitor e LOW para descarregá-lo.

Algoritmo do esboço do capacímetro

Ajustar pino de descarga como entrada (de forma que ele não pode descarregá-lo)
Registrar o horário inicial com millis()
Ajustar o pino de carga para HIGH
Averiguar continuamente a tensão no capacitor para saber se já chegou aos 63,2%
Ao carregar o capacitor, subtrair o horário atual do horário inicial para saber o tempo de carga
Dividir o tempo em segundos pela resistência em ohms e, assim, obter o valor da capacitância
Descarregar o capacitor. Para isso:
- Ajustar o pino de carga como entrada
- Ajustar o pino de descarga como saída e lá pôr LOW
Ler a tensão elétrica para certificar-se de que o capacitor está vazio
Meia-volta ao início do algoritmo

Código

/*  Capacímetro_RC
 *  Paul Badger 2008
 *  Demonstra uso da constante de tempo RC como meio de medir o valor do capacitor 
 *
 * Theory
 *  Um capacitor carregar-se-á, via um resistor, em uma 
 *  constante de tempo, definida como TC segundos onde
 *    TC = R * C
 * 
 *    TC = constante de tempo expressa em segundos
 *    R = resistência em ohms
 *    C = capacitância em farads (1 microfarad (ufd) = .0000001 farad = 10^-6 farads ) 
 *
 *  A tensão no capacitor em uma constante de tempo
 *  é definida como 63.2% da tensão de carga.
 *
 * Montagem do hardware
 *  O capacitor a testar fica entre o ponto comum e o terra
 *  (não se esqueça: ligue o + do capacitor ao ponto comum)
 *  O resistor a testar fica entre o pino de carga
 *  (chargePin) e o ponto comum
 *  Um resistor de 220 ohms entre o pino de descarga
 *  (dischargePin) e o ponto comum
 *  Um fio entre o ponto comum e o pino analógico 
 *  (analogPin, entrada A/D)
 */

#define analogPin      0          // pino analógico a medir tensão no capacitor
#define chargePin      13         // pino a carregar o capacitor
#define dischargePin   11         // pino a descarregar o capacitor
#define resistorValue  10000.0F   // mude esse valor para o valor do seu resistor
                                  // o "F" informa o compilador que trata-se de um ponto flutuante

unsigned long startTime;
unsigned long elapsedTime;
float microFarads;                // variável ponto flutuante para efetuar os cálculos
float nanoFarads;

void setup(){
  pinMode(chargePin, OUTPUT);     // ajuste chargePin como saída
  digitalWrite(chargePin, LOW);  

  Serial.begin(9600);             // inicializa a comunicação serial para fins de depuração de erros
}

void loop(){
  digitalWrite(chargePin, HIGH);  // ponha HIGH em chargePin
  startTime = millis();

  while(analogRead(analogPin) < 648){       // 647 = 63.2% de 1023, que corresponde ao fim de escala
  }

  elapsedTime= millis() - startTime;
 // converta milissegundos a segundos ( 10^-3 ) e farads a microfarads ( 10^6 ), líquidos 10^3 (1000)  
  microFarads = ((float)elapsedTime / resistorValue) * 1000;   
  Serial.print(elapsedTime);       // imprima à saída serial
  Serial.println(" mS    ");       // imprima unidade e retorno de carro

  if (microFarads > 1){
    Serial.print((long)microFarads);  // imprima à saída serial
    Serial.println(" microFarads");   // imprima unidade e retorno de carro
  }
  else
  {
    // se o valor for menor que um microfarad, converta
    // a nanofarads (10^-9 farad). 
    // trata-se de um artifício para que Serial.print imprima pontos flutuantes

    nanoFarads = microFarads * 1000.0;      // multiplique por 1000 para converter a nanofarads (10^-9 farads)
    Serial.print((long)nanoFarads);         // imprima à saída serial
    Serial.println(" nanoFarads");          // imprima unidade e retornod de carro
  }

  /* descarregue capacitor  */
  digitalWrite(chargePin, LOW);             // ponha LOW em chargePin
  pinMode(dischargePin, OUTPUT);            // ajuste dischargePin como saída
  digitalWrite(dischargePin, LOW);          // ponha LOW
  while(analogRead(analogPin) > 0){         // espere até esvaziar capacitor
  }

  pinMode(dischargePin, INPUT);            // ajuste de novo o pino para entrada
}

Cronômetro com Arduino

2010-04-16T19:37:00.000-03:00

Abaixo, um esboço que demonstra como fazer duas coisas ao mesmo tempo baseado na função millis().

/* Cronômetro
 * Paul Badger 2008
 * Demonstra o uso de millis(), resistores pull-up, 
 * como fazer duas coisas acontecerem ao mesmo tempo,
 * imprime frações
 *
 * Montagem física: interruptor momentâneo ao pino 4 e ao
 * terra, e o LED com um resistor em série entre o pino 13  
 * e o terra
 */

#define ledPin  13                  // LED ao pino digital 13
#define buttonPin 4                 // botão ao pino 4

int value = LOW;                    // valor anterior do LED
int buttonState;                    // variável a guardar estado do botão
int lastButtonState;                // variável a guardar o último estado do botão
int blinking;                       // condição para piscamento - o cronômetro venceu
long interval = 100;                // intervalo de piscamento - mude à vontade
long previousMillis = 0;            // variável a guardar o último momento de atualização do LED
long startTime ;                    // momento de partida do cronômetro
long elapsedTime ;                  // tempo decorrido no cronômetro
int fractional;                     // variável a guardar parte fracionária do tempo

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

   pinMode(ledPin, OUTPUT);       // ajuste o pino digital como saída
   pinMode(buttonPin, INPUT);     // linha não muito necessária, já que os pinos são por padrão entradas
   digitalWrite(buttonPin, HIGH); // ligue resistores de pull-up
}

void loop()
{
    // aguarde pressionamento do botão
   buttonState = digitalRead(buttonPin); // leia e guarde estado do botão

   if (buttonState == LOW && lastButtonState == HIGH  &&  blinking == false){
    // veja se houve transição de HIGH para LOW
    // em caso positivo, então trata-se de um novo pressionamento enquanto o relógio não corre: parta o relógio

      startTime = millis();    // guarde o tempo de partida
      blinking = true;         // ligue o piscar enquanto corre o relógio
      delay(5);                // pequena pausa para filtrar ruído mecânico do botão
      lastButtonState = buttonState;  // guarde buttonState em lastButtonState, para que possa comparar mais tarde
   }

   else if (buttonState == LOW && lastButtonState == HIGH && blinking == true){
    // veja se houve transição de HIGH para LOW
    // em caso positivo, trata-se de um novo pressionamento enquanto o relógio corre: pare o relógio e exiba mensagem

        elapsedTime = millis() - startTime;  // guarde tempo decorrido
        blinking = false;                    // desligue o pisca-pisca
        lastButtonState = buttonState;       // guarde buttonState em lastButtonState, para comparar mais tarde
       // rotina para exibir tempo decorrido 
        Serial.print( (int)(elapsedTime / 1000L));         // divida por 1000 para converter a segundos - e então converta a inteiro
        Serial.print(".");                   // imprima ponto decimal

       // use operador módulo para obter parte fracionária part do tempo 
       fractional = (int)(elapsedTime % 1000L);

       // preencha com zeros à esquerda - não seria ótimo se 
       // a linguage Arduino tivesse algo específico para tratar disso? :)
       if (fractional == 0)
          Serial.print("000");      // inclua 3 zeros
       else if (fractional < 10)
          Serial.print("00");       // inclua 2 zeros
       else if (fractional < 100)
          Serial.print("0");        // inclua 1 zero

       Serial.println(fractional);  // imprima parte fracionária do tempo
   }

   else{
      lastButtonState = buttonState;                        // guarde buttonState em lastButtonState, para comparar mais tarde
   }

   // rotina de piscamento - pisca LED enquanto conta o tempo
   // verifique se já é hora de piscar LED; isto é, a diferença
   // entre o tempo atual e o último momento em que piscamos o LED é maior que
   // o intervalo ao qual queremos piscá-lo?

   if ( (millis() - previousMillis > interval) ) {

      if (blinking == true){
         previousMillis = millis();  // lembre-se da última vez que piscou-se o LED

         // se LED está desligado, ligue-o e vice-versa
         if (value == LOW)
            value = HIGH;
         else
            value = LOW;
         digitalWrite(ledPin, value);
      }
      else{
         digitalWrite(ledPin, LOW);  // desligue o LED caso não esteja a piscar
      }
   }
}

Controle Nintendo Wii + Arduino

2010-03-20T11:43:00.000-03:00

Nintendo Wii está revolucionando o modo com que jogadores fazem a interação com o console. Indo um pouco mais a fundo na idéia, perceberemos que dentro do controle do Wii, existem vários sensores, dentre eles um ou mais "acelerometros".

Pegando carona no controle, foi desenvolvido um adaptador de WiiNunchuck para o Arduino, que recebe o nome de "Nunchuck". O adaptador faz a comunicação com o Arduino por I2C e é muito simples:

adaptador nunchuck

Código Fonte:

/*
 * NunchuckPrint
 *
 * 2007 Tod E. Kurt, http://todbot.com/blog/
 *
 * The Wii Nunchuck reading code is taken from Windmeadow Labs
 *   http://www.windmeadow.com/node/42
 */
 
#include 

void setup()
{
  Serial.begin(19200);
  nunchuck_setpowerpins(); // use analog pins 2&3 as fake gnd & pwr
  nunchuck_init(); // send the initilization handshake
  Serial.print ("Finished setup\n");
}

void loop()
{
  nunchuck_get_data();
  nunchuck_print_data();
  delay(100);
}


//
// Nunchuck functions
//

static uint8_t nunchuck_buf[6];   // array to store nunchuck data,

// Uses port C (analog in) pins as power & ground for Nunchuck
static void nunchuck_setpowerpins()
{
#define pwrpin PORTC3
#define gndpin PORTC2
    DDRC |= _BV(pwrpin) | _BV(gndpin);
    PORTC &=~ _BV(gndpin);
    PORTC |=  _BV(pwrpin);
    delay(100);  // wait for things to stabilize        
}

// initialize the I2C system, join the I2C bus,
// and tell the nunchuck we're talking to it
void nunchuck_init()
{ 
  Wire.begin();                 // join i2c bus as master
  Wire.beginTransmission(0x52); // transmit to device 0x52
  Wire.send(0x40);  // sends memory address
  Wire.send(0x00);  // sends sent a zero.  
  Wire.endTransmission(); // stop transmitting
}

// Send a request for data to the nunchuck
// was "send_zero()"
void nunchuck_send_request()
{
  Wire.beginTransmission(0x52); // transmit to device 0x52
  Wire.send(0x00);  // sends one byte
  Wire.endTransmission(); // stop transmitting
}

// Receive data back from the nunchuck, 
int nunchuck_get_data()
{
    int cnt=0;
    Wire.requestFrom (0x52, 6); // request data from nunchuck
    while (Wire.available ()) {
      // receive byte as an integer
      nunchuck_buf[cnt] = nunchuk_decode_byte(Wire.receive());
      cnt++;
    }
    nunchuck_send_request();  // send request for next data payload
    // If we recieved the 6 bytes, then go print them
    if (cnt >= 5) {
     return 1;   // success
    }
    return 0; //failure
}

// Print the input data we have recieved
// accel data is 10 bits long
// so we read 8 bits, then we have to add
// on the last 2 bits.  That is why I
// multiply them by 2 * 2
void nunchuck_print_data()
{ 
  static int i=0;
  int joy_x_axis = nunchuck_buf[0];
  int joy_y_axis = nunchuck_buf[1];
  int accel_x_axis = nunchuck_buf[2]; // * 2 * 2; 
  int accel_y_axis = nunchuck_buf[3]; // * 2 * 2;
  int accel_z_axis = nunchuck_buf[4]; // * 2 * 2;

  int z_button = 0;
  int c_button = 0;

  // byte nunchuck_buf[5] contains bits for z and c buttons
  // it also contains the least significant bits for the accelerometer data
  // so we have to check each bit of byte outbuf[5]
  if ((nunchuck_buf[5] >> 0) & 1) 
    z_button = 1;
  if ((nunchuck_buf[5] >> 1) & 1)
    c_button = 1;

  if ((nunchuck_buf[5] >> 2) & 1) 
    accel_x_axis += 2;
  if ((nunchuck_buf[5] >> 3) & 1)
    accel_x_axis += 1;

  if ((nunchuck_buf[5] >> 4) & 1)
    accel_y_axis += 2;
  if ((nunchuck_buf[5] >> 5) & 1)
    accel_y_axis += 1;

  if ((nunchuck_buf[5] >> 6) & 1)
    accel_z_axis += 2;
  if ((nunchuck_buf[5] >> 7) & 1)
    accel_z_axis += 1;

  Serial.print(i,DEC);
  Serial.print("\t");
  
  Serial.print("joy:");
  Serial.print(joy_x_axis,DEC);
  Serial.print(",");
  Serial.print(joy_y_axis, DEC);
  Serial.print("  \t");

  Serial.print("acc:");
  Serial.print(accel_x_axis, DEC);
  Serial.print(",");
  Serial.print(accel_y_axis, DEC);
  Serial.print(",");
  Serial.print(accel_z_axis, DEC);
  Serial.print("\t");

  Serial.print("but:");
  Serial.print(z_button, DEC);
  Serial.print(",");
  Serial.print(c_button, DEC);

  Serial.print("\r\n");  // newline
  i++;
}

// Encode data to format that most wiimote drivers except
// only needed if you use one of the regular wiimote drivers
char nunchuk_decode_byte (char x)
{
  x = (x ^ 0x17) + 0x17;
  return x;
}

Com o código não se assuste! Basta saber que para receber dados do Wii, digitar: "nunchuck_get_data();" , quando quiser imprimir os valores na serial, digitar: "nunchuck_print_data();".

Resultado:

Usando o serial monitor do Arduino você consegue visualizar estes dados. Pode em um futuro próximo também, adicionar caracteristas ao processing, pensou já? Quanta coisa daria para ser feita?

Qq dúvida, postar comentário.

Créditos: Hack N Mod

Conectando Xbee ao Arduino

2010-03-16T22:57:00.001-03:00

Este post visa exemplificar os primeiros passos com Arduino e Xbee.

Xbee são módulos de rádio para efetuar comunicação serial entre dois pontos (ponto a ponto, ponto a multiponto e etc), conta com protocolo Zigbee e assim garante fidelidade na conexão. Estes são produzidos pela DIGI (antiga MaxStream) e possui duas versões a série 1 e 2. Série 1 e 2 não se comunicam entre si e ambas possuem modelos bem semelhantes:

Xbee 1mW, antena tipo fio, RSPMA ,UFL e chip. A distância de comunicação chega até 40m em ambientes fechados e 100m em ambientes abertos.

XbeePRO 50mW, antena tipo fio, RSPMA ,UFL e chip. A distância de comunicação chega até 300m em ambientes fechados e 1600m em ambientes abertos.

Módulo Xbee 1mW – MaxStream

Xbee Shield para Arduino

O Xbee utiliza o protocolo ZigBee que este por sua vez utiliza como base o protocolo IEEE 802.15.4.

Utilizações:
Automação Residencial: Controle de Iluminação, Alarmes, Controle de Temperatura;
Automação Predial: Controle de Temperatura, Telemetria Elevadorista, Controle Elétrico;
Automação industrial: Telecontrole de Sensores, Terminais Inteligentes, Comunicação com Centrais.
Automação Comercial: Geradores de Senhas, Terminais Inteligentes, Software simultâneo;

Em nosso caso vamos criar uma conexão entre dois Xbee utilizando o Arduino e o PC.

Materiais Necessários:
2 Shield Xbee para Arduino;
2 Arduino (um deles sem o microcontrolador, cuidado ao retirar para não entortar os seus pinos);
2 Módulos Xbee;
1 Bateria 9V para alimentar o Arduino extra;
1 Caso USB (A-B) para conectar o Arduino ao PC;

Configuração Inicial
De fábrica cada módulo Xbee vem configurado com uma PANID (número que identifica a rede) de número 3332 e configurados com uma taxa de transmissão de 9600 baud, com dados de 8 bits sem paridade e 1 bit de parada.

Cada Xbee Shield tem um par de jumpers para definir se a comunicação serial se realiza pela porta USB ou pelao próprio Xbee. Como primeira tentativa vamos configura-lo para interagir com a porta USB, isso significa colocar os jumpers na posição externa dos pinos, na figura abaixo pode-se ver como ficaria.

Configuração dos pinos do shield Xbee

Podemos utilizar o programa HyperTerminal do Windows para começar a configurar o módulo Xbee. Outra alternativa seria usar o Serial Monitor que vem integrado com a IDE do Arduino ou o programa Bray++ Terminal.

O comando necessário para começar a programar o módulo é “+++”, ou seja três simbolos de soma consecutivos. Teclando-os devemos receber como resposta um “OK”

Estabelecendo conexão com o Xbee

Uma vez estabelecida a conexão só temos 5 segundos para interagir com o módulo. Depois deste tempo, o módulo regressa a seu estado nativo e para voltar a conexão deve redigitar “+++”.

Cada comando que mandamos ao Xbee deve ser precedido pelas letras AT (de AT Command = Comando AT)

A tabela de comandos mais usuais pode ser encontrado na página dedicada no site do Arduino.

Usaremos para conexão ao PC a placa Arduino sem o microcontrolador ATMEGA. A razão para isto é que desta maneira podemos diretamente interagir pelo USB com o módulo Xbee.

Para este exemplo proponho a seguinte configuração: uma PANID de 3332, um módulo com endereço ‘0’ e o outro com ‘1’. O módulo com endereço ‘0’ será o que vai estar conectado ao PC e o módulo com endereço ‘1’ será o módulo remoto.

Para configurar o primeiro com a endereço ‘0’, 9600 baud, 8 bits, sem paridade, com 1 bit de parada e comunicação com o módulo de ID1 usamos os seguintes comandos:

ATID3332

DH0

DL1

MY0

BD3

WR

CN

As letras AT indicam ao Xbee que vamos lhe enviar comandos.
ID3332: Define PANID de 3332;
DH0: Define direção ‘1’, com quem o Xbee estará se comunicando;
DL1: Define direção ‘1’, com quem o Xbee estará se comunicando;
MY0: Define endereço ‘0’, próprio endereço;
BD3: Define velocidade em 9600 baud;
WR: Faz a gravação do módulo;
CN: Encerra conexão com o módulo;

Passo seguinte é conectar o segundo Xbee Shield ao Arduino sem microcontrolador. Configuramos da mesma maneira:
ID3332: Define PANID de 3332;
DH0: Define endereço ‘1’, com quem o Xbee estará se comunicando;
DL1: Define endereço ‘1’, com quem o Xbee estará se comunicando;
MY0: Define endereço ‘1’, próprio endereço;
BD3: Define velocidade em 9600 baud;
WR: Faz a gravação do módulo;
CN: Encerra conexão com o módulo;

Depois de terminada a configuração dos módulos estamos aptos de estabelecer uma conexão cpm os módulos.

Programando o Arduino remoto
Vamos colocar o módulo Xbee com endereço ‘1’ no Arduino que tem o microcontrolador e vamos programar nele um código que envia via Serial um número. Também vamos incluir uma leitura da porta serial para saber se foi recebido um caracter em particular e se caso for afirmativos iremos trocar o estado de um LED conectado ao pino digital 13.

É importante remover o módulo Xbee dete Arduino enquanto programamos, para que possamos estabelecer a comunicação serial.

int numero = 0;
char recepcao;
int estado = 1;

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

void loop() {
Serial.print(numero);
Serial.println();
delay(1000);
numero++;
// ler da serial
recepcao = Serial.read();
if (recepcao == 'x')
{
estado = !estado;
digitalWrite(13,estado);
}
}

Depois de carregar este código podemos testa-lo abrindo uma conexão serial entre o Arduino. Devemos observar o numero ascendente e quando enviamos o caracter ‘x’ devemos observar uma troca do estado do LED conectado ao pino 13

Provando a comunicação sem fio
Uma vez programado o Arduino vamos desconectar o jumper USB e colocar no outro, aonde possamos alimenta-lo com uma bateira 9V. Também vamos conectar o Xbee para que possa começar a comunicação serial sem fio. Devemos nos assegurar que os jumpers do interior do Arduino estejam em ‘Xbee"’. No PC vamos conectar o Arduino sem microcontrolador com o Xbee shield de endereço ‘0’ e vamos abrir o Hyper Terminal, depois de alguns segundos devemos começar a observar o numero recebido do endereço ‘1’ em ascendencia e quando teclamos a tecla ‘x’ conferimos se o LED mudou de estado.

Recebendo os dados pelo Hyper Terminal do Windows

Espero que gostem do exemplo e o desenvolvam com sabedoria. Xbee é uma ferramenta implantada no Brasil em meados de 2007 e está em plena expansão.

Como visualizar graficamente dados do seu Arduino em tempo real?

2010-03-10T23:40:00.001-03:00

O título deste post pode parecer um tanto assustador no começo, porém lembre-se de que nos temos um companheiro e tanto para este feito que é o PROCESSING! Vocês se lembram de um post que eu já citei sobre ele? O que ele irá fazer? Ele irá servir de base para fazermos as amostras dos dados na tela do PC!

Vamos usar um controle do nintendo WII neste tutorial, por que possui varios sensores que podemos escolher (entre eles o acelerometro) e faciilmente o conctamos ao Arduino para receber dados.

Uma vez que os sensores transmitiram dados com sucesso para a porta serial, nos podemos usar estes dados para criar um gráfico, criamos uma nova perspectiva para ele. Para começar, iremos pegar o valor de uma variavel vinda pela porta serial e jogar no grafico, o resultado deve ficar mais ou menos assim:

Código (Sketch):

//Este exemplo le em um simples byte valores de 0 a 255 e faz o grafico.

/////////////////////////////////////////
//Código comunicação serial básica
//por Chang Soo Lee
//ITP, NYU
//Criado em 11/27/2005
/////////////////////////////////////////

import processing.serial.*;
Serial myPort;
int serial = 1; 
PFont font;
int numH = 370;  

void setup () {
  size(270, 440);
  println(Serial.list());
  myPort = new Serial(this, Serial.list()[0], 9600);
  // Carrega a fonte 
  // Diretrorio de seu sketch. Use Tools > Create Font 
  // para criar uma distributable bitmap font  
  // para fontes de vetor use a função createFont() 
  font = loadFont("ArialMT-48.vlw"); 
  smooth(); 
}

void draw () {
  background(255);

  if (myPort.available() > 0) {
    serial = myPort.read();
    serialEvent();
  } 

  line(70,70,70,370);  
  line(70,370,200,370);
  fill(0);
  textFont(font, 11); 
  text("Sensor\nValue",22,80);
  text("Analog Input", 95, 390);
  text(serial,25,110);
  noFill();
}

void serialEvent(){
  if(serial>1){
  rect(120,numH-serial, 20, serial);
  } 
}

Similar ao anterior agora vamos fazer o gráfico de várias variaveis ao mesmo tempo. É um pouco mais complicado pois nós temos que separar as variaveis. Para aprender como fazer isto sugiro que deem uma olhada sobre “transmissao serial multivariavel” no site do Arduino (www.arduino.cc).

Código:

// 3 sensores analogicos formatados e enviados pelo arduino. processing pega estes dados e faz o grafico.


// From ITP at NYU – //http://itp.nyu.edu/physcomp/

//código que vai no arduino!!!!

int an1, an2, an3 = 0;

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

void loop() {
  an1 = analogRead(0);
  delay(5); 
  an2 = analogRead(1);
  delay(5); 
  an3 = analogRead(2);
  Serial.print("X");
  Serial.println(an1,DEC);
  Serial.print("Y");
  Serial.println(an2,DEC);
  Serial.print("Z");
  Serial.println(an3,DEC);
  delay(15);               
}

//Código que vai no PROCESSING!!!!


import processing.serial.*;

String buff = "";
int val = 0;
int NEWLINE = 10;
int xPos,yPos,zPos = 0;
int displaySize = 2;
int an1, an2, an3;

Serial port;

void setup(){
  background(80);
  size(800,600);
  smooth();

  port = new Serial(this, Serial.list()[0], 19200);
}

void draw(){
  // new background over old
  fill(80,5);
  noStroke();
  rect(0,0,width,height);

  // deixa uma pequena area em frente dos novos dados
  fill(80);
  rect(xPos+displaySize,0,50,height);

  // Verifica serial e processa
  while (port.available() > 0) {
    serialEvent(port.read());
  }
}


void serialEvent(int serial) { 
  if(serial != '\n') { 
    buff += char(serial);
  } else {
    int curX = buff.indexOf("X");
    int curY = buff.indexOf("Y");
    int curZ = buff.indexOf("Z");

    if(curX >=0){
      String val = buff.substring(curX+1);
      an1 = Integer.parseInt(val.trim());

      xPos++;
      if(xPos > width) xPos = 0;

      sensorTic(xPos,an1+20);
    }    
    if(curY >=0){
      String val = buff.substring(curY+1);
      an2 = Integer.parseInt(val.trim());

      yPos++;
      if(yPos > width) yPos = 0;

      sensorTic(yPos,an2-255);
    }
    if(curZ >=0){
      String val = buff.substring(curZ+1);
      an3 = Integer.parseInt(val.trim());

      zPos++;
      if(zPos > width) zPos = 0;

      sensorTic(zPos,an3-255);
    }

    // Limpa valor de "buff"
    buff = "";
  }
}

void sensorTic(int x, int y){
  stroke(0,0,255);
  fill(0,0,255);
  ellipse(x,y,displaySize,displaySize);
}

Em breve postarei como adaptar o controle do WII em seu Arduino.

Arduino + Sensor Temperatura + Visual c# parte 2/2

2010-02-22T21:16:00.001-03:00

Vimos anteriormente como utilizar os dados enviados pelo arduino no ZEDGRAPH, agora iremos criar um programa em Visual C#, para formatar os dados.

Você poerá utilizar o programa exemplo em C# anterior para fazer um “managed” de suas portas com.

private void serialPortArduino_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e) { int bytesToRead = serialPortArduino.BytesToRead; if (bytesToRead >= 13) { char[] z = new char[13]; serialPortArduino.Read(z, 0, 13); string n = new string(z); ProcessReceivedData(n); } }

Código para receber dado do Arduino via Serial. Observe que os dados vão se agrupando em um vetor conforme chegam ao buffer.

delegate void SetTextCallback(string text); private void ProcessReceivedData(string text) { if (this.zedGraphControlTemperature.InvokeRequired) { SetTextCallback d = new SetTextCallback(ProcessReceivedData); this.Invoke(d, new object[] { text }); } else { temperatureData.Add(GetActualTimeInDouble(), ConvertToCelsius(Convert.ToDouble(text.Split(':')[1]))); zedGraphControlTemperature.AxisChange(); zedGraphControlTemperature.PerformAutoScale(); zedGraphControlTemperature.Refresh(); } }

Função esta que trata o dado recebido pelo Arduino na Serial, já armazenada em vetor. Utiliza do componente ZEDGRAPH para tal.

Previa do programa trabalhando! Não reparem o som (de ótima qualidade, rs)

Código Fonte Projeto pronto:
TemperatureLogger v0.1 (Código fonte)

Executável da aplicação:
TemperatureLogger v0.1

Código fonte para o Arduino:
TemperatureLogger v0.1 (Archivo fuente para el IDE de Arduino)

Créditos para:

Arduino + Sensor Temperatura + Visual c# parte 1/2

2010-02-22T20:43:00.001-03:00

Vejamos passo a passo como capturar um valor de temperatura pelo Arduino, enviar via Serial e Interpretar com Visual C# no pc.

ProtoShield

Arduino Duemila

Sensor temperatura ZX-TEMP

ZX-TEMP, nada mais é que um termistor e voce pode facilmente troca-lo por outro do mesmo tipo, existe infinitos!

Circuito Temperatura:

Sketchs, partes que considero importantes p/ entendimento do mesmo:

float convertToCelsius(long sensorVal) { return map((int)(sensorVal*1000), 438000,573000,26000,37000)/1000; }

Função “convertToCelsius”, tem por função mapear a unidade referida e retorna-la já em Celsius (ler o sensor e mostrar o resultado!).

void printTemp(float tempCelcius) { // Formato TEMP_:000000: Serial.print("TEMP_:"); if(tempCelcius<100) // tem menos de 3 dígitos Serial.print("0"); if(tempCelcius<10) // tem menos de 2 dígitos Serial.print("0"); int c = (int)tempCelcius; float r = tempCelcius-c; Serial.print(c); long rem = r*1000; Serial.print(rem); if(rem<100) // Tem menos de 3 dígitos Serial.print("0"); if(rem<10) // Tem menos de 2 dígitos Serial.print("0"); Serial.print(":"); }

Esta função tem por objetivo formatar o dado recebido pela “convertToCelsius” para mandar via SERIAL! O protocolo particular utilizado é de mandar um inteiro de 000000 digitos! Mas por quê então preciso desta função, ora bolas?

Lembre-se: ‘000050’ é diferente de ‘50’ quando voce vai manda-lo via SERIAL, por isso a necessidade da função!!

Agora antes de iniciarmos na plataforma Microsoft Visual C#, podemos trabalhar com o programa ZedGraph, o qual é um gerador de gráficos que também interpreta dados vindos por determinada serial.

Como vamos nos conectar ao Arduino, é necessário escolher uma porta.

A finalidade é gerar algo parecido com isto:

Sketch Arduino Completo:
TemperatureLogger v0.1 (Código fonte ARDUINO)

Visual C# no próximo post!

Arduino seguindo a luz

2010-02-19T12:08:00.001-02:00

Esta é uma forma simples de você fazer um servo motor seguir a luz, usando alguns simples componentes!

O vídeo original é feito com um ArduinoMEGA, o qual tem mais I/O (entradas e saídas). Todavia pode ser construído com qualquer base “Arduinana”.

Componentes:
1 x Servo motor (Parabólica serve também)
2 x Fotoresistores
2 x Resistor 470ohms

Faça as ligações como descrito no esquema do FRITIZING acima.

Lembre-se que a gambiarra aqui é colocar de alguma forma uma pequena protoboard em cima do servo! Ou fica a vontade para usar a imaginação! (veja vídeo topo pagina)

SKETCH:

#include <Servo.h>

Servo myservo;

int pos = 0; // Variavel para guardar posicao servo.
int inputPhotoLeft = 1; // Facil de ler, instante 1 ou 0.
int inputPhotoRight = 0;

int Left = 0; // Guarda valor fotoresistor.
int Right = 0; // Guarda valor fotoresistor.

void setup()
{
myservo.attach(9); // Conecta servo ao pino digital 9.
}

void loop()
{
// Le os valores dos fotoresistores e guarda nas variaveis
Left = analogRead(inputPhotoLeft);
Right = analogRead(inputPhotoRight);

// Checa se a esquerda é maior que direita, se sim move p/ direita.
if (Left > (Right +20))
// +20 é uma zona morta, sem isso causa interferencia.
{
if (pos < 179)
pos++;
myservo.write(pos);
}

// Checa se a esquerda é menor que a direita, se sim move esquerda.
if (Right > (Left +20))
// +20 é uma zona morta, sem isso causa interferencia.
{
if (pos > 1)
pos -= 1;
myservo.write(pos);
}

// Adicionando delay ou não o servo corre mais devagar
delay(10);
}

Qualquer dúvida por favor comente, seu feedback é muito importante!

Créditos, http://stigern.net/blog/?cat=35

Arduino comunicando com Visual C#

2010-02-18T22:41:00.002-02:00

Como se pode comunicar com o Arduino através de um computador e recorrendo à linguagem C#? O objectivo é fazer uma coisa com este aspecto:

Antes de mais nada instale a versão gratuita do Microsoft Visual C# Express (a Microsoft também tem coisas boas!).

A idéia principal do programa é enviar uma informação através da porta serial à qual está ligado o Arduino. Em rigor, o Arduino está ligado ao computador através de USB mas como tem um conversor USB-Serial, abstraímos-nos do USB e falamos apenas da ligação Serial.
Por forma a simplificar o "protocolo" de comunicação a informação transmitida é constituída apenas por caracteres. Um caracter corresponde a uma determinada ação. Descreve-se aqui o exemplo mais simples que é acender e apagar um LED!

Abre o Microsoft Visual C# Express e faz File>New>Project e na tab Visual C# escolhe "Windows Forms Application".
Vais precisar de uma TextBox, um Button, duas Labels, duas ComboBoxes e uma SerialPort. Arrasta cada um desses compotentes para a Form1 que é criada assim que cria o projecto. Para adicionar o código a cada um destes componentes basta clicar duas vezes em cima de cada um.

Só vou listar aqui as duas partes de código que considero mais importantes. O código na íntegra está disponível no fim deste post.
Para que possa comunicar-se através da porta Serial tem que definir, pelo menos, duas coisas: a taxa de transferência de dados (BAUD RATE) e a porta em que está ligado o Arduino (por ex: COM7). Se não souber em que porta está ligado o Arduino clica com o botão direito do mouse no "Meu Computador", "Propriedades" e em "Gerenciador de Dispositivos". Aí, encontrará essa informação.
Para definir a baud rate utiliza o seguinte código:

private void baudrate_combobox_SelectedIndexChanged(object sender, EventArgs e)
{
serialPort.BaudRate = Convert.ToInt16(baudrate_combobox.Text);
}

O valor escolhido para a baud rate tem de corresponder ao utilizado pelo Arduino.
Para definir a porta serial bem como efetuar a sua abertura, utiliza o seguinte código:

private void port_combobox_SelectedIndexChanged(object sender, EventArgs e)
{
serialPort.PortName = port_combobox.Text;
try
{
serialPort.Open();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}

As funções try/catch previnem o programa de qualquer exceção que possa ocorrer na abertura da porta Serial.
Por fim, para enviar uma mensagem para o Arduino utiliza o seguinte código:

private void send_button_Click(object sender, EventArgs e)
{
try
{
serialPort.Write(message_textbox.Text);
message_textbox.Text = "";
}
catch (Exception ex)
{
MessageBox.Show(ex.Message,"ERROR",MessageBoxButtons.OK,MessageBoxIcon.Error);
}
}

Por sua vez vais precisar de enviar código para o Arduino por forma a que este fique à espera e reconheça os comandos (caracteres, neste caso) que lhe envia. Assim faz o upload do seguinte código:

#define BAUD_RATE 9600
#define ledPin 13
char incomingChar;
void setup()
{
pinMode(ledPin, OUTPUT);
// serial communication
Serial.begin(BAUD_RATE);
}
void loop()
{
if(Serial.available() > 0){
incomingChar = Serial.read();
//your protocol goes here
switch(incomingChar){
case '1':
// led is ON
digitalWrite(ledPin, HIGH);
break;
case '0':
// led is OFF
digitalWrite(ledPin, LOW);
break;
}
}

O que é que este código quer dizer? Quer dizer que se enviar um caracter '1' o LED ligado no pino 13 se acende e que se enviar um caracter '0' o LED fica desligado.
Concluindo... C# é uma excelente linguagem para, com poucas linhas e em pouco tempo, se fazer umas brincadeiras interessantes. Mais. O que se tentou aqui fazer foi, nada mais nada menos, do que algo que já existe no Arduino IDE desde a sua versão 0017. Ainda assim, espero que tenha sido do teu agrado.

LINKS P/ PROGRAMAS COMPILADOS:
TalkToArduino C# source code
TakToArduino.pde

Créditos, http://bravomofo.blogspot.com/2009/12/talk-to-arduino-with-c.html

Diodo

2010-02-17T22:53:00.001-02:00

No artigo sobre como se acende um LED acabei por falar de díodos. Disse que o LED tem um ánodo e um cátodo, o qual causa uma queda de tensão de um certo valor, que é polarizado e mostrei o seu símbolo eléctrico. Tudo isto se aplica a um díodo comum, com pequenas variações: a queda de tensão provocada por um díodo comum é de aproximadamente 0.7 V, e o símbolo é muito parecido com o do LED, só não tendo as 2 “ondas” (que representam a luz que sai do LED). No símbolo mais comum do LED, estas ondas são apenas setas retas, e tem uma bola em redor.

Caracteristicas do diodo:

Só conduz corrente eléctrica num sentido, do ánodo para o cátodo.

Só começa a conduzir corrente quando a tensão aplicada é igual ou superior a 0.7 V.

Quando conduz corrente, causa uma queda (redução) de tensão de 0.7 V.

1. Só conduz corrente eléctrica num sentido, do ánodo para o cátodo.
A melhor forma de perceber é utilizar um LED como exemplo, e vou utilizar o mesmo circuito do artigo sobre como acender LEDs. A figura abaixo mostra 2 versões desse circuito. A versão à esquerda é a habitual, que usamos para acender o LED; a corrente, a vermelho tracejado, circula do ponto positivo da fonte para o negativo, e o LED deixa passar essa corrente, acendendo. No circuito à direita, o LED está ligado “ao contrário”, e desta forma impede a corrente de circular; o LED mantém-se apagado. Portanto o LED só deixa passar a corrente eléctrica num sentido, do ánodo para o cátodo tal como acontece no circuito da esquerda: a corrente entra pelo ánodo e sai pelo cátodo! Repare-se como o símbolo do próprio díodo é uma seta que aponta no sentido em que deixa passar a corrente.

Muitas vezes é feita uma comparação da corrente eléctrica a circular num circuito com a água a circular em canos. É possível ter num cano de água um dispositivo semelhante a um díodo:

As 2 portas, a castanho, abrem-se facilmente empurradas pela força da água, deixando-a passar, desde que a água circule da direita para a esquerda (por exemplo empurrada por uma bomba de água). Se ela vier da esquerda, então vai empurrar as portas de tal modo que estas fecham-se, impedindo a água de continuar a fluir para a direita. Um díodo faz a mesma coisa.
Outras analogias são as veias do nosso corpo, que têm válvulas que deixam passar o sangue apenas num sentido, e também os “pipos” das camaras de ar dos pneus, que apenas deixam passar o ar de fora para dentro (quando estamos a encher). São ambos exemplos de “díodos”, noutros domínios.

2. Só começa a conduzir corrente quando a tensão aplicada é igual ou superior a 0.7 V.
Esta característica é bastante auto-explicativa. Se a tensão da fonte que fornece energia ao circuito for inferior 0.7 V, o díodo não se deixa atravessar por corrente. Ele apresenta-se como um circuito aberto, tal como se tivessemos ligado o díodo ao contrário. Digamos que 0.7 V é a tensão mínima para que o díodo comece a funcionar. E isto leva-nos à última característica.

3. Quando conduz corrente, causa uma queda (redução) de tensão de 0.7 V.
Se voltarmos à analogia com a água e à figura do canal de água mais acima, podemos pensar que alguma da força da corrente da água é gasta a abrir e manter as portas abertas. Podemos pensar na força da água como sendo a tensão (força electromotriz), e assim a analogia completa-se. Se formos medir a tensão nos pinos de um díodo quando este está a conduzir corrente, vamor medir aproximadamente os 0.7 V, tal com nos circuitos com LEDs (mas neste caso a tensão depende da cor do LED).

Ok… então se os LEDs dão luz, o díodo comum faz o quê? Bom, os díodos começaram por ser utilizados como componentes rectificadores. Muito informalmente, rectificar é transformar um sinal AC num sinal DC. Num sinal AC a tensão varia entre valores negativos e valores positivos, e a sua aplicação a um díodo elimina uma metade do sinal, a metade positiva ou a metade negativa dependendo da forma como o díodo é ligado. No circuito abaixo temos uma fonte de tensão de 5 V AC, que é rectificada por um díodo que lhe remove a metade negativa do sinal, ficando uma tensão DC. O gráfico mostra o valor da tensão no ponto AC (a verde) e no ponto DC (a azul).

Deve ter reparado na diferença de amplitude entre as 2 tensões… consegue adivinhar a que se deve? Sim? Não? E se eu te disser que essa diferença é de 0.7 V, ajuda ? Pois é, é preciso não esquecer que o díodo causa uma queda de tensão de 0.7 V. A rectificação é usada por exemplo em receptores de rádio e fontes de conversão AC-DC (como um carregador típico de bateria de celular, que converte os 220 V AC da rede em 4 ou 5 V DC).

Humm… e é só para isso que o díodo serve? Não, na verdade, as utilizações do díodo estão apenas limitadas pela nossa imaginação! Mas exemplos típicos de utilização são: conversores DC-DC comutados, como referências de tensão baratas, como redutores de tensão, e para impedir que a ligação acidental de fontes de tensão “ao contrário” causem danos em equipamentos, entre outros. Em tempos também foram usados em electrónica digital, como portas digitais e na construção de memórias ROM. Acho que vale a pena falar um pouquinho mais acerca de algumas das utilizações típicas.

Imagina que tem um aparelho que é muito sensível e caro (por exemplo um auxiliar de audição), e portanto quer protegê-lo de vários tipos de acidentes. Um dos acidentes que pode acontecer é o utilizador do aparelho colocar as pilhas ao contrário por distração ou porque não leu o manual como deve ser. Uma forma de efetuar essa proteção é exactamente colocar um díodo em série com a fonte de alimentação (as pilhas).

Como o díodo só conduz corrente eléctrica num sentido, se as pilhas forem colocadas ao contrário o díodo “barra” a passagem da corrente e não acontece nenhuma desgraça ao pobre aparelho. Nesta aplicação aproveitamos a característica nº 1 do díodo.

Com a 2ª característica do díodo pode fazer um circuito que verifica se um par de pilhas alcalinas de 1.5 V ainda tem carga suficiente, acendendo um LED em caso afirmativo:

Uma pilha alcalina vulgar está completamente gasta se apresentar 1.1 V de tensão; vamos então arbitrariamente assumir para o nosso exemplo que se ainda medimos 1.25 V a pilha está boa. Neste caso, um par de pilhas alcalinas ainda tem bastante carga se der 1.25 V + 1.25 V = 2.5 V em utilização. Uma vez que o díodo comum só conduz corrente a partir de 0.7 V, e o LED vermelho só a partir de aproximadamente 1.8 V, temos que o díodo mais o LED resultam numa queda de tensão de 0.7 + 1.8 = 2.5 V. Logo, são precisos 2.5 V ou mais para que circule corrente no circuito e o LED acenda. Como precisamos de calcular uma resistência para limitar a corrente no LED, vamos usar o valor de tensão de um par de pilhas completamente novas: 3 V. Portanto, aos 3 V a corrente no LED não pode ser mais do que 0.02 A, que é a corrente máxima num LED vermelho. Calculamos então a resistência usando a Lei de Ohm: (3 V – 2.5 V) / 0.02 A = 25 Ω (podemos usar o valor comercial 33 Ω).

Agora imagina que tem um circuito que tem que ser alimentado por 2 tensões diferentes; uma é um valor qualquer de 4.5 V a 5.5 V e a outra é de 3.1 V a 3.4 V. Imagina também que só tem 6 V, tirados de 4 pilhas de 1.5 V ligadas em série. Uma forma de obter as tensões desejadas é pegar nos 6 V do conjunto das pilhas e aproveitar a 3ª característica do modelo de funcionamento do díodo para obter as tensões menores, como na figura.

O 1º díodo subtrai 0.7 V e portanto ficamos com 6 – 0.7 = 5.3 V, que está dentro do intervalo desejado de 4.5 V a 5.5 V. Depois adicionámos mais 3 díodos em série para reduzir ainda mais a tensão, ficando então com 6 – 0.7 – 3 x 0.7 = 3.2 V, que cumpre o requisito de termos um valor no intervalo 3.1 V a 3.4 V. Aqui usamos a característica que o díodo tem de reduzir a tensão em 0.7 V, para obter tensões diferentes da que tínhamos disponível.
Como nota final acerca deste circuito, é preciso dizer que ele só reduz realmente as tensões para os valores apresentados se houver alguma corrente a fluir pelos díodos. O díodo causa realmente uma queda de tensão, mas só quando flui corrente (lembram-se da regra 3 do modelo? Começa por dizer quando conduz corrente); isto bate certo com a Lei de Ohm, pois se a corrente é zero, não pode haver queda de tensão! Para termos um conversor utilizável na prática, teriamos que acrescentar uma resistência entre a saída 5.3 V e o negativo, e entre a saída de 3.2 V e também o negativo. Estas resistências fazem com que esteja sempre a fluir uma “correntezinha” mínima e assim os díodos a causar a queda de tensão. A resistência deve ser calculada para deixar fluir 1 mA de corrente, que é um valor pequeno para não se deperdiçar muita energia e ao mesmo tempo é um valor suficientemente grande para que o díodo funcione bem. Aplicando a Lei de Ohm podemos calcular essas resistências; por exemplo a resistência para a saída de 3.2 V deve ser 3.2 V / R = 0.001 A (Lei de Ohm, I = V / R) <=> R = 3.2 V / 0.001 A = 3200 ohms.

Já agora, existem outros tipos de díodo? Por acaso existem. Alguns dos mais conhecidos são o díodo Zener, o Varicap, o Fotodíodo e o Schottky.

O Zener é um díodo especial que em certas condições fixa uma certa tensão aos seus terminais; existem díodos Zener para várias tensões maiores que alguns volts, como 3.3 V ou 5.6 V, e são usados como reguladores e referências de tensão.

O Varicap é um díodo que funciona como um condensador variável controlado por tensão. Era utilizado por exemplo em sintonizadores de rádio “digitais”, até começarem a ser usados PLLs.

O fotodíodo é um díodo sensível à luz e pode ser usado como detector de luz, para vários comprimentos de onda. É usado por exemplo nos receptores de commandos infra-vermelhos.

O Schottky é um díodo em que a queda de tensão é de aproximadamente 0.3 V em vez dos típicos 0.7 V. Isto tem a vantagem de haver um menor desperdício de energia por dissipação térmica no díodo, o que é importante em aplicações em que a eficiência energética e baixo consumo são importantes. É que na verdade, a queda de tensão que os díodos apresentam é uma característica indesejável! Vamos pensar no detector de inversão de tensão de alimentação da figura mais acima. Se o díodo estiver a ser atravessado por uma corrente de 100 mA, a potência que ele dissipa na forma de calor (logo, desperdício, porque a função do díodo não é dar calor) é dada pela fórmula da potência (em Watts, W), a quem eu costumo chamar “lei companheira da lei de Ohm” (a fórmula da potência dissipada já dava para outro tutorial):

      P = V x I

Logo, 0.7 V * 0.1 A = 0.07 W = 70 mW. Pode parecer pouco, mas muitos aparelhos portáteis consomem pouco mais do que isso! Se o aparelho estiver a ser alimentado a 3 V, ele estará a consumir (3V – 0.7 V) * 0.1 A = 230 mW, e por aqui se vê que 30% (70/230) da potência retirada das pilhas está a ser desperdiçada no díodo! Se for usado um díodo Schottky em vez do díodo comum, a potência perdida será 0.3 * 0.1 = 30 mW, ou seja, aproximadamente 13% (30/230) do consumo inicial do aparelho, em vez de 30%. Quer dizer que a autonomia das pilhas aumentou 17% só com a troca de um componente. Uma melhoria significativa!

Outra característica que torna os Schottky muito apeteciveis em certas aplicações é a velocidade de reacção. Por ser constituído por apenas um bloco semiconductor e um bloco metálico, este díodo é extremamente rápido a mudar de estado entre “a conduzir” e “ao corte”.

Então e se eu quiser fazer umas experiências, que díodos posso comprar na loja?…

Bom, existem díodos muito comuns e baratos que pode comprar com facilidade praticamente em qualquer loja de eletronica; são eles o 1N4148 e o 1N4001 a 1N4007. O 1º é para correntes até perto de 0.2 A e os restantes para correntes até cerca de 1 A.

Qualquer dúvida poste um comentário.

Créditos a NJAY, em http://troniquices.wordpress.com/2007/11/28/o-diodo/

Desculpe pelo mal entendido, porém internet é internet! Nada se cria tudo se copia…

Caso alguma parte tenha se ofendido favor ler anuncio a direita do blog!

Att, denadai.sicari

Tellymate Shield

2010-02-10T20:33:00.001-02:00

Já pensou, ao invés de usar LCD comum para mandar mensagens ou atualizar dados enfim… O famoso e notável Display de Cristal Liquido!

Se você já está cansado dele (como eu), chegou a sua vez!

TellyMate é um prototipo para receber comandos pelo canal ICSP, sendo que a Serial para USB, fica livre! Quando ele recebe determinado comandos, envia para uma Televisão mensagens, alguns graficos simples, jogos e por enquanto (infelizmente) apenas em preto e branco.

Olhe como é simples escrever na Televisão com o TellyMate!

Serial.begin(57600); //57k6 baud
Serial.println(”Hello!”);

NOTA: EXEMPLO ABAIXO ESTA MODIFICADO!

Você pode conferir o projeto completo em:

http://www.batsocks.co.uk/products/Shields/TellyMate%20Shield.htm

Por enquanto não encontrei para compra aqui no Brasil e em muitas poucas lojas na America. Como o autor disponibiliza sua obra no site (código aberto), a única solução é confeccionar a placa! Quando tiver resultados “pomposos” posto aqui para vocês verem o resultado!

delayMicroseconds(μs)

2010-02-05T15:26:00.003-02:00

Suspende a execução do programa pelo tempo (em microsegundos) especificado como parâmetro. Um 1 milisegundo há 1.000 microsegundos e em 1 segundo há 1 milhão.

Atualmente o maior valor que produzirá uma suspenção precisa é 16383. Isto pode mudar em distribuições futuras do Arduino. Para suspenções maiores que milhares de microsegundo você deve utilizar a função delay().

Parâmetros

μs: o número de microsegundos da suspenção.

Retorno

Nenhum

Exemplo

int outPin = 8;                 // digital pino 8

void setup()
{
  pinMode(outPin, OUTPUT);      // marca o pino digital como saída
}

void loop()
{
  digitalWrite(outPin, HIGH);   // ativa o pino
  delayMicroseconds(50);        // suspenção de 50 microsegundos      
  digitalWrite(outPin, LOW);    // desativa o pino
  delayMicroseconds(50);        // suspenção de 50 microsegundos      
}

configura o pino 8 para trabalhar como uma saída. Envia uma cadeia de de pulsos com um período de 100 microsegundos.

Cuidados e problemas conhecidos

Esta função funciona com bastante precisão na faixa dos 3 microsegundos e acima. Não podemos nos assegurar que funcione com precisão para tempos de suspenção menores.

Para assegurar suspenções mais precisas esta função desabilita as interrupções durante sua operação. Isto significa que algumas coisas (como o recebimento de informações seriais, ou que a atualização do valor de retorno da função mills() ) não funcionarão. Desse modo, você deve usar esta função apenas para suspenções curtas, e usar delay() para as mais longas.

delayMicroseconds(0) gerará uma suspanção muito maior do que a esperada (~1020 μs) bem como se o parâmetro for um número negativo.

delay(ms)

2010-02-05T15:25:00.002-02:00

Suspende a execução do programa pelo tempo (em milisegundos) especificado como parâmetro. (Em um segundo há 1.000 milisegundos.)

Parâmetros

ms (unsigned long): o número de milisegundos em que o programa ficará com a execução em suspenso.

Retorno

nenhum

Exemplo

int ledPin = 13;                 // LED conectado ao pino digital 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // marca o pino digital como saída
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // acende o LED
  delay(1000);                  // espera por um segundo
  digitalWrite(ledPin, LOW);    // apaga o LED
  delay(1000);                  // espera por um segundo
}

Cuidado

Embora seja fácil criar um LED piscando com a função delay(), e muitos programas usam intervalos curtos para tarefas como a de filtrar ruídos, o uso do delay() em um programa tem aspectos negativos importantes. Nenhuma leitura de sensores, cálculo matemático, ou manipulação de pinos pode seguir durante a execução desta função, portanto muitas outras funções ficam em espera. Para controles de tempo alternativos veja a função millis() e e seu programa de exemplo. Programadores com mais conhecimento normalmente evitam o uso de delay() para cronometrar eventos mais logos do que 10 milisegundos, a não ser que o programa seja muito simples.

Algumas coisas de fato continuam acontecendo enquanto a função delay() está controlando o chip ATmega porque as interrupções não são desabilitadas. A comunicação que aparece no pino RX continua sendo gravada. os pinos e as leituras de PWM (analogWrite) são mantidos, e as interrupções continuam funcionando.

micros()

2010-02-05T15:20:00.000-02:00

Retorna o número de microsegundos desde que a placa Arduino começou a rodar o programa.

Este número extrapolará (voltará ao zero) depois de aproximamente 70 minutos. Nas placas Arduino de 16 MHz (e.g. Duemilanove e Nano), esta função tem uma resolução de 4 microsegundos (o valor de retorno será sempre um múltiplo de 4) Nas placas Arduino de 8MHz (e.g. LilyPad), esta função tem uma resolução de 8 microsegundos.

Nota: em 1 milisegundo há 1.000 microsegundos e 1.000.000 de microsegundos em 1 segundo.

Parâmetros
Nenhum

Retorno
O número de microsegundos desde que o programa começou a rodar como um tipo longo não assinalado.

Exemplo
unsigned long time;
void setup(){
Serial.begin(9600);
}

void loop(){
Serial.print("Time: ");
time = micros(); //imprime o tempo desde que o programa começou a rodar
Serial.println(time); //espera um segundo para não ficar enviando quantidades absurdas de dados
delay(1000);
}

millis()

2010-02-05T15:18:00.002-02:00

Retorna o número de milisegundos desde que a placa Arduino começou a rodar o programa. Este número extrapolrá (voltará ao zero) depois de aproximamente 50 dias.

Parâmetros

Nenhum

Retorno

O número de milisegundos desde que o programa começou a rodar como um tipo longo não assinalado.

Exemplo

unsigned long time;

void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.print("Time: ");
  time = millis();
  //imprime o tempo desde que o programa começou
  Serial.println(time);
  // espera um segundo para não ficar enviando quantidades absurdas de dados
  delay(1000);
}

Dica:

Verifique o retorno para o millis é um longo não assinalado. Erros podem ocorrer se um programador tentar realizar cálculos com outros tipos de dados, como inteiros.

random()

2010-02-05T15:09:00.002-02:00

A função random gera números pseudo-aleatórios.

Sintaxe

long random(max)
long random(min, max)

Parâmetros

min - limite inferior do valor aleatório, inclusivo (opcional)

max - limite superior do valor aleatório, exclusivo

Retorno

long - um número aleatório entre min e (max-1)

Note:

Se for importante para uma seqüência de valores gerados pela função random() ser diferente, a cada execução de um programa, use randomSeed() para inicializar o gerador de números aleatórios a partir de um valor também aleatório, como um analogRead() de um pino que não esteja conectado.

De modo semelhante, pode ocasionalmente ser útil usar seqüências pseudo-aleatórias que se repetem exatamente a cada execução de um programa. Isto pode ser obtido atravéz da função randomSeed() de um número fixado, antes de se iniciar a seqüência aleatória.

Exemplo

long randNumber;

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

  // se o pino de entrada analógica 0 não estiver conectado, ruído analógico
  // aleatório fará com que a função randomSeed() gere
  // diferente números de início cada vez que o programa for executado.
  // randomSeed() irá embralhar a função random.
  randomSeed(analogRead(0));
}

void loop() {
  // imprime um número aleatório entre 0 e 299
  randNumber = random(300);
  Serial.println(randNumber);  

  // imprime um número aleatório entre 10 e 19
  randNumber = random(10, 20);
  Serial.println(randNumber);

  delay(50);
}

pow(base, expoente)

2010-02-05T15:08:00.002-02:00

Calcula o valor de um número elevado a uma potência. Pow() pode ser utilizado com uma potência fracionária. É útil para gerar mapeamentos exponenciais de valores ou curvas.

Parâmetros

base: o número(float)

expoente: a potência à qual a base é elevada (float)

Retorno

O resultado da exponeciação (double)

constrain(x, a, b)

2010-02-05T15:07:00.002-02:00

Restringe um número dentro de uma faixa.

Parâmetros

x: o número a restringir, todos os tipos de dados

a: o extremo inferior da faixa, todos os tipos de dados

b: o extremo superior da faixa, todos os tipos de dados

Retorno

x: se x estiver entre a e b

a: se x for menor que a

b: se x for mairo que b

Exemplo

sensVal = constrain(sensVal, 10, 150);
// limita o valor da variável sensVal a valores entre 10 e 150

map(value, fromLow, fromHigh, toLow, toHigh)

2010-02-05T15:06:00.000-02:00

Re-mapeia um número de uma faixa de valores para outra. Isto é, um valor de fromLow é mapeado para toLow, um valor fromHigh para toHigh, e valores intermediários da primeira faixa para a segunda faixa, mantendo-se a proporção entre eles.

Não restringe valores dentro da faixa, porque valores que extrapolem podem ser úteis e intencionais. A função constrain() pode ser utilizada tantes antes como depois desta função se limites para as faixas forem necessários.

Verifique que os limites inferiores de uma faixa podem ser maiores ou menores que os limites superiores. Desse modo a função map() pode ser utilizada para colocar em ordem reversa uma faixa de valores, como por exemplo:

y = map(x, 1, 50, 50, 1);

A função também pode utilizar números negativos como neste exemplo:

y = map(x, 1, 50, 50, -100);

A função map() utiliza números inteiros e não gera frações. Quando o resultado for fracionário ele será truncado e não arredondado.

Parâmetros

value: o número a ser mapeado

fromLow: limite inferior da faixa atual de value

fromHigh: limite superior da faixa atual de value

toLow: limite inferior da faixa para a qual se quer mapear

toHigh: limite superior da faixa para a qual se quer mapear

Retorno

O valor mapeado.

Exemplo

/* Mapear uma entrada analógica de 10 bits para uma saída analógica de 8 bits (0 a 255) */
void setup() {}

void loop()
{
  int val = analogRead(0);
  val = map(val, 0, 1023, 0, 255);
  analogWrite(9, val);
}

Comunicação Serial Arduino Com Fio

2010-02-05T14:45:00.000-02:00

Podemos precisar a qualquer momento nos comunicar com outros dispositivos, no caso outros Arduinos.

Este post traz uma simples solução para este problema, "Como se comunicar serialmente com outro ARDUINO!?"

comunicação serial via modulo XBEE

Comunicação serial por fio

Configurando os pinos RX/TX do Arduino por fio

No Arduino emissor teremos um potenciometro, do qual é lido o valor e mandado via serial.

No receptor teremos um LED que irá mudar o seu brilho conforme o valor do potencimetro.

Faça agora as seguintes conexões:

TX_ARDUINO#1 - - - - RX_ARDUINO#2

RX_ARDUINO#2 - - - - TX_ARDUINO#1

NOTA: QUANDO FOR PASSAR O CÓDIGO PARA O ARDUINO, DESCONECTAR OS FIOS DE TX E RX DE AMBOS OS LADOS!

Código Emissor:

int analogValue5, val5;

void setup() {
// Habilita porta Serial
Serial.begin(19200);
}

void loop() {
// Le pino analogico 5
analogValue5 = analogRead(5);

// Mapeia os valores para 0 - 255
val5 = map(analogValue5, 0, 1023, 0, 255);

// envia o valor via serial em modo binário
Serial.println(val5, BYTE);

}

Código Receptor:

byte incomingByte;

void setup() {
// Habilita comunicação serial
Serial.begin(19200);

// declara pin 11 como output, este é o LED
pinMode (11, OUTPUT);
}

void loop() {

// Se há bytes livres vindo da porta serial
if (Serial.available()) {

// Seta o valor para a variavel 'incomingByte'
incomingByte = Serial.read();

// Escreve o valor no pino 11
analogWrite(11, int(incomingByte));

}
}

Espero que seja de bom uso a todos, em breve postarei minhas experiências com um modulo XBEE.

Att,

Nova IDE Arduino 0018, liberada 29/01/2010.

2010-02-03T19:23:00.000-02:00

A nova IDE Arduino 0018 foi liberada no dia 29/01/2010.

A nova versão traz modificações em bibliotecas, tais como:

Bug consertado do pino R/W LCD
Adicionado parâmetro de precisão para trabalhar com FLOAT
Bug consertado dos pinos analógicos no Arduino MEGA

Todas as novidades no release notes são (em inglês):

0018 - 2010.01.29
[core / libraries]
* Added tone() and noTone() functions for frequency generation.
* Added Serial.end() command.
* Added precision parameter for printing of floats / doubles.
* Incorporated latest version of Firmata.
* Fixed bug w/ disabling use of the RW pin in the LiquidCrystal library.
* No longer disabling interrupts in delayMicroseconds().
* Fixed bug w/ micros() returning incorrect values from within an interrupt.
* Fixed bug that broke use of analog inputs 8-15 on the Mega.

[environment]
* Synchronized with the Processing 1.0.9 code base, bringing various fixes,
including to a bug causing saving to fail when closing the last sketch.
* Added support for third-party hardware in the SKETCHBOOK/hardware folder,
mirroring the current structure of the hardware folder in Arduino.
* Added Ctrl-Shift-M / Command-Shift-M shortcut for serial monitor.
* Hold down shift when pressing the Verify / Compile or Upload toolbar
buttons to generate verbose output (including command lines).
* Moving build (on upload) from the applet/ sub-folder of the sketch
to a temporary directory (fixing problems with uploading examples from
within the Mac OS X disk image or a Linux application directory).
* Fixed bug the prevented the inclusion of .cpp and .h (or .c and .h) files
of the same name in a sketch.
* Improved the Mac OS X disk image (.dmg): added a shortcut to the
Applications folder, a background image with arrow, and new FTDI drivers.

Links:

Para download do Arduino 0018 clique no link correspondente ao seu sistema operacional:
Windows
Mac OS X
Linux (32bit)

PING))) Sensor Ultrasonico para medir distancia

2010-01-27T19:21:00.002-02:00

PING))) é um sensor ultrasonico, fabricado pela empresa Parallax. Ele detecta a distancia de objetos em frente ao sensor (+/- 3m). Ele trabalha enviando sinais de ultrasom e os recebendo de volta pelo principio do eco quando este encontrar um objeto. O Arduino irá calcular a distancia a partir do sinal enviado pelo PING))), sendo assim a duração do sinal (pulso) é proporcional a sua distancia.

Pode ser facilmente encontrado no ML (Mercado Livre.com).

Circuito:

O pino 5V do PING))) é conectado ao pino 5V do Arduino, o pino GND ao GND e o pino SIG (sinal) é conectado ao pino digital 7 do arduino.

Sketch:

const int pingPin = 7;

void setup() {
   // initialize serial communication:
   Serial.begin(9600);
 }

void loop()
 {
   // establish variables for duration of the ping, 
   // and the distance result in inches and centimeters:
   long duration, inches, cm;

// The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
   // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
   pinMode(pingPin, OUTPUT);
   digitalWrite(pingPin, LOW);
   delayMicroseconds(2);
   digitalWrite(pingPin, HIGH);
   delayMicroseconds(5);
   digitalWrite(pingPin, LOW);

// The same pin is used to read the signal from the PING))): a HIGH
   // pulse whose duration is the time (in microseconds) from the sending
   // of the ping to the reception of its echo off of an object.
   pinMode(pingPin, INPUT);
   duration = pulseIn(pingPin, HIGH);

// convert the time into a distance
   inches = microsecondsToInches(duration);
   cm = microsecondsToCentimeters(duration);

Serial.print(inches);
   Serial.print("in, ");
   Serial.print(cm);
   Serial.print("cm");
   Serial.println();

delay(100);
 }

long microsecondsToInches(long microseconds)
 {
   // According to Parallax's datasheet for the PING))), there are
   // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
   // second).  This gives the distance travelled by the ping, outbound
   // and return, so we divide by 2 to get the distance of the obstacle.
   // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
   return microseconds / 74 / 2;
 }

long microsecondsToCentimeters(long microseconds)
 {
   // The speed of sound is 340 m/s or 29 microseconds per centimeter.
   // The ping travels out and back, so to find the distance of the
   // object we take half of the distance travelled.
   return microseconds / 29 / 2;
 }

Construir um Sensor de proximidade por Infravermelho

2010-01-26T16:26:00.000-02:00

Bem, com certeza todos já conhecem os famosos sensores de proximidade por infravermelho da SHARP que custam entre 20 e 30 euros lá fora:

Bom, eu fiz o meu por R$0,00 e vou ensinar como!

Primeiro recolher o material necessário:

- Sensor IR

- LED IR

- Transistor NPN (usei o BC547)

- Caneta velha

Como gosto de reciclar, encontrei logo 2 receptores de infravermelhos e alguns transístores em uma lataria velha que guardo aqui em casa. Os receptores são assim:

Estes vão ser os que vocês vão encontrar certamente, mas eles funcionam de maneira diferente. O Maior coloca "0 / LOW" em "out" enquanto não detecta infravermelho mas assim que detecta coloca "1 / HIGH". O pequeno funciona ao contrário. Decidi usar o pequeno pois é o que se adaptava melhor ao que queria fazer.

Com um tubo de caneta opaco, corte-o em duas partes com 5cm cada uma:

Com a pistola de cola quente, colei o Sensor IR a um lado dos tubos:

Fiz o mesmo com o outro tubo para o LED e em seguida colei os tubos um ao lado do outro:

Vamos agora às ligações. As ligações são bastante simples, o sensor tem 3 pinos, 2 para alimentação e o outro pino que ou tem o valor lógico 1 ou 0.

O sensor tem uma maneira engraçada de funcionar. O que estes sensores fazem é detectar variações de luz, por exemplo, quando pressionamos um botão em um controle remoto, o LED dele pisca com uma determinada frequência (+/- 33KHz) e o que o sensor da TV ou video detecta é esta variação. Estes sensores não detectam apenas, única e exclusivamente luz infravermelha, eles "apanham" tudo (são um pouco mais sensiveis ao IR claro). Se nós acendermos um LED IR em frente a este sensor veremos ele detectar qualquer coisa por um breve momento e a estabilizar logo em seguida, isto porque ele internamente "satura" a esse comprimento de onda. É por isso que quando estamos em casa, de luzes ligadas, conseguimos mudar de canal com o nosso controle remoto.

Para ligar o LED há um pequeno senão, como o valor no pino varia tão rápido, se ligarmos o LED direto, este parece que nem acende e sim desta forma nem precisamos de uma resitência. É aqui que entra o transístor, com ele conseguimos ter o LED a brilhar a todo o seu explendor e a frequência desejada!

Fica tudo mais ou menos assim:

É isto que temos de fazer então, colocar o LED IV a piscar (a qualquer valor na frequência dos KHz) e ver se o sensor detecta qualquer coisa!

Para colocar o LED a piscar decidi criar uma interrupção com um timer, de modo a que de cada vez que esta ocorresse acendia ou apagava o LED. Na função loop fico à espera que o sensor detecte alguma coisa. Simples não é?

Sketch:

#include
#define irx 2 // Sensor IR no pin digital 2

static boolean output = HIGH; // Variável para defenir o estado do LED de infravermelhos, é estática para ser usada durante a interrupção

void setup(){
pinMode(irx, INPUT); // Pin onde está o LED infravermelhos é pin output
Serial.begin(9600); // Iniciar comunicação Serial com o computador...
MsTimer2::set(5, flash); // Defenir intrrupções de 5 em 5 ms e durante a interrupção é chamada a função flash
MsTimer2::start(); // Iniciar interrupções
}

void loop(){
while(digitalRead(irx)); // Enquanto não houver nada no Sensor não sai daqui, o sensor coloca 1 quando n detecta nada e passa a 0 qd detecta algo
Serial.println("ICEBERG!"); // Oi.. Apanhou qualquer coisa... OH NÂO É UM ICEBERG... OH GOD, THE PAIN, CAN YOU FEEL THE PAIN?
// MAYDAY MAYDAY!
// - Alô diz iz German Cost Guard, can we help you? (Sotaque alemão)
// YES, YES! We're SINKING!
// - Okay so what are you sinking (thinking) about? (ahha XD)
}

void flash() { // Função chamda durante a interrupção
digitalWrite(12, output); // Anceder ou apagar o LED IR
output = !output; // Alterar o output...
}

Criando Caracteres no LCD

2010-01-13T19:59:00.000-02:00

Já precisou usar uma seta para direita no LCD em seu trabalho? ou para esquerda? ou para baixo/cima? Tentou upar códigos e mais códigos e nada? Aqui esta a solução para você...

Com este software online você consegue criar qualquer caractere em uma matriz de 5 x 8 quadrados.

Link para o software criador de caracteres

Exemplo de Sketch:

#include   //inicia biblioteca LCD

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //configura pinos 

byte newChar[8] = {
 B00100,      //vetor aonde é criado os caracteres
 B00100,      //no caso em questao, 1 = escrito
 B00100,      //0 = apagado
 B00100,
 B00100,
 B11111,
 B01110,
 B00100
};

void setup() {
 lcd.createChar(0, newChar); //Chama função para criar caractere
 lcd.begin(16, 2); //inicia LCD
 lcd.write(0); //escreve LCD
}

void loop() {}

Comunicação Serial Arduino <> Host

2010-01-13T19:39:00.004-02:00

A conexão serial vai ser usada para fazer a ponte com o computador em aplicações software-hardware e também para subir novos códigos que podem ser compilados usando as funções e tutoriais compatíveis com arduino.

Para isto você vai precisar de um cabo serial preparado para trocar dados com o microprocessador, que pode ser feito como o desenho do esquema abaixo, com um plug db9 fêmea (conhecido como cabo serial).

Feito o cabo agora basta fazer as conexões usando um chip inversor de polaridade para as portas Rx Tx (porta lógica NOT). Estamos fazendo nesta figura com um cmos4069, chip facilmente encontrado e que não deve custar mais que alguns centavos.

A comunicação Rx Tx é a ponte para conectar seu microprocesador com outros softwares ou hardwares em tempo real, utilizando este protocolo. Você poderia também fazer esta comunicação entre outro microprocessador, teclados MIDI, ou dispositivos USB, só pra ter uma idéia.

Mas vamos usar aqui esta técnica por também ja resolver nosso problema de precisar reprogramar nosso projeto.

Feitas todas conexões você já pode acessar o seu software da IDE do arduino e selecionar a conexão ttyS0 para a comunicação serial direta. Se você estiver utilizando um adaptador serial-usb conectado no db9 basta delecionar a conexão ttyUSB0.

Gravando o BootLoader

2010-01-13T19:34:00.000-02:00

O primeiro passo a partir de que você tem um atmega8 ou amega168 virgem é preparar um circuito para gravação do “bootloader” do arduino.

O bootloader ( numa analogia bem tosca) é como se fosse a “bios” do seu computador - ele é o programa que vai ficar em loop no seu microprocessador esperando comandos para executar dentro de ciclos de tempo: como abrir e fechar portas analógicas e digitais, receber ou enviar pulsos para estas e fazer comunicação com outro hardware pelo protocolo serial.

O software que está pronto para compilar estas funções e subir estes códigos “de arduino” no seu microprocessador pode ser encontrado neste LINK.

Mas antes que você comece a usar as funcões “de arduino” em seu microprocessador atmel, você precisa subir este pequeno programa. Isso só pode ser feito com um gravador específico. O gravador que nós vamos utilizar é o mais simples possível, feito com alguns resistores e um cabo de porta paralela.

A pinagem utilizada é a que segue neste esquema:

Abaixo um exemplo em foto de como ficará seu cabo (atenção para a comparação com o esquema, pois o desenho abaixo está de ponta cabeça em relação a este)

Em seguida você deve preparar uma protoboard para receeber o chip e aplicar as voltagens do gravador. Perceba que o esquema da protoboard é exatamente o mesmo que depois iráser usado para seu arduino artesanal no dia a dia, apenas estamos dando outro uso para ele, baseado na configuração virgem do microprocessador.

A pinagem (que será conectada no cabo paralelo feito anteriormente) vai funcionar da seguinte maneira:

Agora se tudo estiver correto, basta iniciar o software de compilação do arduino (arduino IDE) e escolher o microprocessador atmega8 ou atmega168. Utilize as versões “NG older” para este esquemático que dispomos neste tutorial.

Em seguida basta escolher o gravador “Parallel Programmer”:

Se tudo der certo no final seu console vai mostrar “Done Uploading”.

A partir daí vocẽ ja pode gravar códigos de arduino, utilizando a conexão serial!

Pinos Arduino's

2010-01-13T19:29:00.000-02:00

Para iniciarmos a montagem do Arduino em uma ProtoBoard, necessitamos seu circuito e devidos pinos:

Testador de Cristais

2010-01-11T20:37:00.000-02:00

Quando vou trabalhar com Microcontroladores tenho sempre a mesma dificuldade! Encontrar algum cristal ressonante que esteja funcionando no meio de tanta tralha velha que ainda guardo no meu quarto.

Então por um passeio tipico pela internet, encontrei um circuito muito bom para testar e verificar se o cristal está ou não em ótimas condições de trabalho.

Circuito:

Circuito Testa Cristal

R1 = 100K

R2 = 2K2

R3 = 330 OHM

Q1, Q2 = 2N3563

D1 = 1N4148

C1, C2 = 220pF

C3 = 100pF

C4 = 0.1uF (100 nF)

D2 = LED VERMELHO (ULTRA BRILHO)

Materiais Diversos: Garras Jacaré, Clip para bateria de 9V, Fios, Solda, etc...

O transistor Q1, um 2N3563 e seus associados formam um circuito oscilador que sómente irá oscilar se um Cristal bom estiver conectado nas garras do teste. A saída do oscilador, é retificada pelo diodo 1N4148 e filtrada por C3, um capacitor de 100pF. A voltagem positiva sobre o capacitor é aplicada à base de Q2, outro 2N3563, causando sua condução. Quando isso acontece, a corrente flui através do Led. Se o cristal estiver bom, o Led irá indicar. Também poderá ser utilizado os transistores NTE123AP, PN100 ou 2N3904.

E que tal falar um pouco mais sobre EEPROMs?

2010-01-11T17:45:00.000-02:00

Quase todos devem saber o que são e o que acontece quando começamos a ficar sem espaço no nosso microcontrolador e temos a necessidade de migrar dados, ou então quando queremos fazer muitos registros e os míseros bytes de memória que o nosso microcontrolador tem não são suficientes.

EEPROM 24LC256

Pois bem as EEPROMs são mesmo nossas amigas e então as i2c são tão fáceis de implementar que ao fim de algum tempo nem nos lembramos que as temos na protoboard. Estas ocupam apenas os pinos 4 e 5 analógicos do Arduino, ocupando um endereço no BUS (leia post I2C), ou seja, podemos continuar com todos os outros dispositivos i2c que lá tinhamos ligados anteriormente.

A EEPROM que vou usar neste tutorial é uma 24LC256 da Microchip. Esta EEPROM tem 32K endereços a 8 bits fazendo dela uma EEPROM com 256 Kbits memória!

A Atmel, assim como outras marcas, também têm estas EEPROMS. A da Atmel é a 24C256, mas as memórias da Microchip são bem melhores! As da Microchip aguentam os dados por mais de 200 anos, na Atmel é só 40; As da Microchip vão para mais de um milhão de ciclos escrita, as da Atmel só vão para 100 mil. A Microchip dá 3 pinos para endereço, a Atmel só dá dois.

As ligações são estas:

Os pinos A0 a A2 servem para indicar o endereço da EEPROM no bus i2c, se estiverem todos ligados ao GND o endereço no Arduino é 0x50. Assim, conseguimos ter até 8 EEPROMS no mesmo bus fazendo 2Mbit de memória!

O pino WP é o pino que indica se a EEPROM está protegida contra escita, se ligarem este pino a VCC não podem escrever na EEPROM e se o ligarem ao GND já podem, é como o botão nos cartões de memória.

Depois de ligar isto tudo vamos lá testar! Para o teste liguem o WP a GND.

Sketch:

#include // Para a EEPROM 24LC256, assim chamamos as bibliotecas i2c

#define eeprom 0x50 // endereço da eeprom já shiftado

void setup(void){

Wire.begin(); // Iniciar ligações i2c

Serial.begin(9600); // Assim podemos ver qualquer coisa no console serial

unsigned int address = 0; //endereçamento a 2 bytes

Serial.println("A escrever o melhor numero de sempre nos 10 primeiros bytes!");

for(address = 0; address<10; address++)

writeEEPROM(eeprom, address, '3');

Serial.println("Vamos ler se esta tudo ok, deve ver 33, 33, 33, 33... 10x 33");

for(address = 0; address<10; address++) {

Serial.print(readEEPROM(eeprom, address), HEX);

Serial.print(", ");

}

void loop(){}

//-------Rotinas para EEPROMS i2c por Daniel Gonçalves------

// Podem usar estas rotinas à vontade para projectos particulares.

// Para fins comerciais entrar em contato com we_real_cool@hotmail.com

void writeEEPROM(int deviceaddress, unsigned int eeaddress, byte data ) {

Wire.beginTransmission(deviceaddress);

Wire.send((int)(eeaddress >> 8)); // MSB

Wire.send((int)(eeaddress & 0xFF)); // LSB

Wire.send(data);

Wire.endTransmission();

}

byte readEEPROM(int deviceaddress, unsigned int eeaddress ) {

byte rdata = 0xFF;

Wire.beginTransmission(deviceaddress);

Wire.send((int)(eeaddress >> 8)); // MSB

Wire.send((int)(eeaddress & 0xFF)); // LSB

Wire.endTransmission();

Wire.requestFrom(deviceaddress,1);

if (Wire.available()) rdata = Wire.receive();

return rdata;

}

Biblioteca EEPROM

2010-01-11T17:30:00.000-02:00

O microcontrolador Arduino tem 512bytes de EEPROM (memória na qual os valores ficam armazenados mesmo sem alimentação) disponível para uso. Esta biblioteca proporciona a leitura e a escrita desses bytes.

A função EEPROM.write(address, value)

Escreve um byte na EEPROM.

adress: O local para escrever (endereço), de 0 até 511 (tipo int)

value: o valor para escrever, de 0 até 255 (tipo byte (binário))

O datasheet do Atmega (uControlador Arduino) diz que a sua EEPROM tem uma vida útil de 100.000 ciclos de leitura/escrita, o que significa que 100.000 é o limite para você poder obter dados desta memória. Tenha isso em mente para projetos que demandem grande expectativa de via útil e muita movimentação de dados.

Também especifica que um ciclo de escrita demora 3,3ms para ser completado, sendo assim não precisa criar um delay para isto, porém sempre tenha cuidado com manipulação muito rápida de dados.

Exemplo:

#include

void setup()

{

for (int i = 0; i < 512; i++)

EEPROM.write(i, i);

}

void loop()

{

}

A função EEPROM.read(address)

Lê um byte da EEPROM, sendo que os endereços que constarem como nulos (que nunca tenham sido gravados), irão assumir 255 como valor.

address: o local a ser lido, de 0 até 511 (tipo int)

Retorna o valor gravado no endereço especificado.

Exemplo:

#include

int a = 0;

int value;

void setup()

{

Serial.begin(9600);

}

void loop()

{

value = EEPROM.read(a);

Serial.print(a);

Serial.print("\t");

Serial.print(value);

Serial.println();

a = a + 1;

if (a == 512)

a = 0;

delay(500);

}

Protocolo I2C, uma breve descrição!

2010-01-11T16:27:00.000-02:00

Protocolo I²C ou I2C

O protocolo I²C foi desenvolvido pela Philips em 1996, e veio para ficar pois este permite uma boa modelarização das comunicações, baixando o tempo e custo de desenvolvimento de dispositivos, assim como uma grande flexibilidade no funcionamento, consumindo pouca corrente, e sendo bastante imune a ruídos.

Deixemos-nos de teorias pois não é o objectivo deste artigo, existe muita informação sobre este barramento e por isso vamos tentar apenas criar aqui um local de fácil compreensão e consulta do protocolo.

Começamos então pelo modo Standard, ou Single Master.

O barramento é conhecido por utilizar apenas dois fios para comunicação entre vários dispositivos electrónicos (128 slaves creio eu devido à estrutura que iremos analisar mais à frente.), mas contudo este necessita de 4 fios, dois de alimentação, e os dois fios de dados.

Estes são então:

VCC (normalmente +5V)
GND (massa comum entre os equipamentos, muito importante para que quando os dispositivos queiram dizer zero, o consigam dizer de forma perceptível para todas as outras máquinas)
SDA (Serial DAta Line)
SCL (Serial CLock)

No esquema a baixo pode-se facilmente identificar a estrutura da rede:

R --> pullup opcional, raramente são mencionadas mas devem de se usar entre 4KOhm a 10KOhm.

Assim, como na maioria dos barramentos, meter um fio a VCC (quer este seja a 5V ou até mesmo a 3,3V, pois testei a utilização de 3,3V para este barramento e funciona sem quaisquer problemas, mesmo com um master a comunicar e a ler entre 0V~5V) significa mete-lo a HIGH, ou a estado binário 1 (um).

E como é de calcular, se os estados são binários, serão o oposto ou seja meter um fio a GND (0V quer para um circuito entre 0V~5V quer para entre 0V~3,3V) significa mete-lo a LOW, ou estado 0 (zero).

Assim passo a mostrar o esquema de comunicações:

Passando então a explicar:

Start bit é gerado pelo Master
7 bits de endereço são dados pelo master para dizer com que slave pretende comunicar
1 bit indica se existe intenção de escrita ou de leitura nesse dispositivo
slave após se ter identificado com aquele endereço diz que tomou conhecimento
1 byte (8 bits) de dados são mandados para o slave ou pelo salve dependendo da intenção anterior de R/W
após cada thread de dados um ack bit é dado pelo outro dispositivo para dizer que recebeu o byte inteiro
a tarefa repete-se desde o ponto 5 até que seja dado o stop bit representado por um Fim no esquema

Bits de start e de stop:

Outras condições de estado:

SDA só pode variar com SCL a LOW, e quando SCL subir SDA tem que se manter estável até que SCL desça. Qualquer variação de SDA enquanto SCL esta a HIGH será interpretado como um START ou STOP bit.
O dispositivo que está endereçado naquele momento ou acaba de ficar endereçado deve de responder com um acknowledge bit após cada byte transmitido. O master gerará um SCL extra após cada byte, ao qual o slave deverá fazer pull down do SDA para que o master saiba que o byte foi bem recebido.

Disponível em: Protocolo I2C

2010-01-11T14:18:00.000-02:00

Coisas interessantes que acontecem na Internet, todos os dias.

Disponivel em:

DanielAndrade

analogRead()

2010-01-08T16:37:00.002-02:00

Lê o valor de um pino analógico especificado. A placa Arduino contém um conversor analógico-digital de 10 bits com 6 canais (8 canais no Mini e no Nano). Com isto ele pode mapear voltagens de entrada entre 0 e 5 volts para valores inteiros entre 0 e 1023. Isto permite uma resolução entre leituras de 5 volts / 1024 unidades ou 0,0049 volts (4.9 mV) por unidade.

São necessários aproximadamente 100 μs (0.0001 s) para ler uma entrada analógica, portanto a velocidade máxima de leitura é de aproximadamente 10.000 vezes por segundo.

Sintaxe

analogRead(pin)

Parâmetros

pin: o número do pino analógico que se deseja ler (0 a 5 na maioria das placas, 0 ta 7 no Mini e no Nano)

Retorno

int (0 a 1023)

Note

Se o pino analógico não estiver conectado a nada o valor de retorno do analogRead() vai variar de acordo com uma grande quantidade de fatores (e.g. os valores de outras entradas analógicas, a distância de sua mão à placa, etc.). Na prática é um valor aleatório.

Exemplo

 
int analogPin = 3;     // perna do meio de um potenciómetro conectada ao pino analógico 3
                       // pernas externas conectadas ao terra e ao +5V
int val = 0;           // variável para armazenar o valor lido
void setup()
{
  Serial.begin(9600);          //  inicial a comunicação serial
}

void loop()
{
  val = analogRead(analogPin);    // lê o pino de entrada
  Serial.println(val);             // informa o valor lido 
}

analogWrite()

2010-01-08T16:36:00.002-02:00

Escreve um valor analógico (onda PWM) em um pino. Pode ser usado para acender um LED variando o brilho ou girar um motor a velocidade variável. Depois de realizar um analogWrite(), o pino vai gerar uma onda quadrada estável com o ciclo de rendimento especificado até que o próximo analogWrite() seja realizado (ou que seja realizado um digitalRead() oudigitalWrite() no mesmo pino). A freqüência do sinal PWM é de aproximadamente 490Hz.

Nas novas placas Arduino (incluindo o Mini e o BT) com o chip ATmega168 esta função é eficiente nos pinos 3,5,6,9,10 e 11. Placas Arduino mais antigas com um ATmega8 suportam o analogWrite() apenas nos pinos 9,10 e 11.

Sintaxe

analogWrite(pin, valor)

Parâmetros

pin: o pino no qual se deseja escrever

valor: o rendimento do ciclo: entre 0 (sempre desligado) e 255 (sempre ligado).

Retorno

nenhum

Notas e problemas conhecidos

Não é necessário realizar um pinMode() para pré-determinar o comportamento do pino como saída antes de realizar um analogWrite().

As saídas PWM geradas pelos pinos 5 e 6 terão rendimento de ciclo acima do esperado. Isto se deve às interações com as funções millis() e delay(), que compartilham o mesmo temporizador interno usado para gerar as saídas PWM.

Exemplo

Torna o brilho de um LED proporcional ao valor lido em um potenciómetro.

 
int ledPin = 9;      // LED conectado ao pino digital 9
int analogPin = 3;   // potentiómetro conectado ao pino analógico 3
int val = 0;         // variável para armazenar o valor lido

void setup()
{
  pinMode(ledPin, OUTPUT);   // pré-determina o pino como saída
}

void loop()
{
  val = analogRead(analogPin);   // lê o pino de entrada
  analogWrite(ledPin, val / 4);  // os valores do analogRead variam de 0 a 1023, os valores do analogWrite variam de 0 a 255

}

digitalRead()

2010-01-08T16:35:00.003-02:00

Lê o valor de um pino digital especificado, HIGH ou LOW.

Sintaxe

digitalRead(pin)

Parâmetros

pin: o número do pin digital que você quer ler (int)

Retorno

HIGH ou LOW

Exemplo

 

int ledPin = 13; // LED conectado ao pino digital 13

int inPin = 7;   // botão conectado ao pino digital 7
int val = 0;     // variável para armazenar o valor lido
void setup()
{
pinMode(ledPin, OUTPUT);      // pré-determina o pino digital 13 como uma saída
pinMode(inPin, INPUT);      // pré-determina o pino dgital 7 como uma entrada
}
void loop()
{
val = digitalRead(inPin);   // lê o pino de entrada
digitalWrite(ledPin, val);    // acende ou apaga o LED de acordo com o pino de entrada
}

Transfere para o pino 13 o valor lido no pino 7 que é uma entrada.

Nota

Se o pino não estiver conectado a nada digitalRead() pode retornar tanto HIGH como LOW (e isso pode variar aleatoriamente).

Os pinos de entrada analógica podem ser usados como pinos digitais e devem ser referenciados com os números de 14 (entrada analógica 0) a 19 (entrada analógica 5).

HIGH / LOW

2010-01-08T16:34:00.000-02:00

Escreve um valor HIGH ou um LOW em um pino digital. Se o pino foi configurado como uma saída (output) com o pinMode(), sua voltagem será determinada ao valor correspondente: 5V (ou 3.3V nas placas de 3.3V) para HIGH, 0V (terra) para LOW.

Se o pino está configurado como uma entrada (input) escrever um HIGH levantará o resistor interno de 20KΩ (tutorial de pinos digitais). Escrever um LOW rebaixará o resistor.

Sintaxw

digitalWrite(pin, valor)

Parâmetros

pin: o número do pin

valor: HIGH ou LOW

Retorno

nenhum

Exemplo

 
int ledPin = 13;                 // LED conectado ao pino digital 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // determia o pino digital como uma saída
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // acende o LED
  delay(1000);                  // espera um segundo
  digitalWrite(ledPin, LOW);    // apaga um led
  delay(1000);                  // espera um segundo
}

Nota

Os pinos de entrada analógica podem ser usados como pinos digitais e devem ser referenciados com os números de 14 (entrada analógica 0) a 19 (entrada analógica 5).

pinMode

2010-01-08T16:32:00.002-02:00

Configura o pino especificado para que se comporte ou como uma entrada (input) ou uma saída (output). Veja a descrição dos pinos digitais para mais detalhes.

Sintaxe

pinMode(pin, mode);

Parâmetros

pin: o número do pin o qual você deseja predeterminar.

mode: pode ser INPUT ou OUTPUT

Retorno

Nenhum

Exemplo

int ledPin = 13;                 // LED conectado ao pino digital 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // predetermina o pino digital como uma saída
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // acende o LED
  delay(1000);                  // espera um segundo
  digitalWrite(ledPin, LOW);    // apaga o LED
  delay(1000);                  // espera um segundo
}

Nota

Os pinos de entrada analógica podem ser usados como pinos digitais e devem ser referenciados com os números de 14 (entrada analógica 0) a 19 (entrada analógica 5).

Elementos de sintaxe

2010-01-08T16:02:00.006-02:00

; (ponto e vírgula)

Usada para terminar uma sentença.

Exemplo
int a = 13;

Dica

Esquecer de finalizar uma linha com ponto e vírgula causa um erro de compilação. O texto sobre o erro pode ser óbvio e se referir a um ponto e vírgula faltando, ou não. Se ocorrer um erro de compilação impenetrável ou aparenetemente ilógico uma das primeiras coisas a checar é um ponto e vírgula faltando na vizinhança, precedendo a linha indicada pelo compilador.

{} (chaves)

Chaves são uma parte essencial da linguagem de programação C. Elas são usadas em muitas construções diferentes, descritas abaixo, e isto pode algumas vezes ser confuso para iniciantes.
Uma chave abrindo "{" deve sempre ser seguida por uma fechando "}". Frequentemente nos referimos a esta condição como equilibrio entre as chaves. A IDE (integrated development environment ou ambiente de desenvolvimento integrado) do Arduino inclui uma característica prática para checar o equilibrio das chaves. Apenas com o selecionar de uma chave ou clicar no ponto imediatamente posterior faz com que sua companheira lógica seja destacada.
No presente momento esta característica é um pouco defeituosa e a IDE frequentemente encontrará (incorretamente) uma chave em um bloco de texto que tenha sido comentado.
Programadores principiantes e programadores vindos das linguagens C e do BASIC frequentemente consideram o uso das chaves confuso ou desalentador. Afinal as mesmas chaves substituem a sentença RETURN em uma subrotina(função), a sentença ENDIF em uma condicional e a sentença NEXT em um FOR.
Por que o uso das chaves é tão variado, é uma boa prática de programação digitar o fecha-chaves "}" logo após digitar o abre-chaves "{" quando estiver fazendo uma construção que as requer. Inserte então alguns "ENTER" entre as chaves e comece a digitar o código. Agindo assim suas chaves nunca ficarão desequilibradas.
Chaves desequilibradas causam erros de comilação bastante enigmáticos e que podem ser difíceis de rastrear em um programa longo. Por causa de seus usos variados, as chaves são também incrivelmente importantes para a sintaxe de um programa e mover uma chave uma ou duas linhas pode alterar completamente o seu significado.
Os principais usos das chaves

Funções
void myfunction(datatype argument){
sentença(s)
}
Loops
while (expressão booleana)
{
sentença(s)
}

do
{
sentença(s)
} while (expressão booleana);

for (inicialização; condição de término; expressão de incremento)
{
sentença(s)
}
Sentenças condicionais

if (expressão booleana)
{
sentença(s)
}

else if (expressão booleana)
{
sentença(s)
}
else
{
sentença(s)
}

// (comentarios)

Comentários são linhas no programa que são usados para informar a você mesmo ou outras pessoas sobre o modo como o progama trabalha. Elas são ignoradas pelo compilador e não são exportadas para o processador e portanto não ocupam a memória do chip ATmega.
O único propósito dos comentários são ajudar a entender (ou relembrar) como o programa funciona. Há dois modos diferentes de marcar uma linha como um comentário.

Exemplo

x = 5; // Esta é uma linha simples de comentário. Qualquer coisa depois das barras é um comentário
// até o fim da linha

/* este é um bloco de comentário - usado para "comentar" blocos inteiros de código

if (gwb == 0){ // não há problema em uma linha simples dentro de um bloco de comentário
x = 3; /* mas outro bloco de comentário é inválido */
}
// não esqueça de fechar o bloco de comentário, eles têm que ser equilibrados
*/

Dica
Quando estiver experimentando com o código "comentar" partes do programa é um modo conveniente de remover linhas que podem conter problemas. Este procedimento mantém as linhas no código mas as trasnforma em comentários de modo que o compilador as ignora. Isto pode ser especialmente útil quando tentamos localizar um problema, ou quando um programa apresenta erros de compilação cujas explicações são obscuras ou inúteis.

/* */ (Bloco de Comentarios)

Comentários são linhas no programa que são usados para informar a você mesmo ou outras pessoas sobre o modo como o progama trabalha. Elas são ignoradas pelo compilador e não são exportadas para o processador e portanto não ocupam a memória do chip ATmega.
O único propósito dos comentários são ajudar a entender (ou relembrar) como o programa funciona. Há dois modos diferentes de marcar uma linha como um comentário.
Exemplo

x = 5; // Esta é uma linha simples de comentário. Qualquer coisa depois das barras é um comentário
// até o fim da linha

/* este é um bloco de comentário - usado para "comentar" blocos inteiros de código

if (gwb == 0){ // não há problema em uma linha simples dentro de um bloco de comentário
x = 3; /* mas outro bloco de comentário é inválido */
}
// não esqueça de fechar o bloco de comentário, eles têm que ser equilibrados
*/

Dica
Quando estiver experimentando com o código "comentar" partes do programa é um modo conveniente de remover linhas que podem conter problemas. Este procedimento mantém as linhas no código mas as trasnforma em comentários de modo que o compilador as ignora. Isto pode ser especialmente útil quando tentamos localizar um problema, ou quando um programa apresenta erros de compilação cujas explicações são obscuras ou inúteis.

#define
é um componente muito útil da linguagem C que permite ao programador dar um nome a uma constatnte antes que o programa seja compilado. Constantes definidas no Arduino não ocupam espaço em memória no chip. O compilador substitui referêancias a estas constantes pelo valor definido no momento da compilação.

Isto pode causar alguns efeitos indesejáveis se, por exemplo, um nome de constante que tenha sido defindo por um #define é incluido em alguma outra constante ou nome de variável. Neste caso o texto deve ser substituido pelo valor (ou texto) do #define.

Em geral, a palavra chave const é preferível para definir constatntes e deve ser usada ao invés de #define.

A sintaxe do #define na linguagem Arduino é a mesma da linguagem C:
Sintaxe
#define nomeDeConstante valor
Verifique que o # é necessário.
Exemplo

#define ledPin 3
// O compilador vai substituir quanquer menção a ledPin pelo valor 3 no momento da compilação.
Dica
Não há ponto e vírgula após a declaração #define. Se você incluir um o compilador vai lançar erros críticos no final do programa.
#define ledPin 3; // isto é um erro
Do mesmo modo o compilador gerará erros se após o #define houver um =.
#define ledPin = 3 // isto também é um erro

#include

é usado para incluir outras bibliotecas no seu programa. Isto permite ao programador acessar um grande número de bibliotecas padrão da linguagem C (grupos de funções pré-definidas), e também à bibliotecas desenvolvidas especificamente para o Arduino.
A página principal de referência para as bibliotecas C AVR (AVR é a referência aos chips Atmel nos quais o Arduino está baseado) está aqui.
Verifique que #include, de modo similar ao #define, não leva ponto e vírgula no final.
Exemplo
Este exemplo inclui uma biblioteca que é utilizada para armazenar dados na memória flash ao invés de na ram. Isto economiza espaço na ram para as necessidades de memória dinâmica e torna o uso de grandes tabelas mais prático.
#include

prog_uint16_t myConstants[] PROGMEM = {0, 21140, 702 , 9128, 0, 25764, 8456,
0,0,0,0,0,0,0,0,29810,8968,29762,29762,4500};

goto

2010-01-08T16:01:00.000-02:00

Transfere o fluxo do programa para um outro ponto etiquetado

Sintaxe

label:

goto etiqueta; // envia o fluxo do programa para etiqueta

Dica

O uso do goto é desencorajado em programação C e inclusive alguns autores afirmam que o goto nunca é realmente necessário, mas usado com cautela pode simplificar alguns programas. A razão pela qual muitos programadores desaprovam seu uso é que com o uso indiscriminado é fácil de se criar um programa com um fluxo indefinido e muito difícil de ser depurado.

No entanto, há casos em que o goto pode ser útil e simplificar o código. Uma destas situações é provocar uma saída de um grupo de loops aglutinados ou de blocos lógicos if com uma determinada condição.

Exemplo

for(byte r = 0; r < 255; r++){
    for(byte g = 255; g > -1; g--){
        for(byte b = 0; b < 255; b++){
            if (analogRead(0) > 250){ goto bailout;}
            // more statements ... 
        }
    }
}
bailout:

return

2010-01-08T16:00:00.002-02:00

Finaliza uma função e retorna um valor, se necessário.

Sintaxe:

return;

return valor; // ambas formas são válidas

Parâmetros

valor: alguma variável ou constante

Exemplos:

Uma função para comparar o valor de um sensor com um limite

 int checkSensor(){       
    if (analogRead(0) > 400) {
        return 1;
    else{
        return 0;
    }
}

A palavra-chave return é útil para testar uma seção de código sem ter que transformar em "comentário" um grande e possivelmente defeituoso bloco de código.

void loop(){

// aqui, uma brilhante idéia de programação

return;

// restante do bloco de código não funcional
// este código nunca será executado
}

continue

2010-01-08T15:58:00.002-02:00

continue é usado para saltar porções de código em blocos do, for, ou while. Ele força com que o código avance até o teste da condição saltando todo o demais.

Exemplo

for (x = 0; x < 255; x ++)
{
    if (x > 40 && x < 120){      // criar saltos de execução
        continue;
    }

    digitalWrite(PWMpin, x);
    delay(50);
}

break

2010-01-08T15:57:00.002-02:00

break é usado para sair de um bloco do, for, ou while, se sobrepondo à condição normal de verificação. Também é usado para sair de uma sentença switch.

Examplo

for (x = 0; x < 255; x ++)
{
    digitalWrite(PWMpin, x);
    sens = analogRead(sensorPin);  
    if (sens > threshold){      // checar a detecção por um sensor
       x = 0;
       break;
    }  
    delay(50);
}

do

2010-01-08T15:56:00.002-02:00

O do funciona da mesma maneira que o while loop, com a exceção de que a condição é testada no final do bloco de código. Enquanto no while, se a condição for falsa, o bloco de código não será executado, no do ele sempre será executado pelo menos uma vez.

do
{
    // bloco de código
} while (condição);

Exemplo

do
{
  delay(50);          // espera para que os sensores se estabilizem
  x = readSensors();  // verifica o sensor

} while (x < 100);

while

2010-01-08T15:55:00.002-02:00

while fará com que o bloco de código entre chaves se repita continua e indefinidamente até que a expressão ente parentesis() se torne falsa. Algo tem que provocar uma mudança no valor da variável que está sendo verificada ou o código vai sempre ficar dando voltas dentro do while. Isto poderia ser o incremento de uma variável ou uma condição externa como o teste de um sensor.

Syntax

while(expressão){
  // código
}

Parâmetros

expressão - uma sentença boolena em C que possa ser verificada como verdadeira ou falsa

Exemplo

var = 0;
while(var < 200){
  // algum código que se repete 200 vezes
  var++;
}

for

2010-01-08T15:47:00.000-02:00

A sentença for é utilizada para repetir um bloco de código delimitado por chaves. Um contador com incremento normalmente é usado para controlar e finalizar o loop. A sentença for é util para quanquer operação repetitiva, e é frequentemente usada com arrays para operar em conjuntos de dados ou de pinos.

Há três partes no cabeçalho do for:

for (inicialização; condição; incremento) {

//sentença(s);

}

A inicialização ocorre primeiro e apenas uma vez. Cada vez que o circuíto é executado a condição é verificada; se for verdadeira o bloco de código e o incremento são executados, e então a condição é testada novamente. Quando a condição se torna falsa o circuíto termina.

Exemplo

// Aumentar o brilho de um LED usando um pino PWM
int PWMpin = 10; // um LED em série com um resisotr de 1kΩ no pino 10

void setup()
{
  // nenhum setup é necessário
}

void loop()
{
   for (int i=0; i <= 255; i++){
      analogWrite(PWMpin, i);
      delay(10);
   } 
}

Dica de programação

Na linguagem C o circuito for é muito mais flexível que os circuitos for encontrados a algumas outras linguagens de programação, incluindo BASIC. Qualquer dos elementos do cabeçalho pode ser omitido, embora os ";" sejam necessários. Qualquer destes elementos também podem ser substituidos por qualquer sentença válida em C com varáveis não correlatas. Estes tipos não usuais de sentenças for as vezes podem ser a solucão para alguns problemas raros de programação.

switch case

2010-01-08T15:46:00.000-02:00

Do mesmo modo que as sentenças if, as switch / case controlam o fluxo dos programas. Switch/case permite ao programador construir uma lista de "casos" dentro de um bloco delimitado por chaves. O programa checa cada caso com a vaiável de teste e executa o código se encontrar um valor idêntico.

Switch / case é um pouco mais flexível que uma estrutura if/else de modo que o programador pode determinar se a estruturaswitch deve continuar checando por valores idênticos na lista dos "caosos" após encontrar um valor idêntico. Se a sentençabreak não é encontrada após a execução do bloco de código selecionado por um dos "casos", então o programa vai continuar a checar por mais valores idênticos entre os "casos" restantes. Se uma sentença break é encontrada o código sai da estrutura do mesmo modo que em uma construção if/else if.

Parâmetros

var - a variável para a qual você busca valores idênticos
default - se nenhuma outra condição for satisfeita o código que está no default é executado
break - sem o break a sentença switch vai continuar checando as outras sentenças case para quanquer outro possível valor idêntico. Se algum for encontrado será executado do mesmo modo, o que pode não ser o que você deseja. Break indica ao switch para parar de procurar por outros valores idênticos e sai da sentença switch.

Exemplo

  switch (var) {
    case 1:
      //faça alguma coisa quando var == 1
      break;
      // break is optional
    case 2:
      //faça alguma coisa quando == 2
      break;
    default: 
      // se nenhum valor for idêntico, faça o default
      // default é opcional
  }

if / else

2010-01-08T15:44:00.000-02:00

if/else permite um controle maior sobre o fluxo de código do que a sentença if básica, tornando possível que múltiplos testes sejam agrupados. Por exemplo, uma entrada analógica poderia ser verificada e uma ação específica seria tomada se o valor de input fosse menor que 500 e outra ação seria tomada se o input fosse 500 ou mais. O código seria assim:

if (pinFiveInput < 500)
{
  // ação A
}
else
{
  // ação B
}

else pode preceder outro teste if , e assim mltiplos testes, mutuamente exclusivos, podem ser realizados ao mesmo tempo.

Cada teste precede o próximo até que um teste com vavlor verdadeiro é encontrado. Quando um teste com valor verdadeiro é encontrado o seu bloco de código associado é execuatod e então o programa salta para a sequencia após todo o bloco if/else. Se a nenhum teste é atribuido o valor verdadeiro o bloco que estiver no else sozinho é executado, se houver algum.

Note que um bloco else if pode ser usado com ou sem um bloco else final. Um número ilimitado destes ramos else if é permitido.

if (pinFiveInput < 500)
{
  // faça a coisa A
}
else if (pinFiveInput >= 1000)
{
  // faça a coisa B
}
else
{
  // faça a coisa C
}

Outro modo de fazer testes de ramificações mutuamente exclusivas é através da sentença switch case.

if (condicional) e ==, !=, <, > (operadores de comparação)

2010-01-08T15:42:00.000-02:00

IF, que é usado juntamente com um operador de comparação, verifica quando uma condição é satisfeita, como por exemplo um input acima de um determinado valor. O formato para uma verificação if é:

if (algumaVariavel > 50)
{
  // faça alguma coisa
}

O programa checa se algumaVariavel (colocar acentos em nomes de variáveis não é uma boa idéia) é maior que 50. Se for, o programa realiza uma ação específica. Colocado de outra maneira se a sentença que está dentro dos parêntesis é verdadeira o código que está dentro das chaves roda; caso contrário o programa salta este bloco de código.

As chaves podem ser omitidas após uma sentença if se só houver uma única linha de código (definida pelo ponto e vírgula) que será executado de modo condicional:

if (x > 120)  digitalWrite(LEDpin, HIGH); 

if (x > 120)
digitalWrite(LEDpin, HIGH); 

if (x > 120) {digitalWrite(LEDpin, HIGH);}   // todos são corretos

A sentença que está sendo verificada necessita o uso de pelo menos um dos operadores:

Operadores de comparação:

 x == y (x é igual a y)
 x != y (x é não igual a y)
 x <  y (x é menor que y)  
 x >  y (x é maior que y) 
 x <= y (x é menor ou igual a y) 
 x >= y (x é maior ou igual a y)

Cuidado:

Tenha precaução com o uso acidental de apenas um sinal de igual (if (x = 10) ). O sinal de igual simples é um operador de designação e coloca o valor 10 na variável x. Ao contrário o sinal de igual duplo (if (x == 10) ), que é um operador de comparação, verifica se x é igual a 10 ou não. A última senteça só é verdadeira se x for igual a 10, mas a anterior sempre será verdadeira.

Isto ocorre por que a linguagem C (na qual o Arduino é baseado) atribui um valor à sentença (x=10) do seguinte modo: 10 é colocado na variável x (lembre o sinal de igual simples é um operador de designação), então x agora contém 10. Então o condicional 'if' atribui um valor a 10, que será sempre verdadeiro (TRUE), desede que números diferentes de zero são sempre equiparados à verdadeiro. Consequentemente, if (x = 10) será sempre verdadeiro, que não é o que pretendemos quando usamos um 'if'. Adcionalmente o valor 10 será guardado na variável x que também não é o que pretendemos.

Estrutura void loop()

2010-01-08T15:39:00.000-02:00

Após criar uma fução setup() que declara os valores iniciais, a função loop() faz exatamente o que seu nome sugere, entra em looping (executa sempre o mesmo bloco de código), permitindo ao seu programa fazer mudanças e responder. Use esta função para controlar ativamente a placa Arduino.

Exemplo

 
int buttonPin = 3;

// setup inicializa o serail e o pino do button(botão)
void setup()
{
  beginSerial(9600);
  pinMode(buttonPin, INPUT);
}

// loop checa o botão a cada vez,
// e envia o serial se ele for pressionado
void loop()
{
  if (digitalRead(buttonPin) == HIGH)
    serialWrite('H');
  else
    serialWrite('L');

  delay(1000);
}

Estrutura void setup()

2010-01-08T15:37:00.000-02:00

A função setup() é chamada quando um programa pomeça a rodar. Use esta função para inicializar as sua variáveis, os modos dos pinos, declarar o uso de bibliotecas, etc. Esta função será executada apenas uma vez após a placa Arduino ser ligada ou resetada.

Exemplo

 
int buttonPin = 3;

void setup()
{
  Serial.begin(9600);
  pinMode(buttonPin, INPUT);
}

void loop()
{
  // ...
}

Arduino e a linguagem C

2010-01-08T15:34:00.001-02:00

Bom pessoal, o que todos acreditam saber sobre o ARDUINO é que ele é compilado em liguagem C, mas será essa a verdade? Para quem já cursou um técnico em Informática sabe que a linguagem de programação utilizada pela IDE do Arduino está longe de ser um C puro e sim uma mistura de C, C+, C++, JAVA e por ai vai...

Eu nem sei por que diabos escrevi isto, mas foi um modo de começar a falar de linguagem de programação...

Como estou sem idéias para projetos, vou postar em uma nova tag "Compilando", como usar a linguagem ARDUINO!

Leitura de temperatura com Arduino + LM35 (Melhorado)

2010-01-07T20:16:00.000-02:00

Hoje o post, é sobre o leitor de temperatura utilizando o LM35, porém inserindo um LCD e recalculando a temperatura em Kelvin e Farenheit.

Código:

//Leitura de Temperatura em Celsius, Kelvin e Farenheit com o Arduino
//Sketch V1.1
//Autor, Danilo de Nadai Sicari - 12/12/09
//esquema para ligação do LCD, disponivel em post antigo

#include

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int lm35=0;
int c, k, f, temp;

void setup() {

  pinMode(lm35, INPUT);
  lcd.begin(16, 2);
  lcd.print("THERMLCD v1.1");
}

void loop() {

  temp = ( 5 * analogRead(lm35) * 100 ) / 1024;
  c = temp;
  k = temp + 273.15; //calcula Farenheit
  f = 32 + (1.8 * temp);//calcula Kelvin

  lcd.setCursor(0, 1); //exibe Celsius em decimal
  lcd.print(c, DEC);
  lcd.setCursor(3, 1);
  lcd.print("C");

  lcd.setCursor(6, 1); //exibe Farenheit em decimal
  lcd.print(f, DEC);
  lcd.setCursor(9, 1);
  lcd.print("F");

  lcd.setCursor(12, 1); //exibe Kelvin em decimal
  lcd.print(k, DEC);
  lcd.setCursor(15, 1);
  lcd.print("K");

  delay(60000); //aguarda 1 min. para realizar nova leitura e atualizar LCD
}

Espero que curtam, e boa sorte!

Att, denadai.sicari