Arduino.ru

Народ вчем косяк ?ну не как с этим milles ошибка со строки 064 if(digitalRead(BUTTON1) == 0)и нужо-ли в 060 //выесняем не настал ли момент смены состояния светодиода

#include "NRF24L01.h"

//***************************************************
#define TX_ADR_WIDTH    5   //5 неподписанных символы Техас (RX) ширина адрес
#define TX_PLOAD_WIDTH  23  //   без знака символы Техас полезной нагрузки

int ledLED1=5;//номер пина со светодидиодом
int ledState1=LOW;//состояние светодиода
int pinBUTTON1=A0;//пин,к которому подключена кнопка

//последний момент времени, когда состояние светодиода изменилось
unsigned long previousMilles1=0;
long OnTime1=1000;//длительность свечения светодиода (в миллисекундах)
long OttTime1=50;//свечение не горит(в миллисекундах)

int ledLED2=6;//номер пина со светодидиодом
int ledState2=LOW;//состояние светодиода
int pinBUTTON2=A1;//пин,к которому подключена кнопка

//последний момент времени, когда состояние светодиода изменилось
unsigned long previousMilles2=0;
long OnTime2=1000;//длительность свечения светодиода (в миллисекундах)
long OttTime2=50;//свечение не горит(в миллисекундах)

int ledLED3=7;//номер пина со светодидиодом
int ledState3=LOW;//состояние светодиода
int pinBUTTON3=A3;//пин,к которому подключена кнопка

//последний момент времени, когда состояние светодиода изменилось
unsigned long previousMilles3=0;
long OnTime3=1000;//длительность свечения светодиода (в миллисекундах)
long OttTime3=50;//свечение не горит(в миллисекундах)





//***************************************************

unsigned char TX_ADDRESS[TX_ADR_WIDTH]  = 
{
  0xaa,0xbb,0xcc,0xdd,0xee
}; // Define a static TX address// Определить статический адрес TX
unsigned char rx_buf[TX_PLOAD_WIDTH] = {0}; // Инициализировать значение
unsigned char tx_buf[TX_PLOAD_WIDTH] = {0};// Инициализировать значение
//***************************************************

void setup() // недействительными установки
{
  SPI_DIR = ( CE + SCK_pin + CSN + MOSI_pin);
  SPI_DIR &=~ ( IRQ + MISO_pin);
  init_io();                        // Инициализировать IO порт
  unsigned char status=SPI_Read(STATUS);
  initialize_R_T();
  
  }
 
void loop()// недействительными цикл ()
{
  
    unsigned char Rx_szTemp[1] = {0}; // держать полученные данные
  
    //Start TX mode // Запуск режима TX 
    if(digitalRead(BUTTON1) == 0)
    {
       RF_SendData("1");   // отправить '1' через модуль РФ
    }
    else if(digitalRead(BUTTON2) == 0)// иначе, если
    {
       RF_SendData("2");   //send '2' through RF module
    }
    else if(digitalRead(BUTTON3) == 0)
    {
       RF_SendData("3");  //send '3' through RF module
    }
    
    //RX mode// Режим приема
    RF_ReceiveData(&Rx_szTemp[0]); // получить данные от модуля РФ
     
    if(Rx_szTemp[0] == '1')   // если = полученные данные '1'
     {
      if((ledState1=HIGH)&&(currentMilles-previousMilles1>=OnTime1))
     }
       LedState1=LOW;//включам
       previousMilles1=currentMilles;//запоминаем момент времени
       digitalWrite(ledPin1,ledState1);//реализуем новое состояние
      {
     else if((ledState1==LOW)&&(currentMilles-previousMilles1>OffTime1))
      }
      ledState1=HIGH;//выключам
      previousMilles1=currentMilles;//запоминаем момент времени
      digitalWrite(ledPin1,ledState1);//реализуем новое состояние
      {
       
    else if(Rx_szTemp[0] == '2')  // если = полученные данные '2'
     }
      if((ledState2=HIGH)&&(currentMilles-previousMilles2>=OnTime2))
     {
       LedState2=LOW;//включам
       previousMilles2=currentMilles;//запоминаем момент времени
       digitalWrite(ledPin2,ledState2);//реализуем новое состояние
     }
     else if((ledState2==LOW)&&(currentMilles-previousMilles2>OffTime2))
     {
      ledState2=HIGH;//выключам
      previousMilles2=currentMilles;//запоминаем момент времени
      digitalWrite(ledPin2,ledState2);//реализуем новое состояние
      }
    else if(Rx_szTemp[0] == '3')  // если = полученные данные '3'
     {
       if((ledState3=HIGH)&&(currentMilles-previousMilles3>=OnTime3))
       }
       LedState3=LOW;//включам
       previousMilles3=currentMilles;//запоминаем момент времени
       digitalWrite(ledPin3,ledState3);//реализуем новое состояние
     {
     else if((ledState3==LOW)&&(currentMilles-previousMilles3>OffTime3))
      }
      ledState3=HIGH;//выключам
      previousMilles3=currentMilles;//запоминаем момент времени
      digitalWrite(ledPin3,ledState3);//реализуем новое состояние
      }
     }
    }


