micropython编程爱好网

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 184747|回复: 2

使用文件系统

[复制链接]

24

主题

24

帖子

3268

积分

管理员

Rank: 9Rank: 9Rank: 9

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

内容


' t. V9 \% t- j

本教程介绍 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 上,主文件系统挂载在 /。

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% |/ \  fESP32

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

# s- o/ Z$ Y4 g

2 ?3 T  B5 K0 Y: |8 m) A自定义块设备

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

  1. class RAMBlockDev:
    % O& S$ n! a* E" e  h! Z  ~9 E
  2.     def __init__(self, block_size, num_blocks):5 C: ]7 A6 e" v' o5 a$ T% ?* b
  3.         self.block_size = block_size) H; A3 p4 q8 j) c, V- }4 m
  4.         self.data = bytearray(block_size * num_blocks)! b! G) A( Y0 Y# O

  5. * T  q" L+ y1 w( F; @; P4 _
  6.     def readblocks(self, block_num, buf):$ p% g1 _' ]- A. t% h
  7.         for i in range(len(buf)):9 ^' a. G" |0 I. N
  8.             buf[i] = self.data[block_num * self.block_size + i]( ]# ]2 k( t9 d  I

  9. ' E) O: E! Y) c. C) b
  10.     def writeblocks(self, block_num, buf):& \% F) E* H9 Q  A& W( p- w+ y
  11.         for i in range(len(buf)):. e' ?8 q: q: |" Y
  12.             self.data[block_num * self.block_size + i] = buf[i]
    : g7 X( v5 L4 O+ Q7 Y% t2 _: X

  13. " r& Q! r4 a6 d. O  W
  14.     def ioctl(self, op, arg):6 H& f7 f2 X4 r- M1 A" q7 B0 X& v
  15.         if op == 4: # get number of blocks* R$ V$ j9 B# F7 n# p
  16.             return len(self.data) // self.block_size  Z: ]7 x. J* l/ c4 ]
  17.         if op == 5: # get block size
      Z5 ], M5 }- T  L* ]+ T* h# ]
  18.             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

