bjc / arduinocore-gd32

Arduino core for GD32 devices, community developed, based on original GigaDevice's core

GD32 Arduino Core (New)

This is a Arduino core is based off of the original GigaDevice core that was provided by the company in early June 2021 (see https://github.com/CommunityGD32Cores/GD32Core/)

It is currently a work in progress, but believed to be functional on GigaDevice's mBed boards.

The intention is to further develop that original core in an open-source, community-driven manner.

Collaborating

Interested in collaborating? Join our dedicated Discord channel for this at https://discord.gg/59kf4JxsRM.

Media

A GD32F303CC chip (placed on a bluepill PCB) runs its first blinky code with the new Arduino core!

first_blinky_gd32f303cc_1080p.mp4

The same board reading out a DHT11 temperature & humidity sensor and displaying it on an SSD1306 OLED via the Adafruit GFX libraries

The board runs the Adafruit SSD1306 test sketch

i2c_oled.mp4

And here it is using analogRead() to read the voltage over a potentiomeneter as a 12-bit value.

Using this core with PlatformIO

Currently, development of this core is being done using PlatformIO. It uses the custom PlatformIO platform https://github.com/CommunityGD32Cores/platform-gd32.

Using PlatformIO is already possible to very easily edit code in the IDE and even live-debug a chip (with e.g. an ST-Link)

Various example projects for this platform for the SPL framework and this Arduino core are currently hosted at https://github.com/CommunityGD32Cores/gd32-pio-projects.

Using this core with the Arduino IDE

To compile for this core with the Arduino IDE, add the following URL to the boards manager.

https://raw.githubusercontent.com/CommunityGD32Cores/GD32Core-New/main/package_gd32_index.json

This will install the core and compiler toolchain against the 'main' git branch.

Current state

The gd32-arduino-blinky project compiles for the gd32f307_mbed board and the genericGD32F303CC board and works (see video above).

Multiple more complicated demos work, like an SSD1306 OLED, analog input, Serial, etc. See issue CommunityGD32Cores#8 for the latest state of tested components.

Library compatibility list

Legend:

• ✔️ = working
• ❌ = not working at all
• ⚠️ = some features not working
• ⁉️ = untested

Name	Works?	Notes
Adafruit GFX	✔️	Tested in conjunction with SSD1306 OLED, CP437 symbols works
Adafruit SSD1306	✔️	Tested on SSD1306 I2C 128x64 OLED, entire extensive demo works
SimpleDHT	✔️	Works with DHT11 (Temp & Humidity) and OLED, demo above

Updates / History

31.05.2021:

Initial contact and thoughts about an Arduino core implementation from scratch for GD32 devices with @kemotz via Email.

02.06.2021:

Creation of the Github project https://github.com/maxgerhardt/gd32-arduino-core/ and a discord channel.

10.06.2021:

A custom dev board has been designed and is in production. The repo with the files for it is at https://github.com/kemotz/GD32F1x0-dev-brd.

@obra and @algernon join the project.

GigaDevices is contact with a request for information on a potentially existing in-house developed Arduino core and code licensing questions.

16.06.2021:

GigaDeviecs confirms that there is a internally developed Arduino core, sends it over to use and approves of publishing it. The code is also BSD 3-clause licensed.

The original files for this are found at https://github.com/CommunityGD32Cores/GD32Core.

The focus shifts from creating a new Arduino core from scratch to getting the retrieved one working and expanding upon it.

18.06.2021:

Arduino core:

• Add package.json for PlatformIO compatibility
• Add tools\platformio\platformio-build.py PlatformIO builder script
• gives a successful build for the gd32f307_mbed board
• gives a successful build for the genericGD32F303CC board (and gives a working blinky!)

19.06.2021:

• Addded a lot more demos to https://github.com/maxgerhardt/gd32-pio-projects (now https://github.com/CommunityGD32Cores/gd32-pio-projects/)
• Added catalog of issues for future work
• Added Arduino IDE build support, upload not yet working upload working fine :)

