DS18B20 - Sensor de temperatura inteligente

DS18B20 - Sensor de temperatura inteligente

Neste tutorial iremos demonstrar como desenvolver sistemas de monitoramento de temperatura utilizando o sensor de temperatura DS18B20. Para demonstrar seu funcionamento, utilizaremos o Arduino uno.

[toc]

Sensores de Temperatura

Os sensores de temperatura são dispositivos que ajudam a identificar o nível de aquecimento de um determinado equipamento ou processo com o objetivo de fazer com que este permaneça em condições adequadas para o seu funcionamento.

Em virtude dos infinitos tipos de aplicações existentes, é fácil perceber a necessidade de uma vasta gama de sensores, os quais, de maneira individual, cumprem requisitos particulares de cada situação.

Aqui em nosso portal nós tempos dois tutoriais muito interessantes sobre medição de temperatura:

• LM35 - Medindo temperatura com Arduino
• DHT11 e DHT22 - Sensor de Humidade e Temperatura com Arduino
• Termopar tipo K + MAX 6675 - Medindo temperatura

O sensor de temperatura DS18B20

O sensor de temperatura DS18B20 é um termômetro digital produzido pela Dallas Instruments.

Em geral, sensores de temperaturas são analógicos (entenda Grandezas digitais e analógicas) e fornecem um valor de tensão ou corrente que será interpretado pelo Arduino ou outro microcontrolador.

Já o sensor DS18B20 possui sua própria inteligência. Ele é capaz de ler a temperatura, interpreta-la e enviar a informação do valor de temperatura em graus Celsius para o microcontrolador usando um barramento de apenar um fio (protocolo de comunicação One wire ou 1-wire ).

O sensor de temperatura DS18B20 pode medir temperaturas entre -55 ºC e 125 ºC com uma precisão de cerca de 0,5 ºC na faixa de -10 ºC e +85 ºC.

- Endereço único e fixo

Cada sensor DS18B20 possui um endereço serial exclusivo de 64 bits, de modo que, o desenvolvedor,  pode colocar vários sensores em um mesmo barramento, utilizando apenas uma única porta do microcontrolador e obter os valores de temperatura de cada sensor separadamente.

Assim, é simples usar um  microcoontrolador para controlar muitos DS18B20s distribuídos por uma grande área.

- Encapsulamento

O Sensor de temperatura DS18B20 é produzido com encapsulamento TO-92, que é o mesmo formato que o LM35.

Mas é muito comum encontrá-lo com proteção à prova d'água. É o mesmo sensor de temperatura, apenas soldam os fios nas pernas do DS18b20 e o colocam dentro de uma capsula metálica.

Veja que dentro do encapsulamento metálico podemos encontrar o DS18B20 em seu formato original:

Devido a sua versatilidade, esses sensores são muito usados e controle de climatização, monitoramento de temperatura de equipamentos e máquinas e monitoramento de processos e sistemas de controle.

É comum encontrá-los também no controle de temperatura de piscinas e banheiras aquecidas.

- Outras vantagens

Esse sensor ainda possui outros recursos muito interessantes que não serão usados nesse tutorial, mas fica a dica para futuros estudos:

• Modo parasita (Parasitic Power Mode): Ele pode ser alimentado usando o próprio barramento de comunicação, assim, em vez de usar 3 fios para ligar o sensor, seria usado apenas 2. Um para comunicação e alimentação e outro como referência;
• Alarme programável: É possível programar um alarme de temperatura alta e baixa.  para que quando a temperatura estiver fora desses valores o sensor sinalize. Esse configuração é gravada em uma memória não volátil EEPROM (Entenda o que é memoria não volátil);
• Resolução configurável: Por fim, é possível configurar qual a resolução que se deseja: 9, 10, 11 ou 12 bits.

Veja mais no Datasheet do sensor DS28b20.

Mãos à obra - Medindo temperaturas com um sensor DS18B20

Componentes necessários

Para desenvolver este projeto, precisaremos dos seguintes componentes:

• 1 x Arduino UNO
• 1 x Sensor de temperatura DS18B20

Montando o projeto

Programando

#include <OneWire.h>
#include <DallasTemperature.h>

OneWire pino(3);
DallasTemperature barramento(&pino);
DeviceAddress sensor;

void setup(void)
{
  Serial.begin(9600);
  barramento.begin();
  barramento.getAddress(sensor, 0);  
}

void loop()
{
  barramento.requestTemperatures(); 
  float temperatura = barramento.getTempC(sensor);
  Serial.print(temperatura);
  delay(500);
}

Colocando para funcionar

Entendendo a fundo

Hardware

- Protocolo One-Wire

Nesta seção nós vamos falar um pouco do protocolo de comunicação utilizado para fazermos com que os dados provenientes do sensor de temperatura DS18B20 cheguem até o nosso Arduino UNO o protocolo One-Wire (também referenciado como 1-Wire).

O protocolo One-Wire foi desenvolvido pela Dallas Semiconductor e consiste em um protocolo de comunicação cuja estrutura se dá em forma de um barramento, ou seja, sob a forma de uma linha única para transmissão de dados, na qual, podem ser conectados vários dispositivos, de modo que estes possam trocar informações com o nosso Arduino UNO.

Você pode estar pensando neste momento que o protocolo em questão é idêntico ao nosso famoso protocolo SPI, entretanto, apesar de parecerem iguais, o protocolo One-Wire trabalha com taxas de transmissão de dados mais baixas e também com um maior alcance do que o protocolo SPI.

- Endereço One-Wire

Cada elemento inserido no barramento irá possuir um determinado endereço, de modo que, o próprio barramento, através de um algoritmo de busca pode determinar quais são os endereços que estão sendo utilizados pelos dispositivos para que seja possível fazer com que o mestre, em nosso caso, o Arduino UNO possa interagir com os mesmos de maneira rápida e fácil.

Apenas como uma curiosidade, os endereços dos dispositivos são fixos e não podem ser alterados.

Software

Neste ponto, serão demonstrados todos os passos para o desenvolvimento do código que deve ser inserido no Arduino UNO para que seja possível a realização da medição de temperaturas com o sensor de temperatura DS18B20.

– Incluindo as bibliotecas que serão utilizadas

O primeiro passo que devemos realizar para atingir o objetivo proposto consiste na inclusão das bibliotecas adequadas para permitir a interação do sensor de temperatura DS18B20 com o  Arduino UNO. Neste tutorial, nós vamos utilizar duas bibliotecas, estas são: OneWire.h (que pode ser obtida aqui) e a DallasTemperature.h, que por sua vez, pode ser adquirida neste link.

#include <OneWire.h>
#include <DallasTemperature.h>

– Criando o objeto da classe Onewire

Na parte de criação de objetos, nós devemos criar primeiramente um objeto referente ao o pino que será utilizado para transmissão de dados.

OneWire pino(3);

– Criando o objeto da classe DallasTemperature

Em seguida, nós devemos criar o objeto que será responsável por representar o barramento de sensores em nosso código, associando o mesmo ao objeto pino, criado anteriormente. Neste momento, nós passamos a referência criada anteriormente (o objeto OneWire) para o objeto proveniente da biblioteca DallasTemperature (após a realização deste procedimento, nós iremos manipular somente a biblioteca DallasTemperature.h, de modo que, intrinsecamente ela mesma irá fazer o uso da biblioteca OneWire.h.

DallasTemperature barramento(&pino);

– Criando um objeto para o sensor

Em seguida, nós devemos criar o objeto que será responsável por representar o endereço do sensor de temperatura em nosso código (consequentemente, este objeto acaba representando o sensor em si, pois, ele está diretamente atrelado ao próprio endereço).

DeviceAddress sensor;

Como temos apenas um sensor, basta que nós criemos apenas um objeto do tipo DeviceAddress. No caso de termos mais de um sensor nós deveremos declarar um objeto do tipo DeviceAddress para cada elemento, ou seja, para dois sensores,  por exemplo, criaríamos os objetos sensor1 e sensor2.

– Definindo as configurações iniciais

Na função setup() nós vamos iniciar o nosso barramento de sensores através da sentença sensor.begin() e em seguida vamos armazenar o endereço do único sensor existente no barramento no objeto sensor. Além dos procedimentos realizados, nós vamos também iniciar a comunicação serial do nosso Arduino com a IDE do Arduino para imprimir os valores.

void setup() {
  Serial.begin(9600);
  barramento.begin(); 
  barramento.getAddress(sensor, 0)
}

Caso a nossa aplicação necessite a utilização de vários sensores nós podemos incluir alguns trechos de código responsáveis por fazer com que o barramento seja lido pelo Arduino e em seguida por fazer com que este informe para o leitor quantos sensores existem no mesmo. Estas linhas de código irão demonstrar os endereços físicos de cada sensor para o usuário, de modo que, caso testados um a um, será possível construir uma lista que possibilite identificar o sensor em aplicações que possuam vários sensores. Estas linhas de código podem ser inseridas após a sentença barramento.begin().

 Serial.print("Neste barramento foram encontrados ");
 Serial.print(barramento.getDeviceCount(), DEC);
 Serial.println(" sensores.");

Quando nós temos vários sensores em um mesmo barramento, os endereços dos mesmos serão armazenados de acordo com certos índices (começados com 0), que por sua vez, são utilizados para identificar os endereços existentes. Portanto, para dois sensores, por exemplo, podemos associar os endereços físicos encontrados pelo Arduino aos objetos do tipo DeviceAddress da seguinte forma:

barramento.getAddress(sensor1, 0)
barramento.getAddress(sensor2, 1)

– Realizando as medidas de temperatura

Dentro da função loop(), utilizamos a sentença barramento.requestTemperatures() para fazer a requisição das temperaturas obtidas ao longo do barramento e a sentença barramento.getTempC() para selecionar o valor referente à temperatura proveniente do nosso sensor e em seguida, armazenamos o mesmo dentro de uma variável do tipo float chamada temperatura.

void loop() 
{
  barramento.requestTemperatures();
  float temperatura = barrmento.getTempC(sensor);
  Serial.print(temperatura);
  delay(500);
}

De maneira análoga, no caso da existência de mais de um sensor de temperatura, basta utilizarmos a sentença barramento.getTempC() com o objeto do tipo DeviceAddress referente ao sensor desejado como parâmetro.

Considerações finais

Neste tutorial, demonstramos como você deve proceder para realizar medições de temperatura com um sensor DS18B20. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Controlando relés com um Arduino e ScadaBR

Controlando relés com um Arduino e o ScadaBR

Nos tutoriais anteriores nós demonstramos os procedimentos necessários para realizar a comunicação entre uma placa Arduino e o ScadaBR através do protocolo Modbus nas versões Serial e TCP/IP. Neste tutorial, vamos dar sequência ao desenvolvimento de projetos de automação, no entanto, ao contrário dos conteúdos anteriores, nós iremos ensinar como realizar o acionamento de múltiplas saídas digitais do Arduino por meio do ScadaBR.

[toc]

Série Arduino com ScadaBR

Este tutorial faz parte de uma série de tutoriais voltados para o ensino da utilização das placas Arduino em conjunto com o ScadaBR para o desenvolvimento de aplicações de automação. Atualmente, esta série conta com os seguintes tutoriais:

• ScadaBR com Arduino - Primeiros passos
• ScadaBR com Arduino via Modbus TCP/IP

Mãos à obra - Controlando relés com o ScadaBR

Componentes necessários

• 1 x Placa Arduino UNO Rev 3
• 1 x Shield Ethernet Wiznet W5100
• 1 x Módulo Relé 4 canais

Montando o projeto

Programando

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

const int RELE1_COIL = 0;
const int RELE2_COIL = 1;
const int RELE3_COIL = 2;
const int RELE4_COIL = 3;

ModbusIP mb;

void setup() 
{
   byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }
   byte ip[] = { 192, 168, 25, 16 }; 
   mb.config(mac,ip);  
   pinMode(2, OUTPUT);
   pinMode(3, OUTPUT);
   pinMode(4, OUTPUT);
   pinMode(5, OUTPUT);
   
   mb.addCoil(RELE1_COIL); 
   mb.addCoil(RELE2_COIL); 
   mb.addCoil(RELE3_COIL); 
   mb.addCoil(RELE4_COIL); 
}
 
void loop() 
{
   mb.task();
   digitalWrite(2, mb.Coil(RELE1_COIL));
   digitalWrite(3, mb.Coil(RELE2_COIL));
   digitalWrite(4, mb.Coil(RELE3_COIL));
   digitalWrite(5, mb.Coil(RELE4_COIL));
}

Configurando o Scadabr

Neste momento, vamos apresentar os procedimentos iniciais que devem ser feitos no ScadaBR para que seja possível realizar a interação entre mesmo e a nossa placa Arduino. Primeiramente, para cumprirmos o objetivo apresentado, devemos fazer com que o ScadaBR identifique o elemento com o qual irá se comunicar. Isto deve ser feito através da criação de um elemento chamado Data source, que por sua vez, será a ponte entre a placa Arduino que estamos utilizando e o ScadaBR.

Data source é a estrutura que permite a comunicação entre o Arduino e o ScadaBR

Em seguida, na criação do Data source, devemos dizer qual tipo de comunicação existirá entre os 2 elementos. Neste tutorial, vamos utilizar o protocolo Modbus IP, portanto basta encontrarmos a opção Modbus IP na lista de Data Sources e clicar no ícone à direita da lista em questão.

Em seguida, o ScadaBR irá nos direcionará para uma página, na qual, devemos definir os parâmetros do Data source em questão (lembre-se de que ele é a ponte entre o Arduino UNO e o ScadaBR). Em um primeiro momento, devemos apenas nomear o nosso Data source e também definir o tempo em que os dados serão atualizados (esta informação é muito importante, ou seja, torna-se fundamental que o leitor tenha conhecimento da aplicação que está desenvolvendo para que a escolha deste parâmetro resulte em um funcionamento eficaz do projeto).

Além destas configurações, devemos também especificar mais alguns parâmetros relativos à comunicação que será estabelecida, como por exemplo: o endeceço IP previamente configurado no código do Arduino UNO e o tipo de transporte (sugerimos a opção "TCP com manter-vivo" em um primeiro momento. Não há necessidade de alterarmos o campo Porta.

Após a criação e configuração do Data source, devemos criar pequenas estruturas denominadas Data point. Os Data points são os elementos que irão conter os valores relacionados com as entradas e saídas da nossa placa Arduino. Para realizar este procedimento, vamos até a parte inferior da tela e em seguida clicamos no ícone localizado à direita da tabela referente aos Data points.

Após clicarmos no ícone citado, o ScadaBR nos dará uma janela com algumas opções para serem definidas. Primeiramente, devemos nomear o Data point (neste tutorial, chamamos o mesmo de RELÉ 1). Em seguida, devemos garantir que campo Faixa do registro esteja com a opção Status do Coil selecionada.  Para salvar as configurações feitas, basta clicar no ícone existente na extremidade superior direita da janela.

Em seguida, devemos fazer os mesmos procedimentos para o relé 2, de modo que, desta vez, devemos associar o Offset do Data Point em questão com o valor atribuído no código do Arduino (neste caso, o número 1).

Em relação aos outros dois relés devemos fazer a mesma coisa, porém, para o relé 3, o campo offset será preenchido com 2 e no caso do relé 4, o campo offset deverá ser preenchido com 3.

A figura a seguir mostra como a tabela onde estão organizados os Data points ficará após a criação realizada anteriormente. Para habilitar o data point desejado basta clicar no círculo vermelho presente no campo Status do Data point criado.

Por fim, devemos ir ao topo da página, salvar as configurações realizadas (procedimento idêntico ao realizado no passo anterior) e habilitar o Data source, clicando novamente no círculo vermelho existente ao lado do ícone de utilizado para salvar.

Neste momento o leitor deve retornar a watch list (primeiro ícone da esquerda na barra de ferramentas) e no lado esquerdo da interface apresentada, clicar na seta para visualizar o estado do data point criado.

Após realizarmos o procedimento citado anteriormente, os nossos Data points aparecerão criados no lado direito da interface apresentada em nossa watch list.

Para acionarmos o relé, basta posicionarmos o mouse sobre o ícone localizado à esquerda do nome do Data point e alterar o valor do mesmo (repare que quando o valor do mesmo for 0 (zero), o relé estará apagado, ao passo que, quando alterarmos para 1(um) o relé será acionado).

Veja o resultado do acionamento do relé no ScadaBR.

.

Entendendo a fundo

Software

Neste ponto, serão demonstrados todos os passos para o desenvolvimento do código que deve ser inserido no Arduino UNO para que seja possível a realização da comunicação entre o mesmo e o ScadaBR.

– Incluindo as bibliotecas que serão utilizadas

O primeiro passo para o estabelecimento da comunicação entre os dois elementos consiste na inclusão das bibliotecas adequadas para a utilização do protocolo Modbus TCP/IP (desenvolvidas pelo  André Sarmento e estão disponíveis aqui). Além disso, devemos declarar também as bibliotecas responsáveis pelo funcionamento do protocolo de comunicação SPI e pela conectividade da nossa placa Arduino com a rede local.

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

– Definindo as estruturas do protocolo Modbus

Posteriormente, devemos determinar as estruturas que serão responsáveis pelo acionamento dos relés. Assim como nos tutoriais anteriores, nós iremos abordar apenas uma entre as demais estruturas existente no protocolo Modbus: os Coils. Estes elementos atuam no armazenamento de valores que podem ser utilizados no acionamento on/off de dispositivos.

Para definirmos os Coils que serão utilizados no acionamento dos relés basta declararmos quatro variáveis do tipo const int e em seguida atribuir um número à cada uma delas de acordo com a quantidade de Coils em uso no projeto (sempre começando com 0).

const int RELE1_COIL = 0;
const int RELE2_COIL = 1;
const int RELE3_COIL = 2; 
const int RELE4_COIL = 3;

– Criando o objeto mb

Antes de prosseguir para a função setup(), deve-se criar um objeto chamado mb para que possamos fazer o controla das estruturas existentes no protocolo Modbus.

ModbusIP mb;

– Definindo as configurações iniciais

Na função Setup() existem algumas linhas de código referentes às definições iniciais do programa. Primeiramente, devemos definir alguns parâmetros relacionados ao protocolo de comunicação utilizado, de modo que, este procedimento é realizado através da definição dos endereços MAC e IP da nossa placa Arduino UNO (na prática, o endereço MAC pode ser qualquer um, desde que seja único na rede, enquanto o endereço IP deve ser um endereço válido em sua rede local). Em seguida, para configurarmos o nosso protocolo Modbus, utilizamos a função config() em conjunto com os valores determinados anteriormente.

Em seguida, utilizamos a função pinMode() para definir os modos de operação dos pinos digitais 2,3,4,5 como saídas digitais e por fim, adicionamos os Coils que serão responsáveis por conter os valores utilizados no acionamento dos relés, através da função addCoil() .

void setup() {
  
 byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED } 
 byte ip[] = { 192, 168, 25, 16 }; 
 mb.config(mac,ip); 
 pinMode(2, OUTPUT);
 pinMode(3, OUTPUT); 
 pinMode(4, OUTPUT); 
 pinMode(5, OUTPUT);
 
 mb.addCoil(RELE1_COIL); 
 mb.addCoil(RELE2_COIL); 
 mb.addCoil(RELE3_COIL); 
 mb.addCoil(RELE4_COIL); 

}

– Realizando o acionamento do led

Dentro da função loop(), utilizamos a função task() para gerenciar a comunicação e a troca de dados entre os dispositivos que estão conectados através do protocolo Modbus. Além da função citada, temos também as funções necessárias para realizar a escrita dos dados referentes ao acionamento dos relés em suas respectivas instâncias Coil.

void loop() 
{
  mb.task();
  
  digitalWrite(2, mb.Coil(RELE1_COIL));
  digitalWrite(3, mb.Coil(RELE2_COIL)); 
  digitalWrite(4, mb.Coil(RELE3_COIL)); 
  digitalWrite(5, mb.Coil(RELE4_COIL));

}

Considerações finais

Neste tutorial, demonstramos como você fazer para acionar um conjunto de relés com Arduino e o ScadaBR, esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões. Além disso, lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Trava Elétrica Solenoide com Arduino

Trava elétrica solenoide com Arduino

Imagine que você esteja indo visitar um amigo que mora em um prédio. Muito provavelmente, você chegará, tocará o interfone e alguns segundos depois alguém atenderá o mesmo e abrirá o portão para que você possa entrar no mesmo e chegar até o apartamento onde o seu amigo mora. Por se tratar de algo comum em nosso dia a dia, nós não nos damos conta de todo o processo que acontece até o momento em que o portão é aberto e nem dos elementos que fazem parte do sistema em questão, sendo assim, neste tutorial vamos falar sobre um dos principais elementos de todo o contexto citado: a trava elétrica ou fechadura eletrônica. esse dispositivo permite que o portão possa ser aberto quando desejado e em outros instantes permaneça fechado, entretanto, de modo especial, aprenderemos como controlar uma mini-trava elétrica solenoide em conjunto com uma placa Arduino. Tal projeto nos dará base para futuros projetos de automação residencial, entre outros.

[toc]

A trava elétrica solenoide

A trava elétrica solenoide é um elemento muito semelhante as travas que possuímos nas portas das nossas casas, pois, ambos os tipos pressupõem uma estrutura dotada de uma saliência que impede ou libera a movimentação de uma porta em função da sua posição. A grande diferença entre essas duas modalidades é que enquanto a trava tradicional tem a posição de sua saliência alterada por meio de uma chave, as travas elétricas solenoide têm o estado das suas saliências alterado através da aplicação de um determinado nível de tensão em seus terminais.

Caso 12 V sejam aplicados nos terminais da nossa mini-trava elétrica solenoide, a saliência é recolhida, ou seja, vai para dentro da estrutura e permanece nesta posição enquanto o sinal de tensão estiver sendo aplicado. Em contrapartida, quando não há tensão nos terminais citados, fica para fora da estrutura impedindo a movimentação da porta.

Como você deve ter notado, para utilizarmos a nossa mini-trava elétrica solenoide nós precisamos aplicar um sinal contínuo de tensão de 12 V, no entanto, as nossas placas Arduino não são capazes de nos fornecer esta magnitude de tensão, portanto, podemos notar que precisaremos implementar algum tipo de ideia para atingirmos este objetivo. O que faremos neste tutorial é utilizar um relé cuja bobina possa ser energizada com 5V, de modo que, no momento da ocorrência deste fato, alguns de seus contatos serão fechados fornecendo o caminho para a corrente proveniente de uma fonte externa de 12 V.

Aqui em nosso portal nós temos alguns tutoriais muito interessantes sobre a manipulação de relés:

• Shield Ethernet W5100 - Acionamento remoto de relés com HTML
• Módulo relé - Acionando cargas com Arduino
• Acionando um módulo relé via Bluetooth

Mãos à obra - Acionando a mini-trava elétrica solenoide

Componentes necessários

Para desenvolver este projeto, precisaremos dos seguintes componentes:

• 1 x Arduino UNO
• 1 x Módulo Relé 4 canais ou outro.
• 1 x Mini trava elétrica solenoide 12V
• 1 x Fonte bivolt 12V 2A
• 1 x Adaptador P4/KRE 

Apenas como uma observação, neste tutorial nós utilizamos um Módulo relé 4 canais, mas poderíamos tranquilamente recorrer à um único relé ou um módulo com apenas 1 canal.

Montando o projeto

No esquemático de ligação do Arduino UNO com o Módulo relé 4 canais apresentado anteriormente, nós demonstramos a conexão entre os elementos citados utilizando todos os canais de relés, no entanto, neste projeto só utilizaremos o canal 4,  ligado a porta digital 5 do Arduino.

Programando

Aqui, nós iremos disponibilizar para você o código que utilizamos para desenvolver a aplicação deste tutorial

void setup() 
{
     Serial.begin(9600); 
     pinMode(5,OUTPUT);
     digitalWrite(5,HIGH);  
     Serial.print("Porta fechada");
}
void loop() 
{
  char comando;
  if (Serial.available()>0)
    {
        comando = Serial.read();
        if (comando == 'a') 
        {
           digitalWrite(5,LOW);
           Serial.print("Porta aberta");
           delay(2000);
           digitalWrite(5,HIGH);
           Serial.print("Porta fechada");
         }    
}

Colocando para funcionar

Em uma situação normal, a mini-trava elétrica se encontrará nesta posição:

Após aplicarmos o nível de tensão de 12V nos terminais da trava ela ficará desta forma:

Veja também o resultado que obtemos no Serial Monitor:

Entendendo a fundo

Hardware

- Alimentação

Alguns pontos devem ser ressaltados no tocante ao hardware utilizado neste tutorial. Primeiramente, para que fosse possível conectarmos a fonte de 12V tanto no módulo relé (fio +) quanto na nossa mini-trava elétrica solenoide (fio -) sem que fosse necessário cortarmos o fio da mesma, nós utilizamos um adaptador P4/KRE fêmea conforme a imagem abaixo.

- Normalmente Fechado e Normalmente Aberto

Um outro ponto muito importante que devemos evidenciar diz respeito ao funcionamento dos relés utilizados. Estes dispositivos possuem dois contatos:

• Um contato Normalmente Aberto (NA), que por sua vez, encontra-se aberto até o momento em que a bobina do relé é alimentada (momento em que este é fechado);
• e um contato Normalmente Fechado (NF), cujo principio de funcionamento é o inverso do apresentado anteriormente, ou seja, este permanece fechado até que a bobina do relé seja alimentada.

- Contato Normalmente Aberto do relé

Para desenvolver esta aplicação nós utilizamos o contato Normalmente Aberto (NA) do relé 4 do módulo utilizado para fazer com que a alimentação da fonte externa só chegasse até a mini-trava elétrica solenoide no momento em que a bobina do relé fosse energizada, ou seja, fechando o contato.

- A Trava elétrica normalmente fechada

Repare que esta forma de montagem faz com que em uma situação de, por exemplo, falta de energia, a porta fique trancada, pois, neste momento, a mini-trava não estará energizada e portanto a saliência da mesma estará para fora, impedindo a movimentação da porta.

É possível dizer que, em particular, essa trava elétrica trabalha como normalmente fechada. Ou seja, na ausência de energia ela se manterá fechada. Quando energizada ela será aberta.

Software

Nesta seção nós iremos explicar passo a passo o funcionamento do nosso código

– Definindo as configurações iniciais do projeto

Dentro da função setup(), temos a definição do modo de operação do pino que será utilizado neste projeto, isto é, do pino 5 como um pino de saída digital. Além desta configuração, por meio da função Serial.begin(), nós inicializamos o procedimento necessário para que seja possível estabelecer alguma comunicação através da porta serial e por último, com a função digitalWrite() nós pedimos ao Arduino que disponibilize nível lógico alto na saída digital previamente configurada (isto é feito para que o relé permaneça na condição inicial, pois, os relés do módulo utilizado são ativados com nível lógico baixo). Por último, nós enviamos uma mensagem através da porta serial indicando que a trava está trancando a porta.

void setup() 
{
   pinMode(5,OUTPUT);     
   Serial.begin(9600);     
   digitalWrite(5,HIGH);  
   Serial.print("Porta fechada");
}

– Trancando e destrancando uma porta

Na função loop() nós vamos primeiramente criar uma variável do tipo char chamada comando, que por sua vez, será responsável por armazenar os caracteres que chegarem através da porta serial. Em seguida, nós verificamos se o caractere em questão (enviado através do serial monitor) corresponde à letra a, de modo que, caso esta hipótese seja afirmativa, nós vamos fazer com que o Arduino disponibilize nível baixo na saída digital 5, fazendo com que o relé seja acionado e portanto a saliência da mini-trava seja recolhida. Por outro lado, após 2 segundos nesta posição nós soltamos a saliência com a utilização das funções delay() e digitalWrite().

Além disso, perceba que nós utilizamos sentenças Serial.print() para fazer com que o Arduino apresente as mudanças nos estados da trava sempre que ela for acionada ou desligada.

void loop() 
{
  char comando;
  if (Serial.available()>0)
    {
        comando = Serial.read();
        if (comando == 'a') 
        {
           digitalWrite(5,LOW);
           Serial.print("Porta aberta");
           delay(2000);
           digitalWrite(5,HIGH);
           Serial.print("Porta fechada");
         }    
}

Considerações finais

Neste tutorial, nós demonstramos como você fazer para utilizar a mini-trava elétrica solenoide em seus projetos,  esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Display Gráfico 128x64 com Arduino

Display gráfico 128x64

Neste tutorial você aprenderá a controlar o display gráfico 128x64 pixels em seus projetos. Aqui, abordaremos o uso das principais funções do display, como a inserção de caracteres especiais e de elementos como círculos, quadrados, box de texto e, além disso, você verá também o esquema de ligação utilizando o Arduino Mega.

[toc]

Contexto histórico

O display gráfico é largamente utilizado em celulares, painéis e interfaces IHM (interface homem máquina). Uma das grandes vantagens de sua utilização é o fato de funcionarem por pixels ao invés de caracteres definidos possibilitando a exibição de qualquer tipo de caractere, tamanho ou fonte. O display que iremos utilizar possui escrita branca, sendo composto por 128x64 pixels, ou seja, 128 pixels de comprimento e 64 pixels de largura.

Funcionamento do Display Gráfico 128x64

Este display possui a pinagem conforme a figura abaixo, tendo 8 portas de dados e 6 para controle, além da entrada de alimentação dos display assim como o controle de backlight (iluminação de fundo).

A tabela abaixo representa a função de cada pino do display com maiores detalhes.

Aplicações do Display Gráfico 128x64

O display gráfico pode ser utilizado em qualquer projeto que se deseja exibir uma informação ao usuário. Alguns exemplos de aplicação:

•  IHM;
• Osciloscópio;
• Medidor de energia elétrica;
• Jogos;
• Plotagem de funções;

Na área automobilística em projetos de veículos Baja, grande parte dos painéis são construídos com este tipo de display, a fim de exibir velocidade, rotação, nível de combustível e bateria, isso é possível devido sua ampla área de trabalho em relação à outros displays comerciais e também por sua robustez.

Mãos à obra- Conexão do Display Gráfico 128x64 com o Arduino

 Componentes Necessários

• 1 x​ ​Arduino Uno​ ou​ ​Arduino Mega
• 1 x ​Display Gráfico 128x64
• 1 x​ ​Potenciômetro 10KΩ
• 1 x​ ​Protoboard
• Fios Jumpers

Montando o Projeto

Agora chegou a hora de colocar a mão na massa, vamos​ conectar os componentes do projeto na protoboard.​ Antes disso, desligue o cabo USB de seu Arduino e posteriormente monte seu circuito conforme a figura a seguir.

Há duas observações que devemos ficar atentos. Uma delas está relacionada com a alimentação do display, de modo que, este deve ser ser alimentado com uma tensão de 5 Vdc. Outro ponto de atenção é que ao se utilizar o backlight (iluminação de fundo) haverá um consumo maior de corrente. Portanto, dependendo do consumo dos outros componentes do seu projeto, o Arduino não suportará e por proteção irá resetar constantemente. Nesse caso, é indicado que se utilize uma fonte externa ao invés da USB do Computador.

Conectando ao computador

Para iniciar o projeto, primeiramente conecte o Arduino ao computador por meio do cabo USB. Posteriormente, abra a IDE do Arduino e comece a programar.

Programando

Agora que toda a parte de hardware da aplicação está montada, vamos ao software responsável por controlar o display e exibir textos e formas nesse. Segue abaixo o código comentado que exemplifica o funcionamento do display gráfico 128x64.

// Biblioteca utilizada no Projeto
#include "U8glib.h"

//Configuração de Pinagem, Enable, RW, RS, RESET
U8GLIB_ST7920_128X64_1X Display(8, 7, 6 , 9);

// Rotina de Configuração da Escrita no Display
void Display_config() {

  Display.setFont(u8g_font_6x10);
  Display.setFontRefHeightExtendedText();
  Display.setDefaultForegroundColor();
  Display.setFontPosTop();
}

void Tela1() {

  Display.setFont(u8g_font_unifont);
  Display.drawStr(45, 15, "Vida");
  Display.drawStr(53, 40, "de");
  Display.drawStr(35, 60, "Silicio");
}

void Tela2() {

  Display.setFont(u8g_font_unifont);
  Display.drawBox(0, 0, 128, 64);
  Display.setColorIndex(0);
  Display.drawStr(4, 35, "Vida de Silicio");
  Display.drawStr(5, 35, "Vida de Silicio");
  Display.drawFrame(1, 1, 126, 62);
}

void Tela3() {

  Display.setFont(u8g_font_helvB08);
  Display.drawStr(45, 31, "Arduino");
  Display.drawStr90(105, 15, "Display");
  Display.drawStr270(20, 55, "Eletronica");
}

void Tela4() {

  Display.setFont(u8g_font_robot_de_niro);
  Display.drawStr(0, 13, "Vida de Silicio");

  Display.setFont(u8g_font_helvB08);
  Display.drawStr(0, 25, "Display Grafico");

  Display.setFont(u8g_font_8x13);
  Display.drawBox(0, 31, 96, 13);
  Display.setColorIndex(0);
  Display.drawStr(0, 41, "Arduino Mega");

  Display.setFont(u8g_font_ncenB10);
  Display.setColorIndex(1);
  Display.drawStr(0, 60, "0123456789");
}

void Tela5() {

  char ASCII[2] = " ";
  int dec = 32;

  Display.setFont(u8g_font_robot_de_niro);

  for (int linha = 10; linha < 70; linha += 10) {
    for (int coluna = 2; coluna < 128; coluna += 8) {
      ASCII[0] = dec;
      Display.drawStr(coluna, linha, ASCII);
      dec ++;
    }
  }
  
}

void Tela6() {

  Display.setFont(u8g_font_8x13);

  Display.drawLine(10, 2, 110, 2);
  Display.drawBox(20, 10, 15, 15);
  Display.drawCircle(85, 20, 15);
  Display.drawEllipse(30, 50, 10, 10);
  Display.drawDisc(90, 50, 10);
}

void setup() {

  Serial.begin(9600);

  if ( Display.getMode() == U8G_MODE_R3G3B2 )
    Display.setColorIndex(20);
  else if ( Display.getMode() == U8G_MODE_GRAY2BIT )
    Display.setColorIndex(1);
  else if ( Display.getMode() == U8G_MODE_BW )
    Display.setColorIndex(1);
}

void loop() {

  //Tela 1
  Display.firstPage();
  do {
    Display_config();
    Tela1();
  }
  while (Display.nextPage());
  delay(1000);

  //Tela 2
  Display.firstPage();
  do {
    Display_config();
    Tela2();
  }
  while (Display.nextPage());
  delay(1000);

  //Tela 3
  Display.firstPage();
  do {
    Display_config();
    Tela3();
  }
  while (Display.nextPage());
  delay(1000);

  //Tela 4
  Display.firstPage();
  do {
    Display_config();
    Tela4();
  }
  while (Display.nextPage());
  delay(1000);

  //Tela 5
  Display.firstPage();
  do {
    Display_config();
    Tela5();
  }
  while (Display.nextPage());
  delay(1000);

  //Tela 6
  Display.firstPage();
  do {
    Display_config();
    Tela6();
  }
  while (Display.nextPage());
  delay(1000);

}

Colocando para funcionar

Para verificar o funcionamento do display gráfico 128x64, foi montado em bancada o circuito com Arduino Mega, como pode ser visualizado no vídeo a seguir:

Entendo a fundo

Entendendo o Software

– Incluindo as bibliotecas a serem utilizadas

Inicialmente para que a aplicação funcione de forma adequada é necessário adicionar a biblioteca que permitirá acessar as funções e comandos para a escrita no display gráfico.

#include "U8glib.h"

Na próxima linha criamos um objeto chamado Display, responsável por acessar as instruções existentes na biblioteca U8glib.h. Note que o objeto Display(8, 7, 6, 9) envia quatro valores como parâmetro ao construtor da biblioteca, esses parâmetros dentro dos parênteses informam quais serão os pinos de comunicação entre o arduino e display. Sendo assim, cada pino tem a seguinte função (Enable, RW, RS, RESET).

U8GLIB_ST7920_128X64_1X Display(8, 7, 6 , 9);

– Configurando a escrita no display

Na função Display_config(), são definidos algumas características do display e a respeito das informações que seram escrita no mesmo. A primeira linha executada contém a seguinte instrução: Display.setFont(u8g_font_6x10), responsável por definir a fonte das mensagem mostradas no display com o nome da mesma dentro dos parenteses. Com a instrução Display.setFontRefHeightExtendedText() definimos a altura de referência padrão para o modelo do display utilizado, no caso o ST7920. Em seguida a instrução Display.setDefaultForegroundColor() que define a cor de fundo padrão e por último com o comando Display.setFontPosTop() é definido o tamanho de fonte máximo permitido para o display. Para mais modelos de fontes, cores de fundo, funções especiais e até mesmo como configurar outros modelos de display gráfico e tipos de comunicação consulte a arquivo .h da biblioteca U8glib.h que você encontrará uma grande variedade de informações e configurações para os mais variados displays.

void Display_config() {

  Display.setFont(u8g_font_6x10);
  Display.setFontRefHeightExtendedText();
  Display.setDefaultForegroundColor();
  Display.setFontPosTop();
}

– Função Tela1 - Imprimido texto simples

Para exibir as diferentes opções de escrita no display, foram criados algumas funções para cada tela em questão. Na função Tela1(), a primeira instrução executada é Display.setFont().  Esta responsável por selecionar a fonte que será empregada na escrita. Logo abaixo, o comando Display.drawStr recebe três parâmetros: (pos. X, pos. Y, "String") para exibir a string entre aspas no display na posição desejada. Nesta função considera-se o ponto de referência (0,0) o ponto superior esquerdo.

void Tela1() {

  Display.setFont(u8g_font_unifont);
  Display.drawStr(45, 15, "Vida");
  Display.drawStr(53, 40, "de");
  Display.drawStr(35, 60, "Silicio");
}

– Função Tela2 - Imprimindo com moldura

Esta rotina tem por finalidade programar uma moldura na interface do display. A função Display.drawBox () recebe quatro parâmetros (pos. X, pos. Y, largura, altura) e tem por finalidade imprimir uma "caixa" na tela de acordo com os parâmetros. Já a função Display.setColorIndex(0), é responsável por inverter as cores dos pixels nas coordenadas da string no display. Observe ainda que a instrução Display.drawStr() foi executada duas veses, mas com um deslocamento em no eixo X. Esse artifício permite exibir mensagens na tela do display com a fonte mais grossa.

void Tela2() {

  Display.setFont(u8g_font_unifont);
  Display.drawBox(0, 0, 128, 64);
  Display.setColorIndex(0);
  Display.drawStr(4, 35, "Vida de Silicio");
  Display.drawStr(5, 35, "Vida de Silicio");
  Display.drawFrame(1, 1, 126, 62);
}

– Função Tela3 - Imprimindo com diferentes ângulos 

Esta tela é similar à tela 1. Nesse caso as informações exibidas são rotacionadas em 0, 90 e 270 graus. Ou seja, Display.drawStr() escreve a string Arduino na horizontal, Display.drawStr90() escreve a string Display com inclinação de 90º, enquanto que Display.drawStr270() provoca um giro de 270º na string Eletronica. Observe que a fonte nessa função foi alterada em relação a primeira tela com o comando Display.setFont(u8g_font_helvB08).

void Tela3() {

  Display.setFont(u8g_font_helvB08);
  Display.drawStr(45, 31, "Arduino");
  Display.drawStr90(105, 15, "Display");
  Display.drawStr270(20, 55, "Eletronica");
}

– Função Tela4 - Imprimindo textos com diferentes fundos e fontes

Nesta tela, há configuração de diferentes fontes de escrita e cor de fundo por meio das funções Display.setFont() e Display.setColorIndex().

void Tela4() {

  Display.setFont(u8g_font_robot_de_niro);
  Display.drawStr(0, 13, "Vida de Silicio");

  Display.setFont(u8g_font_helvB08);
  Display.drawStr(0, 25, "Display Grafico");

  Display.setFont(u8g_font_8x13);
  Display.drawBox(0, 31, 96, 13);
  Display.setColorIndex(0);
  Display.drawStr(0, 41, "Arduino Mega");

  Display.setFont(u8g_font_ncenB10);
  Display.setColorIndex(1);
  Display.drawStr(0, 60, "0123456789");
}

– Função Tela5 - Imprimindo caracteres especiais

Nessa tela foram apresentados alguns caracteres da tabela ASCII. Caso você não tenha uma tabela como essa pode acessar uma nesse LINK, usada como base para fazer o tutorial. No vídeo apresentando, os caracateres especiais exibidos correpondem aos numeros em decimal de 32 a 127. Observe que nao função Tela5, é instanciado a variável ASCII (do tipo char) que recebe os valores (do tipo int), e exibe o seu caractere correspondente por meio da intrução Display.drawStr(coluna, linha, ASCII). Os dois for presentes na função são utilizados para imprimir os caracteres ao longo de toda a área do display, sendo que o primeiro for é responsáel por pular linhas ao passo que na linhas corresponde não há mais espaço para exibir mais caracteres. Já o segundo for, ou for interno, é responsável por definir a posição de cada caractere ao longo dos 128 pixels disponíveis do display. A variável dec so pode ser incrementada até o valor 127, que é o valor decimal correspondente ao último caractere especial da tabela ASCII, por isso a variável foi incrementada dentro do segundo for, que por coincidência também tem limite de 127, definido pelo numero máximo de  pixels do display.

void Tela5() {

  char ASCII[2] = " ";
  int dec = 32;

  Display.setFont(u8g_font_robot_de_niro);

  for (int linha = 10; linha < 70; linha += 10) {
    for (int coluna = 2; coluna < 128; coluna += 8) {
      ASCII[0] = dec;
      Display.drawStr(coluna, linha, ASCII);
      dec ++;
    }
  }
  
}

– Função Tela6 - Imprimindo formas geométricas

Na função Tela6(), são exibidos diferentes formas geométricas, todas as funções tem em comum os seguites parâmetros (pos. X, pos. Y). Com a mescla dessas figuras geométricas é possível fazer vários formatos e artes diferentes para serem exibidos no display. As seguir listamos oque cada instrução para desenhar as figuras no display recebe de parâmetros:

• Display.drawLine(pos. X , pos. Y, comprimento em X, pos. final Y);
• Display.drawBox(pos. X, pos. Y, comprimento da base, comprimento da altura);
• Display.drawCircle(pos. X, pos. Y, raio do círculo);
• Display.drawEllipse(pos. X, pos. Y, raio em X, raio em Y);
• Display.drawDisc(pos. X, pos. Y, raio do disco).

void Tela6() {

  Display.setFont(u8g_font_8x13);

  Display.drawLine(10, 2, 110, 2);
  Display.drawBox(20, 10, 15, 15);
  Display.drawCircle(85, 20, 15);
  Display.drawEllipse(30, 50, 10, 10);
  Display.drawDisc(90, 50, 10);
}

– Estabelecendo as configurações iniciais

Na função void setup(), foram realizados algumas configurações de exibião do display. Possibilitando definir a intensidade, a cor, e o pixel ativado. A função Display.getMode() seleciona o modo de operação do display. Por exemplo, o comando U8G_MODE_R3G3B2, define o padrão RGB.

void setup() {

  if ( Display.getMode() == U8G_MODE_R3G3B2 )
    Display.setColorIndex(20);
  else if ( Display.getMode() == U8G_MODE_GRAY2BIT )
    Display.setColorIndex(1);
  else if ( Display.getMode() == U8G_MODE_BW )
    Display.setColorIndex(1);
}

– Mudando as telas

Na função void loop() é realizada a mudanas das telas, na primeira linha é executada a instrução Display.firstPage(), que tem por finalidade iniciar a comunicação do display com o Arduino e habilitar a exibião de informações na tela do mesmo. Em seguida a função Display_config() já explicada anteriormente é executada, seguida da chamada da função Tela1(). A cada nova função de exibição de tela o comando Display.nextPage() também é executado para evitar sobreposição e lixo de caracteres das telas anteriores. Observe que o tempo de exibição de cada tela é de 1 segundo, sendo possível por meio da função delay() que possui como parâmetro o tempo em milisegundos da mudança da troca de telas.

  Display.firstPage();
  do {
    Display_config();
    Tela1();
  }

Desafio

Para aprimorar suas habilidade com o displays, propomos a você desenvolver um relógio analógico/digital. Uma dica, é utilizar o módulo RTC DS 3231. Agora é com você!

Fechamento

Neste tutorial, demonstramos como você pode utilizar o display gráfico em seus projetos, esperamos que você continue nos acompanhando e sinta-se à vontade para deixar suas sugestões dúvidas nos comentários abaixo.

by Equipe MountainBaja

Configurando o Xbee pelo software XCTU

Configurando o Xbee pelo software XCTU

Este tutorial tem por objetivo desenvolver uma maior compreensão a respeito do módulo Xbee. Sua configuração utilizando o software XCTU, bem como as características elétricas principais e algumas aplicações serão descritas e listadas a seguir. Este equipamento, devido a sua praticidade e facilidade de configuração pode ser utilizado em vários circuitos eletrônicos, contribuindo para processos de otimização de trabalhos e tráfego de informações. Logo, ressaltar sua importância e praticidade de utilização é um bom viés de estudo.

[toc]

Módulo Xbee

O módulo Xbee S2C é uma placa de circuito impresso que se comunica via radiofrequência utilizando o padrão de comunicação de rede sem fio Zigbee. Isso permite que vários destes módulos possam conversar entre si em uma rede wireless, mesmo contidos em circuitos eletrônicos independentes. Pode ser amplamente empregado em ambientes onde sejam requeridas redes de comunicação e transmissão de dados entre  centrais eletrônicas que se encontram localizadas distantes umas das outras, eliminando a necessidade de linhas de comunicação físicas. Além disso, permite que sejam desenvolvidas redes robustas, confiáveis e que possuam uma boa a relação de custo-benefício.

Algumas aplicações

Pelo fato de ser um equipamento de configuração relativamente simples e amplamente encontrado no mercado, o módulo Xbee pode ser empregado em uma gama de setores. Algumas funções realizadas por esse sistema encontram-se listadas a seguir:

• Segurança;
• Ventilação;
• Controle de iluminação;
• Aquecimento;
• Periféricos para computadores;
• Mouse e teclado;
• Joystick;
• Controle de processos;
• Gerenciamento de energia;
• Rastreamento de equipamentos;
• Telemetria de veículos e aeromodelos.

Especificações do Dispositivo

O módulo Xbee possui como características principais para operação e configuração:

• Distância de alcance: 60m em ambiente fechado e até 1200m em ambiente aberto;
• Frequência de trabalho: 2.4 GHz;
• Taxa de dados: 250Kbps;
• Tensão de alimentação: 2.8 à 3.4 VDC;
• Corrente de transmissão: 45mA (3.3V);
• Corrente de recepção: 50mA (3.3V);
• Antena: Conector Integrado de Chicote, Chip ou U.FL, Conector RPSMA;
• Potência de transmissão: 1mW (0dBm)
• Dimensões: 2.438cm x 2.761cm;
• Temperatura de operação: -40 to 85º C (industrial).

Conhecendo o XCTU

O software XCTU é uma aplicação gratuita com uma multi-plataforma compatível com Windows, MacOS e Linux. Este dispositivo possui uma interface que permite a configuração e arquitetura de rede sem fio simples. O software conta ainda com uma extensão que permite realizar testes de comunicação entre módulos para validar range e envio de pacote de dados. Contido nesse conjunto de ferramentas, há também o API Frame Builder que permite o desenvolvimento simples e rápido de quadros de API de módulos XBee.

Mãos à obra - Configurando o módulo Xbee

Componentes Necessários:

• 1 x Xbee S2C
• 1 x adaptador Xbee explorer
• 1 x cabo mini USB A

Tendo em mãos os componentes listados, segue o link do Datasheet do Xbee para maiores informações sobre pinagem e características elétricas, bem como um passo a passo para configurar o Xbee.

Configurando o Xbee

Realizando o download do software XCTU

Inicialmente, é necessário baixar e instalar o software XCTU para a configuração do Xbee. Para isso, basta acessar o seguinte link e prosseguir nos passos indicados pela interface de download.

Executando a ligação entre o módulo Xbee e o software

Conecte o adaptador ao computador e execute o XCTU. A interface é mostrada a seguir.

Uma vez aberta à interface, entre na guia Discover Devices para adicionar o módulo de rádio no software.

Selecione a opção USB serial port e click em Next.

Em Set port parameters é possível configurar os parâmetros da comunicação USB ou então, se nenhuma modificação for executada na configuração padrão, basta clicar em Finish.

Configuração do módulo

Após a identificação do Xbee pelo software, selecione-o e clique em Add selected devices.

Para configurá-lo, no campo Radio Modules, clique sobre o Xbee. Será aberta uma aba chamada Radio configuration.

Para atualizar para a última versão de firmware basta clicar na janela Update, selecionar a última versão, e instalar clicando em Update. Nesse momento, o software irá coletar configurações pré-definidas em seu Xbee.

Siga clicando na aba Radio configuration > Networking:

• No campo ID PAIN ID digite um nome de identificação. Preencha com o nome 'CF' ou então com um nome composto por código hexadecimal (de 0 a H).

• No campo SC scan channels digite um código de identificação. Preencha com '7FFF'.

Siga clicando na aba Radio configuration>Addressing:

• No campo SL e SH serial number low, verifique se o endereço de seu Xbee é o mesmo que se encontra gravado na parte traseira desse. Esse número também é indicado na interface do XCTU, no campo MAC. O campo SL serial number é a primeira parte do endereço, e o SH serial number a segunda parte. Ambos números já são identificados automaticamente pelo XCTU.

MAC do Xbee - identificação física

• No campo DH Destination Adress High adicione um código. Preencha com '0' e no campo DL Destination Adress Low adicione um código. Preencha com 'FFFF'.

• No campo NI Noder Identification adicione um nome ao Xbee. Nesse caso, foi escolhido o nome 'VidadeSilicio1'.

Para salvar as alterações no seu módulo Xbee clique em Write.

Configuração pronta

A partir deste ponto, seu Xbee já se encontra configurado e pronto para uso! Para configurar outros módulos em uma mesma rede, basta seguir os mesmos procedimentos listados até este ponto. É cabível salientar que as configurações de ID, SC, DH e DL devem ser as mesmas para todos os demais módulos a serem configurados.

Considerações finais

Espera-se que este tutorial possa ter ajudado no desenvolvimento de seu projeto. A equipe responsável agradece pela sua leitura e, em caso de dúvidas e sugestões, deixe seu cometário para que possamos sanar suas dúvidas! Obrigado!

by Equipe MountainBaja

Xbee - Comunicação entre Arduinos

Xbee - Comunicação entre dois Arduinos

A comunicação entre dois ou mais Arduinos é uma prática muito utilizada em eletrônica por permitir a troca de informações e comandos, o que possibilita o monitoramento remoto de variáveis importantes em um sistema de controle utilizando estes equipamentos. Essa comunicação possui grande autonomia e é capaz de otimizar vários sistemas e projetos. Esse tutorial tem como objetivo ensinar como são feitos os processos necessários, os componentes utilizados, as aplicações e algumas informações a respeito do desenvolvimento destes sistemas, para que você possa desenvolver sua aplicação de transmissão de dados utilizando dois Arduinos e Xbee com eficiência.

[toc]

Módulo Xbee

O Xbee é um módulo de rádio frequência que realiza comunicação serial entre dois pontos para estabelecer conexões wireless. As redes utilizam o protocolo ZigBee, contando com taxas de transferência de dados que variam entre 20kbps e 250kbps e são capazes de hospedar milhares de dispositivos. O protocolo ZigBee que é baseado no IEEE 802.15.4 permite uma grande fidelidade de conexão, tornando-se assim ideal para projetos robustos.

Algumas aplicações

A comunicação robusta e segura entre dois ou mais Arduinos pode ser aplicada em diversos projetos que utilizam do monitoramento remoto. Alguns deles são listados a seguir:

• Acompanhamento de atividades de alto risco;
• Automação residencial, comercial e industrial;
• Telemetria em veículos Baja e Fórmula SAE;
• Controle de processos à longa distância;

Mãos à obra - Realizando a comunicação entre dois Arduinos utilizando o Xbee

Componentes necessários

Neste tutorial, é necessário que se tenha em mãos os seguintes componentes:

• 2 x Arduinos Uno
• 2 x Módulos Xbee
• 2 x Adaptadores Xbee Explorer
• 1 x Protoboard
• Fios Jumpers
• 3 x Leds
• 3 x Resistores 330Ω
• 1 x Cabo USB mine A

Configurando o Xbee utilizando o software XCTU

Para mais informações sobre o módulo XBee e como configurá-lo, basta seguir o tutorial "Configurando o XBee utilizando o software XCTU", que pode ser consultado no seguinte link. Feito isso, siga as instruções a seguir para realizar a comunicação entre dois Arduinos.

Comunicação entre os dois arduinos

Uma vez configurados os módulos Xbee utilizando o XCTU, faça as ligações elétricas conforme os diagramas das figuras a seguir. Nesse tutorial temos dois hardware a serem montados, vamos chama-los de conjunto transmissor e conjunto receptor.

Programando

Nesse tutorial vamos utilizar dois Arduinos comunicando entre si por meio dos módulos Xbee, a intenção é pressionar botões conectados a um microcontrolador e por sua vez transmitir tal informação para o conjunto receptor que analisará o comando e aturá em suas saídas, representadas por leds. Como a aplicação é composta por dois Arduino, a seguir é apresentado o código do conjunto transmissor:

#include<SoftwareSerial.h>
SoftwareSerial XBEE1(3, 2);

#define btn1 10
#define btn2 9
#define btn3 8

void setup() {

  Serial.begin(9600);
  XBEE1.begin(9600);

  pinMode(btn1, INPUT_PULLUP);
  pinMode(btn2, INPUT_PULLUP);
  pinMode(btn3, INPUT_PULLUP);

  Serial.println("Iniciando...");
}

void loop() {

  if (digitalRead(btn1) == LOW) {
    while (digitalRead(btn1) == LOW) {}
    XBEE1.print(1);
    XBEE1.println("");
    Serial.println("LED 1");
  }

  if (digitalRead(btn2) == LOW) {
    while (digitalRead(btn2) == LOW) {}
    XBEE1.print("2");
    XBEE1.println("");
    Serial.println("LED 2");
  }

  if (digitalRead(btn3) == LOW) {
    while (digitalRead(btn3) == LOW) {}
    XBEE1.print('3');
    XBEE1.println("");
    Serial.println("LED 3");
  }
}

Do mesmo modo, é necessário programar o segundo Arduino com o código do conjunto receptor, como pode ser visualizado a seguir:

#include<SoftwareSerial.h>
SoftwareSerial XBEE2(3, 2);

#define LED1 10
#define LED2 9
#define LED3 8

int c = 0;

void setup() {

  Serial.begin(9600);
  XBEE2.begin(9600);

  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(13, OUTPUT);
}

void loop() {

  if (XBEE2.available() > 0) {

    c = XBEE2.read();

    if (c == "1") {
      digitalWrite(LED1, !digitalRead(LED1));
      Serial.print("LED1 - ");
      Serial.println(digitalRead(LED1));
    }

    if (c == "2") {
      digitalWrite(LED2, !digitalRead(LED2));
      Serial.print("LED2 - ");
      Serial.println(digitalRead(LED2));
    }

    if (c == "3") {
      digitalWrite(LED3, !digitalRead(LED3));
      Serial.print("LED3 - ");
      Serial.println(digitalRead(LED3));
    }

    Serial.flush();
  }

}

Colocando para funcionar

A seguir, um pequeno vídeo do funcionamento da comunicação entre os Arduinos:

Testando a comunicação.

Entendendo a fundo

Software - Conjunto transmissor

- Incluindo a biblioteca que será utilizada

Primeiramente para que a aplicação funcione de forma adequada é necessário adcionar a biblioteca SoftwareSerial.h, isso permitirá normear dois pinos digitais do Arduino para realizarem comunicação serial com o módulo Xbee transmissor.

#include<SoftwareSerial.h>

Na linha seguinte, o comando SoftwareSerial XBEE1(3, 2) é um construtor da biblioteca SoftwareSerial.h, esse permite criar um objeto que poderá acessar todas as funções da biblioteca, denominado de XBEE1. Os dois parâmetros dentro dos parênteses informam quais seram os pinos de comunicação serial. Sendo assim o pino 3 é o Rx e o pino 2 o Tx.

SoftwareSerial XBEE1(3, 2);

- Declarando as variáveis do projeto

Posteriormente, para receber os sinais dos botões é necessário a criação ou definição das variáveis de entrada do Arduino. A variável btn1 é responsável por definir o pino de entrada do sinal do botão 1 no microcontrolador, e o mesmo acontece para o botão 2 e botão 3.

#define btn1 10
#define btn2 9
#define btn3 8

- Estabelecendo as configurações iniciais

Na função setup(), primeiro inicializamos a comunicação serial com a função Serial.begin(9600), onde definimos o baudrate para 9600. Na próxima linha iniciamos a porta serial responsável por enviar as informações para o módulo Xbee e definimos o baudrate para 9600. Continuando, a linha seguinte é composta pela definição das I/O, ou seja, com a função pinMode(btn1, INPUT_PULLUP) definimos que a variável btn1 é um pino de entrada do microcontrolador e habilitamos os resistores de PULLUP internos do Arduino, eliminando a necesidade de montar a configuração externamente. Da mesma forma repetimos o comando para os demais botões. A última linha a ser executada dentro do setup() é a função Serial.println("Iniciando...") que exibe no monitor serial a string dentro dos parênteses.

void setup() {

  Serial.begin(9600);
  XBEE1.begin(9600);

  pinMode(btn1, INPUT_PULLUP);
  pinMode(btn2, INPUT_PULLUP);
  pinMode(btn3, INPUT_PULLUP);

  Serial.println("Iniciando...");
}

- Enviando dados para o outro Arduino

A função void loop() é a parte responsável por identificar se algum dos três botões foram pressionados. A condicional if(digitalRead(btn1) == LOW)  avalia o caso em que o primeiro botão seja pressionado, levando a entrada do Arduino a nível lógico baixo (LOW).

if (digitalRead(btn1) == LOW) {

Se o botão 1 se mantiver pressionado as condições dentro das chaves do if() não são executadas, pois a instrução while(digitalRead(btnt1) == LOW){} também é verdadeira e não possui nenhuma instrução dentro de suas chaves. Esse procedimento também conhecido como intertravamento elétrico é utilizado para evitar que ao pressionar os botões o Arduino execute as instruções diversas veses enquanto o botão esta pressionado.

while (digitalRead(btn1) == LOW) {}

Após soltar o botão o while é interrompido e a função XBEE1.print("1") envia o valor 1 para o conjunto receptor por meio do Xbee e comando Serial.println("LED 1") exibe no monitor serial a string LED 1. O mesmo procedimento explicado acima acontece para todos os demais botões com excessão do valor a ser enviando para acionar os led do conjunto receptor e a mensagem no monitor serial.

  XBEE1.print("1");
  XBEE1.println("");
  Serial.println("LED 1");
}

A seguir exibimos a função void loop()  do conjunto transmissor por completo:

  if (digitalRead(btn1) == LOW) {
    while (digitalRead(btn1) == LOW) {}
    XBEE1.print("1");
    XBEE1.println("");
    Serial.println("LED 1");
  }

  if (digitalRead(btn2) == LOW) {
    while (digitalRead(btn2) == LOW) {}
    XBEE1.print("2");
    XBEE1.println("");
    Serial.println("LED 2");
  }

  if (digitalRead(btn3) == LOW) {
    while (digitalRead(btn3) == LOW) {}
    XBEE1.print("3");
    XBEE1.println("");
    Serial.println("LED 3");
  }

Software - Conjunto receptor

- Incluindo a biblioteca que será utilizada

Da mesma forma que no primeiro Arduino é necessário incluir a biblioteca SoftwareSerial.h, isso permitirá normear dois pinos digitais do Arduino para realizarem comunicação serial com o módulo Xbee receptor.

#include<SoftwareSerial.h>

Na linha seguinte, o comando SoftwareSerial XBEE2(3, 2) é um construtor da biblioteca SoftwareSerial.h, esse permite criar um objeto que poderá acessar todas as funções da biblioteca, denominado de XBEE2. Os dois parâmetros dentro dos parênteses informam quais seram os pinos de comunicação serial. Sendo assim o pino 3 é o Rx e o pino 2 o Tx.

SoftwareSerial XBEE2(3, 2);

- Declarando as variáveis do projeto

Subsequentemente para acionar os leds no conjunto receptor é necessário a criação ou definição das variáveis de saída do Arduino. A variável LED1 é responsável por definir o pino de saída do primeiro led do microcontrolador, e o mesmo acontece para os leds 2 e 3. Já a variável C (do tipo inteiro) é criada para armazenar os comandos recebido por radiofrequência do Xbee receptor.

#define LED1 10
#define LED2 9
#define LED3 8

int c = 0;

- Estabelecendo as configurações iniciais

Na função setup() repetimos o procedimento do primeiro Arduino,  inicializamos a comunicação serial com a função Serial.begin(9600), onde definimos o baudrate para 9600. Na próxima linha iniciamos a porta serial responsável por enviar as informações para o módulo Xbee e definimos o baudrate para 9600. Posteriormente com as função pinMode(LED1, OUTPUT) definimos a variável LED1 como saída de dados, o mesmo é realizado para as variáveis LED2 e LED3 que controlam o estados dos leds 2 e  3 respectivamente.

void setup() {

  Serial.begin(9600);
  XBEE2.begin(9600);

  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
}

- Recebendo os dados do transmissor

Na função void loop() do segundo Arduino o objetivo é receber os dados transmitidos e verificar se existe algum comando ou instrução a ser executada para o respectivo comando. A primeira linha a ser executada é if(XBEE2.available()> 0), essa condicional verifica se existe algum dado disponível na porta de comunicação serial do Xbee receptor.

if (XBEE2.available() > 0)

Caso exista alguma informação, a condicional é aceita e a segunda linha é executada, com a instrução c = XBEE2.read(), a variável C armazena as informações disponível na porta serial.

c = XBEE2.read();

Em seguida, a próxima linha executada pelo Arduino é uma nova condicional que verifica se o valor de C corresponde a 1, caso esse if() seja verdadeiro, a função digitalWrite(LED1, !digitalRead(LED1)) é executada. Uma observação importante a ser feita é sobre o segundo parâmetro da função digitalWrite(), a instrução !digitalRead(LED1), lê o estado atual da saída do led e o inverte, ou seja, com apenas um botão conseguimos ligar e desligar o led 1.

if (c == '1') {
  digitalWrite(LED1, !digitalRead(LED1));

As duas próximas linhas dento do primeiro if() exibem no monitor serial o nome do led e o valor do estado atual (0 - desligado, 1 - ligado). O mesmo procedimento é avaliado para os demais leds, alterando apenas o valor da variável C e a saída a ser acionada.

  Serial.print("LED1 - ");
  Serial.println(digitalRead(LED1));
}

A última linha do loop() é composta pela expressão Serial.flush(), essa instrução permite a conclusão da transmissão de dados da porta serial.

Serial.flush();

A seguir exibimos a função void loop() por completo:

  if (XBEE2.available() > 0) {

    c = XBEE2.read();

    if (c == 1) {
      digitalWrite(LED1, !digitalRead(LED1));
      Serial.print("LED1 - ");
      Serial.println(digitalRead(LED1));
    }

    if (c == 2) {
      digitalWrite(LED2, !digitalRead(LED2));
      Serial.print("LED2 - ");
      Serial.println(digitalRead(LED2));
    }

    if (c == 3) {
      digitalWrite(LED3, !digitalRead(LED3));
      Serial.print("LED3 - ");
      Serial.println(digitalRead(LED3));
    }

    Serial.flush();
  }

Desafio

Desenvolva um projeto que seja possível medir a temperatura de um determinado ambiente, utilize por o exemplo o sensor de temperatura LM35, e envie o valor da variável para um tela de LCD para monitoramento. Se o valor da temperatura exceder um determinado valor, envie uma informação para acionar um cooler ou ventilador e resfriar o ambiente.

Considerações Finais

Espera-se que este tutorial possa ter ajudado no desenvolvimento de seu projeto. A equipe responsável agradece pela sua leitura e, em caso de dúvidas e sugestões, deixe seu comentário para que possamos sanar suas dúvidas! Obrigado!

by Equipe MountainBaja

Módulo GPS NEO-6M com Arduino

Utilização do Módulo GPS NEO-6M

Visando aplicações de telemetria em Geolocalização, o objetivo deste tutorial será apresentar como funciona o Módulo GPS NEO-6M (Ublox NEO-6M) e propor um exemplo de aplicação prática em conjunto com o Arduino Uno na captação das coordenadas de localização geográficas.

[toc]

Contexto Histórico

Durante guerras, era essencial saber a localização das tropas aliadas e inimigas para desenvolver estratégias de ataque e defesa. Com isso, sempre houve uma grande preocupação das grandes nações em aplicar tecnologias para conseguir essas informações de maneira mais rápida, o que se intensificou no contexto da guerra fria em que Estados Unidos e União Soviética estavam interessados no desenvolvimento desta tecnologia. Em 1957, a União Soviética lançou seu primeiro satélite artificial no espaço, iniciando assim a pesquisa do uso de satélites para geolocalização. Porém, a tecnologia GPS - Global Position System foi criada pelos americanos, com o projeto NAVSTAR em 1960, desenvolvido pelo Departamento de Defesa dos Estados Unidos. Este projeto conseguia oferecer informações sobre qualquer localização no planeta, e apenas nos anos 90 se tornou totalmente operacional.

Atualmente, a aplicação do GPS deixou de ser unicamente utilizada militarmente e é amplamente utilizada em veículos do mundo todo, na agricultura, estudos geológicos, meteorológicos, entre outras várias utilizações.

Como funciona o GPS

A figura a seguir mostra uma ilustração de como localizar o módulo GPS, que foi realizada utilizando como coordenadas a localização do módulo na cidade de Itabira MG.

A localização exata do módulo GPS está indicada pela circunferência vermelha. Cada uma das outras circunferências são os sinais provenientes de três satélites. Caso o módulo GPS recebesse sinal de apenas um satélite como, por exemplo, o verde, ele saberia que está em algum ponto de toda a sua circunferência. Caso o módulo GPS recebesse sinais de apenas dois satélites como, por exemplo, verde e amarelo, note que existe duas intersecções entre estes círculos. Assim, o módulo não saberia discernir em qual dos dois pontos eles estão. Porém, quando o módulo GPS recebe o sinal de três satélites, note que existe apenas um ponto de intersecção entre os três sinais. Isso permite que o módulo consiga se localizar geograficamente com maior precisão.

O Módulo GPS NEO-6M

O Módulo GPS NEO-6M é um módulo GPS pronta para uso junto a placas de desenvolvimento. Elá possui o Ublox GPS NEO-6M, módulo pertencente a uma família de GPS autônomos. Fácil de usar, esse módulo consegue, sozinho, determinar com precisão  horizontal de até 2,5m a sua localização.

Você pode conferir mais informações sobre o GPS NEO-6M através do datashett na página do produto no próprio site da Ublox.

Esse módulo também vem equipado com todos os periféricos necessários para que você possa implementa-lo em seu projeto com facilidade.

Especificações técnicas

• Tensão de alimentação: 3V a 5V;
• Modelo: GY-GPS6MV2;
• Antena externa de Cerâmica;
• Velocidade padrão: 9600 bps;
• Número de canais: 50;
• Sensibilidade: -146dBm/-160dBm;
• Faixa de atualização de navegação: 5Hz;
• Altitude limite: 50000m;
• Velocidade limite: 500m/s;
• Memória de Armazenamento: EEPROM;
• Com Bateria de backup: MS621FE;
• Possui LED para indicar o sinal;

Algumas aplicações

Este módulo GPS utiliza a comunicação serial/TTL e, por isso, ele possui somente quatro pinos. Com estas características, este módulo é muito utilizado em:

• Circuitos de drones;
• Carrinhos de controle remoto;
• Veículos de transporte;
• Mapeamento de rotas.

Mãos à obra – Utilizando o Módulo GPS NEO-6M

Componentes Necessários

Para desenvolvimento do projeto, serão utilizados os seguintes componentes:

• 1 x Módulo GPS NEO-6M
• 1 x Arduino Uno
• 1 x Protoboard
• Fios Jumpers

Montando o projeto

Para realizar a montagem do projeto, deve-se conectar os pinos TX e RX do módulo GPS aos pinos TX e RX correspondentes no Arduino. É possível utilizar o próprio microcontrolador para suprir a alimentação do módulo GPS, conectando os cabos Vcc e Gnd desse aos respectivos equivalentes, como é mostrado no circuito abaixo. A utilização do Arduino se dá em virtude do seu baixo custo e também pela facilidade na implementação e comunicação com o módulo.

Após o código carregado e o circuito montado, basta energizar o conjunto para que funcione. Para obter melhores resultados, ou seja, mais rápidos e confiáveis, é aconselhável a utilização do módulo ao ar livre. Isso permite que este consiga captar os sinais por sua antena de maneira mais eficiente.

Com o circuito pronto, pode-se comparar os dados coletados com o próprio GPS do aplicativo Google Maps. Desta forma é possível ter em mãos uma ferramenta comparativa de dados para verificar se o módulo está captando informações corretas e se a programação está funcionando como o esperado.

Programando

Após realizar a montagem do projeto na protoboard e verificar se as conexões estão corretas, copie e cole o código abaixo na IDE do Arduino e em seguida faça o Upload para o mesmo:

#include<SoftwareSerial.h>    
#include<TinyGPS.h>           

SoftwareSerial SerialGPS(8, 9);     
TinyGPS GPS;                       

float lat, lon, vel;
unsigned long data, hora;
unsigned short sat;

void setup() {

  SerialGPS.begin(9600);  
  Serial.begin(9600);     

  Serial.println("Buscando satelites...");
}

void loop() {

  while (SerialGPS.available()) {
    if (GPS.encode(SerialGPS.read())) {

      //Hora e data
      GPS.get_datetime(&data, &hora);
      
      Serial.print("--");
      Serial.print(hora / 1000000);
      Serial.print(":");
      Serial.print((hora % 1000000) / 10000);
      Serial.print(":");
      Serial.print((hora % 10000) / 100);
      Serial.print("--");

      Serial.print(data / 10000);
      Serial.print("/");
      Serial.print((data % 10000) / 100);
      Serial.print("/");
      Serial.print(data % 100);
      Serial.println("--");
      
      //latitude e longitude
      GPS.f_get_position(&lat, &lon);

      Serial.print("Latitude: ");
      Serial.println(lat, 6);
      Serial.print("Longitude: ");
      Serial.println(lon, 6);

      //velocidade
      vel = GPS.f_speed_kmph();

      Serial.print("Velocidade: ");
      Serial.println(vel);

      //Satelites
      sat = GPS.satellites();

      if (sat != TinyGPS::GPS_INVALID_SATELLITES) {
        Serial.print("Satelites: ");
        Serial.println(sat);
      }

      Serial.println("");
    }
  }
}

Colocando para funcionar

Veja como ficou o resultado no Monitor serial da IDE Arduino:

Entendendo a fundo

Software

- Incluindo as bibliotecas a serem utilizadas

Inicialmente para que a aplicação funcione de forma adequada é necessário adicionar duas bibliotecas, a primeira é a SoftwareSerial.h, que permitirá nomear dois pinos digitais do Arduino para realizarem comunicação serial com o módulo GPS. A segunda biblioteca necessária é a TinyGPS.h, essa atua contendo todas as funções e comando necessários para se comunicar com o módulo e acessar suas ferramentas.

#include<SoftwareSerial.h>  
#include<TinyGPS.h>

Nas próximas duas linhas criamos dois objetos responsáveis por acessar as instruções existentes em cada biblioteca. Observe ainda que o objeto SerialGPS(8, 9) envia dois valores como parâmetro ao construtor da biblioteca SoftwareSerial.h, esses parâmetros dentro dos parênteses informam quais serão os pinos de comunicação serial. Sendo assim o pino 8 é o Rx e o pino 9 o Tx. O objeto GPS não possui nenhum parâmetro a ser enviado ao construtor da biblioteca TinyGPS.h.

SoftwareSerial SerialGPS(8, 9);     
TinyGPS GPS;

- Declarando as variáveis do  projeto

Em seguida é necessário instanciar ou criar as variáveis responsáveis por armazenar os dados obtidos pela comunicação do GPS com os satélites. As variáveis lat, lon, vel (do tipo long) armazenam respectivamente os valores de Latitude, Longitude e Velocidade de onde se encontra a aplicação. Já as variáveis data e hora (do tipo unsigned long) são responsáveis por guarda as informações de data e hora solicitadas pelo módulo GPS. Por fim a variável sat (do tipo unsigned short) é incumbida de armazenar a quantidade de satélites disponíveis para se comunicar com o módulo.

float lat, lon, vel;
unsigned long data, hora;
unsigned short sat;

- Estabelecendo as configurações iniciais

Na função void setup(), primeiro inicializamos a comunicação serial com a função Serial.begin(9600), onde definimos o baudrate para 9600. Na próxima linha iniciamos a porta serial responsável por enviar e receber informações do módulo GPS e definimos o baudrate para 9600. A última linha do setup() é composta pela instrução Serial.println("Buscando satelites...") que exibe no monitor serial a string dentro das aspas.

void setup() {

  Serial.begin(9600);
  SerialGPS.begin(9600);      

  Serial.println("Buscando satelites...");
}

– Comunicação com o GPS

A função void loop() contém todos os procedimentos para que o GPS colete dados dos satélites. A primeira instrução executada pelo microcontrolador é a while (SerialGPS.available()), essa instrução permite identificar se existe algum dado disponível do GPS para o Arduino. Caso essa verificação aponte dados disponíveis, o if() dentro das chaves do while()  é executado. Essa condicional faz a verificação de um caractere proveniente do GPS, e faz a validação do mesmo de forma a liberar ou não o request (solicitação) de informações do mesmo.

while (SerialGPS.available()) {
  if (GPS.encode(SerialGPS.read())) {

– Aquisição de hora e data

Dentro das chaves do if() é possível solicitar diversas informações dos satélites por meio do GPS. Duas informações importantes que permitem validar análises, são data e horário. Assim o objeto GPS por meio da função get_datatime(&data, &hora) armazena nas variáveis data e hora os respectivos dados. Observe que as duas variáveis são do tipo long, desta maneira a data fica no formato ddmmaa e o horário no formato hhmmss. Para separar a data em dia/mês/ano é utilizado o procedimento de divisão e resto da divisão(%), tal procedimento também é repetido para o horário. Para exemplificar, suponha que o valor da variável data seja 230318. O dia pode ser encontrado desta forma: data/10000 = 23, e assim para separar o mês basta usar o resto da divisão da operação anterior: (hora % 1000000) / 10000 = 03, e assim por diante como mostrado no código abaixo:

GPS.get_datetime(&data, &hora);

Serial.print("--");
Serial.print(hora / 1000000);
Serial.print(":");
Serial.print((hora % 1000000) / 10000);
Serial.print(":");
Serial.print((hora % 10000) / 100);
Serial.print("--");

Serial.print(data / 10000);
Serial.print("/");
Serial.print((data % 10000) / 100);
Serial.print("/");
Serial.print(data % 100);
Serial.println("--");

– Aquisição da latitude e longitude

Para obter a informação da Latitude e Longitude de onde se encontra a aplicação, basta utilizar a seguinte instrução: GPS.f_get_position(&lat, &lon), essa função armazena nas variáveis lat e lon  os respectivos valores e exibe-os no monitor serial com a instrução Serial.println(lat, 6). O valor 6 nesse caso indica o número de casa decimais.

GPS.f_get_position(&lat, &lon);

Serial.print("Latitude: ");
Serial.println(lat, 6);
Serial.print("Longitude: ");
Serial.println(lon, 6);

– Aquisição da velocidade

Da mesma forma, para receber a informação da velocidade da aplicação em relação ao satélite com o qual o módulo esta se comunicando, basta chamar a função GPS.f_speed_kmph(), que retorna o valor da velocidade e armazena a mesma na variável vel. Posteriormente a variável é mostrada no monitor serial através da função Serial.println(vel). Uma observação importante, neste caso, a função f_speed_kmph() nesse caso já retornou o valor da velocidade em km/h, mas é possível trabalhar com unidades como nós, milha/s e milha/h, basta pesquisar as funções disponíveis na biblioteca TinyGPS.h.

vel = GPS.f_speed_kmph();

Serial.print("Velocidade: ");
Serial.println(vel);

– Satélites disponíveis

A última função para solicitar informações do módulo GPS é a GPS.satellites(). Por meio dessa função o objeto GPS repassa a variável sat a quantidade de satélites encontrados e disponíveis para comunicação com o módulo GPS conectado ao Arduino. Em seguida uma nova condicional é avaliada, esse if (sat != TinyGPS::GPS_INVALID_SATELLITES) é utilizado para verificar se o valor de satélites armazenados na variável sat é um valor válido antes de imprimi-lo no monitor serial com a função Serial.println(sat). Tal procedimento de verificação é usado nas demais funções anteriores, mas todos internamente.

sat = GPS.satellites();

  if (sat != TinyGPS::GPS_INVALID_SATELLITES) {
     Serial.print("Satelites: ");
     Serial.println(sat);
  }

Desafio

Agora que você já conhece as funções do módulo GPS, temos alguns desafios para que você possa aplicar seus conhecimentos:

• Que tal controlar um carrinho de controle remoto com ele? Por exemplo, entre no aplicativo Google Maps e pegue as coordenadas próximas de sua casa. Utilizando o Módulo GPS NEO-6M, faça com que o carrinho chegue a algum lugar próximo das coordenadas tomadas anteriormente.
• Adquira os dados de latitude e longitude do Módulo GPS NEO-6M durante um deslocamento executado por você e plote um gráfico. Esse pode ser feito utilizando os Softwares Excel, Origin ou até mesmo o LabView. Você verá que irá formar um mapa com a trajetória executada.

Considerações finais

Nesse tutorial, demonstramos como você pode obter informações de localização e deslocamento utilizando um Arduino Uno e um Módulo GPS. Espera-se que este tutorial possa ter ajudado no desenvolvimento de seu projeto. A equipe responsável agradece pela sua leitura e, em caso de dúvidas e sugestões, deixe seu comentário para que possamos sanar suas dúvidas! Obrigado!

by Equipe MountainBaja

Sensor Capacitivo com Arduino

Sensor Capacitivo com Arduino

Neste tutorial ensinaremos a você o princípio de funcionamento de um sensor capacitivo, como fazer a alimentação e o tratamento do sinal de saída do mesmo utilizando o Arduino.

[toc]

Sensor capacitivo

O sensor capacitivo é um sensor amplamente empregado para detecção de materiais diversos sem que estes precisem ter algum tipo de contato com o mesmo. Este processo é feito através da variação da capacitância interna do sensor. O princípio de funcionamento básico deste sensor é caracterizado pela presença de duas placas metálicas separadas por um dielétrico (como um capacitor convencional) de forma que, quando algum tipo de material entra na sua zona de detecção, a capacitância interna do circuito é alterada e, a partir desta variação, os contatos normalmente abertos (NA) e normalmente fechados (NF) são comutados).

Como o sensor capacitivo funciona

- Capacitâcia

Como dito, o sensor capacitivo detecta a variação de capacitância. Para entender como isso pode ser útil, vamos entender primeiro, de forma simples, como funciona um capacitor e o que é capacitância.

Um capacitor é um componentes que armazena energia em forma de campo elétrico. Ele é formado por duas placas separadas que podem conter(,) ou não um material dielétrico entre elas.

Uma das principais propriedades de um capacitor é a capacitância, que por sua vez, define a quantidade de energia que esse capacitor pode armazenar. Essa capacitância é proporcional a constante dielétrica do material entre as placas , de modo que, quanto maior for a constante dielétrica, maior será a capacitância.

Por sua vez, essa constante dielétrica está relacionada com a facilidade de condução do campo elétrico no material entre as placas. Podemos ter, entre as placas, materiais tais como o ar, mica e cerâmica. Cada um possui sua própria contante dielétrica que interfere na capacitância de forma diferente.

- O sensor capacitivo

O sensor capacitivo nada mais é que um capacitor, mas suas placas estão dispostas de modo que o campo elétrico forma um meio circulo, tal como a figura a seguir:

Dessa forma, podemos detectar um objeto que entre no campo elétrico do sensor, já que o mesmo influenciará na capacitância.

Uma aplicação muito comum seria a de verificar a presença de liquido dentro de um recipiente, podendo constatar se há nível dentro de um tanque, por exemplo.

Perceba que no exemplo dos dois tanques, quando o tanque está cheio, o liquido interfere na capacitância do sensor e, dessa forma, ele consegue detectar que o tanque está cheio.

Aplicações

Diversos são os campos onde o sensor capacitivo pode ser empregado devido à sua capacidade de ser sensibilizado tanto por materiais condutores como não condutores. Alguns exemplos de aplicação:

• Sensor de proximidade;
• Controle do nível de fluido;
• Contadores em linha de produção;
• Medidor de espessura;
• Medidor de posicionamento;
• Detectar o conteúdo de caixas em linhas de produção.

Um exemplo peculiar pode ser analisado uma vez que este sensor é também aplicado na área automobilista em projetos de veículos Baja. As equipes realizam a detecção de combustível, no interior do tanque, posicionando o sensor na parte externa desse podendo assim coletar informações sobre o nível de gasolina. O emprego do sensor é baseado no fato de ser possível medir o nível da gasolina externamente e informar ao piloto, através de algum indicativo(Led ou Display), que é necessário abastecer. Nesta aplicação e em muitas outras onde o ambiente de medição de nível esta sujeito a vibrações e movimento, a realização de filtros ou médias de um conjunto de amostras coletadas para que se tenha uma saída de maior confiabilidade, é uma das estratégias utilizadas para sanar a inconsistência dos dados.

Mãos à obra - Como tratar o sinal deste sensor

Componentes Necessários

• 1 x Arduino Uno ou Arduino Mega
• 1 x Sensor capacitivo
• 1 x Resistor 10KΩ
• 1 x Diodo Zener
• 1 x Protoboard
• Fios Jumpers

Ligando o sensor a uma fonte DC

O sensor utilizado nesse tutorial é o CM18 - 3005NC NPN desenvolvido pela empresa JNG, mas essa aplicação é válida para a maioria de sensores capacitivos existentes. A faixa de alimentação do mesmo é de 10 à 30 volts em tensão contínua(DC), possui um range de comutação de aproximadamente 8 milímetros e contato normal fechado (NF). O cabo de sinal do sensor se mantém no mesmo nível de tensão de alimentação. Quando houver a detecção, o cabo de sinal recebe o nível baixo (0V) e um Led de sinalização na parte de trás do sensor é energizado, evidenciando seu funcionamento.

O sensor é do tipo NPN (NC). Esse dado pode ser obtido ao se analisar o nome de identificação do sensor uma vez que as duas últimas letras são reservadas para informar a forma de saída e o estado de saída, respectivamente. Portanto a letra 'N' corresponde a NPN e a letra 'C' fornece o contato que é normal fechado (NC).

O dispositivo Normalmente Fechado (NF) - em inglês Normally Closed (NC) - é aquele que o circuito normalmente está conduzindo. Quando esse dispositivo sofre alguma alteração, já esperada, ele abre o circuito e para de conduzir.

O dispositivo Normalmente Aberto (NA) - em inglês Normally Open (NO) - é aquele que normalmente não está conduzindo. Quando esse dispositivo sofre alguma  alteração, já esperada, ele fecha o circuito e começa a conduzir.

No sensor capacitivo essa alteração esperada seria equivalente a detecção do sensor. Ou seja, quando o sensor é normalmente fechado e ele detecta algo ele irá abrir o circuito.

Desta forma, o nome do sensor pode ser decomposto segundo o exemplo abaixo:

Sendo assim, a saída digital é controlada pelo transistor NPN ou PNP. A diferença entre estes tipos está atrelada ao fato que aquele, ao comutar, conecta o negativo (azul) à carga, já este, o PNP ,conecta o positivo (marrom) à carga. Tal fato pode ser facilmente compreendido ao se analisar a imagem abaixo:

A imagem a seguir mostra o sensor capacitivo alimentado por uma fonte de tensão DC, observe que o sensor esta alimentado com 12Vcc através do cabo "jacaré". Assim, com um multímetro conectado ao terminal de sinal(preto) e a referência(azul) do sensor podemos medir a tensão de saída quando o mesmo não detecta o objeto ou fluido.

Agora que já sabemos como alimentar um sensor capacitivo e a amplitude do sinal de saída, é hora de montar o circuito que reduz a tensão do sensor a um nível seguro para o Arduino.

Realizando as conexões

Uma vez identificados os terminais do sensor e fixado este nas proximidades da superfície de medição, é necessário reduzir a tensão para os níveis de trabalho suportados pelo Arduino. Para isso, podem ser empregadas algumas configurações de circuitos que realizam a redução desta tensão. Tais componentes ou circuitos integrados são listados abaixo:

• Diodo zener + resistor;
• Divisor de tensão;
• Optoacopladores;
• Amplificadores operacionais(Ampop)
• Transistores MOSFET ou TBJ;

Nesse tutorial será utilizado o circuito composto por um diodo zener e um resistor, em vista da facilidade de montagem e por apresentar um ótimo desempenho para a aplicação. O circuito desta configuração citada foi simulado utilizando o software Proteus conforme apresentado na imagem a seguir:

Como pode ser observado na imagem acima, foi utilizado um resistor que tem a função de restringir a corrente no pino digital do Arduino, evitando danos ao mesmo. Para essa função, resistores entre 4.7kΩ a 10KΩ são suficientes para limitar a corrente.

Já o diodo zener tem a função de regular a tensão de saída do sensor em um valor seguro de operação para o Arduino. Nesse caso, a escolha do mesmo deve levar em conta que o máximo valor de tensão admissível nas entradas do microcontrolador é de 5V. Para esse tutorial o diodo zener utilizado foi o 1N4732A, esse semicondutor opera numa faixa de 3.3 a 24Vdc, fixando a tensão em 4.7V com uma corrente nominal de 53mA, garantindo assim que a tensão na entrada digital do Arduino não exceda o valor limite e danifique sua entrada ou o embarcado definitivamente.

Na simulação para representar a dinâmica do sinal de saída do sensor (lembrando que o sensor é NF), foi utilizada uma bateria de 12V, juntamente com uma chave que expressa a comutação do sensor. Na imagem a seguir é possível observar que no instante em que a chave está fechada (sensor não detecta objeto ou fluído) a tensão no pino digital do Arduino será nível lógico alto(≅4.7V):

No instante em que algum objeto interceptar a área de detecção do sensor (chave aberta), a saída comuta para 0V e a tensão na entrada do microcontrolador também será 0V, como mostrado na figura abaixo:

Tratando o sinal do sensor com divisor de tensão

Existem diversas formas de tratar o sinal de saída do sensor capacitivo, de modo que, algumas delas já foram apresentadas anteriormente. Nesta seção vamos explicar como montar outro circuito: o divisor de tensão. Como o nome já diz, a segunda maneira de reduzir a tensão de saída do sensor é utilizando um divisor de tensão, muito parecido com a anterior, substituindo o diodo por outro resistor e aumentando o valor das resistências de ambos os resistores. A imagem a seguir exibe tal configuração:

Esta configuração é bem simples também. É comum adicionar resistores na ordem de MΩ pois assim o circuito não drena corrente do sinal do sensor e também não interfere no valor da tensão sob o resistor R2 (que será composto apenas pelo sinal de tensão de saída do sensor reduzido). Para dimensionar os valores de resistência é necessário estipular um dos dois resistores, sendo assim, fixamos R2 = 1MΩ. Aplicando a seguinte formula, podemos encontrar o valor de R1:

Vout = (R2 * Vin)/R1 + R2

Como conhecemos o valor de tensão que pode entrar no pino digital do Arduino(Vout) e o valor da tensão de saída do sensor(Vin) juntamente com o valor do resistor R2, temos:

R1 = (R2 * Vin/Vout) - R2

R1 = (1M * 12/5) - 1M

R1 = 1.4MΩ

Desta forma, é possível definir o valor do primeiro resistor que compõe o divisor de tensão. Como existem valores tabelados para resistores(,) e o valor encontrado para R1 não é comercial, colocamos no circuito um resistor de 1.5MΩ, para que este não interfira de forma brusca no funcionamento do circuito. A diferença é que no momento em que o sensor não detecta objetos, sinal de saída 12V, o valor da tensão na entrada do Arduino será um pouco menor que 5V, mas ainda sim garantindo seu correto funcionamento.

É importante destacar que, se comparado com o circuito diodo Zener e divisor de tensão, o circuito utilizando opto acoplador possui a vantagem de isolar o circuito do sensor, atuando com uma proteção. Em caso de ocorrência de algum curto circuito no sensor, esta corrente não afetará a placa de circuito microcontrolador.

Ajustando a sensibilidade do sensor

É comum que esses sensores disponham de um parafuso na parte traseira da carcaça para ajustar a sensibilidade de comutação. Uma vez que se deseja empregar esse sensor em algum projeto prático, é necessário realizar o devido ajuste. Outra observação importante é a existência de um pequeno led na parte traseira do invólucro, que tem o papel de indicar a comutação do sensor, auxiliando até mesmo no ajuste da sensibilidade e em casos de manutenção e verificação de falhas. A imagem a seguir permite identificar o parafuso de ajuste e o led:

Montando o projeto

Agora, vamos conectar os componentes do projeto na protoboard. Para isso, desligue o cabo USB de seu Arduino e monte seu circuito conforme a figura a seguir.

Existem duas observações importantes sobre a montagem: a primeira diz respeito a alimentação do sensor, pois, como sabemos, o sensor pode ser alimentado por uma fonte DC de 10 a 30Vdc (no diagrama acima utilizamos uma bateria comum por questões de representação). A segunda observação é sobre o jumper de GND do Arduino conectado ao da fonte de alimentação do sensor, pois, sem essa conexão o circuito não funcionará de forma adequada pois os mesmos não dispõem de um sinal de referência em comum. Uma vez que a montagem acima esta finalizada, falta realizar a programação do seu modulo Arduino.

Programando

Abra sua IDE e conecte o Arduino ao computador por meio do cabo USB e analise o código a seguir.

- Código utilizado

Agora que toda a parte de hardware da aplicação está montada, vamos ao software responsável por coletar o sinal do sensor e fazer a indicação da comutação do sensor capacitivo:

//Arduino e Sensor Capacitivo

#define pinSensor 8   //Define o pino de entrada do sinal do sensor
#define LED 13        //Define led(pino 13) da placa do arduino 

bool statusSensor = false;  //variável que armazena o estado do sensor 

void setup() {
  Serial.begin(9600); //Inicialização da porta de comunicação Serial

  pinMode(pinSensor, INPUT); //Define o sensor como entrada de informações
  pinMode(LED, OUTPUT);      //Define o led como saída
}

void loop() {

  //Faz a leitura digital do estado do sensor
  //acionado - 0(0V)  desacionado - 1(+Vcc) 
  statusSensor = digitalRead(pinSensor); 

  //se o valor da variável for 1(true) entra no if
  if (statusSensor == true) {
    Serial.println("Objeto nao Detectado!");  //exibe na serial a string dentro das aspas
    digitalWrite(LED, LOW); //Apaga o led
  }

  //se o valor da variável for 0(false) entra no else if
  else if (statusSensor == false) {
    Serial.println("Objeto Detectado!"); //exibe na serial a string dentro das aspas
    digitalWrite(LED, HIGH);  //Acende o led
  }

  delay(500); //atraso de 1/2 segundo
}

Colocando para funcionar

Para se verificar o funcionamento do sensor capacitivo, foi montado em bancada o circuito que reduz a tensão de saída juntamente com um Arduino Mega, como pode ser visualizado na imagem a seguir:

Leitura do sinal do sensor capacitivo com Arduino.

Monitor serial aberto.

Entendendo a fundo

Software

– Declarando as variáveis do projeto

Primeiramente, para desenvolver a aquisição do sinal do sensor é necessário a criação ou definição das variáveis de entrada e saída do Arduino. A variável pinSensor é responsável por definir o pino de entrada do sinal do sensor no microcontrolador e a variável LED é utilizada para definir o pino do led da placa Arduino Mega. Ja á variável statusSensor (do tipo booleana) tem a função de armazenar o valor referente ao estado do sensor.

#define pinSensor 8   
#define LED 13

bool statusSensor = false;

– Estabelecendo as configuraões iniciais

Na função setup(), existem duas seções, a primeira delas é a função Serial.begin(9600), onde é inicializado a porta de comunicação serial e definimos o baudrate para 9600. A segunda parte é composta pela definição das I/O, ou seja, com a função pinMode(pinSensor, INPUT) definimos que a variável pinSensor é um pino de entrada de dados. Da mesma forma com a instrução pinMode(LED, OUTPUT) determinamos que a variável LED é um pino de saída do Arduino.

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

  pinMode(pinSensor, INPUT); 
  pinMode(LED, OUTPUT);      
}

– Aquisição do sinal do sensor

Na função void loop(), utiliza-se primeiramente a instrução digitalRead(pinSensor) para armazenar na variável statusSensor o valor digital do estado do sensor que pode ser 0(false) ou 1(true), o parêmetro dentro dos parênteses é o pino a ser lido.

 statusSensor = digitalRead(pinSensor);

Na próxima linha de código, existe a condicional if(), caso o estado do sensor armazenado na variável statusSensor venha a ser 1(true), a condição é aceita e o Arduino executa as duas funções dentro da condicional. A primeira função Serial.println("Objeto nao Detectado!"), exibe no monitor serial Objeto nao Detectado!, que o sensor não esta detectando nenhum objeto ou fluído próximo a sua área de contato. A segunda instrução executada é a digitalWrite(LED, LOW), tal função  recebe dois parâmetros (pino do Arduino, nível lógico) desta forma como o comando foi LOW a saída(led) é desligado.

  if (statusSensor == true) {
    Serial.println("Objeto nao Detectado!");  
    digitalWrite(LED, LOW); 
  }

Da mesma forma existe uma condicinal else if() que avalia o caso em que o sensor esta detectando algum objeto próximo a sua região de sensibilidade. Sendo assim, se o valor de statusSensor for 0(false), a condição é válida e o Arduino executa as duas próximas funções dentro das chaves. A primeira função Serial.println("Objeto Detectado!"),  exibe no monitor serial Objeto Detectado!, que o sensor esta detectando objeto próximo a sua face frontal, e a segunda instrução ascende o led da placa digitalWrite(LED, HIGH), pois foi passado o parêmetro HIGH(ligado, 1).

  else if (statusSensor == false) {
    Serial.println("Objeto Detectado!"); 
    digitalWrite(LED, HIGH); 
  }

A última linha de código é composta pela função delay(ms), essa função quando executada gera um atraso no código em milisegundos de acordo com o valor do parâmetro passado dentro dos parênteses, nesse caso 500ms ou 1/2 segundo.

delay(500);

Desafio

Desenvolva um projeto que seja possível medir o nível de algum fluído em um reservatório e acionar uma bomba d'água quando o nível estiver baixo. Para isso utilize um sensor capacitivo, uma válvula solenóide ou bomba de aquário e uma ponte H para fazer o acionamento destes.

Considerações finais

Espera-se que este tutorial possa ter ajudado no desenvolvimento de seu projeto. A equipe responsável agradece pela sua leitura e, em caso de dúvidas e sugestões, deixe seu comentário para que possamos sanar suas dúvidas! Obrigado!

by Equipe MountainBaja

ScadaBR com Arduino via Modbus TCP/IP

ScadaBR com Arduino via Modbus TCP/IP 

No tutorial anterior aprendemos a dar o primeiros passos com SCADABR. Dando sequencia, neste tutorial demonstraremos os procedimentos necessários para a comunicação do Arduino com o ScadaBR utilizando uma outra categoria do protocolo modbus: o modbus TCP/IP.

[toc]

Mãos à obra - Estabelecendo a comunicação entre uma placa Arduino e o ScadaBR

Componentes necessários

• 1 x Arduino UNO
• 1 x Shield Ethernet Wiznet W5100
• 1 x Protoboard
• 1 x Resistor 330 Ω
• 1 x Led verde difuso

Montando o projeto

Programando

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

const int LED_COIL = 0;

ModbusIP mb;

void setup() 
{
   byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }
   byte ip[] = { 192, 168, 25, 16 }; 
   mb.config(mac,ip);  
   pinMode(9, OUTPUT);
   mb.addCoil(LED_COIL); 

}
 
void loop() 
{
   mb.task();
   digitalWrite(9, mb.Coil(LED_COIL));

}

Configurando o Scadabr

Neste momento, vamos apresentar os procedimentos iniciais que devem ser feitos no ScadaBR para que seja possível realizar a interação entre mesmo e a nossa placa Arduino. Primeiramente, para cumprirmos o objetivo apresentado, devemos fazer com que o ScadaBR identifique o elemento com o qual irá se comunicar. Isto deve ser feito através da criação de um elemento chamado Data source, que por sua vez, será a ponte entre a placa Arduino que estamos utilizando e o ScadaBR.

Data source é a estrutura que permite a comunicação entre o Arduino e o ScadaBR

Em seguida, na criação do Data point, devemos dizer qual tipo de comunicação existirá entre os 2 elementos. Como dito anteriormente utilizaremos o protocolo Modbus através da comunicação serial, portanto basta na lista de seleção encontrar a opção Modbus IP e clicar no ícone à direita da lista em questão.

Em seguida, o ScadaBR irá nos direcionará para uma página, na qual, devemos definir os parâmetros do Data source em questão (lembre-se de que ele é a ponte entre o Arduino UNO e o ScadaBR). Em um primeiro momento, devemos apenas nomear o nosso Data source e também definir o tempo em que os dados serão atualizados (esta informação é muito importante, ou seja, torna-se fundamental que o leitor tenha conhecimento da aplicação que está desenvolvendo para que a escolha deste parâmetro resulte em um funcionamento eficaz do projeto).

Além destas configurações, devemos também especificar mais alguns parâmetros relativos à comunicação que será estabelecida estabelecida, como por exemplo: o endeceço IP previamente configurado no código do Arduino UNO e o tipo de transporte (sugerimos a opção "TCP com manter-vivo" em um primeiro momento. Não há necessidade de alterarmos o campo Porta.

Após a criação e configuração do Data source, devemos criar uma pequena estrutura denominada Data point. Os Data points são os elementos que irão conter os valores relacionados com as entradas e saídas da nossa placa Arduino. Para realizar este procedimento, vamos até a parte inferior da tela e em seguida clicamos no ícone localizado à direita da tabela referente aos Data points.

Após clicarmos no ícone citado, o ScadaBR nos dará uma janela com algumas opções para serem definidas. Primeiramente, devemos nomear o Data point (neste tutorial, chamamos o mesmo de LED). Em seguida, devemos garantir que campo Faixa do registro esteja com a opção Status do Coil selecionada.  Para salvar as configurações feitas, basta clicar no ícone existente na extremidade superior direita da janela.

Como este é um tutorial introdutório, nós não iremos abordar o funcionamento dos outros campos.

A figura a seguir mostra como a tabela onde estão organizados os Data points ficará após a criação realizada anteriormente. Para habilitar o data point desejado basta clicar no círculo vermelho presente no campo Status do Data point criado.

Por fim, devemos ir ao topo da página, salvar as configurações realizadas (procedimento idêntico ao realizado no passo anterior) e habilitar o Data source, clicando novamente no círculo vermelho existente ao lado do ícone de utilizado para salvar.

Neste momento o leitor deve retornar a watch list (primeiro ícone da esquerda na barra de ferramentas) e no lado esquerdo da interface apresentada, clicar na seta para visualizar o estado do data point criado.

Após realizarmos o procedimento citado anteriormente, o nosso Data point aparecerá criado no lado direito da interface apresentada em nossa watchlist.

.

Para acionarmos o led basta posicionarmos o mouse sobre o ícone localizado à esquerda do nome do Data point e alterar o valor do mesmo (repare que quando o valor do mesmo for 0 (zero), o led estará apagado, ao passo que, quando alterarmos para 1(um) o led será acionado).

Veja o resultado do acionamento do led no ScadaBR.

Entendendo a fundo

Software

Neste ponto, serão demonstrados todos os passos para o desenvolvimento do código que deve ser inserido no Arduino UNO para que seja possível a realização da comunicação entre o mesmo e o ScadaBR.

– Incluindo as bibliotecas que serão utilizadas

O primeiro passo para o estabelecimento da comunicação entre os dois elementos consiste na inclusão das bibliotecas adequadas para a utilização do protocolo Modbus TCP/IP (desenvolvidas pelo  André Sarmento e estão disponíveis aqui). Além disso, devemos declarar também as bibliotecas responsáveis pelo funcionamento do protocolo de comunicação SPI e pela conectividade da nossa placa Arduino com a rede local.

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

– Definindo as estruturas do protocolo Modbus

Posteriormente, devemos determinar a estrutura que será responsável pelo acionamento do led. Neste tutorial, iremos abordar apenas uma entre as demais estruturas existente no protocolo MODBUS: os Coils. Estes elementos atuam no armazenamento de valores que podem ser utilizados no acionamento on/off de dispositivos.

Para definirmos o Coil que será utilizado no acionamento do led basta declararmos uma variável do tipo const int e em seguida atribuir um número à mesma de acordo com a quantidade de Coils em uso no projeto (como nesta aplicação estamos utilizando somente um Coil, atribuímos o numero 0 (zero) à variável declarada).

const int LED_COIL = 0;

– Criando o objeto mb

Antes de prosseguir para a função setup(), deve-se criar um objeto chamado mb para que possamos fazer o controla das estruturas existentes no protocolo Modbus.

ModbusIP mb;

– Definindo as configurações iniciais

Na função Setup() existem algumas linhas de código referentes às definições iniciais do programa. Primeiramente, devemos definir alguns parâmetros relacionados ao protocolo de comunicação utilizado, de modo que, este procedimento é realizado através da definição dos endereços MAC e IP da nossa placa Arduino UNO (na prática, o endereço MAC pode ser qualquer um, desde que seja único na rede, enquanto o endereço IP deve ser um endereço válido em sua rede local). Em seguida, para configurarmos o nosso protocolo Modbus, utilizamos a função config() em conjunto com os valores determinados anteriormente.

Em seguida, utilizamos a função pinMode() para definir o modo de operação do pino digital 9 como uma saída digital e por fim, adicionamos o Coil que será responsável por conter os valores utilizados no acionamento do led.

void setup() {
  
 byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED } 
 byte ip[] = { 192, 168, 25, 16 }; 
 mb.config(mac,ip); 
 pinMode(9, OUTPUT); 
 mb.addCoil(LED_COIL);

}

– Realizando o acionamento do led

Dentro da função loop(), utilizamos a função task() para gerenciar a comunicação e a troca de dados entre os dispositivos que estão conectados através do protocolo Modbus. Além da função citada, temos também a função necessária para realizar a escrita do dado referente ao acionamento do led na instância Coil.

void loop() {
 
mb.task();
  
digitalWrite(9, mb.Coil(LED_COIL));

}

Considerações finais

Neste tutorial, demonstramos como você fazer para estabelecer uma comunicação entre a sua placa Arduino e o ScadaBR através de uma rede local, esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Scadabr com Arduino - Primeiros Passos

Scadabr com Arduino via Modbus Serial

Neste tutorial aprenderemos a importância dos sistemas supervisórios e vamos dar início ao desenvolvimento de projetos de automação utilizando as placas Arduino em conjunto com o ScadaBR. Aqui, iremos apresentar alguns conceitos introdutórios para que você entenda todo conteúdo de maneira bastante simples e rápida. Além disso, o foco deste conteúdo será a demonstração dos procedimentos necessários para que seja possível realizar a comunicação entre os dois elementos citados.

[toc]

A importância dos sistemas supervisórios

Ao lidar com sistemas automáticos é comum que tenhamos alguma interface para o acompanhamento das variáveis do processo. Seja a temperatura de um cômodo sob o efeito do funcionamento de um ar condicionado ou até mesmo a velocidade de um avião. Com certeza você deve ter em mente vários outros exemplos de sistemas automáticos que precisam de supervisionamento, ou seja, de que alguém acompanhe as variáveis do processo.

Esse supervisionamento pode ter várias motivações, alguns exemplos:

• Verificar se o sistema está respondendo da forma correta
• Verificar possíveis desequilíbrios inesperados seja por falha do sistema automático ou por algum problema físico com o equipamento
• Prevenir acidentes
• Coleta de informações de produtividade

Para isso, precisamos dos sistemas supervisórios que disponibilizam as informações do processo para que o usuário possa monitorá-las e rastreá-las. Estes sistemas também são chamados de SCADA (Supervisory Control and Data Aquisition).

Sistemas SCADA

Inicialmente, podemos dizer que os sistemas SCADA (Supervisory Control And Data Aquisition) consistem em softwares que são utilizados para supervisionar e controlar atividades ou processos que detenham algum nível de automação. Tais sistemas são encontrados de maneira ampla em aplicações industriais, porém, também estão presentes em outros setores, como por exemplo, geração, transmissão e distribuição de energia elétrica, atividades acadêmicas e até mesmo em projetos automação residencial.

A função de supervisão realizada por um sistema SCADA em cima de um determinado processo ocorre por meio da aquisição dos dados referentes ao comportamento das variáveis de controle existentes no mesmo através de sensores. Em contrapartida, a função de controle desempenhada pelo sistema em questão está relacionada ao envio de comandos para os equipamentos e dispositivos presentes no processo citado.

Desta maneira, podemos notar que, para atingir o objetivo de monitorar e controlar sistemas ou processos com eficiência, o software SCADA deve ter a capacidade de comunicar-se com o um grande número de dispositivos, inclusive, produzidos por diversos fabricantes (motivo pelo qual os sistemas SCADA normalmente oferecem uma vasta gama de drivers de comunicação, envolvendo os mais diversos protocolos utilizados, para que a troca de informações possa ocorrer com o mínimo de incompatibilidade possível).

Antigamente, os sistemas SCADA eram mais utilizados em conjunto com equipamentos como CLPs e SDCDs, no entanto, com a popularização de sistemas embarcados mais acessíveis e dotados de uma boa capacidade de processamento (como por exemplo, as placas Arduino), os sistemas SCADA estão sendo cada vez mais encontrados em aplicações de automação, das mais variadas vertentes, utilizando os elementos citados.

ScadaBR

O ScadaBR é um sistema SCADA cuja função consiste em possibilitar a realização de procedimentos de aquisição de dados e além disso, é composto por ferramentas que auxiliam no desenvolvimento de sistemas supervisórios para monitoramento de processos. É importante ressaltar que o ScadaBR é um recurso disponibilizado em licença Open Source e o mesmo também possui suporte para uma vasta gama de protocolos de comunicação, sendo portanto, compatível com um grande número de hardwares dos mais diversos fabricantes, característica essencial para ser utilizado, por exemplo, em ambientes industriais.

Assim como a maioria dos sistemas SCADA, o ScadaBR possui basicamente duas frentes, sendo que uma delas é voltada para o desenvolvimento, onde pode-se produzir interfaces gráficas para que o operador do processo em questão possa interagir de maneira mais eficiente com o mesmo, seja monitorando as variáveis do processo ou até mesmo manipulando-as, enquanto a outra é responsável pela execução da aplicação.

Além das tarefas usuais de controle e supervisão, o ScadaBR também disponibiliza várias ferramentas auxiliares como por exemplo:

• Banco de dados para armazenamento das informações pertinentes.
• Gerenciador de alarmes e eventos para indicação de falhas ou situações excepcionais.
• Ferramentas de representação gráfica para apresentação das informações ao longo do tempo, permitindo a realização de análises do comportamento de uma ou mais variáveis.
• Ambiente de elaboração de Scripts para desenvolvimento de lógicas de automação.
• Gerador de relatórios para formalizar as informações existentes no projeto

Estas e outras informações, assim como o manual de usuário do ScadaBR podem ser encontradas aqui.

Mãos à obra - Estabelecendo a comunicação entre uma placa Arduino e o ScadaBR

Componentes necessários

• 1 x Arduino Micro ou Arduino Uno
• 1 x Protoboard
• 1 x Resistor 330 Ω
• 1 x Led verde difuso

Montando o projeto

Programando o Arduino

#include <Modbus.h>;
#include <ModbusSerial.h>;

const int LED_COIL = 0;

ModbusSerial mb;

void setup() 
{
   mb.config(&Serial, 38400, SERIAL_8N1);  
   mb.setSlaveId(10);
   pinMode(5, OUTPUT);
   mb.addCoil(LED_COIL); 

}
 
void loop() 
{
   mb.task();
   digitalWrite(5, mb.Coil(LED_COIL));

}

Instalando o ScadaBR

- Realizando o download do ScadaBR

Neste momento serão demonstrados os passos necessários para que o ScadaBR possa ser utilizado. Primeiramente, deve-se efetuar o download do ScadaBR propriamente dito, de modo que, para realizar este procedimento basta clicar na aba downloads presente no site do ScadaBR e em seguida no botão apresentado na figura abaixo, ou caso prefira, basta clicar aqui.

- Realizando o download do JRE6

Em seguida, deve-se efetuar o download do Java Runtime Environment 6 (lembre-se de escolher a versão compatível com o sistema operacional que está sendo utilizado). Este pode ser encontrado aqui

- Acessando o ScadaBR

Após a realização dos dois itens descritos, pode-se proceder com a instalação de ambos (para evitar erros, recomenda-se que o JRE 6 seja instalado antes do ScadaBR). Por fim, para acessar o ScadaBR basta clicar no ícone do mesmo (ou inicia-lo diretamente ao final da instalação) e inserir “admin” em ambos os campos (User id e Password, note que posteriormente será possível modificar estes parâmetros).

Configurando o Scadabr

- Criando o Data source

Neste momento, vamos apresentar os procedimentos iniciais que devem ser feitos no ScadaBR para que seja possível realizar a interação entre mesmo e a nossa placa Arduino.

Primeiramente, para cumprirmos o objetivo apresentado, devemos fazer com que o ScadaBR identifique o elemento com o qual irá se comunicar. Isto deve ser feito através da criação de um elemento chamado Data source , que por sua vez, será a ponte entre a placa Arduino que estamos utilizando e o ScadaBR.

Data source é a estrutura que permite a comunicação entre o Arduino e o ScadaBR

Em seguida, na criação do Data source, devemos dizer qual tipo de comunicação existirá entre os 2 elementos.

Como dito anteriormente utilizaremos o protocolo Modbus através da comunicação serial, portanto basta na lista de seleção encontrar a opção Modbus Serial e clicar no ícone à direita da lista em questão.

- Determinando as configurações iniciais do Data source

Em seguida, o ScadaBR irá nos direcionara para uma página, na qual, devemos definir os parâmetros do Data source em questão (lembre-se de que ele é a ponte entre o Arduino Micro e o ScadaBR). Em um primeiro momento, devemos apenas nomear o nosso Data source e também definir o tempo em que os dados serão atualizados (esta informação é muito importante, ou seja, torna-se fundamental que o leitor tenha conhecimento da aplicação que está desenvolvendo para que a escolha deste parâmetro resulte em um funcionamento eficaz do projeto).

Além destas configurações, devemos também especificar mais alguns parâmetros relativos à comunicação que será estabelecida estabelecida, como por exemplo: a porta COM utilizada (neste artigo utilizamos a porta COM4), e a taxa de transmissão utilizada (38400 bps).

- Localizando o Arduino

Posteriormente,  clicamos no botão pesquisar por nós (existente no quadro Pesquisa de nós modbus) para conferirmos se na porta COM4 existe algum dispositivo utilizando o protocolo Modbus. Como nós definimos no código do Arduino que o endereço do mesmo será o número 10, o ScadaBR encontrará justamente este endereço na lista apresentada na figura abaixo.

- Criando o Data point

Após a criação e configuração do Data source, devemos criar uma pequena estrutura denominada Data point.

Os Data points são os elementos que irão conter os valores relacionados com as entradas e saídas da nossa placa Arduino. Para realizar este procedimento, vamos até a parte inferior da tela e em seguida clicamos no ícone localizado à direita da tabela referente aos Data points.

Após clicarmos no ícone citado, o ScadaBR nos dará uma janela com algumas opções para serem definidas.

Primeiramente, devemos nomear o Data point (neste tutorial, chamamos o mesmo de LED). Em devemos definir 2 campos fundamentais: o primeiro é o ID do escravo (aqui devemos colocar o endereço determinado no código do Arduino) e o segundo é a Faixa do registro (neste campo devemos selecionar a opção Status do Coil).  Para salvar as configurações feitas, basta clicar no ícone existente na extremidade superior direita da janela.

Como este é um tutorial introdutório, nós não iremos abordar o funcionamento dos outros campos.

- Habilitando o Data point

A figura a seguir mostra como a tabela onde estão organizados os Data points ficará após a criação realizada anteriormente. Para habilitar o data point desejado basta clicar no círculo vermelho presente no campo Status do Data point criado.

- Salvando o Data source

Por fim, devemos ir ao topo da página, salvar as configurações realizadas (procedimento idêntico ao realizado no passo anterior) e habilitar o Data source, clicando novamente no círculo vermelho existente ao lado do ícone de utilizado para salvar.

- Ativando o Data point criado

Neste momento o leitor deve retornar a watch list (primeiro ícone da esquerda na barra de ferramentas) e no lado esquerdo da interface apresentada, clicar na seta para visualizar o estado do data point criado.

Após realizarmos o procedimento citado anteriormente, o nosso Data point aparecerá criado no lado direito da interface apresentada em nossa watchlist.

Para acionarmos o led basta posicionarmos o mouse sobre o ícone localizado à esquerda do nome do Data point e alterar o valor do mesmo (repare que quando o valor do mesmo for 0 (zero), o led estará apagado, ao passo que, quando alterarmos para 1(um) o led será acionado).

Veja o resultado do acionamento do led no ScadaBR.

.

Entendendo a fundo

Software

Neste ponto, serão demonstrados todos os passos para o desenvolvimento do código que deve ser inserido no Arduino Micro para que seja possível a realização da comunicação entre o mesmo e o ScadaBR.

– Incluindo as bibliotecas que serão utilizadas

O primeiro passo para o estabelecimento da comunicação entre os dois elementos consiste na inclusão das bibliotecas adequadas para a utilização do protocolo Modbus Serial no código do Arduino Micro. As bibliotecas utilizadas neste artigo foram desenvolvidas pelo André Sarmento e estão disponíveis aqui.

#include <Modbus.h>;
#include <ModbusSerial.h>;

– Definindo as estruturas do protocolo Modbus

Posteriormente, devemos determinar a estrutura que será responsável pelo acionamento do led.

Neste tutorial, iremos abordar apenas uma entre as demais estruturas existente no protocolo MODBUS: os Coils. Estes elementos atuam no armazenamento de valores que podem ser utilizados no acionamento on/off de dispositivos.

Para definirmos o Coil que será utilizado no acionamento do led basta declararmos uma variável do tipo const int e em seguida atribuir um número à mesma de acordo com a quantidade de Coils em uso no projeto (como nesta aplicação estamos utilizando somente um Coil, atribuímos o numero 0 (zero) à variável declarada).

const int LED_COIL = 0;

– Criando o objeto mb

Antes de prosseguir para a função setup(), deve-se criar um objeto chamado mb para que possamos fazer o controla das estruturas existentes no protocolo Modbus.

ModbusSerial mb;

– Definindo as configurações iniciais

Na função Setup() existem algumas linhas de código referentes às definições iniciais do programa.

Primeiramente, devemos configurar os parâmetros relacionados ao protocolo de comunicação utilizado, de modo que, este procedimento é realizado através da função config(), na qual, o único parâmetro que precisamos alterar é o segundo (que diz respeito à taxa de transmissão utilizada).

Em seguida, utilizamos a função setSlaveId() para definirmos o endereço que será atribuído ao Arduino Micro, neste caso, utilizaremos o endereço 10.

Em seguida, utilizamos a função pinMode() para definir o modo de operação do pino digital 5 como uma saída digital e por fim, adicionamos o Coil que será responsável por conter os valores utilizados no acionamento do led.

void setup() {
  
mb.config(&Serial, 38400, SERIAL_8N1);
mb.setSlaveId(10);
pinMode(5, OUTPUT);
mb.addCoil(LED_COIL); 

}

– Realizando o acionamento do led

Dentro da função loop(), utilizamos a função task() para gerenciar a comunicação e a troca de dados entre os dispositivos que estão conectados através do protocolo Modbus. Além da função citada, temos também a função necessária para realizar a escrita do dado referente ao acionamento do led na instância Coil.

void loop() {
 
mb.task();
  
digitalWrite(5, mb.Coil(RELE_COIL));

}

Considerações finais

Neste tutorial, demonstramos como você fazer para estabelecer uma comunicação entre a sua placa Arduino e o ScadaBR, esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Como usar uma Protoboard?

Protoboard - O que é e como usar?

Protoboard, matriz de contato, breadboard e placa de ensaio. Vários nomes para uma das peças mais importantes quando o assunto é montagem de circuitos elétricos. Seja para fins educacionais ou até para o desenvolvimento de protótipos iniciais de produtos em empresas, a protoboard sempre estará presente. Nesse tutorial você entenderá, de uma vez por todas, o que é e como usar esta ferramenta que te acompanhará por toda a sua jornada como desenvolvedor.

[toc]

O que é Protoboard?

Lembro da minha primeira aula de laboratório de eletricidade. Foi a minha primeira vez com uma protoboard, inesquecível! hehehe

Eu até entendia bem sobre como funcionavam os circuitos elétricos.  Apesar de tudo aquilo ser novo para mim, eu estava confiante, já estava acostumado a fazer algumas gabiarras (quase tinha colocado fogo em casa algumas vezes =|). Estava ansioso para me divertir nas experiências práticas e me tornar um mestre dos circuitos elétricos.

Foi então que chegou o tão esperado dia, entrei no laboratório e, em minha bancada, me deparei com aquela pastilha de plastico branca e cheia de furos (ela também estava cheia de marcas de fogo oriundas de curtos-circuito e explosões de capacitores), eu não era capaz de imaginar como aquilo poderia me ajudar a montar o meu circuito.

Verdade seja dita, o primeiro dia com uma protoboard é sempre muito confuso (há aqueles que passam a vida toda na mesma confusão). Imagine você olhar uma placa com algumas centenas de furos e, sem uma explicação decente de como usar ela, ter que montar um circuito elétrico (que para os inciantes é algo totalmente novo).

A protoboard, aquela pastilha plastica estranha, era um dos equipamentos mais importantes daquele laboratório. Com ela era possível montar e desmontar circuitos repetidas vezes. 

- Uma Placa de Ensaio reutilizável

Em português, o nome correto para a famosa protoboard é Placa de Ensaio ou Matriz de contato, o que define bem a função dela e como ela funciona.

Quando trabalhamos com circuitos elétricos em laboratório, seja para fins educacionais ou profissionais, muitas vezes usamos a protoboard. Ela tem o intuito de simplificar o processo de estudo e pesquisa referentes aos circuitos elétricos e eletrônicos.

Com uma protoboard é possível construir protótipos de projetos ou ensaiar circuitos, pois, sendo ela uma matriz de contato reutilizável, evitamos a necessidade de confeccionar uma placa de circuito impresso e possibilitando a fácil alteração do circuito, deixando ele flexível.

Usando o Arduino, por exemplo, continuamente teremos que montar circuitos com LED’s, sensores, entre outros. Dessa forma, o uso de protoboards será comum no seu dia-a-dia como um desenvolvedor.

Como uma Protoboard funciona?

Continuando a jornada de minha primeira aula de laboratório, lembro que o professor desenhou no quadro o que seria o Raio-x da Protoboard e explicou que por dentro da Protoboard havia uma matriz de contatos. Vários barramentos metálicos em paralelo tal como podemos ver nessa imagem em que cada linha desenhada representa um barramento.

A imagem a seguir mostra uma foto de dentro da protoboard, onde podemos identificar esses barramentos metálicos :

Esses barramentos metálicos tem a forma de um grampo:

Assim, quando enfiamos um fio na protoboard ele fica preso internamente a este grampo:

Veja uma foto por baixo da placa de ensaio:

- Barramentos de alimentação

Nas extremidades superior e inferior podemos notar 4 barramentos na horizontais: 2 em cima e 2 em baixo.

Essa linhas desenhadas representam um barramento metálico na horizontal, no qual, todos os pontos de uma mesma linha conectados entre si.

Você poderá identificar facilmente esses barramentos em sua protoboard. Em geral elas possuem a função de barramentos de alimentação e por isso costumam ter uma indicação de tensão positiva e negativa.

Veja que na foto onde mostramos esse barramentos metálicos de alimentação nitidamente:

- Barramentos de prototipagem

- No centro, temos barramentos perpendiculares com um pequeno espaçamento no meio.

- Note que, para a protoboard de 400 pontos, temos 60 barramentos verticais de 5 pontos cada. São 30 na parte superior e outros 30 na parte inferior separados por uma divisão.

- É importante você ter em mente que os barramentos de cima não são conectados nos de baixo. Ou seja, Na coluna 1, o pontos entre linha A e E formam um barramento vertical. Enquanto que, na mesma coluna só que entre a linhas F e J existe outro barramento.

Veja como esses barramentos metálicos estão dispostos na parte interna da matriz de contato:

- Resumo

Olhando todos os barramentos da protoboard, temos:

1. Barramentos horizontais em sua extremidades que geralmente são usados para alimentação do circuito, geralmente são 2 em cima e dois em baixo;
2. Barramentos verticais usados para a montagem do circuito
3. Existe um espaçamento central entre os barramentos verticais que separa em barramentos verticais superiores e inferiores

Modelos de protoboard

É possível encontrar diversos tamanhos de protoboard. Desde protoboard de 170 pontos até outras com mais de 3000 pontos.

Todas funcionam de forma semelhante, possuindo barramentos verticais e/ou  horizontais .

Para alguns modelos pequenos, tal como a de 170 pontos, temos apenas barramentos verticais devido ao espaço reduzido:

A protoboard 830 pontos é a mais popular de todas, muito usada para fins didáticos e profissionais.

Fios Jumpers

Ao montar circuitos em sua protoboard, é essencial o uso de fios jumpers. Esses fios têm como função conduzir energia elétrica entre um barramento e outro, auxiliando na montagem do circuito.

Esse fios jumpers podem ser feitos em casa com fios de rede, foi com esses que comecei. O problema desses jumpes é o fato de os fios quebrarem com facilidade.

Hoje é possível comprar fios jumpers próprios para prototipagem de vários tamanhos e modelos.

Esses fios jumpers facilitam muito a vida dos desenvolvedores.

Mãos à obra - Montando um circuito na Protoboard

Para entender como usar a protoboard, precisamos de um exemplo prático. Para isso montaremos um circuito simples para acender um LED.

Componentes necessários

• Protoboard - Usaremos uma protoboard de 830 pontos, mas você pode fazer em qual quer uma outra
• Fios Jumpers
• 1x LED Difuso Vermelho
• 1x Resistor 220Ohm
• 1x Chave momentânea (push button)
• Fonte de Alimentação 5V

Montando o Circuito

O circuito que vamos montar é bem simples, ele tem como função deixar um LED ligado. O desenho do circuito é:

Na protoboard esse circuito ficará da seguinte forma.

Entendendo a fundo

Vamos seguir esse circuito passo a passo a montagem do circuito na protoboard:

- Definindo os barramentos de Alimentação

Primeiro vamos definir os barramentos que irão receber os pinos de alimentação. Em geral costumo usar um barramento de cima para alimentação positiva e um barramento de baixo para o GND (referência).

É importante que só se ligue a energia nesses barramentos depois que o circuito estiver pronto. Ou seja, definimos o barramento que será usado, mas ainda não conectaremos nele os fios da fonte externa de tensão. Por isso iremos desconsiderar a fonte de alimentação.

Dessa forma, vamos chamar o barramento positivo pela letra A e o barramento de referência pela letra G.

- Conectando o resistor

O próximo passo é conectar o resistor. Para montagem do circuito é usual usar os barramentos verticais. Dessa forma, conectamos uma das pernas em um barramento (B) e a outra perna em outro (C).

Como uma das pernas do resistor estará conectada a fonte de alimentação positiva, precisamos colocar um jumper entre o barramento A e B.

- Conectando o LED

Agora vamos conectar o LED. Como ele tem uma de suas pernas conectadas à umas das pernas do resistor, vamos colocar essa primeira perna no barramento C e a outra perna no barramento D.

OBS.: Ao usar um LED você deve se atentar para o posicionamento correto dele. A corrente deve fluir da maior perna para a menor. Para nosso experimento a maior perna do LED fica conectada ao resistor, a menor irá se conectar à chave momentânea.

- Conectando a chave momentânea

Agora precisamos conectar a chave momentânea. Para isso iremos coloca-la entre os barrementos verticais superiores e  inferiores.

Como uma da pernas da chave está conectada ao LED, vamos colocar essa perna no barramento D.

Aqui, também precisamos colocar um fio jumper indo da chave momentânea (E) para o barramento de referência (G).

- Ligando a fonte externa

Agora que nosso circuito está montado, basta ligar a fonte de alimentação externa com 5V.

Essa fonte de energia pode ser oriunda dos pinos de alimentação 5V e GND de um Arduino UNO por exemplo. Você também poderá usar um conjunto em série de 6 Pilhas AA 1,5V, que totalizará 6V.

Por fim teremos o seguinte circuito. Em preto, destacamos por onde a corrente está sendo conduzida através dos barramentos metálicos da matriz de contato.

Dica

Ao usar o protoboard, eu costumo dividir meu circuito em nós, denominando cada um com uma letra e depois considerando que cada nó é um barramento do protoboard.

Nó, em circuitos elétricos, nada mais é que um ponto comum de interligação de dois ou mais componentes.

Veja que no exemplo anterior dividimos o circuito em vários nós e o denominamos com letras. Ao transferir para protoboard, cada nó assumiu seu próprio barramento.

Considerações finais

Nesse tutorial vimos como é organizada uma protoboard e como montar um circuito simples nela. Agora que você entende como usá-la, você poderá trabalhar em seus projetos com mais autonomia.

Boa diversão!

by Allan Mota

Shield Ethernet W5100 - Controlando um LED RGB via PWM com HTML

Shield Ethernet W5100 - Controlando um LED RGB via PWM com HTML - Servidor WEB

Neste tutorial, iremos ampliar um pouco mais do conteúdo relacionado à criação de um Servidor Web utilizando o Arduino UNO juntamente com o Ethernet Shield W5100. Anteriormente, aprendemos a desenvolver uma interface utilizando caixas de seleção, através das quais, tornou-se possível o realizarmos o acionamento e o desligamento de relés (e consequentemente cargas que não poderiam ser acionadas diretamente pelo Arduino UNO). Desta vez, vamos demonstrar como criar uma interface HTML para controlarmos a cor da luz emitida por um LED RGB usando PWM.

É importante, para o pleno entendimento desse tutorial, que o leitor tenha lido todos os tutoriais anteriores:

• Shield Ethernet W5100 - Criando um Servidor Web com Arduino
• Shield Ethernet W5100 - Monitorando sensores com um Servidor Web
• Shield Ethernet W5100 - Controlando saídas via Servidor Web
• Shield Ethernet W5100 - Acionamento remoto de relés com HTML

Além disso, caso você queira aprender mais sobre o funcionamento destes tipo de LED, confira o nosso tutorial específico sobre a utilização de LED RGB.

[toc]

Mãos à obra - Criando a interface HTML para manipulação do LED RGB via PWM

Componentes necessários

Para desenvolver este projeto, precisaremos dos seguintes componentes:

• 1 x Placa Arduino UNO Rev 3
• 1 x Shield Ethernet Wiznet W5100
• 1 x LED RGB Catodo Comum
• 3 x resistores de 330Ω
• 1 x Protoboard

Montando o projeto

Programando

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

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 25, 16);
EthernetServer server(80);

