Medidor de PH con pantalla gráfica JLX12864.

La Pantalla LCD 128x64 JLX12864G-086 es una una estupenda pantalla con pines para una interfaz SPI.
Este modelo cuenta con un regulador de voltaje integrado lo que permite conectarla directamente a 5 Voltios.
La pantalla LCD 128x64 JLX12864G-086 es una gran opción para ser utilizada en lugar de la pantalla del Nokia 5110.
Entre sus principales características destaca su diseño sencillo, compacto y estando integrado en una placa que dispone de 4 perforaciones para su fijación, con todos los componentes necesarios para su funcionamiento.
Dispone de LED (backlight) que facilita la visualización de datos, contribuyendo así a la mejora de los proyectos realizados por los diseñadores. Para poder usar esta pantalla necesitamos la biblioteca U8glib que se puede descargar de distintos lugares en Internet y tenemos las siguientes conexiones para este ejemplo.
CS :   8
RST : 9
RS :   10
SPI_SDA : 18 
SPI_SCK : 19
VDD :   3v3 
LEDA : 5v  

También vamos a usar el sensor PHE201 - BNC y la interfaz PL4502 para vincular este sensor a una placa Arduino. 
Recordemos que el pH es una medida de acidez o alcalinidad de una disolución, la escala de pH varía de 0 a 14. 
El pH indica la concentración de iones hidrógeno [H]+ presentes en determinadas disoluciones. Se puede cuantificar de forma precisa mediante un sensor que mide la diferencia de potencial entre dos electrodos, un electrodo de referencia (de plata/cloruro de plata) y un electrodo de vidrio que es sensible al ion de hidrógeno.
Esto es lo que formará la sonda PHE201, la interfaz PL4502 es el circuito electrónico para acondicionar la señal y poder conectarla a un microcontrolador como Arduino.
Los sensores para medir ph son delicados (además de costosos) es por esto que debemos tener especial cuidado al usarlos y sobre todo cuando dejamos de usarlos asegurar que la sonda de vidrio este correctamente limpia con agua destilada.
Si bien este sensor no califica como un sensor "profesional" su precisión en la medición no le envidia nada a un sensor de laboratorio. Si lo vamos a usar de manera continua, por ejemplo sumergido constantemente en el agua de un acuario la vida útil del electrodo sera de unos cuatro años.
Para conectarnos con el microcontrolador la interfaz ofrece los siguientes pines de control:

• To: Temperatura.
• Do: Señal del limite de ph
• Po: Valor de ph en voltios (conectado A0 en el ejemplo)
• G:  Masa del circuito analogico.
• G:  Masa del circuito digital.
• V+: Alimentación de 5V.

La interfaz que vincula el sensor al Arduino tiene dos pre-set, el que esta mas próximo al conector BNC será el que se usa para calibrar el sensor (no viene calibrado). La medición del sensor es lineal y para ajustarlo necesitamos dos buffers que generalmente vienen con el propio sensor, uno de ph 4.01 y otro de ph 6.86. 
Considerando que el sensor es lineal con estos dos buffers podemos usar un poco de matemática para convertir el voltaje medido en cada uno de estos dos puntos de ph.
La formula general sería A = MX + B, por lo que tenemos tenemos que calcular M y B ya que X sería el voltaje y  A el ph.
El resultado es  A = -5.70x + 21.34, en nuestro caso usamos un medidor de ph comercial para ajustar el sensor bajo prueba.

Como se puede ver en la imagen la exactitud del sensor respecto de uno comercial es muy buena, en realidad la única diferencia que encontramos de este sensor con sus referentes comerciales es la duración en un uso intensivo y continuo.
Otra cosa a tener en cuenta es que es recomendable montar la interfaz de tal forma de tener acceso al pre-set de calibración ya que si el sensor pasa mucho tiempo sin uso seguramente sera necesario hacer algún ajuste de calibración par volver a usarlo.
El segundo pre-set sirve para fijar el umbral de disparo de una alarma a un determinado nivel de ph, la interfaz tiene dos led's, uno verde que indica que está funcionando y uno rojo para avisar el disparo de la alarma de ph.
El resultado mostrado en la imagen anterior se obtuvo con el siguiente código:

