terça-feira, 31 de julho de 2012

Interligando Microcontrolador e LabView

Então vamos colocar as mãos no teclado e partir para o primeiro programa utilizando o Arduino e dessa vez o PIC também vai entrar na jogada, e é claro o LabView!
Esse projeto é um dos rápidos, mas que pode ser utilizado para implementar em outros mais complexos.

Vamos começar primeiro com o Arduino, a ideia aqui vai ser enviar 5 Strings, ou seja, vou enviar de uma vez só pela porta serial uma frase, que contem os dados separados por virgula.


// o scan from string tem que ter %[^,] como parametro para pegar os valores entre as virgulas

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

void loop() 
{
    Serial.print("teste_1");
    Serial.print(",");
    Serial.print("teste_2");
    Serial.print(",");
    Serial.print("teste_3");
    Serial.print(",");
    Serial.println("");
    delay(1000);
    
}



Executando esse programa recebemos as seguintes informações na porta serial:


Da pra ver que essa parte é realmente muito fácil, as informações transferidas tem que estar entre as virgulas(ou qualquer outro separador esse é um exemplo, pelo LabView você determina isso).

Agora vamos ver um programa em C para o PIC usando o compilador C18 da Microship:

unsigned char teste_1[] = "teste_1;
unsigned char teste_2[] = "teste_2;
unsigned char teste_3[] = "teste_3;
unsigned char virgula[] = ",";
unsigned char espaco[] = "";

void main(void)
{
    
    while(1) // Laço infinito que executa o funcionamento principal do projeto.    
{
if(!BusyUSART())
{
putsUSART((char *) teste_1 );
  putsUSART((char *) virgula  );
  putsUSART((char *) teste_1 );
  putsUSART((char *) virgula  );
  putsUSART((char *) teste_1 );
  putsUSART((char *) virgula  );
  putsUSART((char *)  espaco );


Delay10KTCYx(240);                      //200ms
}
}//end while(1)
}//end main

Esse programa esta ressumido e não tem a parte de configuração, mas basicamente é isso, faz a mesma coisa que o código do Arquino faz, não vou entrar mais em detalhes porque em outros projetos vou cobrir mais a parte do PIC e em outros mais a parte do Arduino.

Passando para o LabView, vamos criar um novo projeto, a primeira etapa é criar o canal de comunicação entre o Microcontrolador e o LabView, no caso vamos usar a conexão serial, então vamos usar esse blocos no LabView,vamos utilizar o Visa Configure Serial Port, nele entraremos com todas informações sobre a conexão como velocidade, paridade de bits, data bits e etc...
Aqui tem um documento com muita informação boa sobre Visa Serial.

Ao adicionar os blocos e interligar eles aparecem automaticamente na parte de Projeto:


Essas configurações de porta serial eu uso em todos projetos envolvendo o microcontrolador seja utilizando rs-232,bluetooth ou até mesmo radio frequência, então eu deixo um template salvo e só edito como tratar as informações recebidas..

Com a porta serial comunicando, partimos para o próximo passo, temos que processar os dados, para isso utilizaremos o Visa Read, que vai fazer o trabalho de ler as Strings enviadas pelo microcontrolador.


Na figura o ponto laranja é o Visa Read, o ponto verde é o Scan From String, um bloco extremamente importante, pois ele recebe a String completa, e nele configuramos qual carácter vai ser o separados de dados, nesse exemplo será a ","(virgula), então ele recebe a informação bruta dessa forma: "teste_1,teste_2,teste_3,teste_4,teste_5," o papel do bloco é ler teste_1, e logo quando "ver" a virgula ignorar o resto da String,sendo assim podemos colocar vários blocos, e ajustar o offset para 1, cada bloco tem o papel de pegar a String e cortar a sua parte.

Certo agora temos as Strings picadas, mas esse valor é de texto, ele não assume valor numeral, assim temos que usar outro bloco para transformar essa String em decimal(ou qualquer outro tipo de conversão, fracionário,octal,hexa etc..). O bloco roxo é o Decimal String To Number.

