Controlando muchos LED de 14 segmentos

Navega tus respuestas
0

(Lo siento, es un poco largo, ¡pero he marcado las preguntas en negrita!)

Encontré estos LED alfanuméricos de 14 segmentos en línea y quería controlar 16 de ellos usando un microcontrolador TI. Cada LED alfanumérico tiene 15 pines, 1 para cada segmento y luego uno para el punto en la parte inferior derecha. Si quisiera alimentar cada uno directamente, necesitaría 240 pines GPIO. No es ideal (y no es posible).

Mi siguiente idea fue controlar cada cuadrado de LED individual usando dos Registros de desplazamiento SIPO de 8 bits . La cuestión es que necesitaría 2 de estos para cada cuadrado de LED, lo que significa que tendría que usar 32 en total. Una vez más, no es ideal.

Mi idea final fue utilizar solo dos registros de desplazamiento SIPO de 8 bits, pero "redirigir" la salida colectiva de 16 bits a un cuadrado individual utilizando algún tipo de circuito. Sé que los decodificadores son uno a muchos, pero solo envían un bit hacia afuera. Necesito un circuito que envíe datos de 16 bits. Estoy pensando que esto implica la combinación de una tonelada de decodificadores, como este chip que tiene dos decodificadores 1 a 4 . Sin embargo, esto parece realmente ineficiente. ¿Qué tipo de circuito necesitaría para este tipo de redirección?

También, mi problema es que cada cuadrado solo estará iluminado 1/16 del tiempo, por lo que será 1/16 tan brillante. Podría pasar 16 veces más que la corriente, pero eso me parece una mala idea ... ¿Cómo me aseguro de que los LED estén funcionando a su máxima intensidad?

Además, ¿hay alguna forma de que el LED "persista" usando algún tipo de memoria? Si los valores del cuadrado no cambian, entonces no veo por qué necesito sigue pedaleando a través de ellos. ¿Haría el truco un pestillo D cerrado?

Por favor, avísame si estoy haciendo esto mal. Esta es la primera vez que intento algo así de complejo, y estoy un poco perdido en este momento.

    
pregunta rcplusplus

1 respuesta

3

Algunas posibilidades, dependiendo de la cantidad de pines que quieras gastar para conducirlos.

  1. 2 registros SR en el segmento y 16 pines individuales para visualización individual.

  2. 2 registros SR en el segmento más dos registros SR para la pantalla 16, controlados independientemente. Esto permite una actualización de pantalla muy rápida de dígitos a dígitos.

  3. 4 SR se registran juntos. La menor cantidad de pines utilizados y la más lenta.

Para obtener soluciones más estáticas, busque controladores dedicados como max7219 o su equivalente moderno.

editar:

Puse esto junto con un viejo proyecto mío para demostrar el enfoque mencionado en el # 2 anterior: impulsa hasta 8 dígitos de 14 segmentos de leds con cuatro pines. 

//display a digit in lRAM[SRDIG_CNT]
//blanking optional - currently disabled
void ledx14_display(void) {
    static uint8_t cnt = 0x00;              //lsb first
    static uint16_t tmp=0;                  //pick up the current char

    //blanking the segments
    //ledx14seg_write(0);                       //active high segments
    //ledx14seg_write(0);

    //shift to the next digit
    IO_SET(SRDIG_PORT, SRDIG_SCLK);         //sclk on positive edge
    IO_CLR(SRDIG_PORT, SRDIG_SCLK);

    //send the segment data
    ledx14seg_write(tmp >> 8);              //send the msb first
    ledx14seg_write(tmp);                   //send the lsb

    //strike out the digit data
    IO_SET(SRSEG_PORT, SRSEG_SLAT);         //strike out data on positive edge
    IO_CLR(SRSEG_PORT, SRSEG_SLAT);

    //advance to the next digit
    cnt = (cnt == SRDIG_CNT - 1)?0x00:(cnt+1);  //advance to the next digit
    if (cnt==0) IO_CLR(SRSEG_PORT, SRSEG_SDI);  //digit active low (common cathod)
    else IO_SET(SRSEG_PORT, SRSEG_SDI);
    tmp = lRAM[cnt];
}

aquí está la pantalla siendo controlada por un 12f675. los tres registros SR comparten pines SDI / SLAT pero con sus propios pines SCLK.

los datos que se muestran (correctamente puedo agregar) son 0x0101, 0x0202, 0x0303, 0x0404, de izquierda a derecha. Cada dígito tarda 0.3ms en actualizarse. o 2.4ms para los 8 dígitos. 100 bytes de flash y 24 bytes de ram.

tal como está, el código puede manejar hasta 8 dígitos. con la adición de un registro de desplazamiento y sin aumento de pines, el código puede manejar 16 dígitos.

trasladarlo a un arduino debería ser bastante fácil.

espero que ayude.

    
respondido por el dannyf

Lea otras preguntas en las etiquetas

74hc165 invirtiendo los pines 15 y 2, ¿funciona? ¿Cómo copiar un polígono en águila de una capa a varias otras en el editor de la biblioteca (paquete)?