物联网开发笔记(96)- Micropython ESP32开发之SPI接口控制Micro SD卡TF卡模块挂载内存卡

这篇具有很好参考价值的文章主要介绍了物联网开发笔记(96)- Micropython ESP32开发之SPI接口控制Micro SD卡TF卡模块挂载内存卡。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、目的

        这一节我们学习如何使用乐鑫的ESP32开发板连接SD卡模块,进行目录、文件的相关操作。

        在早前我们也介绍过TFT SD卡的操作,这里我们重新复习一下。

物联网开发笔记(60)- 使用Micropython开发ESP32开发板之SPI接口控制Micro SD卡TF卡模块_microsd卡 spi_魔都飘雪的博客-CSDN博客使用Micropython开发ESP32开发板之SPI接口控制Micro SD卡TF卡模块https://blog.csdn.net/zhusongziye/article/details/128278381?spm=1001.2014.3001.5501二、环境

        ESP32(固件:esp32-20220618-v1.19.1.bin) + Thonny(V4.0.1) + TF卡模块 + 4G TF内存卡 + Win10 64位商业版

        接线方法:连接时请注意你购买的模块的工作电压是3.3V还是5V。和我买的一样的是5V。

esp32 sd卡,物联网开发,MicroPython,物联网,单片机,嵌入式硬件

三、SD卡模块介绍

        SD卡仅支持FAT/FAT32格式,不支持NTFS。所以你买到SD卡后需要将其格式化为正确的格式。

esp32 sd卡,物联网开发,MicroPython,物联网,单片机,嵌入式硬件

四、SD卡驱动代码

sdcard.py

"""
MicroPython driver for SD cards using SPI bus.

Requires an SPI bus and a CS pin.  Provides readblocks and writeblocks
methods so the device can be mounted as a filesystem.

Example usage on pyboard:

    import pyb, sdcard, os
    sd = sdcard.SDCard(pyb.SPI(1), pyb.Pin.board.X5)
    pyb.mount(sd, '/sd2')
    os.listdir('/')

Example usage on ESP8266:

    import machine, sdcard, os
    sd = sdcard.SDCard(machine.SPI(1), machine.Pin(15))
    os.mount(sd, '/sd')
    os.listdir('/')

"""

from micropython import const
import time


_CMD_TIMEOUT = const(100)

_R1_IDLE_STATE = const(1 << 0)
# R1_ERASE_RESET = const(1 << 1)
_R1_ILLEGAL_COMMAND = const(1 << 2)
# R1_COM_CRC_ERROR = const(1 << 3)
# R1_ERASE_SEQUENCE_ERROR = const(1 << 4)
# R1_ADDRESS_ERROR = const(1 << 5)
# R1_PARAMETER_ERROR = const(1 << 6)
_TOKEN_CMD25 = const(0xFC)
_TOKEN_STOP_TRAN = const(0xFD)
_TOKEN_DATA = const(0xFE)


