Impresión de varias variables en una sola!!

Que tal chicos !!

recurro nuevamente a los mejores.

El código que comento más abajo es sólo a modo de ejemplo de lo que pretendo realizar.
He usado un código de un reloj 1302 en donde busco crear una sola variable a partir de varias otras…

En el sketch se puede apreciar como va realizando una impresión de las horas, minutos y segundos por separado…
La pregunta en concreto es como poder realizar una variable que involucre la impresión de “horas:minutos:segundos”.

#include <DS1302.h>

// Inicializacion del modulo.
DS1302 rtc(2, 3, 5);
Time t;

void setup() {
// Inicializacion del puerto serie.
Serial.begin(9600);
}

void loop() {
  // Obtencion de datos
  t = rtc.getTime();

  if (t.dow == 1) Serial.print("lun,");  // La variable t.dow (dia de la semana) tedra valor de 1 para dia lunes y 7 para domingo.
  if (t.dow == 2) Serial.print("mar,");
  if (t.dow == 3) Serial.print("mie,");
  if (t.dow == 4) Serial.print("jue,");
  if (t.dow == 5) Serial.print("vie,");
  if (t.dow == 6) Serial.print("sab,");
  if (t.dow == 7) Serial.print("dom,");


  Serial.print(t.date, DEC);  // Dia del mes
  Serial.print("/");
  Serial.print(t.mon);        // MES
  Serial.print("/");
  Serial.print(t.year, DEC);  // AÑO
 
  
  Serial.print("\t");

  
  Serial.print(t.hour, DEC);
  Serial.print(":");  // Minutos.
  Serial.print(t.min, DEC);
  Serial.print(":");  // Segundos.
  Serial.print(t.sec, DEC);

 Serial.println("\t");
  String data(t.hour,t.mon,t.min);
  Serial.println(data);
  delay(3000);
}

De antemano agradezco sus positivas respuestas !

Francuqo:
La pregunta en concreto es como poder realizar una variable que involucre la impresión de "horas:minutos:segundos".

No es una sola variable, sino en una sola línea:

Serial.println(t.hour + ":" + t.min + ":" + t.sec);

En una sola variable sería:

char hora[10];
sprintf(hora, "%d:%d:%d", t.hour, t.min, t.sec);
Serial.println(hora);

Lucario448:
No es una sola variable, sino en una sola línea:

Serial.println(t.hour + ":" + t.min + ":" + t.sec);

En una sola variable sería:

char hora[10];

sprintf(hora, "%d:%d:%d", t.hour, t.min, t.sec);
Serial.println(hora);

La variable en char me funcionó, la impresión en una sola línea no, me imprime puros garabatos. Agradecido de su respuesta. Sos un Crakkkk Lucario448

prueba asi

sprintf(hora, "%02d:%02d:%02d", t.hour, t.min, tsec);

Gracias por la corrección. A como lo escribí, te podría imprimir algo como:

2:5:8

Para referirse a las 2 de la mañana, 5 minutos y 8 segundos.

Con la corrección de surbyte, mostraría:

02:05:08

Gracias chicos por la pronta y acertadas respuestas ...

En relación a la solución anterior, tengo otra duda; que no parece ser tan difícil , pero mi falta de experiencia no me permite ver más allá de lo que mis ojos ven xD.

Bajo la solución de

char hora[10];
sprintf(hora, "%d:%d:%d", t.hour, t.min, t.sec);
Serial.println(hora);

He creado una variable similar para la fecha.

Necesito crear un archivo en la sd con el nombre de la fecha actual. Para crear dicho archivo, la librería SD.h ocupa la siguiente línea de código

 myFile = SD.open("datalog.txt", FILE_WRITE);//abrimos  el archivo

En efectos prácticos , esa línea me crea un archivo .txt en la memoria sd con el nombre de "datalog.txt" .... Necesitando que ese archivo se cree diariamente con la fecha actual.

