En este tutorial, aprenderás cómo puedes controlar los displays de 7 segmentos de 4 dígitos TM1637 con Arduino. Estos displays son fantásticos para mostrar datos de sensores, temperatura, tiempo, etc.
He incluido 3 ejemplos en este tutorial. En el primer ejemplo, veremos las funciones básicas de la librería TM1637Display. En el segundo ejemplo, te mostraré cómo puedes mostrar la hora en una pantalla de 4 dígitos. El último ejemplo puede ser usado para crear un simple display de temperatura en combinación con el DHT11.
También se incluyen diagramas de cableado. Después del ejemplo, desgloso y explico cómo funciona el código, por lo que no deberías tener problemas para modificarlo y adaptarlo a tus necesidades.
Si tiene alguna pregunta, deje un comentario a continuación.
Si quieres ver más tutoriales de visualización, consulta los siguientes artículos:
- Cómo controlar un carácter I2C LCD con Arduino
- Cómo utilizar una pantalla LCD de 16×2 caracteres con Arduino
Suministros
Componentes de hardware
Software
Makerguides.com is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to products on Amazon.com. As an Amazon Associate we earn from qualifying purchases.
Información sobre la pantalla
Las pantallas de 4 dígitos y 7 segmentos suelen requerir 12 pines de conexión. Eso es bastante y no deja mucho espacio para otros sensores o módulos. Gracias al CI TM1637 montado en la parte posterior del módulo de visualización, este número puede reducirse a sólo cuatro. Dos pines son necesarios para las conexiones de alimentación y los otros dos pines se utilizan para controlar los segmentos.
Los visualizadores de 7 segmentos contienen 7 (u 8) LEDs direccionables individualmente. Los segmentos están etiquetados de la A a la G y algunos displays tienen también un punto (el 8º LED). Utilice esta imagen como referencia cuando configure los segmentos individuales en el código más adelante.
Puedes comprar muchos módulos de visualización diferentes que utilizan un CI TM1637. El color, el tamaño, los puntos y los puntos de conexión pueden ser diferentes. No tengo experiencia con todas las diferentes versiones de esta pantalla, pero siempre que utilicen el TM1637, los ejemplos de código proporcionados a continuación deberían funcionar.
Aquí puedes encontrar las especificaciones básicas del módulo de visualización que he utilizado en este tutorial.
Especificaciones de la pantalla de 4 dígitos y 7 segmentos TM1637
| Tensión de funcionamiento | 3.3 - 5 V |
| Consumo de corriente | 80 mA |
| Niveles de luminosidad | 8 |
| Dimensiones de la pantalla | 30 x 14 mm (0,36″ dígitos) |
| Dimensiones totales | 42 x 24 x 12 mm |
| Dimensiones de los agujeros | 38 x 20, ⌀ 2,2 mm |
| Temperatura de funcionamiento | -10 - 80 °C |
| Coste | Comprobar el precio |
El CI TM1637 está fabricado por Titan Micro Electronics. Para obtener más información, puede consultar la hoja de datos a continuación:
Cableado - Conexión de la pantalla de 7 segmentos de 4 dígitos TM1637 a Arduino UNO
Conectar la pantalla a un Arduino u otro microcontrolador es súper fácil. Sólo hay que conectar 4 cables: 2 para la alimentación y 2 para transferir los datos.
El siguiente diagrama de cableado muestra cómo se puede conectar la pantalla al Arduino.
Las conexiones también se indican en la tabla siguiente:
Conexiones de la pantalla TM1637
| TM1637 Pantalla de 4 dígitos | Arduino |
|---|---|
| VCC | 5 V |
| GND | GND |
| CLK | Clavija digital 2 |
| DIO | Clavija digital 3 |
Tenga en cuenta que el orden y la ubicación de las clavijas pueden ser diferentes según el fabricante.
Para este tutorial, he conectado CLK y DIO a los pines 2 y 3 respectivamente, pero puedes cambiar esto a cualquiera de los pines digitales que quieras. Sólo tienes que cambiar la configuración de los pines en el código en consecuencia.
TM1637 Pantalla de 4 dígitos y 7 segmentos Código de ejemplo de Arduino
Avishay Orpaz ha escrito una excelente biblioteca para los displays TM1637, la biblioteca TM1637Display. Esta biblioteca tiene varias funciones incorporadas que hacen que el control de la pantalla sea bastante fácil.
Las principales funciones son:
- setSegments() - Establece el valor bruto de los segmentos de cada dígito
- showNumberDec() - Mostrar un número decimal
- showNumberDecEx() - Mostrar un número decimal con puntos decimales o dos puntos
- setBrightness() - Establecer el brillo de la pantalla
- clear() - Borrar la pantalla
El ejemplo de código que sigue presenta todas estas funciones. A continuación explicaré con más detalle cómo se puede utilizar cada función.
Puedes cargar el código de ejemplo en tu Arduino utilizando el IDE de Arduino.
Para instalar la biblioteca, puedes descargarla como un .zip desde GitHub aquí. A continuación, ve a Sketch > Include Library > Add .ZIP Library ... en el IDE de Arduino.
Otra opción es ir a Herramientas > Administrar Bibliotecas... o teclear Ctrl + Shift + I en Windows. El Administrador de Bibliotecas se abrirá y actualizará la lista de bibliotecas instaladas.
Puedes buscar 'tm1637' y buscar la biblioteca de Avishay Orpaz. Selecciona la última versión y haz clic en Instalar.
Código de ejemplo
Puede copiar el código haciendo clic en el botón de la esquina superior derecha del campo de código.
/* Example code for TM1637 4 digit 7 segment display with Arduino. More info: www.www.makerguides.com */
// Include the library:
#include "TM1637Display.h"
// Define the connections pins:
#define CLK 2
#define DIO 3
// Create display object of type TM1637Display:
TM1637Display display = TM1637Display(CLK, DIO);
// Create array that turns all segments on:
const uint8_t data[] = {0xff, 0xff, 0xff, 0xff};
// Create array that turns all segments off:
const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00};
// You can set the individual segments per digit to spell words or create other symbols:
const uint8_t done[] = {
SEG_B | SEG_C | SEG_D | SEG_E | SEG_G, // d
SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F, // O
SEG_C | SEG_E | SEG_G, // n
SEG_A | SEG_D | SEG_E | SEG_F | SEG_G // E
};
// Create degree Celsius symbol:
const uint8_t celsius[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_D | SEG_E | SEG_F // C
};
void setup() {
// Clear the display:
display.clear();
delay(1000);
}
void loop() {
// Set the brightness:
display.setBrightness(7);
// All segments on:
display.setSegments(data);
delay(1000);
display.clear();
delay(1000);
// Show counter:
int i;
for (i = 0; i < 101; i++) {
display.showNumberDec(i);
delay(50);
}
delay(1000);
display.clear();
delay(1000);
// Print number in different locations, loops 2 times:
int j;
for (j = 0; j < 2; j++) {
for (i = 0; i < 4; i++) {
display.showNumberDec(i, false, 1, i);
delay(500);
display.clear();
}
}
delay(1000);
display.clear();
delay(1000);
// Set brightness (0-7):
int k;
for (k = 0; k < 8; k++) {
display.setBrightness(k);
display.setSegments(data);
delay(500);
}
delay(1000);
display.clear();
delay(1000);
// Print 1234 with the center colon:
display.showNumberDecEx(1234, 0b11100000, false, 4, 0);
delay(1000);
display.clear();
delay(1000);
int temperature = 24;
display.showNumberDec(temperature, false, 2, 0);
display.setSegments(celsius, 2, 2);
delay(1000);
display.clear();
delay(1000);
display.setSegments(done);
while(1);
}
Cómo funciona el código:
El código comienza con la inclusión de la biblioteca. Asegúrese de que tiene la biblioteca correcta instalada, de lo contrario recibirá un mensaje de error al compilar el código.
// Include the library: #include "TM1637Display.h"
El siguiente paso es especificar las clavijas de conexión. La declaración #define se utiliza para dar un nombre a un valor constante. El compilador sustituirá cualquier referencia a esta constante por el valor definido cuando se compile el programa. Por lo tanto, en todos los casos en los que se menciona CLKel compilador lo sustituirá por el valor 2 al compilar el programa.
// Define the connections pins: #define CLK 2 #define DIO 3
Initiate Display
A continuación, creamos un objeto display del tipo TM1637Display con los pines CLK y DIO definidos. Ten en cuenta que he llamado al display 'display', pero puedes usar otros nombres también como 'temperature_display'.
El nombre que le des a la pantalla se utilizará más tarde para escribir datos en esa pantalla en particular. Puedes crear y controlar múltiples objetos de visualización con diferentes nombres y pines de conexión. Actualmente no hay límite en la biblioteca.
// Create display object of type TM1637Display: TM1637Display display = TM1637Display(CLK, DIO); // You can create more than one display object. Give them different names and connection pins: TM1637Display display_1 = TM1637Display(2, 3); TM1637Display display_2 = TM1637Display(4, 5); TM1637Display display_3 = TM1637Display(6, 7);
Hay varias maneras de controlar los segmentos individuales de la pantalla. Antes de la sección de configuración del código, especifiqué varias matrices para establecer los segmentos individuales de la pantalla. Utilizaremos la función setSegments() más tarde para escribirlos en la pantalla.
The first option is to write hexadecimal numbers to the display for each digit. The hexadecimal 0xff translates to 11111111 in binary, this sets all the segments on (including the dot if your display has one). 0xef for example, translates to 11101111. This would set all the segments on, except for segment E. Note that counting goes from right to left, so 11111111 corresponds to segments (dot)GFEDCBA.
// Create array that turns all segments on:
const uint8_t data[] = {0xff, 0xff, 0xff, 0xff};
// Create array that turns all segments off:
const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00};
La biblioteca tiene una función incorporada que facilita la configuración de segmentos individuales. Vea el fragmento de código siguiente. Puede crear matrices para deletrear palabras. Cada segmento está separado por un | y los dígitos de la pantalla están separados por una coma.
// You can set the individual segments per digit to spell words or create other symbols:
const uint8_t done[] = {
SEG_B | SEG_C | SEG_D | SEG_E | SEG_G, // d
SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F, // O
SEG_C | SEG_E | SEG_G, // n
SEG_A | SEG_D | SEG_E | SEG_F | SEG_G // E
};
Setup function
Puedes dejar la sección de configuración del código vacía si quieres. Yo sólo he utilizado la función clear() para asegurarse de que la pantalla se ha borrado.
void setup() {
// Clear the display:
display.clear();
delay(1000);
}
Loop function
En la sección de bucles del código, muestro varios ejemplos de las diferentes funciones de la biblioteca:
setSegments(segments[ ], length, position)
Esta función puede utilizarse para establecer los segmentos individuales de la pantalla. El primer argumento es la matriz que incluye la información del segmento. El segundo argumento especifica el número de dígitos a modificar (0-4). Si se quiere deletrear dOnE, esto sería 4, para un símbolo °C, esto sería 2. El tercer argumento establece la posición desde la que se va a imprimir (0 - más a la izquierda, 3 - más a la derecha). Así que si quieres imprimir un símbolo °C en el tercer y cuarto dígito, usarías
// Create degree Celsius symbol:
const uint8_t celsius[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_D | SEG_E | SEG_F // C
};
display.setSegments(celsius, 2, 2);
El segundo y tercer argumento de la función también pueden omitirse.
showNumberDec(number, leading_zeros, length, position)
Esta es probablemente la función que más utilizará. El primer argumento es un número que se quiere mostrar en la pantalla. El resto de los argumentos son opcionales.
El segundo argumento puede utilizarse para activar o desactivar los ceros a la izquierda. 10 sin ceros a la izquierda se imprimiría como __10 y con ceros a la izquierda como 0010. Puede activarlos estableciendo este argumento como verdadero o desactivarlos estableciéndolo como falso. NOTA: el cero a la izquierda no es compatible con los números negativos.
El tercer y cuarto argumento son los mismos que en la función anterior.
// Print the number 12 without leading zeros on the second and third digit: display.showNumberDec(12, false, 2, 1);
showNumberDecEx(number, dots, leading_zeros, length, position)
Esta función permite controlar los puntos de la pantalla. Sólo el segundo argumento es diferente de la función showNumberDec. Le permite establecer los puntos entre los dígitos individuales.
Puede utilizar los siguientes valores.
For displays with dots between each digit use
- 0b10000000 - 0.000
- 0b01000000 - 00.00
- 0b00100000 - 000.0
- 0b11100000 - 0.0.0.0
for displays with just a colon use
- 0b01000000 - 00:00
and for displays with dots and colons colon use
- 0b11100000 - 0.0:0.0
Así que si quieres mostrar un reloj con los dos puntos centrales activados (ver el ejemplo del reloj más abajo), usarías algo como
// Print 1234 with the center colon: display.showNumberDecEx(1234, 0b11100000, false, 4, 0);
setBrightness(brightness, true/false)
Esta función ajusta el brillo de la pantalla (como su nombre indica). Puede especificar un nivel de brillo desde 0 (brillo más bajo) hasta 7 (brillo más alto). El segundo parámetro se puede utilizar para encender o apagar la pantalla, falso significa apagado.
// Set the display brightness (0-7): display.setBrightness(7);
Ejemplo de reloj: TM1637 Pantalla de 4 dígitos y 7 segmentos con DS3231 RTC
Uno de los usos típicos de un display de 4 dígitos y 7 segmentos es mostrar la hora. Combinando el TM1637 con un módulo de reloj de tiempo real (RTC), puede crear fácilmente un reloj de 24 horas.
En este ejemplo he utilizado este módulo RTC DS3231 de uso común.
Este módulo se comunica con el Arduino a través de I2C, por lo que sólo necesita dos conexiones para leer la hora.
El siguiente diagrama de cableado muestra cómo se puede conectar el RTC DS3231 al Arduino. Tenga en cuenta que la pantalla TM1637 se conecta de la misma manera que antes.
Las conexiones también se indican en la tabla siguiente:
Conexiones RTC del DS3231
| DS3231 | Arduino |
|---|---|
| VCC | 5 V |
| GND | GND |
| SDA | A4 |
| SCL | A5 |
El siguiente ejemplo de código puede utilizarse para mostrar la hora en un formato de 24 horas. Si su pantalla tiene dos puntos centrales, este código hará que parpadee. También puede desactivar esto eliminando las últimas líneas de código.
La primera vez que cargues el código, el RTC se ajustará a la hora en que se compiló el boceto.
Puedes instalar una batería de tipo moneda en la parte posterior del módulo, para que la hora se almacene en caso de que se pierda la energía. Aparentemente, el circuito de carga de la mayoría de los módulos chinos puede sobrecargar la batería de celda de moneda, por lo que es posible que desee comprar un módulo DS3231 de Adafruit en su lugar.
El código utiliza la biblioteca RTC de Adafruit, que puedes descargar aquí en GitHub. También puedes instalarla a través del Gestor de Bibliotecas en el IDE de Arduino buscando 'RTClib', o haciendo clic en el botón de descarga de abajo:
Código de ejemplo
/* Arduino example code to display a 24 hour time format clock on a
TM1637 4 digit 7 segment display with a DS32321 RTC.
More info: www.www.makerguides.com */
// Include the libraries:
#include "RTClib.h"
#include "TM1637Display.h"
// Define the connections pins:
#define CLK 2
#define DIO 3
// Create rtc and display object:
RTC_DS3231 rtc;
TM1637Display display = TM1637Display(CLK, DIO);
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Wait for console opening:
delay(3000);
// Check if RTC is connected correctly:
if (!rtc.begin()) {
Serial.println("Couldn't find RTC");
while (1);
}
// Check if the RTC lost power and if so, set the time:
if (rtc.lostPower()) {
Serial.println("RTC lost power, lets set the time!");
// The following line sets the RTC to the date & time this sketch was compiled:
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
// This line sets the RTC with an explicit date & time, for example to set
// January 21, 2014 at 3am you would call:
//rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
}
// Set the display brightness (0-7):
display.setBrightness(5);
// Clear the display:
display.clear();
}
void loop() {
// Get current date and time:
DateTime now = rtc.now();
// Create time format to display:
int displaytime = (now.hour() * 100) + now.minute();
// Print displaytime to the Serial Monitor:
Serial.println(displaytime);
// Display the current time in 24 hour format with leading zeros enabled and a center colon:
display.showNumberDecEx(displaytime, 0b11100000, true);
// Remove the following lines of code if you want a static instead of a blinking center colon:
delay(1000);
display.showNumberDec(displaytime, true); // Prints displaytime without center colon.
delay(1000);
}
Ejemplo de termómetro: TM1637 Pantalla de 4 dígitos y 7 segmentos con sensor de temperatura y humedad DHT11
Los displays de 4 dígitos y 7 segmentos son ideales para mostrar lecturas de sensores como la temperatura, la humedad, el voltaje o la velocidad. En el siguiente ejemplo, le mostraré cómo puede mostrar las lecturas de temperatura en la pantalla del TM1637.
Utilizaremos el popular sensor de temperatura y humedad DHT11.
El siguiente diagrama de cableado muestra cómo se puede conectar el sensor DHT11 en combinación con la pantalla TM1637 al Arduino.
Tenga en cuenta que la pantalla TM1637 se conecta de la misma manera que antes.
Las conexiones también se indican en la tabla siguiente:
Conexiones DHT11
| DHT11 | Arduino |
|---|---|
| + | 5 V |
| - | GND |
| s | Clavija digital 4 |
Tenga en cuenta que el orden de los pines puede ser diferente, dependiendo del fabricante.
Si quieres utilizar un sensor de 4 pines, consulta mi tutorial para los sensores de temperatura y humedad DHT11 y DHT22.
El código de ejemplo que aparece a continuación se puede utilizar para mostrar las lecturas de temperatura en la pantalla. Alterna entre la temperatura en Celius y Fahrenheit, ambas se muestran durante 2 segundos.
La función setSegments() se utiliza para mostrar los símbolos Celsius y Fahrenheit.
El código utiliza la biblioteca de sensores DHT de Adafruit que puedes descargar aquí en GitHub. Esta librería sólo funciona si también tienes instalada la librería Adafruit Unified Sensor, que también está disponible en GitHub.
También puede descargar las dos bibliotecas haciendo clic en los botones de abajo:
Para más información vea mi tutorial de DHT11 con Arduino.
Código de ejemplo
/* Arduino example sketch to display DHT11 temperature readings
on a TM1637 4-digit 7-segment display.
More info: www.www.makerguides.com */
// Include the libraries:
#include "TM1637Display.h"
#include "Adafruit_Sensor.h"
#include "DHT.h"
// Define the connections pins:
#define CLK 2
#define DIO 3
#define DHTPIN 4
// Create variable:
int temperature_celsius;
int temperature_fahrenheit;
// Create degree Celsius symbol:
const uint8_t celsius[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_D | SEG_E | SEG_F // C
};
// Create degree Fahrenheit symbol:
const uint8_t fahrenheit[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_E | SEG_F | SEG_G // F
};
// Set DHT type, uncomment whatever type you're using!
#define DHTTYPE DHT11 // DHT 11
//#define DHTTYPE DHT22 // DHT 22 (AM2302)
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Create display object of type TM1637Display:
TM1637Display display = TM1637Display(CLK, DIO);
// Create dht object of type DHT:
DHT dht = DHT(DHTPIN, DHTTYPE);
void setup() {
// Set the display brightness (0-7):
display.setBrightness(0);
// Clear the display:
display.clear();
// Setup sensor:
dht.begin();
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Wait for console opening:
delay(2000);
}
void loop() {
// Read the temperature as Celsius and Fahrenheit:
temperature_celsius = dht.readTemperature();
temperature_fahrenheit = dht.readTemperature(true);
// Print the temperature to the Serial Monitor:
Serial.println(temperature_celsius);
Serial.println(temperature_fahrenheit);
// Show the temperature on the TM1637 display:
display.showNumberDec(temperature_celsius, false, 2, 0);
display.setSegments(celsius, 2, 2);
delay(2000);
display.showNumberDec(temperature_fahrenheit, false, 2, 0);
display.setSegments(fahrenheit, 2, 2);
delay(2000);
}
Conclusión
En este artículo te he mostrado cómo puedes utilizar un display de 7 segmentos de 4 dígitos TM1637 con Arduino. También hemos visto un ejemplo de reloj y termómetro. Espero que lo hayas encontrado útil e informativo. Si lo has hecho, ¡compártelo con un amigo al que también le guste la electrónica y hacer cosas!
Me gusta mucho usar estos displays para mostrar lecturas de sensores o cosas como la velocidad de un motor. Con la librería TM1637Display, programar los displays se convierte en algo muy sencillo, así que no hay razón para que no incorpores uno en tu próximo proyecto.
Me encantaría saber qué proyectos planeas construir (o ya has construido) con esta pantalla. Si tienes alguna pregunta, sugerencia, o si crees que faltan cosas en este tutorial, por favor deja un comentario abajo.
Tenga en cuenta que los comentarios son retenidos por la moderación para evitar el spam.
Benne is professional Systems Engineer with a deep expertise in Arduino and a passion for DIY projects.
Pavel
Friday 1st of December 2023
Can you please fix missing library names in include statements? Thank you so much for this tutorial.
Pavel
Sunday 3rd of December 2023
@Stefan Maetschke, Thank you Stefan, it all looks good now. Thank you very much for this high quality easy to follow tutorial.
Stefan Maetschke
Friday 1st of December 2023
@Pavel, there is an issue with the syntax highlighter, which I fixed but I don't see any missing library names. Which ones are missing? Thanks Stefan
Bryan
Wednesday 14th of June 2023
#include #include #include #include
LiquidCrystal_I2C lcd(0x27,16,2);
// Pin yang terhubung dengan keypad const byte ROWS = 4; // jumlah baris pada keypad const byte COLS = 4; // jumlah kolom pada keypad char keys[ROWS][COLS] = { {'1','2','3','A'}, {'4','5','6','B'}, {'7','8','9','C'}, {'*','0','#','D'} }; byte rowPins[ROWS] = {9, 8, 7, 6}; // pin baris keypad terhubung ke pin Arduino byte colPins[COLS] = {5, 4, 3, 2}; // pin kolom keypad terhubung ke pin Arduino Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
// Pin yang terhubung dengan 4 Digit seven segment TM1637 #define CLK_PIN 10 #define DIO_PIN 11 TM1637Display display(CLK_PIN, DIO_PIN);
const String PASSWORD = "1234"; // Password yang benar String enteredPassword = ""; // Password yang diinput
void setup() { lcd.begin();
lcd.print("Masukkan Password");
display.setBrightness(0x0f); // Atur kecerahan TM1637
updateDisplay(); }
void loop() { char key = keypad.getKey();
if (key) { if (key == '#') { // Tombol "#" ditekan if (enteredPassword == PASSWORD) { lcd.clear(); lcd.print("Password OK"); } else { lcd.clear(); lcd.print("Password NOT OK"); } delay(2000); lcd.clear(); enteredPassword = ""; } else if (key == '*') { // Tombol "*" ditekan enteredPassword = ""; } else { // Tombol angka ditekan if (enteredPassword.length() < 4) { enteredPassword += key; } }
updateDisplay(); } }
void updateDisplay() { // Mengupdate tampilan TM1637 display.showNumberDec(atoi(enteredPassword.c_str()), true, 4, 0); }
Reza
Lunes 17 de mayo de 2021
Muchas gracias por publicar, esto realmente me ayudó a entender cómo controlar la pantalla
stephen
Martes 20 de abril de 2021
Hice algunos cambios pero funciona muy bien buen trabajo :)
Ricky
Martes 16 de febrero de 2021
Hola, El proyecto es muy bonito. Lo he utilizado con el MLX90614 pero no he podido mostrar el tercer dígito con un decimal. ¿Has probado a hacerlo con el punto decimal del termómetro de tres dígitos?