Werken met bestandssystemen

Deze tutorial beschrijft hoe de OpenMV Cam een bestandssysteem op het apparaat zelf biedt, waardoor standaard Python-bestands-I/O-methoden gebruikt kunnen worden met persistente opslag.

De OpenMV Cam maakt een standaardconfiguratie aan en detecteert en koppelt automatisch het primaire bestandssysteem bij het inschakelen, dus deze tutorial is vooral nuttig als je het flashgeheugen opnieuw wilt partitioneren, het type bestandssysteem wilt wijzigen of een aangepast blokapparaat wilt gebruiken.

Het bestandssysteem wordt ondersteund door het interne flashgeheugen, of door een SD-kaart wanneer er een geplaatst is.

VFS

MicroPython implementeert een Unix-achtige Virtual File System (VFS)-laag. Alle gekoppelde bestandssystemen worden gecombineerd tot één enkel virtueel bestandssysteem, beginnend bij de root /. Bestandssystemen worden gekoppeld in mappen binnen deze structuur, en bij het opstarten wordt de werkmap ingesteld op het primaire bestandssysteem.

Op de OpenMV Cam wordt het interne flashgeheugen gekoppeld op /flash en is dit de werkmap. Als er een SD-kaart geplaatst is, wordt deze gekoppeld op /sdcard en wordt in plaats daarvan de werkmap.

Blokapparaten

Een blokapparaat is een instantie van een klasse die het vfs.AbstractBlockDev-protocol implementeert.

Bij het inschakelen probeert de OpenMV Cam het bestandssysteem op het interne flashgeheugen (of de SD-kaart) te detecteren en automatisch te configureren en te koppelen. Als er geen bestandssysteem gevonden wordt, wordt een FAT-bestandssysteem aangemaakt dat het volledige flashgeheugen beslaat. Om het ingebouwde bestandssysteem te wissen of opnieuw te formatteren is de eenvoudigste weg OpenMV IDE of een fabrieksreset; de lager gelegen Python-API hieronder is bedoeld voor geavanceerd/programmatisch gebruik.

Intern flashgeheugen

Op STM32-gebaseerde OpenMV Cams biedt de klasse pyb.Flash toegang tot het interne flashgeheugen. Op borden met groter extern flashgeheugen wordt dat in plaats daarvan gebruikt. Het kwarg start moet altijd opgegeven worden, d.w.z. pyb.Flash(start=0).

Opmerking: Voor achterwaartse compatibiliteit implementeert het, wanneer geconstrueerd zonder argumenten (d.w.z. pyb.Flash()), alleen de eenvoudige blokinterface en weerspiegelt het het virtuele apparaat dat aan USB-massaopslag wordt gepresenteerd (d.w.z. het bevat een virtuele partitietabel aan het begin).

Aangepaste blokapparaten

Je kunt ook je eigen blokapparaat in Python maken en koppelen — bijvoorbeeld een RAM-schijf. De volgende klasse implementeert een eenvoudig blokapparaat dat zijn gegevens in RAM opslaat met behulp van een bytearray

class RAMBlockDev:
    def __init__(self, block_size, num_blocks):
        self.block_size = block_size
        self.data = bytearray(block_size * num_blocks)

    def readblocks(self, block_num, buf):
        for i in range(len(buf)):
            buf[i] = self.data[block_num * self.block_size + i]

    def writeblocks(self, block_num, buf):
        for i in range(len(buf)):
            self.data[block_num * self.block_size + i] = buf[i]

    def ioctl(self, op, arg):
        if op == 4: # get number of blocks
            return len(self.data) // self.block_size
        if op == 5: # get block size
            return self.block_size

Het kan als volgt gebruikt worden:

import vfs

bdev = RAMBlockDev(512, 50)
vfs.VfsFat.mkfs(bdev)
vfs.mount(bdev, '/ramdisk')

Eenmaal gekoppeld kan het bestandssysteem gebruikt worden zoals het normaal vanuit Python-code gebruikt zou worden, bijvoorbeeld:

with open('/ramdisk/hello.txt', 'w') as f:
    f.write('Hello world')
print(open('/ramdisk/hello.txt').read())

Bestandssystemen

De OpenMV Cam formatteert het interne flashgeheugen als FAT zodat, op borden die het bestandssysteem via USB-massaopslag beschikbaar maken, de host-pc het kan lezen en schrijven zonder extra stuurprogramma’s.

FAT is niet bestand tegen stroomuitval tijdens schrijfacties, wat kan leiden tot beschadiging van het bestandssysteem. Werp de schijf uit/ontkoppel deze op de host voordat je de camera uitschakelt, en geef de voorkeur aan een SD-kaart boven het interne flashgeheugen voor gegevens die het script terugschrijft.

Op STM32-gebaseerde OpenMV Cams kan het interne flashgeheugen vanuit Python opnieuw geformatteerd worden:

import os, vfs, pyb
vfs.umount('/flash')
vfs.VfsFat.mkfs(pyb.Flash(start=0))
vfs.mount(pyb.Flash(start=0), '/flash')
os.chdir('/flash')