v1.4

README.md

@@ -56,6 +56,7 @@ Gyver433_xx<пин, буфер, CRC> xx;
 #define G433_SLOW           // [TX] длинная синхронизация при отправке на SYN480R РЕЖЕ 400мс
 #define G433_MANCHESTER     // [должно быть одинаково на RX и TX] интерфейс Manchester Coding для экспериментов =) 
 #define G433_SPEED 1000     // [должно быть одинаково на RX и TX] скорость 100-8000 бит/с, по умолч. 2000 бит/с 
+#define G433_RSSI_COUNT 10  // [RX] количество успешно принятых пакетов для расчёта RSSI (по умолч. 10)
 ```
 
 <a id="usage"></a>
@@ -74,6 +75,7 @@ bool readData(T &data);     // прочитает буфер в любой ти
 uint16_t getSize();         // получить размер принятых данных
 uint16_t gotData();         // вернёт количество успешно принятых в tickISR() байт (см. пример isr_rx)
 uint8_t buffer[];           // доступ к буферу для отладки
+uint8_t getRSSI();          // получить качество приёма (процент успешных передач)
 
 // ============= CRC =============
 // можно использовать встроенные функции для генерации байта CRC для ручной упаковки пакетов
@@ -84,7 +86,7 @@ uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size);    // ручной CRC XOR
 <a id="example"></a>
 ## Примеры
 Остальные примеры смотри в **examples**!
-![Logo](/doc/scheme.jpg)
+![scheme](/doc/scheme.jpg)
 ### Отправка
 ```cpp
 #include <Gyver433.h>
@@ -151,6 +153,8 @@ void loop() {
 - v1.0
 - v1.1 - оптимизация, новый интерфейс, поддержка дешёвых синих модулей, работа в прерывании
 - v1.2 - улучшение качества связи, оптимизация работы в прерывании
+- v1.3 - добавлен вывод RSSI
+- v1.4 - переделан FastIO
 
 <a id="feedback"></a>
 ## Баги и обратная связь

examples/demo_rx/demo_rx.ino

@@ -31,6 +31,9 @@ void loop() {
     // принятые данные доступны в .buffer
     // и имеют размер .size
     Serial.write(rx.buffer, rx.size);
-    Serial.println();
+
+    // выведем также качество связи
+    Serial.print(", RSSI: ");
+    Serial.println(rx.getRSSI());
   }
 }

examples/raw_tx/raw_tx.ino

