Pflanzenwächter para el Alféizar de la ventana de la Parte 3 – Extensión de sensores de humedad de suelo en un máximo de seis Piezas.

En la tercera Parte de la Serie "Pflanzenwächter" nos encontramos con que en las Partes anteriores ya desplegado schaltungstechnisches Detalle de vuelta y ampliar el Número de nuestros Pflanzenwächter conectables Feuchtesensoren a un máximo de seis. El uno o el otro son, quizás, los que ya son seis divisor de tensión dado cuenta, pero hasta ahora, sin embargo, sólo una de ellas se halla estaba. El restante 5 divisor de tensión sirvieron hasta ahora en el Principal, para ello, a 5 de 6 Analógico-Digital de las Entradas del ESP32 define en 0 para tirar para, por una parte, en un posiblemente incontrolado Alas a impedir, pero también para nuestros ESP detectable en el de 6 Entradas ahora un Sensor de humedad está conectado y en qué no. Porque, SIN cambiar el Código, a través de una simple Conexión de un Sensor adicional (hasta un máximo de 6) y el posterior Reinicio del Sistema, además de los Sensores de acuerdo a su Gusto y Necesidad de amarrar. Podemos, por tanto, cualquier Número de mínimo de 1 hasta un máximo de 6 Sensores, empezando por el de la izquierda, el Puerto (GPIO36), siguiendo hasta el máximo a la derecha (Puerto GPIO 33 comas. Ello no obstante, no hay Puertos entre los Sensores que se omiten, ya que estos, de lo contrario, no se detectan. A continuación se muestra la Maximalbestückung con Feuchtesensoren demostrado que

Nuestra Lista se amplía, por tanto, en:1 x LED de Color Verde (560nm); 5 mm

• 1x LED de Color Amarillo (605nm); 5 mm
• 1x LED de Color Rojo (633nm); 5 mm
• 6x130kΩ Resistencia de Tolerancia de ±1%
• 6x 47kΩ Resistencia de Tolerancia de ±1
• 3x 150 Ω Resistencia de Tolerancia de ±1%
• 6x Sensor de humedad Capacitivo
  
• 1x ESP32-38Pin Variante Generic; Tipo NodeMCU-32S; Pierna 38;
• 1x YwRobot placa de pruebas de tensión

, Después de los necesarios cambios en el Hardware, a nosotros, ni nuestro Código en el ESP un poco de personalización, así como nuestra APLICACIÓN Móvil ampliar. Primero vamos a cargar el siguiente Código en nuestro ESP alto:

#include <driver/adc.h>
#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>


// Portedefinierung Led's
#define LED_Rot     18    // LED Rojo 
#define LED_Gelb    14    // el LED Amarillo
#define LED_Gruen   15    // LED Verde

// LED PWM Configuración
#define PWMfreq 5000  // 5 Khz frecuencia fundamental de Pantalla LED
#define PWMledChannelA  0
#define PWMledChannelB  1
#define PWMledChannelC  2
#define PWMresolution  8 // 8 Bits de Resolución para el LED PWM

//Otras Definiciones
#define ADCAttenuation ADC_ATTEN_DB_11    //ADC_ATTEN_DB_11 = 0-3,6 V Amortiguación ADC (ADC Extensión
#define MoisureSens_Poll_Interval 300000   // Intervalo de tiempo entre dos Bodenfeuchtemessungen en Milisegundos -> cada 5 Minutos Paquete de datos a un Teléfono móvil para enviar
#define MaxSensors 6                      // Número Máximo de conectables FeuchteSensoren
#define StartInit true
#define Sens_Calib true
#define Sens_NOTCalib false

// Blynk APLICACIÓN Definiciones
#define BLYNK_GREEN     "#23C48E"
#define BLYNK_BLUE      "#04C0F8"
#define BLYNK_YELLOW    "#ED9D00"
#define BLYNK_RED       "#D3435C"
#define BLYNK_BLACK     "#000000"
#define BLYNK_PRINT Serial
#define BLYNK_NO_BUILTIN
#define BLYNK_NO_FLOAT
//#define BLYNK_DEBUG

struct MoistureSensorCalibrationData
{   int Data[MaxSensors * 2] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,}; // Calibration Data para el sensor de Humedad. Por favor, el Proyecto de Texto de nota y Valores según personalizar   String SensorName[MaxSensors] = {"Planta 1", "Planta 2", "Planta De 3", "Planta 4", "Planta 5", "Planta 6"}; // Sensorname, también en la APP, como el Encabezado aparece   el byte StatusBorderPercentValues[MaxSensors * 2][2] = { {10, 50},     // Conjunto bidimensional para valores límite porcentuales (semáforo) individualmente para cada sensor de humedad (1 -6)     {10, 50},     {10, 50},     {10, 50},     {10, 50},     {10, 50}   };
};

