Multiplexación de 7 segmentos muestra con Arduino y registros de cambio (3 / 5 paso)

Paso 3: Tiempo de código!

Para empezar te aquí es un esquema simple que mostrará 456 con decimales en forma de retraso de tiempo para demostrar la multiplexación. También hice flexible para dar cabida a diversas configuraciones que tenga. La fuente también está disponible en la parte inferior para descargar. Asegúrese de entender el código en primer lugar, y luego copiar y pegar en un dibujo nuevo. A continuación, realizar los ajustes necesarios a las variables y asignaciones de las patillas ya que pueden ser diferentes en su situación. Una vez hecho esto, sube a la Arduino.

Una cosa que debe tener en cuenta es la dirección del flujo de datos. Si te acuerdas de mi esquema, la izquierda más cambio de registro recibirá el primer byte pero descargará los datos de la SER a si se recibe otro byte. Por lo tanto, si usted quiere enviar 11111111 al dígito del extremo derecho, tendría que cambiar a 11111111 y 00000000 y finalmente 00000000. No te preocupes, esto es manejado automáticamente por el código.

CÓDIGO DE INICIO

/*
Código para interfaz con displays de 7 segmentos
método de multiplexación
y el cambio de TPIC6B595 registro (1 dígito)
Por K.O.
*/

Asignaciones de pines (debe cambiar estos)
const int CLK = 9;           Conectado al pin de TPIC 13: SRCLK (también conocido como reloj)
const int cierre = 10;          Conectado al pin de TPIC 12: RCLK (también conocido como cierre-carga-CS/SS...)
const int OE = 11;          Conectado al pin de TPIC 9: OE (salida activar)
const int duda = 12;          Conectado al pin de TPIC 3: SER (aka MOSI)

Patrones de números (0-9)
Drenajes de 0-7 deben estar conectados a los segmentos A-DP respectivamente ***
const numTable de bytes [] =
{
B11111100,
B01100000,
B11011010,
B11110010,
B01100110,
B10110110,
B10111110,
B11100000,
B11111110,
B11110110
};

Variables globales
int numDevices = 1;                       El número de dígitos x Mostrar módulos va a usar
int maxDisplays = 3;                      La muestra máximo que se podía acomodar (ver Nota 1)
int maxDigits = 3;                        Las cifras máxima por que va a mostrar display de módulo (cada SR puede manejar un máximo de 8 dígitos)
int SRData [3] [3];                         La ubicación de almacenamiento para la información de dígitos. Debemos especificar una matriz fija en tiempo de compilación (ver Nota 2)
depuración booleano = true;                     Cambie a true para imprimir mensajes
int delayTime = 1000;                     Opcional (sólo para demostrar la multiplexación)

/*
Notas
1. se recomienda utilizar una fuente externa para evitar oversource el microcontrolador/que se hunde
o si necesita alto voltaje, alta corriente muestra. Este código se activa o desactivar todos los segmentos de un dígito para *** cada *** Mostrar.
Por lo tanto, si uso 2 x 3 dígitos muestra todos mostrando un 8 + DP, el consumo máximo será:
20 mA (corriente delantera lo desea) * 8 (segmentos que están en) * 2 (pantallas que muestran información idéntica) = 320mA
2. la primera dimensión debe ser igual a maxDisplays. La segunda dimensión debe ser igual al número de dígitos
*/

void setup()
{
Serial.Begin(9600);

Modos de juego pin
pinMode(CLK,OUTPUT);
pinMode(LATCH,OUTPUT);
pinMode (duda, salida);
pinMode (OE, salida);

Init Display de 7 segmentos
digitalWrite(OE,LOW);        Permite la operación de SR
initializeSRData();          Prepara SR y borra datos en línea serial

Prueba
setDigit(0,0,4,true);
setDigit(0,1,5,true);
setDigit(0,2,6,true);
}

void loop()
{
refreshDisplay();            Recorre todas las pantallas y dígitos
}

