Electrónica y programación para Microcontroladores.

Libros técnicos para electrónica programable.

Email
Contactanos en:

consultas@firtec.com.ar

Arduino

Revolviendo viejos cacharros electrónicos en desuso encontré un viejo sistema de alarma que que si bien es funcional no tiene la posibilidad de conectar con nada excepto con un par de controles remotos para manejar sus funciones.
Se me ocurrió montarla en un deposito que está a varias calles de mi casa pero claro lo ideal seria poder controlar su estado y saber si se dispara o no. Como la alarma no tiene conectividad pero el deposito tiene conexión a Internet entonces me propuse construir un dispositivo que fuera capaz de actuar sobre los botones del control remoto y para eso desmonte uno de los controles dejando su placa al descubierto. Inicialmente arme todo en un proto-board para verificar su funcionamiento.

Como tenia un par de relay usados con Arduino, use uno para actuar en cada botón ACTIVAR y DESACTIVAR y el estado de la alarma lo veo monitoreando el voltaje de salida que activa una sirena de 12V, si hay voltaje la sirena suena y por lo tanto la alarma se disparo, para censar este voltaje uso un acoplador óptico PC817.
El cerebro de todo el proyecto es una placa Pico W que se conecta a Internet a un broker MQTT gratuito que cree en el sitio HiveMQ.

El código completo en MicroPython es el siguiente:

"""
**************************************************
Objtivo: Monitor del estado de una alarma 
         por Internet con MQTT
Electrónica: Pico W + CD4001 + PC817
Autor. Daniel Schmidt
***************************************************
"""
 
from machine import Pin
from time import sleep
import network
from umqtt.simple import MQTTClient
import config
import time
from machine import WDT
 
topic_sub = b'casa/activar'
topic_sub_d = b'casa/desactivar'
led= machine.Pin('LED', machine.Pin.OUT)
led.value(0)
MQTT_TOPIC_ESTADO = 'alarma/estado'
 
# Parametros del MQTT
MQTT_SERVER = config.mqtt_server
MQTT_PORT = 0
MQTT_USER = config.mqtt_username
MQTT_PASSWORD = config.mqtt_password
MQTT_CLIENT_ID = b"raspberrypi_casa"
MQTT_KEEPALIVE = 7200
MQTT_SSL = True   
MQTT_SSL_PARAMS = {'server_hostname': MQTT_SERVER}

#Pines asignados
broker_ok = Pin(12, Pin.OUT)
broker_ok.value(0)
wifi_ok = Pin(13, Pin.OUT)
wifi_ok.value(0)
estado = Pin(16, Pin.IN)
activar = Pin(14, Pin.OUT)
activar.value(0)
desactivar = Pin(15, Pin.OUT)
desactivar.value(0)
verificar = Pin(17, Pin.IN, Pin.PULL_UP)
estado = Pin(16, Pin.IN)
 
def sub_cb(topic, msg):
    msg = msg.decode('utf-8')
    #print(msg)
    if msg == '1':
       activar.on()
    elif msg == '0':
       activar.off()
    if msg == '2':
       desactivar.on()
    elif msg == '0':
       desactivar.off()
   
