==================== GyverBus.h ====================
	Инициализация:
	GBUS<пин, тип> объект(адрес, размер буфера)
	- пин: номер пина
	- тип: GBUS_FULL - двухсторонняя связь (активен по умолчанию, можно не указывать)
	- тип: GBUS_TX - только отправка (экономит память)
	- тип: GBUS_RX - только приём (экономит память)
	
	Список методов:
	tick() - отправляет и принимает данные. Вызывать хотя бы каждую миллисекунду. Возвращает коды статусов, тип GBUSstatus (enum)
	getStatus() - возвращает коды статусов (такие же как tick()), тип GBUSstatus (enum)
	
	sendData(адрес, дата) - вводит данные на отправку по адресу получателя. Принимает любй тип данных (переменные, массивы, структуры). Отправка начнётся автоматически после "освобождения" линии
	gotData() - вернёт true, если новый пакет данных принят без ошибок. Сам сбрасывается в false
	readData(дата) - выводит данные из внутреннего буфера в указанную "переменную" (переменные, массивы, структуры)
	
	sendRequest(адрес) - отправить "запрос" по адресу получателя
	gotRequest() - вернёт true, если на наш адрес пришёл запрос. Сам сбрасывается в false. Адрес отправителя можно узнать в getTXaddress()	
	
	getTXaddress() - возвращает адрес отправителя с последнего успешного получения данных или запроса
	isBusy() - возвращает true, если линия занята. Возвращает false, если с момента последнего общения по линии прошло GBUS_BUSY_TIMEOUT миллисекунд
	
	sendAck(адрес) - отправляет ack (ответ на запрос) по адресу
	gotAck() - вернёт true, если на наш адрес пришёл ack (ответ на запрос). Сам сбрасывается в false. Адрес отправителя можно узнать в getTXaddress()	
	
	sendRequestAck(адрес, кол-во попыток, таймаут) - отправляет реквест на адрес. 
	Ждёт ответ (ack или data), если не дожидается в теч. таймаута - отправляет ещё раз.
	Если количество попыток превышено - возвращает ACK_ERROR (0 ноль).
	Если принят ack - возвращает ACK_ONLY (1 единица)
	Если принята дата - возвращает ACK_DATA (2 два)
	ФУНКЦИЯ БЛОКИРУЮЩАЯ
	Смотри примеры call_response_tx_ack и call_response_rx_ack
	
	sendRaw(байтовый массив, размер) - отправит сырые байты (без протокола) по шине. Смотри примеры в папке raw	
	gotRaw() - вернёт true, были приняты какие-то данные (приём завершён успешно). Сам сбрасывается в false.
	rawSize() - вернёт количество принятых байт (последний успешный приём). Иначе вернёт 0
	
	buffer - можно обращаться как к массиву. Встроенный буфер библиотеки	
	
	==================== GBUSmini.h ====================
	// Все функции (кроме GBUS_is_busy) блокируют выполнение кода на время приёма/отправки

// Возвращает true, если линия занята. Таймаут GBUS_BUSY_TIMEOUT мс
bool GBUS_is_busy(byte pin);

// Отправить сырые данные (пин, дата, размер)
// Формат посылки GBUS [суммарное количество байт, адрес получателя, адрес отправителя, ...байты даты..., CRC]
// Функция блокирующая на всё время отправки
// 640 байт (Arduino Nano), 150 байт ATtiny13 (microCore)
void GBUS_send_raw(byte pin, byte* data, byte size);

// Отправить данные с CRC (пин, адрес получателя, адрес отправителя, дата, размер)
// Функция блокирующая на всё время отправки
// 740 байт (Arduino Nano), 230 байт ATtiny13 (microCore)
void GBUS_send_crc(byte pin, byte to, byte from, byte* data, byte size);

// Отправить данные без CRC (пин, адрес получателя, адрес отправителя, дата, размер)
// Функция блокирующая на всё время отправки
// 700 байт (Arduino Nano), 200 байт ATtiny13 (microCore)
void GBUS_send_no_crc(byte pin, byte to, byte from, byte* data, byte size);

// Прочитать сырые данные (пин, дата, размер)
// Вызывать как можно чаще, чтобы не пропустить. Функция блокирующая на всё время приёма.
// Возвращает количество принятых байт при завершении приёма
// 520 байт (Arduino Nano), 220 байт ATtiny13 (microCore)
byte GBUS_read_raw(byte pin, byte* buf, byte size);

// Прочитать данные с CRC (пин, наш адрес, дата, размер)
// Вызывать как можно чаще, чтобы не пропустить. Функция блокирующая на всё время приёма
// Возвращает адрес отправителя при успешном завершении приёма. При ошибке возвращает 0
// 650 байт (Arduino Nano), 330 байт ATtiny13 (microCore)
byte GBUS_read_crc(byte pin, byte addr, byte* buf, byte size);

// Прочитать данные без CRC (пин, наш адрес, дата, размер)
// Вызывать как можно чаще, чтобы не пропустить. Функция блокирующая на всё время приёма
// Возвращает адрес отправителя при успешном завершении приёма. При ошибке возвращает 0
// 622 байт (Arduino Nano), 300 байт ATtiny13 (microCore)
byte GBUS_read_no_crc(byte pin, byte addr, byte* buf, byte size);

// Отправить запрос (пин, адрес получателя, адрес отправителя)
// Функция блокирующая на всё время отправки
// 640 байт (Arduino Nano), 150 байт ATtiny13 (microCore)
void GBUS_send_request(byte pin, byte to, byte from);

// Принять запрос (пин, наш адрес)
// Вызывать как можно чаще, чтобы не пропустить. Функция блокирующая на всё время приёма
// Возвращает адрес отправителя при успешном завершении приёма. При ошибке возвращает 0
// 540 байт (Arduino Nano), 220 байт ATtiny13 (microCore)
byte GBUS_read_request(byte pin, byte addr);

// Отправить подтверждение (пин, адрес получателя, адрес отправителя)
// Функция блокирующая на всё время отправки
void GBUS_send_ack(byte pin, byte to, byte from);

// Принять подтверждение (пин, наш адрес)
// Вызывать как можно чаще, чтобы не пропустить. Функция блокирующая на всё время приёма
// Возвращает адрес отправителя при успешном завершении приёма. При ошибке возвращает 0
byte GBUS_read_ack(byte pin, byte addr);

// Отправить запрос и ждать подтверждения приёма, т.е. пытаться достучаться
// (пин, адрес получателя, адрес отправителя, кол-во попыток, таймаут между попытками)
// возвращает 0 при таймауте, 1 при успехе (получили ack)
// см. примеры call response _ack
byte GBUS_send_request_ack(byte pin, byte to, byte from, byte tries, int timeout);

PWMrelay(byte pin, bool dir, int period);   // пин, уровень реле HIGH/LOW, период
void tick();                                // тик, вызывать как можно чаще, сам управляет реле
void setPWM(byte duty);                     // установить величину ШИМ, 0-255. При значении 0 и 255 тик неактивен!
byte getPWM();                              // возвращает величину ШИМ
void setPeriod(int period);                 // установить период ШИМ в миллисек. (по умолч. 1000мс == 1с)
int getPeriod();                            // получить период
void setLevel(bool level);                  // установить установить уровень реле (HIGH/LOW)

// ============ Методы класса microLED ============
// ЛЕНТА: имя буфера, количество ледов, пин
microLED(LEDdata *LEDarray, int LEDamount, byte pin);

// МАТРИЦА: имя буфера, пин, ширина матрицы, высота матрицы, тип матрицы, угол подключения, направление	(см. ПОДКЛЮЧЕНИЕ МАТРИЦЫ)
microLED(LEDdata *LEDarray, byte pin, byte width, byte height, M_type type, M_connection conn, M_dir dir);