void setup() 
{
  Ethernet.begin(mac, ip);
  server.begin();
  pinMode(5,OUTPUT);
  pinMode(6,OUTPUT);
  pinMode(9,OUTPUT);
 // Serial.begin(9600);
}
void loop() 
{  
     String req_str;
     EthernetClient client = server.available();  
     if (client) 
     {
           req_str = "";
           boolean currentLineIsBlank = true;
           while (client.connected()) 
           {
                 if (client.available()) 
                 {
                       char c = client.read();    
                       req_str += c;    
                       if(c == '\n' && currentLineIsBlank) 
                       {
                               int pwm_range_5 = 0;
                               int pwm_range_6 = 0;
                               int pwm_range_9 = 0;
                               client.println("HTTP/1.1 200 OK");
                               client.println("Content-Type: text/html");
                               client.println("Connection: close");
                                client.println();
                             client.println("<!DOCTYPE html>");
                             client.println("<html lang=\"pt-br\">");                
                                  client.println("<head>");
                                       client.println("<meta charset= \"UTF-8\"/>");
                                       client.println("<title>RGB Vida de silício</title>"); 
                                 client.println("</head>");
                                 client.println("<body>");
                                      client.println("<h1>Acionamento de leds RGB</h1>");
                                      client.println("<hr/>");
                                      client.println("<h2>Componentes do led RGB</h2>");
                                       if(req_str.startsWith("POST"))
                                        {
                                              String conteudo_POST = "";
                                              for(int i=0;i<26;i++)
                                              {
                                                  c = client.read();  
                                                  conteudo_POST += c; 
                                                  
                                              }
                                              
                                                   pwm_range_5 = conteudo_POST.substring((conteudo_POST.indexOf("PWM5") + 5),(conteudo_POST.indexOf("PWM6") - 1)).toInt();
                                                   pwm_range_6 = conteudo_POST.substring((conteudo_POST.indexOf("PWM6") + 5),(conteudo_POST.indexOf("PWM9") - 1)).toInt();
                                                   pwm_range_9 = conteudo_POST.substring((conteudo_POST.indexOf("PWM9") + 5),(conteudo_POST.indexOf("PWM9") + 8)).toInt();
                                                   analogWrite(5,pwm_range_5);
                                                   analogWrite(6,pwm_range_6);
                                                   analogWrite(9,pwm_range_9);
                                                    conteudo_POST = "";
                                                
                                            }
                                          client.println ("<form action=\"\" method=\"post\">");
                                                 client.println("<p>Porta D5: " + String(pwm_range_5) + "</p>");
                                                 client.println("0 <input type=\"range\" value=\"" + String(pwm_range_5) + "\"name=\"PWM5\"  min=\"0\"  max=\"255\" step=\"1\" onchange=\"submit()\"/>  255");
                                                 client.println("<p>Porta D6: " + String(pwm_range_6) + "</p>");
                                                 client.println("0 <input type=\"range\" value=\"" + String(pwm_range_6) + "\"name=\"PWM6\"  min=\"0\"  max=\"255\" step=\"1\" onchange=\"submit()\"/>  255");
                                                 client.println("<p>Porta D9: " + String(pwm_range_9) + "</p>");
                                                 client.println("0 <input type=\"range\" value=\"" + String(pwm_range_9) + "\"name=\"PWM9\"  min=\"0\"  max=\"255\" step=\"1\" onchange=\"submit()\"/>  255");
                                           client.println ("</form>");   
                                    client.println ("</body>");
                             client.println ("</html>");
                             break;
                         }
                  if (c == '\n') 
                 {
                       currentLineIsBlank = true;
                 }
                 else if (c != '\r')                   
                {
                      currentLineIsBlank = false; 
                                  }
            }
       }
       delay(1);
      client.stop();
     }
}

