Publicado em Deixe um comentário

Medidor Temperatura, Servo Motor.

Dois outros tutoriais que escrevi mostram o básico ( Arduino 101 ) e como criar um data logger realmente básico ( Arduino Datalogger – simples ). Este tutorial irá mostrar como conectar servomotores e usar o sensor de temperatura para movê-lo!

A premissa é que, muitas vezes, você quer responder a alguma entrada e fazer algo acontecer. A maioria dos tutoriais mostra como acender as luzes ou emitir um som. Aqui, quero mostrar como você pode usar um simples servomotor para abrir algo (como uma janela) em proporção à temperatura ambiente.

Vamos começar!Adicionar dicaPerguntarComenteBaixar

Etapa 1: Adicionando os Componentes

Imagem de adicionar os componentes
Imagem de adicionar os componentes

Para este tutorial, você precisará de:

  • Um arduino
  • Uma tábua de pão pequena
  • Um servo motor
  • Um LED
  • um resistor, ajustado para 150Ω
  • um sensor de temperatura

Eu uso o Tinkercad para todos os tutoriais até eu entrar em classes ou bibliotecas complexas, então vá até lá e ganhe uma conta! Para adicionar os componentes, você precisará abrir o componente Componentes e pesquisar / rolar, certificando-se de ter selecionado “todos” em vez de “básico” no seletor suspenso de componentes.

Se você não tiver certeza de como usá-los, ou se a qualquer momento se perder, volte ao Passo 1 e use o tutorial 101 e datalogger para começar. Eles são um bom ponto de partida.

Vamos ligar isso.Adicionar dicaPerguntarComenteBaixar

Etapa 2: conectando a fiação

Imagem de Fiação Acima
Imagem de Fiação Acima
Imagem de Fiação Acima
Imagem de Fiação Acima

Um lembrete de que todas as colunas em uma placa de montagem estão conectadas, mas há uma lacuna no meio que desconecta a matriz superior da parte inferior.

  1. Use a primeira imagem como guia sobre como conectar os fios 5v e GND do Arduino à breadboard. Conecte as portas 5V e GND no Arduino à breadboard. Essencialmente, esses dois trilhos de energia fornecem um número maior de portas para acessar a energia ao criar protótipos.
  2. Conecte a parte inferior da placa ao topo. Certifique-se de combinar GND / Negativo (preto) para 5v / Positivo (vermelho).
  3. Certifique-se de que todos os componentes estejam na metade inferior da placa de montagem, exceto o servo, e que eles estão cruzando as colunas. Isso é importante, então não cruzamos nenhum fio.
    1. Adicione o LED (imagem 2).
    2. Use o resistor e conecte a um dos pinos (usei o ânodo). 
      Se você usou o ânodo (e é mais fácil seguir o diagrama de fiação na imagem), conecte o cátodo (negativo) à linha GND na breadboard. 

      Dica rápida! Se você passar o mouse sobre o final dos pinos em um componente, ele informará qual é o ânodo e o catodo, ou sinal etc.
    3. Ligue o sensor de temperatura. Certifique-se de que a perna esquerda vá para 5v. A perna direita vai para o GND. A perna do meio deve estar conectada ao pino A0. 
      Este é um dispositivo analógico e, como tal, precisa de um pino analógico. Poderíamos usar digital e dizer para receber analógico, mas temos pinos suficientes.
    4. Para o servo, temos três fios. Estes incluem 5v, GND (terra) e um fio de sinal.
      1. Conecte o fio marrom no servo ao GND na breadboard.
      2. Conecte o fio vermelho no servo a um pino de 5v na breadboard.
      3. Conecte o fio laranja ao pino digital 3 no Arduino.

Se não tiver certeza, verifique as imagens acima!Adicionar dicaPerguntarComenteBaixar

Etapa 3: o código

Imagem do Código

Neste exemplo, estou supondo que tenho uma casa em um clima quente. Eu gostaria de abrir as janelas quando ficar quente para que eu possa maximizar o fluxo de ar, porque eu tenho um condensador de ar que requer pressão positiva maciça na casa para resfriar o local. Então, vamos controlar automaticamente as janelas para maximizar o fluxo de ar.

Vamos entrar no código bom e rápido!

#include <servo.h>

Esta é a primeira vez (nesta série) que usamos uma biblioteca. Uma biblioteca é como uma caixa com uma série de pastas. Em cada pasta há folhas de papel, e cada uma delas tem instruções especiais sobre como usar dispositivos específicos. Você pode “incluir” essas pastas em seu código, o que torna mais rápido escrever seu código!No passado, escrevi plugins para webapps e outros softwares que são distribuídos gratuitamente. É uma ótima maneira de retribuir à comunidade! Depois de ter desenvolvido uma boa base de habilidades em código, é uma oportunidade válida para se envolver em código aberto.

Nós usamos a instrução #include para dizer ao Arduino que ele irá usar a biblioteca. Se é uma biblioteca global (algo que você instalou com o gerenciador de pacotes ou embutido no Arduino, como math.h), então você irá colocá-lo entre os símbolos <>.

Mais tarde, você aprenderá a escrever o seu próprio e se você armazená-los na pasta do projeto, você colocará o nome do arquivo entre aspas duplas, “assim”. Isso porque o compilador (o programa que converte o código de algo que podemos ler para algo que o Arduino pode ler) precisa referenciar o arquivo na pasta, não no escopo global.

O próximo bloco de código deve parecer bastante familiar, então vamos apenas olhar para os novos recursos.

// Definir constantes
#define temperatura A0
#define ledIndicator 2
#define servoPin 3
// Inicializa a classe servo
Servo MainServo;

Então, nós definimos as duas constantes que vamos usar. Estes são os pinos conectados aos sensores ou saídas. Nós também definimos o pino servo.

Você pode ver a linha Servo mainServo – é onde instanciamos a classe Servo que instalamos com a biblioteca. Isto é como ligar a máquina de café para aquecê-lo (eu amocafé …). Está pronto para ir! Neste caso, mainServo é o nome que demos a esta nova instanciação. Isso é importante, porque com as classes, eu poderia ter 1, 2 ou muitos servos rodando ao mesmo tempo! É por isso que usamos classes, porque eles são pequenos pacotes por conta própria, podemos usar muitas vezes e fazer muitas coisas com eles.

// Definir variáveis
posição int = 0;
int previousPosition;
void setup () {
	pinMode (temperatura, INPUT);
	pinMode (ledIndicator, OUTPUT);
	// Diz ao mainServo qual pino ele está conectado
	mainServo.attach (servoPin);
	Serial.begin (9600);
}

Este bloco de código acima é bastante consistente com tudo o que fizemos. A única nota importante a fazer é a chamada de função mainServo.attach () . Aqui, dissemos à mainServo para executar uma função chamada attach () e dentro das chaves redondas, indicamos o pino ao qual estamos anexando o servo. Isso ajuda o servo a saber para onde enviar os sinais mais tarde.Se você está se perguntando como sabemos quais chamadas de função fazer dentro de nossa biblioteca, todas as bibliotecas têm documentação. Esta documentação informa quais funções existem dentro da biblioteca e como você pode usá-las (por exemplo, quais parâmetros cada função executa).

void loop () {
}

O próximo bloco de código vai dentro do código loop () .

// Análise de temperatura
int tempReading = analogRead (temperatura);
// Se estiver usando uma entrada de 5v
tensão de flutuação = tempReading * 5.0;
// Dividido por 1024
voltagem / = 1024,0;
// Convertendo de 10mv por grau
float tempC = (voltagem - 0,5) * 100;
// Isso mapeia a temperatura para graus abertos para a aba
int position = map (tempC, 10, 50, 0, 180); <br>

Neste bloco, estamos completando a análise de temperatura (vimos isso no tutorial do registrador de dados). Essencialmente, estamos pegando o sinal analógico enviado pelo sensor de temperatura e convertendo-o em graus.

A função map () nos permite converter isso em algo utilizável. Em vez de executar matemáticas complexas que precisariam de muitas linhas, nós as convertemos assim:

map (variableValue, fromLow, deHigh, toLow, toHigh);

