Arduino CH32V003

[Christoph M. (mchris)]

Im Moment experimentiere ich mit dem CH32V003 und diesem Framwork:
https://github.com/openwch/arduino_core_ch32?tab=readme-ov-file

und versuche hier mal ein paar Eigenheiten zu dokumentieren.

Hier gibt es eine Anleitung:
https://www.hackster.io/patrick-fitzgerald2/program-ch32v003-risc-v-with-arduino-ide-135f6f

Auf welche Pins wird der serielle Port "gemapped".

[Christoph M. (mchris)]

Hab's raus gekriegt:

/*
 * CH32V003F4P6 Serial Send Test
 * 
 * CH32V003F4P6 TX (output) : PD5
 * 
 * has to be connected to the Programming Dongle RX
 * 
 * Framework:
 * https://github.com/openwch/arduino_core_ch32
 */


void setup() {
  Serial.begin(115200);
}

uint8_t Counter = 0;

void loop() 
{
  Serial.println(Counter++);
  delay(100);
}

[Christoph M. (mchris)]

Geschwindigkeit Pin-Toggle mit digitalWrite:
255kHz

[Alexander (alecxs)]

Und ohne die while Schleife?

[Christoph M. (mchris)]

>Und ohne die while Schleife?
Ist für die Geschwindigkeit.

[Alexander (alecxs)]

Ja, mich hätte halt mal der Unterschied interessiert wieviel langsamer 
das ist.

[Peter D. (peda)]

Alexander schrieb:
> Ja, mich hätte halt mal der Unterschied interessiert wieviel langsamer
> das ist.

Schau doch mal in die Arduino core library.

[Alexander (alecxs)]

steht da nicht drin ;)

[Peter D. (peda)]

Alexander schrieb:
> steht da nicht drin ;)

Da müßte aber main drinstehen, was dann loop und noch anderen Schrunz 
aufruft.
Ohne ein main beschwert sich jeder C-Compiler heftig.

[Alexander (alecxs)]

Christoph M. schrieb:
> Geschwindigkeit Pin-Toggle mit digitalWrite:
> 255kHz

Ich wollte hier nur wissen: 233kHz oder so

[Rainer W. (rawi)]

Peter D. schrieb:
> Da müßte aber main drinstehen, was dann loop und noch anderen Schrunz
> aufruft.

Tut es. Die Aktionen in der Hauptschleife von main() sind überschaubar 
(loop(), Interrupts) solange auf der seriellen Schnittstelle Ruhe 
herrscht:

  for (;;) {
    loop();
    if (serialEventRun) serialEventRun();
  }

Die Interrupts

[Christoph M. (mchris)]

>Christoph M. schrieb:
>> Geschwindigkeit Pin-Toggle mit digitalWrite:
>> 255kHz
Alexander (alecxs)
18.06.2025 15:46
>Ich wollte hier nur wissen: 233kHz oder so

 * Results:
 * 
 * within while loop  255kHz
 * without while loop 213kHz

Es wäre interessant zu sehen, wie schnell es maximal wird, wenn man 
direkt auf den Port schreibt.

[Christoph M. (mchris)]

Oha, der Speicherverbrauch des Framworks scheint exorbitant:

/*
 * trigonometrie speed test
 */

void setup()
{
  Serial.begin(115200);
}

void loop()
{
  float sum=0;

  float x,y,z;
  
  Serial.println("start");
  for(uint32_t n=0;n<100000;n++)
  {
    x=sin(2*PI*n/1000);
    x=cos(2*PI*n/1000);
    sum+=sqrt(x*x+y*y);    
  }
  Serial.print("sum: ");
  Serial.print(sum);
}

/tmp/arduino_build_733415/CH32V003_trigonometrieSpeed.ino.elf section 
`.text' will not fit in region `FLASH'

