void nrf_drv_saadc_uninit(void)
{
ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
nrf_saadc_int_disable(NRF_SAADC_INT_ALL);
nrf_drv_common_irq_disable(SAADC_IRQn);
nrf_saadc_task_trigger(NRF_SAADC_TASK_STOP);
// Wait for ADC being stopped.
uint32_t timeout = HW_TIMEOUT;
while (nrf_saadc_event_check(NRF_SAADC_EVENT_STOPPED) == 0 && timeout > 0)
{
--timeout;
}
ASSERT(timeout > 0);
nrf_saadc_disable();
m_cb.adc_state = NRF_SAADC_STATE_IDLE;
for (uint8_t channel = 0; channel < NRF_SAADC_CHANNEL_COUNT; ++channel)
{
if (m_cb.psel[channel].pselp != NRF_SAADC_INPUT_DISABLED)
{
(void)nrf_drv_saadc_channel_uninit(channel);
}
}
m_cb.state = NRF_DRV_STATE_UNINITIALIZED;
}
ret_code_t nrf_drv_saadc_sample_convert(uint8_t channel, nrf_saadc_value_t * p_value)
{
if (m_cb.adc_state != NRF_SAADC_STATE_IDLE)
{
return NRF_ERROR_BUSY;
}
m_cb.adc_state = NRF_SAADC_STATE_BUSY;
nrf_saadc_int_disable(NRF_SAADC_INT_END);
nrf_saadc_buffer_init(p_value, 1);
nrf_saadc_channel_input_set(channel,
m_cb.psel[channel].pselp, m_cb.psel[channel].pseln);
nrf_saadc_task_trigger(NRF_SAADC_TASK_START);
nrf_saadc_task_trigger(NRF_SAADC_TASK_SAMPLE);
uint32_t timeout = 100000;
while (0 == nrf_saadc_event_check(NRF_SAADC_EVENT_END) && timeout > 0)
{
timeout--;
}
nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
nrf_saadc_channel_input_set(channel, NRF_SAADC_INPUT_DISABLED, NRF_SAADC_INPUT_DISABLED);
nrf_saadc_int_enable(NRF_SAADC_INT_END);
m_cb.adc_state = NRF_SAADC_STATE_IDLE;
return NRF_SUCCESS;
}
ret_code_t nrf_drv_saadc_buffer_convert(nrf_saadc_value_t * p_buffer, uint16_t size)
{
ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
ASSERT((size % m_cb.active_channels) == 0);
nrf_saadc_int_disable(NRF_SAADC_INT_END | NRF_SAADC_INT_CALIBRATEDONE);
if (m_cb.adc_state == NRF_SAADC_STATE_CALIBRATION)
{
nrf_saadc_int_enable(NRF_SAADC_INT_END | NRF_SAADC_INT_CALIBRATEDONE);
return NRF_ERROR_BUSY;
}
if (m_cb.adc_state == NRF_SAADC_STATE_BUSY)
{
if ( m_cb.p_secondary_buffer)
{
nrf_saadc_int_enable(NRF_SAADC_INT_END);
return NRF_ERROR_BUSY;
}
else
{
m_cb.p_secondary_buffer = p_buffer;
m_cb.secondary_buffer_size = size;
if (!m_cb.low_power_mode)
{
while (nrf_saadc_event_check(NRF_SAADC_EVENT_STARTED) == 0)
;
nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
nrf_saadc_buffer_init(p_buffer, size);
}
nrf_saadc_int_enable(NRF_SAADC_INT_END);
return NRF_SUCCESS;
}
}
nrf_saadc_int_enable(NRF_SAADC_INT_END);
m_cb.adc_state = NRF_SAADC_STATE_BUSY;
m_cb.p_buffer = p_buffer;
m_cb.buffer_size = size;
m_cb.p_secondary_buffer = NULL;
if (m_cb.low_power_mode)
{
m_cb.buffer_size_left = size;
nrf_saadc_buffer_init(p_buffer, m_cb.active_channels);
}
else
{
nrf_saadc_buffer_init(p_buffer, size);
nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
nrf_saadc_task_trigger(NRF_SAADC_TASK_START);
}
return NRF_SUCCESS;
}
void nrf_drv_saadc_limit_set(uint8_t channel, int16_t limit_low, int16_t limit_high)
{
ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
ASSERT(m_cb.event_handler); // only non blocking mode supported
nrf_saadc_channel_limits_set(channel, limit_low, limit_high);
uint32_t int_mask = nrf_saadc_limit_int_get(channel, NRF_SAADC_LIMIT_LOW);
if (limit_low == NRF_DRV_SAADC_LIMITL_DISABLED)
{
m_cb.limits_enabled_flags &= ~(0x80000000 >> LOW_LIMIT_TO_FLAG(channel));
nrf_saadc_int_disable(int_mask);
}
ret_code_t nrf_drv_saadc_sample_convert(uint8_t channel, nrf_saadc_value_t * p_value)
{
if (m_cb.adc_state != NRF_SAADC_STATE_IDLE)
{
return NRF_ERROR_BUSY;
}
m_cb.adc_state = NRF_SAADC_STATE_BUSY;
nrf_saadc_int_disable(NRF_SAADC_INT_STARTED | NRF_SAADC_INT_END);
nrf_saadc_buffer_init(p_value, 1);
if (m_cb.active_channels > 1)
{
for (uint8_t i = 0; i < NRF_SAADC_CHANNEL_COUNT; ++i)
{
nrf_saadc_channel_input_set(i, NRF_SAADC_INPUT_DISABLED, NRF_SAADC_INPUT_DISABLED);
}
}
nrf_saadc_channel_input_set(channel,
m_cb.psel[channel].pselp, m_cb.psel[channel].pseln);
nrf_saadc_task_trigger(NRF_SAADC_TASK_START);
nrf_saadc_task_trigger(NRF_SAADC_TASK_SAMPLE);
uint32_t timeout = HW_TIMEOUT;
while (0 == nrf_saadc_event_check(NRF_SAADC_EVENT_END) && timeout > 0)
{
timeout--;
}
nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
if (m_cb.active_channels > 1)
{
for (uint8_t i = 0; i < NRF_SAADC_CHANNEL_COUNT; ++i)
{
nrf_saadc_channel_input_set(i, m_cb.psel[i].pselp, m_cb.psel[i].pseln);
}
}
if (m_cb.low_power_mode)
{
nrf_saadc_int_enable(NRF_SAADC_INT_STARTED | NRF_SAADC_INT_END);
}
else
{
nrf_saadc_int_enable(NRF_SAADC_INT_END);
}
m_cb.adc_state = NRF_SAADC_STATE_IDLE;
return NRF_SUCCESS;
}
ret_code_t nrf_drv_saadc_init(nrf_drv_saadc_config_t const * p_config,
nrf_drv_saadc_event_handler_t event_handler)
{
if (m_cb.state != NRF_DRV_STATE_UNINITIALIZED)
{
return NRF_ERROR_INVALID_STATE;
}
if (event_handler == NULL)
{
return NRF_ERROR_INVALID_PARAM;
}
if (p_config == NULL)
{
p_config = &m_default_config;
}
m_cb.event_handler = event_handler;
nrf_saadc_resolution_set(p_config->resolution);
nrf_saadc_oversample_set(p_config->oversample);
m_cb.low_power_mode = p_config->low_power_mode;
m_cb.state = NRF_DRV_STATE_INITIALIZED;
m_cb.adc_state = NRF_SAADC_STATE_IDLE;
m_cb.active_channels = 0;
m_cb.limits_enabled_flags = 0;
m_cb.conversions_end = false;
nrf_saadc_int_disable(NRF_SAADC_INT_ALL);
nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
nrf_drv_common_irq_enable(SAADC_IRQn, p_config->interrupt_priority);
nrf_saadc_int_enable(NRF_SAADC_INT_END);
if (m_cb.low_power_mode)
{
nrf_saadc_int_enable(NRF_SAADC_INT_STARTED);
}
nrf_saadc_enable();
return NRF_SUCCESS;
}
ret_code_t nrf_drv_saadc_buffer_convert(nrf_saadc_value_t * p_buffer, uint16_t size)
{
ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
nrf_saadc_int_disable(NRF_SAADC_INT_END);
if (m_cb.adc_state == NRF_SAADC_STATE_BUSY)
{
if ( m_cb.p_secondary_buffer)
{
nrf_saadc_int_enable(NRF_SAADC_INT_END);
return NRF_ERROR_BUSY;
}
else
{
m_cb.p_secondary_buffer = p_buffer;
m_cb.secondary_buffer_size = size;
if (m_cb.active_channels == 1)
{
while (nrf_saadc_event_check(NRF_SAADC_EVENT_STARTED) == 0);
nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
nrf_saadc_buffer_init(p_buffer, size);
}
nrf_saadc_int_enable(NRF_SAADC_INT_END);
return NRF_SUCCESS;
}
}
nrf_saadc_int_enable(NRF_SAADC_INT_END);
m_cb.adc_state = NRF_SAADC_STATE_BUSY;
m_cb.scan_pos = NRF_SAADC_CHANNEL_COUNT;
for (uint8_t i = 0; i < NRF_SAADC_CHANNEL_COUNT; ++i)
{
if (m_cb.psel[i].pselp)
{
m_cb.scan_pos = i;
break;
}
}
// Find the first enabled channel.
if (m_cb.scan_pos >= NRF_SAADC_CHANNEL_COUNT)
{
return NRF_ERROR_INVALID_STATE;
}
m_cb.buffer = p_buffer;
m_cb.buffer_size = size;
m_cb.buffer_pos = 0;
m_cb.p_secondary_buffer = NULL;
nrf_saadc_channel_input_set(m_cb.scan_pos,
m_cb.psel[m_cb.scan_pos].pselp, m_cb.psel[m_cb.scan_pos].pseln);
if (m_cb.active_channels == 1)
{
nrf_saadc_buffer_init(p_buffer, size);
}
else
{
nrf_saadc_buffer_init(p_buffer, 1);
}
nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
nrf_saadc_task_trigger(NRF_SAADC_TASK_START);
return NRF_SUCCESS;
}
