Arduino.ru

Коллеги, сильно меня зацепила вот эта тема, а тут, вдруг случайно родилось интересное (для меня, по крайней мере) её развитие, коим и спешу с Вами поделиться.

Думаю, не одного меня достало нытьё про то, что digitalRead/digitaWrite/pinMode ну такие, просто, ужасно медленные. Ноют чаще всего те, для кого проблема медленности этих функций стоит примерно на 100501-ом месте в списке их бед, начинающемся с "памагити кампилятор ругаеццо", но ноют.

Известно, что если пины и их значения - константы, то можно использовать CyberLib. Но, во-первых, у неё непривычный синтаксис, а во-вторых, если вдруг в скетче на 100500 констант пришлось таки поработать с одной переменной, то придётся использовать и обычный digitalRead - т.е. мешать в одном коде два синтаксиса работы с портами. Решением может стать библиотека DigitalPins. Она использует привычный синтаксис и вполне работает в том же синтаксисе и с переменными (правда, при этом digitalWrite уже не компилируется в одну команду, чудес не бывает). Но, Вы видели её код? Та ещё помойка!

Но, до некоторых пор, я считал DigitalPins приличным решением, пригодным и для констант, и для переменных. Но, лишь до тех пор, пока не подумал, а почему бы собственно, не написать работу с пинами просто на С++, безо всяких препроцессоров, в лоб? Может, результаты будут не хуже?

Итак, вот простая (всего 38 строчек) непосредственная реализация digitalRead/digitalWrite/pinMode для UNO-подобных. Все три функции являются статическими методами класса PinOps и вызывать их надо с соответсвующим префиксом (например, PinOps::digitalRead(10); ).

#ifndef	PINOPS_H
#define	PINOPS_H

struct PinOps {

	static inline volatile uint8_t & getIn(const uint8_t pin) __attribute__((always_inline)) {
		return (pin < 8) ? PIND : (pin < 14) ? PINB : PINC; // может ошибку обработать?
	}

	static inline volatile uint8_t & getOut(const uint8_t pin) __attribute__((always_inline)) {
		return (pin < 8) ? PORTD : (pin < 14) ? PORTB : PORTC; // может ошибку обработать?
	}

	static inline volatile uint8_t & getDDR(const uint8_t pin) __attribute__((always_inline)) {
		return (pin < 8) ? DDRD : (pin < 14) ? DDRB : DDRC; // может ошибку обработать?
	}

	static inline uint8_t getBitMask(const uint8_t pin) __attribute__((always_inline)) {
		return  1 << ((pin < 8) ? pin : (pin < 14) ? (pin - 8) : (pin - 14)); // может ошибку обработать?
	}

	static inline void digitalWrite(const int8_t pin, const bool val) __attribute__((always_inline)) {
		if (val) getOut(pin) |= getBitMask(pin);
		else getOut(pin) &= ~getBitMask(pin);
	}

	static inline bool digitalRead(const int8_t pin) __attribute__((always_inline)) {
		return static_cast<bool>(getIn(pin) & getBitMask(pin));
	}

	static inline void pinMode(const int8_t pin, const bool val) __attribute__((always_inline)) {
		if (val) getDDR(pin) |= getBitMask(pin);
		else getDDR(pin) &= ~getBitMask(pin);
	}

};

#endif	//	PINOPS_H

Все эксперименты проводились на IDE 1.8.9 с опциями из коробки, плата – Uno. Для экспериментов были написаны четыре скетча на все возможные случаи. Скетчи такие:

1. Все параметры всех функций – константы;
2. Номера пинов – константы, а значения – переменные;
3. Номера пинов – переменные, а значения – константы;
4. Все параметры – переменные.

Каждый из скетчей позволяет запуститься в режиме оригинальных ардуиновских функций, в режиме использования DigitalPins и в режиме использования PinOps. Первый скетч (где все константы) ещё и в режиме прямой работы с портами (к переменным это неприменимо). Для конфигурации скетча (с какой библиотекой работать) нужно задать константу METHOD (строка №6) одним из значений из строк №№1-4.

Вот скетчи и результаты экспериментов:

Эксперимент №1. Все параметры всех функций –  константы.

#define	DIRECT_PORTS 1
#define	ORIGINAL_ARDUINO 2
#define	DIGITALPINS 3
#define	PINOPS 4

#define METHOD ORIGINAL_ARDUINO

//////////////////////////////////////
#if  METHOD == DIGITALPINS
#include <DigitalPins.h>
#endif

#if METHOD == PINOPS
#include <PinOps.h>
#endif

