Как вывести несколько переменных в строке?

Это, наверное, не лучше, просто по-другому. Вы можете использовать объект String для вывода. Эти объекты допускают объединение и поддерживают автоматическую типизацию.

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]);
}

Я обычно использовал вкладки, чтобы сделать все лучше в сериале. Когда вещи выстраиваются так, как я, это позволяет arduino работать как можно быстрее, при этом замечая определенные изменения в переменных.

Попробуйте что-нибудь вроде этого:

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();

Или что-то вроде этого:

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

Я обычно (болезненно) придерживаюсь нескольких строк серийной печати, но когда она становится запутанной, я возвращаюсь к sprintf. Это раздражает тем, что для этого у вас должен быть доступный буфер.

Использование так же просто (??), как:

char buffer[35]; // вы должны знать, как долго могут храниться ваши данные
                 // не забывайте, что символы непечатаемых и нулевых терминов
sprintf(buffer,"var1:%i\tvar2:%i\tvar3:%i",var1,var2,var3);
Serial.println(buffer);

Однако хочу предупредить, что он (по умолчанию) не поддерживает плавающие типы.

Я обычно не ставлю два ответа на вопрос, но я только сегодня нашел это, где вы можете использовать printf без буфера.

// Функция, которая printf и связанная с ней будет использоваться для печати
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);

    // Настройка stdout
    fdev_setup_stream(&serial_stdout, serial_putchar, NULL, _FDEV_SETUP_WRITE);
    stdout = &serial_stdout;

    printf(""Мое любимое число %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);    
  }
}

Это все еще имеет ограничение с плавающей точкой.

edit: Я подумал, что мог бы провести небольшое тестирование на этом, и это работает довольно хорошо. Я добавил лучший тест в цикл с форматированным выводом.

Используя Streaming.h, вместо

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

можно написать

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

Определение << в потоковой передаче.h фактически переводит это в серию обычных вызовов Serial.print (). То есть < < - это синтаксический сахар, реализованный без увеличения размера кода.

Если у вас не установлен Streaming.h, получите Streaming5.zip от arduiniana.org. Распакуйте его в каталог библиотек, например, в ~/sketchbook/библиотеки. Добавьте строку #включить <Потоковое.h><Потоковое.h> в скетчи, где вы используете << в качестве оператора потока.

Предусмотрены спецификаторы базового преобразования _HEX, _DEC, _OCT и _BIN, а также функция _FLOAT (с количеством знаков после запятой) и endl. Например, чтобы напечатать значения широты и долготы в форме типа "Ваши координаты -23.123, 135.4567”, можно написать:

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

Это также можно было бы записать как

Serial << F("Ваши координаты ") << _FLOAT(latitude,3) << ", " << _FLOAT(longitude,4) << endl;

что позволило бы сохранить более длинную строку в PROGMEM вместо того, чтобы переносить ее в оперативную память.

Обратите внимание, что Streaming.h не создает никаких строк как таковых; он просто доставляет текст своих <<-аргументов в поток. Класс PString в arduiniana может создавать строки из входных данных потока, если требуются или необходимы строки вместо выходных данных потока.

От http://playground.arduino.cc/Main/Printf Я заметил, что это отлично работает на mega2560

Вот и все, что просто сработало, не нужно vsnprintf_P или 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));

Вы увидите на терминале:

New amount: $55

Использование будет зависеть от типа данных ваших переменных.

Если они являются int, то это будет %d или %i Если они являются строковыми, то это будет %s

Оболочка для печати

Вы можете изменить лимит в зависимости от ваших требований

#include <stdarg.h>
void p(char *fmt, ... ){
    char buf[128]; // результирующая строка ограничена 128 символами
    va_list args;
    va_start (args, fmt );
    vsnprintf(buf, 128, fmt, args);
    va_end (args);
    Serial.print(buf); // Вывод результата в последовательный порт
}

Источник: https://playground.arduino.cc/Main/Printf

Примеры использования:

p("Var 1:%s\nVar 2:%s\nVar 3:%s\n", var1, var2, var3); // строки
p("Var 1:%d\nVar 2:%d\nVar 3:%d\n", var1, var2, var3); // числа

ESP8266

Он встроен в последовательный класс фреймворка. Нет необходимости в дополнительной библиотеке или функции.

// строки
Serial.printf("Var 1:%s\nVar 2:%s\nVar 3:%s\n", var1, var2, var3);
// числа
Serial.printf("Var 1:%d\nVar 2:%d\nVar 3:%d\n", var1, var2, var3);

Дополнительные сведения о советах по форматированию на справочной странице по формату printf : http://www.cplusplus.com/reference/cstdio/printf/

\n-это escape - последовательность для перевода строки.

Escape-последовательности используются для представления определенных специальных символов в строковых и символьных литералах.

Источник: http://en.cppreference.com/w/cpp/language/escape

[ПРАВИТЬ] - Как упоминал @Juraj, он недоступен в большинстве модулей AVR. Поэтому я добавил упоминание ESP8266 и обертку printf для обычных AVR-модулей

Я использую это только для отладки, но:

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

Я новичок в мире Arduino, но недавно обнаружил, что это обычный C++ (без исключений и, вероятно, полиморфизма). Но вы все еще можете наслаждаться шаблонами. Поэтому мое решение состоит в том, чтобы использовать следующие шаблоны:

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...);
}

....

// где-то в вашем коде
myprint("type: ", results.decode_type, 
        "\t value: ", results.value, 
        "\t addr: ", results.address,
        "\t cmd: ", results.command);

Хорошо, что здесь не используется дополнительная память и дополнительная обработка.

Одним из возможных решений является:

Serial.println((Строка)"Вар 1:" + переменная 1 + " Вар 2:" + переменная 2 + " Вар 3:" + переменная 3);

Приведенное выше решение от Iain увеличивает размер кода.

Я использую PrintEx уже много лет, и он отлично работает. См. Описание ссылки ввода здесь