Proyecto de lectura de 4 sondas DS18B20 y visualización en pantalla Nextion

[diegoing]

Estoy intentando hacer un programa para leer 4 sondas del tipo DS18B20 mediante arduino y poder verlas en una pantalla nextion. Puedo ver los resultados de las lecturas en el monitor serie, pero no me salen el la pantalla nexion. Es un Proyecto Docente para un ciclo de FP. Adjunto programación y pantallazo de la pantalla nextión. He estado haciendo pruebas y por eso veréis líneas de programa como comentarios ya que las dejo sin uso así.

Desearía que me dijerais donde esta el error de forma sencilla ya que no soy un experto en programación. Mi problema es que necesito ver los valores negativos ya que necesito la aplicación para analizar temperaturas de un cámara de congelación.

#include <Nextion.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// Pin donde se conecta el bus 1-Wire
/// const int pinDatosDQ = 2;
 
// Instancia a las clases OneWire y DallasTemperature
OneWire oneWireObjeto(2);
DallasTemperature sensors(&oneWireObjeto);

///void n1PopCallback(void *ptr);
///void n2PopCallback(void *ptr);
///void n3PopCallback(void *ptr);
///void n4PopCallback(void *ptr);

// Variables con las direcciones únicas de los 4 sensores DS18B20
DeviceAddress address1 = {0x28, 0xFF, 0x20, 0xCE, 0xA4, 0x16, 0x05, 0x8D};//dirección del sensor 1
DeviceAddress address2 = {0x28, 0xFF, 0x74, 0xDA, 0xA2, 0x16, 0x04, 0xBE};//dirección del sensor 2
DeviceAddress address3 = {0x28, 0xFF, 0xD6, 0xBD, 0xA4, 0x16, 0x04, 0xC9};//dirección del sensor 3
DeviceAddress address4 = {0x28, 0xFF, 0x03, 0xDC, 0xA2, 0x16, 0x04, 0x8B};//dirección del sensor 4 

/*
 * Declare a number object [page id:0,component id:3, component name: "n0"]. 
 */
//NexNumber n1 = NexNumber(0, 3, "n1");
//NexNumber n2 = NexNumber(0, 5, "n2");
//NexNumber n3 = NexNumber(0, 9, "n3");
//NexNumber n4 = NexNumber(0, 7, "n4");


// End of declaring objects


// char buffer[100] = {0};  // This is needed only if you are going to receive a text from the display. You can remove it otherwise.
                         // Further on this sketch I do receive text so that's why I created this buffer.
                         
 // NexTouch *nex_listen_list[] = {
 // &bt0,  // Button added
 // &bt1,  //
 // &n1,
 // &n2,
 // &n3,
 // &n4,
 
//  NULL  // String terminated
// };  // End of touch event list




void setup() {
   delay(1000);
   // Iniciamos la comunicación serie
    Serial.begin(9600);
    // Iniciamos el bus 1-Wire
    sensors.begin(); 
    
    // Buscamos los sensores conectados
//  Serial.println("Buscando dispositivos...");
 // Serial.println("Encontrados: ");
 // Serial.print(sensorDS18B20.getDeviceCount());
 // Serial.println(" sensores");
}
 