estructura Datos de sensor de humedad
{   int Por ciento[MaxSensors] = {0, 0, 0, 0, 0, 0};  // Datos del sensor de humedad en porcentaje   byte Porcentaje antiguo[MaxSensors] = {0, 0, 0, 0, 0, 0}; // Anterior _ Datos del sensor de humedad en porcentaje (propósito: guardar la cantidad de datos).   bool DataValid [MaxSensors] = {falso, falso, falso, falso, falso, falso};
};


// Variables globales

char auth[] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; // Ingrese la aplicación Blynk de acuerdo con las instrucciones para el token de autenticación (correo electrónico).
// Sus datos de acceso WiFi.
char ssid[] = "Your_WLAN_SSID";                 // Adaptarse a su propio SSID de WLAN
char pasar[] = "Tu _WLAN _Passwort!";           // Adapta tu propia contraseña de WiFi

Sensor de humedad Calibración Datos MCalib;
Datos de sensor de humedad MMeasure;
byte Sensores de humedad adjuntos; // Sensores de humedad activa detectados (recuento)
sin firmar largo Moisure_ServiceCall_Handler = 0;  // Variable de retraso para retraso entre lecturas de Moisure

nulo configuración() {   pinMode(LED_rojo, SALIDA);   pinMode(LED_Amarillo, SALIDA);   pinMode(LED_Verde, SALIDA);   De serie.comenzar(115200);   // inicializa la comunicación en serie a 115200 bits por segundo:   ledcSetup(PWMledChannelA, PWMfreq, Resolución PWM);   ledcSetup(PWMledChannelB, PWMfreq, Resolución PWM);   ledcSetup(PWMledChannelC, PWMfreq, Resolución PWM);   ledcAttachPin(LED_rojo, PWMledChannelA);   // adjunta el canal al GPIO para ser controlado   ledcAttachPin(LED_Amarillo, PWMledChannelB);   ledcAttachPin(LED_Verde, PWMledChannelC);   SetLedConfig(255, 255, 255);   De serie.println(F("Configuración del sistema:"));   Sensores de humedad adjuntos = Detección de humedad Sensores();   De serie.imprimir(Sensores de humedad adjuntos);   De serie.println(F("Sensor (es) de humedad del suelo"));   De serie.imprimir(F("Conexión a WLAN"));   retrasar(500);   Blynk.comenzar(auth, ssid, pasar);  // Inicializa la conexión WiFi a través de la Biblioteca Blync   De serie.println(F("exitoso".));   SetLedConfig(0, 0, 0);   Init_Blynk_APP();   Run_MoistureSensors(StartInit);   para (int yo = Sensores de humedad adjuntos; yo < 6; yo++) {     Update_Blynk_APP(yo, Sens_Calib);   };
}

byte Detección de humedad Sensores ()
{
#definir MinSensorValue 100   byte Detectado = 0;   para (int yo = 0; yo < MaxSensors; yo++)   {     int MSensorRawValue = ReadMoistureSensor_Raw_Val(yo);     si ( MSensorRawValue > MinSensorValue) {       Detectado++;     } otra cosa {       romper;     }   }   si (Detectado < 1)   {     De serie.println(F("No se detectaron sensores de humedad del suelo. El sistema se detuvo".));     esp_deep_sleep_start();     mientras que (1) {}   }   volver Detectado;
}

bool SetLedConfig(byte Rojo, byte amarillo, byte verde)
{   ledcWrite(PWMledChannelA, Rojo); // LED rojo   ledcWrite(PWMledChannelB, amarillo); // LED amarillo   ledcWrite(PWMledChannelC, verde); // LED verde   volver cierto;
}

