SD card support

[FreeBear-nc]

Got a esp32-s3-4848s040 and have made an initial stab at utilising the TF card slot. Using the sample code SD_Test.ino from the Arduino library, I've confirmed which gpio pins are used, and that it can read a card.

Struggling to work out the best way to debug the code as I break modify stuff. Can't use the jtag port as pins are either used for the display or the TF slot. Open to suggestions on debugging.

[FreeBear-nc]

Note to self: pio device monitor gets a text console and can use printf() statements.
Also see: https://docs.espressif.com/projects/arduino-esp32/en/latest/guides/tools_menu.html#core-debug-level

[FreeBear-nc]

Added SD card statistics to the web info page, but used & free space is showing as zero - Might have a faulty card.

[IanSMoyes]

I think this is a really useful project but, keeping in mind the lack of response, it just seems to be me and you buddy.

[FreeBear-nc]

Coding has had to take a back seat while I work on urgent stuff here.
Got a second display on order so that I don't have to use a live system for testing - Should be able to do some more work over the weekend.

[IanSMoyes]

I found this: but I haven’t been able to deploy it yet.

{"type": "code", "language": "c", "description": "SPI and GPIO initialization for STM32", "content": "void SPI_Init(void) {\n __HAL_RCC_SPI1_CLK_ENABLE();\n __HAL_RCC_GPIOA_CLK_ENABLE();\n\n GPIO_InitTypeDef GPIO_InitStruct = {0};\n\n // SPI SCK\n GPIO_InitStruct.Pin = GPIO_PIN_5;\n GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;\n GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;\n HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);\n\n // SPI MISO\n GPIO_InitStruct.Pin = GPIO_PIN_6;\n GPIO_InitStruct.Mode = GPIO_MODE_INPUT;\n HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);\n\n // SPI MOSI\n GPIO_InitStruct.Pin = GPIO_PIN_7;\n GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;\n HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);\n\n // SPI CS\n __HAL_RCC_GPIOB_CLK_ENABLE();\n GPIO_InitStruct.Pin = GPIO_PIN_6;\n GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;\n GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;\n HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);\n\n // SPI configuration\n SPI_HandleTypeDef hspi1;\n hspi1.Instance = SPI1;\n hspi1.Init.Mode = SPI_MODE_MASTER;\n hspi1.Init.Direction = SPI_DIRECTION_2LINES;\n hspi1.Init.DataSize = SPI_DATASIZE_8BIT;\n hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;\n hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;\n hspi1.Init.NSS = SPI_NSS_SOFT;\n hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;\n hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;\n hspi1.Init.TIMode = SPI_TIMODE_DISABLE;\n hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;\n hspi1.Init.CRCPolynomial = 10;\n HAL_SPI_Init(&hspi1);\n}"}
{"type": "code", "language": "c", "description": "Function to send an SPI command", "content": "uint8_t SPI_SendCommand(uint8_t cmd, uint32_t arg, uint8_t crc) {\n uint8_t response = 0;\n uint8_t buffer[6];\n\n // Construct command packet\n buffer[0] = cmd | 0x40; // Start + Command index\n buffer[1] = (arg >> 24) & 0xFF;\n buffer[2] = (arg >> 16) & 0xFF;\n buffer[3] = (arg >> 8) & 0xFF;\n buffer[4] = arg & 0xFF;\n buffer[5] = crc;\n\n // Send command packet\n HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET); // CS low\n for (int i = 0; i < 6; i++) {\n HAL_SPI_Transmit(&hspi1, &buffer[i], 1, HAL_MAX_DELAY);\n }\n\n // Wait for response (response[7] == 0)\n for (int i = 0; i < 8; i++) {\n HAL_SPI_Receive(&hspi1, &response, 1, HAL_MAX_DELAY);\n if (!(response & 0x80)) {\n break;\n }\n }\n\n HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET); // CS high\n return response;\n}"}
{"type": "code", "language": "c", "description": "Function to read data from the TF card", "content": "uint8_t TFCard_ReadData(uint8_t *buffer, uint16_t length) {\n uint8_t token;\n\n // Wait for data token (0xFE)\n do {\n HAL_SPI_Receive(&hspi1, &token, 1, HAL_MAX_DELAY);\n } while (token != 0xFE);\n\n // Read data\n for (int i = 0; i < length; i++) {\n HAL_SPI_Receive(&hspi1, &buffer[i], 1, HAL_MAX_DELAY);\n }\n\n // Read and discard CRC\n uint8_t crc[2];\n HAL_SPI_Receive(&hspi1, crc, 2, HAL_MAX_DELAY);\n\n return 0;\n}"}
{"type": "code", "language": "c", "description": "Function to write data to the TF card", "content": "uint8_t TFCard_WriteData(const uint8_t *buffer, uint16_t length) {\n uint8_t response;\n uint8_t token = 0xFE;\n\n // Send data token\n HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET); // CS low\n HAL_SPI_Transmit(&hspi1, &token, 1, HAL_MAX_DELAY);\n\n // Write data\n for (int i = 0; i < length; i++) {\n HAL_SPI_Transmit(&hspi1, (uint8_t *)&buffer[i], 1, HAL_MAX_DELAY);\n }\n\n // Send dummy CRC\n uint8_t crc[2] = {0xFF, 0xFF};\n HAL_SPI_Transmit(&hspi1, crc, 2, HAL_MAX_DELAY);\n\n // Get data response\n HAL_SPI_Receive(&hspi1, &response, 1, HAL_MAX_DELAY);\n if ((response & 0x1F) != 0x05) {\n HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET); // CS high\n return 1; // Error\n }\n\n // Wait for write to finish\n while (HAL_SPI_Receive(&hspi1, &response, 1, HAL_MAX_DELAY) == HAL_OK && response == 0);\n\n HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET); // CS high\n return 0;\n}"}
{"type": "code", "language": "c", "description": "Example of usage: Initialize SPI, send command, read and write data", "content": "int main(void) {\n HAL_Init();\n SystemClock_Config();\n SPI_Init();\n\n // Send CMD0 (GO_IDLE_STATE) to reset the card\n uint8_t response = SPI_SendCommand(0x00, 0x00000000, 0x95);\n if (response != 0x01) {\n // Handle error\n }\n\n // Read data from address 0x0000\n uint8_t readBuffer[512];\n response = SPI_SendCommand(0x11, 0x00000000, 0xFF); // CMD17 (READ_SINGLE_BLOCK)\n if (response == 0x00) {\n TFCard_ReadData(readBuffer, 512);\n }\n\n // Write data to address 0x0000\n uint8_t writeBuffer[512] = {0x01, 0x02, 0x03, ...};\n response = SPI_SendCommand(0x18, 0x00000000, 0xFF); // CMD24 (WRITE_BLOCK)\n if (response == 0x00) {\n TFCard_WriteData(writeBuffer, 512);\n }\n\n while (1) {}\n}"}

