コード例 #1
0
ファイル: at25dfx_hal_spi.c プロジェクト: kerichsen/asf
/**
 * \brief Select one external SerialFlash component.
 *
 * \param mem_id  The SerialFlash index number.
 */
void at25dfx_spi_select_device(uint8_t mem_id)
{
	UNUSED(mem_id);
#if defined( AT25DFX_USES_SPI_MASTER_SERVICE)
#if (AT25DFX_MEM_CNT==1)
		spi_select_device(AT25DFX_SPI_MODULE, &AT25DFX_DEVICE1);
#else
		switch (mem_id) {
		case 1:
			spi_select_device(AT25DFX_SPI_MODULE, &AT25DFX_DEVICE1);
			break;

		case 2:
			spi_select_device(AT25DFX_SPI_MODULE, &AT25DFX_DEVICE2);
			break;

		case 3:
			spi_select_device(AT25DFX_SPI_MODULE, &AT25DFX_DEVICE3);
			break;

		case 4:
			spi_select_device(AT25DFX_SPI_MODULE, &AT25DFX_DEVICE4);
			break;

		default:
			/* unhandled_case(id); */
			return;
		}
#endif

/* Implementation with USART in SPI mode service */
#elif defined(AT25DFX_USES_USART_SPI_SERVICE)
#if (AT25DFX_MEM_CNT==1)
		usart_spi_select_device(AT25DFX_SPI_MODULE, &AT25DFX_DEVICE1);
#else
		switch (mem_id) {
		case 1:
			usart_spi_select_device(AT25DFX_SPI_MODULE,&AT25DFX_DEVICE1);
			break;

	case 2:
		usart_spi_select_device(AT25DFX_SPI_MODULE, &AT25DFX_DEVICE2);
		break;

	case 3:
		usart_spi_select_device(AT25DFX_SPI_MODULE, &AT25DFX_DEVICE3);
		break;

	case 4:
		usart_spi_select_device(AT25DFX_SPI_MODULE, &AT25DFX_DEVICE4);
		break;

	default:
		/* unhandled_case(id); */
		return;
	}
#endif

#endif
}
コード例 #2
0
// reg: 5 bit memory map address (LSB first)
// Note: Executable in power down or standby modes only
void nrf24l01_write_register(uint8_t reg, uint8_t writeData)
{
	spi_select_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf);
	uint8_t data[2] = {NRF24L01_W_REGISTER | (NRF24L01_REGISTER_MASK & reg), writeData };
	spi_write_packet(&CONF_NRF24L01_SPI, data, 2);
	spi_deselect_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf);
}
コード例 #3
0
/**
 * 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);
}
コード例 #4
0
ファイル: ads7843.c プロジェクト: marekr/asf
uint32_t ads7843_init(void)
{
	volatile uint32_t uDummy;
	struct spi_device ADS7843_SPI_DEVICE_CFG = {
		/** Board specific chip select configuration*/
#ifdef BOARD_ADS7843_SPI_NPCS
		.id = BOARD_ADS7843_SPI_NPCS
#else
#warning The board TouchScreen chip select definition is missing. Default configuration is used.
		.id = 0
#endif
	};

	spi_master_init(BOARD_ADS7843_SPI_BASE);
	spi_master_setup_device(BOARD_ADS7843_SPI_BASE, &ADS7843_SPI_DEVICE_CFG,
			SPI_MODE_0, ADS7843_SPI_BAUDRATE, 0);
	spi_select_device(BOARD_ADS7843_SPI_BASE, &ADS7843_SPI_DEVICE_CFG);
	spi_enable(BOARD_ADS7843_SPI_BASE);

	for (uDummy = 0; uDummy < 100000; uDummy++) {
	}

	ads7843_send_cmd(CMD_ENABLE_PENIRQ);

	return 0;
}