Algo como esto ... "fechaActual.txt" ... el problema lo tengo en la extensión del archivo, puesto que yo podría poner una variable cualquiera en la linea de la SD, pero no hallo como lograr que esa variable que vaya en comillas "variable.txt" quede con la extensión .txt.

Intenté ser lo mas claro posible, espero no morir en el intento.

Saludos cordiales.

Alguien se toma el tiempo de buscar las cosas en este foro?
Todo lo que preguntas esta respondido no una sino muchas veces.
Busca almacenamiento en SD, tomate el mismo tiempo que a veces nos tomamos nosotros para responderte.

No lo tomes a mal pero se nota una vez mas que no has ENTENDIDO las normas del foro.
Ellas dices que debes buscar y consultar dudas, no pedir a cada momento por resolver cosas que ya estan resueltas.

Luego del regaño te respondo.
Del mismo modo que imprimes un array de caracteres formateado con ":" o "/" puedes crear un array de este tipo

char buffer[20]; 
sprintf(buffer, "datalog%02d%02d%02d.txt", t.day, t.month, t.year); // hoy sería dalog041016.txt
myFile = SD.open(buffer, FILE_WRITE);//abrimos  el archivo

La librería SD puede manejar nombres LFN?

"dalog041016.txt" no cabe en el formato 8.3, así que posiblemente el nombre final sea algo así como: "DALOG~1.TXT"

bueno... quita letras a datalog y con dat041016.txt solucionado

Bueno... :sweat_smile: no quería seguir insistiendo, pero... sigue siendo demasiado largo.

"dat041016" ocupa 9 caracteres, y el límite es 8.

Un nombre definitivo se me ocurre que sea "DL041016.txt", a duras penas cabe en el irritante formato 8.3
Lleva las iniciales "DL" de "DataLog", así que considero que es un nombre suficientemente significativo.

Gracias por sus respuestas.

Me di el tiempo de buscar en el foro, y no solo en él. Existe mucha información como señalan pero no tan concreta como la que han expuesto. Se habla de como usar la SD, las conexiones, la librería, y "Guardar el dato en tarjeta SD con fecha y hora" , "Como usar tarjetas SD con Arduino" , "Descargar por serial y guardar en SD" ... bla bla.

Efectivamente existen un par de de títulos abiertos que buscaban lo mismo que yo, curiosamente las respuestas no eran las mejores y no lo digo sólo yo, lo dicen en el mismo foro que no pudieron solucionar su problema.

De la manera que sea, estoy agradecido de su tiempo. Aunque me queda una sensación de que cada vez que alguien escriba tan solo la palabra SD, se armará un lío.

Gracias Lucario por tu intervención, puesto que muchas veces con esa simple explicación que la gente desconoce, evitas muchos dolores de cabeza.

Buen día a todos !

Francuqo:
Aunque me queda una sensación de que cada vez que alguien escriba tan solo la palabra SD, se armará un lío.

Por qué lo dices? La librería no es difícil de usar; está documentada en la página de Arduino.cc.

De lo que posiblemente hay discusión, es de la velocidad de lectura/escritura, leer y escribir a la misma vez, a veces con el nombre de archivo (como ahora). Pero en realidad... nada grande.

Efectivamente trabajo en eso ahora. Y es lo que más me complica en realidad. Ya que lo que busco es poder mostrar en un servidor web los datos que ya he guardado en la SD gracias a su guía y dirección.

El código de toma de lecturas es el siguiente:

#include <SD.h>
#include "max6675.h"  //declaramos que utilizaremos la Librería módulo Termocupla 
#include <DS1302.h>  //Librería Reloj

File myFile;
DS1302 rtc(19, 20, 21); // (RST,DAT,CLK)
Time t;
char hora[10];
char fecha[10];
char DL[20];