// лента и матрица
void setRGB(int num, byte r, byte g, byte b);   // RGB
void setHSV(int num, byte h, byte s, byte v);   // HSV
void setHEX(int num, uint32_t color);           // HEX
void setColor(int num, COLORS color);           // стандартный цвет (см. "Стандартные цвета")
void colorWheel(int num, int color);            // цвет 0-1530	
void fill(LEDdata color);                       // заливка цветом (mRGB, mWHEEL, mHEX, mHSV)
void setLED(int n, LEDdata color);              // ставим цвет светодиода (mRGB, mWHEEL, mHEX, mHSV)	
uint32_t getColorHEX(int num);                  // получить HEX цвет диода (для сравнения и т.п.)
LEDdata getColor(int num);                      // получить цвет диода в LEDdata
void fade(int num, byte val);                   // уменьшить яркость на val

void setBrightness(byte newBright);             // яркость 0-255
void clear();                                   // очистка
void show();                                    // отправка

// матрица
void setPix(int x, int y, LEDdata color);       // ставим цвет пикселя x y в LEDdata (mRGB, mWHEEL, mHEX, mHSV)
uint32_t getColorHEX(int x, int y);             // получить цвет пикселя в HEX
LEDdata getColor(int x, int y);                 // получить цвет пикселя в LEDdata
void fadePix(int x, int y, byte val);           // уменьшить яркость пикселя на val
uint16_t getPixNumber(int x, int y);            // получить номер пикселя в ленте по координатам

// ============ Функции кодирования цвета ============
LEDdata mRGB(byte r, byte g, byte b);   // RGB 255, 255, 255
LEDdata mWHEEL(int color);              // цвета 0-1530
LEDdata mHEX(uint32_t color);           // HEX цвет
LEDdata mHSV(byte h, byte s, byte v);   // HSV 255, 255, 255
LEDdata mCOLOR(COLORS color);           // цвет

// ==================== Константы ====================
// Стандартные цвета
WHITE
SILVER
GRAY
BLACK
RED
MAROON
YELLOW
OLIVE
LIME
GREEN
AQUA
TEAL
BLUE
NAVY
PINK
PURPLE

void hardwareEnable(uint16_t data);				// включение указанной периферии (см. ниже "Константы периферии")
void hardwareDisable(uint16_t data);			// выключение указанной периферии (см. ниже "Константы периферии")
void setSystemPrescaler(prescalers_t prescaler);// установка делителя системной частоты (см. ниже "Константы делителя")
void bodInSleep(bool en);						// Brown-out detector в режиме сна (true вкл - false выкл) по умолч. отключен!
void setSleepMode(sleepmodes_t mode);			// установка текущего режима сна (см. ниже "Режимы сна")
void autoCalibrate(void);						// автоматическая калибровка таймера сна, выполняется 2 секунды
uint16_t getMaxTimeout(void);					// возвращает реальный период "8 секунд", выполняется ~8 секунд
void calibrate(uint16_t ms);					// ручная калибровка тайм-аутов watchdog для sleepDelay (ввести макс период из getMaxTimeout)
void sleep(sleepprds_t period);					// сон на фиксированный период (см. ниже "Периоды сна")
uint8_t sleepDelay(uint32_t ms);				// сон на произвольный период в миллисекундах (до 52 суток), возвращает остаток времени для коррекции таймеров
void correctMillis(bool state);					// корректировать миллис на время сна sleepDelay() (по умолчанию включено)
void wakeUp(void);								// помогает выйти из sleepDelay прерыванием (вызывать в будящем прерывании)	

/* 
	РЕЖИМЫ СНА для setSleepMode()
	
	IDLE_SLEEP			- Легкий сон, отключается только клок CPU и Flash, просыпается от любых прерываний
	ADC_SLEEP			- Легкий сон, отключается CPU и system clock, АЦП начинает преобразование при уходе в сон (см. пример ADCinSleep)	
	POWERDOWN_SLEEP		- Наиболее глубокий сон, отключается всё кроме WDT и внешних прерываний, просыпается от аппаратных (обычных + PCINT) или WDT за 1000 тактов (62 мкс)
	STANDBY_SLEEP		- Глубокий сон, идентичен POWERDOWN_SLEEP + system clock активен, пробуждение за 6 тактов (0.4 мкс)
	POWERSAVE_SLEEP		- Глубокий сон, идентичен POWERDOWN_SLEEP + timer 2 активен (+ можно проснуться от его прерываний), можно использовать для счета времени (см. пример powersaveMillis)
	EXTSTANDBY_SLEEP	- Глубокий сон, идентичен POWERSAVE_SLEEP + system clock активен, пробуждение за 6 тактов (0.4 мкс)
*/

/* 
	ПЕРИОДЫ СНА для sleep()
	
	SLEEP_16MS
	SLEEP_32MS
	SLEEP_64MS
	SLEEP_128MS
	SLEEP_256MS
	SLEEP_512MS
	SLEEP_1024MS
	SLEEP_2048MS
	SLEEP_4096MS
	SLEEP_8192MS
	SLEEP_FOREVER	- вечный сон без таймера
*/

/* 
	КОНСТАНТЫ ДЕЛИТЕЛЯ для setSystemPrescaler()
	
	PRESCALER_1
	PRESCALER_2
	PRESCALER_4
	PRESCALER_8
	PRESCALER_16
	PRESCALER_32
	PRESCALER_64
	PRESCALER_128
	PRESCALER_256
*/

/* 
	КОНСТАНТЫ ПЕРИФЕРИИ для hardwareDisable() и hardwareEnable()
	
	PWR_ALL		- всё железо
	PWR_ADC		- АЦП и компаратор
	PWR_TIMER1	- Таймер 0
	PWR_TIMER0	- Таймер 1
	PWR_TIMER2	- Таймер 2
	PWR_TIMER3	- Таймер 3
	PWR_TIMER4	- Таймер 4
	PWR_TIMER5	- Таймер 5	
	PWR_UART0	- Serial 0
	PWR_UART1	- Serial 1
	PWR_UART2	- Serial 2
	PWR_UART3	- Serial 3
	PWR_I2C		- Wire
	PWR_SPI		- SPI
	PWR_USB		- USB	
	PWR_USI		- Wire + Spi (ATtinyXX)
	PWR_LIN		- USART LIN (ATtinyXX)
*/

GyverBME280();								// Create an object of class BME280
bool begin(void);							// Initialize sensor with standard or previously selected parameters
bool isMeasuring(void);						// Returns 'true' while the measurement is in progress					
float readPressure(void);					// Read and calculate atmospheric pressure [float , Pa]
float readHumidity(void);					// Read and calculate air humidity [float , %]
void oneMeasurement(void);					// Make one measurement and go back to sleep [FORCED_MODE only]
void setMode(uint8_t mode);
float readTemperature(void);				// Read and calculate air temperature [float , *C]
void setFilter(uint8_t mode);				// Adjust the filter ratio other than the standard one [before begin()]
void setStandbyTime(uint8_t mode);			// Adjust the sleep time between measurements [NORMAL_MODE only][before begin()]
void setHumOversampling(uint8_t mode);		// Set oversampling or disable humidity module [before begin()]
void setTempOversampling(uint8_t mode);		// Set oversampling or disable temperature module [before begin()]
void setPressOversampling(uint8_t mode);	// Set oversampling or disable pressure module [before begin()]

void begin(int baudrate = 400);
void setClock(uint32_t clock);
void beginTransmission(void);
void beginTransmission(uint8_t addr);
void endTransmission(void);
void write(uint8_t data);
void requestFrom(uint8_t addr);
uint8_t receive_ack(void);
uint8_t receive_nack(void);

MicroDS3231();                  // конструктор
void setTime(uint8_t seconds , uint8_t minutes , uint8_t hours , uint8_t date, uint8_t month, uint16_t year);	// установка времени
void setTime(uint8_t param);    // установка времени == времени компиляции
bool lostPower(void);           // проверка на сброс питания
uint8_t getSeconds(void);       // получить секунды
uint8_t getMinutes(void);       // получить минуты
uint8_t getHours(void);         // получить часы
uint8_t getDay(void);           // получить день недели
uint8_t getDate(void);          // получить число
uint16_t getYear(void);         // получить год
uint8_t getMonth(void);         // получить месяц

