Arduino.ru

Коллеги, хочу по мере «нечем заняться» публиковать некую серию этюдов, для тех из вас, кто только осваивается с программированием. Если это кому-то нужно и интересно, отпишитесь, это будет для меня серьёзным стимулом продолжать такую практику.

Ловите первый этюд.

Часто в кодах, публикуемых на данном форуме, используются структуры для хранения каких-то наборов значений. Для примера в данном этюде я буду рассматривать некую структуру значений датчиков, хотя, всё, что будет сказано, никак к ней не привязано и может применяться с любыми другими структурами.

Итак, наша модельная структура:

struct SSensorValue {
	unsigned long timeStamp;  //	Время съёма показаний (мс от запуска МК)
	float temperture;         //	температура в градусах С
	float humidity;           //	влажность в %
	float pressure;           //	давление в мм.рт.ст.
};

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

Теперь, допустим, в процессе работы нам надо иногда печатать значение этой структуры (всех полей) в тот же Serial (например, для отладки или ещё для чего). Пробуем:

struct SSensorValue {
	unsigned long timeStamp;  //	Время съёма показаний (мс от запуска МК)
	float temperture;         //	температура в градусах С
	float humidity;           //	влажность в %
	float pressure;           //	давление в мм.рт.ст.
};

void setup() {
	Serial.begin(115200);
	Serial.println("Fun begins!");
	//
	//	Объявляем структуру и заполняем какими-то значениями
	//
	SSensorValue sv;
	sv.timeStamp = millis();
	sv.temperture = 36.6;
	sv.humidity = 93.2;
	sv.pressure = 755;
	//
	//	Печатаем структуру
	//
	Serial.print(sv);
}

void loop() {}

