Estadísticas de Covid-19 + Raspberry Pi + LCD I2C: 6 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-31 10:18

Así que un día, al azar, de la nada, decidí conseguir algunas piezas que tenía por ahí y hacer algo que me entregara estadísticas en tiempo real sobre Covid-19. No dediqué mucho tiempo a que se viera bien porque ¿por qué hacer algo permanente cuando este evento no lo será? Por lo tanto, mi pantalla está montada en una pequeña caja de cartón.

Piezas necesarias:

• Raspberry Pi: cualquier modelo. Usé Raspberry Pi 3A +
• Pantalla LCD I2C de 20x4: ninguna marca en particular … pero necesita la mochila I2C
• Cables de puente hembra a hembra: solo 4 de ellos para conectar el I2C al Pi

www.adafruit.com/product/4027

www.amazon.com/gp/product/B01GPUMP9C/ref=p…

www.amazon.com/gp/product/B01L5ULRUA/ref=p…

Estos enlaces van directamente a las fuentes en las que compré. Lamento decir que Adafruit no está cumpliendo en este momento, pero Amazon lo está … lentamente debido a que su enfoque principal se centra en los artículos esenciales, que no son. Todos se pueden encontrar en otros lugares de Amazon y eBay.

Obviamente, necesitará un adaptador de CA, un cable USB y una tarjeta microSD para todo esto.

Paso 1: configuración del hardware

Consulte la imagen de distribución de pines adjunta. Dice B +, pero también se aplica a todos los demás modelos de Raspberry Pi posteriores.

Con una mochila I2C unida a la pantalla LCD, esta conexión solo requiere 4 cables para funcionar.

Conecte GND a cualquiera de los pines de tierra en la Raspberry Pi: Pin 6, 9, 14, 20, 25, 30, 34, 39. Lo conecté al pin 6.

Conecte VCC a cualquiera de los pines de 5 voltios en la Raspberry Pi: Pin 2, 4. Usé el pin 4

Conecte SDA al pin 3.

Conecte SCL al Pin 5.

Si siguió mi configuración, terminará con los 4 cables en un patrón 2x2 en los encabezados GPIO.

Su método de montaje puede ser cualquier cosa que pueda imaginar … o nada en absoluto. Como dije en la introducción, esta cepa del coronavirus no va a durar para siempre, por lo que no necesito que mi configuración tampoco. Si decido mantener esta configuración después de que termine este evento, podría convertirlo en una pantalla meteorológica o algo así.

Adjunté una tuerca y un perno junto con espaciadores de nailon en las 4 esquinas de mi Pi 3A +. Esto es estrictamente opcional. Hice esto porque a veces tengo esto en una superficie de metal, no me gustó tener mis configuraciones temporales en un Pi que está dentro de una carcasa y no quiero arriesgarme a estropearlo porque olvidé quitarlo del metal. superficie antes de encenderlo.

Paso 2: Configuración del software Pi

Como dije en la introducción, no importa qué modelo de Raspberry Pi uses. Estoy usando esto en una Raspberry Pi 3A + a través de WiFi, pero también lo he probado en Raspberry Pi 2 con cable ethernet y Raspberry Pi Zero versión 1.3 (el primer Pi Zero con el conector de cámara en serie) con un dongle USB WiFi.

No voy a escribir cómo instalar Raspbian en una tarjeta MicroSD porque hay millones de instrucciones sobre cómo hacerlo. Tengo una microSD de 16GB con Raspbian Buster Lite. En una nota al margen, casi siempre uso Raspbian Lite porque no necesito los otros paquetes de software inútiles en ninguno de mis proyectos. Si instalo software usando apt-get, instalará los requisitos previos que faltan.

Conectar a una red. Una vez más, hay millones de instrucciones sobre cómo hacer esto, por lo que no profundizaré aquí. Puede utilizar el cable o la conexión inalámbrica, pero esto requerirá una conexión a Internet.

Opcional, pero puede habilitar SSH para conectarse usando PuTTY. Yo hice.

Actualiza todo y luego reinicia:

actualización de sudo apt

sudo apt upgrade -y sudo apt dist-upgrade sudo rpi-update sudo reboot

