Chgment autoradio - Récupération des infos: température, etc

[man3515]

Merci d'utiliser un traducteur pour afficher la version française de vos discussion.

Please use a translator to view the French version of your discussion.

[Emudem]

c'est ma radio, photos jointes.


Est-il possible d'afficher la température extérieure ?


Merci

[fb78]

c'est ma radio, photos jointes.

ça ne ressemble pas du tout à une radio !!!!!

Est-il possible d'afficher la température extérieure ?

oui, sur la radio

[Emudem]

radio photo ci-jointe.

J'ai installé Arduino et je n'arrive pas à afficher la température

[fb78]

J'ai installé Arduino

ça veut dire quoi "J'ai installé Arduino" ?????

[man3515]

@Francis : Emudem est espagnol et passe par un traducteur, ce qui peut expliquer ces imprécisions linguistiques

[fb78]

Ah, ok David mais cela ne l'empêche pas de donner plus d'informations !!!

[vinzzz34]

Bonjour à vous,

je vous partage le code source de l'arduino qui avait été développé par moi et feu Francis.
Il n'est pas maintenant utile de le garder secret sachant que les tablettes chinoise savent le faire maintenant.

Amis développeurs bonne lecture

Code : Tout sélectionner

/*
  Auteurs: Francis BRUMENT alias FB78 (merci de ne pas me plagier et me contacter à fb.gps@free.fr si vous souhaitez des modifications).
           Vincent NEIHCEL alias vinzzz34.

  Mon site:
  http://chez.fb.free.fr/

  Utilisation:
  Programme pour afficher la date, l'heure GPS (heure UTC de Paris) et la température extérieure sur un afficheur connecté à un réseau CAN.

  Circuits utilisés:
  1 Arduino UNO Rev.3 ou plus
  1 CAN-BUS Shield v1.2 ou plus
  1 GPS Shield NEO v3.1 ou plus

  Fonctionalités:
  A chaque mise sous tension ou "Reset" du circuit, la date et l'heure seront directement initialisées par le GPS à l'heure de Paris.
  L'heure sera affichée dans le format hh:mm (exemple: 19:45) en "big clock" au centre de l'écran ou en normal avec la date.
  La date sera affichée dans le format jjjj nn mmmm aaaa (exemple: Vendredi 09 novembre 2018) sur la 2ème ligne de l'écran LCD.
  Pour basculer (ON ou OFF) en "mode debug" ou non, il faut envoyer la commande "Texte" puis en guise de texte le mot clé "Debug".
  Le programme lit aussi les trames CAN de la climatisation pour transmettre des informations à l'application Android pour visualisation.
*/

#include "EEPROM.h"                                     // pour enregistrer les options du programme (format de l'heure, affichage date ou pas, etc...)
#include "mcp_can.h"                                    // pour gérer le port CAN
#include "SoftwareSerial.h"                             // pour gérer la liaison soft du GPS

const String verProg = "5.1 du 05/08/2019";             // version et date du programme à mettre à jour aussi dans le fichier "tuscani\Versions.txt" sur mon site
                                                        // le point dans "verProg" est obligatoirement en 2ème position et la longueur doit être de 17 caractères
