Kreativa diorama belysning med Arduino och TLC5940 (5 / 11 steg)

Steg 5: Skriva koden

Först måste du TLC5940 Aduino bibliotek. Installationen instruktionerna är föråldrade. Ladda ner biblioteket och packa upp i en temporär katalog. Sedan öppna Arduino redaktör och gå till skiss -> Importera bibliotek och lägga till biblioteket. Redaktören kommer att göra resten.

Redigera filen tlc_config.h för att ändra antalet TLC5940 du använder. Detta projekt går dig TLCs så raden läser

#define NUM_TLCS 3

Koden är ganska enkelt härifrån och kommenteras. Jag har några kommentarer i slutet också.

LEDController.ino

#include "Arduino.h"
#include < Tlc5940.h >
#include < tlc_config.h >
#include "LedController.h"

Rot-lista för alla lysdioder
Lista * lightList = NULL;
olika värden för att söka igenom RGBs
int rgbIndex = 0;
int rgbLastStart = 0;
booleska firstRGBIndex;
int maxRGB = 252;

Praktiskt för steping genom alla lampor
Varje LED blinkar, som hjälper hitta saknade eller felaktiga anslutningar
void diag()
{
för (uint8_t x = 0, x < 40, x ++)
{
om (x > 0)
{
TLC.set(x-1,0);
}
TLC.set(x,1000);
While(TLC.Update());
Delay(500);
}
}

/*
Pausa i 5 sekunder så att du kan dra upp
alla diagnostiska du kan behöva.
Initiera TLC kedjan.
Skapa en komplett ljus
*/
void setup()
{
Delay(5000);
TLC.init();
TLC.Clear();
lightList = createList();

addNode (lightList, createRGBCluster1());
addNode (lightList, createLEDCluster1a());
addNode (lightList, createLEDCluster2());
}

/*
Increment RGB-värdet så att den sakta rör sig genom
listan över färgövergångar.
Hålla aktuell tid så du vet när du ska sätta på och stänga lampor.
Kör igenom listan.
*/
void loop()
{

diag();
rgbIndex = rgbLastStart + 1.
firstRGBIndex = sant;
lång tid = millis();
iterateList(time,lightList);

/*
Uppdateringen är klar asynkront på TLC: s.
Du måste vänta tills allt uppdateras eller dina lampor kommer
Visa felaktiga värden.
*/
While(TLC.Update());
}

/ * Enda länklista.
De flesta av följande funktioner skapa en nod av någon typ
och koppla den till slutet av en lista. Detta system skapas en lista över listor för varje
Lysdioder. Här exponeras något minne utmaning som listan är använda några
statiskt tilldelade värden och aktier några av dessa värden. Pekare
ha skulle varit ett klokare val.
*/
Lista * createList(void)
{
Lista * lista = (List*)malloc(sizeof(List));
listan -> huvud = NULL;
listan -> svans = NULL;
returnera lista;
}

Lista * addNode (lista * listan, nod-nod)
{
om (lista! = NULL & & nod! = NULL)
{
om (listan -> huvud == NULL)
{
listan -> huvud = nod;
listan -> svans = lista -> huvud;
} annat {
listan -> svans -> nästa = nod;
listan -> svans = nod;
}
}
}
Nod * createNode (NodeType typ, uint8_t pin)
{
Nod * resultatet = (Node*)malloc(sizeof(Node));
resultat -> nästa = NULL;
resultat -> Skriv = typ;

Switch(Type)
{
fall lista:
resultat -> värde = createList();
bryta;
fall LED_RGB:
resultat -> värde = createRGB(pin);
bryta;
fall LED_NORMAL:
resultat -> värde = createLED(pin);
bryta;
}
returnera resultat;
}

Nod * createRGBNode (lista * lista, uint8_t pin, Runtimes runtimes, RGB * useSettings)
{
Nod * resultat = createNode (LED_RGB, pin);
RGB * rgb = (RGB *) resultat -> värde;
configureRGB (rgb, runtimes, useSettings);
addNode (lista, resultat);
returnera resultat;
}

void configureRGB (RGB * rgb, Runtimes runtimes, RGB * useSettings)
{
om (useSettings! = NULL)
{
RGB -> useSettings = useSettings;
RGB -> färg = useSettings -> färg;
RGB -> runtimes = useSettings -> runtimes;
} annat
{
RGB -> runtimes = runtimes;
}
}

