¿Utilizar display ánodo común en circuito cátodo común? SOLUCIONADO

Anda que he tardado en volver al foro... Ya le estoy cogiendo cariño y todo...

Buenas tardes. Me estoy peleando para intentar hacer un circuito, en el que un display de cuatro dígitos marque la temperatura de un sensor. Pero primero quiero experimentar en circuitos sencillos, para familiarizarme con el manejo del display (el del sensor lo tengo claro y probado).

El caso es que googleando, solo encuentro ejercicios para display con cátodo común, mientras que el mío es de ánodo común. Entiendo perfectamente el comportamiento de un led cómo diodo y entiendo que cambiando la polaridad va o no va. Hasta aquí bien.

Pero el problema que tengo ahora es saber si es posible hacer funcionar un display con ánodo común, en un circuito de cátodo común. Entiendo que en el caso del ánodo común, se conecta uno de los pines (el común) a 5V de Arduino y el resto de pines reciben pulsos de tierra, también de Arduino. Y no veo la manera de pensar en si es posible hacer el cambio.

La pregunta es si ¿es posible hacer trabajar un display con ánodo común, en un esquema de circuito de display con el cátodo común? ¿O no es posible, y cada display debe trabajar con sus circuitos?

Probablemente tenga una solución sencilla, pero ahora mismo no doy con ella.

Gracias por la atención

salu2

Claro, que es posible agrega un ! (negador) antes de que cada salida y funcionará al revés, obviamente si esta bien cableado. Coloca el código, enlace a la librería, esquema y lo verificamos.

Gracias por responder, Surbyte, pero ¡uy! aún no he empezado. En principio estoy buscando algún proyecto que no solamente encienda el "8", si no que además haga algo, cómo contar o descontar con varios dígitos, un reloj o algo así, que me sirva para comprender más sobre displays. Pero me parece que voy a ser más humilde y empezaré por el manejo de un solo led.

¿Te parece que empiece por algo muy fácil, subo un sketch cualquiera con cátodo común y me asesoras del cambio?

Mira, este mismo es de cátodo común. ¿Que debería añadir y donde para hacer el cambio?:

http://hardwarehacking.mx/2013/06/19/leccion-4-arduino-contador-con-display-de-7-segmentos/ 

//Declaramos los pines de salida,
//en el el proyecto asi lo tenemos cableado
int a = 2;
int b = 3;
int c = 6;
int d = 5;
int e = 4;
int f = 1;
int g = 0;//Hacemos que todas nuestras variables sean salidas
void setup(){
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);}

void loop(){
//Cero
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,LOW);

delay(1000);
//Uno
digitalWrite(a,LOW);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);

delay(1000);

//Uno
digitalWrite(a,LOW);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);

delay(1000);

//Dos
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,LOW);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,LOW);
digitalWrite(g,HIGH);

delay(1000);

//Tres
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,HIGH);

delay(1000);

//Cuatro
digitalWrite(a,LOW);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);

delay(1000);

//Cinco
digitalWrite(a,HIGH);
digitalWrite(b,LOW);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);

delay(1000);

//Seis
digitalWrite(a,HIGH);
digitalWrite(b,LOW);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);

delay(1000);

//Siete
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);

delay(1000);

//Ocho
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);

delay(1000);

//Nueve
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);

delay(1000);

}

Hay otra versión más elaborada y con menos codigos en la misma página, pero supongo que las modificaciones serán las mismas:

//Declaramos los pines de salida,
//en el el proyecto asi lo tenemos cableado
int a = 2;
int b = 3;
int c = 6;
int d = 5;
int e = 4;
int f = 1;
int g = 0;

void setup(){
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);}

void escribirEnElDisplay(int va, int vb, int vc, int vd, int ve, int vf, int vg){

digitalWrite(a,va);
digitalWrite(b,vb);
digitalWrite(c,vc);
digitalWrite(d,vd);
digitalWrite(e,ve);
digitalWrite(f,vf);
digitalWrite(g,vg);

}