@@ -19,7 +19,7 @@ void loop() {
   if (++count >= 100) count = 0;
 
   // отправка данных типа byte*
-  tx.write(data, sizeof(data));
+  tx.write((byte*)data, sizeof(data));
 
   // отправка 10 раз в сек
   delay(100);

keywords.txt

@@ -26,6 +26,7 @@ getSize	KEYWORD2
 gotData	KEYWORD2
 G433_crc8	KEYWORD2
 G433_crc_xor	KEYWORD2
+getRSSI	KEYWORD2
 
 #######################################
 # Constants (LITERAL1)

library.properties

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

src/FastIO_v2.cpp

@@ -1,17 +1,6 @@
-// Быстрый IO для AVR (для остальных будет digitalxxxxx)
-// v1.0
+#include "FastIO_v2.h"
 
-#ifndef FastIO_h
-#define FastIO_h
-#include <Arduino.h>
-
-bool fastRead(const uint8_t pin);				// быстрое чтение пина
-void fastWrite(const uint8_t pin, bool val);	// быстрая запись
-uint8_t fastShiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder); 				// быстрый shiftIn
-void fastShiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t data);	// быстрый shiftOut
-
-// ================================================================
-bool fastRead(const uint8_t pin) {
+bool F_fastRead(const uint8_t pin) {
 #if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)
     if (pin < 8) return bitRead(PIND, pin);
     else if (pin < 14) return bitRead(PINB, pin - 8);
@@ -32,8 +21,7 @@ bool fastRead(const uint8_t pin) {
     return 0;
 }
 
-
-void fastWrite(const uint8_t pin, bool val) {
+void F_fastWrite(const uint8_t pin, bool val) {
 #if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)
     if (pin < 8) bitWrite(PORTD, pin, val);
     else if (pin < 14) bitWrite(PORTB, (pin - 8), val);
@@ -56,8 +44,7 @@ void fastWrite(const uint8_t pin, bool val) {
 #endif
 }
 
-
-uint8_t fastShiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder) {
+uint8_t F_fastShiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder) {
 #if defined(AVR)
     volatile uint8_t *_clk_port = portOutputRegister(digitalPinToPort(clockPin));
     volatile uint8_t *_dat_port = portInputRegister(digitalPinToPort(dataPin));
@@ -81,8 +68,7 @@ uint8_t fastShiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder) {
 #endif
 }
 
-
-void fastShiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t data) {
+void F_fastShiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t data) {
 #if defined(AVR)
     volatile uint8_t *_clk_port = portOutputRegister(digitalPinToPort(clockPin));
     volatile uint8_t *_dat_port = portOutputRegister(digitalPinToPort(dataPin));
@@ -105,5 +91,3 @@ void fastShiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t d
     shiftOut(dataPin, clockPin, bitOrder, data);
 #endif
 }
-
-#endif

src/FastIO_v2.h

@@ -0,0 +1,13 @@
+// Быстрый IO для AVR (для остальных будет digitalxxxxx)
+// v1.0
+
+#ifndef _FastIO_v2_h
+#define _FastIO_v2_h
+#include <Arduino.h>
+
+bool F_fastRead(const uint8_t pin);				// быстрое чтение пина
+void F_fastWrite(const uint8_t pin, bool val);	// быстрая запись
+uint8_t F_fastShiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder); 				// быстрый shiftIn
+void F_fastShiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t data);	// быстрый shiftOut
+
+#endif

src/Gyver433.h

@@ -18,12 +18,14 @@
     v1.0 - релиз
     v1.1 - оптимизация, новый интерфейс, поддержка дешёвых синих модулей, работа в прерывании
     v1.2 - улучшение качества связи, оптимизация работы в прерывании
+    v1.3 - добавлен вывод RSSI
+    v1.4 - переделан FastIO
 */
 
 #ifndef Gyver433_h
 #define Gyver433_h
 #include <Arduino.h>
-#include "FastIO.h"
+#include "FastIO_v2.h"
 
 uint8_t G433_crc8(uint8_t *buffer, uint8_t size);       // ручной CRC8
 uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size);    // ручной CRC XOR
@@ -34,6 +36,10 @@ uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size);    // ручной CRC XOR
 #define G433_SPEED 2000
 #endif
 
+#ifndef G433_RSSI_COUNT
+#define G433_RSSI_COUNT 10
+#endif
+
 // тайминги интерфейса
 #define FRAME_TIME (1000000ul / G433_SPEED) // время фрейма (либо HIGH)
 #define HALF_FRAME (FRAME_TIME / 2)         // полфрейма (либо LOW)
@@ -55,9 +61,9 @@ uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size);    // ручной CRC XOR
 #endif
 
 // режимы CRC
-#define G433_CRC8 0
-#define G433_XOR 1
-#define G433_NOCRC 2
+#define G433_NOCRC 0
+#define G433_CRC8 1
+#define G433_XOR 2
 
 // количество синхроимпульсов
 #if defined(G433_FAST)
@@ -83,7 +89,8 @@ public:
     
     // отправка, блокирующая. Кушает любой тип данных
     template <typename T>