void loop() {
  
sensors.requestTemperatures();   //envía el comando para obtener las temperaturas
float temp1= sensors.getTempC(address1);//Se obtiene la temperatura en °C del sensor 1
float temp2= sensors.getTempC(address2);//Se obtiene la temperatura en °C del sensor 2
float temp3= sensors.getTempC(address3);//Se obtiene la temperatura en °C del sensor 3
float temp4= sensors.getTempC(address4);//Se obtiene la temperatura en °C del sensor 4    
    
    // Leemos y mostramos los datos de los sensores DS18B20
    Serial.print("Temperatura S1: ");
    Serial.print(temp1);
    Serial.println(" C");
    
    Serial.print("t11.txt=");
    Serial.print("\"");
    Serial.print(temp1);
    Serial.print("\"");
    Serial.write(0xff);
    Serial.write(0xff);
    Serial.write(0xff);
    
    Serial.print("Temperatura S2: ");
    Serial.print(temp2);
    Serial.println(" C");

    Serial.print("t12.txt=");
    Serial.print("\"");
    Serial.print(temp2);
    Serial.print("\"");
    Serial.write(0xff);
    Serial.write(0xff);
    Serial.write(0xff);
    
    Serial.print("Temperatura S3: ");
    Serial.print(temp3);
    Serial.println(" C");

     Serial.print("t13.txt=");
    Serial.print("\"");
    Serial.print(temp3);
    Serial.print("\"");
    Serial.write(0xff);
    Serial.write(0xff);
    Serial.write(0xff);
    
    Serial.print("Temperatura S4: ");
    Serial.print(temp4);
    Serial.println(" C");

    Serial.print("t14.txt=");
    Serial.print("\"");
    Serial.print(temp4);
    Serial.print("\"");
    Serial.write(0xff);
    Serial.write(0xff);
    Serial.write(0xff);

    
    delay(1000); 

[Surbyte]

Moderador:
Por favor, lee las Normas del foro y edita tu código/error usando etiquetas de código.
Ve a edición, luego selecciona todo el código que has publicado, lo cortas y click en (<CODE/>)

Te respondo pero por favor, no sigas respondiendo sin antes editar lo que te he indicado.

Varias preguntas:
Primera : has probado las 4 sondas sin mostrarlas en la pantalla Nextion no?
Segunda: Has generado algun código que presenta datos en la pantalla nextion, aunque sea al azar?
Si resuelves 1 y 2, tienes lo que quieres.

Veo que hay varios Serial.print con las temp1 a 4. Esos valores se imprimen correctamente?

[diegoing]

Surbyte buenos días, y gracias por decirme como colocar el Código de forma correcta. Creo que ya lo modifiqué y lo entendí.

A lo que me indicas primero de si leo las sondas, te comento que sí a través del monitor serie. Adjunto un pantallazo de lo que se lee.

En relación a la segunda pregunta en su día use un cogido creado con VISUINO con la pantalla nexion que me leía las sondas y tenia botones de prueba, pero no me leía las temperaturas en negativo por lo que quise crear un código nuevo para arreglar este problema. Además el código de visuino no lo entiendo nada porque es mas complicado y además ya no tengo licencia gratis de Visuino para trabajar con él. También perdí la programación de la Nextion para este codigo. Adjunto dicho código creado con Visuino:

#include <OpenWire.h>
#include <Mitov.h>
#include <Mitov_FormattedSerial.h>
#include <Mitov_Display_Nextion.h>
#include <DallasTemperature.h>  // The MAX31850 DallasTemp library https://github.com/adafruit/MAX31850_DallasTemp needs to be installed trough the Arduino IDE for this Scetch to compile!
#include <Mitov_Maxim_OneWire_Thermometer.h>
#include <Mitov_Timing.h>
#include <Mitov_Math.h>
#include <Mitov_BinaryGenerators.h>


// Arduino Board Declarations

namespace BoardDeclarations
{
Mitov::TypedSerialPort<Mitov::SerialPort<SERIAL_TYPE, Serial>, SERIAL_TYPE, Serial> SerialPort0;
Mitov::ArduinoDigitalInputChannel<3, false> ArduinoDigitalChannel_3( false );
} // BoardDeclarations

// Declarations



namespace Declarations
{
Mitov::DisplayNextion<Mitov::TypedSerialPort<Mitov::SerialPort<SERIAL_TYPE, Serial>, SERIAL_TYPE, Serial>, BoardDeclarations::SerialPort0> DisplayNextion1;
Mitov::DisplayNextionElementText TArduinoDisplayNextionElementText1( Declarations::DisplayNextion1, "t0", -1, 0 );
Mitov::DisplayNextionElementText TArduinoDisplayNextionElementText2( Declarations::DisplayNextion1, "t1", -1, 1 );
Mitov::DisplayNextionElementText TArduinoDisplayNextionElementText3( Declarations::DisplayNextion1, "t2", -1, 2 );
Mitov::DisplayNextionElementText TArduinoDisplayNextionElementText4( Declarations::DisplayNextion1, "t3", -1, 3 );
Mitov::DisplayNextionElementAnalogProgressBar TArduinoDisplayNextionElementAnalogProgressBar1( Declarations::DisplayNextion1, "j0", -1, 4 );
Mitov::DisplayNextionElementText TArduinoDisplayNextionElementText5( Declarations::DisplayNextion1, "t12", -1, 12 );
Mitov::DisplayNextionElementButton TArduinoDisplayNextionElementButton1( Declarations::DisplayNextion1, "b0", -1, -1 );
Mitov::DisplayNextionElementText TArduinoDisplayNextionElementText6( Declarations::DisplayNextion1, "t13", -1, 13 );
Mitov::OneWireThermometer Thermometer1( 2, 0, 0x28, 0xFF, 0x20, 0xCE, 0xA4, 0x16, 0x05, 0x8D );
Mitov::OneWireThermometer Thermometer2( -1, 1, 0x28, 0xFF, 0x74, 0xDA, 0xA2, 0x16, 0x04, 0xBE );
Mitov::OneWireThermometer Thermometer3( -1, 2, 0x28, 0xFF, 0xD6, 0xBD, 0xA4, 0x16, 0x04, 0xC9 );
Mitov::OneWireThermometer Thermometer4( -1, 3, 0x28, 0xFF, 0x03, 0xDC, 0xA2, 0x16, 0x04, 0x8B );
Mitov::ClockGenerator ClockGenerator1;
Mitov::CompareValue<String> CompareValue1 = Mitov::CompareValue<String>( String() );
Mitov::PulseGeneratorSimple PulseGenerator2;
} // Declarations

// Type Converters

namespace TypeConverters
{
Mitov::TypedConvert<float,String> Converter0;
Mitov::TypedConvert<float,String> Converter1;
Mitov::TypedConvert<float,String> Converter2;
Mitov::TypedConvert<float,String> Converter3;
Mitov::Convert_DigitalToText Converter4;
Mitov::Convert_DigitalToText Converter5;
} // TypeConverters

// Pin Call Declarations

namespace PinCalls
{
void PinCallerReceive1( void *_Data );
void PinCallerReceive2( void *_Data );
void PinCallerReceive3( void *_Data );
void PinCallerReceive4( void *_Data );
void PinCallerReceive5( void *_Data );
void PinCallerReceive6( void *_Data );
void PinCallerReceive7( void *_Data );
void PinCallerReceive8( void *_Data );
void PinCallerReceive9( void *_Data );
void PinCallerReceive10( void *_Data );
void PinCallerReceive11( void *_Data );
void PinCallerReceive12( void *_Data );
void PinCallerReceive13( void *_Data );
void PinCallerReceive14( void *_Data );
void PinCallerReceive15( void *_Data );
} // PinCalls

// Pin Call Implementations

namespace PinCalls
{
void PinCallerReceive1( void *_Data )
{
  Declarations::TArduinoDisplayNextionElementAnalogProgressBar1.InputPin_o_Receive( _Data );
  TypeConverters::Converter0.Convert( _Data, PinCallerReceive2 );
}

void PinCallerReceive2( void *_Data )
{
  Declarations::TArduinoDisplayNextionElementText1.InputPin_o_Receive( _Data );
  Declarations::CompareValue1.InputPin_o_Receive( _Data );
}
void PinCallerReceive3( void *_Data )
{
  Declarations::Thermometer1.OneWireInputPin_o_Receive( _Data );
}

void PinCallerReceive5( void *_Data )
{
  TypeConverters::Converter1.Convert( _Data, PinCallerReceive4 );
}

void PinCallerReceive4( void *_Data )
{
  Declarations::TArduinoDisplayNextionElementText2.InputPin_o_Receive( _Data );
}
void PinCallerReceive6( void *_Data )
{
  Declarations::Thermometer2.OneWireInputPin_o_Receive( _Data );
}

void PinCallerReceive8( void *_Data )
{
  TypeConverters::Converter2.Convert( _Data, PinCallerReceive7 );
}

void PinCallerReceive7( void *_Data )
{
  Declarations::TArduinoDisplayNextionElementText3.InputPin_o_Receive( _Data );
}
void PinCallerReceive9( void *_Data )
{
  Declarations::Thermometer3.OneWireInputPin_o_Receive( _Data );
}

void PinCallerReceive11( void *_Data )
{
  TypeConverters::Converter3.Convert( _Data, PinCallerReceive10 );
}

void PinCallerReceive10( void *_Data )
{
  Declarations::TArduinoDisplayNextionElementText4.InputPin_o_Receive( _Data );
}
void PinCallerReceive12( void *_Data )
{
  Declarations::Thermometer1.ClockInputPin_o_Receive( _Data );
}

void PinCallerReceive14( void *_Data )
{
  TypeConverters::Converter4.Convert( _Data, PinCallerReceive13 );
  TypeConverters::Converter5.Convert( _Data, PinCallerReceive15 );
  BoardDeclarations::ArduinoDigitalChannel_3.DigitalInputPin_o_Receive( _Data );
}

void PinCallerReceive13( void *_Data )
{
  Declarations::TArduinoDisplayNextionElementText5.InputPin_o_Receive( _Data );
}
void PinCallerReceive15( void *_Data )
{
  Declarations::TArduinoDisplayNextionElementText6.InputPin_o_Receive( _Data );
}
} // PinCalls

namespace ComponentsHardware
{
void SystemUpdateHardware()
{
}
} // ComponentsHardware


//The setup function is called once at startup of the sketch
void setup()
{
   
  Declarations::Thermometer1.AlarmHighTemperature = 90;
  Declarations::Thermometer1.OutputPin.SetCallback( PinCalls::PinCallerReceive1 );
  Declarations::Thermometer2.OneWireOutputPin.SetCallback( PinCalls::PinCallerReceive3 );
  Declarations::Thermometer2.OutputPin.SetCallback( PinCalls::PinCallerReceive5 );
  Declarations::Thermometer3.OneWireOutputPin.SetCallback( PinCalls::PinCallerReceive6 );
  Declarations::Thermometer3.OutputPin.SetCallback( PinCalls::PinCallerReceive8 );
  Declarations::Thermometer4.OneWireOutputPin.SetCallback( PinCalls::PinCallerReceive9 );
  Declarations::Thermometer4.OutputPin.SetCallback( PinCalls::PinCallerReceive11 );
  Declarations::ClockGenerator1.Frequency = 10;
  Declarations::ClockGenerator1.OutputPin.SetCallback( PinCalls::PinCallerReceive12 );
  Declarations::CompareValue1.OutputPin.SetCallback( PinCalls::PinCallerReceive14 );
  Declarations::CompareValue1.Value = "30";
  Declarations::CompareValue1.CompareType = Mitov::ctBigger;

  BoardDeclarations::SerialPort0.SystemInit();
  Declarations::DisplayNextion1.SystemInit();
  Declarations::Thermometer1.SystemInit();
  Declarations::Thermometer2.SystemInit();
  Declarations::Thermometer3.SystemInit();
  Declarations::Thermometer4.SystemInit();
  Declarations::ClockGenerator1.SystemInit();
  Declarations::PulseGenerator2.SystemInit();

  Declarations::Thermometer1.SystemStart();
  Declarations::Thermometer2.SystemStart();
  Declarations::Thermometer3.SystemStart();
  Declarations::Thermometer4.SystemStart();
  Declarations::ClockGenerator1.SystemStart();
  Declarations::CompareValue1.SystemStart();
  Declarations::PulseGenerator2.SystemStart();
}

// The loop function is called in an endless loop
void loop()
{
  unsigned long A_Current_Microseconds = micros();

  BoardDeclarations::SerialPort0.SystemLoopBegin( A_Current_Microseconds );
  Declarations::DisplayNextion1.SystemLoopBegin( A_Current_Microseconds );
  Declarations::Thermometer1.SystemLoopBegin( A_Current_Microseconds );
  Declarations::Thermometer2.SystemLoopBegin( A_Current_Microseconds );
  Declarations::Thermometer3.SystemLoopBegin( A_Current_Microseconds );
  Declarations::Thermometer4.SystemLoopBegin( A_Current_Microseconds );
  Declarations::ClockGenerator1.SystemLoopBegin( A_Current_Microseconds );
  Declarations::PulseGenerator2.SystemLoopBegin( A_Current_Microseconds );
}

[Surbyte]

Hay forma de simular algo con Nextion? Los que no la tenemos no podemos guiarte sin hacerlo.