/**
* @brief Function for receiving and sending data from IRQ. (The same for both IRQs).
*/
static __INLINE void spi_master_send_recv_irq(volatile spi_master_instance_t * const p_spi_instance)
{
APP_ERROR_CHECK_BOOL(p_spi_instance != NULL);
p_spi_instance->bytes_count++;
if (!p_spi_instance->started_flag)
{
p_spi_instance->started_flag = true;
spi_master_signal_evt(p_spi_instance,
SPI_MASTER_EVT_TRANSFER_STARTED,
p_spi_instance->bytes_count);
}
uint8_t rx_byte = p_spi_instance->p_nrf_spi->RXD;
uint8_t * p_rx_buffer = p_spi_instance->p_rx_buffer;
uint16_t rx_length = p_spi_instance->rx_length;
uint16_t rx_index = p_spi_instance->rx_index;
if ((p_rx_buffer != NULL) && (rx_index < rx_length))
{
p_rx_buffer[p_spi_instance->rx_index++] = rx_byte;
}
uint8_t * p_tx_buffer = p_spi_instance->p_tx_buffer;
uint16_t tx_length = p_spi_instance->tx_length;
uint16_t tx_index = p_spi_instance->tx_index;
uint16_t max_length = p_spi_instance->max_length;
if (tx_index < max_length)
{
p_spi_instance->p_nrf_spi->TXD = ((p_tx_buffer != NULL) && (tx_index < tx_length)) ?
p_tx_buffer[tx_index] : SPI_DEFAULT_TX_BYTE;
(p_spi_instance->tx_index)++;
}
if (p_spi_instance->bytes_count >= max_length)
{
nrf_gpio_pin_set(p_spi_instance->pin_slave_select);
uint16_t transmited_bytes = p_spi_instance->tx_index;
spi_master_buffer_release(&(p_spi_instance->p_tx_buffer), &(p_spi_instance->tx_length));
spi_master_buffer_release(&(p_spi_instance->p_rx_buffer), &(p_spi_instance->rx_length));
p_spi_instance->state = SPI_MASTER_STATE_IDLE;
spi_master_signal_evt(p_spi_instance, SPI_MASTER_EVT_TRANSFER_COMPLETED, transmited_bytes);
}
}
/**@brief Function for receiving and sending data from IRQ. (The same for both IRQs). */
static __INLINE void spi_master_send_recv_irq(spi_master_instance_t * const p_spi_instance)
{
uint8_t rx_byte;
APP_ERROR_CHECK_BOOL(p_spi_instance != NULL);
APP_ERROR_CHECK_BOOL(p_spi_instance->state == SPI_MASTER_STATE_BUSY);
p_spi_instance->bytes_count++;
rx_byte = p_spi_instance->p_nrf_spi->RXD;
if (p_spi_instance->start_flag)
{
p_spi_instance->start_flag = false;
spi_master_signal_evt(p_spi_instance, SPI_MASTER_EVT_FIRST_BYTE_RECEIVED, (uint16_t)rx_byte);
}
else if (p_spi_instance->abort_flag ) //this is tricky, but callback for SPI_MASTER_EVT_FIRST_BYTE_RECEIVED will set this flag for a first byte, which is bad because there is still byte in a buffer
{ //and for a single byte transaction you will get XFERDONE event to restart
p_spi_instance->abort_flag = false;
p_spi_instance->state = SPI_MASTER_STATE_ABORTED;
nrf_gpio_pin_set(p_spi_instance->pin_slave_select);
spi_master_signal_evt(p_spi_instance, SPI_MASTER_EVT_TRANSFER_ABORTED, 0);
return;
}
if ((p_spi_instance->p_rx_buffer != NULL) &&
(p_spi_instance->rx_index < p_spi_instance->rx_length))
{
p_spi_instance->p_rx_buffer[p_spi_instance->rx_index++] = rx_byte;
}
if ((p_spi_instance->tx_index < p_spi_instance->max_length) && (!(p_spi_instance->abort_flag))) //do not TX if you know that there is an abort to be done - this should work for a DOUBLE BUFFERING ???
{
p_spi_instance->p_nrf_spi->TXD = ((p_spi_instance->p_tx_buffer != NULL) &&
(p_spi_instance->tx_index < p_spi_instance->tx_length)) ?
p_spi_instance->p_tx_buffer[p_spi_instance->tx_index] :
SPI_DEFAULT_TX_BYTE;
(p_spi_instance->tx_index)++;
}
if (p_spi_instance->bytes_count >= p_spi_instance->max_length)
{
APP_ERROR_CHECK_BOOL(p_spi_instance->bytes_count == p_spi_instance->max_length);
nrf_gpio_pin_set(p_spi_instance->pin_slave_select);
p_spi_instance->state = SPI_MASTER_STATE_IDLE;
spi_master_signal_evt(p_spi_instance,
SPI_MASTER_EVT_TRANSFER_COMPLETED,
p_spi_instance->tx_index);
}
return;
}
/**
* @brief Function for transmitting data between SPI master and SPI slave.
*/
uint32_t spi_master_send_recv(const spi_master_hw_instance_t spi_master_hw_instance,
uint8_t * const p_tx_buf, const uint16_t tx_buf_len,
uint8_t * const p_rx_buf, const uint16_t rx_buf_len)
{
#if defined(SPI_MASTER_0_ENABLE) || defined(SPI_MASTER_1_ENABLE)
spi_master_instance_t * p_spi_instance = spi_master_get_instance(spi_master_hw_instance);
uint32_t err_code = NRF_SUCCESS;
uint16_t max_length = 0;
if (p_spi_instance->state == SPI_MASTER_STATE_IDLE)
{
NVIC_DisableIRQ(p_spi_instance->irq_type);
max_length = (rx_buf_len > tx_buf_len) ? rx_buf_len : tx_buf_len;
if (max_length > 0)
{
p_spi_instance->state = SPI_MASTER_STATE_BUSY;
p_spi_instance->start_flag = true; //abort_flag should set by abort and cleared only by restart
p_spi_instance->bytes_count = 0;
p_spi_instance->max_length = max_length;
spi_master_buffer_release(&(p_spi_instance->p_tx_buffer), &(p_spi_instance->tx_length));
spi_master_buffer_release(&(p_spi_instance->p_rx_buffer), &(p_spi_instance->rx_length));
/* Initialize buffers */
spi_master_buffer_init(p_tx_buf, tx_buf_len, &(p_spi_instance->p_tx_buffer),
&(p_spi_instance->tx_length), &(p_spi_instance->tx_index));
spi_master_buffer_init(p_rx_buf, rx_buf_len, &(p_spi_instance->p_rx_buffer),
&(p_spi_instance->rx_length), &(p_spi_instance->rx_index));
nrf_gpio_pin_clear(p_spi_instance->pin_slave_select);
spi_master_send_initial_bytes(p_spi_instance);
spi_master_signal_evt(p_spi_instance, SPI_MASTER_EVT_TRANSFER_STARTED, max_length);
}
else
{
err_code = NRF_ERROR_INVALID_PARAM;
}
NVIC_EnableIRQ(p_spi_instance->irq_type);
}
else
{
err_code = NRF_ERROR_BUSY;
}
return err_code;
#else
return NRF_ERROR_NOT_SUPPORTED;
#endif
}
/**
* @brief Function for restarting transfer
*/
uint32_t spi_master_restart(const spi_master_hw_instance_t spi_master_hw_instance)
{
spi_master_instance_t * p_spi_instance = spi_master_get_instance(spi_master_hw_instance);
NVIC_DisableIRQ(p_spi_instance->irq_type);
spi_master_signal_evt(p_spi_instance, SPI_MASTER_EVT_TRANSFER_RESTARTED, 0);
p_spi_instance->state = SPI_MASTER_STATE_BUSY;
p_spi_instance->bytes_count = 0;
p_spi_instance->tx_index = 0;
p_spi_instance->rx_index = 0;
p_spi_instance->start_flag = true;
p_spi_instance->abort_flag = false; //you should force clearing abort flag - no other way for 1 byte transfer
nrf_gpio_pin_clear(p_spi_instance->pin_slave_select);
spi_master_send_initial_bytes(p_spi_instance);
NVIC_EnableIRQ(p_spi_instance->irq_type);
return NRF_SUCCESS;
}