O que isto faz é pegar o valor da variável que temos (como graus) e converter o valor mínimo possível e o valor máximo possível em pode nos dar (neste caso, eu defino o mínimo para 10 graus e o máximo para 50 graus . Estes são os valores mínimo e máximo que estou esperando do sensor de temp, e também sei que em 10degrees, gostaria que o windows completamente fechado para manter o calor dentro! Enquanto em 50degrees, eu quero que eles completamente abertos para o fluxo de ar máximo!

if (previousPosition! = position) {
	Serial.print ("Nova posição:");
	Serial.println (posição);
	mainServo.write (posição);
	digitalWrite (ledIndicator, HIGH);
	// Espere o servo se mover
	atraso (2000);
}
// Desligue a luz indicadora
digitalWrite (ledIndicator, LOW);
// set previousPosition por isso, se não temos que mudar, não disparamos o servo
previousPosition = posição;

Neste bloco, decidi apenas permitir que o servo disparasse quando a posição realmente mudasse. Isso não deve ser assim tão frequentemente, mas pode ser. Nesse caso, talvez eu precise fazer algumas alterações para que o código só permita o movimento quando a alteração da temperatura for superior a 5 graus, caso contrário, poderá estar aparando constantemente a janela, o que pode danificar o servo. Enfim, um problema para outro dia!

Então, se a posição mudar, então nós imprimiremos a nova posição para o Serial e então, usando a chamada da função mainServo.write () , passando a nova posição, o servo muda de posição. Para alertar o usuário de que algo está acontecendo, ligo um LED e aguardo 2 segundos para o servo se mover. As duas últimas linhas desligam o LED e certificam-se de que a previousPosition está armazenada para que possamos verificar o próximo loop.

Publicado em Deixe um comentário

Automático de Bateria

O módulo HC-SR04

O módulo de sensor ultrassônico HC-SR04 é comumente usado em projetos com Arduino
para realização em leituras de distâncias que podem variar entre 2 centímetros e 4 metros, permitindo uma precisão de 3 milímetros.
Baseado no envio e recebimento de sinais ultrassonicos pelos sensores, calcula a distância entre o sensor e o objeto com base no tempo entre o envio (Trigger) e o retorno (Echo) do sinal.
fonte: http://cienciaemserrinha.blogspot.com.br/2016/09/crob-aula-25-sensores-ultrassonico.html
O inicio de transmissão ocorre com um pulso de 10 us, seguido por 8 pulsos de 40 KHz, ode o sensor aguarda o retorno, determinando uma distância por meio de uma equação onde:
Distância = (Tempo Echo * velocidade do som) /2

Conexão com o Arduino

A ligação do Arduino com o módulo sensor ultrassônico é bastante simples: no modulo são encontrados 4 pinos, VCC,  Trigger, ECHO e GND.
Abaixo um exemplo de ligação do módulo em um Arduino Uno.
fonte: próprio autor

Código fonte (exemplo)

//Teste Sensor Ultrassonico
//Elaboração: Tony Emerson Marim
//=== http://mecatronizar.blogspot.com.br ===
//
// Baseado no programa original de FILIPEFLOP
//Carrega a biblioteca do sensor ultrassonico
#include <Ultrasonic.h>
//Define os pinos para o trigger e echo
#define pino_trigger 2
#define pino_echo 3
//Inicializa o sensor nos pinos definidos acima
Ultrasonic ultrasonic(pino_trigger, pino_echo);
void setup()
{
  Serial.begin(9600);
  Serial.println("Lendo dados do sensor...");
}
void loop()
{
  //Le as informacoes do sensor, em cm e pol
  float cmMsec, inMsec;
  long microsec = ultrasonic.timing();
  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
  inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);
  //Exibe informacoes no serial monitor
  Serial.print("Distancia em cm: ");
  Serial.print(cmMsec);
  Serial.print(" - Distancia em milimetros: ");
  Serial.println((float)cmMsec*10.0);
  Serial.print(" - Distancia em polegadas: ");
  Serial.println(inMsec);
  delay(1000);
}

No código acima uma leitura de distância em três unidades diferentes centímetro, milímetro e polegada e imprime os valores medidos no monitor serial do Arduino.
Para o funcionamento ideal desse módulo, faz-se necessário declarar no código fonte uma biblioteca Ultrassonic.h, que estarei disponibilizando ao final do projeto.

fonte: próprio autor

Projeto medidor de distâncias

Vamos nesse projeto fazer uso de um sensor ultrassônico para funcionar como uma trena eletrônica fazendo medidas de objetos colocados à sua frente, e mostrando em um display LCD as distâncias medidas.
Os componentes usados para a construção do projeto são:
1 Aruino (estarei usando um Arduino nano nessa demonstração)
1 protoboard
1 módulo sensor HC-SR 04
1 visor LCD 16×2
1 potênciometro 10Kohm
1 transistor 2N2222 (NPN)
2 resistores 10Kohm
1 pushbutton
1 buzzer 5VCC
cabos jumper
fonte: próprio autor
Quando o botão for acionado sinais ultrassônicos são disparados pelo sensor até localizar um objetos e calcular o tempo de retorno exibindo o valor da distância.
Existe no projeto um transistor 2N2222 tipo NPN um resistor e um potenciômetro, ambos com uma resistência de 10Kohms, responsáveis para o funcionamento do display a cada leitura. Um buzzer faz com que o usuário se atente para uma condição onde o dispositivo fica fora do alcance para medição e o retorno de toda leitura vai ser demonstrada em um visor LCD 16X2.

Para o funcionamento do visor segue um tutorial simples da ligação de um visor LCD no arduino (tutorial) onde está disponível também informações sobre a biblioteca necessária para seu funcionamento.

Esquema de ligação

Seguindo o desenho abaixo todos os componentes necessários para o funcionamentos estão expostos como sugestão para o sistema.

fonte: próprio autor

O código fonte

//Medidor com Ultrassonico e LCD
//Elaboração: Tony Emerson Marim
//=== http://mecatronizar.blogspot.com.br ===
// Variáveis do processo
int l = 255;
int PINO_TRIGGER = 9;
int PINO_ECHO = 8;
#define BUTTON 10
#define LUMIN 7
#define PINO_TRIGGER 9
#define PINO_ECHO 8
#define NOTE_A4 440
// Bibliotecas utilizadas
#include <LiquidCrystal.h>
#include <Ultrasonic.h>
// Pinagem utilizada na biblioteca do LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
  pinMode(BUTTON, INPUT);
  pinMode(PINO_TRIGGER, OUTPUT );
  pinMode(PINO_ECHO, INPUT );
  pinMode(LUMIN, OUTPUT);
  Serial.begin( 115200 );
  Serial.println( "Ultrasonic ranging module: ");
  // Especificação de coluna e linha na LCD
  lcd.begin(16, 2);
}
void loop() {
while(digitalRead(BUTTON) == LOW) {             // Estado da leitura enquanto sinal baixo
  analogWrite(LUMIN, 0);
  lcd.clear();
  noTone(6);
}
analogWrite(LUMIN, l);
digitalWrite(PINO_TRIGGER, LOW);            // sinal baixo no pino Trigger
digitalWrite(PINO_TRIGGER, HIGH);        // envia pulso de 10us no pino
delayMicroseconds( 100 );
digitalWrite(PINO_TRIGGER, LOW);
long duration = pulseIn(PINO_ECHO, HIGH);
long r = 3.4 * duration / 2;            // Lógica matemática da distância
float distance = r / 100.00;
lcd.setCursor(0, 0);
lcd.print("tempo: ");
lcd.print(duration);
lcd.print(" us    ");
lcd.setCursor(0, 1);
if( duration > 38000 ) {
lcd.println("fora de alcance    ");
  tone(6, NOTE_A4);
}        // condição se duração for maior que 38ms para encontrar um obstáculo
else {
  lcd.print("dist: ");
  lcd.print(distance); lcd.println(" cm    "); noTone(6);
  }
delay( 5000 );                            // tempo ativo na LCD para leitura dos dados
}
Nesse circuito o sensor ultrassom de pois de enviar uma rajada de pulsos, calcula a distância do objeto e retorna o valor em unidades métricas para ser exibida pela LCD, que também recebe o tempo de retorno do trabalho executado. Caso o objeto esteja fora de alcance do sensor um sinal sonoro é emitido até que se torne possível encontrar o obstáculo.

fonte: prórpio autor

No vídeo abaixo é possível assistir uma demonstração do circuito em funcionamento.

Você pode encontrar para baixar a biblioteca do módulo Ultrasonic nesse LINK.
Caso seja necessário, todos os arquivos para realização do projeto encontra-se nesse LINK.

[FONTE]  http://www.mecatronizando.com.br/2016/10/medidor-de-distancias-arduino-lcd.html
Publicado em Deixe um comentário

TRANSMITINDO DADOS VIA LUZ USANDO LASER E ARDUINO

Atualmente alguns módulos laser permitem que os mesmos sejam controlados através de um pino de Sinal, ou seja, este mesmo pino torna possível injetar sinais no feixe de laser e utilizando-se de um receptor próprio, ou até mesmo em alguns casos uma célula fotovoltaica, é possível recuperar esses dados transmitidos por meio do feixe a vários metros de distância, quando se usa algum material para a propagação do feixe como, por exemplo, um cabo de fibra ótica há um menor risco de interferência e interrupção na comunicação, mas o princípio é o mesmo.
Já pensou como seria legal mandar mensagens, transmitir informações e até mesmo áudios através da luz? A Autocore Robótica mandou pra gente os módulos para podermos montar esse projeto e aqui vamos ensinar como fazer isso, não tudo porque áudio vai ficar para outro artigo, mas a parte de transmitir informações e mandar mensagens sim!

MATERIAL UTILIZADO:

– 2x Arduino                                          (Versão de sua preferência)
– Módulo Laser 650nm 6mm 5V       (link)
– Módulo Receptor Laser                    (link)

MONTAGEM:

TRANSMISSOR

Módulo Laser KY-008