class SDCard:
    def __init__(self, spi, cs, baudrate=1320000):
        self.spi = spi
        self.cs = cs

        self.cmdbuf = bytearray(6)
        self.dummybuf = bytearray(512)
        self.tokenbuf = bytearray(1)
        for i in range(512):
            self.dummybuf[i] = 0xFF
        self.dummybuf_memoryview = memoryview(self.dummybuf)

        # initialise the card
        self.init_card(baudrate)

    def init_spi(self, baudrate):
        try:
            master = self.spi.MASTER
        except AttributeError:
            # on ESP8266
            self.spi.init(baudrate=baudrate, phase=0, polarity=0)
        else:
            # on pyboard
            self.spi.init(master, baudrate=baudrate, phase=0, polarity=0)

    def init_card(self, baudrate):

        # init CS pin
        self.cs.init(self.cs.OUT, value=1)

        # init SPI bus; use low data rate for initialisation
        self.init_spi(100000)

        # clock card at least 100 cycles with cs high
        for i in range(16):
            self.spi.write(b"\xff")

        # CMD0: init card; should return _R1_IDLE_STATE (allow 5 attempts)
        for _ in range(5):
            if self.cmd(0, 0, 0x95) == _R1_IDLE_STATE:
                break
        else:
            raise OSError("no SD card")

        # CMD8: determine card version
        r = self.cmd(8, 0x01AA, 0x87, 4)
        if r == _R1_IDLE_STATE:
            self.init_card_v2()
        elif r == (_R1_IDLE_STATE | _R1_ILLEGAL_COMMAND):
            self.init_card_v1()
        else:
            raise OSError("couldn't determine SD card version")

        # get the number of sectors
        # CMD9: response R2 (R1 byte + 16-byte block read)
        if self.cmd(9, 0, 0, 0, False) != 0:
            raise OSError("no response from SD card")
        csd = bytearray(16)
        self.readinto(csd)
        if csd[0] & 0xC0 == 0x40:  # CSD version 2.0
            self.sectors = ((csd[8] << 8 | csd[9]) + 1) * 1024
        elif csd[0] & 0xC0 == 0x00:  # CSD version 1.0 (old, <=2GB)
            c_size = (csd[6] & 0b11) << 10 | csd[7] << 2 | csd[8] >> 6
            c_size_mult = (csd[9] & 0b11) << 1 | csd[10] >> 7
            read_bl_len = csd[5] & 0b1111
            capacity = (c_size + 1) * (2 ** (c_size_mult + 2)) * (2**read_bl_len)
            self.sectors = capacity // 512
        else:
            raise OSError("SD card CSD format not supported")
        # print('sectors', self.sectors)

        # CMD16: set block length to 512 bytes
        if self.cmd(16, 512, 0) != 0:
            raise OSError("can't set 512 block size")

        # set to high data rate now that it's initialised
        self.init_spi(baudrate)

    def init_card_v1(self):
        for i in range(_CMD_TIMEOUT):
            self.cmd(55, 0, 0)
            if self.cmd(41, 0, 0) == 0:
                # SDSC card, uses byte addressing in read/write/erase commands
                self.cdv = 512
                # print("[SDCard] v1 card")
                return
        raise OSError("timeout waiting for v1 card")

    def init_card_v2(self):
        for i in range(_CMD_TIMEOUT):
            time.sleep_ms(50)
            self.cmd(58, 0, 0, 4)
            self.cmd(55, 0, 0)
            if self.cmd(41, 0x40000000, 0) == 0:
                self.cmd(58, 0, 0, -4)  # 4-byte response, negative means keep the first byte
                ocr = self.tokenbuf[0]  # get first byte of response, which is OCR
                if not ocr & 0x40:
                    # SDSC card, uses byte addressing in read/write/erase commands
                    self.cdv = 512
                else:
                    # SDHC/SDXC card, uses block addressing in read/write/erase commands
                    self.cdv = 1
                # print("[SDCard] v2 card")
                return
        raise OSError("timeout waiting for v2 card")

    def cmd(self, cmd, arg, crc, final=0, release=True, skip1=False):
        self.cs(0)

        # create and send the command
        buf = self.cmdbuf
        buf[0] = 0x40 | cmd
        buf[1] = arg >> 24
        buf[2] = arg >> 16
        buf[3] = arg >> 8
        buf[4] = arg
        buf[5] = crc
        self.spi.write(buf)

        if skip1:
            self.spi.readinto(self.tokenbuf, 0xFF)

        # wait for the response (response[7] == 0)
        for i in range(_CMD_TIMEOUT):
            self.spi.readinto(self.tokenbuf, 0xFF)
            response = self.tokenbuf[0]
            if not (response & 0x80):
                # this could be a big-endian integer that we are getting here
                # if final<0 then store the first byte to tokenbuf and discard the rest
                if final < 0:
                    self.spi.readinto(self.tokenbuf, 0xFF)
                    final = -1 - final
                for j in range(final):
                    self.spi.write(b"\xff")
                if release:
                    self.cs(1)
                    self.spi.write(b"\xff")
                return response

        # timeout
        self.cs(1)
        self.spi.write(b"\xff")
        return -1

    def readinto(self, buf):
        self.cs(0)

        # read until start byte (0xff)
        for i in range(_CMD_TIMEOUT):
            self.spi.readinto(self.tokenbuf, 0xFF)
            if self.tokenbuf[0] == _TOKEN_DATA:
                break
            time.sleep_ms(1)
        else:
            self.cs(1)
            raise OSError("timeout waiting for response")

        # read data
        mv = self.dummybuf_memoryview
        if len(buf) != len(mv):
            mv = mv[: len(buf)]
        self.spi.write_readinto(mv, buf)

        # read checksum
        self.spi.write(b"\xff")
        self.spi.write(b"\xff")

        self.cs(1)
        self.spi.write(b"\xff")

    def write(self, token, buf):
        self.cs(0)

        # send: start of block, data, checksum
        self.spi.read(1, token)
        self.spi.write(buf)
        self.spi.write(b"\xff")
        self.spi.write(b"\xff")

        # check the response
        if (self.spi.read(1, 0xFF)[0] & 0x1F) != 0x05:
            self.cs(1)
            self.spi.write(b"\xff")
            return

        # wait for write to finish
        while self.spi.read(1, 0xFF)[0] == 0:
            pass

        self.cs(1)
        self.spi.write(b"\xff")

    def write_token(self, token):
        self.cs(0)
        self.spi.read(1, token)
        self.spi.write(b"\xff")
        # wait for write to finish
        while self.spi.read(1, 0xFF)[0] == 0x00:
            pass

        self.cs(1)
        self.spi.write(b"\xff")

    def readblocks(self, block_num, buf):
        nblocks = len(buf) // 512
        assert nblocks and not len(buf) % 512, "Buffer length is invalid"
        if nblocks == 1:
            # CMD17: set read address for single block
            if self.cmd(17, block_num * self.cdv, 0, release=False) != 0:
                # release the card
                self.cs(1)
                raise OSError(5)  # EIO
            # receive the data and release card
            self.readinto(buf)
        else:
            # CMD18: set read address for multiple blocks
            if self.cmd(18, block_num * self.cdv, 0, release=False) != 0:
                # release the card
                self.cs(1)
                raise OSError(5)  # EIO
            offset = 0
            mv = memoryview(buf)
            while nblocks:
                # receive the data and release card
                self.readinto(mv[offset : offset + 512])
                offset += 512
                nblocks -= 1
            if self.cmd(12, 0, 0xFF, skip1=True):
                raise OSError(5)  # EIO

    def writeblocks(self, block_num, buf):
        nblocks, err = divmod(len(buf), 512)
        assert nblocks and not err, "Buffer length is invalid"
        if nblocks == 1:
            # CMD24: set write address for single block
            if self.cmd(24, block_num * self.cdv, 0) != 0:
                raise OSError(5)  # EIO

            # send the data
            self.write(_TOKEN_DATA, buf)
        else:
            # CMD25: set write address for first block
            if self.cmd(25, block_num * self.cdv, 0) != 0:
                raise OSError(5)  # EIO
            # send the data
            offset = 0
            mv = memoryview(buf)
            while nblocks:
                self.write(_TOKEN_CMD25, mv[offset : offset + 512])
                offset += 512
                nblocks -= 1
            self.write_token(_TOKEN_STOP_TRAN)

    def ioctl(self, op, arg):
        if op == 4:  # get number of blocks
            return self.sectors
        if op == 5:  # get block size in bytes
            return 512

