Estadístiques Covid-19 + Raspberry Pi + LCD I2C: 6 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-31 10:17

Així que a l’atzar, un dia, vaig decidir obtenir algunes parts que tenia al voltant i fer alguna cosa que em proporcionés estadístiques en temps real de Covid-19. No vaig dedicar gaire temps a fer-ho semblar bo, perquè per què fer alguna cosa permanent quan aquest esdeveniment no serà? Per tant, la meva pantalla s’acaba de muntar en una petita caixa de cartró.

Peces necessàries:

• Raspberry Pi: qualsevol model. He utilitzat Raspberry Pi 3A +
• Pantalla LCD 20x4 I2C: cap marca particular … però necessita la motxilla I2C
• Filferros de pont femení a femení: només 4 d’ells per connectar l’I2C al Pi

www.adafruit.com/product/4027

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

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

Aquests enllaços van directament a les fonts que he comprat. Disculpeu dir que Adafruit no està lliurant ara mateix, però Amazon és … lentament a causa del seu principal enfocament cap als articles essencials, que no ho són. Totes es poden trobar en altres llocs d’Amazon i eBay.

Per descomptat, necessitareu un adaptador de CA, un cable USB i una targeta microSD.

Pas 1: Configuració del maquinari

Feu referència a la imatge de pinout adjunta. Diu B +, però s'aplica a tots els altres models de Raspberry Pi que també han arribat després d'aquest.

Amb una motxilla I2C connectada a la pantalla LCD, aquesta connexió només requereix 4 cables per funcionar.

Connecteu GND a qualsevol dels pins de terra del Raspberry Pi: Pin 6, 9, 14, 20, 25, 30, 34, 39. El vaig connectar al pin 6.

Connecteu VCC a qualsevol dels pins de 5 volts del Raspberry Pi: pin 2, 4. He utilitzat el pin 4

Connecteu SDA al pin 3.

Connecteu SCL al pin 5.

Si heu seguit la meva configuració, acabareu amb els 4 cables en un patró de 2x2 a les capçaleres GPIO.

El vostre mètode de muntatge pot ser qualsevol cosa que pugueu imaginar … o res de res. Com he dit a la introducció, aquesta soca del coronavirus no durarà per sempre, de manera que tampoc necessito la meva configuració. Si decideixo mantenir aquesta configuració un cop finalitzat aquest esdeveniment, podria convertir-la en una pantalla meteorològica o alguna cosa així.

He fixat una rosca i un cargol junt amb separadors de niló a les 4 cantonades del meu Pi 3A +. Això és estrictament opcional. Ho he fet perquè de vegades tinc això en una superfície metàl·lica, no m'agradava tenir les meves instal·lacions temporals en un Pi que es troba dins d'un estoig i no vull arriscar-me a desordenar-lo perquè m'he oblidat de treure'l del metall superfície abans d’engegar-la.

Pas 2: Configuració del programari Pi

Com he dit a la introducció, no importa el model de Raspberry Pi que utilitzeu. Ho faig servir en un Raspberry Pi 3A + a través de WiFi, però també ho he provat a Raspberry Pi 2 amb cable ethernet i a Raspberry Pi Zero versió 1.3 (el primer Pi Zero amb el connector de la càmera sèrie) amb un dongle USB WiFi.

No escriuré com instal·lar Raspbian en una targeta MicroSD perquè hi ha milions d’instruccions sobre com fer-ho. Tinc una microSD de 16 GB amb Raspbian Buster Lite. En un sentit, gairebé sempre faig servir Raspbian Lite perquè no necessito els altres paquets de programari inútils en cap dels meus projectes. Si instal·lo programari amb apt-get, s'instal·laran els requisits previs que falten.

Connecteu-vos a una xarxa. De nou, hi ha milions d’instruccions per fer-ho, de manera que no aprofundiré aquí. Podeu connectar-vos per cable o sense fils, però caldrà una connexió a Internet.

Opcional, però podeu habilitar SSH per connectar-se mitjançant PuTTY. Ho vaig fer.

Actualitzeu-ho tot i reinicieu:

actualització sudo apt

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

Aquesta és una configuració que faré aquí. De nou, hi ha milions de maneres de fer-ho, però la millor referència que he trobat és aquí:

Aquests són els aspectes més destacats:

sudo apt install i2c-tools

sudo apt install python-smbus

També haureu d’habilitar I2C

sudo raspi-config

- 5 opcions d'interfície

- P5 I2C

