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

//----------------------------------------------------------------------------void spiEepromWriteSR(spiEepromDriver * sedp, uint8_t sr){	spiStart(sedp->spip, &sedp->cfgp->spicfg);	spiSelect(sedp->spip);	spiPolledExchange(sedp->spip, OP_WRSR);	spiPolledExchange(sedp->spip, sr);	spiUnselect(sedp->spip);}

static int SPISendData(SPIDriver *SPIPtr, uint8_t *TxBuf, size_t Size)  {    spiStart(SPIPtr, &HSSpiConfig); /* Setup transfer parameters.       */    spiSelect(SPIPtr); /* Slave Select assertion.          */    spiSend(SPIPtr, Size, TxBuf); /* Send command                     */    spiUnselect(SPIPtr); /* Slave Select de-assertion.       */    spiStop(SPIPtr);    return 0;  }

void _readBuffer(uint16_t len, uint8_t *data){  uint8_t tx[] = { READ_BUF_MEM };  spiSelect(_spip);  spiSend(_spip, 1, tx);  spiReceive(_spip, len, data);  spiUnselect(_spip);}

/** * @brief   Reads a register value. * @pre     The SPI interface must be initialized and the driver started. * * @param[in] spip      pointer to the SPI initerface * @param[in] reg       register number * @return              The register value. */uint8_t lis302dlReadRegister(SPIDriver *spip, uint8_t reg) {  spiSelect(spip);  txbuf[0] = 0x80 | reg;  txbuf[1] = 0xff;  spiExchange(spip, 2, txbuf, rxbuf);  spiUnselect(spip);  return rxbuf[1];}

/** * @brief   Writes a value into a generic register using SPI. * @pre     The SPI interface must be initialized and the driver started. * * @param[in] spip      pointer to the SPI interface * @param[in] reg       starting register address * @param[in] n         number of adjacent registers to write * @param[in] b         pointer to a buffer of values. */static void lis302dlSPIWriteRegister(SPIDriver *spip, uint8_t reg, size_t n,                                     uint8_t* b) {  uint8_t cmd;  (n == 1) ? (cmd = reg) : (cmd = reg | LIS302DL_MS);  spiSelect(spip);  spiSend(spip, 1, &cmd);  spiSend(spip, n, b);  spiUnselect(spip);}

void ad5504Stop(void) {  /* All DAC channels are in the power down mode. */  txBuf[0] = AD5504_CONTROL;  txBuf[1] = AD5504_DAC_A; /* Set DAC channel A to 0. */  spiSelect(&SPID1);  spiSend(&SPID1, 2 * sizeof(uint16_t), (uint8_t *)txBuf);  spiUnselect(&SPID1);}