五、检查SD卡是否挂载成功代码

from machine import Pin,SPI
from sdcard import SDCard
import time,os,esp

cs = Pin(5,Pin.OUT)
spi = SPI(2,sck = Pin(18),mosi = Pin(23),miso = Pin(19))
sd = SDCard(spi,cs)

def main():
    os.VfsFat(sd)
    os.mount(sd,"/sd")  # 挂载SD卡
    
    fb = os.statvfs('/sd')
    print("SD capacity  = %d B %d M"%(fb[0] * fb[2],fb[0] * fb[2]/1024/1024))
    print("SD Remaining = %d B %d M"%(fb[0] * fb[3],fb[0] * fb[3]/1024/1024))

    print("esp32 Flash容量: %d M"%(esp.flash_size()/1024/1024))

    while True:
        pass


if __name__ == "__main__":
    main()

演示效果:

esp32 sd卡,物联网开发,MicroPython,物联网,单片机,嵌入式硬件

 六、示例代码

from machine import Pin,SPI
from sdcard import SDCard
import time,os,esp

cs = Pin(5,Pin.OUT)
spi = SPI(2,sck = Pin(18),mosi = Pin(23),miso = Pin(19))
sd = SDCard(spi,cs)

def main():
    os.VfsFat(sd)  # 创建一个使用 FAT 文件系统格式的文件系统对象。
    os.mount(sd,"/sd")  # 挂载SD卡
    
    fb = os.statvfs('/sd')  # 获取文件系统的状态。
    print("SD capacity  = %d B %d M"%(fb[0] * fb[2],fb[0] * fb[2]/1024/1024))
    print("SD Remaining = %d B %d M"%(fb[0] * fb[3],fb[0] * fb[3]/1024/1024))
    
    print("esp32 Flash容量: %d M"%(esp.flash_size()/1024/1024))
    
    # 获取文件或目录的状态,若不存就创建
    try:
        os.stat("/sd/Hi")  # 获取文件或目录的状态。
    except:
        os.mkdir("/sd/Hi")  # 创建目录
    #os.rmdir("/sd/Hi")  # 删除目录
    print(os.listdir("/sd"))  # os.listdir不带参数,列出当前目录。否则列出给定的目录
    
    # 写操作
    w = open("/sd/Hi/text.txt",'w',encoding="utf-8")
    w.write("Welcome to China!")
    w.close()
    print(os.listdir("/sd/Hi"))
    
    # 读操作
    r =  open("/sd/Hi/text.txt",'r',encoding="utf-8")
    text = r.read()  # f.read()直接读取全部文件
    r.close()
    print(text)
    
    r =  open("/sd/Hi/text.txt",'r',encoding="utf-8")
    text = r.read().split()  # r.read().split()把文件内容当成一个列表返回
    r.close()
    print(text)
    
    for chine in text:
        print(chine)
    
    for number in range(len(text)):
        print(text[number])
    
    for i in range(10):
        w = open("/sd/Hi/number.txt",'w',encoding="utf-8")
        w.write("%.3d"%i)
        w.close()
        
        r =  open("/sd/Hi/number.txt",'r',encoding="utf-8")
        num = r.read()
        r.close()
        
        #print("number = %s"%num)
        print("number = %.3d"%(int(num)))
        
        time.sleep(0.01)
    
    os.umount("/sd")  # 卸载SD卡
    
    while True:
        pass


