Радиочастотный пакетный импульс 433 МГц с микросхемой ATTiny85

communication attiny rf attiny85

Недавно я создал эскиз ATTiny85.

Мой проект состоит из:

• Только 1 микросхема ATTiny85
• 1 радиочастотный модуль 433 МГц => используя вывод данных 2
• 2x входных цифровых контакта => используя контакт 3 и контакт 4

Работа на частоте 16 МГц с использованием ядра платы ATTiny85 с сайта https://github.com/damellis/attiny

Все работает на 5 В, 1 А 7805, используя только 24,4 мА в режиме ожидания 29,5 мА при передаче.

Я немного оптимизировал свой код, и эскиз работает так, как задумано. Однако иногда модуль RF 433 просто продолжает отправлять данные в течение нескольких секунд вместо отправки пакета, а затем ждет моего 7-секундного тайм-аута.

Я использую внутренние подтягивающие резисторы на контактах 3 и 4.

Это происходит периодически.. Я хотел бы знать, сталкивался ли кто-нибудь с подобной проблемой и знает, как предотвратить эту "неконтролируемую передачу".. Или предложения по улучшению кода и т. д.

>

Как ни странно, с помощью этого дешевого модуля я могу получить точные сигналы на расстоянии 450+ метров прямой видимости (фермерская земля) на моем чувствительном приемнике.

Модуль RF 433

У меня есть катушка SMD, я также припаял провод LAN длиной 17,3 см в качестве антенны.

Водопад СДР

Я ожидаю постоянного всплеска каждые 7 секунд.

Код

Код начинается с циклического выполнения оператора переключателя по состояниям, когда входной сигнал H/L или когда таймер истекает и состояние изменяется.

Когда инициируется состояние триггера, цикл for копирует и объединяет сжатую шестнадцатеричную строку, а затем следующий цикл for отправляет эти сигналы через контакт 2.

После отправки сигнала состояние меняется на тайм-аут ожидания перед повторной отправкой импульса.

Вот в чем проблема.

Иногда сигнал продолжает отправляться, как будто состояние зависает на несколько секунд, но затем таймер начинает работать как положено...

Таймер на 15 минут с большей продолжительностью работает нормально, проблема возникает только с циклами на 7 и 9 секунд.

---

Фотографии тестирования печатной платы

---

Полный эскиз [обновлено с предложениями]

#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h>

#define DATA_PIN PB2//цифровой контакт 2
#define ALARM_TRIGGER_PIN PB3//цифровой контакт 3
#define LEARN_PIN PB4//цифровой контакт 4

//15мин= 900000 мс
//16мин = 960000 мс
//20мин= 500000 мс
const unsigned long DELAY_TIME_ZONE_HEARTBEAT = 900000;//15мин
const unsigned long DELAY_TIME_CHECKALARM_TIMEOUT = 7000;//7сек
const unsigned long DELAY_TIME_CHECKLEARN_TIMEOUT = 9000;//9сек

unsigned long Delay_Start_Check_Alarm = 0;
unsigned long Delay_Start_Heartbeat = 0;
unsigned long Delay_Start_Learn = 0;

char LEARN[] ="269369a6924d36da6c800";//сжатый шестнадцатеричный сигнал; LearnState/подделать тот же сигнал
char ALARM[] = "da4da69a4934db69b200";//сжатый шестнадцатеричный сигнал
char HEARTBEAT[] ="1269b4d349269b6d36400";//сжатый шестнадцатеричный сигнал
uint16_t pulse = 1100;//чипу Attiny85 требуется больше времени задержки
uint8_t i;

//пользовательские состояния
enum State 
{
  ALARMTIMEOUT,
  CHECKING,
  HEARTBEATTIMEOUT,
  HEARTBEATSEND,
  LEARNTIMEOUT,
  LEARNSEND,
  ALARMSEND
};

enum State state;

void setup() 
{    
  DDRB |= (1 << DATA_PIN);// заменяет pinMode(DATA_PIN, OUTPUT);
  DDRB &= ~(1 << ALARM_TRIGGER_PIN); // заменяет pinMode(ALARM_TRIGGER_PIN, INPUT);
  DDRB &= ~(1 << LEARN_PIN); // заменяет pinMode(LEARN_PIN, INPUT);

  PORTB |= (1 << ALARM_TRIGGER_PIN);//инициируем поднятие тревожного контакта
  PORTB |= (1 << LEARN_PIN);// инициируем подтягивание штыря обучения

  ADCSRA &= ~(1 << ADEN); //Отключаем АЦП, экономим ~230мкА

  Delay_Start_Check_Alarm = Delay_Start_Heartbeat = Delay_Start_Learn  = millis();//установлен для запуска миллис
  state = CHECKING;//начальное состояние
}

