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

/** * Init function. */int lsm303_init(SPIDriver *spip) {	uint8_t who_am_i;	// FIXME: interrupt lines will be rearranged!	spiAcquireBus(spip);	who_am_i = lsm303dReadRegister(spip, LSM303D_WHO_AM_I);	if (who_am_i != 0x49) {		spiReleaseBus(spip);		return -1;	}	lsm303dWriteRegister(spip, LSM303D_CTRL0, 0x00);	lsm303dWriteRegister(spip, LSM303D_CTRL2, 0x40); // 194Hz anti-alias filter BW	lsm303dWriteRegister(spip, LSM303D_CTRL3, 0x04); // Acc data-ready on INT1	lsm303dWriteRegister(spip, LSM303D_CTRL4, 0x04); // Mag data-ready on INT2	lsm303dWriteRegister(spip, LSM303D_CTRL5, 0xF4); // Temp sensor enabled, magnetometer high-res, Mag 100Hz	lsm303dWriteRegister(spip, LSM303D_CTRL6, 0x00); // Mag FS ±2 gauss	lsm303dWriteRegister(spip, LSM303D_CTRL7, 0x00);	lsm303dWriteRegister(spip, LSM303D_CTRL1, 0x67); // Acc 100Hz, axes enabled, no data update until MSB and LSB read	spiReleaseBus(spip);	chThdSleepMilliseconds(250);	return 0;}

static msg_t set_full_scale(void *ip, lis302dl_fs_t fs) {  float newfs, scale;  uint8_t i, cr;  if(fs == LIS302DL_FS_2G) {    newfs = LIS302DL_2G;  }  else if(fs == LIS302DL_FS_8G) {    newfs = LIS302DL_8G;  }  else {    return MSG_RESET;  }  if(newfs != ((LIS302DLDriver *)ip)->fullscale) {    scale = newfs / ((LIS302DLDriver *)ip)->fullscale;    ((LIS302DLDriver *)ip)->fullscale = newfs;#if LIS302DL_USE_SPI#if LIS302DL_SHARED_SPI  spiAcquireBus(((LIS302DLDriver *)ip)->config->spip);  spiStart(((LIS302DLDriver *)ip)->config->spip,          ((LIS302DLDriver *)ip)->config->spicfg);#endif /* LIS302DL_SHARED_SPI */    lis302dlSPIReadRegister(((LIS302DLDriver *)ip)->config->spip,                            LIS302DL_AD_CTRL_REG1, 1, &cr);#if LIS302DL_SHARED_SPI  spiReleaseBus(((LIS302DLDriver *)ip)->config->spip);#endif /* LIS302DL_SHARED_SPI */#endif /* LIS302DL_USE_SPI */    cr &= ~(LIS302DL_CTRL_REG1_FS_MASK);    cr |= fs;#if LIS302DL_USE_SPI#if LIS302DL_SHARED_SPI  spiAcquireBus(((LIS302DLDriver *)ip)->config->spip);  spiStart(((LIS302DLDriver *)ip)->config->spip,          ((LIS302DLDriver *)ip)->config->spicfg);#endif /* LIS302DL_SHARED_SPI */    lis302dlSPIWriteRegister(((LIS302DLDriver *)ip)->config->spip,                             LIS302DL_AD_CTRL_REG1, 1, &cr);#if LIS302DL_SHARED_SPI  spiReleaseBus(((LIS302DLDriver *)ip)->config->spip);#endif /* LIS302DL_SHARED_SPI */#endif /* LIS302DL_USE_SPI */    /* Scaling sensitivity and bias. Re-calibration is suggested anyway. */    for(i = 0; i < LIS302DL_NUMBER_OF_AXES; i++) {      ((LIS302DLDriver *)ip)->sensitivity[i] *= scale;      ((LIS302DLDriver *)ip)->bias[i] *= scale;    }  }  return MSG_OK;}

static msg_t wavePlayerThread(void *arg) {	(void)arg;	chRegSetThreadName("blinker");	UINT temp, bufSwitch=1;	codec_pwrCtl(1);	codec_muteCtl(0);	f_read(&f1, buf, PLAYBACK_BUFFER_SIZE, &temp);	bytesToPlay-=temp;	chEvtAddFlags(1);	while(bytesToPlay)	{		chEvtWaitOne(1);		if (bufSwitch)		{			codec_audio_send(buf, temp/2);			spiAcquireBus(&SPID1);			f_read(&f1, buf2, PLAYBACK_BUFFER_SIZE, &temp);			spiReleaseBus(&SPID1);			bufSwitch=0;		}		else		{			codec_audio_send(buf2, temp/2);			spiAcquireBus(&SPID1);			f_read(&f1, buf, PLAYBACK_BUFFER_SIZE, &temp);			spiReleaseBus(&SPID1);			bufSwitch=1;		}		bytesToPlay-=temp;		if (chThdShouldTerminate()) break;	}	codec_muteCtl(1);	codec_pwrCtl(0);	playerThread=NULL;	f_close(&f1);	return 0;}

static void cmd_write(BaseSequentialStream *chp, int argc, char *argv[]) {    (void)argc;    (void)argv;    acquire_bus();    write_index(0x00);    chprintf(chp,"Device ID %x/r/n",read_data());    release_bus();    //chprintf(chp,"GRAM %x/r/n",gdispReadReg(0x22));     /*gdispClear(White);    chThdSleepMilliseconds(3000);    gdispClear(Red);    chThdSleepMilliseconds(3000);    gdispClear(Blue);    chThdSleepMilliseconds(3000);    gdispClear(Green);*/    #if 0    uint8_t c = 0xAA;    uint8_t d = 0x55;    spiAcquireBus(&SPID1);              /* Acquire ownership of the bus.    */    spiStart(&SPID1, &spicfg);       /* Setup transfer parameters.       */    spiSelect(&SPID1);                  /* Slave Select assertion.          */    spiSend(&SPID1, 1, &c);    spiSend(&SPID1, 1, &d);    spiUnselect(&SPID1);                /* Slave Select de-assertion.       */    spiReleaseBus(&SPID1);              /* Ownership release.               */    #endif}

static uint32_t getTemperatureStr(char * temperatureStr){    float temperature = 0;    float pressure = 0;    spiAcquireBus(&CC3000_SPI_DRIVER);    i2cAcquireBus(&I2C_DRIVER);    i2cStart(&I2C_DRIVER, &i2cConfig);    if (RDY_OK != mplOneShotReadBarometer(&I2C_DRIVER,                                          MPL3115A2_DEFAULT_ADDR,                                          &pressure,                                           &temperature))    {        return 1;    }    i2cStop(&I2C_DRIVER);    i2cReleaseBus(&I2C_DRIVER);    spiReleaseBus(&CC3000_SPI_DRIVER);     temperature += CELSIUS_TO_KELVIN;    snprintf(temperatureStr, TEMPERATURE_STRING_SIZE, "%.2f K", temperature);     temperatureStr[TEMPERATURE_STRING_SIZE-1] = 0;    return 0;}

static msg_t read_raw(void *ip, int32_t axes[LIS302DL_NUMBER_OF_AXES]) {  uint8_t i, tmp;  osalDbgCheck((ip != NULL) && (axes != NULL));  osalDbgAssert((((LIS302DLDriver *)ip)->state == LIS302DL_READY),              "read_raw(), invalid state");#if LIS302DL_USE_SPI  osalDbgAssert((((LIS302DLDriver *)ip)->config->spip->state == SPI_READY),                "read_raw(), channel not ready");#if	LIS302DL_SHARED_SPI  spiAcquireBus(((LIS302DLDriver *)ip)->config->spip);  spiStart(((LIS302DLDriver *)ip)->config->spip,          ((LIS302DLDriver *)ip)->config->spicfg);#endif /* LIS302DL_SHARED_SPI */    for(i = 0; i < LIS302DL_NUMBER_OF_AXES; i++) {      lis302dlSPIReadRegister(((LIS302DLDriver *)ip)->config->spip,                              LIS302DL_AD_OUT_X + (i * 2), 1, &tmp);      axes[i] = (int32_t)((int8_t)tmp);    }#if	LIS302DL_SHARED_SPI  spiReleaseBus(((LIS302DLDriver *)ip)->config->spip);#endif /* LIS302DL_SHARED_SPI */#endif /* LIS302DL_USE_SPI */   return MSG_OK;}

static uint32_t getPressureStr(char * pressureStr){    float pressure;    float temperature;    spiAcquireBus(&CC3000_SPI_DRIVER);    i2cAcquireBus(&I2C_DRIVER);    i2cStart(&I2C_DRIVER, &i2cConfig);    if (RDY_OK != mplOneShotReadBarometer(&I2C_DRIVER,                                          MPL3115A2_DEFAULT_ADDR,                                          &pressure,                                           &temperature))    {        return 1;    }    i2cStop(&I2C_DRIVER);    i2cReleaseBus(&I2C_DRIVER);    spiReleaseBus(&CC3000_SPI_DRIVER);     pressure /= 1000; /* kPa */    snprintf(pressureStr, PRESSURE_STRING_SIZE, "%.2f kPa", pressure);     pressureStr[PRESSURE_STRING_SIZE-1] = 0;    return 0;}

msg_t Mtd25::spi_write_enable(void) {  msg_t ret = MSG_RESET;  uint8_t tmp;#if SPI_USE_MUTUAL_EXCLUSION  spiAcquireBus(this->spip);#endif  /* try to enable write access */  spiSelect(spip);  spiPolledExchange(spip, S25_CMD_WREN);  spiUnselect(spip);  chSysPolledDelayX(10);  /* check result */  spiSelect(spip);  spiPolledExchange(spip, S25_CMD_RDSR1);  tmp = spiPolledExchange(spip, 0);  spiUnselect(spip);  if (tmp & S25_SR1_WEL)    ret = MSG_OK;  else    ret = MSG_RESET;#if SPI_USE_MUTUAL_EXCLUSION  spiReleaseBus(this->spip);#endif  return ret;}

static flash_error_t read(void *instance, flash_address_t addr,                          uint8_t *rp, size_t n) {  N25Q128Driver *devp = (N25Q128Driver *)instance;  SPIDriver *spip = devp->config->spip;  osalDbgAssert(devp->state == FLASH_READY, "invalid state");#if N25Q128_SHARED_SPI == TRUE  spiAcquireBus(spip);  spiStart(spip, devp->config->spicfg);#endif  devp->state = FLASH_ACTIVE;  /* Read command.*/  spiSelect(spip);  spi_send_cmd_addr(devp, N25Q128_CMD_READ, addr);  spiReceive(spip, n, rp);  spiUnselect(spip);  devp->state = FLASH_READY;#if N25Q128_SHARED_SPI == TRUE  spiReleaseBus(spip);#endif  return FLASH_NO_ERROR;}

/** * @brief 25XX low level write then read rountine. * * @param[in]  eepcfg pointer to configuration structure of eeprom file. * @param[in]  txbuf  pointer to buffer to be transfered. * @param[in]  txlen  number of bytes to be transfered. * @param[out] rxbuf  pointer to buffer to be received. * @param[in]  rxlen  number of bytes to be received. */static void ll_25xx_transmit_receive(const SPIEepromFileConfig *eepcfg,                                     const uint8_t *txbuf, size_t txlen,                                     uint8_t *rxbuf, size_t rxlen) {#if SPI_USE_MUTUAL_EXCLUSION  spiAcquireBus(eepcfg->spip);#endif  spiStart(eepcfg->spip, eepcfg->spicfg);  spiSelect(eepcfg->spip);#ifdef POLLED_SPI  size_t count = 0;  for( count = 0; count < txlen; ++count )      spiPolledExchange( eepcfg->spip, txbuf[count] );  for( count = 0; count < rxlen; ++count )      rxbuf[count] = spiPolledExchange( eepcfg->spip, 0 );#else  spiSend(eepcfg->spip, txlen, txbuf);  if (rxlen) /* Check if receive is needed. */    spiReceive(eepcfg->spip, rxlen, rxbuf);#endif  spiUnselect(eepcfg->spip);#if SPI_USE_MUTUAL_EXCLUSION  spiReleaseBus(eepcfg->spip);#endif}

/** * @brief   Deactivates the L3GD20 Complex Driver peripheral. * * @param[in] devp       pointer to the @p L3GD20Driver object * * @api */void l3gd20Stop(L3GD20Driver *devp) {  uint8_t cr1;  osalDbgCheck(devp != NULL);  osalDbgAssert((devp->state == L3GD20_STOP) || (devp->state == L3GD20_READY),                "l3gd20Stop(), invalid state");  if (devp->state == L3GD20_READY) {    /* Disabling all axes and enabling power down mode.*/    cr1 = 0;    #if L3GD20_USE_SPI#if	L3GD20_SHARED_SPI    spiAcquireBus(devp->config->spip);    spiStart(devp->config->spip,             devp->config->spicfg);#endif /* L3GD20_SHARED_SPI */    l3gd20SPIWriteRegister(devp->config->spip, L3GD20_AD_CTRL_REG1,                            1, &cr1);    spiStop(devp->config->spip);    #if	L3GD20_SHARED_SPI    spiReleaseBus(devp->config->spip);#endif /* L3GD20_SHARED_SPI */ #endif /* L3GD20_USE_SPI */  }			   devp->state = L3GD20_STOP;}

static void adis16405_read_multiple(int base_addr, int num, uint16_t* rx_buff) {    spiAcquireBus(&ADIS16405_SPID);    spiStart(&ADIS16405_SPID, &spi_cfg);    for (int i = 0; i < num; i++)        rx_buff[i] = internal_adis16405_read_u16(base_addr + i * 2);    spiReleaseBus(&ADIS16405_SPID);}

static voidxflash_txn_end(){  spiUnselect(SPI_FLASH);#if SPI_USE_MUTUAL_EXCLUSION  spiReleaseBus(SPI_FLASH);#endif}

void gyro_write_register (uint8_t address, uint8_t data) {  address = address & (~0x80);         /* Clear the write bit (bit 7)      */  spiAcquireBus(&SPID1);               /* Acquire ownership of the bus.    */  spiStart(&SPID1, &gyro_cfg);         /* Setup transfer parameters.       */  spiSelect(&SPID1);                   /* Slave Select assertion.          */  spiSend(&SPID1, 1, &address);        /* Send the address byte            */  spiSend(&SPID1, 1, &data);   spiUnselect(&SPID1);                 /* Slave Select de-assertion.       */  spiReleaseBus(&SPID1);               /* Ownership release.               */}

/** * @brief Sends a byte through the SPI interface and return the byte    * received from the SPI bus.     * @param byte : byte to send.     * @retval : The value of the received byte.     */ void sendByte3310( uint8_t byte ){    spiAcquireBus( &SPI_3310 );     // Acquire ownership of the bus.    spiStart( &SPI_3310, &spicfg ); // Setup transfer parameters.    spiSelect( &SPI_3310 );         // Slave Select assertion.    spiStartSend( &SPI_3310, 1, &byte );    //spiExchange( &SPI_3310, 512,    //             txbuf, rxbuf );  // Atomic transfer operations.    spiUnselect( &SPI_3310 );       // Slave Select de-assertion.    spiReleaseBus( &SPI_3310 );     // Ownership release.}

uint16_t A4960::writeReg(const uint8_t addr, const uint16_t data) {    const uint16_t txData = (uint16_t(addr & 0x7) << 13) | 0x1000 | (data & 0xfff);    uint16_t rxData;    spiAcquireBus(spip);    spiSelect(spip);    spiExchange(spip, 1, &txData, &rxData);    spiUnselect(spip);    spiReleaseBus(spip);    return rxData;}

void sendArray3310( uint8_t * data, int cnt ){    spiAcquireBus( &SPID1 );     // Acquire ownership of the bus.    spiStart( &SPID1, &spicfg ); // Setup transfer parameters.    spiSelect( &SPID1 );         // Slave Select assertion.    //spiExchange( &SPID1, 512,    //            txbuf, rxbuf );  // Atomic transfer operations.    spiStartSend( &SPI_3310, cnt, data );    spiUnselect( &SPID1 );       // Slave Select de-assertion.    spiReleaseBus( &SPID1 );     // Ownership release.}

uint8_t fm25l16_exchange(int len){	spiAcquireBus(&SPID1);              /* Acquire ownership of the bus.    */	spiStart(&SPID1, &hs_spicfg);       /* Setup transfer parameters.       */	spiSelect(&SPID1);                  /* Slave Select assertion.          */	spiExchange(&SPID1, len,			txbuf, rxbuf);          /* Atomic transfer operations.      */	spiUnselect(&SPID1);                /* Slave Select de-assertion.       */    spiReleaseBus(&SPID1);              /* Ownership release.               */	return len;}

uint8_t fm25l16_write_read(uint8_t cmd){	spiAcquireBus(&SPID1);              /* Acquire ownership of the bus.    */	spiStart(&SPID1, &hs_spicfg);       /* Setup transfer parameters.       */	spiSelect(&SPID1);                  /* Slave Select assertion.          */	tx_ch = cmd;	spiExchange(&SPID1, 1,			&tx_ch, &rx_ch);          /* Atomic transfer operations.      */	spiUnselect(&SPID1);                /* Slave Select de-assertion.       */    spiReleaseBus(&SPID1);              /* Ownership release.               */	return rx_ch;}

uint8_t gyro_read_register (uint8_t address) {  uint8_t receive_data;  address = address | 0x80;            /* Set the read bit (bit 7)         */  spiAcquireBus(&SPID1);               /* Acquire ownership of the bus.    */  spiStart(&SPID1, &gyro_cfg);         /* Setup transfer parameters.       */  spiSelect(&SPID1);                   /* Slave Select assertion.          */  spiSend(&SPID1, 1, &address);        /* Send the address byte */  spiReceive(&SPID1, 1,&receive_data);   spiUnselect(&SPID1);                 /* Slave Select de-assertion.       */  spiReleaseBus(&SPID1);               /* Ownership release.               */  return (receive_data);}

uint8_t writeByteSPI(uint8_t txbyte){	uint8_t rxbyte = 0;	spiAcquireBus(&SPID1);              /* Acquire ownership of the bus.    */    spiStart(&SPID1, spicfg);       /* Setup transfer parameters.       */    spiSelect(&SPID1);                  /* Slave Select assertion.          */    spiExchange(&SPID1, 1,                &txbyte, &rxbyte);          /* Atomic transfer operations.      */    spiUnselect(&SPID1);                /* Slave Select de-assertion.       */    spiReleaseBus(&SPID1);	chThdSleepMilliseconds(1);	return rxbyte;}

/*! /brief Process information from a adis_spi_cb event * */void adis_spi_cb_txdone_handler(eventid_t id) {	(void) id;	switch(adis_driver.reg) {		case ADIS_PRODUCT_ID:			spiUnselect(adis_driver.spi_instance);			spiReleaseBus(adis_driver.spi_instance);			adis_tstall_delay();			spiAcquireBus(adis_driver.spi_instance);			spiSelect(adis_driver.spi_instance);			spiStartReceive(adis_driver.spi_instance, adis_driver.rx_numbytes, adis_driver.adis_rxbuf);			adis_driver.state             = ADIS_RX_PEND;			break;		case ADIS_GLOB_CMD:			spiStartReceive(adis_driver.spi_instance, adis_driver.rx_numbytes, adis_driver.adis_rxbuf);			adis_driver.state             = ADIS_RX_PEND;			break;		default:			spiUnselect(adis_driver.spi_instance);			spiReleaseBus(adis_driver.spi_instance);			adis_driver.state             = ADIS_IDLE;			break;	}}

int max6675_get_temp(const struct max6675 *max){	uint16_t read;	spiAcquireBus(max->driver);	spiStart(max->driver, &max->config);	spiSelect(max->driver);	spiReceive(max->driver, 1, &read);	spiUnselect(max->driver);	spiStop(max->driver);	spiReleaseBus(max->driver);	return (read >> 3) * 250;}

static void adis16405_write_u8(uint8_t addr, uint8_t val) {    uint16_t txbuf[1] = {        ((((uint16_t)addr | 0x80) << 8) | val)    };    spiAcquireBus(&ADIS16405_SPID);    spiStart(&ADIS16405_SPID, &spi_cfg);    spiSelect(&ADIS16405_SPID);    spiSend(&ADIS16405_SPID, 1, (void*)txbuf);    spiUnselect(&ADIS16405_SPID);    spiReleaseBus(&ADIS16405_SPID);}

static THD_FUNCTION(spi_thread_2, p) {  (void)p;  chRegSetThreadName("SPI thread 2");  while (true) {    spiAcquireBus(&PORTAB_SPI1);        /* Acquire ownership of the bus.    */    palWriteLine(PORTAB_LINE_LED1, PORTAB_LED_OFF);    spiStart(&PORTAB_SPI1, &ls_spicfg); /* Setup transfer parameters.       */    spiSelect(&PORTAB_SPI1);            /* Slave Select assertion.          */    spiExchange(&PORTAB_SPI1, 512,                txbuf, rxbuf);          /* Atomic transfer operations.      */    spiUnselect(&PORTAB_SPI1);          /* Slave Select de-assertion.       */    spiReleaseBus(&PORTAB_SPI1);        /* Ownership release.               */  }}

static THD_FUNCTION(spi_thread_2, p) {  (void)p;  chRegSetThreadName("SPI thread 2");  while (true) {    spiAcquireBus(&SPID2);              /* Acquire ownership of the bus.    */    palClearPad(GPIOA, GPIOA_LED_GREEN);/* LED OFF.                         */    spiStart(&SPID2, &ls_spicfg);       /* Setup transfer parameters.       */    spiSelect(&SPID2);                  /* Slave Select assertion.          */    spiExchange(&SPID2, 512,                txbuf, rxbuf);          /* Atomic transfer operations.      */    spiUnselect(&SPID2);                /* Slave Select de-assertion.       */    spiReleaseBus(&SPID2);              /* Ownership release.               */  }}

static THD_FUNCTION(spi_thread_1, p){  (void)p;  chRegSetThreadName("SPI thread 1");  while (TRUE) {    spiAcquireBus(&SPID1);              /* Acquire ownership of the bus.    */    palSetPad(GPIOF, GPIOF_LED_GREEN);  /* LED ON.                          */    spiStart(&SPID1, &hs_spicfg);       /* Setup transfer parameters.       */    spiSelect(&SPID1);                  /* Slave Select assertion.          */    spiExchange(&SPID1, 512,                txbuf, rxbuf);          /* Atomic transfer operations.      */    spiUnselect(&SPID1);                /* Slave Select de-assertion.       */    spiReleaseBus(&SPID1);              /* Ownership release.               */  }}

static msg_t spi_thread_2(void *p) {  (void)p;  chRegSetThreadName("SPI thread 2");  while (TRUE) {    spiAcquireBus(&SPID1);              /* Acquire ownership of the bus.    */    palSetPad(IOPORT3, GPIOC_LED);      /* LED OFF.                         */    spiStart(&SPID1, &ls_spicfg);       /* Setup transfer parameters.       */    spiSelect(&SPID1);                  /* Slave Select assertion.          */    spiExchange(&SPID1, 512,                txbuf, rxbuf);          /* Atomic transfer operations.      */    spiUnselect(&SPID1);                /* Slave Select de-assertion.       */    spiReleaseBus(&SPID1);              /* Ownership release.               */  }  return 0;}

static msg_t spi_thread_1(void *p) {    (void)p;    chRegSetThreadName("SPI thread 1");    while (TRUE) {        spiAcquireBus(&SPID2);              /* Acquire ownership of the bus.    */        palClearPad(PORT11, P11_LED1);      /* LED ON.                          */        spiStart(&SPID2, &hs_spicfg);       /* Setup transfer parameters.       */        spiSelect(&SPID2);                  /* Slave Select assertion.          */        spiExchange(&SPID2, 512,                    txbuf, rxbuf);          /* Atomic transfer operations.      */        spiUnselect(&SPID2);                /* Slave Select de-assertion.       */        spiReleaseBus(&SPID2);              /* Ownership release.               */    }    return 0;}