Pronto agora temos o valor em decimal e podemos utilizar da maneira que for melhor, seja num gráfico, ou um tanque que vai enchendo de acordo com valor, ai vai mais da imaginação.
Esse projeto mesmo é só pra não deixar um buraco nessa parte de comunicação com LabView e como enviar os seus dados.Existem outras maneiras de enviar esses dados,como mandar as Strings separadas por um espaço, ao fazer a leitura da String bruta basta modificar o offset de onde vai começar a ler, assim cada bloco tem sua informação.O problema do uso dessa técnica é que por exemplo enviando: "XXXX YYY ZZZZ", esses valores podem alterar durante o programa, então vamos supor que dessa vez recebemos "XX YY ZZZ", o tamanho da String mudou, então os espaços estão em lugar diferente, e como seu offset é fixo os dados ignorados são picados, contendo informações do seu antecessor e adjacente.

Aqui está a programação em bloco do labview

Essa é a imagem do projeto completo em funcionamento, que pode ser editado e usado no futuro bem facilmente.


segunda-feira, 30 de julho de 2012

Projeto Chave Mecânica BCD

Encontrei essas peças em uma sucata(!). Muito bom o que você pode encontrar vasculhando por ai, o mais legal dessas chaves é que são mecânicas e tem a saída em formato BCD(Binary-coded decimal), ou seja, seguem a seguinte tabela:


Decimal
Digit
BCD
8 4 2 1
00 0 0 0
10 0 0 1
20 0 1 0
30 0 1 1
40 1 0 0
50 1 0 1
60 1 1 0
70 1 1 1
81 0 0 0
91 0 0 1



Então resolvi criar um programa para fazer a leitura dessas chaves, dessa vez estou usando o PIC 18F4550, hora de variar um pouco :-)



/******************************************************************************
 *
 *            VRO PROJETOS PLACA E-P18 (PIC18F4550)
 *
 ******************************************************************************
 * Dependencias:     Veja a seção INCLUDES abaixo
 * Microcontrolador:      PIC18F4550
 * Opção de Clock: HS 20MHz (externo) - CPU:48MHz (interno)
 * Compilador:         C18 v3.37 ou superior
 * Empresa:                 VRO Projetos
 * Plataforma: Placa E-P18 v3.6
 * Autor: Vinicius Rodrigues de Oliveira(viniciusro@gmail.com)
 * Versão: v1.0
 *****************************************************************************/
/** I N C L U D E S **********************************************************/
#include <p18cxxx.h>
#include <delays.h>
#include "displayLCD.h"
/** D E F I N E S ************************************************************/
//Entradas Digitais
#define  B0    PORTBbits.RB0
#define  B1    PORTBbits.RB1
#define  B2    PORTBbits.RB2
#define  B3    PORTBbits.RB3
#define  MULT1     PORTCbits.RC2
#define  MULT2     PORTDbits.RD0
#define  MULT3     PORTDbits.RD1
#define  BOTAO_1    PORTEbits.RE1
#define  BOTAO_2    PORTEbits.RE2
/** V A R I A V E I S   G L O B A I S ****************************************/
char chave   = 0;
char chave1 = 0;
char chave2 = 0;
char CHE     = 0;
char senha   = 0;
char senha1 = 0;
/**  P R O T O T I P O S   P R I V A D O S ***********************************/
void ConfiguraSistema(void);
/** F U N C O E S ************************************************************/
/******************************************************************************
 * Funcao:         void main(void)
 * Entrada:        Nenhuma (void)
 * Saída:            Nenhuma (void)
 * Descrição:     Função principal do programa. 
 *****************************************************************************/

