Arduino.ru

А что каждый приёмник не может слать ещё и свой ID?

Наверное может, а как?

Ну, как Вы шлёте любую информацию, так и эту шлите. 

Не совсем понятно

Если брать фрагментом кода, то организовано так.

Приемник. Сначала принимает, потом шлет обратную переменную

if (radio.available()) {                                          // Запуск приема
radio.read(&msg, sizeof(msg) );           
fwd = msg[1];
bwd = msg[2];
spd = msg[3];
radio.writeAckPayload( 2, &ack2, sizeof(ack2));     
previousMillis = currentMillis + interv; 
} 

Передатчик. Цикл приема обратной связи.

 if (radio.available(0xAABBCCDD11LL)) {
 previousMillis1 = currentMillis1 +interval;
 radio.read(&ack1,sizeof(ack1));
}
 if (radio.available(0xAABBCCDD22LL)) {
 previousMillis2 = currentMillis2 +interval;
 radio.read(&ack2,sizeof(ack2));
}

Собственно при работе пульта с одним приемником все работает, а второй приемник шлет на эту же трубу, хотя указана другая. Начинается конфликт. 

В инете я не смог найти решение обратной связи для двух приемников

Ну, Вы шлите кроме этой переменной ещё и номер приёмника. Объедините их в один пакет и шлите. Тогда передатчик будет знать кто ему это присал

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

Есть ли фрагмент кода?

Я все это понимаю. Речь идет именно о двух приемниках, которые конфлитуют друг с другом даже на разных "трубах"

Кидать пакеты друг другу я умею :)

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

В чем вообще проблема - не ясно.

Проблема в том, что есть функция передачи пакета по "трубе", но нет функции ее приема. Как принять сигнал с двух передатчиков одновременно?

Очевидно, что "одновременно" один приемник может принять только один сигнал. Поэтому принимайте последовательно.

А зачем одновременно-то?
Можно:
1. Мастер - в режиме приёма. При получении пакета (структуры) смотрим идентификатор (кто прислал) и используем данные.
2. Мастер поочерёдно опрашивает слэйвов и получает данные, зная от кого они пришли.

В этом и вся проблема. Как заставить его узнавать кто прислал?

послушайте, сколько можно тупить! Вам уже раз шесть сказали, как это делается. Максимальный размер данных NRF24 - 32 байта. Отведите 1-2 байта из них под ID передатчика - и передавайте вместе с данными. ВСЕ.

Прежде чем задавать следующий одинаковый вопрос - попытайтесь вникнуть в уже полученные ответы.

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

Напрягите мозг и соберите пример сами. Вот у вас есть код сообщении #4. "Вперед" вы отправляете массив из трех элементов, а обратно - переменную ask2. Что мешает сделать ask2 массивом, где, к примеру - первый элемент будет номером передатчика, а второй - собственно данными?

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

Блин. Я все это понимаю, но

Если оба передатчика передают массив

array[2], то первый передатчик передает в переменной [1] свой идентификатор, а второй передатчик в этой же переменной передает [0]

Блин. Я все это понимаю, но

Если оба передатчика передают массив

array[2], то первый передатчик передает в переменной [1] свой идентификатор, а второй передатчик в этой же переменной передает 0

У вас данные с каждого передатчика нормально передаются? - так что мешает так же ID передавать? Вы длину данных на размер ID увеличили, я надеюсь?

приведите код, как вы отправляете массив.

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

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

ну мне-то это не нужно - это ж у вас ID при передаче теряется, не у меня.

вот центральный

#include <SPI.h>
#include <RF24.h>
#include <nRF24L01.h>

RF24 radio(9, 10);

const uint64_t pipe[2] = {0xE8E8F0F0E1LL, 0xE8E8F0F0E2LL};
byte dev_id, dev_val, temp_in[32][16], temp_out[32][16], timeout[32], flag[32], data_in[16], data_out[16];
byte id = 31;
byte dev_value = 32;
byte nrf_retry = 3;
unsigned long prevnrfmillis;
boolean  nrf_flag, flag_timeout;

void setup() {
  radio.begin();
  radio.setAutoAck(false);
  radio.setChannel(110);
  radio.setPALevel(RF24_PA_MAX);
  radio.setDataRate(RF24_250KBPS);
  radio.openReadingPipe(1, pipe[1]);
  radio.openWritingPipe(pipe[0]);
  radio.startListening();
}

