Ss_McAir24.cpp

Go to the documentation of this file.

#include "Ss_McAir24.h"

ss_nrf24 McAir24 = ss_nrf24();

// =============================================================================
void ss_nrf24::transferSync(uint8_t *dataout,uint8_t *datain,uint8_t len)
{
    for(uint8_t i = 0;i < len;i++) datain[i] = SPI.transfer(dataout[i]);
}
// =============================================================================
void ss_nrf24::transmitSync(uint8_t *dataout,uint8_t len)
{
    //for(uint8_t i = 0;i < len;i++) SPI.transfer(dataout[i]);
  while (len--) SPI.transfer(*dataout++);
}

// =============================================================================
/*! Initialize the nrf24 library
\param ce ce pin
\param scn csn pin  
\return return false if some initializing errors was found
*/

bool ss_nrf24::init(uint8_t ce,uint8_t csn)
// Should be called in the early initializing phase at startup.
{

    csnPin = csn;
    cePin=ce;
    pinMode(cePin,OUTPUT);
    pinMode(csnPin,OUTPUT);

    ceLow();
    csnHi();

    pinMode(SCK, OUTPUT);
    pinMode(MOSI, OUTPUT);
    // Wait for NRF24 POR (up to 100msec)
    delay(100);

    SPI.begin();
    SPI.setDataMode(SPI_MODE0);
    SPI.setBitOrder(MSBFIRST);
    #ifdef __AVR__
           SPI.setClockDivider(SPI_CLOCK_DIV2);
    #else          //#ifdef _SAM3XA_
         SPI.setClockDivider(21);
    #endif


    powerDown();
    flushTx();
    flushRx();

    return powerUpRx();
}

// =============================================================================
/*! Set rf channel
\param channel is the channel number from 0 to 127. Every channel adds a 1MHz (or a bit more, related to the speed setting) to the basic 2.4GHz frequency.
Warning: In some countries you can have some limitation, for example in USA the last legal channel is 84.

*/
void ss_nrf24::setChannel(uint8_t channel)
{
    configRegister(RF_CH,channel);
}

// =============================================================================
/*! Set payload size

Note: if you don't use my McAirData protocol, you MUST set this and please remember that payload size MUST be the same in server and client module. 
\param payload_size is the size of payload.
*/
void ss_nrf24::setPayLoadSize(uint8_t payload_size)
{  // Set length of incoming payload 
    configRegister(RX_PW_P0, payload_size);
    configRegister(RX_PW_P1, payload_size);
  payload=payload_size;
}

// =============================================================================
/*! Set receiver address (local module)
\param adr is a 5byte address. 

*/
void ss_nrf24::setRADDR(uint8_t * adr)
{  // Sets the receiving address
    ceLow();
    writeRegister(RX_ADDR_P1,adr,McAir24_ADDR_LEN);
    ceHi();
}
// =============================================================================
/*! Set trasmitter address (remote module)
\param adr is the 5bytes address. 
*/
void ss_nrf24::setTADDR(uint8_t * adr)
// Sets the transmitting address
{
     //RX_ADDR_P0 must be set to the sending addr for auto ack to work.
    writeRegister(RX_ADDR_P0,adr,McAir24_ADDR_LEN);
    writeRegister(TX_ADDR,adr,McAir24_ADDR_LEN);
}
// =============================================================================
/*! Checks if data is available for reading
\return This function return true if you have data ready, or false if data aren't ready

*/
bool ss_nrf24::dataReady()
// 
{
    // See note in getData() function - just checking RX_DR isn't good enough
    uint8_t status = getStatus();

    // We can short circuit on RX_DR, but if it's not set, we still need
    // to check the FIFO for any pending packets
       if(status & McAir24_RX_DR) return 1;
//    VERIFICARE 
//        // Manual says that messages > 32 octets should be discarded
//    if (spiRead(NRF24_COMMAND_R_RX_PL_WID) > 32)
//    {
//  flushRx();
//  return false;
//    }
    return !rxFifoEmpty();
}

// =============================================================================
bool ss_nrf24::rxFifoEmpty()
{
    uint8_t fifoStatus;
    readRegister(McAir24_Reg17_FIFO_STATUS,&fifoStatus,sizeof(fifoStatus));
    return (fifoStatus & McAir24_RX_EMPTY);  //1 fifo empty / 0 fifo data
}

