[ARDUINO] Fading ledstrip

Een vriend van me vroeg mij of ik een RGB LEDstrip kon programmeren zodat die bij een druk op de knop langzaam naar een bepaalde kleur zou gaan. Met een kleine LEDstrip ben ik begonnen.

Voor dit project heb ik een Arduino Pro Micro gebruikt. Deze heb ik zo geprogrammeerd dat LEDs over een periode van een aantal seconden langzaam overgaan in een andere kleur. Omdat de LEDjes die in de LEDstrip zitten alleen maar aan of uit kunnen, moet je gebruikmaken van persistence of vision: als een LEDje op een bepaalde snelheid knippert, lijkt het niet alsof het knippert, maar alsof het licht gedimd is. De PWM-pin (Pulse Width Modulation) van de Pro Micro zorgt ervoor dat de LEDjes heel snel achter elkaar aan en uit worden geschakeld.

Benodigdheden:

• Breadboard
• Jump wires (male to female)
• Push button
• Arduino pro micro
• 1K Ohm weerstandjes
• 10K Ohm weerstandje
• NPN Transistors
• Ledstrip RGB 5 meter 60 leds per meter
• 12v adapter
• 12v adapter connector

 

 

Aansluiten

Van de Arduino Pro Micro gebruiken we pin 3, 5 en 6 (de PWM-pinnen) voor de aansturing van de LEDstrip. Pin 3 voor de rode led, 5 voor de groene led en 6 voor de blauwe led. Deze verbinden we via een 1 kOhm weerstand met base (middelste pootje) van de transistor. Sluit de collectors (rechter pootje) van de transistors aan op de ground, en sluit de emitters (linker pootje) van de transistors aan op de desbetreffende RGB-led. Sluit de GND pin van de Pro Micro aan op GND. Sluit vervolgens een push button aan volgens het schema. De pootjes staan zodanig dat die maar op 2 manieren past. Het maakt niet uit hoe je de push button plaatst. Verbind het pootje rechtsboven met pin A3. Verbind het pootje linksonder met VCC. Verbind het pootje rechtsonder via een 10k Ohm weerstand met GND. Sluit tot slot de 12v adapter aan via de connector. Sluit de + aan op de rode lijn van de breadboard, sluit de - aan op de zwarte lijn van de breadboard.

Code

const int pinRed = 3;
const int pinGreen = 5;
const int pinBlue = 6;
const int pushButton = 21; // A3

// waardes waarmee de led begint zodra de functie aangeroepen wordt (0 = uit, 255 = hoogste waarde)

// formaat: { rood, groen, blauw }
byte rgbMatrix[7][3] = {
  
    { 0, 0, 0 },
    { 255, 0, 0 },
    { 255, 255, 0 },
    { 0, 255, 255 },
    { 255, 255, 255 },
    { 0, 0, 255 },
    { 0, 0, 0 }
}; // 

// aantal stappen om van start naar end te gaan
const int steps = 255;

// aantal seconden om van start naar end te gaan (milliseconden)
const int timer = 5000;

// zorg ervoor dat de functie FadeColor alleen wordt aangeroepen op als de ledjes hun eindwaarde hebben bereikt
boolean state = false;

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

  pinMode(pinRed, OUTPUT);
  pinMode(pinGreen, OUTPUT);
  pinMode(pinBlue, OUTPUT); // de RGB pinnen moeten als output worden gemarkeerd, zodat er een hoog (5v) en laag (0v) signaal naartoe gestuurd kan worden
  
  pinMode(pushButton, INPUT);  
  
  analogWrite(pinRed, rgbMatrix[0][0]);
  analogWrite(pinGreen, rgbMatrix[0][1]);
  analogWrite(pinBlue, rgbMatrix[0][2]); // schrijf de allereerste waarde uit het rgbMatrix naar de pinnen.
}

void loop() {
  while (state == false){ // als de LED strip bezig is met faden, zal niet worden gereageerd op de push button
    while (digitalRead(pushButton) == HIGH){
      state = true;
      fadeColor();
      digitalWrite(pushButton, LOW);
    }
  }
}

void fadeColor(){
  int startRed, startGreen, startBlue, endRed, endGreen, endBlue;
  analogWrite(pinRed, 0);
  analogWrite(pinGreen, 0);
  analogWrite(pinBlue, 0); // alle pinnen worden uitgeschakeld, voordat wordt begonnen met het faden
  int r, g, b;
  for (int k = 1; k < 7; k++){
    int prevKey = k - 1;
    startRed = rgbMatrix[prevKey][0];
    startGreen = rgbMatrix[prevKey][1];
    startBlue = rgbMatrix[prevKey][2];

    endRed = rgbMatrix[k][0];
    endGreen = rgbMatrix[k][1];
    endBlue = rgbMatrix[k][2];
    for (int i = 0; i <= steps; i++){
    
      r = startRed + round((endRed - startRed) / steps * i);
      g = startGreen + round((endGreen - startGreen) / steps * i);
      b = startBlue + round((endBlue - startBlue) / steps * i); // het verschil tussen twee stappen wordt berekend, en toegevoegd aan de waarde van de vorige kleur
      analogWrite(pinRed, r);
      analogWrite(pinGreen, g);
      analogWrite(pinBlue, b);
  
      delay(round(timer / steps)); // het aantal stappen en de tijd bepalen hoelang er moet worden gewacht
      Serial.print((int)i);
    }
  }
  state = false;
}

										

Resultaat

Als alles gelukt is, zou het er ongeveer zo uit moeten zien: