کتابخانه و برنامه ی نمونه برای راه اندازی NRF24L01 کدویژن mega32

چیپ NRF24L01 نمونه تصحیح شده با امکانات بیشتر و دیتا ریت بالاتر چیپ NRF2401 است که توسط شرکت NORDIC در اوایل سال 2008 معرفی شد.
این چیپ  یک ماژول بسیار عالی برای ارسال و دریافت اطلاعات بدون خطا است چیزی که در ماژول های  HMTR یا حتی در RFMXX ها یا به کلی وجود نداشت یا این که مشکلات خاص خود را داشت.
مدولاسیون ارتباطی این ماژول به صورت GFSK است , همان مدولاسیونی که در تکنولوژی BLUETOOTH استفاده شده و به صورت انحصاری در دست چند شرکت بزرگ مثل BLUETOOTH  و  NORDIC SEMICONDUCTOR   و TEXAS INSTRUMENT و چند شرکت دیگر قرار دارد.
فرکانس ارتباطی این چیپ 2.4 گیگا هرتز است که این خاصیت آن ویژگی های زیادی را برای ما به ارمغان می آورد ! از جمله کوچک شدن سایز آنتن که حتی میتوان از خود PCB به صورت یک آنتن استفاده کرد , مورد دیگر هم به دلیل فرکانس بالا بسیار راحت تر از دیوار یا اجسام دیگر عبور می کند و با عث می شود که برد بیشتری هم به ما بدهد

کتابخانه های لازم

1.spi.c

#include <spi2.h>
#include <mega32.h>


#define PORT_SPI    PORTB
#define DDR_SPI     DDRB
#define DD_MISO     DDB6
#define DD_MOSI     DDB5
#define DD_SS       DDB4
#define DD_SCK      DDB7


void spi_init()
// Initialize pins for spi communication
{
//    DDR_SPI &= ~((1<<DD_MOSI)|(1<<DD_MISO)|(1<<DD_SS)|(1<<DD_SCK));
//    // Define the following pins as output
//    DDR_SPI |= ((1<<DD_MOSI)|(1<<DD_SS)|(1<<DD_SCK));
//
//    
//    SPCR = ((1<<SPE)|               // SPI Enable
//            (0<<SPIE)|              // SPI Interupt Enable
//            (0<<DORD)|              // Data Order (0:MSB first / 1:LSB first)
//            (1<<MSTR)|              // Master/Slave select   
//            (0<<SPR1)|(1<<SPR0)|    // SPI Clock Rate
//            (0<<CPOL)|              // Clock Polarity (0:SCK low / 1:SCK hi when idle)
//            (0<<CPHA));             // Clock Phase (0:leading / 1:trailing edge sampling)
//
//    SPSR = (1<<SPI2X);              // Double Clock Rate

// SPI initialization
// SPI Type: Master
// SPI Clock Rate: 2*500.000 kHz
// SPI Clock Phase: Cycle Start
// SPI Clock Polarity: Low
// SPI Data Order: MSB First
SPCR=0x51;
SPSR=0x01;
    
}

void spi_transfer_sync (char * dataout, char * datain, char len)
// Shift full array through target device

{
       char i; 
            
       for (i = 0; i < len; i++) {
             SPDR = dataout[i];
             while((SPSR & (1<<SPIF))==0);
             datain[i] = SPDR;
       }
}

void spi_transmit_sync (char * dataout, char len)
// Shift full array to target device without receiving any byte
{
       char i;      
       for (i = 0; i < len; i++) {
             SPDR = dataout[i];
             while((SPSR & (1<<SPIF))==0);
       }
}

char spi_fast_shift (char data)
// Clocks only one byte to target device and returns the received one
{
    SPDR = data;
    while((SPSR & (1<<SPIF))==0);
    return SPDR;
}

2.spi.h

#ifndef _SPI_H_
#define _SPI_H_

#include <io.h>


void spi_init();
void spi_transfer_sync (char* dataout, char* datain, char len);
void spi_transmit_sync (char * dataout, char len);
char spi_fast_shift (char data);


#endif /* _SPI_H_ */

3.mrif.c

#include <mirf.h>
#include <nRF24L01.h>
#include <spi2.h>
#include <mega32.h>
#include <delay.h>

// Defines for setting the MiRF registers for transmitting or receiving mode
#define TX_POWERUP mirf_config_register(CONFIG, mirf_CONFIG | ( (1<<PWR_UP) | (0<<PRIM_RX) | (1<<MASK_MAX_RT) ) )
#define RX_POWERUP mirf_config_register(CONFIG, mirf_CONFIG | ( (1<<PWR_UP) | (1<<PRIM_RX) | (1<<MASK_MAX_RT) ) )