MicroDS18B20(uint8_t pin);  // конструктор
void requestTemp();         // запросить температуру
float getTemp(void);        // получить температуру

	Библиотека полностью совместима с оригинальной LiquidCrystal_I2C

GButton(uint8_t pin);
// класс кнопки, принимает пин
	
GButton(uint8_t PIN, boolean type, boolean dir);    
// класс кнопки, принимает PIN пин, тип type (HIGH_PULL / LOW_PULL) и направление dir (NORM_OPEN / NORM_CLOSE)
// HIGH_PULL - кнопка подключена к GND, пин подтянут к VCC, pinMode - INPUT_PULLUP (по умолчанию)
// LOW_PULL - кнопка подключена к VCC, пин подтянут к GND, pinMode - INPUT
// NORM_OPEN - кнопка по умолчанию разомкнута
// NORM_CLOSE - кнопка по умолчанию замкнута
                                                    
void setDebounce(uint16_t debounce);           // установка времени антидребезга (по умолчанию 80 мс)
void setTimeout(uint16_t timeout);             // установка таймаута удержания (по умолчанию 500 мс)	
void setClickTimeout(uint16_t timeout);        // установка таймаута между нажатиями (по умолчанию 300 мс)
void setStepTimeout(uint16_t step_timeout);    // установка таймаута между инкрементами (по умолчанию 400 мс)
void setType(boolean type);                    // установка типа кнопки (HIGH_PULL - подтянута к питанию, LOW_PULL - к gnd)	
void setDirection(boolean dir);                // установка направления (разомкнута/замкнута по умолчанию - NORM_OPEN, NORM_CLOSE)	
	
void setTickMode(boolean tickMode);            // (MANUAL / AUTO) ручной или автоматический опрос кнопки функцией tick()	
                                               // MANUAL - нужно вызывать функцию tick() вручную														
                                               // AUTO - tick() входит во все остальные функции и опрашивается сама
	
void tick();                                   // опрос кнопки	
void tick(boolean state);                      // опрос внешнего значения (0 нажато, 1 не нажато) (для матричных, резистивных клавиатур и джойстиков)
	
boolean isPress();      // возвращает true при нажатии на кнопку. Сбрасывается после вызова
boolean isRelease();    // возвращает true при отпускании кнопки. Сбрасывается после вызова
boolean isClick();      // возвращает true при клике. Сбрасывается после вызова
boolean isHolded();     // возвращает true при удержании дольше timeout. Сбрасывается после вызова
boolean isHold();       // возвращает true при нажатой кнопке, не сбрасывается
boolean state();        // возвращает состояние кнопки

boolean isSingle();     // возвращает true при одиночном клике. Сбрасывается после вызова
boolean isDouble();     // возвращает true при двойном клике. Сбрасывается после вызова
boolean isTriple();     // возвращает true при тройном клике. Сбрасывается после вызова
	
boolean hasClicks();    // проверка на наличие кликов. Сбрасывается после вызова
uint8_t getClicks();    // вернуть количество кликов
uint8_t getHoldClicks();// вернуть количество кликов, предшествующее удерживанию
	
boolean isStep();       // возвращает true по таймеру setStepTimeout, смотри пример
void resetStates();     // сбрасывает все is-флаги и счётчики

Encoder(uint8_t, uint8_t, uint8_t);
// CLK, DT, SW

Encoder(uint8_t, uint8_t, uint8_t, boolean);
// CLK, DT, SW, тип (TYPE1 / TYPE2): TYPE1 одношаговый, TYPE2 двухшаговый. Если ваш энкодер работает странно, смените тип
		
void tick();                             // опрос энкодера, нужно вызывать постоянно или в прерывании
void setType(boolean type);              // TYPE1 / TYPE2 - тип энкодера TYPE1 одношаговый, TYPE2 двухшаговый. Если ваш энкодер работает странно, смените тип
void setTickMode(boolean tickMode);      // MANUAL / AUTO - ручной или автоматический опрос энкодера функцией tick(). (по умолчанию ручной)
void setDirection(boolean direction);    // NORM / REVERSE - направление вращения энкодера
void setFastTimeout(int timeout);        // установка таймаута быстрого поворота
	
boolean isTurn();                        // возвращает true при любом повороте, сама сбрасывается в false
boolean isRight();                       // возвращает true при повороте направо, сама сбрасывается в false
boolean isLeft();                        // возвращает true при повороте налево, сама сбрасывается в false
boolean isRightH();                      // возвращает true при удержании кнопки и повороте направо, сама сбрасывается в false
boolean isLeftH();                       // возвращает true при удержании кнопки и повороте налево, сама сбрасывается в false
boolean isFastR();                       // возвращает true при быстром повороте
boolean isFastL();                       // возвращает true при быстром повороте
	
boolean isPress();                       // возвращает true при нажатии кнопки, сама сбрасывается в false
boolean isRelease();                     // возвращает true при отпускании кнопки, сама сбрасывается в false
boolean isClick();                       // возвращает true при нажатии и отпускании кнопки, сама сбрасывается в false
boolean isHolded();                      // возвращает true при удержании кнопки, сама сбрасывается в false
boolean isHold();                        // возвращает true при удержании кнопки, НЕ СБРАСЫВАЕТСЯ

// N - номер таймера (0, 1... 5)
TimerN.setPeriod(период) - установка периода в микросекундах и запуск таймера. Возвращает реальный период (точность ограничена разрешением таймера).
TimerN.setFrequency(частота) - установка частоты в Герцах и запуск таймера. Возвращает реальную частоту (точность ограничена разрешением таймера).
TimerN.setFrequencyFloat(частота float) - установка частоты в Герцах и запуск таймера, разрешены десятичные дроби. Возвращает реальную частоту (точность ограничена разрешением таймера).
TimerN.enableISR(источник) - включить прерывания, канал прерываний CHANNEL_A или CHANNEL_B (+ CHANNEL_C у Mega2560), сдвиг фазы 0-359 (без указания параметров будет включен канал А и сдвиг фазы 0).
TimerN.disableISR(источник) - выключить прерывания, канал CHANNEL_A или CHANNEL_B. Счёт таймера не останавливается (без указания параметров будет выключен канал А).
TimerN.pause() - приостановить счёт таймера, не сбрасывая счётчик
TimerN.resume() - продолжить счёт после паузы
TimerN.stop() - остановить счёт и сбросить счётчик
TimerN.restart() - перезапустить таймер (сбросить счётчик)
TimerN.setDefault() - установить параметры таймера по умолчанию ("Ардуино-умолчания")
TimerN.outputEnable(канал, режим) - канал: включить выход таймера CHANNEL_A или CHANNEL_B (+ CHANNEL_C у Mega2560). Режим: TOGGLE_PIN, CLEAR_PIN, SET_PIN (переключить/выключить/включить пин по прерыванию)
TimerN.outputDisable(канал) - отключить выход таймера CHANNEL_A или CHANNEL_B (+ CHANNEL_C у Mega2560, см. такблицу таймеров)
TimerN.outputState(канал, состояние) - сменить состояние канала: HIGH / LOW
TimerN.phaseShift(источник, фаза) - сдвинуть фазу канала на 0-360 градусов (у 8 бит таймеров двигается только канал B)
	
Прерывание
ISR(TIMERn_A) {
// ваш код
}

// N - номер таймера (0, 1 или 2)
void timerN_ISR(void (*isr)());         // подключить прерывание
void timerN_setPeriod(uint32_t time);   // установить период (мкс)
void timerN_setFrequency(uint32_t hz);  // установить частоту (Гц)
void timerN_start(void);                // запустить
void timerN_stop(void);                 // остановить
void timerN_resume(void);               // продолжить
void timerN_restart(void);              // перезапустить

// Библиотека содержит макро-функции, возвращающие цифру
BUILD_YEAR	- год
BUILD_MONTH	- месяц
BUILD_DAY	- день
BUILD_HOUR	- час
BUILD_MIN	- минута
BUILD_SEC	- секунда

