¿Cuál es la forma "aceptada" de manejar MUCHAS pantallas de cátodo común de 2 dígitos y 16 segmentos?

Tengo un proyecto que tiene 18 de estas pantallas de cátodo común, 36 dígitos en total, organizadas en tres filas de 12 dígitos. Mi primera versión del proyecto usó un Arduino y registros de desplazamiento para controlarlos. Desplazaría la columna 0 de dígitos, los trabaría para proporcionar energía a las pantallas y luego conectaría a tierra la columna 0. Esto mostraría el primer carácter. Luego, cambiaría la siguiente columna de datos, desactivaría el suelo en la columna 0, bloquearía la columna 1 y proporcionaría suelo a la columna 1 para mostrárselo al usuario.

Funciona, pero tiene un par de problemas. Es muy, muy, muy tenue. Puedo hacerlo más brillante manteniendo cada pantalla encendida un rato más, pero no llega muy lejos, y puedes sentir la baja frecuencia de actualización cuando la miras. Además, si tengo una columna que tiene muy pocos segmentos activos, consumen toda la corriente que estoy suministrando y esa columna termina siendo mucho más brillante que el resto.

Tengo una tonelada (¿diría que tengo "una plétora"?) de controladores LED MAX-7219, pero hay un inconveniente: el controlador LED asume un máximo de 8 segmentos por cátodo. Consideré usar un controlador LED para controlar la mitad de los segmentos en 8 dígitos y otro controlador para la otra mitad. Esto (probablemente) funcionaría: simplemente desactivaría la pantalla en la mitad superior y activaría la inferior, luego revertiría el proceso unos milisegundos más tarde.

Realmente quiero que el dibujo sea de fuego y olvido. Tengo que generar los datos que estoy mostrando, y esto lleva tiempo. Durante este tiempo, realmente no puedo estar quemando la CPU, fallando las pantallas. (Técnicamente, podría colocar un temporizador, pero tendría que detener el temporizador mientras extraía nuevos datos, y ese temporizador podría interferir con la biblioteca LedController, así como con las comunicaciones en serie que estoy usando para obtener los datos de un módulo GPS, de todos modos.)

Entonces, ¿hay alguna manera de que pueda cambiar 36 dígitos de datos y olvidarme por completo de ellos durante 100-1000 ms, dejando el trabajo de controlar la pantalla en el hardware de otra persona? Incluso he considerado tener un arduino para procesar datos, luego transferirlos, de alguna manera, a otros tres, o incluso seis, arduinos para su visualización.

Al hacer este tipo de trabajo, NO usa código de biblioteca. Escribí software en un núcleo 8051 verdaderamente estúpido, usando el C8051F061, que tomó datos ADC de 16 bits a 1 MHz, procesó los datos en tiempo real, generó resultados de medición rápidos y, al mismo tiempo, actualizó una pantalla. Incluso escribí un O/S de subprocesos múltiples para que el código también estuviera bastante limpio. ¡Ese maldito dispositivo solo tiene 1 DPTR, por lo que copiar bloques es doloroso! ¿Está buscando una recomendación de producto? ¿O estás buscando hacer esta cosa de "disparar y olvidar".
Hay muchas maneras de hacer esto, lo que es aceptable realmente depende de su aplicación y presupuesto.
Además, ¿quiere decir que está usando una pantalla que tiene (2) pantallas de 7 segundos más puntos decimales? ¿O está usando (2) de esas elegantes cosas de dígitos de 16 segundos en la pantalla? No me queda claro.
@Trevor He encontrado algunos controladores que harán el truco, ICM7245, por ejemplo, pero cuestan alrededor de $ 20 CADA UNO. Tengo 30 MAX7219 por ahí y me gustaría descubrir cómo usarlos, si es posible. Estoy jugando con la idea de usar 2 7219 por 8 dígitos, y tener un 555, un inversor y un par de transistores para alternar entre ellos para mostrar la mitad del carácter a la vez. Siempre que la frecuencia de actualización del 555 sea mucho menor que la frecuencia de conmutación del 7219, debería funcionar. Experimentaré con él tan pronto como llegue mi pedido de 555 e inversores. =]
@jonk Los paquetes tienen dos dígitos cada uno, 16 segmentos por dígito. 18 pines, dos son cátodos que seleccionan que dígito mostrar y al resto de pines se les asigna el mismo segmento en ambos dígitos.
@user30997 Con el MAX7219, 320 mamá es la única garantía que tiene, por "dígito", que funciona para 40 mamá por LED. Con 1/8 de servicio, esto implica un promedio de 5 mamá por LED con fines de comparación de brillo. ¿Es ese un nivel de brillo medio aceptable para ti? Entonces, dos MAX7219 tienen 16 segmentos (necesarios) y 16 pines de hundimiento, pero solo 2 cátodos comunes para hundir. Probablemente podría unir pines de hundimiento para aumentar las corrientes. Si hizo esto en pares, necesitaría (9) MAX7219 para los 36 dígitos, con 10 mamá por LED promedio. Podría ir por ese camino.
@ user30997 Además, ¿tiene un enlace para la pantalla de 2 dígitos? Soy curioso.
@ usuario30997 Está bien. Esa es una pantalla de 14 segmentos. Hay pantallas de 16 segmentos que también son geniales. El tuyo incluye un DP. ¿Planea incluir el DP de todas las pantallas?
@jonk Si uso el punto decimal, solo estará en la tercera columna. He estado experimentando con la pantalla y creo que es lo suficientemente brillante como para funcionar conmigo. Si termino trabajando con la solución 555, tendrán la mitad del brillo máximo, pero puede que no haya forma de evitarlo.
Supongo que podría quedarme con los registros de desplazamiento, pero tener suficientes (72!) ellos para mostrar la otra mitad. =] El costo de esa solución sería un poco menor (para circuitos integrados) que los controladores LED, pero usaría más espacio en la placa.