//**************************************************
// Function: init_io();// Функция: init_io ();
// Description:// Описание:
// flash led one time,chip enable(ready to TX or RX Mode),// Светодиодной вспышкой один раз, чип позволит (готовый TX RX или режим),
// Spi disable,Spi clock line init high// Спи отключить, SPI часы линии инициализировать высокой
//**************************************************
void init_io(void)//недействительными init_io (недействительными)
{
  SPI_PORT&=~CE;			// Чип позволит
  SPI_PORT|=CSN;			// Спи отключить	
  SPI_PORT&=~SCK_pin;			// Спи часы линии инициализировать высокой
}

/**************************************************
 * Function: SPI_RW();//Функция: SPI_RW ();
 * 
 * Description:// Описание:
 * Writes one unsigned char to nRF24L01, and return the unsigned char read
 * from nRF24L01 during write, according to SPI protocol
   Пишет один неподписанный символ для NRF24L01, и вернуть неподписанные символ читать
 * От NRF24L01 во пишут, в соответствии с протоколом SPI
 **************************************************/
unsigned char SPI_RW(unsigned char Byte)//подписанные символ SPI_RW (неподписанные символ байт)
{
  unsigned char i;                      //неподписанные символ я;
  for(i=0;i<8;i++)                      // выход 8-бит
  {
    if(Byte&0x80)                       //если (байт & 0x80)
    {
      SPI_PORT |=MOSI_pin;    // Выход "неподписанные символ ', MSB для MOSI_pin
    }
    else                     //другой        
    {
      SPI_PORT &=~MOSI_pin;
    }
    SPI_PORT|=SCK_pin;                     // Установить SCK_pin высокий ..
    Byte <<= 1;                         // Сдвиг следующий бит в MSB ..
    if(SPI_IN & MISO_pin) //если (SPI_IN & MISO_pin)
    {
      Byte |= 1;       	        // Захватить текущее MISO_pin немного
    }
    SPI_PORT&=~SCK_pin;            	       // ..то Установить SCK_pin низкий снова
  }
  return(Byte);           	       // Возврат прочитать неподписанные символ
}
/**************************************************/

/**************************************************
 * Function: SPI_RW_Reg(); // Функция: SPI_RW_Reg ();
 * 
 * Description:// Описание:
 * Writes value 'value' to register 'reg'// Записывает значение '' значение для регистрации '' рег
/**************************************************/
unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value)//неподписанные символ SPI_RW_Reg (неподписанные символ рег, символьное значение без знака)
{
  unsigned char status;// неподписанных статус символ;

  SPI_PORT&=~CSN;                   // ДНС низкий, инициализировать сделка SPI
  status = SPI_RW(reg);             // Выбрать регистр
  SPI_RW(value);                    // ..и Значение записи к нему ..
  SPI_PORT|=CSN;                    // ДНС высокой снова

  return(status);                   // Вернуть NRF24L01 статус неподписанные символ
}
/**************************************************/

/**************************************************
 * Function: SPI_Read();//Функция: SPI_Read_Buf ();
 * 
 * Description://Описание:
 * Read one unsigned char from nRF24L01 register, 'reg'Читайте одну неподписанные символ из регистра NRF24L01, "рег"
/**************************************************/
unsigned char SPI_Read(unsigned char reg)//неподписанные символ SPI_Read (неподписанные символ рег)
{
  unsigned char reg_val;// неподписанные символ reg_val;

  SPI_PORT&=~CSN;                // ДНС низкий, инициализировать SPI связь ...
  SPI_RW(reg);                   // Выбор зарегистрируйтесь, чтобы читать из ..
  reg_val = SPI_RW(0);           // ..то Прочитать значение регистра
  SPI_PORT|=CSN;                 // ДНС высокий, прекратить общение SPI

  return(reg_val);               // Возвращаемое значение регистра
}
/**************************************************/

/**************************************************
 * Function: SPI_Read_Buf();//Функция: SPI_Write_Buf ();
 * 
 * Description://Описание:
 * Reads 'unsigned chars' #of unsigned chars from register 'reg' //Читает неподписанные символы 'неподписанных симв' #of из 'рег' регистра
 * Typically used to read RX payload, Rx/Tx address//Обычно используется для чтения RX полезной нагрузки, прием / передача адрес
/**************************************************/
unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes)//неподписанные символ SPI_Read_Buf (неподписанные символ рег, неподписанные символ * pBuf, неподписанные символ байт)
{
  unsigned char status,i;//неподписанных статус символ, я;

  SPI_PORT&=~CSN;                   // Установить ДНС низкий, инициализации SPI tranaction
  status = SPI_RW(reg);       	    // Выберите зарегистрируйтесь, чтобы написать и прочитать статус неподписанные символ

  for(i=0;i<bytes;i++)             //для (я = 0; я <байт; я ++)
  {
    pBuf[i] = SPI_RW(0);    // // Выполнить SPI_RW читать неподписанные символ из NRF24L01
  }

  SPI_PORT|=CSN;                   // Установить ДНС высокой снова

  return(status);                  // Вернуть NRF24L01 статус неподписанные символ
}
/**************************************************/