def initialize_wifi(ssid, password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(ssid, password) # Conectado con la red WiFi
    while not wlan.isconnected():
        wifi_ok.toggle()
        print("Conectando a la red Wi-Fi...")
        time.sleep(1)
    wifi_ok.value(1)
    print('Conectado al WiFi!!')
    network_info = wlan.ifconfig()
    print('IP address:', network_info[0])
    return True
 
def connect_mqtt():
    try:
        client = MQTTClient(client_id=MQTT_CLIENT_ID,
                            server=MQTT_SERVER,
                            port=MQTT_PORT,
                            user=MQTT_USER,
                            password=MQTT_PASSWORD,
                            keepalive=MQTT_KEEPALIVE,
                            ssl=MQTT_SSL,
                            ssl_params=MQTT_SSL_PARAMS)
        client.connect()
        client.set_callback(sub_cb) # Asocia la función de retorno (IMPORTANTE!!)
        return client
    except Exception as e:
        print(f"Shit.... el broker no me atiende :(: {e}")
        return None
    
 
def publish_mqtt(topic, value):
    client.publish(topic, value)
    #print("Publicado:", value)
 
try:
    wifi_ok.value(0)
    time.sleep(10)
    if not initialize_wifi(config.wifi_ssid, config.wifi_password):
        print('Shit!!!! el WiFi... no conecta :(')
    else:
        # Conéctar al broker MQTT e inicie el cliente MQTT.
        client = connect_mqtt()
        wdt = WDT(timeout=8000)  # Habilita el watchdog para 8 Segundos
        while True:
            if client is None:
                broker_ok.toggle()
                print("Intentando reconectar...")
                client = connect_mqtt()
                wdt.feed()   # Borra el WD -------
                time.sleep(5) # Esperar antes de reintentar
            try:
                client.ping() # Verificar la conexión
                broker_ok.value(1)
                client.subscribe(topic_sub)
                client.subscribe(topic_sub_d)
                if (verificar.value() == 0):
                    estado = 'Activada'
                else:
                    estado = 'Apagada'
                # Publica el estado de alarma
                wdt.feed()   # Borra el WD -------
                publish_mqtt(MQTT_TOPIC_ESTADO, str(estado))
                wdt.feed()   # Borra el WD -------
                time.sleep(5)
            except Exception as e:
                broker_ok.value(0)
                print(f"Se perdió la conexión MQTT. {e}")
                client.disconnect() # Desconectar el cliente anterior
                client = None # Marcar como no conectado para que el bucle se reconecte
                wdt.feed()   # Borra el WD -------
                time.sleep(5)
 
except Exception as e:
    print('Error:', e)
    machine.reset()

En el archivo config.py se almacenan las credenciales de acceso a la red WiFi como también el acceso al broker.

1
2
3
4
5
6
wifi_ssid = 'xxxxxxxx'
wifi_password = 'xxxxxxxxxxx'
mqtt_server = b'xxxxxxxxxxxxxxxxxxxxxxxxxxxx.s1.eu.hivemq.cloud'
mqtt_username = b'xxxxxxxxxxx'
mqtt_port = '8883'
mqtt_password = b'xxxxxxxxxxx'

El funcionamiento sorprende por la estabilidad del broker, realmente muy bueno tanto que voy agregarle mas funciones como control de luces, botón de pánico Incluso el envío de mensajes por WS o Telegram avisando a alguien mas sobre lo que está sucediendo.

El funcionamiento es muy simple, la placa electrónica cada 5 segundos me envía el estado de alarma que veo en una aplicación que descargue del PlayStore, del montón de app que hay esta cumple con lo que necesito.

Si la alarma se activa en el teléfono suena una alarma para indicar que hay un intruso. Si quiero activar la alarma oprimo el botón correspondiente y  el programa envía un comando al broker que a su vez lo envía a la placa electrónica que actúa sobre el relevador correspondiente y le "hace creer" al control remoto que un dedo humano activo el botón lo mismo para desactivar.
Una vez que el sistema esta conectado se pueden sumar tantas funciones como comandos sean enviados.

Esta claro que se podrían eliminar los relay y hacerlo todo mas "electrónico" pero como salio funcionando a la primera así se quedo.
Toda esta maraña de cables lleva ya dos semanas funcionando sin problemas así que el paso siguiente será soldar todo en una placa colocarlo en una caja y montar todo en el lugar definitivo. Es de notar que todo este control y o acción sobre la alarma o el sistema bajo control es totalmente gratuito el único costo realmente muy bajo son los componentes para el montaje y basta que nuestro móvil tenga acceso a Internet tendremos control del sistema desde cualquier parte del mundo.
Luego estaré subiendo el diagrama electrónico.

 

 

 

Las palomas si bien son aves simpáticas pueden dejar de serlo cuando deciden de manera insistente construir su nido en el compresor del sistema de aire acondicionado.
Esto ademas de ser molesto por la cantidad de basura que generan al construir su nido resulta peligroso para las propias palomas y  para el equipo de aire acondicionado .
Como la idea es tratar de convencer a las palomas de que se busquen otro lugar sin hacerles daño se me ocurrió construir este pequeño dispositivo usando el sensor ultrasónico HC-SR04 un Arduino Nano y algunos componentes extras como un potenciómetro de 10K, dos display cátodo común  y dos transistores BC337.

El objetivo es usar el sensor para detectar palomas en donde no deben estar y activar una señal sonora que las espante cada vez que se acerquen a la zona de cobertura. El sistema cuenta con un potenciómetro que ajusta el rango de alcance donde se debe  activar el sistema "espanta palomas", este rango se visualiza en dos dígitos.
El rango se puede cambiar actuando sobre el botón de programación y moviendo el potenciómetro, el nuevo valor se almacena en memoria EEPROM por lo tanto el sistema siempre "recuerda" el valor fijado aunque su alimentación se pierda.
El siguiente es el código completo del trabajo propuesto.

/******************************************************************************
** Detector de proximidad por ulatrasonido con Arduino y sensor SRF-04.
** El ejemplo incluye un ajuste de rango que va desde 1 cmts. a 50 cmts. 
** mediante un potenciómetro y la posibilidad de ver el rango en dos dígitos
** con multiplexor de dos transistores BC337 y un decodificador BCD CD4511.
**
** Target: Arduino nano
** Ide para Arduino v.1.8.19 con Linux Debian.
** 
********************************************************************************/
/* NOTA: Para la conexion de los segmentos del display (cátodo común) al CD4511 
 *       ver la hoja de datos del BCD.
********************************************************************************/
#include <EEPROM.h>
#define prog 4  // Boton para programar nuevo rango
#define led 15  // Pin para controlar la sirena, led o un relevador.
 
#define A 8   // Pin A entrada BCD del CD4511 (pin 7)
#define B 9   // Pin B entrada BCD del CD4511 (PIN 1)
#define C 10  // Pin C entrada BCD del CD4511 (Pin 2)
#define D 11  // Pin D entrada BCD del CD4511 (Pin 6)
#define T1 2  // Pin control de la base del transistor BC337 (Unidad)
#define T2 3  // Pin control de la base del transistor BC337 (Decena)
 
const unsigned char EchoPin = 5;    // Pin para el ultrasonido
const unsigned char TriggerPin = 6; // Pin para el ultrasonido
unsigned int conversion =0;
unsigned char muestras =0, rango = 0, unidad = 0, decena = 0, marca = 1;
unsigned int M0=0;
 
void setup() {
  pinMode(led, OUTPUT); // Para controlar un led, sirena o un relay
  pinMode(A, OUTPUT);  // Pines para pasar al BCD los valores binarios
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(T1, OUTPUT); // Pin para la base de transistor unidad
  pinMode(T2, OUTPUT); // pin para la base del transistor decena
  pinMode(prog,INPUT_PULLUP); // Botón para programar el rango
  digitalWrite(led,LOW );
  Serial.begin(9600);
  pinMode(TriggerPin, OUTPUT);
  pinMode(EchoPin, INPUT);
  
  if(EEPROM.read(0) > 50){  // Recupera de memoria el último rango válido
    rango = 30;  // Si no es válido asigna uno por defecto.
  }
  else
    rango = EEPROM.read(0);   // Recupera el rango guardado en memoria
  decena = (rango / 10) % 10; // y ajusta la unidad y decena para ver
  unidad = rango % 10;        // el dato del rango en el display.
    
  //---------- Congigura el Timer 1 ----------------
  noInterrupts();           // No interupciones
  TCNT1 = 65000;            // Ajusta modulo a ~6 Milisegundos
  TCCR1B |= (1 << CS10);    // Sin prescalador 
  TIMSK1 |= (1 << TOIE1);   // Habilita la mascara de interrupción
  interrupts();             // Habilita las interrupciones generales
}
 
void loop() {
rango = EEPROM.read(0); 
if (digitalRead(prog) == LOW){ // Boton de programa activado?
  Leer_Conversor();            // OK, entonces leer el conversor.
  EEPROM.write(0, conversion); // Almacena el nuevo rango
  delay(500);
}
  int dist = ping(TriggerPin, EchoPin); 
  if(dist <= rango)              // Distancia es menor al rango??
    digitalWrite(led,HIGH );     // Sirena o led activado
  if(dist >= rango || dist == 0) // Distancia > 31  o 0 ?? 
     digitalWrite(led,LOW );  // Entonces apagar sirena!!!
  Serial.println(dist);
  delay(500);
  
}
/****************************************************************
* Función para medir la distancia a que se encuentra el intruso
*****************************************************************/
int ping(int TriggerPin, int EchoPin) {
  long tiempo, distancia;
  digitalWrite(TriggerPin, LOW);  // Genera un pulso limpio de 4us
  delayMicroseconds(4);
  digitalWrite(TriggerPin, HIGH);  // Genera disparo de 10us
  delayMicroseconds(10);
  digitalWrite(TriggerPin, LOW);
  tiempo = pulseIn(EchoPin, HIGH);  // Mide el tiempo entre pulsos
  distancia = tiempo * 10 / 292/ 2; // Convierte la distancia, en cm 
  return distancia;
} 
/****************************************************************
*  Lee el canal A0 donde se ha colocado un potenciómetro de 10K
*  para leer un voltaje entre 0 y 5V que se escalara a un valor
*  entre 0 y 50 para ajustar nuevos rangos.
* 
*****************************************************************/
void Leer_Conversor(void){      
do{
  M0 += analogRead(A0);    // Lee el A/D y acumula el dato en M0
  muestras++;         // Incrementa el contador de muestras
}while(muestras <=49);    // Se tomaron  muestras ??
  conversion = M0/50;    // Se busca el promedio de las 50 muestras
  conversion = map(conversion, 0, 1023, 0, 50);
  decena = (conversion / 10) % 10;
  unidad = conversion % 10;
  M0 =0;
  muestras =0;
 }
/************************************************************************
  Muestra el rango ajustado o extraído de la memoria
**************************************************************************/
void Multiplexador(){
  switch(marca){   // El valor de marca determina que transistor se activa.
    case 1:{
      PORTB = unidad;   // Pasa al BCD CD4511 el valor de la Unidad
      digitalWrite(T1, HIGH); // Activar el display de la unidad
      break;
     }
    case 2:{
      digitalWrite(T1, LOW);  // Apagar el display de la unidad
      PORTB = decena;         // Pasa al BCD CD4511 el valor de la Decena
      if(decena > 0)          // Si la decena es 0 apagar el dígito
         digitalWrite(T2, HIGH); // Activar el display de la decena
       break;
    }
    case 3:{
      digitalWrite(T2, LOW);  // Apagar el display de la decena
      marca =0;
      break;
    }
  }
} 
 
 
/* ******** ISR del Timer 1 por desborde **************
  *  Determina la velocidad a la cual se mostrará el 
  *  valor de la unidad y la decena.
 ******************************************************/
ISR(TIMER1_OVF_vect){
  TCNT1 = 65000;    // 5,7 Milisegundos
  marca++;          // Apuntador para activar los transistores  
  Multiplexador();  // LLama a la función para mostrar los datos
}
 
 
/************************************************************************
  Escala el valor del conversor a un valor entre 0 y 50
**************************************************************************/
 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;
}

