class SDCard – pilote de carte SD / MMC

La classe SDCard pilote le logement de carte SD / MMC des caméras OpenMV qui en disposent. Le pilote implémente l’interface vfs.AbstractBlockDev, ce qui permet de le passer directement à vfs.mount():

import machine
import vfs

sd = machine.SDCard()
vfs.mount(sd, "/sd")

Note

Le micrologiciel OpenMV monte automatiquement la carte SD au démarrage, de sorte que la plupart des scripts ne construisent jamais directement un objet SDCard – ils se contentent de lire et d’écrire via le chemin monté automatiquement. Ne construisez un objet manuellement que lorsque vous avez besoin d’un point de montage non par défaut ou d’un accès brut au niveau bloc via readblocks() / writeblocks() / ioctl().

Sur les OpenMV Cam M7 / H7 / H7 Plus / Pure Thermal / N6, le logement est piloté par le contrôleur SDMMC intégré au STM32 en mode SD 4 bits. Sur l’OpenMV Cam RT1062, le logement est piloté par le contrôleur USDHC de l’i.MX RT, également en mode SD 4 bits. Aucun argument de multiplexage de broches n’est nécessaire sur aucune carte OpenMV actuelle – le pilote connaît le câblage de la carte.

Non exposé sur l’OpenMV Cam AE3 (port alif).

Constructeurs

class machine.SDCard(id: int = 1) → SDCard

Renvoie le singleton SDCard correspondant au logement SD identifié par id. id est accepté pour la compatibilité entre ports, mais les ports pris en charge par OpenMV n’exposent qu’un seul logement ; passez 1 ou omettez-le.

Sur STM32, le constructeur ne prend aucun argument ; sur mimxrt, l’argument id est accepté mais seule la valeur 1 est valide.

Méthodes

present() → bool

Renvoie True si une carte est actuellement détectée dans le logement, False sinon.

Sur les cartes câblant un signal de détection de carte, la méthode reflète ce signal en temps réel, de sorte qu’elle peut être interrogée après la construction de l’objet SDCard pour réagir à une insertion / un retrait à chaud. Sur les cartes dépourvues de signal de détection de carte, la valeur est figée au moment de la construction – elle indique le résultat de la sonde CMD0 initiale effectuée par le pilote lors de la création de l’objet, et une carte insérée à chaud par la suite ne sera pas visible tant que l’objet n’est pas reconstruit (ou que init() n’est pas appelée sur mimxrt).

info() → tuple[int, int, int]

Renvoie un triplet décrivant la carte actuellement insérée :

  • [0] num_blocks – capacité totale en blocs de 512 octets. Multipliez par 512 pour obtenir la capacité brute en octets.

  • [1] block_size – toujours 512 pour les cartes SD. Inclus pour que les appelants puissent calculer num_blocks * block_size de manière portable.

  • [2] card_type – le type de carte signalé par le bus SD lors de la séquence d’initialisation CMD8 / OCR. Les valeurs typiques sont 0 (SDSC – capacité standard), 0x40 (SDHC / SDXC – haute / extrême capacité) et 0x80 (MMC).

Utile pour vérifier que la carte a bien été reconnue, ou pour afficher l’espace libre par rapport à la capacité totale.

power(state: bool, /) → None

Active ou désactive le rail d’alimentation du logement de carte. Le micrologiciel STM32 expose la méthode, mais aucune OpenMV Cam actuelle ne commande l’alimentation SD, de sorte que l’appel n’a en pratique aucun effet. Conservée pour la compatibilité avec du code écrit à l’origine pour les cartes de référence STM32 de MicroPython en amont. Port STM32 uniquement.

read(block_num: int, /) → bytes

Lit un unique bloc de 512 octets sur la carte et le renvoie sous la forme d’un objet bytes nouvellement alloué.

Il s’agit de la lecture de bloc unique héritée fournie par le port STM32. Le nouveau code devrait plutôt utiliser readblocks() – cette méthode fonctionne sur tous les ports OpenMV, peut lire un nombre quelconque de blocs contigus en un seul transfert et évite l’allocation à chaque appel en écrivant dans un tampon fourni par l’appelant. Port STM32 uniquement.