/********************************************************************
 * Descripción: Medición del PH con sensor PHE201 + Interfaz PL4502.
 *              Datos mostrados en pantalla LCD JLX12864G.           
 * Placa Arduino: NANO
 * Arduino IDE: 1.8.15
 *
 * www.firtec.com.ar
********************************************************************/
#include "U8glib.h"  // Biblioteca para el control de pantalla
const int analogInPin = A0; 
int sensorValue = 0; 
unsigned long int conversor; 
float b;
int buf[10],temp;
char buffer[20] = "0";
U8GLIB_NHD_C12864 u8g(19, 18, 8, 10, 9);    // Arduino NANO
//U8GLIB_NHD_C12864 u8g(13, 11, 8, 10, 9);  // Arduino UNO 
 
void Medir_PH(void);
 
void draw(void) {
  u8g.setFont(u8g_font_10x20r);
  u8g.drawStr( 8, 17, "Nivel de PH");
  u8g.drawHLine(0,0, 128);    // Linea horizontal superior
  u8g.drawHLine(0,63, 128);   // Linea horizontal inferior
  u8g.drawVLine(0, 1, 64);    // Linea vertical izquierda
  u8g.drawVLine(127, 1, 64);  // Linea vertical derecha
  u8g.setFont(u8g_font_6x12);
  u8g.setFont(u8g_font_osb21);
  u8g.drawStr( 43, 46, buffer);
  u8g.setFont(u8g_font_6x12r);
  u8g.drawStr(10, 60, "Control Hidroponia");
}
/************************************************
**  Configuración del hardware
************************************************/
void setup(void) {
  u8g.setContrast(0); // Configura el contraste
  u8g.setRot180();    // Rota la pantalla (si fuera necesario)
}
/************************************************
**  Bucle principal del programa
************************************************/
void loop(void) {
  u8g.firstPage();  // Muestra la pagina principal
  do {
    draw();
  } 
  while( u8g.nextPage() );
  Medir_PH();       // Obtiene el valor del PH
}
/************************************************
**  Función encargada de medir el PH
**  Sensor:   PHE201 - BNC
**  Inerface: PL4502
************************************************/
void Medir_PH(void){
   for(int i=0;i<10;i++) 
 { 
  buf[i]=analogRead(analogInPin);
  delay(10);
 }
 for(int i=0;i<9;i++)
 {
  for(int j=i+1;j<10;j++)
  {
   if(buf[i]>buf[j])
   {
    temp=buf[i];
    buf[i]=buf[j];
    buf[j]=temp;
   }
  }
 }
 conversor=0;
 for(int i=2;i<8;i++)
 conversor+=buf[i];
 float pHVol=(float)conversor*5.0/1024/6;
 float Valor_PH = -5.70 * pHVol + 21.34;
 dtostrf(Valor_PH, 1, 1, buffer);
 delay(100);
}
//*************** Fin del archivo Firtec Argentina ********************

El código en si es bastante simple quedando bajo el control de la correspondiente biblioteca todo el control de la pantalla LCD.
Desde este link podemos ver como configurar muchas otras fuentes para mostrar los mensajes, también en este otro link tenemos información de otras funciones de la biblioteca U8glib.

[MATERIAL EXTRAÍDO DE UNO DE NUESTROS LIBROS TÉCNICOS]

Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo. 

Las semillas necesitan tener condiciones propicias para germinar y una de ellas es la temperatura, por eso si queremos adelantar la época de siembra para adelantar los cultivos unos meses será necesario proporcionar la temperatura adecuada.  
Un semillero de cama caliente no es mas que un semillero al cual le estamos añadiendo un componente que haga que suba la temperatura ambiente y así nuestra semilla pueda germinar, casos como por ejemplo los tomates o los pimientos son plantas que sin una temperatura de unos 20ºC o 25ºC no germinarían.
Con este proyecto podemos construir semillero de cama caliente con un costo muy económico. 
Para esto solo necesitaremos una bandeja de plástico algo gruesa no muy profunda, un cable calefactor, un poco de arena, piedra sanitaria para gatos y un poco de electrónica.

Caja de plástico con el cable calefactor instalado.

En el fondo de la caja colocamos un colchón de arena para que el cable no este en contacto directo con la caja de plástico, luego cubrimos la arena con una fina capa de piedras sanitarias para gatos, esto por si algo de agua de las bandejas de germinación se filtra al sustrato.