const String jours[] = {"Dimanche","Lundi","Mardi","Mercredi","Jeudi","Vendredi","Samedi"};
const String mois[]  = {"janvier","fevrier","mars","avril","mai","juin","juillet","aout","septembre","octobre","novembre","decembre"};
const byte CAN_CS = 10;                                 // assigne la pin Chip Select du CAN Shield
const byte sondeTemp = 0;                               // assigne la pin analogique A0 pour la sonde de température extérieure
const byte RX = 3, TX = 4;                              // assigne les pins Receive (RX) et Transmit (TX) du GPS soft
const byte adrOptions = 0;                              // assigne l'adresse EEPROM pour les 7 options
const char finChaine = '\n';                            // définition de "fin de chaine" pour économiser la mémoire de 2 Ko
unsigned char power1[] = {64,0,0,0,0,0,0,0};            // données envoyées à l'écran LCD
unsigned char power2[] = {1,0,0,0,0,0,0,0};
unsigned char heure1[] = {64,0,0,0,0,0,35,0};
unsigned char heure2[] = {128,0,0,0,0,0,0,0};           // format de l'heure à 24H
unsigned char infos1[] = {162,0,0,0,0,0,0,0};           // pour le big clock : on remplace 162 par 1
unsigned char infos2[] = {16,62,43,130,0,2,0,42};
unsigned char atten1[] = {33,32,32,32,65,84,84,69};     // message:   ATTE
unsigned char atten2[] = {34,78,84,69,32,71,80,83};     // message:NTE GPS
unsigned char datas1[] = {33,0,0,0,0,0,0,0};
unsigned char datas2[] = {34,0,0,0,0,0,0,0};
unsigned char datas3[] = {35,0,0,0,0,0,0,0};
unsigned char datas4[] = {36,0,0,0,0,0,0,0};
unsigned char datas5[] = {37,0,0,0,0,0,0,0};
unsigned char datas6[] = {38,0,0,0,0,0,0,0};
unsigned char datas7[] = {39,64,65,0,0,0,0,0};
unsigned char datas8[] = {40,0,0,0,0,0,0,0};
unsigned char hretmn[] = {0,0,0,0,0,0,0,0};
unsigned char temper[] = {0,0,0,0,0,0,0,0};
float moyenne, tempExt, tempInt;                        // moyenne des températures, température extérieure et température intérieure (climatisation)
boolean debug = false;                                  // pour exécuter le programme en "mode debug" --> envoi les données de contrôle vers Android
boolean dateNOK = true;                                 // pour afficher "ATTENTE GPS" seulement si la date n'a pas été affichée
String texte;                                           // texte affiché au centre à la place de l'heure
int nb, i;                                              // variables générales
int CanId = 0;                                          // identification des trames CAN de la climatisation
byte ac = -1;                                           // climatisation en automatique
byte onoff = -1;                                        // climatisation en marche/arrêt
byte mode = -1;                                         // dégivrage (climatisation)
byte vent = -1;                                         // vitesse de la ventilation (climatisation)
byte air = -1;                                          // air recyclé (climatisation)
byte options;                                           // 1 octet pour mémoriser 7 options possibles (1 = option active, 0 = option non active)
                                                        // bits 7 6 5 4 3 2 1 0
                                                        //      ^ ^ ^ ^ ^ ^ ^ ^
                                                        //      | | | | | | | |_ big clock (1) ou clock normale (0)
                                                        //      | | | | | | |___ texte au choix (1) ou l'heure au centre (0)
                                                        //      | | | | | |_____ heure d'hiver (1) ou heure d'été (0)
                                                        //      | | | | |_______ 
                                                        //      | | | |_________ 
                                                        //      | | |___________ 
                                                        //      | |_____________ 
                                                        //      |_______________ options non initialisées (1) ou options initialisées (0)
const byte bitBigClock = 0;                             // position binaire de l'option "Big clock"
const byte bitTexte = 1;                                // position binaire de l'option "Texte"
const byte bitHiver = 2;                                // position binaire de l'option "Heure d'hiver"
const byte bitOptions = 7;                              // position binaire de "Options initialisées"

MCP_CAN CAN(CAN_CS);                                            // Set CS pin
SoftwareSerial SoftGPS(RX, TX);                                 // création de l'objet GPS

void setup()
  {
  Serial.begin(19200);
  SoftGPS.begin(9600);                                          // obligatoirement à 9600 bauds sinon blocage
  pinMode(CAN_CS, OUTPUT);                                      // déclare la pin Chip Select en sortie
  digitalWrite(CAN_CS, LOW);                                    // sélectionne le CAN Shield
  while (CAN.begin(CAN_100KBPS, MCP_8MHz) != CAN_OK)            // initialisation du CAN-BUS Shield à 16MHz (MCP_16MHz) ou à 8MHz (MCP_8MHz)
    {
    if (debug) Serial.println(F("erreur init. CAN Shield, recommence dans 1 sec."));
    delay(1000);
    }
  if (debug) Serial.println(F("CAN Shield initialisé"));
  delay(1000);                                                  // attente de stabilisation du CAN-BUS
  CAN.sendMsgBuf(256, 0, 8, power1);                            // allumage de l'écran LCD
  CAN.sendMsgBuf(6, 0, 8, power2);                              // modèle Europe
  CAN.sendMsgBuf(6, 0, 8, heure1);                              // positionne en mode format
  delay(250);
  CAN.sendMsgBuf(41, 0, 8, heure2);                             // set l'heure en format 24H
  options = EEPROM.read(adrOptions);                            // lecture des options mémorisées à l'adresse 0 de l'EEPROM
  if (bitRead(options, bitOptions))                             // si les options n'ont jamais été initialisées
    {
    EEPROM.update(adrOptions, 0);                               // initialise toutes les options par défaut à la 1ère utilisation de l'Arduino
    }
  else
    {
    if (bitRead(options, bitBigClock))                          // si option "BigClock" active
      {
      infos1[0] = 1;                                            // affichage de l'heure en format big_clock
      }
    else
      {
      infos1[0] = 162;                                          // affichage de l'heure en format date_heure
      }
    CAN.sendMsgBuf(6, 0, 8, infos1);
    if (bitRead(options, bitTexte))                             // si option "Texte" active
      {
      char temp[12];
      for (i = 0; i < 12; i++) temp[i] = char(EEPROM.read(i + 1)); // lecture du texte mémorisé dans l'EEPROM (adresses 1 à 12)
      texte = temp;
      }
    // suite pour les autres options
    }
  }