/** @cond 0*/
/**INDENT-OFF**/
#ifdef __cplusplus
}
コード例 #5
0
ファイル: spi_task.c プロジェクト: poppe34/Pop-and-Zig
void spi_sendToDev(packet_t *pkt)
{
	//cli();
	uint8_t len;
	uint8_t flag = 0xAA;
	if(pkt)
	{
        spi_select_device(SPI_USB, &SPI_DEVICE_USB);
		SPIC.DATA = flag;
		while(!spi_is_rx_full(SPI_USB));

	    spi_write_packet(SPI_USB, &(pkt->len), 1);

	    spi_write_packet(SPI_USB, &(pkt->task), 1);

	    spi_write_packet(SPI_USB, &(pkt->subTask), 1);

	    spi_write_packet(SPI_USB, pkt->buf, pkt->len);
	    spi_deselect_device(SPI_USB, &SPI_DEVICE_USB);
	}
	else
	{
		LED_On(LED6_GPIO);
	}		
	sei();
}
コード例 #6
0
// reg: 5 bit memory map address (LSB first)
// Note: Executable in power down or standby modes only
void nrf24l01_write_array_register(uint8_t reg, uint8_t* writeData, uint8_t dataLen)
{
	spi_select_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf);
	spi_write_single_packet(&CONF_NRF24L01_SPI, NRF24L01_W_REGISTER | reg);
	spi_write_packet(&CONF_NRF24L01_SPI, writeData, dataLen);
	spi_deselect_device(&CONF_NRF24L01_SPI, &nrf24l01_spi_device_conf);
}
コード例 #7
0
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;
}
コード例 #8
0
// 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;
}
コード例 #9
0
ファイル: CC1101.c プロジェクト: Hylian/quadrotor
char CCStrobe(char addr)
{
	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);
	spi_read_single(&SPIC, &stat);
	
	spi_deselect_device(&SPIC, &spi_device_conf);	
	return stat;
}
コード例 #10
0
/**
 * 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;
}
コード例 #11
0
uint8_t AT42QT1110_send_cmd(uint8_t cmd) {
	uint8_t data;
	
	spi_select_device(SPI_TOUCH, &spi_device_touch);
	
	spi_write_single(SPI_TOUCH, cmd);
	
	data = AT42QT1110_spi_read_timeout(&data, 100);
	
	spi_deselect_device(SPI_TOUCH, &spi_device_touch);
	
	return data;
}
コード例 #12
0
ファイル: enc28j60.c プロジェクト: wbeck10/ENC28J60Lib
void ENC28J60_WriteBuffer(uint16_t len, uint8_t* data)
{
  status_code_t ret = STATUS_OK;
  spi_select_device(avr32SPI, &spiDevice);
  spi_write_single(avr32SPI, ENC28J60_WRITE_BUF_MEM);
  for(;;)
  {
    if(spi_is_tx_ready(avr32SPI))
    break;
  }
  ret = spi_write_packet(avr32SPI, data, len);
  spi_deselect_device(avr32SPI, &spiDevice);
}
コード例 #13
0
ファイル: CC1101.c プロジェクト: Hylian/quadrotor
char CCWriteBurst(char addr, const 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|0x40);
	spi_read_single(&SPIC, &stat);
	
	spi_write_packet(&SPIC, *dataPtr, size);	
	
	spi_deselect_device(&SPIC, &spi_device_conf);
	return stat;
}
コード例 #14
0
void AT42QT1110_send_data(uint8_t* data, uint8_t length) {
	uint8_t i;
	
	spi_select_device(SPI_TOUCH, &spi_device_touch);
	
	for (i=0; i<length; i++) {
		delay_us(150);
		spi_write_single(SPI_TOUCH, data[i]);
	}
	
	spi_deselect_device(SPI_TOUCH, &spi_device_touch);
	
	return;
}
コード例 #15
0
uint8_t CS4270_read_data(void) {
	
	uint8_t data;
	
	spi_select_device(SPI_CODEC, &spi_device_codec);
	
	spi_write_single(SPI_CODEC, CS4270_ADDRESS_READ);
	
	spi_read_single(SPI_CODEC, &data);
	
	spi_deselect_device(SPI_CODEC, &spi_device_codec);
	
	return data;
}
コード例 #16
0
ファイル: CC1101.c プロジェクト: Hylian/quadrotor
char CCRead(char addr, char* data)
{
	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|0x80);
	spi_read_single(&SPIC, &stat)
	
	spi_write_single(&SPIC, CONFIG_SPI_MASTER_DUMMY);
	spi_read_single(&SPIC, data);
	
	spi_deselect_device(&SPIC, &spi_device_conf);
	return stat;
};
コード例 #17
0
/**
 * 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;
}
コード例 #18
0
ファイル: enc28j60.c プロジェクト: wbeck10/ENC28J60Lib
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;
}
コード例 #19
0
// 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
}
コード例 #20
0
ファイル: spi_task.c プロジェクト: poppe34/Pop-and-Zig
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);

}
コード例 #21
0
ファイル: spi_driver.c プロジェクト: athind94/sunswift
uint16_t spi1_transfer() {

	u16 data;
	int i;
	spi_select_device(MAX6675);	// CS high
	SPI2_CLK_L();

	for(i = 0; i < 16; i++) {
		SPI2_CLK_H();
		data << 1;
		data |= SPI2_SOMI_VAL();
		SPI2_CLK_L();
	}
	
	SPI2_CLK_L();
	spi_deselect_all();
	return data;
}
コード例 #22
0
ファイル: rf230.c プロジェクト: poppe34/Pop-and-Zig
void RF230frameWrite(uint8_t *frame_wr, uint8_t len)
{

	report_packet(frame_wr, len);
    cli();

    /* Start transmission */
    spi_select_device(SPI_ZIGBEE, &SPI_DEVICE_ZIGBEE);
    
	spi_write_once(SPI_ZIGBEE, RF230_SPI_FRAME_WRITE);
	
	spi_write_once(SPI_ZIGBEE, len);
	
    spi_write_packet(SPI_ZIGBEE, frame_wr, len);
	
    spi_deselect_device(SPI_ZIGBEE, &SPI_DEVICE_ZIGBEE); // end of transmissions

    sei();
}// end RF230frameWrite
コード例 #23
0
static sint8 spi_rw(uint8* pu8Mosi, uint8* pu8Miso, uint16 u16Sz)
{
	struct spi_device spi_device_conf;
	spi_device_conf.id = CONF_WIFI_M2M_SPI_CS_PIN;
	uint8 u8Dummy = 0;
	uint8 u8SkipMosi = 0, u8SkipMiso = 0;
	uint16_t txd_data = 0;
	uint16_t rxd_data = 0;

	if (!pu8Mosi) {
		pu8Mosi = &u8Dummy;
		u8SkipMosi = 1;
	}
	else if(!pu8Miso) {
		pu8Miso = &u8Dummy;
		u8SkipMiso = 1;
	}
	else {
		return M2M_ERR_BUS_FAIL;
	}

	spi_select_device(CONF_WIFI_M2M_SPI_MODULE, &spi_device_conf);
	while (u16Sz) {
		txd_data = *pu8Mosi;
		/* Write one byte */
		spi_write_packet(CONF_WIFI_M2M_SPI_MODULE, (uint8_t*)(&txd_data), 1);
		/* Read SPI master data register. */
		spi_read_single(CONF_WIFI_M2M_SPI_MODULE, (uint8_t*)(&rxd_data));
		
		*pu8Miso = rxd_data;

		u16Sz--;
		if (!u8SkipMiso)
			pu8Miso++;
		if (!u8SkipMosi)
			pu8Mosi++;
	}

	spi_deselect_device(CONF_WIFI_M2M_SPI_MODULE, &spi_device_conf);

	return M2M_SUCCESS;
}
コード例 #24
0
void AT42QT1110_get_data(uint8_t cmd, uint8_t* data, uint8_t length) {
	uint8_t idle;
	uint8_t i;
	
	spi_select_device(SPI_TOUCH, &spi_device_touch);
	
	idle = AT42QT1110_send_cmd(cmd);
	
	if (idle != 0x55) return;
	
	for (i=0; i<length; i++) {
		delay_us(150);
		spi_write_single(SPI_TOUCH, 0x00);
		AT42QT1110_spi_read_timeout(data, 100);
	}	
	
	spi_deselect_device(SPI_TOUCH, &spi_device_touch);
	
	return;
}
コード例 #25
0
ファイル: rf230.c プロジェクト: poppe34/Pop-and-Zig
void RF230registerWrite(uint8_t address, uint8_t data)
{
    uint8_t temp_address;

    temp_address = address;
    temp_address |= RF230_SPI_WRITE;

    cli();
    /* Start transmission */
    spi_select_device(SPI_ZIGBEE, &SPI_DEVICE_ZIGBEE);
    /* Send Address */
    spi_write_once(SPI_ZIGBEE, temp_address);
    /* Send New Register value */
	spi_write_once(SPI_ZIGBEE, data);
	/* End Transmission */
	spi_deselect_device(SPI_ZIGBEE, &SPI_DEVICE_ZIGBEE); // end of transmissions

    sei();

}
コード例 #26
0
ファイル: spi_display.c プロジェクト: artvirewig/idk-firmware
void spi_sensor_init(void)
{
	uint8_t data_buffer[3] = {0x0, 0x0, 0x0};
	spi_init_pins();
	spi_master_init(&SPIC);
	spi_master_setup_device(&SPIC, &SPI_ADC, SPI_MODE_3, 500000, 0);
	spi_enable(&SPIC);
	spi_select_device(&SPIC, &SPI_ADC);
	spi_write_packet(&SPIC, resetdata, 5);
	//clock reg
	data_buffer[0] = 0x20;
	spi_write_packet(&SPIC, data_buffer, 1);
	//data_buffer[0] = 0x00;
	data_buffer[0] = clockreg;
	spi_write_packet(&SPIC, data_buffer, 1);
	
	//setup reg
	data_buffer[0] = 0x10;
	spi_write_packet(&SPIC, data_buffer, 1);
	//data_buffer[0] = 0x04;
	data_buffer[0] = setupreg;
	spi_write_packet(&SPIC, data_buffer, 1);
	
	//offset reg
	data_buffer[0] = 0x60;
	spi_write_packet(&SPIC, data_buffer, 1);
	data_buffer[0] = 0x18;
	data_buffer[1] = 0x3A;
	data_buffer[2] = 0x00;
	spi_write_packet(&SPIC, data_buffer, 3);
	
	//gain reg
	data_buffer[0] = 0x70;
	spi_write_packet(&SPIC, data_buffer, 1);
	data_buffer[0] = 0x89;
	data_buffer[1] = 0x78;
	data_buffer[2] = 0xD7;
	spi_write_packet(&SPIC, data_buffer, 3);

	spi_deselect_device(&SPIC, &SPI_ADC);
}
コード例 #27
0
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;
}
コード例 #28
0
ファイル: enc28j60.c プロジェクト: wbeck10/ENC28J60Lib
void ENC28J60_WriteOp(uint8_t op, uint8_t address, uint8_t data)
{
    uint8_t cmd;
    
    spi_select_device(avr32SPI, &spiDevice);
    cmd = op | GET_REGISTERADDRESS(address);
    spi_write_single(avr32SPI, cmd);
    for(;;)
    {
      if(spi_is_tx_ready(avr32SPI))
        break;
    }
    spi_write_single(avr32SPI, data);
    for(;;)
    {
      if(spi_is_tx_ready(avr32SPI))
        break;
    }
    
    spi_deselect_device(avr32SPI, &spiDevice);
}
コード例 #29
0
ファイル: rf230.c プロジェクト: poppe34/Pop-and-Zig
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;
}
コード例 #30
0
/**
 * 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;
}