v1.2

README.md

@@ -4,7 +4,7 @@
 Библиотека для радиомодулей 433 МГц и Arduino
 - Супер лёгкая либа, заведётся даже на тини13 (отправка)
 - Поддержка кривых китайских модулей
-- Интерфейс Manchester Coding (v1.1)
+- Интерфейс Manchester или Pulselength
 - Встроенный CRC контроль целостности (CRC8 или XOR)
 - Ускоренный алгоритм IO для AVR Arduino
 - Опционально работа в прерывании (приём данных)
@@ -36,34 +36,43 @@
 <a id="init"></a>
 ## Инициализация
 ```cpp
-//Классы:
+// === КЛАССЫ ===
-Gyver433_RX // приёмник
+// Gyver433_RX - приёмник
-Gyver433_TX // передатчик
+// Gyver433_TX - передатчик
 
+// === ИНИЦИАЛИЗАЦИЯ ===
+Gyver433_xx<пин> xx;
+Gyver433_xx<пин, буфер> xx;
 Gyver433_xx<пин, буфер, CRC> xx;
 // пин: цифровой пин
-// буфер: размер буфера в байтах. На "ручную" отправку буфер не нужен (пример raw_tx). По умолч. 64 байта
+// буфер: размер буфера в байтах. На "ручную" отправку буфер не нужен. По умолч. 64
 // CRC: проверка целостности данных: G433_CRC8 (надёжный), G433_XOR (лёгкий), G433_NOCRC (отключено). По умолч. G433_CRC8
 
-// Дефайны-настройки перед подключением библиотеки
+
-#define G433_SLOW_MODE      // "медленный режим" для синих модулей SYN480R
+// === ДЕФАЙНЫ-НАСТРОЙКИ ===
-#define G433_SPEED 1000     // скорость 100-8000 бит/с, по умолч. 2000 бит/с
+// вызывать перед подключением библиотеки
+#define G433_FAST         // [TX] короткая синхронизация для зелёных модулей
+#define G433_MEDIUM       // [TX] средняя синхронизация при отправке на SYN480R ЧАЩЕ 400мс (активно по умолчанию)
+#define G433_SLOW         // [TX] длинная синхронизация при отправке на SYN480R РЕЖЕ 400мс
+#define G433_MANCHESTER   // [должно быть одинаково на RX и TX] интерфейс Manchester Coding для экспериментов =) 
+#define G433_SPEED 1000   // [должно быть одинаково на RX и TX] скорость 100-8000 бит/с, по умолч. 2000 бит/с 
 ```
 
 <a id="usage"></a>
 ## Использование
 ```cpp
 // ========= Gyver433_TX =========
-void sendData(T &data);                 // отправить данные любого типа (CRC добавится автоматически)
+void sendData(T &data);                 // отправить данные любого типа (CRC добавляется автоматически)
 void write(uint8_t* buf, uint8_t size); // отправить массив байт указанного размера (CRC не добавляется)
 uint8_t buffer[];                       // доступ к буферу для отладки
 
 // ========= Gyver433_RX =========
-uint8_t tick();             // неблокирующий приём, вернёт кол-во успешно принятых байт
+uint16_t tick();            // неблокирующий приём, вернёт кол-во успешно принятых байт
-uint8_t tickWait();         // блокирующий приём, вернёт кол-во успешно принятых байт
+uint16_t tickWait();        // блокирующий приём (более надёжный), вернёт кол-во успешно принятых байт
+uint16_t tickISR();         // тикер для прерывания по CHANGE (см. пример isr_rx)
 bool readData(T &data);     // прочитает буфер в любой тип данных (в указанную переменную)
-int getSize();              // получить размер принятых данных
+uint16_t getSize();         // получить размер принятых данных
-bool gotData();             // вернёт true при получении корректных данных (если tick опрашивается в другом месте)
+uint16_t gotData();         // вернёт количество успешно принятых в tickISR() байт (см. пример isr_rx)
 uint8_t buffer[];           // доступ к буферу для отладки
 
 // ============= CRC =============
@@ -73,12 +82,11 @@ uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size);    // ручной CRC XOR
 ```
 
 <a id="example"></a>
