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:
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.
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:
Mãos à obra - Controlando relés com o ScadaBR
Componentes necessários
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.
Medição de Potência Elétrica utilizando arduino
Medição do consumo de Potência Elétrica utilizando arduino
Diante de um período no qual os assuntos do momento estão relacionados a eficiência energética e meios de reduzir o consumo de energia, temas relacionados ao monitoramento de energia estão em alta e sendo alvos de pesquisas e desenvolvimentos de produtos. Sabendo quanto um aparelho ou dispositivo eletrônico consome pode ser muito útil quando se busca reduzir os gastos relacionados ao consumo.
Neste tutorial, iremos mostrar como a medição da potência elétrica pode ser utilizada para mensurar o consumo de energia utilizada pelo dispositivo. Recomendamos que leiam os tutoriais a respeito dos seguinte sensores: sensor de corrente SCT-013 e/ou módulo ACS712, pois para a medição de corrente alternada utilizaremos o módulo ACS712 ou o SCT-013 (você poderá escolher qual será o melhor para sua aplicação) e o tutorial sobre medição de tensão elétrica AC utilizando Transformador. Possuindo o conhecimento destes tutoriais, você poderá compreender melhor cada passo apresentado neste tutorial.
Mas antes de irmos diretamente para a parte prática, uma pergunta deve ser feita: você sabe o que é potência elétrica?
Potência Elétrica
A potência elétrica pode ser definida como a quantidade de energia consumida em uma determinada quantidade de tempo. Sua unidade de medida é o Watt, que corresponde a quantidade de energia por segundo (joule/segundo).
Para podermos mensurar o valor de potência elétrica consumida por um aparelho, precisamos saber antes qual o valor que ele consome por segundo. Para isso, temos a seguinte relação.
Potência elétrica = tensão · corrente
ou
P = V · I
Com isso, poderemos monitorar os valores de corrente e tensão de um determinado aparelho e desse modo, mensurar o seu consumo de potência elétrica. Mas, o que significa tensão? E corrente?
Tensão Elétrica
Consiste na diferença de potencial entre dois pontos, no qual pode ser gerado corrente elétrica. Também é conhecida como DDP (Diferença de Potencial) e sua unidade de medida é Volt (V).
Corrente Elétrica
É definido como o fluxo ordenado dos elétrons dentro de um condutor. É gerado a partir de uma diferença de potencial entre dois pontos.

Agora que sabemos mais a respeito dos conceitos elétricos envolvidos, poderemos prosseguir com a parte prática.
Mãos à obra - Mensurando o consumo de potência elétrica de um aparelho
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.
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.
Descobrindo o endereço I2c de dispositivos com Arduino
Descobrindo o endereço I2C de dispositivos com Arduino
Quando compramos equipamentos de lojas desconhecidas quase sempre nos deparamos com o problema de não termos disponível um datasheet ou algum tipo de documentação que auxilie na utilização dos mesmos. Sabendo disso, neste tutorial nós iremos aprender a como identificar o endereço I2C de dispositivos com um Arduino.
[toc]
Protocolo I2C
O protocolo I2C, ou Inter-Integrated Circuit é um protocolo de comunicação desenvolvido pela Philips, que teve como objetivo inicial, interconectar dispositivos de baixa velocidade e curta distância. A comunicação i2C funciona por meio de um barramento onde apenas um dispositivo, denominado mestre, é responsável por requisitar informações dos dispositivos conectados. A conexão I2C é feita através de dois fios, sendo eles:
- sda: Transmitir dados entre receptor e transmissor via barramento.
- scl: Temporizar e sincronizar unidades conectadas ao sistema.
É também interessante possuir um resistor pull-up nas trilhas sda e scl para estabilizar o barramento de comunicação

