#include
#include “fatfs.h”
#include

FATFS gSDFatFs; /// File system object for SD card logical drive
FIL gMyFile; /// File object
char aSDPath[4] = { 0 }; /// SD card logical drive path
static uint8_t aExcelHeader[] = “Time, vCell1, vCell2, vCell3, vCell4, vCell5, vCell6, vCell7, vCell8, vCell9, vCell10, vCell11, vCell12, vCell13, vCell14, vCell15, vCell16, Stack Voltage, PACK Pin Voltage, LD Pin Voltage, CC2 Current, TS1, TS2, TS3, TS4”;

/**
* @brief Create Default Directories.
* @param none
* @retval FRESULT status
* @warning This function takes 2 seconds to create directory
*/
uint8_t SD_Init(void)
{
FRESULT ret; /* FatFs function common result code */

ret = f_mount(&gSDFatFs, (TCHAR const*)aSDPath, 1);

if(ret != FR_OK)
{
/* f_mount failed */
return ret;
}

// Create New Folder
ret = f_mkdir(“Logs”);
if((ret != FR_EXIST) && (ret != FR_OK))
{
/* f_mount failed */
return ret;
}

/* ToDo
* create a file to log desynchronized data
*/
ret = f_mount(NULL, (TCHAR const*)aSDPath, 1);

return ret;
}

/**
* @brief Append data into sd card and create file if not exist.
* @param pDir file name
* @param pData The buffer to write
* @retval FRESULT status
*/
uint8_t SD_File_Operations( uint8_t *pDir, uint8_t *pData)
{
FRESULT ret; /* FatFs function common result code */
uint32_t byteswritten; /* File write/read counts */
uint8_t aDirPath[20];

sprintf((char*)aDirPath,”Logs/%s.csv\n”,pDir); /* File read buffer */

ret = f_mount(&gSDFatFs, (TCHAR const*)aSDPath, 1);

if(ret != FR_OK)
{
/* f_mount failed */
return ret;
}

// Create New file
switch (f_open(&gMyFile, (char*)aDirPath, FA_CREATE_NEW | FA_WRITE))
{
case FR_EXIST:

f_open(&gMyFile, (char*)aDirPath, FA_OPEN_APPEND | FA_WRITE);

ret = f_write(&gMyFile, pData, strlen((char *)pData), (void *)&byteswritten);
if((byteswritten == 0) || (ret != FR_OK))
{
return ret;
}
f_close(&gMyFile);

break;

case FR_OK:

ret = f_write(&gMyFile, aExcelHeader, strlen((char *)aExcelHeader), (void *)&byteswritten);
if((byteswritten == 0) || (ret != FR_OK))
{
return ret;
}
f_close(&gMyFile);

break;

default:
return ret;

}

ret = f_mount(NULL, (TCHAR const*)aSDPath, 1);

return ret;
}

It seems like you’re experiencing connectivity issues with your STM32U5 series board (B-U585I-IOT02A Discovery kit). Here are some troubleshooting steps to resolve the problem:

1) Check for Driver Installation: Ensure that the necessary USB drivers for your STM32 board are installed on your PC. You can usually find these drivers on the official STMicroelectronics website. Download and install the appropriate drivers if they are missing.

2) USB Cable: Even if you’ve tried different cables, ensure you are using a high-quality USB cable that supports data transfer, not just charging.

3) Power Source: Double-check the power source for your STM32 board. Make sure the jumper settings for power (5V UCPD and 5V_USB_STLK) are correct.

4) Reset the Board: Try a hard reset of the board. Disconnect it from the PC, press and hold the RST and USER buttons, then reconnect it while holding these buttons. This should force it into DFU mode.

5) Device Manager: Open Device Manager and check for any disabled or hidden devices. Sometimes, the board might appear but with a yellow warning sign. If so, right-click and enable it.

6) ST-Link Drivers: Make sure that you have the ST-Link drivers installed if your board uses them for debugging.

7) STMCube Programmer: Ensure you are using the latest version of the STMCube Programmer. It’s possible that the software might not recognize older versions of the board.

8) Firmware and IDE Compatibility: Verify that the firmware on your board is compatible with the version of STMCube IDE you are using. It’s essential that they are in sync.

9) Try Another PC: If possible, test your board on a different PC to eliminate the possibility of issues with your current computer’s USB ports.

The reason for this automatic clearing of the ADDR flag without explicitly reading SR2 could be attributed to the nature of the I2C protocol and its hardware implementation. When the I2C peripheral detects that the slave address matches and the ADDR flag is set, it knows that the address phase has been successfully completed. At this point, the I2C peripheral might automatically clear the ADDR flag as it transitions to the next phase of communication, which could involve reading or writing data.

In many microcontroller or peripheral implementations of the I2C protocol, this automatic clearing of the ADDR flag can help simplify software handling

Yes, it is possible to perform OTA updates on an ESP32 from a different Wi-Fi network, even if you are physically located in a different country. The requirement for both the ESP32 and the computer to be on the same Wi-Fi network is a common scenario for convenience, but it’s not a strict limitation.

The ESP32 can connect to any Wi-Fi network with internet access, and you can set up your ESP32 to listen for OTA updates on a specific port. As long as your ESP32 is accessible from the internet (using its IP address and the designated port), you can initiate an OTA update from your computer in the USA to the ESP32 in India.

Here are the general steps to achieve this:

1. Configure the ESP32 for OTA:
Set up your ESP32 to be capable of receiving OTA updates. Make sure you have the necessary libraries and code in place to handle OTA updates.

2. Port Forwarding:
In the router settings of the network where your ESP32 is connected (in India), you need to configure port forwarding to route incoming connections on the OTA port to the local IP address of your ESP32.

3. Determine ESP32’s Public IP:
Find out the public IP address of the network in India where your ESP32 is connected. You can use online services like “WhatIsMyIP” to determine this IP.

4. Update Code from USA:
From your computer in the USA, you can initiate the OTA update by sending the firmware to the ESP32’s public IP address using the specified port. This may involve using specialized tools or scripts, depending on your development environment.

5. Firewall and Security Considerations:
Keep in mind that security and firewall settings can affect this process. Ensure that your ESP32’s firewall allows incoming connections on the designated OTA port. You might also want to consider implementing security measures like authentication and encryption for the OTA process to ensure the integrity of the updates.