-## Пример
+## Примеры
-Остальные примеры смотри в **examples**!  
+Остальные примеры смотри в **examples**!
+![Logo](/doc/scheme.jpg)
 ### Отправка
 ```cpp
-// ======== ПЕРЕДАТЧИК =========
-#define G433_SLOW_MODE
 #include <Gyver433.h>
 Gyver433_TX<2, 20> tx;  // указали пин и размер буфера
 
@@ -96,9 +104,10 @@ void loop() {
   tx.sendData(data);
   delay(100);
 }
+```
 
-// ======== ПРИЁМНИК =========
+### Приём
-#define G433_SLOW_MODE
+```cpp
 #include <Gyver433.h>
 Gyver433_RX<2, 20> rx;  // указали пин и размер буфера
 
@@ -107,36 +116,33 @@ void setup() {
 }
 
 void loop() {
-  if (rx.tickWait()) {
+  if (rx.tickWait()) {                  // если успешно принято больше 0
-    Serial.write(rx.buffer, rx.size);
+    Serial.write(rx.buffer, rx.size);   // выводим
     Serial.println();
   }
 }
 ```
 
-### Приём
+### Приём в прерывании
 ```cpp
-// крупный приёмник 5.0 SYN480R
-
-#define G433_BUFSIZE 50   // размер буфера
-#define G433_SPEED 2000   // скорость бит/сек (минимальная)
-
 #include <Gyver433.h>
-Gyver433_RX rx(2);
+Gyver433_RX<2, 20> rx;  // указали пин и размер буфера
 
 void setup() {
-  Serial.begin(9600);
+  Serial.begin(9600);  
+  attachInterrupt(0, isr, CHANGE);  // прерывание пина радио по CHANGE
 }
 
+void isr() {
+  rx.tickISR();     // спец. тикер вызывается в прерывании
+}
 
 void loop() {
-  // tick принимает асинхронно, но может ловить ошибки при загруженном коде
+  if (rx.gotData()) {                   // если успешно принято больше 0
-  // tickWait блокирует выполнение, но принимает данные чётко
+    Serial.write(rx.buffer, rx.size);   // выводим
-  if (rx.tickWait()) {
+    Serial.println();
-    byte buf[64];
+  }  
-    rx.readData(buf);
+  delay(200);                           // имитация загруженного кода
-    for (byte i = 0; i < rx.size; i++) Serial.write(buf[i]);
-  }
 }
 ```
 
