RGB neopixel on VCC-GND YD-ESP32-S3

[bixb922]

I am trying to make the RGB on the PCB work on a VCC-GND YD-ESP32-S3 N8R8 2022-V1.4. I tried with GENERIC_S3_SPIRAM_OCT-20230320-unstable-v1.19.1-974-ga2b31f968.bin and with the version provided by the vendor YD-ESP32-S3-N8R8-MPY-V1.1.bin. The schematic shows that the RGB is connected to GPIO48 (or GPIO38 on other versions ot the board).
The code I tried is:

from machine import Pin
import neopixel
import time
import sys
print(sys.implementation)
# output=(name='micropython', version=(1, 19, 1), _machine='ESP32S3 module (spiram octal) with ESP32S3', _mpy=10502)
for p in [38,48]:
    np = neopixel.NeoPixel(Pin(p), 1, timing=0 )
    np[0] = (255,255,255)
    np.write()
    time.sleep(1)
    np[0] =  (0,0,0)
    np.write()
    time.sleep(1)

The RGB pixel does not turn on. I tried with all the other pins (1 to 48), timing=0 and 1, bpp=3 and 4 and all combinations, but no result. I have only one board, so it may be defective. Has anyone tried this? Is the code correct?

(edit) neopixel works correctly on GPIO48. I used np.write instead of np.write(). I edited the above code and it works well! I can also confirm it works with RMT.bitstream_channel set to None (bitbang) and with RMT channels 1, 2, 3.

[PBrunot]

Doesn't work for me either but it's not a NeoPixel issue.

I tried your code with my board, a VCC-GND YD-ESP32-S3 N8R2 2022-V1.3, running a recent built (MicroPython v1.19.1-915-g2bcd88d55-dirty on 2023-03-05, ESP32S3 module with ESP32S3). I built this version myself to be able to specify Flash size. I never tested the NeoPixel before.

What I did:

• checked on board that ESP32S3-WROOM-S1 GPIO48 is connected to the resistor to the DIN signal
• checked on scope that no signal comes out GPIO48 with NeoPixel(Pin(48))
• checked on scope that a 800 kHz signal comes out GPIO10 with NeoPixel(Pin(10))
• if I connect the GPIO 10 to the NeoPixel resistor, the NeoPixel lights up

