使用文件系统 内容 使用文件系统
6 I# H# W( g1 ?7 e虚拟FS 块设备
+ [. q* Q e9 j7 M3 ]内置块设备
3 }$ [% u' c. u) a: p* [0 }自定义块设备 2 L) M0 d' a8 J# x8 E
文件系统
, Q5 b& ?4 G% \
- ` H5 O7 a, A0 e: r # v3 C" \. C% X* k4 o
0 E7 u: \7 V1 `# f I0 |- R本教程介绍 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 上,主文件系统挂载在 /。 - T: |6 l2 ` u; @4 t
块设备块设备是实现 uos.AbstractBlockDev协议的类的实例 。 内置块设备端口提供内置块设备来访问它们的主闪存。 开机时,MicroPython 将尝试检测默认闪存上的文件系统并自动配置和挂载它。如果没有找到文件系统,MicroPython 将尝试创建一个跨越整个闪存的 FAT 文件系统。端口还可以提供一种机制来“恢复出厂设置”主闪存,通常是通过在开机时按下按钮的某种组合。 STM32 / Pyboard该pyb.Flash类,可以访问内部闪存。在一些具有较大外部闪存的板上(例如 Pyboard D),它将使用它来代替。该 startkwarg应始终指定,即 pyb.Flash(start=0)。 注意:为了向后兼容,当构造没有参数时(即 pyb.Flash()),它只实现简单的块接口并反映呈现给 USB MSC 的虚拟设备(即它在开始时包含一个虚拟分区表)。 , ^/ A5 m5 c% k9 ~' F- H: n
ESP8266内部闪存作为块设备对象公开,该对象 flashbdev 在启动时在模块中创建 。默认情况下,此对象作为全局变量添加,因此通常可以简单地作为bdev. 这实现了扩展接口。 3 L$ B* {. ^' V5 q2 B
ESP32esp32.Partition类用于实现为板限定分区的块设备。与 ESP8266 一样,有一个全局变量 bdev指向默认分区。这实现了扩展接口。 , U0 L/ r1 Y" I4 u. P5 }
3 f# }6 ?& j# X. ]! w
自定义块设备以下类实现了一个简单的块设备,该设备使用以下命令将其数据存储在 RAM 中 bytearray: - class RAMBlockDev:* }- @! ?' L2 j! k2 H: Y- G; Q
- def __init__(self, block_size, num_blocks):
- a+ a/ V/ a" p8 T) d) r/ M - self.block_size = block_size$ @( x9 ?* ~4 V6 h% Q L
- self.data = bytearray(block_size * num_blocks)
% K: o' \! [% u; k - 3 K1 n$ b# \. D* ]
- def readblocks(self, block_num, buf):
" j0 i' v! L+ l - for i in range(len(buf)):
! I3 v( H) [0 f - buf[i] = self.data[block_num * self.block_size + i]* P; S' C0 c4 H2 r! \3 H$ A& B% W
N% x: C& b+ D$ v4 I% U- @- def writeblocks(self, block_num, buf):/ r% c0 l2 _% s
- for i in range(len(buf)):
0 t8 f2 v G) J8 ? - self.data[block_num * self.block_size + i] = buf[i]
6 t! g( ]5 [( g; j1 H; G6 C; z ? - % f( r/ f3 t3 N' ?! L
- def ioctl(self, op, arg):0 Y* P/ ?# w* B
- if op == 4: # get number of blocks
: R+ j- l0 D- w& U- W; E" p* ]8 D. p - return len(self.data) // self.block_size
7 H- d7 m/ C% v" z - if op == 5: # get block size6 g$ m4 a6 u* A# C9 V
- return self.block_size
复制代码
+ F- N! P8 n* X/ A# j7 M) q* ~* K3 ~2 a' v* P @3 n: ]
+ }4 r) H2 R6 U/ g5 H它可以按如下方式使用: - import os4 V6 d. j' ]; d r: b4 j) }7 ^
! T4 B4 x8 }$ x, H2 g- bdev = RAMBlockDev(512, 50)3 q0 O+ ~. f Z
- os.VfsFat.mkfs(bdev)
! E/ v+ ^( h' t+ k( x - os.mount(bdev, '/ramdisk')
复制代码
" n* D: s6 M" H! @# Q' c( d& r
. D0 W2 s4 M2 G% C0 u* |支持简单接口和扩展接口(即 uos.AbstractBlockDev.readblocks() 和 uos.AbstractBlockDev.writeblocks() 方法的签名和行为)的块设备的示例 是: - class RAMBlockDev:
+ z$ N% J/ }, S( v8 H4 N! w - def __init__(self, block_size, num_blocks):; `& Q, p8 l2 v: K/ W
- self.block_size = block_size+ ^% k X& V; D. t( M, p
- self.data = bytearray(block_size * num_blocks)
& o& B" y/ y0 l0 U/ M5 Y, n% Q - 7 D8 H0 Q+ L7 [) i7 X
- def readblocks(self, block_num, buf, offset=0):
+ U* n' {1 v, x6 l' m% h; b - addr = block_num * self.block_size + offset
7 U D" u( ]7 B5 I0 h - for i in range(len(buf)):1 V3 R6 v9 ]9 I7 F, ?$ B
- buf[i] = self.data[addr + i]
5 j' k" I/ q8 \* Y2 o - 5 |# G. D" M) h) }/ o, |6 e
- def writeblocks(self, block_num, buf, offset=None):/ b, D5 V5 V% A
- if offset is None:& d% ^7 b% P3 j! A
- # do erase, then write4 b+ { r$ U/ x3 L
- for i in range(len(buf) // self.block_size):' C8 l9 ^# z7 {0 E
- self.ioctl(6, block_num + i). E% u0 f$ F$ s; v6 i5 t! u
- offset = 0
* @! f3 ]# }* I7 f; u - addr = block_num * self.block_size + offset, M/ M! c" S) m
- for i in range(len(buf)):
2 a' y! p, Y2 t L7 C; t& c+ Z - self.data[addr + i] = buf[i]" l* A, b& D1 W" w1 [
- + {$ n' _) k2 s5 X4 n( g/ Z
- def ioctl(self, op, arg):
/ S! G) q8 ?5 t( y7 ~ - if op == 4: # block count
' P8 s, V* E& E6 U3 r q - return len(self.data) // self.block_size$ b3 D! t2 l) K) z
- if op == 5: # block size& C) d, l1 i6 w' v6 y" O3 {3 Z1 J
- return self.block_size
" a3 W, \# ^# P: T' p8 L0 W - if op == 6: # block erase9 s1 b* `6 t/ S& E& G
- return 0
复制代码
' T/ l: d% Z% I$ Y
0 M: b& P8 }* _; e; y1 J3 {% V o* V0 c- ^- B; d4 o U
由于它支持扩展接口,因此可以用于littlefs: - import os! K4 E0 J' r6 Q, @% r0 a& Q
- ( L4 F3 N* {2 w& ^
- bdev = RAMBlockDev(512, 50)* l8 @7 ?# l+ n! U# p' U
- os.VfsLfs2.mkfs(bdev)
' V) }$ m/ U+ m3 g) l, \2 G5 M - os.mount(bdev, '/ramdisk')
复制代码 & b! }6 E. r) |5 W5 M6 U
% W/ r! R( m, Y/ }6 x* `6 f9 K4 N( J$ z
一旦挂载,文件系统(无论其类型如何)就可以像通常在 Python 代码中使用的那样使用,例如: - with open('/ramdisk/hello.txt', 'w') as f:5 O$ _. c5 X0 X" s
- f.write('Hello world') B3 u/ ~9 A4 Y3 c- I( G
- print(open('/ramdisk/hello.txt').read())
复制代码 ! V |0 Q, B! E6 S6 ~
# A1 _4 A+ _6 j0 R8 ?7 k
, c: Q! A/ ?. V
+ k6 I, c9 C) o" I
0 L: u8 k" j7 R7 r) w文件系统MicroPython 端口可以提供 FAT、 和 的实现。 littlefs v1 and littlefs v2. 下表显示了固件中默认包含给定端口/板组合的文件系统,但可以在自定义固件构建中选择启用它们。
" e$ j0 k6 A l% b) nFATFAT 文件系统的主要优点是它可以通过支持的板(例如 STM32)上的 USB MSC 访问,而主机 PC 上不需要任何额外的驱动程序。 但是,FAT 不能容忍写入期间的电源故障,这可能会导致文件系统损坏。对于不需要 USB MSC 的应用,建议使用 littlefs 代替。 要使用 FAT 格式化整个闪存: - # ESP8266 and ESP32
* ]: m& m0 Q7 w* |; `4 z1 _ W* W - import os1 v. G, Y, y6 N2 W4 {# F
- os.umount('/')- H+ O7 _- E4 ]9 t1 P
- os.VfsFat.mkfs(bdev)
/ j' ~* g" {1 `8 ^" j - os.mount(bdev, '/') p) e$ p" c+ H% t( U3 q
- ; d8 j7 L& m1 q. Q. \
- # STM32
, E6 B; h* P* X& J8 O9 O- s - import os, pyb# [3 p+ U+ G t- Q% E+ R) E' Z. i) \, |
- os.umount('/flash')# }- V# ], y( C( X: }) B: ~( s8 K
- os.VfsFat.mkfs(pyb.Flash(start=0))
# X- ]9 y' U2 l/ W& X, T - os.mount(pyb.Flash(start=0), '/flash'). d/ |' C6 y8 b. l; L9 `
- os.chdir('/flash')
复制代码 ' h& s. Q% L2 ?* o, V6 M
0 P1 u1 ~0 O9 R6 `$ o
6 L$ T; H8 X! }& S i3 X0 ^/ i: [) ? S
LittlefsLittlefs是专为基于闪存的设备设计的文件系统,对文件系统损坏具有更强的抵抗力。 笔记 有报告称 littlefs v1 和 v2 在某些情况下会失败,有关详细信息,请参阅littlefs issue 347 和 littlefs issue 295. . M C/ A6 [, d
注意:它仍然可以使用 littlefs FUSE 驱动程序通过 USB MSC 访问。请注意,您必须使用该-b=4096 选项来覆盖块大小。 使用 littlefs v2 格式化整个闪存: - # ESP8266 and ESP32% ]5 h- @7 R' R. w
- import os4 @- w/ z3 b& U7 X% T6 P& [% m4 Y
- os.umount('/')
7 e" S* i( w- V. { - os.VfsLfs2.mkfs(bdev)8 c7 U$ B% p/ u
- os.mount(bdev, '/')! r3 m" a$ x$ a! i: o
- ; u1 b$ c2 N4 F. q3 t5 L0 D
- # STM32" l# w- P5 t2 F/ L9 m7 d
- import os, pyb, y+ _8 X/ t, a8 d& U/ T
- os.umount('/flash')
) L$ E' F2 u# t8 L# ` - os.VfsLfs2.mkfs(pyb.Flash(start=0))
0 w8 W7 b9 `9 k8 I4 p - os.mount(pyb.Flash(start=0), '/flash')
8 g- G* N1 D0 @9 [ Z - os.chdir('/flash')
复制代码
- W+ M- \, d* q! g: \$ e9 A# @! [2 A8 s: n
6 K/ G- M' `+ z7 w1 H3 r) S& r$ D$ u" g f3 o, r
混合 (STM32)通过使用 start 和 len kwargs to pyb.Flash,您可以创建跨越闪存设备子集的块设备。 例如,将第一个 256kiB 配置为 FAT(并通过 USB MSC 可用),其余配置为 littlefs: - import os, pyb, a2 C0 Z7 `4 ~0 x% U
- os.umount('/flash')# n, w3 i: l1 G7 C, w3 j# P
- p1 = pyb.Flash(start=0, len=256*1024)! ~8 H! K* f7 ] H9 y
- p2 = pyb.Flash(start=256*1024) S; j: e" Z! i; N
- os.VfsFat.mkfs(p1)
/ k$ y2 ^( i. {# T1 R- w - os.VfsLfs2.mkfs(p2)
3 _, u- Q) X/ _3 N |2 N2 P - os.mount(p1, '/flash') j+ P, ?7 ~8 s' { Y
- os.mount(p2, '/data')' J* Y e# Q7 C0 p! `% A5 Z
- os.chdir('/flash')
复制代码
' Q: K5 R! a9 s! K& l' H* `" M- c
+ r8 o) }1 S2 I: ]& s! P
9 G8 Z7 m, H; ]% K( t8 w4 ^这可能有助于使您的 Python 文件、配置和其他很少修改的内容通过 USB MSC 可用,但允许频繁更改的应用程序数据驻留在 littlefs 上,从而具有更好的电源故障恢复能力等。 偏移处的分区 0 将自动挂载(并自动检测文件系统类型),但您可以添加: - import os, pyb3 K+ q8 ]( y, t7 ^. R
- p2 = pyb.Flash(start=256*1024)2 B0 P8 P& @ D5 a
- os.mount(p2, '/data')
复制代码
6 e& Y' z# q7 ~& |) q
& G1 ]# U f& ~) E+ F: e1 v, z$ E/ T) R$ H+ ~
来 boot.py挂载数据分区。
6 }4 Q, l+ i3 @& n混合动力(ESP32)在 ESP32 上,如果您构建自定义固件,您可以修改 partitions.csv以定义任意分区布局。 启动时,名为“vfs”的分区将被/默认挂载,但任何额外的分区都可以boot.py 使用: - import esp32, os) S9 a/ T6 u: A0 }
- p = esp32.Partition.find(esp32.Partition.TYPE_DATA, label='foo')$ E \' t9 j- w
- os.mount(p, '/foo')
复制代码
" Y, P! p- P# B) l7 K1 \- w: @$ I' j9 H9 G* Y& j1 A/ N
8 \6 M! c% a, @- j% x1 [/ b
1 S5 e! S- `1 E# K' `
, L; ?2 ?7 r8 \3 O$ f% l. Y3 O
|