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

int main(void) {	thread_t *sh = NULL;	PollerData.temp = 0;	PollerData.press = 0;/*	PollerData.uTime = 0;*/	halInit();	chSysInit();	shellInit();		usbDisconnectBus(serusbcfg.usbp);	chThdSleepMilliseconds(1000);	usbStart(serusbcfg.usbp, &usbcfg);	usbConnectBus(serusbcfg.usbp);		sduObjectInit(&SDU1);	sduStart(&SDU1, &serusbcfg);	// SPI-related pins (for display)	palSetPadMode(GPIOB, 11, PAL_MODE_OUTPUT_PUSHPULL); 	palSetPadMode(GPIOB, 10, PAL_MODE_OUTPUT_PUSHPULL);	palSetPadMode(GPIOB, 13, PAL_MODE_ALTERNATE(5));	palSetPadMode(GPIOB, 14, PAL_MODE_OUTPUT_PUSHPULL);	palSetPadMode(GPIOB, 15, PAL_MODE_ALTERNATE(5));	spiStart(&SPID1, &spi1cfg);	spiStart(&SPID2, &spi2cfg);	i2cStart(&I2CD1, &i2cconfig);	initGyro();	initAccel();	initMag();//	nunchuk_status = nunchuk_init();	bmp085_status = bmp085_init();	lcd5110Init();	lcd5110SetPosXY(0, 0);	lcd5110WriteText("P :: ");	lcd5110SetPosXY(0, 1);	lcd5110WriteText("T :: ");	chThdCreateStatic(waThreadBlink, sizeof(waThreadBlink), NORMALPRIO, ThreadBlink, NULL);	chThdCreateStatic(waThreadButton, sizeof(waThreadButton), NORMALPRIO, ThreadButton, NULL);	chThdCreateStatic(waPoller, sizeof(waPoller), NORMALPRIO, ThreadPoller, NULL);    while (TRUE) {		if (!sh) {			sh = shellCreate(&shCfg, SHELL_WA_SIZE, NORMALPRIO);		}		else if (chThdTerminatedX(sh)) {			chThdRelease(sh);			sh = NULL;		}		chThdSleepMilliseconds(1000);	}	return 0; // never returns, lol}

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

int main(void) {    halInit();    chSysInit();    chThdSleepMilliseconds(200);    // input capture & high-res timer    const ICUConfig icuConfig = { ICU_INPUT_ACTIVE_HIGH, 1000000, nullptr, nullptr, nullptr, nullptr, nullptr };    icuStart(&TIMING_ICU, &icuConfig);    icuEnable(&TIMING_ICU);    // serial setup    const SerialConfig btSerialConfig = { 921600, 0, USART_CR2_STOP1_BITS, USART_CR3_CTSE | USART_CR3_RTSE };    sdStart(&BT_SERIAL, &btSerialConfig);    // PWM setup    const PWMConfig mPWMConfig = { STM32_TIMCLK1, PWM_PERIOD, nullptr, {            { PWM_OUTPUT_DISABLED, nullptr },            { PWM_OUTPUT_DISABLED, nullptr },            { PWM_OUTPUT_ACTIVE_HIGH, nullptr },            { PWM_OUTPUT_ACTIVE_HIGH, nullptr } }, 0, };    pwmStart(&M1_PWM, &mPWMConfig);    // SPI setup    // speed = pclk/8 = 5.25MHz    const SPIConfig m1SPIConfig = { NULL, GPIOC, GPIOC_M1_NSS, SPI_CR1_DFF | SPI_CR1_BR_1 };    const SPIConfig m2SPIConfig = { NULL, GPIOD, GPIOD_M2_NSS, SPI_CR1_DFF | SPI_CR1_BR_1 };    const SPIConfig adcSPIConfig = { NULL, GPIOA, GPIOA_ADC_NSS, SPI_CR1_BR_2 | SPI_CR1_CPHA };    spiStart(&M1_SPI, &m1SPIConfig);    spiStart(&M2_SPI, &m2SPIConfig);    spiStart(&ADC_SPI, &adcSPIConfig);    // motor setup    A4960 m1(&M1_SPI, &M1_PWM, M1_PWM_CHAN);    A4960 m2(&M2_SPI, &M2_PWM, M2_PWM_CHAN);    // ADC setup    ADS1259 adc(&ADC_SPI);    // initialize control structure    Tortilla tortilla(m1, m2, adc, &TIMING_ICU, &BT_SERIAL);    // start slave threads//    chThdCreateStatic(waHeartbeat, sizeof(waHeartbeat), IDLEPRIO, tfunc_t(threadHeartbeat), nullptr);    chThdCreateStatic(waIO, sizeof(waIO), LOWPRIO, tfunc_t(threadIO), &tortilla);    // done with setup    palClearPad(GPIOC, GPIOC_LEDB);    palClearPad(GPIOB, GPIOB_LED2);    tortilla.fastLoop();}

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}

void demo_acc_start(accelerometer_callback callback){    static const SPIConfig spi1cfg = {        NULL,        /* HW dependent part.*/        GPIOE,        GPIOE_CS_SPI,        SPI_CR1_BR_0 | SPI_CR1_BR_1 | SPI_CR1_CPOL | SPI_CR1_CPHA    };    spiStart(&SPID1, &spi1cfg);    acc_callback = callback;    chThdSleepMilliseconds(500);    /* LIS302DL initialization.*/    lis302dlWriteRegister(&SPID1, LIS302DL_CTRL_REG1, 0x43);    lis302dlWriteRegister(&SPID1, LIS302DL_CTRL_REG2, 0x00);    lis302dlWriteRegister(&SPID1, LIS302DL_CTRL_REG3, 0x00);    chThdCreateStatic(waAcceleroThd,                      sizeof(waAcceleroThd),                      NORMALPRIO + 10,                      AcceleroThd,                      NULL);}

/* * Application entry point. */int main(void) {  /*   * 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 SPID1. Slave select is configured on GPIOC pin 0. This is   * PCS4 for the KINETIS DSPI managed slave select.   */  palSetPadMode(GPIOC, 5, PAL_MODE_ALTERNATIVE_2);  /* SCK  */  palSetPadMode(GPIOC, 6, PAL_MODE_ALTERNATIVE_2);  /* MOSI */  palSetPadMode(GPIOD, 3, PAL_MODE_ALTERNATIVE_2);  /* MISO */  palSetPadMode(GPIOC, 0, PAL_MODE_ALTERNATIVE_2);  /* SS   */  /*   *  Initializes the SPI driver 1.   */  spiStart(&SPID1, &spi1cfg);  /*   * Creates the blinker threads.   */  chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);  while (1) {    chThdSleepMilliseconds(500);  }}

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

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