In this JSONL format:

•	Each line is a JSON object.
•	Each JSON object includes the code type, language, description, and code content.
•	The code is structured for initialization, sending commands, reading data, writing data, and an example usage.

Ensure that you adapt the code to your specific environment, such as the actual GPIO pin numbers and the specific hardware initialization routines.

[IanSMoyes]

At first glance it seems like a lot of code for a little ESP32 to drink.

[FreeBear-nc]

Would help if you formatted the code so that it is easier to read. That, and a link to the original source so that minor details such as licencing can be checked.
As it stands, it would appear to be targeted at the STM32 (Arm based) microcontrollers. The code may not be compatible with either the Arduino or Espressif libraries. Not that it matters, as we already have low level access working.

[IanSMoyes]

Sorry. It came to you formatted as it came to me. It's straight off chatgpt so I don't have the original source. If you think it's no use then best just delete it. Sorry I wasted your time. Have you come up with anything?

…

On Sun, 30 Jun 2024, 10:26 FreeBear-nc, ***@***.***> wrote: Would help if you formatted the code so that it is easier to read. That, and a link to the original source so that minor details such as licencing can be checked. As it stands, it would appear to be targeted at the STM32 (Arm based) microcontrollers. The code may not be compatible with either the Arduino or Espressif libraries. Not that it matters, as we already have low level access working. — Reply to this email directly, view it on GitHub <#727 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AO64SONRIDRWEX56JUTRCBTZJ7FNHAVCNFSM6AAAAABH3ETRRGVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TSMJVHA3DG> . You are receiving this because you commented.Message ID: ***@***.***>