void loop() {
  for (uint8_t i = 0; i < 16; i++) {
    data_out[i] = 0;
    data_in[i] = 0;
  }
  if (!nrf_flag) {
    data_out[0] = dev_id;
    temp_out[dev_id][0] = dev_id;
    for (uint8_t i = 0; i < 16; i++) {
      data_out[i] = temp_out[dev_id][i];
      temp_out[dev_id][i] = 0;
    }
    radio.stopListening();
    radio.flush_tx();
    radio.write(&data_out, sizeof(data_out) );
    radio.startListening();
    for (uint8_t i = 0; i < 16; i++) {
      data_out[i] = 0;
    }
    flag[dev_id] = false;
    nrf_flag = true;
    flag_timeout = false;
    prevnrfmillis = millis();
  }
  if (!flag_timeout && (millis() - prevnrfmillis > 20)) {
    flag_timeout = true;
  }
  if (radio.available() && !flag_timeout) {
    radio.read(&data_in, sizeof(data_in) );
    if (data_in[0] == dev_id) {
      for (uint8_t i = 0; i < 16; i++) {
        temp_in[dev_id][i] = data_in[i];
        data_in[i] = 0;
      }
      flag[dev_id] = true;
      //flag_timeout = true;
    }
  }
  if (flag_timeout) {
    timeout[dev_id] = timeout[dev_id] + 1;
    if (flag[dev_id]) {
      timeout[dev_id] = 0;
    }
   
    dev_id += 1;
    if (dev_id >= dev_val) {
      dev_id = 0;
    }
    nrf_flag = false;
 }
}

вот ведомые

#include <SPI.h>
#include "RF24.h"
#include "nRF24L01.h"

const uint64_t pipe[2] = {0xE8E8F0F0E1LL, 0xE8E8F0F0E2LL};
int t, h;
byte data_in[16], data_out[16];
boolean flag_sw;
byte id = 4;

RF24 radio(9, 10);

void setup() {
  radio.begin();
  radio.setAutoAck(false);
  radio.setChannel(110);
  radio.setPALevel(RF24_PA_MAX);
  radio.setDataRate(RF24_250KBPS);
  radio.openReadingPipe(1, pipe[0]);
  radio.openWritingPipe(pipe[1]);
  radio.startListening();
}

void loop() {
  if ( radio.available() ) {
    while (radio.available()) {
      radio.read( &data_in, sizeof(data_in));
      if (data_in[0] == id) {
        flag_sw = true;
        for (uint8_t i = 0; i < 16; i++) {
          data_in[i] = 0;
        }
      }
    }
  }
  if (flag_sw == true) {
    data_out[0] = id;
    data_out[1] = ((t >> 8) & 0xFF);
    data_out[2] = (t & 0xFF);
    data_out[3] = ((h >> 8) & 0xFF);
    data_out[4] = (h & 0xFF);
    radio.stopListening();
    radio.write( &data_out, sizeof(data_out) );
    radio.startListening();
    for (uint8_t i = 0; i < 16; i++) {
      data_out[i] = 0;
    }
    flag_sw = false;
  }
}

А почему автоответ выключен?

он мне не нужен, только эфир засоряет

Megawollt - посмотрел еще раз ваш код из сообшения #4. Что-то вы странно с массивом работаете. Вы не забыли, что в массиве из трех элементов их индексы будут 0, 1 и 2, а не 1,2,3 ?

Может у вас именно поэтому с передачей проблемы. что вы индексы массивов путаете?

Не забыли. Индексы не путаем. Массив обозначен как четырехэлементный. :Р

Я не настолько туп, как вы думете, да и проблем с передачей массива нет. Оба приемника работают и массивы свои получают.

Приемники кидают обратно переменную float, напряжение на аккумуляторах. Так вот доходит только одна

Вот код. Передатчик

#include <nRF24L01.h>
#include <RF24.h>
#include <SPI.h>
#include <U8glib.h>


#define potPin      A0     //Вывод резистора скорости
#define uPin        A3    //Вывод напряжения батареи
#define fwdPin      0    //Вывод кнопки "Вперед"
#define bwdPin      2   //Вывод кнопки "Назад"
#define LED         1  //Пин диода 

//Контакты от радиомодуля NRF24L01 подключаем к пинамнам:
//SCK -> 13//MISO -> 12//MOSI -> 11//CSN -> 10//CE -> 9