Como a comunicação I2C é feita via um barramento, cada dispositivo conectado ao sistema deve possuir um endereço único. Este código é composto por um valor de 7 bits, disponibilizando um total de 127 endereços onde apenas o intervalo 0x8 até 0 intervalo 0x77 está disponível para utilização.
Mãos à obra - Descobrindo o endereço I2C de dispositivos utilizando o seu Arduino
Componentes utilizados:
Montando o projeto
Como teste do nosso código de pesquisa, iremos conectar um dispositivo I2C ao nosso Arduino Nano. Para fazer isso basta conectar o pino SDA ao pino A4 do Arduino e o pino SCL ao pino A5 do Arduino, além é claro dos pinos utilizados para alimentação. A figura abaixo ilustra o processo de ligação dos fios de comunicação e alimentação.
Veja como ficou a montagem na prática.
Atenção, sempre monte o seu circuito com a alimentação do Arduino desligada. Para evitar possíveis curtos circuitos que possam vir a danificar o seu módulo ou até mesmo o microcontrolador.
Programando
Agora que temos conectado ao nosso sistema um módulo que supostamente não sabemos o seu endereço. Iremos utilizar carregar o seguinte código em nossa placa para sua identificação.
#include <Wire.h> #define TEMPOLEITURA 100 #define TEMPOESPERA 3000 byte endereco; byte codigoResultado=0; byte dispositivosEncontrados=0; void setup() { Serial.begin(9600); Wire.begin(); while (!Serial); scanI2c(); } void scanI2c(){ for (endereco=0; endereco<128; endereco++){ Wire.beginTransmission(endereco); codigoResultado = Wire.endTransmission(); if (codigoResultado==0){ Serial.print ("Dispositivo I2c detectado no endereço: "); Serial.println(endereco,HEX); dispositivosEncontrados++; delay(TEMPOESPERA); } delay(TEMPOLEITURA); } if (dispositivosEncontrados>0){ Serial.print("Foi encontrado um total de: "); Serial.print(dispositivosEncontrados); Serial.println(" dispositivos"); } else{ Serial.println("Nenhum dispositivo foi encontrado !!!"); } } void loop() { }
Entendendo a fundo
Software
- Incluindo as bibliotecas necessárias
De início, para ser possível a utilização da comunicação I2C no nosso Arduino, nós iremos precisar adicionar a biblioteca wire.h que pode ser feita através da seguinte sentença:
#include <Wire.h>
- Temporizadores de pesquisa e tempo de espera
Iremos também neste código criar dois temporizadores para definir de quanto em quantos milissegundos o nosso código deverá fazer a pesquisa em um novo endereço e por quanto tempo ele deve esperar após encontrar um dispositivo conectado ao barramento I2C. Para isso, iremos criar 2 diretivas define que serão responsáveis por armazenar estes valores, fazendo com que eles sejam facilmente parametrizáveis.
#define TEMPOLEITURA 100 #define TEMPOESPERA 3000
- Função setup
Na função setup, iremos inicializar a comunicação I2C para identificação de dispositivos e também iremos inicializar a comunicação serial, para que os dados sejam mostrados no serial monitor.
void setup() { Serial.begin(9600); Wire.begin(); while (!Serial); scanI2c(); }
Na versão Leonardo do Arduino, para utilização correta da porta serial, é importar adicionar o trecho:
while (!Serial);Pois assim iremos garantir que a comunicação serial está de fato funcionando corretamente.
- Variáveis de controle
Para deslocarmos entre os endereços, identificarmos se o dispositivo está realmente conectado ao barramento e contar quantos dispositivos estão conectados, nós iremos utilizar três variáveis do tipo byte. A utilização destas variáveis com este tipo deve-se ao fato de que como estes valores nunca serão maiores que 255(,) não existe a possibilidade de overflow. Sendo assim iremos economizar cerca de 3 bytes de memória, se utilizássemos por exemplo o tipo int para armazenar.
byte endereco; byte codigoResultado=0; byte dispositivosEncontrados=0;
- Função scanI2c
Dentro da função scanI2c nós iremos realizar todo o processo de busca por dispositivos conectados, que será feito da seguinte forma:
- Através do comando for, percorrer todos os endereços disponíveis no protocolo I2C, partindo do 0 até o 127.
for (endereco=0; endereco<128; endereco++);
- Utilizando o método Wire.beginTransmission, iremos tentar estabelecer uma comunicação com o dispositivo conectado, utilizando como endereço a posição atual do for.
Wire.beginTransmission(endereco);
- Logo em seguida iremos encerrar a transmissão através do método Wire.endTransmission
. Estemétodo possui um retorno que consiste em:- Igual a 0 - Conexão fechada com sucesso
- Diferente de 0 - Falha na transmissão ou não existe dispositivo conectado
- Sabendo disso, iremos armazenar este valor de retorno em nossa variável codigoResultado
codigoResultado = Wire.endTransmission();
- Logo em seguida verificamos se a variável codigoResultado é igual a zero, caso seja mostramos o código do dispositivo e contabilizamos a variável que mostra o total de dispositivos encontrados e aguardamos o tempo em milissegundos definido em TEMPOESPERA
if (codigoResultado==0){ Serial.print ("Dispositivo I2c detectado no endereço: "); Serial.println(endereco,HEX); dispositivosEncontrados++; delay(TEMPOESPERA); }
- Após cada tentativa de leitura também aguardamos um intervalo de tempo definido em TEMPOLEITURA.
delay(TEMPOLEITURA);
- Ao fim do for verificamos se o número de dispositivos encontrados é maior que zero, caso seja mostramos este valor na serial, caso contrário informamos que nenhum dispositivo foi encontrado.
if (dispositivosEncontrados>0){ Serial.print("Foi encontrado um total de: "); Serial.print(dispositivosEncontrados); Serial.println(" dispositivos"); } else{ Serial.println("Nenhum dispositivo foi encontrado !!!"); }
Vídeo Tutorial
Vocês também podem ver uma explicação do código em vídeo no canal abaixo:
https://www.youtube.com/watch?v=SaZYSTw627o
Desafio
Agora que você sabe como descobrir o endereço de dispotivos I2C. Tente conectar mais de um ao barramento e veja se o código consegue detectar todos. Tente também criar uma lógica para salvar o endereço dos dispositivos identificados pelo sistema.
Considerações Finais
Este tutorial, teve como objetivo mostrar uma forma bem simples para encontrar o endereço de dispositivos conectados via I2C. Espero que tenham gostado do conteúdo apresentado, sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.
Caso queira saber mais sobre o Display LCD 16x2 com Adaptador I2C, acesse o tutorial: Display LCD 20×4 e LCD 16×2 com Adaptador I2C – Utilizando o display com Arduino
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!
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!
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.