static voidxflash_txn_begin(){#if SPI_USE_MUTUAL_EXCLUSION  spiAcquireBus(SPI_FLASH);#endif  spiStart(SPI_FLASH, &flash_spi_cfg);  spiSelect(SPI_FLASH);}

void ad5504Init(void) {  /* Only DAC channel A is in the power up mode. */  txBuf[0] = AD5504_CONTROL | AD5504_CR_DAC_A_POWER_UP;  txBuf[1] = AD5504_DAC_A; /* Set DAC channel A to 0. */  spiSelect(&SPID1);  spiSend(&SPID1, 2 * sizeof(uint16_t), (uint8_t *)txBuf);  spiUnselect(&SPID1);}

/** * @brief   Sends a command an returns a single byte response. * * @param[in] mmcp      pointer to the @p MMCDriver object * @param[in] cmd       the command id * @param[in] arg       the command argument * @return              The response as an @p uint8_t value. * @retval 0xFF         timed out. * * @notapi */static uint8_t send_command_R1(MMCDriver *mmcp, uint8_t cmd, uint32_t arg) {  uint8_t r1;  spiSelect(mmcp->config->spip);  send_hdr(mmcp, cmd, arg);  r1 = recvr1(mmcp);  spiUnselect(mmcp->config->spip);  return r1;}

/** * @brief   Reads a generic register value using SPI. * @pre     The SPI interface must be initialized and the driver started. * * @param[in] spip      pointer to the SPI interface * @param[in] reg       starting register address * @param[in] n         number of consecutive registers to read * @param[in] b         pointer to an output buffer. */static void l3gd20SPIReadRegister(SPIDriver *spip, uint8_t reg,  size_t n,                                     uint8_t* b) {  uint8_t cmd;  (n == 1) ? (cmd = reg | L3GD20_RW) : (cmd = reg | L3GD20_RW | L3GD20_MS);  spiSelect(spip);  spiSend(spip, 1, &cmd);  spiReceive(spip, n, b);  spiUnselect(spip);}

/* * Read the current acceleration values from the ADXL on SPI driver `SPID`. * The values are stored in `accels` as three int16s. */static void adxl3x5_read_accel(SPIDriver* SPID, int16_t* accels){    uint8_t adr = 0x32 | (1<<6) | (1<<7);    spiSelect(SPID);    spiSend(SPID, 1, (void*)&adr);    spiReceive(SPID, 6, (void*)accels);    spiUnselect(SPID);}

void _writeBuffer(uint16_t len, uint8_t *data){  uint8_t tx[] = { WRITE_BUF_MEM };  spiSelect(_spip);  spiSend(_spip, 1, tx);  spiSend(_spip, len, data);  spiUnselect(_spip);}

/* * Application entry point. */int main(void) {  uint8_t i;  /*   * System initializations.   * - HAL initialization, this also initializes the configured device drivers   *   and performs the board-specific initializations.   * - Kernel initialization, the main() function becomes a thread and the   *   RTOS is active.   */  halInit();  chSysInit();  /*   * Activates the SD1 and SPI1 drivers.   */  sdStart(&SD1, NULL);                  /* Default: 38400,8,N,1.            */  spiStart(&SPID1, &spicfg);  /*   * Creates the blinker threads.   */  chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);  chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, NULL);  /*   * Normal main() thread activity, in this demo it updates the 7-segments   * display on the LPCXpresso main board using the SPI driver.   */  i = 0;  while (TRUE) {    if (!palReadPad(GPIO0, GPIO0_SW3))      TestThread(&SD1);    spiSelect(&SPID1);    spiSend(&SPID1, 1, &digits[i]);                 /* Non polled method.   */    spiUnselect(&SPID1);    chThdSleepMilliseconds(500);    spiSelect(&SPID1);    spiPolledExchange(&SPID1, digits[i | 0x10]);    /* Polled method.       */    spiUnselect(&SPID1);    chThdSleepMilliseconds(500);    i = (i + 1) & 15;  }}

void adxl362_write_register (uint16_t address, uint8_t data) {    uint8_t command = 0x0A;    spiStart(&SPID1, &adxl362_cfg);      /* Setup transfer parameters. */    spiSelect(&SPID1);                   /* Slave Select assertion.    */    spiSend(&SPID1, 1, &command);        /* Write Command              */    spiSend(&SPID1, 1, &address);        /* Address                    */    spiSend(&SPID1, 1, &data);           /* Data                       */    spiUnselect(&SPID1);                 /* Slave Select de-assertion. */}

static void sendToPot(Mcp42010Driver *driver, int channel, int value) {	lockSpi(SPI_NONE);	spiStart(driver->spi, &driver->spiConfig);	spiSelect(driver->spi);	int word = (17 + channel) * 256 + value;	spiSend(driver->spi, 1, &word);	spiUnselect(driver->spi);	spiStop(driver->spi);	unlockSpi();}