U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE);  // I2C / TWI 
RF24 radio(9, 10);                        //Подключения радиоблока

                
long previousMillis1 = 0;  
long previousMillis2 = 0;  
const int interval = 2000;          //Интервал ожидания обратного пакета
double ubat = 0.0;                //Напряжение батареи
byte spd_d = 0;                  //Скорость для отображения на дисплее                  //Комманда "Назад"
int pipe;
int msg[4]; 
int ack1;
int ack2;
float vout1 = 0.0;
float vin1 = 0.0;
float vout2 = 0.0;
float vin2 = 0.0;
float R1 = 100000.0; 
float R2 = 10000.0; 
unsigned long timer1;  


void setup(){
  pinMode(fwdPin, INPUT);                //Режимы пинов
  pinMode(bwdPin, INPUT);
  pinMode(LED, OUTPUT);
  digitalWrite(bwdPin, HIGH);
  digitalWrite(fwdPin, HIGH);
  digitalWrite(LED, LOW);
  ubat = (analogRead(uPin) * 5.35) / 1023.0;
  radio.begin();
  radio.setDataRate(RF24_250KBPS);                   // Скорость передачи
  radio.setChannel(112);                            // Номер канала от 0 до 127
  radio.setPALevel(RF24_PA_MAX);                   // Мощность передатчика
  radio.setRetries(15, 15);                       // Кол-во попыток и время между попытками
  radio.enableDynamicPayloads();
  radio.enableAckPayload();
  radio.setAutoAck(1);
  radio.openWritingPipe(0xF0F0F0F0FFLL);         // Открываем канал передачи
  radio.openReadingPipe(1,0xAABBCCDD11LL);      // Открываем один из 6-ти каналов приема
  radio.openReadingPipe(2,0xAABBCCDD22LL);
//radio.startListening();                      // Начинаем слушать эфир

  u8g.setRot180();
  u8g.setFont(u8g_font_6x12);
} //end setup

void loop(){                                 //Начало цикла
  u8g.firstPage();  
  do {
  u8g.drawRFrame(1, 1, 127, 31, 1); 
  unsigned long currentMillis1 = millis();  
  unsigned long currentMillis2 = millis();
  
  if (millis()> timer1 + 10000){
  ubat = (analogRead(uPin) * 5.35) / 1023.0;          //Замер напряжения батареи
  timer1 = millis();  
  }
 
  msg[3] = map(analogRead(potPin), 1023, 0, 255, 50);   //Маппинг 10 бит в 8 бит
  spd_d = map(msg[3], 50, 255, 20,100);                //Маппинг скорости для дисплея из 255 в 100

vout1 = (ack1 * 5.0) / 1024.0;
vin1 = vout1 / (R2/(R1+R2));
if (vin1<0.09) {
vin1=0.0;
}
vout2 = (ack2 * 5.0) / 1024.0;
vin2 = vout2 / (R2/(R1+R2));
if (vin2<0.09) {
vin2=0.0;
}


 
 if (radio.available(&pipe)) {
 if(pipe == 1){
 previousMillis1 = currentMillis1 +interval;
 radio.read(&ack1,sizeof(ack1));
}
 if (pipe == 2) {
 previousMillis2 = currentMillis2 +interval;
 radio.read(&ack2,sizeof(ack2));
}
}

//  Строка напряжения батареи
  u8g.setPrintPos(70, 10);
  u8g.print("Bat");
  u8g.setPrintPos(95, 10);
  u8g.print(ubat);
  u8g.print("V");

if(msg[1] == 111 || msg[2] == 222){
digitalWrite(LED, HIGH);
}
else{
digitalWrite(LED, LOW);  
}
  

  //Строка скорости
  
   u8g.setPrintPos(5, 10);
   u8g.print("Speed ");
   u8g.print(spd_d);
   u8g.print("%");

  //Строка соединения
  if (currentMillis1 < previousMillis1) {   
  u8g.setPrintPos(5, 20);
  u8g.print("Connected ");
  u8g.print("Acc ");
  u8g.setPrintPos(90, 20);
  u8g.print(vin1);
  u8g.print("V");
 }
  else {
u8g.setPrintPos(25, 20);
u8g.print("Not connected");
ack1 = 0;
}
  if (currentMillis2 < previousMillis2) {   
u8g.setPrintPos(5, 30);
  u8g.print("Connected ");
  u8g.print("Acc ");
  u8g.setPrintPos(90, 30);
  u8g.print(vin2);
  u8g.print("V");
}
  else {
u8g.setPrintPos(25, 30);
u8g.print("Not connected");
ack2 = 0;
}

  //если кнопка "Вперед" нажата ...
  if (digitalRead(fwdPin) == LOW && !digitalRead(bwdPin) == LOW){
  msg[1] = 111;
  msg[2] = 0; 
  }
   
  //если кнопка "Назад" нажата ...
else if (digitalRead(bwdPin) == LOW && !digitalRead(fwdPin) == LOW){
  msg[2] = 222;
  msg[1] = 0; 
  }
 else {
 msg[1] = 0; 
 msg[2] = 0; 
 }
 
 radio.write(&msg,sizeof(msg));

} while(u8g.nextPage());
} //Конец цикла