También podemos eliminar el CD4511 y manejar todo el display directamente con Arduino, para esto tendríamos que modificar el circuito electrónico y adecuarlo a este nuevo código que es el que actualmente esta funcionando en terreno.

/********************************************************************************* 
* Los segmentos están conectados de la siguiente forma:
* Pin 2 segmento a          
* Pin 3 segmento b         
* Pin 4 segmento c         
* Pin 5 segmento d         
* Pin 6 segmento e
* Pin 7 segmento f
* Pin 8 segmento g       
***********************************************************************************/
#include <EEPROM.h>
#define prog 15  // Botón para programar nuevo rango
#define led 16  // Pin para controlar la sirena, led o un relevador.
#define T1 17  // Pin control de la base del transistor BC337 (Unidad)
#define T2 18  // Pin control de la base del transistor BC337 (Decena)
 
//----- Codifica los números y segmentos ---------------
const unsigned char num_array[10][7]PROGMEM = 
  {{ 1,1,1,1,1,1,0 },   // 0
  { 0,1,1,0,0,0,0 },    // 1
  { 1,1,0,1,1,0,1 },    // 2
  { 1,1,1,1,0,0,1 },    // 3
  { 0,1,1,0,0,1,1 },    // 4
  { 1,0,1,1,0,1,1 },    // 5
  { 1,0,1,1,1,1,1 },    // 6
  { 1,1,1,0,0,0,0 },    // 7
  { 1,1,1,1,1,1,1 },    // 8
  { 1,1,1,0,0,1,1 }};   // 9
  
 
