Een Arduino LED Mood Cube verbeteren (eenvoudig) (inclusief video): 4 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Na het zien van een LED-project met een kleine Mood Cube, gemaakt door 'earl, besloot ik een verbeterde versie van de LED Mood Cube te maken. Mijn versie zal complexer zijn dan de originele, omdat hij iets groter zal zijn dan de originele, twee kleuren meer zal hebben in vergelijking met de originele kubus (geel en wit toegevoegd), een oneindige hoeveelheid kleurenrotatie, enz. Dit zou een goed project moeten zijn om verder te oefenen met het gebruik van LED-verlichting voor degenen die het concept van het verbinden van LED-verlichting met draden begrepen.

Stap 1: Materialen

Hier zijn enkele materialen die je nodig hebt om deze Mood Cube te maken:

• Breadboard
• Arduino - (ik heb Leonardo hier)
• Arduino-voeding / USB-kabel
• Breadboard
• Jumper Wires (Veel van hen, ik gebruikte 29 draden)
• Rode LED x 2
• Blauwe LED x 2
• Groene LED x 2
• Gele LED x 2
• Witte LED x 1
• 9 weerstanden
• Doos groot genoeg voor het breadboard (ik gebruikte een schoenendoos)
• Gereedschapsmes
• Papier

Stap 2: Coderen

Enige uitleg voor de hier gegeven code:

Het krediet van de codes gaat naar de oorspronkelijke bron van mijn project, aangezien de redacteur van het project deze codes heeft gemaakt. Ik heb er slechts enkele verbeterd door ze complexer te maken. In sommige codes ziet u op het einde //改. Dit betekent dat deze code door mij is bewerkt, dus het is anders dan mijn oorspronkelijke bron.

Ik heb ook een versie van de code op Arduino Creator.

