KY-009 comparativ cu KY-011 pe Raspberry Pi 5, în C, folosind biblioteca GPIO_RPI5

Modulele KY-009 și KY-011 sunt două module LED foarte simple, dar utile, atunci când vrei să înveți controlul pinilor GPIO pe Raspberry Pi 5. Deși la prima vedere par similare, ele sunt concepute pentru scopuri diferite:

• KY-011 este un modul LED bicolor, de regulă roșu + verde.
• KY-009 este un modul RGB, adică roșu + verde + albastru.

În acest articol vom analiza diferențele tehnice dintre ele, modul de funcționare, conexiunea la Raspberry Pi 5 și exemple practice în limbajul C, folosind biblioteca GPIO_RPI5.

1. Ce este modulul KY-011?

KY-011 este un modul cu două LED-uri interne, unul roșu și unul verde, conectate printr-un catod comun. Asta înseamnă că pinul comun se leagă la GND, iar fiecare culoare se activează separat aplicând nivel logic HIGH pe anodul corespunzător, printr-o rezistență serie.

Avantajul lui KY-011 este simplitatea. Cu doar două ieșiri GPIO poți obține:

• roșu,
• verde,
• ambele simultan, ceea ce produce vizual o nuanță apropiată de galben.

KY-011 este foarte potrivit pentru:

• indicatori de stare simplă,
• OK / ERROR,
• RUN / STOP,
• stare rețea / eroare / avertizare.

2. Ce este modulul KY-009?

KY-009 conține trei LED-uri interne într-un singur pachet: roșu, verde și albastru. Și acest modul este cu catod comun, deci pinul comun merge la GND, iar cele trei canale de culoare sunt controlate individual.

Față de KY-011, KY-009 poate afișa mult mai multe culori, deoarece prin combinarea intensităților RGB poți obține o gamă foarte mare de nuanțe. Totuși, asta vine cu o cerință importantă: pentru culori intermediare și tranziții line ai nevoie de PWM (Pulse Width Modulation), nu doar de ON/OFF digital.

KY-009 este potrivit pentru:

• feedback vizual avansat,
• efecte de culoare,
• semnalizare multistare,
• proiecte demo și educaționale.

3. KY-009 vs KY-011 – comparație directă

4. Cum funcționează electric aceste module?

4.1 Catod comun

La ambele module, catodul comun se conectează la GND. Fiecare culoare are anod separat. Când un pin GPIO este setat la HIGH, curentul circulă din GPIO prin rezistență, apoi prin LED, spre GND. LED-ul se aprinde.

4.2 De ce sunt necesare rezistențe serie?

LED-ul nu trebuie legat direct la GPIO fără limitare de curent. Rezistența serie protejează atât LED-ul, cât și pinul Raspberry Pi 5. În practică:

• la KY-011 se folosește câte o rezistență pe fiecare canal activ,
• la KY-009 se folosește câte o rezistență separată pentru roșu, verde și albastru.

4.3 De ce KY-009 are nevoie de PWM?

Dacă scrii doar HIGH sau LOW pe cele trei canale ale lui KY-009, obții doar combinații digitale:

• roșu,
• verde,
• albastru,
• cyan,
• magenta,
• galben,
• alb aproximativ,
• stins.

Pentru tranziții line și nuanțe intermediare trebuie să reglezi timpul în care fiecare canal rămâne HIGH într-o perioadă fixă, adică să folosești PWM.

5. De ce este potrivită biblioteca GPIO_RPI5?

Biblioteca GPIO_RPI5 este foarte potrivită pentru astfel de proiecte deoarece oferă:

• inițializare simplă prin gpio_init(),
• configurarea pinilor prin pinopen(..., OUTPUT) și pinopen(..., INPUT),
• scriere digitală prin pinwrite(),
• citire prin pinread(),
• toggle rapid prin pintoggle(),
• configurare funcții alternative prin pinalt(),
• control asupra rezistențelor interne de pull prin pinpull().

Pentru aplicații LED, backend-ul direct pe /dev/gpiomem0 este alegerea corectă, fiind mult mai rapid decât backend-ul bazat pe pinctrl. Acest lucru este important mai ales atunci când implementezi software PWM.

6. Pini recomandați pe Raspberry Pi 5

Pentru a păstra exemplele clare și ușor de cablat, vom folosi următoarele GPIO-uri, toate disponibile pe header-ul de 40 de pini:

7. Schema de conectare pentru KY-011

Conexiune recomandată:

• Pin comun GND al modulului KY-011 -> GND pe Raspberry Pi 5 (Pin 6)
• Pin RED -> rezistență serie -> GPIO17 (Pin 11)
• Pin GREEN -> rezistență serie -> GPIO27 (Pin 13)

Observație: pentru 3,3 V, modulul este frecvent folosit cu rezistențe dedicate pe fiecare canal. Dacă vrei un montaj mai conservator pentru Raspberry Pi 5, poți alege rezistențe puțin mai mari, cu prețul unei luminozități mai mici.

8. Schema de conectare pentru KY-009

Conexiune recomandată:

• Pin comun GND al modulului KY-009 -> GND pe Raspberry Pi 5 (Pin 6)
• Pin RED -> rezistență serie -> GPIO17 (Pin 11)
• Pin GREEN -> rezistență serie -> GPIO27 (Pin 13)
• Pin BLUE -> rezistență serie -> GPIO22 (Pin 15)

Pentru canalul RGB este important să ai trei rezistențe separate, una pe fiecare culoare.

• Test functional

9. Compilare folosind GPIO_RPI5

Din repository-ul bibliotecii, poți folosi backend-ul direct, care este cel mai potrivit pentru LED-uri și PWM software.

chmod +x ./build.sh
./build.sh

# alternativ, compilare manuală:
gcc -c gpio_rpi5.c -o gpio_rpi5.o -Wall -Wextra
ar rcs gpio_rpi5.a gpio_rpi5.o

Pentru fiecare exemplu C de mai jos:

gcc ky011_demo.c -I. -L. -l:gpio_rpi5.a -o ky011_demo -Wall -Wextra
sudo ./ky011_demo

Sau, pentru RGB:

gcc ky009_demo.c -I. -L. -l:gpio_rpi5.a -o ky009_demo -Wall -Wextra
sudo ./ky009_demo

10. Exemplu C – KY-011 ca indicator de stare

Acest exemplu aprinde alternativ roșu, verde, apoi ambele simultan.

#include "gpio_rpi5.h"
#include <stdio.h>
#include <unistd.h>

#define LED_RED   GPIO17
#define LED_GREEN GPIO27

static void leds_off(void)
{
    pinwrite(LED_RED, LOW);
    pinwrite(LED_GREEN, LOW);
}

int main(void)
{
    if (gpio_init() != 0) {
        fprintf(stderr, "Eroare: gpio_init() a esuat.\n");
        return 1;
    }

    pin_t red   = pinopen(LED_RED, OUTPUT);
    pin_t green = pinopen(LED_GREEN, OUTPUT);

    if (red.mode == UNDEF || green.mode == UNDEF) {
        fprintf(stderr, "Eroare: pinopen() a esuat.\n");
        gpio_cleanup();
        return 1;
    }

    leds_off();

    while (1) {
        /* ROSU */
        pinwrite(LED_RED, HIGH);
        pinwrite(LED_GREEN, LOW);
        sleep(1);

        /* VERDE */
        pinwrite(LED_RED, LOW);
        pinwrite(LED_GREEN, HIGH);
        sleep(1);

        /* AMBELE -> galben aproximativ */
        pinwrite(LED_RED, HIGH);
        pinwrite(LED_GREEN, HIGH);
        sleep(1);

        /* STINS */
        leds_off();
        sleep(1);
    }

    pinclose(LED_RED);
    pinclose(LED_GREEN);
    gpio_cleanup();
    return 0;
}

Ce face acest exemplu?

• apelează gpio_init(),
• deschide doi pini ca ieșiri,
• scrie HIGH/LOW pe fiecare canal,
• folosește KY-011 ca indicator de stare simplu.

11. Exemplu C – KY-009 în mod digital simplu