/* Tabela BCD:       B0|B1|B2|B3
  0000       0
0001 1
0010 2
0011     3
0100     4
0101     5
0110     6
0111     7
1000     8
1001     9
*/
void main(void)
{


// Configura as portas e periféricos do PIC.
ConfiguraSistema();
B0=0;
B1=0;
B2=0; 
B3=0;
  MULT1=0;
  MULT2=0;
MULT3=0;

    while(1) // Laço infinito que executa o funcionamento principal do projeto.    
{

CHE++;


PosicaoCursorLCD(1,1);
EscreveFraseRomLCD("Multiplexando...");


PosicaoCursorLCD(2,1);
EscreveFraseRomLCD("CH1:");
PosicaoCursorLCD(2,5);
EscreveInteiroLCD(chave);


PosicaoCursorLCD(2,7);
EscreveFraseRomLCD("CH2:");
PosicaoCursorLCD(2,11);
EscreveInteiroLCD(chave1);


PosicaoCursorLCD(2,12);
EscreveFraseRomLCD("CH3:");
PosicaoCursorLCD(2,16);
EscreveInteiroLCD(chave2);
Delay10KTCYx(40);


if (CHE>3)
{
CHE=0;
}


if (CHE==0)
{
MULT1=1;
//Para Digito:0
if(B0==0 && B1==0 && B2==0 && B3==0)
{
chave=0;
Delay10KTCYx(10);
}
//Para Digito:1
if(B0==0 && B1==0 && B2==0 && B3==1)
{
chave=1;
Delay10KTCYx(10);
}
//Para Digito:2
if(B0==0 && B1==0 && B2==1 && B3==0)
{
chave=2;
Delay10KTCYx(10);
}
//Para Digito:3
if(B0==0 && B1==0 && B2==1 && B3==1)
{
chave=3;
Delay10KTCYx(10);
}
//Para Digito:4
if(B0==0 && B1==1 && B2==0 && B3==0)
{
chave=4;
Delay10KTCYx(10);
}
//Para Digito:5
if(B0==0 && B1==1 && B2==0 && B3==1)
{
chave=5;
Delay10KTCYx(10);
}
//Para Digito:6
if(B0==0 && B1==1 && B2==1 && B3==0)
{
chave=6;
Delay10KTCYx(10);
}
//Para Digito:7
if(B0==0 && B1==1 && B2==1 && B3==1)
{
chave=7;
Delay10KTCYx(10);
}
//Para Digito:8
if(B0==1 && B1==0 && B2==0 && B3==0)
{
chave=8;
Delay10KTCYx(10);
}


//Para Digito:9
if(B0==1 && B1==0 && B2==0 && B3==1)
{
chave=9;
Delay10KTCYx(10);
}
MULT1=0;
}


if (CHE==1)
{


MULT2=1;
//Para Digito:0
if(B0==0 && B1==0 && B2==0 && B3==0)
{
chave1=0;
Delay10KTCYx(10);
}
//Para Digito:1
if(B0==0 && B1==0 && B2==0 && B3==1)
{
chave1=1;
Delay10KTCYx(10);
}
//Para Digito:2
if(B0==0 && B1==0 && B2==1 && B3==0)
{
chave1=2;
Delay10KTCYx(10);
}
//Para Digito:3
if(B0==0 && B1==0 && B2==1 && B3==1)
{
chave1=3;
Delay10KTCYx(10);
}
//Para Digito:4
if(B0==0 && B1==1 && B2==0 && B3==0)
{
chave1=4;
Delay10KTCYx(10);
}
//Para Digito:5
if(B0==0 && B1==1 && B2==0 && B3==1)
{
chave1=5;
Delay10KTCYx(10);
}
//Para Digito:6
if(B0==0 && B1==1 && B2==1 && B3==0)
{
chave1=6;
Delay10KTCYx(10);
}
//Para Digito:7
if(B0==0 && B1==1 && B2==1 && B3==1)
{
chave1=7;
Delay10KTCYx(10);
}
//Para Digito:8
if(B0==1 && B1==0 && B2==0 && B3==0)
{
chave1=8;
Delay10KTCYx(10);
}


//Para Digito:9
if(B0==1 && B1==0 && B2==0 && B3==1)
{
chave1=9;
Delay10KTCYx(10);
}
MULT2=0;
}


if (CHE==2)
{


MULT3=1;
//Para Digito:0
if(B0==0 && B1==0 && B2==0 && B3==0)
{
chave2=0;
Delay10KTCYx(10);
}
//Para Digito:1
if(B0==0 && B1==0 && B2==0 && B3==1)
{
chave2=1;
Delay10KTCYx(10);
}
//Para Digito:2
if(B0==0 && B1==0 && B2==1 && B3==0)
{
chave2=2;
Delay10KTCYx(10);
}
//Para Digito:3
if(B0==0 && B1==0 && B2==1 && B3==1)
{
chave2=3;
Delay10KTCYx(10);
}
//Para Digito:4
if(B0==0 && B1==1 && B2==0 && B3==0)
{
chave2=4;
Delay10KTCYx(10);
}
//Para Digito:5
if(B0==0 && B1==1 && B2==0 && B3==1)
{
chave2=5;
Delay10KTCYx(10);
}
//Para Digito:6
if(B0==0 && B1==1 && B2==1 && B3==0)
{
chave2=6;
Delay10KTCYx(10);
}
//Para Digito:7
if(B0==0 && B1==1 && B2==1 && B3==1)
{
chave2=7;
Delay10KTCYx(10);
}
//Para Digito:8
if(B0==1 && B1==0 && B2==0 && B3==0)
{
chave2=8;
Delay10KTCYx(10);
}


//Para Digito:9
if(B0==1 && B1==0 && B2==0 && B3==1)
{
chave2=9;
Delay10KTCYx(10);
}
MULT3=0;
}

}//end while(1)

}//end main