.arduino15/packages/WCH/tools/riscv-none-embed-gcc/8.2.0/bin/../lib/gcc/ 
riscv-none-embed/8.2.0/../../../../riscv-none-embed/bin/ld:  region 
`FLASH' overflowed by 8680 bytes

[Alexander (alecxs)]

Interessant, doch ein gewisser Unterschied.

[Christoph M. (mchris)]

Alexander (alecxs)
18.06.2025 19:16
>Interessant, doch ein gewisser Unterschied.

Beim Arduino-Nano ist der Unterschied relativ gesehen kleiner:

/*
 * Arduino Nano Results:
 * 
 * within while loop  149kHz
 * without while loop 146kHz
 * 
 */

[Christoph M. (mchris)]

Beim Arduino Nano passt der obige "trigonometrie Speedtest" locker:

Der Sketch verwendet 2570 Bytes (8%) des Programmspeicherplatzes. Das Maximum sind 30720 Bytes.
Globale Variablen verwenden 200 Bytes (9%) des dynamischen Speichers, 1848 Bytes für lokale Variablen verbleiben. Das Maximum sind 2048 Bytes.

[Yalu X. (yalu) (Moderator)]

Christoph M. schrieb:
> Oha, der Speicherverbrauch des Framworks scheint exorbitant:

Der Grund dafür:

  Beitrag "Re: CH32V003, float wirklich langsam?"

[Christoph M. (mchris)]

> Oha, der Speicherverbrauch des Framworks scheint exorbitant:
>>Der Grund dafür:
>>  Beitrag "Re: CH32V003, float wirklich langsam?"

Danke.

Auszug:

von Yalu X. (yalu) (Moderator)
14.04.2025 12:47
  
In der Mounriver-Toolchain für die CH32-Controller wird die generische
soft-fp der glibc verwendet. Diese ist in C implementiert und in
keinster Weise an spezifische CPU-Typen angepasst. Die AVR-FP-Routinen
hingegen sind in Assembler speziell für diesen CPU-Typ geschrieben.

Was mich dabei wundert: Die RISC-V Architektur ist ja ziemlich genau 
über die Abkürzungen der Erweiterung der Namensbezeichnung.

Die Bezeichnung von WCH ist RISCV-V2A

https://akizukidenshi.com/goodsaffix/CH32V003.pdf

was aber nicht mit der Namenskonvention der RISC-V Organisation 
übereinstimmt.
Im Datenblatt wird dann auf die Bezeichnung des Cores als RV32EC 
verwiesen .

* E => Embedded, nur 16 Register
* C => 16-bit compressed instructions
https://five-embeddev.com/riscv-user-isa-manual/Priv-v1.12/rv32e.html

Da die RISC-V Architekur ja ein mittlerweile recht verbreiteter Standard 
ist, sollte man erwarten, dass es eine schnelle Assembler-Float-Lib dazu 
gibt.

[Rainer W. (rawi)]

Christoph M. schrieb:
> CH32V003_Arduino_toggleSpeedTest.png

Christoph M. schrieb:
>>Und ohne die while Schleife?
> Ist für die Geschwindigkeit.

Da es dir anscheinend auf Geschwindigkeit ankommt, ist die relativ 
langsame Funktion digitalWrite() doch eher ungeeignet. Wäre an deren 
Stelle das deutlich schlankere digitalWriteFast() nicht naheliegender?

p.s.
Programmcode als PNG ist schon stark :-(

[Nemopuk (nemopuk)]

Rainer W. schrieb:
> Programmcode als PNG ist schon stark

Kopierschutz

[Christoph M. (mchris)]

Hier mal der Geschwindigkeitstest mit direktem Beschreiben von PC1.
Die Frequenz liegt bei knapp 6MHz.
Bei 48Mhz wäre das also 48/6/2=4 Zyklen pro Schreiben. Die Frage ist: 
Wieviel davon braucht der Sprung?

/*
 * CH32V003
 * 
 * Pin Toogle Speed Test
 * Results:
 * 
 * Toggle Speed: 168ns, ~5.95 MHz
 * 
 * 2025-06-19 mchris 
 * 
*/


#define RCC_APB2PCENR   (*(volatile uint32_t*)0x40021018) // APB2 Peripheral Clock Enable Register
// Controls the clock to APB2 peripherals.
// You must enable the clock for GPIOC (by setting bit 4, IOPCEN) before using any GPIOC functions.

#define GPIOC_CFGLR     (*(volatile uint32_t*)0x40011000) // GPIOC Port Configuration Low Register
// Configures the mode and configuration (input/output, push-pull/open-drain, etc.) for pins PC0-PC7.
// Each pin uses 4 bits: [MODE1:0 | CNF1:0]. For PC1, configure bits 7:4.

#define GPIOC_BSHR      (*(volatile uint32_t*)0x40011010) // GPIOC Bit Set/Reset Register
// Allows atomic setting or resetting of GPIOC output pins.
// Write '1' to bit n (0-15) to set PCn high; write '1' to bit n+16 (16-31) to set PCn low.
// Example: GPIOC_BSHR = (1 << 1);      // Set PC1 high
//          GPIOC_BSHR = (1 << (1+16)); // Set PC1 low

void setup()
{
  // Enable GPIOC clock
  RCC_APB2PCENR |= (1 << 4); // Set bit 4 (IOPCEN) to enable GPIOC peripheral clock

  // Configure PC1 as push-pull output, 50MHz
  GPIOC_CFGLR &= ~(0xF << 4); // Clear configuration bits for PC1 (bits 7:4)
  GPIOC_CFGLR |=  (0x3 << 4); // Set MODE1=11 (output 50MHz), CNF1=00 (push-pull)
}

void loop()
{
  // Blink PC1
  while (1) {
    GPIOC_BSHR = (1 << 1);      // Set PC1 high
    //delay(1000);
    GPIOC_BSHR = (1 << (1 + 16)); // Set PC1 low
    //delay(1000);
  }
}

[Christoph M. (mchris)]

Rainer W. (rawi)
19.06.2025 06:40

>p.s.
>Programmcode als PNG ist schon stark :-(
Im Screenshot geht es darum, den Speicherverbrauch anzuzeigen. Ich 
vertraue darauf, dass du die 2 Zeilen bei Bedarf auch selber eintippen 
kannst.

[Benjamin K. (bentschie)]

Christoph M. schrieb:
> Wieviel davon braucht der Sprung?

Sieht man doch ganz gut auf dem Oszi. 1 Takt High, 1 Takt Low, 2 Takte 
für den Sprung.

Due könntest auch in der Schleife mehrere High/Low wechsel einbauen und 
dann siehst du auf dem Oszi die einzelnen zeiten etwas besser.

[Ralph S. (jjflash)]

... ich habe zwar einen ganz anderen Ansatz für die 
Verwendungsmöglichkeiten von CH32V003, habe aber in meinen Anleitungen 
zum Schluß auch die Möglichkeit der Programmierung unter Arduino 
behandelt und verwende in dieser Anleitung denselben (offiziellen) Core 
wie du, den ich um meine eigenen Programmiermöglichkeiten (unter Linux) 
erweitert hab.

Was ich beim Schreiben einer Anleitung vermisst habe, war ein typisches 
Pinoutmapping des Chips zur Arduino Programmierung und deshalb habe ich 
dann dieses hier im Anhang erstellt.

:-) vllt. kannst du das für deine Seite zur Programmierung von CH32V003 
unter Arduino gebrauchen.

Gruß,
Ralph

[Christoph M. (mchris)]

>:-) vllt. kannst du das für deine Seite zur Programmierung von CH32V003
>unter Arduino gebrauchen.

Wow, finde ich extrem gut gemacht. Danke :-)

[Christoph M. (mchris)]

Benjamin K. (bentschie)
19.06.2025 07:42
>Du könntest auch in der Schleife mehrere High/Low wechsel einbauen und
>dann siehst du auf dem Oszi die einzelnen zeiten etwas besser.

Eine sehr gute Idee :-)
Ich meine 2 Cyclen pro Portschreiben zu sehen.

/*
   CH32V003

   Pin Toogle Speed Test
   Results:

   Toggle Speed: 82ns or 12.2MHz for ON/OFF

   2025-06-19 mchris

*/



#define GPIOC_BSHR      (*(volatile uint32_t*)0x40011010) // GPIOC Bit Set/Reset Register

void setup()
{
  pinMode(PC1, OUTPUT);
}

#define LEDON {GPIOC_BSHR = (1 << 1);}
#define LEDOFF {GPIOC_BSHR = (1 << (1 + 16));}

void loop()
{
  // Blink PC1
  while (1) {
    LEDON;
    LEDOFF;
    LEDON;
    LEDOFF;
  }
}

[Alexander (alecxs)]

Ralph S. schrieb:
> Was ich beim Schreiben einer Anleitung vermisst habe, war ein typisches
> Pinoutmapping des Chips zur Arduino Programmierung und deshalb habe ich
> dann dieses hier im Anhang erstellt.

Gleich in die README.md mit reinpacken und einen Pull request schicken.

[Yalu X. (yalu) (Moderator)]

Christoph M. schrieb:
> Was mich dabei wundert: Die RISC-V Architektur ist ja ziemlich genau
> über die Abkürzungen der Erweiterung der Namensbezeichnung.
>
> Die Bezeichnung von WCH ist RISCV-V2A
>
> https://akizukidenshi.com/goodsaffix/CH32V003.pdf
>
> was aber nicht mit der Namenskonvention der RISC-V Organisation
> übereinstimmt.
> Im Datenblatt wird dann auf die Bezeichnung des Cores als RV32EC
> verwiesen .

RV32EC ist der Name einer von der Berkeley-Universität bzw. RISC-V
International entwickelten Befehlssatzarchitektur.

QingKe V2A ist der Name eines von Nanjing Qinheng Microelectronics
entwickelten Prozessorkerns, der die RV32EC-Architektur implementiert.

CH32V003 ist der Name eines ebenfalls von Nanjing Qinheng
Microelectronics unter der Marke WinChipHead (WCH) entwickelten
Mikrocontrollers, der auf dem QingKe-V2A-Kern basiert.

[Christoph M. (mchris)]

Gerade ist mir eingefallen, dass der PiPico2 ja auch zwei otpionale 
RISC-V Cöre besitzt. Die beiden RV32IMACZ sollten abwärtskompatibel zum 
RV32EC des QingKe V2A sein.
Man kann den Kern in der IDE auswählen und mein hüpergeniales Programm 
(Screenshot) braucht nur 56256 Bytes.

[Ralph S. (jjflash)]

Christoph M. schrieb:
> Oha, der Speicherverbrauch des Framworks scheint exorbitant:

Guckst du hier:

Beitrag "Re: CH32V003: Selbstbauprogrammer und "Getting started""

da hab ich einen Vergleich des Speicherbedarfs gemacht. Für dein 
Arduinoprogramm oben

Christoph M. schrieb:
> for(uint32_t n=0;n<100000;n++)
>   {
>     x=sin(2*PI*n/1000);
>     x=cos(2*PI*n/1000);
>     sum+=sqrt(x*x+y*y);
>   }

wird garantiert irgendwo die Math-Library eingebunden (des Sinus und 
Cosinus wegen) und wie ich weiß, ist diese Bibliothek schon außerhalb 
von Arduino so groß, dass Sinus und Cosinus auch außerhalb von Arduino 
nicht in ein reines C-Programm eingebunden werden kann, weil auch hier 
schon zu groß!

[Johann L. (gjlayde)]

Christoph M. schrieb:

> void loop()
> {
>   float sum=0;
> 
>   float x,y,z;
> 
>   Serial.println("start");
>   for(uint32_t n=0;n<100000;n++)
>   {
>     x=sin(2*PI*n/1000);
>     x=cos(2*PI*n/1000);
>     sum+=sqrt(x*x+y*y);
>   }
>   Serial.print("sum: ");
>   Serial.print(sum);
> }
>

Also man sollte sich schon genau überlegen, wie man einen Benchmark 
schreibt.  GCC v15 optimiert das einfach zu sum = 0.

Auch wenn man den Code umschreibt zu

>     x=sin(2*PI*n/1000);
>     y=cos(2*PI*n/1000);

ist es nicht wirklich geschickt, weil man auf einen Blick sieht, dass 
die Berechnung gleichbedeutend mit "sum = 100000" ist.  (Zumindest mit 
entspannter IEEE Interpretation, also rein arithmetisch).

[Christoph M. (mchris)]

Johann L. (gjlayde) Benutzerseite
>Also man sollte sich schon genau überlegen, wie man einen Benchmark
>schreibt.  GCC v15 optimiert das einfach zu sum = 0.

Erstaunlich. Ich hätte nicht erwartet, dass der Compiler so gut 
optimieren kann.

> ist es nicht wirklich geschickt, weil man auf einen Blick sieht, dass
> die Berechnung gleichbedeutend mit "sum = 100000" ist.
Inclusive der Rundungsfehler der FP32 Rechnung?

[Christoph M. (mchris)]

Dieser Benchmark wäre besser:

void setup() {
  Serial.begin(115200);
}

void loop() {
  float sum = 0;
  float x, y;
  Serial.println("start");
  uint32_t start = micros();
  for (uint32_t n = 0; n < 10000; n++) {
    float r = random(0, 1000) * 1e-6; 
    x = sin(2 * PI * n / 1000 + r);
    y = cos(2 * PI * n / 1000 + r);
    sum += sqrt(x * x + y * y);
  }
  uint32_t dt = micros() - start;
  Serial.print("sum: ");
  Serial.println(sum, 6); // more decimals for float
  Serial.print("calculation time [us]: ");
  Serial.println(dt);
  Serial.println();
  delay(1000); // avoid flooding serial
}

Auf einem Arduino-Nano ergibt sich:

  
start  
sum: 10000.000000
calculation time [us]: 4457368

[Christoph M. (mchris)]

Oje, sieht schlecht aus für das RiscV-Softwareframework:

Arduino Nano Atmega328
start  
sum: 10000.000000
calculation time [us]: 4.457.368

PiPico2 RiscV RV32IMACZ 
start
sum: 10000.000000
calculation time [us]:   742.654

PiPico2 ARM Mode
start
sum: 10000.000000
calculation time [us]:    87.584

Geschwindigkeitgewinn (Faktor) reltaiv zum Arduino Nano:
PiPico RiscV : ~6
PiPico ARM : ~50

[Rainer W. (rawi)]

Christoph M. schrieb:
> Im Screenshot geht es darum, den Speicherverbrauch anzuzeigen. Ich
> vertraue darauf, dass du die 2 Zeilen bei Bedarf auch selber eintippen
> kannst.

Nein, es ging darum, den Code zu zeigen, mit dem die 255kHz erreicht 
werden. Sonst wäre das Bild absolut unpassend zum Kommentar ;-)

[Johann L. (gjlayde)]

Christoph M. schrieb:
> Johann L. (gjlayde) Benutzerseite
>>Also man sollte sich schon genau überlegen, wie man einen Benchmark
>>schreibt.  GCC v15 optimiert das einfach zu sum = 0.
>
> Erstaunlich. Ich hätte nicht erwartet, dass der Compiler so gut
> optimieren kann.

y wird nicht initialisiert aber im Ausdruck für sum verwendet.  sum hat 
folglich keinen definierten Wert, also kann man auch sum=0 nehmen.

[Christoph M. (mchris)]

Johann L. (gjlayde)
>y wird nicht initialisiert aber im Ausdruck für sum verwendet.  sum hat
>folglich keinen definierten Wert, also kann man auch sum=0 nehmen.

Du hast Recht. Es ist mir leider zu spät aufgefallen.
Die neue Version mit Verhinderung des Wegoptimierens mittels 
Zufallsfunktion geht.
Beitrag "Re: Arduino CH32V003"

[Christoph M. (mchris)]

Hier gibt es ein Arduino-Mini-artiges Board für's Steckbrett:
https://www.tindie.com/products/canhobby/risc-v-dev-board-ch32v003/

[Christoph M. (mchris)]

Man kann die Toolchain der Arduino-IDE nutzen, um Bare-Metal Assembler 
zu programmieren:

Code:
Beitrag "Re: RISCV (CH32V003): GNU Assembler übersetzt "CALL" nicht korrekt (oder bin ich nur zu doof?)"

Assembler-Script:
Beitrag "Re: RISCV (CH32V003): GNU Assembler übersetzt "CALL" nicht korrekt (oder bin ich nur zu doof?)"