使用文件系统 内容 使用文件系统
8 p4 N1 c: p$ F虚拟FS 块设备 5 z6 |; G/ D1 j: z
内置块设备 5 p' ^3 q3 i' E( I& I
自定义块设备
! N" g" Q8 H2 F9 J$ h
文件系统 " x: j5 q! a* L" K0 l& q! S) f
, @0 H% p. ~- x0 \: d5 M8 p
+ X& j+ z3 l, a$ O8 m7 y; c
2 p7 M$ Q% W! f
本教程介绍 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 上,主文件系统挂载在 /。
' g j( N& z/ N' i, t+ `块设备块设备是实现 uos.AbstractBlockDev协议的类的实例 。 内置块设备端口提供内置块设备来访问它们的主闪存。 开机时,MicroPython 将尝试检测默认闪存上的文件系统并自动配置和挂载它。如果没有找到文件系统,MicroPython 将尝试创建一个跨越整个闪存的 FAT 文件系统。端口还可以提供一种机制来“恢复出厂设置”主闪存,通常是通过在开机时按下按钮的某种组合。 STM32 / Pyboard该pyb.Flash类,可以访问内部闪存。在一些具有较大外部闪存的板上(例如 Pyboard D),它将使用它来代替。该 startkwarg应始终指定,即 pyb.Flash(start=0)。 注意:为了向后兼容,当构造没有参数时(即 pyb.Flash()),它只实现简单的块接口并反映呈现给 USB MSC 的虚拟设备(即它在开始时包含一个虚拟分区表)。 3 i3 A$ l- h0 _- c& f
ESP8266内部闪存作为块设备对象公开,该对象 flashbdev 在启动时在模块中创建 。默认情况下,此对象作为全局变量添加,因此通常可以简单地作为bdev. 这实现了扩展接口。
: ]% e! y/ d* HESP32esp32.Partition类用于实现为板限定分区的块设备。与 ESP8266 一样,有一个全局变量 bdev指向默认分区。这实现了扩展接口。 8 l+ t: w3 p4 v! ` K [; Q
" G" R1 z: z. X% |) M8 `
自定义块设备以下类实现了一个简单的块设备,该设备使用以下命令将其数据存储在 RAM 中 bytearray: - class RAMBlockDev:$ C2 F3 j0 F$ Y, e3 K
- def __init__(self, block_size, num_blocks):& V& F. ~6 H+ j0 O) M
- self.block_size = block_size: J9 Q+ k, ^. c6 W. V; |" B
- self.data = bytearray(block_size * num_blocks)( p# K d8 ~* g: @5 E
( g( g2 c8 ] a/ T0 n! U- def readblocks(self, block_num, buf):1 P% q+ Y5 J7 R. t' H" f
- for i in range(len(buf)):* I! X0 w/ r" Q2 _& L% I
- buf[i] = self.data[block_num * self.block_size + i]4 m/ a. x4 T: q4 p* C8 w
! m/ x2 ^4 M, K! x& t' Z- def writeblocks(self, block_num, buf):
) M% V# `7 N) L u/ h0 V2 b - for i in range(len(buf)):
* d+ u; `! b0 W N" K' ^3 v- f, V+ H - self.data[block_num * self.block_size + i] = buf[i] i6 q& p$ ], G( {% q& O8 W( e
3 x5 W- M2 F; i% x- def ioctl(self, op, arg):9 y5 t3 {+ r4 q# e+ b
- if op == 4: # get number of blocks; z% P3 t- `: l' H8 d5 k8 x( o9 c
- return len(self.data) // self.block_size
5 x7 h/ U4 o" X - if op == 5: # get block size
) ~. v& K5 y- A% [ - return self.block_size
复制代码
8 Q6 ?/ W- @" X5 f2 M5 d
+ w7 ?8 @, ~/ Q& B, u
+ t/ s* |9 }* l8 \它可以按如下方式使用: - import os& N0 Q. H' [8 T
) S" |3 b, E) m+ r, g" ^- bdev = RAMBlockDev(512, 50)
8 ~' O: j. k z0 x: | - os.VfsFat.mkfs(bdev)
9 N: L! I2 {4 [# q6 o4 T0 \+ b - os.mount(bdev, '/ramdisk')
复制代码
2 X9 m. p. J1 t3 z' B2 w) A
/ V; M. f* E7 [; s) e! [' W: T* T, g0 K3 C
支持简单接口和扩展接口(即 uos.AbstractBlockDev.readblocks() 和 uos.AbstractBlockDev.writeblocks() 方法的签名和行为)的块设备的示例 是: - class RAMBlockDev:
$ H/ Y1 U1 C( U# V - def __init__(self, block_size, num_blocks):
( x0 k1 p0 U! f" M6 b5 d6 p* z& E( M/ j S - self.block_size = block_size+ ^) S4 b8 Q( w
- self.data = bytearray(block_size * num_blocks); n; A1 `: L$ Z4 O- w+ ~2 b
- # r( ?6 x! ~$ \2 L' @# `
- def readblocks(self, block_num, buf, offset=0):( G+ M9 S" {% g W8 w! K4 w' D
- addr = block_num * self.block_size + offset
0 C! p: O! a+ d, { - for i in range(len(buf)):# n9 Q8 f, N# l2 z4 P+ z3 {. X
- buf[i] = self.data[addr + i]
$ {6 Y; h4 \. [* O2 L - ! V, |0 g. ?) J( D8 }
- def writeblocks(self, block_num, buf, offset=None):
! g5 M7 Y p# ?1 E! P - if offset is None:0 V! a) \, r) }3 v0 `
- # do erase, then write
* c( I: Y3 c' q; A A# C - for i in range(len(buf) // self.block_size):
: ~% o4 v" a ^- U \ - self.ioctl(6, block_num + i)/ Z8 @/ Y* h3 e" Q h
- offset = 0
# W' S& P c- i$ J/ Q! A/ ?/ h - addr = block_num * self.block_size + offset
# J) G4 K J# x5 D - for i in range(len(buf)):
" Z* l5 c3 |! }0 t4 G/ B - self.data[addr + i] = buf[i]
, e" ?8 b* T) o W( M
1 X7 U3 v8 V- d& b. O( R& X& e- def ioctl(self, op, arg):$ C' _9 e9 k# C/ z
- if op == 4: # block count
( p) N6 w' j; J6 F$ m - return len(self.data) // self.block_size
8 d; a2 P' ~4 u - if op == 5: # block size1 l3 n; }8 h# ?1 R; f+ G8 u7 T
- return self.block_size0 G5 G2 e6 j3 q6 n* Z% f
- if op == 6: # block erase
2 c) I D: r8 N& K* P& z - return 0
复制代码
+ v8 G& r$ ~, u k* A( P7 ^% i
+ W& }% ]6 w5 Z
! _2 K% B {* @8 B( F由于它支持扩展接口,因此可以用于littlefs: - import os
]6 I8 R, E( x" @4 A2 U6 c
- o$ W; }2 M3 l3 c- bdev = RAMBlockDev(512, 50)
! X( f4 u9 A2 F1 N9 l - os.VfsLfs2.mkfs(bdev)( e: s: N% G. V* y8 Z
- os.mount(bdev, '/ramdisk')
复制代码
Q% Q4 Q b3 K/ U
. G- Q- E; D, E1 }% m8 v) ~7 d: X! N2 g4 f! k
一旦挂载,文件系统(无论其类型如何)就可以像通常在 Python 代码中使用的那样使用,例如: - with open('/ramdisk/hello.txt', 'w') as f:5 i$ s& w0 ]' X8 j
- f.write('Hello world')
@- N9 O: m5 U! M- q7 i- X8 G - print(open('/ramdisk/hello.txt').read())
复制代码 4 q8 M- t& X( `: D1 H( O
4 T/ B, W0 }2 H1 l9 L1 u3 R" n$ @ v3 F: s: V# k/ F" {
4 S( t/ g9 J0 q- u* i! E/ P3 o
; m& C$ }9 j- {3 W文件系统MicroPython 端口可以提供 FAT、 和 的实现。 littlefs v1 and littlefs v2. 下表显示了固件中默认包含给定端口/板组合的文件系统,但可以在自定义固件构建中选择启用它们。 : g) i; D# c7 D9 p
FATFAT 文件系统的主要优点是它可以通过支持的板(例如 STM32)上的 USB MSC 访问,而主机 PC 上不需要任何额外的驱动程序。 但是,FAT 不能容忍写入期间的电源故障,这可能会导致文件系统损坏。对于不需要 USB MSC 的应用,建议使用 littlefs 代替。 要使用 FAT 格式化整个闪存: - # ESP8266 and ESP32
! w7 t( x6 z2 ^ - import os1 \7 k/ L& E8 I5 J, S1 {$ l$ x
- os.umount('/')
& @. X9 A4 }) C2 i, C& Z1 C- X+ ] - os.VfsFat.mkfs(bdev)
0 A; C7 y- b6 N4 W - os.mount(bdev, '/')7 h) m* x, B, h. X! U4 h, H
- : f6 |( L) _+ q! U9 U4 ?
- # STM32
0 k; l9 ^$ ]$ |$ m( o) V* b - import os, pyb6 ?5 J, M0 x) g% c9 {+ {/ }( w% K
- os.umount('/flash')2 C4 V, r p0 u/ { i6 p1 e
- os.VfsFat.mkfs(pyb.Flash(start=0))2 x. n& k7 u$ ~/ {& S
- os.mount(pyb.Flash(start=0), '/flash')
8 e) C! I( c5 k: Y# Q" L - os.chdir('/flash')
复制代码
- P Q; l" \3 R+ a: _1 D1 Q0 W6 Y4 b8 h7 N4 {$ H2 {, Q" E H4 ]
% q' ?& }2 w2 H
+ Q2 [& B; D y3 qLittlefsLittlefs是专为基于闪存的设备设计的文件系统,对文件系统损坏具有更强的抵抗力。 笔记 有报告称 littlefs v1 和 v2 在某些情况下会失败,有关详细信息,请参阅littlefs issue 347 和 littlefs issue 295. - R7 x/ B- _/ |+ j" Z/ y0 n
注意:它仍然可以使用 littlefs FUSE 驱动程序通过 USB MSC 访问。请注意,您必须使用该-b=4096 选项来覆盖块大小。 使用 littlefs v2 格式化整个闪存: - # ESP8266 and ESP32. P3 g) V% W D2 }
- import os. }6 U4 a& r7 b3 Y# y1 o2 f* e+ ^
- os.umount('/')
' [# z% c W3 t$ V+ }2 j - os.VfsLfs2.mkfs(bdev)1 B6 B: o( Z, I' h( Q
- os.mount(bdev, '/')* \5 g; K: k8 e" n4 A7 Y$ x) Z
! n3 F/ A$ w2 B$ }- # STM325 r8 C' u7 ^5 g8 k7 L4 q3 k
- import os, pyb
. C' C+ |& t& J H7 o' C/ A - os.umount('/flash')0 y6 h6 j, @- }; u" i3 l1 K
- os.VfsLfs2.mkfs(pyb.Flash(start=0))+ y8 W7 j: o8 D9 \. D
- os.mount(pyb.Flash(start=0), '/flash')! k0 W& z" L2 w3 d+ |, W- ]6 \
- os.chdir('/flash')
复制代码 1 [6 M$ \+ H% ] W
9 V$ F( Z5 s4 g
, G B, ]! F$ e- @( x! C% r
& n. ~8 o; n3 O9 ^5 d8 s2 V混合 (STM32)通过使用 start 和 len kwargs to pyb.Flash,您可以创建跨越闪存设备子集的块设备。 例如,将第一个 256kiB 配置为 FAT(并通过 USB MSC 可用),其余配置为 littlefs: - import os, pyb
( D( }9 ~) q% X& Q( z' ~- Z - os.umount('/flash')- N4 E$ o: R0 u8 m" a) U, x
- p1 = pyb.Flash(start=0, len=256*1024)
& e9 r [6 v# A - p2 = pyb.Flash(start=256*1024)
$ W0 @ e8 t; G* N# n1 M3 v. d G - os.VfsFat.mkfs(p1)* k ~1 s( H4 F7 L' p0 \
- os.VfsLfs2.mkfs(p2)1 j% t& K4 A- Q! y9 [" {
- os.mount(p1, '/flash')9 z$ A! G" d( }- m1 j$ Y8 B
- os.mount(p2, '/data')6 W& W( s% O( \ I& _
- os.chdir('/flash')
复制代码 / d6 Q7 U6 j# ^/ i! u. M' x- w' m
6 b( T" Y6 R; b. B2 v0 p' X* C0 M5 c- S
这可能有助于使您的 Python 文件、配置和其他很少修改的内容通过 USB MSC 可用,但允许频繁更改的应用程序数据驻留在 littlefs 上,从而具有更好的电源故障恢复能力等。 偏移处的分区 0 将自动挂载(并自动检测文件系统类型),但您可以添加: - import os, pyb
: A9 N' U; ~' R: ` - p2 = pyb.Flash(start=256*1024): V/ p5 D! E* e( X" @, `; P$ T
- os.mount(p2, '/data')
复制代码 ; X& ?/ L( y* h r
$ _+ d/ S" K8 I; s) u" n6 F
5 y& Z" V1 K0 a3 X3 d! E; C
来 boot.py挂载数据分区。 ; H: {( r* c! Y9 u. y
混合动力(ESP32)在 ESP32 上,如果您构建自定义固件,您可以修改 partitions.csv以定义任意分区布局。 启动时,名为“vfs”的分区将被/默认挂载,但任何额外的分区都可以boot.py 使用: - import esp32, os
9 \" g9 D ^/ q - p = esp32.Partition.find(esp32.Partition.TYPE_DATA, label='foo')
7 h1 r+ I2 W5 o' K, e4 _- c% h - os.mount(p, '/foo')
复制代码
X# C9 j8 ~) G4 P* [- f0 u; P% a. U8 g
+ ^7 O1 W& L1 ~/ ~* {2 ?: B. V- i) W: ]
. l- A0 l7 M/ p0 [
! }' ?8 q/ }' o( A |