API tools faq
paste
Advertisement
Guest User

NRF24L01 Configuration

a guest
Feb 13th, 2016
192
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 14.34 KB | None | 0 0
raw download clone embed print report
  1. #ifndef NRF_H_
  2. #define NRF_H_
  3.  
  4. #include "stm32l1xx_hal.h"
  5.  
  6. volatile uint8_t mode;
  7. #define RX_MODE 1
  8. #define TX_MODE 0
  9.  
  10. /* Registers */
  11. #define NRF_CONFIG      0x00
  12. #define NRF_EN_AA       0x01
  13. #define NRF_EN_RXADDR   0x02
  14. #define NRF_SETUP_AW    0x03
  15. #define NRF_SETUP_RETR  0x04
  16. #define NRF_RF_CH       0x05
  17. #define NRF_RF_SETUP    0x06
  18. #define NRF_STATUS      0x07
  19. #define NRF_OBSERVE_TX  0x08
  20. #define NRF_CD          0x09
  21. #define NRF_RX_ADDR_P0  0x0A
  22. #define NRF_RX_ADDR_P1  0x0B
  23. #define NRF_RX_ADDR_P2  0x0C
  24. #define NRF_RX_ADDR_P3  0x0D
  25. #define NRF_RX_ADDR_P4  0x0E
  26. #define NRF_RX_ADDR_P5  0x0F
  27. #define NRF_TX_ADDR     0x10
  28. #define NRF_RX_PW_P0    0x11
  29. #define NRF_RX_PW_P1    0x12
  30. #define NRF_RX_PW_P2    0x13
  31. #define NRF_RX_PW_P3    0x14
  32. #define NRF_RX_PW_P4    0x15
  33. #define NRF_RX_PW_P5    0x16
  34. #define NRF_FIFO_STATUS 0x17
  35. #define NRF_DYNPD       0x1C
  36. #define NRF_FEATURE     0x1D
  37.  
  38. /* Commands */
  39. #define NRF_CMD_R_REGISTER          0x00
  40. #define NRF_CMD_W_REGISTER          0x20
  41. #define NRF_CMD_R_RX_PAYLOAD        0x61
  42. #define NRF_CMD_W_TX_PAYLOAD        0xA0
  43. #define NRF_CMD_FLUSH_TX            0xE1
  44. #define NRF_CMD_FLUSH_RX            0xE2
  45. #define NRF_CMD_REUSE_TX_PL         0xE3
  46. #define NRF_CMD_ACTIVATE            0x50
  47. #define NRF_CMD_R_RX_PL_WID         0x60
  48. #define NRF_CMD_W_ACK_PAYLOAD       0xA8
  49. #define NRF_CMD_W_TX_PAYLOAD_NOACK  0xB0
  50. #define NRF_CMD_NOP                 0xFF
  51.  
  52. #define NRF_SPI_TIMEOUT 100000
  53.  
  54.  
  55. typedef enum{
  56.     NRF_DATA_RATE_250KBPS=1,
  57.     NRF_DATA_RATE_1MBPS=0,
  58.     NRF_DATA_RATE_2MBPS=2
  59. } NRF_DATA_RATE;
  60.  
  61. typedef enum{
  62.     NRF_TX_PWR_M18dBm=0,
  63.     NRF_TX_PWR_M12dBm=1,
  64.     NRF_TX_PWR_M6dBm=2,
  65.     NRF_TX_PWR_0dBm=3
  66. } NRF_TX_PWR;
  67.  
  68. typedef enum{
  69.     NRF_ADDR_WIDTH_3=1,
  70.     NRF_ADDR_WIDTH_4=2,
  71.     NRF_ADDR_WIDTH_5=3
  72. } NRF_ADDR_WIDTH;
  73.  
  74. typedef enum{
  75.     NRF_CRC_WIDTH_1B=0,
  76.     NRF_CRC_WIDTH_2B=1
  77. } NRF_CRC_WIDTH;
  78.  
  79. typedef enum{
  80.     NRF_STATE_RX=1,
  81.     NRF_STATE_TX=0
  82. } NRF_TXRX_STATE;
  83.  
  84.  
  85. typedef enum{
  86.     NRF_OK,
  87.     NRF_ERROR
  88. } NRF_RESULT;
  89.  
  90.  
  91. #define NRF_CS_ENABLE   HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET)
  92. #define NRF_CS_DISABLE  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET)
  93.  
  94. #define NRF_CE_ENABLE   HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7, GPIO_PIN_SET)
  95. #define NRF_CE_DISABLE  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7, GPIO_PIN_RESET)
  96.  
  97. SPI_HandleTypeDef *nrf_spi;
  98. UART_HandleTypeDef *nrf_uart;
  99.  
  100. void NRF_Init(SPI_HandleTypeDef *spi, UART_HandleTypeDef* uart)
  101. {
  102.     nrf_spi = spi;
  103.     nrf_uart = uart;
  104. }
  105.  
  106.  
  107. NRF_RESULT NRF_SendCommand(uint8_t cmd, uint8_t* tx, uint8_t* rx,
  108.         uint8_t len) {
  109.     uint8_t myTX[len + 1];
  110.     uint8_t myRX[len + 1];
  111.     myTX[0] = cmd;
  112.  
  113.     int i = 0;
  114.     for (i = 0; i < len; i++) {
  115.         myTX[1 + i] = tx[i];
  116.         myRX[i] = 0;
  117.     }
  118.  
  119.     NRF_CS_ENABLE;
  120.     if (HAL_SPI_TransmitReceive(nrf_spi, myTX, myRX, 1 + len, NRF_SPI_TIMEOUT)
  121.             != HAL_OK) {
  122.         return NRF_ERROR;
  123.     }
  124.  
  125.     for (i = 0; i < len; i++) {
  126.         rx[i] = myRX[1 + i];
  127.     }
  128.  
  129.     NRF_CS_DISABLE;;
  130.  
  131.     return NRF_OK;
  132. }
  133.  
  134. NRF_RESULT NRF_ReadRegister(uint8_t reg, uint8_t* data) {
  135.     uint8_t tx = 0;
  136.     if (NRF_SendCommand(NRF_CMD_R_REGISTER | reg, &tx, data, 1) != NRF_OK) {
  137.         return NRF_ERROR;
  138.     }
  139.     return NRF_OK;
  140. }
  141.  
  142. NRF_RESULT NRF_WriteRegister(uint8_t reg, uint8_t* data) {
  143.     uint8_t rx = 0;
  144.     if (NRF_SendCommand(NRF_CMD_W_REGISTER | reg, data, &rx, 1) != NRF_OK) {
  145.         return NRF_ERROR;
  146.     }
  147.     return NRF_OK;
  148. }
  149.  
  150. NRF_RESULT NRF_PowerUp(uint8_t powerUp) {
  151.     uint8_t reg = 0;
  152.     if (NRF_ReadRegister(NRF_CONFIG, &reg) != NRF_OK) {
  153.         return NRF_ERROR;
  154.     }
  155.  
  156.     if (powerUp) {
  157.         reg |= 1 << 1;
  158.     } else {
  159.         reg &= ~(1 << 1);
  160.     }
  161.  
  162.     if (NRF_WriteRegister(NRF_CONFIG, &reg) != NRF_OK) {
  163.         return NRF_ERROR;
  164.     }
  165.     return NRF_OK;
  166. }
  167.  
  168. NRF_RESULT NRF_EnableCRC(uint8_t activate) {
  169.     uint8_t reg = 0;
  170.     if (NRF_ReadRegister(NRF_CONFIG, &reg) != NRF_OK) {
  171.         return NRF_ERROR;
  172.     }
  173.  
  174.     if (activate) {
  175.         reg |= 1 << 3;
  176.     } else {
  177.         reg &= ~(1 << 3);
  178.     }
  179.  
  180.     if (NRF_WriteRegister(NRF_CONFIG, &reg) != NRF_OK) {
  181.         return NRF_ERROR;
  182.     }
  183.     return NRF_OK;
  184. }
  185.  
  186. NRF_RESULT NRF_SetCRCWidth(NRF_CRC_WIDTH width) {
  187.     uint8_t reg = 0;
  188.     if (NRF_ReadRegister(NRF_CONFIG, &reg) != NRF_OK) {
  189.         return NRF_ERROR;
  190.     }
  191.  
  192.     if (width == NRF_CRC_WIDTH_2B) {
  193.         reg |= 1 << 2;
  194.     } else {
  195.         reg &= ~(1 << 3);
  196.     }
  197.  
  198.     if (NRF_WriteRegister(NRF_CONFIG, &reg) != NRF_OK) {
  199.         return NRF_ERROR;
  200.     }
  201.     return NRF_OK;
  202. }
  203.  
  204. NRF_RESULT NRF_RXTXControl(NRF_TXRX_STATE rx) {
  205.     uint8_t reg = 0;
  206.     if (NRF_ReadRegister(NRF_CONFIG, &reg) != NRF_OK) {
  207.         return NRF_ERROR;
  208.     }
  209.  
  210.     if (rx) {
  211.         reg |= 1;
  212.     } else {
  213.         reg &= ~(1);
  214.     }
  215.  
  216.     if (NRF_WriteRegister(NRF_CONFIG, &reg) != NRF_OK) {
  217.         return NRF_ERROR;
  218.     }
  219.     return NRF_OK;
  220. }
  221.  
  222. NRF_RESULT NRF_SetRetransmittionCount(uint8_t count) {
  223.     count &= 0x0F;
  224.     uint8_t reg = 0;
  225.     if (NRF_ReadRegister(NRF_SETUP_RETR, &reg) != NRF_OK) {
  226.         return NRF_ERROR;
  227.     }
  228.  
  229.     reg &= 0xF0;    // clearing bits 0,1,2,3
  230.     reg |= count;   // setting count
  231.  
  232.     if (NRF_WriteRegister(NRF_SETUP_RETR, &reg) != NRF_OK) {
  233.         return NRF_ERROR;
  234.     }
  235.     return NRF_OK;
  236. }
  237.  
  238. NRF_RESULT NRF_SetRetransmittionDelay(uint8_t delay) {
  239.     delay &= 0x0F;
  240.     uint8_t reg = 0;
  241.     if (NRF_ReadRegister(NRF_SETUP_RETR, &reg) != NRF_OK) {
  242.         return NRF_ERROR;
  243.     }
  244.  
  245.     reg &= 0x0F;    // clearing bits 1,2,6,7
  246.     reg |= delay << 4;  // setting delay
  247.  
  248.     if (NRF_WriteRegister(NRF_SETUP_RETR, &reg) != NRF_OK) {
  249.         return NRF_ERROR;
  250.     }
  251.     return NRF_OK;
  252. }
  253.  
  254. NRF_RESULT NRF_SetAddressWidth(NRF_ADDR_WIDTH width) {
  255.     uint8_t reg = 0;
  256.     if (NRF_ReadRegister(NRF_SETUP_AW, &reg) != NRF_OK) {
  257.         return NRF_ERROR;
  258.     }
  259.  
  260.     reg &= 0x03;    // clearing bits 0,1
  261.     reg |= width;   // setting delay
  262.  
  263.     if (NRF_WriteRegister(NRF_SETUP_AW, &reg) != NRF_OK) {
  264.         return NRF_ERROR;
  265.     }
  266.     return NRF_OK;
  267. }
  268.  
  269. NRF_RESULT NRF_EnableRXPipe(uint8_t pipe) {
  270.     uint8_t reg = 0;
  271.     if (NRF_ReadRegister(NRF_EN_RXADDR, &reg) != NRF_OK) {
  272.         return NRF_ERROR;
  273.     }
  274.  
  275.     reg |= 1 << pipe;
  276.  
  277.     if (NRF_WriteRegister(NRF_EN_RXADDR, &reg) != NRF_OK) {
  278.         return NRF_ERROR;
  279.     }
  280.     return NRF_OK;
  281. }
  282.  
  283. NRF_RESULT NRF_EnableAutoAcknowledgement(uint8_t pipe) {
  284.     uint8_t reg = 0;
  285.     if (NRF_ReadRegister(NRF_EN_AA, &reg) != NRF_OK) {
  286.         return NRF_ERROR;
  287.     }
  288.  
  289.     reg |= 1 << pipe;
  290.  
  291.     if (NRF_WriteRegister(NRF_EN_AA, &reg) != NRF_OK) {
  292.         return NRF_ERROR;
  293.     }
  294.     return NRF_OK;
  295. }
  296.  
  297. NRF_RESULT NRF_SetRFChannel(uint8_t ch) {
  298.     ch &= 0x7F;
  299.     uint8_t reg = 0;
  300.     if (NRF_ReadRegister(NRF_RF_CH, &reg) != NRF_OK) {
  301.         return NRF_ERROR;
  302.     }
  303.  
  304.     reg |= ch;  // setting channel
  305.  
  306.     if (NRF_WriteRegister(NRF_RF_CH, &reg) != NRF_OK) {
  307.         return NRF_ERROR;
  308.     }
  309.     return NRF_OK;
  310. }
  311.  
  312. NRF_RESULT NRF_SetTXPower(NRF_TX_PWR pwr) {
  313.     uint8_t reg = 0;
  314.     if (NRF_ReadRegister(NRF_RF_SETUP, &reg) != NRF_OK) {
  315.         return NRF_ERROR;
  316.     }
  317.     reg &= 0xF9;    // clear bits 1,2
  318.     reg |= pwr << 1;    // set bits 1,2
  319.     if (NRF_WriteRegister(NRF_RF_SETUP, &reg) != NRF_OK) {
  320.         return NRF_ERROR;
  321.     }
  322.     return NRF_OK;
  323. }
  324.  
  325. NRF_RESULT NRF_SetCCW(uint8_t activate) {
  326.     uint8_t reg = 0;
  327.     if (NRF_ReadRegister(NRF_RF_SETUP, &reg) != NRF_OK) {
  328.         return NRF_ERROR;
  329.     }
  330.  
  331.     if (activate) {
  332.         reg |= 0x80;
  333.     } else {
  334.         reg &= 0x7F;
  335.     }
  336.  
  337.     if (NRF_WriteRegister(NRF_RF_SETUP, &reg) != NRF_OK) {
  338.         return NRF_ERROR;
  339.     }
  340.     return NRF_OK;
  341. }
  342.  
  343. NRF_RESULT NRF_SetDataRate(NRF_DATA_RATE rate) {
  344.     uint8_t reg = 0;
  345.     if (NRF_ReadRegister(NRF_RF_SETUP, &reg) != NRF_OK) {
  346.         return NRF_ERROR;
  347.     }
  348.     if (rate & 1) { // low bit set
  349.         reg |= 1 << 5;
  350.     } else {    // low bit clear
  351.         reg &= ~(1 << 5);
  352.     }
  353.  
  354.     if (rate & 2) { // high bit set
  355.         reg |= 1 << 3;
  356.     } else {    // high bit clear
  357.         reg &= ~(1 << 3);
  358.     }
  359.     if (NRF_WriteRegister(NRF_RF_SETUP, &reg) != NRF_OK) {
  360.         return NRF_ERROR;
  361.     }
  362.     return NRF_OK;
  363. }
  364.  
  365. NRF_RESULT NRF_ClearInterrupts() {
  366.     uint8_t reg = 0;
  367.     if (NRF_ReadRegister(NRF_STATUS, &reg) != NRF_OK) {
  368.         return NRF_ERROR;
  369.     }
  370.  
  371.     reg |= 7 << 4;  // setting bits 4,5,6
  372.  
  373.     if (NRF_WriteRegister(NRF_STATUS, &reg) != NRF_OK) {
  374.         return NRF_ERROR;
  375.     }
  376.     return NRF_OK;
  377. }
  378.  
  379. NRF_RESULT NRF_FlushTX() {
  380.     uint8_t rx = 0;
  381.     uint8_t tx = 0;
  382.     if (NRF_SendCommand(NRF_CMD_FLUSH_TX, &tx, &rx, 0) != NRF_OK) {
  383.         return NRF_ERROR;
  384.     }
  385.     return NRF_OK;
  386. }
  387.  
  388. NRF_RESULT NRF_FlushRX() {
  389.     uint8_t rx = 0;
  390.     uint8_t tx = 0;
  391.     if (NRF_SendCommand(NRF_CMD_FLUSH_RX, &tx, &rx, 0) != NRF_OK) {
  392.         return NRF_ERROR;
  393.     }
  394.     return NRF_OK;
  395. }
  396.  
  397. NRF_RESULT NRF_ReadRXPayload(uint8_t* data, uint8_t len) {
  398.     uint8_t tx[32];
  399.     if (NRF_SendCommand(NRF_CMD_R_RX_PAYLOAD, tx, data, len) != NRF_OK) {
  400.         return NRF_ERROR;
  401.     }
  402.     return NRF_OK;
  403. }
  404.  
  405. NRF_RESULT NRF_WriteTXPayload(uint8_t* data, uint8_t len) {
  406.     uint8_t rx[32];
  407.     if (NRF_SendCommand(NRF_CMD_W_TX_PAYLOAD, data, rx, len) != NRF_OK) {
  408.         return NRF_ERROR;
  409.     }
  410.     return NRF_OK;
  411. }
  412.  
  413. NRF_RESULT NRF_EnableRXDataReadyIRQ(uint8_t activate) {
  414.     uint8_t reg = 0;
  415.     if (NRF_ReadRegister(NRF_CONFIG, &reg) != NRF_OK) {
  416.         return NRF_ERROR;
  417.     }
  418.  
  419.     if (!activate) {
  420.         reg |= 1 << 6;
  421.     } else {
  422.         reg &= ~(1 << 6);
  423.     }
  424.  
  425.     if (NRF_WriteRegister(NRF_CONFIG, &reg) != NRF_OK) {
  426.         return NRF_ERROR;
  427.     }
  428.     return NRF_OK;
  429. }
  430.  
  431. NRF_RESULT NRF_EnableTXDataSentIRQ(uint8_t activate) {
  432.     uint8_t reg = 0;
  433.     if (NRF_ReadRegister(NRF_CONFIG, &reg) != NRF_OK) {
  434.         return NRF_ERROR;
  435.     }
  436.     if (!activate) {
  437.         reg |= 1 << 5;
  438.     } else {
  439.         reg &= ~(1 << 5);
  440.     }
  441.     if (NRF_WriteRegister(NRF_CONFIG, &reg) != NRF_OK) {
  442.         return NRF_ERROR;
  443.     }
  444.     return NRF_OK;
  445. }
  446.  
  447. NRF_RESULT NRF_EnableMaxRetransmitIRQ(uint8_t activate) {
  448.     uint8_t reg = 0;
  449.     if (NRF_ReadRegister(NRF_CONFIG, &reg) != NRF_OK) {
  450.         return NRF_ERROR;
  451.     }
  452.     if (!activate) {
  453.         reg |= 1 << 4;
  454.     } else {
  455.         reg &= ~(1 << 4);
  456.     }
  457.     if (NRF_WriteRegister(NRF_CONFIG, &reg) != NRF_OK) {
  458.         return NRF_ERROR;
  459.     }
  460.     return NRF_OK;
  461. }
  462.  
  463. NRF_RESULT NRF_SetRXAddress(uint8_t* address, uint8_t PX, uint8_t len) {
  464.     uint8_t rx[5];
  465.     if (PX > 5) {
  466.         return NRF_ERROR;
  467.     }
  468.     if (NRF_SendCommand(NRF_CMD_W_REGISTER | (NRF_RX_ADDR_P0+PX), address, rx, len) != NRF_OK) {
  469.         return NRF_ERROR;
  470.     }
  471.     return NRF_OK;
  472. }
  473.  
  474. NRF_RESULT NRF_SetRXPayloadWidth_PX(uint8_t PX, uint8_t width) {
  475.     width &= 0x3F;
  476.     if (PX > 5) {
  477.         return NRF_ERROR;
  478.     }
  479.     if (NRF_WriteRegister(NRF_RX_PW_P0+PX, &width) != NRF_OK) {
  480.         return NRF_ERROR;
  481.     }
  482.     return NRF_OK;
  483. }
  484.  
  485. NRF_RESULT NRF_SetTXAddress(uint8_t* address) {
  486.     uint8_t rx[5];
  487.     if (NRF_SendCommand(NRF_CMD_W_REGISTER | NRF_TX_ADDR, address, rx, 5) != NRF_OK) {
  488.         return NRF_ERROR;
  489.     }
  490.     return NRF_OK;
  491. }
  492.  
  493. void PRINT_LN(const char *data)
  494. {
  495.     uint8_t datax[32];
  496.     uint8_t i = 0;
  497.     while(data[i] != '\0')
  498.     {
  499.         datax[i] = data[i];
  500.         i++;
  501.     }
  502.  
  503.     HAL_UART_Transmit(nrf_uart, datax, i, 1000);
  504.     uint8_t ln = '\n';
  505.     HAL_UART_Transmit(nrf_uart, &ln, 1, 1000);
  506. }
  507.  
  508. void PRINT_ARRAY(uint8_t *data, uint8_t len)
  509. {
  510.     HAL_UART_Transmit(nrf_uart, data, len, 1000);
  511.     uint8_t ln = '\n';
  512.     HAL_UART_Transmit(nrf_uart, &ln, 1, 1000);
  513. }
  514.  
  515. void NRF_test(void)
  516. {
  517.     const uint8_t PAYLOAD_SIZE = 8;
  518.     uint8_t config = 0xFF;
  519.     uint8_t addr_p0[] = {0x01, 0x02, 0x03, 0x04, 0x05};
  520.     uint8_t addr_p1[] = {0x06, 0x07, 0x08, 0x09, 0x10};
  521.     uint8_t addr_p2[] = {0x11};
  522.     uint8_t addr_p3[] = {0x12};
  523.     uint8_t addr_p4[] = {0x13};
  524.     uint8_t addr_p5[] = {0x14};
  525.     uint8_t dados[32];
  526.     for (config = 0; config < 32; config++) {
  527.         dados[config] = 'A' + config;
  528.     }
  529.  
  530.     NRF_CE_DISABLE;
  531.     NRF_CS_DISABLE;
  532.  
  533.     NRF_PowerUp(0);
  534.     HAL_Delay(500);
  535.  
  536.     NRF_PowerUp(1);
  537.     HAL_Delay(500);
  538.  
  539.     do {
  540.         NRF_ReadRegister(NRF_CONFIG, &config);
  541.     }while ((config & 0x02) == 0);
  542.  
  543.     NRF_SetRXPayloadWidth_PX(0, PAYLOAD_SIZE);
  544.     NRF_SetRXPayloadWidth_PX(1, PAYLOAD_SIZE);
  545.     NRF_SetRXPayloadWidth_PX(2, PAYLOAD_SIZE);
  546.     NRF_SetRXPayloadWidth_PX(3, PAYLOAD_SIZE);
  547.     NRF_SetRXPayloadWidth_PX(4, PAYLOAD_SIZE);
  548.     NRF_SetRXPayloadWidth_PX(5, PAYLOAD_SIZE);
  549.  
  550.     NRF_SetRXAddress(addr_p0, 0, 5);
  551.     NRF_SetRXAddress(addr_p1, 1, 5);
  552.     NRF_SetRXAddress(addr_p2, 2, 1);
  553.     NRF_SetRXAddress(addr_p3, 3, 1);
  554.     NRF_SetRXAddress(addr_p4, 4, 1);
  555.     NRF_SetRXAddress(addr_p5, 5, 1);
  556.  
  557.     NRF_SetTXAddress(addr_p0);
  558.  
  559.     NRF_EnableTXDataSentIRQ(1);
  560.     NRF_EnableRXDataReadyIRQ(1);
  561.     NRF_EnableMaxRetransmitIRQ(1);
  562.  
  563.     NRF_EnableCRC(1);
  564.     NRF_SetCRCWidth(NRF_CRC_WIDTH_1B);
  565.     NRF_SetAddressWidth(NRF_ADDR_WIDTH_5);
  566.  
  567.     NRF_SetRetransmittionCount(15);
  568.     NRF_SetRetransmittionDelay(15);
  569.  
  570.     NRF_SetRFChannel(60);
  571.     //NRF_SetTXPower(NRF_TX_PWR_0dBm); //NRF_SetDataRate(NRF_DATA_RATE_1MBPS);
  572.     config = 0x0f;
  573.     NRF_WriteRegister(NRF_RF_SETUP, &config);
  574.  
  575.     NRF_EnableRXPipe(0);
  576.     NRF_EnableRXPipe(1);
  577.     NRF_EnableRXPipe(2);
  578.     NRF_EnableRXPipe(3);
  579.     NRF_EnableRXPipe(4);
  580.     NRF_EnableRXPipe(5);
  581.  
  582.     NRF_EnableAutoAcknowledgement(0);
  583.     NRF_EnableAutoAcknowledgement(1);
  584.     NRF_EnableAutoAcknowledgement(2);
  585.     NRF_EnableAutoAcknowledgement(3);
  586.     NRF_EnableAutoAcknowledgement(4);
  587.     NRF_EnableAutoAcknowledgement(5);
  588.  
  589.     NRF_ClearInterrupts();
  590.  
  591.     NRF_CE_DISABLE;
  592.     NRF_RXTXControl(NRF_STATE_RX);
  593.     NRF_CE_ENABLE;
  594.  
  595.     NRF_FlushRX();
  596.  
  597.     uint8_t status, fifo_status, busy = 0, rxpo;
  598.     mode = RX_MODE;
  599.  
  600.     for ( ; ; )
  601.     {
  602.        
  603.         if (NRF_ReadRegister(NRF_STATUS, &status) == NRF_OK)
  604.         {
  605.             if (status & (1 << 6)) // RX_RD -> PACKET RECEIVED
  606.             {
  607.                 PRINT_LN("RX_RD\0");
  608.                 NRF_CE_DISABLE;
  609.                 rxpo = (0x07 & (status >> 1));
  610.                 NRF_ReadRegister(NRF_FIFO_STATUS, &fifo_status);
  611.                 if ((fifo_status & 0x01) == 0 && (rxpo != 0x07)) // CHECK IF RX FIFO IS NOT EMPTY
  612.                 {
  613.                     PRINT_LN("FIFO RX\0");
  614.                     NRF_ReadRXPayload(dados, PAYLOAD_SIZE);
  615.                     PRINT_ARRAY(dados, PAYLOAD_SIZE);
  616.  
  617.                     status |= (1<<6);
  618.                     NRF_WriteRegister(NRF_STATUS, &status);
  619.                     NRF_FlushRX();
  620.                 } else {
  621.                     PRINT_LN("FIFO EMPTY\0");
  622.                 }
  623.                 NRF_CE_ENABLE;
  624.                 NRF_RXTXControl(NRF_STATE_RX);
  625.             }
  626.  
  627.             if (status & (1 << 5)) // TX_RD -> DATA SENT
  628.             {
  629.                 PRINT_LN("TX SD\0");
  630.                 status |= 1 << 5;   // clear the interrupt flag
  631.  
  632.                 NRF_CE_DISABLE;
  633.                 NRF_RXTXControl(NRF_STATE_RX);
  634.                 NRF_CE_ENABLE;
  635.  
  636.                 NRF_WriteRegister(NRF_STATUS, &status);
  637.                 busy = 0;
  638.                 dados[0] ++;
  639.             }
  640.  
  641.             if (status & (1 << 4)) // MAX RT REACHED
  642.             {
  643.                 PRINT_LN("MAX RT REACHED\0");
  644.                 status |= 1 << 4;
  645.                 NRF_FlushTX();
  646.  
  647.                 NRF_CE_DISABLE;
  648.                 NRF_RXTXControl(NRF_STATE_RX);
  649.                 NRF_CE_ENABLE;
  650.  
  651.                 NRF_WriteRegister(NRF_STATUS, &status);
  652.                 busy = 0;
  653.             }
  654.  
  655.         }
  656.  
  657.         if (TX_MODE == mode)
  658.         {
  659.            
  660.             {
  661.                 PRINT_LN("SENDING...");
  662.                 PRINT_ARRAY(dados, PAYLOAD_SIZE);
  663.  
  664.                 busy = 1;
  665.  
  666.                 NRF_CE_DISABLE;
  667.                 NRF_RXTXControl(NRF_STATE_TX);
  668.                 NRF_WriteTXPayload(dados, PAYLOAD_SIZE);
  669.                 NRF_CE_ENABLE;
  670.  
  671.             }
  672.             mode = RX_MODE;
  673.         }
  674.     }
  675.  
  676. }
  677.  
  678. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  679. {
  680.  
  681.     if (huart->Instance == USART2)
  682.     {
  683.         HAL_UART_Receive_IT(&huart2, &input_data, 1);
  684.         if (input_data == '1')
  685.         {
  686.             mode = RX_MODE;
  687.             PRINT_LN("RX_MODE");
  688.         }
  689.         else if (input_data == '2')
  690.         {
  691.             mode = TX_MODE;
  692.             PRINT_LN("TX_MODE");
  693.         }
  694.  
  695.     }
  696. }
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!