void setAnalogMux(ADC_modes mux);           // Аналоговый вход (ADC_A0-ADC_A7)/ термодатчик (ADC_SENSOR)/ 1.1V (ADC_1V1)/ ADC_GND (default: ADC_A0)
void ADC_enable(void);                      // Включить АЦП 
void ADC_disable(void);                     // Выключить АЦП (default)
void ADC_setPrescaler(byte prescl);         // Выбрать делитель частоты АЦП (2, 4, 8, 16, 32, 64, 128) // (default: 2)
void ADC_setReference(ADC_modes ref);       // Выбрать источник опорного напряжения АЦП (ADC_1V1, ADC_AREF, ADC_VCC) // (default: ADC_AREF)
void ADC_autoTriggerEnable(ADC_modes trig); // Включить автозапуск АЦП и выбрать событие (FREE_RUN, ANALOG_COMP, ADC_INT0, TIMER0_COMPA, TIMER0_OVF, TIMER1_COMPB, TIMER1_OVF)
void ADC_autoTriggerDisable(void);          // Выключить автозапуск АЦП // (default)
void ADC_attachInterrupt(void (*isr)());    // Включить прерывание готовности АЦП и выбрать функцию, которая будет при этом выполняться
void ADC_detachInterrupt(void);             // Выключить прерывание готовности АЦП // (default) 
void ADC_startConvert(void);                // Ручной запуск преобразования
unsigned int ADC_read(void);                // Прочитать значение регистров АЦП (Вызов до окончания преобразования вернет неверный результат)
boolean ADC_available(void);                // Проверить готовность преобразования АЦП
unsigned int ADC_readWhenAvailable(void);   // Дождаться окончания текущего преобразования и вернуть результат
void ACOMP_attachInterrupt(void (*isr)(), ADC_modes source); // Включить прерывание компаратора и выбрать при каком событии оно будет вызвано (FALLING_TRIGGER, RISING_TRIGGER, CHANGE_TRIGGER)
void ACOMP_detachInterrupt(void);           // Выключить прерывание компаратора // (default)
void ACOMP_enable(void);                    // Включить компаратор // (default: Включен)
void ACOMP_disable(void);                   // Принудительно выключить компаратор
boolean ACOMP_read(void);                   // Прочитать значение на выходе компаратора 
void ACOMP_setPositiveInput(ADC_modes in);  // Настроить куда подкл +Вход компаратора (ADC_1V1, ADC_AIN0) (default: ADC_AIN0 - pin 6) 
void ACOMP_setNegativeInput(ADC_modes in);  // Настроить куда подкл -Вход компаратора (ADC_AIN1, ANALOG_MUX) (default: ADC_AIN1 - pin 7)

// n - номер таймера (0, 1 или 2)
void TIMERn_COMPA_attachInterrupt(void (*isr)());
void TIMERn_COMPB_attachInterrupt(void (*isr)());
void TIMERn_COMPA_detachInterrupt(void);
void TIMERn_COMPB_detachInterrupt(void);
void TIMERn_setClock(byte clk);
void TIMERn_setMode(byte mode);
void TIMERn_COMPA_mode(byte mode);
void TIMERn_COMPB_mode(byte mode);
byte TIMERn_getCounter(void);
void TIMERn_setCounter(byte value);
void TIMERn_COMPA_setValue(byte value);
void TIMERn_COMPB_setValue(byte value);

// прерывания watchdog
void WDT_attachInterrupt(void (*isr)(),int prescaler);
void WDT_detachInterrupt(void);

// ============== Функции для расширенной генерации ШИМ сигнала ==============

// Данные функции убирают один ШИМ выход у 8-ми битных таймеров, оставляя нам ШИМ пины D3, D5, D9 и D10 на ATmega328

void PWM_frequency(byte pin, long freq, modes correct);
/*	PWM_freqency(пин, частота, режим) - запустить ШИМ с выбранной частотой
	- Пины: D3 (таймер 2), D5 (таймер 0 - сломает millis/delay), D9 и D10 (таймер 1)
	- Режим: 0 (FAST_PWM), 1 (CORRECT_PWM)
	- Частота: 250-200'000 Гц для всех таймеров
	- Для изменения заполнения используй PWM_set
		- Разрядность в этом режиме приведена к 8 битам, на деле шаги изменения разные!
*/

void PWM_resolution(byte pin, byte res, modes correct);
/*	PWM_resolution(пин, разрядность, режим) - запустить ШИМ с выбранной разрядностью
	- Пины: D3 (таймер 2), D5 (таймер 0 - сломает millis/delay), D9 и D10 (таймер 1)
	- Режим: 0 (FAST_PWM), 1 (CORRECT_PWM)
	- Разрешение: D3 (4-8 бит), D5 (4-8 бит), D9 и D10 (4-16 бит)
	- Частота в этом режиме выбирается автоматически максимальная согласно возможностям таймера (см. таблицу)
	- Для изменения заполнения используй PWM_set
		- Пределы заполнения для разной разрядности указаны в таблице
*/

void PWM_set(byte pin, unsigned int duty);
/*	PWM_set(пин, заполнение) - изменить заполнение на выбранном пине
	- Пин: D3, D5, D6, D9, D10, D11
	- Заполнение: зависит от разрешения и режима (см. таблицу)
		- При использовании PWM_frequency разрядность составляет 8 бит (0-255)
		- При использовании PWM_resolution макс. значение заполнения равно (2^разрядность - 1), также смотри таблицу
*/

void PWM_detach(byte pin);		// отключает ШИМ на выбранном пине (позволяет использовать digital Read/Write)
void PWM_attach(byte pin);		// подключает ШИМ на выбранном пине (с последними настройками)
void PWM_default(byte pin);		// сброс настроек соответствующего пину таймера на "стандартные" для Arduino

void PWM_16KHZ_D3(byte duty);
/* 	Запуск ШИМ с частотой 16 кГц на пине D3
	- Отменяет настройки PWM_frequency/PWM_resolution
	- Разрядность приведена к 8 битам (заполнение 0-255)
	- Заполнение меняет сама (не нужно вызывать PWM_set) */

void PWM_20KHZ_D3(byte duty);
/* 	Запуск ШИМ с частотой 20 кГц на пине D3
	- Отменяет настройки PWM_frequency/PWM_resolution
	- Разрядность приведена к 8 битам (заполнение 0-255)
	- Заполнение меняет сама (не нужно вызывать PWM_set) */

void PWM_16KHZ_D5(byte duty);
/* 	Запуск ШИМ с частотой 16 кГц на пине D5
	- Отменяет настройки PWM_frequency/PWM_resolution
	- Разрядность приведена к 8 битам (заполнение 0-255)
	- Заполнение меняет сама (не нужно вызывать PWM_set) */

void PWM_20KHZ_D5(byte duty);
/* 	Запуск ШИМ с частотой 20 кГц на пине D5
	- Отменяет настройки PWM_frequency/PWM_resolution
	- Разрядность приведена к 8 битам (заполнение 0-255)
	- Заполнение меняет сама (не нужно вызывать PWM_set) */

void PWM_16KHZ_D9(int duty);
/* 	Запуск ШИМ с частотой 16 кГц (15.6 кГц) на пине D9
	- Отменяет настройки PWM_frequency/PWM_resolution
	- Разрядность ровно 10 бит (заполнение 0-1023)
	- Заполнение меняет сама (не нужно вызывать PWM_set) */

void PWM_20KHZ_D9(int duty);
/* 	Запуск ШИМ с частотой 20 кГц на пине D9
	- Отменяет настройки PWM_frequency/PWM_resolution
	- Разрядность приведена к 10 битам (заполнение 0-1023)
	- Заполнение меняет сама (не нужно вызывать PWM_set) */

void PWM_16KHZ_D10(int duty);
/* 	Запуск ШИМ с частотой 16 кГц (15.6 кГц) на пине D10
	- Отменяет настройки PWM_frequency/PWM_resolution
	- Разрядность ровно 10 бит (заполнение 0-1023)
	- Заполнение меняет сама (не нужно вызывать PWM_set) */