@@ -144,6 +150,7 @@ void loop() {
 ## Версии
 - v1.0
 - v1.1 - оптимизация, новый интерфейс, поддержка дешёвых синих модулей, работа в прерывании
+- v1.2 - улучшение качества связи, оптимизация работы в прерывании
 
 <a id="feedback"></a>
 ## Баги и обратная связь

examples/demo_rx/demo_rx.ino

@@ -1,21 +1,21 @@
+// демо-пример: инициализация и настройки
 // крупный приёмник SYN480R [VCC: 3.3-5.5V, logic: VCC]
 // или MX-RM-5V (RF-5V) [VCC: 5V, logic: 5V]
 
-// "медленный режим" для синих модулей SYN480R
+// дефайны перед подключением библиотеки
-// Объявляется перед подключением библиотеки
+//#define G433_MANCHESTER   // интерфейс Manchester Coding для экспериментов =)
-// Зелёным модулям не нужен!
+//#define G433_SPEED 1000   // скорость 100-8000 бит/с, по умолч. 2000 бит/с
-#define G433_SLOW_MODE
-
-// можно указать скорость, по умолч. стоит 2000 бит/с
-// рабочий диапазон: 100-8000 бит/с
-//#define G433_SPEED 1000
 
 #include <Gyver433.h>
-// Gyver433_TX<пин, буфер, CRC>
+//Gyver433_RX<пин> rx;
+//Gyver433_RX<пин, буфер> rx;
+//Gyver433_RX<пин, буфер, CRC> rx;
+
 // пин: цифровой пин
-// буфер: размер приёмного буфера в байтах
+// буфер: размер буфера в байтах. По умолч. 64
 // CRC: проверка целостности данных: G433_CRC8 (надёжный), G433_XOR (лёгкий), G433_NOCRC (отключено). По умолч. G433_CRC8
-Gyver433_RX<2, 20> rx;  // указали пин и размер буфера
+
+Gyver433_RX<2, 20> rx;
 
 void setup() {
   Serial.begin(9600);
@@ -25,7 +25,7 @@ void loop() {
   // "тик" опрашивает радио и вернёт количество успешно принятых байт
   // tick принимает асинхронно, но может ловить ошибки при загруженном коде
   // tickWait блокирует выполнение, но принимает данные чётко
-  
+
   //if (rx.tick()) {
   if (rx.tickWait()) {
     // принятые данные доступны в .buffer
@@ -33,4 +33,4 @@ void loop() {
     Serial.write(rx.buffer, rx.size);
     Serial.println();
   }
-}
+}

examples/demo_tx/demo_tx.ino

@@ -1,21 +1,24 @@
+// демо-пример: инициализация и настройки
 // мелкий передатчик SYN115 [VCC: 1.8-3.6V, logic: VCC]
 // или FS1000A [VCC: 3-12V, logic: 5V]
 
-// "медленный режим" для синих модулей SYN115
+// дефайны перед подключением библиотеки
-// Объявляется перед подключением библиотеки
+//#define G433_FAST         // короткая синхронизация для зелёных модулей
-// зелёным модулям не нужен!
+//#define G433_MEDIUM       // средняя синхронизация для SYN480R при отправке ЧАЩЕ 400мс (активно по умолчанию)
-#define G433_SLOW_MODE
+//#define G433_SLOW         // длинная синхронизация для SYN480R при отправке РЕЖЕ 400мс
-
+//#define G433_MANCHESTER   // интерфейс Manchester Coding для экспериментов =)
-// можно указать скорость, по умолч. стоит 2000 бит/с
+//#define G433_SPEED 1000   // скорость 100-8000 бит/с, по умолч. 2000 бит/с
-// рабочий диапазон: 100-8000 бит/с
-//#define G433_SPEED 1000
 
 #include <Gyver433.h>
-// Gyver433_TX<пин, буфер, CRC>
+//Gyver433_TX<пин> tx;
+//Gyver433_TX<пин, буфер> tx;
+//Gyver433_TX<пин, буфер, CRC> tx;
+
 // пин: цифровой пин
 // буфер: размер буфера в байтах. На "ручную" отправку буфер не нужен. По умолч. 64
 // CRC: проверка целостности данных: G433_CRC8 (надёжный), G433_XOR (лёгкий), G433_NOCRC (отключено). По умолч. G433_CRC8
-Gyver433_TX<2, 20> tx;  // указали пин и размер буфера
+
+Gyver433_TX<2, 20> tx;
 
 void setup() {
 }
@@ -34,4 +37,4 @@ void loop() {
 
   // отправка 10 раз в сек
   delay(100);
-}
+}

examples/isr_rx/isr_rx.ino

@@ -1,5 +1,5 @@
 // приём в прерывании. Отправляет пример demo_tx
-#define G433_SLOW_MODE
+//#define G433_SPEED 1000   // скорость 100-8000 бит/с, по умолч. 2000 бит/с
 
 #include <Gyver433.h>
 Gyver433_RX<2, 20> rx;  // указали пин и размер буфера
@@ -11,18 +11,16 @@ void setup() {
 }
 
 void isr() {
-  rx.tick();  // тикер вызывается в прерывании
+  rx.tickISR();  // спец. тикер вызывается в прерывании по CHANGE
 }
 
 void loop() {
-  // .gotData() вернёт true при получении корректных данных
+  // .gotData() вернёт количество удачно принятых в прерывании байт  
-  // и сам сбросится до следующего приёма
+  if (rx.gotData()) {   // если больше 0
-  // внутри gotData() встроен тик!
-  if (rx.gotData()) {
     Serial.write(rx.buffer, rx.size);
     Serial.println();
   }
 
   // имитация загруженного кода
-  delay(200);
+  delay(100);
 }

examples/raw_rx/raw_rx.ino

@@ -1,6 +1,6 @@
 // обмен сырыми данными без CRC и буфера на отправку
+// отправляет пример raw_tx
 
-#define G433_SLOW_MODE
 #include <Gyver433.h>
 Gyver433_RX<2, 20, G433_NOCRC> rx;  // буфер на приём нужен!
 
@@ -13,4 +13,4 @@ void loop() {
     Serial.write(rx.buffer, rx.size);
     Serial.println();
   }
-}
+}

examples/raw_tx/raw_tx.ino

@@ -1,8 +1,10 @@
 // обмен сырыми данными без CRC и буфера на отправку
+// принимает пример raw_rx
+
+//#define G433_SPEED 1000   // скорость 100-8000 бит/с, по умолч. 2000 бит/с
 
-#define G433_SLOW_MODE
 #include <Gyver433.h>
