Statistiche Covid-19 + Raspberry Pi + LCD I2C: 6 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-31 10:21

Così, casualmente, un giorno, ho deciso di prendere alcune parti che avevo in giro e fare qualcosa che mi avrebbe fornito statistiche in tempo reale su Covid-19. Non ho dedicato molto tempo a renderlo bello, perché perché creare qualcosa di permanente quando questo evento non ci sarà? Pertanto, il mio display è semplicemente montato su una piccola scatola di cartone.

Parti necessarie:

• Raspberry Pi - qualsiasi modello. Ho usato Raspberry Pi 3A+
• Display LCD 20x4 I2C - nessuna marca particolare… ma necessita dello zaino I2C
• Cavi jumper femmina-femmina - Solo 4 di loro per collegare 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…

Questi collegamenti vanno direttamente alle fonti da cui ho acquistato. Mi dispiace dire che Adafruit non sta consegnando in questo momento, ma Amazon è … solo lentamente a causa del loro focus principale sugli articoli essenziali, che non sono. Tutto può essere trovato altrove su Amazon e eBay.

Ovviamente avrai bisogno di un adattatore CA, un cavo USB e una scheda microSD per andare con tutto questo.

Passaggio 1: configurazione hardware

Fare riferimento all'immagine del pinout allegata. Dice B+, ma si applica anche a tutti gli altri modelli Raspberry Pi successivi a quello.

Con uno zaino I2C collegato al display LCD, questa connessione richiede solo 4 fili per funzionare.

Collega GND a uno qualsiasi dei pin di terra sul Raspberry Pi: Pin 6, 9, 14, 20, 25, 30, 34, 39. L'ho collegato al pin 6.

Collega VCC a uno dei pin da 5 volt sul Raspberry Pi: Pin 2, 4. Ho usato il pin 4

Collegare SDA al pin 3.

Collegare SCL al pin 5.

Se hai seguito la mia configurazione, ti ritroverai con tutti e 4 i fili in uno schema 2x2 sulle intestazioni GPIO.

Il tuo metodo di montaggio può essere qualsiasi cosa tu possa immaginare… o niente del tutto. Come ho detto nell'introduzione, questo ceppo del coronavirus non durerà per sempre, quindi non ho bisogno della mia configurazione nemmeno per questo. Se decido di mantenere questa configurazione dopo che questo evento è finito, potrei trasformarlo in un display meteorologico o qualcosa del genere.

Ho attaccato un dado e un bullone insieme a distanziali in nylon a tutti e 4 gli angoli del mio Pi 3A+. Questo è strettamente facoltativo. L'ho fatto perché a volte ho questo su una superficie metallica, non mi piaceva avere le mie configurazioni temporanee su un Pi che si trova all'interno di un case e non voglio rischiare di rovinarlo perché ho dimenticato di rimuoverlo dal metallo superficie prima di accenderlo.

Passaggio 2: installazione del software Pi

Come ho detto nell'introduzione, non importa quale modello di Raspberry Pi usi. Lo sto usando su un Raspberry Pi 3A+ tramite WiFi, ma l'ho testato anche su Raspberry Pi 2 su cavo ethernet e Raspberry Pi Zero versione 1.3 (il primissimo Pi Zero con il connettore della fotocamera seriale) con un dongle WiFi USB.

Non scriverò come installare Raspbian su una scheda MicroSD perché ci sono milioni di istruzioni su come farlo. Ho una microSD da 16 GB con Raspbian Buster Lite. Una nota a margine, uso quasi sempre Raspbian Lite perché non ho bisogno degli altri pacchetti software inutili in nessuno dei miei progetti. Se installo il software utilizzando apt-get, verranno installati i prerequisiti mancanti.

Connettiti a una rete. Di nuovo, ci sono milioni di istruzioni là fuori su come farlo, quindi non andrò in profondità qui. Puoi andare via cavo o wireless, ma ciò richiederà una connessione a Internet.

Facoltativo, ma puoi abilitare SSH per connettersi utilizzando PuTTY. L'ho fatto.

Aggiorna tutto quindi riavvia:

sudo apt update

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

Questa è una configurazione che esaminerò qui. Di nuovo, ci sono milioni di modi per farlo, ma il miglior riferimento che ho trovato è proprio qui:

Ecco i punti salienti:

sudo apt install i2c-tools

sudo apt install python-smbus

Dovrai anche abilitare I2C

sudo raspi-config

- 5 opzioni di interfaccia

- P5 I2C

Riavvia per applicare le modifiche