void PWM_20KHZ_D10(int duty);
/* 	Запуск ШИМ с частотой 20 кГц на пине D10
	- Отменяет настройки PWM_frequency/PWM_resolution
	- Разрядность приведена к 10 битам (заполнение 0-1023)
	- Заполнение меняет сама (не нужно вызывать PWM_set) */
/*
	============= Таблица №1 частот для расширенной генерации ШИМ (PWM_resolution) =============
 _________________________________________________________________________________________________________________________
|Разрядность, бит   |4      |5      |6      |7      |8     |9       |10      |11     |12     |13     |14    |15    |16    |
|___________________|_______|_______|_______|_______|______|________|________|_______|_______|_______|______|______|______|
|Макс. значение duty|15     |31     |63     |127    |255   |511     |1023    |2047   |4095   |8191   |16383 |32767 |65535 |
|___________________|_______|_______|_______|_______|______|________|________|_______|_______|_______|______|______|______|
|Fast   | Пины 3, 5 |1 МГц  |516 кГц|254 кГц|126 кГц|63 кГц|-       |-       |-      |-      |-      |-     |-     |-     |
|PWM    | 9, 10     |1 МГц  |516 кГц|254 кГц|126 кГц|63 кГц|31.2 кГц|15.6 кГц|7.8 кГц|3.9 кГц|1.9 кГц|980 Гц|488 Гц|244 Гц|
|_______|___________|_______|_______|_______|_______|______|________|________|_______|_______|_______|______|______|______|
|Correct| Пины 3, 5 |571 кГц|266 кГц|129 кГц|63 кГц |32 кГц|-       |-       |-      |-      |-      |-     |-     |-     |
|PWM    | 9, 10     |571 кГц|266 кГц|129 кГц|63 кГц |32 кГц|15.7 кГц|7.8 кГц |3.9 кГц|1.9 кГц|976 Гц |488 Гц|244 Гц|122 Гц|
|_______|___________|_______|_______|_______|_______|______|________|________|_______|_______|_______|______|______|______|
*/

// ============ Функции для настройки стандартной генерации ШИМ сигнала (analogWrite) ============

// Данные функции НЕ убирают один ШИМ выход у 8-ми битных таймеров, можно использовать все 6 ШИМ пинов с настроенной частотой! См. таблицу.

void PWM_prescaler(byte pin, byte mode);
/*	PWM_prescaler(пин, режим) - установить предделитель таймера (меняет частоту ШИМ)
	- Пин: D3, D5, D6, D9, D10, D11
	- Режим: 1-7, см. таблицу частот
*/

void PWM_mode(byte pin, byte mode);
/*	PWM_mode(пин, режим) - установить режим генерации ШИМ
	- Пин: D3, D5, D6, D9, D10, D11
	- Режим: 0 - FastPWM, 1 - Phase-correct, см. таблицу частот
*/

void PWM_TMR1_8BIT();	// Установить таймер 1 (ШИМ на D9 и D10) в режим 8 бит. См. таблицу частот

void PWM_TMR1_10BIT();	// Установить таймер 1 (ШИМ на D9 и D10) в режим 10 бит. См. таблицу частот

/*
	========== Таблица №2 частот для стандартной генерации ШИМ (PWM_prescaler) ==========
	
	Timer 0 по умолчанию работает в режиме Fast PWM 
	Timer 1 и 2 по умолчанию работают в режиме Phase-correct
 _______________________________________________________________________________________________
|       | Timer0 (пины 5 и 6) 8 bit | Timer 1 (пины 9 и 10) 10 bit  | Timer2 (пины 3 и 11) 8 bit|
|       | Timer1 (пины 9 и 10) 8 bit|                               |                           |
|       |___________________________|_______________________________|___________________________|
|mode   | Phase-correct | Fast PWM  | Phase-correct     | Fast PWM  | Phase-correct | Fast PWM  |
|_______|_______________|___________|___________________|___________|_______________|___________|
|1      | 31.4 kHz      | 62.5 kHz  | 7.8 kHz           | 15.6 kHz  | 31.4 kHz      | 62.5 kHz  |
|2      | 4 kHz         | 7.8 kHz   | 977 Hz            | 2 kHz     | 4 kHz         | 8 kHz     |
|3      | 490 Hz        | 976 Hz    | 122 Hz            | 244 Hz    | 980 Hz        | 2 kHz     |
|4      | 122 Hz        | 244 Hz    | 30 Hz             | 61 Hz     | 490 Hz        | 980 Hz    |
|5      | 30 Hz         | 61 Hz     | 7.6 Hz            | 15 Hz     | 245 Hz        | 490 Hz    |
|6      | -             | -         | -                 | -         | 122 Hz        | 244 Hz    |
|7      | -             | -         | -                 | -         | 30 Hz         | 60 Hz     |
|_______|_______________|___________|___________________|___________|_______________|___________|
*/

void reset(void);                               // сброс
void disable(void);                             // отключить WDT
void enable(uint8_t mode, uint8_t prescaler);   // включить WDT с настройками
// mode:
// RESET_MODE - сброс при зависании (при тайм-ауте WDT)
// INTERRUPT_MODE - прерывание при зависании (при тайм-ауте WDT)
// INTERRUPT_RESET_MODE - первый таймаут - прерывание, второй - сброс
// prescaler:
// WDT_PRESCALER_2, WDT_PRESCALER_4... WDT_PRESCALER_1024

void write(uint16_t angle);                 // аналог метода из библиотеки Servo
void writeMicroseconds(uint16_t angle);     // аналог метода из библиотеки Servo
void attach(uint8_t pin);                   // аналог метода из библиотеки Servo
void attach(uint8_t pin, int min, int max); // аналог метода из библиотеки Servo. min по умолч. 500, max 2400
void detach();                              // аналог метода detach из библиотеки Servo
void start();                               // attach + разрешает работу tick
void stop();                                // detach + запрещает работу tick
		
boolean tick();                             // метод, управляющий сервой, должен опрашиваться как можно чаще.
                                            // Возвращает true, когда целевая позиция достигнута.
                                            // Имеет встроенный таймер с периодом SERVO_PERIOD

boolean tickManual();                       // метод, управляющий сервой, без встроенного таймера.
                                            // Возвращает true, когда целевая позиция достигнута

void setSpeed(int speed);					// установка максимальной скорости (больше 0), градусов / с
void setAccel(int accel);					// установка ускорения (0.1-1), условные величины
void setTarget(int target);					// установка целевой позиции в мкс (~500 - 2400 серво, ~150-600 драйвер PCA9685)
void setTargetDeg(int target);				// установка целевой позиции в градусах (0-макс. угол). Зависит от min и max
void setAutoDetach(boolean set);			// вкл/выкл автоматического отключения (detach) при достижении угла. По умолч. вкл
void setCurrent(int target);				// установка текущей позиции в мкс (~500 - 2400 серво, ~150-600 драйвер PCA9685)
void setCurrentDeg(int target);				// установка текущей позиции в градусах (0-макс. угол). Зависит от min и max
void setMaxAngle(int maxAngle);				// установка макс. угла привода
int getCurrent();							// получение текущей позиции в мкс (~500 - 2400 серво, ~150-600 драйвер PCA9685)
int getCurrentDeg();						// получение текущей позиции в градусах (0-макс. угол). Зависит от min и max
int getTarget();							// получение целевой позиции в мкс (~500 - 2400 серво, ~150-600 драйвер PCA9685)
int getTargetDeg();							// получение целевой позиции в градусах (0-макс. угол). Зависит от min и max

// ============== Бегущее среднее ==============
GFilterRA();                                // инициализация фильтра
GFilterRA(float coef, uint16_t interval);   // расширенная инициализация фильтра (коэффициент, шаг фильтрации)
void setCoef(float coef);                   // настройка коэффициента фильтрации (0.00 - 1.00). Чем меньше, тем плавнее
void setStep(uint16_t interval);            // установка шага фильтрации (мс). Чем меньше, тем резче фильтр
	
float filteredTime(int16_t value);          // возвращает фильтрованное значение с опорой на встроенный таймер	
float filtered(int16_t value);              // возвращает фильтрованное значение
	