-Gyver433_TX<2, 0, G433_NOCRC> tx;
+Gyver433_TX<2, 0, G433_NOCRC> tx; // буфер на отправку 0! Экономим
 
 void setup() {
 }

examples/rx433_lcd/rx433_lcd.ino

@@ -1,4 +1,5 @@
 // выводим данные на дисплей. Отправляет пример demo_tx
+//#define G433_SPEED 1000   // скорость 100-8000 бит/с, по умолч. 2000 бит/с
 
 #include <Gyver433.h>
 Gyver433_RX<2> rx;  // указали пин

examples/rx433_struct/rx433_struct.ino

@@ -1,6 +1,7 @@
 // приём структуры данных
 
-#define G433_SLOW_MODE
+//#define G433_SPEED 1000   // скорость 100-8000 бит/с, по умолч. 2000 бит/с
+
 #include <Gyver433.h>
 Gyver433_RX<2, 10> rx;  // указали пин и размер буфера
 

examples/tx433_struct/tx433_struct.ino

@@ -1,6 +1,8 @@
 // передача структуры данных
 
-#define G433_SLOW_MODE
+//#define G433_SPEED 1000   // скорость 100-8000 бит/с, по умолч. 2000 бит/с
+#define G433_SLOW // отправляю раз в секунду на SYN480R
+
 #include <Gyver433.h>
 Gyver433_TX<2, 10> tx;  // указали пин и размер буфера
 
@@ -25,7 +27,7 @@ void loop() {
 
   tx.sendData(data);
   
-  Serial.println("Transmit:");
+  Serial.println("Transmitted:");
   Serial.println(data.counter);
   Serial.println(data.randomNum);
   Serial.println(data.analog);

keywords.txt

@@ -13,8 +13,11 @@ Gyver433_RX	KEYWORD1
 # Methods and Functions (KEYWORD2)
 #######################################
 sendData	KEYWORD2
+sendDataSlow	KEYWORD2
 write	KEYWORD2
+writeSlow	KEYWORD2
 tick	KEYWORD2
+tickISR	KEYWORD2
 tickWait	KEYWORD2
 readData	KEYWORD2
 size	KEYWORD2
@@ -30,5 +33,8 @@ G433_crc_xor	KEYWORD2
 G433_CRC8	LITERAL1
 G433_XOR	LITERAL1
 G433_NOCRC	LITERAL1
+G433_FAST	LITERAL1
+G433_MEDIUM	LITERAL1
+G433_SLOW	LITERAL1
 G433_SPEED	LITERAL1
-G433_SLOW_MODE	LITERAL1
+G433_MANCHESTER	LITERAL1

library.properties

@@ -1,5 +1,5 @@
 name=Gyver433
-version=1.1
+version=1.2
 author=AlexGyver <alex@alexgyver.ru>
 maintainer=AlexGyver <alex@alexgyver.ru>
 sentence=Simple library for 433 MHz radio

src/Gyver433.h

@@ -3,10 +3,12 @@
     Документация: 
     GitHub: https://github.com/GyverLibs/Gyver433
     Возможности:
-    - Не использует прерывания и таймеры (кроме нулевого, читает micros())
+    - Супер лёгкая либа, заведётся даже на тини13 (отправка)
-    - Встроенный CRC контроль целостности
+    - Поддержка кривых китайских модулей
+    - Интерфейс Manchester или Pulselength
+    - Встроенный CRC контроль целостности (CRC8 или XOR)
     - Ускоренный алгоритм IO для AVR Arduino
-    - Работает с хорошими и плохими 433 МГц модулями
+    - Опционально работа в прерывании (приём данных)
     
     AlexGyver, alex@alexgyver.ru
     https://alexgyver.ru/
@@ -15,6 +17,7 @@
     Версии:
     v1.0 - релиз
     v1.1 - оптимизация, новый интерфейс, поддержка дешёвых синих модулей, работа в прерывании
+    v1.2 - улучшение качества связи, оптимизация работы в прерывании
 */
 
 #ifndef Gyver433_h
@@ -22,43 +25,33 @@
 #include <Arduino.h>
 #include "FastIO.h"
 
-// настройки из скетча:
-// #define G433_SLOW_MODE - включить "медленный режим" для плохих модулей
-// #define G433_SPEED n - скорость, бит/сек. Рекомендуется 2000. Работает вплоть до 6000
-
 uint8_t G433_crc8(uint8_t *buffer, uint8_t size);       // ручной CRC8
 uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size);    // ручной CRC XOR
 #define TRAINING_TIME_SLOW (500000ul)                   // время синхронизации для SLOW_MODE
 
 // =========================================================================
 #ifndef G433_SPEED