write(block_num: int, data: bytes, /) → None

Écrit un unique bloc de 512 octets sur la carte. data doit faire exactement 512 octets de long.

Il s’agit de l’écriture de bloc unique héritée fournie par le port STM32 ; le nouveau code devrait plutôt utiliser writeblocks(), qui fonctionne sur tous les ports OpenMV et peut écrire un nombre quelconque de blocs contigus par appel. Port STM32 uniquement.

readblocks(block_num: int, buf: bytearray) → None
readblocks(block_num: int, buf: bytearray, offset: int) → None

Lit des données brutes alignées sur des blocs depuis la carte dans buf. Point d’entrée standard de périphérique bloc vfs.AbstractBlockDev utilisé par la couche système de fichiers.

Forme simple (readblocks(block_num, buf)) : lit des blocs entiers à partir de l’indice de bloc block_num. len(buf) doit être un multiple de la taille de bloc SD (512 octets).

Forme étendue (readblocks(block_num, buf, offset)) : lit len(buf) octets – pas nécessairement un nombre entier de blocs – à partir de l’octet offset à l’intérieur du bloc block_num. Utilisée par littlefs et d’autres systèmes de fichiers adressables à l’octet.

writeblocks(block_num: int, buf: bytes | bytearray) → None
writeblocks(block_num: int, buf: bytes | bytearray, offset: int) → None

Écrit des données brutes alignées sur des blocs depuis buf vers la carte. Point d’entrée standard de périphérique bloc vfs.AbstractBlockDev utilisé par la couche système de fichiers.

Forme simple (writeblocks(block_num, buf)) : écrit des blocs entiers à partir de l’indice de bloc block_num. len(buf) doit être un multiple de la taille de bloc SD (512 octets). Chaque bloc concerné est entièrement réécrit.

Forme étendue (writeblocks(block_num, buf, offset)) : écrit len(buf) octets – pas nécessairement un nombre entier de blocs – à partir de l’octet offset à l’intérieur du bloc block_num. Utilisée par littlefs et d’autres systèmes de fichiers adressables à l’octet.

ioctl(cmd: int, arg: int) → int | None

Point d’entrée de contrôle standard vfs.AbstractBlockDev. Appelé par la couche système de fichiers au montage/démontage et à chaque synchronisation. Les valeurs de cmd reconnues sont :

  • 1 – initialiser. Renvoie 0 en cas de succès.

  • 2 – désinitialiser. Renvoie 0 en cas de succès.

  • 3 – synchroniser les écritures en attente. Renvoie 0 (le pilote SDMMC écrit de manière synchrone, rien à vider).

  • 4 – renvoie le nombre de blocs du périphérique.

  • 5 – renvoie la taille d’un bloc unique (toujours 512).

  • 6 – efface un bloc (sans effet sur SD, conservé pour respecter le contrat vfs.AbstractBlockDev).

  • 7 – indique si le périphérique prend en charge l’effacement de bloc (0 sur SD).

Les appelants directs n’utilisent normalement pas cette méthode – le pilote du système de fichiers traite automatiquement tous les codes standard une fois que la SDCard est montée.

init(*args, **kwargs) → None

Réinitialise entièrement l’interface SD. Accepte les mêmes arguments que le constructeur. Utile pour redétecter une carte insérée à chaud sur les cartes dépourvues de signal de détection de carte, puisque present() est sinon figée au moment de la construction. Port mimxrt uniquement.

deinit() → None

Désinitialise l’interface SD, libérant le contrôleur SDMMC/USDHC et les broches d’E/S qu’il occupait. L’objet SDCard devient inutilisable jusqu’à ce que init() soit de nouveau appelée. Utilisez-la avant de reprogrammer la carte depuis une autre interface, ou pour couper l’alimentation du logement dans une application alimentée par batterie. Port mimxrt uniquement.