/**************************************************
 * Function: SPI_Write_Buf();//Функция: SPI_Write_Buf ();
 * 
 * Description://Описание:
 * Writes contents of buffer '*pBuf' to nRF24L01//Записывает содержимое буфера '*', чтобы pBuf NRF24L01
 * Typically used to write TX payload, Rx/Tx address//Обычно используется, чтобы написать полезную нагрузку TX, Rx / Tx адрес
/**************************************************/
unsigned char SPI_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes)//неподписанные символ SPI_Write_Buf (неподписанные символ рег, неподписанные символ * pBuf, неподписанные символ байт)
{
  unsigned char status,i;//неподписанных статус символ, я;

  SPI_PORT&=~CSN;                   // Установить ДНС низкий, инициализации SPI tranaction
  status = SPI_RW(reg);             //  Выберите зарегистрируйтесь, чтобы написать и прочитать статус неподписанные символ
  for(i=0;i<bytes; i++)             // затем написать все неподписанные символ в буфере (* pBuf)
  {
    SPI_RW(*pBuf++);                
  }
  SPI_PORT|=CSN;                   // Установить ДНС высокой снова
  return(status);                  // Вернуть NRF24L01 статус неподписанные символ
}
/**************************************************/

/**************************************************
 * Function: Initialize TX & RX mode;//Функция: Инициализировать режим TX & RX;
 * 
 * Description://Описание:
 * This function initializes one nRF24L01 device to//Эта функция инициализирует один NRF24L01 устройство к
 * TX mode, set TX address, set RX address for auto.ack,//Режим Техас, установить TX-адрес, установите адрес RX для auto.ack,
 * fill TX payload, select RF channel, datarate & TX pwr.//Заполнить TX полезной нагрузки, выберите радиочастотный канал, DataRate & TX PWR.
 * PWR_UP is set, CRC(2 unsigned chars) is enabled, & PRIM:TX.//PWR_UP установлен, КПР (2 неподписанные символов) включена, и ПРИМ: TX.
 * 
 * ToDo: One high pulse(>10us) on CE will now send this//ToDo: Один высокий пульс (> 10us) на CE теперь отправить это
 **************************************************/
void initialize_R_T(void)//недействительными initialize_R_T (недействительными)
{
  SPI_PORT&=~CE;

  SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // Записывает TX_Address в NRF24L01
  SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // RX_Addr0 же, как TX_Adr для Auto.Ack

  SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      // Включить Auto.Ack: Pipe0
  SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  // Включить Pipe0

  SPI_RW_Reg(WRITE_REG + RF_CH, 50);        // Выбор радиочастотного канала 50
  SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x26);   // TX_PWR: 0 дБм, DataRate: 250 Мбит, МШУ: HCURR

  SPI_PORT|=CE;
}
/**************************************************
 * Function: TX_Mode(); //Функция: TX_Mode ();
 * 
 * Description: //Описание:
 * This function initializes one nRF24L01 device to //Эта функция инициализирует один NRF24L01 устройство к
 * TX mode, set TX address, set RX address for auto.ack, //Режим Техас, установить TX-адрес, установите адрес RX для auto.ack,
 * fill TX payload, select RF channel, datarate & TX pwr. //Заполнить TX полезной нагрузки, выберите радиочастотный канал, DataRate & TX PWR.
 * PWR_UP is set, CRC(2 unsigned chars) is enabled, & PRIM:TX. //PWR_UP установлен, КПР (2 неподписанные символов) включена, и ПРИМ: TX.
 * 
 * ToDo: One high pulse(>10us) on CE will now send this //ToDo: Один высокий пульс (> 10us) на CE теперь отправить это
 * packet and expext an acknowledgment from the RX device. //Пакет и expext подтверждение от устройства RX.
 **************************************************/
void TX_Mode(void) //недействительными TX_Mode (недействительными)
{
  SPI_PORT&=~CE;

  SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x1f); // 500us + 86us, 10 Retrans ...
  SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);     // Установить PWR_UP немного, включите CRC (2 неподписанные знаков) и Прим: TX. MAX_RT & TX_DS включен ..
  SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);

  SPI_PORT|=CE;
}

