Sistema Automático de Rega de Plantas de Escritório com Arduino, WiFi e IFTTT

Componentes e Materiais

Arduino Due	×	1
Andium Anduino WiFi	×	1
Arduino Zero	×	1
Sensor Capacitivo de Umidade do Solo	×	1

Aplicativos e Serviços Online

• Arduino IDE
• IFTTT
• Adafruit IO

Sobre o Projeto

Motivação

Aqui na Andium, estamos super animados por finalmente ter nos mudado para nosso novo espaço de escritório. Estamos equipando com paredes cobertas de quadros brancos, nova tecnologia brilhante e todos os confortos de casa. Especialmente começou a parecer casa quando colocamos um punhado destes amigos verdes folhosos pelo espaço!

Só que esquecemos de regá-las e dentro de uma semana ou mais nossos amigos folhosos começaram a parecer assim...

Falha.

Somos uma empresa de IoT, somos melhores que isso. Como nossas plantas não estão conectadas à internet! Espero que não seja tarde demais para este pequeno, montei uma solução usando nosso shield anduinoWiFi e IFTTT. Hora de dar voz às nossas plantas!

Começando

Se você tem dedo verde, provavelmente já parou de ler, mas se você é como eu e precisa dar às suas plantas a capacidade de implorar digitalmente por misericórdia e gritar por água, então você está no lugar certo.

Para dar voz às suas plantas, você precisará de um Arduino Due ou Zero, um shield anduinoWiFi (ou qualquer outro Arduino com WiFi que possa falar com Adafruit IO) e por último um 'Sensor Capacitivo de Umidade do Solo'. Ah, e um copo de água. (Dê à sua planta quando terminarmos, elas agradecerão via e-mail agora).

Sensor de Umidade

O sensor de umidade do solo é bem legal, não há muitos sensores onde você é realmente encorajado a submergir em terra molhada, então aproveite isso enquanto pode. Não demais, observe esta linha...

O que quer que você faça, não submerja seu sensor abaixo daquela linha branca. Nada acima dela tolerará a exposição à umidade muito bem, então tenha cuidado ao regar suas plantas que contêm este sensor.

Se você clicou na próxima foto acima, pode estar se perguntando por que tenho o sensor submerso em um copo d'água. Bem, não se pergunte mais!

Como Calibrar o 'Sensor Capacitivo de Umidade do Solo'

Nosso sensor capacitivo tem três fios que conectaremos a 3.3V (vermelho), terra (preto) e (azul - sinal) pino analógico A1. Quando calibramos nosso sensor, vamos registrar a leitura de capacitância quando o sensor está completamente seco, e então fazer uma segunda leitura quando o sensor está submerso (até a linha branca!) em um copo d'água. Isso nos dá nossos limites extremos de 0-100% de umidade relativa.

Conecte seu sensor, rode este sketch, e anote seus resultados. Para referência, meu dryVal foi 807 e meu wetVal foi 415.

int inputPin = A1;
void setup() {
  Serial.begin(115200);
  delay(3000);
}
void loop() {
  Serial.print("Raw val: ");
  Serial.println(readHumidity());
  delay(3000);
}
int readHumidity() {
  int sensorVal = analogRead(inputPin);
  return sensorVal;
}

Uma vez que você tenha estes dois números, está pronto para configurar o mapeamento de umidade relativa. Considere-se calibrado!

O Sketch

