¿Puede alguien explicarme la lógica de programación detrás de la multiplexación de una pantalla de segmento LED?

El truco aquí es que no debe tratar cada dígito como una entidad separada.

Básicamente, la multiplexación es una forma de compartir una pequeña cantidad de pines IO para controlar una mayor cantidad de cosas físicas, en este caso los LED. Esto se llama multiplexación por división de tiempo . La multiplexación es solo una forma de conducir dispositivos N*M con N+M IO pins.

Lo que te falta aquí es que no cuentas para cada dígito internamente. En su lugar, tiene un contador que mantiene el valor del contador global .

Supongamos que el contador interno tiene un valor de 502 . Primero, ilumina el número 1 dígito, con el valor 5 . Luego, ilumina el número 2 dígitos, con el valor 0 , y finalmente, el número 3 dígitos con el valor 2 . No hay un incremento o realmente ningún conocimiento de lo que significa el valor 502 .

Si desea incrementar el contador, debe modificar el número del contador interno, no todo lo que tenga que ver con el sistema de multiplexación.

Para una implementación aún más básica, separe todo el concepto de números de la multiplexación. En este caso, tiene una matriz en la memoria que simplemente determina qué LEDs están encendidos. Su sistema de multiplexación simplemente se sienta allí y escanea esa matriz, iluminando cada parte por turno, y nada más . El código que maneja o incluso es consciente de que los valores en la matriz representan números que no saben que los dígitos están multiplexados, o incluso existen. Simplemente sabe que este bit significa que ese LED debe estar iluminado a medida que ilumina cada segmento de la pantalla a su vez.

El código que escribe los valores en la matriz es lo que controla determinar qué orden de bits significa qué dígitos.

Críticamente, el conteo y la multiplexación son procesos separados . Para que la multiplexación sea efectiva en un sistema de visualización, la multiplexación debe ejecutarse rápidamente (más de 100 veces por segundo). Sin embargo, dado que el código que modifica la matriz es independiente, puede ejecutarse mucho más lentamente (por ejemplo, a un ritmo que los humanos pueden rastrear, etc.).

El punto es que contar y mostrar son dos procesos separados.

Para darte una respuesta más práctica, he aquí cómo he hecho esto recientemente en un PIC (nota: estoy en un nivel aleatorio de retoques):

1. Configure un temporizador para que se desborde cada segundo y genere una interrupción. La rutina de interrupción relativa a este temporizador agregará 1 a una variable previamente iniciada y configurará el temporizador para que comience a contar nuevamente (es decir, configure el valor inicial que necesita para que envíe una interrupción después de 1 segundo). Así que tienes una variable que mantiene la cuenta. Este número puede ser entre 000 y 999, por lo que debe agregar un if...else stcuture en esta misma rutina para restablecer la variable a cero si llega al límite.

2. En la página principal, configura un bucle que actualice una matriz de números al ingresar los dígitos del número actual, por ejemplo. si el número es 391, pondrá 3, 9 y 1 en la matriz. Solo haz esto como dis[3]=number/1000; dis[2]=(number-dis[3]*1000)/100; etc. obtienes la deriva, el resto se desecha cada vez. Esto no tiene que hacerse tan a menudo, los humanos son lentos de todos modos. Esto no se hace en la rutina de interrupción porque son cálculos no urgentes y no se puede perder el tiempo allí.

3. Cree otra rutina de interrupción relativa a otro temporizador, configúrela de modo que genere una interrupción aproximadamente 50 veces por segundo, de esta manera no podrá ver cómo se encienden y apagan las pantallas. En esta rutina, apaga todas las pantallas (con pantalla me refiero a la única casilla de 7 segmentos), luego enciende la que desea y muestra el dígito que desea. Luego arregle los bits del temporizador para que la interrupción vuelva a suceder después de 1/50 s. De esta manera, la pantalla permanecerá encendida con ese número hasta la próxima interrupción. La próxima vez, tendrá que mostrar otro dígito, en la siguiente pantalla. Para hacer un seguimiento de esto, use una variable n que va de 0 a 2 y se incrementa en uno cada vez que hay una interrupción del temporizador de la pantalla, y reinicie a 0 antes del final de la rutina de interrupción si ha alcanzado el número 2 (porque tendrá que mostrar el primer / 0º dígito la próxima vez, en la primera / 0ª visualización). De esta manera, el código solo tiene que tomar el elemento nth de la matriz, escribirlo en las pantallas y encender la pantalla nth (por ejemplo, escribir 0x01<<n en el registro que decide qué pantalla está activada, por lo que cambia el 1 al un poco de approriate.

Como puede ver, la pantalla utiliza un temporizador y una rutina de interrupción, y se comporta independientemente del número. El hecho de que esté contando segundos en lugar de mostrar cualquier otro número es completamente irrelevante para la parte de la pantalla.