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;
}
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;
}
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 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);
}
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;
}
Timer::Timer() : _running(), _start(), _time(), _ticker_data(get_us_ticker_data()) {
reset();
}
Timer::Timer() : _running(), _start(), _time(), _ticker_data(get_us_ticker_data()), _lock_deepsleep(true) {
reset();
}
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 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);
}
#include "mbed_helpers.h"
#include "llos_system_timer.h"
#include "llos_memory.h"
//--//
extern "C"
{
typedef struct LLOS_MbedTimer
{
LLOS_Context Context;
ticker_event_t TickerEvent;
} LLOS_MbedTimer;
static LLOS_SYSTEM_TIMER_Callback s_TimerCallback = NULL;
static const ticker_data_t *s_pTickerData = get_us_ticker_data();
// This is used to call back into the Kernel using a WellKnownMethod
static void MbedInterruptHandler(uint32_t id)
{
if (s_TimerCallback != NULL)
{
LLOS_MbedTimer *pCtx = (LLOS_MbedTimer*)id;
if (pCtx != NULL)
{
uint64_t ticks = us_ticker_read();
s_TimerCallback(pCtx->Context, ticks);
}
}
uint32_t HAL_GetTick()
{
return ticker_read_us(get_us_ticker_data()) / 1000; // 1 ms tick is required for ST HAL
}
