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.