RGB * createRGB (uint8_t stift)
{
RGB * resultatet = (RGB*)malloc(sizeof(RGB));
resultat -> pin = pin;
resultat -> color.r = 0;
resultat -> color.g = 0;
resultat -> color.b = 0;
resultat -> useSettings = NULL;
returnera resultat;
}

Nod * createLEDNode (lista * lista uint8_t pin, Runtimes runtimes, uint8_t nivå)
{
Nod * resultat = createNode (LED_NORMAL, pin);
LED * ledde = (LED *) resultat -> värde;
LED -> nivå = nivå.
LED -> runtimes = runtimes;
addNode (lista, resultat);
returnera resultat;
}

LED * createLED (uint8_t stift)
{
LED * resultatet = (LED*)malloc(sizeof(LED));
resultat -> pin = pin;
resultat -> nivå = 0;
resultat -> runtimes.startTime=0;
resultat -> runtimes.runTime=0;
resultat -> runtimes.on=false;
returnera resultat;
}

void setRGBLed(RGB *led)
{
TLC.set (ledde -> pin, ledde -> color.r);
TLC.set (ledde -> pin + 1, ledde -> color.g);
TLC.set (ledde -> pin + 2, ledde -> color.b);
}

/*
gå igenom listan och bestämma den korrekta
sätt att utföra varje nod.
*/
void iterateList (lång tid, lista * lista)
{
om (lista! = NULL)
{
Nod-nod = lista -> huvud;
medan (nod! = NULL)
{
executeNode (tid, nod);
nod = nod -> nästa;
}
}
}

void executeNode (lång tid, nod-nod)
{
om (nod! = NULL)
{
Växla (nod -> typ)
{
fall lista:
iterateList (tid, (lista *) nod -> värde);
bryta;
fall LED_RGB:
setRGB (time,(RGB*) nod -> värde);
bryta;
fall LED_NORMAL:
setLED (time,(LED*) nod -> värde);
bryta;
standard:
TLC.set(1,200);
TLC.Update();
bryta;
}
} annat {
}
}

/*
Hemsk fusk pågår här.
Det finns bara en RGB lista så ska vi hålla några extra stat
och tillämpa den på bara rgb listan. BLECH.
Dock går denna matris mycket snabbare genom att söka igenom förberäknade
värden än att försöka beräkna och Visa dessa värden.
*/
void setRGB (lång tid, RGB * rgb)
{
om (rgb! = NULL)
{
booleska cykel = tid > rgb -> runtimes.startTime + rgb -> runtimes.wait;
om (cyklar)
{
om (rgb -> useSettings! = NULL)
{
RGB -> färg = rgb - > useSettings -> färg;
RGB -> runtimes = rgb - > useSettings -> runtimes;
} annat
{
om (firstRGBIndex)
{
firstRGBIndex = false;
rgbLastStart ++;
om (rgbLastStart > maxRGB)
{
rgbLastStart = 0;
}

rgbIndex = rgbLastStart;
}
RGB -> färg = rgbPattern [rgbIndex ++];

om (rgbIndex > maxRGB)
{
rgbIndex = 0;
}

}
RGB -> runtimes.startTime = tid;
}
setRGBLed(rgb);

}
}

void setLED (lång tid, LED * ledde)
{
om (ledde! = NULL)
{
lång execWindow = ledde -> runtimes.startTime + ledde -> runtimes.runTime;
om (ledde -> runtimes.runTime == -1 || (tid > ledde -> runtimes.startTime & & tid < execWindow))
{
LED -> runtimes.on = sant;
TLC.set (ledde -> pin, ledde -> nivå);
} else om (tid > execWindow & & led -> runtimes.on == true) {
LED -> runtimes.startTime = tid + ledde -> runtimes.wait;
LED -> runtimes.on = false;
TLC.set (ledde -> pin, 0);
}
}
}

/*
De olika LED array fabrik metoderna
*/
Nod * createRGBCluster1(void)
{
int jag = 0;
int vänta = 50;
Runtimes rt = (Runtimes) {0, 0, vänta, false};

Nod * rgbList = createNode (lista, 0);
Lista * rgbCluster1 = (lista *) rgbList -> värde;
Nod * en = createRGBNode (rgbCluster1, i, rt, NULL);
Nod * b = createRGBNode (rgbCluster1, jag += 3, rt, NULL);
Nod * c = createRGBNode (rgbCluster1, jag += 3, rt, NULL);
Nod * d = createRGBNode (rgbCluster1, jag += 3, rt, NULL);
Nod * e = createRGBNode (rgbCluster1, jag += 3, rt, NULL);

Låt dem dela värderingar som skapar ett slags coola
fontänen effekt.
createRGBNode (rgbCluster1, jag += 3, rt, (RGB *) e -> värde);
createRGBNode (rgbCluster1, jag += 3, rt, (RGB *) d -> värde);
createRGBNode (rgbCluster1, jag += 3, rt, (RGB *) c -> värde);
createRGBNode (rgbCluster1, jag += 3, rt, (RGB *) b -> värde);
createRGBNode (rgbCluster1, jag += 3, rt, (RGB *) ett-> värde);

återvända rgbList;
}

