Hi,
I want to enable 8 channels of saadc in SE mode with 10 bits of resolution. the number of samples in every packet is 32, which means every channel have 4 samples in every packet. then I will put 5 buffers of saadc in 1 buffer and then I transmit it via BLE to the PC. for transmitting in the most efficient way, I put every 10 bits sample in 1.5 bytes as follow
for ( i = 0; i < SAMPLES_IN_BUFFER; i+=2)
{
tx_payload.data[k] = (uint8_t)(p_event->data.done.p_buffer[i]);
tx_payload.data[k+1] = (uint8_t)(p_event->data.done.p_buffer[i] >> 8) | (uint8_t)(p_event->data.done.p_buffer[i+1] << 4);
tx_payload.data[k+2] = (uint8_t)(p_event->data.done.p_buffer[i+1] >> 4);
k+=3;
}
I am getting the right value of adc but the frequency is not okay. for example, when I am sampling a 10 Hz signal, I receive a 20 Hz signal.
Can you help me find the problem?
my whole code is as follow:
/**
* Copyright (c) 2014 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* 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, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, 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 Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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.
*
*/
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include "sdk_common.h"
#include "nrf.h"
#include "nrf_esb.h"
#include "nrf_error.h"
#include "nrf_esb_error_codes.h"
#include "nrf_delay.h"
#include "nrf_gpio.h"
#include "nrf_clock.h"
#include "boards.h"
#include "nrf_delay.h"
#include "app_util.h"
/** user's code begins 1.
*/
#include <stdio.h>
#include "nrf_drv_saadc.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "app_error.h"
#include "app_util_platform.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "bsp.h"
#include "nrf_drv_gpiote.h"
/** user's code ends 1.
*/
/** user's code begins 2.
*/
int Sleep = 0;
int Command = 1;
int Record = 2;
int nrf_mode = 0;
#define E1 NRF_SAADC_INPUT_AIN0 // Open //
#define E2 NRF_SAADC_INPUT_AIN1 // BAT //
#define E3 NRF_SAADC_INPUT_AIN2 // Open //
#define E4 NRF_SAADC_INPUT_AIN3 // Ref //
#define E5 NRF_SAADC_INPUT_AIN4 // E3 //
#define E6 NRF_SAADC_INPUT_AIN5 // E4 //
#define E7 NRF_SAADC_INPUT_AIN6 // E1 //
#define E8 NRF_SAADC_INPUT_AIN7 // E2 //
#define Status_LED 10
#define Pin_CTRL 26
#define PIN_IN 25
int count=0;
uint32_t Record_time=0;
bool nrf_record_config = false;
#define SAMPLES_IN_BUFFER 32
volatile uint8_t state = 1;
static const nrf_drv_timer_t m_timer = NRF_DRV_TIMER_INSTANCE(0);
static nrf_saadc_value_t m_buffer_pool[2][SAMPLES_IN_BUFFER];
static nrf_ppi_channel_t m_ppi_channel;
static nrf_ppi_channel_t m_ppi_channel0;
static nrf_esb_payload_t tx_payload = NRF_ESB_CREATE_PAYLOAD (0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00);
static nrf_esb_payload_t rx_payload;
static uint32_t Sending_packet_passed;
static uint32_t Sending_packet_failed;
int i,k;
uint8_t flag=0;
uint8_t iteration=1;
uint32_t time_count_m = 0;
uint32_t packet=0;
const nrf_drv_timer_t TIMER_Sleep = NRF_DRV_TIMER_INSTANCE(1);
/* Functions */
void timer_handler(nrf_timer_event_t event_type, void * p_context);
void saadc_sampling_event_init(void);
void saadc_sampling_event_enable(void);
void saadc_callback(nrf_drv_saadc_evt_t const * p_event);
void saadc_init(void);
void nrf_esb_event_handler(nrf_esb_evt_t const * p_event);
void clocks_start( void );
uint32_t esb_init_ptx( void );
uint32_t esb_init_prx( void );
void in_pin_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action);
void gpio_init( void );
void delay_s(uint32_t s_time);
void delay_m(uint32_t m_time);
void delay_h(uint32_t h_time);
void stop_saadc(void);
void TIMER_Sleep_event_handler(nrf_timer_event_t event_type, void* p_context);
void timer_init(void);
/** user's code ends 2.
*/
int main(void)
{
ret_code_t err_code;
gpio_init();
err_code = NRF_LOG_INIT(NULL);
APP_ERROR_CHECK(err_code);
NRF_LOG_DEFAULT_BACKENDS_INIT();
clocks_start();
/** user's code begins 3.
*/
NRF_POWER->DCDCEN=1;
ret_code_t ret_code = nrf_pwr_mgmt_init();
APP_ERROR_CHECK(ret_code);
/** usr's code ends 3.
*/
while (true)
{
count=0;
if (nrf_mode == Sleep)
{
nrf_gpio_pin_clear(Pin_CTRL);
nrf_gpio_pin_clear(Status_LED);
timer_init();
nrf_pwr_mgmt_run();
nrf_mode = Command;
nrf_drv_timer_disable(&TIMER_Sleep);
nrf_drv_timer_uninit(&TIMER_Sleep);
}
if (nrf_mode == Command)
{
err_code = esb_init_prx();
APP_ERROR_CHECK(err_code);
err_code = nrf_esb_start_rx();
APP_ERROR_CHECK(err_code);
while(nrf_mode == Command)
{
nrf_gpio_pin_toggle(Status_LED);
nrf_delay_ms(200);
count++;
if (count==150)
{
nrf_mode = Sleep;
err_code = nrf_esb_stop_rx();
APP_ERROR_CHECK(err_code);
nrf_esb_disable();
nrf_saadc_disable();
count = 0;
}
}
}
if (nrf_mode == Record)
{
if(nrf_record_config == true)
{
nrf_gpio_pin_set(Pin_CTRL);
err_code = nrf_esb_stop_rx();
APP_ERROR_CHECK(err_code);
err_code = esb_init_ptx();
APP_ERROR_CHECK(err_code);
saadc_init();
saadc_sampling_event_init();
saadc_sampling_event_enable();
nrf_record_config = false;
}
else
nrf_pwr_mgmt_run();
}
}
}
/**
* @brief Handler for timer events.
*/
void TIMER_Sleep_event_handler(nrf_timer_event_t event_type, void* p_context)
{
switch (event_type)
{
case NRF_TIMER_EVENT_COMPARE1:
nrf_drv_timer_disable(&TIMER_Sleep);
nrf_drv_timer_uninit(&TIMER_Sleep);
for (int i=0; i<10; i++)
{
nrf_gpio_pin_toggle(Status_LED);
nrf_delay_ms(1000);
}
break;
default:
//Do nothing.
break;
}
}
void timer_init(void)
{
// uint32_t time_ms = (4*60+50)*1000; //Time(in miliseconds) between consecutive compare events.
uint32_t time_ms = 0.5*60*1000;
uint32_t time_ticks;
uint32_t err_code = NRF_SUCCESS;
//Configure TIMER_Sleep for generating simple light effect - leds on board will invert his state one after the other.
nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
err_code = nrf_drv_timer_init(&TIMER_Sleep, &timer_cfg, TIMER_Sleep_event_handler);
APP_ERROR_CHECK(err_code);
time_ticks = nrf_drv_timer_ms_to_ticks(&TIMER_Sleep, time_ms);
nrf_drv_timer_extended_compare(
&TIMER_Sleep, NRF_TIMER_CC_CHANNEL1, time_ticks, NRF_TIMER_SHORT_COMPARE1_CLEAR_MASK, true);
nrf_drv_timer_enable(&TIMER_Sleep);
}
void timer_handler(nrf_timer_event_t event_type, void * p_context)
{
}
void saadc_sampling_event_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_init();
APP_ERROR_CHECK(err_code);
nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
timer_cfg.bit_width = NRF_TIMER_BIT_WIDTH_32;
err_code = nrf_drv_timer_init(&m_timer, &timer_cfg, timer_handler);
APP_ERROR_CHECK(err_code);
/* setup m_timer for compare event every 50us */
uint32_t ticks = nrf_drv_timer_us_to_ticks(&m_timer, 50);
nrf_drv_timer_extended_compare(&m_timer,
NRF_TIMER_CC_CHANNEL0,
ticks,
NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK,
false);
nrf_drv_timer_enable(&m_timer);
uint32_t timer_compare_event_addr = nrf_drv_timer_compare_event_address_get(&m_timer,
NRF_TIMER_CC_CHANNEL0);
uint32_t saadc_sample_task_addr = nrf_drv_saadc_sample_task_get();
/* setup ppi channel so that timer compare event is triggering sample task in SAADC */
err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
timer_compare_event_addr,
saadc_sample_task_addr);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel0);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_assign(m_ppi_channel0,
nrf_saadc_event_address_get(NRF_SAADC_EVENT_END),
nrf_saadc_task_address_get(NRF_SAADC_TASK_START));
APP_ERROR_CHECK(err_code);
}
void saadc_sampling_event_enable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_enable(m_ppi_channel0);
APP_ERROR_CHECK(err_code);
}
void saadc_callback(nrf_drv_saadc_evt_t const * p_event) //ok
{
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
ret_code_t err_code;
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SAMPLES_IN_BUFFER);
APP_ERROR_CHECK(err_code);
if (flag == 0)
{
if (iteration == 5)
{
for ( i = 0; i < SAMPLES_IN_BUFFER; i+=2)
{
tx_payload.data[k] = (uint8_t)(p_event->data.done.p_buffer[i]);
tx_payload.data[k+1] = (uint8_t)(p_event->data.done.p_buffer[i] >> 8) | (uint8_t)(p_event->data.done.p_buffer[i+1] << 4);
tx_payload.data[k+2] = (uint8_t)(p_event->data.done.p_buffer[i+1] >> 4);
k+=3;
}
iteration = 1;
flag=1;
}
if (iteration == 4)
{
for ( i = 0; i < SAMPLES_IN_BUFFER; i+=2)
{
tx_payload.data[k] = (uint8_t)(p_event->data.done.p_buffer[i]);
tx_payload.data[k+1] = (uint8_t)(p_event->data.done.p_buffer[i] >> 8) | (uint8_t)(p_event->data.done.p_buffer[i+1] << 4);
tx_payload.data[k+2] = (uint8_t)(p_event->data.done.p_buffer[i+1] >> 4);
k+=3;
}
iteration = 5;
}
if (iteration == 3)
{
for ( i = 0; i < SAMPLES_IN_BUFFER; i+=2)
{
tx_payload.data[k] = (uint8_t)(p_event->data.done.p_buffer[i]);
tx_payload.data[k+1] = (uint8_t)(p_event->data.done.p_buffer[i] >> 8) | (uint8_t)(p_event->data.done.p_buffer[i+1] << 4);
tx_payload.data[k+2] = (uint8_t)(p_event->data.done.p_buffer[i+1] >> 4);
k+=3;
}
iteration = 4;
}
if (iteration == 2)
{
for ( i = 0; i < SAMPLES_IN_BUFFER; i+=2)
{
tx_payload.data[k] = (uint8_t)(p_event->data.done.p_buffer[i]);
tx_payload.data[k+1] = (uint8_t)(p_event->data.done.p_buffer[i] >> 8) | (uint8_t)(p_event->data.done.p_buffer[i+1] << 4);
tx_payload.data[k+2] = (uint8_t)(p_event->data.done.p_buffer[i+1] >> 4);
k+=3;
}
iteration = 3;
}
if (iteration == 1 && flag ==0)
{
k=1;
for ( i = 0; i < SAMPLES_IN_BUFFER; i+=2)
{
tx_payload.data[k] = (uint8_t)(p_event->data.done.p_buffer[i]);
tx_payload.data[k+1] = (uint8_t)(p_event->data.done.p_buffer[i] >> 8) | (uint8_t)(p_event->data.done.p_buffer[i+1] << 4);
tx_payload.data[k+2] = (uint8_t)(p_event->data.done.p_buffer[i+1] >> 4);
k+=3;
}
iteration = 2;
}
}
if (flag == 1)
{
tx_payload.data[0]=Sending_packet_passed;
tx_payload.data[241]=Sending_packet_failed;
if (nrf_esb_write_payload(&tx_payload) == NRF_SUCCESS)
{
Sending_packet_passed++;
}
else
{
Sending_packet_failed++;
}
flag=0;
}
}
}
void stop_saadc(void)
{
nrf_drv_timer_disable(&m_timer);
nrf_drv_timer_uninit(&m_timer);
nrf_drv_ppi_channel_disable(m_ppi_channel);
nrf_drv_ppi_channel_disable(m_ppi_channel0);
nrf_drv_ppi_uninit();
nrf_drv_saadc_abort();
nrf_drv_saadc_uninit();
while(nrf_drv_saadc_is_busy());
}
void saadc_init(void) //ok
{
ret_code_t err_code;
nrf_saadc_channel_config_t channel_config0 =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(E1);
nrf_saadc_channel_config_t channel_config1 =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(E2);
nrf_saadc_channel_config_t channel_config2 =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(E3);
nrf_saadc_channel_config_t channel_config3 =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(E4);
nrf_saadc_channel_config_t channel_config4 =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(E5);
nrf_saadc_channel_config_t channel_config5 =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(E6);
nrf_saadc_channel_config_t channel_config6 =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(E7);
nrf_saadc_channel_config_t channel_config7 =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(E8);
err_code = nrf_drv_saadc_init(NULL, saadc_callback);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(0, &channel_config0);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(1, &channel_config1);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(2, &channel_config2);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(3, &channel_config3);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(4, &channel_config4);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(5, &channel_config5);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(6, &channel_config6);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(7, &channel_config7);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[0], SAMPLES_IN_BUFFER);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[1], SAMPLES_IN_BUFFER);
APP_ERROR_CHECK(err_code);
}
/** user's code ends 2.
*/
void nrf_esb_event_handler(nrf_esb_evt_t const * p_event)
{
switch (p_event->evt_id)
{
case NRF_ESB_EVENT_TX_SUCCESS:
NRF_LOG_DEBUG("TX SUCCESS EVENT");
nrf_gpio_pin_set(Status_LED);
packet++;
if(packet==60000)
{
time_count_m++;
packet=0;
}
if(time_count_m == Record_time)
{
stop_saadc();
nrf_mode = Sleep;
packet=0;
time_count_m=0;
nrf_gpio_pin_clear(Status_LED);
}
break;
case NRF_ESB_EVENT_TX_FAILED:
NRF_LOG_DEBUG("TX FAILED EVENT");
(void) nrf_esb_flush_tx();
(void) nrf_esb_start_tx();
nrf_gpio_pin_clear(Status_LED);
break;
case NRF_ESB_EVENT_RX_RECEIVED:
NRF_LOG_DEBUG("RX RECEIVED EVENT");
while (nrf_esb_read_rx_payload(&rx_payload) == NRF_SUCCESS)
{
Record_time = rx_payload.data[1];
bsp_board_leds_off();
nrf_mode = Record;
nrf_record_config = true;
}
break;
}
}
void clocks_start( void )
{
NRF_CLOCK->EVENTS_HFCLKSTARTED = 0;
NRF_CLOCK->TASKS_HFCLKSTART = 1;
while (NRF_CLOCK->EVENTS_HFCLKSTARTED == 0);
}
uint32_t esb_init_ptx( void )
{
uint32_t err_code;
uint8_t base_addr_0[4] = {0xE7, 0xE7, 0xE7, 0xE7};
uint8_t base_addr_1[4] = {0xC2, 0xC2, 0xC2, 0xC2};
uint8_t addr_prefix[8] = {0xE7, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8 };
nrf_esb_config_t nrf_esb_config = NRF_ESB_DEFAULT_CONFIG;
nrf_esb_config.protocol = NRF_ESB_PROTOCOL_ESB_DPL;
nrf_esb_config.tx_output_power = NRF_ESB_TX_POWER_0DBM;
nrf_esb_config.retransmit_delay = 600;
nrf_esb_config.bitrate = NRF_ESB_BITRATE_2MBPS_BLE;
nrf_esb_config.payload_length = 242;
nrf_esb_config.event_handler = nrf_esb_event_handler;
nrf_esb_config.mode = NRF_ESB_MODE_PTX;
nrf_esb_config.selective_auto_ack = false;
err_code = nrf_esb_init(&nrf_esb_config);
VERIFY_SUCCESS(err_code);
err_code = nrf_esb_set_base_address_0(base_addr_0);
VERIFY_SUCCESS(err_code);
err_code = nrf_esb_set_base_address_1(base_addr_1);
VERIFY_SUCCESS(err_code);
err_code = nrf_esb_set_prefixes(addr_prefix, NRF_ESB_PIPE_COUNT);
VERIFY_SUCCESS(err_code);
return err_code;
}
uint32_t esb_init_prx( void )
{
uint32_t err_code;
uint8_t base_addr_0[4] = {0xE7, 0xE7, 0xE7, 0xE7};
uint8_t base_addr_1[4] = {0xC2, 0xC2, 0xC2, 0xC2};
uint8_t addr_prefix[8] = {0xE7, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8 };
nrf_esb_config_t nrf_esb_config = NRF_ESB_DEFAULT_CONFIG;
nrf_esb_config.protocol = NRF_ESB_PROTOCOL_ESB_DPL;
nrf_esb_config.tx_output_power = NRF_ESB_TX_POWER_0DBM;
nrf_esb_config.retransmit_delay = 600;
nrf_esb_config.bitrate = NRF_ESB_BITRATE_2MBPS_BLE;
nrf_esb_config.payload_length = 242;
nrf_esb_config.event_handler = nrf_esb_event_handler;
nrf_esb_config.mode = NRF_ESB_MODE_PRX;
nrf_esb_config.selective_auto_ack = false;
err_code = nrf_esb_init(&nrf_esb_config);
VERIFY_SUCCESS(err_code);
err_code = nrf_esb_set_base_address_0(base_addr_0);
VERIFY_SUCCESS(err_code);
err_code = nrf_esb_set_base_address_1(base_addr_1);
VERIFY_SUCCESS(err_code);
err_code = nrf_esb_set_prefixes(addr_prefix, NRF_ESB_PIPE_COUNT);
VERIFY_SUCCESS(err_code);
return err_code;
}
void in_pin_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
{
}
void gpio_init( void )
{
ret_code_t err_code;
nrf_gpio_cfg_output(Status_LED);
nrf_gpio_cfg_output(Pin_CTRL);
err_code = nrf_drv_gpiote_init();
APP_ERROR_CHECK(err_code);
nrf_drv_gpiote_in_config_t in_config = GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
in_config.pull = NRF_GPIO_PIN_PULLDOWN;
err_code = nrf_drv_gpiote_in_init(PIN_IN, &in_config, in_pin_handler);
APP_ERROR_CHECK(err_code);
nrf_drv_gpiote_in_event_enable(PIN_IN, true);
}
void delay_s(uint32_t s_time)
{
if (s_time == 0)
{
return;
}
do
{
nrf_delay_ms(1000);
} while (--s_time);
}
void delay_m(uint32_t m_time)
{
if (m_time == 0)
{
return;
}
do
{
delay_s(60);
} while (--m_time);
}
void delay_h(uint32_t h_time)
{
if (h_time == 0)
{
return;
}
do
{
delay_m(60);
} while (--h_time);
}
