¿Cómo conectar esta pantalla LED de 7 segmentos a Arduino?

Tengo la siguiente pantalla LED, que quiero conectar a Arduino UNO.

De acuerdo con la hoja de datos , hay pin de reloj. ¿Tengo que construir una fuente de reloj externa para él o puedo alimentarlo desde Arduino?

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

Cualquier consejo práctico sobre cómo conectarse será apreciado.

Actualizar:

Gracias a Oli Glaser, creé un boceto para Arduino y lo presento aquí, en caso de que alguien tenga el mismo tipo de pantalla LED.

const int CLOCK_PIN = 2; 
const int DATA_PIN  = 3; 
const int DATA_EN_PIN  = 4; 

const byte numbers[16] = {
                    0b11111100,
                    0b01100000,
                    0b11011010,
                    0b11110010,
                    0b01100110,
                    0b10110110,
                    0b10111110,
                    0b11100000,
                    0b11111110,
                    0b11100110,
                    0b11101110,
                    0b00111110,
                    0b10011100,
                    0b01111010,
                    0b10011110,
                    0b10001110
};

void loadLed(byte d1, byte d2, byte d3)
{
  digitalWrite(DATA_EN_PIN, 0);

  digitalWrite(DATA_PIN, 1);
  digitalWrite(CLOCK_PIN, 1);
  delayMicroseconds(5);
  digitalWrite(CLOCK_PIN, 0);
  delayMicroseconds(5);

  for (int i=7; i >= 0; i--)
  {
    if(d1 & (1 << i))
      digitalWrite(DATA_PIN, 1);
    else
      digitalWrite(DATA_PIN, 0);
    digitalWrite(CLOCK_PIN, 1);
    delayMicroseconds(5);      
    digitalWrite(CLOCK_PIN, 0);
    delayMicroseconds(5);
  }

  for (int i=7; i >= 0; i--)
  {
    if(d2 & (1 << i))
      digitalWrite(DATA_PIN, 1);
    else
      digitalWrite(DATA_PIN, 0);
    digitalWrite(CLOCK_PIN, 1);
    delayMicroseconds(5);      
    digitalWrite(CLOCK_PIN, 0);
    delayMicroseconds(5);
  }

  for (int i=7; i >= 0; i--)
  {
    if(d3 & (1 << i))
      digitalWrite(DATA_PIN, 1);
    else
      digitalWrite(DATA_PIN, 0);
    digitalWrite(CLOCK_PIN, 1);
    delayMicroseconds(5);      
    digitalWrite(CLOCK_PIN, 0);
    delayMicroseconds(5);
  }

  for (int i=0; i <= 10; i++)
  {
    digitalWrite(DATA_PIN, 0);
    digitalWrite(CLOCK_PIN, 1);
    delayMicroseconds(5);      
    digitalWrite(CLOCK_PIN, 0);
    delayMicroseconds(5);
  }
  digitalWrite(DATA_EN_PIN, 1);
}

void setup()
{
  pinMode(CLOCK_PIN, OUTPUT);
  pinMode(DATA_PIN, OUTPUT);
  pinMode(DATA_EN_PIN, OUTPUT);
  delay(100);
  loadLed(numbers[7], numbers[8], numbers[3]);
}


void loop()
{
}

Por supuesto, esto se puede optimizar, pero hay un pequeño problema: cada quinto reinicio del tablero mostrará basura aleatoria. Traté de jugar con retraso, establecido en 50, no es bueno. Buscando solución.

Su imagen original era muy grande. La reduje de imagen de 3.1 Mpix a 160 kpix sin pérdida de información.

Respuestas (1)

Los pines de reloj y datos son para su entrada en serie. Estos se pueden controlar directamente desde el Arduino, simplemente conecte cada uno a una salida digital.

Para la rutina de datos, según la hoja de datos, hay un bit de inicio, seguido de 35 bits de datos que corresponden a la tabla "Secuencia de entrada en serie" en su pregunta.

Cree una función en su "boceto" para controlar la carga en serie, algo como a continuación: no he verificado este código. Solo necesita llamarlo cada vez que desee actualizar la pantalla.
Tendrá que reemplazar el set_data_piny set_clock_pincon las llamadas Arduino correctas a los pines GPIO que haya conectado a los pines de datos del reloj en la pantalla (no uso Arduino, así que no los conozco) Lo mismo para el (retraso de microsegundos) delay_usque se puede ajustar a cualquier tiempo que desee hasta una velocidad de reloj de 500 kHz; puede agregar una definición para el valor para guardar el cambio de cada uno.
Cada segmento se desplaza de MSB a LSB, lo que corresponde con A(MSB) a DP(LSB) para cada carácter de entrada:

void load_data(char seg1, char seg2, char seg3)
{
    char i, temp;
    char position = 0;

    set_data_pin(1);  // clock start bit in
    set_clock_pin(1);
    delay_us(5);
    set_clock_pin(0);
    delay_us(5);

    temp = seg1;
    while(i<8)
    {
        set_data_pin(temp & 0x80);  // set data pin
        set_clock_pin(1);
        delay_us(5);
        set_clock_pin(0);
        delay_us(5);
        i++;
        temp = temp << i; // shift next bit out
    }

    temp = seg2;
    while(i<8)
    {
        set_data_pin(temp & 0x80);  // set data pin
        set_clock_pin(1);
        delay_us(5);
        set_clock_pin(0);
        delay_us(5);
        i++;
        temp = temp << i; // shift next bit out
    }

    temp = seg3;
    while(i<8)
    {
        set_data_pin(temp & 0x80);  // set data pin
        set_clock_pin(1);
        delay_us(5);
        set_clock_pin(0);
        delay_us(5);
        i++;
        temp = temp << i; // shift next bit out
    }

    // Last 11 bits - do something here if needed
    while(i<11)
    {
        set_data_pin(0);  // set data pin
        set_clock_pin(1);
        delay_us(5);
        set_clock_pin(0);
        delay_us(5);
        i++;
    }
}

Conexiones

  • Conecte el pin VDD a +5V y el pin VSS a tierra (0V)
  • Conecte los pines VLED a +5V también.
  • Conecte el pin DATA ENABLE bajo (es decir, a tierra), ya que está activo bajo .
  • Para los pines Bits 25-34, déjelos desconectados si no desea usarlos, de lo contrario, puede usarlos como salidas digitales. No los ate alto o bajo (es decir, no los conecte a +5V o tierra)
  • Para el pin BC (control de brillo), puede usar solo una resistencia para fijar el brillo, o un potenciómetro y una resistencia para controlar el brillo de la pantalla.
    Para calcular el valor, podemos usar la información en la hoja de datos:

    1. el maximo absoluto I F (corriente directa) para la pantalla es de 30 mA (pág. 2)
    2. La corriente de la pantalla suele ser 36 veces mayor que la corriente en el pin BC (pág. 4) y la corriente máxima en el pin BC es 550 m A (pág. 5)

    Entonces, con esta información, podemos calcular el mejor valor para el bote. Si nuestro objetivo es un máximo operativo típico de 20 mA, entonces:

    + 5 V 20 metro A ÷ 36 = 9 k Ω

    Este es el valor mínimo de resistencia que usaríamos (conectado entre +5V y pin BC)
    Si queremos variar la corriente, digamos de 10 metro A 20 metro A , entonces podemos agregar un 9 k Ω pot en serie con la resistencia con su limpiaparabrisas conectado a un extremo (cualquiera de los extremos) Luego, la corriente varía entre:

    + 5 V 9 k Ω × 36 = 20 metro A

    con la olla girada completamente hacia el otro lado

    + 5 V 9 k Ω + 9 k Ω × 36 = 10 metro A

    Tenga en cuenta que la hoja de datos no es particularmente útil con los detalles sobre el pin de control de brillo: muestra el potenciómetro configurado para un control de voltaje variable en el diagrama, lo que confunde un poco las cosas. Simplemente ignoré este diagrama y tomé lo que está escrito como correcto. También asumo que la resistencia está en los 5V completos (es decir, el pin BC está justo por encima de 0V), lo que probablemente no sea el caso, pero es mejor ser conservador si no se dan detalles.
    Esto significa que es posible que deba experimentar un poco para obtener el brillo correcto; si es demasiado tenue, intente cambiar a una resistencia más baja.

gracias, intentaré "convertirlo" a Arduino en breve y le responderé con más preguntas. Mientras tanto, ¿tengo que llamar a esto solo una vez o continuamente? ¿Debo dar 1 al pin de habilitación de datos (conectar a + 5 V)?
¿Debo conectar VDD y VLED a Arduino +5V?
Solo necesita llamarlo cada vez que desee actualizar la pantalla. Actualicé la respuesta un poco con más detalles.
Esto funcionó muy bien, sin embargo, como mencioné en mi actualización, aproximadamente cada quinto reinicio producirá basura.
Parece que puede ser un problema separado, posiblemente no relacionado con el código (al menos no con la parte que muestra). Intente agregar un retraso razonable (p. ej., 100 ms) al inicio (p. ej., al final de una rutina de inicio) antes de enviar datos a la pantalla. Si esto no ayuda, necesitaremos más detalles para solucionarlo. Comenzaría una nueva pregunta y mencionaría exactamente lo que está sucediendo (proceso de reinicio utilizado, fuente de alimentación, qué arduino, cualquier dato de alcance/multímetro tomado, etc.)
@Pablo - Vaya, olvidé agregar el segundo retraso en las rutinas, lo siento. He actualizado - intente agregar esto.
He actualizado el código también. No es bueno. Parece que tiene algo que ver con la llamada inicial justo después de reiniciar (presiono el botón de reinicio en el Arduino, o simplemente lo cargo desde el IDE de Arduino). Si hago una cuenta regresiva, la basura cargada inicialmente se sobrescribirá y nunca ocurrirá. Estoy subiendo un video para demostrar el problema. Me temo que si creo una nueva publicación, puede considerarse duplicada :)
Puede intentar conectar el pin de habilitación de datos a un GPIO y mantenerlo alto hasta que desee cargar algunos datos (es decir, agregarlo a la rutina). Además, agregue una resistencia de 10k desde el pin de habilitación de datos a V+ para asegurarse de que esté alto hasta que el Arduino se inicializa y toma el control de la línea (haga esto al principio de la rutina de inicio)
¡Bingo! ¡La habilitación de datos lo hace totalmente estable! ¡Impresionante! ¡Actualicé el código y acepté la respuesta perfecta! Entonces, tal vez haya una ráfaga de datos en el medio.