Statistiques Covid-19 + Raspberry Pi + LCD I2C : 6 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-31 10:19

Alors un jour, au hasard, j'ai décidé de récupérer quelques pièces que j'avais traînées et de faire quelque chose qui me fournirait des statistiques en temps réel sur Covid-19. Je n'ai pas mis beaucoup de temps à le rendre joli car pourquoi faire quelque chose de permanent alors que cet événement ne va pas être ? Par conséquent, mon écran est simplement monté sur une petite boîte en carton.

Pièces nécessaires:

• Raspberry Pi - n'importe quel modèle. J'ai utilisé Raspberry Pi 3A+
• Écran LCD I2C 20x4 - pas de marque particulière… mais nécessite le sac à dos I2C
• Fils de raccordement femelle à femelle - Seulement 4 d'entre eux pour connecter l'I2C au Pi

www.adafruit.com/product/4027

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

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

Ces liens renvoient directement aux sources auprès desquelles j'ai acheté. Désolé de dire qu'Adafruit ne livre pas pour le moment, mais Amazon le fait… lentement, car leur objectif principal est les articles essentiels, ce qui n'est pas le cas. Tous peuvent être trouvés ailleurs sur Amazon et eBay.

Vous aurez évidemment besoin d'un adaptateur secteur, d'un câble USB et d'une carte microSD pour accompagner tout cela.

Étape 1: configuration du matériel

Référencez l'image de brochage ci-jointe. Il est écrit B+, mais cela s'applique également à tous les autres modèles de Raspberry Pi qui ont suivi celui-ci.

Avec un sac à dos I2C attaché à l'écran LCD, cette connexion ne nécessite que 4 fils pour fonctionner.

Connectez GND à l'une des broches de masse du Raspberry Pi: broches 6, 9, 14, 20, 25, 30, 34, 39. Je l'ai connectée à la broche 6.

Connectez VCC à l'une des broches de 5 volts du Raspberry Pi: broches 2, 4. J'ai utilisé la broche 4

Connectez le SDA à la broche 3.

Connectez SCL à la broche 5.

Si vous avez suivi ma configuration, vous vous retrouverez avec les 4 fils dans un motif 2x2 sur les en-têtes GPIO.

Votre méthode de montage peut être tout ce que vous pouvez imaginer… ou rien du tout. Comme je l'ai dit dans l'intro, cette souche du coronavirus ne va pas durer éternellement, donc je n'ai pas besoin de ma configuration non plus. Si je décide de conserver cette configuration après la fin de cet événement, je pourrais la transformer en un affichage météo ou quelque chose du genre.

J'ai attaché un écrou et un boulon avec des entretoises en nylon aux 4 coins de mon Pi 3A+. Ceci est strictement facultatif. Je l'ai fait parce que j'ai parfois cela sur une surface métallique, je n'aimais pas avoir mes configurations temporaires sur un Pi qui se trouve à l'intérieur d'un boîtier, et je ne veux pas risquer de le gâcher parce que j'ai oublié de le retirer du métal surface avant de l'allumer.

Étape 2: Configuration du logiciel Pi

Comme je l'ai dit dans l'intro, peu importe le modèle de Raspberry Pi que vous utilisez. Je l'utilise sur un Raspberry Pi 3A+ via WiFi, mais je l'ai également testé sur Raspberry Pi 2 sur câble Ethernet et Raspberry Pi Zero version 1.3 (le tout premier Pi Zero avec le connecteur de caméra série) avec un dongle USB WiFi.

Je ne vais pas taper comment installer Raspbian sur une carte MicroSD car il existe des millions d'instructions sur la façon de le faire. J'ai une microSD de 16 Go sous Raspbian Buster Lite. Par ailleurs, j'utilise presque toujours Raspbian Lite car je n'ai besoin des autres packages logiciels inutiles dans aucun de mes projets. Si j'installe un logiciel à l'aide d'apt-get, il installera les prérequis manquants.

Se connecter à un réseau. Encore une fois, il existe des millions d'instructions sur la façon de procéder, je n'entrerai donc pas dans les détails ici. Vous pouvez aller avec ou sans fil, mais cela nécessitera une connexion Internet.

Facultatif, mais vous pouvez activer SSH pour se connecter à l'aide de PuTTY. J'ai fait.

Mettez tout à jour puis redémarrez:

mise à jour sudo apt

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

C'est une configuration que je vais parcourir ici. Encore une fois, il y a des millions de façons de le faire, mais la meilleure référence que j'ai trouvée est ici:

Voici les faits saillants:

sudo apt installer les outils i2c

sudo apt installer python-smbus

Vous devrez également activer I2C

sudo raspi-config

- 5 options d'interfaçage

-P5 I2C

Redémarrez pour appliquer les modifications

