РЕШЕНО Nrf24l01+ не понятненько работают

Всем доброго времени суток! Код рабочий, но работает раз, через раз
Вообщем у меня тип умный дом.
Пока что побеждаю радио, пока что имеем рабочую регистрацию, и получение инфы от сенсоров.
Алгоритм получения инфы: База проходиться по массиву, открывает трубу(персональную для каждого сенсора) на отправку туда шлет некий байт "запрос", а сенсор отвечает на общую трубу для информации.
Сенсор у меня Arduino nano, База NodeMCU 1.0;
"Проблема" а точнее не правильную работу заметно начиная с двух устройств в схеме.
Вот так выглядит лог с одним сенсором(черная консоль это сенсор, а порт ардуино иде это база).

Спойлер: Лог с одним сенсором

Но вот с подключением в сети второго сенсора, начинаются проблемы(первый сенсор с керамикой и електролитом на nrf24l01+, второй просто керамика на nrf'ке) частичные недолеты пакетов то у одного то у друго-го, то все ок, причем все (увидите на логе) повторяется циклично !

Спойлер: Лог с двумя сенсорами

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

----

База:

Код (C++):

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#define v_kef 100
uint8_t id_sensor = 0;
uint8_t type_sensor = 1;
RF24 radio(D4, D8);
struct message {
  uint8_t id;
  uint8_t type;
  uint8_t data;
};
struct info_ {
  uint8_t id_sensor;
  uint8_t type_sensor;
  int16_t v_bat;
  uint8_t status_sensor;
  uint8_t signal_lvl;
  uint8_t person_pipe[1][6];
};
message rx_data;
info_ reg_pack;
//uint8_t v_kef = 100;
uint8_t pipe = 0;
//uint8_t address[][6] = {0xAABBCCDD11LL, 0xAABBCCDD22LL, 0xAABBCCDD33LL, 0xAABBCCDD44LL, 0xAABBCCDD55LL};
uint8_t address[20][6] = {"0Node", "1Node", "2Node", "3Node"}; //0-Заглушка;1-Alarms;2-Reg; 3-Get_data; Another sesors!
uint8_t pipes_elems() {
  uint8_t memory = sizeof(address) / sizeof(address[0]);
  uint8_t elems = 0;
  if (memory <= 254) {
    for (uint8_t i = 0; i < memory; i++) {
      if (address[i][0] != 0) {
        elems++;
      }
    }
  }
  else {
    Serial.println("ERROR! Size of array more 255 elements!");
  }
  return elems;
}
boolean get_info(uint8_t elem) {
}
boolean get_data(uint8_t elem) {
  Serial.print("Elem:");
  Serial.print(elem);
  radio.stopListening();
  radio.openWritingPipe(address[elem]);
  boolean tx = false;
  uint8_t data = 101;
  for (uint8_t i = 0; i < 20; i++) {
    tx = radio.write(&data, sizeof(data));
    if (tx) {
      break;
    }
    delay(200);
  }
  radio.startListening();
  if (!tx) {
    Serial.println(" Sensor not talk with me!");
    return false;
  }
  Serial.print(" Sended! ");
  uint8_t i = 0;
  uint8_t pipe = 0;
  while (i < 20) {
    if (radio.available(&pipe)) {
      Serial.print(pipe);
      if (pipe == 3) {
        break;
      }
    }
    i++;
    delay(150);
  }
  if (i < 15) {
    radio.read(&rx_data, sizeof(rx_data));
    Serial.print(" Id: ");
    Serial.print(rx_data.id);
    Serial.print(" Data:");
    Serial.println(rx_data.data);
    return true;
  }
  else {
    Serial.println("Responce not recived!");
    return false;
  }
}
void get_data_all() {
  Serial.println("Start polling sensors!");
  if (pipes_elems() > 4) {
    for (uint8_t i = 4; i <= pipes_elems() - 1; i++) {
      get_data(i);
      delay(20);
    }
  }
  else {
    Serial.println("Not found sensors!");
  }
}
boolean register_() {
  radio.stopListening();
  Serial.print("Scaning:");
  radio.openWritingPipe(address[2]);
  boolean tx = false;
  uint8_t status_ = 200; //200 - granted!
  for (uint8_t i = 0; i < 15; i++) {
    tx = radio.write(&status_, sizeof(status_));
    if (tx) {
      break;
    }
  }
  radio.startListening();
  if (!tx) {
    Serial.println("not found!");
    return false;
  }
  Serial.println("found!");
  uint8_t pipe_r = 0;
  for (uint8_t i = 0; i < 20; i++) {
    if (radio.available(&pipe_r)) {
      if (pipe_r == 2) {
        break;
      }
    }
    delay(200);
  }
  if (pipe_r != 2) {
    Serial.println("REG cansel, respocne not recived!");
    return false;
  }
  radio.read(&reg_pack, sizeof(reg_pack));
  if (reg_pack.id_sensor != 0 or reg_pack.signal_lvl < 100) {//Verifying..
    Serial.println("Reg cansel, sensor not verifyed!");
    return false;
  }
  Serial.println("Sensor OK! Continue reg him!");
  reg_pack.id_sensor = random(1, 230);
  Serial.print("Him new id is:");
  Serial.println(reg_pack.id_sensor);
  radio.stopListening();
  boolean tx_second = false;
  for (uint8_t i = 0; i < 20; i++) {
    tx_second = radio.write(&reg_pack, sizeof(reg_pack));
    if (tx_second) {
      break;
    }
    delay(10);
  }
  if (!tx_second) {
    Serial.println("Reg error, packet not recived!");
    radio.startListening();
    return false;
  }
  Serial.println("Reg OK!");
  radio.startListening();
  memcpy(address[pipes_elems()], reg_pack.person_pipe[0], sizeof(address[0]));
  return true;
}
void setup() {
  Serial.begin(115200);
  radio.begin();
  radio.setAutoAck(true);
  radio.setChannel(120);
  radio.openReadingPipe(1, address[1]);//Alarm pipe
  radio.setAutoAck(1, true);
  radio.openReadingPipe(2, address[2]);//Reg pipe
  radio.setAutoAck(2, true);
  radio.openReadingPipe(3, address[3]);//Data-info pipe
  radio.setAutoAck(3, true);
  radio.openWritingPipe(address[0]);//Trash pipe
  radio.setPALevel (RF24_PA_MAX);
  radio.setDataRate(RF24_1MBPS);
  radio.startListening();
  radio.powerUp();
  delay(100);
  Serial.println();
  Serial.print("Pipes:");
  Serial.println(pipes_elems());
}

void loop() {
  if (Serial.available() > 0) {
    String buffer_ = Serial.readString();
    if (buffer_ == "tx") {
      Serial.println("Start sending...");
      get_data_all();
    }
    else if (buffer_ == "reg") {
      Serial.println("Start registering...");
      register_();
    }
  }
}

Сенсор:

Код (C++):

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include <EEPROM.h>
#define key 131
uint8_t id_sensor = 0;
uint8_t type_sensor = 1;
RF24 radio(9, 10);
struct message {
  uint8_t id;
  uint8_t type;
  uint8_t data;
};
struct info {
  uint8_t id_sensor;
  uint8_t type_sensor;
  int16_t v_bat;
  uint8_t status_sensor;
  uint8_t signal_lvl;
  uint8_t person_pipe[1][6];
};
message send_data;
info info_data;
const uint8_t v_kef = 100;
uint8_t pipe = 0;
//uint8_t address[][6] = {0xAABBCCDD11LL, 0xAABBCCDD22LL, 0xAABBCCDD33LL, 0xAABBCCDD44LL, 0xAABBCCDD55LL};
uint8_t address[4][6] = {"5Node", "1Node", "2Node", "3Node"}; //0-person pipe; 1-alarms; 2-reg; 3-Info;
void setup() {
  Serial.begin(115200);
  randomSeed(analogRead(0));
  radio.begin();
  radio.setAutoAck(true);
  radio.setChannel(120);
  radio.setRetries(1, 7);
  radio.openReadingPipe(1, address[0]);
  radio.setAutoAck(1, true);
  radio.openWritingPipe(address[3]);
  radio.setDataRate(RF24_1MBPS );
  radio.setPALevel (RF24_PA_MAX);
  //radio.powerUp();
  delay(100);
  if (id_sensor == 0) {
    Serial.println("Sysetm not reg!");
    Serial.println("Starting register...");
    radio.startListening();
    radio.closeReadingPipe(1);
    radio.openReadingPipe(1, address[2]);
    radio.setAutoAck(1, true);
    while (true) {
      Serial.println("Waiting a reg packet!");
      while (true) {
        if (radio.available(&pipe)) {
          if (pipe == 1) {
            Serial.println("Packet resived!");
            break;
          }
        }
        delay(100);
      }
      uint8_t incoming_data = 0;
      radio.read(&incoming_data, sizeof(incoming_data));
      if (incoming_data != 200) {
        Serial.println("Reg not granted!");
        continue;
      }
      Serial.println("Register granted!");
      Serial.println("Configuring packet...");
      float v_batt = 5.5;
      info_data.id_sensor = 0;
      info_data.type_sensor = type_sensor;
      info_data.v_bat = int(v_batt * v_kef);
      info_data.status_sensor = 1;
      info_data.signal_lvl = 250;
      memcpy(info_data.person_pipe[0], address[0], sizeof(info_data.person_pipe[0]));
      Serial.println("Start sending...");
      radio.stopListening();
      radio.openWritingPipe(address[2]);
      boolean send_status = false;
      for (byte i = 0; i < 10; i++) {
        send_status = radio.write(&info_data, sizeof(info_data));
        delay(10);
        if (send_status == true) {
          break;
        }
      }
      radio.startListening();
      if (send_status == false) {
        Serial.println("Send err!");
        continue;
      }
      Serial.println("Responce wait....");
      boolean is_reciv = false;
      for (uint8_t i = 0; i < 20; i++) {
        if (radio.available(&pipe)) {
          if (pipe == 1) {
            is_reciv = true;
            break;
          }
        }
        delay(200);
      }
      if (!is_reciv) {
        Serial.println("Reg ERR, responce not recived!");
        continue;
      }
      Serial.println("Reg OK!");
      radio.read(&info_data, sizeof(info_data));
      id_sensor = info_data.id_sensor;
      Serial.print("My new id:");
      Serial.println(id_sensor);
      radio.closeReadingPipe(1);
      radio.openReadingPipe(1, address[0]);
      radio.setAutoAck(1, true);
      radio.stopListening();
      radio.openWritingPipe(address[3]);
      radio.startListening();
      break;
    }
  }
  radio.powerUp();
}

void loop() {
  if (radio.available()) {
    Serial.println("Data recived!");
    uint8_t incoming_data = 0;
    radio.read(&incoming_data, sizeof(incoming_data));
    if (incoming_data == 101) {
      Serial.println("Request on data get!");
      radio.stopListening();
      boolean status_s = false;
      uint8_t i = 0;
      send_data.id = id_sensor;
      send_data.type = type_sensor;
      send_data.data = random(1, 45);
      while (!status_s && i < 20) {
        delay(10);
        status_s = radio.write(&send_data, sizeof(send_data));
        i++;
      }
      if (status_s) {
        Serial.println("Success! Data sended!");
      }
      else {
        Serial.println("Error! Data not sended!");
      }
      radio.startListening();
    }
    else if (incoming_data == 102) {
      Serial.println("Request on info get!");
      radio.stopListening();
      boolean status_s = false;
      uint8_t i = 0;
      float v_batt = 5.5;
      info_data.id_sensor = id_sensor;
      info_data.type_sensor = type_sensor;
      info_data.v_bat = int(v_batt * v_kef);
      info_data.status_sensor = 1;
      info_data.signal_lvl = 250;
      while (!status_s && i < 20) {
        delay(10);
        status_s = radio.write(&info_data, sizeof(info_data));
        i++;
      }
      if (status_s) {
        Serial.println("Success! Data sended!");
      }
      else {
        Serial.println("Error! Data not sended!");
      }
      radio.startListening();
    }
  }
}

 

От нас чего хочешь?

 

Из-за чего могут быть такие циклические сбои, на что мне обратить внимание или что исправить ?

 

Взять бубен и вызвать радиодуха. Принести ему что-нить в жертву. Авось и поможет беде.

 

Сойдет в жертву nrf спалить ?

 

Я в принципе отказался от nRF. Ну их в пень.

 

Все таки не так вопрос поставил) Я хочу узнать почему оно сбоит цыклически ! Оно работает раз через раз, но работает ведь! Так почему же все таки сбоит

 

