El TM1637 es un driver para display de LED de 7 segmentos y teclado, muy popular por ser muy barato y muy sencillo de usar, tanto a nivel electrónico como a nivel de software. Existe en formato de superficie y de inserción y hay gran número de módulos, sobre todo para gestionar display de LED, que lo incluyen; lo que hace que este integrado sea muy usado para pequeños montajes que muestren valores numéricos.
Como se explica en el anterior artículo sobre el driver TM1637, la comunicación con este dispositivo es del tipo serie de dos hilos: una línea para una señal de reloj y otra línea para la información. Aunque el funcionamiento es muy similar al más conocido I2C, el TM1637 utiliza su propio protocolo TWSI.
Al disponer de resistencias pull-up en las líneas de reloj y datos, cuando las comunicaciones se encuentran inactivas el nivel de la señal es alto. Para realizar las pruebas no es crítico pero para el funcionamiento normal sí es relevante considerar que debe establecerse el estado de alta impedancia en los pines de comunicaciones del microcontrolador para enviar un valor 1, y no un nivel alto de salida, ya que serán las resistencias las responsables de subir el nivel en la línea de comunicaciones. Enviar un valor 0 sí que se consigue estableciendo un nivel bajo de salida. Traducido al lenguaje usado en Arduino, sería necesario usar (pin «numero_pin» como entrada, para llevarlo al estado de alta impedancia) para conseguir el nivel alto en la línea conectada a «numero_pin» y para el nivel bajo.
|
1 2 3 4 5 6 7 8 |
// Establecer niveles alto y bajo en comunicaciones TWSI con resistencias pull-up // Establecer el nivel alto (valor 1) pinMode(numero_pin,INPUT); // Establecer el modo de alta impedancia en el pin numero_pin para que las resistencias pull-up lo lleven a nivel alto // Establecer el nivel bajo (valor 0) pinMode(numero_pin,OUTPUT); digitalWrite(numero_pin,LOW); |
A grandes rasgos, el protocolo de comunicaciones con el TM1637 consiste en el envío de una orden que describa la operación que se desea realizar y si procede, el envío y/o recepción de información del mismo. Cada byte de datos que se envía, ya corresponda a orden o a datos, va precedido por una señal de inicio y seguido de la recepción de una señal de estado y el envío de una señal de terminación.
Como puede verse en el gráfico de abajo, la marca de inicio consiste en establecer durante dos ciclos de reloj a nivel bajo la línea de datos y a nivel alto la de reloj. En el resto de los ciclos, incluyendo el de la marca de fin, la señal de reloj alterna nivel bajo y alto (en este orden) Los bits de datos ocupan dos ciclos cada uno y se envían empezando en el LSB (bit menos significativo) y terminando en el MSB (bit más significativo)
Para conseguir una frecuencia máxima de 250 KHz se puede optar por establecer el nivel correspondiente y no cambiarlo al siguiente hasta que el tiempo de medio ciclo no haya pasado, lo que supone la opción más ortodoxa, o detener la ejecución del programa en el microcontrolador durante un intervalo de tiempo antes de cambiarlo. En la librería para Arduino incluida más abajo he optado por esta segunda alternativa porque los paquetes de datos que se envían son muy pequeños, porque se envían a intervalos muy largos en proporción y porque la pausa para conseguir reproducir la frecuencia es relativamente breve: despreciable en los microcontroladores de menores prestaciones; sólo en los más rápidos merecería la pena modificarla para tratar de aprovechar más recurso de cómputo de microcontrolador infrautilizado en esta versión.
La pausa necesaria para conseguir la frecuencia de 250 KHz es de 4 microsengundos por ciclo, 2 microsegundos a nivel alto y 2 a nivel bajo. Como el integrado se fabrica con cierta tolerancia y la frecuencia es la máxima, debe hacerse una pausa un poco mayor (por seguridad, algo más del 5 % indicado en la datasheet podría ser suficiente) como en Arduino la pausa mínima es de un microsegundo, he optado por hacer pausas de 3 microsegundos entre los dos tiempos de cada ciclo, lo que asegura, aunque con cierto «desperdicio» de tiempo, que la librería proporciona una frecuencia operativa.
En el uso del TM1637 como driver para display de LED de 7 segmentos se utilizan 3 de las órdenes de su protocolo de funcionamiento Además del código ó que indica el inicio del envío de datos, ya sea usado como byte de inicio o sumado a la información enviada.
-
El cuarto bit activa (enciende) o desactiva (apaga) el dispositivo según se envíe en nivel alto o bajo respectivamente. Con los tres últimos bits se establece el valor del brillo, siendo cero el menor brillo (encendido, pero con la menor intensidad) Una operación permite realizar directamente el activado del dispositivo con cierto valor de brillo. Como el valor mostrado en el display no se borra, se puede cambiar el brillo mientras se sigue mostrando información.
Como explicaba más arriba, cada comando va precedido de una señal de inicio, la consulta del resultado del envío y una señal de terminación. De este modo, por ejemplo, para activar el dispositivo con un brillo medio se enviaría:
- Marca de inicio
-
0b10000000 OR 0b00001000 OR 0b00000011 -> 0b10001011/0x8b
(Configurar OR Activar OR brillo nivel 3) - Consultar estado
- Marca de fin
-
Se utiliza para cambiar los segmentos encendidos/apagados en un dígito concreto (que corresponde a una dirección de memoria del dispositivo) El protocolo conforme al cual se utiliza esta orden requiere el envío del comando (con las marcas y consultas explicadas antes), el código de inicio de envío de datos (0xC0) al que, con una operación OR, se añade la posición (el dígito que se modifica) y por último el nuevo valor que debe mostrarse. De esta forma, por ejemplo, para cambiar el segundo dígito y dibujar un guión (el segmento g) se seguiría la secuencia:
- Marca de inicio
- 0x44/0b01000100
- Consultar estado
- Marca de fin
- Marca de inicio
- 0xC0/0b01000100 OR 00000001 (Código de inicio de datos OR segundo dígito)
- 0x40/0b01000000 (segmento g)
- Consultar estado
- Marca de fin
-
Sirve para cambiar varios dígitos consecutivos (normalmente todos) en una única operación. Esta orden escribe en una posición e incrementa automáticamente para escribir otro valor en la siguiente. Por ejemplo, para modificar los tres primeros dígitos y representar tres líneas horizontales (los segmentos a, g y d) se utilizaría el siguiente protocolo
- Marca de inicio
- 0x40/0b01000000
- Consultar estado
- Marca de fin
- Marca de inicio
- 0xC0/0b01000100 OR 00000000 (Código de inicio de datos OR primer dígito)
- 0x40/0b00000001 (segmento a)
- 0x40/0b01000000 (segmento g)
- 0x40/0b00001000 (segmento d)
- Consultar estado
- Marca de fin
Para hacer más cómoda la escritura del código y más sencilla su lectura, en la librería se utilizan nombres (macros o variables) para las órdenes, para los valores de los segmentos y de sus combinaciones (el dibujo de los dígitos) formando un vector () con el que acceder más fácilmente a la representación de cada número, y una macro más para la pausa con la que se establece la frecuencia de funcionamiento del driver.
API de la librería
Los objetos de la clase definida en la librería TM1637 están asociados a los pines por los que se comunican con el microcontrolador y con la cantidad de dígitos del driver, que se indican al crear los objetos junto con el brillo con el que inicialmente se activa el dispositivo. Una vez creado el objeto se puede modificar el brillo mientras el driver sigue funcionando pero, lógicamente, no así los pines ni el número de dígitos.
Los métodos de la librería que se describen a continuación permiten presentar en el driver desde valores completos con formato (hora y minutos, por ejemplo) hasta segmentos arbitrarios de uno de los grupos de LED con los que, por ejemplo, «dibujar» letras.
El valor de retorno de la mayoría de las funciones es el estado que el driver devuelve en cada operación. Como lo normal es que los valores se vayan reescribiendo periódicamente, es frecuente que simplemente se ignore este valor de retorno y se muestre correctamente al siguiente envío por lo que podría mostrarse un valor incorrecto durante el intervalo de refresco del display.
-
Al crear el objeto TM1637 el display no tiene ningún LED encendido ni está preparado para enviar información (se encuentra en estado de alta impedancia) Usando esta función el display permanece apagado y el driver se prepara para recibir datos.
-
Envía al driver la señal de desactivar (apagar) el display sin necesidad de destruir el objeto.
-
Al crear el objeto se puede indicar el brillo con el que se mostrará inicialmente (el mínimo, por defecto) la función se puede establecer un nuevo valor. El TM1637 puede utilizar 8 niveles de brillo (de 0 a 7) siendo cero el mínimo valor encendido visible, es decir, cero no significa apagado sino encendido con la mínima intensidad.
-
Una ventaja de usar un driver para LED como el TM1637 consiste en que el microcontrolador sólo tienen que enviar el valor que se desea representar y no es necesario refrescar la información para que se siga mostrando; por contra, esta información permanecerá en el display hasta que se borre, por lo que es necesario incluir esta función en la API de la librería.
-
Con este método se cambia el estado de los LED de un dígito individual definiendo en bruto los que se deben encender o apagar en determinada posición. El parámetro «segmentos» es un byte en el que los bits a uno representan los segmentos encendidos (según el esquema de la imagen de arriba) y los bits a cero los segmentos apagados. El parámetro «posición» indica el número del dígito que se modifica.
12345678910111213141516171819202122232425// Mostrar tres líneas horizontales en el segundo dígito#include "TM1637.h"#define CANTIDAD_DIGITOS 4 // El display tiene 4 dígitos (el driver soporta hasta 6 dígitos)#define PAUSA 3000 // Una pausa de 3 segundos para prepararse para ver el comportamiento del montajeTM1637 pantalla_led(8,9,CANTIDAD_DIGITOS,0); // pin reloj 8, pin datos 9, cantidad dígitos 4, brillo 0 (mínimo)byte segmentos=SEGMENTO_A|SEGMENTO_G|SEGMENTO_D; // encender los segmentos a (horizontal superior) g (medio) y d (inferior)byte posicion=1; // Segundo dígitovoid setup(){pantalla_led.activar();pantalla_led.borrar();delay(PAUSA);}void loop(){pantalla_led.escribir_segmento(posicion,segmentos);delay(PAUSA);pantalla_led.borrar();delay(PAUSA);} -
Este método sirve para escribir varios dígitos desde la primera posición. El driver permite empezar en cualquier posición y escribir cualquier número de dígitos. Con esta función se empieza siempre en la primera posición (dígito número cero) y se espera escribir en todos las posiciones del display. La función espera el puntero a una matriz de caracteres cuya longitud corresponde con el número de dígitos que se indicara cuando se creó el objeto TM1637.
123456789101112131415161718192021222324252627282930// Escribir segmentos arbitrarios en 4 segmentos formando el texto «HOLA»#include "TM1637.h"#define CANTIDAD_DIGITOS 4 // El display tiene 4 dígitos (el driver soporta hasta 6 dígitos)#define PAUSA 3000 // Una pausa de 3 segundos para prepararse para ver el comportamiento del montajeTM1637 pantalla_led(8,9,CANTIDAD_DIGITOS,0); // pin reloj 8, pin datos 9, cantidad dígitos 4, brillo 0 (mínimo)byte segmentos[]= // Un ejemplo de segmentos arbitrarios (HOLA){SEGMENTO_B|SEGMENTO_C|SEGMENTO_E|SEGMENTO_F|SEGMENTO_G,SEGMENTO_A|SEGMENTO_B|SEGMENTO_C|SEGMENTO_D|SEGMENTO_E|SEGMENTO_F,SEGMENTO_D|SEGMENTO_E|SEGMENTO_F,SEGMENTO_A|SEGMENTO_B|SEGMENTO_C|SEGMENTO_E|SEGMENTO_F|SEGMENTO_G};void setup(){pantalla_led.activar();pantalla_led.borrar();delay(PAUSA);}void loop(){pantalla_led.escribir_segmentos(segmentos);delay(PAUSA);pantalla_led.borrar();delay(PAUSA);} -
Con el anterior método se puede escribir una configuración arbitraria de segmentos en un dígito pero lo normal es usar los display de LED de 7 segmentos, como su nombre sugiere, para mostrar valores numéricos con ellos. Con esta función se puede escribir un dígito numérico, el parámetro «dígito», en una posición concreta del display, el parámetro «posición», que opcionalmente puede activar su segmento separador (punto decimal o dos puntos horarios) si el parámetro «coma» tiene el valor .
-
Con esta función se pueden escribir todos los dígitos del display en formato numérico. El parámetro «dígitos» es un puntero a un vector de dígitos numéricos (bytes) de longitud correspondiente a la usada para crear el objeto TM1637. Con el parámetro «posicion_coma» se puede indicar el dígito que tendrá activado el separador, ya sea punto decimal o dos puntos para información horaria. Para reservar el valor cero como indicador de que no se usa el separador, la posición de la coma empieza a contar desde uno y llega hasta la cantidad de dígitos del display.
-
Con esta función pueden obtenerse los valores de los segmentos que corresponden a los dígitos numéricos de forma que pueden usarse los métodos de escritura arbitraria de segmentos mezclándolos con representaciones numéricas de manera sencilla. El parámetro «número» corresponde con el valor que se traducirá en los segmentos que lo representan.
-
Sirve para escribir un valor numérico completo (el parámetro «valor»), que puede requerir varios dígitos. Opcionalmente se puede activar el separador decimal en la posición indicada por el parámetro «posicion_coma»
12345678910111213141516171819202122232425262728// Mostrar valores numéricos en el display LED#include "TM1637.h"#define CANTIDAD_DIGITOS 4 // El display tiene 4 dígitos (el driver soporta hasta 6 dígitos)#define PAUSA_CORTA 150 // Una pausa breve para distinguir el cambio de valor#define PAUSA_LARGA 5000 // Una pausa de 5 segundos para prepararse para ver el comportamiento del montajeTM1637 pantalla_led(8,9,CANTIDAD_DIGITOS,0); // pin reloj 8, pin datos 9, cantidad dígitos 4, brillo 0 (mínimo)void setup(){pantalla_led.activar();pantalla_led.borrar();delay(PAUSA_LARGA);}void loop(){for(int valor=-999;valor<10000;valor++){pantalla_led.escribir_valor(valor); // Al omitir el parámetro de la posición del separador decimal no se activa (sin punto decimal ni separador horario)delay(PAUSA_CORTA);}delay(PAUSA_LARGA);pantalla_led.borrar();delay(PAUSA_LARGA);} -
Esta función muestra en el display dos valores ya formateados suponiendo que dispone de 4 dígitos destinados a información horaria: el separador son dos puntos. Escribe las horas (parámetro «horas») y los minutos (parámetro «minutos») encendiendo el separador (dos puntos en un display horario) cuando el parámetro «puntos» vale y los valores con un cero inicial cuando son menores de 10 si el parámetro «cero_inicial» es .
-
Este método es un envoltorio (wrapper) del anterior para que el código que se escriba usándolo gane en claridad. Los métodos de la librería para mostrar información horaria no verifican los valores indicados por los parámetros de entrada, sólo simplifican su uso.
-
Con esta función, desarrollada para usar un display horario (con separador de dos puntos) de 6 dígitos, el máximo que soporta el TM1637, se puede representar la hora, los minutos y los segundos en una única operación que se usa como las anteriores.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152// Mostrar las horas y los minutos desde que inicia el programa#include "TM1637.h"#define CANTIDAD_DIGITOS 4 // El display tiene 4 dígitos (el driver soporta hasta 6 dígitos)#define SEGUNDO 1000 // Milisegundos de un segundo#define MINUTO 60000 // Milisegundos en un minuto (1000*60)#define FINAL 6000000 // 6000000 milisegundos = 100 minutos (100*1000*60) Posteriormente parpadea en lugar de mostrar el valor#define PAUSA_PARPADEO 300 // Al llegar al valor FINAL no se muestra el tiempo sino que se hace parpadear al display con PAUSA_PARPADEO de intervalo entre encendido y apagadoTM1637 pantalla_led(8,9,CANTIDAD_DIGITOS,0); // pin reloj 8, pin datos 9, cantidad dígitos 4, brillo 0 (mínimo)// byte desbordamiento[]={SEGMENTO_G,SEGMENTO_G,SEGMENTO_G,SEGMENTO_G}; // Como alternativa pueden hacerse parpadear cuatro guionesbyte minutos;byte segundos;unsigned long reloj;boolean estado_parpadeo=false;void setup(){pantalla_led.activar();pantalla_led.borrar();reloj=0;}void loop(){if(millis()>FINAL){estado_parpadeo=!estado_parpadeo;if(estado_parpadeo){// pantalla_led.escribir_segmentos(desbordamiento); // Como alternativa pueden hacerse parpadear cuatro guionespantalla_led.escribir_segmento(1,CON_PUNTOS);}else{pantalla_led.borrar();}delay(PAUSA_PARPADEO);}else{if(millis()>reloj){reloj=millis()+SEGUNDO;minutos=millis()/MINUTO; // Como no hay horas, se muestran más de 59 minutossegundos=(millis()-minutos*MINUTO)/SEGUNDO;pantalla_led.escribir_minutos_segundos(minutos,segundos); // Por defecto muestra el separador horario y los ceros iniciales}}}
Librería Arduino para controlar un display LED con el driver TM1637
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
//TM1637.h #if defined(ARDUINO) && ARDUINO>=100 #include "Arduino.h" #else #include "WProgram.h" #endif #define TM1637_PAUSA 3 // Un poco más de dos, la mitad de cuatro microsegundos, para una frecuencia máxima de 250 KHz (con dos no funciona) #define TM1637_ACTIVAR 0x88 // Inicializar OR Activar [OR brillo] #define TM1637_DESACTIVAR 0x80 // Inicializar (sin activar ni brillo) #define TM1637_ESCRIBIR_EN_POSICION 0x44 #define TM1637_ESCRIBIR_INCREMENTAR 0x40 #define TM1637_INICIO_DATOS 0xC0 #define SEGMENTO_A 0B00000001 #define SEGMENTO_B 0B00000010 #define SEGMENTO_C 0B00000100 #define SEGMENTO_D 0B00001000 #define SEGMENTO_E 0B00010000 #define SEGMENTO_F 0B00100000 #define SEGMENTO_G 0B01000000 #define CON_PUNTOS 0B10000000 // Para mostrar el punto decimal (o dos puntos en un display de reloj) haciendo una operación OR con el número class TM1637 { private: byte pin_reloj; byte pin_datos; byte cantidad_digitos; byte brillo; byte segmentos_numero[11]; // Representación del 0 al 9 en un display de 7 segmentos (el último es el que representa el error) long valores_maximos[7]; // El TM1637 puede representar 6 dígitos como máximo long valores_minimos[7]; void inicio_envio(); void fin_envio(); boolean enviar(byte dato); protected: public: TM1637(byte nuevo_pin_reloj,byte nuevo_pin_datos,byte nuevo_numero_digitos=4,byte nuevo_brillo=0); ~TM1637(); boolean activar(); boolean desactivar(); boolean cambiar_brillo(byte nuevo_brillo); boolean borrar(); boolean escribir_valor(long valor,byte coma=0); boolean escribir_horas_minutos(byte horas,byte minutos,boolean puntos=true,boolean cero_inicial=false); boolean escribir_minutos_segundos(byte horas,byte minutos,boolean puntos=true,boolean cero_inicial=true); boolean escribir_horas_minutos_segundos(byte horas,byte minutos,byte segundos,boolean cero_inicial=false); boolean escribir_digito(byte posicion,byte digito,boolean coma=false); boolean escribir_digitos(byte *digito,byte coma=0); boolean escribir_segmento(byte posicion,byte segmento); boolean escribir_segmentos(byte *segmento); byte numero_a_segmento(byte numero); }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 |
//TM1637.cpp #include "TM1637.h" TM1637::TM1637(byte nuevo_pin_reloj,byte nuevo_pin_datos,byte nuevo_cantidad_digitos,byte nuevo_brillo) { // Representación de los decimales en un display de 7 segmentos segmentos_numero[0]=0x3F; segmentos_numero[1]=0x06; segmentos_numero[2]=0x5B; segmentos_numero[3]=0x4F; segmentos_numero[4]=0x66; segmentos_numero[5]=0x6D; segmentos_numero[6]=0x7D; // 0x7C; El 6 feo ahorra energía segmentos_numero[7]=0x27; // 0x07; El 7 clásico ahorra energía segmentos_numero[8]=0x7F; segmentos_numero[9]=0x6F; // 0x67; El 9 de palo ahorra energía segmentos_numero[10]=0x40; // Dibujo usado para simbolizar un de error (será una tira de guiones creada con el segmento g) // Valores máximos (más uno, para ahorrar en el bucle) El TM1637 puede representar 6 dígitos como máximo. Más rápido almacenar los valores que calcularlos valores_maximos[0]=0; // Añadido para poder comparar directamente con el número de dígitos valores_maximos[1]=10; valores_maximos[2]=100; valores_maximos[3]=1000; valores_maximos[4]=10000; valores_maximos[5]=100000; valores_maximos[6]=1000000; // Valores mínimos. El TM1637 puede representar 6 dígitos como máximo. Más rápido almacenar los valores que calcularlos valores_minimos[0]=0; // Añadido para poder comparar directamente con el número de dígitos valores_minimos[1]=0; valores_minimos[2]=-9; valores_minimos[3]=-99; valores_minimos[4]=-999; valores_minimos[5]=-9999; valores_minimos[6]=-99999; pin_reloj=nuevo_pin_reloj; pin_datos=nuevo_pin_datos; cantidad_digitos=nuevo_cantidad_digitos; brillo=nuevo_brillo; } TM1637::~TM1637() { desactivar(); } boolean TM1637::activar() { pinMode(pin_reloj,INPUT); pinMode(pin_datos,INPUT); delayMicroseconds(TM1637_PAUSA); delayMicroseconds(TM1637_PAUSA); return cambiar_brillo(brillo); } boolean TM1637::desactivar() { boolean estado; inicio_envio(); estado=enviar(TM1637_DESACTIVAR); fin_envio(); return estado; } boolean TM1637::cambiar_brillo(byte nuevo_brillo) // Como no se borra el contenido de los registros también puede usarse para cambiar el brillo { boolean estado; inicio_envio(); estado=enviar(TM1637_ACTIVAR|(nuevo_brillo&0B00000111)); // Ignorar todos los bits menos los tres últimos para no alterar el código de la orden por error fin_envio(); return estado; } boolean TM1637::borrar() { byte todo_ceros[cantidad_digitos]; for(byte numero_digito=0;numero_digito<cantidad_digitos;numero_digito++) { todo_ceros[numero_digito]=0; } return escribir_segmentos(todo_ceros); } boolean TM1637::escribir_valor(long valor,byte coma) { byte segmento[cantidad_digitos]; byte numero_digito=0; long resto=abs(valor); byte digito; if(valor>valores_maximos[cantidad_digitos]-1||valor<valores_minimos[cantidad_digitos]) { for(numero_digito=0;numero_digito<cantidad_digitos;numero_digito++) { segmento[numero_digito]=SEGMENTO_G; } } else { if(valor==0) { numero_digito++; segmento[cantidad_digitos-numero_digito]=segmentos_numero[0]; } else { while(numero_digito<cantidad_digitos&&resto>0) { numero_digito++; digito=resto%10; segmento[cantidad_digitos-numero_digito]=segmentos_numero[digito]; resto/=10; } if(valor<0) { numero_digito++; segmento[cantidad_digitos-numero_digito]=SEGMENTO_G; } } while(numero_digito<cantidad_digitos) { numero_digito++; segmento[cantidad_digitos-numero_digito]=0; // Apagar los que no se usen } } return escribir_segmentos(segmento); } boolean TM1637::escribir_horas_minutos(byte horas,byte minutos,boolean puntos,boolean cero_inicial) { // No se verifican los valores para poder usarla de forma flexible byte segmento[4]; // hora y minutos siempre son 4 dígitos segmento[0]=horas/10; if(segmento[0]>0||cero_inicial) { segmento[0]=segmentos_numero[segmento[0]]; } else { segmento[0]=0; } segmento[1]=segmentos_numero[horas%10]; if(puntos) { segmento[1]|=CON_PUNTOS; } segmento[2]=segmentos_numero[minutos/10]; segmento[3]=segmentos_numero[minutos%10]; return escribir_segmentos(segmento); } boolean TM1637::escribir_minutos_segundos(byte horas,byte minutos,boolean puntos,boolean cero_inicial) { return escribir_horas_minutos(horas,minutos,puntos,cero_inicial); } boolean TM1637::escribir_horas_minutos_segundos(byte horas,byte minutos,byte segundos,boolean cero_inicial) { byte segmento[6]; // hora, minutos y segundos siempre son 6 dígitos segmento[0]=horas/10; if(segmento[0]>0||cero_inicial) { segmento[0]=segmentos_numero[segmento[0]]; } else { segmento[0]=0; } segmento[1]=segmentos_numero[horas%10]; segmento[2]=segmentos_numero[minutos/10]|CON_PUNTOS; // Siempre con puntos segmento[3]=segmentos_numero[minutos%10]; segmento[4]=segmentos_numero[segundos/10]|CON_PUNTOS; // Siempre con puntos segmento[5]=segmentos_numero[segundos%10]; return escribir_segmentos(segmento); } boolean TM1637::escribir_digito(byte posicion,byte digito,boolean coma) { return escribir_segmento(posicion,numero_a_segmento(digito)); } boolean TM1637::escribir_digitos(byte *digito,byte coma) { byte segmento[cantidad_digitos]; for(byte numero_digito=0;numero_digito<cantidad_digitos;numero_digito++) { segmento[numero_digito]=numero_a_segmento(digito[numero_digito]); if(numero_digito==coma-1) { segmento[numero_digito]|=CON_PUNTOS; } } return escribir_segmentos(segmento); } boolean TM1637::escribir_segmento(byte posicion,byte segmento) { boolean estado; inicio_envio(); estado=enviar(TM1637_ESCRIBIR_EN_POSICION); fin_envio(); inicio_envio(); estado|=enviar(TM1637_INICIO_DATOS|(posicion&0B00000011)); // Ignorar todos los bits menos los dos últimos para no alterar el código de la orden por error estado|=enviar(segmento); fin_envio(); return estado; } boolean TM1637::escribir_segmentos(byte *segmento) // Escribe toda la pantalla, el vector debe contener todos los dígitos { boolean estado; byte numero_digito; inicio_envio(); estado=enviar(TM1637_ESCRIBIR_INCREMENTAR); fin_envio(); inicio_envio(); estado|=enviar(TM1637_INICIO_DATOS); for(numero_digito=0;numero_digito<cantidad_digitos;numero_digito++) { estado|=enviar(segmento[numero_digito]); } fin_envio(); return estado; } // No se utiliza digitalWrite para enviar un nivel alto. Establecer el modo como entrada hace que el pin pase a estado de alta impedancia, la resistencia de pullup hace que el nivel sea alto boolean TM1637::enviar(byte dato) { boolean respuesta; for(byte numero_bit=0;numero_bit<8;numero_bit++) { pinMode(pin_reloj,OUTPUT); digitalWrite(pin_reloj,LOW); if(dato&(1<<numero_bit)) { pinMode(pin_datos,INPUT); } else { pinMode(pin_datos,OUTPUT); digitalWrite(pin_datos,LOW); } delayMicroseconds(TM1637_PAUSA); pinMode(pin_reloj,INPUT); delayMicroseconds(TM1637_PAUSA); } // Leer respuesta TM1637 (estado) pinMode(pin_reloj,OUTPUT); digitalWrite(pin_reloj,LOW); delayMicroseconds(TM1637_PAUSA); pinMode(pin_datos,INPUT); pinMode(pin_reloj,INPUT); delayMicroseconds(TM1637_PAUSA); respuesta=digitalRead(pin_datos); return respuesta; } void TM1637::inicio_envio() { pinMode(pin_reloj,INPUT); pinMode(pin_datos,OUTPUT); digitalWrite(pin_datos,LOW); delayMicroseconds(TM1637_PAUSA); delayMicroseconds(TM1637_PAUSA); } void TM1637::fin_envio() { pinMode(pin_reloj,OUTPUT); digitalWrite(pin_reloj,LOW); pinMode(pin_datos,OUTPUT); digitalWrite(pin_datos,LOW); delayMicroseconds(TM1637_PAUSA); pinMode(pin_reloj,INPUT); delayMicroseconds(TM1637_PAUSA); pinMode(pin_datos,INPUT); // Al terminar, reloj y datos quedan en alta impedancia hasta la siguiente operación } byte TM1637::numero_a_segmento(byte numero) { if(numero>9) { return(segmentos_numero[10]); } else { return(segmentos_numero[numero]); } } |
Víctor Ventura
Desarrollando aplicaciones para la web conocí el potencial de internet de las cosas, encontré la excusa perfecta para satisfacer la inquietud de aprender electrónica que había tenido desde siempre. Ahora puedo darme el gusto de programar las cosas que yo mismo diseño y fabrico.
Sígueme:
David
Buenas tardes,
he intentado hacer tus ejemplos,y m ehes imposible,todos dan error como el que abajo te indico.
Dispongo de todo el material y sigo todos los pasos y no funciona nada porque no compila.
Espero que puedas ayudarme.Gracias.
Arduino:1.6.4 (Windows 7), Placa:»Arduino Uno»
Opciones de compilación cambiadas, reconstruyendo todo
sketch_oct31a:8: error: invalid preprocessing directive #TM1637
sketch_oct31a:9: error: ‘SEGMENTO_A’ was not declared in this scope
sketch_oct31a:9: error: ‘SEGMENTO_G’ was not declared in this scope
sketch_oct31a:9: error: ‘SEGMENTO_D’ was not declared in this scope
sketch_oct31a.ino: In function ‘void setup()’:
sketch_oct31a:14: error: ‘pantalla_led’ was not declared in this scope
sketch_oct31a.ino: In function ‘void loop()’:
sketch_oct31a:21: error: ‘pantalla_led’ was not declared in this scope
invalid preprocessing directive #TM1637
This report would have more information with
«Show verbose output during compilation»
activala desde Archivo > Preferencias
Víctor Ventura
Hola, David.
Me parece que se te ha olvidado incluir la librería. Ese error
invalid preprocessing directive #TM1637me hace pensar que no has escrito#include "TM1637.h"para cargar «TM1637.h» donde están definidas también las constantes SEGMENTO_A, SEGMENTO_G, SEGMENTO_D… por las que también te avisa de error.Saludos
David
Hola de nuevo Víctor:
La libreria la tengo incluida si, y descargada en el programa.
El error me sale en el ejemplo de esta misma pagina,me he dado cuenta que en los códigos que has publicado en el segundo ejemplo( mostrar tres lineas horizontales en el segundo dígito) , hay una linea de comando,que dice esto:
«TM1637 pantalla_led(8,9,CANTIDAD_DIGITOS,0); // pin reloj 8, pin datos 9, cantidad dígitos 4, brillo 0 (mínimo)»
y al compilarlo me da error desde esa linea de codigo,como si faltara algo delante de «TM1637….».
Como en todos los ejemplos esa linea da error.
No se si me he explicado bien.
Gracias por tu tiempo y ayuda.
Un saludo.
David
Hola de nuevo Víctor:
He de disculparme,el problema que te comentaba lo tenia yo en el IDE de Arduino.
Tus códigos funcionan a la perfección. Sin ningún error.
Yo dispongo de una librería del modulo TM1637 que he utilizado en anterioridad,que nada tiene que ver con los que tienes publicados.
Resulta que al utilizar el programa «CodeBlocks» para generar las librerías,pues me despisté y las metí en la misma carpeta que ya existía,y se hizo un lio el IDE y solo me daba error,porque no leía la que debía,lo he solucionado cambiando nombres de carpeta,( simple).
Me ha costado estar hasta las cuatro de la mañana,pero me costaba creer tanto error.
Al final error soluccionado.
Te pido mil disculpas por tanto lio.
Mañana ya intentare probar el hacer el reloj en tiempo real con este modulo en lugar de con pantalla LCD como se ve habitualmente.
Pues mi deseo es crear un reloj con led 7 segmentos ( o hacer cada segmento con led,ya veré).
Gracias y disculpa nuevamente.
Un saludo.
Víctor Ventura
Hola, David.
No pasa nada, son errores típicos que le pasan a todo el mundo. A mí me parece que parte de la diversión está en ir resolviendo problemas.
Suerte con tu proyecto. No tengas problema en preguntar cualquier cosa en la que te podamos ayudar.
Saludos
Pablo
Hola, muy interesante y completo.
Estos display (el modulo de 4) son I2C verdad? , hay manera de conectar en paralelo o en cascada , lo que sucede es que necesito 5 displays para representar los valores que necesito y no veo que en el mercado esten.
Gracias,
sludos
Víctor Ventura
Hola, Pablo.
Como explico en el artículo, los TM1637 no son exactamente I2C, utilizan su propio protocolo TWSI, pero igual que ocurriría si usaran el protocolo I2C puedes conectar en un bus los 5 que necesitas.
Yo he encontrado grupos de 6 dígitos pero supongo que te refieres a 5 grupos de 4 dígitos. Sea como fuere tu configuración, puedes ir agrupando hasta 6 dígitos por cada TM1637 y hacer una cadena de TM1637 hasta conseguir todos los dígitos que necesites. Te recomiendo que consultes mi artículo TM1637 driver para display LED de 6 dígitos de 7 segmentos y teclado de 16 pulsadores, que te puede orientar un poco más.
¡Suerte con tu proyecto! ¡Hasta pronto!
Mauro
Buenas tardes,
Copie el código y las librerías tal cual ud. colocó. Compilé sin problemas. Sin embargo el display está totalmente apagado. No da señales de vida. Tengo que pensar que me vendieron un display que no funciona?
Víctor Ventura
Hola, Mauro.
Antes de pensar eso yo revisaría si las conexiones están todas en su sitio. Las de la parte de Arduino y las de la parte del TM1637. Tengo un montón de integrados de ese tipo y todavía no he conseguido romper ninguno 🙂
Lo que sí que he conseguido romper son displays LED (aunque es bastante raro si están en un módulo integradas con el TM1637) Con un polímetro y paciencia puedes probar la continuidad de cada segmento LED de la pantalla (puede que se enciendan un poco) Si el display (o algún segmento) está roto, ya sí puedes organizar el entierro.
Suerte.
Mauro
Muchas gracias por su respuesta. Voy a intentar.
Soy novato en Arduino y estos son mis primeros pasos. Probé código de un montón de páginas y varias librerías TM1637 pero el artefacto no responde.
edwin
Probaste que la conexion CLK y DIO sean las del scripts?
edwin
Muy agradecido por la libreria, que me ha resultado mas amigable que las otras similares para este tipo de display. Sin embargo tengo un problema y es que no puedo cargar el punto decimal en la representacion de temperaturas y humedades; por algun misterio no logro resolver este enigma ¿Alguna sugerencia? Gracias
Víctor Ventura
Hola, Edwin.
Suele funcionar 🙂 ¿No tienes alguna pista más que nos ayude a averiguar qué pasa?
Gracias por participar en polaridad.es
edwin
Gracias Victor, esw un misterio porque con las otras librerias (que no incluyen el punto o punto y coma) funciona perfectamente, y con esta tambien salvo el tema del punto… Cuando en la referencia de la funcion » pantalla_led.escribir_valor(valor);» paso un valor de temperatura o uno de humedad y la posicion «2» para el punto; a las variables las he convertido a int, las le utilizado en float pero no logro que me responda el condenado punto.
Lo bueno es que este problemaita lo he visto en general en todos los proyectos de la web. Parece una deficiencia del controlador del tm1637 de su fabricante chino (Catalex)
En otro orden tu web es estupenda y muy agradable de leer y aprender, un cordial saludo desde Argentina
Víctor Ventura
Hola, Edwin.
Pues a lo peor es algún lote de fábrica, a mí sí que me funciona sin más problemas. Ciertamente, eso de que no te funcione ninguna librería, da que pensar que sea culpa del hardware.
Gracias por visitar polaridad.es, vuelve pronto, que esta web queda muy cerca de Argentina 😉
Enrique
Muchas Gracias por esta información voy a experimentar con este chip que tiene su chiste. Quisiera saber si se puede conectar a un microcontrolador que se alimenta a 3V, y si en todo caso la conexion es identica a la de un micro alimentado a 5V. Otra duda que quizá me puedas aclarar es porque nos obligan a que cambiar la configuracion de las lineas de datos y reloj para que el «1» lo realicen las resistencias de pull up de 10K y no, se pueda mandar con una salida común. quizá esto reduciría el código.
Muchas Gracias.
Víctor Ventura
Hola, Enrique.
No te puedo responder con total seguridad porque la hoja de datos está escrita en chino (o a lo peor ni eso, no sé chino) Pero, hasta donde sé, la alimentación y el nivel lógico es de 5 V con una tolerancia de ±10 %.
Lo de las resistencias pull-up ni me lo había planteado porque es todo un clásico en este tipo de comunicaciones. Si es que se puede cambiar, que no creo, no lo sé.
Voy a darle alguna vuelta mental a lo del ahorro de código si no hubiera que cambiar el nivel alto, ahora mismo no me imagino cómo.
Muchas gracias por participar en polaridad.es
Enrique
Muchas Gracias por tu respuesta Victor.
Con respecto a interconectar el TM1637 con un microcontrolador a 3 V, haber si opinas como yo.
En la conexion tradicional con las resistencias de pull up a 5V, se dañarían las entradas de un microcontolador de 3V puesto que no se puede exceder el voltaje de entrada en alto a un nivel mayor al de alimentación del microcontrolador, en este caso 3V.
Por otro lado conectar las resistencias de pull up a 3V para no dañar al microcontrolador quiza haga que el TM1637 funcione de manera inesperada, en el manual dicen que el voltaje mínimo en las líneas de reloj y datos debe ser 3.5V y el micro de 3V no los dá. (habria que hacer pruebas para ver si funciona, pero por algo nos obligan a cambiar la configuracion de las líneas.
Una alternativa, es poner las salidas del micro de 3V (reloj y datos) un transistor NPN en cada una como un BC547 o similar para mandar a cero esas salidas cuando asi se requiera. El uno logico lo sigue dando las resistencia de pull up conectada a 5V. (tomar en cuenta que esto invierte el valor lógico a la salida)
Con esa configuración almenos puedo satisfacer ambas necesidades de alimentación. la situación del reconocimiento (si es que realmente se requiere) se puede resolver tomando una derivación de la línea de datos a un diodo 1n4148 polarizado inversamente con una tercera líea configurada como entrada y con otra resistencia de pull up del lado del micro de 3V a ese nivel.
Como el diodo esta inversamente polarizado no se drena corriente de la resistencia de 10K a 5V.
Como estoy en proceso de recodificación basado en tus librerías no lo he probado… pero en cuanto tenga resultados se los hago saber.
pd. con esa configuración no se tendría que estar reconfigurando la dirección de las líneas.
Para los amigos que trabajen con MCU a 5V tu metódo es el óptimo).
Gracias por tu trabajo y por tu foro.
Víctor Ventura
Hola, Enrique.
Es muy interesante lo que comentas. En realidad, abre el tema de la regulación de nivel en comunicaciones, que da para todo un artículo.
Mi opción, por ser breve, es que el TM1637 es un integrado barato, perfecto cuando se usa en contexto y si no encaja en el conjunto del proyecto no merece la pena darle muchas vueltas y es preferible buscar alternativas.
Con carácter general, usar resistencias o diodos para bajar el nivel son una buena opción, aunque hay que cuidar la velocidad de conmutación y la duración de los flancos (no quiero ahora extenderme más ahora, como digo, da para un artículo). Salvo en algunos montajes concretos, mi opción por defecto para regular el nivel de las comunicaciones es usar el típico regulador de tensión basado en MOSFET o algún integrado de los que incluyen varios puertos para regulación rápida del nivel de tensión.
Un saludo, Enrique. Gracias por participar en polaridad.es
ivan
como descargo la libreria??
Víctor Ventura
Hola, Ivan.
No había ningún enlace para descargar la librería (pensaba que bastaría con copiar y pegar el código). Como los deseos de mis lectores son órdenes para mí, aquí puedes descargar la librería para controlar desde Arduino un display LED de basado en el TM1637. Por favor, dinos si lo he grabado correctamente, que vas a estrenar la descarga 🙂
Gracias por visitar polaridad.es
ivan
Muchisimas gracias por contestar tan rapido y por solucionarme el problema porque me estaba volviendo loco intentando crear la libreria… me falta mucho por aprender!!! Gracias!!
Víctor Ventura
🙂
Amaia
Buenos dias,
Tengo problemas al compilar. No he utilizado nunca un diplay y he copiado uno de tus ejemplos. Me ha este error:
Arduino:1.8.1 (Windows Store 1.8.1.0) (Windows 10), Tarjeta:»Arduino/Genuino Uno»
C:\Users\AL\Documents\Arduino\display\display.ino:3:20: fatal error: TM1637.h: No such file or directory
#include «TM1637.h»
^
compilation terminated.
exit status 1
Error compilación en tarjeta Arduino/Genuino Uno.
Este reporte podría tener más información con
«Mostrar salida detallada durante la compilación»
opción habilitada en Archivo -> Preferencias.
Víctor Ventura
Hola, Amaia.
Cuando se incluye un documento en otro (una librería, en este caso) usando comillas para indicar el nombre del archivo, como en
#include "TM1637.h"lo que se le dice al compilador (bueno, al preprocesador) es que busque ese documento en la misma carpeta en la que se encuentra el que lo importa (tu programa).¿Has grabado los archivos TM1637.h y TM1637.cpp dentro de la carpeta en la que está tu programa? Creo que ese es el problema.
Gracias por participar en polaridad.es
Hugo Hernández
Como puedo leer un valor de una entrada analógica con el display de 7 segmentos TM1637
Víctor Ventura
Hola, Hugo.
No sé si entiendo tu pregunta. El TM1637 no tiene entradas analógicas sino digitales (para teclado).
Si te refieres a mostrar una entrada analógica de Arduino, puedes leerla con
analogRead, convertirla, por ejemplo, conmapy mostrarla usando el métodoescribir_valorde la librería del artículo.Gracias por visitar polaridad.es
jesus
Muchas gracias, nos ayudas mucho.
En cuanto al punto a mi me pasa lo mismo que a Edwin, supongo que estoy haciendo algo mal…. puedes poner un ejemplo en el q funcione el punto?
Gracias
Alberto
Hola, quiero hacer un termómetro digital, los dos primeros módulos para mostrar números, el cuarto la letra «C» y el problema es que quiero representar en el tercer módulo una «º», o sea iluminar los segmentos ABFG del tercer módulo, ¿Podrías ayudarme?
Pongo el sketch:
#include «TM1637.h»
#define CLK 2 // Pin CLK
#define DIO 3 // Pin DIO
TM1637 tm1637(CLK,DIO);
void setup()
{
tm1637.init(); // Inicializa modulo
tm1637.set(0); // Brillo, 0 (minimo) a 7 (maximo)
tm1637.point(POINT_OFF); // Apaga dos puntos
}
void loop()
{
tm1637.display(0, 2); //el número 2
tm1637.display(1, 4); //el número 4
tm1637.display(2, 25 ); //»25″ es un guión, ¿cómo represento el símbolo grados?
tm1637.display(3, 0x0c); //la letra C
}
Victor Buenaventura
Victor hola
Estoy tratando de programar un termómetro con el TM1637 pero no lo he conseguido. Me podías orientar al respecto por favor. Muchas gracias.
JOSE COSTA ROS
Hola,
excelente post. Tengo dos display de 4 Dígitos iguales que los mostrados en la imagen de este post.
No logro que aparezcan los digitos en el display (utilizando «otra» librería que no es para el… si enciende segmentos, por lo que la comunicación y conexionado es correcto).
Con la librería descargada de comentarios, conectada teniendo en cuenta las posiciones indicadas en el programa (alimentación, reloj, datos, tierra..), etc… no hace nada. He probado otro arduino, las dos pantallas… cables…
Estoy en ese punto que «ya no se que hacer». He probado todos los ejemplos aquí expuestos y ninguno me da resultado.
Si se te ocurre algo que se me pueda estar escapando… espero que me digas.
Saludos!!!
juan
Buenas Victor
a mi me pasa exactamente lo mismo que a jose pero con un modulo de 6 digitos, llevo todo el dia y no hay manera que me funcione con tu codigo, no hace nada de nada,
un saludo
Víctor Ventura
Hola Jose y Juan.
Entiendo que si os funciona con otra librería, el módulo no está roto.
Ya os podéis imaginar que, si publico el código es porque ha funcionado en las pruebas que he hecho (con muchos módulos como el de la foto ¡Son tan baratos!)
Lo único que se me ocurre, y es poco, es que no estéis conectando el módulo en las patillas que el código usa o que las utilicéis para otras cosas que interfieran.
A lo mejor saber algo más de vuestra implementación ayudaría.
Saludos y gracias por participar en el blog.
Juan
hola Víctor y gracias por tu rápida respuesta,
yo no uso el modulo de la foto, uso el modulo de 6 dígitos, 6-Digit LED Displey TM1637 de ROBOTDYN
espero que me puedas ayudar o alguna forma de poder trabajar los 6 dígitos, gracias
Mario
Muchas gracias Victor, muy instructivo. Te dejo una pequeña modificación que hace que tu biblioteca funcione con los módulos ROBOTDYN y otros.
Descargar la versión para ROBOTDYN
Xavier Sánchez
Hola Victor Ventura, ante mano gracias por brindar esta información a la comunidad, realmente me ayudó al uso de este Display, que ignorantemente lo había comprado sin saber siquiera que es una librería y mucho menos que algunos dispositivos la necesitan haha.
Me funcionó todo muy bien, pero tengo una duda, es que tengo que realizar un trabajo en el que consiste medir el voltaje de 3 LEDs de diferentes colores, entonces como podría hacer para hacer eso y que los valores me salgan en el Display, te agradecería mucho algún comentario o guia por favor.
Gracias y saludos.
Miguel Navia
Hola Victor, quiero hacer la siguiente pregunta las librerias
Arduino.h
WProgram.h
hay buscarlas en la red o fueron creadas por vos
Muchas Gracias
Atte.
Miguel
Víctor Ventura
Hola, Miguel.
Son parte del IDE de Arduino, no tienes que buscarlas.
Hasta pronto.
Jose Luis
Hola Victor,
He probado tus librerías, y de los varios módulos de 7 segmentos que tengo, solamente he conseguido hacer funcionar uno de ellos, de 0.36 pulgadas y utilizando un «arduino mega», porque con un «arduino uno», se volvia loco el display y a los pocos segundos se apagaba. Los módulos de 0.56 pulgadas que tengo no encienden. Con otra librería muy básica si he conseguido que funcionen, pero me gustan mucho mas las funciones que tu incluyes.
He probado el código que dejo Mario el 11 de marzo en los comentarios, pero me da errores de compilación, entre otras cosas por el tipo de caracteres que utiliza la página web, por ejemplo en la línea #include “Arduino.h” al pegarla me aparecen otro tipo de comillas, y me da error de compilación. Corrijo esos errores pero aparecen mas errores similares y mis conocimientos no dan para subsanarlos.
No se si tu tendrás acceso al código fuente que escribió Mario, sin esas modificaciones que salen al cortar y pegar, si fuera así te estaría muy agradecido si las pudieses publicar en un zip. O si Mario lee este comentario a ver si lo puede hacer él.
Muchas gracias por todo el esfuerzo que haceis en ayudar a la gente.
Víctor Ventura
Hola, Jose Luis.
He formateado el código fuente de Mario y he puesto un enlace para que se pueda descargar. Me temo que no puedo hacer mucho más con eso; ni siquiera sé qué es ROBOTDYN.
Tampoco puedo decirte nada fiable de tu problema. Yo probaría con los sospechosos habituales: ¿Has alimentado por separado el módulo y el driver o desde Arduino? ¿El programa que explota la librería hace un uso muy intensivo de MCU (por eso soportaría Mega pero no Uno)?
Saludos.
Jose Luis
Hola Victor, lo primero darte las gracias por tu rápida contestación.
He probado a alimentar los módulos con una fuente externa, juntando las masas, y tampoco he logrado que funcionen. También he copiado el código de Mario y me da error de compilación, al no estar definida por lo menos una variable, con lo cual deduzco que el código está incompleto, no me he molestado en mirar mas.
Los módulos ROBOTDYN, son módulos fabricados por esta empresa China. Desconozco si tienen alguna característica que los haga especiales.
https://robotdyn.es.aliexpress.com/store/group/Segment/1950989_504708861.html?spm=a219c.12010615.0.0.183dc2043WYDag
Por otro lado conseguí que los módulos funcionasen con la librería “DigitalTube”, es una librería muy básica, nada que ver con la tuya, pero inspirándome en tu librería, bueno, mas que inspirándome, medio copiando y adaptando partes de tu código, he realizado modificaciones en esa librería consiguiendo hacerla mas funcional para mis propósitos.
De nuevo te doy las gracias, por tu esfuerzo y tu tiempo .
Saludos.
Antonio
Buenos dias.
Primero, gracias a dios que existen personas como Victor, que de forma totalmente altruista nos hace la vida mas facil a los que trabajamos en el complicado mundo de la electrónica.
Por fin hice funcionar esta magnifica librería. Al final opte por sustituir la que arduino trae por defecto ,por la tuya. A final de cuentas, poco iba a hacer con la original, con cuatro o cinco sentencias, siendo esta de victor muchisimo más completa, y encima en español.
Ahora mi duda es a nivel de hareware. Verás; no me quedó muy claro lo del tema de las resistencias pull-up.
Ni tampoco el qué pines hay que configurar como entradas-salidas, ni por qué.
Si bien Victor, o algún otro compañero tuviese la amabilidad de ponerme por aquí algún pequeño programa ejemplo que le haya funcionado para quedarme con el cante de como configurar los pines, le estaría muy agradecido. O si alguien me pudiese decir como configurar los del proyecto que yo quiero realizar.
Yo voy a utilizar el pin D2 como datos y el D3 como reloj.
Muchísimas gracias de antemano
Gaston Gibert
Buenas, Hola Victor, tenes idea como puedo hacer para que el display muestre la temperatura expresada de la siguiente manera, ejemplo digito1 (3) digito2 (0) digito3 (°) digito4 (5) se debería ver 30°5 una forma de expresar la temperatura 30,5 con decimales. desde ya muchas gracias.