使用文件系统 内容 使用文件系统
5 }) t# y3 [" a" \" S虚拟FS 块设备 * p, R, }8 _& s9 J6 g
文件系统
2 F6 g! i9 z& @: {' f
* E: S! N! ~4 L( O" H6 D8 X
4 M0 L: i2 x" y: I% s- c
' t. V9 \% t- j本教程介绍 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 上,主文件系统挂载在 /。 3 C% W9 s6 E6 w" j1 U3 h
块设备块设备是实现 uos.AbstractBlockDev协议的类的实例 。 内置块设备端口提供内置块设备来访问它们的主闪存。 开机时,MicroPython 将尝试检测默认闪存上的文件系统并自动配置和挂载它。如果没有找到文件系统,MicroPython 将尝试创建一个跨越整个闪存的 FAT 文件系统。端口还可以提供一种机制来“恢复出厂设置”主闪存,通常是通过在开机时按下按钮的某种组合。 STM32 / Pyboard该pyb.Flash类,可以访问内部闪存。在一些具有较大外部闪存的板上(例如 Pyboard D),它将使用它来代替。该 startkwarg应始终指定,即 pyb.Flash(start=0)。 注意:为了向后兼容,当构造没有参数时(即 pyb.Flash()),它只实现简单的块接口并反映呈现给 USB MSC 的虚拟设备(即它在开始时包含一个虚拟分区表)。
1 i: @9 f8 K9 o* s9 F) y0 J, X+ VESP8266内部闪存作为块设备对象公开,该对象 flashbdev 在启动时在模块中创建 。默认情况下,此对象作为全局变量添加,因此通常可以简单地作为bdev. 这实现了扩展接口。
8 P* r% j% |/ \ fESP32esp32.Partition类用于实现为板限定分区的块设备。与 ESP8266 一样,有一个全局变量 bdev指向默认分区。这实现了扩展接口。 # s- o/ Z$ Y4 g
2 ?3 T B5 K0 Y: |8 m) A自定义块设备以下类实现了一个简单的块设备,该设备使用以下命令将其数据存储在 RAM 中 bytearray: - class RAMBlockDev:
% O& S$ n! a* E" e h! Z ~9 E - def __init__(self, block_size, num_blocks):5 C: ]7 A6 e" v' o5 a$ T% ?* b
- self.block_size = block_size) H; A3 p4 q8 j) c, V- }4 m
- self.data = bytearray(block_size * num_blocks)! b! G) A( Y0 Y# O
* T q" L+ y1 w( F; @; P4 _- def readblocks(self, block_num, buf):$ p% g1 _' ]- A. t% h
- for i in range(len(buf)):9 ^' a. G" |0 I. N
- buf[i] = self.data[block_num * self.block_size + i]( ]# ]2 k( t9 d I
' E) O: E! Y) c. C) b- def writeblocks(self, block_num, buf):& \% F) E* H9 Q A& W( p- w+ y
- for i in range(len(buf)):. e' ?8 q: q: |" Y
- self.data[block_num * self.block_size + i] = buf[i]
: g7 X( v5 L4 O+ Q7 Y% t2 _: X
" r& Q! r4 a6 d. O W- def ioctl(self, op, arg):6 H& f7 f2 X4 r- M1 A" q7 B0 X& v
- if op == 4: # get number of blocks* R$ V$ j9 B# F7 n# p
- return len(self.data) // self.block_size Z: ]7 x. J* l/ c4 ]
- if op == 5: # get block size
Z5 ], M5 }- T L* ]+ T* h# ] - return self.block_size
复制代码 $ X7 D' U/ I. e" @9 F
/ `3 T$ R& h* G+ k' Y
$ v2 ^7 G' e B" l6 I4 v
它可以按如下方式使用: - import os: F; X5 \( D+ w; O6 c
n4 ` ~$ p. A+ A- bdev = RAMBlockDev(512, 50)* l, q6 x/ O) F$ z: l Q" M
- os.VfsFat.mkfs(bdev)) L9 D7 ^% N5 F$ F, L2 O4 v, X
- os.mount(bdev, '/ramdisk')
复制代码 / T/ g* E( G$ n l6 q
/ b: H0 {/ y5 n. S0 t& Z
. d6 b4 o, p* H, v1 j( `
支持简单接口和扩展接口(即 uos.AbstractBlockDev.readblocks() 和 uos.AbstractBlockDev.writeblocks() 方法的签名和行为)的块设备的示例 是: - class RAMBlockDev:* r% h9 S0 V; T5 ~
- def __init__(self, block_size, num_blocks):
0 `* r- Q+ W: j - self.block_size = block_size
- T' R, n! a2 c8 n, R/ L - self.data = bytearray(block_size * num_blocks)
4 i* [4 W x/ K( k8 C. u/ a5 ? - ) R! J# S1 U- b/ q
- def readblocks(self, block_num, buf, offset=0):
( x1 N, c X; X) T2 F2 ^ - addr = block_num * self.block_size + offset
6 A2 X- Q+ [. d, K" | K - for i in range(len(buf)):
' N- @, B- Q8 X& E+ R* J - buf[i] = self.data[addr + i]. p" J" l0 R* v* |2 t' |" e3 @
- $ z2 }3 k( v2 T
- def writeblocks(self, block_num, buf, offset=None):
& J7 X$ o6 v- ^5 l; C3 v - if offset is None:- Y# Y: U- `2 M" p
- # do erase, then write8 z* p s6 J/ W
- for i in range(len(buf) // self.block_size):( {/ M, V4 ?6 u( T- Z7 C
- self.ioctl(6, block_num + i)
0 p3 `: O; i; B& W - offset = 00 i* O [5 B5 a4 ?$ G9 r1 n) {& \& b
- addr = block_num * self.block_size + offset7 E3 ]" B$ [$ G- y3 d& d
- for i in range(len(buf)):
$ A! s6 ]8 } p: k* h* s' J - self.data[addr + i] = buf[i]# x! b' b: _5 @9 D0 C
5 M' U) U9 Y/ a: R% U- def ioctl(self, op, arg):
2 k; O( k' k: D# y. n9 m - if op == 4: # block count
9 i0 Z, \: }4 D3 t; A2 ] - return len(self.data) // self.block_size- L& B. V5 z; ^& X4 g
- if op == 5: # block size
1 J0 R$ U. e+ }) G% T8 j - return self.block_size
& x- g9 c$ j/ H( F9 k s5 J! X$ a - if op == 6: # block erase0 z* V5 a j9 Q1 i" z: m
- return 0
复制代码 1 v. P: @8 m4 P7 F. C# O. [: |
: V/ j4 \& P0 J3 T; \) H( a! b/ P6 v- N" P Z
由于它支持扩展接口,因此可以用于littlefs: - import os
7 X/ f1 T- k. o+ B: j. b- ]0 X. } - / o( r# a% n& p' ]/ P
- bdev = RAMBlockDev(512, 50)
S$ f [6 U" q- q - os.VfsLfs2.mkfs(bdev): ^0 ^, R8 n* ~, n7 i
- os.mount(bdev, '/ramdisk')
复制代码 % g0 K' |" E8 z) a
4 N9 l( t8 p. o
' f K* Z2 s0 {0 h" z$ j一旦挂载,文件系统(无论其类型如何)就可以像通常在 Python 代码中使用的那样使用,例如: - with open('/ramdisk/hello.txt', 'w') as f:- e) `! Q# [) Y: g. [7 d
- f.write('Hello world')
h( ?$ M6 a) O$ [3 n2 i - print(open('/ramdisk/hello.txt').read())
复制代码
8 h- v& d9 b L& ?3 y0 s% I7 T+ a a5 p6 L7 D6 t
! X! E2 q( \) N/ K" `1 g/ \
3 |# z# H# ~! ~' z3 \- y; p: e' m) ^
文件系统MicroPython 端口可以提供 FAT、 和 的实现。 littlefs v1 and littlefs v2. 下表显示了固件中默认包含给定端口/板组合的文件系统,但可以在自定义固件构建中选择启用它们。 5 q- E V& U$ I
FATFAT 文件系统的主要优点是它可以通过支持的板(例如 STM32)上的 USB MSC 访问,而主机 PC 上不需要任何额外的驱动程序。 但是,FAT 不能容忍写入期间的电源故障,这可能会导致文件系统损坏。对于不需要 USB MSC 的应用,建议使用 littlefs 代替。 要使用 FAT 格式化整个闪存: - # ESP8266 and ESP32
+ `/ N% W. m% k7 e- P - import os
: H5 |& j# `3 Y ] A- n - os.umount('/'). ^& S3 |+ b% {) y7 o
- os.VfsFat.mkfs(bdev) h$ c: O8 e; C/ u
- os.mount(bdev, '/')
# x# }% h* O4 p% s. M3 u
1 n4 b9 s* f/ G e0 W4 P- # STM32
9 [- t7 n6 [0 Y$ b1 {' E7 q - import os, pyb
1 w# L! c( E7 F2 }. ^6 x - os.umount('/flash')1 A, p: w% @# P D% L! C) j6 p1 Z
- os.VfsFat.mkfs(pyb.Flash(start=0))( V) D, f8 n% m( f3 H5 T/ F; v9 F
- os.mount(pyb.Flash(start=0), '/flash')$ h6 ]6 M0 c1 @% O5 U
- os.chdir('/flash')
复制代码 2 p" Q- `! M- O7 O& Y; c6 C( Z" k
) Y/ `2 A- |) w$ I
% e; `) s$ _0 ^4 r& `* y0 ?! S; ~4 ~5 [6 K0 h! |( M( C( l) S7 C
LittlefsLittlefs是专为基于闪存的设备设计的文件系统,对文件系统损坏具有更强的抵抗力。 笔记 有报告称 littlefs v1 和 v2 在某些情况下会失败,有关详细信息,请参阅littlefs issue 347 和 littlefs issue 295. ! a Q- n; J) J, q- k) K
注意:它仍然可以使用 littlefs FUSE 驱动程序通过 USB MSC 访问。请注意,您必须使用该-b=4096 选项来覆盖块大小。 使用 littlefs v2 格式化整个闪存: - # ESP8266 and ESP32
3 p5 J! H0 g: |; H/ N2 c y. ] - import os
4 `& O$ z% J- h+ A6 @/ e" h - os.umount('/')
& C r" Y- p/ r - os.VfsLfs2.mkfs(bdev)5 X3 p1 g4 k! g: p g
- os.mount(bdev, '/')
5 X& `* }4 i6 ]- @) J9 |5 w4 {
5 J v3 P) O) J) J/ Z( C7 Q& }4 [- # STM321 [& Y8 w" D! U) U0 N
- import os, pyb( s8 e- s9 w- v
- os.umount('/flash')1 ` L" @. S) P+ O) M
- os.VfsLfs2.mkfs(pyb.Flash(start=0))
/ Q5 |, \# @4 Y6 ~ ? - os.mount(pyb.Flash(start=0), '/flash')) @. y( o- f% v; \0 W
- os.chdir('/flash')
复制代码 - N& E/ K# _1 Z) |
. A C3 a, L( R+ M. m. W" s5 J
/ p/ g2 V3 r+ H- m7 w
; g8 m2 b% s& Z: R5 O% t0 h1 Q混合 (STM32)通过使用 start 和 len kwargs to pyb.Flash,您可以创建跨越闪存设备子集的块设备。 例如,将第一个 256kiB 配置为 FAT(并通过 USB MSC 可用),其余配置为 littlefs: - import os, pyb
* n1 g( E6 E. {% r# c - os.umount('/flash')
* E' Q" I7 X. u$ E6 S. P5 q3 x - p1 = pyb.Flash(start=0, len=256*1024)& m; n* h8 m# p0 `/ r
- p2 = pyb.Flash(start=256*1024)
! C# Z+ H% ~* u - os.VfsFat.mkfs(p1)
, f& ^ D" ]! Q) C - os.VfsLfs2.mkfs(p2)
. S# u& o& c: ~: Z, t) N- Z+ Y* @ - os.mount(p1, '/flash')
8 e3 g# w* r: C3 n5 p% `6 y - os.mount(p2, '/data')7 p. ]; Z8 b; ^+ _; Y& y
- os.chdir('/flash')
复制代码
/ }% G0 z/ K; V5 X
$ g2 [; U+ h+ m2 |: x
n) i5 R3 S5 p这可能有助于使您的 Python 文件、配置和其他很少修改的内容通过 USB MSC 可用,但允许频繁更改的应用程序数据驻留在 littlefs 上,从而具有更好的电源故障恢复能力等。 偏移处的分区 0 将自动挂载(并自动检测文件系统类型),但您可以添加: - import os, pyb
9 `$ _( [. V2 g5 `4 A* I; ^3 @ - p2 = pyb.Flash(start=256*1024)
- P+ D, A6 n ?% D8 F" P - os.mount(p2, '/data')
复制代码 . e5 l% M3 e5 E7 Y, m
: Q* i$ H C# F+ _( {" ]$ D/ n u' V7 q
来 boot.py挂载数据分区。
6 S3 m' E7 N8 L1 g混合动力(ESP32)在 ESP32 上,如果您构建自定义固件,您可以修改 partitions.csv以定义任意分区布局。 启动时,名为“vfs”的分区将被/默认挂载,但任何额外的分区都可以boot.py 使用: - import esp32, os
" x4 Q u, U% Z - p = esp32.Partition.find(esp32.Partition.TYPE_DATA, label='foo')% ]7 w0 W. O' h: ]' e: X
- os.mount(p, '/foo')
复制代码 ( U, _* m. {2 [ v* h8 E$ m5 [
1 Z4 F4 g# q4 V9 [0 D( o' y8 @- {0 O8 J
' q4 K$ D; `: a* o0 P2 W- x1 E
4 m" r4 q/ G3 V3 X
|