/******************************************************************************
 * Funcao:          void ConfiguraSistema(void)
 * Entrada:         Nenhuma (void)
 * Saída:             Nenhuma (void)
 * Descrição:       ConfiguraSistema é a rotina de configuração principal do PIC.
 *      Seu objetivo é configurar as portas de I/O e os periféricos
 *      do microcontrolador para que os mesmos trabalhem da maneira
 *      desejada no projeto.  
 *****************************************************************************/
void ConfiguraSistema(void)
{
// Desabilita todas as analógicas
ADCON1 = ADCON1 | 0x0F;


// Configura o Diaplay LCD
ConfiguraLCD();
DesligaCursor();


// Configura saidas digitais
TRISCbits.TRISC2 = 0; 
TRISDbits.TRISD0 = 0; 
TRISDbits.TRISD1 = 0; 


// Configura entradas digitais
TRISBbits.TRISB0 = 1;   //Configura pino RB0 (Bit 1) como entrada digital
TRISBbits.TRISB1 = 1;   //Configura pino RB1 (Bit 2) como entrada digital
TRISBbits.TRISB2 = 1;   //Configura pino RB2 (Bit 3) como entrada digital
TRISBbits.TRISB3 = 1;   //Configura pino RB3 (Bit 4) como entrada digital
TRISEbits.TRISE1 = 1;   //Configura pino RE1 (botao 1) como entrada digital
TRISEbits.TRISE2 = 1;   //Configura pino RE2 (botao 2) como entrada digital

}//end ConfiguraSistema


/** V E C T O R   R E M A P P I N G ******************************************/
// Rotina necessária para o compilador C18 saber onde é o início do vetor de
// "reset".
// Copiar na íntegra esta parte do código dentro do arquivo "main.c" de TODO 
// projeto usado com o Bootloader no PIC.


extern void _startup (void);        // See c018i.c in your C18 compiler dir
#pragma code REMAPPED_RESET_VECTOR = 0x1000
void _reset (void)
{
   _asm goto _startup _endasm
}
/** FIM DO ARQUIVO main.c ***************************************************************/


E ai?! Acho mais difícil que o Arduino? Parece ser, mas não é assim, o PIC te da mais liberdade nas configuradões, você tem que fazer em todos programas.
O funcionamento é o seguinte uma variável fica incrementando a cada laço do programa,isso determina qual chave vai ser lida, é feita a varredura de todas chaves e utilizado a multiplexação para ler 4 chaves usando as mesmas portas, ativando uma de cada vez e guardando seu valor.Por exemplo, se CHE=0 então esta selecionada a chave 1, assim é feita a leitura digital de suas 4 saídas(BCD), de acordo com essa leitura temos o valor que esta na chave mecânica depois disso guardamos o valor em uma variável e passamos para outra chave e assim por diante.
A multiplexação é feita de uma forma que alimenta uma chave por vez, tornando possível utilizar apenas 4 portas para ler todas chaves simultaneamente, quando a chave 1 esta sendo lida as outras 3 chaves estão desligadas(isso vai ficar bem visível no video).

Os LED's na placa sinaliza qual chave esta ativa pra leitura a cada momento do programa.

domingo, 29 de julho de 2012

Arduino com Ethernet Shield lendo Twitter

Hoje surgiu a oportunidade de utilizar o Ethernet Shield com chip Wiznet W5100 e slot de cartão SD que comprei no dealextreme:
Esse shield em particular te abre uma gama muito grande de projetos, te da a liberdade de acessar a internet e utilizar o cartão SD dele para fazer logs e tudo mais, não vou entrar muito nos detalhes dele, num post futuro quem sabe. No Brasil esse mesmo shield chega a custar entre 250-350 reais, então vale a pena esperar 1 mês e receber da China com preço de 17 USD.