// Flag which denotes transmitting mode
bit PTX;
char address[5]= { 0xb3, 0xb4, 0xb5, 0xb6, 0x05, };

void mirf_init() 
// Initializes pins ans interrupt to communicate with the MiRF module
// Should be called in the early initializing phase at startup.
{
    // Define CSN and CE as Output and set them to default
    DDRD.0 = 1;
    DDRC.7 = 1;
    mirf_CE_lo;
    mirf_CSN_hi; 
    
    
    // External Interrupt(s) initialization
    // INT2: On
    // INT2 Mode: Falling Edge
    GICR|=0x20;
    MCUCR=0x00;
    MCUCSR=0x00;
    GIFR=0x20;

    // Initialize spi module
    spi_init();
}


void mirf_config() 
// Sets the important registers in the MiRF module and powers the module
// in receiving mode
{
    // Set RF channel
    mirf_config_register(RF_CH,mirf_CH);

    // Set length of incoming payload 
   // mirf_config_register(RX_PW_P0, mirf_PAYLOAD);
    mirf_config_register( DYNPD, 0x3f);
    mirf_config_register( FEATURE, 0x07);
    
    mirf_config_register( EN_RXADDR, 0x3f); 
    
    mirf_config_register(RF_SETUP, 0x06); 
     
    mirf_config_register( EN_AA, 0x3f );
     
    mirf_set_RADDR ( address );
     
     //mirf_set_TADDR( address );
     

    // Start receiver 
    PTX = 0;        // Start in receiving mode
    RX_POWERUP;     // Power up in receiving mode
   
 mirf_CE_hi;     // Listening for pakets
}

void mirf_set_RADDR(char * adr) 
// Sets the receiving address
{
    mirf_CE_lo;
    mirf_write_register(RX_ADDR_P0,adr,5);  
   
    mirf_CE_hi;
}

void mirf_set_TADDR(char * adr)
// Sets the transmitting address
{
    mirf_write_register(TX_ADDR, adr,5);
}

// External Interrupt 0 service routine

interrupt [EXT_INT2] void ext_int2_isr(void)
{
char status;   
    // If still in transmitting mode then finish transmission
    if (PTX) 
    {
       
        // Read MiRF status 
        mirf_CSN_lo;                                // Pull down chip select
        status = spi_fast_shift(NOP);               // Read status register
        delay_us(30);
        mirf_CSN_hi;                                // Pull up chip select

        mirf_CE_lo;                             // Deactivate transreceiver
        RX_POWERUP;                             // Power up in receiving mode
        delay_us(30);
        mirf_CE_hi;                             // Listening for pakets
        PTX = 0;                                // Set to receiving mode

        // Reset status register for further interaction
        mirf_config_register(STATUS,(1<<TX_DS)|(1<<MAX_RT)); // Reset status register 
        
    } 

}
    
  


char mirf_data_ready() 
// Checks if data is available for reading
{  
    char status;
    if (PTX) return 0;
    
    // Read MiRF status 
    mirf_CSN_lo;                                // Pull down chip select
    status = spi_fast_shift(NOP);               // Read status register    
    
    mirf_CSN_hi;                                // Pull up chip select
    return status & (1<<RX_DR);
}

void mirf_get_data(char * data) 
// Reads mirf_PAYLOAD bytes into data array
{
    
    mirf_CSN_lo;                                 // Pull down chip select
    spi_fast_shift( R_RX_PAYLOAD );            // Send cmd to read rx payload
    spi_transfer_sync(data,data,mirf_PAYLOAD); // Read payload
    mirf_CSN_hi;                               // Pull up chip select
    mirf_config_register(STATUS,(1<<RX_DR));   // Reset status register
}

void mirf_config_register(char reg, char value)
// Clocks only one byte into the given MiRF register
{
    mirf_CSN_lo;
    spi_fast_shift(W_REGISTER | (REGISTER_MASK & reg));
    spi_fast_shift(value);
    
    mirf_CSN_hi;
}

void mirf_read_register(char reg, char *value, char len)
// Reads an array of bytes from the given start position in the MiRF registers.
{
    mirf_CSN_lo;
    spi_fast_shift(R_REGISTER | (REGISTER_MASK & reg));
    spi_transfer_sync(value,value,len); 
    
    mirf_CSN_hi;
}

