RE: Having problem for connection between nRF24l01+ and nRF51822

Masoumeh — Tue, 13 Oct 2020 12:53:38 GMT
Thanks for your answer. my problem is solved. it was due to an error in the program.
RE: Having problem for connection between nRF24l01+ and nRF51822

run_ar — Tue, 13 Oct 2020 11:43:57 GMT
Sorry for the late answer. Following the backward compatibility guide should help set up communication between nrf51 and L01+. But did you try to set up communication between two L01+ devices to make sure your spi and L01+ implementation is wprking? Also, please note that L01+ is a legacy product and not recommended for new designs.
RE: Having problem for connection between nRF24l01+ and nRF51822

Masoumeh — Thu, 17 Sep 2020 10:37:19 GMT
yes I checked that. Since I am using nRF24L01+ not the nRF24E/U , and it doesn't have an internal micro I can use nrf sdk go library. I write the code below for nRF24L01+.
I don't know what's the problem I checked everything so many times but still the two don't connect.
/**
  ******************************************************************************
  * File Name          : main.c
  * Description        : Main program body
  ******************************************************************************
  *
  * COPYRIGHT(c) 2020 STMicroelectronics
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */
/* Includes ------------------------------------------------------------------*/
#include "stm32f1xx_hal.h"

/* USER CODE BEGIN Includes */
#include <stdio.h>
/* USER CODE END Includes */

/* Private variables ---------------------------------------------------------*/
SPI_HandleTypeDef hspi2;

UART_HandleTypeDef huart2;
UART_HandleTypeDef huart3;
DMA_HandleTypeDef hdma_usart2_tx;

DMA_HandleTypeDef hdma_memtomem_dma1_channel1;

/* USER CODE BEGIN PV */
/* Private variables ---------------------------------------------------------*/

// opcode commands
const uint8_t R_REGISTER[]={0x00};
const uint8_t W_REGISTER[]={0x20};
const uint8_t R_RX_PAYLOAD[]={0x61};
const uint8_t W_TX_PAYLOAD[]={0xA0};
const uint8_t FLUSH_TX[]={0xE1};
const uint8_t FLUSH_RX[]={0xE2};
const uint8_t REUSE_TX_PL[]={0xE3};
const uint8_t R_RX_PL_WID[]={0x60};
const uint8_t W_ACK_PAYLOAD[]={0xA8};
const uint8_t W_TX_PAYLOAD_NOACK[]={0xB0};
const uint8_t NOP[]={0xFF};

// Register ADDRESSES

const uint8_t READ_CONFIG[]={0x00};
const uint8_t WRITE_CONFIG[]={0x20};
const uint8_t READ_EN_AA[]={0x01};
const uint8_t WRITE_EN_AA[]={0x21};
const uint8_t READ_EN_RXADDR[]={0x02};
const uint8_t WRITE_EN_RXADDR[]={0x22};
const uint8_t READ_SETUP_AW[]={0x03};
const uint8_t WRITE_SETUP_AW[]={0x23};
const uint8_t READ_SETUP_RETR[]={0x04};
const uint8_t WRITE_SETUP_RETR[]={0x24};
const uint8_t READ_RF_CH[]={0x05};
const uint8_t WRITE_RF_CH[]={0x25};
const uint8_t READ_RF_SETUP[]={0x06};
const uint8_t WRITE_RF_SETUP[]={0x26};
const uint8_t READ_STATUS[]={0x07};
const uint8_t WRITE_STATUS[]={0x27};
const uint8_t READ_OBSERVE_TX[]={0x08};
const uint8_t READ_PRD[]={0x09};
const uint8_t READ_RX_ADDR_P0[]={0x0A};
const uint8_t WRITE_RX_ADDR_P0[]={0x2A};
const uint8_t READ_RX_ADDR_P1[]={0x0B};
const uint8_t WRITE_RX_ADDR_P1[]={0x2B};
const uint8_t READ_RX_ADDR_P2[]={0x0C};
const uint8_t WRITE_RX_ADDR_P2[]={0x2C};
const uint8_t READ_RX_ADDR_P3[]={0x0D};
const uint8_t WRITE_RX_ADDR_P3[]={0x2D};
const uint8_t READ_RX_ADDR_P4[]={0x0E};
const uint8_t WRITE_RX_ADDR_P4[]={0x2E};
const uint8_t READ_RX_ADDR_P5[]={0x0F};
const uint8_t WRITE_RX_ADDR_P5[]={0x2F};
const uint8_t READ_TX_ADDR[]={0x10};
const uint8_t WRITE_TX_ADDR[]={0x30};
const uint8_t READ_RX_PW_P0[]={0x11};
const uint8_t WRITE_RX_PW_P0[]={0x31};
const uint8_t READ_RX_PW_P1[]={0x12};
const uint8_t WRITE_RX_PW_P1[]={0x32};
const uint8_t READ_RX_PW_P2[]={0x13};
const uint8_t WRITE_RX_PW_P2[]={0x33};
const uint8_t READ_RX_PW_P3[]={0x14};
const uint8_t WRITE_RX_PW_P3[]={0x34};
const uint8_t READ_RX_PW_P4[]={0x15};
const uint8_t WRITE_RX_PW_P4[]={0x35};
const uint8_t READ_RX_PW_P5[]={0x16};
const uint8_t WRITE_RX_PW_P5[]={0x36};
const uint8_t READ_FIFO_STATUS[]={0x17};
const uint8_t READ_DYNPD[]={0x1C};
const uint8_t WRITE_DYNPD[]={0x3C};
const uint8_t READ_FEATURE[]={0x1D};
const uint8_t WRITE_FEATURE[]={0x3D};