Módulo GPS NEO-6M | Arduino UNO |
VCC | 5V |
RX | Pino 9 |
TX | Pino 8 |
GND | GND |

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!
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!
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.
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.
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:
- 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;
- Barramentos verticais usados para a montagem do circuito
- 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!

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.
Shield display LCD TFT 2.4" Touchscreen - Descobrindo o drive
Shield display LCD TFT 2.4" Touchscreen - Descobrindo o drive
No desenvolvimento de qualquer tipo de projeto, é indispensável o uso de uma interface que permita ao usuário ver todo o funcionamento do sistema. Entretanto, essa não é uma tarefa fácil, principalmente quando dispomos de sistemas de baixo poder computacional, como é o caso dos microcontroladores tais como os Arduino. Sabendo disso, neste tutorial você aprenderá a utilizar o display TFT 2.4" com touchscreen embutido em conjunto a uma Placa Arduino Uno e descobriremos como resolver o problema da tela branca, comum ao usar esse LCD. Com esse display podemos criar interfaces interativas e supervisionar dados em tempo real.
É interessante ressaltar que uma das maiores dificuldade na utilização desse tipo de LCD se dá em achar a biblioteca adequada. Isso porque existe diversos modelos semelhantes o que gera uma grande confusão na hora de botar ele para funcionar. Pensando nisso, nesse conteúdo usamos uma biblioteca que faz a leitura do controlador usado pelo Display e nos informa qual é o driver através do monitor serial. Em seguida usamos o número do controlador para configurar a Biblioteca.
[toc]
O Shield Display LCD TFT 2.4" Touchscreen
O shield Lcd 2.4" possui uma resolução de 240x320, além de possuir uma interface touchscreen resistiva por onde é possível interagir com a tela sem a necessidade de botões. A tela conta com um total de 13 pinos distribuídos entre alimentação, controle do touch e controle do display. Se você deseja adicionar sensores em conjunto com a tela, recomendo que utilize o Arduino Mega, pois ao acoplar o shield em um Arduino uno você não terá espaço nem pinos para conectar outros dispositivos.
Esse shield também possui uma interface para cartões SD em sua parte traseira. Tal interface é muito comum em LCDs coloridos, seu propósito é armazenar imagens prontas para serem exibidas no Display. Além disso, esse módulo SD pode ser usado para armazenar outras informações que seja úteis ao seu projeto.

Ao utilizar essa tela no Arduino uno, se certifique que a parte do conector USB do arduino NÃO esteja tocando no shield, caso contrário pode ocorrer um curto circuito capaz de danificar o shield ou até o Arduino.
Mãos à obra – Construindo um sistema de controle de acesso utilizando a shield LCD
O projeto é divido em duas partes, na primeira descobrimos qual o controlador do nosso LCD e em seguida configuramos a biblioteca para se adequar ao modelos de Display que temos em mão.
Componentes Utilizados:
- 1x Placa Arduino Uno REV3 - Você pode usar o Arduino Mega
- 1x Shield Lcd TFT 2.4" Touchscreen
Montando o projeto
Para realizar a montagem em um Arduino uno não existe muito segredo, basta encaixar o módulo em seu Arduino sempre deixando um espaço entre o conector usb e a shield. Tenha cuidado para não amassar uma das pernas de seu shield.
Caso tudo esteja funcionando corretamente o display deverá acender como mostra o gif abaixo:

Instalando Biblioteca da Tela
A utilização destas telas nem sempre é uma tarefa fácil, isso ocorre devido a grande quantidade de controladores disponíveis no mercado para este tipo de tela. Sabendo disso, neste tutorial iremos utilizar uma biblioteca que abrange uma grande quantidade de controladores, no caso a MCUFRIEND. A instalação da biblioteca pode ser feita de maneira bem simples, bastando seguir os seguintes passos:
- Clique em Sketch e vá até a opção Incluir Biblioteca como mostra a figura abaixo:
- Logo em seguida selecione a opção Gerenciar Bibliotecas, uma nova tela será aberta onde você pode gerenciar todas as bibliotecas disponíveis no repositório.

- Por fim, para instalar a biblioteca, basta digitar MCUF RIEND_kbv na barra de pesquisa e instalar a opção da imagem.

Ao fim do processo de instalação, reinicie a IDE do Arduino para diminuir a possibilidade de problemas de compatibilidade.
Descobrindo o Driver do Display LCD TFT 2.4"
Agora que temos a nossa biblioteca instalada, iremos testar se da forma como ela está já conseguimos renderizar informações na tela. Para isso execute o seguinte código:
#include <MCUFRIEND_kbv.h> MCUFRIEND_kbv tft; #define VERDE 0x07E0 #define BRANCO 0xFFFF void setup() { Serial.begin(9600); uint16_t ID = tft.readID(); Serial.print("Identificador do display: "); Serial.println(ID,HEX); tft.begin(ID); tft.setRotation(1); tft.fillScreen(BRANCO); tft.setCursor(20,100); tft.setTextColor(VERDE); tft.setTextSize(3); tft.print("It's Alive !!!"); } void loop() { }
O código acima realiza uma leitura do registrador responsável por armazenar o código do circuito integrado que controla a tela através da função readID(). Com este código, a biblioteca sabe quais os registradores utilizados para entrada e saída de dados, podendo assim estabelecer uma comunicação com o display que é feita através da função begin(ID). Além de fazer isso, no monitor serial e escreve a mensagem "It's Alive" em verde caso o código esteja funcionando corretamente.
Se tudo estiver ok, você verá a seguinte mensagem escrita em seu display:
Dessa forma, o nosso controlador é o driver LGPD4532.
Consertando bug da tela branca - Configurando a biblioteca para o nosso controlador
Caso a tela simplesmente continue branca, será necessário realizar uma modificação na biblioteca MCUFRIEND. Para isso você deve ir até a pasta onde a biblioteca está instalada:
- Windows: C:\Program Files (x86)\Arduino\libraries
- Linux: /home/Usuario/Arduino/libraries
Após encontrar a localização da biblioteca instalada, selecione a pasta MCUFRIEND_kbv e abra o arquivo MCUFRIEND_kbv.cpp com o seu editor de textos favorito