void setup() {
#if METHOD == PINOPS
	PinOps::pinMode(3, OUTPUT);
	const bool b = PinOps::digitalRead(3);
	PinOps::digitalWrite(3, HIGH);
#elif  METHOD == DIGITALPINS
	_pinMode(3, OUTPUT);
	const bool b = _digitalRead(3);
	_digitalWrite(3, HIGH);
#elif  METHOD == DIRECT_PORTS
	DDRD |= 8;
	const bool b = static_cast<bool>(PIND & 8);
	PORTD |= 8;
#elif  METHOD == ORIGINAL_ARDUINO
	pinMode(3, OUTPUT);
	const bool b = digitalRead(3);
	digitalWrite(3, HIGH);
#endif
	PORTB = b;	// просто, чтобы не вязалась, что b не используется.
}

void loop(void) {}

Ничего неожиданного. И DigitalPins, и PinOps показали результат прямой работы с портами, т.е. именно в неё и скомпилировались.

Эксперимент №2. Параметр пин – константа, а параметр значение – переменная.

#define	ORIGINAL_ARDUINO 2
#define	DIGITALPINS 3
#define	PINOPS 4


#define METHOD ORIGINAL_ARDUINO

//////////////////////////
#if  METHOD == DIGITALPINS
#include <DigitalPins.h>
#endif

#if METHOD == PINOPS
#include <PinOps.h>
#endif

void setup() {
	const int v = analogRead(0);
#if METHOD == PINOPS
	PinOps::pinMode(3, v);
	const bool b = PinOps::digitalRead(3);
	PinOps::digitalWrite(3, v);
#elif  METHOD == ORIGINAL_ARDUINO
	pinMode(3, v);
	const bool b = digitalRead(3);
	digitalWrite(3, v);
#elif  METHOD == DIGITALPINS
	_pinMode(3, v);
	const bool b = _digitalRead(3);
	_digitalWrite(3, v);
#endif
	PORTB = b;	// просто, чтобы не вязалась, что b не используется.
}

void loop(void) {}

А вот здесь PinOps вырывается немного вперёд, оптимизатор делает своё дело!

Эксперимент №3. Параметр пин – переменная, а значение – константа.

#define	ORIGINAL_ARDUINO 2
#define	DIGITALPINS 3
#define	PINOPS 4


#define METHOD PINOPS

//////////////////////////////
#if  METHOD == DIGITALPINS
#include <DigitalPins.h>
#endif

#if METHOD == PINOPS
#include <PinOps.h>
#endif

void setup() {
	const int p = analogRead(0);
#if METHOD == PINOPS
	PinOps::pinMode(p, OUTPUT);
	const bool b = PinOps::digitalRead(p);
	PinOps::digitalWrite(p, HIGH);
#elif  METHOD == ORIGINAL_ARDUINO
	pinMode(p, OUTPUT);
	const bool b = digitalRead(p);
	digitalWrite(p, HIGH);
#elif  METHOD == DIGITALPINS
	_pinMode(p, OUTPUT);
	const bool b = _digitalRead(p);
	_digitalWrite(p, HIGH);
#endif
	PORTB = b;	// просто, чтобы не вязалась, что b не используется.
}

void loop(void) {}

Опа! А при переменных номерах пинов DigitalPins проигрывает оригинальным ардуиновским функциям из Wiring! Круто! PinOps, по-прежнему, лидер.

Эксперимент №4. Все параметры всех функций - переменные.

#define	ORIGINAL_ARDUINO 2
#define	DIGITALPINS 3
#define	PINOPS 4


#define METHOD ORIGINAL_ARDUINO
//////////////////////////////

#if  METHOD == DIGITALPINS
#include <DigitalPins.h>
#endif

#if METHOD == PINOPS
#include <PinOps.h>
#endif

void setup() {
	const int v = analogRead(0);
	const int p = analogRead(0);
#if METHOD == PINOPS
	PinOps::pinMode(p, v);
	const bool b = PinOps::digitalRead(p);
	PinOps::digitalWrite(p, v);
#elif  METHOD == ORIGINAL_ARDUINO
	pinMode(p, v);
	const bool b = digitalRead(p);
	digitalWrite(p, v);
#elif  METHOD == DIGITALPINS
	_pinMode(p, v);
	const bool b = _digitalRead(p);
	_digitalWrite(p, v);
#endif
	PORTB = b;	// просто, чтобы не вязалась, что b не используется.
}

void loop(void) {}

Ну, тут уже совсем неприлично! DigitalPins проиграл Wiring более, чем в два раза! И эту библиотеку я считал хорошей!? А PinOps – опять лидер!

Вот, собственно и вся недолга. Никаких извращений, простое и понятное написание программы на С++ безо всяких извратов с препроцессором и даже без constexpr. Этот язык многое позволяет, просто «готовить нужно уметь»!