/* Code voor cross-fading 3 LED's, rood, groen en blauw (RGB) Om fades te creëren, moet u twee dingen doen: 1. Beschrijf de kleuren die u wilt weergeven 2. Geef een lijst van de volgorde waarin u ze wilt laten vervagen

EEN KLEUR BESCHRIJVEN:

Een kleur is slechts een reeks van drie percentages, 0-100, die de rode, groene en blauwe LED's aansturen

Rood is de rode LED op vol, blauw en groen uit

int rood = { 100, 0, 0 } Dim wit is alle drie de LED's bij 30% int dimWhite = {30, 30, 30} enz.

Hieronder vindt u enkele veelvoorkomende kleuren, of maak er zelf een

LIJST VAN DE BESTELLING:

In het hoofdgedeelte van het programma moet u de volgorde vermelden waarin u de kleuren wilt laten verschijnen, b.v. crossFade(rood); crossFade(groen); crossFade (blauw);

Die kleuren verschijnen in die volgorde en vervagen uit

de ene kleur en de andere

Daarnaast zijn er 5 optionele instellingen die u kunt aanpassen:

1. De beginkleur is ingesteld op zwart (zodat de eerste kleur vervaagt), maar u kunt de beginkleur op een andere kleur instellen 2. De interne lus loopt voor 1020 interacties; de variabele 'wait' stelt de geschatte duur van een enkele crossfade in. In theorie zou een 'wacht' van 10 ms een crossFade van ~10 seconden moeten opleveren. In de praktijk vertragen de andere functies die de code uitvoert dit tot ~11 seconden op mijn bord. YMMV. 3. Als 'repeat' op 0 staat, loopt het programma oneindig door. als het is ingesteld op een getal, zal het dat aantal keren herhalen en vervolgens stoppen bij de laatste kleur in de reeks. (Stel 'return' in op 1, en maak de laatste kleur zwart als je wilt dat deze aan het einde uitdooft.) 4. Er is een optionele 'hold'-variabele, die het programma voor 'hold' milliseconden pauzeert wanneer een kleur voltooid, maar voordat de volgende kleur begint. 5. Stel de DEBUG-vlag in op 1 als u wilt dat de foutopsporingsuitvoer naar de seriële monitor wordt verzonden.

De binnenkant van het programma is niet ingewikkeld, maar ze

zijn een beetje kieskeurig -- de innerlijke werking wordt uitgelegd onder de hoofdlus.

April 2007, Clay Shirky

*

/ Uitgang

int ylwPin = 5; // Gele LED, aangesloten op digitale pin 5 //改 int redPin = 6; // Rode LED, aangesloten op digitale pin 6 //改 int grnPin = 7; // Groene LED, aangesloten op digitale pin 7 //改 int bluPin = 8; // Blauwe LED, aangesloten op digitale pin 8 //改 int whiPin = 9; // Witte LED, aangesloten op digitale pin 9 //改 int ylwPin2 = 10; // Gele LED, aangesloten op digitale pin 10 //改 int redPin2 = 11; // Rode LED, aangesloten op digitale pin 11 //改 int grnPin2 = 12; // Groene LED, aangesloten op digitale pin 12 //改 int bluPin2 = 13; // Blauwe LED, aangesloten op digitale pin 13 //改

// Kleurarrays

int zwart [9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };//改 int wit [9] = { 100, 100, 100, 100, 100, 100, 100, 100, 100 };//改 int rood[9] = { 0, 0, 100, 0, 0, 0, 100, 0, 0 };//改 int groen[9] = { 0, 100, 0, 0, 0, 0, 0, 100, 0 };//改 int blauw[9] = { 0, 0, 0, 100, 0, 0, 0, 0, 100 };//改 int geel[9] = { 100, 0, 0, 0, 0, 100, 0, 0, 0 }; //改 int paars [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; //改 int oranje [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; //改 int roze [9] = { 0, 50, 0, 0, 50, 0, 0, 50, 0, }; //改 // enz.

// Initiële kleur instellen

int redVal = zwart[0]; int grnVal = zwart [1]; int bluVal = zwart[2]; int ylwVal = zwart [3]; //改 int whiVal = zwart [4]; //改

int wacht = 15; // 10ms interne crossFade-vertraging; verhogen voor langzamere fades //改

int vasthouden = 1; // Optioneel vasthouden wanneer een kleur voltooid is, voor de volgende crossFade //改 int DEBUG = 1; // DEBUG-teller; indien ingesteld op 1, zal waarden terugschrijven via seriële int loopCount = 60; // Hoe vaak moet DEBUG rapporteren? int herhalen = 0; // Hoe vaak moeten we een lus maken voordat we stoppen? (0 voor geen stop) //改 int j = 0; // Lusteller voor herhaling

// Initialiseer kleurvariabelen

int prevR = redVal; int prevG = grnVal; int prevB = bluVal; int prevY = ylwVal; int prevW = whiVal; //改

// Stel de LED-uitgangen in

void setup () { pinMode (redPin, OUTPUT); // stelt de pinnen in als output pinMode (grnPin, OUTPUT); pinMode (bluPin, UITGANG); pinMode(ylwPin, UITGANG); //改 pinMode (whiPin, OUTPUT); //改 pinMode (grnPin2, UITGANG); //改 pinMode (bluPin2, UITGANG); //改 pinMode (ylwPin2, OUTPUT); //改 pinMode (redPin2, OUTPUT); //改

if (DEBUG) { // Als we waarden voor foutopsporing willen zien…

Serieel.begin(9600); // … stel de seriële uitgang in } }

// Hoofdprogramma: geef de volgorde van crossfades weer

void loop() { crossFade(rood); crossFade(groen); crossFade (blauw); crossFade (geel); crossFade (wit); crossFade (roze); crossFade (paars); crossFade (oranje);

if (repeat) { // Doen we een eindig aantal keren in een lus?

j += 1; if (j >= repeat) { // Zijn we er al? uitgang(j); // Zo ja, stop. } } }

/* ONDER DEZE REGEL IS DE WISKUNDE -- JE MOET DIT NIET VERANDEREN VOOR DE BASIS

Het programma werkt als volgt:

Stel je een crossfade voor die de rode LED in tien stappen van 0-10, de groene van 0-5 en de blauwe van 10 naar 7 verplaatst. We willen de 10 stappen tellen en de kleurwaarden in gelijkmatig getrapte stappen verhogen of verlagen. Stel je voor dat een + aangeeft dat je een waarde met 1 verhoogt en dat een - gelijk is aan het verlagen ervan. Onze 10-staps fade zou er als volgt uitzien:

1 2 3 4 5 6 7 8 9 10

R + + + + + + + + + + G + + + + + B - - -

Het rood gaat in tien stappen van 0 naar 10, het groen van

0-5 in 5 stappen, en de blauwe zakt van 10 naar 7 in drie stappen.

In het echte programma worden de kleurpercentages omgezet naar

0-255 waarden, en er zijn 1020 stappen (255*4).

Om erachter te komen hoe groot een stap moet zijn tussen een op- of

door een van de LED-waarden omlaag te vinken, noemen we calculatorStep(), die de absolute kloof tussen de begin- en eindwaarden berekent en die kloof vervolgens deelt door 1020 om de grootte van de stap tussen aanpassingen in de waarde te bepalen. */