Este módulo pode funcionar de duas formas, a primeira e mais comum é ele ligado o 5V no pino S e GND no pino (-), ou seja, ele estará sempre ligado, e bom, não é essa a ligação que precisamos, a ligação que precisamos você precisa fazer da seguinte forma:

Arduino Laser
D3 S
GND (-)
5V (+)

Ligado dessa forma temos o pino de sinal para transmitirmos qualquer coisa, lembrando que quando ligado dessa forma o laser ira parecer bem fraco se não houver algo no pino de sinal, então nada de pânico, ele não está estragado.
Quando é dito que pode ser injetado qualquer sinal, é literalmente qualquer sinal mas, claro, que não seja fora do que ele consegue trabalhar, vamos ao código.

CÓDIGO

A maneira mais simples e fácil de se transmitir dados através de um feixe de luz é a mesma para se transmitir através de um único fio, estou falando da comunicação série ou comunicação serial, em que os dados são enviados em uma sequência por um só fio, nesse caso, um só feixe.
Por se tratar de comunicação serial, vamos usar um código baseado no exemplo da biblioteca SoftwareSerial, pois queremos manter a porta Serial do Arduino livre para enviarmos o que quisermos.

  1. #include <SoftwareSerial.h>
  2. SoftwareSerial mySerial(2, 3); // RX, TX (Laser (S))
  3. void setup() {
  4. // Abre a serial para enviar dados
  5. Serial.begin(57600);
  6. while (!Serial) {
  7. ; // Espera para Arduinos com ATmega32u4 (USB Nativa)
  8. }
  9. Serial.println(“Envie o que quiser!”);
  10. mySerial.begin(4800);
  11. mySerial.println(“Hello world!”);
  12. }
  13. void loop() {
  14. if (Serial.available()) {
  15. mySerial.write(Serial.read());
  16. }
  17. }

 

 RECEPTOR

Não adianta nada um sistema transmitindo dados se você não consegue recebê-los, correto? Então vamos ao receptor! O receptor é bem simples de se utilizar, usaremos o mesmo programa do transmissor porém com pequenas mudanças, pois somente precisamos receber os dados que estão chegando pelo feixe do laser, então vamos a ligação:

Módulo Receptor Laser

O módulo receptor não tem mistério algum em sua ligação, basta ligar conforme os pinos escritos em seu corpo que não há erro, ou seja, pinos VCC, OUT e GND conectados no Arduino nos pinos 5V, D3 e GND, respectivamente. Então bastará apontar o feixe para a ponta do sensor, aquele componente parecido com um “transistor transparente” para que ele consiga receber o sinal corretamente. Devido a sua sensibilidade algumas vezes não preciso o laser estar apontado diretamente em seu centro para que o sinal consiga ser recebido. Vamos ao código:

  1. #include <SoftwareSerial.h>
  2. SoftwareSerial mySerial(3, 2); // RX (OUT do Receptor), TX
  3. void setup() {
  4. // Abre a serial para receber dados
  5. Serial.begin(57600);
  6. while (!Serial) {
  7. ; // Espera para Arduinos com ATmega32u4 (USB Nativa)
  8. }
  9. Serial.println(“Aguarde pelos dados.”);
  10. mySerial.begin(4800);
  11. }
  12. void loop() {
  13. if (mySerial.available()) {
  14. Serial.write(mySerial.read());
  15. }
  16. }

 CONCLUSÕES

É totalmente possível enviar dados por meio da luz utilizando o laser, porém devido a limitações construtivas, o laser ou seu sensor possui uma velocidade máxima em que é possível enviar dados sem que comece a aparecer erros, neste caso, nossos testes não conseguiram uma recuperação significativa de dados em velocidades acima de 38400bps, por isso recomendamos velocidades mais baixas.
Outro fator importante é o meio, bom, se você está transmitindo dados de grande importância você não vai querer erros ou que eles sejam corrompidos, certo? Então mandar dados em longa distância pelo ar não é muito seguro caso você queira isso, mas e se você possuir um cabo para guiar a luz até onde quer chegar? Eis que temos o princípio de comunicação da fibra óptica!
Agora é sua vez!!
Na Autocore Robótica você vai encontrar tudo que precisa para fazer este projeto e outros também disponíveis aqui no site, visita lá! https://www.autocorerobotica.com.br/

 

Publicado em Deixe um comentário

VOLTÍMETRO USANDO ARDUINO

 
Bom, vejo alguns projetos e dúvidas de pessoas que querem medir ou monitorar tensões maiores que 5V com qualquer Arduino, como todos devem saber, o conversor ADC do Arduino trabalha com tensão de no máximo 5V o que limita as medições a no máximo tal valor, logo, é preciso desenvolver algo para se trabalhar com tensões superiores.
 

MAS ANTES DE CONTINUARMOS, VAMOS A ALGUNS CONCEITOS:

VOLTÍMETRO

Aparelho utilizado para medir a diferença de potencial entre dois pontos; por esse motivo deve ser ligado sempre em paralelo com o trecho do circuito do qual se deseja obter a tensão elétrica. Para não atrapalhar o circuito, sua resistência interna deve ser muito alta, a maior possível.
Se sua resistência interna for muito alta, comparada às resistências do circuito, consideramos o aparelho como sendo ideal.
Os voltímetros podem medir tensões contínuas ou alternadas dependendo da qualidade do aparelho.
Voltímetro Ideal → Resistência interna infinita.
Fonte: InfoEscola

Sendo assim precisamos que nosso sistema de medição cause o menor impacto possível na fonte, ou origem, da tensão, para que este impacto seja o mínimo então precisaremos de uma alta resistência.

ENTÃO, COMO MEDIR?

Para este projeto definimos que queremos medir tensões de até 55V, além de ser um valor que facilita os cálculos normalmente é também uma tensão que atenderá aos mais variados projetos,  e para isso usaremos o método de Divisor de Tensão.
Como funciona um Divisor de Tensão:
O funcionamento do circuito é muito simples de compreender. Pela lei de Ohm a corrente total do circuito é definida por, onde Vo é tensão que irá para o Arduino, Vi a tensão da fonte e R1 e R2, os valores do primeiro e segundo resistor, respectivamente:

formula

Tenha sempre em mãos essa fórmula!

EXEMPLO:

Exemplo
Veja o circuito acima, temos que a entrada é 5V, R1 e R2 são resistores de 10kΩ, e na saída o valor é 2,5V, ou seja a metade da entrada, agora vamos provar que realmente a saída será a metade da entrada, o que no caso já dobraria a tensão máxima que o Arduino poderia ler, vamos aos cálculos:
Exemplo
Comprovamos que realmente teremos os 2.5V na saída se aplicarmos 5V na entrada, agora que vimos que o método realmente funciona, vamos a montagem final do circuito.

MONTAGEM

COMPONENTES NECESSÁRIOS:

1x – Arduino
1x – Display LCD 16×2 com módulo I2C
1x- Resistor de 100kΩ
1x – Resistor de 10kΩ
Protoboard e jumpers

FUNDAMENTO:

Lembra do conceito do voltímetro? Que ele deve possuir uma resistência alta para ter pouca influencia sobre a tensão a fim de se medir? Então, por isso temos que garantir que no circuito, mesmo na máxima tensão para que foi projetado, circule pouca corrente pelo Divisor, veja a seguir:
Circuito
Como pode ser visto, a corrente que irá circular quando funcionando na tensão máxima será de 500μA, tal corrente é tão pequena que não irá afetar a fonte de tensão a ser medida.

CIRCUITO

Os resistores são ligados em série, entre o resistor de 100kΩ e o de 10kΩ, o ligue ao pino A0 do Arduino.
Circuito
 

ATENÇÃO: OS NEGATIVOS SÃO COMUNS, NUNCA INVERTA A POLARIDADE!

PROGRAMANDO

O programa possui a mesma fórmula que usamos acima para calcular o valor de saída, porém de forma inversa para acharmos a tensão de entrada, assim temos:
Vi = Vo / (R2/(R1+R2))Vi = Vo / (R2/(R1+R2))
Já conhecida a formula bastou adaptá-la para tal função, onde o valor de entrada agora é o valor a ser achado em que ao se transpor a (R2/(R1+R2)) ele passa a dividir ao invés de multiplicar.