void mirf_write_register(char reg, char * value, char len) 
// Writes an array of bytes into inte the MiRF registers.
{
    mirf_CSN_lo;
    spi_fast_shift(W_REGISTER | (REGISTER_MASK & reg));
    spi_transmit_sync(value,len);
   
    mirf_CSN_hi;
}


void mirf_send( char * value,  char len) 
// Sends a data package to the default address. Be sure to send the correct
// amount of bytes as configured as payload on the receiver.
{
    while (PTX);                  // Wait until last paket is send

    mirf_CE_lo;

    PTX = 1;                        // Set to transmitter mode
    TX_POWERUP;                     // Power up
    
    mirf_CSN_lo;                    // Pull down chip select
    spi_fast_shift( FLUSH_TX );     // Write cmd to flush tx fifo
    
    mirf_CSN_hi;                    // Pull up chip select
    
    mirf_CSN_lo;                    // Pull down chip select
    spi_fast_shift( W_TX_PAYLOAD ); // Write cmd to write payload
    spi_transmit_sync(value,len);   // Write payload
    
    mirf_CSN_hi;                    // Pull up chip select
   
    mirf_CE_hi;                     // Start transmission
}

4.mrif.h

#ifndef _MIRF_H_
#define _MIRF_H_

#include <io.h>

// Mirf settings
#define mirf_CH         112
#define mirf_PAYLOAD    1
#define mirf_CONFIG     ( /*(1<<MASK_RX_DR) |*/ (1<<EN_CRC) | (0<<CRCO) )

// Pin definitions for chip select and chip enabled of the MiRF module
#define CE  PD0
#define CSN PC7

// Definitions for selecting and enabling MiRF module
#define mirf_CSN_hi     PORTC.7 = 1 ;
#define mirf_CSN_lo     PORTC.7 = 0 ;
#define mirf_CE_hi      PORTD.0 = 1 ;
#define mirf_CE_lo      PORTD.0 = 0 ;

// Public standart functions
void mirf_init();
void mirf_config();
void mirf_send(char * value, char len);
void mirf_set_RADDR(char * adr);
void mirf_set_TADDR(char * adr);
char mirf_data_ready();
void mirf_get_data(char * data);


// Public extended functions
void mirf_config_register(char reg, char value);
void mirf_read_register(char reg, char * value, char len);
void mirf_write_register(char reg, char * value, char len);

#endif /* _MIRF_H_ */

برنامه ی نمونه برای mega32 فرستنده

#include <mega32.h>
#include <spi2.c>
#include <mirf.c>
#define xtal  8000000
#include <delay.h>
char t=0;

interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{
 t++;
 POWER++;
 TCNT0=0x00;
    if ( t==z)
    {
    PORTD.7 = !(PORTD.7);
    t = 0;
    }
}
                

void main(void)
{
char data_buf[1];
char buffer,i;

PORTA=0x00;
DDRA=0xff;
   
PORTD=0xfe;
DDRD=0x01; 
 
PORTC=0x00;
DDRC=0xff;

PORTB=0x0f;
DDRB=0xB0;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 31.250 kHz
// Mode: Normal top=0xFF
// OC0 output: Disconnected
TCCR0=0x04;
TCNT0=0x00;
OCR0=0x00;
TIMSK=0x01;

//// Allocate buffer array
//    char data_buf[1];
//// Initialize SPI
//    spi_init();
//// Send 0xFF to spi slave and read 1 byte back to the same array
//    data_buf[0] = 0xFF;
//    spi_transfer_sync(data_buf,data_buf,1);
//// Show received byte on LEDs
//    PORTC = ~data_buf[0];


  

 // Initialize AVR for use with mirf
mirf_init();
// Wait for mirf to come up
delay_ms(300);
// Activate interrupts
#asm ( "sei" )
// Configure mirf
mirf_config();
// Test communication

while(1)
{
if(PIND.2==0)
{
 data_buf[0]=1;
 delay_ms(30);
 mirf_send(data_buf,1);
 }
 
 if(PIND.3==0)
{
 data_buf[0]=2;
 delay_ms(30);
 mirf_send(data_buf,1);
 }
 
 if(PIND.4==0)
{
 data_buf[0]=3;
 delay_ms(30);
 mirf_send(data_buf,1);
 }
 
 if(PIND.5==0)
{
 data_buf[0]=4;
 delay_ms(30);
 mirf_send(data_buf,1);
 }
 
 if((PIND.2==1)&(PIND.3==1)&(PIND.4==1)&(PIND.5==1))
 {
 data_buf[0]=5;
 delay_ms(30);
 mirf_send(data_buf,1);
 }
 

  



//while (!mirf_data_ready());
//
//mirf_get_data(data_buf);

}

}

 برنامه نمونه برای گیرنده mega32

