Arduino Aquaponics: Controlador de bomba de JSON (2 / 3 paso)

Paso 2: Sketch de Arduino

La función de análisis busca el final de la respuesta, crea un objeto aJson y luego obtiene el modo.  Dependiendo del valor de modo, una de tres cosas ocurre.  El primer modo es Siempre, por lo que el relé está activado.  Si usas la palanca, se sincronizan los tiempos de ejecución y ociosos.  Por último, Manual es acompañado por el estado que desea la bomba en.

#include < SPI.h >
#include < Ethernet.h > / Ethernet escudo
#include < aJSON.h > / / parsear JSON.  Crédito: Tema interactivo
#include < Wire.h >
#include "RTClib.h" / / ChronoDot.  Crédito: Adafruit Industries
#include < Time.h >
#include < TimeAlarms.h >

RTC - ChronoDot
RTC_DS1307 RTC;

Fecha y hora futura;
basculante largo sin firmar;
corriente largo sin firmar;

Escudo de Ethernet
mac de bytes [] = {0x90, 0xA2, 0xD0, 0x0D, 0xA0, 0 x 00};
myIP de bytes [] = {192, 168, 1, 15};                    Quite el comentario de aquí y la línea 52 si es necesario.
puerta de entrada de bytes [] = {192, 168, 1, 1};

Char [] servidor = "http://www. myapsystem. appspot.com ";              Cambiar esto para que coincida con el identificador de aplicación que configura en el paso 3
Cliente EthernetClient;

Es fácil cambiar los nombres de la aplicación
Aplicación de la secuencia = "http://www. myapsystem.appspot.com/ ";        Cambiar esto para que coincida con el identificador de aplicación que configura en el paso 3

Pernos de
int connectedON = 8;
int connectedOFF = 9;
int pumpRelay = 23;

PumpRelay valores
String current_mode = "Manual";  El modo por defecto
String pumpState = "off";        El estado por defecto
int pumpRunTime = 20;            Duración de 20 segundos
int pumpIdleTime = 40;           Sentado inactivo durante 40 segundos

void setup() {}
Relé de giro primero
digitalWrite (pumpRelay, HIGH);

Desactivar tarjeta SD si uno en la ranura
pinMode(4,OUTPUT);
digitalWrite(4,HIGH);

Inicio serie
Serial.Begin(9600);
Delay(1000);

Salida Ethernet
Ethernet.Begin(Mac);
Ethernet.Begin (mac, myIP);
Ethernet.Begin (mac, myIP, puerta de entrada);
Delay(1000);

Inicio RTC
Wire.Begin();
RTC.begin();

if (!. {RTC.isrunning())}
Serial.println ("RTC no está en ejecución");
}

Fecha y hora = ahora RTC.now();
Compilado de DateTime = DateTime (__DATE__, __TIME__);
Si (now.unixtime() < compiled.unixtime()) {}
Serial.println ("RTC es más viejo que el tiempo de compilación! Puesta al día");
RTC.adjust (DateTime (__DATE__, __TIME__));
}

Modos de juego pin
pinMode (connectedON, salida);
pinMode (connectedOFF, salida);
pinMode (pumpRelay, salida);

Sistema de alarmas
Alarm.timerRepeat (30, sincronización);
Alarm.timerRepeat (1, checkRelay);

Sync();

Serial.println ("instalación completa");
}

void loop() {}
Alarm.Delay(1000);
}

{} void sync()
Serial.println("Syncing");
¿Gae (aplicación + "adacs/sync? Estado = "+ pumpState);
Serial.println();
}

void checkRelay() {}
Fecha y hora = ahora RTC.now();
actual = now.unixtime();

Si (current_mode == "Toggle") {}
Si (actual < toggle) {}

} else {}
Determinar que el estado para pasar a
Si (pumpState == "off") {}
La bomba estaba apagado.  Encender y ajustar tiempo de palanca siguiente basado en tiempo de ejecución
digitalWrite (pumpRelay, bajo);

Serial.println ("encendiendo la bomba");

pumpState = "on";

Sistema la próxima vez de palanca
futuro = now.unixtime() + pumpRunTime;
palanca now.unixtime() = pumpRunTime;
} else if (pumpState == "on") {}
La bomba fue el.  Apague y coloque la próxima vez alternar basada en tiempo de inactividad
digitalWrite (pumpRelay, HIGH);

Serial.println ("desactivar la bomba");

pumpState = "off";

