Arduino.ru

write() - правильно. А то похоже было, что через println() собрались отправлять.

С битовыми полями (#13) - наглядней.

typedef struct {
  uint8_t A : 1;
  uint8_t B : 1;
  uint8_t C : 1;
  uint8_t D : 1;
  uint8_t E : 1;
  uint8_t F : 1;
  uint8_t G : 1;
  uint8_t K : 1;
 } sms_t;


void setup() {
Serial.begin(9600);
}

void loop() {
sms_t packet;

packet.A=0;
packet.B=1;
packet.C=0;

Serial.println(packet.A);
Serial.println(packet.B);
Serial.println(packet.C);
delay(500);

}//loop

Как-то так?

Похоже на то, что надо.

Можно ещё и так:

typedef union {
  uint8_t setOne;  // 8 bits as the byte
  // the same bits, but splitted 
  struct {
    uint8_t A : 1;   // #0
    uint8_t B : 1;   // ...
    uint8_t C : 1;
    uint8_t D : 1;
    uint8_t E : 1;
    uint8_t F : 1;
    uint8_t G : 1;
    uint8_t K : 1;   // #7
  };
} sms_t;

void setup() {
  Serial.begin(115200);
}

void loop() {
  sms_t packet;
  packet.setOne = 0xFF;
  packet.A = 0;
  packet.B = 1;
  packet.C = 0;
  Serial.println(packet.A);
  Serial.println(packet.B);
  Serial.println(packet.C);

  Serial.println(packet.setOne, BIN);

  delay(500);

}//loop

Во-первых, 0 == FF не получается никак.

Во-вторых, уже изобретена масса способов, как обойти проблему трактовки отдельных байтов:

1. В протоколе MIDI все команды имеют старший бит 1, а данные - 0.

2. В кодировке UUE каждые 3 байта преобразуются в 4, чтобы избежать как совпадения со служебными символами, так и исключить символы сто старшим битом 1.

3. При кодировании целых чисел переменной длины в каждом байте используется 7 битов, а 8-й служит индикатором окончанияф числа.

Можно произвольным способом сочетать и модифицировать эти способы.

Да, это понятно. Но Онкель то не указывает что у него данные 7-битные! И если в той же КС вместо FF писать 0, чему верить? КС ведь тоже может иметь действительно 0-е значение? Как то неаккуратненько.

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

а как не заниматца, тут битрикс обновлял и стойкая мысль, что жрать осталось только бизонье дерьмо, но зато его много )))

PS я правда Самуи не знаю, знаю есть Самоа и Новая Гвинея, это оно?

Нет. Самуи - в Сиамском заливе. Придет starbit - опишет в красках. 

Настоящий мужик в еде должен быть непривередлив. Хоть говна, лишь бы полный рот. :-)

так это из анекдоту...
я к тому, что написали коду немерянно, только сайт завалился после их автоматического обновления PHP и Percona...и сидел полдня вытаскивал всё ручками...по старинке...из командной строки...

Совершенно неважна разрядность тех данных, что нужно передать. Хоть 21! Их всегда можно преобразовать в последовательность 7-разрядных. Или 6-разрядных, как в UUE.

Это все совершенно непринципиально. Можно в маркер писать 0, а в КС - FF. Можно в маркер писать А5, а к КС - 5А. Можно допустить совпадение КС с маркером, а можно саму КС сделать 7-разрядной - это все несущественные детали реализации.

typedef union {
  uint8_t setOne;  // 8 bits as the byte
  // the same bits, but splitted 
  struct {
    uint8_t A : 1;   // #0
    uint8_t B : 1;   // ...
    uint8_t C : 1;
    uint8_t D : 1;
    uint8_t E : 1;
    uint8_t F : 1;
    uint8_t G : 1;
    uint8_t K : 1;   // #7
  };
} sms_t;

void setup() {
  Serial.begin(115200);
}

void loop() {
  sms_t packet;
  packet.setOne = 0xFF;
  packet.A = 0;
  packet.B = 1;
  packet.C = 0;
  Serial.println(packet.A);
  Serial.println(packet.B);
  Serial.println(packet.C);

  Serial.println(packet.setOne, BIN);

  delay(500);

}//loop

Спасибо.

Всем большое Спасибо.

 sSerial.write((char *) & ports, sizeof(ports));
 delay(500);

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

Можно как-то отследить момент когда данные полностью отправятся?