Esta es una configuración por la que pasaré aquí. Nuevamente, hay millones de formas de hacer esto, pero la mejor referencia que encontré está aquí:

Estos son los aspectos más destacados:

sudo apt instalar herramientas i2c

sudo apt install python-smbus

También necesitará habilitar I2C

sudo raspi-config

- 5 opciones de interfaz

- P5 I2C

Reinicie para aplicar los cambios

sudo reiniciar

Ahora es el momento de ver si hiciste todo esto correctamente hasta ahora

i2cdetect -y 1

Si su pantalla está encendida y su Raspberry Pi puede verla, aparecerá un gráfico. La dirección del 20x4 que compré en Amazon y que utilizo para este proyecto es 27. Técnicamente, esto se identificará como 0x27 para los scripts de Python que vendrán más adelante. He tenido la misma dirección para 2 pantallas de 16x2 que también compré en Amazon y una de 40x2 que encontré en eBay.

Paso 3: Configuración de Python

Así que ahora para las cosas complejas. Intentaré que sea lo más simple posible. Para empezar, solo escribiré archivos en el directorio de inicio.

toque I2C_LCD_driver.py

nano I2C_LCD_driver.py

Pegue el contenido a continuación en su script de Python recién creado.

# - * - codificación: utf-8 - * - # Código original encontrado en: #

"""

Compiled, mashed and generally mutilated 2014-2015 by Denis Pleic Made available under GNU GENERAL PUBLIC LICENSE

# Modified Python I2C library for Raspberry Pi

# as found on https://gist.github.com/DenisFromHR/cc863375a6e19… # Joined existing 'i2c_lib.py' and 'lcddriver.py' into a single library # added bits and pieces from various sources # By DenisFromHR (Denis Pleic) # 2015-02-10, ver 0.1

"""

# i2c bus (0 -- original Pi, 1 -- Rev 2 Pi)

I2CBUS = 0

# LCD Address

ADDRESS = 0x27

import smbus

from time import sleep

class i2c_device:

def _init_(self, addr, port=I2CBUS): self.addr = addr self.bus = smbus. SMBus(port)

# Write a single command

def write_cmd(self, cmd): self.bus.write_byte(self.addr, cmd) sleep(0.0001)

# Write a command and argument

def write_cmd_arg(self, cmd, data): self.bus.write_byte_data(self.addr, cmd, data) sleep(0.0001)

# Write a block of data

def write_block_data(self, cmd, data): self.bus.write_block_data(self.addr, cmd, data) sleep(0.0001)

# Read a single byte

def read(self): return self.bus.read_byte(self.addr)

# Read

def read_data(self, cmd): return self.bus.read_byte_data(self.addr, cmd)

# Read a block of data

def read_block_data(self, cmd): return self.bus.read_block_data(self.addr, cmd)

# commands

LCD_CLEARDISPLAY = 0x01 LCD_RETURNHOME = 0x02 LCD_ENTRYMODESET = 0x04 LCD_DISPLAYCONTROL = 0x08 LCD_CURSORSHIFT = 0x10 LCD_FUNCTIONSET = 0x20 LCD_SETCGRAMADDR = 0x40 LCD_SETDDRAMADDR = 0x80

# flags for display entry mode

LCD_ENTRYRIGHT = 0x00 LCD_ENTRYLEFT = 0x02 LCD_ENTRYSHIFTINCREMENT = 0x01 LCD_ENTRYSHIFTDECREMENT = 0x00

# flags for display on/off control

LCD_DISPLAYON = 0x04 LCD_DISPLAYOFF = 0x00 LCD_CURSORON = 0x02 LCD_CURSOROFF = 0x00 LCD_BLINKON = 0x01 LCD_BLINKOFF = 0x00

# flags for display/cursor shift

LCD_DISPLAYMOVE = 0x08 LCD_CURSORMOVE = 0x00 LCD_MOVERIGHT = 0x04 LCD_MOVELEFT = 0x00

# flags for function set

LCD_8BITMODE = 0x10 LCD_4BITMODE = 0x00 LCD_2LINE = 0x08 LCD_1LINE = 0x00 LCD_5x10DOTS = 0x04 LCD_5x8DOTS = 0x00

# flags for backlight control

LCD_BACKLIGHT = 0x08 LCD_NOBACKLIGHT = 0x00