sudo reboot

Ora è il momento di vedere se hai fatto tutto correttamente finora

i2cdetect -y 1

Se il tuo display è acceso e può essere visto dal tuo Raspberry Pi, apparirà un grafico. L'indirizzo per il 20x4 che ho acquistato su Amazon e che utilizzo per questo progetto è 27. Tecnicamente questo identificherà come 0x27 per gli script Python che verranno dopo. Ho avuto lo stesso indirizzo per 2 display 16x2 che ho acquistato anche su Amazon e uno 40x2 che ho trovato su eBay.

Passaggio 3: installazione di Python

Quindi ora per le cose complesse. Cercherò di mantenerlo il più semplice possibile. Per cominciare, scriverò solo i file nella directory home.

tocca I2C_LCD_driver.py

nano I2C_LCD_driver.py

Incolla il contenuto sottostante nello script Python appena creato.

# -*- codifica: utf-8 -*-# Codice originale trovato in: #

"""

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),="">

So che questo script è piuttosto disordinato, ma è efficace. Mostrerà le statistiche attuali per i casi di Covid-19 negli Stati Uniti. Il database principale viene aggiornato ogni 5 minuti. Il mio script impiega 1 minuto per scorrere completamente 3 pagine e estrarrà numeri aggiornati ogni volta che il ciclo ricomincia.

Passaggio 4: eseguire Python

Cominciamo:

pitone covid19.py

La prima pagina mostra il numero totale di casi e decessi da quando il coronavirus ha colpito per la prima volta il Paese. La seconda pagina mostra quei numeri per casi e decessi avvenuti solo nel giorno corrente. Il terzo mostra persone in condizioni critiche, quindi casi e decessi per milione di persone. La seconda riga della terza pagina mostrava la data del primo caso nel paese, ma ho dovuto rimuoverla perché lo script a volte si interrompeva e si bloccava citando quella riga con un errore.

Esistono modi per eseguire automaticamente questo script, ma non entrerò nei dettagli qui. Eseguo il mio su comando dopo che mi sono connesso SSH tramite PuTTY. Mentre è in esecuzione, non sarai in grado di eseguire altri comandi finché non premi Ctrl+C.

Passaggio 5: cosa succede se non vivo negli Stati Uniti?

Questo script può essere modificato per mostrare le statistiche per altri paesi. Come puoi vedere, l'URL nel mio script viene estratto da un'API qui: (non utilizzare Internet Explorer per visualizzare queste pagine. Cercherà di scaricare un file.json. Ho usato Chrome)

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

Ora visita lo stesso indirizzo, ma una cartella più in alto

coronavirus-19-api.herokuapp.com/countries

Questo elenca le statistiche per ogni paese. Ovviamente sarà un incubo cercare di estrarre i dati API da questa pagina. Quindi è meglio aprire la pagina per il tuo paese specifico. I nostri amici in Canada dovrebbero modificare lo script con questo URL:

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

Nota molto importante qui. L'URL dell'API deve essere specifico, ovvero senza spazi in un URL. Nella navigazione web, gli spazi in un indirizzo web sono sostituiti da "%20" e con ciò detto, i nostri amici in paesi con nomi di 2 parti, come ad esempio la Nuova Zelanda, dovrebbero sostituire l'URL in questo script con:

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

Passaggio 6: considerazioni finali

Ho fatto molte cose con Raspberry Pi e Arduino nel corso degli anni, ma la maggior parte di ciò che ho costruito sono solo repliche di idee di altri. Questo è quasi lo stesso tranne che ho compilato pezzi da molte fonti in questa configurazione. Sebbene questa configurazione non ti manterrà al sicuro e in salute durante questo periodo difficile, ti terrà sicuramente occupato mentre lo imposti e ti terrà informato in seguito.

Se non disponi già di queste parti, non stressarti nell'acquistarle a meno che tu non sia seriamente intenzionato a costruirle. Come ho detto prima, i tempi di spedizione si stanno allungando in questo momento perché questi sforzi vengono fatti per gli articoli essenziali. Avevo solo queste parti già per imparare e sperimentare. Il display montato su scatola è stato originariamente impostato per visualizzare le statistiche in tempo reale di un altro Raspberry Pi sulla mia rete che esegue Pi-Hole. Dopo che questo evento Covid-19 sarà finito, potrei trasformarlo in un display meteorologico.

Per chiunque stia leggendo, voglio dare un grido a questo istruibile:

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

Non l'ho ancora provato, ma ho gli ingredienti esatti e potrei provarlo prima o poi.