Piedras sanitarias sobre la capa de arena.

Para contener la electrónica se usó una caja estanca que se adosó a la caja que contiene las bandejas de cultivo.

Caja conteniendo toda la electrónica.

El sistema de control está compuesto por un Arduino NANO que ejecuta un programa PID para controlar un contactor de estado solido opto-acoplado.
La caja de control se comunica mediante un enlace Bluetooth a un móvil donde envía la temperatura del sustrato y la potencia aplicada al cable calefactor. (Se puede usar cualquier aplicación para visualizar los datos enviados).
El código para Arduino es el siguiente.

/*********************************************************************************
   Descripción: Ejemplo para PID usando las bibliotecas de Arduino
                El objetivo es mantener la temperatura dentro de una
                caja de acuerdo al valor de un Set Point.
                El sensor usado es un DS18B20 conectado en el pin 10 
                y la salida para el control PID en el pin 3 (PWM).
                El envío de datos se hace mediante un enlace Bluetooth
                Kp, Ki y Kd se ajustan de manera experimental.
 
   Placa Arduino: NANO
   Arduino IDE: 1.8.13
   www.firtec.com.ar
************************************************************************************/
#include <PID_v1.h>
#include <OneWire.h>
#include <avr/wdt.h>
#include <DallasTemperature.h>
#include <SoftwareSerial.h>
#define ledPin 13   
#define alarma 14   
SoftwareSerial mySerial(11, 12); 
 
OneWire UnWire(10);
DallasTemperature sensor(&UnWire);
byte retardo = 0;   // Usado para enviar datos por Bluetooth cada 5 segundos
int salidaPWM = 3;  					// Salida de señal PWM
double temp, error, Setpoint, Output; 	// Variables del PID
double Kp = 7, Ki = 8.5, Kd = 4.5; 		// Ajustes empírico del PID
byte potencia;
char buffer[10] = "";
volatile bool flag_txt = false;
PID myPID(&temp, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);
 
long map(long x, long in_min, long in_max, long out_min, long out_max){
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
 
void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(alarma, OUTPUT);
  digitalWrite(alarma, LOW); 
  noInterrupts(); 
  TCCR1A = 0;                // El registro de control A queda todo en 0
  TCCR1B = 0;                // limpia registrador
  TCNT1  = 0;                // Inicialíza el temporizador
  OCR1A = 0x3D09;            // Carga el registrador de comparación: 16MHz/1024/1Hz = 15625 = 0X3D09
  TCCR1B |= (1 << WGM12)|(1<<CS10)|(1 << CS12);   // Modo CTC, prescaler de 1024: CS12 = 1 e CS10 = 1  
  TIMSK1 |= (1 << OCIE1A);  // Habilita interrupción por igualdad de comparación
  TIMSK1 |= (1 << TOIE1);   
  interrupts();             
  mySerial.begin(9600);
  pinMode(salidaPWM, OUTPUT);  
  Setpoint = 30;
  myPID.SetMode(AUTOMATIC); // Configura y activa PID
  myPID.SetOutputLimits(0, 255);
  wdt_disable();
  wdt_enable(WDTO_4S);
 
}
void loop() {
  wdt_reset(); // Borra el contador del wachdog
  sensor.requestTemperatures();
  temp = sensor.getTempCByIndex(0);
  myPID.Compute(); // Calcula salida PWM
  analogWrite(salidaPWM, Output);
  dtostrf(temp, 2, 1, buffer);
  if((temp < 28) | (temp > 32)) // Alarma por debajo de 28 o superior a 32
    digitalWrite(alarma, HIGH); 
  else
    digitalWrite(alarma, LOW); 
  potencia = map(Output, 0, 255, 0, 100); // Escala la potencia del calefator
  if(flag_txt == true){
    retardo++;
    if(retardo == 5){   // Enviar datos por Bluetooth?
      mySerial.print("Temperatura Sustrato: ");
      mySerial.println(buffer);
      mySerial.print("Calefactor al ");
      mySerial.print(potencia);
      mySerial.println("%");
      retardo = 0;
      wdt_reset(); 		// Borra el contador del wachdog
    }
    wdt_reset(); 		// Borra el contador del wachdog
    flag_txt = false; 	// Borra bandera de INTE
  }
 
}
 
