CH32V103 EEPROM Lib Issues

[KenRouKoro]

The EEPROM library is not fully successful when running on CH32V103X8T6. Currently, it can successfully read and write the first 2 bytes, but cannot read or write the following 24 bytes, which are always read as 255.

After studying the CH32V103 Flash in depth, I found that the ch32v10x library within the ch32 package in current CH32 platformio and arduino_core_ch32 projects lacks many components compared to the official library. Specifically in the Flash section, the FLASH_ROM_ERASE and FLASH_ROM_WRITE methods are missing. I have tried to create a simulated EEPROM library (not Arduino standard) for reference, which uses the last 128 bytes of the ch32v103. The 128-byte size matches exactly the quick programming size of the ch32v103.

eeprom_emulation.h

#ifndef EEPROM_EMULATION_H
#define EEPROM_EMULATION_H

#include "Arduino.h"
#include "ch32v10x_flash.h"
#include "debug.h"

#ifdef __cplusplus
extern "C" {
#endif

/* EEPROM emulation configuration */
#define EEPROM_SIZE                 128                    // EEPROM size in bytes
#define EEPROM_START_ADDR          ((uint32_t)0x0800FF80) // Flash start address (last 128 bytes)
#define EEPROM_END_ADDR            ((uint32_t)0x08010000) // Flash end address
#define EEPROM_BUFFER_SIZE         EEPROM_SIZE            // Write buffer size

/* Status definitions */
typedef enum
{
    EEPROM_OK = 0,
    EEPROM_ERROR,
    EEPROM_ADDR_OUT_OF_RANGE,
    EEPROM_FLASH_ERROR
} EEPROM_Status;

/* Function declarations */

/**
 * @brief  Initialize EEPROM emulation
 * @param  None
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_Init(void);

/**
 * @brief  Read one byte from EEPROM
 * @param  addr: Address offset (0-127)
 * @retval Read data
 */
uint8_t EEPROM_ReadByte(uint16_t addr);

/**
 * @brief  Read multiple bytes from EEPROM
 * @param  addr: Start address offset (0-127)
 * @param  data: Data buffer pointer
 * @param  len: Read length
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_ReadBytes(uint16_t addr, uint8_t* data, uint16_t len);

/**
 * @brief  Write one byte to write buffer (not immediately to Flash)
 * @param  addr: Address offset (0-127)
 * @param  data: Data to write
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_WriteByteToBuffer(uint16_t addr, uint8_t data);

/**
 * @brief  Write multiple bytes to write buffer (not immediately to Flash)
 * @param  addr: Start address offset (0-127)
 * @param  data: Data buffer pointer
 * @param  len: Write length
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_WriteBytesToBuffer(uint16_t addr, const uint8_t* data, uint16_t len);

/**
 * @brief  Manually execute write operation (write buffer data to Flash)
 * @param  None
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_Commit(void);

/**
 * @brief  Check if buffer has uncommitted data
 * @param  None
 * @retval 1: Has pending writes, 0: No pending writes
 */
uint8_t EEPROM_HasPendingWrites(void);

/**
 * @brief  Clear write buffer (discard uncommitted data)
 * @param  None
 * @retval None
 */
void EEPROM_ClearBuffer(void);

/**
 * @brief  Format EEPROM area (erase all data)
 * @param  None
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_Format(void);

#ifdef __cplusplus
}
#endif

#endif /* EEPROM_EMULATION_H */

eeprom_emulation.cpp

#include "eeprom_emulation.h"
#include <string.h>

/* Private variables */
static uint8_t eeprom_buffer[EEPROM_BUFFER_SIZE];  // Write buffer
static uint8_t buffer_dirty = 0;                   // Buffer dirty flag
static uint8_t eeprom_initialized = 0;             // Initialization flag

/* Private function declarations */
static EEPROM_Status EEPROM_EraseFlash(void);
static EEPROM_Status EEPROM_WriteFlash(void);
static uint8_t EEPROM_IsAddressValid(uint16_t addr);

/**
 * @brief  Check if address is valid
 * @param  addr: Address offset
 * @retval 1: Valid, 0: Invalid
 */
static uint8_t EEPROM_IsAddressValid(uint16_t addr)
{
    return (addr < EEPROM_SIZE) ? 1 : 0;
}

/**
 * @brief  Erase EEPROM Flash area
 * @param  None
 * @retval EEPROM_Status Operation status
 */
static EEPROM_Status EEPROM_EraseFlash(void)
{
    FLASH_Status status;
    
    // Use fast erase API
    status = FLASH_ROM_ERASE(EEPROM_START_ADDR, EEPROM_SIZE);
    
    if(status != FLASH_COMPLETE)
    {
        return EEPROM_FLASH_ERROR;
    }
    
    return EEPROM_OK;
}

/**
 * @brief  Write buffer data to Flash
 * @param  None
 * @retval EEPROM_Status Operation status
 */
static EEPROM_Status EEPROM_WriteFlash(void)
{
    FLASH_Status status;
    
    // Erase Flash area first
    if(EEPROM_EraseFlash() != EEPROM_OK)
    {
        return EEPROM_FLASH_ERROR;
    }
    
    // Use fast write API
    status = FLASH_ROM_WRITE(EEPROM_START_ADDR, (uint32_t*)eeprom_buffer, EEPROM_SIZE);
    
    if(status != FLASH_COMPLETE)
    {
        return EEPROM_FLASH_ERROR;
    }
    
    return EEPROM_OK;
}

/**
 * @brief  Initialize EEPROM emulation
 * @param  None
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_Init(void)
{
    uint16_t i;
    
    // Read current data from Flash to buffer
    for(i = 0; i < EEPROM_SIZE; i++)
    {
        eeprom_buffer[i] = *((uint8_t*)(EEPROM_START_ADDR + i));
    }
    
    buffer_dirty = 0;
    eeprom_initialized = 1;
    
    return EEPROM_OK;
}

/**
 * @brief  Read one byte from EEPROM
 * @param  addr: Address offset (0-127)
 * @retval Read data
 */
uint8_t EEPROM_ReadByte(uint16_t addr)
{
    if(!eeprom_initialized)
    {
        EEPROM_Init();
    }
    
    if(!EEPROM_IsAddressValid(addr))
    {
        return 0xFF; // Return 0xFF for invalid addresses
    }
    
    // Read from buffer if there's uncommitted data
    if(buffer_dirty)
    {
        return eeprom_buffer[addr];
    }
    
    // Read directly from Flash
    return *((uint8_t*)(EEPROM_START_ADDR + addr));
}

/**
 * @brief  Read multiple bytes from EEPROM
 * @param  addr: Start address offset (0-127)
 * @param  data: Data buffer pointer
 * @param  len: Read length
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_ReadBytes(uint16_t addr, uint8_t* data, uint16_t len)
{
    uint16_t i;
    
    if(!eeprom_initialized)
    {
        EEPROM_Init();
    }
    
    if(!EEPROM_IsAddressValid(addr) || !EEPROM_IsAddressValid(addr + len - 1))
    {
        return EEPROM_ADDR_OUT_OF_RANGE;
    }
    
    if(data == NULL)
    {
        return EEPROM_ERROR;
    }
    
    for(i = 0; i < len; i++)
    {
        data[i] = EEPROM_ReadByte(addr + i);
    }
    
    return EEPROM_OK;
}

/**
 * @brief  Write one byte to write buffer (not immediately to Flash)
 * @param  addr: Address offset (0-127)
 * @param  data: Data to write
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_WriteByteToBuffer(uint16_t addr, uint8_t data)
{
    if(!eeprom_initialized)
    {
        EEPROM_Init();
    }
    
    if(!EEPROM_IsAddressValid(addr))
    {
        return EEPROM_ADDR_OUT_OF_RANGE;
    }
    
    // Write to buffer
    eeprom_buffer[addr] = data;
    buffer_dirty = 1;
    
    return EEPROM_OK;
}

/**
 * @brief  Write multiple bytes to write buffer (not immediately to Flash)
 * @param  addr: Start address offset (0-127)
 * @param  data: Data buffer pointer
 * @param  len: Write length
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_WriteBytesToBuffer(uint16_t addr, const uint8_t* data, uint16_t len)
{
    uint16_t i;
    
    if(!eeprom_initialized)
    {
        EEPROM_Init();
    }
    
    if(!EEPROM_IsAddressValid(addr) || !EEPROM_IsAddressValid(addr + len - 1))
    {
        return EEPROM_ADDR_OUT_OF_RANGE;
    }
    
    if(data == NULL)
    {
        return EEPROM_ERROR;
    }
    
    for(i = 0; i < len; i++)
    {
        eeprom_buffer[addr + i] = data[i];
    }
    
    buffer_dirty = 1;
    
    return EEPROM_OK;
}

/**
 * @brief  Manually execute write operation (write buffer data to Flash)
 * @param  None
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_Commit(void)
{
    if(!eeprom_initialized)
    {
        return EEPROM_ERROR;
    }
    
    if(!buffer_dirty)
    {
        return EEPROM_OK; // No data to write
    }
    
    // Write to Flash
    if(EEPROM_WriteFlash() != EEPROM_OK)
    {
        return EEPROM_FLASH_ERROR;
    }
    
    buffer_dirty = 0;
    
    return EEPROM_OK;
}

/**
 * @brief  Check if buffer has uncommitted data
 * @param  None
 * @retval 1: Has pending writes, 0: No pending writes
 */
uint8_t EEPROM_HasPendingWrites(void)
{
    return buffer_dirty;
}

/**
 * @brief  Clear write buffer (discard uncommitted data)
 * @param  None
 * @retval None
 */
void EEPROM_ClearBuffer(void)
{
    uint16_t i;
    
    if(!eeprom_initialized)
    {
        EEPROM_Init();
        return;
    }
    
    // Reload data from Flash to buffer
    for(i = 0; i < EEPROM_SIZE; i++)
    {
        eeprom_buffer[i] = *((uint8_t*)(EEPROM_START_ADDR + i));
    }
    
    buffer_dirty = 0;
}

/**
 * @brief  Format EEPROM area (erase all data)
 * @param  None
 * @retval EEPROM_Status Operation status
 */
EEPROM_Status EEPROM_Format(void)
{
    uint16_t i;
    
    if(!eeprom_initialized)
    {
        EEPROM_Init();
    }
    
    // Clear buffer (set to 0xFF)
    for(i = 0; i < EEPROM_SIZE; i++)
    {
        eeprom_buffer[i] = 0xFF;
    }
    
    buffer_dirty = 1;
    
    // Write to Flash immediately
    return EEPROM_Commit();
}

[maxint-rd]

Thank you for testing the V103 and posting this issue. As mentioned in this comment, the EEPROM library was contributed by me (in PR #103). The code was based on this example from the CH32fun project and EVT example code, when I only had the V003 available.

Good to see you've found something that works for you. Congratulations!
I wonder if your eeprom emulation code also works for the chips that I have (V003/X033/V002/V006). Perhaps the FLASH_ROM_WRITE API is missing there too.

I've looked into the V103 datasheet and reference manual and compared it with the others to find V103 specifics. These are my findings:

• According the V103 datasheet there is a "128B user-defined information storage area" at the same address as the other chips. For V003 that area is 64B; for VM00x and X03x it is 256B. The layout/address of the 16-byte information structure is the same as for other chips.
• The USER byte has different bits for the V103 compared to V003 and others. WRPR bytes apply to different size blocks. Perhaps the V103 also uses some different bits for flags or different registers?
• Reading flash data is trivial due to the direct addressing in the general address space.
• For manipulating option bytes the procedures are at page 333 of the V103 reference manual. Unlocking is identical to V003, except for some translation difference.
• User Option Bytes Erasure has a difference in step 4 with regards to STAT bit, Otherwise erasure seems the same.
• The text for programming option bytes shows some differences, Main difference with V003 is in step 3, again the STAT bit. Main difference with V002/V006 seems the writing of 2 bytes vs. 4 bytes before checking BSY and clearing EOP.
• The V103 and V003 only support writing option bytes in standard programming mode, two bytes at a time. Fast mode is not supported. On VM00x fast mode is supported.

From your code I understand this to be the essential call:

    // Use fast write API
    status = FLASH_ROM_WRITE(EEPROM_START_ADDR, (uint32_t*)eeprom_buffer, EEPROM_SIZE);

As listed above, fast mode cannot be used for the option bytes. Comparing the functionality of the rest of the code, I don't see significant differences. Once that API function is available for all chips, it should be possible to integrate this call into the EEPROM library to keep it compatible with Arduino standards. Personally, I'd rather use the user-defined information storage area and include the Data0 and Data1 bytes since these can be programmed easily using the LinkE utility. Unfortunately I don't have a V103 in my collection, so other than testing compilation, I cannot test it.

At the moment I think I should first check the current code to see how close it follows the reference manual. Initial tests of writing a larger area on the X033 showed some issues with reliability. Perhaps the X033 and V103 are a bit more sensitive than V003 and is that related to your experience? The library code could perhaps be made more gentle as currently it has no handling of EOP or STAT bits, nor checking of data written. I also want to test that on the V002/V006.

I don't know when I can spend more time on this, but will post my findings in this topic. Would you have time to test and give feedback if I make changes?

[KenRouKoro]

I pulled the latest example code for ch32v00x, which was updated in March of this year, and I also found the FLASH_ROM_WRITE function inside. I think this might be caused by the native library of the current arduino_core_ch32 project not being updated.
I am currently using ch32v103 in my product, and I have a large number of v103 chips available for testing.

[maxint-rd]

With regards to SDK being updated into the Arduino core, I believe you are correct. For the V002/V006 I also saw more recent API code in the SDK than what's included in the current master branch.

Unfortunately at the moment this core doesn't receive much support by WCH. It seems to be very much a community effort by a limited amount of participating members. That's a shame as the CH32 brings good value for money to the Arduino ecosystem, yet interested people may move on to other platforms due to the effort required.

Personally I'm just a hobbyist with no product ambitions. I do have plans to use my chips in my own projects, but I'm afraid I can't do much about the lack of support. For now I try to make things better in my own development environment, sharing my code and experience along the way.

It would be great if WCH would allow some time by a dedicated developer, but after the efforts of @yangliangquan last April, things appear to have gone quiet again.

[maxint-rd]

Hello @KenRouKoro - Today I looked further into the issues I had with X033 to use more than 26 option bytes for EEPROM emulation. I had similar issues when testing the V002 and V006. Upon comparing the code for various boards, I noticed that for some boards the flash latency may not be set correctly in the current Arduino core. Looking at the current EVT code in SystemInit (void) within system_ch32v00X.c I see this:
FLASH->ACTLR = (uint32_t)FLASH_ACTLR_LATENCY_2;
Some implementations of SetSysClockToXX_HSI(void) in the Arduino core use this:
FLASH->ACTLR |= (uint32_t)FLASH_ACTLR_LATENCY_1;

In the reference manuals for V003/V00X/X03x I saw this recommendation:

FLASH_ACTLR
  [1:0] LATENCY[1:0] RW
    FLASH wait status number.
    00: 0 wait (Recommended 0<=SYSCLK<=15MHz);
    01: 1 wait (Recommended 15<SYSCLK<=24MHz);
    10: 2 wait (Recommended 24<SYSCLK<=48MHz);
    11: Reserved.

For V103 these recommendations are different (1 wait state for up to 48MHz, 2 wait states for 48-72MHz). For V20x/V30x I didn't see a latency recommendation.

The current V10x implementation in the master branch may be incorrect. It has LATENCY_1 for the higher HSI frequencies. The same line in this EVT source has it changed to LATENCY_2.
That value could be related to the write failures you noticed.

Note however that there are other differences. For the V002/V006 it seems to use another method to write option bytes than V003. For the V103 I also see other functions such as FLASH_ProgramHalfWord and some cryptic flag setting here in FLASH_ProgramOptionByteData:
*(__IO uint32_t*)0x40022034 = *(__IO uint32_t*)((Address & 0xFFFFFFFC) ^ 0x00001000);
The current EEPROM library code has no such line.

For now I haven't tried to decipher that line. It appears to be another undocumented register like this one somewhere on top of the documented flash registers. (In STM32 0x40022034 is the Flash PCROP zone B Start address register).

Edit: I succeeded writing the larger option byte area of the V002/V006/X033. It required getting this update from the EVT code before I could use fast page writing (see this commit). For the V10x/V20x/V30x fast page writing uses different functions that require further research/testing.

[KenRouKoro]

Let me mention something slightly off-topic. I found a CH32X033 on my new motherboard, and I'm a bit curious whether this chip can read firmware.

[maxint-rd]

Interesting indeed. I wonder what it's purpose is. I suspect it to be something related to USB. The CH334U next to it is a 4-port USB 2.0 hub. The 75232G below it is an RS-232 serial driver chip. The X033 has support for USB. Perhaps it's used as a serial to USB converter? I've been using the X033 TSSOP20 for some hobby projects. It can be read/programmed with the WCH LinkE using a two wire interface (SWD/SWIO).