Cambio pantalla de color (14 / 15 paso)

Paso 14: Programa 2

salida serie para 74hc374
2013
Rayo McQueen
Utilizado para la prueba de exhibición del temp de color personalizado
//
Espacios en blanco Mostrar primero
//
Algunos cool flasheo y cambio de
//
Mano larga. No hay tablas usadas en este.
//
Ninguna temperatura se muestre.
//
const int blue_data = 13; 74xx374 pin3
const int red_data = 12; 74xx374 pin3
const int green_data = 11; 74xx374 pin3
const int blue_clk3 = 10; azul 3 dígitos
const int blue_clk2 = 9; dígito 2 azul
const int blue_clk1 = 8; 1er dígito azul
const int red_clk3 = 7; rojo 3 dígitos
const int red_clk2 = 6; dígitos 2 º rojo
const int red_clk1 = 5; 1er dígito rojo
const int green_clk3 = 4; verde 3 dígitos
const int green_clk2 = 3; dígitos 2 º verde
const int green_clk1 = 2; 1er dígito verde
//
//
//
int en blanco = 0; Espacios en blanco 0
int All_on = 255; Todo en 255
int cero = 252; Cero
int uno = 12; Uno
int dos = 182; Dos
int tres = 158; Tres
int 4 = 78; Cuatro
int 5 = 218; Cinco
int 6 = 122; Seis
int siete = 140; Siete
int 8 = 254; Ocho
int 9 = 206; Nueve
int DP = 1; Lugar decimal
int alto = 128; Segmento superior centro
int Ltop = 64; Segmento superior lado izquierdo
int Lbot = 32; Segmento inferior de lado izquierdo
int Bot = 16; Segmento inferior
int Rbot = 8; Segmento inferior de lado derecho
int RdeP = 4; Segmento superior lado derecho
int medio = 2; Segmento medio

//
int val = 500; utilizado por el retraso
int val2 = 150; //
Círculo de int = 0; utilizado para el número de veces a lazo
//
void setup() {}
pinMode (blue_data, salida); definir pin12 salida
pinMode (red_data, salida); definir pin12 salida
pinMode (green_data, salida); definir pin12 salida
pinMode (blue_clk3, salida); definir pin12 salida
pinMode (blue_clk2, salida); definir pin12 salida
pinMode (blue_clk1, salida); definir pin12 salida
pinMode (red_clk3, salida); definir pin12 salida
pinMode (red_clk2, salida); definir pin12 salida
pinMode (red_clk1, salida); definir pin12 salida
pinMode (green_clk3, salida); definir pin12 salida
pinMode (green_clk2, salida); definir pin12 salida
pinMode (green_clk1, salida); definir pin12 salida
//
}