/**************************************************
 * Function: RX_Mode();//Функция: RX_Mode ();
 * 
 * Description://Описание:
 * This function initializes one nRF24L01 device to//Эта функция инициализирует один NRF24L01 устройство к
 * RX Mode, set RX address, writes RX payload width,//RX Режим установите RX адрес, пишет ширину RX полезной нагрузки,
 * select RF channel, datarate & LNA HCURR.//Выберите радиочастотный канал, DataRate & МШУ HCURR.
 * After init, CE is toggled high, which means that//После инициализации, CE переключается высокой, что означает, что
 * this device is now ready to receive a datapacket.//Это устройство готово для приема datapacket.
/**************************************************/
void RX_Mode(void)//недействительными RX_Mode (недействительными)
{
  SPI_PORT&=~CE;
  
  SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); // Выбор же RX ширину полезной нагрузки как TX шириной Payload
  SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);     //Установить PWR_UP немного, включите CRC (2 неподписанные символов) & Прим: RX. Включен RX_DR ..
  
  SPI_PORT|=CE;                             // Установить CE контактный высокой для того, чтобы устройство RX
}

//RF transmit data function// Функция передачи данных РФ
void RF_SendData(char *TXdata)
{
    TX_Mode();  // Включить режим Tx                                                // activate Tx mode
    
    for(short i=0; i<23;i++)// для (короткий я = 0; я <23; я ++)
    {
      tx_buf[i] = (unsigned char)*(TXdata+i);  // Сохранить данные в массив                                   // store the data to an array 
    }      
      
    unsigned char status = SPI_Read(STATUS);   // Читаем значение регистра статуса в                // read register STATUS's value
    
    if(status&TX_DS)    // если данные готовы получить (TX_DS) прервать                                       // if receive data ready (TX_DS) interrupt
    {
      SPI_RW_Reg(FLUSH_TX,0);                                  
      SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);       // Запись в TX_FIFO playload
    }
    if(status&MAX_RT)                                         // если принимать данные готовые (MAX_RT) прервать это повтора чем SETUP_RETR
    {
      SPI_RW_Reg(FLUSH_TX,0);
      SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);      // Отключение режима Standy
    }
    SPI_RW_Reg(WRITE_REG+STATUS,status);                     // Ясно RX_DR или TX_DS или MAX_RT флаг прерывания
    delay(50);
    RX_Mode();    
}

//RF receive data function// РФ получить функцию передачи данных
void RF_ReceiveData(unsigned char *RXdata)// недействительными RF_ReceiveData (неподписанные символ * RXdata)
{
    RX_Mode();      // Включить режим RX                                                
    unsigned char status = SPI_Read(STATUS);  // Читаем значение регистра статуса в
    if(status&RX_DR)                                                 // если данные готовы получить (TX_DS) прервать
    {
      SPI_Read_Buf(RD_RX_PLOAD, rx_buf, TX_PLOAD_WIDTH);             // Прочитать playload в rx_buf
      SPI_RW_Reg(FLUSH_RX,0);                                        // Ясно RX_FIFO                               
      
      *RXdata = rx_buf[0];                                           // передать полученные данные в RXdata
      Serial.println(rx_buf[0]);
    }
    SPI_RW_Reg(WRITE_REG+STATUS,status);                             // Ясно RX_DR или TX_DS или MAX_RT флаг прерывания
    delay(50);
    TX_Mode(); 
}

ПОМОГИТЕ

Может и глупый вопрос. Как а Ардуинке вывести нумерацию строк для проверки по ошибкам? И возможно ли - ?

inp
inp
inp

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

-
-
-

1

2

3

=

Файл->Настройки->Показать номера строк.

З.Ы. Вам шнурки погладить? А то, гляжу - вам совсем недосуг покопаться в настройках IDE, тем более, что так близко к носу они спрятаны.

Спасибо – гляжу,  ущемлены в общение.  Могли – бы и промолчать с цензурой. Это Вы все такие АСЫ. А что не спросишь - читайте, ищите.  Вот и все. НУ я просто ступанул - ну , что. Согласен в угол.

Хамить изволите? Брысь в подъезд, и на корточках семки стрелять! 

Да все на много банальнее – у Меня программа Arduino 1.0.5

И там в настройках этого нет (Файл->Настройки->Показать номера строк.)

– БЕ –БЕ- БЕ.

=

Ещё бы подревнее мамонта откопали, что ли.

Помогите в чем косяк - ошибки Build options changed, rebuilding all

Статья и примеры которые мне помогли когда я заново разбирался с НРФками, так как с прошлого раза всё забыл..

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

http://arduinolab.pw/index.php/2015/12/02/radiomoduli-nrf24l01-i-arduino/

Хотелось бы пример - обмена команд  кнопок и LED  ОБМЕН между сабой?

а не подскажите как на один SPI (ардуино нано  атмега 328) повесить нрф и к примеру модуль семисегмента на мах7219 чтобы тот отображал принимаемое значение?

не совместимы

Кто - Брежнев с Джавахардлалом Неру? Не согласен - лобызались тока в путь :)

:) мимокассы пошло 

#715 инфой владеете ?поможете?спать не ложусь третьи сутки пока не заставлю работать =)

На max7219 имеется нога CS, у nrf24 нога CSN. Какому чипу туда подать ноль, тот и получает доступ к SPI.

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

#include "NRF24L01.h"