Какая боль! Компилятор сказал, что понятия не имеет как именно мы собираемся печатать значение переменной типа SSensorValue :(

В общем-то, это понятно, откуда системе знать что у нас там за структура и как именно мы собираемся её печатать?

Вопрос, что делать?

Как всегда, есть 100500 путей!

Путь первый: вместо Serial.print(sv); расписать поэлементную печать. Что-то вроде такого:

struct SSensorValue {
	unsigned long timeStamp;  //	Время съёма показаний (мс от запуска МК)
	float temperture;         //	температура в градусах С
	float humidity;           //	влажность в %
	float pressure;           //	давление в мм.рт.ст.
};

void setup() {
	Serial.begin(115200);
	Serial.println("Fun begins!");
	//
	//	Объявляем структуру и заполняем какими-то значениями
	//
	SSensorValue sv;
	sv.timeStamp = millis();
	sv.temperture = 36.6;
	sv.humidity = 93.2;
	sv.pressure = 755;
	//
	//	Печатаем структуру
	//
	Serial.print("SENSOR VALUE: Time:");
	Serial.print(sv.timeStamp);
	Serial.print("ms; T:");
	Serial.print(sv.temperture);
	Serial.print("C; H:");
	Serial.print(sv.humidity);
	Serial.print("%; P:");
	Serial.print(sv.pressure);
	Serial.println("mm");
}

void loop() {}

Но такой путь хорош, если печатать нам надо только в одном месте программы. А если в нескольких? Везде расписывать эту кучу строк? А, главное, если приспичит что-то в печати поменять, не забывать менять везде? Нет, это большая головная боль.

Можно пойти другим путём - написать функцию печати и вызывать её вместо Serial.print(sv); Примерно так:

struct SSensorValue {
	unsigned long timeStamp;  //	Время съёма показаний (мс от запуска МК)
	float temperture;         //	температура в градусах С
	float humidity;           //	влажность в %
	float pressure;           //	давление в мм.рт.ст.
};

void printSensorValue(const void * vv) {
	const SSensorValue * sv = (const SSensorValue *) vv;
	Serial.print("SENSOR VALUE: Time:");
	Serial.print(sv->timeStamp);
	Serial.print("ms; T:");
	Serial.print(sv->temperture);
	Serial.print("C; H:");
	Serial.print(sv->humidity);
	Serial.print("%; P:");
	Serial.print(sv->pressure);
	Serial.println("mm");
}

void setup() {
	Serial.begin(115200);
	Serial.println("Fun begins!");
	//
	//	Объявляем структуру и заполняем какими-то значениями
	//
	SSensorValue sv;
	sv.timeStamp = millis();
	sv.temperture = 36.6;
	sv.humidity = 93.2;
	sv.pressure = 755;
	//
	//	Печатаем структуру
	//
	printSensorValue(&sv);
}

void loop() {}

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

Такой подход был бы хорош в языке С, но для С++ он инороден. Недостаток этого подхода в том, что он несколько выбивается из идеологии объектно-ориентированного программирования, которая предполагает, что всё, что связано с обработкой данных некоторого класса (а структура - это класс), должно быть собрано (правильный термин "инкапсулировано") внутри класса, а не во внешних функциях. Класс должен быть самодостаточен.

Давайте попробуем сделать печать - собственным методом нашей структуры, чтобы она сама знала как ей печататься, а вместо вызова глобальной функции печати, будем вызывать метод переменной sv. Вот смотрите:

struct SSensorValue {
	unsigned long timeStamp;  //	Время съёма показаний (мс от запуска МК)
	float temperture;         //	температура в градусах С
	float humidity;           //	влажность в %
	float pressure;           //	давление в мм.рт.ст.

	void printIt() {
		Serial.print("SENSOR VALUE: Time:");
		Serial.print(timeStamp);
		Serial.print("ms; T:");
		Serial.print(temperture);
		Serial.print("C; H:");
		Serial.print(humidity);
		Serial.print("%; P:");
		Serial.print(pressure);
		Serial.println("mm");
	}
};

void setup() {
	Serial.begin(115200);
	Serial.println("Fun begins!");
	//
	//	Объявляем структуру и заполняем какими-то значениями
	//
	SSensorValue sv;
	sv.timeStamp = millis();
	sv.temperture = 36.6;
	sv.humidity = 93.2;
	sv.pressure = 755;
	//
	//	Печатаем структуру
	//
	sv.printIt();	// sv сама знает как её печататься!
}

void loop() {}

Пока понятно?

Это уже почти хорошо, но и здесь не всё слава Богу!

Во-первых, в нашем методе печати намертво забит Serial, а это не единственный в природе выводной поток и что нам делать, если захочется вывести куда-то ещё? Кроме того, всё же было бы гораздо лучше, если бы обучили сам Serial понимать наш метод печати и вернулись бы к нашей первоначальной идее писать просто Serial.print(sv), но чтобы при этом каким-то образом вызывался наш метод. Это было бы лучше и с точки зрения единообразности кода и с точки зрения других способов использования Serial (например, с операторами потокового ввода/вывода – я покажу как это делается в следующем этюде, если хоть кто-то заинтересуется этим).

Итак, мы всё же хотим писать просто и естественно: Serial.print(sv)

Обычно, в грамотно, профессионально сделанных системах печати, существует интерфейс Printable (печатабельно). Суть этого интерфейса в том, что ели некоторый класс объявлен Printable, он (класс) обязан содержать в себе метод печати собственных объектов. Причём метод строго стандартизованный. Тогда методы системы печати, могут просто вызывать этот метод печати класса и позволять ему распечатать себя, как он считает нужным.

К счастью, система печати в Arduino IDE сделана достаточно грамотно и такой интерфейс в ней содержится. Выглядит он вот так:

class Printable {
public:
	virtual size_t printTo(Print& p) const = 0;
};

То есть, для того чтобы наша структура была Printable (печатабельной), она обязана содержать метод с именем printTo и параметром "ссылка на Print" (кстати, наш любимый Serial - объект типа Print). Если наша структура будет содержать такой метод, то система печати просто будет сама вызывать его, когда ей нужно отпечатать нашу структуру!

Давайте это напишем:

struct SSensorValue : public Printable {
	unsigned long timeStamp;  //	Время съёма показаний (мс от запуска МК)
	float temperture;         //	температура в градусах С
	float humidity;           //	влажность в %
	float pressure;           //	давление в мм.рт.ст.

	size_t printTo(Print& p) const { // в качестве p нам передадут, например, Serial
		size_t res = p.print("SENSOR VALUE: Time:");
		res += p.print(timeStamp);
		res += p.print("ms; T:");
		res += p.print(temperture);
		res += p.print("C; H:");
		res += p.print(humidity);
		res += p.print("%; P:");
		res += p.print(pressure);
		return res + p.println("mm");
	}
};

void setup() {
	Serial.begin(115200);
	Serial.println("Fun begins!");
	//
	//	Объявляем структуру и заполняем какими-то значениями
	//
	SSensorValue sv;
	sv.timeStamp = millis();
	sv.temperture = 36.6;
	sv.humidity = 93.2;
	sv.pressure = 755;
	//
	//	Печатаем структуру
	//
	Serial.print(sv);
}

void loop() {}

Вот так! Обратите внимание: в строке 1 мы указали, что наша структура поддерживает интерфейс Printable, а в строках 7-17 мы реализовали необходимый для этого интерфейса метод printTo. Теперь, мы можем просто писать Serial.print(sv) (строка 34) и система поймёт, чтов этот момент надо просто вызвать наш метод, а он всё. что нужно, напечатает. Причём напечатает не тупо в Serial, а именно в тот поток, для которого он был вызван.

Если Вы запустите этот скетч, то он спокойно скомпилируется и в сериале Вы увидите:

Fun begins!
SENSOR VALUE: Time:0ms; T:36.60C; H:93.20%; P:755.00mm

Вот , примерно так делаются "печатабельные" структуры и классы. Такой подход естественнен для С++. Следствием такой естественности будет, например, то, что это безо всяких исземений будет работать с любыми потоками, но потоки - тема следующего этюда.