const unsigned char EchoPin = 11;    // Pin para el ultrasonido
const unsigned char TriggerPin = 12; // Pin para el ultrasonido
unsigned int conversion =0;
unsigned char muestras =0, rango = 0, unidad = 0, decena = 0, marca = 1;
unsigned int M0=0;
 
boolean debug = false; // falso o true ahorra memoria y código mas ágil
 
void setup() {
  pinMode(led, OUTPUT); // Para controlar un led, sirena o un relay
  pinMode(T1, OUTPUT); // Pin para la base de transistor unidad
  pinMode(T2, OUTPUT); // pin para la base del transistor decena
  pinMode(prog,INPUT_PULLUP); // Botón para programar el rango
  // -- Configuración de los pines de los segmentos  
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  digitalWrite(led,LOW );
   
  if (debug) 
     Serial.begin(9600);
  
  pinMode(TriggerPin, OUTPUT);
  pinMode(EchoPin, INPUT);
  
  if(EEPROM.read(0) > 50){  // Recupera de memoria el último rango válido
    rango = 30;  // Si no es válido asigna uno por defecto.
  }
  else
    rango = EEPROM.read(0);   // Recupera el rango guardado en memoria
  decena = (rango / 10) % 10; // y ajusta la unidad y decena para ver
  unidad = rango % 10;        // el dato del rango en el display.
    
  //---------- Congigura el Timer 1 ----------------
  noInterrupts();           // No interrupciones
  TCNT1 = 65000;            // Ajusta modulo a ~6 Milisegundos
  TCCR1B |= (1 << CS10);    // Sin prescalador 
  TIMSK1 |= (1 << TOIE1);   // Habilita la mascara de interrupción
  interrupts();             // Habilita las interrupciones generales
}
 
