Covid-19 Stats + Raspberry Pi + I2C LCD: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-31 10:23

Então, aleatoriamente do nada, um dia, decidi pegar algumas peças que tinha por aí e fazer algo que me entregasse estatísticas em tempo real sobre Covid-19. Não gastei muito tempo fazendo com que parecesse bonito, porque por que fazer algo permanente quando esse evento não vai ser? Portanto, minha tela é montada apenas em uma pequena caixa de papelão.

Peças necessárias:

• Raspberry Pi - qualquer modelo. Usei Raspberry Pi 3A +
• Visor LCD I2C 20x4 - nenhuma marca em particular … mas precisa da mochila I2C
• Fios de jumper fêmea para fêmea - apenas 4 deles para conectar o I2C ao Pi

www.adafruit.com/product/4027

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

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

Esses links vão diretamente para as fontes de onde comprei. Lamento dizer que a Adafruit não está entregando agora, mas a Amazon está … apenas lentamente devido ao seu foco principal estar voltado para itens essenciais, o que não é verdade. Todos podem ser encontrados em outros lugares na Amazon e no eBay.

Obviamente, você precisará de um adaptador AC, cabo USB e cartão microSD para fazer tudo isso.

Etapa 1: configuração do hardware

Consulte a imagem de pinagem anexada. Diz B +, mas se aplica a todos os outros modelos do Raspberry Pi que vieram depois desse também.

Com uma mochila I2C conectada ao display LCD, esta conexão requer apenas 4 fios para funcionar.

Conecte o GND a qualquer um dos pinos de aterramento no Raspberry Pi: Pino 6, 9, 14, 20, 25, 30, 34, 39. Eu o conectei ao pino 6.

Conecte o VCC a qualquer um dos pinos de 5 volts no Raspberry Pi: Pino 2, 4. Usei o pino 4

Conecte o SDA ao pino 3.

Conecte o SCL ao pino 5.

Se você seguiu minha configuração, você terminará com todos os 4 fios em um padrão 2x2 nos conectores GPIO.

Seu método de montagem pode ser qualquer coisa que você possa imaginar … ou nada. Como eu disse na introdução, essa cepa do coronavírus não vai durar para sempre, então não preciso da minha configuração para nenhum dos dois. Se eu decidir manter essa configuração após o término do evento, posso transformá-la em uma exibição do tempo ou algo assim.

Coloquei uma porca e um parafuso junto com espaçadores de náilon em todos os 4 cantos do meu Pi 3A +. Isso é estritamente opcional. Fiz isso porque às vezes tenho isso em uma superfície de metal, não gosto de ter minhas configurações temporárias em um Pi que está dentro de uma caixa e não quero arriscar bagunçar porque esqueci de removê-lo do metal superfície antes de ligá-lo.

Etapa 2: configuração do software Pi

Como eu disse na introdução, não importa qual modelo Raspberry Pi você usa. Estou usando isso em um Raspberry Pi 3A + em WiFi, mas também testei no Raspberry Pi 2 no cabo Ethernet e no Raspberry Pi Zero versão 1.3 (o primeiro Pi Zero com o conector serial da câmera) com um dongle WiFi USB.

Não vou digitar como instalar o Raspbian em um cartão MicroSD porque existem milhões de instruções sobre como fazer isso. Eu tenho um microSD de 16 GB executando Raspbian Buster Lite. Em uma nota lateral, quase sempre uso Raspbian Lite porque não preciso dos outros pacotes de software inúteis em nenhum dos meus projetos. Se eu instalar o software usando apt-get, ele instalará os pré-requisitos ausentes.

Conectar a uma rede. Novamente, existem milhões de instruções sobre como fazer isso, então não vou me aprofundar aqui. Você pode usar com fio ou sem fio, mas isso exigirá uma conexão com a Internet.

Opcional, mas você pode habilitar o SSH para se conectar usando PuTTY. Eu fiz.

Atualize tudo e reinicie:

atualização do apt sudo

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

Esta é uma configuração que irei fazer aqui. Novamente, existem milhões de maneiras de fazer isso, mas a melhor referência que encontrei está bem aqui:

Aqui estão os destaques:

sudo apt install i2c-tools

sudo apt install python-smbus

Você também precisará habilitar I2C

sudo raspi-config

- 5 opções de interface