// =============================================================================
/*! Reads data from module and transfert it to Arduino's buffer
\param data is the buffer where you want to copy the data. Please remember that data buffer MUST be at least as payload size. 
*/
void ss_nrf24::getData(uint8_t * data)
// Reads payload bytes into data array
{
    csnLow();                               // Pull down chip select
    SPI.transfer( R_RX_PAYLOAD );            // Send cmd to read rx payload
    transferSync(data,data,payload); // Read payload
    csnHi();                               // Pull up chip select
    // NVI: per product spec, p 67, note c:
    //  "The RX_DR IRQ is asserted by a new packet arrival event. The procedure
    //  for handling this interrupt should be: 1) read payload through SPI,
    //  2) clear RX_DR IRQ, 3) read McAir24_Reg17_FIFO_STATUS to check if there are more 
    //  payloads available in RX FIFO, 4) if there are more data in RX FIFO,
    //  repeat from step 1)."
    // So if we're going to clear RX_DR here, we need to check the RX FIFO
    // in the dataReady() function
    configRegister(McAir24_Reg07_STATUS,McAir24_RX_DR);   // Reset status register
}
// =============================================================================
uint8_t ss_nrf24::configRegister(uint8_t reg, uint8_t value)
{
    csnLow();
    uint8_t status=SPI.transfer(McAir24_W_REGISTER | (McAir24_REGISTER_MASK & reg));
    SPI.transfer(value);   //vale solo per un byte
    csnHi();
    return(status);
}
// =============================================================================
void ss_nrf24::writeRegister(uint8_t reg, uint8_t * value, uint8_t len)
{  // Writes an array of bytes into inte the McAir24 registers.
    csnLow();
    SPI.transfer(McAir24_W_REGISTER | (McAir24_REGISTER_MASK & reg));
    transmitSync(value,len);   //bytes multipli
    csnHi();
}
// =============================================================================
uint8_t ss_nrf24::readRegister(uint8_t reg, uint8_t * value, uint8_t len)
{ // Reads an array of bytes from the given start position in the McAir24 registers.
    csnLow();
    uint8_t status=SPI.transfer(McAir24_R_REGISTER | (McAir24_REGISTER_MASK & reg));
    transferSync(value,value,1);
    csnHi();
    return(status);}

// =============================================================================
uint8_t ss_nrf24::readRegister(uint8_t reg)
{
    csnLow();
    SPI.transfer(McAir24_R_REGISTER | (McAir24_REGISTER_MASK & reg));
    uint8_t status=SPI.transfer(0xff);
    csnHi();
    return(status);
}

// =============================================================================
/*! Send data to remote module
 \param value is the buffer of data. The lenght is not specificated because it's used the payload size. 
*/
void ss_nrf24::send(uint8_t * value)
{
    uint8_t status;
    status = getStatus();
    while (PTX)
    {  // Wait until last paket is send
        status = getStatus();
      if(status & (McAir24_MASK_TX_DS  | McAir24_MASK_MAX_RT))
      {
            PTX = 0;
            break;
        }
    }

    ceLow();
    powerUpTx();       // Set to transmitter mode , Power up
    spiCommand(McAir24_FLUSH_TX);

    csnLow();                     // Pull down chip select
    SPI.transfer( W_TX_PAYLOAD ); // Write cmd to write payload
   //W_TX_PAYLOAD=0xa0, per fare no ACK usa 0xb0


    transmitSync(value,payload);  // Write payload
    csnHi();                      // Pull up chip select


    ceHi();                     // Start transmission  
    //while(isSending()){}
}