CÓDIGO

  1. //Display/
  2. #include <LiquidCrystal_I2C.h>
  3. #include “Wire.h”
  4. LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE);
  5. //Sensor de tensão//
  6. int analogInput = A0;
  7. float Vo = 0.0, Vi = 0.0;
  8. float value_aux = 0, value = 0;
  9. //Valores dos Resistores//
  10. float R1 = 100000.0; //Resistência R1 (100K) -veja no texto!
  11. float R2 = 10000.0; //Resistência R2 (10K) – veja no texto!
  12. void setup(){
  13. pinMode(analogInput, INPUT);
  14. lcd.begin(16, 2);
  15. lcd.setBacklight(HIGH);
  16. lcd.setCursor(2,0);
  17. lcd.print(“Voltimetro DC”);
  18. lcd.setCursor(14,1);
  19. lcd.print(“V”);
  20. }void loop(){
  21. //Aquisição
  22. for(int i=60;i>0;i–){
  23. value_aux = analogRead(analogInput);
  24. value += pow(value_aux,2);
  25. }
  26. value = sqrt(value/60);
  27. Vo = (value * 5.0) / 1023.0;
  28. Vi = Vo / (R2/(R1+R2));
  29. if (Vi<0.09) {Vi=0.0;} //Filtrando medições errôneas!
  30. lcd.setCursor(5,1);
  31. lcd.print(” “);
  32. lcd.setCursor(5,1);
  33. lcd.print(Vi);
  34. delay(500);
  35. }
  1. //Display/
  2. #include <LiquidCrystal_I2C.h>
  3. #include “Wire.h”
  4. LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE);
  5. //Sensor de tensão//
  6. int analogInput = A0;
  7. float Vo = 0.0, Vi = 0.0;
  8. float value_aux = 0, value = 0;
  9. //Valores dos Resistores//
  10. float R1 = 100000.0; //Resistência R1 (100K) -veja no texto!
  11. float R2 = 10000.0; //Resistência R2 (10K) – veja no texto!
  12. void setup(){
  13. pinMode(analogInput, INPUT);
  14. lcd.begin(16, 2);
  15. lcd.setBacklight(HIGH);
  16. lcd.setCursor(2,0);
  17. lcd.print(“Voltimetro DC”);
  18. lcd.setCursor(14,1);
  19. lcd.print(“V”);
  20. }void loop(){
  21. //Aquisição
  22. for(int i=60;i>0;i–){
  23. value_aux = analogRead(analogInput);
  24. value += pow(value_aux,2);
  25. }
  26. value = sqrt(value/60);
  27. Vo = (value * 5.0) / 1023.0;
  28. Vi = Vo / (R2/(R1+R2));
  29. if (Vi<0.09) {Vi=0.0;} //Filtrando medições errôneas!
  30. lcd.setCursor(5,1);
  31. lcd.print(” “);
  32. lcd.setCursor(5,1);
  33. lcd.print(Vi);
  34. delay(500);
  35. }

 

MELHORANDO SEUS RESULTADOS

Na eletrônica se sabe que os resistores sempre tem uma variação, ou seja, uma margem de erro e que seu valor real nem sempre é o valor nominal. Para melhorar seus resultados você pode fazer o seguinte procedimento:

1 – MEÇA SEUS RESISTORES


Ao medir seus resistores você irá trabalhar com valores (próximos aos) reais, fazendo com o que valor mostrado no resultado esteja ainda mais preciso.

2 – SIMULE COM OS NOVOS VALORES

1
Ao simular com os valores obtidos no passo anterior você garante que o medidor ainda pode ou não ir até o mesmo limite que foi projetado, de modo que a tensão na saída sempre seja de no máximo 5V, no meu caso, por exemplo, a máxima tensão que eu poderia medir era de 52V, como pode ser visto acima, caso aplicasse os 55V a tensão na saída seria ligeiramente superior a 5V.

3 – ALTERE O CÓDIGO

Agora que você já tem seus novos valores para as resistências basta trocar no código.

  1. //Valores dos Resistores//
  2. float R1 = 92700.0; //92700 Resistência R1 (100K)
  3. float R2 = 9600.0; //9600 Resistência R2 (10K)
  1. //Valores dos Resistores//
  2. float R1 = 92700.0; //92700 Resistência R1 (100K)
  3. float R2 = 9600.0; //9600 Resistência R2 (10K)

[Fonte] https://www.zonamaker.com.br/voltimetro-usando-arduino/

Publicado em Deixe um comentário

Interfacing o Arduino no modem USB GPRS

Modem GPRS barato da Dealextreme

Modem GPRS barato da Dealextreme

Para explorar a funcionalidade deste dispositivo eu escrevi um programa simples que é baseado no terminal Xbee . O programa inicializa o PL-2303 e aguarda a entrada do usuário passando as teclas para o modem e exibindo respostas para a tela. Vamos executá-lo e ver do que este pequeno modem é capaz.
O arranjo de hardware é mostrado na imagem do título. Durante a operação normal, o sistema pode ser alimentado por USB; dependendo da sua placa Arduino você pode precisar desconectar o modem durante a programação. Todas as interações ocorrem via emulador de terminal rodando em um PC – eu uso massa no Windows e minicom no Linux. Usar o monitor serial incorporado no Arduino IDE não é recomendado. O modem precisa de cartão SIM ativado para funcionar, eu uso SIM pré-pago da T-Mobile e também o usei com sucesso com a AT & T.
Se tudo estiver conectado corretamente, o esboço gerará o seguinte:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
Começar
PL Init
Addr: 1
NC: 1
0000: 09 02 27 00 01 01 00 A0 FA 09 04 00 00 03 FF 00
0010: 00 00 07 05 81 03 0A 00 01 07 05 02 02 40 00 00
0020: 07 05 83 02 40 00 00 Conf.Val: 01
Iface Num: 00
Alt. Set: 00
Descritor de ponto final:
Comprimento: 07
Tipo: 05
Endereço: 81
Atributos: 03
MaxPktSize: 000A
Enquete: 01
Conf.Val: 01
Iface Num: 00
Alt. Set: 00
Descritor de ponto final:
Comprimento: 07
Tipo: 05
Endereço: 02
Atributos: 02
MaxPktSize: 0040
Poll Intrv: 00
Conf.Val: 01
Iface Num: 00
Alt. Set: 00
Descritor de ponto final:
Comprimento: 07
Tipo: 05
Endereço: 83
Atributos: 02
MaxPktSize: 0040
Poll Intrv: 00
Conf: 1
PL configurado

A última mensagem (linha 38) mostra que o PL-2303 foi reconhecido e configurado com sucesso. Digite atno teclado e pressione Enter. Se você vir OKna próxima linha, o modem está ativo e respondendo.

...
Conf: 1
PL configurado
a
Está bem

Agora vamos ver se um modem está conectado a uma rede. Digite at+creg?e pressione Enter:

em + creg?
+ CREG: 0, 1
 
Está bem

O segundo número em resposta indica o estado do registro. Minha saída (1) significa que o modem está felizmente registrado na rede doméstica. Outros números que você pode ver são “0” – sem serviço, “2” – procurando operador, “3” – registro negado.
Se o modem estiver registrado, é possível determinar o operador da célula:

no + cops?
+ COPS: 0,0, "T-Mobile 260"
 
Está bem

Quando o modem está online, podemos fazer algo útil. Eu já enviei várias mensagens de texto para este número, vamos dar uma olhada nelas usando o +CMGLcomando:

em + cmgl = 1
+ CMGL: 1,1, 50
07912160130320F8040B919127163673F500001101814190044A23F3F61C6496BFDBA0F3FB7D6697152D503BACAFCBDF76C0B91D4EB35DE3771B
+ CMGL: 2,1, 57
07912160130320F5040B919127163673F500001101814124244A2B66F9BB0D3ABFDF677619447F83885850FB4D2EB7152D503BACAFCBDF76C0B91D4EB35DE3771B
+ CMGL: 3,1, 53
07912160130320F8000B919127163673F500001101817184554A26F4F29C0E9A81CCF2771B747EBFCFECB2A2056A87F575F9DB0E38B7C369B66BFC6E03
+ CMGL: 4,1, 53
07912160130320F8040B919127163673F500001101817145154A26F4F29C0EA281CCF2771B747EBFCFECB2A2056A87F575F9DB0E38B7C369B66BFC6E03
 
Está bem

O que você vê é emitido no formato PDU. Muitos dispositivos GSM têm esse formato ativado na inicialização. Tudo bem com computadores, mas não é tão fácil para humanos. Felizmente para nós, este modem também suporta o modo de texto SMS, que pode ser ativado usando o +CMGFcomando:

a + cmgf = 1
Está bem
em + cmgl = "ALL"
+ CMGL: 1, "REC READ", "19725555555" ,, "11/10 / 18,14: 09: 40-36", 145,35
sms do google
               - m ... v@gmail.com
+ CMGL: 2, "REC READ", "19725555555" ,, "11/10 / 18,14: 42: 42-36", 145,43
do google ao modem DX
                       - m ... v@gmail.com
+ CMGL: 3, "REC READ", "19725555555" ,, "11/10 / 18,17: 48: 55-36", 145,38
teste 3 do google
                  - m ... v@gmail.com
+ CMGL: 4, "REC READ", "19725555555" ,, "11/10 / 18,17: 54: 51-36", 145,38
teste 4 do google
                  - m ... v@gmail.com
 
Está bem

O envio de mensagens também é fácil. Isso é feito usando o +CMGScomando. O comando considera o número de telefone do destinatário como um parâmetro e gera um prompt no qual uma mensagem pode ser digitada. O fim da mensagem é indicado pressionando Ctrl+z, certifique-se de que seu programa de terminal passe este código inalterado para o modem (a massa funciona corretamente aqui). Aqui está um exemplo:

em + cmgs = "19725555555"
> teste da T-Mobile para o google
>
+ CMGS: 34
 
Está bem