它可以按如下方式使用:

  1. import os: F; X5 \( D+ w; O6 c

  2.   n4 `  ~$ p. A+ A
  3. bdev = RAMBlockDev(512, 50)* l, q6 x/ O) F$ z: l  Q" M
  4. os.VfsFat.mkfs(bdev)) L9 D7 ^% N5 F$ F, L2 O4 v, X
  5. 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() 方法的签名和行为)的块设备的示例 是:

  1. class RAMBlockDev:* r% h9 S0 V; T5 ~
  2.     def __init__(self, block_size, num_blocks):
    0 `* r- Q+ W: j
  3.         self.block_size = block_size
    - T' R, n! a2 c8 n, R/ L
  4.         self.data = bytearray(block_size * num_blocks)
    4 i* [4 W  x/ K( k8 C. u/ a5 ?
  5. ) R! J# S1 U- b/ q
  6.     def readblocks(self, block_num, buf, offset=0):
    ( x1 N, c  X; X) T2 F2 ^
  7.         addr = block_num * self.block_size + offset
    6 A2 X- Q+ [. d, K" |  K
  8.         for i in range(len(buf)):
    ' N- @, B- Q8 X& E+ R* J
  9.             buf[i] = self.data[addr + i]. p" J" l0 R* v* |2 t' |" e3 @
  10. $ z2 }3 k( v2 T
  11.     def writeblocks(self, block_num, buf, offset=None):
    & J7 X$ o6 v- ^5 l; C3 v
  12.         if offset is None:- Y# Y: U- `2 M" p
  13.             # do erase, then write8 z* p  s6 J/ W
  14.             for i in range(len(buf) // self.block_size):( {/ M, V4 ?6 u( T- Z7 C
  15.                 self.ioctl(6, block_num + i)
    0 p3 `: O; i; B& W
  16.             offset = 00 i* O  [5 B5 a4 ?$ G9 r1 n) {& \& b
  17.         addr = block_num * self.block_size + offset7 E3 ]" B$ [$ G- y3 d& d
  18.         for i in range(len(buf)):
    $ A! s6 ]8 }  p: k* h* s' J
  19.             self.data[addr + i] = buf[i]# x! b' b: _5 @9 D0 C

  20. 5 M' U) U9 Y/ a: R% U
  21.     def ioctl(self, op, arg):
    2 k; O( k' k: D# y. n9 m
  22.         if op == 4: # block count
    9 i0 Z, \: }4 D3 t; A2 ]
  23.             return len(self.data) // self.block_size- L& B. V5 z; ^& X4 g
  24.         if op == 5: # block size
    1 J0 R$ U. e+ }) G% T8 j
  25.             return self.block_size
    & x- g9 c$ j/ H( F9 k  s5 J! X$ a
  26.         if op == 6: # block erase0 z* V5 a  j9 Q1 i" z: m
  27.             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:

  1. import os
    7 X/ f1 T- k. o+ B: j. b- ]0 X. }
  2. / o( r# a% n& p' ]/ P
  3. bdev = RAMBlockDev(512, 50)
      S$ f  [6 U" q- q
  4. os.VfsLfs2.mkfs(bdev): ^0 ^, R8 n* ~, n7 i
  5. os.mount(bdev, '/ramdisk')
复制代码
% g0 K' |" E8 z) a

4 N9 l( t8 p. o
' f  K* Z2 s0 {0 h" z$ j

一旦挂载,文件系统(无论其类型如何)就可以像通常在 Python 代码中使用的那样使用,例如:

  1. with open('/ramdisk/hello.txt', 'w') as f:- e) `! Q# [) Y: g. [7 d
  2.     f.write('Hello world')
      h( ?$ M6 a) O$ [3 n2 i
  3. 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# ~! ~' z
3 \- y; p: e' m) ^
文件系统

MicroPython 端口可以提供 FAT、 和 的实现。 littlefs v1 and littlefs v2.

下表显示了固件中默认包含给定端口/板组合的文件系统,但可以在自定义固件构建中选择启用它们。

5 q- E  V& U$ I
FAT

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

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

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

  1. # ESP8266 and ESP32
    + `/ N% W. m% k7 e- P
  2. import os
    : H5 |& j# `3 Y  ]  A- n
  3. os.umount('/'). ^& S3 |+ b% {) y7 o
  4. os.VfsFat.mkfs(bdev)  h$ c: O8 e; C/ u
  5. os.mount(bdev, '/')
    # x# }% h* O4 p% s. M3 u

  6. 1 n4 b9 s* f/ G  e0 W4 P
  7. # STM32
    9 [- t7 n6 [0 Y$ b1 {' E7 q
  8. import os, pyb
    1 w# L! c( E7 F2 }. ^6 x
  9. os.umount('/flash')1 A, p: w% @# P  D% L! C) j6 p1 Z
  10. os.VfsFat.mkfs(pyb.Flash(start=0))( V) D, f8 n% m( f3 H5 T/ F; v9 F
  11. os.mount(pyb.Flash(start=0), '/flash')$ h6 ]6 M0 c1 @% O5 U
  12. 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
Littlefs

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

笔记

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

! a  Q- n; J) J, q- k) K

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

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

  1. # ESP8266 and ESP32
    3 p5 J! H0 g: |; H/ N2 c  y. ]
  2. import os
    4 `& O$ z% J- h+ A6 @/ e" h
  3. os.umount('/')
    & C  r" Y- p/ r
  4. os.VfsLfs2.mkfs(bdev)5 X3 p1 g4 k! g: p  g
  5. os.mount(bdev, '/')
    5 X& `* }4 i6 ]- @) J9 |5 w4 {

  6. 5 J  v3 P) O) J) J/ Z( C7 Q& }4 [
  7. # STM321 [& Y8 w" D! U) U0 N
  8. import os, pyb( s8 e- s9 w- v
  9. os.umount('/flash')1 `  L" @. S) P+ O) M
  10. os.VfsLfs2.mkfs(pyb.Flash(start=0))
    / Q5 |, \# @4 Y6 ~  ?
  11. os.mount(pyb.Flash(start=0), '/flash')) @. y( o- f% v; \0 W
  12. 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:

  1. import os, pyb
    * n1 g( E6 E. {% r# c
  2. os.umount('/flash')
    * E' Q" I7 X. u$ E6 S. P5 q3 x
  3. p1 = pyb.Flash(start=0, len=256*1024)& m; n* h8 m# p0 `/ r
  4. p2 = pyb.Flash(start=256*1024)
    ! C# Z+ H% ~* u
  5. os.VfsFat.mkfs(p1)
    , f& ^  D" ]! Q) C
  6. os.VfsLfs2.mkfs(p2)
    . S# u& o& c: ~: Z, t) N- Z+ Y* @
  7. os.mount(p1, '/flash')
    8 e3 g# w* r: C3 n5 p% `6 y
  8. os.mount(p2, '/data')7 p. ]; Z8 b; ^+ _; Y& y
  9. os.chdir('/flash')
复制代码

/ }% G0 z/ K; V5 X
$ g2 [; U+ h+ m2 |: x
  n) i5 R3 S5 p

这可能有助于使您的 Python 文件、配置和其他很少修改的内容通过 USB MSC 可用,但允许频繁更改的应用程序数据驻留在 littlefs 上,从而具有更好的电源故障恢复能力等。

偏移处的分区 0 将自动挂载(并自动检测文件系统类型),但您可以添加:

  1. import os, pyb
    9 `$ _( [. V2 g5 `4 A* I; ^3 @
  2. p2 = pyb.Flash(start=256*1024)
    - P+ D, A6 n  ?% D8 F" P
  3. 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 使用:

  1. import esp32, os
    " x4 Q  u, U% Z
  2. p = esp32.Partition.find(esp32.Partition.TYPE_DATA, label='foo')% ]7 w0 W. O' h: ]' e: X
  3. 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

本帖子中包含更多资源

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

x
回复

使用道具 举报

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

本版积分规则

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

粤公网安备 44030702001224号

GMT+8, 2025-7-11 06:43 , Processed in 0.140401 second(s), 20 queries .

Powered by Discuz! X3.4

Copyright © 2001-2020, Tencent Cloud.

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