void (*ResetSoft) (void) = 0;                                   // fonction de relance du "setup" (le hard n'est pas réinitialisé)

void loop()
  {
//*******************************************************
//   traitement des commandes reçues sur le port série
//*******************************************************
  if (Serial.available())                                       // si une commande a été émise sur le port série depuis l'application Android
    {
    String commande = Serial.readStringUntil(finChaine);
    if (debug)
      {
      Serial.print(F("commande="));
      Serial.println(commande);
      }
    if (commande == F("Reset"))                                 // si réinitialisation de l'Arduino
      {
      ResetSoft();                                              // appelle la fonction "ResetSoft" qui relance uniquement le "setup"
      }
    if (commande == F("Reinit"))                                // si réinitialisation de toutes les options
      {
      EEPROM.update(adrOptions, 0);                             // enregistre toutes les options à zéro (valeur par défaut)
      options = 0;                                              // et RAZ des options en cours
      }
    if (commande == F("Version"))                               // si demande d'affichage de la version sur l'écran Android
      {
      Serial.println(verProg);                                  // envoi la version et la date sur le port série vers Android
      }
    if (commande == F("Texte"))                                 // si affichage d'un texte à la place de l'heure au centre
      {
      String nouveau = "";                                      // chaine qui va recevoir le nouveau texte
      do
        {
        if (Serial.available()) nouveau = Serial.readStringUntil(finChaine);  // lecture du texte saisi dans l'application Android
        }
      while (nouveau == "");
      nouveau = nouveau.substring(0, 12);                       // limitation à 12 caractères maximum
      if (debug)
        {
        Serial.print(F("nouveau="));
        Serial.println(nouveau);
        }
      if (nouveau != F("Annuler"))                              // si la commande "Texte" n'a pas été annulée
        {
        if (nouveau == F("Debug"))                              // si le texte envoyé = "Debug"
          {
          if (debug) debug = false; else debug = true;          // bascule (ON/OFF) le "mode debug" --> exécute ou non tous les "Serial.print"
          }
        else                                                    // sinon, on enregistre le texte
          {
          texte = nouveau;                                      // on remplace l'ancien texte par le nouveau
          for (i = 0; i < 12; i++) EEPROM.write(i + 1, texte[i]); // écriture du texte dans l'EEPROM (des adresses 1 à 12)
          infos1[0] = 162;
          CAN.sendMsgBuf(6, 0, 8, infos1);                      // affichage du texte sur l'écran LCD
          bitSet(options, bitTexte);                            // option "Texte" active
          bitClear(options, bitBigClock);                       // option "BigClock" inactive
          }
        }
      }
    if (commande == F("HeureEte"))                              // si affichage de l'heure d'été
      {
      bitClear(options, bitHiver);                              // option "Heure d'Hiver" inactive
      }
    if (commande == F("HeureHiver"))                            // si affichage de l'heure d'hiver
      {
      bitSet(options, bitHiver);                                // option "Heure d'Hiver" active
      }
    if (commande == F("BigClock"))                              // si affichage de l'heure en gros au centre de l'écran LCD
      {                                                         // à la place de la date
      infos1[0] = 1;
      CAN.sendMsgBuf(6, 0, 8, infos1);
      bitClear(options, bitTexte);                              // option "Texte" inactive
      bitSet(options, bitBigClock);                             // option "BigClock" active
      }
    if (commande == F("DateHeure"))                             // si affichage de la date au centre et de l'heure
      {                                                         // à la place de l'heure en gros
      infos1[0] = 162;
      CAN.sendMsgBuf(6, 0, 8, infos1);
      bitClear(options, bitTexte);                              // option "Texte" inactive
      bitClear(options, bitBigClock);                           // option "BigClock" inactive
      }
    if (commande == F("Clim"))                                  // si demande de toutes les infos de la climatisation
      {
      Serial.println("0>" + String(int(tempExt + 20)));         // température extérieure (+ 20 pour ne jamais être négatif avec le signe -)
      delay(200);
      Serial.println("1>" + String(tempInt * 0.5 + 17));        // température intérieure
      delay(200);
      Serial.println("2>" + String(mode));                      // mode 1 à 5
      delay(200);
      Serial.println("3>" + String(air));                       // air recyclé, extérieur, mode auto
      delay(200);
      Serial.println("4>" + String(ac));                        // AC clim active
      delay(200);
      Serial.println("5>" + String(onoff / 20 - 1));            // marche/arrêt
      delay(200);
      Serial.println("6>" + String(vent - 1));                  // ventilation
      }
    // suite pour les autres commandes (options)
    EEPROM.update(adrOptions, options);                         // enregistre (si elles ont changées) les nouvelles options à l'adresse 0
    commande = "";
    }

//*******************************************************
//              lecture des trames
//*******************************************************
  String trame, tampon, jj, mm, aa, heures, minutes;
  byte hr, mn;
  if (SoftGPS.available())                                      // si le GPS envoi des trames
    {
    trame = SoftGPS.readStringUntil(finChaine);
    i = trame.indexOf(F("RMC"));
    if (i >= 0)                                                 // si la trame RMC a été reçue
      {
      if (debug)
        {
        Serial.print(F("trame="));
        Serial.println(trame.substring(i - 3, trame.indexOf('*', i) + 3));
        }

//*******************************************************
//            traitement de la date et de l'heure
//*******************************************************
      int j = trame.indexOf('*', i) - 10;                       // recherche le début de la date
      jj = trame.substring(j, j + 2);
      mm = trame.substring(j + 2, j + 4);
      aa = trame.substring(j + 4, j + 6);
      if (jj.toInt()>=1 && jj.toInt()<=31 && mm.toInt()>=1 && mm.toInt()<=12 && aa.toInt()>=18 && aa.toInt()<=99) // si la date est valide dans la trame
        {
        dateNOK = false;                                        // RAZ du flag affichage de "ATTENTE GPS"
        heures = trame.substring(i + 4, i + 6);
        if (bitRead(options, bitHiver))                         // si option "Heure d'hiver" active
          {
          heures = String(heures.toInt() + 1);                  // ajustement heure d'hiver pour le fuseau horaire de Paris
          if (heures.toInt() == 24)                             // si on a dépassé minuit à cause de l'ajustement d'heure
            {
            heures = F("00");                                   // réinitialisation de l'heure
            j = -1;                                             // set l'indicateur
            }
          }
        else
          {
          heures = String(heures.toInt() + 2);                  // ajustement heure d'été pour le fuseau horaire de Paris
          if (heures.toInt() == 25)                             // si on a dépassé minuit à cause de l'ajustement d'heure
            {
            heures = F("01");                                   // réinitialisation de l'heure
            j = -1;                                             // set l'indicateur
            }
          }
        if (j == -1)                                            // si l'heure a été réinitialisée
          {
          jj = jj.toInt() + 1;                                  // incrémente le jour
          if (jj.toInt() > 31 || (mm.toInt() == 2 && jj.toInt() > 29))
            {
            jj = F("01");
            mm = mm.toInt() + 1;                                // incrémente le mois
            }
          if (mm.toInt() > 12)
            {
            mm = F("01");
            aa = aa.toInt() + 1;                                // incrémente l'année
            }
          }
/*
jj = "02";    // pour forcer une date test la plus longue possible : Dimanche 02 septembre 2018
mm = "09";
aa = "18";
*/
/*
jj = "07";    // pour forcer une date test la plus courte possible : Lundi 07 mai 2018
mm = "05";
aa = "18";
*/
        int c = (14 - mm.toInt())/12;
        int m = mm.toInt() + 12*c - 2;
        int a = aa.toInt() - c;
        j = (jj.toInt() + a + a/4 - a/100 + a/400 + (31*m)/12) %7;            // calcule le jour de la semaine
        tampon = jours[j] + ' ' + jj + ' ' + mois[mm.toInt()-1] + " 20" + aa; // et assemblage de la date complète
        if (debug)
          {
          Serial.print(F("date="));
          Serial.println(tampon);
          }
        CAN.sendMsgBuf(6, 0, 8, infos1);                        // mode USB info
        CAN.sendMsgBuf(1152, 0, 8, infos2);                     // trame de début
        for (c = 1; c < 8; c++) datas1[c] = tampon[c - 1];
        CAN.sendMsgBuf(1152, 0, 8, datas1);                     // début de la date sur la 2ème ligne de l'écran LCD
        for (c = 1; c < 8; c++) datas2[c] = tampon[c + 6];
        CAN.sendMsgBuf(1152, 0, 8, datas2);                     // suite de la date sur la 2ème ligne de l'écran LCD
        for (c = 1; c < 8; c++) datas3[c] = tampon[c + 13];
        CAN.sendMsgBuf(1152, 0, 8, datas3);                     // suite de la date sur la 2ème ligne de l'écran LCD
        for (c = 1; c < 8; c++) datas4[c] = tampon[c + 20];
        CAN.sendMsgBuf(1152, 0, 8, datas4);                     // suite de la date sur la 2ème ligne de l'écran LCD
        CAN.sendMsgBuf(1152, 0, 8, datas5);
        CAN.sendMsgBuf(1152, 0, 8, datas6);

//*******************************************************
//          traitement de l'heure ou du texte
//*******************************************************
        hr = heures.toInt();
        minutes = trame.substring(i + 6, i + 8);
        mn = minutes.toInt();
        if (bitRead(options, bitTexte))                         // si option "Texte" active
          {
          trame = texte;                                        // affiche le texte
          }
        else
          {
          trame = heures + ':' + minutes;                       // affiche l'heure
          }
        for (i = 0; i < tampon.length(); i++) tampon[i] = ' ';  // préparation du champ pour le
        int n = round((12 - trame.length()) / 2);               // centrage des données sur la ligne
        for (i = n; i - n < trame.length(); i++) tampon[i] = trame[i - n];
        if (debug)
          {
          Serial.print(F("heure/texte="));
          Serial.println(tampon);
          }
        for (i = 3; i < 8; i++) datas7[i] = tampon[i - 3];
        CAN.sendMsgBuf(1152, 0, 8, datas7);                     // début de l'heure ou du texte sur la 1ère ligne de l'écran LCD
        for (i = 1; i < 8; i++) datas8[i] = tampon[i + 4];
        CAN.sendMsgBuf(1152, 0, 8, datas8);                     // suite de l'heure ou du texte sur la 1ère ligne de l'écran LCD
        hretmn[0] = (hr/10*16) + (hr%10);
        hretmn[1] = (mn/10*16) + (mn%10);
        CAN.sendMsgBuf(1282, 0, 8, hretmn);                     // envoi l'heure à l'écran LCD (dans l'angle supérieur droit)
        }

//*******************************************************
//        attente réception date et heure valides
//*******************************************************
      else if (dateNOK)                                         // si la date n'a pas déjà été affichée,
        {
        if (debug)
          {
          Serial.println(F("ATTENTE GPS"));
          }
        CAN.sendMsgBuf(6, 0, 8, infos1);                        // affichage du message
        CAN.sendMsgBuf(1152, 0, 8, infos2);
        CAN.sendMsgBuf(1152, 0, 8, atten1);                     // début de la 2ème ligne du message d'attente à l'écran LCD
        CAN.sendMsgBuf(1152, 0, 8, atten2);                     // suite de la 2ème ligne du message d'attente à l'écran LCD
        CAN.sendMsgBuf(1152, 0, 8, datas3);                     // puis envoi de datas vides
        CAN.sendMsgBuf(1152, 0, 8, datas4);
        CAN.sendMsgBuf(1152, 0, 8, datas5);
        CAN.sendMsgBuf(1152, 0, 8, datas6);
        CAN.sendMsgBuf(1152, 0, 8, datas7);
        CAN.sendMsgBuf(1152, 0, 8, datas8);
        }
      }
    SoftGPS.flush();                                            // vide le tampon de réception du GPS soft
    }

//*******************************************************
//      traitement de la température extérieure
//*******************************************************
  int Vo;
  float logR2, R2 = 0, R1 = 30000;                              // valeur de la résistance du pont diviseur en ohms (~30K)
  float A = 0.8956411214e-03, B = 2.286293477e-04, C = 0.9259597517e-07;  // coefficients de Steinhart-Hart et Hart
  Vo = analogRead(sondeTemp);                                   // lecture de la valeur sur la pin A0 (sonde température extérieure)
//Vo = 567;    // simulation de la température à 20,07°C
  delay(1);                                                     // attente de 1 milliseconde pour la stabilisation de l'ADC
  R2 = R1 / (1023.0 / (float)Vo - 1.0);                         // calcule la valeur de la thermistance selon la température
  logR2 = log(R2);
  tempExt = (1.0 / (A + B*logR2 + C*logR2*logR2*logR2));        // équation Steinhart et Hart : T = 1 / {A + B[log(R)] + C[log(R)]^3}
  tempExt -= 273.15;                                            // conversion de la température °Kelvin en température °Celsius
  moyenne += tempExt;                                           // cumule les valeurs de température
  nb += 1;                                                      // et le nombre de cumuls
  if (nb >= 60)                                                 // moyennage sur 60 mesures (~ 2 mesures/sec lorsque le GPS est valide)
    {
    moyenne = round(moyenne / nb);                              // calcule la moyenne des mesures de température toutes les 30 secondes
    temper[1] = int(moyenne * 1.82 + 73);                       // conversion de la température °Celsius en température LCD
    CAN.sendMsgBuf(1281, 0, 8, temper);                         // envoi la température à l'écran LCD
    Serial.println("0>" + String(int(moyenne + 20)));           // température extérieure (+ 20 pour ne jamais être négatif avec le signe -)
    moyenne = 0;
    nb = 0;
    }

//*******************************************************
//        gestion de la climatisation
//*******************************************************
unsigned char len = 0;
unsigned char buf[8];
String msg;
  if (CAN_MSGAVAIL == CAN.checkReceive())                       // si une trame CAN est reçue
    {
    CAN.readMsgBuf(&len, buf);                                  // stockage de cette trame dans un buffer
    CanId = CAN.getCanId();                                     // extraction de l'identification (émetteur) de la trame
    switch(CanId)
      {
      case 305:                                                 // identifiant de la température intérieure
        if (tempInt != buf[1])                                  // si la valeur a changée,
          {
          tempInt = buf[1];                                     // on l'enregistre et
          msg = "1>" + String(tempInt * 0.5 + 17);              // on formate le message à envoyer
          Serial.println(msg);                                  // envoi sur le port série le message pour traitement par Android
          }
        break;
      case 306:                                                 // identifiant de la climatisation
        if (mode != buf[0])
          {
          mode = buf[0];
          msg = "2>" + String(mode);                            // mode 1 à 5
          Serial.println(msg);
          }
        if (air != buf[1])
          {
          air = buf[1];
          msg = "3>" + String(air);                             // air recyclé, extérieur, mode auto
          Serial.println(msg);
          }
        if (ac != buf[2])
          {
          ac = buf[2];
          msg = "4>" + String(ac);                              // AC clim active
          Serial.println(msg);
          }
        if (onoff != buf[3])
          {
          onoff = buf[3];
          msg = "5>" + String(onoff / 20 - 1);                  // marche/arrêt
          Serial.println(msg);
          }
        if ((vent != buf[7]) && (buf[7] < 10))
          {
          vent = buf[7];
          msg = "6>" + String(vent - 1);                        // ventilation
          Serial.println(msg);
          }
        break;
      }
    if (msg != "")
      {
      if (debug)
        {
        Serial.print(F("clim:"));
        Serial.println(msg);
        }
      }
    }
  }

[ouji]

@vinzzz34
Qu'est ce que tu veux faire par "sachant que les tablettes chinoises savent le faire maintenant".
On.peu monter une tablette et conserver nativement l'affichage de la température ?

[vinzzz34]

@vinzzz34
Qu'est ce que tu veux faire par "sachant que les tablettes chinoises savent le faire maintenant".
On.peu monter une tablette et conserver nativement l'affichage de la température ?

oui nous l'avons fait, les postes chinois pour genesis le font aussi maintenant