int ReadMoistureSensor_Raw_Val(byte Sensor)
{   int Valor de retorno, yo;   largo suma = 0;
#definir NUM_READS 6   adc1_config_width(ADC_WIDTH_BIT_12);   // Rango 0-4095   cambiar (Sensor)   {     caso 0:       {         adc1_config_channel_atten(ADC1_CHANNEL_0, Atenuación ADCA);         para (yo = 0; yo < NUM_READS; yo++) { // Algoritmo promedio           suma += adc1_get_raw( ADC1_CHANNEL_0 ); // Leer análogo         }         Valor de retorno = suma / NUM_READS;         romper;       }     caso 1:       {         adc1_config_channel_atten(ADC1_CHANNEL_3, Atenuación ADCA);         para (yo = 0; yo < NUM_READS; yo++) { // Algoritmo promedio           suma += adc1_get_raw( ADC1_CHANNEL_3 ); // Leer análogo         }         Valor de retorno = suma / NUM_READS;         romper;       }     caso 2:       {         adc1_config_channel_atten(ADC1_CHANNEL_6, Atenuación ADCA);         para (yo = 0; yo < NUM_READS; yo++) { // Algoritmo promedio           suma += adc1_get_raw( ADC1_CHANNEL_6 ); // Leer análogo         }         Valor de retorno = suma / NUM_READS;         romper;       }     caso 3:       {         adc1_config_channel_atten(ADC1_CHANNEL_7, Atenuación ADCA);         para (yo = 0; yo < NUM_READS; yo++) { // Algoritmo promedio           suma += adc1_get_raw( ADC1_CHANNEL_7 ); // Leer análogo         }         Valor de retorno = suma / NUM_READS;         descanso;       }     caso 4:       {         adc1_config_channel_atten(ADC1_CHANNEL_4, Atenuación ADCA);         para (yo = 0; yo < NUM_READS; yo++) { // Algoritmo promedio           suma += adc1_get_raw( ADC1_CHANNEL_4 ); // Leer análogo         }         Valor de retorno = suma / NUM_READS;         descanso;       }     defecto:       {         adc1_config_channel_atten(ADC1_CHANNEL_5, Atenuación ADCA);         para (yo = 0; yo < NUM_READS; yo++) { // Algoritmo promedio           suma += adc1_get_raw( ADC1_CHANNEL_5 ); // Leer análogo         }         Valor de retorno = suma / NUM_READS;         descanso;       }   }   regreso Valor de retorno;
}

vacío Init_Blynk_APP()
{   Blynk.setProperty(V1, "etiqueta", MCalib.Nombre del sensor[0]);   Blynk.setProperty(V2, "etiqueta", MCalib.Nombre del sensor[1]);   Blynk.setProperty(V3, "etiqueta", MCalib.Nombre del sensor[2]);   Blynk.setProperty(V4, "etiqueta", MCalib.Nombre del sensor[3]);   Blynk.setProperty(V5, "etiqueta", MCalib.Nombre del sensor[4]);   Blynk.setProperty(V6, "etiqueta", MCalib.Nombre del sensor[5]);
}

vacío Update_Local_Display()
{   byte rojo1 = 0;   byte amarillo1 = 0;   byte verde1 = 0;   para (byte yo = 0; yo < Sensores de humedad adjuntos; yo++)   {     Si (MMeasure.DataValid[yo])     {       Si ( MMeasure.Por ciento[yo] > MCalib.StatusBorderPercentValues[yo][1])       {         verde1++;       } más Si ( MMeasure.Por ciento[yo] > MCalib.StatusBorderPercentValues[yo][0])       {         amarillo1++;       } más       {         rojo1++;       }     }   }   Si (rojo1 > 0)   {     SetLedConfig(255, 0, 0);   }   más Si (amarillo1 > 0)   {     SetLedConfig(0, 255, 0);   }   más Si (verde1 > 0)   {     SetLedConfig(0, 0, 100);   }   más   {     SetLedConfig(100, 100, 100);   }
}