void loop() {
rango = EEPROM.read(0); 
if (digitalRead(prog) == LOW){ // Boton de programa activado?
  Leer_Conversor();            // OK, entonces leer el conversor.
  EEPROM.write(0, conversion); // Almacena el nuevo rango
  delay(500);
}
// NOTA:
// La sirena suena mientras el intruso este dentro del rango.
  int dist = ping(TriggerPin, EchoPin); 
  if(dist <= rango -1)           // Distancia es menor al rango offset??
    digitalWrite(led,HIGH );     // Sirena o led activado
  if(dist >= rango +1 || dist == 0) // Distancia > al offset  o 0 ?? 
     digitalWrite(led,LOW );  // Entonces apagar sirena (o lo que sea)!!!
  
  if (debug) { 
    Serial.println(dist); 
    }   
 
  delay(500);
  
}
/****************************************************************
* Función para medir la distancia a que se encuentra el intruso
*****************************************************************/
int ping(int TriggerPin, int EchoPin) {
  long tiempo, distancia;
  digitalWrite(TriggerPin, LOW);  // Genera un pulso de 4us
  delayMicroseconds(4);
  digitalWrite(TriggerPin, HIGH);  // Genera disparo de 10us
  delayMicroseconds(10);
  digitalWrite(TriggerPin, LOW);
  tiempo = pulseIn(EchoPin, HIGH);  // Mide el tiempo entre pulsos y
  distancia = tiempo * 10 / 292/ 2; // lo convierte a distancia en cm 
  return distancia;
} 
/****************************************************************
*  Lee el canal A0 donde se ha colocado un potenciometro de 10K
*  para leer un voltaje entre 0 y 5V que se escalara a un valor
*  entre 0 y 50 para ajustar nuevos rangos.
* 
*****************************************************************/
void Leer_Conversor(void){      
do{
 
  M0 += analogRead(A0);    // Lee el A/D y acumula el dato en M0
  muestras++;         // Incrementa el contador de muestras
}while(muestras <=29);    // Se tomaron  muestras ??
  conversion = M0/30;    // Se busca el promedio de las 30 muestras
  conversion = map(conversion, 0, 1023, 0, 50);
  decena = (conversion / 10) % 10;
  unidad = conversion % 10;
  M0 =0;
  muestras =0;
 }