if __name__ == "__main__":
    main()

示例效果:

esp32 sd卡,物联网开发,MicroPython,物联网,单片机,嵌入式硬件

 esp32 sd卡,物联网开发,MicroPython,物联网,单片机,嵌入式硬件

七、Micro SD卡TF卡以及模块购买

        请查看下面文章获取某宝购买地址:

物联网开发笔记(60)- 使用Micropython开发ESP32开发板之SPI接口控制Micro SD卡TF卡模块_microsd卡 spi_魔都飘雪的博客-CSDN博客使用Micropython开发ESP32开发板之SPI接口控制Micro SD卡TF卡模块https://blog.csdn.net/zhusongziye/article/details/128278381?spm=1001.2014.3001.5501        SD卡购买地址:

https://detail.tmall.com/item.htm?_u=mp01rch153d&id=613649800295&spm=a1z09.2.0.0.6ea92e8dbo8yfk&sku_properties=5919063:6536025https://detail.tmall.com/item.htm?_u=mp01rch153d&id=613649800295&spm=a1z09.2.0.0.6ea92e8dbo8yfk&sku_properties=5919063:6536025文章来源地址https://www.toymoban.com/news/detail-822954.html

到了这里,关于物联网开发笔记(96)- Micropython ESP32开发之SPI接口控制Micro SD卡TF卡模块挂载内存卡的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包