/* * Write a register at address `adr` with value `val` on the ADXL3x5 on SPI * driver `SPID`. */static void adxl3x5_write_u8(SPIDriver* SPID, uint8_t adr, uint8_t val){    uint8_t tx[2];    tx[0] = adr & ~(1<<7 | 1<<6);    tx[1] = val;    spiSelect(SPID);    spiSend(SPID, 2, (void*)tx);    spiUnselect(SPID);}

//----------------------------------------------------------------------------uint8_t spiEepromReadSR(spiEepromDriver * sedp){	spiStart(sedp->spip, &sedp->cfgp->spicfg);	spiSelect(sedp->spip);	spiPolledExchange(sedp->spip, OP_RDSR);	uint8_t sr = spiPolledExchange(sedp->spip, 0x00);	spiUnselect(sedp->spip);	return sr;}

/** * @brief   Sends a command which returns a five bytes response (R3). * * @param[in] mmcp      pointer to the @p MMCDriver object * @param[in] cmd       the command id * @param[in] arg       the command argument * @param[out] response pointer to four bytes wide uint8_t buffer * @return              The first byte of the response (R1) as an @p *                      uint8_t value. * @retval 0xFF         timed out. * * @notapi */static uint8_t send_command_R3(MMCDriver *mmcp, uint8_t cmd, uint32_t arg,                               uint8_t *response) {  uint8_t r1;    spiSelect(mmcp->spip);  send_hdr(mmcp, cmd, arg);  r1 = recvr3(mmcp, response);  spiUnselect(mmcp->spip);  return r1;}

static uint16_t internal_adis16405_read_u16(uint8_t addr_in) {    uint16_t addr_out = (uint16_t)(addr_in & 0x7F) << 8;    uint16_t data_rx;    spiSelect(&ADIS16405_SPID);    spiSend(&ADIS16405_SPID, 1, (void*)&addr_out);    spiReceive(&ADIS16405_SPID, 1, (void*)&data_rx);    spiUnselect(&ADIS16405_SPID);    return data_rx;}

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

static void M25P16ReadPage(uint32_t Address, uint8_t * Buffer)  {    uint8_t Command[] = { M25P16_READ_BYTES, (Address >> 16) & 0xFF, (Address >> 8) & 0xFF, Address & 0xFF};    spiStart(&FLASH_SPI, &HSSpiConfig); /* Setup transfer parameters.       */    spiSelect(&FLASH_SPI); /* Slave Select assertion.          */    spiSend(&FLASH_SPI, 4, Command); /* Send command                     */    spiReceive(&FLASH_SPI, PAGE_SIZE, Buffer);    spiUnselect(&FLASH_SPI); /* Slave Select de-assertion.       */    spiStop(&FLASH_SPI);  }

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

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

/** * @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.}

static void cjWriteRegister(unsigned char regAddr, unsigned char regValue) {	tx_buff[0] = regAddr;	tx_buff[1] = regValue;#ifdef CJ125_DEBUG_SPI	scheduleMsg(logger, "cjWriteRegister: addr=%d value=%d", regAddr, regValue);#endif /* CJ125_DEBUG_SPI */	// todo: extract 'sendSync' method?	spiSelect(driver);	spiSend(driver, 2, tx_buff);	spiUnselect(driver);}

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.}

static uint8_t sp100_read_byte(int n, uint8_t cmd) {    uint8_t rxb[1], txb[1];    txb[0] = cmd;    sp100_spi_start(n);    spiSelect(sp100_spid);    spiSend(sp100_spid, 1, txb);    spiUnselect(sp100_spid);    chThdSleepMicroseconds(60);    spiSelect(sp100_spid);    spiReceive(sp100_spid, 1, rxb);    spiUnselect(sp100_spid);    chThdSleepMicroseconds(60);    sp100_spi_stop();    return rxb[0];}

void spi_transfer(uint8_t *buf, uint16_t len, uint8_t toggle_cs){	spiSelect (SS_PB2);	spiMultiByteTransfer(buf, len);	if (toggle_cs)		spiDeselect (SS_PB2);	return;}

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