En = 0b00000100 # Enable bit

Rw = 0b00000010 # Read/Write bit Rs = 0b00000001 # Register select bit

class lcd:

#initializes objects and lcd def _init_(self): self.lcd_device = i2c_device(ADDRESS)

self.lcd_write(0x03)

self.lcd_write(0x03) self.lcd_write(0x03) self.lcd_write(0x02)

self.lcd_write(LCD_FUNCTIONSET | LCD_2LINE | LCD_5x8DOTS | LCD_4BITMODE)

self.lcd_write(LCD_DISPLAYCONTROL | LCD_DISPLAYON) self.lcd_write(LCD_CLEARDISPLAY) self.lcd_write(LCD_ENTRYMODESET | LCD_ENTRYLEFT) sleep(0.2)

# clocks EN to latch command

def lcd_strobe(self, data): self.lcd_device.write_cmd(data | En | LCD_BACKLIGHT) sleep(.0005) self.lcd_device.write_cmd(((data & ~En) | LCD_BACKLIGHT)) sleep(.0001)

def lcd_write_four_bits(self, data):

self.lcd_device.write_cmd(data | LCD_BACKLIGHT) self.lcd_strobe(data)

# write a command to lcd

def lcd_write(self, cmd, mode=0): self.lcd_write_four_bits(mode | (cmd & 0xF0)) self.lcd_write_four_bits(mode | ((cmd << 4) & 0xF0))

# write a character to lcd (or character rom) 0x09: backlight | RS=DR< # works! def lcd_write_char(self, charvalue, mode=1): self.lcd_write_four_bits(mode | (charvalue & 0xF0)) self.lcd_write_four_bits(mode | ((charvalue << 4) & 0xF0)) # put string function with optional char positioning def lcd_display_string(self, string, line=1, pos=0): if line == 1: pos_new = pos elif line == 2: pos_new = 0x40 + pos elif line == 3: pos_new = 0x14 + pos elif line == 4: pos_new = 0x54 + pos

self.lcd_write(0x80 + pos_new)

for char in string:

self.lcd_write(ord(char), Rs)

# clear lcd and set to home

def lcd_clear(self): self.lcd_write(LCD_CLEARDISPLAY) self.lcd_write(LCD_RETURNHOME)

# define backlight on/off (lcd.backlight(1); off= lcd.backlight(0)

def backlight(self, state): # for state, 1 = on, 0 = off if state == 1: self.lcd_device.write_cmd(LCD_BACKLIGHT) elif state == 0: self.lcd_device.write_cmd(LCD_NOBACKLIGHT)

# add custom characters (0 - 7)

def lcd_load_custom_chars(self, fontdata): self.lcd_write(0x40); for char in fontdata: for line in char: self.lcd_write_char(line)

The address in that content assumes your LCD address is 0x27. If this is not the case for you, you will need to change it on the line "ADDRESS = 0x27" before you type Ctrl+X to save and exit. Otherwise, just save and exit. This file will need to exist in the same directory as the script that we will use later.

That code was on "https://www.circuitbasics.com/raspberry-pi-i2c-lcd-set-up-and-programming/" just in case it did not paste correctly onto this page.

Now create and edit the main python script:

touch covid19.py

nano covid19.py

Paste the below text into your newly created python script.

import I2C_LCD_driverimport socket import time import fcntl import struct import json import urllib2

display = I2C_LCD_driver.lcd()

url = ("https://coronavirus-19-api.herokuapp.com/countries/usa") data = json.load(urllib2.urlopen(url))

try:

while True: data = json.load(urllib2.urlopen(url)) cases = data['cases'] todaycases = data['todayCases'] deaths = data['deaths'] todaydeaths = data['todayDeaths'] recovered = data['recovered'] active = data['active'] critical = data['critical'] casesperonemillion = data['casesPerOneMillion'] deathsperonemillion = data['deathsPerOneMillion'] display.lcd_display_string("COVID-19 Total Stats", 1) display.lcd_display_string("Cases: " + str(cases), 2) display.lcd_display_string("Deaths: " + str(deaths), 3) display.lcd_display_string("Recovered: " + str(recovered), 4) time.sleep(30) display.lcd_display_string(" ", 1) display.lcd_display_string(" ", 2) display.lcd_display_string(" ", 3) display.lcd_display_string(" ", 4) display.lcd_display_string("COVID-19: " + "%s" %time.strftime("%Y/%m/%d"), 1) display.lcd_display_string("Cases: " + str(todaycases), 2) display.lcd_display_string("Deaths: " + str(todaydeaths), 3) display.lcd_display_string("Active: " + str(active), 4) time.sleep(20) display.lcd_display_string(" ", 1) display.lcd_display_string(" ", 2) display.lcd_display_string(" ", 3) display.lcd_display_string(" str(recovered),="">

Sé que este guión es bastante complicado, pero es efectivo. Mostrará las estadísticas actuales de los casos de Covid-19 en los Estados Unidos. La base de datos principal se actualiza cada 5 minutos. Mi guión tarda 1 minuto en recorrer completamente 3 páginas y extraerá números actualizados cada vez que el ciclo comience de nuevo.

Paso 4: Ejecuta Python

Vamos a empezar:

python covid19.py

La primera página muestra el número total de casos y muertes desde que el coronavirus azotó el país por primera vez. La segunda página muestra esos números para casos y muertes que ocurrieron solo en el día actual. El tercero muestra personas en estado crítico, luego casos y muertes por cada millón de personas. La segunda línea de la tercera página solía mostrar la fecha del primer caso en el país, pero tuve que eliminarla porque el script a veces fallaba y fallaba citando esa línea con un error.

Hay formas de hacer que este script se ejecute automáticamente, pero no entraré en detalles al respecto aquí. Solo ejecuto el mío en el comando después de conectarme SSH a través de PuTTY. Mientras se está ejecutando, no podrá ejecutar ningún otro comando hasta que presione Ctrl + C.

Paso 5: ¿Qué pasa si no vivo en los EE. UU.?

Este script se puede modificar para mostrar estadísticas de otros países. Como puede ver, la URL en mi secuencia de comandos se extrae de una API aquí: (no use Internet Explorer para ver estas páginas. Intentará descargar un archivo.json. Usé Chrome)

coronavirus-19-api.herokuapp.com/countries/usa

Ahora visite la misma dirección, pero una carpeta más arriba

coronavirus-19-api.herokuapp.com/countries

Aquí se enumeran las estadísticas de cada país. Obviamente, será una pesadilla intentar extraer datos de la API de esta página. Por lo tanto, es mejor abrir la página de su país específico. Nuestros amigos en Canadá tendrían que editar el script en esta URL:

coronavirus-19-api.herokuapp.com/countries/canada

Nota muy importante aquí. La URL de la API debe ser específica … lo que significa que no hay espacios en una URL. En la navegación web, los espacios en una dirección web se sustituyen por "% 20" y dicho esto, nuestros amigos en países con 2 nombres de partes, como Nueva Zelanda, por ejemplo, necesitarían reemplazar la URL en este script con:

coronavirus-19-api.herokuapp.com/countries/new%20zealand

Paso 6: Pensamientos finales

He hecho muchas cosas con Raspberry Pi y Arduino a lo largo de los años, pero la mayor parte de lo que he construido son solo réplicas de las ideas de otros. Este es casi el mismo, excepto que compilé piezas de muchas fuentes en esta configuración. Aunque esta configuración no lo mantendrá seguro y saludable durante este momento difícil, seguramente lo mantendrá ocupado mientras lo configura y lo mantendrá informado después.

Si aún no tiene estas piezas, no se estrese comprándolas a menos que se lo tome en serio. Como dije antes, los tiempos de envío están tomando más tiempo en este momento porque esos esfuerzos se están dedicando a artículos esenciales. Solo tenía estas partes ya para aprender y experimentar. La pantalla montada en caja se configuró originalmente para ver estadísticas en tiempo real de otra Raspberry Pi en mi red que ejecuta Pi-Hole. Después de que termine este evento de Covid-19, podría convertirlo en una pantalla meteorológica.

Para cualquiera que esté leyendo, quiero mencionar este instructivo:

www.instructables.com/id/DIY-Hand-Sanitize…

No lo he probado todavía, pero tengo esos ingredientes exactos y podría intentarlo en algún momento.