const int ledPin = 9;
int ledState = HIGH;
long previousMillis = 0; //Variable que se usara para saber la ultima vez que se ejecuto el if
//Estas dos variables son de tipo long porque los valores que recibe son en milisegundos
//se llenaría demasiado rápido si sólo usaramos un int



//long interval = 150000; //El intervalo que determina cada cuanto se entra al if (30000 = 1 minuto ;  15000=30 seg ;  7500 = 15 seg)

long interval = 2000;



int thermoDO_1 = 22;
int thermoCS_1 = 23;
int thermoCLK_1 = 24;

int thermoDO_2 = 25;
int thermoCS_2 = 26;
int thermoCLK_2 = 27;

int thermoDO_3 = 28;
int thermoCS_3 = 29;
int thermoCLK_3 = 30;

int thermoDO_4 = 31;
int thermoCS_4 = 32;
int thermoCLK_4 = 33;

int thermoDO_5 = 34;
int thermoCS_5 = 35;
int thermoCLK_5 = 36;

int thermoDO_6 = 37;
int thermoCS_6 = 38;
int thermoCLK_6 = 39;

int thermoDO_7 = 40;
int thermoCS_7 = 41;
int thermoCLK_7 = 42;

int thermoDO_8 = 43;
int thermoCS_8 = 44;
int thermoCLK_8 = 45;


MAX6675 thermocouple_1(thermoCLK_1, thermoCS_1, thermoDO_1);
MAX6675 thermocouple_2(thermoCLK_2, thermoCS_2, thermoDO_2);

MAX6675 thermocouple_3(thermoCLK_3, thermoCS_3, thermoDO_3);
MAX6675 thermocouple_4(thermoCLK_4, thermoCS_4, thermoDO_4);

MAX6675 thermocouple_5(thermoCLK_5, thermoCS_5, thermoDO_5);
MAX6675 thermocouple_6(thermoCLK_6, thermoCS_6, thermoDO_6);

MAX6675 thermocouple_7(thermoCLK_7, thermoCS_7, thermoDO_7);
MAX6675 thermocouple_8(thermoCLK_8, thermoCS_8, thermoDO_8);




const int chipSelect = 53;
void setup()
{
  pinMode(ledPin, OUTPUT);     //declaramos la variable ledPin como salida

  sprintf(DL, "DL-%d-%d.txt", t.mon, t.date);
  Serial.begin(9600);

  Ethernet.begin(mac, ip);    //inicializa la conexión Ethernet y el servidor
  server.begin();


  Serial.print("Iniciando SD ...");
  if (!SD.begin(53)) {
    Serial.println("No se pudo inicializar");
    return;
  }
  Serial.println("inicializacion exitosa");
}


/* ************************************** LOOP**************************************/

void loop()
{
  temporizador();



}


/* ****************************************** LOOP************************************* */






