Paso 5: Código II
Este paso es sólo el código de C escrito para aquellos que no quieren descargar el archivo zip en el último paso o este paso (mismo código).#include < avr/io.h >
#include < util/delay.h >
#include < stdlib.h >
int rn;
r64 int;
int r48;
int r32;
int r16;
es corto (-) cátodo (c), ánodo (a) es más largo (+) llevar
cátodo <------> capa 1 <------> capa 2 <------> capa 3 <------> capa 4
int c [] = {2,3,4,5 1,3,4,5, 1,2,4,5, 1,2,3,5, 6,7,8,9, 6,7,8,9, 6,7,8,9, 6,7,8,9, 1,2,3,4, 1,2,3,4, 1,2,3,4, 1,2,3,4, 6,7,8,9, 5,7,8,9, 5,6,8,9, 5,6,7,9};
ánodo de <------> capa 1 <------> capa 2 <------> capa 3 <------> capa 4
int a [] = {1,1,1,1 2,2,2,2, 3,3,3,3, 4,4,4,4, 1,1,1,1, 2,2,2,2, 3,3,3,3, 4,4,4,4, 5,5,5,5, 6,6,6,6, 7,7,7,7, 8,8,8,8, 5,5,5,5, 6,6,6,6, 7,7,7,7, 8,8,8,8};
anular el retardo (ms int) / / hay que escribir nuestra propia función de retraso puesto que _delay_ms(int) sólo acepta constantes (no podemos pasar una variable a él)
{
para (int i = 0; i < = ms; i ++)
{
_delay_ms(1); en milisegundos
}
}
int principal (vacío)
{
RN = 642563; la semilla aleatoria
DDRD = 0X00000000;
DDRB = 0X00000000;
PORTD = 0X00000000;
PORTB = 0X00000000;
while(1)
{
LineSpin(20,1,1);
LineSpin(16,1,1);
LineSpin(12,1,1);
LineSpin(8,1,1);
LineSpin(6,1,2);
LineSpin(5,1,2);
LineSpin(4,1,3);
LineSpin(3,1,3);
LineSpin(2,1,4);
LineSpin(1,1,8);
Scroll(75);
Scroll(50);
Scroll(25);
Scroll(10);
Scroll(3);
drawBox(100,40); multiplicar los inputs para obtener el tiempo en ms
Spin(1,60);
Spin(1,40);
Spin(1,30);
Spin(1,20);
Spin(1,15);
Spin(1,10);
Spin(1,8);
Spin(1,6);
Spin(1,5);
Spin(1,4);
Spin(1,3);
Spin(1,3);
Spin(1,3);
Spin(1,3);
Spin(1,3);
Spin(1,3);
Spin(1,3);
lluvia (100, 100, 16);
Snake_x(2,1,100);
Snake_x(2,14,60);
Snake_x(2,16,40);
Snake_x(2,18,20);
Snake_x(2,10,10);
layerPattern(50);
layerPattern(100);
FlashOn(0,0,16);
FlashOn(1,1,10);
FlashOn(10,1,6);
randomGen();
randomGen();
randomGen();
randomGen();
randomGen();
randomGen();
}
return 0;
}
OP pide las coordenadas de lo LED de las matrices indexadas arriba
void op (int n) {}
DDRD = 0X00000000;
DDRB = 0X00000000;
PORTD = 0X00000000;
PORTB = 0X00000000;
int cn = ((c[n-1])-1);
int un = ((a[n-1])-1);
---cátodos
if(CN==8)
{DDRB = _BV(DDB0);
PORTB = _BV(PORTB0);
}
otra cosa
{DDRD = _BV(cn);
PORTD = _BV(cn);
}
---los ánodos
if(an==8) {DDRB | = _BV(an);}
Else {DDRD | = _BV(an);}
}
void allOff()
{/ / se ilumina pins 1-9 off (esto significa que todos los pines utilizados son off)
PORTB & = 0;
PORTD y = 0;
DDRB = 0X00000000; ENTRADA pinMode para todo Puerto
DDRD = 0X00000000; ENTRADA pinMode para todo Puerto
}
FlashOn (int refresh_rate, int dark_time, int ciclos)
{
allOff();
Delay(dark_time);
para (int c = 0; c < ciclos; c ++)
{
para (int i = 1; i < 65; i ++)
{
OP(i);
Delay(refresh_rate);
}
}
}
---algoritmos de dibujos---
void boxFrame(v) {//rasters un marco del alambre de la caja
int lista [40] = {1,2,3,4, 5, 8, 9,12, 13,14,15,16,
17.20, 29,32,
33,36, 45,48,
49,50,51,52 53,56, 57,60, 61,62,63,64};
para (int i = 0; i < 41; i ++) {}
OP(list[i]);
para (int t = 0; t < v; t ++)
_delay_us(10);
}
}
capa patrones (AKA rebanada (z))
void sz1() {/ / se enciende para arriba la capa inferior
para (int i = 1; i < 17; i ++) {}
OP(i);
}
}
void sz2() {/ / se enciende para arriba la capa 2
para (int i = 17; i < 33; i ++) {}
OP(i);
}
}
void sz3() {/ / se enciende para arriba la capa 3
para (int i = 33; i < 49; i ++) {}
OP(i);
}
}
void sz4() {/ / se enciende para arriba la 4ta capa
para (int i = 49; i < 65; i ++) {}
OP(i);
}
}
patrones de corte (x)
void sx1() {/ / enciende el x 1 rebanada (nuevo)
int lista [16] = {1,2,3,4, 17,18,19,20, 33,34,35,36 49,50,51,52};
para (int i = 0; i < 16; i ++) {}
OP(list[i]);
}
}
void sx2() {/ / se enciende para arriba la 2ª x rebanada
int lista [16] = {5,6,7,8, 21,22,23,24, 37,38,39,40, 53,54,55,56};
para (int i = 0; i < 16; i ++) {}
OP(list[i]);
}
}
void sx3() {/ / se enciende para arriba la 3ra x rebanada
int lista [16] = {9,10,11,12 25,26,27,28, 41,42,43,44, 57,58,59,60};
para (int i = 0; i < 16; i ++) {}
OP(list[i]);
}
}
void sx4() {/ / se enciende para arriba el x 4 rebanada (delantero)
int lista [16] = {13,14,15,16 29,30,31,32, 45,46,47,48, 61,62,63,64};
para (int i = 0; i < 16; i ++) {}
OP(list[i]);
}
}
patrones de corte (y)
void sy1() {/ / se enciende el segmento y 1 (izquierda)
para (int i = 0; i < 64; i = i + 4) {}
OP(i);
}
}
void sy2() {/ / se enciende el segmento y 2 º
para (int i = 1; i < 64; i = i + 4) {}
OP(i);
}
}
void sy3() {/ / se enciende el 3er segmento y
para (int i = 2; i < 64; i = i + 4) {}
OP(i);
}
}
void sy4() {/ / se enciende el segmento y 4 º (derecha)
para (int i = 3; i < 64; i = i + 4) {}
OP(i);
}
}
lluvia
{} void lluvia (int dur, int inidur, int ciclos)
srand(RN);
RN = ((rn*13) %7) + 1;
para (int i = 0; i < ciclos; i ++)
{
R64 = (rand () % 16) 49;
R48 = r64-16;
R32 = r48-16;
R16 = r32-16;
OP(R64);
Delay(inidur); Usted puede tener pausa extra larga en la primera luz si quieres con inidur.
OP(R48);
Delay(Dur);
OP(R32);
Delay(Dur);
OP(R16);
Delay(Dur);
}
}
al azar (genera un campo oscilante al azar nebuloso de la luz)
void randomGen() {}
srand(RN);
para (int i = 0; i < 10; i ++) {}
int r = (rand () % 64) + 1;
OP(r);
Delay(100);
}
RN ++;
}
girar alrededor del eje z
void spin11 (int v) {}
int base [8] = {6,11 22.27, 38,43, 54,59}; parte superior izquierda e inferior derecha de cada rebanada
int externa [8] = {oído-pedacito de 1.16, 17.32, 33,48, 49,64}; esquina superior izquierda e inferior derecha
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}
void spin12 (int v) {}
int base [8] = {6,11 22.27, 38,43, 54,59};
int externa [8] = {2.15 18,31, 34,47, 50,63};
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}
void spin21 (int v) {}
int base [8] = {7,10, 23,26, 39,42, 55,58};
int externa [8] = {3,14, 19,30, 35,46, 51,62};
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}
void spin22(int v) {/ / la parte superior derecha e inferior izquierda esquinas
int base [8] = {7,10, 23,26, 39,42, 55,58};
int externa [8] = {4,13 20,29, 36,45, 52,61};
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}
void spin23 (int v) {}
int base [8] = {7,10, 23,26, 39,42, 55,58};
int externa [8] = {8,9, 24,25, 40,41, 56,57};
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}
void spin13 (int v) {}
int base [8] = {6,11 22.27, 38,43, 54,59};
int externa [8] = {5,12 21,28, 37,44, 53,60};
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}
// ------------------ programs ---------------------------------------------
void girar (giros int, int v) {}
para (int i = 0; i < giros; i ++) {}
spin11(v);
spin12(v);
spin21(v);
spin22(v);
spin23(v);
spin13(v);
}
}
desplazamiento vacío (int v) {/ / uno por uno, {encender, esperar, off} cada LED en orden
para (int n = 1; n < 65; n ++) {}
OP(n);
Delay(v); esperar milisegundos v antes rastering siguiente LED
}
}
{} void allOn (ciclos de int, int delaytime)
para (int i = 0; i < ciclos; i ++) {}
para (int n = 1; n < 65; n ++) {}
OP(n);
para (int t = 0; t < delaytime; t ++)
_delay_us(1);
}
}
}
void drawBox (ciclos de int, int v) {/ / v es retraso en 10 micro segundos
para (int i = 0; i < ciclos; i ++) {}
boxFrame(v);
}
}
void layerZup (int v) {/ / más alto v = más lento
para (int t = 0; t < v; t ++) {sz1();}
para (int t = 0; t < v; t ++) {sz2();}
para (int t = 0; t < v; t ++) {sz3();}
para (int t = 0; t < v; t ++) {sz4();}
}
void layerZdown (int v) {}
para (int t = 0; t < v; t ++) {sz4();}
para (int t = 0; t < v; t ++) {sz3();}
para (int t = 0; t < v; t ++) {sz2();}
para (int t = 0; t < v; t ++) {sz1();}
}
void layerYup (int v) {}
para (int t = 0; t < v; t ++) {sy1();}
para (int t = 0; t < v; t ++) {sy2();}
para (int t = 0; t < v; t ++) {sy3();}
para (int t = 0; t < v; t ++) {sy4();}
}
void layerYdown (int v) {}
para (int t = 0; t < v; t ++) {sy4();}
para (int t = 0; t < v; t ++) {sy3();}
para (int t = 0; t < v; t ++) {sy2();}
para (int t = 0; t < v; t ++) {sy1();}
}
void layerXup (int v) {}
para (int t = 0; t < v; t ++) {sx1();}
para (int t = 0; t < v; t ++) {sx2();}
para (int t = 0; t < v; t ++) {sx3();}
para (int t = 0; t < v; t ++) {sx4();}
}
void layerXdown (int v) {}
para (int t = 0; t < v; t ++) {sx4();}
para (int t = 0; t < v; t ++) {sx3();}
para (int t = 0; t < v; t ++) {sx2();}
para (int t = 0; t < v; t ++) {sx1();}
}
void layerPattern (int v) {/ / más alto v = velocidad más lenta de capa de cambio
layerZdown(v);
layerZup(v);
layerYdown(v);
layerYup(v);
layerXdown(v);
layerXup(v);
}
LineSpin (int dur, int dt, int ciclos)
{
para (int c = 0; c < ciclos; c ++)
{
int spin_x [] = {1,5,9,13,14,15,16,12,8,4,3,2};
para (int a = 1; a < 13; a ++)
{
para (int t = 0; t < dur; t ++)
{
OP(spin_x[a]);
Delay(DT);
OP(spin_x[a]+16);
Delay(DT);
OP(spin_x[a]+32);
Delay(DT);
OP(spin_x[a]+48);
Delay(DT);
}
}
}
}
Snake_x (capa int, int ciclos, velocidad de int) / / válido capa 1,2,3,4
{
int start_led = (16 * capa) - 15;
int x[] = {1,5,9,13,14,15,16,12,8,4,3,2};
srand(RN);
int r = rand () % 100;
int current_layer = capa;
para (int c = 0; c < ciclos; c ++)
{
para (int i = 1; i < 13; i ++)
{
Si ((r < 20) & & (current_layer! = 1))
{
current_layer--;
}
else if ((r > 80) & & (current_layer! = 4))
{
current_layer ++;
}
OP(x[i]+(16*(current_layer-1)));
Delay(Speed);
r = rand () % 100;
}
}
}