uint8_t Rxbuffer[]={0x00};
uint8_t num[]={0};
uint8_t buff[2]={0,0};
uint8_t zero[2]={0,0};
uint8_t header[3]={255,255,50};
const int RX_Mode=1;
const int TX_Mode=2;
uint8_t STATUS[]={0};
uint8_t icheck=1;

uint8_t CONFIG[]={0x0B}; // Rx mode = 0x0F  ; Tx mode = 0x0E
uint8_t EN_AA[]={0x3F}; // 
uint8_t EN_RXADDR[]={0x3F};
uint8_t SETUP_AW[]={0x03};
uint8_t SETUP_RETR[]={0x2F};
uint8_t RF_CH[]={0x0F};
uint8_t RF_SETUP[]={0x9F};
uint8_t DYNPD[]={0x3F};	
uint8_t FEATURE[]={0x07};
uint8_t RX_PW_P0[]={0x20};
uint8_t RX_PW_P1[]={0x20};
uint8_t RX_PW_P2[]={0x20};
uint8_t RX_PW_P3[]={0x20};
uint8_t RX_PW_P4[]={0x20};
uint8_t RX_PW_P5[]={0x20};
uint8_t STAT[]={0x7E};
//uint8_t RX_ADDR_P0[]={0xE7,0xE7,0xE7,0xE7,0xE7};
//
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
void Error_Handler(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_SPI2_Init(void);
static void MX_USART3_UART_Init(void);
static void MX_USART2_UART_Init(void);

/* USER CODE BEGIN PFP */
/* Private function prototypes -----------------------------------------------*/
void Send_command(uint8_t *opcode);
void Write_Register(uint8_t *ADDR, uint8_t *Data);
void Read_Register(uint8_t *ADDR, uint16_t num);
void NRF_Deinit(void);
void NRF_Init(void);
void Radio_up(void);
void Radio_down(void);
void Receive_Data(uint8_t *data);
void Send_Data(uint8_t *data);

/* USER CODE END PFP */

/* USER CODE BEGIN 0 */
/******************************************************************************
	CS    	-->   GPIOA-8
	CE    	-->   GPIOA-9
	IRQ   	-->   GPIOB-12
	MISO  	-->   GPIOB-14
	MOSI  	-->   GPIOB-15
	SCK 		-->   GPIOB-13
	
	SWDIO 	-->		GPIOA-13
	SWDCLK 	-->		GPIOA-14
	
	LED1		--> 	GPIOA-15
	LED2		--> 	GPIOB-3
	LED3		--> 	GPIOB-4
	LED4		--> 	GPIOB-5
	LED5		--> 	GPIOB-6
	LED6		--> 	GPIOB-7
	
	LED7		--> 	GPIOA-5
	LED8		--> 	GPIOA-6
	LED9		--> 	GPIOA-7
	LED10		--> 	GPIOB-0
	LED11		--> 	GPIOB-1
	LED12		--> 	GPIOB-2
	
	UART3RX -->		GPIOB-11
	UART3TX --> 	GPIOB-12
	
	UART2RX -->		GPIOA-3
	UART2TX -->		GPIOA-2
	*******************************************************************************/
/* USER CODE END 0 */

int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_SPI2_Init();
  MX_USART3_UART_Init();
  MX_USART2_UART_Init();

  /* USER CODE BEGIN 2 */
//	HAL_MspInit();
	HAL_UART_MspInit(&huart2);
	HAL_SPI_MspInit(&hspi2);
	HAL_UART_MspInit(&huart3);
	NRF_Init();
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */
		Radio_up();
		HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_7);
		HAL_Delay(1000);
		Read_Register((uint8_t*)READ_FIFO_STATUS,1);
		HAL_UART_Transmit(&huart2,Rxbuffer,1,10);	
  }
  /* USER CODE END 3 */

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

  RCC_OscInitTypeDef RCC_OscInitStruct;
  RCC_ClkInitTypeDef RCC_ClkInitStruct;

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = 16;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI_DIV2;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL16;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }

  HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);

  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);

  /* SysTick_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}

/* SPI2 init function */
static void MX_SPI2_Init(void)
{

  hspi2.Instance = SPI2;
  hspi2.Init.Mode = SPI_MODE_MASTER;
  hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi2.Init.NSS = SPI_NSS_SOFT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi2.Init.CRCPolynomial = 10;
  if (HAL_SPI_Init(&hspi2) != HAL_OK)
  {
    Error_Handler();
  }

}

/* USART2 init function */
static void MX_USART2_UART_Init(void)
{

  huart2.Instance = USART2;
  huart2.Init.BaudRate = 921600;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }

}

/* USART3 init function */
static void MX_USART3_UART_Init(void)
{

  huart3.Instance = USART3;
  huart3.Init.BaudRate = 921600;
  huart3.Init.WordLength = UART_WORDLENGTH_8B;
  huart3.Init.StopBits = UART_STOPBITS_1;
  huart3.Init.Parity = UART_PARITY_NONE;
  huart3.Init.Mode = UART_MODE_TX_RX;
  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart3.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart3) != HAL_OK)
  {
    Error_Handler();
  }

}

/** 
  * Enable DMA controller clock
  * Configure DMA for memory to memory transfers
  *   hdma_memtomem_dma1_channel1
  */
static void MX_DMA_Init(void) 
{
  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();

  /* Configure DMA request hdma_memtomem_dma1_channel1 on DMA1_Channel1 */
  hdma_memtomem_dma1_channel1.Instance = DMA1_Channel1;
  hdma_memtomem_dma1_channel1.Init.Direction = DMA_MEMORY_TO_MEMORY;
  hdma_memtomem_dma1_channel1.Init.PeriphInc = DMA_PINC_ENABLE;
  hdma_memtomem_dma1_channel1.Init.MemInc = DMA_MINC_ENABLE;
  hdma_memtomem_dma1_channel1.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  hdma_memtomem_dma1_channel1.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  hdma_memtomem_dma1_channel1.Init.Mode = DMA_NORMAL;
  hdma_memtomem_dma1_channel1.Init.Priority = DMA_PRIORITY_HIGH;
  if (HAL_DMA_Init(&hdma_memtomem_dma1_channel1) != HAL_OK)
  {
    Error_Handler();
  }
        
  

  /* DMA interrupt init */
  /* DMA1_Channel1_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
  /* DMA1_Channel7_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);

}

/** Configure pins as 
        * Analog 
        * Input 
        * Output
        * EVENT_OUT
        * EXTI
*/
static void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct;

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8 
                          |GPIO_PIN_9|GPIO_PIN_15, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3 
                          |GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7, GPIO_PIN_RESET);

  /*Configure GPIO pins : PA5 PA6 PA7 PA15 */
  GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_15;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pins : PB0 PB1 PB2 PB3 
                           PB4 PB5 PB6 PB7 */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3 
                          |GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pin : PB12 */
  GPIO_InitStruct.Pin = GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pins : PA8 PA9 */
  GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);

}

/* USER CODE BEGIN 4 */

/*Write register function*/
void Write_Register(uint8_t *ADDR, uint8_t *Data)
{
	/*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
	HAL_SPI_TransmitReceive(&hspi2,ADDR,STATUS,1,10);
	HAL_SPI_Transmit(&hspi2,Data,1,10);
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);	
}

/*Read register function*/
void Read_Register(uint8_t *ADDR, uint16_t num)
{
	/*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
	HAL_SPI_TransmitReceive(&hspi2,ADDR,STATUS,1,10);
	HAL_SPI_Receive(&hspi2,Rxbuffer,num,10);
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
}

/*Send commands to NRF24L01+ function*/
void Send_command(uint8_t *opcode)
{
	/*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
	HAL_SPI_TransmitReceive(&hspi2,opcode,STATUS,1,10);
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
}
void Radio_up(void)
{
	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9, GPIO_PIN_SET);
}
void Radio_down(void)
{
	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9, GPIO_PIN_RESET);
}

/*initialize NRF24L01+ function*/
void NRF_Init(void)
{
	NRF_Deinit();
	Radio_down();
	Write_Register((uint8_t*)WRITE_CONFIG,(uint8_t*)CONFIG);
	Write_Register((uint8_t*)WRITE_EN_AA,(uint8_t*)EN_AA);
	Write_Register((uint8_t*)WRITE_EN_RXADDR,(uint8_t*)EN_RXADDR);
	Write_Register((uint8_t*)WRITE_SETUP_AW,(uint8_t*)SETUP_AW);
	Write_Register((uint8_t*)WRITE_SETUP_RETR,(uint8_t*)SETUP_RETR);
	Write_Register((uint8_t*)WRITE_RF_CH,(uint8_t*)RF_CH);
	Write_Register((uint8_t*)WRITE_RF_SETUP,(uint8_t*)RF_SETUP);
	Write_Register((uint8_t*)WRITE_RX_PW_P0,(uint8_t*)RX_PW_P0);
	Write_Register((uint8_t*)WRITE_RX_PW_P1,(uint8_t*)RX_PW_P1);
	Write_Register((uint8_t*)WRITE_RX_PW_P2,(uint8_t*)RX_PW_P2);
	Write_Register((uint8_t*)WRITE_RX_PW_P3,(uint8_t*)RX_PW_P3);
	Write_Register((uint8_t*)WRITE_RX_PW_P4,(uint8_t*)RX_PW_P4);
	Write_Register((uint8_t*)WRITE_RX_PW_P5,(uint8_t*)RX_PW_P5);
	Write_Register((uint8_t*)WRITE_DYNPD,(uint8_t*)DYNPD);
	Write_Register((uint8_t*)WRITE_FEATURE,(uint8_t*)FEATURE);
	Radio_up();
	HAL_Delay(5);
}

void NRF_Deinit(void)
{
	Radio_down();
	Write_Register((uint8_t*)WRITE_CONFIG,0x00);
	Write_Register((uint8_t*)WRITE_EN_RXADDR,0x00);
	Write_Register((uint8_t*)WRITE_SETUP_RETR,0x00);
	Write_Register((uint8_t*)WRITE_RF_CH,(uint8_t*)0x02);
	Write_Register((uint8_t*)WRITE_EN_AA,0x00);
	Write_Register((uint8_t*)WRITE_RF_SETUP,(uint8_t*)0x0E);
	Write_Register((uint8_t*)WRITE_DYNPD,0x00);
	Write_Register((uint8_t*)WRITE_FEATURE,0x00);
	Radio_up();
	Send_command((uint8_t*)FLUSH_TX);
	Send_command((uint8_t*)FLUSH_RX);
}

void Send_Data(uint8_t *data)
{
	Send_command((uint8_t*)FLUSH_TX);
	Send_command((uint8_t*)W_TX_PAYLOAD);
	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
	HAL_SPI_TransmitReceive(&hspi2,data,STATUS,32,10);
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
	Write_Register((uint8_t*)WRITE_STATUS,(uint8_t *)0x2E);

}


void Receive_Data(uint8_t *data)
{
	Send_command((uint8_t*)R_RX_PAYLOAD);
	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
	HAL_SPI_Receive(&hspi2,data,32,10);
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
	Send_command((uint8_t*)FLUSH_RX);
	Write_Register((uint8_t*)WRITE_STATUS,(uint8_t *)0x4E);
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	if(GPIO_Pin == GPIO_PIN_12)
	{
		Receive_Data((uint8_t *) Rxbuffer);
		HAL_UART_Transmit(&huart2,Rxbuffer,32,10);
		HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_7);
		HAL_Delay(500);
	}
}


/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @param  None
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler */
  /* User can add his own implementation to report the HAL error return state */
  while(1) 
  {
  }
  /* USER CODE END Error_Handler */ 
}

#ifdef USE_FULL_ASSERT

/**
   * @brief Reports the name of the source file and the source line number
   * where the assert_param error has occurred.
   * @param file: pointer to the source file name
   * @param line: assert_param error line source number
   * @retval None
   */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
    ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */

}

#endif

/**
  * @}
  */ 

/**
  * @}
*/ 

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
RE: Having problem for connection between nRF24l01+ and nRF51822

run_ar — Thu, 17 Sep 2020 10:20:31 GMT
The difference between the Legacy and default define is dynamic payload and the length of the CRC. Did you check that these are the same on both ends?
RE: Having problem for connection between nRF24l01+ and nRF51822

Masoumeh — Wed, 16 Sep 2020 15:51:15 GMT
I am not using the low power libraries in ESB. I am using esb_ptx. in this example we use NRF_ESB_DEFAULT.
RE: Having problem for connection between nRF24l01+ and nRF51822

run_ar — Wed, 16 Sep 2020 13:20:13 GMT
Hi,
Did you read the documentation for Backward compatibility and did you enable legacy support (#define NRF_ESB_LEGACY)?