使用文件系统 内容 使用文件系统
3 x4 r4 S7 G1 ~$ H. m0 Q; T u虚拟FS 块设备
! b) G- \: `8 s3 A z5 M* j内置块设备
2 q& P0 D t2 D7 n6 ]4 p自定义块设备 : X& d! i( O3 n2 }6 @. k H
文件系统
3 h% C* }7 d" _. V5 K: q1 Y5 ^! }( [3 F
+ m& }( ~7 i1 f5 F/ n , o8 Y f5 Y3 D- d: o
本教程介绍 MicroPython 如何提供设备上的文件系统,允许将标准 Python 文件 I/O 方法与持久存储一起使用。 MicroPython 会自动创建默认配置并自动检测主文件系统,因此如果您想修改分区、文件系统类型或使用自定义块设备,本教程将非常有用。 文件系统通常由设备上的内部闪存支持,但也可以使用外部闪存、RAM 或自定义块设备。 在某些端口(例如 STM32)上,文件系统也可以通过 USB MSC 连接到主机 PC。pyboard.py 工具还为主机 PC 提供了一种访问所有端口上的文件系统的方法。 注意:这主要用于 STM32 和 ESP32 等裸机端口。在带有操作系统的端口(例如 Unix 端口)上,文件系统由主机操作系统提供。 虚拟FSMicroPython 实现了一个类 Unix 虚拟文件系统 (VFS) 层。所有挂载的文件系统都组合成一个单一的虚拟文件系统,从 root 开始 /。文件系统被挂载到这个结构的目录中,并且在启动时工作目录被更改为主文件系统被挂载的位置。 在 STM32/Pyboard 上,内部闪存安装在 /flash,可选的 SDCard安装在/sd。在 ESP8266/ESP32 上,主文件系统挂载在 /。
( y; F0 \6 c( _! f# {块设备块设备是实现 uos.AbstractBlockDev协议的类的实例 。 内置块设备端口提供内置块设备来访问它们的主闪存。 开机时,MicroPython 将尝试检测默认闪存上的文件系统并自动配置和挂载它。如果没有找到文件系统,MicroPython 将尝试创建一个跨越整个闪存的 FAT 文件系统。端口还可以提供一种机制来“恢复出厂设置”主闪存,通常是通过在开机时按下按钮的某种组合。 STM32 / Pyboard该pyb.Flash类,可以访问内部闪存。在一些具有较大外部闪存的板上(例如 Pyboard D),它将使用它来代替。该 startkwarg应始终指定,即 pyb.Flash(start=0)。 注意:为了向后兼容,当构造没有参数时(即 pyb.Flash()),它只实现简单的块接口并反映呈现给 USB MSC 的虚拟设备(即它在开始时包含一个虚拟分区表)。
1 C# H- | k! B: I- R# vESP8266内部闪存作为块设备对象公开,该对象 flashbdev 在启动时在模块中创建 。默认情况下,此对象作为全局变量添加,因此通常可以简单地作为bdev. 这实现了扩展接口。 - \+ B9 t/ F6 A% P$ E
ESP32esp32.Partition类用于实现为板限定分区的块设备。与 ESP8266 一样,有一个全局变量 bdev指向默认分区。这实现了扩展接口。 7 z* Z6 ^& B& n; m+ w
2 J( j* |( E0 X, w/ A
自定义块设备以下类实现了一个简单的块设备,该设备使用以下命令将其数据存储在 RAM 中 bytearray: - class RAMBlockDev:8 T6 G: k) a/ L. U9 P0 z5 B, E" r
- def __init__(self, block_size, num_blocks):! K( W, H2 f+ D( g8 C1 `& J
- self.block_size = block_size1 D- i4 X5 m# _. c; L
- self.data = bytearray(block_size * num_blocks), ?/ M! U6 N/ `
8 c# ?. s# O' d- Z; L E' X- def readblocks(self, block_num, buf):
$ D ?2 n6 z! T7 h! f - for i in range(len(buf)):
" F* M& ~7 Z+ ?" r! ? - buf[i] = self.data[block_num * self.block_size + i]/ k. g0 q' L8 {' g$ s8 ]! T
- ( g5 y% d0 d$ H
- def writeblocks(self, block_num, buf):
- `5 H9 a6 k! Z8 F - for i in range(len(buf)):
! X9 D/ x2 B, D% }* q# F# V+ v. I - self.data[block_num * self.block_size + i] = buf[i]& L9 |2 A1 I9 u; B1 N
- " s0 d+ e& ]( S
- def ioctl(self, op, arg):1 H0 A, Z. O0 G: |0 I' q
- if op == 4: # get number of blocks
) @% g& u: M" G3 D - return len(self.data) // self.block_size
7 W$ v* D: U, b, w& f1 U% ^ - if op == 5: # get block size
4 G1 c/ Q$ f# b - return self.block_size
复制代码 & ^8 P$ G- m1 B. I% G4 {1 `
" T& C* Y' U6 R. \' X- G L
6 q5 b* p- |8 G1 l9 N+ O' ^6 V它可以按如下方式使用: - import os3 d: B+ B# _. Y! }' a8 \' i2 f
2 q: g$ y3 C) ^8 z" C9 d- bdev = RAMBlockDev(512, 50)8 M6 G# t2 j' {
- os.VfsFat.mkfs(bdev)
- E& K6 Z' T3 f* r' a& m0 n' _ - os.mount(bdev, '/ramdisk')
复制代码
. ~8 C2 a* `7 ]9 a" Y6 L( E* D9 E0 N4 p# D* a& Z% o
0 ]4 W* U, j+ J. {6 t1 W( v支持简单接口和扩展接口(即 uos.AbstractBlockDev.readblocks() 和 uos.AbstractBlockDev.writeblocks() 方法的签名和行为)的块设备的示例 是: - class RAMBlockDev:, D/ A# ?9 x+ x0 `/ r9 r5 M- \
- def __init__(self, block_size, num_blocks):0 k+ u3 f& f0 X* g8 l& P* U
- self.block_size = block_size& w3 m" `- _8 B9 ^5 [6 X# i
- self.data = bytearray(block_size * num_blocks)4 H$ O0 A% c1 X3 t
8 ?$ ?: a6 N0 M- def readblocks(self, block_num, buf, offset=0):( O G7 @4 [! u" r, v% Y
- addr = block_num * self.block_size + offset( h: G% t# s$ V" n9 x
- for i in range(len(buf)):6 W3 O: n) }. {, \
- buf[i] = self.data[addr + i]; C' Q5 S1 C' q$ V) X4 X
- O3 u4 D5 t; I9 C4 E: y- def writeblocks(self, block_num, buf, offset=None):/ B8 U( @2 n% A6 n* v9 g
- if offset is None:5 z7 Y; Q2 V8 ^1 a0 J2 J
- # do erase, then write* S4 U y# N- o, S- S8 r" D
- for i in range(len(buf) // self.block_size):; ?9 [( q8 V0 p5 @: d8 i
- self.ioctl(6, block_num + i)
! i2 V# k1 ~2 G - offset = 00 }6 Z* M$ h" K) n1 r2 t% Z% c" R* h; P
- addr = block_num * self.block_size + offset
) q; ]$ [/ W# S2 W5 o - for i in range(len(buf)):" ^) B* K1 U p& {9 M, H
- self.data[addr + i] = buf[i]) g' W1 q, }! l4 n+ F1 C, W3 G
- " m; C+ R! P3 K1 @
- def ioctl(self, op, arg):; e6 |# `6 J- {7 C* F9 \
- if op == 4: # block count/ v5 t% K2 @( m( c7 a
- return len(self.data) // self.block_size
, d& _4 R) c X& S- F# v7 x. u - if op == 5: # block size
5 w: m* \3 r+ ?- v D1 y7 Y& I - return self.block_size1 l, B* K9 ~/ z1 U% x* S
- if op == 6: # block erase
$ u2 B3 g) J9 t/ {7 \ - return 0
复制代码 % c% J0 o x j# a) \2 H
) B. G( s1 r$ x/ c! v
9 G* {( i B' A6 ~3 S: ^1 \
由于它支持扩展接口,因此可以用于littlefs: - import os
. E" @6 U g) }4 L4 ^7 l7 Q
* P. o6 J7 s8 g S% e3 l- bdev = RAMBlockDev(512, 50)+ M" ]( Y% h: `8 y" q) H/ l4 r6 J
- os.VfsLfs2.mkfs(bdev)
$ F8 p. D9 |7 t. p! A# I9 I - os.mount(bdev, '/ramdisk')
复制代码 " m1 q# T. z0 P: R' E$ |+ s1 U
; T s6 X7 F' V
7 w% l5 j' `5 S: I5 s2 S一旦挂载,文件系统(无论其类型如何)就可以像通常在 Python 代码中使用的那样使用,例如: - with open('/ramdisk/hello.txt', 'w') as f:
8 k2 A# w# ?6 S1 o1 a/ c3 j - f.write('Hello world')
8 \! I+ T" D6 q8 L2 u! K - print(open('/ramdisk/hello.txt').read())
复制代码 $ W0 T% X) g" L" E: U6 ?0 N7 ]. ^
! U9 ?9 t9 C! V) y, b7 n
0 F6 j& D7 S( a: N+ ^ I2 m# l" a( s2 U
& u5 |# ?. L) w! |9 h$ Z8 m
文件系统MicroPython 端口可以提供 FAT、 和 的实现。 littlefs v1 and littlefs v2. 下表显示了固件中默认包含给定端口/板组合的文件系统,但可以在自定义固件构建中选择启用它们。 - j. u& Y" j0 Y) t; e, x, K0 t3 u
FATFAT 文件系统的主要优点是它可以通过支持的板(例如 STM32)上的 USB MSC 访问,而主机 PC 上不需要任何额外的驱动程序。 但是,FAT 不能容忍写入期间的电源故障,这可能会导致文件系统损坏。对于不需要 USB MSC 的应用,建议使用 littlefs 代替。 要使用 FAT 格式化整个闪存: - # ESP8266 and ESP32
0 j j1 C6 [7 L$ z# a& | - import os
( k& s& h: y# @5 J4 h4 H K - os.umount('/')
, J" y7 n+ ]9 V7 U7 B - os.VfsFat.mkfs(bdev)- ~" b) E7 c$ @( R
- os.mount(bdev, '/')* _# w* ~8 e/ r" D
- 4 q G% D; {/ s- ]
- # STM32
/ k/ X b9 E/ D3 y% Z4 f. |5 Y8 I - import os, pyb# {9 i2 X9 p D- T8 f0 N' j* I9 T- k7 I
- os.umount('/flash')
- E; u, ^. {) m0 d( ^: m - os.VfsFat.mkfs(pyb.Flash(start=0))) H1 p8 U$ q4 v2 w7 p
- os.mount(pyb.Flash(start=0), '/flash')
( Q. r' [" v& L% Z* Y" E- M - os.chdir('/flash')
复制代码 * u! _3 H& ^0 ]3 C! J2 X6 d
6 ]: e1 s5 ?7 y& J$ e
8 \8 Y* h5 T# G" ^1 G" \9 ~/ _( n" W% X+ y" q3 G2 ?
LittlefsLittlefs是专为基于闪存的设备设计的文件系统,对文件系统损坏具有更强的抵抗力。 笔记 有报告称 littlefs v1 和 v2 在某些情况下会失败,有关详细信息,请参阅littlefs issue 347 和 littlefs issue 295.
5 p: R- v9 P9 g: f% g5 y注意:它仍然可以使用 littlefs FUSE 驱动程序通过 USB MSC 访问。请注意,您必须使用该-b=4096 选项来覆盖块大小。 使用 littlefs v2 格式化整个闪存: - # ESP8266 and ESP325 v0 K- W5 T N; U1 g' R: K
- import os
[- n2 n9 p( }5 h - os.umount('/') z" Q% t ?) ~
- os.VfsLfs2.mkfs(bdev)
/ c* A9 n. I! @) ? f J* G - os.mount(bdev, '/')
7 m/ r3 N0 F8 A$ H# J$ `( p S0 t3 T - # [6 p. n& l& s6 C
- # STM321 t V+ t+ ^2 X, a2 i4 Z
- import os, pyb
/ G1 ]# H, c: { - os.umount('/flash')
+ l, \) ?7 A: F' l5 T+ }8 N - os.VfsLfs2.mkfs(pyb.Flash(start=0))* e( }9 ?) i; i3 o# c& \
- os.mount(pyb.Flash(start=0), '/flash')
+ [& F, ^( p- {, w' ~* Z& x - os.chdir('/flash')
复制代码
- w e1 d% P" y( ]0 t! D# R* B
+ C; E8 n4 M/ }! i7 I! v* S7 |+ i0 G8 b
" O, }3 i7 B* k0 _$ m
混合 (STM32)通过使用 start 和 len kwargs to pyb.Flash,您可以创建跨越闪存设备子集的块设备。 例如,将第一个 256kiB 配置为 FAT(并通过 USB MSC 可用),其余配置为 littlefs: - import os, pyb
5 Z6 e6 \' z ^# R& ` - os.umount('/flash')4 p" Z. c& x. {* t% @
- p1 = pyb.Flash(start=0, len=256*1024)
4 H" B! x, p* h% t U' X2 B - p2 = pyb.Flash(start=256*1024)) p; p% {- G2 _7 V
- os.VfsFat.mkfs(p1), k( W& l' `& P d
- os.VfsLfs2.mkfs(p2)
7 f3 ^3 D) |$ @$ H - os.mount(p1, '/flash')
4 k! t3 e: w0 t! I8 [4 h7 d0 @ - os.mount(p2, '/data')3 l- f4 s6 T% k
- os.chdir('/flash')
复制代码 9 H9 A& j# b, N/ g- E# G. }) m
* L5 [( a/ m( S9 q( J1 {
2 Q& P+ A U i' B这可能有助于使您的 Python 文件、配置和其他很少修改的内容通过 USB MSC 可用,但允许频繁更改的应用程序数据驻留在 littlefs 上,从而具有更好的电源故障恢复能力等。 偏移处的分区 0 将自动挂载(并自动检测文件系统类型),但您可以添加: - import os, pyb, {5 p) R! j+ b; I' ~7 p3 T
- p2 = pyb.Flash(start=256*1024)- P8 X/ }, y1 R& m+ @* L
- os.mount(p2, '/data')
复制代码 & f! q1 v8 |5 W
- t0 e& m( H' W+ b+ B. Q$ q" D
9 C1 a3 ~' o" s5 O: H来 boot.py挂载数据分区。 4 a/ _7 W' [& \% W, `0 I
混合动力(ESP32)在 ESP32 上,如果您构建自定义固件,您可以修改 partitions.csv以定义任意分区布局。 启动时,名为“vfs”的分区将被/默认挂载,但任何额外的分区都可以boot.py 使用: - import esp32, os
5 u5 i) @4 o1 [5 y( O- q - p = esp32.Partition.find(esp32.Partition.TYPE_DATA, label='foo')+ N/ N( O9 m" g, n8 T; U
- os.mount(p, '/foo')
复制代码
( s1 e {4 U2 [0 z( t
& @7 c7 M3 ?$ t6 k( Q7 }- N. t0 o! @; T* k) x: H4 y' {. T
4 k# o% D# Z7 h! t$ D9 S9 j
$ B6 z6 _% x$ E% ^, Z1 Z2 s# L
|