Приемник

#include <nRF24L01.h>
#include <RF24.h>
#include <SPI.h>

#define voltmeter A3                  //Вывод вольтметра
#define directPin1 7                
#define directPin2 8                                   //Вывод управления направлением
#define conLed    0               //Вывод светодиода соединения
#define movLed    1              //Вывод светодиода движения   
#define motPin1    5 
#define motPin2    6                 //Вывод управления мотором
#define brake1    A1
#define brake2    A0   

class Timer {

public:
unsigned long previous;
unsigned long interval;
boolean s;
boolean tick;

Timer() {
previous = millis();
s        =        0;
tick     =        0;
}
void  stop()                        {s =  0;                      }
void start()                        {s =  1;                      }
void  read(unsigned long _interval) {
              interval = _interval;
unsigned long current  =  millis();                      tick = 0;
if (s == 0) {previous = current;          }
if (current - previous >  interval) {previous = current; tick = 1;}
}
};

RF24 radio(9, 10);                // Выводы трансивера
Timer timer2;

long previousMillis = 0;        // Переменная внутреннего таймера
int interv = 1500;          // Интервал ожидания соединения
int msg[4];                // Массив переменных приема

byte val;           //Значение ШИМ
int ack2;
unsigned long timer1; 
unsigned long timer3; 
byte fwd;
byte bwd;
byte spd;
bool flag1;
bool flag2;

void setup() {    //Установки
                                 
  pinMode(conLed , OUTPUT);                                // Вывод индикатора соединения
  pinMode(movLed, OUTPUT);                                // Режим индикатора движения
  pinMode(directPin1, OUTPUT);                           // Режим вывода управления
  pinMode(directPin2, OUTPUT); 
  pinMode(motPin1, OUTPUT);
  pinMode(motPin2, OUTPUT);
  pinMode(brake1, OUTPUT);
  pinMode(brake2, OUTPUT);
  
  digitalWrite(conLed , HIGH);                              
  digitalWrite(movLed, HIGH);                                
  digitalWrite(directPin1, LOW);   
  digitalWrite(directPin2, LOW); 
  digitalWrite(motPin1, LOW);
  digitalWrite(motPin2, LOW);
  digitalWrite(brake1, HIGH);
  digitalWrite(brake2, HIGH);
  delay(1500);
  digitalWrite(brake1, LOW);
  digitalWrite(brake2, LOW);
  digitalWrite(conLed , LOW);                              
  digitalWrite(movLed, LOW); 
  
  
  radio.begin();                                        // Включение радиосвязи
  radio.setDataRate(RF24_250KBPS);                     // Скорость передачи
  radio.setChannel(112);                              // Номер канала от 0 до 127
  radio.setPALevel(RF24_PA_MAX);                     // Мощность передатчика
  radio.setRetries(15, 15);                         // Кол-во попыток и время между попытками
  radio.enableAckPayload();
  radio.enableDynamicPayloads();
  radio.setAutoAck(0xAABBCCDD22LL,1);                            // Автоотправка обратного пакета
  radio.openWritingPipe(0xAABBCCDD22LL);         // Открываем канал передачи
  radio.openReadingPipe(1, 0xF0F0F0F0FFLL);     // Открываем один из 6-ти каналов приема
  radio.startListening();                      // Начинаем слушать эфир
   
   ack2 = analogRead(voltmeter);         //Блок вольтметра
         
timer2.start();  
}//Конец установок

