Nrf24l01+

tika
Offline
Зарегистрирован: 22.07.2015

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

    unsigned long currentMillea=milles();//текущее время в миллесикундах
#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(); 
}

ПОМОГИТЕ

tika
Offline
Зарегистрирован: 22.07.2015

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

inp
inp
inp

 

pastry777
Offline
Зарегистрирован: 16.01.2014

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

tika
Offline
Зарегистрирован: 22.07.2015
-
-
-

1

2

3

tika
Offline
Зарегистрирован: 22.07.2015

=

DIYMan
DIYMan аватар
Offline
Зарегистрирован: 23.11.2015

tika пишет:

=

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

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

tika
Offline
Зарегистрирован: 22.07.2015

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

DIYMan
DIYMan аватар
Offline
Зарегистрирован: 23.11.2015

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

tika
Offline
Зарегистрирован: 22.07.2015

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

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

– БЕ –БЕ- БЕ.

tika
Offline
Зарегистрирован: 22.07.2015

=

DIYMan
DIYMan аватар
Offline
Зарегистрирован: 23.11.2015

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

tika
Offline
Зарегистрирован: 22.07.2015

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

_0010.ino: In function 'void loop()':
_0010.ino:148:1: error: a function-definition is not allowed here before '{' token
_0010.ino:165:1: error: a function-definition is not allowed here before '{' token
_0010.ino:386:5: error: expected '}' at end of input
_0010.ino:386:5: error: expected '}' at end of input
_0010.ino:386:5: error: expected '}' at end of input
_0010.ino:386:5: error: expected '}' at end of input
_0010.ino:386:5: error: expected '}' at end of input
Ошибка компиляции.
 
