nesse post mostraremos como podermos energiza o Arduino ou outra placa a partir de painéis solares e também como utilizar uma bateria recarregável para manter nossos projetos funcionando mesmo a noite.
O circuito é bem simples, composto pelos seguintes componentes:
Painel solar;
Arduino;
Bateria recarregável e um conector para ela;
Diodo;
Capacitor de 100uF e 16V (não achei o capacitor de 10V do post original);
Fios;
Protoboard;
Microvoltímetro para testar o circuito.
Abaixo temos a imagem com todos os componentes que utilizaremos:
O primeiro passo é remover o plástico do painel solar e soldar fios e seus terminais positivo e negativo que estão na parte de trás dele:
Em seguida solde pinos do tipo macho na outra extremidade dos fios, para podermos utilizálos no protoboard mais facilmente:
Agora, corte os fios do adaptador da bateria removendo o soquete, pois uitlizaremos nesse circuito somente a parte que conecta à bateria. Solde nas extermidades do fios pinos macho, semelhante aos fios conectados ao painel solar:
Agora começaremos a montar o circuito na protoboard: monte o diodo e o capacitor na protoboard como mostrado na imagem abaixo:
Em seguida, coloque o Arduino na protoboard e ligue os pinos Vin na linha positiva (mais próxima da linha vermelha) do protoboard e o pino GND na linha negativa (mais próxima da linha azul):
Por fim, ligue a bateria recaregável no conector e coloque na protoboard, com o fio positivo (geralmente o vermelho) na linha positiva da protoboard e o fio negativo (geralmente o escuro) na linha negativa da protoboard.
Para completar e acionar o circuito, conecte o painel solar na protoboard, onde o fio escuro (ou o fio que etiver soldado no terminal negativo do painel) deve ser ligado à linha negativa da protoboard e o fio vermelho (ou o fio que estiver soldado ao terminal positivo) deve ser conectado ao terminal do diodo.
Veja a imagem abaixo para confirmar suas conexões do circuito:
Teremos nesse ponto o circuito funcionando. Você pode retirar o Arduino para gravar o programa de seu projeto nele e retorná-lo para a protoboard, utilizando a energia solar para alimentar seu projeto.
O primeiro ponto é motarmos os circuitos, tanto da leitura da umidade do solo como o circuito driver para acionar a bomba. Em seguida devemos fincar os pregos na terra onde está a nossa planta e fixar a mangueira na bomba e no vaso ou região de terra que iremos irrigar. No meu projeto eu deixei a bomba submersa na água para evitar usar mais manguiras, mas não há problemas em utilizar a bomba fora da água.
Realizada a montagem fisica do projeto passaremos para o código. O primeiro passo é declarar as seguintes constantes:
pino digital de acionamento da bomba de água;
pino analógico que fará a leitura da umidade do solo;
O tempo que a bomba ficará ligada quando acionada;
Nível mínimo de umidade do solo, onde a bomba será acionada caso o valor fique abaixo desse valor.
As duas primeiras constantes são bem fáceis de serem atribuídas valores. As duas últimas constates são mais difíceis de acharmos os valores, no meu caso identifiquei os valores experimentandos diversos valores.
O passo seguinte é configurarmos na função SETUP o pino digital como OUTPUT e deixá-lo como LOW para manter a bomba desligada. Também é interessante configurarmos a porta serial para realizarmos o debug do código.
Na função LOOP, devemos realizar a leitura do pino analógico e comparar com a constante de nível minímo de umidade. Caso o valor lido do sensor esteja abaixo da constante, devemos acionar a bomba alterando o pino digital para HIGH.
Em seguida devemos aguarda o tempo necessário para molhar as plantas e desligar a bomba, voltando o estado do pino digital para LOW.
Finalmente devemos aguardar algum tempo com a função delay para voltarmos a fazer uma nova medida da umidade do solo. Abaixo temos o código completo de exemplo:
Nesse ponto temos um projeto simples mas funcional para a irrigação de plantas em vaso ou de uma pequena área. Porém esse projeto ainda consume muita energia. Em posts futuros mostraremos como podemos reduzir o consumo de energia desse e de outros projetos que utilizam Arduino, e como podemos alimentá-lo com energia solar.
no post anterior mostramos como podemos realizar a leitura da humidade de solo para construírmos um projeto de automação de irrigação. Nesse post mostratemos como podemos controlar uma bomba de água para enviar água para as plantas quando o sensor acusar que o solo está seco.
Utilizaremos uma bomba de água anfibia, ou seja, uma bomba que pode ser utilizada tanto dentro como fora da água. Essa bomba, do modelo JT-180, possuí três fios, uma para o terra (preto), outro para o positivo (vermelho) e outro que permite a leitura da velocidade da bomba (branco).
Bomba utilizada no projeto
Nesse projeto utilizaremos somente os fios preto e vermelho e calibraremos o volume de água enviado pelo tempo que a bomba ficará acionada.
Como a bomba é um motor DC de 12V, podemos utilizar o circuito do post sobre motores DC. Faremos um novo código para controlar a bomba.
O primeiro passo no código é declarar qual pino do Arduino estará conectado no driver para controla a bomba.
Em seguida faça as seguintes configurações na função setup:
O pino que controlará o motor como OUTPUT com a função pinMode e deixe o pino no estado LOW com o uso da função digitalWrite
Na função setup, escreva o código para executar os seguintes passos:
Aguarde por algum tempo, como 5 segundos com a função delay
Acione a bomba, mudando o estado do pino de LOW para HIGH com a função digitalWrite, e aguarde por agum tempo, como 3 segundos novamente com a função delay
Desligue a bomba, mudado o estado do pino de HIGH para LOW com a função digitalWrite
Código para acionar a bomba
Nesse ponto estaremos ligando e desligando a bomba, mas ainda não direcione a água para as plantas, pois mandaremos muita água que inundará o vaso e oderá mata as plantas.
Porém, é interessante utilizar esse código para calibrar a quantidade de água que será necessária para molhar as plantas. A calibração será pela quantidade de tempo que a bomba ficará ligada.
No próximo post, mostraremos como juntar a leitura do sensor com o acionamento da bomba para concluírmos o noss projeto.
algum tempo atrás montei um projeto de irrigação a partir das instruções que li em um ótimo livre sobre a Intel Galileo. Como o projeto funcionou bem e alguns amigos pediram para publicá-lo, vou colocar as instruções e adaptações em alguns posts.
Nesse post mostrarei como podemos monta o sensor de humidade de solo com materiais simples: pregos, fios e resistores, além de como ler o valor do sensor.
Cada sensor de humidade é composto de dois pregos, um resistor e fios para as ligações. O principio é bem simples: a água conduz eletricidade, portanto quanto mais seca estiver a terra menos corrente circulará entre os pregos, logo teremos menos tensão no pino analógico.
Para montar o sensor utilize os fios para ligar um dos pregos no 5V da sua placa, no meu caso utilizei um Arduino Nano. O outro prego deve ser conectado em um pino analógico da sua placa e em um resistor. O resistor deve ser conectado ao terra da sua placa.
Abaixo temos o diagrama para um sensor, mas você pode ligar mais de um sensor na placa. O limite é a quantidade de pinos analógicos da sua placa.
Com a montagem completa, fixe os dois pregos na terra, com uma distância de aproximadamente 2 cm.
Passaremos agora para o código, que é bem simples:
Declare uma constante do tipo int, que armazenará qual pino analógico o sensor está ligado;
Inicie a porta Serial na função setup;
Na função loop: realize a leitura da porta analógica com a função analogRead e exiba o valor na porta Serial.
Código para leitura do sensor de humidade
Nesse ponto temos o sensor funcionando e o Arduino lendo o valor da humidade do solo. Nos próximos posts mostraremos como controlar uma bomba de água com o Arduino e ligada e desliga-la a partir do valor do sensor.
nesse post mostraremos como podemos utilizar um sensor de infravermelho para identificar objetos que estejam próximos ao sensor para tomar alguma ação. Podemos utilizar o sensor para disparar alarmes ou mesmo para acionar os braques de um veículo controlador por um Arduino, Raspberry PI ou outros microcontroladores/microprocessadores.
Esse sensor é bem simples de utilizar. Ele é composto de um pino alimentação, um pino que deve ser ligado ao terra e um pino digital. Assim que um objeto ou obstáculo esteja a uma distância inferior a distância estabelecida o pino digital é acionado. A distância miníma de acionamento é configurada através de um potêncimetro que está na placa.
Sensor de obstáculo por IR
Primeiro faremos as conexões entre o sensor e o Arduino:
conecte o pino VCC do sensor no pino +5V do Arduino;
conecte o pino GND do sensor em um pino GND do Arduino;
Conecte o pino OUT do sensor em um pino digital do Arduino.
No exemplo conectamos o sensor diretamente com o Arduino utilizando cabos macho-femea, mas também é possível colocar o sensor em uma protobard e conectá-lo ao Arduino com cabos do tipo macho-macho.
Motagem do circuito
Passaremos agora para o desenvolvimento do código: primeiro declare uma variável que indicará em qual pino digital o sensor está conectado.
Em seguida na função setup, inicie a porta serial para verificar o funcionamento do sensor e configure o pino para entrada (INPUT).
Por fim, na funçao loop faça a leitura do pino digital onde o sensor está conectado com a função digitalRead. No exemplo verificamos o valor do pino (HIG/LOW) para exibir uma mensagem na porta serial, mas você poderá dispara outras ações.
Nesse post demonstraremos o uso do sensor de chuva/gotajamento que também pode ser utilizado para detectar também o nível de água de um recipiente. Esse sensor é composto de três peças: a placa sensora, um cabo de ligação do tipo femea-femea e o conversor com saída analógica e outra digital.
Partes do sensor
A saída analógica emite sinais na mesma proporção em que a placa sensora é molhada. Já a saída digital é acionada quando uma quantidade de água determinada atinge o sensor. A quantidade de água que dispara a saída digital é ajustada no potenciômetro da placa conversora.
Primeiro vamos montar o circuito: conecte os cabos na placa sensora e em seguida no conversor. Na sequência podemos conectar a placa conversora na protoboard ou diretamente no Arduino com cabos jumper macho-femea, conforme a foto abaixo:
Sensor montado
Passaremos agora para o desenvolvimento do código. Primeiro declare as variáveis que indicarão em quais pinos da placa as saídas do sensor estão conectados. Em seguida inicie o pino digital como INPUT e configure a porta serial.
int digital = 8;
int analogico = A0;
void setup() {
pinMode(digital, INPUT);
Serial.begin(9600);
}
Passaremos agora para a função loop. Primeiro faremos a leitura do pino digital, verificando se o valor limite foi acionado, exibindo o resultado na porta serial. Em seguida faremos a leitura do pino analógico, que indicará o quanto molhado está o sensor.
O valor analógico será alterado tanto quando gotas de água atingem a placa como quando a placa sensora é coloca na parede de um recipiente e o nível de água desse recipiente é alterado. Por isso podemos utilizar esse sensor tanto para identificar chuva ou outros gotejamentos como para medir o nível de líquidos dentro de um recipiente.
Naturalmente em nossos projetos o valor de disparado de alguma ação deverá ser calibrado para identificar o valor ideal, tanto da saída digital como a analógica.
valor = analogRead(analogico);
Serial.println(valor);
delay(1000);
}
Com o circuito montado e o código desenvolvido podemos compilar e rodar o programa. Após a compilação e transferência do programa abra o monitor serial para verificar os estados dos pinos. Atinja a placa com algumas gotas de água e veja os valores alterarem, ou mexa no potenciômetro para ajustar o valor de disparo do pino digital.
nesse post demonstraremos como utilizar o módulo de joystick, que pode ser utilizado tanto para jogos como para controlar outros projetos como veículos, drones e braços de robôs. Esse módulo possui cinco pinos seguindo a seguinte distribuição:
Gnd: que deve ser ligado ao terra da placa;
+5V: que deve ser ligado ao 5V da placa;
VRx: pino onde faremos a leitura do valor do eixo X;
VRy: pino onde faremos a leitura do valor do eixo Y;
SW: pino onde faremos a leitura do estado do botão (pressionado ou não).
O funcionamento desse módulo é bem simples, pois ele é composto de dois potenciômetros, um para cada eixo do joystick e um botão. Portanto ao movimentarmos o joystick em alguma direção movemos os potenciômetros. Portanto a leitura desses potenciômetros deve ser realizada pelos pinos analógicos do Arduino ou outra placa que esteja utilizando.
Devido a simplicidade do módulo faremos nesse post um projeto um pouco mais elaborado: O joystick controlará dois servos, um para o eixo X e outro para o eixo Y e o botão acionará dois leds, um no circuito e outro na placa.
O primeiro passo é montarmos o circuito. Conecte cabos do tipo macho-femea no joystick e em seguida conecte os pinos Gnd e 5V do módulo nas linhas da protoboard. O próximo passo é conectar os cabos dos pinos VRx e VRy aos pinos A0 e A1 do Arduino (ou os pinos equivalentes da sua placa). Em seguida conecte o cabo do pino SW na protoboard.
Agora passaremos para a montagem dos servos: Conecte os cabos de Vcc dos servos na mesma linha de furos da protoboard onde você conectou o pino 5V do joystick. Conexão semelhante deve ser feita com os cabos Gnd dos servos na linha de furos onde foi conectado o pino Gnd do joystick. Finalize essa etapa conectando os cabos de sinais dos servos nos pinos 9 e 10 do Arduino (ou outros pinos que tenham suporte a PWM).
Para finalizar o circuito, conecte o terminal negativo de um led ao cabo que está ligado ao pino SW do módulo e em seguida um resistor ao led e a linha do proboard que possui as conexões de 5V. Ligue finalmente um cabo do pino 5V do Arduino a essa última linha e outro cabo do pino Gnd do Arduino na linha onde foram conectados os Gnds tanto do módulo como dos servos.
Diagrama de montagem do circuitoCircuito montado
Passaremos agora para o desenvolvimento do código. Primeiro declare o uso da biblioteca Servo e em seguida as variáveis para indicar os pinos de leitura do módulo de joystick, escrita dos valores para os servos e escrita do led embutido no Arduino (pino 13). Declare também uma variável que armazenará o valor do eixo X e dois objetos para do tipo Servo.
#include <Servo.h>
int joystickX = A0;
int joystickY = A1;
int botao = 7;
int led = 13;
int eixoX = 9;
int eixoY = 10;
int valorX;
Servo servoX;
Servo servoY;
Passaremos agora para a inicialização do projeto na função setup. Configure o pino do botão do joystick como INPUT e o pino do led da placa como OUTPUT. Em seguida utilize a função attach para indicar ao Arduino em quais pinos estão conectados os cabos de sinal dos servos. Finalize a função setup posicionando os servos em 90 graus e atribua esse valor na variável que armazena o valor do servo X.
void setup() {
pinMode(botao, INPUT);
pinMode(led, OUTPUT);
servoX.attach(eixoX);
servoY.attach(eixoY);
servoX.write(90);
servoY.write(90);
valorX = 90;
}
Passaremos agora para a função loop, que executará a lógica de controle do nosso projeto.
O primeiro trecho fará a leitura do botão e quando acionado ligará o led da placa. Devido a montagem do circuito a leitura está invertida, ou seja, quando o botão é acionado o estado do pino é LOW e quando o botão é solto ele volta para o estado HIGH. Por isso foi colocado o if para a inversão da lógica:
void loop() {
int valor = digitalRead(botao);
if (HIGH == valor)
digitalWrite(led, LOW);
else
digitalWrite(led, HIGH);
}
O próximo passo é o controle do eixo X. O servo desse eixo será movimentado somente quando o valor do joystick ultrapassar um determinado valor para evitar acionamentos indevidos, e continuará movimentando no sentido até que seja atingido o valor máximo ou que a alavanca do módulo volte para a posição inicial. Essa característica foi implementada com os dois conjunto de IFs. O primeiro verifica o valor do potenciômetro que controla o eixo e o segundo garante que o servo não movimentará mais do que o limite que desejamos:
valor = analogRead(joystickX);
if (800 < valor)
valorX += 1;
else if (200 > valor)
valorX -= 1;
if (valorX > 160)
valorX = 160;
else if (valorX < 10)
valorX = 10;
servoX.write(valorX);
Já para o eixo Y teremos outro comportamento: o servo movimentará proporcionalmente ao movimento da alavanca do joystick. Para realizar esse comportamento faremos a leitura do valor do eixo Y e em seguida utilizaremos a função map, que produz o efeito de uma “regra de 3” calculando o valor do grau do servo baseado no valor do eixo Y:
valor = analogRead(joystickY);
int valorY = map(valor, 0, 1023, 10, 160);
servoY.write(valorY);
Para finalizar o código vamos fazer o Arduino aguarda 50 microsegundos, abaixo temos o código completo da função loop:
nesse post demonstraremos como utilizamos sensor de ultrasom HC-SR04 para medir distâncias. Esse sensor calcula o tempo que as ondas de ultrasom que ele mesmo emite demoram para retornar. O retorno dessas ondas é chamado de eco. Como a velocidade da onda de ultrasom é conhecida, o sensor mutiplica o tempo que o eco levou para retornar por essa velocidade para calcular a distância.
O sensor deve ser alimentado com 5V, portanto podemos utilizar o pino de 5V do Arduino. A distância de operação do sensor vai de menos de um 1cm para aproximadamente 4 metros.
Iniciaremos montando o circuito. Primeiro ligue o pino Vcc do sensor no 5V do Arduino ou de outra placa que esteja utilizando. Em seguida conecte o pino Gnd ao terra da placa. Por fim conecte os pinos Echo e Trig a dois pinos digitais do Arduino. A imagem abaixo mostra o circuito montado:
Circuito com o sensro de ultrasom
O próximo passo é escrevermos o código. O primeiro passo é declararmos as variáveis que serão utilizadas no código: uma para o pino do Arduino onde conectamos o pino trig do sensor, outra para o pino da placa onde foi conectado o pino echo do sensor e outras três variáveis para a o tempo do eco, distância em cm e em polegadas:
int trigPin = 11;
int echoPin = 12;
long duration, cm, inches;
O próximo passo é configurarmos os pinos da placa como saída e a porta serial, onde escrevemos a distância medida pelo sensor:
O passo final é utilizarmos o sensor na função loop. O uso do sensor é bem simples: primeiro devemos mandar um pulso alto de 10 microsegundos no pino trig o sensor e em seguida esperar por outros 10 microsegundos. Após essa espera o sensor deve ter calculado a distância, que será medida no pino da placa que está conectada ao pino Echo do sensor. Obtenha esse valor com a função pulseIn.
O passo final é calcular a distância em cm ou polegadas. Para obter a distância em cm divida o valor obtido por 2 e depois por 29.1. Já para obter o valor em polegadas divida o valor original por 2 e depois por 74.
duration = pulseIn(echoPin, HIGH);
cm = (duration/2) / 29.1;
inches = (duration/2) / 74;
Após esse cálculo o valor poderá ser utilizado, no caso desse post apenas enviamos para a porta serial, mas você poderá utilizar esse valor para evitar batidas com outros objetos, acionar ou desligar algum dispositov ou tomar alguma outra decisão decisão.
comentamos em um post anterior que é possível desenvolvermos projetos em C++ ou Node .JS utilizando nossa placa Intel Galileo e também executar diversos programas ao mesmo tempo.
Mesmo quando escrevemos nossos programas em outras linguagens podemos utilizar os pinos da nossa placa de forma semelhante quando escrevemos nossos skecths. Para controlar os pinos da Intel Galileo Gen2 devemos utilizar as bibliotecas libmraa e UPM. Essas bibliotecas já estão presentes na imagem que montamos em outro post.
A biblioteca libmraa permite controlarmos os pinos diretamente de forma simples, assim como fazemos em nossos sckecths. Ela possui interfaces para desenvolvermos nossos programas em C++, Javascript, Phyton e Java. A documentação da biblioteca libmraa é encontrada no link http://iotdk.intel.com/docs/master/mraa/.
A biblioteca UPM (Usefull Packages & Modules – Pacotes e módulos úteis) possui classes prontas para lidarmos com uma grande quantidade de sensores e motores e outros componentes, simplificando o desenvolvimento de nossos programas. Dessa forma podemos utilizar uma classe para controlar algum componente ao invés de manipularmos os pinos, o que nos salva tempo para aprendermos a lidar com o componente, desenvolver o código e testá-lo.
Veremos nos próximos post como devemos montar nosso ambiente de desenvolvimento para escrevermos aplicações em C++ ou Node .JS para utilizarmos em nossos projetos com a placa Intel Galileo
nesse post demonstraremos como podemos conectar a placa Intel Galileo Gen2 na nossa rede Wifi. Podemos realizar essa conexão por dois modos:
Utilizando shields WIFI do padrão Arduino
Por meio de uma placa Wifi mini PCI utilizada em notebooks
O uso de um shield Arduino de Wifi possui a vantagem de utilizarmos o padrão Arduino de conexão, porém limitados o uso da conexão apenas aos sketchs, que são os programas desenvolvidos na linguagem do Arduino. Além disso, toda vez que nossos sketchs iniciarem o objeto de WiFi será iniciada a conexão de rede o que consome algum tempo.
Já o uso da placa de Wifi mini PCI possui a vantagem de podermos utilizá-la em todas as linguagens de programação disponíveis para a Intel Galileo Gen2 e a conexão de rede é estabelecida quando a placa é ligada. Outro beneficio do uso da placa mini PCI no lugar de um shield é a redução de espaço que em alguns casos pode ser crucial.
Para adicionar uma conexão WiFi na Intel Galileo com o uso da placa Mini PCI precisaremos acessar o terminal do Yocto, cujo procedimento está descrito no post anterior. Além dos itens mencionados naquele post precisaremos:
Placa Intel Centrino Wireless-N 135;
Adaptador da placa mini PCI;
Um par de antenas de lap top.
O primeiro passo é montarmos o adaptador na placa mini PCI. Fixe o adaptador na placa com o uso dos parafusos que acompanham o adaptador:
Montagem da placa Wifi no adaptador
Em seguida conecte as antenas de laptop nos terminais da placa mini PCI. Para encerra a instalação da placa insira os terminais da placa mini PCI no slot mini PCI que está no verso da placa e encaixe os furos do adaptador nos encaixes da placa:
Montagem no verso da Intel Galileo
Com a montagem física concluída, ligue a Galileo Gen2 na energia e no roteador com o cabo e inicie uma sessão SSH como mostrado no post anterior. Após iniciada a sessão execute o comando connmanctl. Note que o prompt do terminal foi alterado. Inicie a placa de WiFi com o comando enable wifi e em seguida realize a procura da sua rede com o comando scan wifi.
Para listar as redes identificadas utilize o comando services. Será exibida no terminal uma lista com o nome das redes encontradas e um identificador para cada uma.
Comandos para habilitar a interface Wifi
Caso a rede que você deseja conectar sua placa possua senha execute o comando agent on. A conexão com a rede é realizada com o comando connect <ID da rede>. Você não precisa digitar todo o ID da rede, somente os primeiros caracteres e em seguida pressione TAB para o Linux completar o texto. Ao entrar com o comando será solicitada a senha.
Com a conexão estabelecida digite o comando exit para encerrar o connmanctl. Para confirmar que a conexão WiFi foi estabelecida e obter seu endereço IP execute o comando ifconfig. Você poderá utilizar o endereço IP dessa conexão para futuras conexões com o Putty e também em seus programas:
