Enorma led Mood light (8 / 8 steg)

Steg 8: programvara

* LED Driver

byte columnPins [] = {2,3,4,6,7,8,11,12,13}. anslutningar för matrix colums
byte levelPins [] = {5,9,10}. anslutningar av matrix nivåer

initierar LED driver (anger pin lägen och släcks alla lysdioder)
void ledInit() {
för (byte jag = 0; jag < 9; i ++) {
pinMode (columnPins [i], produktionen);
digitalWrite (columnPins [i], låg);
}
för (byte jag = 0; jag < 3; i ++) {
pinMode (levelPins [i], produktionen);
digitalWrite (levelPins [i], hög);
}
}

slå på enda lysdioder
orsakar andra lysdioder till ljus upp om föraren inte är i initierade staten
(du kan inte ta alla 27 lampor med bara 12 stift i taget)
{Ogiltig ledOn (byte kolumn, byte nivå)
digitalWrite (columnPins [kolumn], hög);
digitalWrite (levelPins [nivå], låg);
}

samma som ledOn
void ledOff (byte kolumn, byte nivå) {
digitalWrite (columnPins [kolumn], låg);
digitalWrite (levelPins [nivå], hög);
}

/********************************************************************************
* Grundläggande Drawing API (voxel buffert, cartesian koordinerat system, etc.)
********************************************************************************/

byte buffert [27]. Voxel buffert

drar voxel bufferten (ignorera stödnivåer)
varje voxel > 1 blir på motsvarande LED
void Rita (byte n) {
int col, lvl;
för (byte t = 1; t < n; t ++) {
för (byte jag = 0; jag < 27; i ++) {
om (buffer[i]) {
Col = jag / 3;
lvl = jag %3.
ledOn(col,lvl);
delayMicroseconds(DRAW_PWM_DELAY);
ledOff(col,lvl);
} annat {
delayMicroseconds(DRAW_PWM_DELAY);
}
}
}
}

void draw() {
draw(1);
}

drar voxel bufferten (tar stödnivåer hänsyn)
denna funktion använder en programvara PWM och är ca 128 gånger långsammare
än binärfilen Rita funktion
void drawPwm() {
int col, lvl;
för (byte t = 1; t < = 128; t ++) {
för (byte jag = 0; jag < 27; i ++) {
om (! () t % (1 < <(8-buffer[i]))) {
Col = jag / 3;
lvl = jag %3.
ledOn(col,lvl);
delayMicroseconds(DRAW_PWM_DELAY);
ledOff(col,lvl);
} annat {
delayMicroseconds(DRAW_PWM_DELAY);
}
}
}
}

rensar voxel buffert
void clearBuffer() {
för (byte jag = 0; jag < 27; i ++) {
buffert [i] = 0;
}
}

fyller voxel buffert
void fillBuffer (bytevärde) {
för (byte jag = 0; jag < 27; i ++) {
buffert [i] = värde;
}
}

hämtar värden från voxel buffert (med kartesiska koordinater)
byte getVoxel (char x, char y, char z) {
byte jag = 9 * x - y + 3 * z + 13.
returnera buffert [i];
}

anger värden från voxel buffert (med kartesiska koordinater)
void setVoxel (char x, char y, char z, bytevärde) {
byte jag = 9 * x - y + 3 * z + 13.
om (jag > = 0 & & jag < = 27) {
buffert [i] = värde;
}
}

interpolerar godtyckliga punkter mellan voxlar
void setPoint (float XY, float, flyta z, bytevärde) {
char xint = x > 0? -1: 1;
char yint = y > 0? -1: 1;
char zint = z > 0? -1: 1;

interpolate(x,y,z,Value,0,0,0);
interpolate(x,y,z,Value,0,yint,0);
interpolate(x,y,z,Value,0,0,zint);
interpolate(x,y,z,Value,0,yint,zint);
interpolate(x,y,z,Value,XInt,0,0);
interpolate(x,y,z,Value,XInt,yint,0);
interpolate(x,y,z,Value,XInt,0,zint);
interpolate(x,y,z,Value,XInt,yint,zint);
}

void interpolera (float XY, float, flyta z bytevärde, char xint, char yint, char zint) {
flyta d = sqrt(pow(xint-x,2) + pow(yint-y,2) + pow(zint-z,2));
byte jag = 9 * xint - yint + 3 * zint + 13.
om (jag > = 0 & & jag < = 27) {
buffert [i] + = (värde * (1 d));
}
}

/********************************************************************************
* Några Demos
********************************************************************************/

uppsättningar pin staterna manuellt (förare inte används)
void demoLowLevel() {
ledInit();
händer ingenting syns här
för (byte lvl = 0; lvl < 3; lvl ++) {
digitalWrite (levelPins [lvl], låg);
}
nu väljer vi hela colums
för (byte cykel = 0; cykla < 2; cykel ++) {
för (byte col = 0; col < 9; col ++) {
digitalWrite (columnPins [col], cykel % 2 == 0? HÖG: LÅG);
Delay(100);
}
}

ledInit();
händer ingenting syns här
för (byte col = 0; col < 9; col ++) {
digitalWrite (columnPins [col], hög);
}
nu väljer vi hela nivåer
för (byte cykel = 0; cykla < 2; cykel ++) {
för (byte lvl = 0; lvl < 3; lvl ++) {
digitalWrite (levelPins [lvl], cykel % 2 == 0? LÅG: HÖG);
Delay(200);
}
}

ledInit();
}

några rotationer (ingen drivrutin används också)
void demoRotation() {
rotation sekvens
byte seq [] = {0,1,2,5,8,7,6,3}.

ledInit();
aktiva alla nivåer
för (byte lvl = 0; lvl < 3; lvl ++) {
digitalWrite (levelPins [lvl], låg);
}
den mellersta kolumnen
digitalWrite (columnPins [4], hög);

nu väljer vi hela colums
int cykler = 3 * 3 * 9.
för (int cykel = 0; cykla < cykler, cykel ++) {
digitalWrite (columnPins [seq [cykel %8]], hög);
digitalWrite (columnPins [FF. [(cycle-1) %8]], låg);
om (cykel > = 3 * 9) {
digitalWrite (columnPins [FF. [(cycle+4) %8]], hög);
digitalWrite (columnPins [FF. [(cycle+3) %8]], låg);
}
om (cykel > = 2 * 3 * 9) {
digitalWrite (columnPins [FF. [(cycle+2) %8]], hög);
digitalWrite (columnPins [FF. [(cycle+1) %8]], låg);

digitalWrite (columnPins [FF. [(cycle+6) %8]], hög);
digitalWrite (columnPins [FF. [(cycle+5) %8]], låg);
}
Delay(100);
}

ledInit();
}

direkt tillgång till voxel buffert (kartesiska koordinater används inte)
void demoFill() {
clearBuffer();
för (int cykel = 0; cykla < 2; cykel ++) {
för (int jag = 0; jag < 27; i ++) {
om (cykel % 2 == 0) {
buffert [i] = 8.
} annat {
buffert [i] = 0;
}
draw(50);
}
}
}

behandlar voxlar lagerplatser och fylla dem bit för bit slumpmässigt
void demoBinFill() {
clearBuffer();
för (int jag = 0; jag < 100; i ++) {
buffer[random(0,28)] + = 2;
drawPwm();
}
}

snygg random sparkle
void demoSparkle() {
för (int densitet = 0; täthet < 50, densitet ++) {
för (int cykel = 0; cykel < 3; cykel ++) {
clearBuffer();
för (int jag = 0; jag < densitet; i ++) {
buffer[random(0,28)] = random(0,9);
}
drawPwm();
}
}
}

gör alla lysdioder puls synkront
void demoPulse() {
för (int cykel = 0; cykla < 80; cykel ++) {
fillBuffer(-abs(cycle%16-8)+8);
drawPwm();
}
}

pulserande våg
void demoPulseWave() {
byte r;
för (byte cykel = 0; cykla < 80; cykel ++) {
för (char x =-1; x < = 1; x ++) {
för (char y =-1; y < = 1; y ++) {
för (char z =-1; z < = 1; z ++) {
r = (x * x + y * y + z * z);
setVoxel (x, y, z, -abs((cycle-r)%16-8)+8);
}
}
}
drawPwm();
}
}

visar interpolation
void demoGlowfly() {
flyta dx, dy, dz;
byte steg = 10;

flyta px = random(-100,101)/100,0;
flyta py = random(-100,101)/100,0;
flyta pz = random(-100,101)/100,0;

för (int cykel = 0; cykla < 8; cykel ++) {
DX = (random(-100,101)/100,0 - px) / steg;
dy = (random(-100,101)/100,0 - py) / steg;
DZ = (random(-100,101)/100,0 - pz) / steg;

för (int jag = 0; jag < steg; i ++) {
PX += dx;
py + = dy;
PZ += dz;

clearBuffer();
setPoint (px, py, pz, MAX_INTENSITY);
drawPwm();
}
}
}