In the ESP32S3-WROOM-1 datasheet I can't see with GPIO 48 shouldn't work (https://www.espressif.com/sites/default/files/documentation/esp32-s3-wroom-1_wroom-1u_datasheet_en.pdf )

Maybe someone familiar with NeoPixel implementation can cast some light why it shouldn't work on GPIO48. It's a bit strange that the manufacturer provides Micropython examples and schema with GPIO48 and it does not work. Maybe @bixb922 you could try flashing again the original firmware and we can conclude if that's a Micropython "regression".

[bixb922]

Thanks a lot for the post! That's a good analysis, it confirms that the GPIO48 is connected to the RGB pixel as the schematics says. And it helps to know that on another board it doesn't work either.
I tried the same test program of the OP again with GENERIC_S3_SPIRAM_OCT-20230320-unstable-v1.19.1-974-ga2b31f968.bin and with the vendor's image YD-ESP32-S3-N8R8-MPY-V1.1.bin, and it does not work on neither of those versions.

I wrote a (very crude) bitbang script in Micropython and this turns on the RGB neopixel on GPIO48 with some random color (green, green/yellow, white), since there is no way to get the timing of the neopixel protocol right:

from machine import Pin
p48 = Pin(48,Pin.OUT)
p48.value(0)
for i in range(10):
    p48.value(1)
    p48.value(0)
p48.value(0)

What I conclude so far is: my board is working. The RGB is connected to GPIO48. GPIO48 can be used with machine.Pin.
The neopixel.py module is generic, so the problem might be in machine.bitstream. Pins > 32 use another bank, it may be interesting to test neopixel on pins > 32.
Report as bug?

[PBrunot]

I browsed some similar cases and I think it would be good to test with thealternative bitbang method (no using the remote transmitter RMT of esp32) in machine bitstream before to open an issue. Maybe some specific channel needs to be set for esp32s3 and GPIO48. See #8198 Things done: - I have opened an issue on VCC-GND github : vcc-gnd/YD-ESP32-S3#1 - Tried ```RMT.bitstream_channel(None)``` , no success - Vrowsed the ESP-IDF RMT documentation, but nothing special is mentionned about Pin 47 or 48, as far as I can tell RMT should work on this pin.

[scruss]

Even VCC-GND Studios don't seem especially clear on that solder link. Their repo for the product - YD-ESP32-S3 - only hints that the LED might be connected. Google Translate suggests that the page says "Equipped with a WS2812-RGB LED (note that it is not directly lit through GPIO)"

[musicman7]

Thanks! This worked!

[BDhackers009]

Thanks. I was worried if my board is damaged. BUT after soldering that point the rgb led is working fine..though i used arduino IDE

[bryanjamesl]

This was super helpful. Thanks much. I'm using a standard Pi Pico from VCC-GND, and thought it was defective for days. Turns out it was the solder pad issue mentioned above, which is the same on this standard board. Soon as I connected the two "R7" pads the onboard neopix worked. Thanks again.

[cmesoar]

indeed - super helpful!! after soldering the pad with marginal silkscreen that eventually can be deciphered to read RGB, all the sketches that I've tried using FASTLed or NeoPixel work !!! ten thumbs up for the help here !!! --- ten thumbs down for VCC-GND terrible documentation for a really nice little board---

[bidrohini]

You can share your PCB layout here: https://www.pcbway.com/project/questionpublish
Not sure but there may be some issues with the design. Expert eyes may find the fault.

[tygliu]

Thanks for research from PBrunot & mikadoryu

[thizy0754]

I confirm RGB is working as soon as I solder the RGB marking on the board with the following program 👍 #include <FastLED.h>
#define NUM_LEDS 1
#define DATA_PIN 48
CRGB leds[NUM_LEDS];
void setup() {
Serial.begin(115200);
// put your setup code here, to run once:
FastLED.addLeds<WS2812, DATA_PIN, GRB>(leds, NUM_LEDS); //RGB ou GRB ??
Serial.println("setup");
}
void loop() {
leds[0] = CRGB::Red;
FastLED.show();
Serial.println("red");
delay(500);
leds[0] = CRGB::Green;
FastLED.show();
Serial.println("green");
delay(500);
leds[0] = CRGB::Blue;
FastLED.show();
Serial.println("blue");
delay(500);
leds[0] = CRGB::Black;
FastLED.show();
delay(500);
}

[scruss]

glad it works for you, but this is a MicroPython place ...

[fishybow]

I confirm RGB is working as soon as I solder the RGB marking on the board with the following program 👍 #include <FastLED.h> #define NUM_LEDS 1 #define DATA_PIN 48 CRGB leds[NUM_LEDS]; void setup() { Serial.begin(115200); // put your setup code here, to run once: FastLED.addLeds<WS2812, DATA_PIN, GRB>(leds, NUM_LEDS); //RGB ou GRB ?? Serial.println("setup"); } void loop() { leds[0] = CRGB::Red; FastLED.show(); Serial.println("red"); delay(500); leds[0] = CRGB::Green; FastLED.show(); Serial.println("green"); delay(500); leds[0] = CRGB::Blue; FastLED.show(); Serial.println("blue"); delay(500); leds[0] = CRGB::Black; FastLED.show(); delay(500); }

This worked for me as well.

[PepeTux]

Also you can found the official RGB example and driver here.

`/*
BlinkRGB

Demonstrates usage of onboard RGB LED on some ESP dev boards.

Calling digitalWrite(RGB_BUILTIN, HIGH) will use hidden RGB driver.

RGBLedWrite demonstrates controll of each channel:
void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue_val)

WARNING: After using digitalWrite to drive RGB LED it will be impossible to drive the same pin
with normal HIGH/LOW level
*/
//#define RGB_BRIGHTNESS 64 // Change white brightness (max 255)

// the setup function runs once when you press reset or power the board

void setup() {
// No need to initialize the RGB LED
}

// the loop function runs over and over again forever
void loop() {
#ifdef RGB_BUILTIN
digitalWrite(RGB_BUILTIN, HIGH); // Turn the RGB LED white
delay(1000);
digitalWrite(RGB_BUILTIN, LOW); // Turn the RGB LED off
delay(1000);

neopixelWrite(RGB_BUILTIN,RGB_BRIGHTNESS,0,0); // Red
delay(1000);
neopixelWrite(RGB_BUILTIN,0,RGB_BRIGHTNESS,0); // Green
delay(1000);
neopixelWrite(RGB_BUILTIN,0,0,RGB_BRIGHTNESS); // Blue
delay(1000);
neopixelWrite(RGB_BUILTIN,0,0,0); // Off / black
delay(1000);
#endif
}
`

Regards
Jose Luis

[yunkyusung]

• board: ESP32-S3-CAM N16R8 pinout

• mPython firmware: ESP32_GENERIC_S3-20240602-v1.23.0.bin

• test code ref.: https://randomnerdtutorials.com/micropython-ws2812b-addressable-rgb-leds-neopixel-esp32-esp8266/

• neopixel_test.py

import machine, neopixel
from time import sleep_ms

n = 1    # number of pixels in your strip
p = 48   # GPIO number that will control the strip

np = neopixel.NeoPixel(machine.Pin(p), n)

# Flashes three times in the order of Red, Green, and Blue for 0.5 seconds each, then turns off.
for i in range(3):
    np[0] = (255, 0, 0)  # red
    np.write()
    sleep_ms(500)
    np[0] = (0, 255, 0)  # green
    np.write()
    sleep_ms(500)
    np[0] = (0, 0, 255)  # blue
    np.write()
    sleep_ms(500)

np[0] = (0, 0, 0)  # clear
np.write()

• neopixel.py

# NeoPixel driver for MicroPython
# MIT license; Copyright (c) 2016 Damien P. George, 2021 Jim Mussared
#  https://github.com/micropython/micropython-lib/tree/master/micropython/drivers/led/neopixel

from machine import bitstream

class NeoPixel:
                   # G R B W
    ORDER = (1, 0, 2, 3)      


    def __init__(self, pin, n, bpp=3, timing=1):
        self.pin = pin
        self.n = n
        self.bpp = bpp
        self.buf = bytearray(n * bpp)
        self.pin.init(pin.OUT)
        # Timing arg can either be 1 for 800kHz or 0 for 400kHz,
        # or a user-specified timing ns tuple (high_0, low_0, high_1, low_1).
        self.timing = (
            ((400, 850, 800, 450) if timing else (800, 1700, 1600, 900))
            if isinstance(timing, int)
            else timing
        )

    def __len__(self):
        return self.n

    def __setitem__(self, i, v):
        offset = i * self.bpp
        for i in range(self.bpp):
            self.buf[offset + self.ORDER[i]] = v[i]

    def __getitem__(self, i):
        offset = i * self.bpp
        return tuple(self.buf[offset + self.ORDER[i]] for i in range(self.bpp))

    def fill(self, v):
        b = self.buf
        l = len(self.buf)
        bpp = self.bpp
        for i in range(bpp):
            c = v[i]
            j = self.ORDER[i]
            while j < l:
                b[j] = c
                j += bpp

    def write(self):
        # BITSTREAM_TYPE_HIGH_LOW = 0
        bitstream(self.pin, 0, self.timing, self.buf)

[fishybow]

Similarly. If you are not getting 5V on the 5V/Vin pin, try solder the patch right next to the pin.