Acest exemplu nu folosește PWM. El doar comută combinații de culori fixe.

#include "gpio_rpi5.h"
#include <stdio.h>
#include <unistd.h>

#define LED_R GPIO17
#define LED_G GPIO27
#define LED_B GPIO22

static void rgb_set(int r, int g, int b)
{
    pinwrite(LED_R, r ? HIGH : LOW);
    pinwrite(LED_G, g ? HIGH : LOW);
    pinwrite(LED_B, b ? HIGH : LOW);
}

int main(void)
{
    if (gpio_init() != 0) {
        fprintf(stderr, "Eroare: gpio_init() a esuat.\n");
        return 1;
    }

    pin_t pr = pinopen(LED_R, OUTPUT);
    pin_t pg = pinopen(LED_G, OUTPUT);
    pin_t pb = pinopen(LED_B, OUTPUT);

    if (pr.mode == UNDEF || pg.mode == UNDEF || pb.mode == UNDEF) {
        fprintf(stderr, "Eroare: pinopen() a esuat.\n");
        gpio_cleanup();
        return 1;
    }

    while (1) {
        rgb_set(1, 0, 0); sleep(1); /* rosu */
        rgb_set(0, 1, 0); sleep(1); /* verde */
        rgb_set(0, 0, 1); sleep(1); /* albastru */
        rgb_set(1, 1, 0); sleep(1); /* galben */
        rgb_set(1, 0, 1); sleep(1); /* magenta */
        rgb_set(0, 1, 1); sleep(1); /* cyan */
        rgb_set(1, 1, 1); sleep(1); /* alb aproximativ */
        rgb_set(0, 0, 0); sleep(1); /* stins */
    }

    pinclose(LED_R);
    pinclose(LED_G);
    pinclose(LED_B);
    gpio_cleanup();
    return 0;
}

Avantajele acestui mod

• cod foarte simplu,
• util pentru test electric rapid,
• suficient dacă ai nevoie doar de culori discrete.

Limitări

• nu poți controla luminozitatea pe fiecare canal,
• nu poți obține tranziții line,
• nu exploatezi cu adevărat avantajul RGB.

12. Exemplu C – KY-009 cu software PWM

Pentru a obține culori intermediare cu biblioteca GPIO_RPI5, poți implementa software PWM. Mai jos este o variantă simplă, clară și portabilă.

#include "gpio_rpi5.h"
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

#define LED_R GPIO17
#define LED_G GPIO27
#define LED_B GPIO22

static volatile int keep_running = 1;

static void on_sigint(int sig)
{
    (void)sig;
    keep_running = 0;
}

static void rgb_off(void)
{
    pinwrite(LED_R, LOW);
    pinwrite(LED_G, LOW);
    pinwrite(LED_B, LOW);
}

/*
 * duty: 0..100
 * duration_ms: cat timp sa mentina culoarea
 * period_us: perioada PWM
 */
static void rgb_pwm_soft(int duty_r, int duty_g, int duty_b, int duration_ms)
{
    const int period_us = 2000;   /* 500 Hz */
    const int slices = 100;
    const int slice_us = period_us / slices;
    int cycles = (duration_ms * 1000) / period_us;

    if (cycles < 1) {
        cycles = 1;
    }

    for (int c = 0; c < cycles && keep_running; ++c) {
        for (int s = 0; s < slices; ++s) {
            pinwrite(LED_R, (s < duty_r) ? HIGH : LOW);
            pinwrite(LED_G, (s < duty_g) ? HIGH : LOW);
            pinwrite(LED_B, (s < duty_b) ? HIGH : LOW);
            usleep(slice_us);
        }
    }
}

