Paso 4: programación
Como dijimos en el paso 3, le recomendamos ver este video: http://www.youtube.com/watch?v=FehBLNHMlfo. Muestra cómo realmente conectar el Arduino con lo TLCs en primer lugar, por lo que es un gran lugar para comenzar. En cuanto a programación, dividir el trabajo entre dos Arduinos y consiguió que se comuniquen. Los siguientes programas son simplemente marco para un producto final. LED controlador Arduino se ha completado, mientras que el controlador es simplemente una cáscara para lo que quieras a la Junta Directiva para hacer del programa:Controlador de LED Arduino:
Texas Instruments TLC 5940 con Arduino
Con la ayuda de www.kevindarrah.com
Biblioteca de interfaz periférica de //Serial #include < SPI.h >
Incluyen la fácil transferencia de Lib
#include < EasyTransfer.h >
EasyTransfer ET;
Esto debe ser exactamente la misma en otra Arduino
struct RECEIVE_DATA_STRUCTURE {}
int LEDGrid [18];
};
int LEDData [18];
Matriz RECEIVE_DATA_STRUCTURE;
ch byte = 0, chbit = 0, spibit = 0, spibyte = 0; / / variables utilizan por la rutina de sub de tlc
int SINData; //variable utilizada para pasar datos a lo TLC
byte transferbyte [48] ;// bytes que se envían al tlc5940 vía SPI
48 porque 16 canales @ 12bits da 384bits, 384/8 = 48 bytes, 12 bits a 8 bits conversión
byte DCvalue [32]; / / 0-63, 6 bits Bytes de corrección de punto
int i, j, k, l, m, n; variables de Misc
int cuenta = 0;
//*******************************************************************************************
//*******************************************************************************************
void setup() {/ / principal configuración principal configuración principal principal principal configuración de instalación
ET.begin(details(matrix) y serie);
pinMode (7, salida); //XLAT
pinMode (3, salida); //OSC2B GSCLK
pinMode (4, salida); //VPRG
pinMode (11, salida); //MOSI datos
pinMode (13, salida); //SPI del reloj
El pin 5 es el espacio en blanco
Configurar el SPI
SPI.setBitOrder (MSBFIRST); //Most del pedacito significativo primero
SPI.setDataMode(SPI_MODE0); / / modo 0 borde de datos, reloj de la subsistencia bajo de levantamiento
SPI.setClockDivider (SPI_CLOCK_DIV4); //Run los datos en 16MHz/4-4MHz
para (i = 0; i < 48; i ++) //clear los datos de escala de grises
transferbyte [i] = 0;
para (i = 0; i < 32; i ++) //set datos de corrección del punto máximo (63 decimal de 6 bits)
DCvalue [i] = 63;
¿Serial.Begin (9600); //debugging?
configurar punto de corrección
DotCorrection(); / / sub rutina ayuda a
noInterrupts(); / / configurar los contadores, por lo que no entran con interrupciones
TCCR2A = B00010010; //Timer 2 establecer al comparar Alternar modo pin 5 @ 8MHz, Arduino Digital 3
TIMER 2 ES GSCLCK
Prescaler del temporizador 2 en 1, 16/1 = 16 MHz, pero cambia pin 5 cada otro ciclo, 8MHz
TCCR2B = B00000001;
TCCR1A = B00000000; //Timer 1 no cambiar nada, utilizado para el recuento de
Prescaler del temporizador 1 a Fclk/256
¿Por qué? Necesitamos contar 4096 pulsos de temporizador 2 - pin 5
8 MHz = 1 pulso cada 125ns - 4096 pulsos necesitaría 512us
Temporizador 1 funciona en 16MHz/256 = 62,5 kHz, necesitamos un partido en cada 512us
Básicamente, puedo conseguir una interrupción a llamada cada 512us, así que...
Necesito ejecutar el temporizador 2 @ 8MHz para 512us a 4096 pulsos
No puedo contar los directy de pulsos (demasiado rápido), así
A contar con contador de tiempo 1, que hace un recuento de cada 16us
El contador empieza en 0, por lo que instalaremos a 31 para conseguir una interrupción después de 512us
TCCR1B = B00001100; //Mode=CTC con OSCR1A = superior y 256 como el prescaler
Máscara set up, llamará a ISR (rutina de servicio de Inerrupt) para comparar partido en una
TIMSK1 = B00000010;
Estos son los valores de fósforo para los contadores
0 significa aquí coincidirá en un ciclo de reloj/prescaler
OCR1A = 31; //to obtener nuestra interrupción 512us
Interrupts(); / / poner en marcha los cronómetros.
attachInterrupt (0, actualización, levantamiento);
48
para (i = 0; i < 48; i ++) //wipe los datos en tlc
TLC (i, 0); / / esto es cómo actualizar los LEDs, tlc es una subrutina con dos entradas
Canal de TLC(Channel, Value) en este caso es 0-32 y valor es 0-4095 ciclo de trabajo
4095 es 100% en
pinMode (5, salida); //BLANK configurar este pin aquí, por lo que mantiene en alta impedancia
Estado a través de la configuración, de lo contrario los LEDs se vuelven locos! incluso si escribes esta alta
para (int i = 0; i < 22; i ++) {}
TLC((i*3),4095);
}
Delay(100);
para (int i = 0; i < 22; i ++) {}
TLC((i*3),0);
}
para (int i = 0; i < 22; i ++) {}
TLC((i*3)+1,4095);
}
Delay(100);
para (int i = 0; i < 22; i ++) {}
TLC((i*3)+1,0);
}
para (int i = 0; i < 22; i ++) {}
TLC((i*3)+2,4095);
}
Delay(100);
para (int i = 0; i < 22; i ++) {}
TLC((i*3)+2,0);
}
}
void loop() {/ / MAIN LOOP principal lazo principal lazo MAIN LOOP principal MAIN LOOP LOOP
updateLED();
Esto sería un buen lugar para poner animaciones debido a que usted puede utilizar todas
de las combinaciones de color, no solo 10 o así.
}
{ISR(TIMER1_OVF_vect)}
} / / Sobre límite bandera interrumpir esto es necesario incluso si usted no utiliza
{ISR(TIMER1_COMPB_vect)}
} / / Comparar B - no utilizado
ISR(TIMER1_COMPA_vect) {/ / interrumpir para contar a 4096 pulsos en GSLCK
PORTD | = 1 << 5; / / escribir en blanco alta para reiniciar el contador de 4096 en el TLC
PORTD | = 1 << 7; / / escribir XLAT alto cierre en datos de la última secuencia de datos
PORTD & = ~ (1 << 7); //XLAT puede ir bajo ahora
PORTD & = ~ (1 << 5); //Blank va baja para iniciar el siguiente ciclo
SPI.end (); //end el SPI por lo que podemos escribir al pin de reloj
PORTB | = 1 << 5; / / pin de reloj del SPI para darle la cuenta extra
¿PORTB & = ~ (1 << 5); / / la hoja de datos dice esto necesita por alguna razón?
SPI.begin(); / / iniciar el SPI hacia arriba
para (SINData = 95; SINData > = 0; SINData--) {/ / envía los datos!
SPI.transfer(transferbyte[SINData]); / / Puerto de la SPI sólo entiende bytes 8 bits de ancho
El TLC necesita 12 bits para cada canal, por lo que 64 canales de 12 bits times da 768 bits
768/8 = 96 bytes, 0-95
}
cuenta ++;
}
void updateLED() {}
ET.receiveData();
para (int i = 0; i < 18; i ++) {}
Imprimir lo que está sucediendo
Serial.Print (matriz. LEDGrid[i]);
Serial.Print(",");
Interruptor que recibe los datos de 0-10 y se convierte en colores.
interruptor (matriz. {LEDGrid[i])}
caso 0: / / OFF
TLC(((3*i)),0);
TLC(((3*i)+1),0);
TLC(((3*i)+2),0);
rotura;
caso 1: / / rojo
TLC(((3*i)),4095);
TLC(((3*i)+1),0);
TLC(((3*i)+2),0);
rotura;
caso 2: / / verde
TLC(((3*i)),0);
TLC(((3*i)+1),0);
TLC(((3*i)+2),4095);
rotura;
caso 3: / / azul
TLC(((3*i)),0);
TLC(((3*i)+1),4095);
TLC(((3*i)+2),0);
rotura;
caso 4: / / púrpura
TLC(((3*i)),2000);
TLC(((3*i)+1),4095);
TLC(((3*i)+2),0);
rotura;
caso 5: / / TEAL
TLC(((3*i)),0);
TLC(((3*i)+1),4095);
TLC(((3*i)+2),4095);
rotura;
caso 6: / / amarillo
TLC(((3*i)),3000);
TLC(((3*i)+1),0);
TLC(((3*i)+2),4095);
rotura;
caso 7: / / color de rosa
TLC(((3*i)),4095);
TLC(((3*i)+1),3500);
TLC(((3*i)+2),3500);
rotura;
caso 8: / / naranja
TLC(((3*i)),2232);
TLC(((3*i)+1),0);
TLC(((3*i)+2),1108);
rotura;
caso 9: / / luz azul
TLC(((3*i)),1000);
TLC(((3*i)+1),4095);
TLC(((3*i)+2),2000);
rotura;
caso 10: / / blanco
TLC(((3*i)),1500);
TLC(((3*i)+1),4095);
TLC(((3*i)+2),4095);
rotura;
por defecto:
TLC(((3*i)),100);
TLC(((3*i)+1),200);
TLC(((3*i)+2),200);
}
}
Serial.println("");
}
anular el tlc (canal de int, int valor) {/ / TLC a TLC actualización a actualización TLC a TLC actualización a actualización
Esta rutina debe ocurrir tan rápido como sea posible!
if(Value>4095)
valor = 4095;
if(Value<0)
valor = 0;
Tenemos que convertir el valor de 12 bits en un BYTE de 8 bits, el SPI no puede escribir 12bits
Nosotros averiguar donde en todos los bytes a escribir, así que no tenemos que perder el tiempo
actualización de todo
12 bits en bytes, será de una salida de 12 bits en 0 o 4 en un byte
spibit = 0;
Si //if (bitRead (canal 0)) la lectura del valor es impar, el comienzo es en un 4
spibit = 4;
Esto es una simplificación del canal * 12 bits/8 bits
spibyte = int (canal * 3/2); //this profusión que byte el valor 12 comienza en
para (chbit = 0; chbit < 12; chbit ++, spibit ++) {/ / comienzo en donde irá la actualización
if(spibit==8) {//during el ciclo de 12 bits, el límite de bytes se alcanzará
spibyte ++; //roll en el siguiente byte
spibit = 0; cuenta //reset el bit en el byte
}
Si (bitRead (valor, chbit)) //check el valor de 0 y 1
bitSet (transferbyte [spibyte], spibit); //transferbyte es lo que está escrito para el TLC
otra cosa
bitClear (transferbyte [spibyte], spibit);
} //0-12 poco lazo
}
void DotCorrection() {}
PORTD | = 1 << 4; //VPRG DC modo alta
spibyte = 0; //reset nuestras variables
spibit = 0;
para (ch = 0; ch < 32; ch ++) {/ / bit 6 salidas de una pieza x 32
para (chbit = 0; chbit < 6; chbit ++) {}
{if(spibit==8)}
spibyte ++;
spibit = 0;
}
Si (bitRead (DCvalue [ch], chbit)) //all 6 pedacitos
bitSet (transferbyte [spibyte], spibit); //setting el bit 7 del byte de transferencia
otra cosa
bitClear (transferbyte [spibyte], spibit);
spibit ++;
}
}
SPI.begin();
para (j = spibyte; j > = 0; j--) {}
SPI.transfer(transferbyte[j]);
}
PORTD | = 1 << 7;
PORTD & = ~ (1 << 7);
PORTD & = ~ (1 << 4); //VPRG es bueno para ir en modo normal bajo
}
Controlador Arduino:
/*
Datos leer:
0: APAGADO REALMENTE AHORA
1: RED NOSE
2: JUGANDO VERDE
3: NOTA AZUL
4: BAR PURPLE
5: TEAL -
6: AMARILLO -
7: COLOR DE ROSA -
8: NARANJA -
9: L-AZUL -
10: BLANCO -
DEF:TEST-
*/
El conjunto de datos anterior corresponde a los datos de color en el LED controlador Arduino
Incluyen la fácil transferencia de Lib
#include < EasyTransfer.h >
EasyTransfer ET;
Esto debe ser exactamente la misma en otra Arduino
struct SEND_DATA_STRUCTURE {}
int LEDGrid [18];
};
Matriz SEND_DATA_STRUCTURE;
//----------------------------Variables-------------------------
int buttonRaw [6] [3];
int LEDData [6] [3];
//--------------------------------------------------------------
void setup() {}
Comenzar serie 9600 - depuración
Serial.Begin(9600);
EasyTransfer comienza
ET.begin(details(matrix) y serie);
Pernos de 7-9 se utilizan para los cables del botón
pinMode (7, salida);
pinMode (8, salida);
pinMode (9, salida);
Definir puerto de altavoz - no utilizado en este programa de shell
pinMode (2, salida);
buttonCheck();
}
//------------------------------Setup---------------------------
void loop() {}
buttonCheck();
Update();
Añadir programa de realidad en este espacio. Leer los valores de botón, configurar la
luces y sonidos del juego. Todo depende de ti. Este es el marco
para lo que quieras.
}
//-----------------------------Programs--------------------------
Updater: Añadir luz actual envío de mecánicos. Basta con establecer LEDData [x] [y]
coordenadas de la matriz que se corresponde con la luz apropiada a un número
de 0 a 10 según se define en la parte superior de este programa.
{} void update()
para (int y = 0 y < 3; y ++) {}
para (int x = 0; x < 6; x ++) {}
matriz. LEDGrid [gridCount] = LEDData [x] [y];
gridCount ++;
}
Delay(5);
}
gridCount = 0;
ET.sendData();
}
//-------------------
: Botón verifica valores de botón y guarda los datos crudos en una matriz.
El orden va de (0,0)-(6,0), entonces (0,1)-(6,1), etc. Estos datos pueden
se utiliza para cambiar los valores, etc..
void buttonCheck() {}
para (int y = 0; y < 3; y ++) {}
digitalWrite(7+y,HIGH);
para (int x = 0; x < 6; x ++) {}
buttonRaw [x] [y] = analogRead (x);
}
digitalWrite(7+y,LOW);
}
}