Sistema la próxima vez de palanca
futuro = now.unixtime() + pumpIdleTime;
palanca now.unixtime() = pumpIdleTime;

}

displayTime();
}
}
}

void displayTime() {}
Fecha y hora = ahora RTC.now();
actual = now.unixtime();

Pantalla de hora actual
Serial.Print ("hora:");
Serial.Print(Now.Year(), DEC);
Serial.Print('/');
Serial.Print(Now.month(), DEC);
Serial.Print('/');
Serial.Print(Now.Day(), DEC);
Serial.Print(' ');
Serial.Print(Now.hour(), DEC);
Serial.Print(':');
Serial.Print(Now.minute(), DEC);
Serial.Print(':');
Serial.Print(Now.Second(), DEC);
Serial.println();

Pantalla siguiente alternar tiempo
Serial.Print ("tiempo futuro:");
Serial.Print(Future.Year(), DEC);
Serial.Print('/');
Serial.Print(Future.month(), DEC);
Serial.Print('/');
Serial.Print(Future.Day(), DEC);
Serial.Print(' ');
Serial.Print(Future.hour(), DEC);
Serial.Print(':');
Serial.Print(Future.minute(), DEC);
Serial.Print(':');
Serial.Print(Future.Second(), DEC);
Serial.println();
}

void GAE(String link) {}
éxito booleano = httpRequest(link);
Si (éxito == true) {}
Delay(5000);

Boolean currentLineIsBlank = true;

ReadString de cadena = "";
Reemplazos de Char [100];

mientras (client.connected()) {}
Si (client.available()) {}
char c = client.read();
Serial.Write(c);        Modo de dev

Si (c == '\n' & & currentLineIsBlank) {}
{while(Client.Connected())}
char f = client.read();
readString += f;
}
}

Si (c == '\n') {}
currentLineIsBlank = true;
} else if (c! = '\r') {}
currentLineIsBlank = false;
}
}
}

Client.STOP();

readString.toCharArray (reemplazos, 100);

El objeto JSON completo
aJsonObject * jsonObject = aJson.parse(newString);

Obtener el modo de
modo de aJsonObject * = aJson.getObjectItem (jsonObject, "Modo");
current_mode = modo -> valuestring;    El modo de convertir en cadena y asignar a current_mode

Serial.println ("modo de:" + current_mode);

Modo condicional
Si (current_mode == "Always On") {}
Encienda la bomba
digitalWrite (pumpRelay, bajo);

Estado de actualización
pumpState = "on";

} else if (current_mode == "Toggle") {}
Sincronizar el tiempo de ejecución
aJsonObject * rt = aJson.getObjectItem (jsonObject, "Tiempo");
Cadena rString = rt -> valuestring;
pumpRunTime = rString.toInt();

Sincronizar el tiempo de inactividad
aJsonObject * se = aJson.getObjectItem (jsonObject, "IdleTime");
Cadena iString lo = -> valuestring;
pumpIdleTime = iString.toInt();

Salida opcional
Serial.Print ("tiempo de ejecución:");
Serial.Print(pumpRunTime);
Serial.println();
//
Serial.Print ("tiempo de inactividad:");
Serial.Print(pumpIdleTime);
Serial.println();

} else if (current_mode == "Manual") {}
El estado de sincronización
aJsonObject * st = aJson.getObjectItem (jsonObject, "Estado");
pumpState = st -> valuestring;

Si (pumpState == "on") {}
digitalWrite (pumpRelay, bajo);
} else if (pumpState == "off") {}
digitalWrite (pumpRelay, HIGH);
} else {}
Serial.println ("bomba desconocido estado dado en modo Manual.");
}
} else {}
Serial.println ("Uknown modo detectado durante la sincronización.");
}
} else {}
Serial.println ("no conectado.");
}

Eliminar el objeto raíz
aJson.deleteItem(jsonObject);
}

{} Boolean httpRequest (enlace de cadena)
Si hay una conexión exitosa
Si (client.connect (servidor, 80)) {}
Client.println ("GET" + enlace + "HTTP/1.0");
Client.println();

Encender LED conectado
digitalWrite (connectedOFF, bajo);
digitalWrite (connectedON, HIGH);

verdaderas;
} else {}
No pudo realizar la conexión
Serial.println ("fallada la conexión");
errores += 1;
Client.STOP();

Encender LED conectado
digitalWrite (connectedON, bajo);
digitalWrite (connectedOFF, HIGH);

devuelven el valor false;
}
}