void loop() {                                // Начало цикла
  unsigned long currentMillis = millis();   // Вспомогательная переменная таймера
 
   if (millis()> timer1 + 10000){
   ack2 = analogRead(voltmeter);         //Блок вольтметра
   timer1 = millis();
  }
  
if(val > spd){
val = spd;
 analogWrite(motPin1, val);
 analogWrite(motPin2, val);
}
   
timer2.read(10);   
   
if (radio.available()) {                                          // Запуск приема
radio.read(&msg, sizeof(msg) );           
fwd = msg[1];
bwd = msg[2];
spd = msg[3];
radio.writeAckPayload( 1, &ack2, sizeof(ack2));     
previousMillis = currentMillis + interv; 
} 

  if (fwd == 111 || bwd == 222) {         // Зажигает светодиод при приеме сигнала движения
  digitalWrite(movLed, HIGH);
  
  digitalWrite(brake1, HIGH);
  digitalWrite(brake2, HIGH); 
  }
  else {
    digitalWrite(movLed, LOW);
  } 
if (fwd != 111 && bwd != 222 && val == 0) { 
timer3 = millis();
}
  
  if (currentMillis > previousMillis) {       // Сброс переменных при разрыве связи
    if(val == 0) {digitalWrite(brake1, LOW); digitalWrite(brake2, LOW);}
    digitalWrite(conLed, LOW);               // Выключение индикатора связи
    fwd = 0;
    bwd = 0;
  }
  
  else {                                  // Включение индикатора при соединении
    digitalWrite(conLed, HIGH);
  }

if(fwd == 111 && flag2 !=1 &&  (millis() > timer3 + 200)){
  digitalWrite(directPin1, HIGH);
  digitalWrite(directPin2, HIGH);
flag1 = 1;
if(timer2.tick && val < spd){
val++;  
 analogWrite(motPin1, val);
 analogWrite(motPin2, val);
}
}
else if(bwd == 222 && flag1 != 1 && (millis() > timer3 + 200)){
 digitalWrite(directPin1, LOW);
 digitalWrite(directPin2, LOW);  
flag2 = 1;
if(timer2.tick && val < spd){
val++;  
 analogWrite(motPin1, val);
 analogWrite(motPin2, val);
}
}

else{ 
if(val == 0){
flag1 = 0; flag2=0;  
digitalWrite(brake1, LOW);
digitalWrite(brake2, LOW);
}
if(timer2.tick && val > 0){
val--;  
 analogWrite(motPin1, val);
 analogWrite(motPin2, val);
}
}



}//Конец цикла

Коды передатчика и приемника не перепутали? Почему в передатчике две приемных трубы, а в приемнике одна? Разве примник не должне принимать данные от двух передатчиков?

И еще - я так и не увидел, где же вы передаете уникальный ID приемников/передатчиков вместе с данными.

И поясните еще раз на примере кода. что за проблема у вас.

А код - он, конечно, кривоватый. Миллисом вы категорически неправильно пользуетесь. Ну и функцией map() тоже не всегда.

В передатчике 2 применых трубы, так как он принимает обратную связь с двух приемников.

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

Проблема в том, что с одного приемника приходит обратная связь, а с другого нет и я понимаю, что ошибка где то в реализации труб или команд

Трубы у приемников естественно разные.

И миллис и мап работают. По другому я не умею. Если поясните, буду признателен

ID от труб никак не зависит, поэтому шанс, что это поможет - весьма велик. А вот разные трубы, уже очевидно-  не работают. Поэтому тут два пути - либо неизвестно сколько искать ошибки в использовании вашего метода, либо просто пойти другим путем и использовать разные ID для разных источников. Но дело ваше...

Я вообще замечаю, что вы не очень-то склонны слушать советы. Непонятно, зачем вы тогда их просите.

Про миллис писано сотни страниц. Если вкратце - если вы складываете  время и интервал, то при переполнении миллис это давет ошибку. Если вычитаете интервалы - то все считается правильно даже при переполнении:

currentmillis > previous_millis + interval    // НЕВЕРНО

currentmillis - prev_millis > interval         // Верно

Я люблю слушать советы, если они подкреплены фрагментами кода и ясны для меня.

Вот про миллис очень доходчиво, спасибо.

То есть, если задавать идентификатор, то от идеи с автоответом нужно отказаться вовсе и использовать start и stoplistening?

Я пока не знаю, как совместить автответ и идентификаторы. Большинство решений приходит тогда, когда что-то делаешь. Поэтому я бы просто попробовал написать код с идентификаторами - и посмотрел, решит ли это проблему.

Примеры кода вам давал Валера в сообщении #22

Вот я третий день сижу пробую, поэтому и спросил, может уже кто делал подобное. Даже видео осипова смотрел, но он до автоответов не добирался, а если не использовать автоответы, то индикация статуса соединения не будет стабильна

Честно говоря, с практической точки зрения не вижу никакой разницы между "автответом" и ответом "вручную". Общеизвестно, что функция Авто-Аск у НРФ-ок глючная и поэтому большинство ее отключает.  Но дело ваше.

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