141 //**************************************************
142 // Function: init_io();// Функция: init_io ();
143 // Description:// Описание:
144 // flash led one time,chip enable(ready to TX or RX Mode),// Светодиодной вспышкой один раз, чип позволит (готовый TX RX или режим),
145 // Spi disable,Spi clock line init high// Спи отключить, SPI часы линии инициализировать высокой
146 //**************************************************
147 void init_io(void)//недействительными init_io (недействительными)
148 {
149  
150   SPI_PORT&=~CE;            // Чип позволит
151   SPI_PORT|=CSN;            // Спи отключить   
152   SPI_PORT&=~SCK_pin;           // Спи часы линии инициализировать высокой
153 }
154  
155 /**************************************************
156  * Function: SPI_RW();//Функция: SPI_RW ();
157  *
158  * Description:// Описание:
159  * Writes one unsigned char to nRF24L01, and return the unsigned char read
160  * from nRF24L01 during write, according to SPI protocol
161    Пишет один неподписанный символ для NRF24L01, и вернуть неподписанные символ читать
162  * От NRF24L01 во пишут, в соответствии с протоколом SPI
163  **************************************************/
164 unsigned char SPI_RW(unsigned char Byte)//подписанные символ SPI_RW (неподписанные символ байт)
165 {
166   unsigned char i;                      //неподписанные символ я;
167   for(i=0;i<8;i++)                      // выход 8-бит
168   {
169     if(Byte&0x80)                       //если (байт & 0x80)
170     {
171       SPI_PORT |=MOSI_pin;    // Выход "неподписанные символ ', MSB для MOSI_pin
172     }
173     else                     //другой       
174     {
175       SPI_PORT &=~MOSI_pin;
176     }
177     SPI_PORT|=SCK_pin;                     // Установить SCK_pin высокий ..
178     Byte <<= 1;                         // Сдвиг следующий бит в MSB ..
179     if(SPI_IN & MISO_pin) //если (SPI_IN & MISO_pin)
180     {
181       Byte |= 1;                // Захватить текущее MISO_pin немного
182     }
183     SPI_PORT&=~SCK_pin;                    // ..то Установить SCK_pin низкий снова
184   }
185   return(Byte);                    // Возврат прочитать неподписанные символ
186 }
187 /**************************************************/
188  
189 /**************************************************
190  * Function: SPI_RW_Reg(); // Функция: SPI_RW_Reg ();
191  *
192  Description:// Описание:
193  * Writes value 'value' to register 'reg'// Записывает значение '' значение для регистрации '' рег
194 /**************************************************/
195 unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value)//неподписанные символ SPI_RW_Reg (неподписанные символ рег, символьное значение без знака)
196 {
197   unsigned char status;// неподписанных статус символ;
198  
199   SPI_PORT&=~CSN;                   // ДНС низкий, инициализировать сделка SPI
200   status = SPI_RW(reg);             // Выбрать регистр
201   SPI_RW(value);                    // ..и Значение записи к нему ..
202   SPI_PORT|=CSN;                    // ДНС высокой снова
203  
204   return(status);                   // Вернуть NRF24L01 статус неподписанные символ
205 }
206 /**************************************************/
207  
208 /**************************************************
209  * Function: SPI_Read();//Функция: SPI_Read_Buf ();
210  *
211  Description://Описание:
212  * Read one unsigned char from nRF24L01 register, 'reg'Читайте одну неподписанные символ из регистра NRF24L01, "рег"
213 /**************************************************/
214 unsigned char SPI_Read(unsigned char reg)//неподписанные символ SPI_Read (неподписанные символ рег)
215 {
216   unsigned char reg_val;// неподписанные символ reg_val;
217  
218   SPI_PORT&=~CSN;                // ДНС низкий, инициализировать SPI связь ...
219   SPI_RW(reg);                   // Выбор зарегистрируйтесь, чтобы читать из ..
220   reg_val = SPI_RW(0);           // ..то Прочитать значение регистра
221   SPI_PORT|=CSN;                 // ДНС высокий, прекратить общение SPI
222  
223   return(reg_val);               // Возвращаемое значение регистра
224 }
225 /**************************************************/
226  
227 /**************************************************
228  * Function: SPI_Read_Buf();//Функция: SPI_Write_Buf ();
229  *
230  Description://Описание:
231  * Reads 'unsigned chars' #of unsigned chars from register 'reg' //Читает неподписанные символы 'неподписанных симв' #of из 'рег' регистра
232  * Typically used to read RX payload, Rx/Tx address//Обычно используется для чтения RX полезной нагрузки, прием / передача адрес
233 /**************************************************/
234 unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes)//неподписанные символ SPI_Read_Buf (неподписанные символ рег, неподписанные символ * pBuf, неподписанные символ байт)
235 {
236   unsigned char status,i;//неподписанных статус символ, я;
237  
238   SPI_PORT&=~CSN;                   // Установить ДНС низкий, инициализации SPI tranaction
239   status = SPI_RW(reg);             // Выберите зарегистрируйтесь, чтобы написать и прочитать статус неподписанные символ
240  
241   for(i=0;i<bytes;i++)             //для (я = 0; я <байт; я ++)
242   {
243     pBuf[i] = SPI_RW(0);    // // Выполнить SPI_RW читать неподписанные символ из NRF24L01
244   }
245  
246   SPI_PORT|=CSN;                   // Установить ДНС высокой снова
247  
248   return(status);                  // Вернуть NRF24L01 статус неподписанные символ
249 }
250 /**************************************************/
251  
252 /**************************************************
253  * Function: SPI_Write_Buf();//Функция: SPI_Write_Buf ();
254  *
255  Description://Описание:
256  * Writes contents of buffer '*pBuf' to nRF24L01//Записывает содержимое буфера '*', чтобы pBuf NRF24L01
257  * Typically used to write TX payload, Rx/Tx address//Обычно используется, чтобы написать полезную нагрузку TX, Rx / Tx адрес
258 /**************************************************/
259 unsigned char SPI_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes)//неподписанные символ SPI_Write_Buf (неподписанные символ рег, неподписанные символ * pBuf, неподписанные символ байт)
260 {
261   unsigned char status,i;//неподписанных статус символ, я;
262  
263   SPI_PORT&=~CSN;                   // Установить ДНС низкий, инициализации SPI tranaction
264   status = SPI_RW(reg);             //  Выберите зарегистрируйтесь, чтобы написать и прочитать статус неподписанные символ
265   for(i=0;i<bytes; i++)             // затем написать все неподписанные символ в буфере (* pBuf)
266   {
267     SPI_RW(*pBuf++);               
268   }
269   SPI_PORT|=CSN;                   // Установить ДНС высокой снова
270   return(status);                  // Вернуть NRF24L01 статус неподписанные символ
271 }
272 /**************************************************/
273  
274 /**************************************************
275  * Function: Initialize TX & RX mode;//Функция: Инициализировать режим TX & RX;
276  *
277  Description://Описание:
278  * This function initializes one nRF24L01 device to//Эта функция инициализирует один NRF24L01 устройство к
279  * TX mode, set TX address, set RX address for auto.ack,//Режим Техас, установить TX-адрес, установите адрес RX для auto.ack,
280  * fill TX payload, select RF channel, datarate & TX pwr.//Заполнить TX полезной нагрузки, выберите радиочастотный канал, DataRate & TX PWR.
281  * PWR_UP is set, CRC(2 unsigned chars) is enabled, & PRIM:TX.//PWR_UP установлен, КПР (2 неподписанные символов) включена, и ПРИМ: TX.
282  *
283  * ToDo: One high pulse(>10us) on CE will now send this//ToDo: Один высокий пульс (> 10us) на CE теперь отправить это
284  **************************************************/
285 void initialize_R_T(void)//недействительными initialize_R_T (недействительными)
286 {
287   SPI_PORT&=~CE;
288  
289   SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // Записывает TX_Address в NRF24L01
290   SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // RX_Addr0 же, как TX_Adr для Auto.Ack
291  
292   SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      // Включить Auto.Ack: Pipe0
293   SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  // Включить Pipe0
294  
295   SPI_RW_Reg(WRITE_REG + RF_CH, 50);        // Выбор радиочастотного канала 50
296   SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x26);   // TX_PWR: 0 дБм, DataRate: 250 Мбит, МШУ: HCURR
297  
298   SPI_PORT|=CE;
299 }
300 /**************************************************
301  * Function: TX_Mode(); //Функция: TX_Mode ();
302  *
303  * Description: //Описание:
304  * This function initializes one nRF24L01 device to //Эта функция инициализирует один NRF24L01 устройство к
305  * TX mode, set TX address, set RX address for auto.ack, //Режим Техас, установить TX-адрес, установите адрес RX для auto.ack,
306  * fill TX payload, select RF channel, datarate & TX pwr. //Заполнить TX полезной нагрузки, выберите радиочастотный канал, DataRate & TX PWR.
307  * PWR_UP is set, CRC(2 unsigned chars) is enabled, & PRIM:TX. //PWR_UP установлен, КПР (2 неподписанные символов) включена, и ПРИМ: TX.
308  *
309  * ToDo: One high pulse(>10us) on CE will now send this //ToDo: Один высокий пульс (> 10us) на CE теперь отправить это
310  * packet and expext an acknowledgment from the RX device. //Пакет и expext подтверждение от устройства RX.
311  **************************************************/
312 void TX_Mode(void//недействительными TX_Mode (недействительными)
313 {
314   SPI_PORT&=~CE;
315  
316   SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x1f); // 500us + 86us, 10 Retrans ...
317   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);     // Установить PWR_UP немного, включите CRC (2 неподписанные знаков) и Прим: TX. MAX_RT & TX_DS включен ..
318   SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);
319  
320   SPI_PORT|=CE;
321 }
322  
323 /**************************************************
324  * Function: RX_Mode();//Функция: RX_Mode ();
325  *
326  Description://Описание:
327  * This function initializes one nRF24L01 device to//Эта функция инициализирует один NRF24L01 устройство к
328  * RX Mode, set RX address, writes RX payload width,//RX Режим установите RX адрес, пишет ширину RX полезной нагрузки,
329  * select RF channel, datarate & LNA HCURR.//Выберите радиочастотный канал, DataRate & МШУ HCURR.
330  * After init, CE is toggled high, which means that//После инициализации, CE переключается высокой, что означает, что
331  * this device is now ready to receive a datapacket.//Это устройство готово для приема datapacket.
332 /**************************************************/
333 void RX_Mode(void)//недействительными RX_Mode (недействительными)
334 {
335   SPI_PORT&=~CE;
336   
337   SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); // Выбор же RX ширину полезной нагрузки как TX шириной Payload
338   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);     //Установить PWR_UP немного, включите CRC (2 неподписанные символов) & Прим: RX. Включен RX_DR ..
339   
340   SPI_PORT|=CE;                             // Установить CE контактный высокой для того, чтобы устройство RX
341 }
342  
343 //RF transmit data function// Функция передачи данных РФ
344 void RF_SendData(char *TXdata)
345 {
346     TX_Mode();  // Включить режим Tx                                                // activate Tx mode
347     
348     for(short i=0; i<23;i++)// для (короткий я = 0; я <23; я ++)
349     {
350       tx_buf[i] = (unsigned char)*(TXdata+i);  // Сохранить данные в массив                                   // store the data to an array
351     }     
352       
353     unsigned char status = SPI_Read(STATUS);   // Читаем значение регистра статуса в                // read register STATUS's value
354     
355     if(status&TX_DS)    // если данные готовы получить (TX_DS) прервать                                       // if receive data ready (TX_DS) interrupt
356     {
357       SPI_RW_Reg(FLUSH_TX,0);                                 
358       SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);       // Запись в TX_FIFO playload
359     }
360     if(status&MAX_RT)                                         // если принимать данные готовые (MAX_RT) прервать это повтора чем SETUP_RETR
361     {
362       SPI_RW_Reg(FLUSH_TX,0);
363       SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);      // Отключение режима Standy
364     }
365     SPI_RW_Reg(WRITE_REG+STATUS,status);                     // Ясно RX_DR или TX_DS или MAX_RT флаг прерывания
366     delay(50);
367     RX_Mode();   
368 }
369  
370 //RF receive data function// РФ получить функцию передачи данных
371 void RF_ReceiveData(unsigned char *RXdata)// недействительными RF_ReceiveData (неподписанные символ * RXdata)
372 {
373     RX_Mode();      // Включить режим RX                                               
374     unsigned char status = SPI_Read(STATUS);  // Читаем значение регистра статуса в
375     if(status&RX_DR)                                                 // если данные готовы получить (TX_DS) прервать
376     {
377       SPI_Read_Buf(RD_RX_PLOAD, rx_buf, TX_PLOAD_WIDTH);             // Прочитать playload в rx_buf
378       SPI_RW_Reg(FLUSH_RX,0);                                        // Ясно RX_FIFO                              
379       
380       *RXdata = rx_buf[0];                                           // передать полученные данные в RXdata
381       Serial.println(rx_buf[0]);
382     }
383     SPI_RW_Reg(WRITE_REG+STATUS,status);                             // Ясно RX_DR или TX_DS или MAX_RT флаг прерывания
384     delay(50);
385     TX_Mode();
386     }

 