ISR(TIMER1_COMPA_vect) // Interrupción por igualdad de de comparación en TIMER1
{
   flag_txt = true;    // Bandera para controlar el Bluetooth
}

Placa Arduino montada en la caja estanca.

El sensor de temperatura es un DS18B20 conectado al pin 10 de Arduino, el sensor se coloca en algún punto alejado del cable calefactor para tener una medición mas exacta de la temperatura de todo el sustrato.
Para el control PID se utiliza una biblioteca que resuelve todos los enredos matemáticos del PID.
Para el control de potencia podemos usar un relay de estado sólido o un Triac y un opto-acoplador con detección de cruce por cero.

Relay de estado sólido usado en el ejemplo.

Con un sistema como el propuesto podemos realizar siembras de tomates, morrones, berenjenas, etc a mediados de Julio para tener plantines listo para el trasplante a fines de Septiembre y cosechar los primeros frutos al inicio de Diciembre.

También se puede agregar una iluminación adecuada para el crecimiento de plantas.

El funcionamiento del proyecto tiene un resultado excelente, probado en climas de Argentina.
Material extraído del libro "PROYECTOS CON ELECTRÓNICA".

Nextion es probablemente una de las mejores opciones para crear proyectos con electrónica, podemos hacerlas funcionar con cualquier microcontrolador que disponga de un puerto serial. Para crear una interfaz gráfica en una pantalla Nextion usaremos el editor Nextion, un software provisto por el propio fabricante que hace la tarea del diseño realmente simple.
Una vez que tenemos todo los elementos de la interfaz desplegados en la pantalla se envía la programación a la propia pantalla usando una simple conexión serial.
Este editor de Nextion es la mejor solución, en realidad casi la única para crear proyectos con estas pantallas inteligentes.
Lamentablemente solo existe en versión para Windows que se descarga a través del enlace oficial de Nextion.
Proponemos diseñar la siguiente interfaz gráfica.La pantalla dispone solamente de 4 pines. Dos de ellos son de alimentación (cable rojo y negro) y los otros dos son de recepción para el envío de datos por la conexión serial, recepción cable amarillo y transmisión cable azul, para conectar la pantalla a Raspberry PI estos cables se deben conectan cruzados TX con el cable amarillo y RX con el cable azul. 
La pantalla se programa por medio de una conexión serial desde el propio editor Nextion, para programar la pantalla se debe desconectar de Raspberry y conectarla al computador mediante un adaptador USB-RS232.
Cuando queremos mostrar un dato en la pantalla solo “apuntamos” al componente de la pantalla donde queremos enviar los datos y enviamos la información que se me mostrará donde se indicó, en este ejemplo hay una ventana donde se muestran datos de conversión que se identifica como n0 y que tiene una propiedad que se llama val. Solo debemos apuntar al objeto y su propiedad para mostrar los datos.

Sin embargo los mensajes están estructurados en un protocolo propio que se debe conocer para poder dialogar con la pantalla, los mensajes tienen el siguiente formato 65000501FFFFFF donde el número 65 indica que no hay errores, el siguiente número es la página (una interfaz gráfica puede tener varias páginas), luego tenemos el ID del componente que ha enviado el mensaje, luego el evento y por último tres bytes con FF que son los indicativos de fin de trama.
Por ejemplo imagine que quiere enviar datos al panel n0 desde Python escribimos lo siguiente:

puerto.write(b"n0.val=" + str(dato).encode() + b"\xFF\xFF\xFF")

El indicativo b dice que estamos enviando una cadena de bytes, en dato está el valor a mostrar y finalmente los tres bytes de EOF.
Si quiero recibir un evento desde la pantalla tengo que analizar la trama para saber desde cual página, cual elemento y que acción me esta llegando.
Como en este ejemplo solo tenemos una página y un solo botón las cosas son bastantes simples solo basta el siguiente código para saber cuando el botón envía mensajes y encender un LED según el caso.

