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

v1.1

Browse Source
This commit is contained in:
Alex
2021-06-14 18:36:58 +03:00
parent ef9eca0f9f
commit cb09165d3e
15 changed files with 560 additions and 301 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Gyver433.h
+235 -218
View File
@@ -6,6 +6,7 @@
- Не использует прерывания и таймеры (кроме нулевого, читает micros())
- Встроенный CRC контроль целостности
- Ускоренный алгоритм IO для AVR Arduino
- Работает с хорошими и плохими 433 МГц модулями
AlexGyver, alex@alexgyver.ru
https://alexgyver.ru/
@@ -13,59 +14,67 @@
Версии:
v1.0 - релиз
v1.1 - оптимизация, новый интерфейс, поддержка дешёвых синих модулей, работа в прерывании
*/
#ifndef Gyver433_h
#define Gyver433_h
#include <Arduino.h>
#include "FastIO.h"
/*
Передатчик:
Gyver433_TX tx(пин) - создать объект
sendData(data) - отправить, любой тип данных
Приёмник:
Gyver433_RX rx(пин) - создать объект
tick() - вызывать постоянно для чтения. Асинхронный. Вернёт количество принятых байт
tickWait() - тож самое, но блокирует выполнение, принимает более четко
readData(data) - прочитать, любой тип данных
size - количество принятых байтов
*/
// настройки из скетча:
// #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 2000 // скорость бит/сек (минимальная)
#endif
#ifndef G433_BUFSIZE
#define G433_BUFSIZE 64 // размер буфера приёма и отправки
#define G433_SPEED 3000 // скорость по умолчанию
#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)
// тайминги интерфейса
#define FRAME_TIME (1000000ul / G433_SPEED) // время фрейма
#define HALF_FRAME (FRAME_TIME / 2) // полфрейма
#define START_PULSE (FRAME_TIME * 2) // стартовый импульс
#define TRAINING_AMOUNT_SLOW (TRAINING_TIME_SLOW / FRAME_TIME / 2) // количество импульсов для SLOW_MODE
// crc
uint8_t G433_crc(uint8_t *buffer, uint8_t size);
void G433_crc_byte(uint8_t &crc, uint8_t data);
// количество импульсов в зависимости от 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)
// жоский delay для avr
#ifdef AVR
#define G433_DELAY(x) _delay_us(x)
#else
#define G433_DELAY(x) delayMicroseconds(x)
#endif
// режимы CRC
#define G433_CRC8 0
#define G433_XOR 1
#define G433_NOCRC 2
// crc8 один байт
void G433_crc8_byte(uint8_t &crc, uint8_t data);
// ============ ПЕРЕДАТЧИК ============
template <uint8_t TX_PIN, uint16_t TX_BUF = 64, uint8_t CRC_MODE = G433_CRC8>
class Gyver433_TX {
public:
Gyver433_TX(uint8_t pin) {
#if defined(__AVR__)
_port_reg = portOutputRegister(digitalPinToPort(pin));
_bit_mask = digitalPinToBitMask(pin);
#else
_pin = pin;
#endif
pinMode(pin, OUTPUT);
Gyver433_TX() {
pinMode(TX_PIN, OUTPUT);
}
// отправка, блокирующая. Кушает любой тип данных
@@ -73,195 +82,203 @@ public:
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);
if (CRC_MODE == G433_CRC8) {
buffer[sizeof(T)] = G433_crc8(buffer, sizeof(T));
write(buffer, sizeof(T) + 1);
} else if (CRC_MODE == G433_XOR) {
buffer[sizeof(T)] = G433_crc_xor(buffer, sizeof(T));
write(buffer, sizeof(T) + 1);
} else {
write(buffer, sizeof(T));
}
fastDW(1); // старт бит
delayMicroseconds(START_PULSE); // старт бит
for (int n = 0; n < sizeof(T) + 1; n++) { // буфер + CRC
}
// отправка сырого набора байтов
void write(uint8_t* buf, uint16_t size) {
#ifdef G433_SLOW_MODE
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); // старт
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++) {
fastDW(flag);
flag = !flag;
if (bitRead(buffer[n], b)) delayMicroseconds(HIGH_PULSE);
else delayMicroseconds(LOW_PULSE);
fastWrite(TX_PIN, !(data & 1));
G433_DELAY(HALF_FRAME);
fastWrite(TX_PIN, (data & 1));
G433_DELAY(HALF_FRAME);
data >>= 1;
}
}
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];
#if defined(__AVR__)
volatile uint8_t *_port_reg;
volatile uint8_t _bit_mask;
#else
uint8_t _pin;
#endif
};
// ============ ПРИЁМНИК ============
class Gyver433_RX {
public:
Gyver433_RX(uint8_t pin) {
#if defined(__AVR__)
_pin_reg = portInputRegister(digitalPinToPort(pin));
_bit_mask = digitalPinToBitMask(pin);
#else
_pin = 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;
fastWrite(TX_PIN, 0); // конец передачи
#ifdef G433_SLOW_MODE
tmr = millis();
#endif
}
return 0;
}
// блокирующий приём, вернёт кол-во успешно принятых байт
uint8_t tickWait() {
do {
tick();
} while (parse == 2);
if (byteCount > 0) {
byteCount = 0;
// доступ к буферу
uint8_t buffer[TX_BUF];
private:
#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) { // ловим изменение сигнала
if (parse == 1) { // в прошлый раз поймали фронт
tmr += thisPulse; // сброс таймера
if (thisPulse > START_MIN && thisPulse < START_MAX) { // старт бит?
parse = 2; // ключ на старт
byteCount = bitCount = size = 0; // сброс
dataReady = 0;
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; // флаг на старт
tmr += thisPulse; // сброс таймера
}
prevBit = bit;
}
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;
} else return 0;
}
// прочитает буфер в любой тип данных
template <typename T>
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;
#else
uint8_t _pin;
#endif
};
}
// размер принятых данных
int size = 0;
// доступ к буферу
uint8_t buffer[RX_BUF];
private:
bool prevBit, dataReady = 0;
uint8_t parse = 0;
uint32_t tmr = 0;
uint8_t bitCount = 0, byteCount = 0;
};
void G433_crc_byte(uint8_t &crc, uint8_t data) {
// ===== CRC =====
void G433_crc8_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)
);
// резкий алгоритм для 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;
}
// обычный для всех остальных
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;
}
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