- P5 I2C

Reinicie para aplicar as alterações

sudo reboot

Agora é hora de ver se você fez tudo corretamente até agora

i2cdetect -y 1

Se o seu monitor estiver ligado e puder ser visto pelo seu Raspberry Pi, você terá um gráfico que aparecerá. O endereço do 20x4 que comprei na Amazon e uso para este projeto é 27. Tecnicamente, isso será identificado como 0x27 para os scripts python que virão mais tarde. Tive o mesmo endereço mostrado para 2 monitores 16x2 que também comprei na Amazon e um 40x2 que encontrei no eBay.

Etapa 3: configuração do Python

Então, agora para as coisas complexas. Vou tentar mantê-lo o mais simples possível. Para começar, estarei apenas gravando arquivos no diretório inicial.

toque em I2C_LCD_driver.py

nano I2C_LCD_driver.py

Cole o conteúdo abaixo em seu script Python recém-criado.

# - * - coding: utf-8 - * - # Código original encontrado em: #

"""

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

Eu sei que este script é muito confuso, mas é eficaz. Ele mostrará as estatísticas atuais para os casos de Covid-19 nos Estados Unidos. O banco de dados principal é atualizado a cada 5 minutos. Meu script leva 1 minuto para percorrer completamente as 3 páginas e obterá números atualizados toda vez que o ciclo começar novamente.

Etapa 4: execute o Python

Vamos começar:

python covid19.py

A primeira página mostra o número total de casos e mortes desde que o coronavírus atingiu o país. A segunda página mostra esses números para casos e óbitos que ocorreram apenas no dia atual. O terceiro mostra pessoas em estado crítico, depois casos e mortes por milhão de pessoas. A segunda linha da terceira página costumava mostrar a data do primeiro caso no país, mas tive que removê-la porque o script às vezes apresentava um erro e travava citando essa linha com um erro.

Existem maneiras de fazer esse script rodar automaticamente, mas não vou entrar em detalhes sobre isso aqui. Acabei de executar o meu por comando depois de conectar por SSH a ele por meio do PuTTY. Enquanto estiver em execução, você não poderá executar nenhum outro comando até pressionar Ctrl + C.

Etapa 5: E se eu não morar nos EUA?

Este script pode ser modificado para mostrar estatísticas para outros países. Como você pode ver, o URL em meu script extrai de uma API aqui: (não use o Internet Explorer para visualizar essas páginas. Ele tentará baixar um arquivo.json. Eu usei o Chrome)

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

Agora visite o mesmo endereço, mas uma pasta acima

coronavirus-19-api.herokuapp.com/countries

Isso lista as estatísticas para cada país. Obviamente, será um pesadelo tentar extrair dados da API desta página. Portanto, é melhor abrir a página para seu país específico. Nossos amigos no Canadá precisariam editar o script para este URL:

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

Nota muito importante aqui. O URL para a API precisa ser específico … o que significa que não há espaços em um URL. Na navegação na web, os espaços em um endereço da web são substituídos por "% 20" e, dito isso, nossos amigos em países com 2 nomes de partes, como a Nova Zelândia por exemplo, precisariam substituir o URL neste script por:

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

Etapa 6: Considerações Finais

Fiz muitas coisas com Raspberry Pi e Arduino ao longo dos anos, mas a maior parte do que construí são apenas réplicas de ideias de outros. Este é quase o mesmo, exceto que eu compilei partes de muitas fontes nesta configuração. Embora esta configuração não o mantenha seguro e saudável durante este período difícil, certamente o manterá ocupado enquanto a configura e o manterá informado posteriormente.

Se você ainda não tem essas peças, não se estresse em comprá-las, a menos que leve a sério sua construção. Como eu disse antes, o tempo de envio está demorando mais porque esses esforços estão sendo direcionados para itens essenciais. Eu só tinha essas partes para aprender e experimentar. O display montado em caixa foi originalmente configurado para exibir estatísticas em tempo real de outro Raspberry Pi na minha rede que está executando o Pi-Hole. Depois que esse evento Covid-19 acabar, posso transformá-lo em um mostrador do tempo.

Para qualquer pessoa que esteja lendo, quero dar um grito para este instrutível:

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

Ainda não experimentei, mas tenho esses ingredientes exatos e posso tentar alguma hora.