micropython编程爱好网

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 182416|回复: 2

使用文件系统

[复制链接]

24

主题

24

帖子

3244

积分

管理员

Rank: 9Rank: 9Rank: 9

积分
3244
发表于 2022-1-20 10:06:07 | 显示全部楼层 |阅读模式
使用文件系统

内容

2 p7 M$ Q% W! f

本教程介绍 MicroPython 如何提供设备上的文件系统,允许将标准 Python 文件 I/O 方法与持久存储一起使用。

MicroPython 会自动创建默认配置并自动检测主文件系统,因此如果您想修改分区、文件系统类型或使用自定义块设备,本教程将非常有用。

文件系统通常由设备上的内部闪存支持,但也可以使用外部闪存、RAM 或自定义块设备。

在某些端口(例如 STM32)上,文件系统也可以通过 USB MSC 连接到主机 PC。pyboard.py 工具还为主机 PC 提供了一种访问所有端口上的文件系统的方法。

注意:这主要用于 STM32 和 ESP32 等裸机端口。在带有操作系统的端口(例如 Unix 端口)上,文件系统由主机操作系统提供。

虚拟FS

MicroPython 实现了一个类 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* HESP32

esp32.Partition类用于实现为板限定分区的块设备。与 ESP8266 一样,有一个全局变量 bdev指向默认分区。这实现了扩展接口。

8 l+ t: w3 p4 v! `  K  [; Q
" G" R1 z: z. X% |) M8 `
自定义块设备

以下类实现了一个简单的块设备,该设备使用以下命令将其数据存储在 RAM 中 bytearray:

  1. class RAMBlockDev:$ C2 F3 j0 F$ Y, e3 K
  2.     def __init__(self, block_size, num_blocks):& V& F. ~6 H+ j0 O) M
  3.         self.block_size = block_size: J9 Q+ k, ^. c6 W. V; |" B
  4.         self.data = bytearray(block_size * num_blocks)( p# K  d8 ~* g: @5 E

  5. ( g( g2 c8 ]  a/ T0 n! U
  6.     def readblocks(self, block_num, buf):1 P% q+ Y5 J7 R. t' H" f
  7.         for i in range(len(buf)):* I! X0 w/ r" Q2 _& L% I
  8.             buf[i] = self.data[block_num * self.block_size + i]4 m/ a. x4 T: q4 p* C8 w

  9. ! m/ x2 ^4 M, K! x& t' Z
  10.     def writeblocks(self, block_num, buf):
    ) M% V# `7 N) L  u/ h0 V2 b
  11.         for i in range(len(buf)):
    * d+ u; `! b0 W  N" K' ^3 v- f, V+ H
  12.             self.data[block_num * self.block_size + i] = buf[i]  i6 q& p$ ], G( {% q& O8 W( e

  13. 3 x5 W- M2 F; i% x
  14.     def ioctl(self, op, arg):9 y5 t3 {+ r4 q# e+ b
  15.         if op == 4: # get number of blocks; z% P3 t- `: l' H8 d5 k8 x( o9 c
  16.             return len(self.data) // self.block_size
    5 x7 h/ U4 o" X
  17.         if op == 5: # get block size
    ) ~. v& K5 y- A% [
  18.             return self.block_size
复制代码

8 Q6 ?/ W- @" X5 f2 M5 d
+ w7 ?8 @, ~/ Q& B, u
+ t/ s* |9 }* l8 \