Спасибо, понял вас. А можно прямо посреди кода включать старт и стоп прослушивания? Не будет ли оно мешать самому передатчику?

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

Там есть некий буфер памяти? Иначе же прием/передача не будут включаться синхронно

Valera19701 в вашем коде приемники ничего не шлют в обратку, а у меня проблема именно в этом

а что делают строки с 36 по 46 ?

del

Извините, проглядел. Как команда avaliable различает с какой трубы пришли данные?

У меня сейчас вот так

 if (radio.available(0xAABBCCDD11LL)) {
 radio.read(&ack,sizeof(ack));
 if(ack[2]==1){
 u1 = ack[1];
 previousMillis1 = currentMillis1 +interval;
 }
}
 if (radio.available(0xAABBCCDD22LL)) {
 radio.read(&ack,sizeof(ack));
 if(ack[4]==1){
 u2 = ack[3];
 previousMillis2 = currentMillis2 +interval;
 }
}

первой трубой прекрасно работает, а вторую не видит....Почему так может быть?

опять трубы...

Вы все-таки не въезжаете в базовый принцип. При использовании ID нет необходимости "различать трубы". Да их и не нужно много - откройте одну трубу для всех данных.. Понимаете, при использовании номеров датчиков информация, откуда пришли данные - содержится в самих данных. Вот, посмотрите внимательнее код Валеры - он принимает данные с передатчиков в строках 53-62. Принимается 16 байт, где первый (нулевой) - это номер датчика, а остальные байты - данные.

Что тут непонятного, что мы уже десятки сообщений мусолим?

А зачем тогда нужны трубы? Если передатчик 1 шлет по номеру [0] единицу, то другой то шлет ноль в эту же ячейку

вы, блин, пробовали?!!! - сколько можно писать хрень, а? попробуйте сначала

Не умеете сами - скопируйте код Валеры. У него все работает.

Пробовали.

Код передатчика(Приемная часть)

radio.startListening(); 
 if (radio.available()) {
 while (radio.available()) {
 radio.read(&ack,sizeof(ack));
 if(ack[0]==1){
 u1 = ack[1];
 previousMillis1 = currentMillis1 +interval;
 }
 if(ack[0]==2){
 u2 = ack[2];
 previousMillis2 = currentMillis2 +interval;
 }
}
 }
radio.stopListening();

Код приемника(Передающая)

if (radio.available()) {                                          // Запуск приема
while (radio.available()) {
radio.read(&msg, sizeof(msg) );           
fwd = msg[1];
bwd = msg[2];
spd = msg[3];
ack[0] = 1;
ack[1] = ans;
previousMillis = currentMillis + interv; 
radio.stopListening();
radio.flush_tx();
radio.write(&ack, sizeof(ack)); 
radio.startListening();    
} 
}

ack[0] это идентификатор. Что не так?

в первом коде, если номер передатчика ==1 , вы читаете ответ из ack[1], а если передатчик ==2 - то из ack[2]. хотя в коде приемника отправляете ответ только в ack[1].

Это только по этим огрызкам. Приведите полный код этого примера - уверен, найдутся и еще ошибки

кстати, в вашем коде с трубами (сообщение №41) - похоже, такая же ошибка. Вы в первом передатчике читаете ответ из ack[1] и ack[2]. а во втором - из ack[3] и ack[4].

Это неправильно, нужно в обоих передатчиках читать данные из одни и тех же ячеек, иначе разные трубы просто не имеют смысла.

Вот оно как. Я рассчитывал, что элемент массива 0 это идентификатор, 1 это напряжение на первом приемнике, 2- напряжение на втором. Так нельзя? Надо слать в одну ячейку и по одной трубе, а разным будет только идентификатор 0?

можно, только у вас все в кучу. В том, что вы описали выше - ажно три разных варианта:

1 если элемент массива 0 это идентификатор, то не нужно распихивать данные по разным ячейкам и не нужны разные трубы

2 если трубы разные - то не нужны идентификаторы и не нужно распихивать данные по разным ячейкам

3 если данные от разных приемников в разных ячейках - нет нужды в трубах и идентификаторах

Вы же пытаетесь одновременно применить ВСЕ ТРИ подхода. В принуипе, при грамотном программировании - можно и все три. Только. будем честны - где "грамотное программирование" и где вы...

Вам  уже 100 раз обьяснили:

Первый байт - " я чайник",
Второй байт -  " я на кухне",
Третий байт - " я кипюююююю".
..... и так далее до бесконечности ( вернее до 32 байт)