//***************************************************
#define TX_ADR_WIDTH    5   // 5 unsigned chars TX(RX) address width
#define TX_PLOAD_WIDTH  23  //   unsigned chars TX payload

const int ledPin1 = 5; // номер выхода, подключенного к светодиоду
// Variables will change:
int ledState1 = LOW; // этой переменной устанавливаем состояние светодиода
long previousMillis1 = 0; // храним время последнего переключения светодиода
long interval1 = 1000; // интервал между включение/выключением светодиода (1секунда)
#define BUTTON1 A0

const int ledPin2 = 6; // номер выхода, подключенного к светодиоду
// Variables will change:
int ledState2 = LOW; // этой переменной устанавливаем состояние светодиода
long previousMillis2 = 0; // храним время последнего переключения светодиода
long interval2 = 1000; // интервал между
#define BUTTON2 A1

const int ledPin3 = 7; // номер выхода, подключенного к светодиоду
// Variables will change:
int ledState3 = LOW; // этой переменной устанавливаем состояние светодиода
long previousMillis3 = 0; // храним время последнего переключения светодиода
long interval3 = 1000; // интервал между
#define BUTTON3 A2


//***************************************************

unsigned char TX_ADDRESS[TX_ADR_WIDTH]  = 
{
  0xaa,0xbb,0xcc,0xdd,0xee
}; // Define a static TX address
unsigned char rx_buf[TX_PLOAD_WIDTH] = {0}; // initialize value
unsigned char tx_buf[TX_PLOAD_WIDTH] = {0};
//***************************************************

