Bibliografía

HIDROPONÍA INTEGRANTES:

• VILLA HERRERA JULISSA

• MONGE HERNÁNDEZ IRVING
ZAID
• HERNÁNDEZ RONQUILLO KEVIN
TEMAS SELECTOS DEDAVID
ELECTRONICA Y COMPUTACION 1

DOCENTE: SERGIO FRANCISCO HERNÁNDEZ MACHUCA

XALAPA-ENRIQUEZ, VER. 10 DE JUNIO DEL 2021

Índice
Introducción 2

Teoría de funcionamiento 3

Entradas 3

Salidas: 9

Procesamiento: 9

Esquema 10

Diagrama de flujo y código 11

Diagrama de flujo 11

Diseño del prototipo 0

Etapas de construcción 0

Datos: 0

Descripción del funcionamiento del prototipo 0

Apéndice 3

Hojas de datos 3
Introducción

La hidroponía es la labor o el cultivo de plantas sin utilizar tierra o suelo. Los componentes necesarios son el agua y los
nutrientes. Entre los beneficios de la hidroponía se encuentran el ahorro y conservación del agua, la utilización eficiente de
los recursos y la reducción en gran medida del uso de pesticidas.
Decidimos realizar un sistema de monitoreo de agua para la hidroponía ya que consideramos que es un área en la que, si
se utiliza de forma adecuada, el Internet of Things puede facilitar mucho una actividad que a primera vista parecería
complicada.
Este sistema cuenta con tres elementos principales, los cuales son sensores correspondientes a temperatura, pH (potencial
de hidrógeno) y TDS (total de solidos disueltos) que nos ayudarán a determinar la condición del agua del sistema con base
en sus mediciones.
un dispositivo capaz de monitorear estas tres variables de forma fácil y sencilla

El cultivo hidropónico en un principio era solamente en agua, a la cual se le agregaban los elementos nutritivos. Varios de
los métodos hidropónicos actuales emplean algún tipo de medio de cultivo, tales como grava, arenas, piedra pómez, perlita,
a los cuales se les añade una solución nutritiva que contiene todos los elementos esenciales necesarios para el normal
crecimiento y desarrollo de las plantas. Hoy en día, la técnica de hidroponía juega un papel muy importante en el desarrollo
global de la agricultura. La presión por el incremento de la población, los cambios en el clima, la erosión del suelo, la falta
y contaminación de las aguas, son algunos de los factores que han influenciado la búsqueda de métodos alternos de
producción de alimentos.
Teoría de funcionamiento

SENSOR DE TEMPERATURA DS18B20

SENSOR DE CALIDAD DE AGUA

Entradas
• Alimentación: PC
• Sensor ph :
➢ Tiempo de respuesta: 90% de la lectura final en 1 segundo
➢ Rango de temperatura: 5 a 80 ° C (lecturas no compensadas)
➢ Rango: pH 0-14
➢ Precisión: +/- 0,2 unidades de pH
➢ PH isopotencial: pH 7 (punto en el que la temperatura no tiene efecto)
➢ Valores de calibración predeterminados: pendiente: –3,838, intersección: 13,720
➢ Diámetro del eje: 12 mm DE

• Sensor tds:
✓ Voltaje de entrada: 3.3 ~ 5.5V
✓ Voltaje de salida: 0 ~ 2.3V
✓ Corriente de trabajo: 3 ~ 6mA
✓ Rango de medición TDS: 0 ~ 1000ppm
✓ Precisión de medición TDS: ± 10% FS (25 ℃)
✓ Tamaño del módulo: 42 * 32 mm
✓ Interfaz del módulo: PH2.0-3P
✓ Interfaz de electrodo: XH2.54-2P
✓ Sonda TDS

✓ Cantidad de Aguja: 2
✓ Longitud total: 83cm
✓ Interfaz de conexión: XH2.54-2P
✓ De color negro
✓ Otro: Sonda a prueba de agua
 • Sensor de temperatura DS18B20:

o Rango de temperatura: -55 a 125°C

o Resolución: de 9 a 12 bits (configurable)
o Interfaz 1-Wire (Puede funcionar con un solo pin)
o Identificador interno único de 64 bits
o Multiples sensores puede compartir el mismo pin
o Precisión: ±0.5°C (de -10°C a +85°C)
o Tiempo de captura inferior a 750ms
o Alimentación: 3.0V a 5.5V

• ESP32:

CPU y memoria

• Microprocesadores Xtensa® Dual-Core de 32 bits LX6, hasta 600 MIPS

• 448 KByte de ROM

• 520 KByte SRAM

• 16 KByte SRAM en RTC

• QSPI Flash / SRAM, hasta 4 x 16 MBytes

• Fuente de alimentación: 2,2 V a 3,6 V

Relojes y temporizadores

• Oscilador interno de 8 MHz con calibración

• Oscilador RC interno con calibración

• Oscilador de cristal externo de 2 MHz a 40 MHz

• Oscilador de cristal externo de 32 kHz para RTC con calibración

• Dos grupos de temporizadores, incluidos 2 temporizadores de 64 bits y 1 perro guardián principal en cada grupo

• Temporizador RTC con precisión inferior a un segundo

• Perro guardián de RTC

Interfaces periféricas avanzadas

• SAR ADC de 12 bits hasta 18 canales

• Convertidores D / A de 2 × 8 bits

• 10 × sensores táctiles

• Sensor de temperatura

• 4 × SPI
• 2 × I2S

• 2 × I2C

• 3 × UART

• 1 host (SD / eMMC / SDIO)

• 1 esclavo (SDIO / SPI)

• Interfaz Ethernet MAC con DMA dedicado y compatibilidad con IEEE 1588

• CAN 2.0

• IR (TX / RX)

• Motor PWM

• LED PWM hasta 16 canales

• Sensor de pasillo

• Preamplificador analógico de potencia ultrabaja

Apoyo al desarrollo

• Firmware SDK para una programación rápida en línea

• Cadenas de herramientas de código abierto basadas en GCC

Rango de temperatura de funcionamiento: -40 ° C a + 85 ° C

Dimensiones: 51 x 27 mm
Salidas:
• PÁGINA WEB:

Procesamiento:
• VISUAL CODE: Microcontrolador del esp32 que permite realizar todas las operaciones.
Esquema

Imagen de la simulación en fritzing

Diagrama de flujo y código
Diagrama de flujo
CÓDIGO .CPP

#include <Arduino.h>
#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include "SPIFFS.h"
#include <Arduino_JSON.h>
#include <Adafruit_BME280.h>
#include <Adafruit_Sensor.h>
#include <OneWire.h>
#include <EEPROM.h>
#include "GravityTDS.h"
//TDS
#define TdsSensorPin 34
GravityTDS gravityTds;
float temperature = 25.0,tdsValue = 0.0;

//temperatura
OneWire ds(13);
byte present = 0;
byte type_s=0;
byte data[12];
byte addr[8];
float celsius;
//PH
const byte pHpin = 35;
float Po=0.0;

// Replace with your network credentials

const char* ssid = "moto";
const char* password = "Bubba2306";

// Create AsyncWebServer object on port 80

AsyncWebServer server(8080);
// Create an Event Source on /events
AsyncEventSource events("/events");

// Json Variable to Hold Sensor Readings

JSONVar readings;

// Timer variables
unsigned long lastTime = 0;
unsigned long timerDelay = 30000;
unsigned int c=1;

// Create a sensor object

Adafruit_BME280 bme; // BME280 connect to ESP32 I2C (GPIO 21 = SDA, GPIO 22 = SCL)

// Init BME280
void initBME(){
if (!bme.begin(0x76)) {
Serial.println("Could not find a valid BME280 sensor, check wiring!");
//while (1);
}
}
// Get Sensor Readings and return JSON object
/*
String getSensorReadings(){
readings["temperature"] = String(bme.readTemperature());
readings["humidity"] = String(bme.readHumidity());
readings["pressure"] = String(bme.readPressure()/100.0F);
String jsonString = JSON.stringify(readings);
return jsonString;
}
*/
String getSensorReadings(){
readings["temperature"] = String(celsius);
readings["ph"] = String(Po);
readings["TDS"] = String(tdsValue);
String jsonString = JSON.stringify(readings);
return jsonString;

// Initialize SPIFFS
void initSPIFFS() {
if (!SPIFFS.begin(true)) {
Serial.println("An error has occurred while mounting SPIFFS");
}
Serial.println("SPIFFS mounted successfully");
}

// Initialize WiFi
void initWiFi() {
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
Serial.print("Connecting to WiFi ..");
while (WiFi.status() != WL_CONNECTED) {
Serial.print('.');
delay(1000);
}
Serial.println(WiFi.localIP());
}

void setup() {
//TDS
{
Serial.begin(115200);
gravityTds.setPin(TdsSensorPin);
gravityTds.setAref(5.0); //reference voltage on ADC, default 5.0V on Arduino UNO
gravityTds.setAdcRange(1024); //1024 for 10bit ADC;4096 for 12bit ADC
gravityTds.begin(); //initialization
}
//BME
Serial.begin(115200);
initBME();
initWiFi();
initSPIFFS();

// Web Server Root URL

server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
request->send(SPIFFS,"/index.html" ,"text/html");
});

server.serveStatic("/", SPIFFS, "/");