float filteredTime(float value);            // возвращает фильтрованное значение с опорой на встроенный таймер	
float filtered(float value);                // возвращает фильтрованное значение

// ============== Медиана из трёх ==============
GMedian3();                     // инициализация фильтра
uint16_t filtered(uint16_t);    // возвращает фильтрованное значение

// ============== Медиана из MEDIAN_FILTER_SIZE (настраивается в GyverFilters.h) ==============
GMedian();                      // инициализация фильтра
uint16_t filtered(uint16_t);    // возвращает фильтрованное значение

// ============== Альфа-Бета фильтр ==============
GABfilter(float delta, float sigma_process, float sigma_noise);
// период дискретизации (измерений), process variation, noise variation
		
void setParameters(float delta, float sigma_process, float sigma_noise);
// период дискретизации (измерений), process variation, noise variation
		
float filtered(float value);      // возвращает фильтрованное значение

// ============== Упрощённый Калман ==============
GKalman(float mea_e, float est_e, float q);
// разброс измерения, разброс оценки, скорость изменения значений
		
GKalman(float mea_e, float q);
// разброс измерения, скорость изменения значений (разброс измерения принимается равным разбросу оценки)
		
void setParameters(float mea_e, float est_e, float q);
// разброс измерения, разброс оценки, скорость изменения значений
		
void setParameters(float mea_e, float q);
// разброс измерения, скорость изменения значений (разброс измерения принимается равным разбросу оценки)
		
float filtered(float value);     // возвращает фильтрованное значение

// ============== Линейная аппроксимация ==============
void compute(int *x_array, int *y_array, int arrSize);		// аппроксимировать
float getA();		// получить коэффициент А
float getB();		// получить коэффициент В
float getDelta();	// получить аппроксимированное изменение

GTimer(timerType type, uint32_t interval);  // объявление таймера с указанием типа и интервала (таймер не запущен, если не указывать)
void setInterval(uint32_t interval);    // установка интервала работы таймера (также запустит и сбросит таймер) - режим интервала
void setTimeout(uint32_t timeout);      // установка таймаута работы таймера (также запустит и сбросит таймер) - режим таймаута
boolean isReady();                      // возвращает true, когда пришло время
boolean isEnabled();                    // вернуть состояние таймера (остановлен/запущен)
void reset();                           // сброс таймера на установленный период работы
void start();                           // запустить/перезапустить (со сбросом счёта)
void stop();                            // остановить таймер (без сброса счёта)	
void resume();                          // продолжить (без сброса счёта)	

// ********************************************* Хаки с ШИМ *********************************************
void setPWMmode(byte pin, byte mode);   // установка режима ШИМ на пине 
                                        // пины 3, 5, 6, 9, 10, 11
                                        // режимы: 0 - FastPWM, 1 - Phase-correct PWM

void setPWMprescaler(uint8_t pin, uint16_t mode);
// установка частоты ШИМ на пине. Смотри таблицу частот в GyverHacks.h или примере PWMfreq!

void set8bitPWM();                 // установка ШИМ на пинах 9 и 10 в режим 8 бит (analogWrite 0-255) (по умолчанию)

void set10bitPWM();                // установка ШИМ на пинах 9 и 10 в режим 10 бит (analogWrite 0-1023)

void delayFix(uint32_t delayTime);                  // аналог delay для корректной работы с изменённой частотой ШИМ пинов 5 и 6
void delayMicrosecondsFix(uint32_t delayTime);      // аналог delayMicroseconds для корректной работы с изменённой частотой ШИМ пинов 5 и 6

uint32_t millisFix();                               // аналог millis для корректной работы с изменённой частотой ШИМ пинов 5 и 6
uint32_t microsFix();                               // аналог micros для корректной работы с изменённой частотой ШИМ пинов 5 и 6

void anyPWMinit(byte prescaler);
// инициализация ШИМ на любом пине
// prescaler: 4 - 311 Гц, 5 - 244 Гц, 6 - 122 Гц, 7 - 30 Гц
// если пинов много - понижайте частоту (20 пинов работают отлично на 6 режиме)													
													
void anyPWMpin(uint8_t pin);       // настроить ЛЮБОЙ пин для генерации ШИМ

void anyPWM(byte pin, byte duty);  // включить ШИМ на ЛЮБОМ пине (настроенном выше)

// ********************************************* Ускоряем функции *********************************************

void setPWM(uint8_t pin, uint8_t duty);      // быстрый аналог analogWrite (в 7 раз быстрее)

void setPin(uint8_t pin, uint8_t x);         // быстрый аналог digitalWrite (в 10 раз быстрее)

boolean readPin(uint8_t pin);                // быстрый аналог digitalRead (в 11 раз быстрее)

void setADCrate(byte mode);
// установка скорости работы АЦП (analogRead)
// mode 1: 3.04 мкс (частота оцифровки 329 000 кГц)
// mode 2: 4.72 мкс (частота оцифровки 210 000 кГц)
// mode 3: 8.04 мкс (частота оцифровки 125 000 кГц)
// mode 4: 15.12 мкс (частота оцифровки 66 100 кГц)
// mode 5: 28.04 мкс (частота оцифровки 35 600 кГц)
// mode 6: 56.04 мкс (частота оцифровки 17 800 кГц)													
// mode 7: 112 мкс (частота оцифровки 8 900 Гц)

// ********************************************* Точный вольтметр *********************************************

int getVCC();                      // возвращает опорное напряжение (напряжение питания)
                                   // константа по умолчанию равна 1100, нужно калибровать!
								
void constantWizard();             // помошник калибровки константы (смотри пример)

void restoreConstant(int adr);     // восстановить константу из памяти

void setConst(int new_const);      // установить константу вручную (по умолч. 1100)

int getConst();                    // вывести текущую константу

int getVoltage(uint8_t pin);       // измерить напряжение на пине с учётом опорного

// функции получения процента заряда из напряжения, линеаризованы вручную по графикам разряда АКБ
// использовать вот так: lithiumPercent(getVCC()); - ардуина питается от лития

byte lithiumPercent(int volts);    // возвращает процент заряда Li-ion аккумулятора (4,2-2,8 В)

byte alkaline3Percent(int volts);  // возвращает процент заряда 3х алкалиновых батареек (4,6-3,3 В)

byte nickel3Percent(int volts);    // возвращает процент заряда 3х Ni-Cd аккумуляторов (4.2-3.0 В)

byte nickel4Percent(int volts);    // возвращает процент заряда 4х Ni-Cd аккумуляторов (5.6-4.0В)

// функция для расчёта заряда батареи в процентах
// принимает напряжение в милливолльтах (volts), а также напряжения, при которых заряд равен 100, 80... 0%
byte mVtoPercent(int volts, int volt100, int volt80, int volt60, int volt40, int volt20, int volt0);

// ********************************************* Прочее *********************************************
float getTemp();		// получить примерную температуру ядра процессора (температура окружающей среды или температура внутри корпуса)

GMotor(driverType type, int8_t param1 = NC, int8_t param2 = NC, int8_t param3 = NC, int8_t param4 = NC);
// три варианта создания объекта в зависимости от драйвера:
// GMotor motor(DRIVER2WIRE, dig_pin, PWM_pin, (LOW/HIGH) )
// GMotor motor(DRIVER3WIRE, dig_pin_A, dig_pin_B, PWM_pin, (LOW/HIGH) )
// GMotor motor(RELAY2WIRE, dig_pin_A, dig_pin_B, (LOW/HIGH) )
	
// установка скорости 0-255 (8 бит) и 0-1023 (10 бит)
void setSpeed(int16_t duty);			
	
// сменить режим работы мотора:	
// FORWARD - вперёд
// BACKWARD - назад
// STOP - остановить
// BRAKE - активное торможение
// AUTO - подчиняется setSpeed (-255.. 255) и 0-1023 (10 бит)
void setMode(workMode mode);
	
// направление вращения	
// NORM - обычное
// REVERSE - обратное
void setDirection(dir direction);
	
// установить выход в 8 бит
void set8bitMode();		

// установить выход в 10 бит
void set10bitMode();					
	