它可以按如下方式使用:

  1. import os& N0 Q. H' [8 T

  2. ) S" |3 b, E) m+ r, g" ^
  3. bdev = RAMBlockDev(512, 50)
    8 ~' O: j. k  z0 x: |
  4. os.VfsFat.mkfs(bdev)
    9 N: L! I2 {4 [# q6 o4 T0 \+ b
  5. 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() 方法的签名和行为)的块设备的示例 是:

  1. class RAMBlockDev:
    $ H/ Y1 U1 C( U# V
  2.     def __init__(self, block_size, num_blocks):
    ( x0 k1 p0 U! f" M6 b5 d6 p* z& E( M/ j  S
  3.         self.block_size = block_size+ ^) S4 b8 Q( w
  4.         self.data = bytearray(block_size * num_blocks); n; A1 `: L$ Z4 O- w+ ~2 b
  5. # r( ?6 x! ~$ \2 L' @# `
  6.     def readblocks(self, block_num, buf, offset=0):( G+ M9 S" {% g  W8 w! K4 w' D
  7.         addr = block_num * self.block_size + offset
    0 C! p: O! a+ d, {
  8.         for i in range(len(buf)):# n9 Q8 f, N# l2 z4 P+ z3 {. X
  9.             buf[i] = self.data[addr + i]
    $ {6 Y; h4 \. [* O2 L
  10. ! V, |0 g. ?) J( D8 }
  11.     def writeblocks(self, block_num, buf, offset=None):
    ! g5 M7 Y  p# ?1 E! P
  12.         if offset is None:0 V! a) \, r) }3 v0 `
  13.             # do erase, then write
    * c( I: Y3 c' q; A  A# C
  14.             for i in range(len(buf) // self.block_size):
    : ~% o4 v" a  ^- U  \
  15.                 self.ioctl(6, block_num + i)/ Z8 @/ Y* h3 e" Q  h
  16.             offset = 0
    # W' S& P  c- i$ J/ Q! A/ ?/ h
  17.         addr = block_num * self.block_size + offset
    # J) G4 K  J# x5 D
  18.         for i in range(len(buf)):
    " Z* l5 c3 |! }0 t4 G/ B
  19.             self.data[addr + i] = buf[i]
    , e" ?8 b* T) o  W( M

  20. 1 X7 U3 v8 V- d& b. O( R& X& e
  21.     def ioctl(self, op, arg):$ C' _9 e9 k# C/ z
  22.         if op == 4: # block count
    ( p) N6 w' j; J6 F$ m
  23.             return len(self.data) // self.block_size
    8 d; a2 P' ~4 u
  24.         if op == 5: # block size1 l3 n; }8 h# ?1 R; f+ G8 u7 T
  25.             return self.block_size0 G5 G2 e6 j3 q6 n* Z% f
  26.         if op == 6: # block erase
    2 c) I  D: r8 N& K* P& z
  27.             return 0
复制代码

+ v8 G& r$ ~, u  k* A( P7 ^% i
+ W& }% ]6 w5 Z
! _2 K% B  {* @8 B( F

由于它支持扩展接口,因此可以用于littlefs:

  1. import os
      ]6 I8 R, E( x" @4 A2 U6 c

  2. - o$ W; }2 M3 l3 c
  3. bdev = RAMBlockDev(512, 50)
    ! X( f4 u9 A2 F1 N9 l
  4. os.VfsLfs2.mkfs(bdev)( e: s: N% G. V* y8 Z
  5. 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 代码中使用的那样使用,例如:

  1. with open('/ramdisk/hello.txt', 'w') as f:5 i$ s& w0 ]' X8 j
  2.     f.write('Hello world')
      @- N9 O: m5 U! M- q7 i- X8 G
  3. 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
FAT

FAT 文件系统的主要优点是它可以通过支持的板(例如 STM32)上的 USB MSC 访问,而主机 PC 上不需要任何额外的驱动程序。

但是,FAT 不能容忍写入期间的电源故障,这可能会导致文件系统损坏。对于不需要 USB MSC 的应用,建议使用 littlefs 代替。

要使用 FAT 格式化整个闪存:

  1. # ESP8266 and ESP32
    ! w7 t( x6 z2 ^
  2. import os1 \7 k/ L& E8 I5 J, S1 {$ l$ x
  3. os.umount('/')
    & @. X9 A4 }) C2 i, C& Z1 C- X+ ]
  4. os.VfsFat.mkfs(bdev)
    0 A; C7 y- b6 N4 W
  5. os.mount(bdev, '/')7 h) m* x, B, h. X! U4 h, H
  6. : f6 |( L) _+ q! U9 U4 ?
  7. # STM32
    0 k; l9 ^$ ]$ |$ m( o) V* b
  8. import os, pyb6 ?5 J, M0 x) g% c9 {+ {/ }( w% K
  9. os.umount('/flash')2 C4 V, r  p0 u/ {  i6 p1 e
  10. os.VfsFat.mkfs(pyb.Flash(start=0))2 x. n& k7 u$ ~/ {& S
  11. os.mount(pyb.Flash(start=0), '/flash')
    8 e) C! I( c5 k: Y# Q" L
  12. 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 qLittlefs

Littlefs是专为基于闪存的设备设计的文件系统,对文件系统损坏具有更强的抵抗力。

笔记

有报告称 littlefs v1 和 v2 在某些情况下会失败,有关详细信息,请参阅littlefs issue 347littlefs issue 295.

- R7 x/ B- _/ |+ j" Z/ y0 n

注意:它仍然可以使用 littlefs FUSE 驱动程序通过 USB MSC 访问。请注意,您必须使用该-b=4096 选项来覆盖块大小。

使用 littlefs v2 格式化整个闪存:

  1. # ESP8266 and ESP32. P3 g) V% W  D2 }
  2. import os. }6 U4 a& r7 b3 Y# y1 o2 f* e+ ^
  3. os.umount('/')
    ' [# z% c  W3 t$ V+ }2 j
  4. os.VfsLfs2.mkfs(bdev)1 B6 B: o( Z, I' h( Q
  5. os.mount(bdev, '/')* \5 g; K: k8 e" n4 A7 Y$ x) Z

  6. ! n3 F/ A$ w2 B$ }
  7. # STM325 r8 C' u7 ^5 g8 k7 L4 q3 k
  8. import os, pyb
    . C' C+ |& t& J  H7 o' C/ A
  9. os.umount('/flash')0 y6 h6 j, @- }; u" i3 l1 K
  10. os.VfsLfs2.mkfs(pyb.Flash(start=0))+ y8 W7 j: o8 D9 \. D
  11. os.mount(pyb.Flash(start=0), '/flash')! k0 W& z" L2 w3 d+ |, W- ]6 \
  12. 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:

  1. import os, pyb
    ( D( }9 ~) q% X& Q( z' ~- Z
  2. os.umount('/flash')- N4 E$ o: R0 u8 m" a) U, x
  3. p1 = pyb.Flash(start=0, len=256*1024)
    & e9 r  [6 v# A
  4. p2 = pyb.Flash(start=256*1024)
    $ W0 @  e8 t; G* N# n1 M3 v. d  G
  5. os.VfsFat.mkfs(p1)* k  ~1 s( H4 F7 L' p0 \
  6. os.VfsLfs2.mkfs(p2)1 j% t& K4 A- Q! y9 [" {
  7. os.mount(p1, '/flash')9 z$ A! G" d( }- m1 j$ Y8 B
  8. os.mount(p2, '/data')6 W& W( s% O( \  I& _
  9. 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 将自动挂载(并自动检测文件系统类型),但您可以添加:

  1. import os, pyb
    : A9 N' U; ~' R: `
  2. p2 = pyb.Flash(start=256*1024): V/ p5 D! E* e( X" @, `; P$ T
  3. 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 使用:

  1. import esp32, os
    9 \" g9 D  ^/ q
  2. p = esp32.Partition.find(esp32.Partition.TYPE_DATA, label='foo')
    7 h1 r+ I2 W5 o' K, e4 _- c% h
  3. 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

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|Archiver|手机版|小黑屋|micropython编程爱好网 ( 粤ICP备14010847号-3 )

粤公网安备 44030702001224号

GMT+8, 2025-7-7 07:35 , Processed in 0.187201 second(s), 20 queries .

Powered by Discuz! X3.4

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表