Код (C++):

for (uint8_t i = 0; i < 20; i++) {
    tx = radio.write(&data, sizeof(data));
    if (tx) {
      break;
    }
    delay(200);
  }

Зачем 20 раз посылать по икс раз? Это уже есть в библиотеке и настраивается при инициализации

Код (C++):

radio.setRetries(0, 15);     // (время между попыткой достучаться, число попыток)

Код (C++):

while (i < 20) {
    if (radio.available(&pipe)) {
      Serial.print(pipe);
      if (pipe == 3) {
        break;
      }
    }
    i++;
    delay(150);
  }

Я жду по-другому:

Код (C++):

while ( ! radio.available() && ! timeout ) {
    if ( wait_answ <= millis() ) {
      timeout = true;
    }
  }
  if ( timeout )
  {
    Serial.print("Failed, response timed out.\n");
  }
  else
  {

    //uint8_t len = radio.getDynamicPayloadSize();
    radio.read( &telem, sizeof(telem));              // чиатем входящий сигнал

Периодическая потеря связи является , скорее всего, следствием нарушения синхронизации между посланием и ответом. Об Autoask думали?

 

Во многих протоколах существует процедура перезапроса. Даже тех, что работают по проводам. Снижение скорости работы Wi-Fi есть следствие потери пакетов. Так что вопрос твой риторический.
Работай на частоте 869МГц. Там пока чисто. Если необходимо гарантированно доставить пакет, то это LoRa и подобное с обязательной коррекцией ошибок.

 

Думал, но ведь у сенсора постоянно изменяются данные, и как понимаю нельзя изменять те данные которые были записаны в пакет.
Возможно стоит просто отключить autoack? Ведь я все равно могу ждать ответ не взирая на то отправился ли он или нет. И это освободит радио эфир.

Специально для этого сижу на 120 канале тобиж я уже возможно ушел от шума роутера на 2.4 я то уже на 2.5 где-то =)
Хотя я понимаю что не желательно юзать такую частоту, но просто уже затарился такими модулями =(

Да, но я хотел потом считать качество связи как в Ajax(не реклама). И для этого мне нужно было знать сколько попыток сделала база чтоб достучаться, и потом посчитать силу сигнала(поле в структуре уже выделено).

 

Тогда не забудьте установить

Код (C++):

radio.setRetries(0, 1);

 

nRF не отдаёт силу сигнала. Не обучено.

Я их тоже пару купил на LCSC какие-то брендовые. Резюме такое - диапазон в 2.4 ГГц абсолютно не подходит под радиовещание на малых мощностях и дальние расстояния. Либо 16 дБм и получаем дальности, сопоставимые с Wi-Fi, или же 0 дБм и это джойстики, мышки и прочая кухонная утварь.

 

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

Да тут полностью согласен, но для моей квартиры при условии что база будет в коридоре, все будет ок и к каждой комнате максимум 2 бетонные стены которые не должны быть ему преградой ( я уже тестил вроде связь норм)
UPD:
Про бывал новый код и... не чего =(

Спойлер: Код

База

Код (C++):

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
RF24 radio(D4, D8);
struct message {
  uint8_t id;
  uint8_t type;
  uint8_t data;
};
struct info_ {
  uint8_t id_sensor;
  uint8_t type_sensor;
  int16_t v_bat;
  uint8_t status_sensor;
  uint8_t signal_lvl;
  uint8_t person_pipe[1][6];
};
message rx_data;
info_ reg_pack;
uint8_t address[20][6] = {"0Node", "1Node", "2Node", "3Node", "5Node", "9Node"}; //0-Заглушка;1-Alarms;2-Reg; 3-Get_data; Another sesors!
void radio_init() {
  radio.begin();
  radio.setAutoAck(true);
  radio.setChannel(120);
  radio.openReadingPipe(1, address[1]);
  radio.setAutoAck(1, true);
  radio.openReadingPipe(2, address[2]);//Reg pipe
  radio.setAutoAck(2, true);
  radio.openReadingPipe(3, address[3]);//Data-info pipe
  radio.setAutoAck(3, true);
  radio.openWritingPipe(address[0]);//Trash pipe
  radio.setRetries(3, 15);
  radio.setPALevel (RF24_PA_LOW);
  radio.setDataRate(RF24_250KBPS);
  radio.startListening();
  radio.powerUp();
}
boolean get_data_all() {
  radio_init();
  radio.stopListening();
  radio.powerUp();
  radio.openWritingPipe(address[4]);
  uint8_t data = 101;
  boolean tx = radio.write(&data, sizeof(data));
  Serial.print("TX status:");
  Serial.println(tx);
  radio.startListening();
  uint8_t i = 0;
  while (i < 15) {
    if (radio.available()) {
      break;
    }
    i++;
    delay(150);
  }
  if (i == 15) {
    Serial.println("1 sensor ban =(");
  }
  else {
    message rx_firsth;
    Serial.print("Data recived! ");
    radio.read(&rx_firsth, sizeof(rx_firsth));
    Serial.print("Id:");
    Serial.print(rx_firsth.id);
    Serial.print(" Data:");
    Serial.print(rx_firsth.data);
  }
  delay(150);
  radio.stopListening();
  radio.powerUp();
  radio.openWritingPipe(address[5]);
  uint8_t data2 = 101;
  boolean tx2 = radio.write(&data2, sizeof(data2));
  Serial.print("TX2 status:");
  Serial.println(tx2);
  radio.startListening();
  uint8_t i2 = 0;
  while (i2 < 15) {
    if (radio.available()) {
      break;
    }
    i2++;
    delay(150);
  }
  if (i2 == 15) {
    Serial.println("2 sensor ban =(");
  }
  else {
    message rx_two;
    Serial.print("Data recived! ");
    radio.read(&rx_two, sizeof(rx_two));
    Serial.print("Id:");
    Serial.print(rx_two.id);
    Serial.print(" Data:");
    Serial.print(rx_two.data);
  }
  return true;
}
void setup() {
  Serial.begin(115200);
  radio_init();
}

void loop() {
  if (Serial.available() > 0) {
    String buffer_ = Serial.readString();
    if (buffer_ == "tx") {
      Serial.println("Start sending...");
      get_data_all();
    }
  }
}

Сенсор

Код (C++):

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
RF24 radio(9, 10);
uint8_t id_sensor = 10;
uint8_t type_sensor = 1;
struct message {
  uint8_t id;
  uint8_t type;
  uint8_t data;
};
struct info_ {
  uint8_t id_sensor;
  uint8_t type_sensor;
  int16_t v_bat;
  uint8_t status_sensor;
  uint8_t signal_lvl;
  uint8_t person_pipe[1][6];
};
message rx_data;
info_ reg_pack;
uint8_t address[20][6] = {"0Node", "1Node", "2Node", "3Node", "5Node", "9Node"}; //0-Заглушка;1-Alarms;2-Reg; 3-Get_data; Another sesors!
void radio_init() {
  radio.begin();
  radio.setAutoAck(true);
  radio.setChannel(120);
  radio.openReadingPipe(1, address[4]);
  radio.setAutoAck(1, true);
  radio.openWritingPipe(address[3]);
  radio.setRetries(3, 15);
  radio.setPALevel (RF24_PA_LOW);
  radio.setDataRate(RF24_250KBPS);
  radio.startListening();
  radio.powerUp();
}
void setup() {
  Serial.begin(115200);
  radio_init();
}

void loop() {
  if (radio.available()) {
    uint8_t lol = 0;
    radio_init();
    delay(10);
    radio.read(&lol, sizeof(lol));
    Serial.println("Radio available!");
    radio.stopListening();
    radio.powerUp();
    radio.openWritingPipe(address[3]);
    message mess;
    mess.id = id_sensor;
    mess.type = type_sensor;
    mess.data = (uint8_t)random(1, 20);
    boolean tx = radio.write(&mess, sizeof(mess));
    Serial.print("Send status:");
    Serial.println(tx);
    radio.startListening();
  }
}

 

УХУ проблема решена вообщем надо было отключить autoAck! !!!!!!!!!!