-#define G433_SPEED 3000     // скорость по умолчанию
+#define G433_SPEED 2000
 #endif
 
 // тайминги интерфейса
-#define FRAME_TIME (1000000ul / G433_SPEED)     // время фрейма
+#define FRAME_TIME (1000000ul / G433_SPEED) // время фрейма (либо HIGH)
-#define HALF_FRAME (FRAME_TIME / 2)             // полфрейма
+#define HALF_FRAME (FRAME_TIME / 2)         // полфрейма (либо LOW)
-#define START_PULSE (FRAME_TIME * 2)            // стартовый импульс
+#define START_PULSE (FRAME_TIME * 2)        // стартовый импульс
-#define TRAINING_AMOUNT_SLOW (TRAINING_TIME_SLOW / FRAME_TIME / 2)  // количество импульсов для SLOW_MODE
 
-// количество импульсов в зависимости от SLOW_MODE
+// окно времени для обработки импульса
-#ifdef G433_SLOW_MODE
-#define TRAINING_AMOUNT 40
-#else
-#define TRAINING_AMOUNT 10
-#endif
-
-// окно времени для обработки старта и фрейма
 #define START_MIN (START_PULSE * 3 / 4)
 #define START_MAX (START_PULSE * 5 / 4)
 #define FRAME_MIN (FRAME_TIME * 3 / 4)
 #define FRAME_MAX (FRAME_TIME * 5 / 4)
+#define HALF_FRAME_MIN (HALF_FRAME * 3 / 4)
+#define HALF_FRAME_MAX (HALF_FRAME * 5 / 4)
 
 // жоский delay для avr
 #ifdef AVR
-#define G433_DELAY(x) _delay_us(x)
+#define G433_DELAY _delay_us
 #else
-#define G433_DELAY(x) delayMicroseconds(x)
+#define G433_DELAY delayMicroseconds
 #endif
 
 // режимы CRC
@@ -66,6 +59,17 @@ uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size);    // ручной CRC XOR
 #define G433_XOR 1
 #define G433_NOCRC 2
 
+// количество синхроимпульсов
+#if defined(G433_FAST)
+#define TRAINING_PULSES 10
+#elif defined(G433_MEDIUM)
+#define TRAINING_PULSES 50
+#elif defined(G433_SLOW)
+#define TRAINING_PULSES (TRAINING_TIME_SLOW / FRAME_TIME / 2)
+#else
+#define TRAINING_PULSES 50
+#endif
+
 // crc8 один байт
 void G433_crc8_byte(uint8_t &crc, uint8_t data);
 
