int i2c_byte_read(i2c_t *obj, int last)
{
NRF_TWI_Type *twi = m_twi_instances[TWI_IDX(obj)];
uint32_t t0;
if (last) {
nrf_twi_shorts_set(twi, NRF_TWI_SHORT_BB_STOP_MASK);
}
nrf_twi_task_trigger(twi, NRF_TWI_TASK_RESUME);
t0 = ticker_read(get_us_ticker_data());
do {
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_RXDREADY)) {
nrf_twi_event_clear(twi, NRF_TWI_EVENT_RXDREADY);
return nrf_twi_rxd_get(twi);
}
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_ERROR)) {
nrf_twi_event_clear(twi, NRF_TWI_EVENT_ERROR);
return I2C_ERROR_NO_SLAVE;
}
} while (((uint32_t)ticker_read(get_us_ticker_data()) - t0) < I2C_TIMEOUT_VALUE_US);
return I2C_ERROR_BUS_BUSY;
}
bool sleep_manager_can_deep_sleep_test_check()
{
const uint32_t check_time_us = 2000;
const ticker_data_t *const ticker = get_us_ticker_data();
uint32_t start = ticker_read(ticker);
while ((ticker_read(ticker) - start) < check_time_us) {
if (sleep_manager_can_deep_sleep()) {
return true;
}
}
return false;
}
void wait_us(int us)
{
const ticker_data_t *const ticker = get_us_ticker_data();
uint32_t start = ticker_read(ticker);
if ((us >= 1000) && core_util_are_interrupts_enabled()) {
// Use the RTOS to wait for millisecond delays if possible
sleep_manager_lock_deep_sleep();
Thread::wait((uint32_t)us / 1000);
sleep_manager_unlock_deep_sleep();
}
// Use busy waiting for sub-millisecond delays, or for the whole
// interval if interrupts are not enabled
while ((ticker_read(ticker) - start) < (uint32_t)us);
}
int Timer::slicetime() {
if (_running) {
return ticker_read(_ticker_data) - _start;
} else {
return 0;
}
}
void Ticker::setup(timestamp_t t) {
core_util_critical_section_enter();
remove();
_delay = t;
insert(_delay + ticker_read(_ticker_data));
core_util_critical_section_exit();
}
int i2c_stop(i2c_t *obj)
{
NRF_TWI_Type *twi = m_twi_instances[TWI_IDX(obj)];
uint32_t t0;
// The current transfer may be suspended (if it is RX), so it must be
// resumed before the STOP task is triggered.
nrf_twi_task_trigger(twi, NRF_TWI_TASK_RESUME);
nrf_twi_task_trigger(twi, NRF_TWI_TASK_STOP);
t0 = ticker_read(get_us_ticker_data());
do {
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_STOPPED)) {
return 0;
}
} while (((uint32_t)ticker_read(get_us_ticker_data()) - t0) < I2C_TIMEOUT_VALUE_US);
return 1;
}
QspiStatus flash_wait_for(uint32_t time_us, Qspi &qspi)
{
uint8_t reg[QSPI_STATUS_REG_SIZE];
qspi_status_t ret;
uint32_t curr_time;
const ticker_data_t *const ticker = get_us_ticker_data();
const uint32_t start = ticker_read(ticker);
memset(reg, 255, QSPI_STATUS_REG_SIZE);
do {
ret = read_register(STATUS_REG, reg, QSPI_STATUS_REG_SIZE, qspi);
curr_time = ticker_read(ticker);
} while (((reg[0] & STATUS_BIT_WIP) != 0) && ((curr_time - start) < time_us));
if (((reg[0] & STATUS_BIT_WIP) == 0) && (ret == QSPI_STATUS_OK)) {
return sOK;
} else if (ret != QSPI_STATUS_OK) {
return sError;
} else if ((curr_time - start) >= time_us) {
return sTimeout;
}
return sUnknown;
}
static uint8_t twi_byte_write(NRF_TWI_Type *twi, uint8_t data)
{
uint32_t t0;
nrf_twi_event_clear(twi, NRF_TWI_EVENT_TXDSENT);
nrf_twi_event_clear(twi, NRF_TWI_EVENT_ERROR);
nrf_twi_txd_set(twi, data);
t0 = ticker_read(get_us_ticker_data());
do {
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_TXDSENT)) {
nrf_twi_event_clear(twi, NRF_TWI_EVENT_TXDSENT);
return 1; // ACK received
}
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_ERROR)) {
nrf_twi_event_clear(twi, NRF_TWI_EVENT_ERROR);
return 0; // some error occurred
}
} while (((uint32_t)ticker_read(get_us_ticker_data()) - t0) < I2C_TIMEOUT_VALUE_US);
return 2; // timeout;
}
void Timer::reset() {
_start = ticker_read(_ticker_data);
_time = 0;
}
void Timer::start() {
if (!_running) {
_start = ticker_read(_ticker_data);
_running = 1;
}
}
int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop)
{
twi_info_t *twi_info = TWI_INFO(obj);
bool timeout = false;
uint32_t t0, t1;
#if DEVICE_I2C_ASYNCH
if (twi_info->active) {
return I2C_ERROR_BUS_BUSY;
}
#endif
twi_info->start_twi = false;
NRF_TWI_Type *twi = m_twi_instances[TWI_IDX(obj)];
start_twi_write(twi, address);
// Special case - transaction with no data.
// It can be used to check if a slave acknowledges the address.
if (length == 0) {
nrf_twi_event_t event;
if (stop) {
event = NRF_TWI_EVENT_STOPPED;
nrf_twi_task_trigger(twi, NRF_TWI_TASK_STOP);
} else {
event = NRF_TWI_EVENT_SUSPENDED;
nrf_twi_event_clear(twi, event);
nrf_twi_task_trigger(twi, NRF_TWI_TASK_SUSPEND);
}
t0 = ticker_read(get_us_ticker_data());
do {
if (nrf_twi_event_check(twi, event)) {
break;
}
t1 = ticker_read(get_us_ticker_data());
timeout = (t1 - t0) >= I2C_TIMEOUT_VALUE_US;
} while (!timeout);
uint32_t errorsrc = nrf_twi_errorsrc_get_and_clear(twi);
if (errorsrc & NRF_TWI_ERROR_ADDRESS_NACK) {
if (!stop) {
i2c_stop(obj);
}
return I2C_ERROR_NO_SLAVE;
}
return (timeout ? I2C_ERROR_BUS_BUSY : 0);
}
int result = length;
do {
uint8_t byte_write_result = twi_byte_write(twi, (uint8_t)*data++);
if (byte_write_result != 1) {
if (byte_write_result == 0) {
// Check what kind of error has been signaled by TWI.
uint32_t errorsrc = nrf_twi_errorsrc_get_and_clear(twi);
if (errorsrc & NRF_TWI_ERROR_ADDRESS_NACK) {
result = I2C_ERROR_NO_SLAVE;
} else {
// Some other error - return the number of bytes that
// have been sent successfully.
result -= length;
}
} else {
result = I2C_ERROR_BUS_BUSY;
}
// Force STOP condition.
stop = 1;
break;
}
--length;
} while (length > 0);
if (stop) {
(void)i2c_stop(obj);
}
return result;
}
void Ticker::setup(timestamp_t t) {
remove();
_delay = t;
insert(_delay + ticker_read(_ticker_data));
}
void wait_us(int us) {
const ticker_data_t *const ticker = get_us_ticker_data();
uint32_t start = ticker_read(ticker);
while ((ticker_read(ticker) - start) < (uint32_t)us);
}
