diff --git a/README.md b/README.md new file mode 100644 index 0000000..5229622 --- /dev/null +++ b/README.md @@ -0,0 +1,114 @@ +![License: MIT](https://img.shields.io/badge/License-MIT-green.svg) +![author](https://img.shields.io/badge/author-AlexGyver-informational.svg) +# Gyver433_TX +Библиотека для радиомодулей 433 МГц и Arduino +- Не использует прерывания и таймеры (кроме нулевого, читает micros()) +- Встроенный CRC контроль целостности +- Ускоренный алгоритм IO для AVR Arduino + +### Совместимость +Совместима со всеми Arduino платформами (используются Arduino-функции) + +## Содержание +- [Установка](#install) +- [Инициализация](#init) +- [Использование](#usage) +- [Пример](#example) +- [Версии](#versions) +- [Баги и обратная связь](#feedback) + + +## Установка +- Библиотеку можно найти по названию **Gyver433_TX** и установить через менеджер библиотек в: + - Arduino IDE + - Arduino IDE v2 + - PlatformIO +- [Скачать библиотеку](https://github.com/GyverLibs/Gyver433_TX/archive/refs/heads/main.zip) .zip архивом для ручной установки: + - Распаковать и положить в *C:\Program Files (x86)\Arduino\libraries* (Windows x64) + - Распаковать и положить в *C:\Program Files\Arduino\libraries* (Windows x32) + - Распаковать и положить в *Документы/Arduino/libraries/* + - (Arduino IDE) автоматическая установка из .zip: *Скетч/Подключить библиотеку/Добавить .ZIP библиотеку…* и указать скачанный архив +- Читай более подробную инструкцию по установке библиотек [здесь](https://alexgyver.ru/arduino-first/#%D0%A3%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0_%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA) + + +## Инициализация +```cpp +// указать пин +Gyver433_RX rx(2); +Gyver433_TX tx(2); +``` + + +## Использование +```cpp +// ========= Gyver433_TX ========= +void sendData(T &data); // отправить данные любого типа + +// ========= Gyver433_RX ========= +uint8_t tick(); // неблокирующий приём, вернёт кол-во успешно принятых байт +uint8_t tickWait(); // блокирующий приём, вернёт кол-во успешно принятых байт +bool readData(T &data); // прочитает буфер в любой тип данных (в указанную переменную) +int getSize(); // получить размер принятых данных +``` + + +## Пример +Остальные примеры смотри в **examples**! +### Отправка +```cpp +// мелкий передатчик 3.6V SYN115 + +#define G433_BUFSIZE 50 // размер буфера +#define G433_SPEED 2000 // скорость бит/сек (минимальная) + +#include +Gyver433_TX tx(2); // указали пин + +void setup() { +} + +char data[] = "Hello from #xx"; +byte count = 0; +void loop() { + data[12] = (count / 10) + '0'; + data[13] = (count % 10) + '0'; + if (++count >= 100) count = 0; + tx.sendData(data); + delay(100); +} +``` + +### Приём +```cpp +// крупный приёмник 5.0 SYN480R + +#define G433_BUFSIZE 50 // размер буфера +#define G433_SPEED 2000 // скорость бит/сек (минимальная) + +#include +Gyver433_RX rx(2); + +void setup() { + Serial.begin(9600); +} + + +void loop() { + // tick принимает асинхронно, но может ловить ошибки при загруженном коде + // tickWait блокирует выполнение, но принимает данные чётко + if (rx.tickWait()) { + byte buf[64]; + rx.readData(buf); + for (byte i = 0; i < rx.size; i++) Serial.write(buf[i]); + } +} +``` + + +## Версии +- v1.0 + + +## Баги и обратная связь +При нахождении багов создавайте **Issue**, а лучше сразу пишите на почту [alex@alexgyver.ru](mailto:alex@alexgyver.ru) +Библиотека открыта для доработки и ваших **Pull Request**'ов! \ No newline at end of file diff --git a/doc/scheme.jpg b/doc/scheme.jpg new file mode 100644 index 0000000..2e70dc3 Binary files /dev/null and b/doc/scheme.jpg differ diff --git a/examples/rx433/rx433.ino b/examples/rx433/rx433.ino new file mode 100644 index 0000000..eb3c918 --- /dev/null +++ b/examples/rx433/rx433.ino @@ -0,0 +1,22 @@ +// крупный приёмник 5.0 SYN480R + +#define G433_BUFSIZE 50 // размер буфера +#define G433_SPEED 2000 // скорость бит/сек (минимальная) + +#include +Gyver433_RX rx(2); + +void setup() { + Serial.begin(9600); +} + + +void loop() { + // tick принимает асинхронно, но может ловить ошибки при загруженном коде + // tickWait блокирует выполнение, но принимает данные чётко + if (rx.tickWait()) { + byte buf[64]; + rx.readData(buf); + for (byte i = 0; i < rx.size; i++) Serial.write(buf[i]); + } +} diff --git a/examples/rx433_lcd/rx433_lcd.ino b/examples/rx433_lcd/rx433_lcd.ino new file mode 100644 index 0000000..5ceb5be --- /dev/null +++ b/examples/rx433_lcd/rx433_lcd.ino @@ -0,0 +1,28 @@ +// крупный приёмник 5.0V SYN480R +#define G433_BUFSIZE 50 // размер буфера +#define G433_SPEED 2000 // скорость бит/сек (минимальная) + +#include +Gyver433_RX rx(2); // указали пин + +#include +#include +LiquidCrystal_I2C lcd(0x3f, 16, 2); // или 0x27 + +void setup() { + Serial.begin(9600); + lcd.init(); + lcd.backlight(); +} + +void loop() { + // tick принимает асинхронно, но может ловить ошибки при загруженном коде + // tickWait блокирует выполнение, но принимает данные чётко + if (rx.tick()) { + byte buf[64]; + rx.readData(buf); // прочитать в buf + lcd.clear(); + lcd.home(); + for (byte i = 0; i < rx.size; i++) lcd.write(buf[i]); + } +} diff --git a/examples/rx433_struct/rx433_struct.ino b/examples/rx433_struct/rx433_struct.ino new file mode 100644 index 0000000..8b6cf00 --- /dev/null +++ b/examples/rx433_struct/rx433_struct.ino @@ -0,0 +1,35 @@ +// передача структуры данных +// крупный приёмник 5.0V SYN480R +#define G433_BUFSIZE 50 // размер буфера +#define G433_SPEED 2000 // скорость бит/сек (минимальная) + +#include +Gyver433_RX rx(2); // указали пин + +// формат пакета для приёма (такой же как отправляется) +struct dataPack { + byte counter; + byte randomNum; + int analog; + uint32_t time; +}; + +void setup() { + Serial.begin(9600); +} + +void loop() { + // tick принимает асинхронно, но может ловить ошибки при загруженном коде + // tickWait блокирует выполнение, но принимает данные чётко + if (rx.tick()) { + dataPack data; + rx.readData(data); // прочитать в buf + + Serial.println("Received:"); + Serial.println(data.counter); + Serial.println(data.randomNum); + Serial.println(data.analog); + Serial.println(data.time); + Serial.println(); + } +} diff --git a/examples/tx433/tx433.ino b/examples/tx433/tx433.ino new file mode 100644 index 0000000..a5f8a69 --- /dev/null +++ b/examples/tx433/tx433.ino @@ -0,0 +1,18 @@ +// мелкий передатчик 3.6V SYN115 +#define G433_BUFSIZE 50 // размер буфера +#define G433_SPEED 2000 // скорость бит/сек (минимальная) +#include +Gyver433_TX tx(2); // указали пин + +void setup() { +} + +char data[] = "Hello from #xx"; +byte count = 0; +void loop() { + data[12] = (count / 10) + '0'; + data[13] = (count % 10) + '0'; + if (++count >= 100) count = 0; + tx.sendData(data); + delay(100); +} diff --git a/examples/tx433_struct/tx433_struct.ino b/examples/tx433_struct/tx433_struct.ino new file mode 100644 index 0000000..91dae0e --- /dev/null +++ b/examples/tx433_struct/tx433_struct.ino @@ -0,0 +1,37 @@ +// передача структуры данных +// мелкий передатчик 3.6V SYN115 + +#define G433_BUFSIZE 50 // размер буфера +#define G433_SPEED 2000 // скорость бит/сек (минимальная) +#include +Gyver433_TX tx(2); // указали пин + +// формат пакета для отправки +struct dataPack { + byte counter; + byte randomNum; + int analog; + uint32_t time; +}; +dataPack data; + +void setup() { + Serial.begin(9600); +} + +void loop() { + data.counter++; // тут счётчик + data.randomNum = random(256); // случайное число + data.analog = analogRead(0); // тут ацп + data.time = millis(); // тут миллис + + Serial.println("Transmit:"); + Serial.println(data.counter); + Serial.println(data.randomNum); + Serial.println(data.analog); + Serial.println(data.time); + Serial.println(); + + tx.sendData(data); + delay(1000); +} diff --git a/keywords.txt b/keywords.txt new file mode 100644 index 0000000..ee6890d --- /dev/null +++ b/keywords.txt @@ -0,0 +1,26 @@ +####################################### +# Syntax Coloring Map For Gyver433 +####################################### + +####################################### +# Datatypes (KEYWORD1) +####################################### +Gyver433 KEYWORD1 +Gyver433_TX KEYWORD1 +Gyver433_RX KEYWORD1 + +####################################### +# Methods and Functions (KEYWORD2) +####################################### +sendData KEYWORD2 +tick KEYWORD2 +tickWait KEYWORD2 +readData KEYWORD2 +size KEYWORD2 +getSize KEYWORD2 + +####################################### +# Constants (LITERAL1) +####################################### +G433_SPEED LITERAL1 +G433_BUFSIZE LITERAL1 \ No newline at end of file diff --git a/library.properties b/library.properties new file mode 100644 index 0000000..073a5af --- /dev/null +++ b/library.properties @@ -0,0 +1,9 @@ +name=Gyver433 +version=1.0 +author=AlexGyver +maintainer=AlexGyver +sentence=Simple library for 433 MHz radio +paragraph=Simple library for 433 MHz radio +category=Device Control +url=https://github.com/GyverLibs/Gyver433 +architectures=* \ No newline at end of file diff --git a/src/Gyver433.h b/src/Gyver433.h new file mode 100644 index 0000000..f2206c1 --- /dev/null +++ b/src/Gyver433.h @@ -0,0 +1,259 @@ +/* + Библиотека для радиомодулей 433 МГц и Arduino + Документация: + GitHub: https://github.com/GyverLibs/Gyver433 + Возможности: + - Не использует прерывания и таймеры (кроме нулевого, читает micros()) + - Встроенный CRC контроль целостности + - Ускоренный алгоритм IO для AVR Arduino + + AlexGyver, alex@alexgyver.ru + https://alexgyver.ru/ + MIT License + + Версии: + v1.0 - релиз +*/ + +#ifndef Gyver433_h +#define Gyver433_h +#include + +/* + Передатчик: + Gyver433_TX tx(пин) - создать объект + sendData(data) - отправить, любой тип данных + + Приёмник: + Gyver433_RX rx(пин) - создать объект + tick() - вызывать постоянно для чтения. Асинхронный. Вернёт количество принятых байт + tickWait() - тож самое, но блокирует выполнение, принимает более четко + readData(data) - прочитать, любой тип данных + size - количество принятых байтов +*/ + +#ifndef G433_SPEED +#define G433_SPEED 2000 // скорость бит/сек (минимальная) +#endif +#ifndef G433_BUFSIZE +#define G433_BUFSIZE 64 // размер буфера приёма и отправки +#endif + +// тайминги интерфейса (компилятор посчитает) +#define HIGH_PULSE (1000000ul/G433_SPEED) +#define LOW_PULSE (HIGH_PULSE/2) +#define START_PULSE (HIGH_PULSE*2) +#define PULSE_HYST (LOW_PULSE/2) +#define START_MIN (START_PULSE-PULSE_HYST) +#define START_MAX (START_PULSE+PULSE_HYST) +#define LOW_MIN (LOW_PULSE-PULSE_HYST) +#define LOW_MAX (LOW_PULSE+PULSE_HYST) +#define HIGH_MIN (HIGH_PULSE-PULSE_HYST) +#define HIGH_MAX (HIGH_PULSE+PULSE_HYST) + +// crc +uint8_t G433_crc(uint8_t *buffer, uint8_t size); +void G433_crc_byte(uint8_t &crc, uint8_t data); + +// ============ ПЕРЕДАТЧИК ============ +class Gyver433_TX { +public: + Gyver433_TX(uint8_t pin) : _pin(pin) { +#if defined(__AVR__) + _port_reg = portOutputRegister(digitalPinToPort(pin)); + _bit_mask = digitalPinToBitMask(pin); +#endif + pinMode(pin, OUTPUT); + } + + // отправка, блокирующая. Кушает любой тип данных + template + void sendData(T &data) { + const uint8_t *ptr = (const uint8_t*) &data; + for (uint16_t i = 0; i < sizeof(T); i++) buffer[i] = *ptr++; + buffer[sizeof(T)] = G433_crc(buffer, sizeof(T)); // CRC последним байтом + bool flag = 0; // флаг дрыга + for (uint8_t i = 0; i < 30; i++) { // 30 импульсов для синхронизации + flag = !flag; + fastDW(flag); + delayMicroseconds(HIGH_PULSE); + } + fastDW(1); // старт бит + delayMicroseconds(START_PULSE); // старт бит + for (int n = 0; n < sizeof(T) + 1; n++) { // буфер + CRC + for (uint8_t b = 0; b < 8; b++) { + fastDW(flag); + flag = !flag; + if (bitRead(buffer[n], b)) delayMicroseconds(HIGH_PULSE); + else delayMicroseconds(LOW_PULSE); + } + } + fastDW(0); // передача окончена + } + +private: + void fastDW(bool state) { +#if defined(__AVR__) + if (state) *_port_reg |= _bit_mask; // HIGH + else *_port_reg &= ~_bit_mask; // LOW +#else + digitalWrite(_pin, state); +#endif + } + uint8_t buffer[G433_BUFSIZE]; + const uint8_t _pin; +#if defined(__AVR__) + volatile uint8_t *_port_reg; + volatile uint8_t _bit_mask; +#endif +}; + + +// ============ ПРИЁМНИК ============ +class Gyver433_RX { +public: + Gyver433_RX(uint8_t pin){ +#if defined(__AVR__) + _pin_reg = portInputRegister(digitalPinToPort(pin)); + _bit_mask = digitalPinToBitMask(pin); +#endif + } + + // неблокирующий приём, вернёт кол-во успешно принятых байт + uint8_t tick() { + bool newState = fastDR(); // читаем пин + if (newState != prevState) { // ловим изменение сигнала + uint32_t thisUs = micros(); + uint32_t thisPulse = thisUs - tmr; + if (parse == 1) { // в прошлый раз поймали фронт + if (thisPulse > START_MIN && thisPulse < START_MAX) { // старт бит? + parse = 2; // ключ на старт + tmr = thisUs; + byteCount = 0; + bitCount = 0; + size = 0; + for (uint8_t i = 0; i < G433_BUFSIZE; i++) buffer[i] = 0; + } else { // не старт бит + parse = 0; + } + } else if (parse == 2) { // идёт парсинг + if (thisPulse > LOW_MIN && thisPulse < LOW_MAX) { // low бит + // просто пропускаем (в буфере уже нули) + tmr = thisUs; + bitCount++; + if (bitCount == 8) { + bitCount = 0; + byteCount++; + if (byteCount > G433_BUFSIZE) parse = 0; // оверфлоу + } + } else if (thisPulse > HIGH_MIN && thisPulse < HIGH_MAX) { // high бит + bitSet(buffer[byteCount], bitCount); // ставим бит единичку + tmr = thisUs; + bitCount++; + if (bitCount == 8) { + bitCount = 0; + byteCount++; + if (byteCount > G433_BUFSIZE) parse = 0; // оверфлоу + } + } else { // ошибка или конец передачи + tmr = thisUs; + parse = 0; + // проверяем, есть ли данные и целые ли они + if (byteCount > 0 && G433_crc(buffer, byteCount) == 0) { + size = byteCount - 2; // длина даты (минус crc) + return size; + } + else return 0; + } + } + + if (newState && !prevState && parse == 0) { // ловим фронт + parse = 1; // в следующий раз ждём флаг + tmr = thisUs; + } + prevState = newState; + } + return 0; + } + + // блокирующий приём, вернёт кол-во успешно принятых байт + uint8_t tickWait() { + do { + tick(); + } while (parse == 2); + if (byteCount > 0) { + byteCount = 0; + return size; + } else return 0; + } + + // прочитает буфер в любой тип данных + template + bool readData(T &data) { + if (sizeof(T) > G433_BUFSIZE) return false; + uint8_t *ptr = (uint8_t*) &data; + for (uint16_t i = 0; i < sizeof(T); i++) *ptr++ = buffer[i]; + return true; + } + + // получить размер принятых данных + int getSize() { + return size; + } + + int size = 0; + +private: + bool fastDR() { +#if defined(__AVR__) + return bool(*_pin_reg & _bit_mask); +#else + return digitalRead(_pin); +#endif + } + uint8_t buffer[G433_BUFSIZE]; + bool prevState; + uint8_t parse = 0; + uint32_t tmr = 0; + uint8_t bitCount = 0, byteCount = 0; +#if defined(__AVR__) + volatile uint8_t *_pin_reg; + volatile uint8_t _bit_mask; +#endif +}; + +void G433_crc_byte(uint8_t &crc, uint8_t data) { +#if defined (__AVR__) + // резкий алгоритм для AVR + uint8_t counter; + uint8_t buffer; + asm volatile ( + "EOR %[crc_out], %[data_in] \n\t" + "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_crc(uint8_t *buffer, uint8_t size) { + uint8_t crc = 0; + for (uint8_t i = 0; i < size; i++) G433_crc_byte(crc, buffer[i]); + return crc; +} +#endif \ No newline at end of file