├── schematic.png ├── yd_esp32_s3-23.jpg ├── YD-ESP32-23_V1120.jpg ├── YD-ESP32-S3-SCH-V1.4.pdf ├── yd-esp32-s3-devkitc-1-clone-pinout.jpg ├── Arduino_example ├── BlinkRGB_random_all │ └── BlinkRGB_random_all.ino ├── BlinkRGB │ └── BlinkRGB.ino ├── BlinkRGB_table │ └── BlinkRGB_table.ino ├── BlinkRGB_soft │ └── BlinkRGB_soft.ino ├── BlinkRGB_random │ └── BlinkRGB_random.ino └── BlinkRGB_random_crazy │ └── BlinkRGB_random_crazy.ino └── README.md /schematic.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rtek1000/YD-ESP32-23/HEAD/schematic.png -------------------------------------------------------------------------------- /yd_esp32_s3-23.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rtek1000/YD-ESP32-23/HEAD/yd_esp32_s3-23.jpg -------------------------------------------------------------------------------- /YD-ESP32-23_V1120.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rtek1000/YD-ESP32-23/HEAD/YD-ESP32-23_V1120.jpg -------------------------------------------------------------------------------- /YD-ESP32-S3-SCH-V1.4.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rtek1000/YD-ESP32-23/HEAD/YD-ESP32-S3-SCH-V1.4.pdf -------------------------------------------------------------------------------- /yd-esp32-s3-devkitc-1-clone-pinout.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rtek1000/YD-ESP32-23/HEAD/yd-esp32-s3-devkitc-1-clone-pinout.jpg -------------------------------------------------------------------------------- /Arduino_example/BlinkRGB_random_all/BlinkRGB_random_all.ino: -------------------------------------------------------------------------------- 1 | /* 2 | BlinkRGB - soft all colors 3 | 4 | Demonstrates usage of onboard RGB LED on some ESP dev boards. 5 | 6 | Calling digitalWrite(RGB_BUILTIN, HIGH) will use hidden RGB driver. 7 | 8 | RGBLedWrite demonstrates controll of each channel: 9 | void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue_val) 10 | 11 | WARNING: After using digitalWrite to drive RGB LED it will be impossible to drive the same pin 12 | with normal HIGH/LOW level 13 | */ 14 | //#define RGB_BRIGHTNESS 64 // Change white brightness (max 255) 15 | 16 | // the setup function runs once when you press reset or power the board 17 | 18 | #define RGB_BUILTIN 48 19 | 20 | void setup() { 21 | // No need to initialize the RGB LED 22 | } 23 | 24 | // the loop function runs over and over again forever 25 | void loop() { 26 | // All 27 | uint8_t r = random(0, 255); 28 | uint8_t g = random(0, 255); 29 | uint8_t b = random(0, 255); 30 | 31 | neopixelWrite(RGB_BUILTIN, r, g, b); // RGB 32 | 33 | delay(250); 34 | } 35 | -------------------------------------------------------------------------------- /Arduino_example/BlinkRGB/BlinkRGB.ino: -------------------------------------------------------------------------------- 1 | /* 2 | BlinkRGB 3 | 4 | Demonstrates usage of onboard RGB LED on some ESP dev boards. 5 | 6 | Calling digitalWrite(RGB_BUILTIN, HIGH) will use hidden RGB driver. 7 | 8 | RGBLedWrite demonstrates controll of each channel: 9 | void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue_val) 10 | 11 | WARNING: After using digitalWrite to drive RGB LED it will be impossible to drive the same pin 12 | with normal HIGH/LOW level 13 | */ 14 | //#define RGB_BRIGHTNESS 64 // Change white brightness (max 255) 15 | 16 | #define RGB_BUILTIN 48 17 | 18 | // the setup function runs once when you press reset or power the board 19 | void setup() { 20 | // No need to initialize the RGB LED 21 | } 22 | 23 | // the loop function runs over and over again forever 24 | void loop() { 25 | neopixelWrite(RGB_BUILTIN,RGB_BRIGHTNESS,RGB_BRIGHTNESS,RGB_BRIGHTNESS); // White 26 | delay(1000); 27 | neopixelWrite(RGB_BUILTIN,RGB_BRIGHTNESS,0,0); // Red 28 | delay(1000); 29 | neopixelWrite(RGB_BUILTIN,0,RGB_BRIGHTNESS,0); // Green 30 | delay(1000); 31 | neopixelWrite(RGB_BUILTIN,0,0,RGB_BRIGHTNESS); // Blue 32 | delay(1000); 33 | neopixelWrite(RGB_BUILTIN,0,0,0); // Off / black 34 | delay(1000); 35 | } 36 | -------------------------------------------------------------------------------- /Arduino_example/BlinkRGB_table/BlinkRGB_table.ino: -------------------------------------------------------------------------------- 1 | /* 2 | BlinkRGB - color table 888 3 | 4 | Demonstrates usage of onboard RGB LED on some ESP dev boards. 5 | 6 | Calling digitalWrite(RGB_BUILTIN, HIGH) will use hidden RGB driver. 7 | 8 | RGBLedWrite demonstrates controll of each channel: 9 | void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue_val) 10 | 11 | WARNING: After using digitalWrite to drive RGB LED it will be impossible to drive the same pin 12 | with normal HIGH/LOW level 13 | */ 14 | //#define RGB_BRIGHTNESS 64 // Change white brightness (max 255) 15 | 16 | // the setup function runs once when you press reset or power the board 17 | 18 | #define RGB_BUILTIN 48 19 | 20 | // See: https://barth-dev.de/online/rgb565-color-picker/ 21 | #define RED_888 0xff0000 22 | #define GREEN_888 0x00ff00 23 | #define BLUE_888 0x0000ff 24 | #define YELLOW_888 0xe5a50a 25 | #define ORANGE_888 0xc64600 26 | #define PURPLE_888 0x613583 27 | #define BROWN_888 0x63452c 28 | 29 | uint32_t color_table[7] = {RED_888, GREEN_888, BLUE_888, YELLOW_888, ORANGE_888, PURPLE_888, BROWN_888}; 30 | 31 | void setup() { 32 | // No need to initialize the RGB LED 33 | } 34 | 35 | // the loop function runs over and over again forever 36 | void loop() { 37 | // White 38 | for (uint8_t i = 0; i < 7; i++) { 39 | uint8_t r = (color_table[i] >> 16) & 0xFF; 40 | uint8_t g = (color_table[i] >> 8) & 0xFF; 41 | uint8_t b = color_table[i] & 0xFF; 42 | 43 | neopixelWrite(RGB_BUILTIN, r, g, b); // White 44 | 45 | delay(500); 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /Arduino_example/BlinkRGB_soft/BlinkRGB_soft.ino: -------------------------------------------------------------------------------- 1 | /* 2 | BlinkRGB - soft 3 | 4 | Demonstrates usage of onboard RGB LED on some ESP dev boards. 5 | 6 | Calling digitalWrite(RGB_BUILTIN, HIGH) will use hidden RGB driver. 7 | 8 | RGBLedWrite demonstrates controll of each channel: 9 | void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue_val) 10 | 11 | WARNING: After using digitalWrite to drive RGB LED it will be impossible to drive the same pin 12 | with normal HIGH/LOW level 13 | */ 14 | //#define RGB_BRIGHTNESS 64 // Change white brightness (max 255) 15 | 16 | // the setup function runs once when you press reset or power the board 17 | 18 | #define RGB_BUILTIN 48 19 | 20 | void setup() { 21 | // No need to initialize the RGB LED 22 | } 23 | 24 | // the loop function runs over and over again forever 25 | void loop() { 26 | // White 27 | for (uint8_t i = 0; i < 255; i++) { 28 | neopixelWrite(RGB_BUILTIN, i, i, i); // White 29 | 30 | delay(1); 31 | } 32 | 33 | for (uint8_t i = 255; i > 0; i--) { 34 | neopixelWrite(RGB_BUILTIN, i, i, i); // White 35 | 36 | delay(1); 37 | } 38 | 39 | // Red 40 | for (uint8_t i = 0; i < 255; i++) { 41 | neopixelWrite(RGB_BUILTIN, i, 0, 0); // Red 42 | 43 | delay(1); 44 | } 45 | 46 | for (uint8_t i = 255; i > 0; i--) { 47 | neopixelWrite(RGB_BUILTIN, i, 0, 0); // Red 48 | 49 | delay(1); 50 | } 51 | 52 | // Green 53 | for (uint8_t i = 0; i < 255; i++) { 54 | neopixelWrite(RGB_BUILTIN, 0, i, 0); // Green 55 | 56 | delay(1); 57 | } 58 | 59 | for (uint8_t i = 255; i > 0; i--) { 60 | neopixelWrite(RGB_BUILTIN, 0, i, 0); // Green 61 | 62 | delay(1); 63 | } 64 | 65 | // Blue 66 | for (uint8_t i = 0; i < 255; i++) { 67 | neopixelWrite(RGB_BUILTIN, 0, 0, i); // Blue 68 | 69 | delay(1); 70 | } 71 | 72 | for (uint8_t i = 255; i > 0; i--) { 73 | neopixelWrite(RGB_BUILTIN, 0, 0, i); // Blue 74 | 75 | delay(1); 76 | } 77 | } 78 | -------------------------------------------------------------------------------- /Arduino_example/BlinkRGB_random/BlinkRGB_random.ino: -------------------------------------------------------------------------------- 1 | /* 2 | BlinkRGB - random 3 | 4 | Demonstrates usage of onboard RGB LED on some ESP dev boards. 5 | 6 | Calling digitalWrite(RGB_BUILTIN, HIGH) will use hidden RGB driver. 7 | 8 | RGBLedWrite demonstrates controll of each channel: 9 | void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue_val) 10 | 11 | WARNING: After using digitalWrite to drive RGB LED it will be impossible to drive the same pin 12 | with normal HIGH/LOW level 13 | */ 14 | //#define RGB_BRIGHTNESS 64 // Change white brightness (max 255) 15 | 16 | #define RGB_BUILTIN 48 17 | 18 | uint8_t new_color = 0; 19 | uint8_t previous_color = 0; 20 | 21 | // the setup function runs once when you press reset or power the board 22 | void setup() { 23 | // No need to initialize the RGB LED 24 | } 25 | 26 | // the loop function runs over and over again forever 27 | void loop() { 28 | while (new_color == previous_color) { 29 | new_color = random(0, 5); 30 | } 31 | 32 | previous_color = new_color; 33 | 34 | switch (new_color) { 35 | case 0: 36 | color_while(); 37 | break; 38 | case 1: 39 | color_red(); 40 | break; 41 | case 2: 42 | color_green(); 43 | break; 44 | case 3: 45 | color_blue(); 46 | break; 47 | case 4: 48 | color_black(); 49 | break; 50 | default: 51 | break; 52 | } 53 | } 54 | 55 | void color_while(void) { 56 | // White 57 | for (uint8_t i = 0; i < 255; i++) { 58 | neopixelWrite(RGB_BUILTIN, i, i, i); // White 59 | 60 | delay(1); 61 | } 62 | 63 | for (uint8_t i = 255; i > 0; i--) { 64 | neopixelWrite(RGB_BUILTIN, i, i, i); // White 65 | 66 | delay(1); 67 | } 68 | } 69 | 70 | void color_red(void) { 71 | // Red 72 | for (uint8_t i = 0; i < 255; i++) { 73 | neopixelWrite(RGB_BUILTIN, i, 0, 0); // Red 74 | 75 | delay(1); 76 | } 77 | 78 | for (uint8_t i = 255; i > 0; i--) { 79 | neopixelWrite(RGB_BUILTIN, i, 0, 0); // Red 80 | 81 | delay(1); 82 | } 83 | } 84 | 85 | void color_green(void) { 86 | // Green 87 | for (uint8_t i = 0; i < 255; i++) { 88 | neopixelWrite(RGB_BUILTIN, 0, i, 0); // Green 89 | 90 | delay(1); 91 | } 92 | 93 | for (uint8_t i = 255; i > 0; i--) { 94 | neopixelWrite(RGB_BUILTIN, 0, i, 0); // Green 95 | 96 | delay(1); 97 | } 98 | } 99 | 100 | void color_blue(void) { 101 | // Blue 102 | for (uint8_t i = 0; i < 255; i++) { 103 | neopixelWrite(RGB_BUILTIN, 0, 0, i); // Blue 104 | 105 | delay(1); 106 | } 107 | 108 | for (uint8_t i = 255; i > 0; i--) { 109 | neopixelWrite(RGB_BUILTIN, 0, 0, i); // Blue 110 | 111 | delay(1); 112 | } 113 | } 114 | 115 | void color_black(void) { 116 | // Black 117 | for (uint8_t i = 0; i < 255; i++) { 118 | neopixelWrite(RGB_BUILTIN, 0, 0, 0); // Black 119 | 120 | delay(1); 121 | } 122 | 123 | for (uint8_t i = 255; i > 0; i--) { 124 | neopixelWrite(RGB_BUILTIN, 0, 0, 0); // Black 125 | 126 | delay(1); 127 | } 128 | } 129 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # YD-ESP32-23 2 | 3 | ![img](https://raw.githubusercontent.com/rtek1000/YD-ESP32-23/main/yd_esp32_s3-23.jpg) 4 | 5 | - Ref.: [YD-ESP32-S3 N16R8](https://circuitpython.org/board/yd_esp32_s3_n16r8/) 6 | 7 | - The device uses the ESP32-S3 chip, which can be used for the test prototype of the Internet of Things application and can also be used for practical applications. It is equipped with two USBs, one is a hardware USB-to-serial port (CH343P WCH Qinheng), and the other is ESP32-S3 usb port. 8 | 9 | - - [CircuitPython 9.2.8] Built-in modules available: _asyncio, _bleio, _eve, _pixelmap, adafruit_bus_device, adafruit_pixelbuf, aesio, alarm, analogbufio, analogio, array, atexit, audiobusio, audiocore, audiomixer, audiomp3, binascii, bitbangio, bitmapfilter, bitmaptools, board, builtins, builtins.pow3, busdisplay, busio, busio.SPI, busio.UART, canio, codeop, collections, countio, digitalio, displayio, dualbank, epaperdisplay, errno, espcamera, espidf, espnow, espulp, fontio, fourwire, framebufferio, frequencyio, getpass, gifio, hashlib, i2cdisplaybus, io, ipaddress, jpegio, json, keypad, keypad.KeyMatrix, keypad.Keys, keypad.ShiftRegisterKeys, keypad_demux, keypad_demux.DemuxKeyMatrix, locale, math, max3421e, mdns, memorymap, microcontroller, msgpack, neopixel_write, nvm, onewireio, os, os.getenv, paralleldisplaybus, ps2io, pulseio, pwmio, qrio, rainbowio, random, re, rgbmatrix, rotaryio, rtc, sdcardio, sdioio, select, sharpdisplay, socketpool, socketpool.socketpool.AF_INET6, ssl, storage, struct, supervisor, synthio, sys, terminalio, tilepalettemapper, time, touchio, traceback, ulab, usb, usb_cdc, usb_hid, usb_midi, vectorio, warnings, watchdog, wifi, zlib; Included frozen(?) modules: neopixel 10 | 11 | Pinout: 12 | ![img](https://raw.githubusercontent.com/rtek1000/YD-ESP32-23/main/yd-esp32-s3-devkitc-1-clone-pinout.jpg) 13 | 14 | - Ref.: [VCC-GND Studio YD-ESP32-S3 (DevKitC 1 clone): high-resolution pinout and specs](https://mischianti.org/vcc-gnd-studio-yd-esp32-s3-devkitc-1-clone-high-resolution-pinout-and-specs/) 15 | 16 | #### Note: 17 | - The ‘ESP32 S3 DevKitC1 Clone’ board has a jumper called 'RGB', another called 'IN-OUT', and another called 'USB-OTG', all open. But it may be necessary to solder the jumper for the devices to work. 18 | - - The 'IN-OUT' jumper, when closed, bypasses one diode, making USB VBus power coming to 5Vin. If 5Vin is also connected to external source, it can get back-fed by USB, which is usually undesirable. But USB bus is protected by another diode, it cannot get back-fed by external source. When In-Out is open, 5Vin and USB VBus are separated by diode, USB power does not come to 5Vin. 19 | - - The 'USB-OTG' jumper, when closed, connects together USB VBus lines from both USB-C connectors. 20 | - - Ref.: [Third-party ESP32-S3 development boards 'IN-OUT' and 'USB-OTG' pads - what do they do?](https://www.reddit.com/r/esp32/comments/10rdngp/thirdparty_esp32s3_development_boards_inout_and/?rdt=39953) 21 | 22 | 23 | - The RGB LED did not work with common digitalWrite() commands. RGB LED only worked with neopixelWrite() commands. 24 | - - Arduino IDE: There is a BlinkRGB under the ESP32->GPIO examples that uses the onboard RGB LED. 25 | - - Ref.: https://forum.arduino.cc/t/esp32-s3-devkit-problems/1136923/4 26 | - - Need add: '#define RGB_BUILTIN 48' 27 | - - Avoid looking directly at the LED, place a sheet of paper or a piece of white plastic material over the LED to serve as a diffuser. 28 | 29 | Schematic (Jumpers were not included): 30 | ![img](https://raw.githubusercontent.com/rtek1000/YD-ESP32-23/main/schematic.png) 31 | 32 | ----- 33 | 34 | Example of ESP32-S3 and support for mini keyboard with built-in touchpad: [here](https://github.com/rtek1000/ESP32-S3_USB_Host_HID_Keyboard) 35 | 36 | ![img](https://raw.githubusercontent.com/rtek1000/ESP32-S3_USB_Host_HID_Keyboard/main/Mini%20Keyboard%20With%20Touchpad%20Built-in.jpg) 37 | 38 | ----- 39 | ----- 40 | 41 | #### Warning: 42 | 43 | User [j2s](https://github.com/rtek1000/YD-ESP32-23/issues/3) reported that on his board the 5V pin works as another 3V3 pin, check your board before using. 44 | 45 | ![img](https://raw.githubusercontent.com/rtek1000/YD-ESP32-23/refs/heads/main/YD-ESP32-23_V1120.jpg) 46 | -------------------------------------------------------------------------------- /Arduino_example/BlinkRGB_random_crazy/BlinkRGB_random_crazy.ino: -------------------------------------------------------------------------------- 1 | /* 2 | BlinkRGB - random crazy 3 | 4 | Demonstrates usage of onboard RGB LED on some ESP dev boards. 5 | 6 | Calling digitalWrite(RGB_BUILTIN, HIGH) will use hidden RGB driver. 7 | 8 | RGBLedWrite demonstrates controll of each channel: 9 | void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue_val) 10 | 11 | WARNING: After using digitalWrite to drive RGB LED it will be impossible to drive the same pin 12 | with normal HIGH/LOW level 13 | */ 14 | //#define RGB_BRIGHTNESS 64 // Change white brightness (max 255) 15 | 16 | #define RGB_BUILTIN 48 17 | 18 | uint8_t new_color = 0; 19 | uint8_t previous_color = 0; 20 | 21 | // the setup function runs once when you press reset or power the board 22 | void setup() { 23 | // No need to initialize the RGB LED 24 | } 25 | 26 | // the loop function runs over and over again forever 27 | void loop() { 28 | while (new_color == previous_color) { 29 | new_color = random(0, 5); 30 | } 31 | 32 | previous_color = new_color; 33 | 34 | switch (new_color) { 35 | case 0: 36 | color_while(); 37 | break; 38 | case 1: 39 | color_red(); 40 | break; 41 | case 2: 42 | color_green(); 43 | break; 44 | case 3: 45 | color_blue(); 46 | break; 47 | case 4: 48 | color_black(); 49 | break; 50 | default: 51 | break; 52 | } 53 | } 54 | 55 | void color_while(void) { 56 | // White 57 | uint8_t rand_stop = random(0, 255); 58 | 59 | for (uint8_t i = 0; i < 255; i++) { 60 | neopixelWrite(RGB_BUILTIN, i, i, i); // White 61 | 62 | delay(1); 63 | 64 | if (i == rand_stop) { 65 | break; 66 | } 67 | } 68 | 69 | rand_stop = random(0, 255); 70 | 71 | for (uint8_t i = 255; i > 0; i--) { 72 | neopixelWrite(RGB_BUILTIN, i, i, i); // White 73 | 74 | delay(1); 75 | 76 | if (i == rand_stop) { 77 | break; 78 | } 79 | } 80 | } 81 | 82 | void color_red(void) { 83 | uint8_t rand_stop = random(0, 255); 84 | 85 | // Red 86 | for (uint8_t i = 0; i < 255; i++) { 87 | neopixelWrite(RGB_BUILTIN, i, 0, 0); // Red 88 | 89 | delay(1); 90 | 91 | if (i == rand_stop) { 92 | break; 93 | } 94 | } 95 | 96 | rand_stop = random(0, 255); 97 | 98 | for (uint8_t i = 255; i > 0; i--) { 99 | neopixelWrite(RGB_BUILTIN, i, 0, 0); // Red 100 | 101 | delay(1); 102 | 103 | if (i == rand_stop) { 104 | break; 105 | } 106 | } 107 | } 108 | 109 | void color_green(void) { 110 | uint8_t rand_stop = random(0, 255); 111 | 112 | // Green 113 | for (uint8_t i = 0; i < 255; i++) { 114 | neopixelWrite(RGB_BUILTIN, 0, i, 0); // Green 115 | 116 | delay(1); 117 | 118 | if (i == rand_stop) { 119 | break; 120 | } 121 | } 122 | 123 | rand_stop = random(0, 255); 124 | 125 | for (uint8_t i = 255; i > 0; i--) { 126 | neopixelWrite(RGB_BUILTIN, 0, i, 0); // Green 127 | 128 | delay(1); 129 | 130 | if (i == rand_stop) { 131 | break; 132 | } 133 | } 134 | } 135 | 136 | void color_blue(void) { 137 | uint8_t rand_stop = random(0, 255); 138 | 139 | // Blue 140 | for (uint8_t i = 0; i < 255; i++) { 141 | neopixelWrite(RGB_BUILTIN, 0, 0, i); // Blue 142 | 143 | delay(1); 144 | 145 | if (i == rand_stop) { 146 | break; 147 | } 148 | } 149 | 150 | rand_stop = random(0, 255); 151 | 152 | for (uint8_t i = 255; i > 0; i--) { 153 | neopixelWrite(RGB_BUILTIN, 0, 0, i); // Blue 154 | 155 | delay(1); 156 | 157 | if (i == rand_stop) { 158 | break; 159 | } 160 | } 161 | } 162 | 163 | void color_black(void) { 164 | uint8_t rand_stop = random(0, 255); 165 | 166 | // Black 167 | for (uint8_t i = 0; i < 255; i++) { 168 | neopixelWrite(RGB_BUILTIN, 0, 0, 0); // Black 169 | 170 | delay(1); 171 | 172 | if (i == rand_stop) { 173 | break; 174 | } 175 | } 176 | 177 | rand_stop = random(0, 255); 178 | 179 | for (uint8_t i = 255; i > 0; i--) { 180 | neopixelWrite(RGB_BUILTIN, 0, 0, 0); // Black 181 | 182 | delay(1); 183 | 184 | if (i == rand_stop) { 185 | break; 186 | } 187 | } 188 | } 189 | --------------------------------------------------------------------------------