Praca z systemami plików

Ten samouczek opisuje, w jaki sposób OpenMV Cam udostępnia system plików na urządzeniu, umożliwiając korzystanie ze standardowych metod wejścia/wyjścia plików w Pythonie wraz z trwałą pamięcią.

OpenMV Cam tworzy domyślną konfigurację oraz automatycznie wykrywa i montuje główny system plików przy włączeniu zasilania, więc ten samouczek jest przydatny głównie wtedy, gdy chcesz na nowo podzielić pamięć flash na partycje, zmienić typ systemu plików lub użyć niestandardowego urządzenia blokowego.

System plików jest oparty na wewnętrznej pamięci flash lub na karcie SD, gdy jest ona zainstalowana.

VFS

MicroPython implementuje warstwę wirtualnego systemu plików (VFS) w stylu Uniksa. Wszystkie zamontowane systemy plików są łączone w jeden wirtualny system plików, rozpoczynający się od katalogu głównego /. Systemy plików są montowane w katalogach tej struktury, a przy starcie katalog roboczy jest ustawiany na główny system plików.

W OpenMV Cam wewnętrzna pamięć flash jest montowana w /flash i jest katalogiem roboczym. Jeśli zainstalowana jest karta SD, jest ona montowana w /sdcard i to ona staje się katalogiem roboczym.

Urządzenia blokowe

Urządzenie blokowe jest instancją klasy implementującej protokół vfs.AbstractBlockDev.

Przy włączeniu zasilania OpenMV Cam próbuje wykryć system plików na wewnętrznej pamięci flash (lub karcie SD) oraz automatycznie go skonfigurować i zamontować. Jeśli nie znaleziono żadnego systemu plików, tworzony jest system plików FAT obejmujący całą pamięć flash. Aby wymazać lub sformatować wbudowany system plików, najprostszą drogą jest OpenMV IDE lub przywrócenie ustawień fabrycznych; niskopoziomowe API Pythona poniżej jest przeznaczone do zastosowań zaawansowanych/programowych.

Wewnętrzna pamięć flash

Na kamerach OpenMV Cam opartych na STM32 klasa pyb.Flash zapewnia dostęp do wewnętrznej pamięci flash. Na płytkach posiadających większą zewnętrzną pamięć flash używana będzie zamiast niej. Argument start powinien być zawsze podawany, tj. pyb.Flash(start=0).

Uwaga: dla zachowania zgodności wstecznej, gdy obiekt jest tworzony bez argumentów (tj. pyb.Flash()), implementuje on jedynie prosty interfejs blokowy i odzwierciedla wirtualne urządzenie prezentowane jako pamięć masowa USB (tj. zawiera wirtualną tablicę partycji na początku).

Niestandardowe urządzenia blokowe

Możesz również utworzyć własne urządzenie blokowe w Pythonie i je zamontować — na przykład dysk RAM. Poniższa klasa implementuje proste urządzenie blokowe, które przechowuje swoje dane w pamięci RAM przy użyciu 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

Można go używać w następujący sposób:

import vfs

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

Po zamontowaniu system plików może być używany w normalny sposób z poziomu kodu Pythona, na przykład:

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

Systemy plików

OpenMV Cam formatuje wewnętrzną pamięć flash jako FAT, dzięki czemu na płytkach udostępniających system plików jako pamięć masową USB komputer-host może go odczytywać i zapisywać bez żadnych dodatkowych sterowników.

FAT nie jest odporny na utratę zasilania podczas zapisu, co może prowadzić do uszkodzenia systemu plików. Wysuń/odmontuj dysk na hoście przed wyłączeniem kamery i w przypadku danych zapisywanych przez skrypt preferuj kartę SD zamiast wewnętrznej pamięci flash.

Na kamerach OpenMV Cam opartych na STM32 wewnętrzną pamięć flash można sformatować z poziomu Pythona:

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