Comment imprimer plusieurs variables dans une chaîne?

Supposons que je souhaite imprimer certaines variables sur le terminal. Quel est le moyen le plus simple de les imprimer dans une chaîne?

Actuellement, je fais quelque chose comme ça:

Serial.print("Var 1:");Serial.println(var1);
Serial.print(" Var 2:");Serial.println(var2);
Serial.print(" Var 3:");Serial.println(var3);

Y a-t-il une meilleure manière de faire cela?

ardprintfest une fonction que j'ai piratée ensemble et qui simule printfune connexion série. Cette fonction (indiquée en bas) peut être collée au début des fichiers où elle est nécessaire. Cela ne devrait pas créer de conflits.

Il peut être appelé similaire à printf. Voyez-le en action dans cet exemple:

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  int l=2;
  char *j = "test";
  long k = 123456789;
  char s = 'g';
  float f = 2.3;

  ardprintf("test %d %l %c %s %f", l, k, s, j, f);

  delay(5000);

}

Le résultat attendu est:

test 2 123456789 g test 2.30

Le prototype de fonction est:

int ardprintf(char *, ...);

Il retourne le nombre d'arguments détectés dans l'appel de fonction.

C'est la définition de la fonction:

#ifndef ARDPRINTF
#define ARDPRINTF
#define ARDBUFFER 16
#include <stdarg.h>
#include <Arduino.h>

int ardprintf(char *str, ...)
{
  int i, count=0, j=0, flag=0;
  char temp[ARDBUFFER+1];
  for(i=0; str[i]!='\0';i++)  if(str[i]=='%')  count++;

  va_list argv;
  va_start(argv, count);
  for(i=0,j=0; str[i]!='\0';i++)
  {
    if(str[i]=='%')
    {
      temp[j] = '\0';
      Serial.print(temp);
      j=0;
      temp[0] = '\0';

      switch(str[++i])
      {
        case 'd': Serial.print(va_arg(argv, int));
                  break;
        case 'l': Serial.print(va_arg(argv, long));
                  break;
        case 'f': Serial.print(va_arg(argv, double));
                  break;
        case 'c': Serial.print((char)va_arg(argv, int));
                  break;
        case 's': Serial.print(va_arg(argv, char *));
                  break;
        default:  ;
      };
    }
    else 
    {
      temp[j] = str[i];
      j = (j+1)%ARDBUFFER;
      if(j==0) 
      {
        temp[ARDBUFFER] = '\0';
        Serial.print(temp);
        temp[0]='\0';
      }
    }
  };
  Serial.println();
  return count + 1;
}
#undef ARDBUFFER
#endif

** Pour imprimer le %caractère, utilisez %%. *

Maintenant, disponible sur Gistsub Gists .

Normalement, je ne mettrais pas deux réponses à une question, mais je viens juste de trouver ceci aujourd'hui, où vous pouvez utiliser printf sans aucun tampon.

// Function that printf and related will use to print
int serial_putchar(char c, FILE* f) {
    if (c == '\n') serial_putchar('\r', f);
    return Serial.write(c) == 1? 0 : 1;
}

FILE serial_stdout;

void setup(){
    Serial.begin(9600);

    // Set up stdout
    fdev_setup_stream(&serial_stdout, serial_putchar, NULL, _FDEV_SETUP_WRITE);
    stdout = &serial_stdout;

    printf("My favorite number is %6d!\n", 12);
}

void loop() {
  static long counter = 0;
  if (millis()%300==0){
    printf("millis(): %ld\tcounter: %ld (%02X)\n", millis(), counter, counter++);
    delay(1);    
  }
}

Cela a toujours la limitation en virgule flottante.

edit: Je pensais faire un peu de test à ce sujet, et cela fonctionne assez bien. J'ai ajouté un meilleur test à la boucle avec une sortie formatée.