#include <mega32.h>
#include <spi2.c>
#include <mirf.c>
#define xtal 8000000
#include <delay.h> 

int m;

char t=0;

interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{
 t++;
 TCNT0=0x00;
    if ( t==15)
    {
    PORTD.7 = !(PORTD.7);
    t = 0;
    }
}
                

void main(void)
{
char data_buf[1];
char buffer,i;


ADMUX=0b01000110;
ADCSRA=0b10000110;
   

DDRA=0b1011111;


DDRD=0xff; 
 
PORTC=0x00;
DDRC=0xff;

PORTB=0x0f;
DDRB=0xB0;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 31.250 kHz
// Mode: Normal top=0xFF
// OC0 output: Disconnected
TCCR0=0x04;
TCNT0=0x00;
OCR0=0x00;
TIMSK=0x01;


  TCCR1A=0b10100000;
  TCCR1B=0b00010011;
  ICR1H=0X03;
  ICR1L=0XFF;



 // Initialize AVR for use with mirf
mirf_init();
// Wait for mirf to come up
delay_ms(300);
// Activate interrupts

// Configure mirf
mirf_config();
// Test communication
#asm ( "sei" )

while(1)
{



//mirf_send(data_buf,1);

while (!mirf_data_ready());

 mirf_get_data(data_buf);

switch(data_buf[0]){
case 1:
  OCR1A=m;
  OCR1B=m;
  PORTA.2=1; 
  PORTA.3=0; 
  PORTA.4=0;  
  PORTA.5=1;
  break; 
  
case 2:
  OCR1A=m;
  OCR1B=m;
  PORTA.2=0; 
  PORTA.3=1; 
  PORTA.4=1;  
  PORTA.5=0;
  break;
  
case 3:
  OCR1A=0;
  OCR1B=1023;
  PORTA.2=0; 
  PORTA.3=0; 
  PORTA.4=0;  
  PORTA.5=1;
  break;
  
case 4: 
  OCR1A=1023;
  OCR1B=0;
  PORTA.2=1; 
  PORTA.3=0; 
  PORTA.4=0;  
  PORTA.5=0; 
  break;
  
case 5:
  OCR1A=0;
  OCR1B=0;
 PORTA=0x00;
 break; 
} 

ADCSRA=ADCSRA | 0b01000000;
while((ADCSRA&0b00010000)==0);
ADCSRA=ADCSRA | 0b00010000;
m=ADCW;    
 
  
}

}

کتابخانه و برنامه ی نمونه برای راه اندازی NRF24L01 کدویژن mega 8

1. nrf24l01p.h

#ifndef __nrf24l01p_h_included__
#define __nrf24l01p_h_included__

#define IRQ PORTD.2
#define DD_IRQ DDRD.2

#define CE PORTC.0
#define DD_CE DDRC.0

#define CSN PORTB.2
#define DD_CSN DDRB.2  

#define MOSI PORTB.3
#define DD_MOSI DDRB.3 

#define MISO PORTB.4
#define DD_MISO DDRB.4

#define CLK PORTB.5
#define DD_CLK DDRB.5
 
flash unsigned char base_address[5]={0x00,0x01,0x03,0x07,0x00};
unsigned char temp_address[5]={0x00,0x01,0x03,0x07,0x00};
unsigned char payload[33];
unsigned char command_buff=0,status_buff=0,nrf_state=0;
char nrf_mode;
bit sent_actived=0;
unsigned char spi(unsigned char data){
    SPDR=data;
    while(!(SPSR & 0x80)); 
    data=SPSR; 
    return SPDR;
}
  void nrf_inst(unsigned char ins){
    int i;                              
    CSN=0;    
    status_buff=spi(ins);       
    switch(ins & 0xE0)
    {
        case 0x00:
        {                         
            if((ins & 0x1F)==0x0A || (ins & 0x1F)==0x0B || (ins & 0x1F)==0x10){
                for(i=4;i>=0;i--){
                    temp_address[i]=spi(0xFF);
                }
            }
            else{
                command_buff=spi(0xFF);   
            }
            break;
        }
        case 0x20:  
        {                         
            if((ins & 0x1F)==0x0A || (ins & 0x1F)==0x0B || (ins & 0x1F)==0x10){
                for(i=4;i>=0;i--){
                    spi(base_address[i]);
                } 
            }
            else{  
                spi(command_buff);
            }
            break;
        }         
        case 0x60:
        {
            if((ins & 0x01)==1){
                i=payload[0];
                while(i!=0){
                    payload[i]=spi(0xFF); 
                    i--;
                }    
            }
            else{
                command_buff=spi(0xFF);    
            }
            break;
        }
        case 0xA0:
        {    
            i=payload[0];
            while(i!=0){
                spi(payload[i]); 
                i--;
            }
            break;
        }
        
    }   
    CSN=1;  
    delay_us(10);
  }
  interrupt [EXT_INT0] void ext0_isr(){ 
    if(nrf_mode==0){
        nrf_inst(0xFF); 
        if(status_buff & 0x20){
            nrf_state=2;
            nrf_inst(0x17);        
            if((command_buff & 0x01)==0){
                nrf_inst(0x60);  
                if(command_buff<=32){
                    payload[0]=command_buff; 
                    nrf_inst(0x61);    
                    nrf_state=3;
                }
                else
                    nrf_inst(0xE2);
            }          
        }
        else{
            nrf_state=4;
        }
    }                                                     
    else{
        nrf_inst(0x60); 
        if(command_buff>32){
            nrf_inst(0xE2);
        }
        else{
            payload[0]=command_buff;
            nrf_inst(0x61);
            nrf_state=1;
        }
    }     
    command_buff=0x7E; 
    nrf_inst(0x27);    
    nrf_inst(0xE1);                                                  
  }

  void sent(){ 
    if(sent_actived){
        sent_actived=0;  
        if((temp_address[4]==base_address[4]) && (temp_address[3]==base_address[3]) && (temp_address[2]==base_address[2]) && (temp_address[1]==base_address[1]) && (temp_address[0]==base_address[0])){
            nrf_inst(0xE1); 
            nrf_inst(0xA0);           
            delay_ms(10);
            CE=1;
            delay_us(20);
            CE=0;
            delay_ms(10);
        }
        else{
            nrf_state=5;
        } 
    }                                      
  }

  void nrf_config(char mode){
    IRQ=1; 
    CSN=1; 
    DD_CSN=1;
    CLK=0;
    DD_CLK=1;
    CE=0;
    DD_CE=1;
    DD_MOSI=1;
    DD_MISO=0;  
    GIFR=0x40;
    GICR|=0x40;          
    #asm("sei")
    SPCR=0x50;        
    delay_ms(110);
    
    nrf_mode=mode;   
    
    command_buff=0x01;
    nrf_inst(0x21);   
    
    command_buff=0x01;
    nrf_inst(0x22);   
      
    command_buff=0x03;
    nrf_inst(0x23);   
    
    command_buff=0x2f;
    nrf_inst(0x24);   
                       
    command_buff=0x01;   
    nrf_inst(0x25);      
    
    command_buff=0x06;   
    nrf_inst(0x26);      
    
    nrf_inst(0x2A);      
    
    nrf_inst(0x30);      
    
    command_buff=0x01;   
    nrf_inst(0x3C);      
        
    command_buff=0x07;   
    nrf_inst(0x3D);          
    
    if(mode==0){
        command_buff=0x4E;
        nrf_inst(0x20);   
        delay_ms(100);
        sent_actived=1;
    }
    else{
        command_buff=0x3F;
        nrf_inst(0x20);   
        delay_ms(5);
        CE=1;
    } 
  }
#endif

 برنامه نمونه فرستنده برای ATmega8

#include <mega8.h>
#define xtal 8000000
#include <delay.h>
#include <nrf24l01p.h>

