/**
* Send an instruction to the nRF24L01.
* \param instruction The instruction to send (see the bottom of nRF24L01.h)
* \param data An array of argument data to the instruction. If len is 0, then this may be NULL.
* \param buffer An array for the instruction's return data. This can be NULL if the instruction has no output.
* \param len The length of the data and buffer arrays.
*/
static void send_instruction(uint8_t instruction, uint8_t* data, uint8_t* buffer, uint8_t len)
{
spi_select_device(&SPID, &spi_device_conf);
// send the instruction
spi_write_packet (&SPID, &instruction, 1);
// pass in args
if (len > 0)
{
if (buffer == NULL)
{
spi_write_packet (&SPID, data, len);
}
else
{
for (int i = 0; i < len; i++)
{
spi_write_packet (&SPID, &(data[i]), 1);
spi_read_packet (&SPID, &(buffer[i]), 1);
}
}
}
// resynch SPI
spi_deselect_device(&SPID, &spi_device_conf);
}
uint8_t* nrf24l01_read_array_register(uint8_t reg, uint8_t* readData, uint8_t dataLen)
{
spi_select_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf);
spi_write_single_packet(&CONF_NRF24L01_SPI, NRF24L01_R_REGISTER | (NRF24L01_REGISTER_MASK & reg));
spi_read_packet(&CONF_NRF24L01_SPI, readData, dataLen);
spi_deselect_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf);
return readData;
}
void Sram_Read_Packet(uint16_t tuAddress,uint8_t *tuDataBuffer,uint8_t tuSize)
{
SRAM_Select_Chip();
ProgramToSRAM(SRAM_READ_COMMAND);
SendAddress(tuAddress);
spi_read_packet(SRAM23Kxx_SPI,tuDataBuffer,tuSize);
SRAM_DeSelect_Chip();
}
void spi_polled(void)
{
cli();
uint8_t display = 0x88;
packet_t *packet = TM_newPacket();
if(!(packet))
{
LED_Toggle(LED5_GPIO);
sei();
return;
}
spi_select_device(SPI_USB, &SPI_DEVICE_USB);
uint8_t len = 0;
spi_write_packet(SPI_USB, &display, 1);
_delay_us(10);
spi_read_packet(SPI_USB, &(packet->len), 1);
_delay_us(10);
len= packet->len;
if(len == 0 || len >= 0x88)
{
spi_deselect_device(SPI_USB, &SPI_DEVICE_USB);
sei();
// alarm_new(5, "Received a SPI Packet with no Length");
LED_Toggle(LED4_GPIO);
TM_freePacket(packet);
return;
}
spi_read_packet(SPI_USB, &(packet->task), 1);
_delay_us(10);
spi_read_packet(SPI_USB, &(packet->subTask), 1);
packet->ptr = packet->buf;
_delay_us(10);
spi_read_packet(SPI_USB, packet->ptr, len);
sei();
packet->dir = from_device;
spi_deselect_device(SPI_USB, &SPI_DEVICE_USB);
}
// reg: 5 bit memory map address (LSB first)
uint8_t nrf24l01_read_register(uint8_t reg)
{
spi_select_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf);
spi_write_single_packet(&CONF_NRF24L01_SPI, NRF24L01_R_REGISTER | (NRF24L01_REGISTER_MASK & reg));
uint8_t readData;
spi_read_packet(&CONF_NRF24L01_SPI, &readData, 1);
spi_deselect_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf);
return readData;
}
/**
* \brief Receive a sequence of bytes from a SerialFlash.
*
* \param data Data buffer to read
* \param len Length of data
* \pre The SerialFlash should be selected first using at25dfx_spi_select_device
*/
status_code_t at25dfx_spi_read_packet(void const *data, size_t len)
{
#if defined( AT25DFX_USES_SPI_MASTER_SERVICE)
return spi_read_packet(AT25DFX_SPI_MODULE, (uint8_t*)data, len);
/* Implementation with USART in SPI mode service */
#elif defined(AT25DFX_USES_USART_SPI_SERVICE)
return usart_spi_read_packet(AT25DFX_SPI_MODULE, (uint8_t*)data, len);
#endif
}
/**
* \brief Read response on SPI from PC
*
* return Status
* \param[in] rx_buf Pointer to receive the data
* \param[in] length The length of the read data
* \param[out] rx_buf Pointer to store the received SPI character
*/
enum status_code adp_interface_read_response(uint8_t* rx_buf, uint16_t length)
{
enum status_code status;
/* Send SPI start condition */
adp_interface_send_start();
status = spi_read_packet(EDBG_SPI_MODULE, rx_buf, length);
/* Send SPI end condition */
adp_interface_send_stop();
return status;
}
/**
* Retrieve a register value from the radio.
* \param reg The register value defined in nRF24L01.h (e.g. CONFIG, EN_AA, &c.).
* \param buffer A contiguous memory block into which the register contents will be copied. If the buffer is too long for the
* register contents, then the remaining bytes will be overwritten with 0xFF.
* \param len The length of the buffer.
*/
static uint8_t get_register(radio_register_t reg, uint8_t* buffer, uint8_t len)
{
uint8_t status, i;
uint8_t byte = R_REGISTER | (REGISTER_MASK & reg);
for (i = 0; i < len; i++)
{
// If the buffer is too long for the register results, then the radio will interpret the extra bytes as instructions.
// To remove the risk, we set the buffer elements to NOP instructions.
buffer[i] = 0xFF;
}
spi_select_device(&SPID, &spi_device_conf);
spi_write_packet (&SPID, &byte, 1);
spi_read_packet (&SPID, &status, 1);
spi_read_packet (&SPID, buffer, len);
spi_deselect_device(&SPID, &spi_device_conf);
return status;
}
/**
* Retrieve the status register.
*/
static uint8_t get_status(void)
{
uint8_t status = 0xFF;
spi_select_device(&SPID, &spi_device_conf);
spi_write_packet (&SPID, &status, 1);
spi_read_packet (&SPID, &status, 1);
spi_deselect_device(&SPID, &spi_device_conf);
return status;
}
void ENC28J60_ReadBuffer(uint16_t len, uint8_t* data)
{
status_code_t ret = STATUS_OK;
spi_select_device(avr32SPI, &spiDevice);
spi_write_single(avr32SPI, ENC28J60_READ_BUF_MEM);
for(;;)
{
if(spi_is_tx_ready(avr32SPI))
break;
}
ret = spi_read_packet(avr32SPI, data, len);
spi_deselect_device(avr32SPI, &spiDevice);
data[len] = '\0';
}
char CCReadBurst(char addr, char* dataPtr, char size)
{
char stat;
spi_select_device(&SPIC, &spi_device_conf);
while(PORTC.IN&PIN6_bm==PIN6_bm); //Wait for MISO to go low
spi_write_single(&SPIC, addr|0xC0);
spi_read_single(&SPIC, &stat);
spi_read_packet(&SPIC, dataPtr, size);
spi_deselect_device(&SPIC, &spi_device_conf);
return stat;
}
/**
* Set a register in the radio
* \param reg The register value defined in nRF24L01.h (e.g. CONFIG, EN_AA, &c.).
* \param value The value to write to the given register (the whole register is overwritten).
* \return The status register.
*/
static uint8_t set_register(radio_register_t reg, uint8_t* value, uint8_t len)
{
uint8_t status;
uint8_t byte = W_REGISTER | (REGISTER_MASK & reg);
spi_select_device(&SPID, &spi_device_conf);
spi_write_packet (&SPID, &byte, 1);
spi_read_packet (&SPID, &status, 1);
spi_write_packet (&SPID, value, len);
spi_deselect_device(&SPID, &spi_device_conf);
return status;
}
// Reads payload bytes into data array
void nrf24l01_receive_data(uint8_t* data)
{
spi_select_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf);
spi_write_single_packet(&CONF_NRF24L01_SPI, NRF24L01_R_RX_PAYLOAD);
spi_read_packet(&CONF_NRF24L01_SPI, data, CONF_NRF24L01_PAYLOAD);
spi_deselect_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf);
// NVI: per product spec, p 67, note c:
// "The RX_DR IRQ is asserted by a new packet arrival event. The procedure
// for handling this interrupt should be: 1) read payload through SPI,
// 2) clear RX_DR IRQ, 3) read FIFO_STATUS to check if there are more
// payloads available in RX FIFO, 4) if there are more data in RX FIFO,
// repeat from step 1)."
// So if we're going to clear RX_DR here, we need to check the RX FIFO
// in the dataReady() function
nrf24l01_write_register(NRF24L01_STATUS_REG, NRF24L01_RX_DR_BM); // Reset status register
}
uint8_t ENC28J60_ReadOp(uint8_t op, uint8_t address)
{
uint8_t cmd;
uint8_t data = 0;
spi_select_device(avr32SPI, &spiDevice);
cmd = op | GET_REGISTERADDRESS(address);
spi_write_packet(avr32SPI, &cmd, 1);
for(;;)
{
if(spi_is_tx_ready(avr32SPI))
break;
}
spi_read_packet(avr32SPI, &data, 1);
spi_deselect_device(avr32SPI, &spiDevice);
return data;
}
uint8_t RF230FrameBufferRead(uint8_t *frame_rx)
{
uint8_t dummy = 0x00;
uint8_t len, index = 0, length;
cli();
/* Start transmission */
spi_select_device(SPI_ZIGBEE, &SPI_DEVICE_ZIGBEE);
spi_write_once(SPI_ZIGBEE, RF230_SPI_SRAM_READ);
/* Wait for transmission complete */
len = spi_read_once(SPI_ZIGBEE);
length = len;
spi_read_packet(SPI_ZIGBEE, frame_rx, len);
spi_deselect_device(SPI_ZIGBEE, &SPI_DEVICE_ZIGBEE); // end of transmissions
//report_packet(frame_rx, len);
sei();
return length;
}
static bool spi_at45dbx_mem_check(void)
{
// Select the DF memory to check.
spi_select_device(SPI_EXAMPLE,&SPI_DEVICE_EXAMPLE);
// Send the Status Register Read command following by a dummy data.
spi_write_packet(SPI_EXAMPLE, data, 1);
// Receive status.
spi_read_packet(SPI_EXAMPLE, data,1);
// Extract the status.
status = data[0];
// Deselect the checked DF memory.
spi_deselect_device(SPI_EXAMPLE,&SPI_DEVICE_EXAMPLE);
// Unexpected device density value.
if ((status & AT45DBX_MSK_DENSITY) < AT45DBX_DENSITY) return false;
else return true;
}