[FreeBear-nc]

Sorry. It came to you formatted as it came to me. It's straight off chatgpt so I don't have the original source.

The dangers of using ChatGPT generated code:
You have zero idea as to the sources used to train the AI.
The code could be ripped from proprietary sources with extremely restricted licencing terms.
It is often poor quality code.
This is what it looks like after formatting:

 // {"type": "code", "language": "c", "description": "SPI and GPIO initialization for STM32", "content":}

void SPI_Init(void)
{
    __HAL_RCC_SPI1_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    GPIO_InitTypeDef GPIO_InitStruct = { 0 };

    // SPI SCK
    GPIO_InitStruct.Pin = GPIO_PIN_5;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // SPI MISO
    GPIO_InitStruct.Pin = GPIO_PIN_6;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // SPI MOSI
    GPIO_InitStruct.Pin = GPIO_PIN_7;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // SPI CS
    __HAL_RCC_GPIOB_CLK_ENABLE();
    GPIO_InitStruct.Pin = GPIO_PIN_6;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    // SPI configuration
    SPI_HandleTypeDef hspi1;
    hspi1.Instance = SPI1;
    hspi1.Init.Mode = SPI_MODE_MASTER;
    hspi1.Init.Direction = SPI_DIRECTION_2LINES;
    hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
    hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
    hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
    hspi1.Init.NSS = SPI_NSS_SOFT;
    hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
    hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
    hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
    hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    hspi1.Init.CRCPolynomial = 10;
    HAL_SPI_Init(&hspi1);
}


// {"type": "code", "language": "c", "description": "Function to send an SPI command", "content":}

uint8_t SPI_SendCommand(uint8_t cmd, uint32_t arg, uint8_t crc)
{
    uint8_t response = 0;
    uint8_t buffer[6];

    // Construct command packet
    buffer[0] = cmd | 0x40;        // Start + Command index
    buffer[1] = (arg >> 24) & 0xFF;
    buffer[2] = (arg >> 16) & 0xFF;
    buffer[3] = (arg >> 8) & 0xFF;
    buffer[4] = arg & 0xFF;
    buffer[5] = crc;

    // Send command packet
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET);        // CS low
    for (int i = 0; i < 6; i++) {
        HAL_SPI_Transmit(&hspi1, &buffer[i], 1, HAL_MAX_DELAY);
    }

    // Wait for response (response[7] == 0)
    for (int i = 0; i < 8; i++) {
        HAL_SPI_Receive(&hspi1, &response, 1, HAL_MAX_DELAY);
        if (!(response & 0x80)) {
            break;
        }
    }

    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET);        // CS high
    return response;
}

// {"type": "code", "language": "c", "description": "Function to read data from the TF card", "content":}

uint8_t TFCard_ReadData(uint8_t * buffer, uint16_t length)
{
    uint8_t token;

    // Wait for data token (0xFE)
    do {
        HAL_SPI_Receive(&hspi1, &token, 1, HAL_MAX_DELAY);
    } while (token != 0xFE);

    // Read data
    for (int i = 0; i < length; i++) {
        HAL_SPI_Receive(&hspi1, &buffer[i], 1, HAL_MAX_DELAY);
    }

    // Read and discard CRC
    uint8_t crc[2];
    HAL_SPI_Receive(&hspi1, crc, 2, HAL_MAX_DELAY);

    return 0;
}

// {"type": "code", "language": "c", "description": "Function to write data to the TF card", "content":}

uint8_t TFCard_WriteData(const uint8_t * buffer, uint16_t length)
{
    uint8_t response;
    uint8_t token = 0xFE;

    // Send data token
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET);        // CS low
    HAL_SPI_Transmit(&hspi1, &token, 1, HAL_MAX_DELAY);

    // Write data
    for (int i = 0; i < length; i++) {
        HAL_SPI_Transmit(&hspi1, (uint8_t *) & buffer[i], 1,
                         HAL_MAX_DELAY);
    }

    // Send dummy CRC
    uint8_t crc[2] = { 0xFF, 0xFF };
    HAL_SPI_Transmit(&hspi1, crc, 2, HAL_MAX_DELAY);

    // Get data response
    HAL_SPI_Receive(&hspi1, &response, 1, HAL_MAX_DELAY);
    if ((response & 0x1F) != 0x05) {
        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET);        // CS high
        return 1;                // Error
    }
    // Wait for write to finish
    while (HAL_SPI_Receive(&hspi1, &response, 1, HAL_MAX_DELAY) == HAL_OK
           && response == 0);

    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET);        // CS high
    return 0;
}