Eu comprei ele mas nunca fiz muitos testes, mas hoje apareceu uma ideia que pode ser muito útil.É o seguinte, eu acesso um computador remotamente para fazer algumas atualizações, esse computador fica ligado 24/7, nunca é desligado.Como nenhum sistema é perfeito, é comum o computador travar e eu perder o acesso remotamente, impossibilitando de executar as ações já que o LogMeIn não consegue ligar ele a distancia.
Hoje esse computador travou, e a única solução até então é ir pessoalmente e reiniciar ele, foi ai que eu tive a ideia de utilizar o Arduino+Ethernet+Twitter.

O Ethenet shield acessa a internet,mais precisamente o servidor do twitter e a minha conta e faz a leitura da ultima coisa que eu postei, depois de fazer essa leitura, o Arduino checa se ela se encaixa em alguma ação pre determinada nele. Essa faixa de código determina isso:

Foi feito um exemplo com um LED, que pode ser substituído por um relé ou qualquer outro componente para controlar qualquer tipo de carga remotamente.
Sendo assim você pode ligar e desligar o comutador, cortando a energia dele, ou internamente conectando ao botão de reset.
O programa esta muito bem comentado, e fácil de compreender, o tempo de refrescamento esta em 20000 milissegundos, ou seja, 20 segundos, e pode ser alterado para ter resposta mais rápido, mas achei melhor deixar 20 segundos para não sobrecarregar.



Código Completo:

