static uint16_t SpiBcAccess(uint8_t addr, uint8_t rw, uint16_t data)
{
uint16_t tmp;
/* Enable CS */
GPIO_PinOutClear(BSP_PORT_SPI_CS, BSP_PIN_SPI_CS);
/* Write SPI address MSB */
USART_Tx(BSP_SPI_USART_USED, (addr & 0x3) | rw << 3);
/* Just ignore data read back */
USART_Rx(BSP_SPI_USART_USED);
/* Write SPI address LSB */
USART_Tx(BSP_SPI_USART_USED, data & 0xFF);
tmp = (uint16_t) USART_Rx(BSP_SPI_USART_USED);
/* SPI data MSB */
USART_Tx(BSP_SPI_USART_USED, data >> 8);
tmp |= (uint16_t) USART_Rx(BSP_SPI_USART_USED) << 8;
/* Disable CS */
GPIO_PinOutSet(BSP_PORT_SPI_CS, BSP_PIN_SPI_CS);
return tmp;
}
/*
* Access multiple registers
*/
uint8_t CC1101_Radio::multi_register_access( uint8_t address, uint8_t access_mode, uint8_t* data, uint8_t length )
{
uint8_t reg;
uint8_t status;
uint8_t count;
GPIO_PinOutClear( _CC1101_SPI_CS_PIN );
USART_Tx( _CC1101_USART, address | access_mode );
status = USART_Rx( _CC1101_USART );
for ( count = 0; count < length; count++ )
{
if ( ( access_mode == CC1101_READ_SINGLE ) || ( access_mode == CC1101_READ_BURST ) )
{
USART_Tx( _CC1101_USART, CC1101_SNOP );
reg = USART_Rx( _CC1101_USART );
data[count] = ( uint8_t )reg;
}
else
{
USART_Tx( _CC1101_USART, data[count] );
status = USART_Rx( _CC1101_USART );
}
}
GPIO_PinOutSet( _CC1101_SPI_CS_PIN );
return status;
}
void NRF_ReceivePayload(uint8_t cmd, uint8_t bytes, uint8_t *buf)
{
NRF_CSN_lo;
NRF_USART->CMD = USART_CMD_CLEARRX;
USART_Tx(NRF_USART, cmd);
USART_Rx(NRF_USART);
for (int i = 0; i < bytes; i++) {
USART_Tx(NRF_USART, 0xFF);
buf[i] = USART_Rx(NRF_USART);
}
//while(!(NRF_USART->STATUS & USART_STATUS_TXC)) ;
NRF_CSN_hi;
}
/*
* SPI register access
*/
uint8_t CC1101_Radio::register_access_SPI( uint8_t address, uint8_t access_mode, uint8_t data )
{
uint8_t reg = 0;
GPIO_PinOutClear( _CC1101_SPI_CS_PIN );
USART_Tx( _CC1101_USART, address | access_mode ); // write the address byte
USART_Rx( _CC1101_USART ); // read reply
USART_Tx( _CC1101_USART, data ); // write the data byte(s)
reg = USART_Rx( _CC1101_USART ); // read and save the reply
GPIO_PinOutSet( _CC1101_SPI_CS_PIN );
return reg;
}
uint8_t NRF_ReadByte(uint8_t cmd)
{
volatile uint8_t blah;
NRF_CSN_lo;
while((NRF_USART->STATUS & USART_STATUS_RXDATAV)) {
blah = NRF_USART->RXDATA;
}
while(!(NRF_USART->STATUS & USART_STATUS_TXBL));
NRF_USART->TXDATA = cmd;
while(!(NRF_USART->STATUS & USART_STATUS_TXC));
USART_Rx(NRF_USART);
NRF_USART->TXDATA = 0x00;
while (!(NRF_USART->STATUS & USART_STATUS_TXC)) ;
NRF_CSN_hi;
return USART_Rx(NRF_USART);
}
void NRF_SendCommand(uint8_t cmd, uint8_t data)
{
NRF_CSN_lo;
while(!(NRF_USART->STATUS & USART_STATUS_TXBL));
NRF_USART->TXDATA = cmd;
while(!(NRF_USART->STATUS & USART_STATUS_TXC));
USART_Rx(NRF_USART);
NRF_USART->TXDATA = data;
while (!(NRF_USART->STATUS & USART_STATUS_TXC)) ;
NRF_CSN_hi;
}
/*
* Send a strobe command
*/
uint8_t CC1101_Radio::strobe( uint8_t l_strobe )
{
uint8_t reg = 0;
GPIO_PinOutClear( _CC1101_SPI_CS_PIN );
USART_Tx( _CC1101_USART, l_strobe ); // Write strobe command
reg = USART_Rx( _CC1101_USART ); // Read reply
GPIO_PinOutSet( _CC1101_SPI_CS_PIN );
return reg;
}
static int uart_gecko_poll_in(struct device *dev, unsigned char *c)
{
const struct uart_gecko_config *config = dev->config->config_info;
u32_t flags = USART_StatusGet(config->base);
if (flags & USART_STATUS_RXDATAV) {
*c = USART_Rx(config->base);
return 0;
}
return -1;
}
/**************************************************************************//**
* @brief SPI_TFT_Write Write registers/data to SSD2119 controller
* @param reg
* Register to write to
* @param data
* 16-bit data to write into register
* @note
* It's not possible to read back register value through SSD2119 SPI
* interface, so no SPI_TFT_ReadRegister function is implemented
*****************************************************************************/
void SPI_TFT_WriteRegister(uint8_t reg, uint16_t data)
{
/* Enable chip select */
GPIO_PinOutClear(gpioPortD, 3);
/* Select register first */
USART1->CTRL = USART1->CTRL & ~USART_CTRL_BIT8DV;
USART_Tx(USART1, reg & 0xFF);
USART_Rx(USART1);
/* Write data */
USART1->CTRL = USART1->CTRL | USART_CTRL_BIT8DV;
USART_Tx(USART1, (data & 0xff00) >> 8);
USART_Rx(USART1);
USART_Tx(USART1, (data & 0x00ff));
USART_Rx(USART1);
/* Clear chip select */
GPIO_PinOutSet(gpioPortD, 3);
}
void UART_1_RX_ISR(void)
{
/* Check for RX data valid interrupt */
if(UART_1_DEV->STATUS & UART_STATUS_RXDATAV) {
/* Copy data into RX Buffer */
uint8_t rxData = USART_Rx(UART_1_DEV);
irq_read(UART_1, rxData);
}
if(sched_context_switch_request) {
thread_yield();
}
}
uint8_t NRF_Status(void)
{
volatile uint8_t blah;
NRF_CSN_lo;
while((NRF_USART->STATUS & USART_STATUS_RXDATAV)) {
blah = NRF_USART->RXDATA;
}
while(!(NRF_USART->STATUS & USART_STATUS_TXBL));
NRF_USART->TXDATA = 0xFF;
while (!(NRF_USART->STATUS & USART_STATUS_TXC)) ;
NRF_CSN_hi;
return USART_Rx(NRF_USART);
}
uint8_t rcvr_spi(void)
{
int i;
//while (!(USART1->STATUS & USART_STATUS_TXBL)) ;
//USART1->CMD = USART_CMD_CLEARRX | USART_CMD_CLEARTX;
USART0->CTRL &= ~_USART_CTRL_TXBIL_MASK;
USART0->CTRL |= USART_CTRL_TXBIL_HALFFULL;
for (i = 0; i < 8; i++) {
while(!(USART0->STATUS & USART_STATUS_TXBL)) ;
USART0->TXDATA = 0x07;
}
while (!(USART0->STATUS & USART_STATUS_TXC)) ;
return USART_Rx(USART0);
}
/**************************************************************************//**
* @brief UART/LEUART IRQ Handler
*****************************************************************************/
void UART1_RX_IRQHandler(void)
{
if (UART1->STATUS & USART_STATUS_RXDATAV)
{
/* Store Data */
rxBuffer[rxWriteIndex] = USART_Rx(UART1);
rxWriteIndex++;
rxCount++;
if (rxWriteIndex == RXBUFSIZE)
{
rxWriteIndex = 0;
}
/* Check for overflow - flush buffer */
if (rxCount > RXBUFSIZE)
{
rxWriteIndex = 0;
rxCount = 0;
rxReadIndex = 0;
}
}
}
//USART2_TX_IRQHandler
void USART2_RX_IRQHandler(void)
{
unsigned char c;
ENERGEST_ON(ENERGEST_TYPE_IRQ);
if(USART2->STATUS & USART_STATUS_RXDATAV)
{
c = USART_Rx(USART2);
if(usart2_input_handler != NULL) usart2_input_handler(c);
}
/*
else
{
PRINTF("ERROR: control reg = 0x%lX", (SI32_USART_0->CONTROL.U32 & 0x7));
// Disable all errors
SI32_USART_0->CONTROL_CLR = 0x07;
}
*/
ENERGEST_OFF(ENERGEST_TYPE_IRQ);
}
/**************************************************************************//**
* @brief USART1 RX IRQ Handler
*
* Set up the interrupt prior to use
*
* Note that this function handles overflows in a very simple way.
*
*****************************************************************************/
void USART1_RX_IRQHandler(void)
{
/* Check for RX data valid interrupt */
if (uart->STATUS & USART_STATUS_RXDATAV)
{
/* Copy data into RX Buffer */
uint8_t rxData = USART_Rx(uart);
rxBuf.data[rxBuf.wrI] = rxData;
rxBuf.wrI = (rxBuf.wrI + 1) % BUFFERSIZE;
rxBuf.pendingBytes++;
/* Flag Rx overflow */
if (rxBuf.pendingBytes > BUFFERSIZE)
{
rxBuf.overflow = true;
}
/* Clear RXDATAV interrupt */
USART_IntClear(USART1, USART_IF_RXDATAV);
}
}
/**
* Writes a byte to the ENC28J60 through SPI.
* The chip must be selected prior to this write.
* @param data the 8-bit data byte to write.
*/
void enc28j60_spi_write(uint8_t data)
{
USART_Tx(USART0, data);
USART_Rx(USART0);
}
/**
* Explicitly read a byte from the ENC28J60 by first sending the dummy byte
* 0x00.
* The chip must be selected prior to this write.
* @return the data read.
*/
uint8_t enc28j60_spi_read(void)
{
USART_Tx(USART0, 0);
return USART_Rx(USART0);
}
