API tools faq
paste
Advertisement
Mukmin039

Nrfl.c

Mukmin039
Jul 21st, 2022 (edited)
401
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 13.36 KB | Software | 0 0
raw download clone embed print report
  1.  
  2.  * File:   nrf24_lib.c
  3.  * Author: Noyel Seth (noyelseth@gamil.com)
  4.  */
  5.  
  6. #include "nrf24_lib.h"
  7.  
  8. void nrf24_write_register(unsigned char mnemonic_addr, unsigned char value) {
  9.     NRF24L01_CSN_L();
  10.     if (mnemonic_addr < W_REGISTER) {
  11.         // This is a register access
  12.         SPI_WRITE_BYTE(W_REGISTER | (mnemonic_addr & NRF24_MEM_REGISTER_MASK));
  13.         SPI_WRITE_BYTE(value);
  14.     } else {
  15.         // This is a single byte command or future command/register
  16.         SPI_WRITE_BYTE(mnemonic_addr);
  17.         if ((mnemonic_addr != FLUSH_TX) && (mnemonic_addr != FLUSH_RX) && \
  18.                 (mnemonic_addr != REUSE_TX_PL) && (mnemonic_addr != NRF24_MEM_CMD_NOP)) {
  19.             // Send register value
  20.             SPI_WRITE_BYTE(value);
  21.         }
  22.     }
  23.     NRF24L01_CSN_H();
  24.     __delay_us(10);
  25. }
  26.  
  27. unsigned char nrf24_read_register(unsigned char mnemonic_addr) {
  28.     unsigned char byte0;
  29.     NRF24L01_CSN_L();
  30.     SPI_WRITE_BYTE(R_REGISTER | (mnemonic_addr & NRF24_MEM_REGISTER_MASK) );
  31.     byte0 = SPI_READ_BYTE(NRF24_MEM_CMD_NOP);
  32.     NRF24L01_CSN_H();
  33.     return byte0;
  34. }
  35.  
  36. void nrf24_write_buff(unsigned char mnemonic_addr, unsigned char *buffer, unsigned char bytes) {
  37.     unsigned char i;
  38.     NRF24L01_CSN_L();
  39.     //printf("Buffer = %s\r\n", buffer);
  40.     SPI_WRITE_BYTE(W_REGISTER | mnemonic_addr);
  41.     for (i = 0; i < bytes; i++) {
  42.         SPI_WRITE_BYTE(*buffer);
  43.         buffer++;
  44.         __delay_us(10);
  45.     }
  46.     NRF24L01_CSN_H();
  47. //    __delay_us(10);
  48. }
  49.  
  50. void nrf24_read_buff(unsigned char mnemonic_addr, unsigned char *buffer, unsigned char bytes) {
  51.     unsigned char i;
  52.     NRF24L01_CSN_L();
  53.     SPI_WRITE_BYTE(R_REGISTER | mnemonic_addr);
  54.     for (i = 0; i < bytes; i++) {
  55.         *buffer = SPI_READ_BYTE(NRF24_MEM_CMD_NOP);
  56.         buffer++;
  57.     }
  58.     *buffer = (unsigned char )NULL;
  59.     NRF24L01_CSN_H();
  60. }
  61.  
  62. NRF24_INIT_STATUS nrf24_rf_init(unsigned char mode, unsigned char rf_channel) {
  63.     NRF24_INIT_STATUS stat = NRF24_INIT_FAILED;
  64.     SPI_INIT();
  65.     NRF24L01_CSN_SetOutput();
  66.     NRF24L01_CE_SetOutput();
  67.     NRF24L01_CSN_L();
  68.     NRF24L01_CE_L();
  69.     __delay_us(10);
  70.     NRF24L01_CE_L();
  71.     //nrf24_write_register(NRF24_MEM_CONFIG, 0x0A);//enable CRC 1 byte, power up radio, and ptx mode
  72.     nrf24_write_register(NRF24_MEM_CONFIG, 0x0E);//enable CRC 2 byte, power up radio, and ptx mode
  73.     __delay_us(10);
  74.     //nrf24_write_register(NRF24_MEM_EN_AA, 0x00);//Disable auto acknowledge in pipe 0
  75.     //nrf24_write_register(NRF24_MEM_EN_AA, 0x01); //Enable auto acknowledge in pipe 0
  76.     nrf24_write_register(NRF24_MEM_EN_AA, 0x3F); //Enable auto acknowledge in all pipes
  77.     nrf24_write_register(NRF24_MEM_EN_RXADDR, 0x3F); // enable RX on all data on pipe
  78.     //nrf24_write_register(NRF24_MEM_EN_RXADDR, 0x01); // enable data on pipe 0 only
  79.    //nrf24_write_register(NRF24_MEM_SETUP_AW, 0x01); //
  80.    nrf24_write_register(NRF24_MEM_SETUP_AW, 0x05); //  5 bytes address width
  81.    //nrf24_write_buff(NRF24_MEM_RX_ADDR_P0 , ADDRESS_DATA_RXPIPE0, 5);
  82.    // nrf24_write_buff(NRF24_MEM_TX_ADDR , ADDRESS_DATA_TXPIPE0, 5);
  83.    nrf24_write_buff(NRF24_MEM_RX_ADDR_P0 , ADDRESS_DATA_RXPIPE0, 5);
  84.    nrf24_write_buff(NRF24_MEM_RX_ADDR_P1 , ADDRESS_DATA_RXPIPE1, 5);
  85.    nrf24_write_buff(NRF24_MEM_RX_ADDR_P2 , ADDRESS_DATA_RXPIPE2, 5);
  86.    nrf24_write_buff(NRF24_MEM_RX_ADDR_P3 , ADDRESS_DATA_RXPIPE3, 5);
  87.    nrf24_write_buff(NRF24_MEM_RX_ADDR_P4 , ADDRESS_DATA_RXPIPE4, 5);
  88.    nrf24_write_buff(NRF24_MEM_TX_ADDR , ADDRESS_DATA_TXPIPE0, 5);
  89.    
  90.   // nrf24_write_register(NRF24_MEM_SETUP_RETR, 0x00);
  91.     nrf24_write_register(NRF24_MEM_SETUP_RETR, 0x55); //enable shockburst functions to retry 15 times every 1500usec
  92.     nrf24_set_channel_frq(rf_channel);
  93.     nrf24_write_register(NRF24_MEM_RF_SETUP, 0x06);
  94.     //NRF24L01_WriteRegister(STATUS, 0x70);
  95.     nrf24_write_register(NRF24_MEM_FEATURE, 0x06);// Enables payload length and payload with acknowledge
  96.     //nrf24_write_register(NRF24_MEM_DYNPD, 0x01); //Enables dynn payload length pipe 0
  97.     nrf24_write_register(NRF24_MEM_DYNPD, 0x3F); //Enables dynn payload in all pipes
  98.     nrf24_write_register(NRF24_MEM_RX_PW_P0, PAYLOAD_BYTES);
  99.        
  100.     __delay_us(10);
  101.     nrf24_set_rf_mode(mode);
  102.     __delay_us(10);
  103.    
  104.     if ((nrf24_read_register(NRF24_MEM_CONFIG) & 0x08) != 0){
  105.       //printf("rfCardPresent = TRUE\r\n");
  106.       stat = NRF24_INIT_OK;
  107.     }
  108.     __delay_us(100);
  109.     return stat;
  110. }
  111.  
  112. void nrf24_set_rf_mode(NRF24_OPERATION_MODE mode) {
  113.     switch (mode) {
  114.         case RX_MODE:
  115. //            printf("RX mode\r\n");
  116.             nrf24_write_register(NRF24_MEM_CONFIG, 0x0B); // RX Control
  117.             NRF24L01_CE_H();
  118.             break;
  119.         case TX_MODE:
  120.             nrf24_write_register(NRF24_MEM_CONFIG, 0x0A); // TX Control
  121.             NRF24L01_CE_L();
  122.             break;
  123.     }
  124. }
  125.  
  126. void nrf24_send_rf_data(unsigned char *buffer) {
  127.     nrf24_set_rf_mode(TX_MODE);
  128.     nrf24_write_buff(W_TX_PAYLOAD, buffer, PAYLOAD_BYTES);
  129.     NRF24L01_CE_H();
  130.     __delay_ms(1);
  131.     NRF24L01_CE_L();
  132. }
  133.  
  134. unsigned char nrf24_is_rf_data_available(void) {
  135.     if ((nrf24_read_register(NRF24_MEM_STATUSS) & 0x40) == 0x40) {
  136.         return 0;
  137.     }
  138.     return 1;
  139. }
  140.  
  141. void nrf24_read_rf_data(unsigned char *buffer) {
  142.     nrf24_read_buff(R_RX_PAYLOAD, buffer, PAYLOAD_BYTES);
  143.     nrf24_write_register(NRF24_MEM_STATUSS, 0x70); // Clear STATUS.
  144.     nrf24_flush_tx_rx();
  145. }
  146.  
  147. void nrf24_set_channel_frq(unsigned char rf_channel) {
  148.     nrf24_write_register(NRF24_MEM_RF_CH, rf_channel);
  149. }
  150.  
  151. unsigned char nrf24_get_channel_frq(void) {
  152.     return nrf24_read_register(NRF24_MEM_RF_CH);
  153. }
  154.  
  155. void nrf24_standby_I(void) {
  156.     nrf24_write_register(NRF24_MEM_CONFIG, 0x0A);
  157.     __delay_ms(10);
  158. }
  159.  
  160. void nrf24_flush_tx_rx(void) {
  161.     NRF24L01_CSN_L();
  162.     nrf24_write_register(NRF24_MEM_STATUSS, 0x70);
  163.     __delay_ms(10);
  164.     NRF24L01_CSN_H();
  165.    
  166.     NRF24L01_CSN_L();
  167.     SPI_WRITE_BYTE(FLUSH_TX);
  168.     __delay_ms(10);
  169.     NRF24L01_CSN_H();
  170.    
  171.     NRF24L01_CSN_L();
  172.     SPI_WRITE_BYTE(FLUSH_RX);
  173.     __delay_ms(10);    
  174.     NRF24L01_CSN_H();
  175. }
  176.  
  177. // Print nRF24L01+ current configuration (for debug purposes)
  178. void nrf24_printf_rf_config(void) {
  179.     uint8_t i,j;
  180.     uint8_t aw;
  181.     uint8_t buf[5];
  182.  
  183.     // Dump nRF24L01+ configuration
  184.     // CONFIG
  185.     i = nrf24_read_register(NRF24_MEM_CONFIG);
  186.     printf("[0x%02X] 0x%02X MASK:%03X CRC:%02X PWR:%s MODE:P%s\r\n",
  187.             NRF24_MEM_CONFIG,
  188.             i,
  189.             i >> 4,
  190.             (i & 0x0c) >> 2,
  191.             (i & 0x02) ? "ON" : "OFF",
  192.             (i & 0x01) ? "RX" : "TX"
  193.         );
  194.    
  195.    
  196.     // EN_AA
  197.     i = nrf24_read_register(NRF24_MEM_EN_AA);
  198.     printf("[0x%02X] 0x%02X ENAA: ",NRF24_MEM_EN_AA,i);
  199.     for (j = 0; j < 6; j++) {
  200.         printf("[P%1u%s]%s",j,
  201.                 (i & (1 << j)) ? "+" : "-",
  202.                 (j == 5) ? "\r\n" : " "
  203.             );
  204.     }
  205.     // EN_RXADDR
  206.     i = nrf24_read_register(NRF24_MEM_EN_RXADDR);
  207.     printf("[0x%02X] 0x%02X EN_RXADDR: ",NRF24_MEM_EN_RXADDR,i);
  208.     for (j = 0; j < 6; j++) {
  209.         printf("[P%1u%s]%s",j,
  210.                 (i & (1 << j)) ? "+" : "-",
  211.                 (j == 5) ? "\r\n" : " "
  212.             );
  213.     }
  214.     // SETUP_AW
  215.     i = nrf24_read_register(NRF24_MEM_SETUP_AW);
  216.     aw = (i & 0x03) + 2;
  217.     //printf("%d..\r\n",(i & 0x03) + 2);
  218.     //printf("[0x%02X] 0x%02X EN_RXADDR=%06b (address width = %u)\r\n",NRF24_MEM_SETUP_AW,i,i & 0x03,aw);
  219.     printf("[0x%02X] 0x%02X EN_RXADDR=%06b (address width = %u)\r\n",NRF24_MEM_SETUP_AW,i,i & 0x03,aw);
  220.     // SETUP_RETR
  221.     i = nrf24_read_register(NRF24_MEM_SETUP_RETR);
  222.     printf("[0x%02X] 0x%02X ARD=%X ARC=%X (retr.delay=%uus, count=%u)\r\n",
  223.             NRF24_MEM_SETUP_RETR,
  224.             i,
  225.             i >> 4,
  226.             i & 0x0F,
  227.             ((i >> 4) * 250) + 250,
  228.             i & 0x0F
  229.         );
  230.     // RF_CH
  231.     i = nrf24_read_register(NRF24_MEM_RF_CH);
  232.     printf("[0x%02X] 0x%02X (%.3uGHz)\r\n",NRF24_MEM_RF_CH,i,2400 + i);
  233.     // RF_SETUP
  234.     i = nrf24_read_register(NRF24_MEM_RF_SETUP);
  235.     printf("[0x%02X] 0x%02X CONT_WAVE:%s PLL_LOCK:%s DataRate=",
  236.             NRF24_MEM_RF_SETUP,
  237.             i,
  238.             (i & 0x80) ? "ON" : "OFF",
  239.             (i & 0x80) ? "ON" : "OFF"
  240.         );
  241.     switch ((i & 0x28) >> 3) {
  242.         case 0x00:
  243.             printf("1Mbps ");
  244.             break;
  245.         case 0x01:
  246.             printf("2Mbps ");
  247.             break;
  248.         case 0x04:
  249.             printf("250kbps ");
  250.             break;
  251.         default:
  252.             printf("??? ");
  253.             break;
  254.     }
  255.     printf("RF_PWR=");
  256.     switch ((i & 0x06) >> 1) {
  257.         case 0x00:
  258.             printf("-18");
  259.             break;
  260.         case 0x01:
  261.             printf("-12");
  262.             break;
  263.         case 0x02:
  264.             printf("-6");
  265.             break;
  266.         case 0x03:
  267.             printf("0");
  268.             break;
  269.         default:
  270.             printf("???");
  271.             break;
  272.     }
  273.     printf("dBm\r\n");
  274.    
  275.    
  276.     // STATUS
  277.     i = nrf24_read_register(NRF24_MEM_STATUSS);
  278.     printf("[0x%02X] 0x%02X IRQ:%03X RX_PIPE:%u TX_FULL:%s\r\n",
  279.             NRF24_MEM_STATUSS,
  280.             i,
  281.             (i & 0x70) >> 4,
  282.             (i & 0x0E) >> 1,
  283.             (i & 0x01) ? "YES" : "NO"
  284.         );
  285.     // OBSERVE_TX
  286.     i = nrf24_read_register(NRF24_MEM_OBSERVE_TX);
  287.     printf("[0x%02X] 0x%02X PLOS_CNT=%u ARC_CNT=%u\r\n",NRF24_MEM_OBSERVE_TX,i,i >> 4,i & 0x0F);
  288.    
  289.     // RPD
  290.     i = nrf24_read_register(NRF24_MEM_CD);
  291.     printf("[0x%02X] 0x%02X RPD=%s\r\n",NRF24_MEM_CD,i,(i & 0x01) ? "YES" : "NO");
  292.    
  293.     // RX_ADDR_P0
  294.     nrf24_read_buff(NRF24_MEM_RX_ADDR_P0,buf,aw);
  295.     printf("[0x%02X] RX_ADDR_P0 \"",NRF24_MEM_RX_ADDR_P0);
  296.     for (i = 0; i < aw; i++) printf("%c",buf[i]);
  297.     printf("\"\r\n");
  298.    
  299.     // RX_ADDR_P1
  300.     nrf24_read_buff(NRF24_MEM_RX_ADDR_P1,buf,aw);
  301.     printf("[0x%02X] RX_ADDR_P1 \"",NRF24_MEM_RX_ADDR_P1);
  302.     for (i = 0; i < aw; i++) printf("%c",buf[i]);
  303.     printf("\"\r\n");
  304.    
  305.     // RX_ADDR_P2
  306.     printf("[0x%02X] RX_ADDR_P2 \"",NRF24_MEM_RX_ADDR_P2);
  307.     for (i = 0; i < aw - 1; i++) printf("%c",buf[i]);
  308.     i = nrf24_read_register(NRF24_MEM_RX_ADDR_P2);
  309.     printf("%c\"\r\n",i);
  310.    
  311.     // RX_ADDR_P3
  312.     printf("[0x%02X] RX_ADDR_P3 \"",NRF24_MEM_RX_ADDR_P3);
  313.     for (i = 0; i < aw - 1; i++) printf("%c",buf[i]);
  314.     i = nrf24_read_register(NRF24_MEM_RX_ADDR_P3);
  315.     printf("%c\"\r\n",i);
  316.    
  317.     // RX_ADDR_P4
  318.     printf("[0x%02X] RX_ADDR_P4 \"",NRF24_MEM_RX_ADDR_P4);
  319.     for (i = 0; i < aw - 1; i++) printf("%c",buf[i]);
  320.     i = nrf24_read_register(NRF24_MEM_RX_ADDR_P4);
  321.     printf("%c\"\r\n",i);
  322.    
  323.     // RX_ADDR_P5
  324.     printf("[0x%02X] RX_ADDR_P5 \"",NRF24_MEM_RX_ADDR_P5);
  325.     for (i = 0; i < aw - 1; i++) printf("%c",buf[i]);
  326.     i = nrf24_read_register(NRF24_MEM_RX_ADDR_P5);
  327.     printf("%c\"\r\n",i);
  328.    
  329.     // TX_ADDR
  330.     nrf24_read_buff(NRF24_MEM_TX_ADDR,buf,aw);
  331.     printf("[0x%02X] TX_ADDR \"",NRF24_MEM_TX_ADDR);
  332.     for (i = 0; i < aw; i++) {printf("%c",buf[i]);/*printf("%c %d..",buf[i], buf[i]);*/}
  333.     printf("\"\r\n");
  334.    
  335.     // RX_PW_P0
  336.     i = nrf24_read_register(NRF24_MEM_RX_PW_P0);
  337.     printf("[0x%02X] RX_PW_P0=%u\r\n",NRF24_MEM_RX_PW_P0,i);
  338.    
  339.     // RX_PW_P1
  340.     i = nrf24_read_register(NRF24_MEM_RX_PW_P1);
  341.     printf("[0x%02X] RX_PW_P1=%u\r\n",NRF24_MEM_RX_PW_P1,i);
  342.    
  343.     // RX_PW_P2
  344.     i = nrf24_read_register(NRF24_MEM_RX_PW_P2);
  345.     printf("[0x%02X] RX_PW_P2=%u\r\n",NRF24_MEM_RX_PW_P2,i);
  346.    
  347.     // RX_PW_P3
  348.     i = nrf24_read_register(NRF24_MEM_RX_PW_P3);
  349.     printf("[0x%02X] RX_PW_P3=%u\r\n",NRF24_MEM_RX_PW_P3,i);
  350.    
  351.     // RX_PW_P4
  352.     i = nrf24_read_register(NRF24_MEM_RX_PW_P4);
  353.     printf("[0x%02X] RX_PW_P4=%u\r\n",NRF24_MEM_RX_PW_P4,i);
  354.    
  355.     // RX_PW_P5
  356.     i = nrf24_read_register(NRF24_MEM_RX_PW_P5);
  357.     printf("[0x%02X] RX_PW_P5=%u\r\n",NRF24_MEM_RX_PW_P5,i);
  358. }
  359. /*
  360.  
  361. unsigned char getDynamicPayloadSize(void) {
  362.  
  363.     unsigned char result = 0;
  364.      NRF24L01_CSN_L();
  365.      SPI_WRITE_BYTE(R_RX_PL_WID);
  366.      result = SPI_WRITE_BYTE(0xff);
  367.      NRF24L01_CSN_H();
  368.      return result;
  369.  
  370.    
  371.                                            }
  372. */
  373. void toggle_features(void) {
  374.    
  375.  NRF24L01_CSN_L();
  376.   SPI_WRITE_BYTE( ACTIVATE );
  377.   SPI_WRITE_BYTE( 0x73 );
  378.   NRF24L01_CSN_H();
  379. }
  380.  
  381.  
  382. /*
  383. void enableAckPayload(void) {
  384. //
  385.   // enable ack payload and dynamic payload features
  386.   //
  387.     nrf24_write_register (NRF24_MEM_FEATURE,nrf24_read_register (NRF24_MEM_FEATURE) | _BV (EN_ACK_PAY)| _BV (EN_DPL));
  388.  
  389.     if( ! nrf24_read_register (NRF24_MEM_FEATURE))
  390.     {
  391.         // So enable them and try again
  392.         toggle_features();
  393.         nrf24_write_register(NRF24_MEM_FEATURE,nrf24_read_register (NRF24_MEM_FEATURE) | _BV (EN_ACK_PAY)| _BV (EN_DPL));
  394.        
  395.     }
  396.    
  397.     IF_SERIAL_DEBUG(printf("NRF24_MEM_FEATURE=%i\r\n",nrf24_read_register( NRF24_MEM_FEATURE )));
  398.    
  399.   //
  400.   // Enable dynamic payload on pipes 0 & 1
  401.   //
  402.    
  403.     nrf24_write_register(NRF24_MEM_DYNPD,nrf24_read_register (NRF24_MEM_DYNPD) | _BV(DPL_P0) );
  404.    
  405. }
  406.  
  407. void enableDynamicPayloads(void){
  408.  // Enable dynamic payload throughout the system
  409.     nrf24_write_register(NRF24_MEM_FEATURE, nrf24_read_register (NRF24_MEM_FEATURE) | _BV(EN_DPL));
  410.     // If it didn't work, the features are not enabled
  411.     toggle_features();
  412.     nrf24_write_register(NRF24_MEM_FEATURE, nrf24_read_register (NRF24_MEM_FEATURE) | _BV(EN_DPL));
  413.   }
  414.  
  415. void openWritingPipe(unsigned long long address){
  416.      // Note that AVR 8-bit uC's store this LSB first, and the NRF24L01(+)
  417.   // expects it LSB first too, so we're good.--need to confirm the PIC does the same
  418.    
  419.     unsigned char value;
  420.     value = (unsigned char)(address);
  421.    
  422.     nrf24_write_buff (NRF24_MEM_RX_ADDR_P0,&value,5 );
  423.     nrf24_write_buff (NRF24_MEM_TX_ADDR,&value,5 );
  424.     nrf24_write_register (NRF24_MEM_RX_PW_P0,32 );
  425.  }
  426. */
  427. void writeAckPayload(unsigned char pipe, const void* buf, unsigned char len){
  428.    const char* current;
  429.    current = (const char*)(buf);
  430.    unsigned char i;
  431.    
  432.    NRF24L01_CSN_L();  
  433.    SPI_WRITE_BYTE( W_ACK_PAYLOAD );
  434.    const char max_payload_size = 32;
  435.    unsigned char data;
  436.    data = MIN(len,max_payload_size);
  437.    
  438.    while (data--){
  439.         SPI_WRITE_BYTE(*current++);
  440.         __delay_us(10);
  441.    }
  442.    
  443.   NRF24L01_CSN_H();
  444.    
  445. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!