/************************************************************************
  Muestra el rango ajustado o extraído de la memoria
**************************************************************************/
void Multiplexador(){
  switch(marca){   // El valor de marca determina que transistor se activa.
    case 1:{
      Muestra_Dato(unidad);   // Muestra el valor de la unidad
      digitalWrite(T1, HIGH); // Activar el display de la unidad
      break;
     }
    case 2:{
      digitalWrite(T1, LOW);  // Apagar el display de la unidad
      Muestra_Dato(decena);   // Muestra el valor de la decena
      if(decena > 0)          // Si la decena es 0 apagar el dígito
         digitalWrite(T2, HIGH); // Activar el display de la decena
       break;
    }
    case 3:{
      digitalWrite(T2, LOW);  // Apagar el display de la decena
      marca =0;
      break;
    }
  }
} 
 
/************************************************************************
  Matriz bidimensional para activar los segmentos del display
**************************************************************************/
void Muestra_Dato(unsigned char number){
  unsigned char pin = 2;
  for (unsigned char j=0; j < 7; j++) {
   digitalWrite(pin, pgm_read_byte(&num_array[number][j]));
   pin++;
  }
}
 
 
/* ******** ISR del Timer 1 por desborde **************
  *  Determina la velocidad a la cual se mostrará el 
  *  valor de la unidad y la decena.
 ******************************************************/
ISR(TIMER1_OVF_vect){
  TCNT1 = 65000;    // 5,7 Milisegundos
  marca++;          // Apuntador para activar los transistores  
  Multiplexador();  // LLama a la funcion para mostrar los datos
}
 
 
/************************************************************************
  Escala el valor del conversor a un valor entre 0 y 50
**************************************************************************/
 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;
}
 

En los meses que el sistema lleva funcionando los resultados han sido impecables y las palomas finalmente decidieron buscar un lugar mas tranquilo donde construir su nido :)

 

Cuando se programa la placa Raspberry Pi Pico con Micropython el proceso de actualizar el código en memoria Flash  resulta muy cómodo, como el interprete ya esta cargado en memoria solo conectamos el cable USB y se actualiza el nuevo programa tantas veces como sea necesario o actualizaciones tengamos del código.

Sin embargo cuando trabajamos en C/C++ la mecánica para actualizar los programas en Flash es un poco diferente teniendo que desconectar el cable USB, presionar el boton BOOTSEL y en simultaneo conectar nuevamente el cable USB.
El tema de tener que conectar/desconectar el cable USB me parecía molesto y me puse a investigar la forma de eliminar la necesidad de tener que conectar y desconectar el cable USB en cada re-programación de la Flash. En mi caso tengo montada la placa en un proto-board con alimentación de 5 voltios, esta placa es donde ensamblo los prototipos que luego son programados en la placa definitiva esto es importante porque la placa no debe recibir alimentación por el cable USB, solo el cable GND deberá estar conectado entre la computadora y la placa pico.
Para no tener que desconectar el cable USB del computador he construido el siguiente circuito electrónico que toma señal del punto marcado como TP6 en la placa Pico, cuando se oprime el botón BOOTSEL se dispara un temporizador que corta la energía de la placa durante un par de segundos, la computadora entonces  "entiende" que se desconecto el cable USB y se volvió a conectar luego de unos segundos y la placa pasa a modo programación.

Es decir que solo con actuar sobre el botón BOOTSEL ya es suficiente y no es necesario remover el cable USB en cada actualización de Flash.

Como se ve en el diagrama de la placa Pico, el botón BOOTSEL cambia el estado del pin CS de la memoria Flash en el mismo momento que el cable USB es removido y vuelto a conectar al computador conectando y desconectado la alimentación de la placa Pico y dejando la memoria lista para recibir el nuevo programa Flash.
Obviamente que para que esto funcione la placa Pico no debe recibir alimentación por el USB desde el computador pero si compartir el GND. En mi caso y como ya lo tenía utilicé un pequeño relay de 5 voltios para desconectar/conectar la alimentación de la placa Pico y para eliminar la alimentación por el cable USB, prolijamente abrí un cable USB y corte el cable que trae los 5 voltios.
El sistema funciona perfecto y ya no tengo que conectar y desconectar el cable USB cada vez que actualizo el código en C++ en la memoria Flash de Pico.

 