/*
  Twitter Client

 Esse sketch conecta ao Twitter usando um Ethernet shield. Ele vasculha o XML
 retornado, e procura por <text>esse é um tweet</text>

 Circuito:
 * Ethernet shield ligado nos pinos 10, 11, 12, 13

por Vinicius R.
VRO Projetos
viniciusro@gmail.com

 Esse codigo é de dominio publico.

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

const int led = 7;
// entre com MAC e IP para seu controlador.
// O IP vai depender da sua rede:
byte mac[] = {0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x01};
IPAddress ip(192,168,1,20);

// inicia a biblioteca:
EthernetClient client;

const unsigned long requestInterval = 20000;  // delay entre pedidos

char serverName[] = "api.twitter.com";  // pagina do twitter URL

boolean requested;                   // se vc fez um pedido des de quando conectou
unsigned long lastAttemptTime = 0;            // ultima vez que vc estava conectado em milesegundos

String currentLine = "";            // string para guardar texto de servidor
String tweet = "";                  // string para guardar o tweet
boolean readingTweet = false;       // se vc está atualmente lendo o tweet

void setup() 
{
  pinMode(led, OUTPUT);
  // reserva espaço para as strings:
  currentLine.reserve(256);
  tweet.reserve(150);

 // abre comunicação serial e espera a porta abrir:
  Serial.begin(9600);

  // tenta conexão DHCP:
  Serial.println("Tentando pegar um IP usando DHCP:");
  if (!Ethernet.begin(mac)) 
  {
    // se o  DHCP falhar, começa tentar manualmente:
    Serial.println("não foi possivel pegar um IP usando DHCP, tentando manualmente");
    Ethernet.begin(mac, ip);
  }
  Serial.print("Meu IP:");
  Serial.println(Ethernet.localIP());
  // Conecta no Twitter:
  connectToServer();
}

void loop()
{
  if (client.connected()) 
  {
    if (client.available()) 
    {
      // ler os bytes de entrada:
      char inChar = client.read();

      // adiciona os bytes de entrada ao final da linha:
      currentLine += inChar; 

      // se vc receber "newline" nova linha, limpa a linha:
      if (inChar == '\n') 
      {
        currentLine = "";
      } 
      // se a linha atual terminar com <text>, vai ser seguida do tweet:
      if ( currentLine.endsWith("<text>")) 
      {
        // o tweet esta começando. Limpa a string tweet:
        readingTweet = true; 
        tweet = "";
      }
      // se vc esta atualmente lendo os bytes do tweet, adicona eles a String do tweet,
      if (readingTweet) 
      {
        if (inChar != '<') 
        {
          tweet += inChar;
        } 
        else 
          {
          // se vc receber um caracter "<", chegou ao final do tweet:
          readingTweet = false;
          Serial.println(tweet);
            if(tweet==">.215 ligado")
             {
              digitalWrite(led, HIGH);
              Serial.println("Computador .215 LIGADO");
             }   
            if(tweet==">.215 desligado")
             {
              digitalWrite(led, LOW);
              Serial.println("Computador .215 DESLIGADO");
             }   
            if(tweet==">status")
             {
              Serial.print("Computador .215 esta: ");
              int estado = digitalRead(led);
              if (estado==1)
                {
                 Serial.print("Ligado ");
                }
              if (estado==0)
                {
                 Serial.print("Desligado ");
                }
              Serial.println(estado);
             }
          // fecha conexão com servidor:
          client.stop(); 
        }
      }
    }   
  }
  else if (millis() - lastAttemptTime > requestInterval) 
  {
    // se vc não esta conectado, e passou 2 minutos des da sua ultima conexão
    // então tenta reconectar:
    connectToServer();
  }
}

void connectToServer() 
{
  // tenta conectar e espera em milesegundos:
  Serial.println("conectando no servidor...");
  if (client.connect(serverName, 80)) 
  {
    Serial.println("fazendo pedido de HTTP...");
    // faz pedido HTTP GET para o twitter:
    client.println("GET /1/statuses/user_timeline.xml?screen_name=viniciusrdo&count=1 HTTP/1.1");
    client.println("HOST: api.twitter.com");
    client.println();
  }
  // observa o tempo dessa tentativa de conexão:
  lastAttemptTime = millis();
}


Esse vídeo exemplifica seu funcionamento:




sábado, 28 de julho de 2012

Introdução LabView


O LabVIEW (acrónimo para Laboratory Virtual Instrument Engineering Workbench) é uma linguagem de programação gráfica originária da National Instruments. A primeira versão surgiu em 1986 para o Macintosh e atualmente existem também ambientes de desenvolvimento integrados para os Sistemas Operacionais Windows, Linux e Solaris.
Os principais campos de aplicação do LabVIEW são a realização de medições e a automação. A programação é feita de acordo com o modelo de fluxo de dados, o que oferece a esta linguagem vantagens para a aquisição de dados e para a sua manipulação.
Os programas em LabVIEW são chamados de instrumentos virtuais ou, simplismente, IVs. São compostos pelo painel frontal, que contém a interface, e pelo diagrama de blocos, que contém o código gráfico do programa. O programa não é processado por um interpretador, mas sim compilado. Deste modo a sua performance é comparável à exibida pelas linguagens de programação de alto nível. A linguagem gráfica do LabVIEW é chamada "G".

Retirei esse testo da Wikipédia, quem tiver afim de continuar a ler sobre é só abrir o link e ter uma ideia melhor.
O LabView surgiu para min quando um colega Vinicius Guerra do curso de Mecatrônica da PUC-MG que também gosta de microcontroladores surgiu com a ideia de um projeto, uma bancada para estudos de vibrações(depois eu posto esse projeto completo). Montar a bancada e colocar um motor para vibrar e os amortecedores era a parte tranquila do projeto, o difícil foi configurar um dispositivo para pegar esses dados e mostrar em forma de gráficos no computador em tempo real.
Foi ai que surgiu a necessidade de aprender alguma linguagem para poder juntar o melhor dos dois mundos, porque o microcontrolador apesar de ser um dispositivo poderoso, aliado com outras ferramentas abre uma gama muito maior de possibilidades.Pensei em usar o Matlab mas sinceramente nunca tive muita experiência e nunca tive muita força de vontade para aprender, sempre ouvi falar no Labview como uma ferramenta mais generalizada e com programação relativamente fácil feita em blocos, Já tinha visto o programa antes mas nunca tinha me atrevido a tentar fazer alguma coisa, surgiu a necessidade e cai de cara para aprender.


É muito difícil encontrar material sobre o assunto em português, principalmente voltado para microcontroladores, nesse projeto utilizamos o PIC 18F4550, que é muito poderoso(depois entro mais em detalhes quando colocar o projeto inteiro), esse PIC estava na placa da SEMPRA, uma empresa de Minas Gerais que promove cursos de Sistemas Microcontrolados. A maior parte do material que encontrei era em espanhol, mas o menu de ajuda do LabView é muito completo, cada bloco tem uma explicação de funcionamento com exemplos de ligações.


O programa é constituído por blocos que são interligados de maneiras distintas para gerar os resultados, existe uma versão que tem um toolkit para microcontroladores AVR o que torna mais fácil a comunicação, mas ao meu ver também preso ao programa deles. No meu caso eu usei comunicação serial comum, onde o LabView lia os dados e tratava de maneira diferente.



Ao adicionar os blocos, eles vão diretamente para o painel, onde toda ação acontece:


Essas imagens são de um projeto que esta em andamento, no próximo post vou mostrar mais detalhadamente a criação de um programa no Arduino bem simples para interagir com o LabView.



Hoje já conheço o Processing que caminha lado a lado com o Arduino, e que futuramente eu vou falar mais, apesar de não ter muita informação ainda.


sexta-feira, 27 de julho de 2012

Projeto Rápido - Arduino Alimentando Painel Solar

Então, meus projetos são divididos em 2 campos, projetos pequenos que faço muito rápido e projetos mais complexos,os projetos rápidos geralmente são bem simples, que tem funcionalidade unica, mas que agrega muito ao conhecimento podendo ser colocado em um projeto maior posteriormente.
É uma boa forma de checar se seu projeto mais complexo está funcionando dividindo ele em varias tarefas pequenas assim fica mais fácil de achar um possível erro.

O projeto de hoje é bem tranquilo, mas você tem que ter os componentes, que são muito específicos.
Nesse caso estou usando um painel solar de 5V e que pode fornecer até 130mA  do dealextreme.
Como o projeto tem que ficar no sol e não quero fios passando pelo meu quarto estou utilizando um transmissor bluetooth para comunicar via porta serial, esse dispositivo é muito fácil de configurar, basta adicionar um porta serial sobre seu bluetooth do computador e pronto, no Arduino basta enviar os dados serialmente. É claro vale respeitar a areá de alcance do bluetooth e a velocidade de transmissão, no caso estou utilizando 9600 bps, que é o padrão para esse tipo de comunicação.

E é claro o cérebro de todo funcionamento o Arduino UNO Rev 3, estou usando esse que comprei no dealextreme mesmo pois deixo ele pra "sofrer", tenho outro de uma loja brasileira, que é muito boa por sinal, mas que infelizmente no Brasil os preços são muito elevados.Vai ficar fácil de ver que compro muita coisa da China, pelo preço ser mais acessível, infelizmente o tempo de entrega que complica é geralmente de 1 mês e 2 semanas, nunca ter problema com encomendas extraviadas ou taxadas.

Sobre o projeto é bem simples, o arduino esta sendo alimentado pelo painel solar, o dispositivo bluetooth esta ligado nele (lembrando que o TX do arquino vai no RX do blueetoth) e uma bateria esta alimentando ele separadamente pelo simples fato de que ao fazer uma comunicação com PC se eu ficar perdendo essa ligação toda hora eu teria que ativar a todo momento perdendo o foco principal de ver quanto tempo o Arduino vai rodar com o painel solar alimentando ele.
Com a conexão bluetooth feita e o painel ligado é hora de achar o melhor local com maior incidência de sol, no caso a minha janela :-).


Muito bom! A luz de alimentação esta ligada e o Arduino rodando o programa:

void setup() 
  {
   Serial.begin(9600);
   Serial.println("Painel Solar Ativo");
  }
  
void loop() 
  {
   unsigned long tempo_atual = millis();
   Serial.print("Painel Solar Ativo Por: ");
   Serial.println(tempo_atual);
   delay(1000); 
  }




Esse programa faz o seguinte, quando a placa do Arduino é ligada ele envia "Painel Solar Ativo" pela porta serial para seu computador, ao receber isso sabemos que o painel esta recebendo intensidade luminosa suficiente para alimentar o circuito.Depois disso a variável "tempo_atual" recebe a função millis(); , que faz o seguinte: retorna um numero em milissegundos que é o tempo desde quando a placa do Arduino esta ligada, (esse número tem overflow apos aproximadamente 50 dias).Logo depois esse valor é enviado para o computador que mostra isso no terminal(eu uso o RealTerm). 



Bem com esses dados o circuito funcionou por 3429084 milissegundos, ou seja, 3429 segundos, que são incríveis 57 minutos!! Isso porque o painel estava na minha janela com algumas sombras, e so parou de funcionar por causa da posição do sol (!). Agora eu mudei ele de posição:


Bom é isso ai!!
No futuro penso em usar esse trecho de programa no meu seguidor solar,mas quero agora adicionar as funcionalidades do LabView nesse pequeno projeto assim como leitura analógica da tensão de entrada do painel e pesquisar um banco de capacitores para ajudar manter a placa ligada caso uma sombra ou coisa do tipo interrompa o sol por pouco tempo.