int main(void){        halInit();    chSysInit();     /*     * Initializes the SPI driver 1.     */    spiStart(&SPID1, &spicfg);        chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);    chThdCreateStatic(waSegThread1, sizeof(waSegThread1), NORMALPRIO+2, SegThread1, NULL);    //chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO+2, Thread2, NULL);    //chThdCreateStatic(waPWMThread2, sizeof(waPWMThread2), NORMALPRIO+1, PWMThread2, NULL);            init_digit_pins();    init_SPI1();    palSetPadMode(GPIOC, 8, PAL_MODE_OUTPUT_PUSHPULL);    palSetPadMode(GPIOC, 9, PAL_MODE_OUTPUT_PUSHPULL);//TestThread(&SD1);    while (TRUE){        palSetPad(GPIOC, 8);        //TestThread(&SD1);        chThdSleepMilliseconds(500);        palClearPad(GPIOC, 8);        chThdSleepMilliseconds(500);    }}

/** * @brief   Starts a sequential write. * * @param[in] mmcp      pointer to the @p MMCDriver object * @param[in] startblk  first block to write * * @return              The operation status. * @retval HAL_SUCCESS   the operation succeeded. * @retval HAL_FAILED    the operation failed. * * @api */bool mmcStartSequentialWrite(MMCDriver *mmcp, uint32_t startblk) {  osalDbgCheck(mmcp != NULL);  osalDbgAssert(mmcp->state == BLK_READY, "invalid state");  /* Write operation in progress.*/  mmcp->state = BLK_WRITING;  spiStart(mmcp->config->spip, mmcp->config->hscfg);  spiSelect(mmcp->config->spip);  if (mmcp->block_addresses) {    send_hdr(mmcp, MMCSD_CMD_WRITE_MULTIPLE_BLOCK, startblk);  }  else {    send_hdr(mmcp, MMCSD_CMD_WRITE_MULTIPLE_BLOCK,             startblk * MMCSD_BLOCK_SIZE);  }  if (recvr1(mmcp) != 0x00U) {    spiStop(mmcp->config->spip);    mmcp->state = BLK_READY;    return HAL_FAILED;  }  return HAL_SUCCESS;}

/** * @brief   Starts a sequential read. * * @param[in] mmcp      pointer to the @p MMCDriver object * @param[in] startblk  first block to read * * @return              The operation status. * @retval CH_SUCCESS   the operation succeeded. * @retval CH_FAILED    the operation failed. * * @api */bool_t mmcStartSequentialRead(MMCDriver *mmcp, uint32_t startblk) {  chDbgCheck(mmcp != NULL, "mmcStartSequentialRead");  chDbgAssert(mmcp->state == BLK_READY,              "mmcStartSequentialRead(), #1", "invalid state");  /* Read operation in progress.*/  mmcp->state = BLK_READING;  /* (Re)starting the SPI in case it has been reprogrammed externally, it can     happen if the SPI bus is shared among multiple peripherals.*/  spiStart(mmcp->config->spip, mmcp->config->hscfg);  spiSelect(mmcp->config->spip);  if (mmcp->block_addresses)    send_hdr(mmcp, MMCSD_CMD_READ_MULTIPLE_BLOCK, startblk);  else    send_hdr(mmcp, MMCSD_CMD_READ_MULTIPLE_BLOCK, startblk * MMCSD_BLOCK_SIZE);  if (recvr1(mmcp) != 0x00) {    spiStop(mmcp->config->spip);    return CH_FAILED;  }  return CH_SUCCESS;}

