Enorme luz de estado de ánimo (8 / 8 paso)

Paso 8: software

* LED Driver

Byte [] columnPins = {2,3,4,6,7,8,11,12,13}; las conexiones de la matriz de columnas
Byte [] levelPins = {5,9,10}; conexiones de los niveles de la matriz de

Inicializa el controlador de LED (establece modos de pin y apaga todos los LEDs)
void ledInit() {}
para (byte i = 0; i < 9; i ++) {}
pinMode (columnPins [i], salida);
digitalWrite (columnPins [i], LOW);
}
para (byte i = 0; i < 3; i ++) {}
pinMode (levelPins [i], salida);
digitalWrite (levelPins [i], HIGH);
}
}

encender LEDs individuales
causa otros LEDs luz para arriba si el conductor no está en estado inicializado
(no pueden abordar todos los 27 LEDs con 12 pins a la vez)
{} void ledOn (columna bytes de tamaño, nivel de byte)
digitalWrite (columnPins [columna], HIGH);
digitalWrite (levelPins [nivel], LOW);
}

igual como ledOn
void ledOff (columna byte, byte nivel) {}
digitalWrite (columnPins [columna], LOW);
digitalWrite (levelPins [nivel], HIGH);
}

/********************************************************************************
* API de dibujo básica (almacenador intermediario de voxel, sistema de coordenadas Cartesianas, etc..)
********************************************************************************/

búfer de bytes [27]; buffer de voxel

dibuja el búfer de voxel (haciendo caso omiso de intensidades)
cualquier voxel > 1 se encenderá el LED correspondiente
{} void draw (n bytes)
col de int, lvl;
para (t bytes = 1; t < n; t ++) {}
para (byte i = 0; i < 27; i ++) {}
Si (buffer[i]) {}
col = i / 3;
LVL = 3 %;
ledOn(col,lvl);
delayMicroseconds(DRAW_PWM_DELAY);
ledOff(col,lvl);
} else {}
delayMicroseconds(DRAW_PWM_DELAY);
}
}
}
}

void draw() {}
Draw(1);
}

dibuja el búfer de voxel (toma intensidad en cuenta)
Esta función utiliza un software de PWM y es más lento aproximadamente 128 veces
que el binario de llamar la función
void drawPwm() {}
col de int, lvl;
para (t bytes = 1; t < = 128; t ++) {}
para (byte i = 0; i < 27; i ++) {}
Si (! () t % (1 < <(8-buffer[i]))) {
col = i / 3;
LVL = 3 %;
ledOn(col,lvl);
delayMicroseconds(DRAW_PWM_DELAY);
ledOff(col,lvl);
} else {}
delayMicroseconds(DRAW_PWM_DELAY);
}
}
}
}

borra buffer de voxel
void clearBuffer() {}
para (byte i = 0; i < 27; i ++) {}
buffer [i] = 0;
}
}

llena el búfer de voxel
void fillBuffer (valor del byte) {}
para (byte i = 0; i < 27; i ++) {}
buffer [i] = valor;
}
}

recupera valores de voxel buffer (usando coordenadas cartesianos)
byte getVoxel (char x, char y, char z) {}
byte me = 9 * x - y + 3 * z + 13;
volver buffer [i];
}

establece los valores de búfer de voxel (usando coordenadas cartesianos)
void setVoxel (char x, char y, char z, valor de byte) {}
byte me = 9 * x - y + 3 * z + 13;
Si (i > = 0 & & i < = 27) {}
buffer [i] = valor;
}
}

interpola los puntos arbitrarios entre vóxeles
Valor nulo (float x, float y, float z, valor de byte) {}
¿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);
}

vacío interpolar (float x, float y, float z valor de byte, char xint, char yint, char zint) {}
flotador d = sqrt(pow(xint-x,2) + pow(yint-y,2) + pow(zint-z,2));
byte me = 9 * xint - yint + 3 * zint + 13;
Si (i > = 0 & & i < = 27) {}
buffer [i] += (valor * (1-d));
}
}

/********************************************************************************
* Algunos Demos
********************************************************************************/

Juegos pin Estados manualmente (no utilizar el conductor)
void demoLowLevel() {}
ledInit();
Aquí no ocurre nada visible
para (lvl byte = 0; lvl < 3; lvl ++) {}
digitalWrite (levelPins [lvl], LOW);
}
Ahora seleccionamos a las columnas todo
para (ciclo byte = 0; ciclo < 2; ciclo ++) {}
para (col byte = 0; col < 9; col ++) {}
¿digitalWrite (columnPins [col], ciclo % 2 == 0? ALTO: BAJA);
Delay(100);
}
}

ledInit();
Aquí no ocurre nada visible
para (col byte = 0; col < 9; col ++) {}
digitalWrite (columnPins [col], HIGH);
}
Ahora seleccionamos todos niveles
para (ciclo byte = 0; ciclo < 2; ciclo ++) {}
para (lvl byte = 0; lvl < 3; lvl ++) {}
¿digitalWrite (levelPins [lvl], ciclo % 2 == 0? BAJA: ALTA);
Delay(200);
}
}

ledInit();
}

algunas rotaciones (ninguÌ n conductor usado así)
void demoRotation() {}
secuencia de rotación
Byte [] seq = {0,1,2,5,8,7,6,3};

ledInit();
activa todos los niveles
para (lvl byte = 0; lvl < 3; lvl ++) {}
digitalWrite (levelPins [lvl], LOW);
}
columna media
digitalWrite (columnPins [4], HIGH);

Ahora seleccionamos a las columnas todo
ciclos de int = 3 * 3 * 9;
para (ciclo int = 0; ciclo < ciclos; ciclo ++) {}
digitalWrite (columnPins [seq [ciclo 8%]], HIGH);
digitalWrite (columnPins [seq [(cycle-1) %8]], baja);
Si (ciclo > = 3 * 9) {}
digitalWrite (columnPins [seq [(cycle+4) %8]], alto);
digitalWrite (columnPins [seq [(cycle+3) %8]], baja);
}
Si (ciclo > = 2 * 3 * 9) {}
digitalWrite (columnPins [seq [(cycle+2) %8]], alto);
digitalWrite (columnPins [seq [(cycle+1) %8]], baja);

digitalWrite (columnPins [seq [(cycle+6) %8]], alto);
digitalWrite (columnPins [seq [(cycle+5) %8]], baja);
}
Delay(100);
}

ledInit();
}

acceso directo al búfer de voxel (coordenadas cartesianos no utilizados)
void demoFill() {}
clearBuffer();
para (ciclo int = 0; ciclo < 2; ciclo ++) {}
para (int i = 0; i < 27; i ++) {}
Si (ciclo % 2 == 0) {}
buffer [i] = 8;
} else {}
buffer [i] = 0;
}
Draw(50);
}
}
}

trata de vóxeles como contenedores y llenan poco a poco al azar
void demoBinFill() {}
clearBuffer();
para (int i = 0; i < 100; i ++) {}
buffer[RANDOM(0,28)] += 2;
drawPwm();
}
}

aseado al azar de la chispa
void demoSparkle() {}
para (densidad int = 0; densidad < 50; densidad ++) {}
para (ciclo int = 0; ciclo < 3; ciclo ++) {}
clearBuffer();
para (int i = 0; i < densidad; i ++) {}
buffer[RANDOM(0,28)] = random(0,9);
}
drawPwm();
}
}
}

hace todo pulso LED síncrono
void demoPulse() {}
para (ciclo int = 0; ciclo < 80; ciclo ++) {}
fillBuffer(-abs(cycle%16-8)+8);
drawPwm();
}
}

onda de pulsada
void demoPulseWave() {}
r de bytes;
para (ciclo byte = 0; ciclo < 80; ciclo ++) {}
para (char x =-1; x < = 1; x ++) {}
para (char y =-1; y < = 1; y ++) {}
para (char z =-1; z < = 1; z ++) {}
r = (x * x + y * y + z * z);
setVoxel (x, y, z, - abs((cycle-r)%16-8)+8);
}
}
}
drawPwm();
}
}

muestra la interpolación
void demoGlowfly() {}
flotador de dx, dy, dz;
pasos de bytes = 10;

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

para (ciclo int = 0; ciclo < 8; ciclo ++) {}
DX = (random(-100,101)/100.0 - px) / pasos;
DY = (random(-100,101)/100.0 - py) / pasos;
DZ = (random(-100,101)/100.0 - pz) / pasos;

para (int i = 0; i < pasos; i ++) {}
PX += dx;
py += dy;
PZ += dz;

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