Arduino.ru

Извиняюсь, не точно выразился. Вообщем если отключить датчик и заново включить, с какой-то вероятностью в ком порте базы не будет не малейшего намека на то что она нашла новое устройство, но грубо говоря если слать пакеты в слепую то датчик отвечает тоесть он дошел до void loop но как)))) если база вроде как не получала от него пакета регистрации

Проблема решена! Тут решение -> https://community.alexgyver.ru/threads/nrf24l01-i-esp8266-i-tuda-zhe-arduino-nano.3475/

ссылка не открывается... и вообще форум гайвера лежит четвертый день..

Я использую VPN 

Код приемника:(базы)

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24     radio(D4, D8);
byte transmit_data;
uint8_t  pipe;

void setup()
{
  radio.begin();
  radio.setChannel(120);
  radio.setDataRate(RF24_1MBPS);
  radio.setPALevel(RF24_PA_MAX);
  radio.openReadingPipe (1, 0xAABBCCDD11LL);
  radio.setAutoAck(1, true);
  radio.openReadingPipe (2, 0xAABBCCDD22LL);
  radio.setAutoAck(2, true);
  /*
    radio.openReadingPipe (3, 0xAABBCCDD33LL);
    radio.setAutoAck(3, true);
    radio.openReadingPipe (4, 0xAABBCCDD44LL);
    radio.setAutoAck(4, true);
    radio.openReadingPipe (5, 0xAABBCCDD55LL);
    radio.setAutoAck(5, true);
  */
  radio.startListening();

  Serial.begin(115200);
  Serial.println("Start..");
}


void loop()
{
  if (Serial.available() > 0) {
    String buf = Serial.readString();
    if (buf == "tx") {
      Serial.println("Start sening...");
      radio.stopListening();
      delay(10);
      radio.openWritingPipe(0xAABBCCDD11LL);
      byte bytte = 100;
      boolean status_data = radio.write(&bytte, sizeof(bytte));
      if (status_data) {
        Serial.println("Data sended!");
      }
      else {
        Serial.println("Data sent error");
      }
      delay(10);
      radio.startListening();
    }
  }
  if (radio.available(&pipe))
  {
    Serial.print("Got from..");
    radio.read( &transmit_data, sizeof(transmit_data) );

    if (pipe == 1)
    {
      Serial.println("Pipe 1");
      Serial.println(transmit_data);
    }
    if (pipe == 2)
    {
      Serial.println("Pipe 2 register pipe");
      if (transmit_data == 255) {
        Serial.println("Starting register!");
        radio.stopListening();
        delay(10);
        radio.openWritingPipe(0xAABBCCDD22LL);
        delay(10);
        byte new_id = random(1, 230);
        Serial.print("new id is:");
        Serial.println(new_id);
        boolean status_send = false;
        byte i = 0;
        while (!status_send && i < 10) {
          status_send = radio.write(&new_id, sizeof(new_id));
          delay(100);
          i++;
        }
        if (status_send) {
          Serial.println("Register OK");
        }
        else {
          Serial.println("Register ERR");
        }
        delay(10);
        radio.startListening();
      }
    }
  }
}

Код передатчика("датчика"):

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"
#define key 201
byte id_sensor = 0;
byte type_sensor = 1;
RF24 radio(9, 10);
struct message {
  byte id;
  byte type;
  byte data;
};
message send_data;
byte pipe = 0;
boolean register_sensor() {
  radio.stopListening();
  delay(10);
  radio.openWritingPipe(0xAABBCCDD22LL);
  delay(10);
  byte data = 255;
  boolean status_ = false;
  byte i = 0;
  while (!status_ && i < 100) {
    status_ = radio.write(&data, sizeof(data));
    delay(100);
    i++;
  }
  if (status_) {
    Serial.println("Send OK");
  }
  else {
    Serial.println("Send ERR");
    Serial.println("Restart....");
  }
  delay(50);
  radio.startListening();
  data = 0;
  while (!radio.available()) {
    delay(40);
  }
  radio.read(&data, sizeof(data));
  if (data > 0) {
    Serial.println("REG OK");
    id_sensor = data;
    delay(10);
    radio.closeReadingPipe(2);
    delay(10);
    return true;
  }
  else {
    Serial.println("REG ERR");
    return false;
  }
}
void setup() {
  Serial.begin(9600);
  radio.begin();
  radio.setAutoAck(true);
  radio.setChannel(120);
  radio.setDataRate (RF24_1MBPS);
  radio.setPALevel (RF24_PA_MAX);
  radio.powerUp();
  delay(10);
  radio.startListening();
  delay(10);
  radio.openReadingPipe (1, 0xAABBCCDD11LL);
  radio.setAutoAck(1, true);
  radio.openReadingPipe (2, 0xAABBCCDD22LL);
  radio.setAutoAck(2, true);
  //RF24_1MBPS
  Serial.println("Radio configured!");
  delay(100);
  if (id_sensor == 0) {
    register_sensor();
  }
}
void loop() {
  if (radio.available(&pipe)) {
    if (pipe == 1) {
      byte request = 0;
      radio.read(&request, sizeof(request));
      if (request == 100) {
        radio.stopListening();
        delay(10);
        radio.openWritingPipe(0xAABBCCDD11LL);
        delay(10);
        boolean send_status = false;
        byte i = 0;
        while (!send_status && i < 10) {
          send_status = radio.write(&id_sensor, sizeof(id_sensor));
          i++;
          delay(100);
        }
        delay(10);
        radio.startListening();
      }
    }
  }
}