// =============================================================================
bool ss_nrf24::isSending()
{
    uint8_t status;
    if(PTX){
        status = getStatus();
    if(status & (McAir24_TX_DS  |  McAir24_MAX_RT))  //  if sending successful (TX_DS) or max retries exceded (MAX_RT).
    {
            powerUpRx();
            return false;
        }

        return true;
    }
    return false;
}
// =============================================================================
uint8_t ss_nrf24::getStatus(){
    uint8_t rv;
    readRegister(McAir24_Reg07_STATUS,&rv,1);
    return rv;
}
// =============================================================================
bool ss_nrf24::powerUpRx()
{
    PTX = 0;
    ceLow();
  delayMicroseconds(200);
  // PRIM_RX set=receiver / not set=transmitter
  //EN_CRC: crc activated | CRCO->if set 2bytes crc, else 1byte crc.
  bool status=configRegister(McAir24_Reg00_CONFIG, McAir24_EN_CRC | McAir24_PWR_UP | McAir24_PRIM_RX);
  //configRegister(McAir24_Reg01_EN_AA,0x41);// test abilitazione auto ACK

    ceHi();
  configRegister(McAir24_Reg07_STATUS,McAir24_TX_DS | McAir24_MAX_RT); //clear interrupt 

  flushTx(); // Aggiunta io
  return(status);
}
// =============================================================================
uint8_t ss_nrf24::spiCommand(uint8_t command)
{
    csnLow();
    uint8_t status = SPI.transfer(command);
    csnHi();
    return status;
}
// =============================================================================
uint8_t ss_nrf24::spiRead(uint8_t command)
{
    csnLow();
    SPI.transfer(command); // Send the address, discard status
    uint8_t val = SPI.transfer(0); // The MOSI value is ignored, value is read
    csnHi();
    return val;
}
// =============================================================================
uint8_t ss_nrf24::spiWrite(uint8_t command, uint8_t val)
{
    csnLow();
    uint8_t status = SPI.transfer(command);
    SPI.transfer(val); // New register value follows
    csnHi();
    return status;
}
// =============================================================================
uint8_t ss_nrf24::flushRx()
{
   return spiCommand(McAir24_FLUSH_RX);
}
// =============================================================================
uint8_t ss_nrf24::flushTx()
{
   return spiCommand(McAir24_FLUSH_TX);
}
// =============================================================================
void ss_nrf24::powerUpTx(){
    PTX = 1;
    //configRegister(McAir24_Reg00_CONFIG, McAir24_Base | ( (1<<PWR_UP) | (0<<PRIM_RX) ) );
  configRegister(McAir24_Reg00_CONFIG, McAir24_EN_CRC | McAir24_PWR_UP);
  delayMicroseconds(200);
}
// =============================================================================
void ss_nrf24::ceHi(){
    digitalWrite(cePin,HIGH);
}
// =============================================================================
void ss_nrf24::ceLow(){
    digitalWrite(cePin,LOW);
}
// =============================================================================
void ss_nrf24::csnHi(){
    digitalWrite(csnPin,HIGH);
}
// =============================================================================
void ss_nrf24::csnLow(){
    digitalWrite(csnPin,LOW);
}
// =============================================================================
void ss_nrf24::powerDown()
{// nella nrf24 sono invertite
    ceLow();
    configRegister(McAir24_Reg00_CONFIG, McAir24_Base );
}

// =============================================================================
/*!Set the speed and power of the transmitter
\param sp is a mix of signal power and speed of the transmitter. You can combine them using ! symbol. The option you can combine are:<br>
In this first list you can see the transmission power and relative consumption.
 <ul>
  <li>McAir24_PWR_18dB - 11.3mA (Maximum power)</li>
  <li>McAir24_PWR_12dB - 9mA</li>
  <li>McAir24_PWR_6dB - 7.5mA</li>
  <li>McAir24_PWR_0dB - 7mA</li>
</ul> 
In this second list you can see the speed setting from 250K to 2M                                
 <ul>
  <li>McAir24_SPD_250K (only nrf24l01+, whith plus)</li>
  <li>McAir24_SPD_1M</li>
  <li>McAir24_SPD_2M</li>
</ul>
 
\code 
  McAir24.Set_Speed_Power(McAir24_SPD_1M | McAir24_PWR_18dB);
\endcode
*/


bool ss_nrf24::Set_Speed_Power(uint8_t sp)
{
 bool res=false;
 uint8_t val=0;
 configRegister(McAir24_Reg06_RF_SETUP,sp);
 readRegister(McAir24_Reg06_RF_SETUP,&val,1);

 if (val == sp ) res = true;

 if((sp&McAir24_SPD_250K)==McAir24_SPD_250K)
 {
  configRegister(McAir24_Reg04_SETUP_RETR,0x47); //1250u / 5 retr.  0x47
 }
 else configRegister(McAir24_Reg04_SETUP_RETR,0x13); //500u / 3 retr.
 return(res);
}

// =============================================================================
bool ss_nrf24::waitAvailableTimeout(uint16_t timeout)
{
    while(isSending()){}
    powerUpRx();
    unsigned long starttime = millis();
    while ((millis() - starttime) < timeout) if (dataReady()) return true;
    return false;
}
// =============================================================================
/*! This function sensds data (char) using McAirData protocol
\param group is the grop of data (0 to 255)
\param elemnt is a element of the specific group (0 to 255)
\param dato is the char you want to send
\del is optional (default=30). It's a little delay in milliseconds after data send. It's necessary to prevent buffer overflow if yo are using intensive transmission. 
If you send only a single data you can set to 0 for a faster transmission. 
*/
void ss_nrf24::SendAirData(uint8_t group,uint8_t element,char dato,uint8_t del)
{
  RefData.IO.Data.datachar[0]=dato;
  SetGE(group,element);
  SendData(del);

}
// =============================================================================
/*! This function sensds data (int) using McAirData protocol
\param group is the grop of data (0 to 255)
\param elemnt is a element of the specific group (0 to 255)
\param dato is the int you want to send
\del is optional (default=30). It's a little delay in milliseconds after data send. It's necessary to prevent buffer overflow if yo are using intensive transmission. 
If you send only a single data you can set to 0 for a faster transmission. 
*/
void ss_nrf24::SendAirData(uint8_t group,uint8_t element,int dato,uint8_t del)
{
  RefData.IO.Data.dataint[0]=dato;
  SetGE(group,element);
  SendData(del);
}
// =============================================================================
/*! This function sensds data (float) using McAirData protocol
\param group is the grop of data (0 to 255)
\param elemnt is a element of the specific group (0 to 255)
\param dato is the float you want to send
\del is optional (default=30). It's a little delay in milliseconds after data send. It's necessary to prevent buffer overflow if yo are using intensive transmission. 
If you send only a single data you can set to 0 for a faster transmission. 
*/
void ss_nrf24::SendAirData(uint8_t group,uint8_t element,float dato,uint8_t del)
{
  RefData.IO.Data.datafloat=dato;
  SetGE(group,element);
  SendData(del);
}
// =============================================================================
/*! This function sensds data (unsigned long) using McAirData protocol
\param group is the grop of data (0 to 255)
\param elemnt is a element of the specific group (0 to 255)
\param dato is the unsigned long you want to send
\del is optional (default=30). It's a little delay in milliseconds after data send. It's necessary to prevent buffer overflow if yo are using intensive transmission. 
If you send only a single data you can set to 0 for a faster transmission. 
*/
void ss_nrf24::SendAirData(uint8_t group,uint8_t element,unsigned long dato,uint8_t del)
{
  RefData.IO.Data.datalong=dato;
  SetGE(group,element);
  SendData(del);
}

// =============================================================================
/** \brief Send data using McAir protocol
 * \param del is a optional delay in milli seconds (default is 30 if not specificated)
 */
void ss_nrf24::SendData(uint8_t del)
{
  if(payload!=6) setPayLoadSize(6);
  send((byte *)RefData.databuffer);
  while(isSending()){}
  delay(del);
}
// =============================================================================

// =============================================================================

void ss_nrf24::SetGE(uint8_t group,uint8_t element)
{
  RefData.IO.Group=group;
  RefData.IO.Element=element;
}
// =============================================================================
/*! If there are data ready, this function copies data to internal buffer

After you used this function you can read the internal buffer in very simple mode. You can read Group Element and Data sent by some simple macros:<br>
McAirGroup: contains the group<br>
McAirElement: contains the element of the specific group<br>
For the data you can use some macros depending the type of data you want to read (char, int, float, unsigned long). These are:<br>
<ul>
<li>McAirDataChar</li>
<li>McAirDataInt</li>
<li>McAirDataFloat</li>
<li>McAirDataLong</li>
</ul>

\code


if(McAir24.GetAirData()) // check iv data ready
{
  if(McAirGroup=='T') // group 'T'
  {
   Serial.print("ok received number: ");
   Serial.print((int)McAirElement); //this is the element of specific group 
   Serial.print(" - content: ");
   Serial.println(McAirDataFloat); //this is the float value transmitted in the specific group and element
  }
}
\endcode
\return This function return true if data was read, else return false

*/
bool ss_nrf24::GetAirData()
{
  if(!isSending() && dataReady()) // controllo se ho ricevuto dati rf24
  {
    getData((uint8_t *)RefData.databuffer); //RefData è un puntatore al buffer
    return(true);
  }
  return false;

}


// =============================================================================
/*!Show internal registers in hex and binary format. useful for debug.  
*/
void ss_nrf24::Print_Internal_Registers()
{
  uint8_t registro;
  for(int kk=0;kk<0x17;kk++)
  {
   registro=0;
   McAir24.readRegister( kk, &registro, sizeof(registro) );
   Serial.print( "Register 0x" );
  Serial.print(kk,HEX);

   Serial.print( " = " );

   Serial.print( registro, BIN );
   Serial.print( " - 0x" );
   Serial.println( registro, HEX );
  }

}
// =============================================================================
/*! RPD: Receive Power Detector: This function tell you if the spicificated channel has a sufficient signal power
\return true if signal is present
*/
bool ss_nrf24::isSignal(void)
{
  //setta solo il primo bit per segnali >-64dBm
  //delayMicroseconds(200);  //need 170
  delay(1);
  return ( readRegister(McAir24_Reg09_RPD) & 1 );
}


// =============================================================================