Colocando para funcionar

Entendendo a fundo

Software

Antes de começarmos com a explicação do código, gostaríamos de ressaltar que iremos apresentar apenas os detalhes dos tópicos não contemplados nos tutoriais anteriores, pois, desta maneira, será mais fácil focar nas partes referentes às atualizações feitas sobre o programa já existente, portanto, caso você tenha alguma dúvida sobre alguma parte do programa que não seja explicada neste momento, sugerimos que acesse o nossos materiais citados anteriormente.

– Definindo os pré-requisitos para o funcionamento do código

Inicialmente, devemos incluir duas bibliotecas no código para que o mesmo pudesse funcionar corretamente. A biblioteca SPI.h, responsável pela comunicação dos módulos do shield com o Arduino UNO utilizando o protocolo SPI e a biblioteca Ethernet.h que atua possibilitando a conexão do conjunto, em um primeiro momento, com uma rede local.

Após a inclusão das bibliotecas citadas, devemos definir um endereço MAC (lembre-se que este pode ser qualquer um, desde que seja único em sua rede local) e um endereço IP (este deve ser um endereço válido  e disponível dentro da sua rede local). Além disso, devemos criar o objeto que será responsável por representar o Servidor Web no código (aqui, chamamos este de server) e relacioná-lo com a porta 80.

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

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 25, 16);
EthernetServer server(80);

