/**@brief Handler for SPI0 master events.
*
* @param[in] event SPI master event.
*/
void spi_master_0_event_handler(nrf_drv_spi_evt_type_t* event)
{
// uint32_t err_code = NRF_SUCCESS;
// uint32_t c_buff; // Temporarily store the buffer index of the buffer ready to be compressed
switch (*event)
{
// Transfer complete; store in buffer.
case NRF_DRV_SPI_EVENT_DONE:
nrf_drv_spi_uninit(&m_spi_master_0);
if (buffer_in(&db, &m_rx_data_spi[0]) == BUFFER_FULL) {
if (buffer_compress(db.buffer, db.item_cnt, transmission_buffer) != BUFFER_SUCCESS) {
// buffer_reset(&db);
printf("Error compressing data!\n");
}
intan_convert_channel++;
intan_convert_channel = intan_convert_channel % 32;
}
m_transfer_completed = true;
break;
default:
// No implementation needed.
break;
}
}
void spi_free(spi_t *obj)
{
spi_info_t *p_spi_info = SPI_INFO(obj);
if (p_spi_info->master) {
nrf_drv_spi_uninit(MASTER_INST(obj));
}
else {
nrf_drv_spis_uninit(SLAVE_INST(obj));
}
p_spi_info->initialized = false;
}
void spi_frequency(spi_t *obj, int hz)
{
spi_info_t *p_spi_info = SPI_INFO(obj);
nrf_drv_spi_frequency_t new_frequency = freq_translate(hz);
if (p_spi_info->master)
{
if (p_spi_info->frequency != new_frequency) {
p_spi_info->frequency = new_frequency;
nrf_drv_spi_config_t config;
prepare_master_config(&config, p_spi_info);
nrf_drv_spi_t const *p_spi = MASTER_INST(obj);
nrf_drv_spi_uninit(p_spi);
(void)nrf_drv_spi_init(p_spi, &config,
m_master_event_handlers[SPI_IDX(obj)]);
}
}
// There is no need to set anything in slaves when it comes to frequency,
// since slaves just synchronize with the clock provided by a master.
}
void spi_format(spi_t *obj, int bits, int mode, int slave)
{
if (bits != 8) {
error("Only 8-bits SPI is supported\r\n");
}
if (mode > 3) {
error("SPI format error\r\n");
}
spi_info_t *p_spi_info = SPI_INFO(obj);
if (slave)
{
nrf_drv_spis_mode_t spi_modes[4] = {
NRF_DRV_SPIS_MODE_0,
NRF_DRV_SPIS_MODE_1,
NRF_DRV_SPIS_MODE_2,
NRF_DRV_SPIS_MODE_3,
};
nrf_drv_spis_mode_t new_mode = spi_modes[mode];
// If the peripheral is currently working as a master, the SDK driver
// it uses needs to be switched from SPI to SPIS.
if (p_spi_info->master) {
nrf_drv_spi_uninit(MASTER_INST(obj));
}
// I the SPI mode has to be changed, the SDK's SPIS driver needs to be
// re-initialized (there is no other way to change its configuration).
else if (p_spi_info->spi_mode != (uint8_t)new_mode) {
nrf_drv_spis_uninit(SLAVE_INST(obj));
}
else {
return;
}
p_spi_info->spi_mode = (uint8_t)new_mode;
p_spi_info->master = false;
p_spi_info->flag.readable = false;
// Initialize SDK's SPIS driver with the new configuration.
nrf_drv_spis_config_t config;
prepare_slave_config(&config, p_spi_info);
(void)nrf_drv_spis_init(SLAVE_INST(obj), &config,
m_slave_event_handlers[SPI_IDX(obj)]);
// Prepare the slave for transfer.
p_spi_info->tx_buf = NRF_DRV_SPIS_DEFAULT_ORC;
nrf_drv_spis_buffers_set(SLAVE_INST(obj),
(uint8_t const *)&p_spi_info->tx_buf, 1,
(uint8_t *)&p_spi_info->rx_buf, 1);
}
else // master
{
nrf_drv_spi_mode_t spi_modes[4] = {
NRF_DRV_SPI_MODE_0,
NRF_DRV_SPI_MODE_1,
NRF_DRV_SPI_MODE_2,
NRF_DRV_SPI_MODE_3,
};
nrf_drv_spi_mode_t new_mode = spi_modes[mode];
// If the peripheral is currently working as a slave, the SDK driver
// it uses needs to be switched from SPIS to SPI.
if (!p_spi_info->master) {
nrf_drv_spis_uninit(SLAVE_INST(obj));
}
// I the SPI mode has to be changed, the SDK's SPI driver needs to be
// re-initialized (there is no other way to change its configuration).
else if (p_spi_info->spi_mode != (uint8_t)new_mode) {
nrf_drv_spi_uninit(MASTER_INST(obj));
}
else {
return;
}
p_spi_info->spi_mode = (uint8_t)new_mode;
p_spi_info->master = true;
p_spi_info->flag.busy = false;
// Initialize SDK's SPI driver with the new configuration.
nrf_drv_spi_config_t config;
prepare_master_config(&config, p_spi_info);
(void)nrf_drv_spi_init(MASTER_INST(obj), &config,
m_master_event_handlers[SPI_IDX(obj)]);
}
}
static void st7735_uninit(void)
{
nrf_drv_spi_uninit(&spi);
}
/**@brief Handler for SPI0 company Intan read events.
*
* @param[in] event SPI master event.
*/
void spi_intan_id_read_handler(nrf_drv_spi_evt_type_t* event)
{
uint32_t err_code = NRF_SUCCESS;
//uint32_t c_buff; // Temporarily store the buffer index of the buffer ready to be compressed
switch (*event)
{
//while(app_uart_put(73) != NRF_SUCCESS);
// Transfer complete; store in buffer.
case NRF_DRV_SPI_EVENT_DONE:
nrf_drv_spi_uninit(&m_spi_master_0);
printf("%c\r\n",m_rx_data_spi[1]);
// Transfer done after this point
m_transfer_completed = true;
//printf("Data received\r\n");
//while(app_uart_put(69) != NRF_SUCCESS);
//printf("%d\r\n", ++counter);
//err_code = bsp_indication_set(BSP_INDICATE_RCV_OK);
//APP_ERROR_CHECK(err_code);*/
// All buffers are in use; The just acquired data will be lost.
/*if(buffers_ready[active_buffer])
{
while(app_uart_put(70) != NRF_SUCCESS);
//while(app_uart_put(70) != NRF_SUCCESS);
//printf("All buffers in use. Data lost\r\n");
}
// Still have space to store data.
else
{
// Current buffer still has space
if(ab_capacity > 0)
{
*(data_buffers[active_buffer] + DATA_BUF_SIZE - ab_capacity) = m_rx_data_spi[0];
// Buffer is filled after this storage. Set the next buffer as active. Call compression, if compression is not in progress.
if(--ab_capacity == 0)
{
buffers_ready[active_buffer] = true;
ab_capacity = DATA_BUF_SIZE;
if(active_buffer == NUM_DATA_BUFFERS - 1)
{
active_buffer = 0;
}
else
{
active_buffer++;
}
// Compress
//if(!compression_in_progress)
//{
//printf("Compressing\r\n");
//while(app_uart_put(73) != NRF_SUCCESS);
//compression_in_progress = true;
//err_code = app_timer_start(comp_timer, 5, &c_buff);
//while(app_uart_put(74) != NRF_SUCCESS);
//printf("%d\r\n", err_code);
//while(1);
//APP_ERROR_CHECK(err_code);
//while(app_uart_put(75) != NRF_SUCCESS);
//compress(c_buff, DATA_BUF_SIZE);
//printf("Compress is done\r\n");
//while(app_uart_put(71) != NRF_SUCCESS);
//}
}
}
}
// If not all channels have been sampled, continue sampling from the other channels.
if(intan_convert_channel == NUM_CHANNELS)
{
intan_convert_channel = 0;
}
else
{
sample_data();
}*/
break;
default:
// No implementation needed.
break;
}
}
static void ili9341_uninit(void)
{
nrf_drv_spi_uninit(&spi);
}
