O registro de dados é parte integrante de muitos projetos incorporados. Normalmente, o registro de dados é usado para registrar leituras de sensores, com ou sem carimbo de data/hora. Por exemplo, muitos aplicativos IoT usam registro de dados para armazenar alterações de rede ou dados para solução de problemas ou verificação.
A maneira ideal de registrar dados localmente é usando um cartão SD ou MicroSD. A maioria dos leitores de cartão pode fazer interface com microcontroladores ou microcomputadores por meio de uma porta SPI.
O firmware do módulo de máquina MicroPython contém uma classe SDCard para trabalhar com leitores de cartão SD e MicroSD. A classe machine.SDCard suporta dispositivos de armazenamento SD, MMC e eMMC. O protocolo de comunicação para todos os três tipos de dispositivos de armazenamento é feito através da porta SPI.
A classe SDCard pode ser implementada usando as portas Pyboard, ESP32, CC3200 e mimxrt do MicroPython. O módulo SDCard não é suportado por outras portas.
Neste artigo, discutiremos como fazer a interface de um leitor de cartão SD ou MicroSD com ESP32.
Com esses cartões, é possível adicionar de 4 a 128 GB de armazenamento ao sistema embarcado. Os dados do sensor ou outros dados são registrados em arquivos de texto simples no cartão SD/MicroSD. A maioria dos cartões SD ou MicroSD fornece uma interface de 1 bit para o cartão de memória. A porta SPI é usada nas placas breakout do cartão SD para acessar o dispositivo de armazenamento.
Componentes necessários
Os seguintes componentes são necessários para registro de dados no ESP32.
1. ESP32 x1
2. Módulo de cartão MicroSD x1
3. Cartão MicroSD de 8 GB
4. Cabo microUSB para conectar o ESP32 ao computador
5. Fios de ligação em ponte
Módulo de cartão MicroSD
O módulo de cartão MicroSD contém um slot para inserção do cartão e seis terminais para interface com um microcontrolador. VDD e terra são dois dos pinos. Os outros quatro pinos – MISO, MOSI, SCK e CS – são os terminais da porta SPI que facilitam a interface de 1 bit com o cartão de memória.
A configuração de pinos de um cartão MicroSD.
Cartão MicroSD e ESP32
Para fazer interface do módulo de cartão MicroSD com ESP32:
- Conecte os pinos MOSI, MISO, SCLK e CS do módulo aos pinos GPIO12, GPIO13, GPIO14 e GPIO27 do ESP32. Esses pinos correspondem ao HSPI (SPI1) do ESP32.
- Conecte os pinos VCC e GND do módulo aos 3,3V do ESP32 e aterre.
Os leitores de cartão MicroSD possuem reguladores de tensão integrados para converter a tensão de entrada em 3,3 Vcc. Mas uma tensão tão alta quanto 5V DC pode danificar o módulo ou corromper o cartão de memória.
As conexões do circuito para fazer a interface do módulo do cartão MicroSD com o ESP32.
O módulo da máquina MicroPython
O módulo de máquina do MicroPython foi escrito para lidar com as funções de hardware das portas suportadas. O módulo inclui classes para controlar ou gerenciar a entrada/saída digital, sinais de saída de dispositivos externos, modulação por largura de pulso, conversão analógica para digital, controle de periféricos ADC, UART, SPI, I2C, I2S, temporizador, RTC, temporizador watchdog e SD cartão.
A classe SDcard do módulo suporta a leitura de cartões de memória SD, MMC e eMMC.
Classe SDCard
A classe SDCard fornece acesso aos cartões de memória SD ou MMC usando uma interface SD/MMC dedicada em uma determinada porta MicroPython ou através de um canal SPI.
Para usar a classe em um script MicroPython, o sdcard.py deve ser carregado no ESP32 e depois importado para o script. O SO e o módulo da máquina também devem ser importados.
Para importar os módulos necessários, adicione esta instrução em um script MicroPython:
máquina de importação, cartão SD, sistema operacional
Um objeto da classe SDCard deve ser inicializado dentro do script. O construtor da classe SDCard possui este protótipo:
class machine.SDCard(slot=1, largura=1, cd=Nenhum, wp=Nenhum, sck=Nenhum, miso=Nenhum, mosi=Nenhum, cs=Nenhum, freq=20000000)
Os parâmetros na função construtora:
- slot: seleciona uma das interfaces disponíveis ou usa o padrão
- largura: seleciona a largura do barramento para a interface SD/MMC (para adaptadores de cartão SD/MicroSD, a largura é “1”. Não é necessário especificá-la explicitamente, a menos que o hardware na porta do cartão SD tenha uma interface paralela para ler cartões de memória.)
- cd: especifica um pino de detecção de cartão
- wp: especifica um pino de proteção contra gravação
- sck: especifica um pino de clock SPI
- missô: especifica um pino miso SPI
- mosi: especifica um pino SPI mosi
- cs: especifica um pino de seleção de chip SPI
- frequencia: seleciona a frequência da interface SD/MMC em Hz (suportado apenas no ESP32)
Existem dois blocos SPI de hardware no ESP32: HSPI (SPI1) e VSPI (SPI2). Para este projeto, o adaptador de cartão MicroSD tem interface via SPI 1.
Para iniciar o objeto SDCard, adicione esta instrução ao script MicroPython:
sd = sdcard.SDCard(máquina.SPI(1), máquina.Pin(27))
O módulo do sistema operacional
O módulo MicroPython OS fornece funções para acesso e montagem do sistema de arquivos. Os métodos a seguir são úteis ao trabalhar com um cartão MicroSD.
os.VfsFat : cria um objeto de sistema de arquivos que usa o formato de sistema de arquivos FAT. Um dispositivo de bloco, que implementa o protocolo de bloco, fornece armazenamento do sistema de arquivos FAT. Essencialmente, ele permite que um dispositivo suporte o sistema de arquivos MicroPython. O hardware físico é representado pela classe do sistema de arquivos. Um sistema de arquivos FAT é usado quando um objeto é criado com os.VfsFat . O objeto pode ser montado usando o método os.mount .
Portas MicroPython suportam sistemas de arquivos.
os.mount : monta objetos do sistema de arquivos especificados no local do sistema de arquivos virtual fornecido por um argumento de string. O objeto do sistema de arquivos pode ser um objeto virtual que possui um método mount ou um dispositivo de bloco. Se for um dispositivo de bloco, o tipo de sistema de arquivos será detectado automaticamente; caso contrário, uma exceção será levantada.
A string que especifica o local pode ser '/' para montar o objeto do sistema de arquivos na raiz ou '/
os.listdir : se chamado sem argumento, lista o diretório atual. Caso contrário, lista o diretório especificado.
os.umount : “desmonta” um sistema de arquivos. O local pode ser uma string nomeando o local de montagem ou um objeto do sistema de arquivos montado anteriormente. Durante o processo de desmontagem, o método umount é chamado para o objeto do sistema de arquivos.
Este é um exemplo válido de sistema de arquivos FAT para um cartão MicroSD, montando o objeto do sistema de arquivos na memória.
vfs = os.VfsFat(sd)
os.mount(vfs, “/fc”)
print(“Verificação do sistema de arquivos”)
imprimir(os.listdir(“/fc”))
Criando arquivos de texto
Adicionar arquivos de texto simples a um cartão MicroSD é simples. É possível criar vários arquivos de texto simples em um cartão de memória. Basta criar uma string especificando o caminho do arquivo de texto.
Aqui está um exemplo válido para criar arquivos de texto simples em um cartão MicroSD usando MicroPython.
fn = “/fc/log.txt”
Escrevendo um único bloco
Um único bloco é uma linha de texto. Um arquivo deve ser especificado com uma variável string e um caminho de arquivo especificado deve ser aberto usando o método open para escrever um bloco. O argumento “w” também deve ser passado como modo de arquivo. Um único bloco pode ser escrito chamando o método write .
Este é um exemplo válido de gravação de um único bloco em um arquivo de texto em um cartão MicroSD.
fn = “/fc/one-line-log.txt”
imprimir
print(“Escrita em bloco único”)
com open(fn, “w”) como f:
n = f.write(“1234567890\n”) # um bloco
print(n, “bytes escritos”)
Lendo um único bloco
Para ler um arquivo, o arquivo especificado por uma variável string deve ser aberto usando o método open com o modo de arquivo especificado como “r”. O arquivo é lido chamando o método read .
Este é um exemplo válido de leitura de um arquivo de texto de um cartão MicroSD.
fn = “/fc/one-line-log.txt”
imprimir
print(“Leitura de bloco único”)
com open(fn, “r”) como f:
resultado = f.read
print(len(resultado2), “bytes lidos”)
imprimir
imprimir (resultado)
Escrevendo vários blocos
Escrever vários blocos em um arquivo de texto é semelhante a escrever um único bloco, exceto que o objeto string passado contém várias linhas de texto.
Aqui está um exemplo válido de gravação de vários blocos em um arquivo de texto em um cartão MicroSD.
linha = “abcdefghijklmnopqrstuvwxyz\n”
linhas = linha * 200 # 5400 caracteres
fn = “/fc/multi-line-log.txt”
imprimir
print(“Escrita em vários blocos”)
com open(fn, “w”) como f:
n = f.write(linhas)
print(n, “bytes escritos”)
Lendo vários blocos
Várias linhas em um arquivo de texto são lidas de forma semelhante a uma única linha. Aqui está um exemplo válido de leitura de arquivo de texto multibloco de um cartão MicroSD.
fn = “/fc/multi-line-log.txt”
imprimir
print(“Leitura de vários blocos”)
com open(fn, “r”) como f:
resultado = f.read
print(len(resultado2), “bytes lidos”)
imprimir
imprimir (resultado)
Preparando o ESP32
Antes de continuar, certifique-se de que o MicroPython IDE esteja pronto para escrever, editar e fazer upload dos códigos. Você pode usar uPyCraft IDE ou Thonny IDE como desenvolvimento de software. Com a ajuda do respectivo IDE, carregue o firmware MicroPython para ESP8266 ou ESP32.
Para saber como Clique aqui.
Carregando sdcard.py para ESP32
No uPyCraft IDE, crie um novo arquivo navegando em Arquivos->Novo. Copie e cole o código a seguir no arquivo e salve-o como sdcard.py.
Clique no botão “DownloadandRun” para fazer upload do sdcard.py no diretório raiz do ESP32. Verifique o log do console para verificar a gravação e leitura dos arquivos de texto no cartão MicroSD. Depois que os arquivos são gravados, o número de bytes é relatado. Após a leitura dos arquivos, o número de bytes é lido e o texto lido é impresso no console.