– Definindo as configurações iniciais

Dentro da função setup(), devemos determinar o modo de operação dos pinos digitais que serão utilizados (estes terão o papel de saídas digitais) . Além disso, iniciamos a conexão com a rede local através da função Ethernet.begin() (passando como parâmetro os endereços MAC e IP definidos anteriormente) e também iniciamos o Servidor Web por meio da sentença server.begin() (lembre-se que server é o objeto criado para representar o Servidor Web no código).

void setup() 
{
  Ethernet.begin(mac, ip);
  server.begin();
  pinMode(5,OUTPUT);
  pinMode(6,OUTPUT);
  pinMode(9,OUTPUT);
}

– Entendendo as requisições do navegador

Nos tutoriais anteriores, ressaltamos o mecanismo básico de funcionamento dos códigos voltados para a criação de Servidores Web, o qual, começa através de um procedimento padrão, que por sua vez, consiste em utilizar uma variável para obter caractere por caractere da requisição feita pelo navegador até que esta seja completamente recebida pelo Arduino UNO, de modo que, apenas a partir deste ponto inicia-se o processo de elaboração da página.

Em nosso último tutorial, apresentamos o modo de funcionamento do método GET, no entanto, neste material iremos fazer o uso do método POST. Assim como o método GET, o método POST também serve para envio de informações provenientes dos formulários para o nosso Servidor Web. O primeiro passo para a realização deste procedimento na declaração de uma variável local, do tipo String (esta servirá para armazenar a requisição feita pelo navegador).