https://www.arduino.cc/reference/en/language/functions/communication/serial/availableforwrite/

????????? !!!

 sSerial.write((char *) & ports, sizeof(ports));
 delay(500);

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

 sSerial.write((char *) & ports, sizeof(ports));
 delay(500);

Т.е. данные отправятся полностью, можно не делать паузу и проверку на отправку?

SoftSerial, судя по исходнику, заблокирует исполнение и будет дёргать ногами, пока байты не закончатся.  Так что по выходу из write() будет точно выплюнуто всё.

#include <SoftwareSerial.h>
#include "Packet.h"
const int8_t softRX = 6;
const int8_t softTX = 7;
const int8_t RT = 5;//Передача/прием
bool FlagTransmit = true;


SoftwareSerial sSerial(softRX, softTX);

void setup(void) {
Serial.begin(9600);
sSerial.begin(9600);
pinMode(RT, OUTPUT); 
Serial.println("MASTER console");
}

void loop(void) {

if (FlagTransmit){
digitalWrite(RT, HIGH); //передача 
AllThePorts ports;
ports.address = 1234;
ports.fillUp();
ports.setCRC();
sSerial.write((char *) & ports, sizeof(ports));
//delay(500);  
Serial.println("Otpravka");
FlagTransmit=false;

}else{
  
digitalWrite(RT, LOW); //приём
if (sSerial.available() >= (int) sizeof(AllThePorts)) {
AllThePorts ports;
sSerial.readBytes((char *) & ports, sizeof(ports));

if (ports.getCRC() == ports.crc){
 FlagTransmit=true; 
Serial.println("Priem"); 
//delay(500);  
}else {
Serial.print("Transmission error: ");
}
}  
  
  
}//if (FlagTransmit){
}//loop

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

if (sSerial.availableForWrite()==3) { 
sSerial.write((char *) & ports, sizeof(ports));
}

Так?

Не работает

if (sSerial.availableForWrite()==3) { 
sSerial.write((char *) & ports, sizeof(ports));
}

Так?

1. нет, не так.

2. В софт сериале метод write() блокирующий, поэтому вывод не буферизован и не нуждается в проверке.

3. в хард сериале метод write() НЕблокирующий, поэтому перед отправкой новой порции данных можно проверить наличие места в буфере. Только не на равенство чему-бы-то-ни-было.

4. метод write(const uint8_t *, size_t) возвращает число переданных байт. Таким образом можно следить за отсутствием пропажи байт, без проверки наличия свободного места.

5. Если речь про "типовые" Ардуино на 328-ом контроллере, то пропуск данных при передаче вообще невозможен даже без любых проверок. Метод write(uint8_t) возвращает 1, только после передачи байта или размещения его в буфер.

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

я не читал "кода выше", я написал, как работает сериал в Ардуино.

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

Если проблему устраняет делей, то это всегда проблема в алгоритме. Проблема НЕ в передаче - я тебе это объяснил. Ищи дальше.

Irinka, на форуме уже неоднократно обсуждалось : если идёт отправка и/или приём то не стоит использовать serial.print или любой другой задержки. Если отправка с delay работает,значит банально приемник не успевает обрабатывать данные. В качестве решения - сохранять в буфер, потом обрабатывать или как говорили выше - оптимизировать алгоритм.

Помогите разобраться.

На базе примера ЕвгенийП хочу организовать работу с модулем nRF24L01

Packet.h

#ifndef	PACKET_H
#define	PACKET_H

struct AllThePorts{
uint8_t	text, adr, crc;



	// Нужно вызвать перед отправкой
	void setCRC(void) { crc = getCRC(); }
	
	uint8_t getCRC(void) const {
		const uint8_t * p = reinterpret_cast<const uint8_t *>(this);
		uint8_t crc = 0xFF;
		for (uint8_t n = 0; n < sizeof(*this) - sizeof(crc); n++) {
			crc ^= *p++;
			for (uint8_t i = 0; i < 8; i++) crc = crc & 0x80 ? (crc << 1) ^ 0x31 : crc << 1;
		}
		return crc;
	}

}  __attribute__ ((packed));

#endif	//	PACKET_H

Передатчик:

#include "Packet.h"
#include <SPI.h>
#include "nRF24L01.h" 
#include "RF24.h"
RF24 radio(9, 10);
byte address="Test";