ого... На гайвера наехала РосКомЦензура? :)

Ну уж туда я точно через VPN ходить не стану :)

Evgeniy2020 - в паре слов - в чем оказалась проблема и в чем суть "решения".?

Та вот хрен его знает) код чуть другой, и питание чуть другое и теперь работало 9 из 10, потом я поменял код и все опять вернулось..............

Вообщем что я понял) питание должно быть мега стабильным( я не до конца вставлял зарядку и видимо просаживался кондер и что-то висло)

Доброго времени суток) подскажите пожалуйста как мне хранить массив с трубами как-то так ?

uint64_t pipes[] = {0xAABBCCDD01LL,0xAABBCCDD0BLL};

uint64_t pipes[] = {0xAABBCCDD01LL,0xAABBCCDD0BLL};

Но, на мой взгляд, для хранения 6-байтовой величины использовать 8-байтовые переменные, особенно в условиях явно ограниченного объема памяти, довольно расточительно.

uint64_t pipes[] = {0xAABBCCDD01LL,0xAABBCCDD0BLL};

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

Ну так потому и 8 байт, что используется тип uint64_t.

Ну а вариант, естественно, самому определить структуру нужной длины.

PS. Кстати, я невнимательно посмотрел, похоже там вообще достаточно 5 байт.

PPS. А еще, если у всех "труб" один и тот же префикс, то и его хранить не обязательно, т.е. можно еще значительно подсократить объем.

Оки) думаю пока что остановлюсь одном из вариантов 

  uint8_t pipes[] = {0xAABBCCDD01LL,0xAABBCCDD0BLL};
  uint8_t pipes[][6] = {"1Node", "2Node"};

Новая проблема =) при использовании 

uint8_t address[][6] = {0xAABBCCDD11LL, 0xAABBCCDD22LL, 0xAABBCCDD33LL, 0xAABBCCDD44LL, 0xAABBCCDD55LL};

"регистрация" не пашет, но если использовать 

uint8_t address[][6] = {"1Node", "2Node"}; 

то работает... Хотя и так и так написано в документации к библеотеке.

Код базы:

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
byte id_sensor = 0;
byte type_sensor = 1;
RF24 radio(D4, D8);
struct message {
  byte id;
  byte type;
  byte data;
};
message rx_data;
uint8_t pipe = 0;
//uint8_t address[][6] = {0xAABBCCDD11LL, 0xAABBCCDD22LL, 0xAABBCCDD33LL, 0xAABBCCDD44LL, 0xAABBCCDD55LL};
uint8_t address[][6] = {"1Node", "2Node"};
boolean send_request() {
  radio.stopListening();
  radio.openWritingPipe(address[0]);
  boolean status_s = false;
  byte i = 0;
  byte data = 101;
  while (!status_s && i < 15) {
    status_s = radio.write(&data, sizeof(data));
    i++;
    delay(5);
  }
  if (status_s) {
    Serial.println("Request send!");
  }
  else {
    Serial.println("Request error");
  }
  radio.startListening();
  return status_s;
}
boolean register_() {
  radio.stopListening();
  radio.openWritingPipe(address[1]);
  boolean status_s = false;
  byte i = 0;
  rx_data.id = random(1, 50);
  Serial.print("New id is ");
  Serial.println(rx_data.id);
  while (!status_s && i < 15) {
    status_s =  radio.write(&rx_data, sizeof(rx_data));
    i++;
    delay(5);
  }
  if (status_s) {
    Serial.println("REG OK");
  }
  else {
    Serial.println("REG ERR");
  }
  radio.startListening();
  return status_s;
}
void setup() {
  Serial.begin(115200);
  radio.begin();
  radio.setAutoAck(true);
  radio.setChannel(120);
  radio.setDataRate(RF24_1MBPS);
  radio.setPALevel (RF24_PA_MAX);
  radio.openReadingPipe(1, address[0]);
  radio.openReadingPipe(2, address[1]);
  radio.setAutoAck(1, true);
  radio.setAutoAck(2, true);
  radio.powerUp();
  delay(100);
  radio.startListening();
}

void loop() {
  if (Serial.available() > 0) {
    String buffer_ = Serial.readString();
    if (buffer_ == "tx") {
      Serial.println("Start sending...");
      send_request();
    }
  }
  if (radio.available(&pipe)) {
    Serial.println("DATA recived!");
    radio.read(&rx_data, sizeof(rx_data));
    if (pipe == 1) {
      Serial.print("Pipe 1 Id: ");
      Serial.print(rx_data.id);
      Serial.print(" Type sensor: ");
      Serial.print(rx_data.type);
      Serial.print(" Data: ");
      Serial.println(rx_data.data);
    }
    else if (pipe == 2) {
      Serial.println("New module, veryfing....");
      if (rx_data.id == 0 && rx_data.data == 255) {
        Serial.println("VERIFED! Starting register...");
        register_();
      }
    }
    Serial.println(pipe);

  }

}