redémarrage sudo

Il est maintenant temps de voir si vous avez tout fait correctement jusqu'à présent

i2cdetect -y 1

Si votre écran est sous tension et peut être vu par votre Raspberry Pi, vous aurez un graphique qui s'affichera. L'adresse du 20x4 que j'ai acheté sur Amazon et que j'utilise pour ce projet est 27. Techniquement, cela s'identifiera comme 0x27 pour les scripts python qui viendront plus tard. J'ai eu la même adresse pour 2 écrans 16x2 que j'ai également achetés sur Amazon et un 40x2 que j'ai trouvé sur eBay.

Étape 3: configuration de Python

Alors maintenant pour les trucs complexes. Je vais essayer de rester aussi simple que possible. Pour commencer, je vais simplement écrire des fichiers dans le répertoire personnel.

touchez I2C_LCD_driver.py

nano I2C_LCD_driver.py

Collez le contenu ci-dessous dans votre script python nouvellement créé.

# -*- codage: utf-8 -*-# Code original trouvé à: #

"""

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

Je sais que ce script est assez désordonné, mais il est efficace. Il montrera les statistiques actuelles sur les cas de Covid-19 aux États-Unis. La base de données principale est mise à jour toutes les 5 minutes. Mon script prend 1 minute pour parcourir complètement 3 pages et tirera des nombres mis à jour chaque fois que le cycle recommence.

Étape 4: Exécutez Python

Commençons:

python covid19.py

La première page montre le nombre total de cas et de décès depuis que le coronavirus a frappé le pays pour la première fois. La deuxième page montre ces chiffres pour les cas et les décès survenus uniquement le jour en cours. Le troisième montre les personnes dans un état critique, puis les cas et les décès pour un million de personnes. La deuxième ligne de la troisième page affichait la date du premier cas dans le pays, mais j'ai dû la supprimer car le script faisait parfois erreur et plantait en citant cette ligne avec une erreur.

Il existe des moyens de faire fonctionner ce script automatiquement, mais je n'entrerai pas dans les détails à ce sujet ici. Je viens de lancer le mien sur commande après m'y être connecté en SSH via PuTTY. Pendant son exécution, vous ne pourrez pas exécuter d'autres commandes tant que vous n'aurez pas appuyé sur Ctrl+C.

Étape 5: Et si je ne vis pas aux États-Unis ?

Ce script peut être modifié pour afficher les statistiques d'autres pays. Comme vous pouvez le voir, l'URL de mon script est extraite d'une API ici: (n'utilisez pas Internet Explorer pour afficher ces pages. Il essaiera de télécharger un fichier.json. J'ai utilisé Chrome)

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

Maintenant, visitez cette même adresse, mais un dossier plus haut

coronavirus-19-api.herokuapp.com/countries

Cela répertorie les statistiques pour chaque pays. De toute évidence, ce sera un cauchemar d'essayer d'extraire les données API de cette page. Il est donc préférable d'ouvrir la page de votre pays spécifique. Nos amis au Canada auraient besoin de modifier le script à cette URL:

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

Remarque très importante ici. L'URL de l'API doit être spécifique… ce qui signifie qu'il n'y a pas d'espace dans une URL. Dans la navigation Web, les espaces dans une adresse Web sont remplacés par "%20" et cela dit, nos amis dans les pays avec des noms en 2 parties, comme la Nouvelle-Zélande par exemple, devraient remplacer l'URL dans ce script par:

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

Étape 6: Réflexions finales

J'ai fait beaucoup de choses avec Raspberry Pi et Arduino au fil des ans, mais la plupart de ce que j'ai construit ne sont que des répliques des idées des autres. Celui-ci est presque le même, sauf que j'ai compilé des morceaux de nombreuses sources dans cette configuration. Bien que cette configuration ne vous maintienne pas en sécurité et en bonne santé pendant cette période difficile, elle vous occupera sûrement pendant que vous la configurez et elle vous tiendra informé par la suite.

Si vous n'avez pas déjà ces pièces, ne vous stressez pas pour les acheter à moins que vous ne vouliez vraiment les construire. Comme je l'ai déjà dit, les délais d'expédition prennent plus de temps en ce moment parce que ces efforts sont consacrés aux articles essentiels. Je n'avais déjà ces pièces que pour apprendre et expérimenter. L'écran monté sur boîtier a été initialement configuré pour afficher les statistiques en temps réel d'un autre Raspberry Pi sur mon réseau qui exécute Pi-Hole. Une fois cet événement Covid-19 terminé, je pourrais le transformer en un affichage météo.

Pour tous ceux qui lisent, je veux donner un cri à cette instructable:

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

Je ne l'ai pas encore essayé, mais j'ai ces ingrédients exacts, et je pourrais l'essayer un jour.