#include <WiFi101.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"
#include "AnduinoLCD.h"
// Parâmetros WiFi
#define WLAN_SSID "Andium"
#define WLAN_PASS "maybeitsjustpassword"
// Adafruit IO
#define AIO_SERVER "io.adafruit.com"
#define AIO_SERVERPORT 1883
#define AIO_USERNAME "seuusuario"
#define AIO_KEY "dosifje0j230fj32lksdfj230ff23"
WiFiClient client;
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);
/****************************** Feeds ***************************************/
// Configurar feed para temperatura
Adafruit_MQTT_Publish humidityVal = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/officePlants");
/*Criar instância do AnduinoLCD */
AnduinoLCD LCD = AnduinoLCD(ST7735_CS_PIN, ST7735_DC_PIN, ST7735_RST_PIN);
int inputPin = A1;
const int dryVal = 807;
const int wetVal = 415;
int humidity = 0;
int humidityPrev = 0;
int relHumidity = 0;
void setup() {
  Serial.begin(115200);
  delay(3000);
  // Conectar WiFi e Adafruit.IO
  connectToWiFi();
  connectToAdafruit();
  // Inicializar LCD
  LCD.begin();
  LCDinit();
}
void loop() {
  // ping adafruit io algumas vezes para garantir que permanecemos conectados
  if(! mqtt.ping(3)) {
    // reconectar ao adafruit io se não conectado
    if(! mqtt.connected()) connect();
  }
  humidity = readHumidity();
  // converter int temp para array char
  char b[4];
  String str;
  str=String(humidity);
  for(int i=0; i<str.length(); i++) {
    b[i]=str.charAt(i);
  }
  b[(str.length())+1]=0;
  // Publicar dados
  if (!humidityVal.publish((char*)b)) {
    Serial.println(F("Failed to publish temp"));
  } else {
    Serial.print(F("Humidity published: "));
    Serial.println(humidity);
    displayHumidity(humidity, humidityPrev);
  }
  Serial.print("Humidity: ");
  Serial.print(humidity);
  //Serial.print(" *F\t");
  // temp anterior armazenado para LCD
  humidityPrev = humidity;
  // repetir a cada 10min
  delay(600000);
}
// conectar ao adafruit io via MQTT
void connect() {
  Serial.print(F("Connecting to Adafruit IO... "));
  int8_t ret;
  while ((ret = mqtt.connect()) != 0) {
    switch (ret) {
      case 1: Serial.println(F("Wrong protocol")); break;
      case 2: Serial.println(F("ID rejected")); break;
      case 3: Serial.println(F("Server unavail")); break;
      case 4: Serial.println(F("Bad user/pass")); break;
      case 5: Serial.println(F("Not authed")); break;
      case 6: Serial.println(F("Failed to subscribe")); break;
      default: Serial.println(F("Connection failed")); break;
    }
    if(ret >= 0) mqtt.disconnect();
    Serial.println(F("Retrying connection..."));
    delay(1000);
  }
  Serial.println(F("Adafruit IO Connected!"));
}
void displayHumidity(int humidity, int humidtyPrev) {
  // limpar valor antigo
  LCD.setTextColor(ST7735_BLACK);
  LCD.setTextSize(2);
  LCD.setTextWrap(true);
  LCD.setCursor(40,60);
  LCD.setTextSize(5);
  LCD.print(humidityPrev);
  LCD.setTextSize(2);
  LCD.print("%");
  // Imprimir novo valor
  LCD.setTextColor(ST7735_WHITE);
  LCD.setTextSize(2);
  LCD.setTextWrap(true);
  LCD.setCursor(40,60);
  LCD.setTextSize(5);
  LCD.print(humidity);
  LCD.setTextSize(2);
  LCD.print("%");
}
void connectToWiFi() {
  // Conectar ao ponto de acesso WiFi.
  delay(10);
  Serial.print(F("Connecting to "));
  Serial.println(WLAN_SSID);
  WiFi.begin(WLAN_SSID, WLAN_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(F("."));
  }
  Serial.println(F("WiFi connected!"));
}
void connectToAdafruit() {
  // conectar ao adafruit io
  connect();
}
void LCDinit() {
  LCD.setBacklight(ON);
  LCD.fillScreen(ST7735_BLACK); // limpar tela
  LCD.showBanner(); // carregar Banner Andium
  LCD.setTextColor(ST7735_WHITE);
  LCD.setTextSize(2);
  LCD.setTextWrap(true);
  LCD.setCursor(0,40);
  LCD.print("Humidity: ");
}
int readHumidity() {
  int sensorVal = analogRead(inputPin);
  relHumidity = map(sensorVal, dryVal, wetVal, 0, 100);
  Serial.println("relHumidity");
  Serial.print(relHumidity);
  return relHumidity;
}

Copie e cole este sketch na sua IDE e certifique-se de ter estas bibliotecas instaladas:

• WiFi101
• Adafruit_MQTT
• AnduinoLCD

Bem como seus valores calibrados pessoalmente:

const int dryVal = 807;
const int wetVal = 415;

valores seco e úmido. No final do sketch, quando lemos readHumidity(), usamos estes valores para mapear 0-100% de umidade relativa. Então agora nossos valores lerão 0% quando seco e 100% quando totalmente saturado.

relHumidity = map(sensorVal, dryVal, wetVal, 0, 100);

Se tudo correr bem, e seu Arduino conectar ao WiFi e Adafruit IO, você deve começar a ver leituras a cada 10 minutos. Aqui está um instantâneo de nossas leituras hoje.

Não liguem para aqueles outliers mais cedo hoje, eu também estava publicando enquanto lia minha capacitância bruta não mapeada para determinar meus valores seco e úmido.

Ótimo, agora a cada 10 minutos publicamos nossa leitura de umidade do solo. Agora eu meio que realmente não me importo com as leituras até ter que salvar minhas plantas da morte e regá-las. Vamos usar IFTTT para definir um nível limite de umidade e configurar notificação para ser enviada para que sejamos lembrados de regar nossas plantas!

Limite IFTTT

Usando IFTTT, configurei um limite tal que quando a umidade relativa do solo cai abaixo de 20%, nossas plantas sedentas entrarão em contato conosco via Twitter (@andiumPlants) pedindo para ser regadas! Aqui está um vislumbre da configuração.

É isso!

O Que Vem A Seguir?

Deixo isso para você! Como mais podemos criativamente dar voz às nossas plantas e manter nossa fauna de falhar. Pegue um anduinoWiFi e um sensor de solo e comece a fazer!

Código

Anduino

Uma biblioteca Arduino para o shield Andium(Anduino). Transforme seu Arduino em um AndiumNode. github.com/andium/Anduino