Nod * createLEDCluster1a(void)
{
int jag = 30.
Nod * ledList = createNode (lista, 0);
Lista * ledCluster = (lista *) ledList -> värde;
createLEDNode (ledCluster, i ++, (Runtimes) {-1, -1, -1, sant}, 300);
createLEDNode (ledCluster, i ++, (Runtimes) {-1, -1, -1, sant}, 300);
createLEDNode (ledCluster, i ++, (Runtimes) {-1, -1, -1, sant}, 300);
createLEDNode (ledCluster, i ++, (Runtimes) {-1, -1, -1, sant}, 300);
createLEDNode (ledCluster, i ++, (Runtimes) {-1, -1, -1, sant}, 300);
createLEDNode (ledCluster, i ++, (Runtimes) {-1, -1, -1, sant}, 300);
returnera ledList;
}

Nod * createLEDCluster2(void)
{
int jag = 36.

Nod * ledList = createNode (lista, 0);
Lista * ledCluster = (lista *) ledList -> värde;
createLEDNode (ledCluster, i ++, (Runtimes) {10000, 30000, 25000, sant}, 3000);
createLEDNode (ledCluster, i ++, (Runtimes) {10000, 30000, 25000, sant}, 3000);
createLEDNode (ledCluster, i ++, (Runtimes) {3000, 90000, 45000, sant}, 3000);
createLEDNode (ledCluster, i ++, (Runtimes) {3000, 90000, 45000, sant}, 3000);

returnera ledList;
}

/*
Detta är några gamla kod som gjorde sinusvåg beräkningen.
Det fungerar men är mycket långsam. Jag skrev en del kod för att fånga värdena
och skriva dem ut seriekonsoll istället och sedan kopieras värdena
i sidhuvudet

void setRGBFreq (RGB * led, uint8_t i, uint8_t max)
{
flyta frekvens =. 3;
LED -> r = sin(frequency*(i) + 0) * 127 + 128;
LED -> g = sin(frequency*(i) + 2) * 127 + 128;
LED -> b = sin(frequency*(i) + 4) * 127 + 128;

uint8_t totala = ledde -> r + ledde -> g + ledde -> b;
om (totalt > max)
{
LED -> r-= ledde -> r/total * 100,0;
LED -> g-= ledde -> g/total * 100,0;
LED -> b-= ledde -> b/total * 100,0;
}
printList(led);
}*/

LEDController.h

< code >
#ifndef LEDController
#define LEDController

#define RGB_LEDS 10

TypeDef fasttexttypen {lista, LED_RGB, LED_NORMAL} NodeType;

TypeDef struct
{
lång starttid;
lång körning;
lång väntan;
boolean på;
} Runtimes;

TypeDef struct
{
uint8_t r;
uint8_t g;
uint8_t b;
} Färger;

TypeDef struct rgb {
Färger color.
uint8_t pin;
Runtimes runtimes;
struct rgb * useSettings;
} RGB;

TypeDef struct {
uint8_t pin;
uint8_t nivå.
Runtimes runtimes;
} LED;

TypeDef struct nod {
NodeType typ;
void * värde;
struct nod * nästa;
} Noden;

TypeDef struct {nod * huvud;
Nod * svans.
} Lista;

