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); }
//---------------------------------------------------------------------------- void spiEepromDisableWrite(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; }
void initHip9011(void) { initLogging(&logger, "HIP driver"); print("Starting HIP9011/TPIC8101 driver\r\n"); spiStart(driver, &spicfg); chThdCreateStatic(htThreadStack, sizeof(htThreadStack), NORMALPRIO, (tfunc_t) ivThread, NULL); }
/* * 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 void xflash_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. */ }