// установить deadtime (в микросекундах). По умолч 0
void setDeadtime(uint16_t deadtime);	
	
// установить уровень драйвера (по умолч. HIGH)
void setLevel(int8_t level);			
	
// плавное изменение к указанной скорости
void smoothTick(int16_t duty);
	
// скорость изменения скорости
void setSmoothSpeed(uint8_t speed);

// внутренняя переменная скважности для отладки
int16_t _duty = 0;

// Примечание: далее по тексту под "по умолчанию" имеется в виду "даже если не вызывать функцию"

// Создание объекта
// steps - шагов на один оборот вала (для расчётов с градусами)
// step, dir, pin1, pin2, pin3, pin4 - любые GPIO
// en - пин отключения драйвера, любой GPIO
GStepper<STEPPER2WIRE> stepper(steps, step, dir);						// драйвер step-dir
GStepper<STEPPER2WIRE> stepper(steps, step, dir, en);					// драйвер step-dir + пин enable
GStepper<STEPPER4WIRE> stepper(steps, pin1, pin2, pin3, pin4);			// драйвер 4 пин
GStepper<STEPPER4WIRE> stepper(steps, pin1, pin2, pin3, pin4, en);		// драйвер 4 пин + enable
GStepper<STEPPER4WIRE_HALF> stepper(steps, pin1, pin2, pin3, pin4);		// драйвер 4 пин полушаг
GStepper<STEPPER4WIRE_HALF> stepper(steps, pin1, pin2, pin3, pin4, en);	// драйвер 4 пин полушаг + enable

// Здесь происходит движение мотора, вызывать как можно чаще!
// Имеет встроенный таймер
// Возвращает true, если мотор движется к цели или крутится по KEEP_SPEED
bool tick();

// Инвертировать направление мотора - true (по умолч. false)
void reverse(bool dir);

// инвертировать поведение EN пина - true (по умолч. false)
void invertEn(bool rev);

// Установка режима работы, mode:
// FOLLOW_POS - следование к позиции setTarget(...)
// KEEP_SPEED - удержание скорости setSpeed(...)
void setRunMode(GS_runMode mode);

// Установка текущей позиции мотора в шагах и градусах
void setCurrent(long pos);
void setCurrentDeg(float pos);

// Чтение текущей позиции мотора в шагах и градусах
long getCurrent();
float getCurrentDeg();

// установка целевой позиции в шагах и градусах (для режима FOLLOW_POS)
// type - ABSOLUTE или RELATIVE, по умолчанию стоит ABSOLUTE
void setTarget(long pos);
void setTarget(long pos, GS_posType type);
void setTargetDeg(float pos);
void setTargetDeg(float pos, GS_posType type);

// Получение целевой позиции в шагах и градусах
long getTarget();
float getTargetDeg();

// Установка максимальной скорости (по модулю) в шагах/секунду и градусах/секунду (для режима FOLLOW_POS)
// по умолч. 300
void setMaxSpeed(float speed);
void setMaxSpeedDeg(float speed);

// Установка ускорения в шагах и градусах в секунду (для режима FOLLOW_POS).
// При значении 0 ускорение отключается и мотор работает 
// по профилю постоянной максимальной скорости setMaxSpeed().
// По умолч. 300
void setAcceleration(int accel);
void setAccelerationDeg(float accel);

// Автоотключение EN при достижении позиции - true (по умолч. false).
void autoPower(bool mode);

// Плавная остановка с заданным ускорением от текущего положения. 
// Режим будет переключен на FOLLOW_POS
// Установленная максимальная скорость будет изменена!!!
void stop();

// Жёсткая остановка
void brake();

// Жёсткая остановка + сброс позиции в 0 (для концевиков)
void reset();

// Установка целевой скорости в шагах/секунду и градусах/секунду (для режима KEEP_SPEED)
void setSpeed(float speed);
void setSpeedDeg(float speed);

// Получение целевой скорости в шагах/секунду и градусах/секунду (для режима KEEP_SPEED)
float getSpeed();
float getSpeedDeg();

// Включить мотор (пин EN)
void enable();

// Выключить мотор (пин EN)
void disable();

// Возвращает то же самое, что tick, т.е. крутится мотор или нет
bool getState();

// Возвращает минимальный период тика мотора в микросекундах при настроенной setMaxSpeed() скорости.
// Можно использовать для настройки прерываний таймера, в обработчике которого будет лежать tick() (см. пример timerISR)
uint16_t getMinPeriod();

// Текущий период "тика" для отладки и всего такого
uint16_t stepTime;

// управляет мотором. Вызывать как можно чаще (внутри таймер с периодом dt)
// принимает текущее положение вала мотора (по счёту энкодера)
// возвращает true если мотор всё ещё движется к цели
bool tick(long pos);

// установка передаточного отношения редуктора и энкодера
// пример: если редуктор 1:30 - передаём в функцию 30
// пример: если редуктор 1:30 и энкодер на 12 тиков - передаём 30*12
void setRatio(float ratio);

// установка периода регулятора (рекомендуется 2-50 миллисекунд)
void setDt(int dt);

// установка и получение текущей позиции в тиках энкодера и градусах.
// setCurrent(pos) равносильна вызову tick(pos) и в принципе не нужна!
void setCurrent(long pos);
long getCurrent();
long getCurrentDeg();

// установка и получение целевой позиции в тиках энкодера и градусах
void setTarget(long pos);
void setTargetDeg(long pos);
long getTarget();
long getTargetDeg();

// установка максимальной скорости в тиках энкодера/секунду и градусах/секунду
void setMaxSpeed(int speed);
void setMaxSpeedDeg(int speed);

// установка ускорения тиках энкодера и градусах в секунду
void setAcceleration(float accel);
void setAccelerationDeg(float accel);

// установка и получение целевой скорости в тиках энкодера/секунду и градусах/секунду
void setTargetSpeed(int speed);
void setTargetSpeedDeg(int speed);
int getTargetSpeed();
int getTargetSpeedDeg();

// получить текущую скорость в тиках энкодера/секунду и градусах/секунду
int getSpeed();
int getSpeedDeg();

// получить текущий ШИМ сигнал (float из ПИД регулятора)
float getDuty();

// ручная установка режима работы
// IDLE_RUN - tick() не управляет мотором. Может использоваться для отладки
// ACCEL_POS - tick() работает в режиме плавного следования к целевому углу
// PID_POS - tick() работает в режиме резкого следования к целевому углу
// ACCEL_SPEED - tick() работает в режиме плавного поддержания скорости (с заданным ускорением)
// PID_SPEED - tick() работает в режиме поддержания скорости по ПИД регулятору
void setRunMode(runMode mode);

// возвращает true, если вал мотора заблокирован, а сигнал подаётся
bool isBlocked();

// коэффициенты ПИД регулятора
// пропорциональный - от него зависит агрессивность управления, нужно увеличивать kp
// при увеличении нагрузки на вал, чтобы регулятор подавал больший управляющий ШИМ сигнал
float kp = 2.0;// (знач. по умолчанию)

// интегральный - позволяет нивелировать ошибку со временем, имеет накопительный эффект
float ki = 0.9;// (знач. по умолчанию)

// дифференциальный. Позволяет чуть сгладить рывки, но при большом значении
// сам становится причиной рывков и раскачки системы!
float kd = 0.1;// (знач. по умолчанию)

// установить зону остановки мотора для режима стабилизации позиции (по умолч. 8)
void setStopZone(int zone);

// объявление
GRGB(uint8_t rpin, uint8_t gpin, uint8_t bpin);

// объявление с выбором режима генерации ШИМ (NORM_PWM / ANY_PWM)
// NORM_PWM - дефолтные ШИМ пины (3, 5, 6, 9, 10, 11 для UNO/NANO/MINI)
// ANY_PWM - любой пин делается ШИМ пином (частота ~150 Гц). Подробности в библиотеке GyverHacks
GRGB(uint8_t rpin, uint8_t gpin, uint8_t bpin, boolean pwmmode);