@@ -95,19 +99,17 @@ public:
     
     // отправка сырого набора байтов
     void write(uint8_t* buf, uint16_t size) {
-        #ifdef G433_SLOW_MODE
+        for (uint16_t i = 0; i < TRAINING_PULSES; i++) {
-        for (uint16_t i = 0; i < ((millis() - tmr > 400) ? TRAINING_AMOUNT_SLOW : TRAINING_AMOUNT); i++) {
-        #else
-        for (uint16_t i = 0; i < TRAINING_AMOUNT; i++) {
-        #endif        
             fastWrite(TX_PIN, 1);
             G433_DELAY(FRAME_TIME);
             fastWrite(TX_PIN, 0);
             G433_DELAY(FRAME_TIME);
         }
-        fastWrite(TX_PIN, 1);         // старт
+        fastWrite(TX_PIN, 1);       // старт
-        G433_DELAY(START_PULSE);      // ждём
+        G433_DELAY(START_PULSE);    // ждём
-        fastWrite(TX_PIN, 0);         // старт бит
+        fastWrite(TX_PIN, 0);       // старт бит
+        
+        #ifdef G433_MANCHESTER
         G433_DELAY(HALF_FRAME);       // ждём
         for (uint16_t n = 0; n < size; n++) {
             uint8_t data = buf[n];
@@ -120,165 +122,192 @@ public:
             }
         }
         fastWrite(TX_PIN, 0);   // конец передачи
-        #ifdef G433_SLOW_MODE
+        #else
-        tmr = millis();
+        bool flag = 0;
-        #endif
+        for (uint16_t n = 0; n < size; n++) {
-        }
+            uint8_t data = buf[n];
-        
+            for (uint8_t b = 0; b < 8; b++) {
-        // доступ к буферу
+                if (data & 1) G433_DELAY(FRAME_TIME);
-        uint8_t buffer[TX_BUF];
+                else G433_DELAY(HALF_FRAME);
-        
+                fastWrite(TX_PIN, flag = !flag);
-    private:    
+                data >>= 1;
-        #ifdef G433_SLOW_MODE
-        uint32_t tmr = 0;
-        #endif
-    };
-
-    // ============ ПРИЁМНИК ============
-    template <uint8_t RX_PIN, uint16_t RX_BUF = 64, uint8_t CRC_MODE = G433_CRC8>
-    class Gyver433_RX {
-    public:
-        Gyver433_RX() {
-            pinMode(RX_PIN, INPUT);
-        }
-        
-        // неблокирующий приём, вернёт кол-во успешно принятых байт
-        uint8_t tick() {
-            uint32_t thisPulse = micros() - tmr;                // время импульса
-            if (parse == 2 && thisPulse >= FRAME_TIME * 2) {    // фрейм не закрыт
-                parse = size = 0;                               // приём окончен   
-                if (byteCount > 1) {                            // если что то приняли
-                    if (CRC_MODE == G433_CRC8) {                // CRC8 
-                        if (!G433_crc8(buffer, byteCount)) {
-                            size = byteCount - 2;
-                            dataReady = 1;
-                        }
-                    } else if (CRC_MODE == G433_XOR) {          // CRC XOR
-                        if (!G433_crc_xor(buffer, byteCount)) {
-                            size = byteCount - 2;
-                            dataReady = 1;
-                        }
-                    } else {                                    // без CRC
-                        size = byteCount - 1;
-                        dataReady = 1;
-                    }
-                }
-                return size;
             }
-            bool bit = fastRead(RX_PIN);                        // читаем пин
+        }
-            if (bit != prevBit) {  		                        // ловим изменение сигнала
+        #endif        
-                if (parse == 1) {   			                // в прошлый раз поймали фронт
+    }
-                    tmr += thisPulse;                           // сброс таймера
+    
-                    if (thisPulse > START_MIN && thisPulse < START_MAX) {   // старт бит?
+    // доступ к буферу
-                        parse = 2;                                          // ключ на старт
+    uint8_t buffer[TX_BUF];
-                        byteCount = bitCount = size = 0;                    // сброс
+    
-                        dataReady = 0;
+private:    
-                        for (uint8_t i = 0; i < RX_BUF; i++) buffer[i] = 0; // чистим буфер
+};
-                    } else parse = 0;									    // не старт бит
-                } else if (parse == 2) {		                            // идёт парсинг                
-                    if (thisPulse > FRAME_MIN && thisPulse < FRAME_MAX) {   // фронт внутри таймфрейма
-                        tmr += thisPulse;                                   // синхронизируем тайминги
-                        buffer[byteCount] >>= 1;                            // двигаем байт
-                        if (bit && !prevBit) buffer[byteCount] |= _BV(7);   // пишем единичку
-                        bitCount++;                                         // счётчик битов
-                    }
-                    if (bitCount == 8) {                        // собрали байт
-                        bitCount = 0;                           // сброс
-                        if (++byteCount >= RX_BUF) parse = 0;   // буфер переполнен
-                    }
-                }
 
-                if (bit && !prevBit && parse == 0) {            // ловим фронт
+// ============ ПРИЁМНИК ============
-                    parse = 1;									// флаг на старт
+template <uint8_t RX_PIN, uint16_t RX_BUF = 64, uint8_t CRC_MODE = G433_CRC8>
-                    tmr += thisPulse;                           // сброс таймера
+class Gyver433_RX {
-                }
+public:
-                prevBit = bit;
+    Gyver433_RX() {
+        pinMode(RX_PIN, INPUT);
+    }
+    
+    // неблокирующий приём, вернёт кол-во успешно принятых байт
+    uint16_t tick() {            
+        if (pinChanged()) checkState();       
+        return gotData();
+    }
+    
+    // tick для вызова в прерывании по CHANGE
+    void tickISR() {
+        #ifdef G433_MANCHESTER
+        if (pinChanged()) checkState();        
+        #else
+        checkState();
+        #endif
+    }
+    
+    // блокирующий приём, вернёт кол-во успешно принятых байт
+    uint16_t tickWait() {
+        do {
+            if (tick()) return size;
+        } while (parse == 2);
+        return 0;
+    }
+    
+    // прочитает буфер в любой тип данных
+    template <typename T>
+    bool readData(T &data) {
+        if (sizeof(T) > RX_BUF) return false;		
+        uint8_t *ptr = (uint8_t*) &data;	
+        for (uint16_t i = 0; i < sizeof(T); i++) *ptr++ = buffer[i];
+        return true;
+    }
+    
+    // вернёт true при получении корректных данных
+    uint16_t gotData() {
+        if (parse == 2 && millis() - tmr2 >= 10) {              // фрейм не закрыт
+            parse = size = 0;                                   // приём окончен   
+            if (byteCount > 1) {                                // если что то приняли
+                if (CRC_MODE == G433_CRC8) {                    // CRC8 
+                    if (!G433_crc8(buffer, byteCount)) size = byteCount - 2;
+                } else if (CRC_MODE == G433_XOR) {              // CRC XOR
+                    if (!G433_crc_xor(buffer, byteCount)) size = byteCount - 2;
+                } else size = byteCount - 1;                    // без CRC
             }
-            return 0;
-        }
-        
-        // блокирующий приём, вернёт кол-во успешно принятых байт
-        uint8_t tickWait() {
-            do {
-                if (tick()) return size;
-            } while (parse == 2);
-            return 0;
-        }
-        
-        // прочитает буфер в любой тип данных
-        template <typename T>
-        bool readData(T &data) {
-            if (sizeof(T) > RX_BUF) return false;		
-            uint8_t *ptr = (uint8_t*) &data;	
-            for (uint16_t i = 0; i < sizeof(T); i++) *ptr++ = buffer[i];
-            return true;
-        }
-        
-        // вернёт true при получении корректных данных
-        bool gotData() {
-            tick();
-            if (dataReady) {
-                dataReady = 0;
-                return 1;
-            } return 0;
-        }
-        
-        // получить размер принятых данных
-        int getSize() {
             return size;
         }
-        
+        return 0;
-        // размер принятых данных
+    }
-        int size = 0;
+    
-        
+    // получить размер принятых данных
-        // доступ к буферу
+    uint16_t getSize() {
-        uint8_t buffer[RX_BUF];
+        return size;
-        
+    }
-    private:    
+    
-        bool prevBit, dataReady = 0;
+    // размер принятых данных
-        uint8_t parse = 0;
+    uint16_t size = 0;
-        uint32_t tmr = 0;
+    
-        uint8_t bitCount = 0, byteCount = 0;
+    // доступ к буферу
-    };
+    uint8_t buffer[RX_BUF];
+    
+private:
+    bool pinChanged() {
+        bit = fastRead(RX_PIN);
+        if (bit != prevBit) {
+            prevBit = bit;
+            return 1;
+        } return 0;
+    }
 
-    // ===== CRC =====
+    void checkState() {
-    void G433_crc8_byte(uint8_t &crc, uint8_t data) {
+        uint32_t thisPulse = micros() - tmr;            // время импульса
-#if defined (__AVR__)
+        if (parse == 1) {   			                // в прошлый раз поймали фронт
-        // резкий алгоритм для AVR
+            #ifdef G433_MANCHESTER
-        uint8_t counter;
+            tmr += thisPulse;                           // сброс таймера приёма
-        uint8_t buffer;
+            #endif
-        asm volatile (
+            if (thisPulse > START_MIN && thisPulse < START_MAX) {   // старт бит?
-        "EOR %[crc_out], %[data_in] \n\t"
+                tmr2 = millis();                                    // сброс таймера активности
-        "LDI %[counter], 8          \n\t"
+                parse = 2;                                          // ключ на старт
-        "LDI %[buffer], 0x8C        \n\t"
+                byteCount = bitCount = size = 0;                    // сброс
-        "_loop_start_%=:            \n\t"
+            } else parse = 0;									    // не старт бит
-        "LSR %[crc_out]             \n\t"
+        } else if (parse == 2) {		                            // идёт парсинг            
-        "BRCC _loop_end_%=          \n\t"
+            #ifdef G433_MANCHESTER
-        "EOR %[crc_out], %[buffer]  \n\t"
+            if (thisPulse > FRAME_MIN && thisPulse < FRAME_MAX) {   // фронт внутри таймфрейма
-        "_loop_end_%=:              \n\t"
+                tmr += thisPulse;                                   // синхронизируем тайминги
-        "DEC %[counter]             \n\t"
+                tmr2 = millis();                                    // сброс таймера активности
-        "BRNE _loop_start_%="
+                buffer[byteCount] >>= 1;                            // двигаем байт
-        : [crc_out]"=r" (crc), [counter]"=d" (counter), [buffer]"=d" (buffer)
+                buffer[byteCount] |= (bit << 7);                    // пишем данные
-        : [crc_in]"0" (crc), [data_in]"r" (data)
+                bitCount++;                                         // счётчик битов                
-        );
+            }
-#else
+            #else
-        // обычный для всех остальных
+            uint8_t state = 2;
-        uint8_t i = 8;
+            if (thisPulse > HALF_FRAME_MIN && thisPulse < HALF_FRAME_MAX) state = 0; // low бит
-        while (i--) {
+            else if (thisPulse > FRAME_MIN && thisPulse < FRAME_MAX) state = 1;      // high бит
-            crc = ((crc ^ data) & 1) ? (crc >> 1) ^ 0x8C : (crc >> 1);
+            if (state != 2) {                
-            data >>= 1;
+                buffer[byteCount] >>= 1;                            // двигаем байт
+                buffer[byteCount] |= (state << 7);                  // пишем данные
+                bitCount++;                                         // счётчик битов
+                tmr2 = millis();                                    // сброс таймера активности
+            }
+            #endif
+            if (bitCount == 8) {                        // собрали байт
+                bitCount = 0;                           // сброс
+                if (++byteCount >= RX_BUF) parse = 0;   // буфер переполнен                
+            }            
         }
-#endif
+        #ifdef G433_MANCHESTER
+        if (bit && parse == 0) {                        // ловим фронт
+            parse = 1;									// флаг на старт
+            tmr += thisPulse;                           // сброс таймера
+        }        
+        #else
+        if (parse == 0) parse = 1;                      // принудительно стартуем
+        tmr += thisPulse;                               // сброс таймера приёма
+        #endif
     }
+    bool bit, prevBit;
+    uint8_t parse = 0;
+    uint32_t tmr = 0, tmr2 = 0;
+    uint8_t bitCount = 0, byteCount = 0;
+};
 
-    uint8_t G433_crc8(uint8_t *buffer, uint8_t size) {
+// ===== CRC =====
-        uint8_t crc = 0;
+void G433_crc8_byte(uint8_t &crc, uint8_t data) {
-        for (uint8_t i = 0; i < size; i++) G433_crc8_byte(crc, buffer[i]);
+#if defined (__AVR__)
-        return crc;
+    // резкий алгоритм для AVR
-    }
+    uint8_t counter;
-    uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size) {
+    uint8_t buffer;
-        uint8_t crc = 0;
+    asm volatile (
-        for (uint8_t i = 0; i < size; i++) crc ^= buffer[i];
+    "EOR %[crc_out], %[data_in] \n\t"
-        return crc;
+    "LDI %[counter], 8          \n\t"
+    "LDI %[buffer], 0x8C        \n\t"
+    "_loop_start_%=:            \n\t"
+    "LSR %[crc_out]             \n\t"
+    "BRCC _loop_end_%=          \n\t"
+    "EOR %[crc_out], %[buffer]  \n\t"
+    "_loop_end_%=:              \n\t"
+    "DEC %[counter]             \n\t"
+    "BRNE _loop_start_%="
+    : [crc_out]"=r" (crc), [counter]"=d" (counter), [buffer]"=d" (buffer)
+    : [crc_in]"0" (crc), [data_in]"r" (data)
+    );
+#else
+    // обычный для всех остальных
+    uint8_t i = 8;
+    while (i--) {
+        crc = ((crc ^ data) & 1) ? (crc >> 1) ^ 0x8C : (crc >> 1);
+        data >>= 1;
     }
+#endif
+}
+
+uint8_t G433_crc8(uint8_t *buffer, uint8_t size) {
+    uint8_t crc = 0;
+    for (uint8_t i = 0; i < size; i++) G433_crc8_byte(crc, buffer[i]);
+    return crc;
+}
+uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size) {
+    uint8_t crc = 0;
+    for (uint8_t i = 0; i < size; i++) crc ^= buffer[i];
+    return crc;
+}
 #endif