repository·main·Indexed 18 days ago
https://github.com/openwch/arduino_core_ch32Core library and support for WCH CH32 series MCU evaluation boards, enabling programming and debugging via the Arduino IDE. Supports various families including CH32V00x, CH32V20x, CH32X035, CH32V10x, and CH32V30x. Includes implementations for EEPROM emulation (specifically for CH32V003), Wire (I2C), SPI, and base classes for network/serial communication such as Client and Server.
The EEPROM library uses a RAM buffer to allow speedy access to data. Changes made via write(), put(), or the subscript operator [] only affect the RAM buffer. To persist these changes to the chip's flash memory, you must call EEPROM.commit().
EEPROM.commit() returns a bool indicating whether the write operation was successful.
EEPROM.write(0, 123);
if (EEPROM.commit()) {
// Data successfully saved to flash
}On the CH32V003, the library emulates EEPROM using the Option bytes area in flash memory.
data0 and data1 (Option bytes) and 24 bytes from the user select word storage area._data[26] array is laid out as { ob[4], ob[6], ob[16...62] }.EEPROM.ReadOptionBytes() returns a uint32_t containing the data0 and data1 bytes and their inverse values, useful for inspecting the underlying hardware storage.To use the CH32 core on macOS, you must have the libusb library installed to allow the IDE to communicate with the WCH-LINKE hardware.
Install it using Homebrew:
brew install libusbbrew install libusbTo use CH32 MCU support in the Arduino IDE, add the official WCH boards manager URL to your IDE settings and install the package through the Boards Manager.
https://github.com/openwch/board_manager_files/raw/main/package_ch32v_index.jsonhttps://github.com/openwch/board_manager_files/raw/main/package_ch32v_index.jsonOn Linux, after the first installation of the support package, you must run a configuration script to set up necessary libraries and rules (such as udev rules) to ensure the upload function works correctly.
Navigate to the package installation path within your Arduino IDE directory and execute start.sh. The path typically follows this pattern:
cd ~/.arduino15/packages/WCH/tools/beforeinstall/1.0.0
./start.shUpon successful execution, you should see output indicating that libraries were copied/registered and rules were reloaded.
cd ~/.arduino15/packages/WCH/tools/beforeinstall/1.0.0
./start.shTo use the EEPROM library, you must include the header file and call EEPROM.begin() during your setup phase. This method initializes the EEPROM object by reading the current data from permanent storage into a RAM memory buffer, allowing for fast access.
Note: This library follows the initialization convention used by Serial and Wire classes, which differs from some older Arduino EEPROM implementations.
#include <EEPROM.h>
void setup(){
EEPROM.begin();
}
void loop(){
}To use the I2C Scanner example on CH32 boards, you must manually modify the libraries/Wire/src/utility/twi.c file to support scanning via Wire.endTransmission() without data transmission.
Required changes in twi.c:
I2C_TIMEOUT_TICK to 25 (previously 100ms).Note: The standard Wire.setWireTimeout(timeout, reset_on_timeout) function is currently not supported in this core.
The EEPROM library emulates EEPROM by using the Option bytes area in Flash. On the CH32V003, this provides 26 bytes of storage (2 bytes of option data + 24 bytes of available space).
Important Workflow:
begin() to initialize the library and load existing data into RAM.read(), write(), put(), or get() to manipulate data in the RAM buffer.commit() to write the modified RAM buffer back to Flash. Changes are not persistent until commit() is called.erase() to clear the buffer (requires commit() to persist).#include <EEPROM.h>
void setup() {
EEPROM.begin();
// Writing a value
EEPROM.write(0, 42);
// Writing a complex type using put()
float myValue = 3.14;
EEPROM.put(1, myValue);
// Persist changes to Flash
if (EEPROM.commit()) {
// Success
}
}
void loop() {
// Reading a value
uint8_t val = EEPROM.read(0);
// Reading a complex type using get()
float retrievedValue;
EEPROM.get(1, retrievedValue);
}If you encounter errors during the upload process, ensure that your WCH-LINKE firmware is up to date and consistent with the latest version provided under MRS (MounRiver Studio).
If you encounter libusb related errors after installing the library via Homebrew, contact the MRS team at support@mounriver.com.
Ensure you have run the ./start.sh script in the ~/.arduino15/packages/WCH/tools/beforeinstall/... directory to configure environment rules.
For types larger than a single byte (e.g., int, float, or custom structs), use get() and put().
EEPROM.get(address, variable): Retrieves data of any type from the EEPROM into the provided variable.EEPROM.put(address, variable): Writes data of any type from the variable to the EEPROM RAM buffer. Requires EEPROM.commit() to save.float myValue = 3.14;
int myInt = 100;
// Writing complex types
EEPROM.put(0, myValue);
EEPROM.put(sizeof(float), myInt);
EEPROM.commit();
// Reading complex types
float readValue;
int readInt;
EEPROM.get(0, readValue);
EEPROM.get(sizeof(float), readInt);The EEPROM.erase() method clears the RAM memory buffer, setting all bytes to the default value of 255 (0xFF). To apply this erasure to the permanent flash storage, you must call EEPROM.commit().
EEPROM.erase();
EEPROM.commit();You can interact with individual bytes using read() and write(), or by using the object as an array via the subscript operator.
EEPROM.read(address): Returns the uint8_t value at the specified int address.EEPROM.write(address, value): Writes a uint8_t value to the specified int address in RAM. Requires EEPROM.commit() to save.EEPROM[address]: Subscript operator that allows reading and writing directly to the RAM buffer. Requires EEPROM.commit() to save.// Using read/write
uint8_t val = EEPROM.read(0);
EEPROM.write(0, val + 1);
EEPROM.commit();
// Using subscript operator
uint8_t val2 = EEPROM[0];
EEPROM[0] = val2 + 1;
EEPROM.commit();