void GrabarSD()
{
  t = rtc.getTime();

  float T1 = thermocouple_1.readCelsius() - 2;
  float T2 = thermocouple_2.readCelsius() - 2;
  float T3 = thermocouple_3.readCelsius() - 2;
  float T4 = thermocouple_4.readCelsius() - 2;
  float T5 = thermocouple_5.readCelsius() - 2;
  float T6 = thermocouple_6.readCelsius() - 2;
  float T7 = thermocouple_7.readCelsius() - 2;
  float T8 = thermocouple_8.readCelsius() - 3;


  myFile = SD.open(DL, FILE_WRITE);//abrimos  el archivo

  if (myFile) {
    Serial.print(T1, 1);
    myFile.print(T1, 1);
    Serial.print("\t\t ");
    myFile.print("\t\t ");

    Serial.print(T2, 1);
    myFile.print(T2, 1);
    Serial.print("\t\t ");
    myFile.print("\t\t ");

    Serial.print(T3, 1);
    myFile.print(T3, 1);
    Serial.print("\t\t ");
    myFile.print("\t\t ");

    Serial.print(T4, 1);
    myFile.print(T4, 1);
    Serial.print("\t\t ");
    myFile.print("\t\t ");

    Serial.print(T5, 1);
    myFile.print(T5, 1);
    Serial.print("\t\t ");
    myFile.print("\t\t ");

    Serial.print(T6, 1);
    myFile.print(T6, 1);
    Serial.print("\t\t ");
    myFile.print("\t\t ");

    Serial.print(T7, 1);
    myFile.print(T7, 1);
    Serial.print("\t\t ");
    myFile.print("\t\t ");

    Serial.print(T8, 1);
    myFile.print(T8, 1);
    Serial.print("\t\t");
    myFile.print("\t\t");


    sprintf(hora, "%d:%d:%d", t.hour, t.min, t.sec);
    sprintf(fecha, "%d/%d/%d", t.date, t.mon, t.year);


    Serial.print(fecha);
    Serial.print("\t");
    myFile.print(fecha);
    myFile.print("\t");

    Serial.println(hora);
    myFile.println(hora);

    myFile.close(); //cerramos el archivo


  } else {
    Serial.println("Error al abrir el archivo");
    delay(100);
  }

}




void temporizador()
{

  //La función millis automáticamente comienza a contar milisegundos desde que arranca el codigo
  //Ese valor es asignado a la variable currentMillis

  //Hace una resta: si desde la ultima vez que se reviso millis ya paso mas de 1 segundo..
  //entonces la última vez que se excedio un segundo se actualiza y se cambia a
  // "La ultima vez que ocurrio esa condución es AHORA" y con eso se cambia el estado de la condición

  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis > interval) //Actualmente llevamos 950ms y la última vez fue a los 0ms, eso es mayor a 1000? No, entonces no pasa nada..
  {
    previousMillis = currentMillis; //"La ultima vez fue AHORA"

    if (ledState == LOW) {
      ledState = HIGH;

      GrabarSD();

    }
    else
      ledState = LOW;

    digitalWrite(ledPin, ledState);
  }
}

Con lo anterior, logro satisfactoriamente mostrar las lecturas por serial y guardarlas en la SD.
Pero quiero poder ir mostrando esa “base de datos” en el servidor web montado en arduino, ya que por mi ignorancia, no sé de que otra manera poder mostrar dichas lecturas.
He buscado info pero todo es muy técnico en relación a php, mySQL , y cosas que no entiendo, es por ello que veía la posibilidad de poder mostrar en un servidor web montado en arduino los archivos guardados en la SD, como se muestra en esta imagen:

expuesta al final de este “tutorial”

http://www.ladyada.net/learn/arduino/ethfiles.html

No sé si arduino podrá con tanto en realidad.

Bueno... parece que el código por sí solo puede hacer todo eso; pero lo que no entiendo es: qué es lo que no funciona? :confused:

El código funciona para almacenar los datos en la SD, pero no para mostrar dicho fichero txt como un link en el servidor web, en ello trabajo ahora :sob:

Como en la imagen presentada

Estás tratando de fusionar dos programas?

Bueno, primero que nada, recuerda que el código de ejemplo usa la librería SdFat, y no el típico SD (SdFat soporta LFN, así que ahora eres libre de ponerle el nombre que quieras a los archivos).

La parte del inicializado de la tarjeta supongo que no te crea conflicto.

Quizá para que el programa logre enviar los bytes de cierto archivo, de antemano el logger debe cerrar todos los archivos que tenía trabajando; qué se yo…

Si lo que buscas es fusionar dos programas, más tarde te ayudo con eso; porque en este momento no estoy en casa ni con una PC al alcance.

No sé si esa era la idea, pero creo haberlo conseguido (ver adjunto).

A mi no me compila porque no tengo la librería de la termocupla ni la del reloj.

PD: lo adjunto por el “bendito” límite de caracteres.

SDWebLogger.ino (9.95 KB)