A biblioteca MCUFRIEND possui praticamente todos os controladores disponíveis para esse display, porém algumas são desabilitadas devido a pequena quantidade de memória disponível. Sabendo disso, iremos através dessa modificação habilitar este controlador. Para fazer isso, iremos precisar do identificador do controlador do display, que pode ser obtido através do código de teste apresentado logo acima. Neste exemplo estou utilizando o controlador 4532, então devemos habilitar o suporte a este controlador

Na linha correspondente ao controlador que foi mostrado no código de testes, basta "descomentar" a linha do controlador desejado.

Antes de realizar qualquer modificação em uma biblioteca, é altamente recomendado que se faça backup da versão anterior para que caso ocorre algum problema seja possível retornar ao estado anterior.
Logo após realizar as modificações, salve o arquivo e reinicie a IDE do Arduino. Se tudo tiver sido feito corretamente a mensagem It's Alive irá aparecer na sua tela quando você fizer o upload do código novamente.
Programando
Agora que temos a biblioteca funcionando corretamente, iremos construir a interface do nosso controle de acesso. O código abaixo é responsável por renderizar todos os botões que iremos utilizar em nosso sistema.
#include "Adafruit_GFX.h" // Biblioteca Gráfica Adafruit #include <MCUFRIEND_kbv.h> // Bibllioteca para controle do lcd // Cores que iremos utilizar em nosso projeto #define PRETO 0x0000 #define VERMELHO 0xF800 #define VERDE 0x07E0 #define BRANCO 0xFFFF //---------------------------------------------// MCUFRIEND_kbv tft; // Objeto de comunicação com display void setup() { uint16_t ID = tft.readID(); // Leitura do código de identificação do controlador tft.begin(ID); // Inicialização da tela telaInicial(); // Chamada da função responsável por renderizar o nosso painel de acesso } void telaInicial(){ tft.setRotation(1); // Display é rotacionado para modo paisagem tft.fillScreen(BRANCO); // Tela é preenchida pela cor Branca escreveTexto(50,0,"Controle de Acesso",2,PRETO); // Texto é escrito na posição (50,0) criarBotao(60,50,200,30,"",PRETO); // Criamos uma pequena caixa onde será mostrada a senha digitada criarBotao(50,100,30,30,"1",VERMELHO); // Criação do botão 1 do sistema criarBotao(100,100,30,30,"2",VERMELHO); // Criação do botão 2 do sistema criarBotao(150,100,30,30,"3",VERMELHO); // Criação do botão 3 do sistema criarBotao(200,100,30,30,"4",VERMELHO); // Criação do botão 4 do sistema criarBotao(250,100,30,30,"5",VERMELHO); // Criação do botão 5 do sistema criarBotao(50,150,30,30,"6",VERMELHO); // Criação do botão 6 do sistema criarBotao(100,150,30,30,"7",VERMELHO); // Criação do botão 7 do sistema criarBotao(150,150,30,30,"8",VERMELHO); // Criação do botão 8 do sistema criarBotao(200,150,30,30,"9",VERMELHO); // Criação do botão 9 do sistema criarBotao(250,150,30,30,"0",VERMELHO); // Criação do botão 0 do sistema criarBotao(50,200,120,30,"Apagar",VERMELHO); // Criação do botão Apagar criarBotao(180,200,100,30,"Logar",VERMELHO); // Criação do botão Logar } void telaAcesso(bool acesso){ // Função que controla o acesso ao sistema if (acesso){ // Se o acesso for permitido tft.fillScreen(PRETO); // Tela é preenchida pela cor preta tft.setCursor(10,100); // Cursor é deslocado para pixel de posição (10,100) tft.setTextColor(VERDE); // Cor do texto é alterada para verde tft.setTextSize(3); // Tamanho da fonte do texto é alterada para o tamanho 3 ( Grande ) tft.print("Acesso Autorizado"); // Texto é escrito em verde com mensagem Acesso Autorizado delay(3000); // Sistema aguarda 3 segundos telaInicial(); // Tela de acesso inicial é renderizada } else{ // Caso contrário tft.fillScreen(PRETO); // Tela é preenchida pela cor preta tft.setCursor(40,100); // Cursor é deslocado para pixel de posição (40,100) tft.setTextColor(VERMELHO); // Cor do texto é alterada para vermelho tft.setTextSize(3); // Tamanho da fonte do texto é alterada para o tamanho 3 ( Grande ) tft.print("Acesso Negado"); // Texto é escrito em vermelho com mensagem Acesso Negado delay(3000); // Sistema aguarda 3 segundos telaInicial(); // Tela de acesso inicial é renderizada } } void escreveTexto(int posx,int posy, String texto,int tamanho,int cor){ // Função criada para facilitar escrita de texto tft.setCursor(posx,posy); // Cursor é deslocado para posição passada como parâmetro tft.setTextColor(cor); // Cor a ser escrita é alterada conforme valor recebido como parâmetro tft.setTextSize(tamanho); // Tamanho da fonte é alterado conforme parâmetro recebido tft.print(texto); // Texto passado por parâmetro é escrito na tela } void criarBotao(int posx,int posy, int largura, int altura,String texto,int cor) // { //Create Red Button tft.fillRect(posx,posy, largura, altura, cor); // um quadrado começando em (posx,posy) é renderizado conforme parâmetros passados tft.drawRect(posx,posy, largura, altura,PRETO); // um quadrado de cor preta é desenhado ao redor do quadrado vermelho tft.setCursor(posx+8,posy+4); // Cursor é deslocado para o pixel de posição (posx+8,posy+4) tft.setTextColor(BRANCO); // Cor do texto é alterada para Branco tft.setTextSize(3); // Fonte é alterada para tamanho 3 tft.print(texto); // Texto é escrito em posição determinada } void loop() { // Cada uma das três telas que compõem o sistema é chamada a cada dois segundos telaInicial(); delay(2000); telaAcesso(true); delay(2000); telaAcesso(false); delay(2000); }
Colocando pra funcionar
Entendendo a Fundo
Software
- Incluindo bibliotecas a serem adicionadas ao projeto
Inicialmente podemos observar que necessitamos adicionar penas duas bibliotecas ao nosso projeto. A biblioteca Adafruit_GFX fornece uma série de funções que permitem o desenho de figuras geométricas de forma transparente. Já a biblioteca MCUFRIEND_kbv fornece o objeto com o qual iremos nos comunicar com o display.
#include "Adafruit_GFX.h" // biblioteca com funções Gráficas #include <MCUFRIEND_kbv.h> // biblioteca de acesso e comunicação com display
- Declarando objeto de comunicação com display
Para estabelecer uma comunicação com o nosso display, iremos criar um objeto de nome tft que ficará responsável por renderizar toda a informação que for requisitada pelo código.
MCUFRIEND_kbv tft; // Objeto de comunicação com a tela
O nome do objeto não precisa ser necessariamente tft, você pode nomear o objeto com o nome que preferir.
- Paleta de cores utilizada
Neste exemplo iremos utilizar um total de 4 cores, para desenhar botões e telas de acesso. Para facilitar o trabalho de digitar o código da cor utilizada, criaremos 4 defines contendo as cores utilizadas e seu respectivo código RGB.
#define PRETO 0x0000 #define VERMELHO 0xF800 #define VERDE 0x07E0 #define BRANCO 0xFFFF
- Função desenha botão
Para facilitar o processo de desenhar botões na tela, foi elaborada uma função que dada a posição inicial, dimensões, texto e cor um retângulo representando um botão é desenhado na tela. Seu funcionamento segue a seguinte lógica:
void criarBotao(int posx,int posy, int largura, int altura,String texto,int cor) { tft.fillRect(posx,posy, largura, altura, cor); // Cria um quadrado com inicio na posição (posx,posy) com altura e largura definidas na função tft.drawRect(posx,posy, largura, altura,PRETO); // Cria uma borda ao redor do quadrado desenhado anteriormente tft.setCursor(posx+8,posy+4); // Cursor de escrita é deslocado para centro do quadrado desenhado tft.setTextColor(BRANCO); // Cor do texto é alterada para branco tft.setTextSize(3); // Tamanho do texto é alterado para tamanho 3 tft.print(texto); // Texto é escrito na posição central da caixa desenhada }
- Tft.fillRect()
Esse método recebe como parâmetros a posição inicial onde o quadrado deve começar, sua largura, altura e cor. Com todos esses dados o método irá renderizar na tela um quadrado da seguinte forma:
- Tft.drawRect
O método drawRect por sua vez, com base nos mesmos parâmetros irá criar uma borda sobre o quadrado que foi renderizado anteriormente
- Escrevendo texto
O processo para escrever informações na tela segue o seguinte fluxo:
- Primeiro através da função setCursor() iremos selecionar a posição onde o nosso texto começará a ser Escrito
- Logo em seguida configuramos a cor da fonte e seu tamanho através dos métodos setTextColor() e setTextSize().
- Por fim escrevemos o texto desejado através do método print()
- Função escreveTexto
Como foi possível observar na etapa onde escrevemos o texto dentro do retângulo, uma grande quantidade de comandos é necessária até que se escreva o texto em si. Para reduzir a quantidade de código escrita foi também criada uma função que já encapsula todo esse processo. Seu uso consiste em basicamente fornecer o ponto de inicio do texto, o texto a ser escrito, seu tamanho, e a cor do texto.
void escreveTexto(int posx,int posy, String texto,int tamanho,int cor){ tft.setCursor(posx,posy); // Move cursor para posição inicial onde o texto será escrito tft.setTextColor(cor); // Muda a cor do texto tft.setTextSize(tamanho); // Altera o tamanho da fonte tft.print(texto); // Escreve texto na tela }
- Função setup
dentro da nossa função setup iremos basicamente inicializar a nossa tela seguindo o seguinte fluxo
- Lemos o código de identificação do display através do método readID()
uint16_t ID = tft.readID();
- Inicializamos o nosso display através do método begin()
tft.begin(ID);
-
Mudamos o layout da tela para o modo paisagem através do método setRotation(1)
tft.setRotation(1);
- Por fim chamamos a função telaInicial() que irá renderizar na tela nosso painel de acesso
telaInicial();
- Função telaInicial
A função tela inicial tem como função básica renderizar todos os botões e o campo de texto que será responsável por mostrar a senha digitada. Para isso a função executa os seguintes passos:
- Mudamos a tela para o modo paisagem através do método setRotation(1)
tft.setRotation(1);
- Toda a tela é preenchida pela cor branca através do método fillScreen(BRANCO)
tft.fillScreen(BRANCO);
- Utilizando a função escreveTexto iremos escrever o texto: "Controle de acesso" na cor preta na parte superior da tela
escreveTexto(50,0,"Controle de Acesso",2,PRETO);
- Logo em seguida criamos uma caixa onde a senha digitada será armazenada conforme os botões forem clicados.
criarBotao(60,50,200,30,"",PRETO);
- Sequencialmente, criamos todos os 10 botões que serão utilizados para que o usuário digite a senha para acesso ao sistema. Isso é feito através do método criarBotao(), onda cada botão será desenhado na tela com uma distância de 50 pixels entre um e outro.
criarBotao(50,100,30,30,"1",VERMELHO); criarBotao(100,100,30,30,"2",VERMELHO); criarBotao(150,100,30,30,"3",VERMELHO); criarBotao(200,100,30,30,"4",VERMELHO); criarBotao(250,100,30,30,"5",VERMELHO); criarBotao(50,150,30,30,"6",VERMELHO); criarBotao(100,150,30,30,"7",VERMELHO); criarBotao(150,150,30,30,"8",VERMELHO); criarBotao(200,150,30,30,"9",VERMELHO); criarBotao(250,150,30,30,"0",VERMELHO);
- Por fim, criamos os dois botões responsáveis por apagar caracteres digitados incorretamente, e o botão responsável por validar a senha digitada.
criarBotao(50,200,120,30,"Apagar",VERMELHO); criarBotao(180,200,100,30,"Logar",VERMELHO);
- Função telaAcesso(bool autorizacao)
Agora que temos a nossa tela de controle de acesso criada, iremos precisar criar mais duas telas, uma para quando o acesso for permitido e outra para quando o acesso for negado. Para encapsular todo esse processo e deixa-lo mais transparente, foi criada uma função denominada telaAcesso que funciona da seguinte forma:
- Caso o argumento recebido seja verdadeiro significa que o acesso foi autorizado, então
- A Tela é preenchida pela cor preta através do método fillScreen()
tft.fillScreen(PRETO);
- O cursor é deslocado para o pixel de posição (10,100)
tft.setCursor(10,100);
- A cor do texto é alterada para verde
tft.setTextColor(VERDE);
- O tamanho da fonte do texto é alterada para o tamanho 3
tft.setTextSize(3);
- O texto acesso autorizado é escrito na tela
tft.print("Acesso Autorizado");
- Após 3 segundos o sistema volta para a tela inicial
- A Tela é preenchida pela cor preta através do método fillScreen()
- Caso contrário uma mensagem de acesso negado será escrita em vermelho na tela
- Função Loop()
A função loop por sua vez apenas alterna entre as três telas criadas em nosso sistema sendo cada uma das telas chamadas a cada dois segundos.
void loop() { // Cada uma das três telas que compõem o sistema é chamada a cada dois segundos telaInicial(); delay(2000); telaAcesso(true); delay(2000); telaAcesso(false); delay(2000); }
Desafio
Agora que você sabe como construir uma tela para controle de acesso, tente alterar as cores da paleta de cores, para cores que sejam do seu agrado. Adicione também novos botões ao sistema para que ele possa ter uma maior quantidade de combinações possíveis.
Considerações Finais
Este tutorial teve como objetivo ensinar uma forma de elaborar interfaces utilizando a shield display TfT. Além disso foi possível também aprender a como resolver um problema bastante recorrente neste display devido a grande diversidade de controladores utilizados. Este tutorial foi dividido em duas partes devido a complexidade dos passos apresentados, então aguardem que logo logo iremos adicionar a parte touch ao projeto. Espero que tenham gostado do conteúdo apresentado, sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.
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.
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.
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
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);
– 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(2,OUTPUT); pinMode(3,OUTPUT); pinMode(4,OUTPUT); pinMode(5,OUTPUT); digitalWrite(2,HIGH); digitalWrite(3,HIGH); digitalWrite(4,HIGH); digitalWrite(5,HIGH); }
Observe que além da execução dos procedimentos apresentados anteriormente, nós também optamos por colocar os pinos citados nível alto, pois, os relés do módulo que utilizamos são acionados com nível baixo em suas entradas, portanto, como queremos que eles comecem sem qualquer tipo de acionamento, devemos proporcionar 5 volts em seus respectivos pinos de entrada.
– 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, portanto, vamos utilizá-lo novamente no envio de informações provenientes dos formulários para o nosso Servidor Web. Entretanto, vamos seguir um caminho um pouco diferente para que você possa ver a existência de outras possibilidades. O primeiro passo neste procedimento será a 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; . . .
Por fim, declaramos duas variáveis do tipo inteiro sem sinal e uma do tipo String, as quais, serão responsáveis por retirar o que nós chamamos em nosso tutorial anterior de parâmetro da requisição. Além disso, este trecho de código também cumpre o papel de determinar se o parâmetro é o texto /favicon.ico, de modo que, caso não seja (pois neste momento isto não é interessante para nós), seguimos adiante na construção da página.
A explicação das funções que compõem este passo estão demonstradas em nosso tutorial anterior. Você pode acessá-lo clicando aqui!
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") { . . .
– Enviando o cabeçalho da página
Após termos detectado que o parâmetro da requisição não é o fragmento de texto /favicon.ico, 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>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.
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
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.
Módulo RF 433Mhz - Comunicação entre Arduinos
Módulo RF 433Mhz - Comunicação entre duas placas Arduino
Na maioria das vezes em que falamos sobre comunicação sem fio, pensamos imediatamente no acesso à internet através de computadores ou celulares por meio de algum modem ou roteador que esteja disponibilizando o sinal para tal propósito, no entanto, existem muitos outros métodos de comunicação sem fio. Neste tutorial, demonstraremos como é possível estabelecer uma comunicação sem fio entre duas placas Arduino via radiofrequência, utilizando os módulos Receptor e Transmissor RF 433Mhz (Módulo RF 433Mhz).
[toc]
O que é radiofrequência?
Quando pesquisamos sobre o que vem a ser o conceito de radiofrequência, nos deparamos com várias definições, no entanto, a mais adequada é que afirma que a radiofrequência consiste em uma faixa de frequências que engloba valores de aproximadamente 3KHz (algumas referências trazem valores de 9KHz, 10KHz) até 300GHz, os quais, correspondem ao intervalo de frequências utilizadas por ondas de rádio.
O uso da radiofrequência permite o controle dos mais diversos dispositivos sem que seja necessária a utilização de qualquer tipo de fio. Podemos facilmente encontrar aplicações que utilizam a radiofrequência para atender os seus propósitos, como por exemplo, os portões eletrônicos de residências, os quais, através de um controle remoto operando dentro de uma determinada faixa de frequência, pode-se acionar o motor do portão a uma grande distância.

Os módulos Receptor e Transmissor RF433Mhz
Para realizar o projeto vamos utilizar dois módulos (apresentados na figura abaixo) para que possamos estabelecer uma comunicação sem fio entre duas placas Arduino e assim, comandar uma delas através da outra.

Estes módulos trabalham à uma frequência de 433MHz e tem um alcance de até 90 metros em espaços abertos. Através da utilização destes, é possível realizar transferência de dados em uma velocidade que pode variar até 9200 bits por segundo, de modo que, quanto maior for a distância entre o elemento transmissor e o elemento receptor, menor deve ser a velocidade na transmissão dos dados para diminuir a probabilidade de erros.
Na figura acima, o módulo apresentado do lado direito, é o módulo transmissor. Este contem três pinos: Um para alimentação, outro para o terra e o último para dados. Por outro lado, o módulo presente do lado esquerdo, é o módulo receptor e apesar de este conter 4 pinos, utilizamos apenas 3 deles (assim como o módulo transmissor, utilizamos um pino para alimentação, um para o terra e outro para dados.
Mãos à obra - Comunicando duas placas Arduino via radiofrequência
Nesta seção iremos demonstrar todos os passos que você deve seguir para aprender fazer com que duas placas Arduino se comuniquem via radiofrequência.
Componentes necessários
Montando o projeto
Neste tutorial temos dois hardwares que serão utilizados. O primeiro deles irá conter um Arduino Micro, que por sua vez, irá atuar em conjunto com um módulo Transmissor RF 433Mhz.

O segundo hardware irá conter um Arduino UNO, o qual, irá atuar em conjunto com um módulo Receptor RF 433Mhz.

Programando
Conforme apresentado no tópico anterior, o projeto a ser desenvolvido neste tutorial utiliza duas placas Arduino, portanto, teremos a presença de dois códigos para serem gravados em ambas as placas. Primeiramente, apresentamos o código a ser gravado no Arduino Micro, que por sua vez, estará atuando no envio das informações.
#include <VirtualWire.h> bool estado_led; char data[2]; void setup() { vw_set_tx_pin(5); vw_setup(2000); } void loop() { estado_led = !estado_led; itoa(estado_led, data, 2); vw_send((uint8_t *)data, strlen(data)); vw_wait_tx(); delay(2000); }
Em seguida, apresentamos o código a ser gravado no Arduino UNO, que em nosso projeto, deverá receber as informações obtidas pelo Receptor RF433 Mhz.
#include <VirtualWire.h> byte message[VW_MAX_MESSAGE_LEN]; // Armazena as mensagens recebidas byte msgLength = VW_MAX_MESSAGE_LEN; // Armazena o tamanho das mensagens void setup() { vw_set_rx_pin(5); // Define o pino 5 do Arduino como entrada //de dados do receptor vw_setup(2000); // Bits por segundo pinMode(13,OUTPUT); vw_rx_start(); // Inicializa o receptor } void loop() { if (vw_get_message(message, &msgLength)) // Non-blocking { Serial.print("Recebido: "); Serial.write(message[0]); if(message[0] == '0'){ digitalWrite(13, LOW); } else if(message[0] == '1'){ digitalWrite(13,HIGH); } } }
Entendendo a fundo
Software - Arduino Micro / Transmissor RF 433Mhz
- Incluindo a biblioteca que será utilizadas
Primeiramente, para desenvolvermos uma aplicação como esta, devemos incluir a biblioteca que será utilizada no código, para que assim, o mesmo possa funcionar de maneira adequada. A biblioteca VirtualWire.h é responsável pela comunicação que será estabelecida entre o Arduino UNO e o Arduino Micro através do par Transmissor/Receptor RF 433Mhz.
#include <VirtualWire.h>
-Declarando as variáveis do projeto
Posteriormente, temos um bloco onde ocorre a declaração das variáveis que serão utilizadas no decorrer do programa. A variável estado_led (do tipo booleana) é responsável por armazenar o valor referente ao estado desejado do led (que será acionado na placa Arduino receptora) e a variável data, que por sua vez, é um vetor de caracteres, terá a função de armazenar o dado que será enviado (posteriormente explicaremos o motivo desta variável ter duas posições).
bool estado_led; char data[2];
- Estabelecendo as configurações iniciais
Na função setup(), utilizamos duas funções de configuração do módulo transmissor. A primeira delas é a função vw_set_tx_pin(), que por sua vez, é responsável por determinar qual pino do Arduino Micro será utilizado para enviar os dados da placa para o módulo Transmissor RF 433Mhz.
A outra função existente neste bloco é a função vw_setup(), a qual, serve para inicializar a comunicação entre o Arduino Micro e o módulo Transmissor RF 433Mhz, de modo que, ao utilizarmos a mesma, devemos passar como parâmetro a velocidade de transmissão em bits por segundo.
void setup() { vw_set_tx_pin(5); vw_setup(2000); }
- Enviando dados através do transmissor RF 433Mhz
Dentro da função loop() vamos estabelecer toda parte referente ao envio dos dados propriamente dito. O primeiro passo a ser realizado é a inversão do conteúdo armazenado na variável estado_led, de modo que, como esta variável é do tipo booleana, os valores irão sendo alternados entre 0 e 1 a cada passagem pelo ciclo da função loop().
estado_led = !estado_led;
Em seguida, utilizamos a função itoa() para transformar o valor contido na variável estado_led em uma string e armazenar este valor, já transformado, na variável data (como dissemos anteriormente, esta variável possui duas posições, pois, após o processo de conversão de um determinado número em string, além do mesmo, surge também como resultado, o caractere terminador de strings "\0") .
A função itoa() possui 3 parâmetros, dos quais, o primeiro refere-se à variável cujo valor queremos transformar em string. O segundo, é a variável na qual queremos guardar o resultado gerado e a terceira é o tipo de dado que estamos convertendo, logo, como estamos convertendo um valor binário, utilizamos o número 2 nesta posição.
itoa(estado_led, data, 2);
Posteriormente, utilizamos a função vw_send() para enviar os dados para o Transmissor RF433Mhz transmiti-los (note que esta função possui 2 parâmetros, de modo que, o primeiro deles refere-se à variável que queremos enviar e o seguindo diz respeito ao tamanho da mesma. Sugerimos que utilize esta função neste formato, trocando apenas o nome da variável que você irá utilizar).
vw_send((uint8_t *)data, strlen(data));
Por fim, utilizamos a função vw_wait_tx() para que o programa aguarde a transferência total da mensagem e a função delay() para estipular o tempo que o led levará para trocar de estado.
vw_wait_tx(); delay(2000);
Veja como ficou nossa função loop()
void loop() { estado_led = !estado_led; itoa(estado_led, data, 2); vw_send((uint8_t *)data, strlen(data)); vw_wait_tx(); delay(2000); }
Software - Arduino UNO / Receptor RF 433Mhz
- Incluindo a biblioteca que será utilizadas
Assim como no programa desenvolvido para o Arduino Micro, devemos incluir a biblioteca que será utilizada neste código, para que assim, o mesmo possa funcionar de maneira adequada. A biblioteca VirtualWire.h é responsável pela comunicação que será estabelecida entre o Arduino UNO e o Arduino Micro através do par Transmissor/Receptor RF 433Mhz.
#include <VirtualWire.h>
-Declarando as variáveis do projeto
Posteriormente, temos um bloco onde ocorre a declaração das variáveis que serão utilizadas no decorrer do programa. As variáveis tamanho_msg e msg, ambas do tipo byte, são responsáveis por armazenar informações referentes às mensagens que serão recebidas, para que, utilizando as mesmas, seja possível interpretá-las e tomar as ações necessárias com base no conteúdo recebido.
Apenas a título de curiosidade, o elemento VW_MAX_MESSAGE_LEN é próprio da biblioteca utilizada e armazena o valor referente ao tamanho da mensagem.
byte tamanho_msg = VW_MAX_MESSAGE_LEN; byte message[VW_MAX_MESSAGE_LEN];
- Estabelecendo as configurações iniciais
Na função setup(), utilizamos três funções para a configuração do módulo receptor. A primeira delas é a função vw_set_rx_pin(), que por sua vez, é responsável por determinar qual pino do Arduino UNO será utilizado para receber os dados enviados do módulo Receptor RF 433Mhz para a placa Arduino utilizada.
A segunda função existente neste bloco é a função vw_setup(), a qual, serve para inicializar a comunicação entre o Arduino UNO e o módulo Receptor RF 433Mhz, de modo que, ao utilizarmos a mesma, devemos passar como parâmetro a velocidade de transmissão em bits por segundo (note que esta informação deve ser igual à estabelecida no módulo Transmissor RF 433Mhz). Por fim, através da função vw_rx_start() inicializamos a função de recebimento de dados do Receptor RF 433Mhz. Além disso, definimos o modo de operação do pino 13 através da função pinMode().
void setup() { vw_set_rx_pin(5); // Define o pino 5 do Arduino como entrada vw_setup(2000); //Serial.begin(9600); //while(!Serial){} //de dados do receptor vw_setup(2000); // Bits por segundo pinMode(13,OUTPUT); vw_rx_start(); // Inicializa o receptor }
- Recebendo dados através do Receptor RF 433Mhz
Basicamente, o que fazemos na função loop() é conferir se houve o recebimento de algum dado através da função vw_get_message() e caso tenha, verificamos se este valor, em string, corresponde ao caractere 0, o qual, será responsável por fazer com que o led seja apagado. Em contrapartida, caso, o valor encontrado seja o caractere 1, o led deverá ser acionado.
void loop() { uint8_t message[VW_MAX_MESSAGE_LEN]; uint8_t msgLength = VW_MAX_MESSAGE_LEN; //display.setCursor(0, 0); //Seta a posição do cursor if (vw_get_message(message, &msgLength)) // Non-blocking { Serial.print("Recebido: "); Serial.write(message[0]); if(message[0] == '0'){ digitalWrite(13, LOW); } else{ digitalWrite(13,HIGH); } Serial.println(); }
Considerações finais
Neste tutorial, demonstramos como você pode utilizar o conceito de radiofrequência para fazer com que duas placas Arduino troquem informações entre si. Este foi apenas um conteúdo para que você tenha uma noção de como das os primeiros passos com esta tecnologia, 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.