Nixoid
Nixoid аватар
Offline
Зарегистрирован: 16.09.2011

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

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

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

tika
Offline
Зарегистрирован: 22.07.2015

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

no_nic
Offline
Зарегистрирован: 12.06.2016

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

no_nic
Offline
Зарегистрирован: 12.06.2016

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

DIYMan
DIYMan аватар
Offline
Зарегистрирован: 23.11.2015

no_nic пишет:

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

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

no_nic
Offline
Зарегистрирован: 12.06.2016

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

no_nic
Offline
Зарегистрирован: 12.06.2016

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

a5021
Offline
Зарегистрирован: 07.07.2013

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

no_nic
Offline
Зарегистрирован: 12.06.2016

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

tika
Offline
Зарегистрирован: 22.07.2015
Народ уже 3-й вариант и ошибка таже-в чем косак?
 
_222.ino: In function 'void loop()':
_222:131: error: a function-definition is not allowed here before '{' token
_222:145: error: a function-definition is not allowed here before '{' token
_222:366: error: expected `}' at end of input
_222:366: error: expected `}' at end of input
_222:366: error: expected `}' at end of input
_222:366: error: expected `}' at end of input
 
#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(); 
}

 

Valera19701
Valera19701 аватар
Offline
Зарегистрирован: 18.10.2015

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