24.07.2021:

• moved all relevant projects into the Github org instead of personal accounts, adapted URLs
• build fixes for Linux
• added CI to projects repository, now builds 15 projects fully automatically
• Jesse worked on merging new-style Arduino APIs (https://github.com/arduino/ArduinoCore-API/) to this core
• Jesse started working on USB support (and USB bootloaders)
• later that day, the new ArduinoCore-API adoption was successfully merged and tested

ToDo / thoughts

ToDos are now all moved to issues.

Supported boards

Everything is WIP now and no full support can be expected yet.

Planned support:

GD32F303CC based boards

custom GD32F190 board seen above

the boards previously supported by this core, so GD32F303ZE-EVAL and GD32F307VG-MBED

.. more?

arduinocore-gd32's Issues

Using a total of 6 endpoints seems to cause an assert failure due to buffer sizing calculation

I've finally figured out why enabling both Serial and HID Mouse support has been locking up Kaleidoscope.

We're failing

                assert((buf_offset + ep_desc.wMaxPacketSize) <= 512);

It looks like you're automatically assuming that every endpoint should have a 64 byte buffer.

This is how the Model 100 wants to enumerate:

I can reproduce the failure I'm seeing with the attached sketch that simulates how Kaleidoscope inits HID.
gd32usb-test.txt

As a debugging tactic, I modified line 325 of USBCore.cpp to read:

.wMaxPacketSize = USB_EP_SIZE/2,

This is obviously not correct, but it does result in basic functionality working for me.

Given that the chip supports up to 8 endpoints with its 512b of USB buffer RAM, there ought to be a way to make this go, right?

CDCACM::availabe() blocks

Upstream issue: CommunityGD32Cores#56

Dropping characters when USB Serial reads are slow

We're trying to track down a USB Serial input issue with the GD32 Arduino core which is causing bytes to get dropped. It looks like the issue might be that the GD32 core's CDCACM implementation isn't using the same 64 byte ring buffer as other arduino cores seem to. (api/RingBuffer.h has typedef RingBufferN<SERIAL_BUFFER_SIZE> RingBuffer) - Not every core does appear to use it though.

This may be macOS specific.

To repro:

static constexpr char NEWLINE = '\n';
bool isEOL() {
  return Serial.peek() == NEWLINE;
}

void setup() {
  Serial.begin(9600);
  while (!Serial) { ; }
}

void loop() {
  uint16_t data[384] = {0 };
  int i = 0;
    while (! isEOL() && (i < 384))  {
      data[i]= Serial.parseInt();
      i++;
    } 

    Serial.println("Got data");
    for (auto j = 0; j<= sizeof(data); j++) { 
      Serial.print(data[j]);
      Serial.print(" ");
    }
    Serial.println("");
}

Pasting in

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384

Results in

0 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 7 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 183 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 26 0 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 177 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 384 0 384 0 32760 8193 18837 2048 3088 16385 11451 2048```

win32 crashes USB stack

Enumeration doesn't finish when plugging device into win32 host.

Dropping characters on fast device->host communication

This looks similar to #8 but is during communications in the other direction.

Demo sketch:

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

void loop() {
 for(auto i=0 ;i<1024; i++) 
  Serial.print("0");
 for(auto i=0; i<1024; i++) 
  Serial.print("1");
 for(auto i=0; i<1024; i++) 
  Serial.print("2");
 for(auto i=0 ;i<1024; i++) 
  Serial.print("3");
 for(auto i=0 ;i<1024; i++) 
  Serial.print("4");
 for(auto i=0; i<1024; i++) 
  Serial.print("5");
 for(auto i=0; i<1024; i++) 
  Serial.print("6");
 for(auto i=0 ;i<1024; i++) 
  Serial.print("7");
 for(auto i=0 ;i<1024; i++) 
  Serial.print("8");
 for(auto i=0 ;i<1024; i++) 
  Serial.print("9");
  Serial.println();
  delay(2000);

}

Trailing edge of output: