使用文件系统 内容 使用文件系统
1 `' L0 G9 L/ p8 b* z% z虚拟FS 块设备
5 {! f$ h' Z" u" @ Y5 o0 X2 m内置块设备
7 e! o+ W/ T* X: H# k1 C$ g- M自定义块设备
- z* ~7 o/ Z( O! ?& j$ u
文件系统 * P2 L( b# N! Q9 F
8 o/ @" X! ^2 W7 ~; c8 Q3 p! X% Y ) z- p& F6 a+ g' \$ A
! ^- \, ?- _7 a& W, ^( g% z( 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 上,主文件系统挂载在 /。
+ Q, B8 e3 M* ^% g3 r块设备块设备是实现 uos.AbstractBlockDev协议的类的实例 。 内置块设备端口提供内置块设备来访问它们的主闪存。 开机时,MicroPython 将尝试检测默认闪存上的文件系统并自动配置和挂载它。如果没有找到文件系统,MicroPython 将尝试创建一个跨越整个闪存的 FAT 文件系统。端口还可以提供一种机制来“恢复出厂设置”主闪存,通常是通过在开机时按下按钮的某种组合。 STM32 / Pyboard该pyb.Flash类,可以访问内部闪存。在一些具有较大外部闪存的板上(例如 Pyboard D),它将使用它来代替。该 startkwarg应始终指定,即 pyb.Flash(start=0)。 注意:为了向后兼容,当构造没有参数时(即 pyb.Flash()),它只实现简单的块接口并反映呈现给 USB MSC 的虚拟设备(即它在开始时包含一个虚拟分区表)。
& D" M! X y3 d% S% ^- lESP8266内部闪存作为块设备对象公开,该对象 flashbdev 在启动时在模块中创建 。默认情况下,此对象作为全局变量添加,因此通常可以简单地作为bdev. 这实现了扩展接口。
& k" s: k F$ \( ~8 k; c" oESP32esp32.Partition类用于实现为板限定分区的块设备。与 ESP8266 一样,有一个全局变量 bdev指向默认分区。这实现了扩展接口。 `9 y% m8 n, U, T0 W4 h% g
" G! j- ~1 C+ z8 X* v' b自定义块设备以下类实现了一个简单的块设备,该设备使用以下命令将其数据存储在 RAM 中 bytearray: - class RAMBlockDev:% r% q$ t1 [6 [( e: F
- def __init__(self, block_size, num_blocks):! I8 ~* x5 p, x2 R- e0 q T& D
- self.block_size = block_size
! x/ |; z; \; W. z2 I - self.data = bytearray(block_size * num_blocks)
. n) B2 ~& e P3 S8 [9 \ - : p& W0 g. |# D
- def readblocks(self, block_num, buf):
& P3 _. A: c0 F/ p0 K& W - for i in range(len(buf)):
, e# C/ G% B) }* w) D; ` - buf[i] = self.data[block_num * self.block_size + i]
3 w6 t4 r5 Z! U, u9 m) L) t( M - * r; z; ` h* p7 D' Z, H! G
- def writeblocks(self, block_num, buf):
: @8 V3 s$ N; I3 a; Q3 {1 U - for i in range(len(buf)):
; n M0 Q: R F4 a5 { - self.data[block_num * self.block_size + i] = buf[i]
1 M+ W# q) m# Y6 _: t% A; b. C# O- o - : C/ }% Z5 H! B& [
- def ioctl(self, op, arg):
' l, K4 D8 {; i( d - if op == 4: # get number of blocks4 }; ^/ A' [! k4 `9 C4 B" i8 }
- return len(self.data) // self.block_size" |% t0 ?% Z E
- if op == 5: # get block size; ?. R. C* [( X& R7 J% z
- return self.block_size
复制代码 ( o1 q7 P! o# H O; A/ v
" e8 j4 ]6 y* H! E& U' A% q6 _
& d* U; w' s0 R2 j$ Z
它可以按如下方式使用: - import os
! j8 }. u: Y. x; Z4 a/ P3 C8 `
9 O4 J) W: E1 I$ [8 g/ z- E- bdev = RAMBlockDev(512, 50)
7 i0 B4 J; a# x( x; O8 G/ c - os.VfsFat.mkfs(bdev)
' m/ t. i7 ~/ P6 v - os.mount(bdev, '/ramdisk')
复制代码
% L8 f, ~5 l6 ^+ X% ^/ `& a
( f4 D7 |* ~2 l, |4 M. _
* g0 n3 \; I7 t支持简单接口和扩展接口(即 uos.AbstractBlockDev.readblocks() 和 uos.AbstractBlockDev.writeblocks() 方法的签名和行为)的块设备的示例 是: - class RAMBlockDev:6 }: }2 x8 f0 C* G& Z
- def __init__(self, block_size, num_blocks):
8 f3 d7 S) e2 r( J - self.block_size = block_size. A! \" I4 D( K+ F+ T3 e
- self.data = bytearray(block_size * num_blocks)9 Q6 J- Y3 {/ o" h8 o
^5 v0 }( H/ `0 H. c2 s, I7 J- def readblocks(self, block_num, buf, offset=0):
+ @8 M! d# d+ d2 H8 P - addr = block_num * self.block_size + offset
' Y6 ]% P" S- w - for i in range(len(buf)):: N; T# L' l' c! |. Q5 O# t! \' g
- buf[i] = self.data[addr + i]
/ c. m/ K& ^# y0 O6 b$ m - ' q% d& m4 G7 W6 W$ o: s4 K
- def writeblocks(self, block_num, buf, offset=None):
6 B4 U. B6 r. y8 L/ U: T4 w! ] - if offset is None: J1 X' i( N: C4 I2 o0 G- l; o
- # do erase, then write
* F( M! n2 S/ ^% S$ `, h* Z3 R - for i in range(len(buf) // self.block_size):
) p3 N" L# t( ` - self.ioctl(6, block_num + i)
$ D2 _- V: D {2 P" o - offset = 0
f6 [* a2 b- N) t - addr = block_num * self.block_size + offset P+ k$ m' h( \0 K! h
- for i in range(len(buf)):
7 A4 x7 L+ f* ]# x( ? - self.data[addr + i] = buf[i] E- w! H5 K" ^4 F t& l+ r
z0 L- f9 _- H- def ioctl(self, op, arg):* W5 |6 ]4 R% ^3 R8 [4 d. m
- if op == 4: # block count
& x# d! J" x8 p# a - return len(self.data) // self.block_size; o( ?4 ^2 _! U4 p2 m
- if op == 5: # block size8 Y* i) P3 O$ R
- return self.block_size0 i3 { B% e) j5 s, d
- if op == 6: # block erase
. Y" {' R. x8 {1 j0 [7 g3 D - return 0
复制代码
& w' \7 i$ D/ J! o- k- _2 ?* `7 d4 E2 q$ c% E; n, k. |2 H
1 z9 S7 T8 S. g; M' ^- L4 U6 A, i- B由于它支持扩展接口,因此可以用于littlefs: - import os4 f, j' n7 k* u) b+ `
- - J t: P& E' I3 U. f! q
- bdev = RAMBlockDev(512, 50)* u+ P% c( J, S# X
- os.VfsLfs2.mkfs(bdev)
5 j* `$ m5 z: b$ ~* A3 o0 F& e - os.mount(bdev, '/ramdisk')
复制代码 ' q5 B$ L! c' B5 C8 Z
; ~6 |& Q* j2 R: [5 ^5 W8 Y
9 ]5 k0 Z# B. [1 _& V5 U一旦挂载,文件系统(无论其类型如何)就可以像通常在 Python 代码中使用的那样使用,例如: - with open('/ramdisk/hello.txt', 'w') as f:
0 m O$ y3 w' b6 Q, O5 O2 } - f.write('Hello world')
( N* k/ w8 `3 K - print(open('/ramdisk/hello.txt').read())
复制代码 ) r- i" Z- r3 t; y; k2 y$ B
) W% h x% k+ l/ Z% k1 s
7 s: V" F+ ^% J; q( l6 Z% ]5 X2 X" y4 P4 P; R6 S3 I6 p9 {7 V$ g. w. _
8 \* y# t6 x3 w6 W6 c6 _0 Q w文件系统MicroPython 端口可以提供 FAT、 和 的实现。 littlefs v1 and littlefs v2. 下表显示了固件中默认包含给定端口/板组合的文件系统,但可以在自定义固件构建中选择启用它们。 ) G8 v( ?) k: J
FATFAT 文件系统的主要优点是它可以通过支持的板(例如 STM32)上的 USB MSC 访问,而主机 PC 上不需要任何额外的驱动程序。 但是,FAT 不能容忍写入期间的电源故障,这可能会导致文件系统损坏。对于不需要 USB MSC 的应用,建议使用 littlefs 代替。 要使用 FAT 格式化整个闪存: - # ESP8266 and ESP32
) L% p3 E3 ], l5 B - import os6 u& X6 {7 J( d) D3 O. c! ^
- os.umount('/')
H6 C8 v. m; e5 m" a) q - os.VfsFat.mkfs(bdev)
( r+ l0 I2 R$ n6 }9 a6 P; }- M/ A - os.mount(bdev, '/')
* m& U0 L0 u$ Y) C5 r3 P: e - 5 c; B; ~/ t( C6 ~0 k, A( A7 x8 w1 T
- # STM32
6 R( R2 _+ i, P. A) v - import os, pyb
: q: q" S" u" q: C - os.umount('/flash')
: j8 V" j4 s) `) H' D - os.VfsFat.mkfs(pyb.Flash(start=0))
: K9 n% c6 V1 h - os.mount(pyb.Flash(start=0), '/flash')+ c$ e U' [* O
- os.chdir('/flash')
复制代码
8 ]/ I2 ]; {/ b5 V4 C/ k) S0 v( R9 f) `) ?
' f2 C8 k1 z! e+ Z( _
) I* [0 M |/ K7 ?! j, L( w- FLittlefsLittlefs是专为基于闪存的设备设计的文件系统,对文件系统损坏具有更强的抵抗力。 笔记 有报告称 littlefs v1 和 v2 在某些情况下会失败,有关详细信息,请参阅littlefs issue 347 和 littlefs issue 295. $ g8 b. s; L+ i7 C! S8 i" |
注意:它仍然可以使用 littlefs FUSE 驱动程序通过 USB MSC 访问。请注意,您必须使用该-b=4096 选项来覆盖块大小。 使用 littlefs v2 格式化整个闪存: - # ESP8266 and ESP32
/ n) J; a9 y6 g1 q: K6 @ - import os- t" [+ ]* r: s( ~% X! j' H
- os.umount('/')% r/ v+ _, d& Y' n; Q+ Z# y& l2 p
- os.VfsLfs2.mkfs(bdev)
2 e" W; T4 ?4 I% v. H- l - os.mount(bdev, '/')5 t( p- f7 m9 Z+ T: ]
8 h- g$ K7 ]; {4 f2 i- # STM327 Z$ P, t/ G& L' {
- import os, pyb
; o! C+ |' E/ u3 @ - os.umount('/flash')0 B. z& x9 i. x/ i
- os.VfsLfs2.mkfs(pyb.Flash(start=0))" Z# d6 T' u7 Z' O! R
- os.mount(pyb.Flash(start=0), '/flash')
: y0 {1 [+ {7 T6 j+ d- q2 s' \) | - os.chdir('/flash')
复制代码
3 Y: ^7 x+ U* J k9 G9 d# P. U8 h- U) C3 ]
" i* ]( X( \+ h& g
3 o) x' C3 J. x4 A: K6 C L3 ?
混合 (STM32)通过使用 start 和 len kwargs to pyb.Flash,您可以创建跨越闪存设备子集的块设备。 例如,将第一个 256kiB 配置为 FAT(并通过 USB MSC 可用),其余配置为 littlefs: - import os, pyb ~5 n, P6 `) a- Q; g& W
- os.umount('/flash')2 ?: [/ b/ l: o# Q
- p1 = pyb.Flash(start=0, len=256*1024)
$ J4 l( Z+ S- ^5 S4 x; ~$ U - p2 = pyb.Flash(start=256*1024)
8 s2 M3 `1 T; ~9 o9 {- y s; ^0 S - os.VfsFat.mkfs(p1)5 v& Z" Y) z) d
- os.VfsLfs2.mkfs(p2)
7 |) Q/ d5 ]- W$ I - os.mount(p1, '/flash')
* D) h \6 J) I! r } - os.mount(p2, '/data')
' G9 n) g7 | U0 f" _! R/ X3 q% D - os.chdir('/flash')
复制代码 0 o. k; p5 s% r1 Y7 L
+ f7 X0 a" K x6 s2 \$ g8 G, K. A* _5 O q' A2 e
这可能有助于使您的 Python 文件、配置和其他很少修改的内容通过 USB MSC 可用,但允许频繁更改的应用程序数据驻留在 littlefs 上,从而具有更好的电源故障恢复能力等。 偏移处的分区 0 将自动挂载(并自动检测文件系统类型),但您可以添加: - import os, pyb
( J. Y: F9 _* d1 k - p2 = pyb.Flash(start=256*1024)
( J s7 d2 {. ]- T7 y, K - os.mount(p2, '/data')
复制代码
# r! H, C1 G d5 L6 D) m. ~. t; g) p9 f, I& Q8 c5 n
/ K& Q0 ~! s$ |+ C4 }% J4 G% \' l
来 boot.py挂载数据分区。
; B& Y+ C* p. A. J' b混合动力(ESP32)在 ESP32 上,如果您构建自定义固件,您可以修改 partitions.csv以定义任意分区布局。 启动时,名为“vfs”的分区将被/默认挂载,但任何额外的分区都可以boot.py 使用: - import esp32, os
A$ r# |+ z' x# O9 P# ] - p = esp32.Partition.find(esp32.Partition.TYPE_DATA, label='foo')" g) ]) \ k* `" K. ~ S8 o" ^
- os.mount(p, '/foo')
复制代码 % n9 Q; z8 \8 z+ h' @
) w# p' w- {6 V, L D& O
1 ?8 l' M1 y; S) V, m, e' K% K7 t* t+ h2 k8 a9 k* T8 H8 O
; B2 i3 m! W: m* U5 g& Q
/ m; p- O, X+ {8 X
|