datos_nextion = binascii.hexlify(puerto.readline())
mensaje = str(datos_nextion) 
for indice in range(len(mensaje)): 
          if indice > 3:
                        if mensaje[7] == "3" and bandera == 0: 
                                    bandera = 1 
                                    GPIO.output(16, 0) 
                       else:
                                    GPIO.output(16, 1) 
                                    bandera = 0 

El código completo para leer datos de un conversor MCP3201 y mostrarlos en un panel, también se detecta la acción de un botón para cambiar el estado de un LED conectado a un pin del puerto Raspberry.

import binascii
import time
import spidev
from serial import Serial
import RPi.GPIO as GPIO # Modulo para gestionar los pines GPIO
GPIO.setwarnings(False) # Ignora las advertencias
GPIO.setmode(GPIO.BCM) 	# Los pines serán referidos como Broadcom
spi = spidev.SpiDev()
spi.open(0, 0)
spi.max_speed_hz = 7629
time.sleep(1)
GPIO.setup(16, GPIO.OUT)# Pin 16 será salida
GPIO.output(16, 1)
 
puerto = Serial("/dev/ttyS0", baudrate=9600, timeout=0.2)
if puerto.isOpen() == False:
    puerto.open()
 
puerto.flushInput()
puerto.flushOutput()
bandera = 0
 
 
def Conversor():  # Lee el conversor MCP3201
    
    adc = spi.xfer2([0, 0])
    hi = (adc[0] & 0x1F);
    low = (adc[1] & 0xFe);
    dato = (hi << 8) | low;
    puerto.write(b"n0.val=" + str(dato).encode() + b"\xFF\xFF\xFF")
    
while 1:
    Conversor()
    try:   # Recibe los datos desde la pantalla Nextion     
        datos_nextion = binascii.hexlify(puerto.readline()) 
        mensaje = str(datos_nextion)        # Procesa los datos recibidos
        for indice in range(len(mensaje)):  # Recorre los bytes del mensaje
            if indice > 3:                  # Pantalla envió un mensaje?
                if mensaje[7] == "3" and bandera == 0:  # Mensaje del objeto?
                    bandera = 1             # Avisa que el LED está apagado
                    GPIO.output(16, 0)      # Pin 16 pasa a nivel bajo
                else:
                        GPIO.output(16, 1)  # Pin 16 pasa a nivel alto
                        bandera = 0         # Avisa que el LED está encendido
 
        puerto.flushInput()
        puerto.flushOutput()
        
    except (KeyboardInterrupt, SystemExit):
        puerto.close()
        spi.close()
        GPIO.cleanup()
        raise

En este ejemplo no interesa la página puesto sabemos que es 0 y el botón tiene el ID 3 (podrías ser cualquier número) que también sabemos viene en el casillero 7 de acuerdo a como Python 3 ensambla la trama de recepción.
El resultado final de la aplicación en funcionamiento es el siguiente:

Todo el manejo de pantallas Nextión lo encontrará en nuestros Libros Técnicos.

Los robots por software pueden resultar muy útiles a la hora del desarrollo de sistemas de control, mediante el uso de un Bot vamos a iniciar un chat por Telegram con una placa electrónica para leer datos de un sensor BME280 y controlar el estado de un pin.
Telegram fué anunciada oficialmente en el 2013, está enfocada a la mensajería instantánea, el envío de varios archivos y la comunicación en masa, la aplicación se parece mucho a WhatsApp con algunas funciones extras.
La idea es conectar ESP32 programado con el IDE de Arduino para que envíe mensajes de chat a Telegram, también se puede hacer lo mismo para WhatsApp sin embargo debido a las bibliotecas disponibles en este momento, es mas simple conectar con Telegram.
Para ensamblar el proyecto vamos a necesitar algunas bibliotecas siendo necesario que la versión de ArduinoJson encargada de manejar los textos de los mensajes enviados hacia y desde Telegram sea versión 5.x ya que versiones superiores no funcionan con la biblioteca de Arduino para Telegram.   

• ArduinoJson-5.x.x.
• Universal-Arduino-Telegram-Bot.
• Bibliotecas para programar ESP32.

NOTA:
Para agregar las bibliotecas necesarias para el manejo de ESP32 con Arduino vamos a Archivos > Preferencias > Gestor de URLs Adiciones de Tarjetas y agregamos la siguiente línea: https://dl.espressif.com/dl/package_esp32_index.json

Leer más...