statisk färger rgbPattern [] = {
{128, 243, 31}, {165, 222, 11}, {199, 193, 1}, {227, 158, 3},
{246, 120, 15}, {254, 83, 38}, {251, 50, 68}, {237, 24, 104},
{213, 7, 142}, {182, 1, 179}, {145, 6, 211}, {107, 22, 236},
{71, 47, 250}, {40, 80, 254}, {17, 117, 247}, {3, 155, 229},
{1, 190, 202}, {10, 220, 168}, {29, 242, 131}, {58, 253, 93},
{92, 253, 58}, {130, 242, 30}, {167, 221, 10}, {201, 191, 1},
{228, 156, 3}, {247, 118, 16}, {254, 81, 39}, {251, 48, 70},
{236, 22, 106}, {212, 6, 144}, {180, 1, 181}, {143, 6, 213},
{105, 23, 237}, {69, 49, 251}, {39, 82, 254}, {16, 119, 246},
{3, 157, 228}, {1, 192, 200}, {11, 222, 166}, {31, 243, 129},
{59, 253, 91}, {94, 253, 57}, {132, 241, 29}, {169, 219, 10},
{203, 189, 1}, {230, 154, 4}, {247, 116, 17}, {254, 79, 41},
{250, 46, 72}, {235, 21, 109}, {210, 5, 147}, {178, 1, 183},
{141, 7, 214}, {103, 24, 238}, {68, 51, 251}, {37, 84, 254},
{15, 121, 245}, {3, 159, 226}, {1, 194, 198}, {12, 223, 164},
{32, 243, 126}, {61, 254, 89}, {96, 252, 55}, {134, 240, 27},
{171, 218, 9}, {204, 187, 1}, {231, 152, 4}, {248, 114, 18},
{254, 77, 43}, {250, 45, 74}, {234, 20, 111}, {208, 5, 149},
{176, 1, 185}, {139, 8, 216}, {101, 25, 239}, {66, 52, 252},
{36, 86, 254}, {14, 123, 245}, {2, 161, 225}, {2, 196 196},
{12, 224, 162}, {34, 244, 124}, {63, 254, 87}, {98, 252, 53},
{136, 239, 26}, {173, 216, 8}, {206, 186, 1}, {232, 150, 5},
{249, 112, 20}, {254, 75, 44}, {249, 43, 76}, {233, 19, 113},
{207, 4, 151}, {174, 1, 187}, {137, 8, 217}, {99, 27, 240},
{64, 54, 252}, {34, 88, 254}, {13, 125, 244}, {2, 163, 224},
{2, 198, 195}, {13, 226, 160}, {35, 245, 122}, {65, 254, 85},
{100, 252, 51}, {138, 238, 25}, {175, 215, 7}, {208, 184, 1},
{233, 147, 5}, {249, 109, 21}, {254, 73, 46}, {248, 42, 78},
{231, 18, 115}, {205, 4, 153}, {172, 1, 188}, {135, 9, 219},
{97, 28, 241}, {62, 56, 253}, {33, 90, 253}, {12, 128, 243},
{2, 165, 222}, {2, 199, 193}, {14, 227, 158}, {36, 246, 120},
{67, 254, 83}, {102, 251, 50}, {140, 237, 24}, {177, 213, 7},
{128, 243, 31}, {165, 222, 11}, {199, 193, 1}, {227, 158, 3},
{246, 120, 15}, {254, 83, 38}, {251, 50, 68}, {237, 24, 104},
{213, 7, 142}, {182, 1, 179}, {145, 6, 211}, {107, 22, 236},
{71, 47, 250}, {40, 80, 254}, {17, 117, 247}, {3, 155, 229},
{1, 190, 202}, {10, 220, 168}, {29, 242, 131}, {58, 253, 93},
{92, 253, 58}, {130, 242, 30}, {167, 221, 10}, {201, 191, 1},
{228, 156, 3}, {247, 118, 16}, {254, 81, 39}, {251, 48, 70},
{236, 22, 106}, {212, 6, 144}, {180, 1, 181}, {143, 6, 213},
{105, 23, 237}, {69, 49, 251}, {39, 82, 254}, {16, 119, 246},
{3, 157, 228}, {1, 192, 200}, {11, 222, 166}, {31, 243, 129},
{59, 253, 91}, {94, 253, 57}, {132, 241, 29}, {169, 219, 10},
{203, 189, 1}, {230, 154, 4}, {247, 116, 17}, {254, 79, 41},
{250, 46, 72}, {235, 21, 109}, {210, 5, 147}, {178, 1, 183},
{141, 7, 214}, {103, 24, 238}, {68, 51, 251}, {37, 84, 254},
{15, 121, 245}, {3, 159, 226}, {1, 194, 198}, {12, 223, 164},
{32, 243, 126}, {61, 254, 89}, {96, 252, 55}, {134, 240, 27},
{171, 218, 9}, {204, 187, 1}, {231, 152, 4}, {248, 114, 18},
{254, 77, 43}, {250, 45, 74}, {234, 20, 111}, {208, 5, 149},
{176, 1, 185}, {139, 8, 216}, {101, 25, 239}, {66, 52, 252},
{36, 86, 254}, {14, 123, 245}, {2, 161, 225}, {2, 196 196},
{12, 224, 162}, {34, 244, 124}, {63, 254, 87}, {98, 252, 53},
{136, 239, 26}, {173, 216, 8}, {206, 186, 1}, {232, 150, 5},
{249, 112, 20}, {254, 75, 44}, {249, 43, 76}, {233, 19, 113},
{207, 4, 151}, {174, 1, 187}, {137, 8, 217}, {99, 27, 240},
{64, 54, 252}, {34, 88, 254}, {13, 125, 244}, {2, 163, 224},
{2, 198, 195}, {13, 226, 160}, {35, 245, 122}, {65, 254, 85},
{100, 252, 51}, {138, 238, 25}, {175, 215, 7}, {208, 184, 1},
{233, 147, 5}, {249, 109, 21}, {254, 73, 46}, {248, 42, 78},
{231, 18, 115}, {205, 4, 153}, {172, 1, 188}, {135, 9, 219},
{97, 28, 241}, {62, 56, 253}, {33, 90, 253}, {12, 128, 243},
{2, 165, 222}, {2, 199, 193}, {14, 227, 158}, {36, 246, 120},
{67, 254, 83}, {102, 251, 50}, {140, 237, 24}, {177, 213, 7}
};