vacío Update_Blynk_APP(byte Sensor, bool Calibrado)
{   cambiar (Sensor)   {     caso 0:       {         Si ((MMeasure.DataValid[0]) & (Calibrado))         {           Si ( MMeasure.Por ciento[0] > MCalib.StatusBorderPercentValues[0][1])           {             Blynk.setProperty(V1, "color", BLYNK_GREEN);           } más Si ( MMeasure.Por ciento[0] > MCalib.StatusBorderPercentValues[0][0])           {             Blynk.setProperty(V1, "color", BLYNK_YELLOW);           } más           {             Blynk.setProperty(V1, "color", BLYNK_RED);           }           retrasar(100);           Blynk.virtualWrite(V1, MMeasure.Por ciento[0]);         } más         {           Si (Calibrado)           {             Blynk.setProperty(V1, "etiqueta", "Deaktiviert");             retrasar(100);             Blynk.virtualWrite(V1, 0);             retrasar(100);             Blynk.setProperty(V1, "color", BLYNK_BLACK);           }           más           {             Blynk.virtualWrite(V1, 0);             retrasar(100);             Blynk.setProperty(V1, "color", BLYNK_BLUE);           }         }         descanso;       }     caso 1:       {         Si ((MMeasure.DataValid[1]) & (Calibrado))         {           Si ( MMeasure.Por ciento[1] > MCalib.StatusBorderPercentValues[1][1])           {             Blynk.setProperty(V2, "color", BLYNK_GREEN);           } más Si ( MMeasure.Por ciento[1] > MCalib.StatusBorderPercentValues[1][0])           {             Blynk.setProperty(V2, "color", BLYNK_YELLOW);           } más           {             Blynk.setProperty(V2, "color", BLYNK_RED);           }           retrasar(100);           Blynk.virtualWrite(V2, MMeasure.Por ciento[1]);         } más         {           Si (Calibrado)           {             Blynk.setProperty(V2, "etiqueta", "Deaktiviert");             retrasar(100);             Blynk.virtualWrite(V2, 0);             retrasar(100);             Blynk.setProperty(V2, "color", BLYNK_BLACK);           }           más           {             Blynk.virtualWrite(V2, 0);             retrasar(100);             Blynk.setProperty(V3, "color", BLYNK_BLUE);           }         }         descanso;       }     caso 2:       {         Si ((MMeasure.DataValid[2]) & (Calibrado))         {           Si ( MMeasure.Por ciento[2] > MCalib.StatusBorderPercentValues[2][1])           {             Blynk.setProperty(V3, "color", BLYNK_GREEN);           } más Si ( MMeasure.Por ciento[2] > MCalib.StatusBorderPercentValues[2][0])           {             Blynk.setProperty(V3, "color", BLYNK_YELLOW);           } más           {             Blynk.setProperty(V3, "color", BLYNK_RED);           }           retrasar(100);           Blynk.virtualWrite(V3, MMeasure.Por ciento[2]);         } más         {           Si (Calibrado)           {             Blynk.setProperty(V3, "etiqueta", "Deaktiviert");             retrasar(100);             Blynk.virtualWrite(V3, 0);             retrasar(100);             Blynk.setProperty(V3, "color", BLYNK_BLACK);           }           más           {             Blynk.virtualWrite(V3, 0);             retrasar(100);             Blynk.setProperty(V3, "color", BLYNK_BLUE);           }         }         descanso;       }     caso 3:       {         Si ((MMeasure.DataValid[3]) & (Calibrado))         {           Si ( MMeasure.Por ciento[3] > MCalib.StatusBorderPercentValues[3][1])           {             Blynk.setProperty(V4, "color", BLYNK_GREEN);           } más Si ( MMeasure.Por ciento[3] > MCalib.StatusBorderPercentValues[3][0])           {             Blynk.setProperty(V4, "color", BLYNK_YELLOW);           } más           {             Blynk.setProperty(V4, "color", BLYNK_RED);           }           retrasar(100);           Blynk.virtualWrite(V4, MMeasure.Por ciento[3]);         } más         {           Si (Calibrado)           {             Blynk.setProperty(V4, "etiqueta", "Deaktiviert");             retrasar(100);             Blynk.virtualWrite(V4, 0);             retrasar(100);             Blynk.setProperty(V4, "color", BLYNK_BLACK);           }           más           {             Blynk.virtualWrite(V4, 0);             retrasar(100);             Blynk.setProperty(V4, "color", BLYNK_BLUE);           }         }         descanso;       }     caso 4:       {         Si ((MMeasure.DataValid[4]) & (Calibrado))         {           Si ( MMeasure.Por ciento[4] > MCalib.StatusBorderPercentValues[4][1])           {             Blynk.setProperty(V5, "color", BLYNK_GREEN);           } más Si ( MMeasure.Por ciento[4] > MCalib.StatusBorderPercentValues[4][0])           {             Blynk.setProperty(V5, "color", BLYNK_YELLOW);           } más           {             Blynk.setProperty(V5, "color", BLYNK_RED);           }           retrasar(100);           Blynk.virtualWrite(V5, MMeasure.Por ciento[4]);         } más         {           Si (Calibrado)           {             Blynk.setProperty(V5, "etiqueta", "Deaktiviert");             retrasar(100);             Blynk.virtualWrite(V5, 0);             retrasar(100);             Blynk.setProperty(V5, "color", BLYNK_BLACK);           }           más           {             Blynk.virtualWrite(V5, 0);             retrasar(100);             Blynk.setProperty(V5, "color", BLYNK_BLUE);           }         }         descanso;       }     defecto:       {         Si ((MMeasure.DataValid[5]) & (Calibrado))         {           Si ( MMeasure.Por ciento[5] > MCalib.StatusBorderPercentValues[5][1])           {             Blynk.setProperty(V6, "color", BLYNK_GREEN);           } más Si ( MMeasure.Por ciento[5] > MCalib.StatusBorderPercentValues[5][0])           {             Blynk.setProperty(V6, "color", BLYNK_YELLOW);           } más           {             Blynk.setProperty(V6, "color", BLYNK_RED);           }           retrasar(100);           Blynk.virtualWrite(V6, MMeasure.Por ciento[5]);         } más         {           Si (Calibrado)           {             Blynk.setProperty(V6, "etiqueta", "Deaktiviert");             retrasar(100);             Blynk.virtualWrite(V6, 0);             retrasar(100);             Blynk.setProperty(V6, "color", BLYNK_BLACK);           }           más           {             Blynk.virtualWrite(V6, 0);             retrasar(100);             Blynk.setProperty(V6, "color", BLYNK_BLUE);           }         }         descanso;       }   } // Interruptor final
}