void setup() 
{
  SPI_DIR = ( CE + SCK_pin + CSN + MOSI_pin);
  SPI_DIR &=~ ( IRQ + MISO_pin);
  init_io();                        // Initialize IO port
  unsigned char status=SPI_Read(STATUS);
  initialize_R_T();
  
  // задаем режим выхода для порта, подключенного к светодиоду
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
}
void loop() 
{
  // здесь будет код, который будет работать постоянно
// и который не должен останавливаться на время между переключениями свето
unsigned long currentMillis = millis();
    unsigned char Rx_szTemp[1] = {0}; //hold received data
  
    //Start TX mode  
    if(digitalRead(BUTTON1) == 0)
    {
       RF_SendData("1");   //send '1' through RF module
    }
    else if(digitalRead(BUTTON2) == 0)
    {
       RF_SendData("2");   //send '2' through RF module
    }
    else if(digitalRead(BUTTON3) == 0)
    {
       RF_SendData("3");  //send '3' through RF module
    }
    
    //RX mode
    RF_ReceiveData(&Rx_szTemp[0]); //receive data from RF module
     
    if(Rx_szTemp[0] == '1')   //if received data = '1'
    {
      
//проверяем не прошел ли нужный интервал, если прошел то
if(currentMillis - previousMillis1 > interval1)
 {

  // сохраняем время последнего переключения
previousMillis1 = currentMillis;
// если светодиод не горит, то зажигаем, и наоборот
if (ledState1 == LOW)
ledState1 = HIGH;
else
ledState1 = LOW;
// устанавливаем состояния выхода, чтобы включить или выключить светодиод
digitalWrite(ledPin1, ledState1);
}
    else if(Rx_szTemp[0] == '2')  //if received data = '2'
    {
      //проверяем не прошел ли нужный интервал, если прошел то
if(currentMillis - previousMillis2 > interval2) 
{
  // сохраняем время последнего переключения
previousMillis2 = currentMillis;
// если светодиод не горит, то зажигаем, и наоборот
if (ledState2 == LOW)
ledState2 = HIGH;
else
ledState2 = LOW;
// устанавливаем состояния выхода, чтобы включить или выключить светодиод
digitalWrite(ledPin2, ledState2);
}
    
    else if(Rx_szTemp[0] == '3')  //if received data = '3'
    {
      //проверяем не прошел ли нужный интервал, если прошел то
if(currentMillis - previousMillis3 > interval3)
 {
  // сохраняем время последнего переключения
previousMillis3 = currentMillis;
// если светодиод не горит, то зажигаем, и наоборот
if (ledState3 == LOW)
ledState3 = HIGH;
else
ledState3 = LOW;
// устанавливаем состояния выхода, чтобы включить или выключить светодиод
digitalWrite(ledPin3, ledState3);
}
//**************************************************
// Function: init_io();
// Description:
// flash led one time,chip enable(ready to TX or RX Mode),
// Spi disable,Spi clock line init high
//**************************************************
void init_io(void)
 {
  SPI_PORT&=~CE;			// chip enable
  SPI_PORT|=CSN;			// Spi disable	
  SPI_PORT&=~SCK_pin;			// Spi clock line init high
}

/**************************************************
 * Function: SPI_RW();
 * 
 * Description:
 * Writes one unsigned char to nRF24L01, and return the unsigned char read
 * from nRF24L01 during write, according to SPI protocol
 **************************************************/
unsigned char SPI_RW(unsigned char Byte)
{
  unsigned char i;
  for(i=0;i<8;i++)                      // output 8-bit
  {
    if(Byte&0x80)
    {
      SPI_PORT |=MOSI_pin;    // output 'unsigned char', MSB to MOSI_pin
    }
    else
    {
      SPI_PORT &=~MOSI_pin;
    }
    SPI_PORT|=SCK_pin;                      // Set SCK_pin high..
    Byte <<= 1;                         // shift next bit into MSB..
    if(SPI_IN & MISO_pin)
    {
      Byte |= 1;       	        // capture current MISO_pin bit
    }
    SPI_PORT&=~SCK_pin;            	        // ..then set SCK_pin low again
  }
  return(Byte);           	        // return read unsigned char
}
/**************************************************/

/**************************************************
 * Function: SPI_RW_Reg();
 * 
 * Description:
 * Writes value 'value' to register 'reg'
/**************************************************/
unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value)
{
  unsigned char status;

  SPI_PORT&=~CSN;                   // CSN low, init SPI transaction
  status = SPI_RW(reg);             // select register
  SPI_RW(value);                    // ..and write value to it..
  SPI_PORT|=CSN;                    // CSN high again

  return(status);                   // return nRF24L01 status unsigned char
}
/**************************************************/

/**************************************************
 * Function: SPI_Read();
 * 
 * Description:
 * Read one unsigned char from nRF24L01 register, 'reg'
/**************************************************/
unsigned char SPI_Read(unsigned char reg)
{
  unsigned char reg_val;

  SPI_PORT&=~CSN;                // CSN low, initialize SPI communication...
  SPI_RW(reg);                   // Select register to read from..
  reg_val = SPI_RW(0);           // ..then read register value
  SPI_PORT|=CSN;                 // CSN high, terminate SPI communication

  return(reg_val);               // return register value
}
/**************************************************/

/**************************************************
 * Function: SPI_Read_Buf();
 * 
 * Description:
 * Reads 'unsigned chars' #of unsigned chars from register 'reg'
 * Typically used to read RX payload, Rx/Tx address
/**************************************************/
unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes)
{
  unsigned char status,i;

  SPI_PORT&=~CSN;                   // Set CSN low, init SPI tranaction
  status = SPI_RW(reg);       	    // Select register to write to and read status unsigned char

  for(i=0;i<bytes;i++)
  {
    pBuf[i] = SPI_RW(0);    // Perform SPI_RW to read unsigned char from nRF24L01
  }

  SPI_PORT|=CSN;                   // Set CSN high again

  return(status);                  // return nRF24L01 status unsigned char
}
/**************************************************/

/**************************************************
 * Function: SPI_Write_Buf();
 * 
 * Description:
 * Writes contents of buffer '*pBuf' to nRF24L01
 * Typically used to write TX payload, Rx/Tx address
/**************************************************/
unsigned char SPI_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes)
{
  unsigned char status,i;

  SPI_PORT&=~CSN;                   // Set CSN low, init SPI tranaction
  status = SPI_RW(reg);             // Select register to write to and read status unsigned char
  for(i=0;i<bytes; i++)             // then write all unsigned char in buffer(*pBuf)
  {
    SPI_RW(*pBuf++);
  }
  SPI_PORT|=CSN;                   // Set CSN high again
  return(status);                  // return nRF24L01 status unsigned char
}
/**************************************************/

/**************************************************
 * Function: Initialize TX & RX mode;
 * 
 * Description:
 * This function initializes one nRF24L01 device to
 * TX mode, set TX address, set RX address for auto.ack,
 * fill TX payload, select RF channel, datarate & TX pwr.
 * PWR_UP is set, CRC(2 unsigned chars) is enabled, & PRIM:TX.
 * 
 * ToDo: One high pulse(>10us) on CE will now send this
 **************************************************/
void initialize_R_T(void)
{
  SPI_PORT&=~CE;

  SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // Writes TX_Address to nRF24L01
  SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // RX_Addr0 same as TX_Adr for Auto.Ack

  SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      // Enable Auto.Ack:Pipe0
  SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  // Enable Pipe0

  SPI_RW_Reg(WRITE_REG + RF_CH, 50);        // Select RF channel 50
  SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x26);   // TX_PWR:0dBm, Datarate:250Mbps, LNA:HCURR

  SPI_PORT|=CE;
}
/**************************************************
 * Function: TX_Mode();
 * 
 * Description:
 * This function initializes one nRF24L01 device to
 * TX mode, set TX address, set RX address for auto.ack,
 * fill TX payload, select RF channel, datarate & TX pwr.
 * PWR_UP is set, CRC(2 unsigned chars) is enabled, & PRIM:TX.
 * 
 * ToDo: One high pulse(>10us) on CE will now send this
 * packet and expext an acknowledgment from the RX device.
 **************************************************/