int main(void)
{
    signal(SIGINT, on_sigint);

    if (gpio_init() != 0) {
        fprintf(stderr, "Eroare: gpio_init() a esuat.\n");
        return 1;
    }

    pin_t pr = pinopen(LED_R, OUTPUT);
    pin_t pg = pinopen(LED_G, OUTPUT);
    pin_t pb = pinopen(LED_B, OUTPUT);

    if (pr.mode == UNDEF || pg.mode == UNDEF || pb.mode == UNDEF) {
        fprintf(stderr, "Eroare: pinopen() a esuat.\n");
        gpio_cleanup();
        return 1;
    }

    while (keep_running) {
        rgb_pwm_soft(100, 0,   0,   800);  /* rosu */
        rgb_pwm_soft(0,   100, 0,   800);  /* verde */
        rgb_pwm_soft(0,   0,   100, 800);  /* albastru */

        rgb_pwm_soft(100, 40,  0,   800);  /* portocaliu */
        rgb_pwm_soft(100, 100, 0,   800);  /* galben */
        rgb_pwm_soft(0,   100, 100, 800);  /* cyan */
        rgb_pwm_soft(100, 0,   100, 800);  /* magenta */
        rgb_pwm_soft(40,  100, 40,  800);  /* verde deschis */
        rgb_pwm_soft(100, 100, 100, 800);  /* alb aproximativ */
        rgb_pwm_soft(0,   0,   0,   400);  /* stins */
    }

    rgb_off();
    pinclose(LED_R);
    pinclose(LED_G);
    pinclose(LED_B);
    gpio_cleanup();
    return 0;
}

Ce trebuie înțeles aici?

Acest exemplu împarte fiecare perioadă PWM în 100 de pași. Pentru fiecare pas, fiecare canal este activ sau inactiv în funcție de duty-cycle. Astfel poți controla separat intensitatea roșului, verdelui și albastrului.

Dezavantajul software PWM

Software PWM ocupă procesorul și este sensibil la latențe de sistem. Pentru un demo educațional este perfect, dar pentru control foarte precis sau pentru mai multe canale simultane este preferabil hardware PWM.

13. Observație importantă despre PWM hardware

Biblioteca GPIO_RPI5 documentează și configurarea pinilor în funcții alternative. Asta înseamnă că poți trece unii pini pe funcții dedicate perifericelor hardware.

Pentru PWM hardware, pinii folositi sunt în mod uzual:

• GPIO12 – PWM0_CHAN0
• GPIO13 – PWM0_CHAN1

Acest lucru este util dacă vrei un control mai stabil pentru două canale. Totuși, pentru un LED RGB complet ai nevoie de trei canale. Din acest motiv, pentru un articol introductiv și pentru un exemplu 100% controlat din C cu API-ul de bază, varianta cu software PWM rămâne cea mai simplă de înțeles și de extins.

14. Când alegi KY-011 și când alegi KY-009?

Alege KY-011 dacă:

• vrei un indicator de stare simplu,
• vrei cod minim,
• vrei să înveți rapid controlul digital de bază,
• nu ai nevoie de multe culori.

Alege KY-009 dacă:

• vrei feedback vizual bogat,
• vrei să înveți RGB și PWM,
• vrei efecte de culoare,
• vrei un proiect demonstrativ mai interesant vizual.

15. Greșeli frecvente

• Conectarea LED-urilor fără rezistențe serie.
• Confuzia între numerotarea fizică a pinilor și numerotarea GPIO.
• Utilizarea backend-ului lent pentru aplicații care cer PWM software.
• Încercarea de a obține culori line pe KY-009 doar cu HIGH/LOW.
• Legarea accidentală la 5V a unor conexiuni care trebuie să rămână în domeniul GPIO de 3,3V.

16. Concluzie

KY-011 și KY-009 sunt module excelente pentru experimente cu Raspberry Pi 5. Dacă vrei simplitate și un indicator de stare clar, KY-011 este alegerea potrivită. Dacă vrei să mergi mai departe și să explorezi combinarea culorilor și PWM-ul, KY-009 este net mai interesant.

Folosind biblioteca GPIO_RPI5, poți controla ambele module foarte curat din C. Pentru KY-011 este suficient controlul digital clasic, iar pentru KY-009 poți începe cu combinații fixe și apoi trece la software PWM pentru efecte RGB reale.

Ca regulă practică: KY-011 pentru simplitate, KY-009 pentru flexibilitate.

Cod de test

• https://github.com/SimedruF/GPIO_RPI5