void setup() {
Serial.begin(9600);
radio.begin();
radio.setAutoAck(0);
//radio.setRetries(0, 15);
radio.enableAckPayload();
radio.setPayloadSize(32);
radio.openWritingPipe(address);
radio.setChannel(0x60);
radio.setPALevel (RF24_PA_MAX);
radio.setDataRate (RF24_250KBPS);
radio.powerUp();
radio.stopListening();
}


void loop() {
AllThePorts ports;
ports.text = B11100111;
ports.adr = B11111101;
ports.setCRC();
Serial.println("Sent: "); 
Serial.println(ports.text, BIN); 
Serial.println(ports.adr, BIN); 
radio.write((char *) & ports, sizeof(ports));
delay(1000);
}

Приёмник:

#include "Packet.h"

#include <SPI.h>
#include "nRF24L01.h" 
#include "RF24.h"
RF24 radio(9, 10);
byte address="Test";
byte pipeNo;   

void setup(){
Serial.begin(9600);
radio.begin();
//radio.setAutoAck(0);
//radio.setRetries(0,15);     //(время между попыткой достучаться, число попыток)
radio.enableAckPayload();    //разрешить отсылку данных в ответ на входящий сигнал
radio.setPayloadSize(32);     //размер пакета, в байтах
radio.openReadingPipe(1,address);
radio.setChannel(0x60);
radio.setPALevel (RF24_PA_MAX);
radio.setDataRate (RF24_250KBPS);
radio.powerUp();
radio.startListening();  //начинаем слушать эфир, мы приёмный модуль
}





void loop() {
//if (radio.available(&pipeNo) >= (int) sizeof(AllThePorts)) {
if (radio.available(&pipeNo)) { 
AllThePorts ports;  
radio.read((char *) & ports, sizeof(ports));
if (ports.getCRC() == ports.crc){
Serial.println(ports.text, BIN); 
Serial.println(ports.adr, BIN); 
}else{
Serial.print("Transmission error: ");
}
}


}

Не работает условие 

//if (radio.available(&pipeNo) >= (int) sizeof(AllThePorts)) {

Serial.println((int)sizeof(AllThePorts));

Выдаёт 3 байта, т.е. всё что я отправляю

Serial.print((int)radio.available(&pipeNo)); 

Выдаёт 1

И ещё вопрос, что-то я совсем ничего не поняла...

#include "Packet.h"
#include <SPI.h>
#include "nRF24L01.h" 
#include "RF24.h"
RF24 radio(9, 10);
byte address="Test";
bool FlagTx=true;
unsigned long TimeOtpr;


void setup() {
Serial.begin(9600);
radio.begin();
radio.setAutoAck(0);
//radio.setRetries(0, 15);
radio.enableAckPayload();
radio.setPayloadSize(32);
radio.openWritingPipe(address);
radio.setChannel(0x60);
radio.setPALevel (RF24_PA_MAX);
radio.setDataRate (RF24_250KBPS);
radio.powerUp();
}





void loop() {

if (FlagTx){
//FlagTx=false;
radio.stopListening();
delay(20);
AllThePorts ports;
ports.text = B11100111;
ports.adr = B11111101;
ports.setCRC();
Serial.println("Sent: "); 
radio.write((char *) & ports, sizeof(ports));
TimeOtpr=millis();  
}


/*
if (!FlagTx && millis()-TimeOtpr>=1000){
FlagTx=true;
}
*/

}

Раскоментировав строки в порт печатается "Sent: " раз в 1 секунду, но данные не отправляются. 

Или так:

if (FlagTx){
//FlagTx=false;
radio.stopListening();
delay(20);
AllThePorts ports;
ports.text = B11100111;
ports.adr = B11111101;
ports.setCRC();
Serial.println("Sent: "); 
radio.write((char *) & ports, sizeof(ports));
TimeOtpr=millis();
delay(1000);
}

Работает. Что не так то?

Я помочь в вопросе врятли смогу, так как сам вопрос не понял. Однако - как вы читаете свой код? В нем же полностью отсутсвует форматирование. Я пару минут только фигурные скобки разбирал (где открывается, где закрывается). 

Объяснять я мастерица...

Вопрос по #125 посту:

Почему (int)sizeof(AllThePorts) показывает 3 байта, которые я и отправляю, а (int)radio.available(&pipeNo) показывает 1 байт. В чём дело?

#127 пост:

#include "Packet.h"
#include <SPI.h>
#include "nRF24L01.h" 
#include "RF24.h"
RF24 radio(9, 10);
byte address="Test";
bool FlagTx=true;
unsigned long TimeOtpr;


void setup() {
Serial.begin(9600);
radio.begin();
radio.setAutoAck(0);
//radio.setRetries(0, 15);
radio.enableAckPayload();
radio.setPayloadSize(32);
radio.openWritingPipe(address);
radio.setChannel(0x60);
radio.setPALevel (RF24_PA_MAX);
radio.setDataRate (RF24_250KBPS);
radio.powerUp();
}





void loop() {
  
if (FlagTx){
radio.stopListening();
delay(20);
AllThePorts ports;
ports.text = B11100111;
ports.adr = B11111101;
ports.setCRC();
radio.write((char *) & ports, sizeof(ports));
Serial.println("Sent: "); 
TimeOtpr=millis(); 
FlagTx=true;
delay(1000);

}//if (FlagTx){

}//loop()

Вот к примеру:

41 строка кода FlagTx=true; или FlagTx=false;

Если в коде присутствует эта строка, данные не отправляются, но сообщение Sent выводится.Я не понима.ю что тут не так, ведь всё же элементарно

https://youtu.be/4pV8iIYvY4s

#include "Packet.h"

#include <SPI.h>

#include "nRF24L01.h"

#include "RF24.h"

RF24 radio(9, 10);
byte address = "Test";
unsigned long TimeOtpr;
bool FlagTx = false;

void setup() {
    Serial.begin(9600);
    radio.begin();
    radio.setAutoAck(0);
    //radio.setRetries(0, 15);
    radio.enableAckPayload();
    radio.setPayloadSize(32);
    radio.openWritingPipe(address);
    radio.setChannel(0x60);
    radio.setPALevel(RF24_PA_MAX);
    radio.setDataRate(RF24_250KBPS);
    radio.powerUp();
}




void loop() {

    if (!FlagTx) {
        FlagTx = true;
        radio.stopListening();
        delay(20);
        AllThePorts ports;
        ports.text = B11100111;
        ports.adr = B11111101;
        ports.setCRC();
        radio.write((char * ) & ports, sizeof(ports));
        Serial.println("Sent: ");
        TimeOtpr = millis();
    } //if (FlagTx){


    if (FlagTx && millis() - TimeOtpr >= 1000) FlagTx = false;



} //loop()

Путём проб и ошибок обнаружила, что если изначально bool FlagTx будет равен false то всё работает.

Почему так?

Последний код по логике работы вроде бы (не форматированный код я плохо читаю) не отличается от того что не работал. Так что вполне возможно где то операторные скобки не там стояли или ещё где опечатка была. 

Отличается лишь тем, что начальное значение боулена false. Скобки здесь не причем. При выносе условия в отдельную функцию так же не работает. Фигня какая-то.

PS код отформатировала

А теперь попробуй вот такое:

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

RF24 radio(9, 10);
byte address="Test";
unsigned long TimeOtpr;
bool FlagTx=true;                  // Объявление флага TX - заметь -> ИСТИНОЙ

void setup() {

  Serial.begin(9600);
  radio.begin();
  radio.setAutoAck(0);
//radio.setRetries(0, 15);
  radio.enableAckPayload();
  radio.setPayloadSize(32);
  radio.openWritingPipe(address);
  radio.setChannel(0x60);
  radio.setPALevel (RF24_PA_MAX);
  radio.setDataRate (RF24_250KBPS);
  radio.powerUp();
}

void loop() {

  if(FlagTx){                       // Если флаг разрешает отправку, то выполняем отправку "чего-то"
    radio.stopListening();
    delay(20);
    AllThePorts ports;
    ports.text = B11100111;
    ports.adr = B11111101;
    ports.setCRC();
    radio.write((char *) & ports, sizeof(ports));
    Serial.println("Sent: "); 
    TimeOtpr = millis(); 
    FlagTx = false;                   // Этим мы говорим, что уже отправили "что-то", надо бы "перекурить"...
  }//if (FlagTx){

  if(!FlagTx && millis()-TimeOtpr >= 1000) { // Если отправка запрещена, и мы уже "перекурили" 1 сек, то пора бы и поработать...
    FlagTx=true;                             // Разрешаем отправку
  }
}