Há muito mais que pode ser feito com este pequeno modem (ou para qualquer telefone GSM). Algumas coisas, como fazer ou receber chamadas, são bem fáceis de fazer, enquanto outras, como acessar a Internet, exigiriam alguma programação extra. Nas próximas semanas, estou planejando desenvolver código para dar suporte a um telefone celular no modo autônomo; Nesse meio tempo, tente falar com seu telefone via terminal e deixe-me saber se você tem algum problema.
Oleg.

[Fonte] https://www.circuitsathome.com/mcu/interfacing-arduino-to-usb-gprs-modem/

Publicado em Deixe um comentário

JARDIM MONITOR COM ARDUÍNO.

Introduction: Arduino Plant Monitor

Picture of Arduino Plant Monitor
Picture of Arduino Plant Monitor
It can be hard enough to keep your plants alive and healthy if you dont have time to water them. It gets even harder if you are a trying to plant different species that requires different climats conditions.
The Idea with this build is to make a seedstarter / mini-Greenhouse where i can mimic the necessary conditions for different plants.
Every one of my plants, have a special watering / lightning and temperature needs. The requirements of each one are stored in a database, and the plant is monitored through 3 sensors (Light / Temperature / moisture). Whenever a sensor register a value bellow the saved threshold the Arduino reacts, by turning the water pumps, lightning or the fan to cool the plant.
The plants can be monitored online as well. In my setup i have 16 plants. To make this Instructables short and clear i am not going into details explaining how software and hardware works, instead i will link to Instructables, that can explain topics. I will also share Both my code and schematics, which are commented.
Enjoy, and please remember to comment if you have any suggestions and ideas …. and if you like my Instructable project, please vote for my entry to the contest:)
( I will keep editing the Instructables over the next couple of days, uploading my code and so on 🙂
PS: the plants shown on the picture, were not grown by using the setup-up (It is not that quick qrowing plants !) it is just for the showing the end result.

Step 1: List of Materials

Picture of List of Materials
Here is what you needs :
Micro-Sprinklers, 20 nozzles, 10 meter hose – 8.90 USD
Storage Plastic box, 45 L, 56x39x28 cm – 5.73 USD
Mini Water pump DC 3-12V RS-360SH – 3.94 USD
Normally close, solenoid valve, 12 V – 5.2 USD
Ultrasonic Module HC-SR04 – 1.21 USD
Photoresistor Sensor Module – 0,99 USD
Arduino mega 2560 – 6 USD
Adafruit CC3000 wifi module – 44 USD
74HC595 shift registers – 1 USD for 10 pieces
74HC4051 multiplexers – 1,85 USD for 10 pieces
16 channel 12 V Relay – 12,52 USD
NPN resistor – 1,35 USD for 5 pieces
moisture sensor – 1,12 USD
PCB manifacturing – 17 USD ( you get 10 copies ! )
Aquarium Plastic tube, 3 meter – 2,89 USD
many x wires and connectors

Step 2: The Frame and Earth Trays

Picture of The Frame and Earth Trays
The Frame:
The frame it self is made of an old IKEA Expedit, the one i had laying around had 16 holes in it, which was great for what i intended to do. It wasn’t manipulated what so ever. Every square was 39x39x39 cm, large enough to starting a grow of a plant.
Cost : I had stuff so i used – 0 USD ( A new IKEA Expedit – 82 USD )
The Trays:
The trays were made from som cardboard, i cut it so it could fit inside the boxes of the closet, and the cardboard pieces were taped together. The cardboard tray was then set inside a plastic bag, to make it water resistant and then filled with some earth.
Cost : I had stuff so i used – 0 USD

Step 3: Watering Sprinklers

Picture of Watering Sprinklers
Watering Sprinklers:
I was quite in doubt here on how to proceed , there are different options, starting by just setting the water tube into the tray and let the water run or use something to spray the plat from above. I decided to go with the second Option.
I found some Micro Sprinklers in E-bay, They seemed fine since they only sprayed on a small area, so the wall of my boxes didn’t became wet. Once received, the holes of the sprinklers were too narrow for my low pressure pumps so i had to make the hole a bit bigger using a drill, i went with 1 mm hole, that worked fine. Then i secured the sprinkles at the top of every box with some wires and staples.
Cost : Micro-Sprinklers, 20 nozzles, 10 meter hose – 8.90 USD

Step 4: The Water Container

Picture of The Water Container
The Water Container:
The water container is made of a storage plastic box from IKEA, The box holdes 45 L. In the cover i cut holes with my soldering iron according to the placement of my pumps. That way the wiring of the pumps was outside the box.
Cost : Storage Plastic box, 45 L, 56x39x28 cm – 5.73 USD
The Pumps:
For the pumps i chose 3-12V low pressure pumps, although they are a bit noisy, but it wasn’t that bad, and they worked as they should. The pumps were secured to a piece of wood of the length of the water container, and went through the holes that were cut in the cover of the plastic container cover.
Cost : Mini Water pump DC 3-12V RS-360SH – 3.94 USD ( I used 16 of these = 63 USD )

Step 5: Adding Filling Valve and Ultrasonic Sensor

Picture of Adding Filling Valve and Ultrasonic Sensor
The Filling valve:
The Filling valve is a normally close 12 V solenoid valve. At the side of the plastic container i cut a hole with my soldering iron, and the valve is secured with a wire and glued with a glue gun. The Valve is then Attached to a watering hose.
Cost : Normally close, solenoid valve, 12 V – 5.2 USD
The Ultrasonic Sensor:
For automatic refilling the container, i had to know to level of the water. To achieve that, a couple of options are available. You can either use a water sensor with a couple of wires or use a Ultrasonic sensor. I went with the second option as i found it more reliable. I cut a couple of holes at the cover of my plastic container and then i secured the Ultrasonic sensor to it with a glue gun.
Cost : Ultrasonic Module HC-SR04 – 1.21 USD
se this instructable for more details about measuring water level

Step 6: The Software : the Web Interface

Picture of The Software : the Web Interface
The Web Interface:
I wanted to be able to control the growth of my plants through my plants and also be able to follow the statistics of every plant. I am no programmer, so surely the code can be written more effectively, but it works !.
The website is programmed through JQuery/PHP and i used a MySQL Database. The website is hosted at 000webhost.com which is a free web hosting service. I wont go into details of explaining the code, but i will be listing the function of pages i have. I will attach my code here so it can be used freely.
Index.php
The index page, listes the plants i have, their picture and name, date of planting and the remaining days to harvest. It simply reads the database and displays it.
Details.php
The detail page, shows information about the chosen plants, here it displays the last read sensor value from the moisture, temperature and light sensors, the values are read by connecting to thingspeak.com. in addition to that i have toggle switches to manually activate the water pump, the growing light and the fan.
Stats.php
The stats page shows the values mesured by my sensors. The values are presented in a chart. The values are read by connecting to thingspeak.com. There i made a channel of every plant. Every channel have 3 fields; moisture, temperature, light.
Info.php
The info page shows different informations about the plant.

Step 7: The Software : the Arduino

Picture of The Software : the Arduino
The Arduino software:
The hardest part for me was the electronics and the coding for the Arduino, as i mentioned earlier i am no programmer, so i had to make a lot of research and many questions at the Arduino forum. A Special thanks for Kurt Mckelvey, who helped with some good advices.
I am not planning to go through my code here, as i am going to attach it here and share it, but i will just explain the logic behind it.
In the loop section, the program starts by connection to the internet through the wifi module, then reads the sensors values through the multiplexers, and then upload the values to the thingspeak.com website, then those values are compared to each plants needs, if the program findes it necessary the pumps are turned on, so the plants gets water, light and air according to its need. Those are turned on though a shift register. Between every second watering, the ultrasonic sensor measures the depth of water inside the container, and then open the solenoid valve if the water level is low. The internet connection is then closed. The cycle runs 3 times a day.
Se This tutorial to understand more about shift registers, and this tutorial to know more about multiplexers.

Step 8: The Electronics

Picture of The Electronics
The Electronics:
That was a confusing part, and needed a lot of research, a journey where i learned a lot of stuff, and this was a big reward itself. At the beginning, i was only thinking about making a project involving moisture sensors for 32 plants, and as the project evolved and got a bigger picture, the light and temperature sensors idea emerged. I had also a better idea on how to optimise the hole settings. Unfortunately i am only going to share my old hardware involving the first set-up, since i want to want to add my project to contests, and i did not receive the parts for the light and temperature just yet.
I am sure this part will confuse alot of people,sorry for that, but as soon as i will get the boards and solder, i will update this step.
I had a lot of trial and errors soldering the parts, and due to the many connection of the shift-registers and the multiplexers and lot of wires i got confused. The solution to that was to make a PCB, that was a totally new field to me. After a bit of research i made my self familiar with the Eagle software, i drew the schematics and then sent it to manufacturing though dirtypcbs.com, a cheap, and reliable service.
Costs :
1 x Arduino mega 2560 – 6 USD
1 x Adafruit CC3000 wifi module – 44 USD
4 x 74HC595 shift registers – 1 USD for 10 pieces
5 x 74HC4051 multiplexers – 1,85 USD for 10 pieces
2 x 16 channel 12 V Relay – 12,52 USD each
1 x NPN resistor – 1,35 USD for 5 pieces
32 x moisture sensor – 1,12 USD Each ( 35,84 USD )
many x wires and connectors
PCB manifacturing – 17 USD ( you get 10 copies ! )
Shift registers and multiplexers:
I went with an Arduino Mega due to the many pins needed. In hope for decreasing the number of the digital pins i used 4 shiftregisters, that way 3 Arduino pins allowed me to control 32 water pumps, and for the analog pins i used 5 multiplexers, 1 Master, and 4 slaves, that way using 6 digital and 1 analog pin of my Arduino i could control 32 sensor inputs.
Wifi and moisture sensors:
I used the Adafruit CC3000 wifi module. For the moisture sensors i used 32 cheap moisture sensors, To avoid corrosion of my sensors i used a transistor, so the moisture sensors are only powered when the reading takes place.
Relay:
The pumps and solenoid valve are connected to the Arduino though 2, 16 channels, 12V relays.

Step 9: Testing

Here i am sharing a bit of my testing of the fan, the water pumps and the lights though my relays. Sorry for the quality of the video. I was using my Gopro, so a bit difficult to sight when you don’t have a screen. But anyway it is showing the Concept 🙂

Step 10: Final Thoughts

Many people will ask, why bother about conventional “farming” when there are many alternativs out there, i am talking about aeroponics, hydroponics, aquaponics .. ect, True, those methods are easy to use, and garantie good results, the problem is that you cannot monitor every plant for it self and give it its necessary requirement of moisture, humidity, lightning. Specially if you have special variaties of plants as i have.
This project has been a big learning experience for me, alot of trial and errors and frustration, but at last, it worked. i would like to share some of my thoughts and also what i think could be upgraded.
– The wooden frame : I guess Building it with plastic woud be more effective, specially because of the moisture, and Water splashes. also it would be a good idea to add coverings at the front and the back to totally isolate the single plants.
– The Water container : it was a bad idea to place it at the top of the wooden frame, as the Water keeps dripping of the sprinkles because of the gravity effekt, so i had it removed to the bottom.
– The Hardware and software : Not doubt this is where the biggeste improvement can be done, for the software, more efficiant functions would be nice, the software as it is Works as it should, stable. But improvement can absolutly be done. For the Hardware, improvements can be done as well, i think in my next version i will go with a shift register that controls multiplexers instead of having master and slave multiplexers, i believe that would be more effective.
 Building a box for the arduino and the Electronics.
– All in all, i guess it would be a nice trick to designe it a “node” way, i mean that you can add “components to the main module without new code. lets say you have 5 plants, and you want to add 2 more, then you can just add to new boxes and every thing will Work. I guess i have to think about how it can be done,. Any suggestions are welcome 🙂

[FONTE]  http://www.instructables.com/id/Arduino-Plant-Monitor/

Publicado em Deixe um comentário

Servidor Web WiFi

Neste exemplo, você usará seu WiFi Shield e seu Arduino para criar um servidor Web simples. Usando a biblioteca WiFi , seu dispositivo poderá responder a uma solicitação HTTP com seu escudo WiFI . Depois de abrir um navegador e navegar para o endereço IP do seu escudo Wi-Fi , seu Arduino responderá com apenas HTML suficiente para que um navegador exiba os valores de entrada de todos os seis pinos analógicos.
Este exemplo é escrito para uma rede usando criptografia WPA. Para WEP ou WPA, altere a chamada Wifi.begin () de acordo.

Hardware necessário

  • Escudo Wi-Fi Arduino
  • Placa Arduino compatível com escudo
  • (opcional) Seis sensores analógicos conectados ao Analógico em pinos 0-5

O circuito

O escudo WiFi usa os pinos 10, 11, 12 e 13 para a conexão SPI ao módulo HDG104 . O pino digital 4 é usado para controlar o pino de seleção do escravo no cartão SD.
Você deve ter acesso a uma rede sem fio 802.11b / g que se conecta à Internet para este exemplo. Você precisará alterar as configurações de rede no esboço para corresponder às suas redes SSID específicas.
Para redes que usam criptografia pessoal WPA / WPA2 , você precisa do SSID e da senha. O escudo não se conectará a redes usando a criptografia WPA2Enterprise.
As senhas de rede WEP são seqüências de caracteres hexadecimais conhecidas como chaves. Uma rede WEP pode ter 4 chaves diferentes; cada chave recebe um valor “Índice de chaves”. Para redes criptografadas com WEP, você precisa do SSID, da chave e do número da chave.

imagem desenvolvida usando Fritzing . Para mais exemplos de circuitos, veja a página do projeto Fritzing
Na imagem acima, o Arduino seria empilhado abaixo do escudo WiFi .

Atenção

Este exemplo não requer um cartão SD. Se um cartão SD for inserido, mas não usado, é possível que o esboço seja interrompido, pois o pino 4 é usado como SS (ativo baixo) do SD e, quando não usado, ele é configurado como INPUT por padrão. Duas soluções possíveis:

  • remova o cartão SD;
  • adicione estas linhas de código no setup ()
pinMode OUTPUT 
digitalWrite ALTO ;

Código:

/ * 
  WiFi Web Server 
 Um servidor web simples que mostra o valor dos pinos de entrada analógica. 
 usando um escudo WiFi. 
 Este exemplo é escrito para uma rede usando criptografia WPA. Para 
 WEP ou WPA, altere a chamada Wifi.begin () de acordo. 
 Circuito: 
 * Escudo WiFi anexado 
 * Entradas analógicas anexadas aos pinos A0 a A5 (opcional) 
 criadas em 13 de julho de 2010 
 por dlf (Metodo2 srl) 
 modificado em 31 de maio de 2012 
 por Tom Igoe 
 * / 

#include <SPI.h> 
#include <WiFi.h > 
char ssid “sua rede”      // sua rede SSID (nome) 
char pass [“secretPassword”   // sua senha de rede 
int keyIndex                 // seu número de índice da chave da rede (necessário somente para WEP) 
int status = WL_IDLE_STATUS 
Servidor WiFiServer 80 
void setup 
// Inicializa serial e espera que a porta abra: 
Serial . começar 9600 
while Serial 
; // espera que a porta serial se conecte. Necessário apenas para Leonardo 

// verifique a presença do escudo: 
if ( WiFi. Status == WL_NO_SHIELD 
Serial . println “escudo WiFi não presente” 
// não continue: 
while true 

// tenta conectar-se à rede Wi-Fi: 
while ( status ! = WL_CONNECTED 
Serial . print “Tentando se conectar ao SSID:” )
Serial . println ( ssid 
// Conecte-se à rede WPA / WPA2. Altere esta linha se estiver usando rede aberta ou WEP:    
    status = WiFi. começar ( ssid , passar 
// aguarde 10 segundos para conexão: 
delay 10000 
}
  servidor. begin 
// você está conectado agora, então imprima o status:
  printWifiStatus 

void loop {
// ouve os clientes de entrada
  WiFiClient client = server. disponível 
if ( cliente 
Serial . println “novo cliente” 
// uma solicitação http termina com uma linha em branco 
booleana currentLineIsBlank true 
while ( client. connected 
if ( cliente. disponível 
char c = cliente.ler 
Serial . escrever ( c 
// se você chegou ao final da linha (recebeu um 
caractere // de nova linha ) e a linha está em branco, a solicitação http foi encerrada, 
// para que você possa enviar uma resposta 
se ( c == ‘ \ n ‘ && currentLineIsBlank 
// envia um
          cliente de cabeçalho de resposta HTTP padrão . println “HTTP / 1.1 200 OK” 
          cliente. println “Tipo de Conteúdo: text / html” ;
          cliente. println “Conexão: fechar”  // a conexão será fechada após a conclusão do
          cliente de resposta . println “Atualizar: 5”  // atualiza a página automaticamente a cada 5 segundos do
          cliente. println 
          cliente. println “<! DOCTYPE HTML>” 
          cliente. println “<html>” 
// saída do valor de cada pino de entrada analógica 
para int analogChannel = analogChannel analogChannel ++ 
int sensorReading analogRead ( analogChannel 
            cliente. impressão “entrada analógica” 
            cliente. impressão ( analogChannel 
            cliente. print “é” 
            cliente. impressão ( sensorReading 
            cliente. println (“<br />” 
}
          cliente. println “</ html>” 
pausa 

if ( c == ‘ \ n ‘ 
// você está iniciando uma nova linha
          currentLineIsBlank true 

else if ( c ! = ‘ \ r ‘ 
// você obteve um caracter na linha atual
          currentLineIsBlank false 


}
// fornece ao navegador da web tempo para receber o 
atraso de dados 
// fecha a conexão:
    client. stop 
Serial . println “cliente desassociado” 


void printWifiStatus 
// imprime o SSID da rede à qual você está conectado: 
Serial . print “SSID:” 
Serial . println ( WiFi. SSID ;
// imprima o endereço IP do seu escudo WiFi:
  IPAddress ip = WiFi. localIP 
Serial . print “endereço IP:” 
Serial . println ( ip 
// imprime a intensidade do sinal recebido: 
long rssi = WiFi. RSSI 
Serial . print “intensidade do sinal (RSSI):” 
Serial . impressão ( rssi 
Serial .println “dBm” 
}

Veja também:

 
[Fonte]

Publicado em Deixe um comentário

Web Server com o módulo ESP8266 NodeMCU e DHT22

módulo ESP8266 NodeMCU é uma placa da família ESP8266, sendo umas das mais completas e simples de usar. Neste post vamos mostrar como utilizar essa placa para criar um web server e enviar dados do sensor de temperatura DHT22.

Módulo Wifi ESP8266 NodeMCU
O módulo ESP8266 NodeMCU já tem incorporado um módulo ESP12-E com antena embutida, e ainda conta com um conversor USB-TTL (CH340), facilitando a comunicação e transferência de programas.
Além disso tem um formato que facilita o uso em uma protoboard, permitindo acesso às 11 portas (GPIO) do módulo. Tudo isso significa que você não vai precisar de um microcontrolador adicional como o Arduino, PIC ou Raspberry para criar os seus projetos.

Pinagem módulo NodeMCU

A imagem abaixo ilustra a pinagem do módulo ESP8266 NodeMCU. Com ele podemos usar os pinos da mesma maneira que usamos, por exemplo, no Arduino, com interface SPI, I2C, PWM, etc. Temos ainda os botões RST (Reset) e o Flash, utilizado para upgrade de firmware do módulo.

NodeMCU - Pinagem
O conector de alimentação é micro-usb, e serve também para comunicação com o computador. A programação pode tanto ser feita em Lua, como também com a própria IDE do Arduino, com algumas modificações na parte de gerenciamento da placa.
A instalação do módulo ESP8266 NodeMCU no Windows foi feita de forma automática, com o módulo sendo reconhecido na porta COM13 como um dispositivo USB-Serial CH340. Caso seja necessário, você encontra os drivers para o CH340 neste link.

Instalação do ESPlorer

O programa que vamos utilizar neste post foi feito em Lua, e para enviar este programa para o ESP8266 NodeMCU vamos precisar de um aplicativo que faça essa comunicação com o módulo. Um dos mais usados é o ESPlorer, que você pode baixar neste link. Com o ESPlorer a criação e transferência de programas para o módulo ESP8266 é bastante simplificada, e você tem a opção de salvar programas, enviar comandos especiais ao módulo, resetar, formatar, etc.
O programa não precisa de instalação, e basta você executar o arquivo ESPlorer.bat para que a interface seja carregada. A única exigência é a presença do java (download) na máquina.
Na tela principal, temos do lado esquerdo a área de programação, e do lado direito uma console, onde é mostrado o status de comunicação com o módulo, assim como eventuais avisos e mensagens de erro.
ESPlorer - Tela Principal
Para fazer a comunicação com o módulo NodeMCU selecione a porta COM na parte superior do ESPlorer (no nosso caso, a COM13), selecione a velocidade de comunicação (padrão 9600) e clique em Open:
ESPlorer - Conexão Serial
Pressione o botão RST do módulo e, se estiver tudo ok, o mesmo deve responder com as informações básicas referentes ao firmware instalado:
ESPlorer - ESP8266 conectado
Com o ESPlorer configurado e o módulo funcionando, podemos agora montar o circuito que vai coletar as informações de um sensor de temperatura DHT22 e enviar para uma página web.

Circuito módulo ESP8266 NodeMCU

Monte o circuito abaixo, conectando o pino de dados do DHT22 à porta 4 do NodeMCU (GPIO02). A alimentação do sensor de temperatura será feita pelos pinos 3.3V e GND do módulo.
NodeMCU sensor de temperatura DHT22
Isso é tudo que precisamos na parte do hardware. Conecte agora o cabo micro-usb ao NodeMCU para ligar o circuito e iniciar o processo de transferência de programas.

Instalação biblioteca DHT22 Lua

Antes de transferir o programa que vai criar o webserver no módulo NodeMCU, precisamos da biblioteca do DHT22 para o Lua. Para instalar a biblioteca, acesse este link, e clique sobre o arquivo dht22_min.lua:

Biblioteca DHT22 Lua

Na tela seguinte, selecione a opção RAW, no canto direito da página

O código da biblioteca, “limpo”, será exibido no browser. Copie todo o código e cole no ESPlorer, de preferência em uma nova aba. Em seguida, clique em Save to ESP:

DHT22 Lua Library

Na janela seguinte, coloque o nome do arquivo como dht22_min.lua e clique em Save.

Biblioteca - Save

O programa será então gravado localmente na sua máquina, e também transferido para o ESP8266 NodeMCU.
Vamos conferir para ver se o arquivo está lá mesmo ? No ESPlorer, acesse a aba Commands, depois clique em List files:

ESPlorer - Listar arquivos

Acompanhe o resultado na console, indicando que o arquivo dht22_min.lua foi transferido corretamente:

NodeMCU - Arquivos

Programa Web Server com DHT22

Agora copie o programa abaixo em uma nova aba do ESPlorer. Ele faz a leitura dos dados do DHT22 e cria um web server para exibição de uma página com as informações de temperatura e umidade. Na linha 7, troque os campos NOME_REDE e SENHA_REDE pelas informações da rede wifi à qual o módulo vai se conectar.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
-- Programa: Web Server com ESP8266 NodeMCU e DHT22
-- Autor: Arduino e Cia
-- Baseado no programa original de www.beerandchips.net
-- Define as configuracoes de rede
wifi.setmode(wifi.STATION)
wifi.sta.config("NOME_REDE","SENHA_REDE")
wifi.sta.connect()
-- Definicao de pino do DHT22
PIN = 4 --  data pin, GPIO2
dht22 = require("dht22_min")
chipserial = node.chipid()
-- Cria e roda o web server
srv=net.createServer(net.TCP, 4)
print("Server created on " .. wifi.sta.getip())
srv:listen(80,function(conn)
conn:on("receive",function(conn,request)
print(request)
-- Le as informacoes do sensor de temperatura
dht22.read(PIN)
t = dht22.getTemperature()
h = dht22.getHumidity()
conn:send('<html>')
conn:send('<title>NodeMCU - Arduino e Cia</title></head>')
conn:send('<meta http-equiv="refresh" content="5">')
conn:send('<body bgcolor=\"#ffffff\">')
conn:send('<center>')
conn:send('<table bgcolor=\"#0000ff\" width=\"90%\" border=\"0\">')
conn:send('<tr>')
conn:send('  <td><font size=\"3\" face=\"arial, helvetica\" color=\"#ffffff\"><center>Temperatura</center></font></td>')
conn:send('</tr>')
conn:send('<tr>')
conn:send('  <td><font size=\"7\" face=\"arial, helvetica\" color=\"#ffffff\"><center>'..((t-(t % 10)) / 10).."."..(t % 10)..'&deg;C</center></font></td>')
conn:send('</tr>')
conn:send('<tr>')
conn:send('  <td><font size=\"3\" face=\"arial, helvetica\" color=\"#ffffff\"><center>Umidade</center></font></td>')
conn:send('</tr>')
conn:send('<tr>')
conn:send('  <td><font size=\"5\" face=\"arial, helvetica\" color=\"#ffffff\"><center>'..((h - (h % 10)) / 10).."."..(h % 10)..'%</center></font></td>')
conn:send('</tr>')
conn:send('</table>')
conn:send('</center>')
conn:send('</body></html>')
end)

Pressione a tecla Send to ESP e aguarde até que o programa seja transferido.
Para a parte final, que é o teste em um browser, vamos precisar do endereço IP atribuído ao módulo. Na caixa de seleção do lado direito, abaixo da console, escolhe a opção =wifi.sta.getip() e clique em Send. O endereço IP será exibido na console. No nosso caso, o endereço IP recebido foi 10.0.0.110:

ESPlorer - wifi.sta.getip

Utilize este IP em um browser, digitando-o na barra de endereços. Em poucos instantes as informações de temperatura e umidade do DHT22 serão enviadas pela placa:

Browser Temperatura e Umidade NodeMCU DHT22
Publicado em Deixe um comentário

Módulo Wireless ESP8266 com Arduino

Com o Módulo Wireless ESP8266 você pode conectar o seu Arduino nas redes wireless 802.11 b/g/n, enviando e recebendo dados nos modos AP (Access Point/Ponto de acesso) e STA (Station), e neste tutorial vamos mostrar como configurar esse módulo como web server, enviando dados para um browser.
Módulo Wireless ESP8266
Esse módulo se comunica com o microcontrolador utilizando interface serial e seu firmware pode ser atualizado, se necessário. Possui ainda 2 pinos GPIO (General Purpose Input Output, ou Entrada e Saída de uso geral), permitindo que o módulo seja programado diretamente e a GPIO acionada sem a necessidade de uso de um microcontrolador.
Outras características do Módulo Wireless ESP8266:

  • Conexão à redes padrão 802.11 B/G/N
  • Alcance aproximado: 91 metros
  • Tensão de operação : 3.3 VDC
  • Comunicação serial: pinos TX e RX
  • Modos de operação : Cliente, Access Point, Cliente+Access Point
  • Modos de segurança wireless : OPEN/WEP/WPA_PSK/WPA2_PSK/WPA_WPA2_PSK.
  • Suporta comunicação TCP e UDP, com até 5 conexões simultâneas

O módulo possui antena embutida e um conector de 8 pinos, além dos leds indicadores de funcionamento (vermelho) e comunicação (azul):
Módulo ESP8266 - Pinos
Atenção para o nível de sinal utilizado pelo módulo, que é de 3.3V, assim o pino RX (Recepção serial) não pode ser ligado diretamente ao Arduino. Você pode montar um divisor de tensão com dois resistores, utilizando o calculador deste link.

Ligação do módulo ESP8266 ao Arduino

Na ligação do ESP8266 com o Arduino usamos um resistor de 1K entre o Vcc (3.3V) e o pino CH_PD (Chip Enable). Para o divisor de tensão, utilizamos 2 resistores de 10K, o que diminuiu a tensão do nível de sinal para um valor suficiente para os testes. Os dois push-buttons do circuito serão utilizados para enviar informações à uma página web, utilizando um web server. Os resistores utilizados nos botões também são de 10K.
Circuito Arduino e módulo ESP8266
Recomendamos a utilização de uma fonte externa para alimentação do módulo, pois dependendo da situação ele pode exigir até 300mA de corrente, e o limite do Arduino é de 50mA.
Programa web server ESP8266
Antes de carregarmos o programa do web server, vamos alterar a velocidade de comunicação (baud rate) do módulo, que por padrão está setada em 115200 (firmware versão 0.9.5). Nessa velocidade, a biblioteca Software Serial não foi capaz de realizar a comunicação adequadamente, por isso alteramos a velocidade para 19200, utilizando o programa abaixo.
Na linha 17 colocamos a velocidade padrão (115200), e na linha 25 setamos a nova velocidade (19200):

Nesse programa, é mostrado no serial monitor a versão de firmware do módulo e também se os comandos foram processados com sucesso:
Serial_monitor_Baud_Rate
No programa vamos utilizar a biblioteca SoftwareSerial para efetuar a comunicação com o módulo usando os pinos 2 (RX) e 3 (TX). Assim, podemos utilizar o serial monitor para acompanhar o envio dos comandos ao módulo. Na linha 18 do programa, substitua as informações de SSID (nome da rede wireless) e SENHA pelas informações da rede à qual o módulo irá se conectar.

Acompanhe no serial monitor as informações de conexão ao access point (AP) e também o endereço IP obtido pela placa.
Serial Monitor
Para testar o funcionamento do circuito, abra um browser (Chrome, Firexox, etc) e digite na barra de endereços o endereço IP que foi mostrado no passo anterior, no nosso caso, 192.168.0.27:
ESP8266 - Browser
Acione os botões do circuito para que as informações correspondentes sejam enviadas ao browser. Devido à taxa de atualização, as informações podem demorar alguns segundos para aparecer na tela. Abaixo, temos uma imagem do circuito que utilizamos para montar este post:
Circuito montado
 
[Fonte]

Publicado em Deixe um comentário

Conecte o Arduino na rede wireless 802.11

Conecte o Arduino na rede wireless 802.11 com o módulo ESP8266

módulo wireless ESP8266 permite que você conecte o seu Arduino às redes wi-fi (wireless) padrão 802.11 b/g/n, que são as redes mais comuns utilizadas para acessar a internet. Funciona tanto como um AP (Access Point, ou ponto de acesso), como no modo STA (Station), enviando e recebendo dados.
conectando arduino na rede wireless com modulo ESP8266
Esse módulo é muito parecido fisicamente com alguns módulos NRF24L01, mas, diferente desses, não temos o cristal de 16 Mhz na placa, mas temos leds indicadores de funcionamento e comunicação.

Características e pinagem do módulo ESP8266

No datasheet do chip ESP8266 você encontra todas as informações sobre o CI, e abaixo destaco as mais importantes :
  • Suporte à redes  802.11 B/G/N
  • Alcance aproximado: 91 metros, dependendo do ambiente
  • Tensão de operação : 3.3 VDC
  • Comunicação serial (pinos TX, RX)
  • Possibilidade de upgrade do firmware
  • Modos de operação : Cliente, Access Point, Cliente+Access Point
  • Modos de segurança wireless : OPEN/WEP/WPA_PSK/WPA2_PSK/WPA_WPA2_PSK.
  • Suporta comunicação TCP e UDP
  • Operando nos modos TCP/UDP, permite até 5 conexões simultâneas
Quem já trabalhou com o módulo Bluetooth HC-05 ou HC-06 não terá dificuldade em utilizar o ESP8266, já que ele também se comunica via serial com o Arduino, e pode ter a sua configuração alterada por meio de comandos AT.
Abaixo, a disposição dos pinos do módulo :
ESP8266 Pinout and details
Este módulo trabalha com nível de sinal de 3.3V, assim devemos utilizar um divisor de tensão no pino RX (recepção/serial).

Conexão do ESP8266 ao Arduino Uno

Os pinos RX e TX do Arduino Uno são, respectivamente, os pinos digitais 0 e 1. Como esses pinos são utilizados também para comunicação com o computador, vamos “criar” uma serial nos pinos 2 e 3 por meio da biblioteca SoftwareSerial. Assim, podemos acompanhar os resultados da conexão do módulo ESP8266 no serial monitor.

Utilize um resistor de 10K para ligar o pino CH_PD (Chip Enable) ao pino 3.3V da alimentação do módulo.
Circuito Arduino e módulo ESP8266

No circuito acima montei o divisor de tensão com resistores de 220 e 330 ohms, reduzindo a tensão no pino RX para aproximadamente 3V. Utilize a calculadora de divisor de tensão para calcular a tensão de saída de acordo com os resistores que você estiver usando.

Outra observação importante tem relação com a alimentação do módulo, de 3.3V. Nos testes eu usei o pino 3.3V do Arduino, mas o módulo em algumas situações necessita de até 300mA de corrente, bem acima dos 50mA que o Arduino pode fornecer. Assim, para evitar sobrecarga, utilize uma fonte de alimentação externa para o módulo.

Programa  e download biblioteca ESP8266

Para o funcionamento do módulo juntamente com a biblioteca SoftwareSerial, precisamos fazer uma pequena alteração na biblioteca ESP8266. Primeiramente, faça o download da ESP8266clicando aqui. Em seguida descompacte o arquivo e coloque a pasta da biblioteca dentro da pasta LIBRARIES da IDE do Arduino.

Dentro dessa pasta, procure pelo arquivo ESP8266.h :

Biblioteca ESP8266
Abra esse arquivo utilizando o editor de textos de sua preferência e procure pela linha contendo o seguinte valor:

//#define ESP8266_USE_SOFTWARE_SERIAL

Retire as barras duplas do começo da linha para que o uso da SoftwareSerial seja habilitado. A linha ficará assim:

#define ESP8266_USE_SOFTWARE_SERIAL

Salve o arquivo ESP8266.h. Agora carregue o seguinte programa no Arduino :
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// Programa : Teste modulo wireless ESP8266
// Autor : Arduino e Cia
// Carrega as bibliotecas ESP8266 e SoftwareSerial
#include "ESP8266.h"
#include "SoftwareSerial.h"
// Cria uma serial nas portas 2 (RX) e 3 (TX)
SoftwareSerial minhaSerial(2 , 3);
// Define que o modulo ira utilizar a serial minhaSerial
ESP8266 wifi(minhaSerial);
// Configuracao ID e senha da rede Wireless
#define SSID        "NOME_DA_REDE"
#define PASSWORD    "SENHA_DA_REDE"
void setup()
{
    Serial.begin(9600);
}
void loop(void)
{
    Serial.print("Inicializando modulo\r\n");
    Serial.print("Versao do firmware: ");
    Serial.println(wifi.getVersion().c_str());
    // Define modo de operacao como STA (station)
    if (wifi.setOprToStation()) {
        Serial.print("Modo STA ok\r\n");
    } else {
        Serial.print("Erro ao definir modo STA !r\n");
    }
    // Conexao a rede especificada em SSID
    if (wifi.joinAP(SSID, PASSWORD)) {
        Serial.print("Conectado com sucesso a rede wireless\r\n");
        Serial.print("IP: ");
        Serial.println(wifi.getLocalIP().c_str());
    } else {
        Serial.print("Erro ao conectar rede wireless !!!\r\n");
    }
    Serial.print("*** Fim ***\r\n");
    while(1){}
}
Esse arquivo conecta o módulo à rede wi-fi especificada em SSID (troque o NOME_DA_REDE e SENHA_DA_REDE pelas informações da sua rede wireless), e mostra no serial monitor o endereço IP que foi obtido :
ESP8266 - Serial Monitor
Na pasta de exemplos da biblioteca, você tem outros programas para utilizar o módulo como Webserver, conexões TCP/UDP, buscar informações de páginas web, etc.
[Fonte]