Medición de Temperatura y Humedad con Arduino.

 Uno de mis pasatiempos es el cultivo de plantas tropicales, hortalizas y hongos en ambientes controlados y conocer los valores de temperatura y humedad ambientales resultan indispensables para conocer las condiciones en que los cultivos se están desarrollando. 
Fue entonces que construí este simple medidor basado en un DHT22 conectado a un Arduino Nano. Para mejorar la visualización utilicé una pantalla gráfica JL12864G como se aprecia en la siguiente imagen.

El desarrollo original no pretendía construir un dispositivo elegante si mas bien funcional y práctico que pudiera mover a cualquier parte del vivero o al espacio de cultivo con bancales o cajones de madera.
El código para Arduino es muy simple, el sensor DHT22 conectado al INT0 de la placa Arduino Nano y la pantalla a los pines 8,9,10,18 y 19.

/****************************************************************
* Programa ejemplo para el control de una pantalla JLX12864G.
* Mide temperatura y humedad con sensor DHT22.
* 
* Placa Arduino: ARDUINO NANO
* Arduino IDE con Linux Ubuntu
*
* Por: Daniel Schmidt.
* ***************************************************************/
#include "U8glib.h"
#include <DHT.h>
#include <DHT_U.h>
#include <avr/wdt.h>
 
U8GLIB_NHD_C12864 u8g(19, 18, 8, 10, 9);// Arduino NANO PB0, PB1, PB2, A5 (SCL) A4 (SDA)
 
/*---------------------------------------------------------------------------
 | JLX12864G-086 (Graphic LCD 128x64)                                        |
 |---------------------------------------------------------------------------|
 | Pin Connect :                                                             |
 |          CS : 8         VDD : 3v3                                         |
 |         RST : 9         VSS : GND                                         |
 |          RS : 10       LEDA : 5v                                          |
 | SPI:    SDA : 11                                                          |
 | SPI:    SCK : 13                                                          |
  ---------------------------------------------------------------------------*/
#define DHTTYPE DHT22      // Tipo de sensor
const int DHTPin = 2;       // Pin del sensor (PD2_INT0)
DHT dht(DHTPin, DHTTYPE);   // Instancia del sensor
// Variables del programa
static char Temperatura[5]="";
static char Humedad[5]="";
 
void Mostrar(void) {
  wdt_reset(); // Borra el contador del perro guardián
  u8g.setFont(u8g_font_10x20r);
  u8g.drawStr( 7, 15, "Temperatura");
  u8g.setFont(u8g_font_8x13r);
  u8g.drawStr( 16, 58, "Humedad ");
  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_osb21);
  u8g.drawStr( 40, 43, Temperatura);
  u8g.setFont(u8g_font_8x13r);
  u8g.drawStr( 75, 58, Humedad);
  u8g.setFont(u8g_font_8x13r);
  u8g.drawStr( 110, 58, "%");
}
 
void setup(void) {
  u8g.setContrast(0); // Configura el contraste
  u8g.setRot180();    // Rota la pantalla (si fuera necesario)
  dht.begin();	      // Inicia la Electrónica del sensor
  wdt_disable();      
  wdt_enable(WDTO_8S);// Ajusta el perro guardián a 8 segundos
}
 
void loop(void) {
  u8g.firstPage();  // Muestra la pagina principal
  do {
    Mostrar();
  } 
 while( u8g.nextPage() );
  Medir();       // Obtiene datos del sensor
  delay(3000);
  wdt_reset(); // Borra el contador del WD
}
void Medir(){
 wdt_reset(); // Borra el contador del WD
 float t = dht.readTemperature(); // Lee sensor temperatura
 float h = dht.readHumidity();  // Lee sensor humedad
 
  if (isnan(h) || isnan(t)) { // Verifica si error de lectura
              Serial.println("ERROR!"); 
              }
            else{ // No hay error, procesa los datos
              
   dtostrf(t, 4, 1, Temperatura); // Procesa la temperatura 
   dtostrf(h, 4, 1, Humedad);     // Procesa la humedad
   }
}