-    void sendData(T &data) {
+    bool sendData(T &data) {
+        if (sizeof(T) > TX_BUF) return 0;
         const uint8_t *ptr = (const uint8_t*) &data;
         for (uint16_t i = 0; i < sizeof(T); i++) buffer[i] = *ptr++;
         if (CRC_MODE == G433_CRC8) {
@@ -95,33 +102,34 @@ public:
         } else {
             write(buffer, sizeof(T));
         }
+        return 1;
     }
     
     // отправка сырого набора байтов
     void write(uint8_t* buf, uint16_t size) {
         for (uint16_t i = 0; i < TRAINING_PULSES; i++) {
-            fastWrite(TX_PIN, 1);
+            F_fastWrite(TX_PIN, 1);
             G433_DELAY(FRAME_TIME);
-            fastWrite(TX_PIN, 0);
+            F_fastWrite(TX_PIN, 0);
             G433_DELAY(FRAME_TIME);
         }
-        fastWrite(TX_PIN, 1);       // старт
+        F_fastWrite(TX_PIN, 1);       // старт
         G433_DELAY(START_PULSE);    // ждём
-        fastWrite(TX_PIN, 0);       // старт бит
+        F_fastWrite(TX_PIN, 0);       // старт бит
         
         #ifdef G433_MANCHESTER
         G433_DELAY(HALF_FRAME);       // ждём
         for (uint16_t n = 0; n < size; n++) {
             uint8_t data = buf[n];
             for (uint8_t b = 0; b < 8; b++) {
-                fastWrite(TX_PIN, !(data & 1));
+                F_fastWrite(TX_PIN, !(data & 1));
                 G433_DELAY(HALF_FRAME);
-                fastWrite(TX_PIN, (data & 1));                
+                F_fastWrite(TX_PIN, (data & 1));                
                 G433_DELAY(HALF_FRAME);
                 data >>= 1;
             }
         }
-        fastWrite(TX_PIN, 0);   // конец передачи
+        F_fastWrite(TX_PIN, 0);   // конец передачи
         #else
         bool flag = 0;
         for (uint16_t n = 0; n < size; n++) {
@@ -129,7 +137,7 @@ public:
             for (uint8_t b = 0; b < 8; b++) {
                 if (data & 1) G433_DELAY(FRAME_TIME);
                 else G433_DELAY(HALF_FRAME);
-                fastWrite(TX_PIN, flag = !flag);
+                F_fastWrite(TX_PIN, flag = !flag);
                 data >>= 1;
             }
         }
@@ -137,7 +145,7 @@ public:
     }
     
     // доступ к буферу
-    uint8_t buffer[TX_BUF];
+    uint8_t buffer[TX_BUF + !!CRC_MODE];
     
 private:    
 };
@@ -186,18 +194,31 @@ public:
     uint16_t gotData() {
         if (parse == 2 && millis() - tmr2 >= 10) {              // фрейм не закрыт
             parse = size = 0;                                   // приём окончен   
-            if (byteCount > 1) {                                // если что то приняли
+            if (byteCount > (1 + !!CRC_MODE)) {                 // если что то приняли
+                if (!bitCount) {                                // байт закрыт
                     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
                 }
+                // расчёт RSSI
+                if (!size) errCount++;
+                if (++rcCount >= G433_RSSI_COUNT) {
+                    RSSI = 100 - errCount * 100 / G433_RSSI_COUNT;
+                    errCount = rcCount = 0;
+                }
+            }
             return size;
         }
         return 0;
     }
     
+    // получить качество приёма (процент успешных передач)
+    uint8_t getRSSI() {
+        return RSSI;
+    }
+    
     // получить размер принятых данных
     uint16_t getSize() {
         return size;
@@ -207,11 +228,11 @@ public:
     uint16_t size = 0;
     
     // доступ к буферу
-    uint8_t buffer[RX_BUF];
+    uint8_t buffer[RX_BUF + !!CRC_MODE];
     
 private:
     bool pinChanged() {
-        bit = fastRead(RX_PIN);
+        bit = F_fastRead(RX_PIN);
         if (bit != prevBit) {
             prevBit = bit;
             return 1;
@@ -268,6 +289,7 @@ private:
     uint8_t parse = 0;
     uint32_t tmr = 0, tmr2 = 0;
     uint8_t bitCount = 0, byteCount = 0;
+    uint8_t errCount = 0, rcCount = 0, RSSI = 0;
 };
 
 // ===== CRC =====