void loop() 
{  
     String req_str;
     .
     .
     .

Em seguida, criamos o processo no qual esta variável será preenchida com os caracteres da requisição.

if (client.available()) 
                 {
                       char c = client.read();    
                       req_str += c;    
                       . 
                       . 
                       .

De acordo com o tutorial anterior, pudemos aprender que, em uma requisição GET, o parâmetro da requisição, ou seja, o elemento proveniente da interação do usuário do sistema com um formulário, está localizado na primeira linha da requisição em questão. Entretanto, no caso de uma requisição POST, este mesmo elemento está registrado apenas ao final da mesma. Logo, o que vamos fazer aqui é justamente ler a requisição inteira (ou até o aparente final, como se fosse uma requisição GET) e depois forçaremos o programa a ler mais alguns caracteres da mesma (estes irão conter o parâmetro da requisição).

O primeiro passo a ser realizado após a leitura inteira da requisição é inicializar as variáveis que irão conter os valores a serem utilizados na geração do sinal PWM para cada componente.

 if(c == '\n' && currentLineIsBlank) 
   {
       int pwm_range_5 = 0;
       int pwm_range_6 = 0;
       int pwm_range_9 = 0;
       .
       .
       .

– Enviando o cabeçalho da página

Após termos lido a requisição inteira, devemos primeiramente enviar o cabeçalho padrão para o navegador.

client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println();

– Desenvolvendo a nossa página

Para começar a desenvolver a nossa página, utilizamos primeiro a sentença <!DOCTYPE html> para informarmos ao navegador que estamos utilizando a versão 5 da linguagem HTML.

client.println("<!DOCTYPE html>");

Como sabemos, entre as tags <head> e </head>, fazemos algumas configurações pertinentes ao funcionamento da página que estamos desenvolvendo. As configurações citadas, correspondem à determinação do conjunto de caracteres que deverá ser utilizado pelo navegador (para apresentar caracteres acentuados) e à inclusão de um título na aba da página do navegador.

client.println("<head>");
    client.println("<meta charset= \"UTF-8\"/>");
    client.println("<title>RGB Vida de silício</title>"); 
client.println("</head>");

No corpo da página, começamos escrevendo alguns títulos utilizando as tags de cabeçalho <h1> e <h2>.

client.println("<body>");
     client.println("<h1>Acionamento de leds RGB</h1>");
     client.println("<hr/>");
     client.println("<h2>Componentes do led RGB</h2>");
     .
     .
     .

Em seguida, utilizamos a função startsWith() para verificarmos se a requisição que chegou é do tipo POST (esta função verifica se a primeira palavra do conteúdo armazenado na variável req_str é o fragmento de texto POST). Após verificarmos que a requisição é de fato do tipo POST, declaramos uma variável do tipo string e armazenamos nela 26 caracteres (existentes após o aparente término da requisição). Estes 26 caracteres são justamente o parâmetro da requisição POST, de modo que, este terá a seguinte forma: PWM5=xyz&PWM6=xyz&PWM9=xyz.

 if(req_str.startsWith("POST"))
    {
        String conteudo_POST = "";
        for(int i=0;i<26;i++)
        {
            c = client.read();  
            conteudo_POST += c; 
        }

Posteriormente, preenchemos as variáveis pwm_range5/6/9 com os valores existentes na variável conteudo_POST. Este processo, consiste em desmembrar a string inteira em vários pedaços e associar cada um deles à respectiva variável, que por sua vez, será utilizada na geração do sinal PWM. (A explicação do funcionamento das funções utilizadas pode ser encontrada em nossos tutoriais anteriores)

 pwm_range_5 = conteudo_POST.substring((conteudo_POST.indexOf("PWM5") + 5),(conteudo_POST.indexOf("PWM6") - 1)).toInt();
 pwm_range_6 = conteudo_POST.substring((conteudo_POST.indexOf("PWM6") + 5),(conteudo_POST.indexOf("PWM9") - 1)).toInt();
 pwm_range_9 = conteudo_POST.substring((conteudo_POST.indexOf("PWM9") + 5),(conteudo_POST.indexOf("PWM9") + 8)).toInt();

Por fim, geramos os sinais PWM e limpamos a variável conteudo_POST.

analogWrite(5,pwm_range_5);
analogWrite(6,pwm_range_6);
analogWrite(9,pwm_range_9);
conteudo_POST = "";

– Criando o formulário

Neste momento, adicionamos o formulário e explicitamos que o método que será utilizado para o envio de dados na requisição feita pelo navegador será o POST. Entre as tags <form> e </form>, criaremos os ranges, isto é, os elementos que serão utilizados na interface de comandos na página do navegador.

client.println ("<form action=\"\" method=\"post\">");
   client.println("<p>Componente Azul: " + String(pwm_range_5) + "</p>");
   client.println("0 <input type=\"range\" value=\"" + String(pwm_range_5) + "\"name=\"PWM5\"  min=\"0\"  max=\"255\" step=\"1\" onchange=\"submit()\"/>  255");
   client.println("<p>Componente Verde: " + String(pwm_range_6) + "</p>");
   client.println("0 <input type=\"range\" value=\"" + String(pwm_range_6) + "\"name=\"PWM6\"  min=\"0\"  max=\"255\" step=\"1\" onchange=\"submit()\"/>  255");
   client.println("<p>Componente Vermelha: " + String(pwm_range_9) + "</p>");
   client.println("0 <input type=\"range\" value=\"" + String(pwm_range_9) + "\"name=\"PWM9\"  min=\"0\"  max=\"255\" step=\"1\" onchange=\"submit()\"/>  255");
client.println ("</form>");

Os ranges devem ser incluídos no código através da tag <input> (assim como os checkboxes). Nesta tag nós utilizamos alguns atributos, estes são:

• type: Determina o tipo de elemento de entrada
• value: Valor no qual o cursor deverá permanecer
• name: Nome associado ao elemento
• min/max: Valores extremos da escala
• step: Passo

Considerações finais

Neste tutorial, demonstramos como você pode fazer para criar um sistema de acionamento de um LED RGB para ser utilizado através de um navegador de internet. Para isto, utilizamos um Arduino UNO em conjunto com um Ethernet Shield W5100. Esta foi a quinta parte de uma série de artigos sobre a criação de Servidores Web, portanto, esperamos que continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

A Revolução das Placas de Desenvolvimento

Como as placas de desenvolvimento estão revolucionando o mundo tecnológico?

Assim como internet a revolucionou o mundo, as placas de desenvolvimento vieram para trazer novas possibilidades para os desenvolvedores de tecnologia, sejam elas de pequeno, médio ou grande porte. A possibilidade de inovação pode ser um gancho para impulsionar ainda mais o crescimento tecnológico em todo mundo.

Nesse artigo, vamos falar sobre as principais placas utilizadas no desenvolvimento de tecnologias e aplicações como, por exemplo, as placas Arduino e Raspberry PI. Além disso, vamos falar um pouco também sobre o IoT.

[toc]

A revolução do Arduino

Objetivando a criação de um dispositivo funcional, fácil de programar e com preço acessível para todos os estudantes de eletrônica que buscavam uma maneira para montar seus protótipos sem complicações, nasceram as placas Arduino, fruto da inspiração de 5 pesquisadores da Itália no ano de 2005.

As placas Arduino seguem um conceito de hardware livre, isso significa que qualquer pessoa pode montar, modificar, personalizar e promover melhorias, pois, as mesmas possuem hardwares compostos de componentes, em sua maioria, básicos. Além da facilidade de personalização proposta pelo conceito das placas Arduino, para utilizá-las, basta que as mesmas sejam conectadas a um computador através de um cabo USB, para que então, o usuário possa programar o microcontrolador existente na placa com o código desejado.

O que pode ser feito com o Arduino?

As placas Arduino certamente proporcionaram e ainda proporcionam uma grande revolução tecnológica no mundo, que por sua vez, atinge vários níveis de usuários, indo desde aquelas pessoas com pouco conhecimento de eletrônica e programação, mas que se dedicam para conseguir desenvolver seus projetos, até aqueles que são, de fato, profissionais em assuntos relacionados com a manipulação de sistemas embarcados.

As possibilidades com as placas Arduino realmente são infinitas. Alguns exemplos são:

• Automatizar sua casa, carro, escritório;
• Automatizar os processos de manufatura da indústria;
• Criar novos brinquedos ou melhorar os já existentes;
• Uma infinidade de peças tecnológicas desde pequenos gadgets até projetos mais robustos totalmente inovadores conforme a criatividade do inventor.

Atualmente, podemos citar a IoT (Internet das Coisas) como um dos temas mais ligados à utilização das placas Arduino, isso porque, através deste conceito, cria-se uma concepção em que pode-se obter dados dos mais variados tipos e das mais diversas fontes, para que, posteriormente, alguma ou algumas tarefas possam ser executadas de acordo com os dados citados.

A obtenção das informações é realizada através de sensores, adequadamente posicionados e específicos para cada tipo de grandeza que desejamos aferir. Posteriormente, os dados obtidos são enviados para algum sistema dotado de uma certa capacidade de processamento, neste caso, uma placa Arduino, para que esta avalie as informações e gerencie as ações que devem ser tomadas em relação à manipulação dos equipamentos do sistema.

Assim como as placas Arduino, o conceito IoT também pode ser aplicado para otimizar as tarefas rotineiras, seja em uma casa, empresa, indústria e no agronegócio. De fato, a IoT e as plataformas Arduino estão extremamente ligadas quando o assunto é facilitar a vida das pessoas e criar condições adequadas para tomar decisões com mais assertividade para garantir um controle eficiente do processo produtivo e a redução de custos em alguns setores.

A contribuição das placas Raspberry Pi nessa revolução tecnológica

As placas de desenvolvimento da plataforma Raspberry Pi foram criadas com objetivos educacionais visando auxiliar no ensino e aprendizagem de disciplinas relacionadas à informática, eletrônica e etc, nos diversos cantos do mundo. O fato de possuírem muitos recursos interessantes e de fácil acesso, faz com que as placas Raspberry Pi sejam ideais para a criação de tecnologias que envolvam necessidade da existência de um software robusto por trás da aplicação proposta.

As placas Raspberry são sistemas embarcados fisicamente semelhantes às placas Arduino, mas acredite, estas são computadores completos e extremamente pequenos. Na estrutura de uma plataforma Raspberry Pi, ou seja, na placa de circuito impresso na qual o sistema é montado, estão contidos componentes como o processador, portas USB, entrada para cartão de memória, módulos para conectividade com redes sem fio, entre outros elementos.

Devido suas características, o RaspBerry também se tornou o grande responsável por inúmeros projetos inovadores incluindo desde brinquedos, peças de games e iluminação, robôs e na automação industrial.

Como essas placas de desenvolvimento influenciam a nova revolução industrial?

O conceito de indústria 4.0 traz consigo um conjunto de inovações tecnológicas referentes aos campos da automação e tecnologia da informação, que por sua vez, é aplicado em grande parte processos de manufatura industrial. Sendo assim, integrando as placas de desenvolvimento como as placas Arduino e as placas Raspberry com o conceito de IoT (Internet das coisas) é possível melhorar todos os processos industriais conferindo aumento de eficiência em diversas vertentes.

As chamadas indústrias inteligentes são frutos das grandes revoluções tecnológicas que incentivam a melhoria dos processos de manufatura aumentando a capacidade de operação através da rastreabilidade e monitoramento das atividades através do uso de produtos desenvolvidos, muitas vezes, com as plataformas de desenvolvimento citadas.

Por isso, podemos dizer que estamos na quarta revolução industrial, na era das máquinas livres.

E aí, gostou do artigo? Qual é a sua opinião sobre as placas de desenvolvimento? Qual delas você utiliza?

Artigo enviado pela Agência de Marketing Digital Webtrends, que oferece serviços como Consultoria de Otimização SEO e Criação de Site. 

by Daniel Madeira

Manipulando as portas de saída digital do Arduino com Excel

Manipulando as portas de saída digital do Arduino com Excel

Em nosso tutorial anterior, apresentamos os procedimentos necessários para que você pudesse estabelecer uma conexão entre a sua placa Arduino e o Microsoft Excel. Neste tutorial, vamos prosseguir com este assunto, ensinando a você como devemos proceder para acionar as saídas digitais do seu Arduino (utilizando VBA), no entanto, com mais detalhes.

[toc]

Mãos à obra - Estabelecendo a comunicação entre o Arduino Micro e o Microsoft Excel

Componentes necessários

• 1x Arduino Micro, Placa Arduino UNO Rev 3 ou outro Arduino
• 1 x Protoboard
• 1 x Resistor 330 Ω
• 1 x Led verde difuso

Montando o projeto

Criando a interface do Microsoft Excel

Neste momento, iremos apresentar os passos necessários para que você consiga realizar o desenvolvimento básico de uma interface, a qual, irá conter os botões responsáveis pela manipulação da nossa placa Arduino. Apenas como uma observação, estamos utilizando o Microsoft Excel versão 2013, portanto, é possível que pequenas alterações devam ser feitas, caso você esteja utilizando uma outra versão deste software.

- Criando o botão de abertura da porta COM

O primeiro passo no desenvolvimento da interface citada consiste na criação de um botão e na adição de funcionalidade ao mesmo. Este botão será responsável por fazer com que a porta COM seja aberta, possibilitando portanto, a comunicação do Microsoft Excel com o nosso Arduino Micro.

Para realizar este procedimento você deverá selecionar a opção Inserir (insert) na aba de desenvolvimento e em seguida a opção Botão (Button).

Após o passo anterior, basta arrastar o cursor e criar um botão do tamanho desejado. Veja o resultado:

Antes de prosseguirmos, devemos clicar com o botão direito do mouse sobre o elemento criado e em seguida renomeá-lo para Abrir porta COM.

- Criando o botão de fechamento da porta COM

O procedimento de criação do botão responsável pelo fechamento da porta COM é idêntico ao realizado anteriormente, de modo que, a única diferença existente entre os dois está no código da Macro que será utilizada. Neste caso, a Macro em questão é a referente ao funcionamento do botão de fechamento da porta COM.

- Criando o botão de acionamento do Led

Em seguida, iremos repetir o procedimento de criação para elaborar o botão que será utilizado para acender o led existente em nosso hardware. Neste botão, atribuiremos a Macro referente ao botão de acionamento do Led.

- Criando o botão de desligamento do Led

Por fim, criaremos o botão para desligar o led citado anteriormente. Neste botão, atribuiremos a Macro referente ao botão de desligamento do Led.

Programando - Código do Microsoft Excel

Esse projeto consiste em duas partes distintas de programação: Uma referente à placa Arduino e outra referente ao Microsoft Excel. Começaremos explicando como fazer toda a programação do Microsoft Excel para em seguida mostrar o código utilizado em nosso Arduino.

- Atribuindo uma Macro ao botão de abertura da porta COM

Assim que o botão for criado, é possível adicionar uma Macro ao mesmo. Macros são rotinas que são disparadas de acordo com a ocorrência de algum. Neste tutorial vamos fazer com que uma porta COM seja aberta assim que ocorrer um clique no botão. Para realizarmos este procedimento basta clicar no elemento criado com o botão direito do mouse, escolher a opção Atribuir Macro (Assign Macro) e em seguida em Novo (New).

Neste momento aparecerá um ambiente de programação para o leitor. Note que o ambiente citado já traz duas linhas escritas, de modo que, a primeira delas contém a sentença Sub Button1_Click() e a segunda, End Sub. Para aqueles que nunca mexeram com o VBA, estas duas sentenças correspondem ao início e ao final de um bloco de ações que irão acontecer quando o botão for acionado.

Sub Button1_Click()
 .
 .
 .
End Sub

Entre as duas sentenças apresentadas, deve-se incluir o seguinte código:

Sub Button1_Click()
  
  ReturnValue = Shell("mode.com COM6 baud=9600 parity=n data=8 stop=2 to=off xon=off dtr=off rts=off")
  Application.Wait TimeSerial(Hour(Now()), Minute(Now()), Second(Now()) + 2)
 
  Open "COM6" For Binary Access Read Write As #1
  Range("a1") = 1 
  
End Sub

- Código referente ao funcionamento do botão de fechamento da porta COM (Button2)

No caso deste botão, devemos inserir a Macro referente ao funcionamento do botão de fechamento da porta COM. O código em VBA da Macro em questão é o seguinte:

Sub Button2_Click()
  
  Close #1
  Range("a1") = 0
 
End Sub

- Código referente ao funcionamento do botão de acionamento do LED (Button3)

Em seguida, iremos repetir o procedimento de inclusão de uma Macro em um botão. No entanto, desta vez, atribuiremos a Macro no botão de acionamento do led.

Sub Button3_Click()

If Range("a1") = 0 Then
 
MsgBox "Abra a porta COM"

ElseIf range("a1) = 1 Then

Put #1, , "A"

End If

End Sub

- Código referente ao funcionamento do botão de desligamento do LED (Button4)

Por último, atribuiremos a Macro adequada para o funcionamento do botão de desligamento do led.

Sub Button4_Click()

If Range("a1") = 0 Then
 
MsgBox "Abra a porta COM"

ElseIf range("a1") = 1 Then

Put #1, , "a"

End If

End Sub

Programando - Código do Arduino Micro

char comando;
 
void setup() {
 
    Serial.begin(9600);
    pinMode(2,OUTPUT);
  
  }
 
void loop() {
 
    if (Serial.available()>0)
    {
        comando = Serial.read();
        
        switch (comando) 
        {
            case 'A':
                digitalWrite(2, HIGH);
            break;
  
            case 'a':
                digitalWrite(2,LOW);
            break;
         }
   }
}

Colocando para funcionar

Entendendo a fundo

Software - Microsoft Excel

- Código referente ao funcionamento do botão de abertura da porta COM (Button1)

Entre as linhas de código existentes no bloco referente ao funcionamento do botão de abertura da porta COM, inserimos primeiramente, uma linha de código para definir os parâmetros de comunicação da porta que será utilizada (neste caso, a COM6).

ReturnValue = Shell("mode.com COM6 baud=9600 parity=n data=8 stop=2 to=off xon=off dtr=off rts=off")

Posteriormente, utilizamos a função Application.Wait para determinar um tempo de espera de cerca de 2 segundos para que a função Open (que será apresentada a seguir) possa proceder com segurança na abertura da porta COM escolhida.

 Application.Wait TimeSerial(Hour(Now()), Minute(Now()), Second(Now()) + 2)

Por fim, utilizamos a função Open para abrir a porta COM que foi configurada previamente. Além de abrir a porta em questão, esta função também nomeia a porta citada, de modo que, no resto do código, esta será referenciada por meio o nome dado neste momento. O nome em questão é #1.

Open "COM6" For Binary Access Read Write As #1

Após a abertura da porta, utilizamos uma sentença para colocar o número 1 na célula A1. Este elemento servirá para criarmos um controle responsável por permitir a manipulação da porta de saída digital somente se a porta COM tiver sido aberta.

Range("a1") = 1

Veja como ficou o código referente à Macro do botão 1, na íntegra.

Sub Button1_Click()
  
  ReturnValue = Shell("mode.com COM6 baud=9600 parity=n data=8 stop=2 to=off xon=off dtr=off rts=off")
  Application.Wait TimeSerial(Hour(Now()), Minute(Now()), Second(Now()) + 2)
 
  Open "COM6" For Binary Access Read Write As #1
  Range("a1") = 1 

End Sub

- Código referente ao funcionamento do botão de fechamento da porta COM (Button2)

O código em questão, irá possuir duas linhas, onde, a primeira delas é responsável pelo fechamento da porta COM que foi aberta, no caso, a porta referenciada por #1. A segunda linha do código em questão possui uma a função de inserir o número 0 (zero) na célula A1.

Sub Button2_Click() 

   Close #1 
   Range("a1") = 0

End Sub

- Código referente ao funcionamento do botão de acionamento do led (Button3)

A macro que será atribuída a este botão possui duas estruturas condicionais, em que, a primeira delas, verifica se o conteúdo da célula A1 é o número 0 (zero), ou seja, verifica se a porta COM está fechada, de modo que, caso esta verificação proceda, o Microsoft Excel deverá exibir uma janela de alerta para que o usuário abra a porta COM antes de manipular a porta de saída digital D2.

Em seguida, caso a condição anterior não seja satisfeita, verificamos se a célula A1 possui o número 1 como conteúdo (sinalizando que a porta COM foi aberta). Em caso positivo, enviamos a letra A maiúscula através da porta serial.

Sub Button3_Click()

If Range("a1") = 0 Then
 
  MsgBox "Abra a porta COM"

ElseIf range("a1") = 1 Then

  Put #1, , "A"

End If

End Sub

- Código referente ao funcionamento do botão de desligamento do led (Button3)

Assim como a macro que foi atribuída ao botão de acionamento, a macro presente neste item também possui duas estruturas condicionais, em que, a primeira delas, verifica se o conteúdo da célula A1 é o número 0 (zero), ou seja, verifica se a porta COM está fechada e a segunda, se a mesma está aberta. A diferença entre este caso e o anterior é que caso a porta COM esteja aberta, o Microsoft Excel irá enviar o caractere a (minúsculo) através da porta Serial.

Sub Button4_Click()

If Range("a1") = 0 Then
 
  MsgBox "Abra a porta COM"

ElseIf range("a1") = 1 Then

  Put #1, , "a"

End If

End Sub

Software - Arduino

- Declarando a variável que será utilizada

O primeiro passo na criação do código consiste na declaração da variável do tipo char, que por sua vez, será utilizada para armazenar a informação enviada pelo Microsoft Excel. Neste tutorial, chamaremos esta variável de comando_excel.

char comando_excel;

- Definindo as configurações iniciais

Em seguida, dentro da função setup(), utilizamos a sentença Serial.begin() para iniciarmos o modo de comunicação serial, o qual, será responsável por garantir a interação entre a placa Arduino UNO e o Microsoft Excel. Além disso, através da função pinMode(), determinamos o modo de operação do pino digital 2, de modo que, este atue como uma saída digital.

 void setup() {
 
    Serial.begin(9600);
    pinMode(2,OUTPUT);
  
  }

- Acionando o Arduino através do Microsoft Excel

Na função loop(), através da sentença Serial.available(), verificamos se existe algum caractere proveniente do Microsoft Excel para ser lido e em caso afirmativo, utilizamos a sentença Serial.read() para ler o mesmo.

Após a leitura do primeiro caractere presente no buffer da porta de entrada serial, recorremos à estrutura switch/case, de modo que, esta será responsável por verificar se o caractere recebido é a letra a, maiúscula ou minúscula. Caso o caractere em questão seja a letra A, o Arduino UNO deverá proporcionar nível alto (5V) na porta de saída digital 2. Em contrapartida, caso o caractere em questão seja a letra a, a nossa placa Arduino deverá colocar nível baixo no terminal da porta D2.

void loop() {
 
    if (Serial.available()>0)
    {
        comando_excel = Serial.read();
        
        switch (comando) 
        {
            case 'A':
                digitalWrite(2,HIGH);
            break;
                  
            case 'a': 
                digitalWrite(2,LOW); 
            break;
              
         }
   }
}

Considerações finais

Neste tutorial, demonstramos como você fazer para conseguir manipular as portas de saída digital da sua placa Arduino através do Microsoft Excel. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Shield Ethernet W5100 - Acionamento remoto de relés com HTML

Shield Ethernet W5100 - Acionamento remoto de relés com HTML

Dando prosseguimento ao conteúdo relacionado à criação de Servidores Web utilizando o Arduino UNO juntamente com o Ethernet Shield W5100. Anteriormente, vimos quais eram os procedimentos básicos para criar um Servidor Web, para efetuar a leitura de valores provenientes de elementos ligados tanto às entradas analógicas quanto às digitais e também para realizar o acionamento das portas de saída digital. Neste tutorial você aprenderá como criar uma aplicação na qual será possível criar uma interface, que por sua vez, será apresentada no seu navegador de internet, para que seja possível realizar acionamento de relés.

É importante, para o pleno entendimento desse tutorial, que o leitor tenha lido todos os tutoriais anteriores:

• Shield Ethernet W5100 - Criando um Servidor Web com Arduino
• Shield Ethernet W5100 - Monitorando sensores com um Servidor Web
• Shield Ethernet W5100 - Controlando saídas via Servidor Web

[toc]

Mãos à obra - Desenvolvendo o sistema de acionamento remoto de relés com HTML

Componentes necessários

• 1 x Placa Arduino UNO Rev 3
• 1 x Shield Ethernet Wiznet W5100
• 1 x Módulo Relé 4 canais

Montando o projeto

Programando

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

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 25, 16);
EthernetServer server(80);

void setup() 
{
  Ethernet.begin(mac, ip);
  server.begin();
  pinMode(2,OUTPUT);
  pinMode(3,OUTPUT);
  pinMode(4,OUTPUT);
  pinMode(5,OUTPUT);
  digitalWrite(2,HIGH);
  digitalWrite(3,HIGH);
  digitalWrite(4,HIGH);
  digitalWrite(5,HIGH);
}
void loop() 
{  
     String req_str;
     EthernetClient client = server. available();  
     if (client) 
     {
           req_str = "";
           boolean currentLineIsBlank = true;
           while (client.connected()) 
           {
                 if (client.available()) 
                 {
                       char c = client.read();    
                       req_str += c;    
                       if(c == '\n' && currentLineIsBlank) 
                       {
                             unsigned int posicao_inicial = req_str.indexOf("GET") + 4;
                             unsigned int posicao_final = req_str.indexOf("HTTP/") - 1;
                             String parametro = req_str.substring(posicao_inicial,posicao_final);
                             if(parametro != "/favicon.ico") 
                             {
                             client.println("HTTP/1.1 200 OK");
                             client.println("Content-Type: text/html");
                             client.println("Connection: close");
                             client.println();
                             client.println("<!DOCTYPE html>");
                             client.println("<html lang=\"pt-br\">");                
                                  client.println("<head>");
                                       client.println("<meta charset= \"UTF-8\"/>");
                                       client.println("<title>Acionamento de relés</title>"); 
                                 client.println("</head>");
                                 client.println("<body>");
                                      client.println("<h1>Sistema de acionamento de relés V.1</h1>");
                                      client.println("<hr/>");
                                      client.println("<h2>Portas digitais</h2>");
                                     // client.println("<p>Porta D2:</p>");
                                      client.println ("<form method=\"get\">");
                                      criarformulario (client, parametro);               
                                      client.println ("</form>");                             
                                client.println ("</body>");
                          client.println ("</html>");
                         }
                         break;
                  }
                  if (c == '\n') 
                  {
                         currentLineIsBlank = true;
                   }
                   else if (c != '\r') 
                   {
                         currentLineIsBlank = false; 
                                } 
              }
          }
        delay(1);
        client.stop();
     }
}      

void criarformulario(EthernetClient client_aux, String parametro_aux)
{


   for(int i = 0; i<2; i++)
   {
       client_aux.println("Porta D" + String(i)+ ":");
       client_aux.println("<input type=\"checkbox\"  name=\"D" + String(i) + "\"  value=\"1\" onclick=\"submit()\" disabled>PINO NÃO UTILIZADO (DESABILITADO)</br>");
   }   

for(int i = 2; i<6; i++)
   {
      
       client_aux.println("Porta D" + String(i)+ " (Relé " + String (i - 1) + ") :");
       if(parametro_aux.indexOf("D" + String(i)+ "=1") > -1)
       {
          client_aux.println("<input type=\"checkbox\"  name=\"D" + String(i) + "\"  value=\"1\" onclick=\"submit()\" checked> LIGADA</br>");
          digitalWrite(i,LOW);
       }
       else
       {
          client_aux.println("<input type=\"checkbox\"  name=\"D" + String(i) + "\"  value=\"1\" onclick=\"submit()\"> DESLIGADA</br>");
          digitalWrite(i,HIGH);
       }
   }   
   
   for(int i = 6; i<10; i++)
   {
       client_aux.println("Porta D" + String(i)+ ":");
       client_aux.println("<input type=\"checkbox\"  name=\"D" + String(i) + "\"  value=\"1\" onclick=\"submit()\" disabled>PINO NÃO UTILIZADO (DESABILITADO)</br>");
   }   
   

   for(int i = 10; i<14; i++)
   {
       client_aux.println("Porta D" + String(i)+ ":");
       client_aux.println("<input type=\"checkbox\"  name=\"D" + String(i) + "\"  value=\"1\" onclick=\"submit()\" disabled>EM USO PELO ETHERNET SHIELD W5100 (DESABILITADO)</br>");
   }
}

Colocando para funcionar

Entendendo a fundo

Software

Antes de começarmos com a explicação do código, gostaríamos de ressaltar que iremos apresentar apenas os detalhes dos tópicos não contemplados nos tutoriais anteriores, pois, desta maneira, será mais fácil focar nas partes referentes às atualizações feitas sobre o programa já existente, portanto, caso você tenha alguma dúvida sobre alguma parte do programa que não seja explicada neste momento, sugerimos que acesse o nossos materiais citados anteriormente.

– Definindo os pré-requisitos para o funcionamento do código

Inicialmente, devemos incluir duas bibliotecas no código para que o mesmo pudesse funcionar corretamente. A biblioteca SPI.h, responsável pela comunicação dos módulos do shield com o Arduino UNO utilizando o protocolo SPI e a biblioteca Ethernet.h que atua possibilitando a conexão do conjunto, em um primeiro momento, com uma rede local.

Após a inclusão das bibliotecas citadas, devemos definir um endereço MAC (lembre-se que este pode ser qualquer um, desde que seja único em sua rede local) e um endereço IP (este deve ser um endereço válido  e disponível dentro da sua rede local). Além disso, devemos criar o objeto que será responsável por representar o Servidor Web no código (aqui, chamamos este de server) e relacioná-lo com a porta 80.

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

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 25, 16);
EthernetServer server(80);

void setup() 
{
  Ethernet.begin(mac, ip);
  server.begin();
  pinMode(2,OUTPUT);
  pinMode(3,OUTPUT);
  pinMode(4,OUTPUT);
  pinMode(5,OUTPUT);
  digitalWrite(2,HIGH);
  digitalWrite(3,HIGH);
  digitalWrite(4,HIGH);
  digitalWrite(5,HIGH);
}

void loop() 
{  
     String req_str;
     .
     .
     .

if (client.available()) 
                 {
                       char c = client.read();    
                       req_str += c;    
                       . 
                       . 
                       .

if(c == '\n' && currentLineIsBlank) 
                       {
                             unsigned int posicao_inicial = req_str.indexOf("GET") + 4;
                             unsigned int posicao_final = req_str.indexOf("HTTP/") - 1;
                             String parametro = req_str.substring(posicao_inicial,posicao_final);
                             if(parametro != "/favicon.ico") 
                             {
                             .
                             .
                             .

 client.println("HTTP/1.1 200 OK");
 client.println("Content-Type: text/html");
 client.println("Connection: close");
 client.println();

client.println("<!DOCTYPE html>");

Como sabemos, entre as tags <head> e </head>, fazemos algumas configurações pertinentes ao funcionamento da página que estamos desenvolvendo. As configurações citadas, correspondem à determinação do conjunto de caracteres que deverá ser utilizado pelo navegador (para apresentar caracteres acentuados) e à inclusão de um título na aba da página do navegador.

client.println("<head>");
  client.println("<meta charset= \"UTF-8\"/>");
  client.println("<title>Acionamento de relés</title>"); 
client.println("</head>");

No corpo da página, começamos escrevendo alguns títulos utilizando as tags de cabeçalho <h1> e <h2>.

client.println("<body>");
  client.println("<h1>Sistema de acionamento de relés V.1</h1>");
  client.println("<hr/>");
  client.println("<h2>Portas digitais</h2>"); 
  . 
  .
  .

Em seguida, adicionamos o formulário e explicitamos que o método que será utilizado para o envio de dados na requisição feita pelo navegador será o GET. Entre as tags <form> e </form>, criamos uma função chamada criarformulario(), a qual, será responsável por criar a interface de comandos na página do navegador.

client.println ("<form method=\"get\">");
  criarformulario (client, parametro);               
client.println ("</form>");

Por último, veja o código responsável pela criação da interface de comando, na íntegra.

 client.println("<!DOCTYPE html>");
   client.println("<html lang=\"pt-br\">");                
      client.println("<head>");
         client.println("<meta charset= \"UTF-8\"/>");
         client.println("<title>Acionamento de relés</title>"); 
      client.println("</head>");
      client.println("<body>");
         client.println("<h1>Sistema de acionamento de relés V.1</h1>");
         client.println("<hr/>");
         client.println("<h2>Portas digitais</h2>");
         client.println ("<form method=\"get\">");
            criarformulario (client, parametro);               
         client.println ("</form>");                             
      client.println ("</body>");
   client.println ("</html>");

– Função de criação do formulário

Como dissemos anteriormente, a função criarformulario() será a responsável pela criação da interface de comando que utilizaremos. Esta função é dividida em três blocos, de modo que, o primeiro deles é responsável por criar os checkboxes referentes às portas digitais 0 e 1. Repare que na instrução de criação dos checkboxes (cujo funcionamento já foi apresentado em nossos tutoriais) existe a palavra disabled, a qual, irá fazer com que o checkbox não seja clicável (justamente por não estarmos utilizando estes pinos).

 for(int i = 0; i<2; i++)
 {
     client_aux.println("Porta D" + String(i)+ ":");
     client_aux.println("<input type=\"checkbox\"  name=\"D" + String(i) + "\"  value=\"1\" onclick=\"submit()\" disabled>PINO NÃO UTILIZADO (DESABILITADO)</br>");
 }

O segundo bloco diz respeito à criação dos checkboxes de acionamento dos 4 relés existentes no módulo utilizado. Repare que a estrutura utilizada é a mesma que a anterior, no entanto, utilizamos a função indexOf() para descobrirmos se existe algum elemento do tipo "/?D_=1" (parâmetro da requisição quando algum checkbox é selecionado). Em caso afirmativo, o checkbox é criado e marcado, em caso negativo, ele é apenas criado, porém sem estar selecionado. Consequentemente, também acionamos o relé (com nível lógico 0) ou não (com nível lógico 1), através da função digitalWrite().

for(int i = 2; i<6; i++)
   {
      
       client_aux.println("Porta D" + String(i)+ " (Relé " + String (i - 1) + ") :");
       if(parametro_aux.indexOf("D" + String(i)+ "=1") > -1)
       {
          client_aux.println("<input type=\"checkbox\"  name=\"D" + String(i) + "\"  value=\"1\" onclick=\"submit()\" checked> LIGADA</br>");
          digitalWrite(i,LOW);
       }
       else
       {
          client_aux.println("<input type=\"checkbox\"  name=\"D" + String(i) + "\"  value=\"1\" onclick=\"submit()\"> DESLIGADA</br>");
          digitalWrite(i,HIGH);
       }
   }

O terceiro e o quarto bloco são semelhantes ao primeiro, no entanto, na quarta estrutura de repetição for, apenas alteramos o texto para sinalizar que os pinos 10 a 13 estão sendo utilizados pelo Shield Ethernet W5100.

for(int i = 6; i<10; i++)
   {
       client_aux.println("Porta D" + String(i)+ ":");
       client_aux.println("<input type=\"checkbox\"  name=\"D" + String(i) + "\"  value=\"1\" onclick=\"submit()\" disabled>PINO NÃO UTILIZADO (DESABILITADO)</br>");
   }   
   

   for(int i = 10; i<14; i++)
   {
       client_aux.println("Porta D" + String(i)+ ":");
       client_aux.println("<input type=\"checkbox\"  name=\"D" + String(i) + "\"  value=\"1\" onclick=\"submit()\" disabled>EM USO PELO ETHERNET SHIELD W5100 (DESABILITADO)</br>");
   }
}

Considerações finais

Neste tutorial, demonstramos como você pode fazer para criar um sistema de acionamento de relés para ser utilizado através de um navegador de internet. Para isto, utilizamos um Arduino UNO em conjunto com um Ethernet Shield W5100. Esta foi a quarta parte de uma série de artigos sobre a criação de Servidores Web, portanto, esperamos que continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Microsoft Excel com Arduino - Primeiros passos

Microsoft Excel com Arduino - Primeiros passos

O Visual Basic for Applications ou VBA consiste em uma ferramenta sob forma de linguagem de programação que pode ser usada em conjunto com os diversos programas existentes dentro do pacote Microsoft Office e também com alguns outros softwares externos, com o intuito de expandir as funcionalidades dos mesmos. No Microsoft Excel, por exemplo, este recurso é amplamente utilizado na criação de soluções automatizadas para manipulação de planilhas, oferecendo ao usuário maior facilidade na execução de procedimentos, utilização de recursos de análise de dados, entre outras aplicações mais avançadas. Neste tutorial, iremos adentrar o mundo das aplicações avançadas citadas, ensinando os primeiros passos necessários para que você consiga comandar a sua placa Arduino através do Microsoft Excel.

[toc]

Mãos à obra - Estabelecendo a comunicação entre o Arduino Micro e o Microsoft Excel

Componentes necessários

• 1 x Arduino UNO Rev 3
• 1 x Protoboard
• 1 x Resistor 330 Ω
• 1 x Led verde difuso

Montando o projeto

Criando a interface do Microsoft Excel

Neste momento, iremos apresentar os passos necessários para que você consiga realizar o desenvolvimento básico de uma interface, a qual, irá conter os botões responsáveis pela manipulação da nossa placa Arduino. Apenas como uma observação, estamos utilizando o Microsoft Excel versão 2013, portanto, é possível que pequenas alterações devam ser feitas, caso você esteja utilizando uma outra versão deste software.

- Criando o botão de abertura da porta COM

O primeiro passo no desenvolvimento da interface citada consiste na criação de um botão e na adição de funcionalidade ao mesmo. Este botão será responsável por fazer com que a porta COM seja aberta, possibilitando portanto, a comunicação do Microsoft Excel com o nosso Arduino Micro.

Para realizar este procedimento você deverá selecionar a opção Inserir (insert) na aba de desenvolvimento e em seguida a opção Botão (Button).

Após o passo anterior, basta arrastar o cursor e criar um botão do tamanho desejado. Veja o resultado:

- Criando o botão de fechamento da porta COM

O procedimento de criação do botão responsável pelo fechamento da porta COM é idêntico ao realizado anteriormente, de modo que, a única diferença existente entre os dois está no código da Macro utilizada. No caso, a Macro em questão é a referente ao funcionamento do botão de fechamento da porta COM.

- Criando o botão de acionamento do Led de teste

Por último, iremos repetir o procedimento de criação para elaborar o botão que será utilizado para acender o led existente em nosso hardware. Neste botão, atribuiremos a Macro referente ao botão de acionamento do Led de teste.

Programando -  Microsoft Excel

Esse projeto consiste em duas partes distintas de programação: Uma referente à placa Arduino e outra referente ao Microsoft Excel. Começaremos explicando como fazer toda a programação do Microsoft Excel para em seguida mostrar o código utilizado em nosso Arduino.

- Atribuindo uma Macro ao botão de abertura da porta COM

Assim que o botão for criado, é possível adicionar uma Macro ao mesmo. Macros são rotinas que são disparadas de acordo com a ocorrência de algum. Neste tutorial vamos fazer com que uma porta COM seja aberta assim que ocorrer um clique no botão. Para realizarmos este procedimento basta clicar no elemento criado com o botão direito do mouse, escolher a opção Atribuir Macro (Assign Macro) e em seguida em Novo (New).

Neste momento aparecerá um ambiente de programação para o leitor. Note que o ambiente citado já traz duas linhas escritas, de modo que, a primeira delas contém a sentença Sub Button1_Click() e a segunda, End Sub. Para aqueles que nunca mexeram com o VBA, estas duas sentenças correspondem ao início e ao final de um bloco de ações que irão acontecer quando o botão for acionado.

Sub Button1_Click()
   .
   .
   .

End Sub

Entre as duas sentenças apresentadas, deve-se incluir o seguinte código:

Sub Button1_Click()
  
  ReturnValue = Shell("mode.com COM6 baud=9600 parity=n data=8 stop=2 to=off xon=off dtr=off rts=off")
  Application.Wait TimeSerial(Hour(Now()), Minute(Now()), Second(Now()) + 2)
 
  Open "COM6" For Binary Access Read Write As #1
  
End Sub

- Atribuindo uma Macro ao botão de fechamento da porta COM (Button2)

 No caso deste botão, devemos inserir a Macro referente ao funcionamento do botão de fechamento da porta COM. O código em VBA da Macro em questão é o seguinte:

Sub Button2_Click()
  
  Close #1
 
End Sub

- Atribuindo uma macro no botão de acionamento do Led de teste (Button3)

Por último, iremos repetir o procedimento de inclusão de uma Macro em um botão. No entanto, desta vez, atribuiremos a Macro no botão de acionamento do Led de teste.

Sub Button3_Click()

Put #1, , "a"

End Sub

Programando - Arduino

char comando;
 
void setup() {
 
    Serial.begin(9600);
    pinMode(2,OUTPUT);
  
  }
 
void loop() {
 
    if (Serial.available()>0)
    {
        comando = Serial.read();
        
        switch (comando) 
        {
            case 'A':
                digitalWrite(2, HIGH);
            break;
  
    
        }
    }
}

Colocando para funcionar

Entendendo a fundo

Software - Microsoft Excel

- Código referente ao funcionamento do botão de abertura da porta COM (Button1)

Entre as linhas de código existentes no bloco referente ao funcionamento do botão de abertura da porta COM, inserimos primeiramente, uma linha de código para definir os parâmetros de comunicação da porta que será utilizada (neste caso, a COM6).

ReturnValue = Shell("mode.com COM6 baud=9600 parity=n data=8 stop=2 to=off xon=off dtr=off rts=off")

Posteriormente, utilizamos a função Application.Wait para determinar um tempo de espera de cerca de 2 segundos para que a função Open (que será apresentada a seguir) possa proceder com segurança na abertura da porta COM escolhida.

 Application.Wait TimeSerial(Hour(Now()), Minute(Now()), Second(Now()) + 2)

Por fim, utilizamos a função Open para abrir a porta COM que foi configurada previamente. Além de abrir a porta em questão, esta função também nomeia a porta citada, de modo que, no resto do código, esta será referenciada por meio o nome dado neste momento. O nome em questão é #1.

Open "COM6" For Binary Access Read Write As #1

Veja como ficou o código referente à Macro do botão 1, na íntegra.

Sub Button1_Click()
  
  ReturnValue = Shell("mode.com COM6 baud=9600 parity=n data=8 stop=2 to=off xon=off dtr=off rts=off")
  Application.Wait TimeSerial(Hour(Now()), Minute(Now()), Second(Now()) + 2)
 
  Open "COM6" For Binary Access Read Write As #1

End Sub

- Código referente ao funcionamento do botão de fechamento da porta COM (Button2)

O código em questão, possui uma única linha, que por sua vez, é responsável pelo fechamento da porta COM que foi aberta, no caso, a porta referenciada por #1.

Sub Button2_Click() 

   Close #1 

End Sub

- Código referente ao funcionamento do botão de acionamento do LED (Button3)

A macro que será atribuída a este botão, tem como única linha de código, uma sentença composta pela função Put. Neste trecho de código, determinamos que quando o botão for clicado, o Microsoft Excel deverá enviar o caractere a através da porta serial.

Sub Button3_Click()

Put #1, , "A"

End Sub

Software - Arduino

- Declarando a variável que será utilizada

O primeiro passo na criação do código consiste na declaração da variável do tipo char, que por sua vez, será utilizada para armazenar a informação enviada pelo Microsoft Excel. Neste tutorial, chamaremos esta variável de comando_excel.

char comando_excel;

- Definindo as configurações iniciais

Em seguida, dentro da função setup(), utilizamos a sentença Serial.begin() para iniciarmos o modo de comunicação serial, o qual, será responsável por garantir a interação entre a placa Arduino UNO e o Microsoft Excel. Além disso, através da função pinMode(), determinamos o modo de operação do pino digital 2, de modo que, este atue como uma saída digital.

 void setup() {
 
    Serial.begin(9600);
    pinMode(2,OUTPUT);
  
  }

- Acionando o Arduino através do Microsoft Excel

Na função loop(), através da sentença Serial.available(), verificamos se existe algum caractere proveniente do Microsoft Excel para ser lido e em caso afirmativo, utilizamos a sentença Serial.read() para ler o mesmo.

Após a leitura do primeiro caractere presente no buffer da porta de entrada serial, recorremos à estrutura switch/case, de modo que, esta será responsável por verificar se o caractere recebido é a letra a, maiúscula ou minúscula. Caso o caractere em questão seja a letra A, o Arduino UNO deverá proporcionar nível alto (5V) na porta de saída digital 2.

void loop() {
 
    if (Serial.available()>0)
    {
        comando_excel = Serial.read();
        
        switch (comando) 
        {
            case 'A':
                digitalWrite(2,HIGH);
            break;
         }
   }
}

Considerações finais

Neste tutorial, demonstramos como você fazer para estabelecer uma comunicação entre a sua placa Arduino e o Microsoft Excel, esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira