Paso 7: código de
Si desea utilizar un 16 MHz Arduino luego simplemente cambiar la constante de "Bucle" en la parte superior a 128 en lugar de 8. Esta constante hace simplemente el código todo lo repita varias veces. Corremos nuestro ATtiny en 8 MHz, pero creo que el divisor del reloj interno se debe establecer por defecto porque se comporta como si está funcionando a 1MHz.
Para obtener una velocidad conveniente, multiplicar esta constante Loop hacia arriba por la velocidad de su reloj (por ejemplo, que sea 64 para un 328 en el oscilador interno 8 MHz) etc.. Asegúrese de que siempre es un multipe de 8 o el código es probable que tenga problemas.
El código adjunto es bastante simple y tiene sólo 4 modos:
1 - odd y Even alternando
2 - explorador hacia la derecha
3 - explorador de la izquierda
4 - "Larsen" tipo explorador alterno.
Usted puede agregar fácilmente muchos modos más y este código de núcleo sólo tiene alrededor de 1.6K, para que tengas otro 6 + para jugar con.
El mismo código debe compilar perfectamente para un Arduino sin enmienda. En un Arduino, PB0 a PB4 son digitales "pasadores" de 8 a 12 respectivamente. Es pins 14 a 18 en el ATmega328 real o 168 chip. Esto es muy útil para la prueba o si son codificación mientras espera para que las piezas llegar.
Este es mi código:
Bosquejo de la prueba
Encender cada LED a su vez
Licencia MIT
Esofagogastroduodenal 2012
Esto debe ser mi multiplicador estándar por lo que yo puedo modificar el bosquejo para diferentes tiempos y velocidades de reloj. 128 para Arduino
Que sea un múltiplo de 8.
const unsigned int bucle = 8;
Mapa de 8 a 12 a los correspondientes bits del PORTB en el 328 de los pernos. Puesto que vamos a utilizar comandos PORTB directos que esto debería funcionar en 328 y ATtiny85
Utiliza acceso directo PORTB - que es los pines D0 a D4 en pequeño Arduino o D8 a D12 en Arduino normal
Primer conjunto es esquema de los terminales actuales.
Segundo es una versión antigua:
//
Versión actual:
byte DirMatrix [12] = {B10001 B10001 B10010, B10010, B10100, B10100, B01001, B01001, B01010, B01010, B01100, B01100}; Que pines son de salida y que son de alta impedancia
byte PolMatrix [12] = {B10000 B00001 B10000, B00010, B10000, B00100, B01000, B00001, B01000, B00010, B01000, B00100}; Que pin es alta y que es bajo para cada LED
//
Versión antigua:
byte DirMatrix [12] = {B00110 B00110, B01010, B01010, B10010, B10010, B00101, B00101, B01001, B01001, B10001, B10001}; Que pines son de salida y que son de alta impedancia
byte PolMatrix [12] = {B00010 B00100, B00010, B01000, B00010, B10000, B00001, B00100, B00001, B01000, B00001, B10000}; Que pin es alta y que es bajo para cada LED
byte modo = 0; numeradas de la cero
byte const MaxModes = 4; Número de modos (así 1 si sólo define de modo 0). Si es mayor que 12 tendrá que modificar ChangeMode()
SwitchMode boolean = false;
Boolean ButtonPress = false; Esto ahora puede ser redundante.
void setup() {}
Serial.Begin(9600); Hay algunos comandos de depuración serie restante pero comentado. Trabajan en Ardu' pero no tiny85
Serial.println ("tiny85 test");
Serial.println ("Ugi 2012");
DDRB & = B11100000; ajuste todos los pernos a alta impedancia
}
void loop() {}
interruptor (modo) {}
caso 0:
OddEvenFlash();
rotura;
caso 1:
Progressive(8,0);
rotura;
caso 2:
Progressive(8,1);
rotura;
caso 3:
Larsen(8);
rotura;
}
Si (conmutada) {SwitchMode = false; ChangeMode();}
}
Esta es la rutina central que enciende un LED.
Sólo lleva el número (0 a 11)
usos dirigen de acceso a puerto, para facilidad y rapidez
void LightLED(byte LEDno) {}
DDRB & = B11100000; Configurar los pines entrada
PORTB & = B11100000; Ajuste todos los pernos bajo
PORTB| = PolMatrix [LEDno]; Sets pasadores correspondientes altas y bajas
DDRB| = DirMatrix [LEDno]; fijar pasadores correspondientes a la salida
}
Comprueba el estado del botón.
No llame a menudo ' cos que pierde el tiempo.
Boolean CheckButton() {}
DDRB & = B11100000; Configurar los pines entrada
PORTB & = B11100000; Ajuste todos los pernos bajo
PORTB| = B00000100; Establecer PB2 alta - set pullup interna
delayMicroseconds(100); Necesidad de permitir resolver aumento si problemas con botón Presione
Serial.println (PINB & B00000100);
prensa booleano volátil = PINB & B00000100;
if(!Press) {/ / si derribado por interruptor
mientras (! pulse) {/ / espere hasta que el interruptor de
Serial.Print ("debounce"); Serial.println (PINB & B00000100);
Delay(20);
Pulse = PINB & B00000100;
}
verdaderas;
}
devuelven el valor false;
}
Avances de la variable "Modo".
void ChangeMode() {}
Modo ++;
Si (modo > = MaxModes) modo = 0;
Serial.println(Mode);
para (flash bytes = 0; flash < = modo; flash ++) {}
LightLED(Mode);
Delay(5);
DDRB & = B11100000;
Delay(15);
}
}
Funciones del modo definidas a continuación...
OddEvenFlash - como la función predeterminada. Este parpadea LED pares e impar alternativamente.
Debe ser útil para depurar el hardware así como OK.
void OddEvenFlash() {}
const unsigned int contador = 300;
ButtonPress = 0;
Odd boolean = false;
mientras (!. ButtonPress) {}
para (int unsigned tiempo = 0; tiempo <(Loop*Timer); hora ++) {}
para (byte LED = 0; LED < 12; LED += 2) {}
LightLED(LED+Odd);
}
}
Impar =! Impar;
SwitchMode=CheckButton();
Si {} (conmutada)
Serial.println ("juego del SwitchMode");
retorno;
}
}
}
Progresivo de colocación
Envía un "ojo" de 4 LEDs alrededor del lazo por descolorarse adentro y hacia fuera secuencialmente.
Segunda función - otra vez para hardware de depuración y también se ve genial!
anular progresiva (byte incremento, revés boolean) {}
byte EyePos [4] = {3,2,1,0};
Si {} (inversa)
EyePos [0] = 8;
EyePos [1] = 9;
EyePos [2] = 10;
EyePos [3] = 11;
}
byte EyeInt[4]={64,192,(192-Increment),(64-Increment)};
mientras (!. ButtonPress) {}
para (byte velocidad = 0; Velocidad < Loop; Velocidad += 8) {/ / esto debe igualar velocidad de frecuencia de reloj
para (byte Pos = 0; Pos < 4; POS++) {/ / luz 4 LEDs según su brillo
LightLED(EyePos[Pos]);
Serial.Print (EyePos [Pos], DEC); Serial.Print("="); Serial.Print(EyeInt[pos],DEC); Serial.Print("");
byte de desecho;
para (byte Count = 0; Cuenta < EyeInt [Pos]; Count++) {PORTB & = B11111111;}
}
Serial.println("");
EyeInt [0] += incremento;
EyeInt [1] += incremento;
EyeInt [2] = incremento;
EyeInt [3] = incremento;
Si (EyeInt [3] < incremento) {}
EyeInt [3] = EyeInt [2];
EyeInt [2] = EyeInt [1];
EyeInt [1] = EyeInt [0];
EyeInt [0] = 0;
EyePos [3] = EyePos [2];
EyePos [2] = EyePos [1];
EyePos [1] = EyePos [0];
{if(Reverse)}
EyePos [0]--;
Si (EyePos [0] > 200) {EyePos [0] = 11;}
}
Else {}
EyePos [0] ++;
Si (EyePos [0] > 11) {EyePos [0] = 0;}
}
SwitchMode=CheckButton();
if(SwitchMode) {return;}
}
}
}
}
Onda de tipo escáner Larsen
Podrían ser capaces de hacer esto como parte del progresivo. Yo no podía hacerla eficiente.
void Larsen(byte Increment) {}
byte EyePos [4] = {3,2,1,0};
byte EyeInt[4]={64,192,(192-Increment),(64-Increment)};
Reversa boolean = false;
mientras (!. ButtonPress) {}
para (byte velocidad = 0; Velocidad < Loop; Velocidad += 8) {/ / esto debe igualar velocidad de frecuencia de reloj
para (byte Pos = 0; Pos < 4; POS++) {/ / luz 4 LEDs según su brillo
LightLED(EyePos[Pos]);
Serial.Print (EyePos [Pos], DEC); Serial.Print("="); Serial.Print(EyeInt[pos],DEC); Serial.Print("");
para (byte Count = 0; Cuenta < EyeInt [Pos]; Count++) {PORTB & = B11111111;} / / mantenga el LED encendido durante un tiempo dependiendo de la intensidad del ojo
}
Serial.println("");
}
EyeInt [0] += incremento;
EyeInt [1] += incremento;
EyeInt [2] = incremento;
EyeInt [3] = incremento;
Si (EyeInt [3] < incremento) {}
EyeInt [3] = EyeInt [2];
EyeInt [2] = EyeInt [1];
EyeInt [1] = EyeInt [0];
EyeInt [0] = 0;
EyePos [3] = EyePos [2];
EyePos [2] = EyePos [1];
EyePos [1] = EyePos [0];
{if(Reverse)}
EyePos [0]--;
Si (EyePos [0] > 200) {EyePos [0] = 1; Reverso = false;}
}
Else {}
EyePos [0] ++;
Si (EyePos [0] > 11) {EyePos [0] = 10; Reverso = true;}
}
SwitchMode=CheckButton();
if(SwitchMode) {return;}
}
}
}
