Enorme leidde Mood light (8 / 8 stap)

Stap 8: software

* LED Driver

byte columnPins [] = {2,3,4,6,7,8,11,12,13}; verbindingen van matrix colums
byte levelPins [] = {5,9,10}; Connecties van matrix niveaus

initialiseert de LED driver (pin modi ingesteld en alle LEDs uitgeschakeld)
ongeldig ledInit() {}
voor (byte ik = 0; ik < 9; i ++) {}
pinMode (columnPins [i], OUTPUT);
digitalWrite (columnPins [i], laag);
}
voor (byte ik = 0; ik < 3; i ++) {}
pinMode (levelPins [i], OUTPUT);
digitalWrite (levelPins [i], hoge);
}
}

overschakelen op interne LEDs
zorgt ervoor dat andere LEDs aan het licht op als het stuurprogramma is niet geïnitialiseerd deelstaat
(u kunt niet alle 27 LEDs met slechts 12 pinnen tegelijk richten)
VOID ledOn (byte kolom, byte graad) {}
digitalWrite (columnPins [kolom], hoge);
digitalWrite (levelPins [niveau], laag);
}

hetzelfde als ledOn
VOID ledOff (byte kolom, byte graad) {}
digitalWrite (columnPins [kolom], laag);
digitalWrite (levelPins [niveau], hoge);
}

/********************************************************************************
* Eenvoudige API voor het tekenen (voxel buffer Cartesisch coördinatenstelsel, enz.)
********************************************************************************/

byte buffer [27]; Voxel buffer

trekt de voxel buffer (het negeren van intensiteiten)
elke voxel > 1 schakelt de bijbehorende LED
ongeldig teken (byte n) {}
int col, lvl;
voor (byte t = 1; t < n; t ++) {}
voor (byte ik = 0; ik < 27; i ++) {}
Als (buffer[i]) {}
Col = i / 3;
lvl = i 3 %;
ledOn(col,lvl);
delayMicroseconds(DRAW_PWM_DELAY);
ledOff(col,lvl);
} else {}
delayMicroseconds(DRAW_PWM_DELAY);
}
}
}
}

VOID draw() {}
draw(1);
}

trekt de voxel buffer (duurt intensiteiten in aanmerking)
deze functies maakt gebruik van een software PWM en is ongeveer 128 keer langzamer
trekken dan de binaire functie
ongeldig drawPwm() {}
int col, lvl;
voor (byte t = 1; t < = 128; t ++) {}
voor (byte ik = 0; ik < 27; i ++) {}
Als (! () t % (1 < <(8-buffer[i]))) {
Col = i / 3;
lvl = i 3 %;
ledOn(col,lvl);
delayMicroseconds(DRAW_PWM_DELAY);
ledOff(col,lvl);
} else {}
delayMicroseconds(DRAW_PWM_DELAY);
}
}
}
}

voxel buffer gewist
ongeldig clearBuffer() {}
voor (byte ik = 0; ik < 27; i ++) {}
buffer [i] = 0;
}
}

vult voxel buffer
VOID fillBuffer (de waarde van de byte) {}
voor (byte ik = 0; ik < 27; i ++) {}
buffer [i] = waarde;
}
}

waarden ophaalt van voxel buffer (met behulp van de Cartesische coördinaten)
byte getVoxel (char char y, x, char z) {}
byte ik = 9 * x - y + 3 * z + 13;
retourneren van buffer [i];
}

Hiermee stelt u waarden uit voxel buffer (met behulp van de Cartesische coördinaten)
VOID setVoxel (char char y, char z, x, bytewaarde) {}
byte ik = 9 * x - y + 3 * z + 13;
Als (ik > = 0 & & ik < = 27) {}
buffer [i] = waarde;
}
}

interpoleert willekeurige punten tussen voxels
VOID setPoint (float x, float y, z, bytewaarde zweven) {}
char xint = x > 0? 1:-1;
char yint = y > 0? 1:-1;
zint char = 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 interpoleren (float x, float y, z, bytewaarde, char xint, char yint, char zint zweven) {}
zweven d = sqrt(pow(xint-x,2) + pow(yint-y,2) + pow(zint-z,2));
byte ik = 9 * xint - yint + 3 * zint + 13;
Als (ik > = 0 & & ik < = 27) {}
buffer [i] += (waarde * (1-d));
}
}

/********************************************************************************
* Enkele demo 's
********************************************************************************/

sets pin Staten handmatig (rijder niet gebruikt)
ongeldig demoLowLevel() {}
ledInit();
hier gebeurt er niets zichtbaar
voor (byte lvl = 0; lvl < 3; lvl ++) {}
digitalWrite (levelPins [lvl], laag);
}
nu selecteren we hele kolommen
voor (byte cyclus = 0; cyclus < 2; cyclus ++) {}
voor (byte col = 0; col < 9; col ++) {}
digitalWrite (columnPins [col], cyclus % 2 == 0? HOOG: LAGE);
delay(100);
}
}

ledInit();
hier gebeurt er niets zichtbaar
voor (byte col = 0; col < 9; col ++) {}
digitalWrite (columnPins [col], hoge);
}
nu selecteren wij hele niveaus
voor (byte cyclus = 0; cyclus < 2; cyclus ++) {}
voor (byte lvl = 0; lvl < 3; lvl ++) {}
digitalWrite (levelPins [lvl], cyclus % 2 == 0? LAAG: HOOG);
delay(200);
}
}

ledInit();
}

Sommige rotaties (geen rijder ook gebruikt)
ongeldig demoRotation() {}
rotatie-reeks
byte seq [] = {0,1,2,5,8,7,6,3};

ledInit();
actieve alle niveaus
voor (byte lvl = 0; lvl < 3; lvl ++) {}
digitalWrite (levelPins [lvl], laag);
}
middelste kolom
digitalWrite (columnPins [4], hoge);

nu selecteren we hele kolommen
int cycli = 3 * 3 * 9;
voor (int cyclus = 0; cyclus < cycli; cyclus ++) {}
digitalWrite (columnPins [seq [cyclus %8]], hoge);
digitalWrite (columnPins [seq [(cycle-1) %8]], laag);
Als (cyclus > 3 * 9 =) {}
digitalWrite (columnPins [seq [(cycle+4) %8]], hoge);
digitalWrite (columnPins [seq [(cycle+3) %8]], laag);
}
Als (cyclus > 2 * 3 * 9 =) {}
digitalWrite (columnPins [seq [(cycle+2) %8]], hoge);
digitalWrite (columnPins [seq [(cycle+1) %8]], laag);

digitalWrite (columnPins [seq [(cycle+6) %8]], hoge);
digitalWrite (columnPins [seq [(cycle+5) %8]], laag);
}
delay(100);
}

ledInit();
}

directe toegang tot voxel buffer (cartesische coördinaten niet gebruikt)
ongeldig demoFill() {}
clearBuffer();
voor (int cyclus = 0; cyclus < 2; cyclus ++) {}
for (int i = 0; ik < 27; i ++) {}
Als (cyclus % 2 == 0) {}
buffer [i] = 8;
} else {}
buffer [i] = 0;
}
draw(50);
}
}
}

behandelt voxels zoals opslaglocaties en vul ze beetje bij beetje willekeurig
ongeldig demoBinFill() {}
clearBuffer();
for (int i = 0; ik < 100; i ++) {}
buffer[Random(0,28)] += 2;
drawPwm();
}
}

nette willekeurige sparkle
ongeldig demoSparkle() {}
voor (int dichtheid = 0; dichtheid < 50; dichtheid ++) {}
voor (int cyclus = 0; cyclus < 3; cyclus ++) {}
clearBuffer();
for (int i = 0; ik < dichtheid; i ++) {}
buffer[Random(0,28)] = random(0,9);
}
drawPwm();
}
}
}

maakt alle LEDs pulse synchroon
ongeldig demoPulse() {}
voor (int cyclus = 0; cyclus < 80; cyclus ++) {}
fillBuffer(-abs(cycle%16-8)+8);
drawPwm();
}
}

pulserende Golf
ongeldig demoPulseWave() {}
byte r;
voor (byte cyclus = 0; cyclus < 80; cyclus ++) {}
voor (char x =-1; x < = 1; x ++) {}
voor (char y =-1; y < = 1; y ++) {}
voor (char z =-1; z < = 1, z ++) {}
r = (x * x + y * y + z * z);
setVoxel (x, y, z, -abs((cycle-r)%16-8)+8);
}
}
}
drawPwm();
}
}

toont interpolatie
ongeldig demoGlowfly() {}
zweven dx, dy, dz;
byte stappen = 10;

zweven px = random(-100,101)/100.0;
zweven py = random(-100,101)/100.0;
zweven pz = random(-100,101)/100.0;

voor (int cyclus = 0; cyclus < 8; cyclus ++) {}
DX = (random(-100,101)/100.0 - px) / stappen;
dy = (random(-100,101)/100.0 - py) / stappen;
dz = (random(-100,101)/100.0 - pz) / stappen;

for (int i = 0; ik < stappen; i ++) {}
PX += dx;
py += dy;
PZ += dz;

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