Reinicieu per aplicar els canvis

sudo reiniciar

Ara és hora de veure si fins ara ho heu fet tot correctament

i2cdetect -y 1

Si la pantalla està engegada i la pot veure el vostre Raspberry Pi, tindreu un gràfic que apareix. L'adreça del 20x4 que he comprat a Amazon i que he utilitzat per a aquest projecte és 27. Tècnicament s'identificarà com a 0x27 per als scripts de Python que vindran més endavant. He tingut el mateix programa d'adreces per a dues pantalles de 16x2 que també he comprat a Amazon i una de 40x2 que he trobat a eBay.

Pas 3: Configuració de Python

Ara, doncs, per les coses complexes. Intentaré que sigui el més senzill possible. Per començar, només escriuré fitxers al directori inicial.

toqueu I2C_LCD_driver.py

nano I2C_LCD_driver.py

Enganxeu el contingut següent al vostre script de Python acabat de crear.

# - * - codificació: utf-8 - * - # Codi original trobat a: #

"""

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 aquest guió és força desordenat, però és eficaç. Es mostraran les estadístiques actuals dels casos de Covid-19 als Estats Units. La base de dades principal s’actualitza cada 5 minuts. El meu guió triga 1 minut a recórrer completament 3 pàgines i obtindrà números actualitzats cada vegada que el cicle es torni a iniciar.

Pas 4: executeu Python

Anem a començar:

python covid19.py

La primera pàgina mostra el nombre total de casos i morts des que el coronavirus va arribar al país per primera vegada. La segona pàgina mostra els números de casos i defuncions que només es van produir el dia actual. El tercer mostra persones en estat crític, després casos i morts per cada milió de persones. La segona línia de la tercera pàgina solia mostrar la data del primer cas del país, però l’he hagut d’eliminar perquè de vegades l’escriptura s’esborrava i es bloquejava citant aquesta línia amb un error.

Hi ha maneres de fer que aquest script s'executi automàticament, però aquí no entraré en detalls. Acabo d'executar el meu per ordre després que m'hi connecti SSH mitjançant PuTTY. Mentre s’executa, no podreu executar cap altra ordre fins que no premeu Ctrl + C.

Pas 5: Què passa si no visc als EUA?

Aquest script es pot modificar per mostrar estadístiques d'altres països. Com podeu veure, l'URL del meu script prové d'una API aquí: (no utilitzeu Internet Explorer per veure aquestes pàgines. Intentarà descarregar un fitxer.json. He utilitzat Chrome)

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

Ara visiteu la mateixa adreça, però una carpeta més alta

coronavirus-19-api.herokuapp.com/countries

S'enumeren les estadístiques de cada país. Viouslybviament, serà un malson provar d’extreure dades d’API d’aquesta pàgina. Per tant, és millor obrir la pàgina del vostre país concret. Els nostres amics del Canadà haurien d’editar l’escriptura d’aquest URL:

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

Nota molt important aquí. L'URL de l'API ha de ser específic … és a dir, no hi ha espais en cap URL. A la navegació web, els espais d'una adreça web se substitueixen per "% 20" i, amb això, els nostres amics de països amb dos noms de peça, com Nova Zelanda, per exemple, haurien de substituir l'URL d'aquest script per:

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

Pas 6: Pensaments finals

Al llarg dels anys he fet moltes coses amb Raspberry Pi i Arduino, però la majoria del que he construït són només rèpliques d’idees d’altres. Aquest és gairebé el mateix, tret que he compilat peces de moltes fonts en aquesta configuració. Tot i que aquesta configuració no us mantindrà saludable i segur durant aquests moments difícils, segur que us mantindrà ocupat a mesura que la configureu i us mantindrà informat després.

Si encara no teniu aquestes peces, no us estresseu a comprar-les a menys que vulgueu construir-les. Com he dit abans, els terminis d’enviament s’estan allargant ara mateix perquè s’estan esforçant cap a articles essencials. Només tenia aquestes parts per aprendre i experimentar. La pantalla muntada a la caixa es va configurar originalment per veure estadístiques en temps real d’un altre Raspberry Pi de la meva xarxa que executa Pi-Hole. Un cop acabat aquest esdeveniment de la Covid-19, podria convertir-lo en una exposició meteorològica.

Per a qualsevol persona que llegeixi, vull fer un crit a aquest instructiu:

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

Encara no ho he provat, però tinc aquests ingredients exactes i podria provar-ho algun temps.