vacío Get_Moisture_DatainPercent()
{   byte CalibDataOffset = 0;   para (byte yo = 0; yo < Sensores de humedad adjuntos; yo++)   {     CalibDataOffset =  yo * 2;     En t RawMoistureValue = ReadMoistureSensor_Raw_Val(yo);     Si ((MCalib.Datos[CalibDataOffset] == 0) || (MCalib.Datos[CalibDataOffset + 1] == 0)) // Valor MinADC valor maxADC ADC     {       MMeasure.Por ciento[yo] = RawMoistureValue;       MMeasure.DataValid[yo] = falso;     } más     {       RawMoistureValue = MCalib.Datos[CalibDataOffset + 1] - RawMoistureValue;       RawMoistureValue = MCalib.Datos[CalibDataOffset] + RawMoistureValue;       MMeasure.Por ciento[yo] = mapa(RawMoistureValue, MCalib.Datos[CalibDataOffset], MCalib.Datos[CalibDataOffset + 1], 0, 100);       Si ((MMeasure.Por ciento[yo] > 100 ) | (MMeasure.Por ciento[yo] < 0 ))       {         MMeasure.Por ciento[yo] = RawMoistureValue;         MMeasure.DataValid[yo] = falso;       } más  {         MMeasure.DataValid[yo] = cierto;       }     }   }   regreso ;
}

vacío Run_MoistureSensors (bool En eso)   // HauptFunktion zum Betrieb der Bodenfeuchtesensoren
{   byte MinSensValue = 100;   Si ((millis() - Moisure_ServiceCall_Handler >= MoisureSens_Poll_Interval) | (En eso))   {     Moisure_ServiceCall_Handler = millis();     Get_Moisture_DatainPercent();     para (En t yo = 0; yo < Sensores de humedad adjuntos; yo++)     {       Si (MMeasure.DataValid[yo])       {         Si (MMeasure.Por ciento[yo] != MMeasure.Porcentaje antiguo[yo])         {           MMeasure.Porcentaje antiguo[yo] = MMeasure.Por ciento[yo];           Si (MMeasure.Por ciento[yo] < MinSensValue ) {             MinSensValue = MMeasure.Por ciento[yo];           };           De serie.impresión(F("Sensor Feuchtigkeitswert"));           De serie.impresión(yo);           De serie.impresión(F("en Prozent:"));           De serie.impresión(MMeasure.Por ciento[yo]);           De serie.println(F(" %"));           Update_Blynk_APP(yo, Sens_Calib);    // Aktualisiere Handywerte         }       } más       {         Update_Blynk_APP(yo, Sens_NOTCalib);    // Aktualisiere Handywerte         De serie.impresión(F("Sensor"));         De serie.impresión(yo);         De serie.impresión(F("nicht kalibiert. Bitte kalibrieren. Rohdatenwert:"));         Serial.println(MMeasure.Percent[i]);       }     }     Update_Local_Display();           // se Actualiza el local Pflanzenwächter Display (Led)   }
}

// Main Loop
void loop()
{   Run_MoistureSensors(false);   Blynk.run();   // Execute Blync Basic Functions
} 

es antes de la carga en nuestros ESP tener en cuenta los siguientes Parámetros/Líneas de código a las Necesidades que se deben:

int Datos[MaxSensors*2] = {0,0,0,0,0,0,0,0,0,0,0,0,};

los Valores, según se describe en la Parte 1 de la Serie personalizar.

#define MoisureSens_Poll_Interval 300000

Intervalo de tiempo entre dos Bodenfeuchtemessungen en Milisegundos. El Valor que tiene en él la Influencia de la frecuencia en que los datos móviles se actualizan, y, por tanto, el Volumen de datos que para la Transmisión por Hora de crédito. Cuanto mayor sea, mayor será el Intervalo más amplio. Por favor, en un Valor que sea el propio Volumen de datos o Presupuesto se ajusta. [Ejemplo: 300000 ms = 5 Minutos Datenübertragungsintervall}

char auth[] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
char ssid[] = "Deine_WLAN_SSID";
char pass[] = "Tu _WLAN _Passwort!";

Los valores, según se describe en la Parte 2 de la Serie personalizar.

Se pueden utilizar los siguientes Parámetros/Líneas de código, a las Necesidades:

String SensorName[MaxSensors] = {"Planta 1","Planta 2","Planta 3","Planta 4","Planta 5","Planta 6"};

Feuchtesensorname en la APP, como un Título que se muestra.

byte StatusBorderPercentValues[MaxSensors*2][2]= { {10,50}, .....

 Matriz bidimensional de Prozentgrenzwerte (Semáforo), de uno en uno por Sensor de humedad (1 -6). Tiene Influencia en el "Semáforo" Visualización y la Visualización de los Valores de la APP. La primera, ¿Quién (10) indica el límite de transición entre el Estado de "rojo" y el Estado "amarillo" en. El segundo Valor indica el límite de transición entre el Estado de "amarillo" y el Estado "verde" en. Ejemplo: a partir de 51 % de Humedad del suelo "verde" a partir de 9% de Humedad del suelo "rojo".

Si todos los Parámetros son correctos se ha definido si la Salida en el serial Monitor ahora de la siguiente manera:

Nota: En este Ejemplo, en lugar de max6. a sólo 5 Sensores

tenemos Que HandyApp ni a los cambios de Hardware y Firmware personalizado.

Ya que en nuestro Blynk HandyAPP sólo 2000 puntos de Energía Disponibles de forma gratuita, tenemos que actuar con 6 Sensores conectados algo indígenas. En el primer Paso, vamos a borrar, por lo tanto, en la segunda Parte a la escala de "Gauge" Elemento.

El "Gauge" Elemento, vamos a sustituir por el "Nivel H" Elemento

Ahora vamos a añadir, pues, la Indicación de la Humedad del suelo, el Energiegünstigere Elemento "Nivel H" de un total de 6 veces, agregó.

Ahora, si nuestra Superficie similar a esto:

Ahora tenemos tres Valores que intervienen en las Propiedades de los 6 Elementos de personalización. A modo ejemplificativo, os muestro aquí la Configuración de la primera Sensor

, La más importante de Adaptación es la de Entrada Variable. Esta continua para cada "Nivel H" Elemento desde Input "V1" para la Planta 1 hasta "V6" para la Planta 6 definirse. "V" es sinónimo de "Virtual Pins" y permitir una Asociación entre los Elementos de la APLICACIÓN y las Instrucciones en el Código. También nosotros, como valor Mínimo 0 y Máximo 100. Como tercer paso, vamos a definir como Reading Tasa de "Push" un. En el Diseño de cualquier Color, cualquier Tamaño y cualquier Nombre elegido, ya que este Parámetro, más tarde, a través de nuestro Programa en el ESP establece o define).

El Resultado final, en caso de Activación del Proyecto ahora debe ser similar a la siguiente:

(el último Sensor se desactiva, ya que yo en el Ejemplo, sólo 5 Sensores he conectado. En el caso de Uso de 6 Sensores, el Campo se activa automáticamente)

para obtener Más Información sobre las Blynk APLICACIÓN y su Uso en los Controladores, y los encontrarás en la sección

• Blynk Introducción -> https://www.blynk.cc/getting-started
• Documentación -> http://docs.blynk.cc/
• Sketch Generador -> https://examples.blynk.cc/
• Última Blynk Biblioteca -> https://github.com/blynkkk/blynk-library/releases/download/v0.6.1/Blynk_Release_v0.6.1.zip
• lo más reciente Blynk server -> https://github.com/blynkkk/blynk-server/releases/download/v0.41.5/server-0.41.5.jar
• Blynk Inicio -> https://www.blynk.cc

espero que disfruten de la Reprap, y hasta la próxima Vez.