使用文件系统 内容 使用文件系统 & H! Z# P/ @1 C
虚拟FS 块设备
* ]) h) i# P( i- K. ]# n+ b: m: A, @内置块设备
* F- u* }% ?/ X" K s自定义块设备 , t2 n N- e5 u; l7 p; w6 y
文件系统 4 q3 z% y7 _; c) w6 U% d7 o' |) l0 y
3 Q0 q9 Y8 P L4 u/ J
* j" s+ f- F$ w* P2 k / D* G/ [2 V1 O# E" O% N( S
本教程介绍 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 上,主文件系统挂载在 /。
) P) d& {4 f+ S+ y7 C块设备块设备是实现 uos.AbstractBlockDev协议的类的实例 。 内置块设备端口提供内置块设备来访问它们的主闪存。 开机时,MicroPython 将尝试检测默认闪存上的文件系统并自动配置和挂载它。如果没有找到文件系统,MicroPython 将尝试创建一个跨越整个闪存的 FAT 文件系统。端口还可以提供一种机制来“恢复出厂设置”主闪存,通常是通过在开机时按下按钮的某种组合。 STM32 / Pyboard该pyb.Flash类,可以访问内部闪存。在一些具有较大外部闪存的板上(例如 Pyboard D),它将使用它来代替。该 startkwarg应始终指定,即 pyb.Flash(start=0)。 注意:为了向后兼容,当构造没有参数时(即 pyb.Flash()),它只实现简单的块接口并反映呈现给 USB MSC 的虚拟设备(即它在开始时包含一个虚拟分区表)。 , V: G$ G3 v8 W9 O9 M
ESP8266内部闪存作为块设备对象公开,该对象 flashbdev 在启动时在模块中创建 。默认情况下,此对象作为全局变量添加,因此通常可以简单地作为bdev. 这实现了扩展接口。
. z7 u1 Y' w& p% E0 H' }ESP32esp32.Partition类用于实现为板限定分区的块设备。与 ESP8266 一样,有一个全局变量 bdev指向默认分区。这实现了扩展接口。
( z! Z' c, f2 \/ \$ Q% e
2 z( k9 @6 m8 A- z, ?/ r1 F自定义块设备以下类实现了一个简单的块设备,该设备使用以下命令将其数据存储在 RAM 中 bytearray: - class RAMBlockDev:, n8 I) f$ V+ |$ [0 q8 Y* x0 `# j
- def __init__(self, block_size, num_blocks):. d) {/ H W# j2 k4 M
- self.block_size = block_size
' i2 ?' ~3 ? c. D8 Y! u - self.data = bytearray(block_size * num_blocks)
4 J) f. V% C, R
1 F/ Q4 _7 D2 ^4 H- def readblocks(self, block_num, buf):5 @ e" r9 O3 f
- for i in range(len(buf)):% Y( k% R8 W* e" R" `6 x3 N! t# B7 V
- buf[i] = self.data[block_num * self.block_size + i]
7 k, J8 n5 P- a4 t- ?, z
$ `( y- h1 Y3 }1 B- l6 A- def writeblocks(self, block_num, buf):
! Q# N ?0 k' z& l" ?! E - for i in range(len(buf)):
/ [8 u/ [" x+ o/ S- I T D" { - self.data[block_num * self.block_size + i] = buf[i]+ `8 e6 b; i( y2 h4 i0 k7 M
- 7 c3 ]; n9 n1 A% c$ [$ [0 g
- def ioctl(self, op, arg):
$ E4 x, ]* ]% M" @ - if op == 4: # get number of blocks& j5 z0 S! t1 u2 w% ~
- return len(self.data) // self.block_size
" _+ d+ |; p+ U0 Q - if op == 5: # get block size4 j3 n2 Z, | _1 ?
- return self.block_size
复制代码 ) V- T& p9 o8 S. p
h+ g! r5 V( c$ y& D1 S- a- u' y8 p' g
它可以按如下方式使用: - import os
2 A, Y5 c7 m+ ~% E L% e9 R8 d
% l4 M& H) B7 J' h- bdev = RAMBlockDev(512, 50)4 i7 v' O7 s( n' V5 R
- os.VfsFat.mkfs(bdev)0 J; j0 R& F( t# l c+ I( m
- os.mount(bdev, '/ramdisk')
复制代码
9 M) E( m! ~6 a. n) j
2 ^3 c$ e' [" E2 l, T7 q
) j/ b7 P# x& ?6 ]支持简单接口和扩展接口(即 uos.AbstractBlockDev.readblocks() 和 uos.AbstractBlockDev.writeblocks() 方法的签名和行为)的块设备的示例 是: - class RAMBlockDev:
X; x3 S2 x/ E) X, W" E) O - def __init__(self, block_size, num_blocks):
a- P* Y, r8 x+ D4 b# { - self.block_size = block_size- X! O; U8 A4 V9 n
- self.data = bytearray(block_size * num_blocks)5 w* g5 h% _ U/ m- q
- , v$ l+ D$ U- U$ m' e
- def readblocks(self, block_num, buf, offset=0):6 C! K) H% _# M1 m! G
- addr = block_num * self.block_size + offset! m! b8 q! k1 S, _ n& `
- for i in range(len(buf)):# I P1 M# }3 @; I
- buf[i] = self.data[addr + i]
( u% o9 J$ \4 n( r
1 b. Y' K6 b. H- def writeblocks(self, block_num, buf, offset=None):" w" p, [% h l9 D6 m
- if offset is None:
3 h( f! j5 O1 L! I8 ~' \ - # do erase, then write' K8 D) `! m: Y3 p6 V
- for i in range(len(buf) // self.block_size):" t. }! B$ j6 I
- self.ioctl(6, block_num + i)
$ ]% W# ?2 A. b1 J1 o - offset = 05 M7 o* ]8 g( B g
- addr = block_num * self.block_size + offset; }7 m9 g& k4 P. [; j! M8 l: A6 H
- for i in range(len(buf)):
1 Y h2 V: Z' ^' C, v' {0 R - self.data[addr + i] = buf[i]
/ z( v+ }8 n# u% h5 A3 e/ x# e
7 K# G0 a7 @7 |' q% G4 b- def ioctl(self, op, arg):
1 a; N$ b: p, ]+ J - if op == 4: # block count6 }5 f* q% o% v; l! j
- return len(self.data) // self.block_size* D% U2 e8 |- ^: F9 [6 j' y
- if op == 5: # block size9 x( B& y4 W8 l6 P
- return self.block_size
4 T+ Y) a6 q" S$ T: @ - if op == 6: # block erase- t8 t) T/ k2 K7 ?0 ^
- return 0
复制代码
4 R( H5 b/ Y7 I- L/ t! I8 [) A8 g* h/ O- `/ R
( I6 H a& g# O. Y由于它支持扩展接口,因此可以用于littlefs: - import os
& |, z) Y/ X+ m v2 a5 S
( j& b) ]" p" H( o: Y- bdev = RAMBlockDev(512, 50)
" P+ ]" n' ^& E& G! g% u - os.VfsLfs2.mkfs(bdev)
* G8 h3 Q: ` v9 D' ?3 O2 ^ - os.mount(bdev, '/ramdisk')
复制代码 # X: Q) K) [) y- T/ L/ j3 E
& T+ T' p; J* T$ u/ v
% B2 W) ]/ y& W, r* p一旦挂载,文件系统(无论其类型如何)就可以像通常在 Python 代码中使用的那样使用,例如: - with open('/ramdisk/hello.txt', 'w') as f:
3 N! I" _, Z& O! B0 U F9 V - f.write('Hello world')
( h) V( Y* z+ t' [ {; Z5 g! Q/ C - print(open('/ramdisk/hello.txt').read())
复制代码 * {* J8 G/ P* v1 _0 z
+ s9 v0 w+ U4 l* p6 i
/ D# `" E" R1 G8 h8 R) g" R: r/ e: g% U6 ?! b
& u; k6 p3 ]8 |
文件系统MicroPython 端口可以提供 FAT、 和 的实现。 littlefs v1 and littlefs v2. 下表显示了固件中默认包含给定端口/板组合的文件系统,但可以在自定义固件构建中选择启用它们。 ( w6 q3 ?- Y) @
FATFAT 文件系统的主要优点是它可以通过支持的板(例如 STM32)上的 USB MSC 访问,而主机 PC 上不需要任何额外的驱动程序。 但是,FAT 不能容忍写入期间的电源故障,这可能会导致文件系统损坏。对于不需要 USB MSC 的应用,建议使用 littlefs 代替。 要使用 FAT 格式化整个闪存: - # ESP8266 and ESP32
" |( [ L7 k0 Y5 v - import os
! w. J, ^6 G3 p Q/ Y! l - os.umount('/')
& K; P: e! ~6 s - os.VfsFat.mkfs(bdev)* d0 t. w# f1 M/ x: M H9 u
- os.mount(bdev, '/')
/ _% H: V& @$ n/ t8 h - ) @- D% B5 n" [/ x6 L
- # STM326 G* l0 y6 H6 c, H8 y0 i
- import os, pyb
% t( j% g& {2 O - os.umount('/flash')2 Y* @3 g& x. C7 E/ o
- os.VfsFat.mkfs(pyb.Flash(start=0))
" x7 m$ n7 J: h0 X" N# r5 {4 |% t - os.mount(pyb.Flash(start=0), '/flash')
/ a8 c. n" B4 [ - os.chdir('/flash')
复制代码 * U3 s; ?: {, { r0 i* p
* G" ?( T D0 R1 p: D) u+ y$ T; S3 S6 D& u, ^& p
# ]. [2 W3 y0 w, Q+ ^LittlefsLittlefs是专为基于闪存的设备设计的文件系统,对文件系统损坏具有更强的抵抗力。 笔记 有报告称 littlefs v1 和 v2 在某些情况下会失败,有关详细信息,请参阅littlefs issue 347 和 littlefs issue 295.
" `2 ~% q, p9 Q* L! w) i注意:它仍然可以使用 littlefs FUSE 驱动程序通过 USB MSC 访问。请注意,您必须使用该-b=4096 选项来覆盖块大小。 使用 littlefs v2 格式化整个闪存: - # ESP8266 and ESP32
: V2 `, P$ F# M% o - import os
0 j+ n8 w0 ^4 A, [2 ~ - os.umount('/')
/ W" N1 T% r- j4 ? - os.VfsLfs2.mkfs(bdev)
2 Q/ _/ _1 V# }. d - os.mount(bdev, '/')
2 ]$ c u) c" @% R* L - 0 O5 x/ D1 m: c* A: G1 @; }! \
- # STM32
. ^* h z' B- U: N0 h/ ?. [0 ` - import os, pyb
+ I- E0 p q' Y1 F+ V& \# _1 b+ a- A - os.umount('/flash')4 p' Q, s% U1 o; q Y' E
- os.VfsLfs2.mkfs(pyb.Flash(start=0))# f' `. x& [0 {. `# Y
- os.mount(pyb.Flash(start=0), '/flash')1 s) ^; }+ d! x! x* t
- os.chdir('/flash')
复制代码 " B: _) z7 @2 v4 o* O
/ n( J S( j8 _! _0 y, N! q
) w( _9 s1 w- j
2 X, V0 c& w; n6 Y: I' M
混合 (STM32)通过使用 start 和 len kwargs to pyb.Flash,您可以创建跨越闪存设备子集的块设备。 例如,将第一个 256kiB 配置为 FAT(并通过 USB MSC 可用),其余配置为 littlefs: - import os, pyb
( ]( t* e& M1 o% |' h6 r+ e - os.umount('/flash')) m( Q) Q. f, A
- p1 = pyb.Flash(start=0, len=256*1024)
8 |6 g1 @( N/ w) A- ~, o; g - p2 = pyb.Flash(start=256*1024)# @+ V: p3 R) C5 d
- os.VfsFat.mkfs(p1)
% h* l Z. a1 i - os.VfsLfs2.mkfs(p2)4 {+ K) [6 ]2 v1 Z4 Y7 ?
- os.mount(p1, '/flash'). N( q3 }$ z+ f0 Q' j& P1 s- R
- os.mount(p2, '/data')
6 {/ Y4 X4 t5 V4 o; Z7 g7 _# ] - os.chdir('/flash')
复制代码 8 ?2 A, u- ?1 k; W
# d- P4 q1 X' h2 i
1 X) k6 ?1 t$ i0 J) v这可能有助于使您的 Python 文件、配置和其他很少修改的内容通过 USB MSC 可用,但允许频繁更改的应用程序数据驻留在 littlefs 上,从而具有更好的电源故障恢复能力等。 偏移处的分区 0 将自动挂载(并自动检测文件系统类型),但您可以添加: - import os, pyb3 k8 V& i% V, [& g3 K. l: a* [2 e
- p2 = pyb.Flash(start=256*1024). n) o5 P9 p8 [% z& o* H
- os.mount(p2, '/data')
复制代码 . q0 N8 k2 t ?; V9 [' ?
6 S$ ~$ d6 K6 t3 _. e! ]7 u: E
, ^) x( V; s3 e' C g* ~- A1 |
来 boot.py挂载数据分区。
) C" p/ t C8 J混合动力(ESP32)在 ESP32 上,如果您构建自定义固件,您可以修改 partitions.csv以定义任意分区布局。 启动时,名为“vfs”的分区将被/默认挂载,但任何额外的分区都可以boot.py 使用: - import esp32, os
# M) I% }- x9 h, E: R; x - p = esp32.Partition.find(esp32.Partition.TYPE_DATA, label='foo')) J, |( `- z- o# F# |: O5 E; v
- os.mount(p, '/foo')
复制代码 1 u& O6 E3 i [9 T( g
7 J$ @6 t/ \0 q. G6 H. r+ F6 C+ t3 R
1 @2 B9 d9 ?! {8 N) n, B% _: u" i: w9 ^4 U& ]
4 J) B# i9 ? t9 f4 L1 g- p5 g
8 n, L& J( |9 }! y* c# o* B" [' R
|