// {"type": "code", "language": "c", "description": "Example of usage: Initialize SPI, send command, read and write data", "content":}

int main(void)
{
    HAL_Init();
    SystemClock_Config();
    SPI_Init();

    // Send CMD0 (GO_IDLE_STATE) to reset the card
    uint8_t response = SPI_SendCommand(0x00, 0x00000000, 0x95);
    if (response != 0x01) {
        // Handle error
    }
    // Read data from address 0x0000
    uint8_t readBuffer[512];
    response = SPI_SendCommand(0x11, 0x00000000, 0xFF);        // CMD17 (READ_SINGLE_BLOCK)
    if (response == 0x00) {
        TFCard_ReadData(readBuffer, 512);
    }
    // Write data to address 0x0000
    uint8_t writeBuffer[512] = { 0x01, 0x02, 0x03, ... };
    response = SPI_SendCommand(0x18, 0x00000000, 0xFF);        // CMD24 (WRITE_BLOCK)
    if (response == 0x00) {
        TFCard_WriteData(writeBuffer, 512);
    }

    while (1) {
    }
}

Doing a little bit of digging, the code might be derived (ripped) from an example copyright by ST Microelectronics with the following notice:

• © Copyright (c) 2020 STMicroelectronics.

• All rights reserved.
• This software component is licensed by ST under Ultimate Liberty license
• SLA0044, the "License"; You may not use this file except in compliance with
• the License. You may obtain a copy of the License at:

•                         www.st.com/SLA0044
  

[FreeBear-nc]

From the SLA0044 licence:

4.	This software or any part thereof, including modifications and/or derivative works of this software, must be used and execute solely and exclusively on or in combination with a microcontroller or microprocessor device manufactured by or for STMicroelectronics.
5.	No use, reproduction or redistribution of this software partially or totally may be done in any manner that would subject this software to any Open Source Terms. “Open Source Terms” shall mean any open source license which requires as part of distribution of software that the source code of such software is distributed therewith or otherwise made available, or open source license that substantially complies with the Open Source definition specified at www.opensource.org and any other comparable open source license such as for example GNU General Public License (GPL), Eclipse Public License (EPL), Apache Software License, BSD license or MIT license.

A highly restrictive licence that I could not, would not accept. @fvanroie may feel different.

[IanSMoyes]

Wow! Given your reservations I had expected you would just delete it. You've spent so long on it, thanks I always regard poor quality code as a basis for writing better quality code. Have you come up with something of your own?

…

On Sun, 30 Jun 2024, 12:30 FreeBear-nc, ***@***.***> wrote: From the SLA0044 licence: 4. This software or any part thereof, including modifications and/or derivative works of this software, must be used and execute solely and exclusively on or in combination with a microcontroller or microprocessor device manufactured by or for STMicroelectronics. 5. No use, reproduction or redistribution of this software partially or totally may be done in any manner that would subject this software to any Open Source Terms. “Open Source Terms” shall mean any open source license which requires as part of distribution of software that the source code of such software is distributed therewith or otherwise made available, or open source license that substantially complies with the Open Source definition specified at www.opensource.org and any other comparable open source license such as for example GNU General Public License (GPL), Eclipse Public License (EPL), Apache Software License, BSD license or MIT license. — Reply to this email directly, view it on GitHub <#727 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AO64SOI3RG6F6C2BXKOVCNLZJ7T5PAVCNFSM6AAAAABH3ETRRGVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TSMJWGQZDC> . You are receiving this because you commented.Message ID: ***@***.***>

[FreeBear-nc]

It is worth preserving the code, along with my reasoning - If anyone has a different opinion, they can reference the code, and pass comment.

As for SD access & basic commands, see https://github.com/FreeBear-nc/openHASP/tree/commands (work in progress).