void loop(){

//Cero
escribirEnElDisplay(1,1,1,1,1,1,0);
delay(1000);
//Uno
escribirEnElDisplay(0,1,1,0,0,0,0);
delay(1000);
//Dos
escribirEnElDisplay(1,1,0,1,1,0,1);
delay(1000);
//Tres
escribirEnElDisplay(1,1,1,1,0,0,1);
delay(1000);
//Cuatro
escribirEnElDisplay(0,1,1,0,0,1,1);
delay(1000);
//Cinco
escribirEnElDisplay(1,0,1,1,0,1,1);
delay(1000);
//Seis
escribirEnElDisplay(1,0,1,1,1,1,1);
delay(1000);
//Siete
escribirEnElDisplay(1,1,1,0,0,0,0);
delay(1000);
//Ocho
escribirEnElDisplay(1,1,1,1,1,1,1);
delay(1000);
//Nueve
escribirEnElDisplay(1,1,1,1,0,1,1);
delay(1000);

}

Gracias, Surbyte, al menos ahora se que se puede hacer...

Bueno, vamos a ir un paso mas adelante de lo que has propuesto. He leído lo que has posteado pero voy a pensar en lo que tienes. Y tienes un display de ánodo comun de 4 displays de 7 segmentos y además multiplexado. Entonces pensemos de ese modo no te parece? Existe una librería de 7 segmentos multiplexada

Esta librería resuelve la mayor parte de los problemas que se te pueden presentar y enumero sus características

  1. Soporta un número arbitrario de dígitos
  2. Soporta displyas con puntos decimales, comas y apóstrofes
  3. Soporta, ánodo, cátodo y otras configuraciones de hardware
  4. Funciones de alto nivel para impresion
  5. Numeros (enteros, punto fijo y flotante)
  6. Cadenas de textos
  7. Tiempos (hh:mm) o (mm:ss)
  8. Multiplexado automático con refrezco ajustable
  9. Brillo ajustable a través de control del ciclo de trabajo
  10. Usa timers (interrupcion) para el multiplexado para bajar el uso de recursos, permitiendo que la MCU ejecute otro código
  11. No shadow artifact (no se traducirlo bien)
  12. PDF guía de usuario incluída

Tiene muchos ejemplos.

¡Uy, uy, uy! Surbyte, no andemos tan deprisa, que la velocidad es mala. Vayamos paso a paso, por que no entiendo nada. La librería que propones ¿para que debería utilizarla? ¿Donde y cómo? Es que partimos de la base que no se (no entiendo) cómo se hace el cambio de polaridad del display, cómo se trabaja con ello.

Y sí, tengo un display de ánodo común de 4 displays de 7 segmentos y multiplexado, y la pregunta es cómo lo utilizo en un proyecto con cátodo común. Pero paso a paso, para que pueda entenderlo y aplicar y/o adaptar el conocimiento a los proyectos.

No leiste nada de nada de lo que te pasé?

La librería es para 7segmentos, la cantidad de digitos que desees, anodo o cátodo común, es lo mejor de lo mejor?
Funciona usando un timer asi que no tienes esfuerzo alguno del CPU y defines que pines usar, los que tengas libres, entonces cual es la duda?

Quieres un ejemplo? vamos al primero usando tu DISPLAY 4 Digitos multiplexado.

Bajas la librería, la instalas, en la carpeta libraries, revisas que quede bien, o sea… que el nombre de la carpeta y los archivos que adentro esten, o al menos uno .cpp y otro .h se llamen igual (puede haber muchos mas pero eso no debe preocuparte).

#include <SevenSeg.h>
SevenSeg disp(11,7,3,5,6,10,2);
const byte numOfDigits = 4;
const byte digitPins[numOfDigits] = {12, 9,8,13};

void setup() {
    disp.setDigitPins(numOfDigits, digitPins);
    disp.setCommonCathode(); // La librería asume que trabajás con Anodo Común sino usas esta línea
    disp.setDPPin(4);   // Pin del Punto decimal
    disp.setTimer(2);   // fija que timer vas a usar
    disp.startTimer();
}

void loop(){
   for (int i=1; i<=10; i++) {
       disp.write(i); 
       delay(1000);
   }
}

ISR(TIMER2_COMPA_vect) {
   disp.interruptAction();
}

Este es un ejemplo que luce COMPLEJO pero no lo es.
Es una receta okay?