Код приемника:

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
byte id_sensor = 0;
byte type_sensor = 1;
RF24 radio(9, 10);
struct message {
  byte id;
  byte type;
  byte data;
};
message send_data;
uint8_t pipe = 0;
//uint8_t address[][6] = {0xAABBCCDD11LL, 0xAABBCCDD22LL, 0xAABBCCDD33LL, 0xAABBCCDD44LL, 0xAABBCCDD55LL};
uint8_t address[][6] = {"1Node", "2Node"};
void setup() {
  Serial.begin(115200);
  radio.begin();
  radio.setAutoAck(true);
  radio.setChannel(120);
  radio.setRetries(1,7);
  radio.setDataRate(RF24_1MBPS);
  radio.setPALevel (RF24_PA_MAX);
  radio.openReadingPipe(1, address[0]);
  radio.openReadingPipe(2, address[1]);
  radio.openWritingPipe(address[0]);
  radio.powerUp();
  radio.startListening();
  delay(100);
  if (id_sensor == 0) {
    //Start reg!
    Serial.println("Start registering....");
    radio.stopListening();
    delay(50);
    radio.openWritingPipe(address[1]);
    delay(300);
    Serial.println("Radio done!");
    send_data.id = 0;
    send_data.type = type_sensor;
    send_data.data = 255;
    boolean send_status = false;
    byte i = 0;
    while (!send_status && i < 15) {
      send_status = radio.write(&send_data, sizeof(send_data));
      delay(150);
      i++;
    }
    radio.startListening();
    if (!send_status) {
      Serial.println("Error register!(start infinyt while)");
      while (true) {}
    }
    while (!radio.available()) {}
    Serial.println("Data recived! Veryfing....");
    radio.read(&send_data, sizeof(send_data));
    if (send_data.id != 0 && send_data.type == type_sensor && send_data.data == 255) {
      Serial.println("REG OK");
      id_sensor = send_data.id;
    }
    else {
      Serial.println("REG ERR");
    }
    radio.stopListening();
    radio.openWritingPipe(address[0]);
    radio.startListening();
  }
}

void loop() {
  if (radio.available(&pipe)) {
    if (pipe == 1) {
      Serial.println("Data recived!");
      byte request = 0;
      radio.read(&request, sizeof(request));
      if (request == 101) {
        Serial.println("Request OK Start sending data..");
        radio.stopListening();
        boolean send_s = false;
        byte i = 0;
        send_data.id = id_sensor;
        send_data.type = type_sensor;
        send_data.data = random(1, 30);
        while (!send_s && i < 10) {
          send_s = radio.write(&send_data, sizeof(send_data));
          delay(50);
          i++;
        }
        if (send_s) {
          Serial.println("Data sended!");
        }
        else {
          Serial.println("Error of sending data");
        }
        radio.startListening();
      }
    }
  }
}

uint8_t address[][6] = {0xAABBCCDD11LL, 0xAABBCCDD22LL, 0xAABBCCDD33LL, 0xAABBCCDD44LL, 0xAABBCCDD55LL};

uint8_t address[][6] = {"1Node", "2Node"}; 

Евгений, а цель этих исследований какая? - Если хотите досконально разобраться, почему одно работает, а другое нет - копайте исходный код библиотеки, смотрите как используются эти параметры - потом нам расскажете.

А если вам просто надо, чтоб работало - пользуйте второй вариант

uint8_t address[][6] = {0xAABBCCDD11LL, 0xAABBCCDD22LL, 0xAABBCCDD33LL, 0xAABBCCDD44LL, 0xAABBCCDD55LL};

uint8_t address[][6] = {"1Node", "2Node"}; 

Может кто-то сталкивался! Копаться в либе мне лень)) но могу сразу сказать чуть не до смотрел, в доках написано так 

uint8_t addresses[][6] = {"1Node","2Node"};
openReadingPipe(1,addresses[0]);
openReadingPipe(2,addresses[1]);

http://tmrh20.github.io/RF24/classRF24.html#a9edc910ccc1ffcff56814b08faca5535

Всем) спасибо буду юзать так, как в доках

uint64_t pipes[] = {0xAABBCCDD01LL,0xAABBCCDD0BLL};

не подскажите что это у вас за редактор такой на скрине?

uint64_t pipes[] = {0xAABBCCDD01LL,0xAABBCCDD0BLL};

Подскажу =) Это эмулятор ардуино. Это сайт https://www.tinkercad.com/ где можно создавать 3d модели, а также относительно не давно появилась вкладка схемы. Где можно использовать много радиодеталей вместе с мк(когда создадите проект надо выбрать все инструменты), там есть и ЛБП. и аттини и разные драйвера и тд......