/** * @brief   Starts a sequential read. * * @param[in] mmcp      pointer to the @p MMCDriver object * @param[in] startblk  first block to read * @return              The operation status. * @retval FALSE        the operation was successful. * @retval TRUE         the operation failed. */bool_t mmcStartSequentialRead(MMCDriver *mmcp, uint32_t startblk) {  chDbgCheck(mmcp != NULL, "mmcStartSequentialRead");  chSysLock();  if (mmcp->mmc_state != MMC_READY) {    chSysUnlock();    return TRUE;  }  mmcp->mmc_state = MMC_READING;  chSysUnlock();  spiStart(mmcp->mmc_spip, mmcp->mmc_hscfg);  spiSelect(mmcp->mmc_spip);  send_hdr(mmcp, MMC_CMDREADMULTIPLE, startblk * MMC_SECTOR_SIZE);  if (recvr1(mmcp) != 0x00) {    spiUnselect(mmcp->mmc_spip);    chSysLock();    if (mmcp->mmc_state == MMC_READING)      mmcp->mmc_state = MMC_READY;    chSysUnlock();    return TRUE;  }  return FALSE;}

void dma_storm_spi_start(void){  its = 0;  stop = false;  chBSemObjectInit(&sem, true);  spiStart(&SPID1, &spicfg);  spiStartExchange(&SPID1, SPI_BUF_SIZE, testbuf_flash, testbuf_ram);}

/** * @brief   Starts a sequential read. * * @param[in] mmcp      pointer to the @p MMCDriver object * @param[in] startblk  first block to read * * @return              The operation status. * @retval FALSE        the operation succeeded. * @retval TRUE         the operation failed. * * @api */bool_t mmcStartSequentialRead(MMCDriver *mmcp, uint32_t startblk) {  chDbgCheck(mmcp != NULL, "mmcStartSequentialRead");  chSysLock();  if (mmcp->state != MMC_READY) {    chSysUnlock();    return TRUE;  }  mmcp->state = MMC_READING;  chSysUnlock();  spiStart(mmcp->config->spip, mmcp->config->hscfg);  spiSelect(mmcp->config->spip);  if(mmcp->block_addresses)    send_hdr(mmcp, MMCSD_CMD_READ_MULTIPLE_BLOCK, startblk);  else    send_hdr(mmcp, MMCSD_CMD_READ_MULTIPLE_BLOCK, startblk * MMCSD_BLOCK_SIZE);  if (recvr1(mmcp) != 0x00) {    spiUnselect(mmcp->config->spip);    chSysLock();    if (mmcp->state == MMC_READING)      mmcp->state = MMC_READY;    chSysUnlock();    return TRUE;  }  return FALSE;}

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

/** * @brief   Starts a sequential write. * * @param[in] mmcp      pointer to the @p MMCDriver object * @param[in] startblk  first block to write * @return              The operation status. * @retval FALSE        the operation succeeded. * @retval TRUE         the operation failed. * * @api */bool_t mmcStartSequentialWrite(MMCDriver *mmcp, uint32_t startblk) {  chDbgCheck(mmcp != NULL, "mmcStartSequentialWrite");  chSysLock();  if (mmcp->state != MMC_READY) {    chSysUnlock();    return TRUE;  }  mmcp->state = MMC_WRITING;  chSysUnlock();  spiStart(mmcp->spip, mmcp->hscfg);  spiSelect(mmcp->spip);  if(mmcp->block_addresses)    send_hdr(mmcp, MMC_CMDWRITEMULTIPLE, startblk);  else    send_hdr(mmcp, MMC_CMDWRITEMULTIPLE, startblk * MMC_SECTOR_SIZE);  if (recvr1(mmcp) != 0x00) {    spiUnselect(mmcp->spip);    chSysLock();    if (mmcp->state == MMC_WRITING)      mmcp->state = MMC_READY;    chSysUnlock();    return TRUE;  }  return FALSE;}