Dubbel länkad-lista grundfunktionerna för lysdioder
Lista * createList(void);
Lista * addNode (lista * listan, nod-nod);
Nod * createNode (NodeType typ, uint8_t pin);
RGB * createRGB (uint8_t pin);
LED * createLED (uint8_t pin);
Nod * createRGB (lista * lista, uint8_t pin, Runtimes runtimes, RGB * useSettings);
Nod * createLEDNode (uint8_t pin, Runtimes runTimes, uint8_t nivå);

void iterateList (lång tid, lista * listan);
void setRGBLED (lång tid, RGB * ledde);
void setLED (länge, LED * ledde);

Klustret fabriker
Nod * createRGBCluster1(void);
Nod * createRGBCluster1a(void);
Nod * createLEDCluster2(void);

void configureRGB (RGB * rgb, Runtimes runtimes, RGB * useSettings);

#endif

Koden använder en flera enda länkade listor för att hantera alla lampor, deras färger, ljusstyrka, varaktigheter och andra inställningar. Använda en länkad lista var ett misstag och jag skulle hantera minne på ett annat sätt. Varför? Den statiskt tilldelade rgbPattern använder mycket minne, men alla minne är sammanhängande. De länkade listorna är inte sammanhängande av avsikt, snarare av en tillfällighet. Resultatet är att man kan ha små block av minne som har tilldelats för varje nod i listan. Allokeraren kommer ta tag i det första blocket minne som noden kan passa i. Detta resulterar i allokeraren lämna liten minne luckor mellan listor och noder. Dessa brister ofta inte är användbara och programmet kan inte längre allokera den maximala mängden minne.

Kör slut på minne är lite udda: Arduino omstarter. Du vänta flera sekunder och sedan titta på det pånyttfödd igen, och igen, och du får idén. Jag skrev en snabb funktion, inte ingår i den kod, som skulle skriva ett antal bitar med ett set till en PIN-kod till ge mig en idé hur långt programmet fick. Jag kopplade upp ett oscilloskop till stift och såg bitarna. Att veta att jag omstart var det första sticket. Pin författaren skrev sex bitar inuti setup() funktionen och sedan skulle skriva fem bitarna i funktionen loop(). De fem bitarna var aldrig visas. Bara sex bitar varje 15 sekunder.

Det var då bara en fråga om spela runt med några saker. Jag fick reda på att kommentera bort en byggnads värde av lysdioder låta framsteg som ansökan till loop() och fortsätta att köras. Jag minskat antalet färger i rgbPattern cyklade igenom och då uncommented byggnaden. Programmet körde normalt igen.

Varje färg objekt är bara 24 byte, men det finns 64 rader med 4 färgobjekt varje. Lite mer än 6k tillbringade på färg rotation.

Nästa sak skulle ha varit att fördela en enkel matris för alla noder. Sedan skulle det ha varit en packad minnesblock för alla lampor och frigörs mycket mer minne för resten av app.

Lösningen som är mest sannolikt att arbeta för ett större nätverk av lysdioder är dock en större styrelse med mer minne. En Mega skulle enkelt hantera ett stort antal byggnader.