void TX_Mode(void)
{
  SPI_PORT&=~CE;

  SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x1f); // 500us + 86us, 10 retrans...
  SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);     // Set PWR_UP bit, enable CRC(2 unsigned chars) & Prim:TX. MAX_RT & TX_DS enabled..
  SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);

  SPI_PORT|=CE;
}

/**************************************************
 * Function: RX_Mode();
 * 
 * Description:
 * This function initializes one nRF24L01 device to
 * RX Mode, set RX address, writes RX payload width,
 * select RF channel, datarate & LNA HCURR.
 * After init, CE is toggled high, which means that
 * this device is now ready to receive a datapacket.
/**************************************************/
void RX_Mode(void)
{
  SPI_PORT&=~CE;
  
  SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); // Select same RX payload width as TX Payload width
  SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);     // Set PWR_UP bit, enable CRC(2 unsigned chars) & Prim:RX. RX_DR enabled..
  
  SPI_PORT|=CE;                             // Set CE pin high to enable RX device
}

//RF transmit data function
void RF_SendData(char *TXdata)
{
    TX_Mode();                                                  // activate Tx mode
    
    for(short i=0; i<23;i++)
    {
      tx_buf[i] = (unsigned char)*(TXdata+i);                                     // store the data to an array 
    }      
      
    unsigned char status = SPI_Read(STATUS);                   // read register STATUS's value
    
    if(status&TX_DS)                                           // if receive data ready (TX_DS) interrupt
    {
      SPI_RW_Reg(FLUSH_TX,0);                                  
      SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);       // write playload to TX_FIFO
    }
    if(status&MAX_RT)                                         // if receive data ready (MAX_RT) interrupt, this is retransmit than  SETUP_RETR                          
    {
      SPI_RW_Reg(FLUSH_TX,0);
      SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);      // disable standy-mode
    }
    SPI_RW_Reg(WRITE_REG+STATUS,status);                     // clear RX_DR or TX_DS or MAX_RT interrupt flag
    delay(50);
    RX_Mode();    
}

//RF receive data function
void RF_ReceiveData(unsigned char *RXdata)
{
    RX_Mode();                                                       // activate RX mode
    unsigned char status = SPI_Read(STATUS);                         // read register STATUS's value
    if(status&RX_DR)                                                 // if receive data ready (TX_DS) interrupt
    {
      SPI_Read_Buf(RD_RX_PLOAD, rx_buf, TX_PLOAD_WIDTH);             // read playload to rx_buf
      SPI_RW_Reg(FLUSH_RX,0);                                        // clear RX_FIFO                               
      
      *RXdata = rx_buf[0];                                           //pass the received data to RXdata
      Serial.println(rx_buf[0]);
    }
    SPI_RW_Reg(WRITE_REG+STATUS,status);                             // clear RX_DR or TX_DS or MAX_RT interrupt flag
    delay(50);
    TX_Mode(); 
}

после строки 123 поставь }

Спасибо -поставил аж 4 шт. но на ардуинке в деле на  макете работает  не коректно. Буду рыть. Изменю #define BUTTON1 A0 на int pinBUTTON1=A0; как-же изменю if(digitalRead(BUTTON1) == 0) на if(digitalRead(pinBUTTON1) == 0) и тгд.

ребята, помогите.
Имею два nRF24L01+.
Один на уно, второй на меге.
Заливаю образцовый скетч сканер, работает отлично и на меге и на уно- Пробовал менять каналы вайфая на роутере и видел как полоса шума смещалась.
Верно ли я понимаю, что это значит что модули подключены верно, и с питанием все в порядке? (на питание припаял 10 микрофарад и керамику на каждом модуле)
НО! далее я заливаю на мегу скетч GettingStarted, отключаю от юсб, включаю ее от внешнего источника 5в (4 аккумулятора АА),
Уно подключаю к юсб, также заливаю GettingStarted, в мониторе пишу "Т", но никакого ответа не получаю:

Now sending 11345...failed.
Failed, response timed out.

что я делаю не так? Уже перепробовал все скетчи что были в инете...
Кстати параметры устанавливаются одинаковые на обоих приемниках:

RF24/examples/GettingStarted/
ROLE: Pong back
*** PRESS 'T' to begin transmitting to the other node
STATUS = 0x0e RX_DR=0 TX_DS=0 MAX_RT=0 RX_P_NO=7 TX_FULL=0
RX_ADDR_P0-1 = 0xf0f0f0f0e1 0xf0f0f0f0d2
RX_ADDR_P2-5 = 0xc3 0xc4 0xc5 0xc6
TX_ADDR = 0xf0f0f0f0e1
RX_PW_P0-6 = 0x20 0x20 0x00 0x00 0x00 0x00
EN_AA = 0x3f
EN_RXADDR =0x03
RF_CH = 0x4c
RF_SETUP = 0x07
CONFIG = 0x0f
DYNPD/FEATURE = 0x00 0x00
Data Rate = 1MBPS
Model = nRF24L01+
CRC Length = 16 bits
PA Power = PA_HIGH