unsigned char h1=0,h2=0,h3=0,h4=0,h5=0,h6=0,h7=0,h8=0;
int d1,d2,d3,d4,d5,d6,d7,d8;
    interrupt [TIM0_OVF] void timer0_ovf_isr(void){  
        d1++;
        d2++;
        d3++;
        d4++;
        d5++;
        d6++;
        d7++;
        d8++;
    }
 void main(void){ 
    TCCR0=0x02;
    TCNT0=0x00;
    TIMSK=0x01;  
    #asm("sei")   
nrf_config(0);
//*********************************************//
DDRD.0=0;PORTD.0=1;
DDRD.1=0;PORTD.1=1;
DDRD.3=0;PORTD.3=1;
DDRD.4=0;PORTD.4=1;
DDRD.5=0;PORTD.5=1;
DDRD.6=0;PORTD.6=1;
DDRD.7=0;PORTD.7=1;
DDRC.1=0;PORTC.1=1;

DDRC.2=1;PORTC.2=0;  //baray LED neshadahandey connect
//*********************************************//
   while (1){ 

    if(!PIND.0){ 
        if(d1>=160){ 
            d1=161;
            h1=10; 
        }   
    }else{h1=0;d1=0;}    
    
        if(!PIND.1){ 
            if(d2>=160){ 
                d2=161;
                h2=20; 
            }   
    }else{h2=0;d2=0;}
    
        if(!PIND.3){ 
            if(d3>=160){ 
                d3=161;
                h3=30; 
            }   
    }else{h3=0;d3=0;}
    
        if(!PIND.4){ 
            if(d4>=160){ 
                d4=161;
                h4=40; 
            }   
    }else{h4=0;d4=0;}
    
        if(!PIND.5){ 
            if(d5>=160){ 
                d5=161;
                h5=50; 
            }   
    }else{h5=0;d5=0;}
    
        if(!PIND.6){ 
            if(d6>=160){ 
                d6=161;
                h6=60; 
            }   
    }else{h6=0;d6=0;}
    
        if(!PIND.7){ 
            if(d7>=160){ 
                d7=161;
                h7=70; 
            }   
    }else{h7=0;d7=0;}
    
        if(!PINC.1){ 
            if(d8>=160){ 
                d8=161;
                h8=80; 
            }   
    }else{h8=0;d8=0;}
     
    if(nrf_state==2){
        PORTC.2=1;
    }else{PORTC.2=0;}   
      
      if(nrf_state!=0){
        sent_actived=1;
        nrf_state=0;
      }
      payload[0]=8; 
      payload[1]=h1; 
      payload[2]=h2;
      payload[3]=h3;      
      payload[4]=h4;      
      payload[5]=h5;      
      payload[6]=h6;      
      payload[7]=h7;      
      payload[8]=h8;      
      sent(); 
   }
}

 برنامه نمونه گیرنده برای ATmega8

#include <mega8.h>
#define xtal 8000000
#include <delay.h>
#include <nrf24l01p.h>
unsigned char c1,c2,c3,c4,c5,c6,c7,c8,off=0;
int t=0;
    interrupt [TIM0_OVF] void timer0_ovf_isr(void){
    if(t)t++;
    if(t>=1000){
        t=0;   
        off=1;
    }
}

 void main(void){ 
    TCCR0=0x02;
    TCNT0=0x00;
    TIMSK=0x01;  
    #asm("sei")    
 nrf_config(1); 
 //-----------------------------------//   
    DDRD.0=1;PORTD.0=0;
    DDRD.1=1;PORTD.1=0;
    DDRD.3=1;PORTD.3=0;
    DDRD.4=1;PORTD.4=0;
    DDRD.5=1;PORTD.5=0;
    DDRD.6=1;PORTD.6=0;
    DDRD.7=1;PORTD.7=0;
    DDRC.1=1;PORTC.1=0;
 //-----------------------------------//
   while (1){
       if(nrf_state==1){
        c1=payload[1];
        c2=payload[2];
        c3=payload[3];        
        c4=payload[4];        
        c5=payload[5];        
        c6=payload[6];        
        c7=payload[7];        
        c8=payload[8];         
        nrf_state=0; 
        
        t=1;
        if(c1==10){
        
            PORTD.0=1;
            delay_ms(20);
        }
        if(c2==20){
            PORTD.1=1;
            PORTD.3=1;
        } 
        
        if(c3==30){
            PORTD.4=1;
            delay_ms(20);
        } 
        
        if(c4==40){
            PORTD.0=1;
            PORTD.4=1;
        }
        PORTD=0x00; 
       }
      
       if(off==1){
        off=0;
        PORTD.0=0;PORTD.1=0;PORTD.3=0;PORTD.4=0;PORTD.5=0;PORTD.6=0;PORTD.7=0;PORTC.1=0;
       } 
   }
 }

در پست دیگری فیلم عملکرد مدار و توضیحات بیشتر برای راه اندازی بهتر و شماتیک مدار لازم برای راه اندازی NRF24L01 قرار داده می شود.

 برنامه نمونه برای راه اندازی با کامپایلر بسکام برنامه توسط مهندس عباسزاده نوشته شده است که در فایل zip  برای دانلود قرار داده می شود