int memsSetup(SPIDriver *spi, uint8_t DMA) {  if (!DMA) {    spiStart(spi, &spi1cfg); // start spi    sdriver = spi;  }  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;}

int main(void) {  halInit();  chSysInit();  uint8_t i;  event_listener_t tel;  // Serial Port Setup   sdStart(&SD1, NULL);  palSetPadMode(GPIOC, 4, PAL_MODE_ALTERNATE(7));  palSetPadMode(GPIOC, 5, PAL_MODE_ALTERNATE(7));  chprintf((BaseSequentialStream*)&SD1, "Up and Running/n/r");  palSetPadMode(GPIOB, 3, PAL_MODE_ALTERNATE(6));     /* SCK. */  palSetPadMode(GPIOB, 4, PAL_MODE_ALTERNATE(6));     /* MISO.*/  palSetPadMode(GPIOB, 5, PAL_MODE_ALTERNATE(6));     /* MOSI.*/  palSetPadMode(GPIOC, GPIOC_PIN1, PAL_MODE_OUTPUT_PUSHPULL);  palSetPad(GPIOC, GPIOC_PIN1);  palSetPadMode(GPIOC, GPIOC_PIN2, PAL_MODE_OUTPUT_PUSHPULL);  palClearPad(GPIOC, GPIOC_PIN2);  palSetPadMode(GPIOC, GPIOC_PIN3, PAL_MODE_INPUT_PULLUP);  spiStart(&SPID3, &nrf24l01SPI);  chMtxObjectInit(&nrfMutex);  //FROM RX---  extStart(&EXTD1, &extcfg);  //---  nrf24l01ObjectInit(&nrf24l01);  nrf24l01Start(&nrf24l01, &nrf24l01Config);    //FROM RX ---  extChannelEnable(&EXTD1, 3);  //-----    initNRF24L01(&nrf24l01);  chprintf((BaseSequentialStream*)&SD1, "/n/rUp and Running/n/r");  shellInit();  chEvtRegister(&shell_terminated, &tel, 0);  shelltp1 = shellCreate(&shell_cfg1, sizeof(waShell), NORMALPRIO);  //FROM RX---  chThdCreateStatic(recieverWorkingArea, sizeof(recieverWorkingArea), NORMALPRIO, receiverThread, NULL);  //FROM RX^^^^  /*  for (i=0;i<32;i++) {    serialOutBuf[i] = 3;  }  */  for (;;) {    chEvtDispatch(fhandlers, chEvtWaitOne(ALL_EVENTS));      }}

/*********************************************************************************** * @fn          halRadioSpiInit * * @brief       Initalise Radio SPI interface * * @param       none * * @return      none */static void halRadioSpiInit(void){	palSetPad(CC2520_SPI_CSN_PORT, CC2520_SPI_CSN_PIN);	palSetPadMode(CC2520_SPI_CSN_PORT, CC2520_SPI_CSN_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);	CC2520_ENABLE_SPI_FUNC();	spiStart(&CC2520_SPI, &spicfg);}

//----------------------------------------------------------------------------voidspiEepromDisableWrite(spiEepromDriver * sedp){	spiStart(sedp->spip, &sedp->cfgp->spicfg);	spiSelect(sedp->spip);	spiPolledExchange(sedp->spip, OP_WRDI);	spiUnselect(sedp->spip);}

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 int SPIExchangeData(SPIDriver *SPIPtr, uint8_t *TxBuf, uint8_t *RxBuf, size_t Size)  {    spiStart(SPIPtr, &HSSpiConfig); /* Setup transfer parameters.       */    spiSelect(SPIPtr); /* Slave Select assertion.          */    spiExchange(SPIPtr, Size, TxBuf, RxBuf); /* Atomic transfer operations.      */    spiUnselect(SPIPtr); /* Slave Select de-assertion.       */    return 0;  }

/* * Application entry point. */int main(void) {  Thread *shelltp = NULL;  /*   * 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 serial driver 1 using the driver default configuration.   */  sdStart(&SERIAL_DRIVER, NULL);  /*   * Shell manager initialization.   */  shellInit();  /*   * Activates the EXT driver.   */  extStart(&EXTD1, &extcfg);  /*   * Activates the I2C driver.   */  i2cStart(&I2C_DRIVER, &i2c1cfg);  /*   * Activates the SPI driver.   */  spiStart(&SPI_DRIVER, &spi1cfg);  /*   * Creates the blinker thread.   */  chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);  /*   * Normal main() thread activity, in this demo it does nothing except   * sleeping in a loop and check the button state.   */  while (TRUE) {    if (!shelltp)      shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO - 1);    else if (chThdTerminated(shelltp)) {      chThdRelease(shelltp);      shelltp = NULL;    }    chThdSleepMilliseconds(200);  }}

//----------------------------------------------------------------------------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 voidxflash_txn_begin(){#if SPI_USE_MUTUAL_EXCLUSION  spiAcquireBus(SPI_FLASH);#endif  spiStart(SPI_FLASH, &flash_spi_cfg);  spiSelect(SPI_FLASH);}

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

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

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