自学教程：C++ spi_transfer函数代码示例

int8_t spi_transfer_block(const uint8_t *out_buf, uint8_t *in_buf, uint16_t len){	uint16_t i;	if (in_buf && out_buf) {		for (i = 0; i < len; i++) {			in_buf[i] = spi_transfer(out_buf[i]);		}	}	else if (!in_buf && out_buf) {		for (i = 0; i < len; i++) {			spi_transfer(out_buf[i]);		}	}	else if (in_buf && !out_buf) {		for (i = 0; i < len; i++) {			in_buf[i] = spi_transfer(0xff);		}	}	else if (!in_buf && !out_buf) {		/* No in or out buffer; just move the clock line. */		for (i = 0; i < len; i++) {			spi_transfer(0xff);		}	}	return 0;}

void OSD::ClosePanel(void){    spi_transfer(MAX7456_DMDI_reg);    spi_transfer(MAX7456_END_string); //This is needed "trick" to finish auto increment    DeSelect();;    row++; //only after finish the auto increment the new row will really act as desired}

void spi_write_eeprom(unsigned int addr, unsigned char data_in){	unsigned char temp;	EE_NCS = 0;	delay1();	spi_transfer(WRITE_ENABLE);	EE_NCS = 1;	delay_us(300);	EE_NCS = 0;	delay1();	if((addr & 0x0100) == 0x0100)	{		temp = (WRITE_DATA | 0x08);	}	else	{		temp = WRITE_DATA;	}	spi_transfer(temp);	delay1();	spi_transfer((unsigned char)addr);	delay1();	spi_transfer(data_in);	delay1();	EE_NCS = 1;}

// Checks if MAX_RT has been reacheduint8_t mirf_max_rt_reached(void) {  mirf_CSN_lo; // Pull down chip select  spi_transfer(R_REGISTER | (REGISTER_MASK & STATUS));  uint8_t status = spi_transfer(NOP); // Read status register  mirf_CSN_hi; // Pull up chip select  return status & (1<<MAX_RT);}

// Sends a data package to the default address. Be sure to send the correct// amount of bytes as configured as payload on the receiver.void nrf24_send(uint8_t* value){    /* Go to Standby-I first */    nrf24_ce_digitalWrite(LOW);    /* Set to transmitter mode , Power up if needed */    nrf24_powerUpTx();    /* Do we really need to flush TX fifo each time ? */    #if 1        /* Pull down chip select */        nrf24_csn_digitalWrite(LOW);        /* Write cmd to flush transmit FIFO */        spi_transfer(NRF24L01P_CMD_FLUSH_TX, 1);        /* Pull up chip select */        nrf24_csn_digitalWrite(HIGH);    #endif    /* Pull down chip select */    nrf24_csn_digitalWrite(LOW);    /* Write cmd to write payload */    spi_transfer(NRF24L01P_CMD_W_TX_PAYLOAD, 0);    /* Write payload */    nrf24_transmitSync(value,payload_len);    /* Pull up chip select */    nrf24_csn_digitalWrite(HIGH);    /* Start the transmission */    nrf24_ce_digitalWrite(HIGH);}

// Checks if data is available for readinguint8_t mirf_data_ready(void) {  mirf_CSN_lo; // Pull down chip select  spi_transfer(R_REGISTER | (REGISTER_MASK & STATUS));  uint8_t status = spi_transfer(NOP); // Read status register  mirf_CSN_hi; // Pull up chip select  return status & (1<<RX_DR);}

void cmd_spirom_id() {	unsigned long recv1;	unsigned short recv2;//	spi_init();	spi_set_port(SPI_PORT_NONE); // CSを自分で制御する	spi_set_bit_order(SPI_MSBFIRST);	gpio_set_pinmode(SPI_ROM_PORT,1);	gpio_write_port(SPI_ROM_PORT,0); // CSを下げる	spi_set_bit_length(8);	spi_transfer(0x9f); // コマンド送信	spi_set_bit_length(24);	recv1 = spi_transfer(0) & 0xffffff;	printf("SPI ROM JEDEC ID=%08lx, ",recv1);//	gpio_write_port(SPI_ROM_PORT,1); // CSを上げる	gpio_write_port(SPI_ROM_PORT,0); // CSを下げる	spi_set_bit_length(32);	recv2 = spi_transfer(0x90000000) & 0xffff; // コマンド送信	printf("ID=%04x/n",recv2);	gpio_write_port(SPI_ROM_PORT,1); // CSを上げる	gpio_set_pinmode(SPI_ROM_PORT,0);//	spi_terminate();}

void xhide(void){	spi_transfer(low_byte(400));  spi_transfer(high_byte(400));  spi_transfer(low_byte(400));  spi_transfer(high_byte(400));  //spr++;}

void wr16(unsigned int addr, unsigned int v){	  __wstart(addr);  spi_transfer(low_byte(v));  spi_transfer(high_byte(v));  __end();	}

unsigned char accel_read(unsigned char address) {    unsigned char result;    pin_clear(&ACCEL_CS);    spi_transfer(&spi1, (address&0x3F)<<1);    result = spi_transfer(&spi1, 0x00);    pin_set(&ACCEL_CS);    return result;}

unsigned char gyro_read(unsigned char address) {    unsigned char result;    pin_clear(&GYRO_CS);    spi_transfer(&spi1, 0x80|(address&0x3F));    result = spi_transfer(&spi1, 0x00);    pin_set(&GYRO_CS);    return result;}

//null args for some cmd'svoid sd_send_null_args(void){    spi_transfer(0x00);    spi_transfer(0x00);    spi_transfer(0x00);    spi_transfer(0x00);    spi_transfer(0x95);}

static void nrf24_write_reg(uint8_t addr, uint8_t value) {	nrf24_csn(0);	spi_transfer(addr | W_REGISTER);	spi_transfer(value);	nrf24_csn(1);}

uint8_t rx_fifo_empty() {  uint8_t status = 0x00;  NRF_CS_LOW;  spi_transfer(FIFO_STATUS);  status = spi_transfer(0);  NRF_CS_HIGH;  return (status & (1 << RX_EMPTY));}

/*!	/fn int spi_write(int pin, uint8_t reg, uint8_t data) *	/brief Write 8 address bits to an spi device then writes 8 data bits to the spi device *	@param[in] pin the chipselect pin to toggle *	@param[in] reg the address bits to send to the spi device * 	@param[in] the data to send to the spi device * 	/return returns ERR_NOERR unless an attempt has been made to perform two simultaneous spi transactions, then an error is returned */int spi_write(int pin, uint8_t reg, uint8_t data){	int ret = spi_begin(pin);	if (ret < 0)		return ret;	spi_transfer(reg);	spi_transfer(data);	return spi_end();	}

/*!	/fn int spi_read(int pin, uint8_t reg, uint8_t *data)  *	/brief Write 8 address bits to an spi device then read 8 bits from spi device *	@param[in] pin the chipselect pin to toggle *	@param[in] reg the address bits to send to the spi device * 	@param[out] the data the spi device sent back * 	/return returns ERR_NOERR unless an attempt has been made to perform two simultaneous spi transactions, then an error is returned */int spi_read(int pin, uint8_t reg, uint8_t *data) {	int ret = spi_begin(pin);	if (ret < 0)		return ret;	spi_transfer(reg|0x80);	*data = spi_transfer(0);	return spi_end();}

/* Returns the length of data waiting in the RX fifo */uint8_t nrf24_payloadLength(){    uint8_t status;    nrf24_csn_digitalWrite(LOW);    spi_transfer(NRF24L01P_CMD_R_RX_PL_WID, 0);    status = spi_transfer(0x00, 1);    nrf24_csn_digitalWrite(HIGH);    return status;}

void can_w_bit(uint8_t addr, uint8_t mask, uint8_t val){	CAN_CS_LOW;	spi_transfer(MCP2515_SPI_BITMOD);	spi_transfer(addr);	spi_transfer(mask);	spi_transfer(val);	CAN_CS_HIGH;}

void spi_setRegister(    uint8_t reg,    uint8_t value){    nrf24_csn_digitalWrite(LOW);    spi_transfer(W_REGISTER | (REGISTER_MASK & reg));    spi_transfer(value);    nrf24_csn_digitalWrite(HIGH);}

/* Returns the length of data waiting in the RX fifo */uint8_t nrf24_payloadLength(){    uint8_t status;    nrf24_csn_digitalWrite(LOW);    spi_transfer(R_RX_PL_WID);    status = spi_transfer(0x00);    nrf24_csn_digitalWrite(HIGH);    return status;}

static int rtc_get_temperature(void){	CS_ON();	spi_transfer(RTC_TEMPERATURE | RTC_READ);	uint8_t data = spi_transfer(0);		CS_OFF();		return map(data, 0, 250, -60, 190);}

uint8_t spi_read_auto(uint8_t address) {	uint8_t response;	SPI_CS_LOW	spi_transfer(address | 0x80);	response = spi_transfer(0xFF);	SPI_CS_HIGH	return response;}

uint8_t spi_write_auto(uint8_t address,uint8_t data) {	uint8_t response;	SPI_CS_LOW	spi_transfer(address);	response = spi_transfer(data);	SPI_CS_HIGH	return response;}

static void cmd_write_flash(const char *filename){	FILE *fd;	// maximum hexfile data per line is 255, plus 3 bytes for cmd and addr	uint8_t buffer[255 + 3] = {0};	uint8_t orig[255 + 3] = {0};	uint8_t comp[255 + 3] = {0};	int count;	uint16_t address;	if (check_rdismb()) {		fprintf(stderr, "flash memory is protected/n");		exit(EXIT_FAILURE);	}	disable_infen();	fd = fopen(filename, "r");	if (!fd) {		fprintf(stderr, "can't open %s to read/n", filename);		exit(EXIT_FAILURE);	}	while ((count = hexfile_getline(fd, &address, buffer + 3,						sizeof(buffer) - 3)) > 0) {		enable_wen();		memcpy(orig, buffer + 3, count);		buffer[0] = PROGRAM;		buffer[1] = address >> 8;		buffer[2] = address & 0xff;		printf("writing %i bytes at 0x%04hx.../n", count, address);		if (!spi_transfer(buffer, count + 3)) {			fprintf(stderr, "SPI error/n");			fclose(fd);			exit(EXIT_FAILURE);		}		wait_ready();		comp[0] = READ;		comp[1] = address >> 8;		comp[2] = address & 0xff;		if (!spi_transfer(comp, count + 3)) {			fprintf(stderr, "SPI error/n");			fclose(fd);			exit(EXIT_FAILURE);		}		if (memcmp(orig, comp + 3, count)) {			fprintf(stderr, "error checking memory/n");			fclose(fd);			exit(EXIT_FAILURE);		}	}	fclose(fd);}

// Flush RX and TX FIFOvoid mirf_flush_rx_tx(void) {	mirf_CSN_lo; // Pull down chip select	spi_transfer(FLUSH_RX); // Flush RX	mirf_CSN_hi; // Pull up chip select	mirf_CSN_lo; // Pull down chip select	spi_transfer(FLUSH_TX);  // Write cmd to flush tx fifo	mirf_CSN_hi; // Pull up chip select}

/* send multiple bytes over SPI */void nrf24_transmitSync(uint8_t* dataout,uint8_t len){    uint8_t i;    for(i=0;i<len-1;i++)    {        spi_transfer(dataout[i], 0);    }    spi_transfer(dataout[len-1], 1);}

/* send and receive multiple bytes over SPI */void nrf24_transferSync(uint8_t* dataout,uint8_t* datain,uint8_t len){    uint8_t i;    for(i=0;i<len-1;i++)    {        datain[i] = spi_transfer(dataout[i], 0);    }    datain[len-1] = spi_transfer(dataout[len-1], 1);}

uint8_t can_spi_query(uint8_t cmd){	uint8_t ret;	CAN_CS_LOW;	spi_transfer(cmd);	ret = spi_transfer(0xFF);	CAN_CS_HIGH;	return ret;}

static void nrf24_write_addr_reg(uint8_t addr, uint8_t value[3]) {	nrf24_csn(0);	spi_transfer(addr | W_REGISTER);	spi_transfer(value[0]);	spi_transfer(value[1]);	spi_transfer(value[2]);	nrf24_csn(1);}

void write_register(char register_name, char register_value){    register_name <<= 2;    register_name |= B00000010; //Write command    digitalWrite(SLAVESELECT,LOW); //Select SPI device    spi_transfer(register_name); //Send register location    spi_transfer(register_value); //Send value to record into register    digitalWrite(SLAVESELECT,HIGH);}