то есть проблема появляется только когда питаешь от батареек?

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

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

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

читай, может и получится

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

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

скорее всего. скорее всего через usb будет работать и передача. в идеале для радиомодуля ставить свой отдельный стабилизатор на 3.3в

не матерись. это же форум, еще ничего такого не произошло чтобы матерится

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

на двух юсб шнурах тоже самое. На каждой из них работает скетч сканирования, но если заливать скетчи GETTINGSTARTED  то они не видят друг  друга:

Now sending 95742...ok...Failed, response timed out.

может что то программное? Как вообще проверить осуществляет ли передатчик отправку?

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

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

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

Заработало с вашей библиотекой! Спасибо, А ведь раньше я кучу библиотек перепробывал. В чем хоть причина того что со стандартной библиотекой не работает?

магия)))

а не подскажите, как проверить качество связи, потери пакетов. Может у вас скетчик завалялся?

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

а ну все понятно.  Спасибо.
Кстати, у меня от 3.3 вольт отвратительно работали, дистанция 1 метр, слегка увеличивалась если коснуться пальцем кварца. Потом подключил к 5 вольтам (думаю сгорит- да и черт с таким фуфлом...) Однако стало работать практически идеально. Что за выкрутасы? Может туда китайцы навесили резисторов чтобы к 5 вольтам можно было подключать?
Надеюсь они не сгорят в таком режиме)

а может проблема с питанием)) все на авось. мультиметр заведи себе как минимум

ну неужели вы думаете что у меня нет мультиметра..))
когда были подключены к ардуиновским 3.3- напряжение было 3.24, не прыгало. Осцилографа к сожалению нет. Два кондера еще...незнаю какие могли быть проблемы по питанию от 3.3...
Потом подключил к новой батарейке от материнской платы- модуль вообще не работал.
А от 5 вольт как штык.

заметил тут у китайцев аналоги как 3.3в так и 5в, например 1602 дисплей

может и вифи тоже пошли по этому пути 

Здраствуйте.

Пришли два модуля, заставил их работать по етому примеру(1).

http://arduinolab.pw/index.php/2015/12/02/radiomoduli-nrf24l01-i-arduino/

Потом переписал скетч, отправлял показания потенциометра и зажигал светодиод.

Поработало где-то 5 минут, потом светодиод потух.

Теперь не работают любые примеры.

Если записать пример(1), то на одной ардуино в мониторе порта data все время -1(если приемник) и если передатчик то отсылает медлено.

Вторая ардуина отсилает быстро, а принимать ей нечего.

Ардуино второй день, не пинайте)

Я извеняюсь - Капец не получется 

Я извиняюсь нуждаюсь в помощи-mybotic.com.my/products/2.4G%20Transceiv...RF24L01%20Module/414





мне нужно что-бы светодиоды после получения команды кнопок светили всего 1 секунду и тухли . а в этом проекте они горят постоянно до смены команды

• Arduino Source Code
• 2.4G Transceiver nRF24L01 Module User's Manual v2.0

Еще немного и я стану еще мудрее на год с проблемой NRF21L01+

Помогите врезать в NRF24L01+  для 3х блоков клонов такой пример с 3 кнопками и 3 led на прием и передаче команд. Запарился уже с 10 вариантами. 

const int buttonPin[] = {5,6,7};
const int ledPin[] =  {A0,A1,A2};

long previousMillis[] = {0,0,0}; 

long interval = 1000;

void setup() {
  for(int i=0; i<3; i++)
  {
    pinMode(ledPin[i], OUTPUT);
    digitalWrite(ledPin[i], LOW);
    pinMode(buttonPin[i], INPUT);
  }
}

void loop() {
  unsigned long currentMillis = millis();
  for(int i=0; i<3; i++)
  {
    if (digitalRead(buttonPin[i]) == LOW)
    {
      digitalWrite(ledPin[i], HIGH);
      previousMillis[i] = currentMillis;
    } else
    if (currentMillis - previousMillis[i] > interval)
    {
      digitalWrite(ledPin[i], LOW);
    }
  }
}

чтоб чтото тухло надо чтоб кнопки были нажаты у вас.

елзе убери и закрой если предыдущее через ; и все заработает

Мне нужно что бы при нажатие на кнопку другая NRF24L01+ принимала загорался LED на 1 секундут тухла .И так все 3 команды на 3х клонах дублировали (друг другу прием передача ) LED NRF21L01+ как пример  в #743

Три клона - нажимаем кнопку  на 1 срабатывае  LED  на дрегих 2х и тухнит через 1 сек. и так с других на остальные 2.

твою ж мать а.

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

и стоит ИНАЧЕ т.е. если кнопка НАЖАТА только и только ТОГДА смотрится условия прошела ли твоя секунда.

ты кнопку не нажал или нажал и отпустил. а время еше не прошло. и все выключаться нечему потом у тебя стоит ВКЛЮЧИТЬ если НЕ НАЖАТО

Все крышняк поехал.

а какова практичная альтернатива?