Vamos paso a paso.

  1. SevenSeg disp(a,b,c,d,e,f,g)

  2. definis la cantidad de digitos en esta variable, numOfDigits claro que podes llamarla numeroDeDigitos

  3. digitPins[numOfDigits] = {12, 9,8,13}; definis los pines que usas para comandar los Diplays del 1 al 4 en este caso. o del 1 a numOfDigits.
    Se define de izquierda a derecha.

  4. La librería asume que trabajas con ánodo común pero si queres usar cátodo común solo agregas en el setup esto
    disp.setCommonCathode();

  5. disp.setDPPin(4); Establece el pin que controlaré el punto decimal multiplexado.

  6. Finalmente las instrucciones que setean el timer
    disp.setTimer(2); esta indica que usarás el timer 2.

  7. disp.startTimer(); arranca el timer pero requiere que escribas la interrupción correpondiente.

  8. La interrupción correspondiente al TIMER2 es asi. No hay nada que opinar, para mas info, leer timer2.
    ISR(TIMER2_COMPA_vect) {
    disp.interruptAction();
    }

  9. Finalmente como se escribe los datos en el loop.
    Con la instrucción disp.write(numero); podes escribir enteros
    disp.write(“open”); te permite escribir este cartel
    disp.writeFloat(3.13); hará lo propio con este número real.

Pruébalo y me cuentas.

:o Mira, Surbyte, te agradezco mucho que intentes ayudarme, pero veo que no estoy a la altura. No entiendo nada, me supera con creces. Veo que es demasiado complicado para mi, que estoy empezando, se me va de las manos. Voy a pasar del tema displays y me liaré con cosas más a mi abasto.

Necesito empezar por muy abajo, ya que justo entendí cómo funciona un display, y se me escapa de las manos todo este lio de programación. Si no empiezo entendiendo, de manera muy básica, cómo se gobierna un dígito, no llegaré a ningún sitio (me conozco).

Voy a seguir buscando a ver si logro algún proyecto sencillo que esté a mi alcance, para luego ir complicándolo y ganado en complejidad. Tal vez algún día consiga entender todo ese galimatías...

De todas maneras muchas gracias por intentar echarme un cable.

Lo dejo aquí.

salu2

Vamos que yo te ayudo. No es dificil y cuando sepas usarlo verás que tenia razón.
Tu baja la librería. Luego me dices y yo te doy una mano. Ahora te escribo por privado.

Hola, estube buscando informacion del problema que se presenta en este post, en el momento tengo esta situacion:

Estoy intentando aprender a usar el chip 74hc595 con un display de 7 segmentos anodo comun me base en el codigo y circuito que tienen en esta pagina https://geekytheory.com/como-expandir-los-pines-de-arduino/ el tema que me encontre cuando conecte todo (aclaro que entiendo poco de electronica y programacion, osea estoy en una etapa de copio he intento probar) es que no funciono, en la pagina habla de que el segmento es anodo pero lo conecta en el dibujo del circuito como catodo.

Ahora por lo que pude encontrar es si yo tengo un anodo, el arduino tiene que enviar pulsos negativos y aca es cuando me pierdo, dudo en conectar el segmento a los 5v con el sketch presentado en la pagina. Me cuesta entender la parte de hacer que el arduino ordene que por ejemplo el pin 0 del 74ch595 se convierta en gnd para para hacer circuito con el anodo del segmento

Que pasa si le mando los 5v al pin del 74hc595?, se los pasa al arduino y genera corto?..... porque en el codigo supongo que la logica seria que el arduino le dice al chip que encienda tal pin con corriente, ose manda corriente hacia el segmento y se iria por el gnd del segmento conectado al gnd de arduino, todo esto si el segmenteo fuera catodo... aunque busque algun sketch que fuera para anodo especificamente con el chip, no pude encontrar alguno que explicara con un codigo como funciona. Bueno espero haber sido claro con el problema

Baje la libreria que aconsejan en el post, pero no he podido sacar ejemplos Intente leer el datasheet del chip, pero como mencione antes entiendo poco de electronica y ademas en ingles :confused:

Mira en documentación, que hay un tutorial mio al respecto donde creo respondo tu inquietud.

surbyte: Claro, que es posible agrega un ! (negador) antes de que cada salida y funcionará al revés, obviamente si esta bien cableado. Coloca el código, enlace a la librería, esquema y lo verificamos.

como es lo de agregar un !(negador)??

Negador en programación es invertir tu salida con !

Supon que prendes un rele con digitalWrite(2, HIGH); pues ahora tienes un rele que trabaja a la inversa entonces no cambias nada de tu lógica salvo usar un negador

digitalWrite(2, !HIGH);

es lo mismo que si escribieras

digitalWrite(2, LOW);

ya que !HIGH = LOW es en algebra de bool NO(HIGH) = LOW o NO(1) = 0