Multiplexing 2-Seven Segment Displays using ARM 7

Navega tus respuestas
1

Actualmente estoy tratando de controlar dos pantallas de siete segmentos desde los mismos 7 pines (P0.0 - P0.6) de un microcontrolador ARM 7. Primero estoy probando esto en el software de simulación Proteus.

Sigo el esquema de este tutorial de multiplexación 8051 , sin embargo, mi segmento 7 las pantallas están conectadas desde el Puerto 0.0 al Puerto 0.6 y los dos transistores de control están conectados en P0.7 y P0.8.

Estoy bastante seguro de que la pantalla de siete segmentos y los transistores de mi simulación están conectados correctamente y que el problema surge del siguiente código. También he probado mi código para asegurarme de que estoy mostrando los números correctos y que los pines del transistor están configurados según lo requerido.

El problema que encuentro es que ambos dígitos se imprimen en ambas pantallas , en lugar de que la primera pantalla muestre 1 y la segunda pantalla muestre 2 . 

 #include <LPC21xx.h>
 #define a 0x00000001 
 #define b 0x00000002
 #define c 0x00000004
 #define d 0x00000008
 #define e  0x00000010
 #define f 0x00000020
 #define g 0x00000040
 #define T2 0x00000080
 #define T1 0x00000100

 void small_delay (void);

 int main (void)
{

PINSEL0 = 0;                        //Set P0.0 - P0.15 as GPIOS
PINSEL1 = 0;                        //Set P0.16 - P0.31 as GPIOS
IO0DIR  = 0xFFFFFFFF;               //Set all port0 pins as outputs          



    while (1){  

    IO0SET = e;      //displaying number 1              
    IO0SET = f;      //displaying number 1 
    IO0SET = T1;     //switching on first display
    small_delay();   //calling short delay
    IO0CLR = T1;     //clearing first display

  IO0SET = a;       //displaying number 2
  IO0SET = b;       //displaying number 2
  IO0SET = g;       //displaying number 2
  IO0SET = e;       //displaying number 2
  IO0SET = d;       //displaying number 2
  IO0SET = T2;      //switching on first display
  small_delay();    //calling small delay
  IO0CLR = T2;      //clearing second display
    }

}

void small_delay (void) 
{
unsigned int i, j;

for (i=0; i<10; i++)
 {  
    //do nothing
 }
}

Esto es lo que estoy tratando de lograr con el código anterior:

  1. Envíe los datos 1 a ambas pantallas.
  2. Habilitando el segmento de la izquierda siete usando IO0SET = T1;
  3. Llamando un delay corto.
  4. Deshabilitar el segmento siete izquierdo utilizando IO0CLR = T1;
  5. Enviando datos 2 a ambas pantallas.
  6. Habilitando el segmento siete derecho usando IO0SET = T2;
  7. Llamando un delay corto.
  8. Deshabilitar el segmento siete derecho usando IO0CLR = T2;
  9. Repetir.

¿Hay alguna falla en esta lógica? Cualquier sugerencia / idea con respecto a lo que estoy haciendo mal en mi codificación sería muy apreciada.

    
pregunta Rizzo

2 respuestas

3

Está activando segmentos individuales, pero nunca los vuelve a desactivar, por lo que el resultado es que muestra un 1 y un 2 superpuestos en ambas pantallas.

Cambie sus sentencias IO0CLR = T1 e IO0CLR = T2 en IO0CLR = 0x000001FF para desactivar todos los segmentos, así como los dos ánodos comunes. Luego, sus productos estarán listos para la configuración de los nuevos patrones de segmento.

    
respondido por el Finbarr
2
  

Esto es lo que estoy tratando de lograr con el código anterior:

hay muchos ejemplos de este tipo en la red para que los busque. Todo bastante fácil de entender.

y funciona mejor también.

Aquí está mi versión: 

//display the content of vRAM[8]
void _7seg_display(void) {
    static unsigned char digit=0;                       //digit to be displayed

    DIG_OFF(DIGs);                                      //turn all digits off
    _7SEG_ON(_7seg_font[vRAM[digit]]);                  //display the digit
    //DIG_ON(1<<digit);                                 //turn on the digit
    switch (digit) {
    case 0:
        DIG_ON(DIG0);
        break;
    case 1:
        DIG_ON(DIG1);
        break;
    case 2:
        DIG_ON(DIG2);
        break;
    case 3:
        DIG_ON(DIG3);
        break;
    case 4:
        DIG_ON(DIG4);
        break;
    case 5:
        DIG_ON(DIG5);
        break;
    case 6:
        DIG_ON(DIG6);
        break;
    case 7:
        DIG_ON(DIG7);
        break;
    }
    digit+=1;                                           //increment the digit
    if (digit==_7SEG_NUMBER) digit=0;                   //reset the digit
}

es bastante simple en eso

  1. es independiente del hardware - > lo que significa que simplemente puede copiarlo en un nuevo proyecto y definir ciertas macros para ese proyecto / plataforma, volver a compilar y funcionará.

  2. sigue una lógica simple: inhibe el dígito actual, coloca nuevos datos en los segmentos y luego activa el siguiente dígito.

  3. el código se puede llamar periódicamente a través de una interrupción del temporizador o incluso en el bucle principal.

  4. admite hasta 8 dígitos - > puede ampliarse a más si lo desea.

Una vez más, la clave es asegurarse de que escribes tu código independientemente del hardware para poder reutilizarlo.

    
respondido por el dannyf

Lea otras preguntas en las etiquetas

¿Este condensador es adecuado para el convertidor elevador (ESR bajo)? ¿Cuál es la ruta de retorno actual en esta condición