Arbeta med filsystem

Den här handledningen beskriver hur OpenMV Cam tillhandahåller ett filsystem på enheten, vilket gör att Pythons vanliga metoder för fil-I/O kan användas med beständig lagring.

OpenMV Cam skapar en standardkonfiguration och identifierar samt monterar automatiskt det primära filsystemet vid uppstart, så den här handledningen är främst användbar om du vill partitionera om flashminnet, byta filsystemstyp eller använda en egen blockenhet.

Filsystemet ligger på det interna flashminnet, eller på ett SD-kort när ett sådant är installerat.

VFS

MicroPython implementerar ett Unix-liknande virtuellt filsystemlager (VFS). Alla monterade filsystem kombineras till ett enda virtuellt filsystem, med början i roten /. Filsystem monteras i kataloger i denna struktur, och vid uppstart sätts arbetskatalogen till det primära filsystemet.

På OpenMV Cam monteras det interna flashminnet vid /flash och utgör arbetskatalogen. Om ett SD-kort är installerat monteras det vid /sdcard och blir arbetskatalog i stället.

Blockenheter

En blockenhet är en instans av en klass som implementerar protokollet vfs.AbstractBlockDev.

Vid uppstart försöker OpenMV Cam identifiera filsystemet på det interna flashminnet (eller SD-kortet) och konfigurera samt montera det automatiskt. Om inget filsystem hittas skapas ett FAT-filsystem som spänner över hela flashminnet. För att radera eller formatera om filsystemet ombord är den enklaste vägen OpenMV IDE eller en fabriksåterställning; Python-API:et på lägre nivå nedan är avsett för avancerad/programmatisk användning.

Internt flashminne

På STM32-baserade OpenMV Cam ger klassen pyb.Flash åtkomst till det interna flashminnet. På kort som har ett större externt flashminne används det i stället. Nyckelordsargumentet start bör alltid anges, dvs. pyb.Flash(start=0).

Observera: För bakåtkompatibilitet implementerar den, när den konstrueras utan argument (dvs. pyb.Flash()), endast det enkla blockgränssnittet och återspeglar den virtuella enhet som presenteras för USB-masslagring (dvs. den inkluderar en virtuell partitionstabell i början).

Egna blockenheter

Du kan också skapa din egen blockenhet i Python och montera den — till exempel en RAM-disk. Följande klass implementerar en enkel blockenhet som lagrar sina data i RAM med hjälp av en 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

Den kan användas på följande sätt:

import vfs

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

När den väl är monterad kan filsystemet användas precis som det normalt skulle användas från Python-kod, till exempel:

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

Filsystem

OpenMV Cam formaterar det interna flashminnet som FAT så att värddatorn, på kort som exponerar filsystemet via USB-masslagring, kan läsa och skriva till det utan extra drivrutiner.

FAT tål inte strömavbrott under skrivningar, vilket kan leda till att filsystemet skadas. Mata ut/avmontera enheten på värddatorn innan du stänger av kameran, och föredra ett SD-kort framför det interna flashminnet för data som skriptet skriver tillbaka.

På STM32-baserade OpenMV Cam kan det interna flashminnet formateras om från Python:

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