Ce n'est probablement pas mieux, mais différent. Vous pouvez utiliser l' objet String pour la sortie. Ces objets permettent la concaténation et prennent en charge la conversion automatique.

Serial.begin(9600);
String label = "Var";
const byte nValues = 3;
int var[nValues] = {36, 72, 49};

for (int i = 0; i < nValues; i++) {
    String stuff = label + i + ": ";
    Serial.println(stuff + var[i]);
}

J'utilisais généralement des onglets pour améliorer l'alignement dans la publication en série. Avoir les choses alignées comme si je permettais à l’arduino de se déclencher le plus rapidement possible tout en pouvant remarquer certains changements dans les variables.

Essayez quelque chose comme ça:

Serial.println("Var 1:\tVar 2tVar 3:");
Serial.print("\t");
Serial.print(var1);
Serial.print("\t");
Serial.print(var2);
Serial.print("\t");
Serial.print(var3);
Serial.println();

Ou quelque chose comme ça:

Serial.print("Var 1:");Serial.println(var1);
Serial.print("\tVar 2:");Serial.println(var2);
Serial.print("\tVar 3:");Serial.println(var3);

Je ne l'utilise que pour le débogage mais:

int a = 10;
int b = 20;
Serial.println("a = " + String(a) + " and b = " + String(b));

Je suis novice dans le monde Arduino, mais j'ai récemment découvert qu'il ne s'agissait que d'un C ++ standard (sans exceptions et probablement polymorphisme). Mais vous pouvez toujours profiter des modèles. Ma solution consiste donc à utiliser les modèles suivants:

void myprint(void)
{
  Serial.println("");
}

template<typename ...Args>
void myprint(const uint64_t & val, Args && ...args)
{
  serialPrintUint64(val);
  myprint(args...);
}

template<typename T, typename ...Args>
void myprint(const T & t, Args && ...args)
{
  Serial.print(t);
  myprint(args...);
}

....

// somewhere in your code
myprint("type: ", results.decode_type, 
        "\t value: ", results.value, 
        "\t addr: ", results.address,
        "\t cmd: ", results.command);

La bonne chose ici est qu'il n'utilise pas de mémoire supplémentaire et de traitement supplémentaire ici.

Je colle habituellement (douloureusement) à plusieurs lignes, Serial.printmais quand cela devient compliqué, je retourne à sprintf. C'est embêtant dans la mesure où vous devez avoir un tampon disponible pour cela.

L'utilisation est aussi simple (??) que:

char buffer[35]; // you have to be aware of how long your data can be
                 // not forgetting unprintable and null term chars
sprintf(buffer,"var1:%i\tvar2:%i\tvar3:%i",var1,var2,var3);
Serial.println(buffer);

Un mot d'avertissement cependant, il (par défaut) ne supporte pas les types flottants.

Utilisation Streaming.h, à la place de

Serial.print("Var 1:");Serial.println(var1);
Serial.print(" Var 2:");Serial.println(var2);
Serial.print(" Var 3:");Serial.println(var3);

on peut écrire

Serial << "Var 1:" << var1) << " Var 2:" << var2 << " Var 3:" << var3 << endl;

La définition de <<in Streaming.htraduit en fait cela en une série d' Serial.print()appels ordinaires . C'est-à-dire qu'il <<s'agit d'un sucre syntaxique, mis en œuvre sans augmenter la taille du code.

Si vous n'avez pas Streaming.hinstallé, procurez-vous Streaming5.zipde arduiniana.org . Décompressez-le dans le répertoire de vos bibliothèques, par exemple, dans ~/sketchbook/libraries. Ajoutez la ligne #include <Streaming.h>dans les esquisses où vous utilisez en <<tant qu'opérateur de flux.

Les spécificateurs de conversion de base _HEX, _DEC, _OCT et _BIN sont fournis, ainsi qu'une fonction _FLOAT (avec le nombre de décimales) et endl. Par exemple, pour imprimer les valeurs de latitude et de longitude dans un formulaire du type "Vos coordonnées sont -23.123, 135.4567", on pourrait écrire:

Serial << "Your coordinates are " << _FLOAT(latitude,3) << ", " << _FLOAT(longitude,4) << endl;

Cela pourrait aussi être écrit comme

Serial << F("Your coordinates are ") << _FLOAT(latitude,3) << ", " << _FLOAT(longitude,4) << endl;

qui conserverait la chaîne la plus longue dans PROGMEM au lieu de la placer dans la RAM.

Remarque, Streaming.h ne construit aucune chaîne en tant que telle; il ne fait que transmettre le texte de ses <<arguments à un flux. Une classe PString chez arduiniana peut créer des chaînes à partir d'entrées de flux, si des chaînes au lieu d'une sortie en flux sont souhaitées ou nécessaires.

L'utilisation dépendra du type de données de vos variables.

Si elles le sont int, ce serait %dou %i si elles le seraient string, ce serait%s

Wrapper pour printf

Vous pouvez modifier la limite en fonction de vos besoins

#include <stdarg.h>
void p(char *fmt, ... ){
    char buf[128]; // resulting string limited to 128 chars
    va_list args;
    va_start (args, fmt );
    vsnprintf(buf, 128, fmt, args);
    va_end (args);
    Serial.print(buf); // Output result to Serial
}

Source: https://playground.arduino.cc/Main/Printf

Exemples d'utilisation:

p("Var 1:%s\nVar 2:%s\nVar 3:%s\n", var1, var2, var3); // strings
p("Var 1:%d\nVar 2:%d\nVar 3:%d\n", var1, var2, var3); // numbers

ESP8266

Son intégré dans la Serialclasse du cadre. Pas besoin de bibliothèque ou de fonction supplémentaire.

// strings
Serial.printf("Var 1:%s\nVar 2:%s\nVar 3:%s\n", var1, var2, var3);
// numbers
Serial.printf("Var 1:%d\nVar 2:%d\nVar 3:%d\n", var1, var2, var3);

Plus de détails sur les astuces de formatage sur la page de référence du format printf: http://www.cplusplus.com/reference/cstdio/printf/

\n est la séquence d'échappement du saut de ligne.

Les séquences d'échappement servent à représenter certains caractères spéciaux dans les littéraux de chaîne et les littéraux de caractères.

Source: http://fr.cppreference.com/w/cpp/language/escape

[EDIT] - Comme @Juraj l’a mentionné, il n’est pas disponible sur la plupart des modules AVR. J'ai donc ajouté la mention ESP8266 et un wrapper printf pour les modules AVR courants

Une solution possible est:

Serial.println((String)"Var 1:" + var1 + " Var 2:" + var2 + " Var 3:" + var3);

De http://playground.arduino.cc/Main/Printf j'ai observé que cela fonctionne très bien sur mon méga2560

C'est tout ce que cela a juste fonctionné, pas besoin de vsnprintf_P ou PROGMEM ...

#include "Arduino.h"
void local_printf(const char *format, ...)
{
static char line[80];
va_list args;
va_start(args, format);
int len = vsnprintf(line, sizeof(line), format, args);
va_end(args);
for (char *p = &line[0]; *p; p++) {
    if (*p == '\n') {
        Serial.write('\r');
    }
    Serial.write(*p);
}
if (len >= sizeof(line))
    Serial.write('$');
}

void setup()
{
Serial.begin(115200);
local_printf("%s:%d: %s\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
}

void loop()
{
static int count=0;
local_printf("%s:%d: %s %d\n", __FILE__, __LINE__, __PRETTY_FUNCTION__, count++);
delay(1*1000);
}

// src/main.c:24: void setup()
// src/main.c:30: void loop() 0
// src/main.c:30: void loop() 1

int Money_amount = 55;

Serial.print(String("New amount: $" + Money_amount));

Vous verrez sur le terminal:

New amount: $55