// Request for the latest sensor readings

 server.on("/readings", HTTP_GET, [](AsyncWebServerRequest *request) {
String json = getSensorReadings();
request->send(200, "application/json", json);
json = String();
});

events.onConnect([](AsyncEventSourceClient *client) {
if(client->lastId()){
Serial.printf("Client reconnected! Last message ID that it got is: %u\n", client->lastId());
}
// send event with message "hello!", id current millis
// and set reconnect delay to 1 second
client->send("hello!", NULL, millis(), 10000);
});
server.addHandler(&events);

// Start server
server.begin();
}

void loop() {
//TDS
/*
//temperature = readTemperature(); //add your temperature sensor and read it
gravityTds.setTemperature(temperature); // set the temperature and execute temperature compensation
gravityTds.update(); //sample and calculate
tdsValue = gravityTds.getTdsValue(); // then get the value
Serial.print(tdsValue,0);
Serial.println("ppm");
delay(1000);
*/

//
if ( !ds.search(addr)) {
//Serial.println("No more addresses.");
Serial.println();
ds.reset_search();
delay(250);
return;
}
/*
Serial.print("ROM =");
 for( int i = 0; i < 8; i++) {
Serial.write(' ');
Serial.print(addr[i], HEX);
}
*/
ds.reset();
ds.select(addr);
ds.write(0x44, 1); // start conversion, with parasite power on at the end

delay(1000); // maybe 750ms is enough, maybe not

// we might do a ds.depower() here, but the reset will take care of it.

present = ds.reset();
ds.select(addr);
ds.write(0xBE); // Read Scratchpad

/*
Serial.print(" Data = ");
Serial.print(present, HEX);
Serial.print(" ");
*/
for ( int i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
//Serial.print(data[i], HEX);
}

Serial.println();

// Convert the data to actual temperature

// because the result is a 16 bit signed integer, it should
// be stored to an "int16_t" type, which is always 16 bits
// even when compiled on a 32 bit processor.
int16_t raw = (data[1] << 8) | data[0];
if (type_s) {
raw = raw << 3; // 9 bit resolution default
if (data[7] == 0x10) {
// "count remain" gives full 12 bit resolution
raw = (raw & 0xFFF0) + 12 - data[6];
}
} else {
byte cfg = (data[4] & 0x60);
// at lower res, the low bits are undefined, so let's zero them
 if (cfg == 0x00) raw = raw & ~7; // 9 bit resolution, 93.75 ms
else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
//// default is 12 bit resolution, 750 ms conversion time
}
celsius = (float)raw / 16.0;

Serial.print(" Temperature = ");

Serial.print(celsius);

//Ph

// Po = (1023 - analogRead(pHpin)) / 73.07; // Read and reverse the analogue input value from the pH sensor then scale
0-14.

Serial.println(".");
Po = analogRead(pHpin);
Serial.print("Ph= ");

Serial.println(Po, 2);// Print the result in the serial monitor.

delay(1000);// Take 1 reading per second.

tdsValue = analogRead(TdsSensorPin);
Serial.print(tdsValue);
Serial.println("ppm");

if ((millis() - lastTime) > timerDelay) {

// Send Events to the client with the Sensor Readings Every 30 seconds
events.send("ping",NULL,millis());
events.send(getSensorReadings().c_str(),"new_readings" ,millis());
lastTime = millis();
}
Diseño del prototipo
Etapas de construcción
1. Armado y compilado del código.
2. Compra de componentes.
3. Armado en protoboard.
4. Diseño, comenzamos cortando el PVC, con la broca, adaptamos los codos
de PVC,
5. Seguido de eso lo acoplamos a la pared con algunos clavos, pusimos las
canastillas,
6. Ya armado en un tambo disolvimos los fertilizantes, por último hacemos
funcionar la bomba, y ese impulso hace que recorra toda el agua por los
tubos. Así se alimentan todas las plantas.

Datos:
• El sistema hidróponico necesita hasta cierto tiempo, supervisión de una
persona.

Descripción del funcionamiento del prototipo

El sistema arranca cuando hacemos funcionar la bomba, hablando del prototipo
hidropónico, para la medición de calidad de agua, ph y temperatura, se deben
sumergir en el agua de este sistema, para poder monitorear sus variables, y tener
un resultado favorable del crecimiento y calidad de plantas. Contamos con una
página donde se desplazan los valores.

Tenemos un inicio

Donde se muestra el monitoreo de las variables en una tabla.

Otro apartado donde se muestra un breve descripción de nuestro sistema.
Apéndice
Hojas de datos

SENSOR DE TEMPERATURA (DS18B20)

SENSOR PH DE 0-14
SENSOR DE CALIDAD DE AGUA (TDS):
ESP32: