/** * 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; }