/*====================================================================================================*/
void SPI_RW( nrf_drv_kspi_t *SPIx, uint8_t *writeData, uint8_t writeLens, uint8_t *readData, uint8_t readLens )
{
SPIx->flag = false;
nrf_drv_spi_transfer(&(SPIx->instance), writeData, writeLens, readData, readLens);
while(!SPIx->flag)
__WFE();
}
/**
* @brief Function for requesting the SPI transaction.
*
* The SPI bus must be initialized prior to use of this function.
*
* @param[in] p_txb Pointer to the TX buffer.
* @param[in] tx_len TX buffer length.
* @param[out] p_rxb Pointer to the RX buffer.
* @param[in] tx_len RX buffer length.
*/
__STATIC_INLINE void sdc_spi_transfer(uint8_t const * const p_txb,
uint8_t tx_len,
uint8_t * const p_rxb,
uint8_t rx_len)
{
SDC_CS_ASSERT();
ret_code_t err_code = nrf_drv_spi_transfer(&m_spi, p_txb, tx_len, p_rxb, rx_len);
APP_ERROR_CHECK(err_code);
}
/**@brief Functions prepares buffers and starts data transfer.
*
* @param[in] p_tx_data A pointer to a buffer TX.
* @param[in] p_rx_data A pointer to a buffer RX.
* @param[in] tx_len A length of the tx data buffers.
* @param[in] rx_len A length of the rx data buffers.
*/
uint32_t spi_send_recv(uint8_t * const p_tx_data,
uint8_t * const p_rx_data,
const uint16_t tx_len,
const uint16_t rx_len)
{
// Start transfer.
uint32_t err_code = nrf_drv_spi_transfer(&m_spi_master,
p_tx_data, tx_len, p_rx_data, rx_len);
APP_ERROR_CHECK(err_code);
nrf_delay_ms(DELAY_MS);
return err_code;
}
/**@brief Functions prepares buffers and starts data transfer.
*
* @param[in] p_tx_data A pointer to a buffer TX.
* @param[in] p_rx_data A pointer to a buffer RX.
* @param[in] len A length of the data buffers.
*/
static void spi_send_recv(uint8_t * const p_tx_data,
uint8_t * const p_rx_data,
const uint16_t len)
{
// Initalize buffers.
init_buffers(p_tx_data, p_rx_data, len);
// Start transfer.
uint32_t err_code = nrf_drv_spi_transfer(&m_spi_master,
p_tx_data, len, p_rx_data, len);
APP_ERROR_CHECK(err_code);
nrf_delay_ms(DELAY_MS);
}
/**@brief Functions prepares buffers and starts data transfer.
*
* @param[in] p_tx_data A pointer to a buffer TX.
* @param[in] p_rx_data A pointer to a buffer RX.
* @param[in] len A length of the data buffers.
*/
static void spi_send_recv(uint8_t * const p_tx_data,
uint8_t * const p_rx_data,
const uint16_t len)
{
// Initalize buffers.
// init_buffers(p_tx_data, p_rx_data, len); //comment this out since I want to read a register
// Start transfer.
uint32_t err_code = nrf_drv_spi_transfer(&m_spi_master,
p_tx_data, len, p_rx_data, len);
APP_ERROR_CHECK(err_code);
nrf_delay_ms(100); //not having this delay allows the function to return at least once
}
/**
* @brief TxPacket : transmit TX address and payload data
* @param none
*/
void TxPacket(void)
{
uint32_t err_code;
/* transmiting address */
unsigned char txAddr[5]={
0x22,0xcc,0xcc,0xcc,0xcc,
};
/* transmit Payload data */
unsigned char txBuf[4];
txBuf[0] = 0x20;
txBuf[1] = 'R';
txBuf[2] = 'F';
nrf_gpio_pin_clear(CSN);
/* Write payload data */
err_code = nrf_drv_spi_transfer(&spi, txBuf, 4, NULL, 0);
APP_ERROR_CHECK(err_code);
nrf_gpio_pin_set(CSN);
nrf_delay_ms(10);
/* Spi enable for write a spi command */
nrf_gpio_pin_clear(CSN);
/* Write 4 bytes address */
err_code = nrf_drv_spi_transfer(&spi, txAddr, 5, NULL, 0);
APP_ERROR_CHECK(err_code);
/* Spi disable */
nrf_gpio_pin_set(CSN);
/* Set TRX_CE high,start Tx data transmission, CE pulse */
nrf_gpio_pin_set(TRX_CE);
nrf_delay_ms(10);
nrf_gpio_pin_clear(TRX_CE);
}
/**
* @brief read_config : send read configuration (RC) command.
* @param none
*/
void read_config(void)
{
unsigned char txCmd[1];
unsigned char data[11];
nrf_gpio_pin_clear(CSN);
txCmd[0] = RC;
/* send read configuration command */
uint32_t err_code = nrf_drv_spi_transfer(&spi, txCmd, 1, data, 11);
APP_ERROR_CHECK(err_code);
nrf_gpio_pin_set(CSN); /* Disable Spi */
}
/**@brief Function for initializing a SPI master driver.
*
* @param[in] p_instance Pointer to SPI master driver instance.
* @param[in] lsb Bits order LSB if true, MSB if false.
*/
static void spi_master_init(nrf_drv_spi_t const * p_instance, bool lsb)
{
uint32_t err_code = NRF_SUCCESS;
nrf_drv_spi_config_t config =
{
.irq_priority = APP_IRQ_PRIORITY_LOW,
.orc = 0xCC,
.frequency = NRF_DRV_SPI_FREQ_8M, // originally NRF_DRV_SPI_FREQ_1M
.mode = NRF_DRV_SPI_MODE_0,
.bit_order = (lsb ? //if lsb then LSB_FIRRST, else MSB_FIRST
NRF_DRV_SPI_BIT_ORDER_LSB_FIRST : NRF_DRV_SPI_BIT_ORDER_MSB_FIRST),
};
if (p_instance == &m_spi_master_0)
{
config.sck_pin = SPIM0_SCK_PIN;
config.mosi_pin = SPIM0_MOSI_PIN;
config.miso_pin = SPIM0_MISO_PIN; // SS not initialized
config.ss_pin = SPIM0_SS_PIN;
err_code = nrf_drv_spi_init(p_instance, &config,
//spi_intan_id_read_handler); // EDIT: INTAN ID spi handler
spi_master_0_event_handler); // EDIT: data collection spi handler
}
APP_ERROR_CHECK(err_code);
}
/**@brief Function for sending and receiving data.
*
* @param[in] p_instance Pointer to SPI master driver instance.
* @param[in] p_tx_data A pointer to a buffer TX.
* @param[out] p_rx_data A pointer to a buffer RX.
* @param[in] len A length of the data buffers.
*/
static void spi_send_recv(nrf_drv_spi_t const * p_instance,
uint8_t * p_tx_data,
uint8_t * p_rx_data,
uint16_t tx_len,
uint16_t rx_len)
{
uint32_t err_code = nrf_drv_spi_transfer(p_instance,
p_tx_data, tx_len, p_rx_data, rx_len);
//APP_ERROR_CHECK(err_code);
}
void spi_master_transfer(spi_t *obj,
const void *tx, size_t tx_length,
void *rx, size_t rx_length, uint8_t bit_width,
uint32_t handler, uint32_t event, DMAUsage hint)
{
spi_info_t *p_spi_info = SPI_INFO(obj);
MBED_ASSERT(p_spi_info->master);
(void)hint;
(void)bit_width;
p_spi_info->handler = handler;
p_spi_info->event = event;
p_spi_info->flag.busy = true;
(void)nrf_drv_spi_transfer(MASTER_INST(obj),
(uint8_t const *)tx, tx_length,
(uint8_t *)rx, rx_length);
}
int spi_master_write(spi_t *obj, int value)
{
spi_info_t *p_spi_info = SPI_INFO(obj);
#if DEVICE_SPI_ASYNCH
while (p_spi_info->flag.busy) {
}
#endif
p_spi_info->tx_buf = value;
p_spi_info->flag.busy = true;
(void)nrf_drv_spi_transfer(MASTER_INST(obj),
(uint8_t const *)&p_spi_info->tx_buf, 1,
(uint8_t *)&p_spi_info->rx_buf, 1);
while (p_spi_info->flag.busy) {
}
return p_spi_info->rx_buf;
}
/**@brief Functions prepares buffers and starts data transfer.
*
* @param[in] p_tx_data A pointer to a buffer TX.
* @param[in] p_rx_data A pointer to a buffer RX.
* @param[in] len A length of the data buffers.
*/
static void spi_send_recv(uint8_t * const p_tx_data,
uint8_t * const p_rx_data,
const uint16_t len)
{
// Initalize buffers.
init_buffers(p_tx_data, p_rx_data, len);
// Start transfer.
uint32_t err_code = nrf_drv_spi_transfer(&m_spi_master,
p_tx_data, len, p_rx_data, len);
//m_tx_data
//SEGGER_RTT_printf(0, "\nSent: %s\n", p_tx_data);
//SEGGER_RTT_printf(0, "\nRecieved: %s\n", p_rx_data);
APP_ERROR_CHECK(err_code);
//nrf_delay_us(10);
}
/**
* @brief RxPacket : receive payload data
* @param none
*/
void RxPacket(void)
{
unsigned char rxBuffer[3] = "";
unsigned char txBuf[1];
nrf_delay_ms(100);
nrf_gpio_pin_clear(TRX_CE);
nrf_gpio_pin_clear(CSN);
nrf_delay_ms(1);
txBuf[0] = RRP;
uint32_t err_code = nrf_drv_spi_transfer(&spi, txBuf, 1, rxBuffer, 3);
APP_ERROR_CHECK(err_code);
nrf_gpio_pin_set(CSN);
nrf_delay_ms(10);
nrf_gpio_pin_set(TRX_CE);
}
/**
* @brief Write_Config : send write configuration (WC) command and data.
* @param none
*/
void Write_Config(void)
{
uint32_t err_code;
unsigned char config_data[11]={
0x00,
0x6A, //CH_NO,433MHZ
0x0c, //output power 10db, resend disable, Current Normal operation
0x44, //4-byte address
0x03,0x03, //receive or send data length 32 bytes
0xcc,0xcc,0xcc,0xcc, //receiving address
0x58, //CRC enable,8bit CRC,external clock disable,16MHZ Oscillator
};
/* Spi enable for write a spi command */
nrf_gpio_pin_clear(CSN);
err_code = nrf_drv_spi_transfer(&spi, config_data, 11, NULL, 0);
APP_ERROR_CHECK(err_code);
nrf_gpio_pin_set(CSN); /* Disable Spi */
}
static inline void spi_write(const void * data, size_t size)
{
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, data, size, NULL, 0));
}