void loop() {}
//
EN BLANCO TODOS LOS DÍGITOS
//
shiftOut (blue_data, blue_clk3, LSBFIRST, espacio en blanco); //
shiftOut (blue_data, blue_clk2, LSBFIRST, espacio en blanco); //
shiftOut (blue_data, blue_clk1, LSBFIRST, espacio en blanco); //
//
shiftOut (red_data, red_clk3, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk1, LSBFIRST, espacio en blanco); //
//
shiftOut (green_data, green_clk3, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk2, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk1, LSBFIRST, espacio en blanco); //
//
Delay(Val); demora la cantidad de tiempo en val
//
//
Intermitente para la diversión.
//
//
shiftOut (blue_data, blue_clk3, LSBFIRST, superior); //
shiftOut (red_data, red_clk3, LSBFIRST, RdeP); //
shiftOut (green_data, green_clk3, LSBFIRST, Rbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk3, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk3, LSBFIRST, espacio en blanco); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, superior); //
shiftOut (red_data, red_clk3, LSBFIRST, superior); //
shiftOut (green_data, green_clk3, LSBFIRST, RdeP); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk3, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk3, LSBFIRST, espacio en blanco); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, superior); //
shiftOut (red_data, red_clk2, LSBFIRST, superior); //
shiftOut (green_data, green_clk3, LSBFIRST, superior); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk3, LSBFIRST, espacio en blanco); //
Delay(val2); //
//
shiftOut (blue_data, blue_clk1, LSBFIRST, Ltop); //
shiftOut (red_data, red_clk1, LSBFIRST, superior); //
shiftOut (green_data, green_clk2, LSBFIRST, superior); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk1, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk2, LSBFIRST, espacio en blanco); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, Lbot); //
shiftOut (red_data, red_clk1, LSBFIRST, Ltop); //
shiftOut (green_data, green_clk1, LSBFIRST, superior); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk1, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk1, LSBFIRST, espacio en blanco); //
Delay(val2); //
//
shiftOut (blue_data, blue_clk1, LSBFIRST, Bot); //
shiftOut (red_data, red_clk1, LSBFIRST, Lbot); //
shiftOut (green_data, green_clk1, LSBFIRST, Ltop); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk1, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk1, LSBFIRST, espacio en blanco); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, Bot); //
shiftOut (red_data, red_clk1, LSBFIRST, Bot); //
shiftOut (green_data, green_clk1, LSBFIRST, Lbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk1, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk1, LSBFIRST, espacio en blanco); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, Bot); //
shiftOut (red_data, red_clk2, LSBFIRST, Bot); //
shiftOut (green_data, green_clk1, LSBFIRST, Bot); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk1, LSBFIRST, espacio en blanco); //
Delay(val2); //
//
//
shiftOut (blue_data, blue_clk3, LSBFIRST, Rbot); //
shiftOut (red_data, red_clk3, LSBFIRST, Bot); //
shiftOut (green_data, green_clk2, LSBFIRST, Bot); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk3, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk2, LSBFIRST, espacio en blanco); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, RdeP); //
shiftOut (red_data, red_clk3, LSBFIRST, Rbot); //
shiftOut (green_data, green_clk3, LSBFIRST, Bot); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk3, LSBFIRST, espacio en blanco); //
shiftOut (green_data, green_clk3, LSBFIRST, espacio en blanco); //
Delay(val2); //
//
//
// *********
//
COMPROBAR CADA COLOR EN CADA DÍGITO
Funky para diversión.
Azul en un círculo
Rojo en un círculo pequeño
Verde en un círculo pequeño
//
shiftOut (blue_data, blue_clk3, LSBFIRST, superior); //
shiftOut (red_data, red_clk2, LSBFIRST, superior); //
shiftOut (green_data, green_clk1, LSBFIRST, superior); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, Ltop); //
shiftOut (green_data, green_clk1, LSBFIRST, Ltop); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, superior); //
shiftOut (red_data, red_clk2, LSBFIRST, Lbot); //
shiftOut (green_data, green_clk1, LSBFIRST, Lbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, Bot); //
shiftOut (green_data, green_clk1, LSBFIRST, Bot); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, superior); //
shiftOut (red_data, red_clk2, LSBFIRST, Rbot); //
shiftOut (green_data, green_clk1, LSBFIRST, Rbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, RdeP); //
shiftOut (green_data, green_clk1, LSBFIRST, RdeP); //
Delay(val2); //
//
shiftOut (blue_data, blue_clk1, LSBFIRST, Ltop); //
shiftOut (red_data, red_clk2, LSBFIRST, superior); //
shiftOut (green_data, green_clk1, LSBFIRST, superior); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, Ltop); //
shiftOut (green_data, green_clk1, LSBFIRST, Ltop); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, Lbot); //
shiftOut (red_data, red_clk2, LSBFIRST, Lbot); //
shiftOut (green_data, green_clk1, LSBFIRST, Lbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, Bot); //
shiftOut (green_data, green_clk1, LSBFIRST, Bot); //
Delay(val2); //
//
shiftOut (blue_data, blue_clk1, LSBFIRST, Bot); //
shiftOut (red_data, red_clk2, LSBFIRST, Rbot); //
shiftOut (green_data, green_clk1, LSBFIRST, Rbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, RdeP); //
shiftOut (green_data, green_clk1, LSBFIRST, RdeP); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, Bot); //
shiftOut (red_data, red_clk2, LSBFIRST, superior); //
shiftOut (green_data, green_clk1, LSBFIRST, superior); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, Ltop); //
shiftOut (green_data, green_clk1, LSBFIRST, Ltop); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, Bot); //
shiftOut (red_data, red_clk2, LSBFIRST, Lbot); //
shiftOut (green_data, green_clk1, LSBFIRST, Lbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, Bot); //
shiftOut (green_data, green_clk1, LSBFIRST, Bot); //
Delay(val2); //
//
//
shiftOut (blue_data, blue_clk3, LSBFIRST, Rbot); //
shiftOut (red_data, red_clk2, LSBFIRST, Rbot); //
shiftOut (green_data, green_clk1, LSBFIRST, Rbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, espacio en blanco); //
shiftOut (red_data, red_clk2, LSBFIRST, RdeP); //
shiftOut (green_data, green_clk1, LSBFIRST, RdeP); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, RdeP); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, espacio en blanco); //
Delay(val2); //
//
//
//
lazo aquí 20 veces
Este es mi favorito :)
para (círculo = 0; círculo < 20; círculo ++) {}
//
shiftOut (blue_data, blue_clk3, LSBFIRST, superior); //
shiftOut (red_data, red_clk2, LSBFIRST, superior); //
shiftOut (green_data, green_clk1, LSBFIRST, superior); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, Ltop); //
shiftOut (red_data, red_clk2, LSBFIRST, Ltop); //
shiftOut (green_data, green_clk1, LSBFIRST, Ltop); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, Lbot); //
shiftOut (red_data, red_clk2, LSBFIRST, Lbot); //
shiftOut (green_data, green_clk1, LSBFIRST, Lbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, Bot); //
shiftOut (red_data, red_clk2, LSBFIRST, Bot); //
shiftOut (green_data, green_clk1, LSBFIRST, Bot); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, Rbot); //
shiftOut (red_data, red_clk2, LSBFIRST, Rbot); //
shiftOut (green_data, green_clk1, LSBFIRST, Rbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, RdeP); //
shiftOut (red_data, red_clk2, LSBFIRST, RdeP); //
shiftOut (green_data, green_clk1, LSBFIRST, RdeP); //
Delay(val2); //
shiftOut (blue_data, blue_clk3, LSBFIRST, superior); //
shiftOut (red_data, red_clk2, LSBFIRST, superior); //
shiftOut (green_data, green_clk1, LSBFIRST, superior); //
//
//
shiftOut (blue_data, blue_clk2, LSBFIRST, superior); //
shiftOut (red_data, red_clk1, LSBFIRST, superior); //
shiftOut (green_data, green_clk3, LSBFIRST, superior); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, Ltop); //
shiftOut (red_data, red_clk1, LSBFIRST, Ltop); //
shiftOut (green_data, green_clk3, LSBFIRST, Ltop); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, Lbot); //
shiftOut (red_data, red_clk1, LSBFIRST, Lbot); //
shiftOut (green_data, green_clk3, LSBFIRST, Lbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, Bot); //
shiftOut (red_data, red_clk1, LSBFIRST, Bot); //
shiftOut (green_data, green_clk3, LSBFIRST, Bot); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, Rbot); //
shiftOut (red_data, red_clk1, LSBFIRST, Rbot); //
shiftOut (green_data, green_clk3, LSBFIRST, Rbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, RdeP); //
shiftOut (red_data, red_clk1, LSBFIRST, RdeP); //
shiftOut (green_data, green_clk3, LSBFIRST, RdeP); //
Delay(val2); //
shiftOut (blue_data, blue_clk2, LSBFIRST, superior); //
shiftOut (red_data, red_clk1, LSBFIRST, superior); //
shiftOut (green_data, green_clk3, LSBFIRST, superior); //
//
//
shiftOut (blue_data, blue_clk1, LSBFIRST, superior); //
shiftOut (red_data, red_clk3, LSBFIRST, superior); //
shiftOut (green_data, green_clk2, LSBFIRST, superior); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, Ltop); //
shiftOut (red_data, red_clk3, LSBFIRST, Ltop); //
shiftOut (green_data, green_clk2, LSBFIRST, Ltop); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, Lbot); //
shiftOut (red_data, red_clk3, LSBFIRST, Lbot); //
shiftOut (green_data, green_clk2, LSBFIRST, Lbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, Bot); //
shiftOut (red_data, red_clk3, LSBFIRST, Bot); //
shiftOut (green_data, green_clk2, LSBFIRST, Bot); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, Rbot); //
shiftOut (red_data, red_clk3, LSBFIRST, Rbot); //
shiftOut (green_data, green_clk2, LSBFIRST, Rbot); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, RdeP); //
shiftOut (red_data, red_clk3, LSBFIRST, RdeP); //
shiftOut (green_data, green_clk2, LSBFIRST, RdeP); //
Delay(val2); //
shiftOut (blue_data, blue_clk1, LSBFIRST, superior); //
shiftOut (red_data, red_clk3, LSBFIRST, superior); //
shiftOut (green_data, green_clk2, LSBFIRST, superior); //
//
//
//
}
//
//
//
//
}

Artículos Relacionados

Banco Variable 3A fuente de alimentación con lectura digital en pantalla de color con ATMEGA8

Banco Variable 3A fuente de alimentación con lectura digital en pantalla de color con ATMEGA8

Estoy jugando con la electrónica desde que era un niño y numerosos circuitos. Pero aún ahora, no hice ninguna fuente de alimentación para uso general uso. Tan cansado de hacer fuente de alimentación para cada circuito, decidí aprovechar una estable f
Lecturas del sensor de temperatura y presión de Arduino BMP180 en un 1.8" TFT pantalla a color

Lecturas del sensor de temperatura y presión de Arduino BMP180 en un 1.8" TFT pantalla a color

Pantallas gráficas color añaden una nueva dimensión a cómo puede visualizarse la información recopilada por un Arduino sensores. Las pantallas TFT son también muy baratas en comparación con el tipo de LCD.En el sketch de Arduino presenta aquí se mues
Cómo hacer el cambio de pintura color

Cómo hacer el cambio de pintura color

En este tutorial voy a enseñar cómo hacer un cambio de pintura de color. En esta ocasión, he decidido crear una pintura que cambia de color con la temperatura (pigmento).Hay muchas aplicaciones en que se pueden utilizar recubrimientos termocrómicos.
Doble 7 segmentos poco cambio pantalla

Doble 7 segmentos poco cambio pantalla

He creado una doble pantalla de 7 segmentos led controlada por un Arduino a través de dos registros de desplazamiento de 8 bits. La ventaja es que sólo utiliza 3 pines de Arduino. En lugar de utilizar 14 resistencias para los leds utilicé un regulado
Bob Marley intermitente cambio botella de color

Bob Marley intermitente cambio botella de color

¡ Bienvenido a mi primer proyecto de Instructables! Se me ocurrió la idea después de terminar la bebida, que es muy buena :), y he pensado "Hombre, esta botella es demasiado buena tirar". Este proyecto es muy fácil de hacer y sólo toma aproximad
Pantalla de imprimir un póster con varios colores

Pantalla de imprimir un póster con varios colores

me he vuelto totalmente enamorado de impresión de la pantalla desde que tomé la clase básica en TechShop San José.He conseguido bastante bien en la impresión solo proyectos de color, pero pensé que me desafío a mí mismo y aprender a no sólo de la imp
Cambio de lámpara de color

Cambio de lámpara de color

Cosas necesariascambio LED del colorbateríasoporte de la bateríataza de papel (2 tazas)Paso 1: Paso 1ahora conectar el LED a los terminales de la batería y doblar hacia arriba el LEDPaso 2: Paso 2Ahora coloque la batería y LED dentro de una tazaPaso
Cambio de lámpara de botella de color

Cambio de lámpara de botella de color

Fácil, pero colorida lámpara espectacular.Paso 1: Perforar el agujero Para taladrar vidrio necesita a algunos paciente.Lo he hice con una herramienta diamantada, revestido. Herramienta de carburo de tungsteno es muy usable.Enfriamiento con agua es op
Color cambia Larson Scanner

Color cambia Larson Scanner

Video de escáner en acción. Sí, estoy girando manualmente a través de los colores.¿Quien no ama a KITT, el coche del superhéroe de jinete de la noche? El uno con la luz brillante que despide de un escáner de Larson en el frente. Este escáner fue tan
BRICOLAJE TV de pantalla LCD con Arduino y mando a distancia inteligente

BRICOLAJE TV de pantalla LCD con Arduino y mando a distancia inteligente

En los pasos siguientes, usted hacer un DIY "TV" con el código para un smart remote y realmente vídeos y posiblemente incluso conectar el mando a distancia inteligente a la placa de base real.Materiales:Espejo de papelEstabilizador sólido y no f
Caída hoja pantalla

Caída hoja pantalla

Hola a todos! Yo soy el Sr. sin talento y este es mi primer "arte" implicadas en el proyecto. Así que estoy bastante seguro de que esta lámpara podría haber sido algo mucho más bonito pero es algo que yo todavía estoy un poco orgulloso :)Es una
Aprovechar al máximo su calibrador de pantalla

Aprovechar al máximo su calibrador de pantalla

¿tienes un dispositivo de calibración de monitor? ¿Se ha preguntado si lo podía hacer mejor que el software del fabricante que escupe un perfil de prueba de 30 parches en 5 minutos? ¿Quiero hacerlo en Linux, Mac OS X y Windows? ¿Creo que debo dejar d
Reloj de Color TFT de Arduino

Reloj de Color TFT de Arduino

Usted puede estar familiarizado con un sitio web en el Reino Unido llamado reloj de color (http://thecolourclock.co.uk/) que convierte el tiempo en un valor hexadecimal y luego utiliza ese valor para actualizar el color de fondo. Es muy hipnótico y c
Huevos de Pascua que brillan y cambian de Color

Huevos de Pascua que brillan y cambian de Color

Huevos de Pascua brillan y cambian de ColorCansado de usar los mismo huevos plástico viejo para la caza del huevo de Pascua año tras año. Hacer algo diferente y tiene una búsqueda de huevos de Pascua en la oscuridad! Este Instructable le mostrará cóm