fedor/Gyver433
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v1.2

Browse Source
This commit is contained in:
Alex
2021-06-17 12:49:46 +03:00
parent bd9e4b19ae
commit 48e1fa1e98
12 changed files with 297 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+23 -18
View File
@@ -4,7 +4,7 @@
Библиотека для радиомодулей 433 МГц и Arduino Библиотека для радиомодулей 433 МГц и Arduino
- Супер лёгкая либа, заведётся даже на тини13 (отправка) - Супер лёгкая либа, заведётся даже на тини13 (отправка)
- Поддержка кривых китайских модулей - Поддержка кривых китайских модулей
- Интерфейс Manchester Coding (v1.1) - Интерфейс Manchester или Pulselength
- Встроенный CRC контроль целостности (CRC8 или XOR) - Встроенный CRC контроль целостности (CRC8 или XOR)
- Ускоренный алгоритм IO для AVR Arduino - Ускоренный алгоритм IO для AVR Arduino
- Опционально работа в прерывании (приём данных) - Опционально работа в прерывании (приём данных)
@@ -36,18 +36,26 @@
<a id="init"></a> <a id="init"></a>
## Инициализация ## Инициализация
```cpp ```cpp
//Классы: // === КЛАССЫ ===
Gyver433_RX // приёмник // Gyver433_RX - приёмник
Gyver433_TX // передатчик // Gyver433_TX - передатчик
// === ИНИЦИАЛИЗАЦИЯ ===
Gyver433_xx<пин> xx;
Gyver433_xx<пин, буфер> xx;
Gyver433_xx<пин, буфер, CRC> xx; Gyver433_xx<пин, буфер, CRC> xx;
// пин: цифровой пин // пин: цифровой пин
// буфер: размер буфера в байтах. На "ручную" отправку буфер не нужен (пример raw_tx). По умолч. 64 байта // буфер: размер буфера в байтах. На "ручную" отправку буфер не нужен. По умолч. 64
// CRC: проверка целостности данных: G433_CRC8 (надёжный), G433_XOR (лёгкий), G433_NOCRC (отключено). По умолч. G433_CRC8 // 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> <a id="usage"></a>
@@ -79,7 +87,6 @@ uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size); // ручной CRC XOR
![Logo](/doc/scheme.jpg) ![Logo](/doc/scheme.jpg)
### Отправка ### Отправка
```cpp ```cpp
#define G433_SLOW_MODE
#include <Gyver433.h> #include <Gyver433.h>
Gyver433_TX<2, 20> tx; // указали пин и размер буфера Gyver433_TX<2, 20> tx; // указали пин и размер буфера
@@ -101,7 +108,6 @@ void loop() {
### Приём ### Приём
```cpp ```cpp
#define G433_SLOW_MODE
#include <Gyver433.h> #include <Gyver433.h>
Gyver433_RX<2, 20> rx; // указали пин и размер буфера Gyver433_RX<2, 20> rx; // указали пин и размер буфера
@@ -110,8 +116,8 @@ void setup() {
} }
void loop() { void loop() {
if (rx.tickWait()) { if (rx.tickWait()) { // если успешно принято больше 0
Serial.write(rx.buffer, rx.size); Serial.write(rx.buffer, rx.size); // выводим
Serial.println(); Serial.println();
} }
} }
@@ -119,7 +125,6 @@ void loop() {
### Приём в прерывании ### Приём в прерывании
```cpp ```cpp
#define G433_SLOW_MODE
#include <Gyver433.h> #include <Gyver433.h>
Gyver433_RX<2, 20> rx; // указали пин и размер буфера Gyver433_RX<2, 20> rx; // указали пин и размер буфера
@@ -129,16 +134,15 @@ void setup() {
} }
void isr() { void isr() {
rx.tickISR(); // спец тикер вызывается в прерывании rx.tickISR(); // спец. тикер вызывается в прерывании
} }
void loop() { void loop() {
// вернёт количество удачно принятых в прерывании байт if (rx.gotData()) { // если успешно принято больше 0
if (rx.gotData()) { Serial.write(rx.buffer, rx.size); // выводим
Serial.write(rx.buffer, rx.size);
Serial.println(); Serial.println();
} }
delay(200); // имитация загруженного кода delay(200); // имитация загруженного кода
} }
``` ```
@@ -146,6 +150,7 @@ void loop() {
## Версии ## Версии
- v1.0 - v1.0
- v1.1 - оптимизация, новый интерфейс, поддержка дешёвых синих модулей, работа в прерывании - v1.1 - оптимизация, новый интерфейс, поддержка дешёвых синих модулей, работа в прерывании
- v1.2 - улучшение качества связи, оптимизация работы в прерывании
<a id="feedback"></a> <a id="feedback"></a>
## Баги и обратная связь ## Баги и обратная связь
examples/demo_rx/demo_rx.ino
+13 -13
View File
@@ -1,21 +1,21 @@
// демо-пример: инициализация и настройки
// крупный приёмник SYN480R [VCC: 3.3-5.5V, logic: VCC] // крупный приёмник SYN480R [VCC: 3.3-5.5V, logic: VCC]
// или MX-RM-5V (RF-5V) [VCC: 5V, logic: 5V] // или 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> #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 // CRC: проверка целостности данных: G433_CRC8 (надёжный), G433_XOR (лёгкий), G433_NOCRC (отключено). По умолч. G433_CRC8
Gyver433_RX<2, 20> rx; // указали пин и размер буфера
Gyver433_RX<2, 20> rx;
void setup() { void setup() {
Serial.begin(9600); Serial.begin(9600);
@@ -25,7 +25,7 @@ void loop() {
// "тик" опрашивает радио и вернёт количество успешно принятых байт // "тик" опрашивает радио и вернёт количество успешно принятых байт
// tick принимает асинхронно, но может ловить ошибки при загруженном коде // tick принимает асинхронно, но может ловить ошибки при загруженном коде
// tickWait блокирует выполнение, но принимает данные чётко // tickWait блокирует выполнение, но принимает данные чётко
//if (rx.tick()) { //if (rx.tick()) {
if (rx.tickWait()) { if (rx.tickWait()) {
// принятые данные доступны в .buffer // принятые данные доступны в .buffer
@@ -33,4 +33,4 @@ void loop() {
Serial.write(rx.buffer, rx.size); Serial.write(rx.buffer, rx.size);
Serial.println(); Serial.println();
} }
} }
examples/demo_tx/demo_tx.ino
+14 -11
View File
@@ -1,21 +1,24 @@
// демо-пример: инициализация и настройки
// мелкий передатчик SYN115 [VCC: 1.8-3.6V, logic: VCC] // мелкий передатчик SYN115 [VCC: 1.8-3.6V, logic: VCC]
// или FS1000A [VCC: 3-12V, logic: 5V] // или 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> #include <Gyver433.h>
// Gyver433_TX<пин, буфер, CRC> //Gyver433_TX<пин> tx;
//Gyver433_TX<пин, буфер> tx;
//Gyver433_TX<пин, буфер, CRC> tx;
// пин: цифровой пин // пин: цифровой пин
// буфер: размер буфера в байтах. На "ручную" отправку буфер не нужен. По умолч. 64 // буфер: размер буфера в байтах. На "ручную" отправку буфер не нужен. По умолч. 64
// CRC: проверка целостности данных: G433_CRC8 (надёжный), G433_XOR (лёгкий), G433_NOCRC (отключено). По умолч. G433_CRC8 // CRC: проверка целостности данных: G433_CRC8 (надёжный), G433_XOR (лёгкий), G433_NOCRC (отключено). По умолч. G433_CRC8
Gyver433_TX<2, 20> tx; // указали пин и размер буфера
Gyver433_TX<2, 20> tx;
void setup() { void setup() {
} }
@@ -34,4 +37,4 @@ void loop() {
// отправка 10 раз в сек // отправка 10 раз в сек
delay(100); delay(100);
} }
examples/isr_rx/isr_rx.ino
+4 -4
View File
@@ -1,5 +1,5 @@
// приём в прерывании. Отправляет пример demo_tx // приём в прерывании. Отправляет пример demo_tx
#define G433_SLOW_MODE //#define G433_SPEED 1000 // скорость 100-8000 бит/с, по умолч. 2000 бит/с
#include <Gyver433.h> #include <Gyver433.h>
Gyver433_RX<2, 20> rx; // указали пин и размер буфера Gyver433_RX<2, 20> rx; // указали пин и размер буфера
@@ -11,16 +11,16 @@ void setup() {
} }
void isr() { void isr() {
rx.tickISR(); // спец тикер вызывается в прерывании по CHANGE rx.tickISR(); // спец. тикер вызывается в прерывании по CHANGE
} }
void loop() { void loop() {
// .gotData() вернёт количество удачно принятых в прерывании байт // .gotData() вернёт количество удачно принятых в прерывании байт
if (rx.gotData()) { if (rx.gotData()) { // если больше 0
Serial.write(rx.buffer, rx.size); Serial.write(rx.buffer, rx.size);
Serial.println(); Serial.println();
} }
// имитация загруженного кода // имитация загруженного кода
delay(200); delay(100);
} }
examples/raw_rx/raw_rx.ino
+2 -2
View File
@@ -1,6 +1,6 @@
// обмен сырыми данными без CRC и буфера на отправку // обмен сырыми данными без CRC и буфера на отправку
// отправляет пример raw_tx
#define G433_SLOW_MODE
#include <Gyver433.h> #include <Gyver433.h>
Gyver433_RX<2, 20, G433_NOCRC> rx; // буфер на приём нужен! Gyver433_RX<2, 20, G433_NOCRC> rx; // буфер на приём нужен!
@@ -13,4 +13,4 @@ void loop() {
Serial.write(rx.buffer, rx.size); Serial.write(rx.buffer, rx.size);
Serial.println(); Serial.println();
} }
} }
examples/raw_tx/raw_tx.ino
+4 -2
View File
@@ -1,8 +1,10 @@
// обмен сырыми данными без CRC и буфера на отправку // обмен сырыми данными без CRC и буфера на отправку
// принимает пример raw_rx
//#define G433_SPEED 1000 // скорость 100-8000 бит/с, по умолч. 2000 бит/с
#define G433_SLOW_MODE
#include <Gyver433.h> #include <Gyver433.h>
Gyver433_TX<2, 0, G433_NOCRC> tx; Gyver433_TX<2, 0, G433_NOCRC> tx; // буфер на отправку 0! Экономим
void setup() { void setup() {
} }
examples/rx433_lcd/rx433_lcd.ino
+1
View File
@@ -1,4 +1,5 @@
// выводим данные на дисплей. Отправляет пример demo_tx // выводим данные на дисплей. Отправляет пример demo_tx
//#define G433_SPEED 1000 // скорость 100-8000 бит/с, по умолч. 2000 бит/с
#include <Gyver433.h> #include <Gyver433.h>
Gyver433_RX<2> rx; // указали пин Gyver433_RX<2> rx; // указали пин
examples/rx433_struct/rx433_struct.ino
+2 -1
View File
@@ -1,6 +1,7 @@
// приём структуры данных // приём структуры данных
#define G433_SLOW_MODE //#define G433_SPEED 1000 // скорость 100-8000 бит/с, по умолч. 2000 бит/с
#include <Gyver433.h> #include <Gyver433.h>
Gyver433_RX<2, 10> rx; // указали пин и размер буфера Gyver433_RX<2, 10> rx; // указали пин и размер буфера
examples/tx433_struct/tx433_struct.ino
+4 -2
View File
@@ -1,6 +1,8 @@
// передача структуры данных // передача структуры данных
#define G433_SLOW_MODE //#define G433_SPEED 1000 // скорость 100-8000 бит/с, по умолч. 2000 бит/с
#define G433_SLOW // отправляю раз в секунду на SYN480R
#include <Gyver433.h> #include <Gyver433.h>
Gyver433_TX<2, 10> tx; // указали пин и размер буфера Gyver433_TX<2, 10> tx; // указали пин и размер буфера
@@ -25,7 +27,7 @@ void loop() {
tx.sendData(data); tx.sendData(data);
Serial.println("Transmit:"); Serial.println("Transmitted:");
Serial.println(data.counter); Serial.println(data.counter);
Serial.println(data.randomNum); Serial.println(data.randomNum);
Serial.println(data.analog); Serial.println(data.analog);
keywords.txt
+6 -1
View File
@@ -13,7 +13,9 @@ Gyver433_RX KEYWORD1
# Methods and Functions (KEYWORD2) # Methods and Functions (KEYWORD2)
####################################### #######################################
sendData KEYWORD2 sendData KEYWORD2
sendDataSlow KEYWORD2
write KEYWORD2 write KEYWORD2
writeSlow KEYWORD2
tick KEYWORD2 tick KEYWORD2
tickISR KEYWORD2 tickISR KEYWORD2
tickWait KEYWORD2 tickWait KEYWORD2
@@ -31,5 +33,8 @@ G433_crc_xor KEYWORD2
G433_CRC8 LITERAL1 G433_CRC8 LITERAL1
G433_XOR LITERAL1 G433_XOR LITERAL1
G433_NOCRC LITERAL1 G433_NOCRC LITERAL1
G433_FAST LITERAL1
G433_MEDIUM LITERAL1
G433_SLOW LITERAL1
G433_SPEED LITERAL1 G433_SPEED LITERAL1
G433_SLOW_MODE LITERAL1 G433_MANCHESTER LITERAL1
library.properties
+1 -1
View File
@@ -1,5 +1,5 @@
name=Gyver433 name=Gyver433
version=1.1 version=1.2
author=AlexGyver <alex@alexgyver.ru> author=AlexGyver <alex@alexgyver.ru>
maintainer=AlexGyver <alex@alexgyver.ru> maintainer=AlexGyver <alex@alexgyver.ru>
sentence=Simple library for 433 MHz radio sentence=Simple library for 433 MHz radio
src/Gyver433.h
+223 -192
View File
@@ -3,10 +3,12 @@
Документация: Документация:
GitHub: https://github.com/GyverLibs/Gyver433 GitHub: https://github.com/GyverLibs/Gyver433
Возможности: Возможности:
- Не использует прерывания и таймеры (кроме нулевого, читает micros()) - Супер лёгкая либа, заведётся даже на тини13 (отправка)
- Встроенный CRC контроль целостности - Поддержка кривых китайских модулей
- Интерфейс Manchester или Pulselength
- Встроенный CRC контроль целостности (CRC8 или XOR)
- Ускоренный алгоритм IO для AVR Arduino - Ускоренный алгоритм IO для AVR Arduino
- Работает с хорошими и плохими 433 МГц модулями - Опционально работа в прерывании (приём данных)
AlexGyver, alex@alexgyver.ru AlexGyver, alex@alexgyver.ru
https://alexgyver.ru/ https://alexgyver.ru/
@@ -15,6 +17,7 @@
Версии: Версии:
v1.0 - релиз v1.0 - релиз
v1.1 - оптимизация, новый интерфейс, поддержка дешёвых синих модулей, работа в прерывании v1.1 - оптимизация, новый интерфейс, поддержка дешёвых синих модулей, работа в прерывании
v1.2 - улучшение качества связи, оптимизация работы в прерывании
*/ */
#ifndef Gyver433_h #ifndef Gyver433_h
@@ -22,43 +25,33 @@
#include <Arduino.h> #include <Arduino.h>
#include "FastIO.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_crc8(uint8_t *buffer, uint8_t size); // ручной CRC8
uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size); // ручной CRC XOR uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size); // ручной CRC XOR
#define TRAINING_TIME_SLOW (500000ul) // время синхронизации для SLOW_MODE #define TRAINING_TIME_SLOW (500000ul) // время синхронизации для SLOW_MODE
// ========================================================================= // =========================================================================
#ifndef G433_SPEED #ifndef G433_SPEED
#define G433_SPEED 3000 // скорость по умолчанию #define G433_SPEED 2000
#endif #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_MIN (START_PULSE * 3 / 4)
#define START_MAX (START_PULSE * 5 / 4) #define START_MAX (START_PULSE * 5 / 4)
#define FRAME_MIN (FRAME_TIME * 3 / 4) #define FRAME_MIN (FRAME_TIME * 3 / 4)
#define FRAME_MAX (FRAME_TIME * 5 / 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 // жоский delay для avr
#ifdef AVR #ifdef AVR
#define G433_DELAY(x) _delay_us(x) #define G433_DELAY _delay_us
#else #else
#define G433_DELAY(x) delayMicroseconds(x) #define G433_DELAY delayMicroseconds
#endif #endif
// режимы CRC // режимы CRC
@@ -66,6 +59,17 @@ uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size); // ручной CRC XOR
#define G433_XOR 1 #define G433_XOR 1
#define G433_NOCRC 2 #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 один байт // crc8 один байт
void G433_crc8_byte(uint8_t &crc, uint8_t data); void G433_crc8_byte(uint8_t &crc, uint8_t data);
@@ -95,188 +99,215 @@ public:
// отправка сырого набора байтов // отправка сырого набора байтов
void write(uint8_t* buf, uint16_t size) { 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++) { fastWrite(TX_PIN, 1);
#else G433_DELAY(FRAME_TIME);
for (uint16_t i = 0; i < TRAINING_AMOUNT; i++) { fastWrite(TX_PIN, 0);
#endif G433_DELAY(FRAME_TIME);
fastWrite(TX_PIN, 1);
G433_DELAY(FRAME_TIME);
fastWrite(TX_PIN, 0);
G433_DELAY(FRAME_TIME);
}
fastWrite(TX_PIN, 1); // старт
G433_DELAY(START_PULSE); // ждём
fastWrite(TX_PIN, 0); // старт бит
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));
G433_DELAY(HALF_FRAME);
fastWrite(TX_PIN, (data & 1));
G433_DELAY(HALF_FRAME);
data >>= 1;
}
}
fastWrite(TX_PIN, 0); // конец передачи
#ifdef G433_SLOW_MODE
tmr = millis();
#endif
} }
fastWrite(TX_PIN, 1); // старт
G433_DELAY(START_PULSE); // ждём
fastWrite(TX_PIN, 0); // старт бит
// доступ к буферу #ifdef G433_MANCHESTER
uint8_t buffer[TX_BUF]; G433_DELAY(HALF_FRAME); // ждём
for (uint16_t n = 0; n < size; n++) {
private: uint8_t data = buf[n];
#ifdef G433_SLOW_MODE for (uint8_t b = 0; b < 8; b++) {
uint32_t tmr = 0; fastWrite(TX_PIN, !(data & 1));
#endif G433_DELAY(HALF_FRAME);
}; fastWrite(TX_PIN, (data & 1));
G433_DELAY(HALF_FRAME);
data >>= 1;
}
}
fastWrite(TX_PIN, 0); // конец передачи
#else
bool flag = 0;
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);
else G433_DELAY(HALF_FRAME);
fastWrite(TX_PIN, flag = !flag);
data >>= 1;
}
}
#endif
}
// доступ к буферу
uint8_t buffer[TX_BUF];
private:
};
// ============ ПРИЁМНИК ============ // ============ ПРИЁМНИК ============
template <uint8_t RX_PIN, uint16_t RX_BUF = 64, uint8_t CRC_MODE = G433_CRC8> template <uint8_t RX_PIN, uint16_t RX_BUF = 64, uint8_t CRC_MODE = G433_CRC8>
class Gyver433_RX { class Gyver433_RX {
public: public:
Gyver433_RX() { Gyver433_RX() {
pinMode(RX_PIN, INPUT); pinMode(RX_PIN, INPUT);
} }
// неблокирующий приём, вернёт кол-во успешно принятых байт // неблокирующий приём, вернёт кол-во успешно принятых байт
uint16_t tick() { uint16_t tick() {
checkState(); if (pinChanged()) checkState();
return checkEnd(); return gotData();
} }
// tick для вызова в прерывании // tick для вызова в прерывании по CHANGE
void tickISR() { void tickISR() {
checkState(); #ifdef G433_MANCHESTER
} if (pinChanged()) checkState();
#else
// блокирующий приём, вернёт кол-во успешно принятых байт checkState();
uint16_t tickWait() { #endif
do { }
if (tick()) return size;
} while (parse == 2); // блокирующий приём, вернёт кол-во успешно принятых байт
return 0; uint16_t tickWait() {
} do {
if (tick()) return size;
// прочитает буфер в любой тип данных } while (parse == 2);
template <typename T> return 0;
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]; template <typename T>
return true; bool readData(T &data) {
} if (sizeof(T) > RX_BUF) return false;
uint8_t *ptr = (uint8_t*) &data;
// вернёт true при получении корректных данных for (uint16_t i = 0; i < sizeof(T); i++) *ptr++ = buffer[i];
bool gotData() { return true;
return checkEnd(); }
}
// вернёт true при получении корректных данных
// получить размер принятых данных uint16_t gotData() {
uint16_t getSize() { 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 size; return size;
} }
return 0;
// размер принятых данных }
uint16_t size = 0;
// получить размер принятых данных
// доступ к буферу uint16_t getSize() {
uint8_t buffer[RX_BUF]; return size;
}
private:
void checkState() { // размер принятых данных
bool bit = fastRead(RX_PIN); // читаем пин uint16_t size = 0;
if (bit != prevBit) { // ловим изменение сигнала
uint32_t thisPulse = micros() - tmr; // время импульса // доступ к буферу
if (parse == 1) { // в прошлый раз поймали фронт uint8_t buffer[RX_BUF];
tmr += thisPulse; // сброс таймера
if (thisPulse > START_MIN && thisPulse < START_MAX) { // старт бит? private:
parse = 2; // ключ на старт bool pinChanged() {
byteCount = bitCount = size = 0; // сброс bit = fastRead(RX_PIN);
//dataReady = 0; if (bit != prevBit) {
for (uint8_t i = 0; i < RX_BUF; i++) buffer[i] = 0; // чистим буфер prevBit = bit;
} else parse = 0; // не старт бит return 1;
} else if (parse == 2) { // идёт парсинг } return 0;
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) { // ловим фронт void checkState() {
parse = 1; // флаг на старт uint32_t thisPulse = micros() - tmr; // время импульса
tmr += thisPulse; // сброс таймера if (parse == 1) { // в прошлый раз поймали фронт
} #ifdef G433_MANCHESTER
prevBit = bit; tmr += thisPulse; // сброс таймера приёма
#endif
if (thisPulse > START_MIN && thisPulse < START_MAX) { // старт бит?
tmr2 = millis(); // сброс таймера активности
parse = 2; // ключ на старт
byteCount = bitCount = size = 0; // сброс
} else parse = 0; // не старт бит
} else if (parse == 2) { // идёт парсинг
#ifdef G433_MANCHESTER
if (thisPulse > FRAME_MIN && thisPulse < FRAME_MAX) { // фронт внутри таймфрейма
tmr += thisPulse; // синхронизируем тайминги
tmr2 = millis(); // сброс таймера активности
buffer[byteCount] >>= 1; // двигаем байт
buffer[byteCount] |= (bit << 7); // пишем данные
bitCount++; // счётчик битов
} }
} #else
uint16_t checkEnd() { uint8_t state = 2;
if (parse == 2 && micros() - tmr >= FRAME_TIME * 2) { // фрейм не закрыт if (thisPulse > HALF_FRAME_MIN && thisPulse < HALF_FRAME_MAX) state = 0; // low бит
parse = size = 0; // приём окончен else if (thisPulse > FRAME_MIN && thisPulse < FRAME_MAX) state = 1; // high бит
if (byteCount > 1) { // если что то приняли if (state != 2) {
if (CRC_MODE == G433_CRC8) { // CRC8 buffer[byteCount] >>= 1; // двигаем байт
if (!G433_crc8(buffer, byteCount)) size = byteCount - 2; buffer[byteCount] |= (state << 7); // пишем данные
} else if (CRC_MODE == G433_XOR) { // CRC XOR bitCount++; // счётчик битов
if (!G433_crc_xor(buffer, byteCount)) size = byteCount - 2; tmr2 = millis(); // сброс таймера активности
} else size = byteCount - 1; // без CRC
}
return size;
} }
return 0; #endif
if (bitCount == 8) { // собрали байт
bitCount = 0; // сброс
if (++byteCount >= RX_BUF) parse = 0; // буфер переполнен
}
} }
bool prevBit, dataReady = 0; #ifdef G433_MANCHESTER
uint8_t parse = 0; if (bit && parse == 0) { // ловим фронт
uint32_t tmr = 0; parse = 1; // флаг на старт
uint8_t bitCount = 0, byteCount = 0; 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;
};
// ===== CRC ===== // ===== CRC =====
void G433_crc8_byte(uint8_t &crc, uint8_t data) { void G433_crc8_byte(uint8_t &crc, uint8_t data) {
#if defined (__AVR__) #if defined (__AVR__)
// резкий алгоритм для AVR // резкий алгоритм для AVR
uint8_t counter; uint8_t counter;
uint8_t buffer; uint8_t buffer;
asm volatile ( asm volatile (
"EOR %[crc_out], %[data_in] \n\t" "EOR %[crc_out], %[data_in] \n\t"
"LDI %[counter], 8 \n\t" "LDI %[counter], 8 \n\t"
"LDI %[buffer], 0x8C \n\t" "LDI %[buffer], 0x8C \n\t"
"_loop_start_%=: \n\t" "_loop_start_%=: \n\t"
"LSR %[crc_out] \n\t" "LSR %[crc_out] \n\t"
"BRCC _loop_end_%= \n\t" "BRCC _loop_end_%= \n\t"
"EOR %[crc_out], %[buffer] \n\t" "EOR %[crc_out], %[buffer] \n\t"
"_loop_end_%=: \n\t" "_loop_end_%=: \n\t"
"DEC %[counter] \n\t" "DEC %[counter] \n\t"
"BRNE _loop_start_%=" "BRNE _loop_start_%="
: [crc_out]"=r" (crc), [counter]"=d" (counter), [buffer]"=d" (buffer) : [crc_out]"=r" (crc), [counter]"=d" (counter), [buffer]"=d" (buffer)
: [crc_in]"0" (crc), [data_in]"r" (data) : [crc_in]"0" (crc), [data_in]"r" (data)
); );
#else #else
// обычный для всех остальных // обычный для всех остальных
uint8_t i = 8; uint8_t i = 8;
while (i--) { while (i--) {
crc = ((crc ^ data) & 1) ? (crc >> 1) ^ 0x8C : (crc >> 1); crc = ((crc ^ data) & 1) ? (crc >> 1) ^ 0x8C : (crc >> 1);
data >>= 1; data >>= 1;
} }
#endif #endif
} }
uint8_t G433_crc8(uint8_t *buffer, uint8_t size) { uint8_t G433_crc8(uint8_t *buffer, uint8_t size) {
uint8_t crc = 0; uint8_t crc = 0;
for (uint8_t i = 0; i < size; i++) G433_crc8_byte(crc, buffer[i]); for (uint8_t i = 0; i < size; i++) G433_crc8_byte(crc, buffer[i]);
return crc; return crc;
} }
uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size) { uint8_t G433_crc_xor(uint8_t *buffer, uint8_t size) {
uint8_t crc = 0; uint8_t crc = 0;
for (uint8_t i = 0; i < size; i++) crc ^= buffer[i]; for (uint8_t i = 0; i < size; i++) crc ^= buffer[i];
return crc; return crc;
} }
#endif #endif