tika
Offline
Зарегистрирован: 22.07.2015

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

elvis59
Offline
Зарегистрирован: 09.11.2016

ребята, помогите.
Имею два 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

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

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

elvis59
Offline
Зарегистрирован: 09.11.2016

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

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

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

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

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

elvis59
Offline
Зарегистрирован: 09.11.2016

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

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

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

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

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

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

elvis59
Offline
Зарегистрирован: 09.11.2016

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

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

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

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

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

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

elvis59
Offline
Зарегистрирован: 09.11.2016

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

elvis59
Offline
Зарегистрирован: 09.11.2016

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

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

магия)))

elvis59
Offline
Зарегистрирован: 09.11.2016

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

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

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

elvis59
Offline
Зарегистрирован: 09.11.2016

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

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

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

elvis59
Offline
Зарегистрирован: 09.11.2016

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

smesharik
Offline
Зарегистрирован: 31.01.2016

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

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

IHBALID
Offline
Зарегистрирован: 26.11.2016

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

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

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

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

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

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

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

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

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

tika
Offline
Зарегистрирован: 22.07.2015

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

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





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

 

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

tika
Offline
Зарегистрирован: 22.07.2015

Помогите врезать в 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);
    }
  }
}

 

arDubino
Offline
Зарегистрирован: 12.01.2017

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

arDubino
Offline
Зарегистрирован: 12.01.2017

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

tika
Offline
Зарегистрирован: 22.07.2015

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

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

arDubino
Offline
Зарегистрирован: 12.01.2017

tika пишет:

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

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

твою ж мать а.

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

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

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

tika
Offline
Зарегистрирован: 22.07.2015

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

releyshic
Offline
Зарегистрирован: 20.11.2015

Puhlyaviy пишет:
Значит нужно залесть в библиотеку и посмотреть как она выключается. По всей видимости она не отрубает модуль по команде стоп. Я эту библиотеку 2 года назад последний раз трогал :) не практичные эти модули.

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