void Check_Alarm_And_Heartbeat() 
{
  unsigned long Mill = millis();//устанавливаем текущее время

  uint8_t alarmState = PINB&8;//читаем контакт 3 сигнализации
  uint8_t learnState = PINB&16;//читаем вывод обучения 4

  //цикл главного переключателя
    switch (state) 
    {
    case CHECKING:
         //постоянная проверка здесь
         if((alarmState) && (!learnState))
          {
           state = ALARMSEND;//устанавливаем состояние
           Delay_Start_Check_Alarm = Mill;//сохраняем время
          }
         //цикл обучения
         if((learnState) && (!alarmState))
         {
           state = LEARNSEND;//устанавливаем состояние
           Delay_Start_Learn = Mill;//сохраняем время
         }
         //продолжаем пульс
         if((!alarmState) && (!learnState))
         {
           state = HEARTBEATTIMEOUT;//устанавливаем состояние
         }
         //если оба имеют высокий приоритет, ставим LearnState/сигнал тампера
         if((alarmState) && (learnState))
         {
           state = LEARNSEND;//установить состояние; LearnState/подделать тот же сигнал
           Delay_Start_Learn = Mill;//сохраняем время
         }
        break;
    case LEARNSEND:
         {
           state = LEARNTIMEOUT;//устанавливаем состояние
           char LEARNFINAL[168];//создаем переменную LEARNFINAL и определяем длину
           strcpy(LEARNFINAL, LEARN);//копируем LEARN в новую переменную LEARNFINAL
           for (uint8_t i = 0; i < 7; i++) 
           {
             strcat(LEARNFINAL, LEARN);// добавляем/объединяем LEARN 7 раз в LEARNFINAL
           }
             for (i = 0; i < sizeof(LEARNFINAL); i++)
             {  
               Send_Hex_Digit(DATA_PIN, LEARNFINAL[i], pulse);//отправляем законченное LEARNFINAL var
             }
             //PORTB &= ~(1 << DATA_PIN);//запись низкого уровня
         }
        break;
    case ALARMSEND:
         {
           state = ALARMTIMEOUT;//устанавливаем состояние
           char ALARMFINAL[168];//создаем переменную ALARMFINAL и определяем длину
           strcpy(ALARMFINAL, ALARM);//копируем ALARM в новую переменную ALARMFINAL
            for (uint8_t i = 0; i < 7; i++) 
            {
               strcat(ALARMFINAL, ALARM);//добавляем/объединяем ALARM 7 раз в ALARMFINAL
            }
             for (i = 0; i < sizeof(ALARMFINAL); i++)
             {
               Send_Hex_Digit(DATA_PIN, ALARMFINAL[i], pulse);//отправляем завершенный ALARMFINAL var
             }
             //PORTB &= ~(1 << DATA_PIN);//запись низкого уровня
         }
        break;
    case HEARTBEATSEND:
         {
             state = CHECKING;//изменяем состояние
             char HEARTBEATPREFINAL[160];//создаем HEARTBEATPREFINAL var и определяем длину
             strcpy(HEARTBEATPREFINAL, HEARTBEAT);//копируем HEARTBEAT в новую переменную HEARTBEATPREFINAL
              for (uint8_t i = 0; i < 7; i++)
              {
                 strcat(HEARTBEATPREFINAL, HEARTBEAT);// добавляем/объединяем HEARTBEAT 7 раз с HEARTBEATPREFINAL
              }
             for (i = 0; i < sizeof(HEARTBEATPREFINAL); i++)
             {
               Send_Hex_Digit(DATA_PIN, HEARTBEATPREFINAL[i], pulse);//отправляем завершенное HEARTBEATPREFINAL var
             }
         }
        break;
    case HEARTBEATTIMEOUT:
             state = CHECKING;//изменяем состояние
             if ((Mill - Delay_Start_Heartbeat) >= DELAY_TIME_ZONE_HEARTBEAT)
             {
                 Delay_Start_Heartbeat += DELAY_TIME_ZONE_HEARTBEAT;//предотвращает дрейф
                 state = HEARTBEATSEND;//изменяем состояние по истечении времени
             }
        break;
    case ALARMTIMEOUT:
             state = ALARMTIMEOUT;//изменение состояния
             if ((Mill - Delay_Start_Check_Alarm) >= DELAY_TIME_CHECKALARM_TIMEOUT)
             {
                 state = CHECKING;//изменяем состояние по истечении времени
             } 
        break;
    case LEARNTIMEOUT:
             state = LEARNTIMEOUT;//изменяем состояние
             if ((Mill - Delay_Start_Learn) >= DELAY_TIME_CHECKLEARN_TIMEOUT)
             {
                 state = CHECKING;//изменяем состояние по истечении времени
             } 
        break;
    default:
        //ничего не делать
        break;
    }
}

void Send_Hex_Digit(uint8_t pin, char c, uint16_t pulse) 
{
  byte bc = c - 48 ; // преобразуем c в число от 0 до 15
  for (int i = 3; i >= 0; i--)
  {
    bitWrite(PORTB, pin, bitRead(bc, i));
    delayMicroseconds(pulse);
  }
}

void loop() 
{
  Check_Alarm_And_Heartbeat();
}

    Delay_Start_Check_Alarm = Mill;//Это решило проблему