Respuestas (2)

La oscurecimiento y el brillo variable pueden tener dos causas:

  • Estás MUXing demasiados (¿36?).

  • Sus resistencias limitadoras de corriente LED están en la pata COMÚN, no en cada una de las patas LED.

Muxing más de aproximadamente 8 requiere el interruptor desplegable de cátodo común para extraer demasiada corriente, especialmente cuando todos sus dígitos son "8". Un MOSfet de canal N discreto podría manejar la corriente requerida del controlador de cátodo común. Podría considerar conectar en cadena cuatro registros de desplazamiento y empujarlos a nueve MUX (arreglo de 4 x 9).

Para los ánodos, puede salirse con la suya con los registros de desplazamiento HCMOS (HC164, HC595). Aun así, ayuda comenzar con segmentos de LED eficientes que brindan un brillo decente a 1 mA CC. Los cambios se pueden hacer bastante rápido, de modo que el tiempo para cambiar cinco HC164 conectados en cadena no consuma el período MUX (que debería repetirse más rápido que 30 por segundo, de lo contrario se vuelve ópticamente molesto). Aún debe optimizar el código de cambio para la velocidad. La celda de cambio básica podría verse así (haga 9 filas más de esto):

esquemático

simular este circuito : esquema creado con CircuitLab

Esos nueve MOSfet necesitan una forma de controlar sus puertas. Se puede usar un HC595 para controlar los MOSfets, simplemente cambiando un solo "1" en un anillo. Es posible que necesite dos HC595 para obtener el bit adicional (para obtener un registro de desplazamiento de 9 bits). Su salida de tres estados se puede usar para apagar todos los LED mientras cambia si las rutinas de interrupción tardan demasiado o si el parpadeo de fondo distrae: la resistencia de puerta desplegable de 5k asegurará que todos los MOSfets se apaguen.
Eso es mucho cableado y muchas resistencias. Es probable que cause algo de RFI: intente cablearlo todo muy compacto.
Todo el cambio podríahacerse como un proceso en segundo plano: no necesita un temporizador y puede ser interrumpido fácilmente por sus otros periféricos siempre que sus controladores finalicen en un tiempo razonable. Considere usar el temporizador de vigilancia como el temporizador MUX (si tiene pocos temporizadores), si se puede configurar de manera aproximada en aproximadamente 3 ms.

Como probablemente ya sepa, no existe un método "aceptado". Es un conjunto de compensaciones que solo usted está en una mejor posición para resolver. Solo necesitas usar tu imaginación.

No comprendo completamente su situación. Pero has escrito lo suficiente al respecto que puedo ofrecer un pensamiento o dos. Deduzco que le gustaría usar sus dispositivos MAX7219. Y ya tienes las pantallas que mencionaste también.

Así que algo como esto:

esquemático

simular este circuito : esquema creado con CircuitLab

Se utiliza un MAX7219 para la "mitad superior" de sus pantallas. El otro se usa para la "mitad inferior". Esto obtiene una cobertura completa para todos sus segmentos. El único otro problema son las unidades de dígitos. Para esta situación, activa ambos dispositivos MAX7219. Sin embargo, si imagina que cada pantalla de 2 dígitos tiene cuatro cuadrantes, entonces el MAX7219 superior controla el cuadrante superior izquierdo mientras que el MAX7219 inferior controla el cuadrante inferior derecho. Y luego, en el siguiente período, el MAX7219 superior maneja el cuadrante superior derecho mientras que el MAX7219 inferior maneja el cuadrante inferior izquierdo. Esto mantiene separadas las corrientes de retorno del cátodo. Se necesitan dos períodos para completar un dispositivo de visualización de 2 dígitos. Ocho períodos cubre cuatro pantallas de 2 dígitos, u 8 dígitos en total, y lo hace con solo dos controladores MAX7219 que usan 1 8 ciclos de trabajo

Sin embargo, tendrás que resolver los problemas de disipación. No me he molestado en pensar en esa parte. Tampoco he pensado más en la intensidad media que podrías sacar de esto, más allá de lo que ya mencioné en comentarios.


Si desea que esto sea "dispara y olvida", necesitará otro microcontrolador para operar esta pantalla por usted. Esa no es una tarea difícil. Pero agrega otra MCU y su cadena de herramientas de software y hardware asociada. Y eso puede ser un problema. Pero también una ventaja. Simplemente "descargaría" los datos de la pantalla, permitiéndole almacenarlos en su propia RAM, y luego simplemente se iría hasta la próxima vez que necesite actualizar esos datos de la pantalla.

Por otro lado, no es difícil configurar un evento de temporizador en su sistema actual que funcione completamente "en segundo plano". Puede usar su propio software para "pre-preparar" todos los 8 estados de datos para transmitirlos a 8 búferes simples (dados los datos de visualización que deben mostrarse primero), entre los cuales el evento del temporizador simplemente alterna y luego regresa encima. El software de preparación previa puede ejecutarse en código regular en cualquier momento, completamente independiente de los eventos del temporizador de visualización. Todo lo que hace es establecer un "mensaje de cambio" que busca el evento del temporizador para cambiar al siguiente conjunto de 8 búferes, una vez que completa un ciclo de visualización anterior, liberando la memoria para que los últimos datos de visualización sean utilizados por tu código la próxima vez. ("Doble almacenamiento en búfer".)

Tú decides.