int berekenStep (int prevValue, int endValue) {

int stap = endValue - prevValue; // Wat is de algemene kloof? if (step) { // Als het niet nul is, step = 1020 / step; // delen door 1020 } stap terug; }

/* De volgende functie is berekenVal. Wanneer de luswaarde, i, de stapgrootte bereikt die geschikt is voor een van de kleuren, wordt de waarde van die kleur met 1 verhoogd of verlaagd. (R, G en B worden elk afzonderlijk berekend.) */

int berekenWaarde(int stap, int val, int i) {

if ((step) && i % step == 0) { // Als step niet nul is en het tijd is om een waarde te veranderen, if (stap > 0) { // verhoog de waarde als stap positief is… val += 1; } else if (stap 255) { val = 255; } else if (val < 0) { val = 0; } retourwaarde; }

/* crossFade() converteert het percentage kleuren naar a

0-255 bereik, loopt vervolgens 1020 keer door, controleert of de waarde elke keer moet worden bijgewerkt en schrijft vervolgens de kleurwaarden naar de juiste pinnen. */

void crossFade (int kleur ) { //改

// Converteren naar 0-255 int R = (kleur [0] * 255) / 100; int G = (kleur [1] * 255) / 100; int B = (kleur [2] * 255) / 100; int Y = (kleur [3] * 255) / 100; //改 int W = (kleur [4] * 255) / 100; //改

int stepR = berekenStep(prevR, R);

int stepG = berekenStep(prevG, G); int stepB = berekenStep(prevB, B); int stapY = berekenStep(vorigeY, Y); //改 int stepW = berekenStep (prevW, W); //改

for (int i = 0; i <= 1020; i++) { redVal = berekenVal(stepR, redVal, i); grnVal = berekenVal(stapG, grnVal, i); bluVal = berekenVal(stapB, bluVal, i); ylwVal = berekenVal(stapY, ylwVal, i); //改 whiVal = berekenVal (stapW, whiVal, i); //改

analogWrite(redPin, redVal); // Schrijf huidige waarden naar LED-pinnen

analogWrite(grnPin, grnVal); analogWrite(bluPin, bluVal); analogWrite(ylwPin, ylwVal); //改 analogWrite (whiPin, whiVal); //改 analogWrite (grnPin2, grnVal); //改 analogWrite (bluPin2, bluVal); //改 analogWrite(ylwPin2, ylwVal); //改 analogWrite (redPin2, redVal); //改

vertraging (wacht); // Pauzeer milliseconden 'wacht' voordat je de lus hervat

if (DEBUG) { // Als we seriële uitvoer willen, print het dan op de

if (i == 0 of i % loopCount == 0) { // begin, en elke loopCount keer Serial.print ("Loop/RGBYW: #"); Serial.print(i); Serieel.print(" | "); Serial.print(redVal); Serieel.print(" / "); Serial.print(grnVal); Serieel.print(" / "); Serial.println(bluVal); Serieel.print(" / "); Serial.println(ylwVal); //改 Serial.print(" / "); //改 Serial.println(whiVal); //改 Serial.print(" / "); //改 } DEBUG += 1; } } // Update huidige waarden voor volgende lus prevR = redVal; prevG = grnVal; prevB = blauw; prevY = ylwVal; //改 prevW = whiVal; //改 vertraging (vasthouden); // Pauzeer voor optionele 'wacht' milliseconden voordat de lus wordt hervat}

Stap 3: Instellen

1. Pak het breadboard.

2. Demo van aansluitdraden zodat een LED lampje kan schijnen:

   1. Plaats de LED op het breadboard. Plaats het langere uiteinde aan de linkerkant en het kortere uiteinde aan de rechterkant.
   2. Plaats het ene uiteinde van een jumperdraad op een plek die zich op dezelfde rij bevindt als het langere uiteinde van de LED. Plaats het andere uiteinde op het digitale PWM-gedeelte. De code specificeerde de gele LED's die moesten worden aangesloten op 10 en 5, rode op 6 en 11, blauwe op 8 en 13, groene op 7 en 12, en tenslotte witte LED op 9.
   3. Plaats het ene uiteinde van een weerstand op dezelfde rij met het kortere uiteinde van de LED. Plaats het andere uiteinde ergens in de buurt.
   4. Plaats een uiteinde van een andere jumperdraad met dezelfde rij met het uiteinde van de weerstand dat niet op dezelfde rij staat met het kortere uiteinde van de LED. Plaats het andere uiteinde van de draad op de rij met negatieve ladingen.
   5. Plaats een uiteinde van nog een andere jumperdraad op de negatieve ladingsrij en plaats het andere uiteinde op GND.
3. Herhaal stap 2 voor 8 keer als je wilt dat 9 LED's schijnen

4. Plaats het breadboard in de doos. Een paar herinneringen hier:

   1. Ik heb een voeding gebruikt. Maak een klein gaatje voor uw draden met behulp van een mes om door de doos te gaan en verbinding te maken met het breadboard.
   2. Zorg ervoor dat de doos als een kant open is. Een schoenendoos heeft al een kant die open is. Als de doos volledig gesloten is, knip dan een kant van de doos af om een open ruimte te maken.
   3. Bedek de zijkant met niets met papier. Dit is om LED-lampjes door papier te laten schijnen.