=== Funciones de SR Inicio ===
void initializeSRData()
{
Escáner de pantalla (repite a través de cada módulo de la pantalla)
digitalWrite(LATCH,LOW);      Dice SRs todos que eso uController está enviando datos

para (dispID int = 0; dispID < maxDisplays; dispID ++)
{
Escáner de dígitos (repite a través de cada SR (dígitos) en un módulo de pantalla)
para (int cifras = 0; dígitos < maxDigits; dígitos ++)
{
Borra cualquier basura en la línea serie
shiftOut(DOUT,CLK,LSBFIRST,0);          Cambiar a 0s a todas las pantallas
SRData [dispID] [cifras] = 0;              Almacena un 0 para cada dígito entonces su totalmente apagado
}
}
digitalWrite(LATCH,HIGH);      Cuenta SRs todos que eso uController se hace envío de datos
}

void printSRData()
{
if(!debug)
retorno;

Serial.println ("impresión SR datos...");

Escáner de pantalla
para (dispID int = 0; dispID < maxDisplays; dispID ++)
{
Serial.Print ("ver #");
Serial.println(dispID);

Escáner de dígitos
para (int cifras = 0; dígitos < maxDigits; dígitos ++)
{
Serial.Print ("dígitos");
Serial.Print(digit);
Serial.Print(":");
Serial.println(SRData[dispID][Digit],bin);
}
Serial.println();
}
}

void setDigit (int dispID dígito int, int valor, boolean dp)
{
Comprobador de parámetro
Si (dispID < 0 || dispID > = numDevices)
{
Serial.println ("identificador dispID OoB!");         OoB = fuera de los límites
retorno;
}

Si (dígitos < 0 || dígitos > maxDigits)
{
Serial.println ("dígito OoB!");
retorno;
}

Si (valor < 0 || valor > 9)
{
Serial.println ("valor no válido!");
retorno;
}

valor = numTable [valor];

Dp de la palanca si es necesario
if(DP)
valor | = B00000001;          Se convierte en el primer dígito binario (segmento) con una máscara de bits OR

Almacenar los dígitos
SRData [dispID] [cifras] = valor;

if(debug)
printSRData();
}

void setSegments (int dispID, int dígitos, valor de byte)
{
Comprobador de parámetro
Si (dispID < 0 || dispID > = numDevices)
{
Serial.println ("identificador dispID OoB!");
retorno;
}

Si (dígitos < 0 || dígitos > maxDigits)
{
Serial.println ("dígito OoB!");
retorno;
}

Si (valor < 0 || valor > 255)
{
Serial.println ("bytes no válida!");
retorno;
}

Almacenar los dígitos
SRData [dispID] [cifras] = valor;

if(debug)
printSRData();
}

void clearDisplay(int dispID)
{
initializeSRData();
refreshDisplay();
}

void refreshDisplay()
{
Escáner de dígitos
para (int cifras = 0; dígitos < maxDigits; dígitos ++)
{
Escáner de pantalla
digitalWrite(LATCH,LOW);
para (int dispID = numDevices - 1; dispID > = 0; dispID--)
{
Los dígitos blanker (cambios a 0s para corregir dígitos antes de enviar datos de segmento a dígito deseado)
para (int espacios = (maxDigits - 1 - dígito); blancos > 0; blancos--)
shiftOut(DOUT,CLK,LSBFIRST,0);

shiftOut(DOUT,CLK,LSBFIRST,SRData[dispID][digit]);

Dígitos después blanker (cambios a 0s a dígitos restantes)
para (int espacios = dígitos; blancos > 0; blancos--)
shiftOut(DOUT,CLK,LSBFIRST,0);
}
digitalWrite(LATCH,HIGH);

Demuestra la operación multiplexación
Delay(delayTime);
delayTime-= 10;
Si (delayTime < = 0)
delayTime = 0;
}
}

=== Funciones de SR extremo ===

CÓDIGO FINAL