И если все так же работает, значит это все была не мистика, а невнимательность и куча еще чего (отсутствие комментариев, форматирования - что в совокупности мешало проследить логику и отследить где-же "косяк").

Ну Вы же ничего не изменили в моём скетче, я написала, что работает только при изначальном значении false

https://youtu.be/jor4JwgUqLA

На видео Ваш код, и изменение на false

Мистика)

Я не могу ничего на это ответить.

Не успела ответить. Паузы я куда только не ставила, не в них дело.

И вот так как-то извращаться тоже пробовала (?):

void loop() {

    delay (1000);
    radio.stopListening();
    delay(20);
    AllThePorts ports;
    ports.text = B11100111;
    ports.adr = B11111101;
    ports.setCRC();
    radio.write((char *) & ports, sizeof(ports));
    Serial.println("Sent: "); 
    TimeOtpr = millis(); 
}

void loop() {

    radio.stopListening();
    delay(20);
    AllThePorts ports;
    ports.text = B11100111;
    ports.adr = B11111101;
    ports.setCRC();
    radio.write((char *) & ports, sizeof(ports));
    Serial.println("Sent: "); 
    TimeOtpr = millis(); 
    delay (1000);
}

и результат тот же - не отправляется?

Да, пробовала.

Результат тот же, и вместо bool пробовала byte и int, срабатывается если изначально число 0,а не 1

Можешь провести эксперимент (интереса ради)?

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

#include <SPI.h>                                          // Подключаем библиотеку для работы с шиной SPI
#include <nRF24L01.h>                                     // Подключаем файл настроек из библиотеки RF24
#include <RF24.h>                                         // Подключаем библиотеку для работы с nRF24L01+
RF24           radio(9, 10);                              // Создаём объект radio для работы с библиотекой RF24, указывая номера выводов nRF24L01+ (CE, CSN)
int            data[2];                                   // Создаём массив для отправки данных
void setup(){
    radio.begin();                                        // Инициируем работу nRF24L01+
    radio.setChannel(5);                                  // Указываем канал передачи данных (от 0 до 127), 5 - значит передача данных осуществляется на частоте 2,405 ГГц (на одном канале может быть только 1 приёмник и до 6 передатчиков)
    radio.setDataRate     (RF24_1MBPS);                   // Указываем скорость передачи данных (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS), RF24_1MBPS - 1Мбит/сек
    radio.setPALevel      (RF24_PA_HIGH);                 // Указываем мощность передатчика (RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm, RF24_PA_HIGH=-6dBm, RF24_PA_MAX=0dBm)
    radio.openWritingPipe (0x1234567890LL);               // Открываем трубу с идентификатором 0x1234567890 для передачи данных (на одном канале может быть открыто до 6 разных труб, которые должны отличаться только последним байтом идентификатора)
    radio.stopListening  ();                              // Вsключаем приемник
}
void loop(){
    data[0] = 5;                             // считываем показания Trema слайдера с вывода A1 и записываем их в 0 элемент массива data
    data[1] = 7;                             // считываем показания Trema потенциометра с вывода A2 и записываем их в 1 элемент массива data
    radio.write(&data, sizeof(data));                     // отправляем данные из массива data указывая сколько байт массива мы хотим отправить. Отправить данные можно с проверкой их доставки: if( radio.write(&data, sizeof(data)) ){данные приняты приёмником;}else{данные не приняты приёмником;}
}

А этот в приемник:

#include <SPI.h>                                          // Подключаем библиотеку  для работы с шиной SPI
#include <nRF24L01.h>                                     // Подключаем файл настроек из библиотеки RF24
#include <RF24.h>                                         // Подключаем библиотеку  для работы с nRF24L01+
RF24           radio(9, 10);                              // Создаём объект radio   для работы с библиотекой RF24, указывая номера выводов nRF24L01+ (CE, CSN)
int            data[2];                                   // Создаём массив для приёма данных
void setup(){
    delay(1000);
    Serial.begin(9600);
    radio.begin();                                        // Инициируем работу nRF24L01+
    radio.setChannel(5);                                  // Указываем канал приёма данных (от 0 до 127), 5 - значит приём данных осуществляется на частоте 2,405 ГГц (на одном канале может быть только 1 приёмник и до 6 передатчиков)
    radio.setDataRate     (RF24_1MBPS);                   // Указываем скорость передачи данных (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS), RF24_1MBPS - 1Мбит/сек
    radio.setPALevel      (RF24_PA_HIGH);                 // Указываем мощность передатчика (RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm, RF24_PA_HIGH=-6dBm, RF24_PA_MAX=0dBm)
    radio.openReadingPipe (1, 0x1234567890LL);            // Открываем 1 трубу с идентификатором 0x1234567890 для приема данных (на ожном канале может быть открыто до 6 разных труб, которые должны отличаться только последним байтом идентификатора)
    radio.startListening  ();                             // Включаем приемник, начинаем прослушивать открытую трубу
}
void loop(){
    if(radio.available()){                                // Если в буфере имеются принятые данные
        radio.read(&data, sizeof(data));                  // Читаем данные в массив data и указываем сколько байт читать
        Serial.print("One data: ");                       // Выводим data[0]
        Serial.println(data[0]);                          
        Serial.print("Two data: ");                       // Выводим data[1]
        Serial.println(data[1]);  
        Serial.println("Data send complite. Pause 2 cek");
        delay(2000);
    }
}

И что получится расскажи.

Вусмысле никакие флаги не используются? Где не используются?

В моём скетче я сама добавляю флаг, так как это мне необходимо.

Ваши скетчи не работают, ничего не приходит, нету даже radio.powerUp();

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

Может кто напишет, кто работал с ними - почему так на «левую» переменную оборудование реагирует.  

Я так и не разобраалсь, не получается.

Красавчик помоги...(С) XD

Я заметила, что если ставлю паузу 100 мкс,то по факту она больше

Потому что в коде ещё delay на 20 имеется?

Задержка примерно 1,5 сек получается

Может быть в библиотеки проблема с таймерами?

if (FlagTx){
//FlagTx=false;  
//radio.powerDown();
//delay(100);  
radio.powerUp();  
delay(20);  
radio.stopListening();  
delay(20);
AllThePorts ports;
ports.text = B11100111;
ports.adr = B11111101;
ports.setCRC();
//Serial.println(ports.text, BIN); 
//Serial.println(ports.adr, BIN); 
radio.write((char *) & ports, sizeof(ports));
TimeOtpr = millis();
Serial.println("Sent: ");
delay(1000);
}

С паузой я разобралась. Теперь стабильно раз в секунду данные отправляются-принимаются.

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

НО:

if (FlagTx){
FlagTx=false;  
//radio.powerDown();
//delay(100);  
radio.powerUp();  
delay(20);  
radio.stopListening();  
delay(20);
AllThePorts ports;
ports.text = B11100111;
ports.adr = B11111101;
ports.setCRC();
//Serial.println(ports.text, BIN); 
//Serial.println(ports.adr, BIN); 
radio.write((char *) & ports, sizeof(ports));
TimeOtpr = millis();
Serial.println("Sent: ");
delay(1000);
}

if(!FlagTx && millis()-TimeOtpr >= 2000) { 
FlagTx=true;
}

Без паузы попрежнему не работает

#include "Packet.h"
#include <SPI.h>
#include "nRF24L01.h" 
#include "RF24.h"
RF24 radio(9, 10);
byte address="Test";
bool FlagTx=false;
unsigned long TimeOtpr;



void setup() {
delay(2000);  
Serial.begin(115200);
radio.begin();
radio.setAutoAck(0);
//radio.setRetries(0, 15);
radio.enableAckPayload();
radio.setPayloadSize(32);
radio.openWritingPipe(address);
radio.setChannel(0x60);
radio.setPALevel (RF24_PA_MAX);
radio.setDataRate (RF24_250KBPS);
radio.powerUp();
//radio.stopListening();
}


void loop() {

if (!FlagTx){
FlagTx=true;  
//radio.powerDown();
//delay(100);  
radio.powerUp();  
delay(20);  
radio.stopListening();  
delay(20);
AllThePorts ports;
ports.text = B11100111;
ports.adr = B11111101;
ports.setCRC();
//Serial.println(ports.text, BIN); 
//Serial.println(ports.adr, BIN); 
radio.write((char *) & ports, sizeof(ports));
TimeOtpr = millis();
Serial.println("Sent: ");
//delay(1000);
}

if(FlagTx && millis()-TimeOtpr >= 1000) { 
FlagTx=false;
}


}

и если изначально значение флага false, то работает

Вот неужели кроме меня тема никому не интересна?  XDDD