// NORMAL / REVERSE - направление ШИМ
// общий катод - NORMAL
// общий анод - REVERSE
void setDirection(boolean direction);

// установка ограничения по току: 
// numLeds - количество светодиодов
// vcc - напряжение питания в милливольтах
// maxCur - максимальный ток
void setMaxCurrent(uint16_t numLeds, float vcc, int maxCur);
																	
void setBrightness(byte bright);                     // установка яркости (0-255)
void constantBrightTick(int minVolts, int vcc);      // корректировка под напряжение питания
void gammaTick(int vcc);                             // корректировка красного цвета при падении напряжения питания

void setHEX(uint32_t color);                         // установка цвета в формате HEX (вида 0x808080 )
void setRGB(uint8_t r, uint8_t g, uint8_t b);        // установка цвета в пространстве RGB (каждый цвет 0-255)
void setHSV(uint8_t h, uint8_t s, uint8_t v);        // установка цвета в пространстве HSV (каждая велиична 0-255)
void setHSV_fast(uint8_t h, uint8_t s, uint8_t v);   // более быстрый, но менее красивый вариант предыдущей функции
void setKelvin(int16_t temperature);                 // установить цвет как температуру в Кельвинах (от 1000 до 10'000 - от красного к синему)
void colorWheel(int color);                          // установить цвет (0 - 1530). Максимально широкая палитра ярких цветов (смеси RGB)
	
// плавно изменить текущий цвет к новому за вермя fadeTime в миллисекундах
// для HEX цвета
void fadeTo(uint32_t newColor, uint16_t fadeTime);
	
// для R G B
void fadeTo(uint8_t new_r, uint8_t new_g, uint8_t new_b, uint16_t fadeTime);

GyverTM1637(uint8_t clk, uint8_t dio);                                  // объявление и инициализация
	
void display(uint8_t DispData[]);                                       // выводит цифры массивом по ячейкам. От 0 до 9 (byte values[] = {3, 5, 9, 0}; )
void display(uint8_t BitAddr, int8_t DispData);                         // выводит цифру DispData в указанную ячейку дисплея BitAddr
void display(uint8_t bit0, uint8_t bit1, uint8_t bit2, uint8_t bit3);   // если лень создавать массив, выводит цифры в ячейки
	
void displayByte(uint8_t DispData[]);                                   // выводит байт вида 0xe6 и буквы-константы вида _a , _b .... массивом
void displayByte(uint8_t BitAddr, int8_t DispData);                     // выводит байт вида 0xe6 и буквы-константы вида _a , _b .... в ячейку
void displayByte(uint8_t bit0, uint8_t bit1, uint8_t bit2, uint8_t bit3);  // если лень создавать массив, выводит байты в ячейки
	
void displayClock(uint8_t hrs, uint8_t mins);                           // выводит часы и минуты
void displayClockScroll(uint8_t hrs, uint8_t mins, int delayms);        // выводит часы и минуты с эффектом прокрутки
void displayClockTwist(uint8_t hrs, uint8_t mins, int delayms);         // выводит часы и минуты с эффектом скрутки
	
void displayInt(int value);                                             // выводит число от -999 до 9999 (да, со знаком минус)
	
void runningString(int8_t DispData[], byte amount, int delayMs);        // бегущая строка (array, sizeof(array), задержка в мс)
	
void clear(void);                                                       // очистить дисплей
	
void point(boolean PointFlag);                                          // вкл / выкл точку (POINT_ON / POINT_OFF)

void brightness(uint8_t bright, uint8_t = 0x40, uint8_t = 0xc0);        // яркость 0 - 7	
	
void scroll(uint8_t BitAddr, int8_t DispData, int delayms);             // обновить значение прокруткой (адрес, ЦИФРА, задержка в мс)
void scroll(int8_t DispData[], int delayms);                            // обновить значение прокруткой (массив ЦИФР, задержка в мс)
void scroll(uint8_t bit0, uint8_t bit1, uint8_t bit2, uint8_t bit3, int delayms);   // прокрутка посимвольно
void scrollByte(uint8_t BitAddr, int8_t DispData, int delayms);         // обновить значение прокруткой (адрес, БАЙТ, задержка в мс)
void scrollByte(int8_t DispData[], int delayms);                        // обновить значение прокруткой (массив БАЙТ, задержка в мс)
void scrollByte(uint8_t bit0, uint8_t bit1, uint8_t bit2, uint8_t bit3, int delayms);  // прокрутка посимвольно
	
void twist(uint8_t BitAddr, int8_t DispData, int delayms);              // обновить значение скручиванием (адрес, ЦИФРА, задержка в мс)
void twist(int8_t DispData[], int delayms);                             // обновить значение скручиванием (массив ЦИФР, задержка в мс)
void twist(uint8_t bit0, uint8_t bit1, uint8_t bit2, uint8_t bit3, int delayms);   // скрутка посимвольно
void twistByte(uint8_t BitAddr, int8_t DispData, int delayms);          // обновить значение скручиванием (адрес, БАЙТ, задержка в мс)
void twistByte(int8_t DispData[], int delayms);                         // обновить значение скручиванием (массив БАЙТ, задержка в мс)
void twistByte(uint8_t bit0, uint8_t bit1, uint8_t bit2, uint8_t bit3, int delayms);  // скрутка посимвольно

==== datatype это float или int, в зависимости от выбранного (см. пример integer_calc) ====

GyverPID();
GyverPID(float new_kp, float new_ki, float new_kd, int16_t new_dt = 100);		// kp, ki, kd, dt
	
datatype setpoint = 0;		// заданная величина, которую должен поддерживать регулятор
float input = 0;			// сигнал с датчика (например температура, которую мы регулируем)
datatype output = 0;		// выход с регулятора на управляющее устройство (например величина ШИМ или угол поворота серво)
	
datatype getResult();												// возвращает новое значение при вызове (если используем свой таймер с периодом dt!)	
datatype getResult(datatype new_setpoint, datatype new_input);		// принимает setpoint и input
	
datatype getResultTimer();											// возвращает новое значение не ранее, чем через dt миллисекунд (встроенный таймер с периодом dt)
datatype getResultTimer(datatype new_setpoint, datatype new_input);	// тож самое, но принимает setpoint и input
	
void setDirection(uint8_t direction);						// направление регулирования: NORMAL (0) или REVERSE (1)
void setMode(uint8_t mode);									// режим: работа по входной ошибке ON_ERROR (0) или по изменению ON_RATE (1)
void setLimits(int min_output, int max_output);				// лимит выходной величины (например для ШИМ ставим 0-255)
void setDt(int16_t new_dt);									// установка времени дискретизации (для getResultTimer)
void tune(float new_kp, float new_ki, float new_kd);		// перенастройка коэффициентов (П, И, Д)

// принимает установку, ширину гистерезиса, направление (NORMAL, REVERSE)
// NORMAL - включаем нагрузку при переходе через значение снизу (пример: охлаждение)
// REVERSE - включаем нагрузку при переходе через значение сверху (пример: нагрев)
GyverRelay(float new_setpoint, float new_hysteresis, boolean direction);
GyverRelay();

// расчёт возвращает состояние для управляющего устройства (реле, транзистор) (1 вкл, 0 выкл)
boolean getResult();                        // расчёт
boolean getResult(float new_input);         // расчёт, принимает текущую величину с датчика
boolean getResultTimer();                   // расчёт по встроенному таймеру
boolean getResultTimer(float new_input);    // расчёт, принимает текущую величину с датчика (+ по встроенному таймеру)
	
void setDirection(boolean);                 // направление регулирования (NORMAL, REVERSE)
	
float input;                        // сигнал с датчика (например температура, которую мы регулируем)
float setpoint;                     // заданная величина, которую должен поддерживать регулятор (температура)
	
float signal;                       // сигнал (для отладки)
float hysteresis;                   // ширина гистерезиса (половина в минус, половина в плюс)
float k = 0;                        // коэффициент усиления	по скорости (по умолч. 0)
float rate;                         // скорость изменения величины (производная)
int16_t sampleTime = 1000;          // время итерации, мс (по умолч. секунда)