/******************************************************************************* * @fn bspSpiOpen * * @brief Open the RTOS SPI driver * * @param none * * @return none */ void bspSpiOpen(void) { if (hSpiPin != NULL) { // Remove IO configuration of SPI lines PIN_close(hSpiPin); hSpiPin = NULL; } if (spiHandle == NULL) { /* Configure SPI as master, 1 mHz bit rate*/ SPI_Params_init(&spiParams); spiParams.bitRate = 1000000; spiParams.mode = SPI_MASTER; spiParams.transferMode = SPI_MODE_BLOCKING; /* Attempt to open SPI. */ spiHandle = SPI_open(Board_SPI0, &spiParams); if (spiHandle == NULL) { Task_exit(); } } nUsers++; }
void spiLcd_Init() { SPI_Handle handle; SPI_Params params; SPI_Transaction transaction; //PIN_Id csnPin1 = PIN_ID(Board_CSN_1); uint8_t txBuf[] = "Hello World"; // Transmit buffer // Init SPI and specify non-default parameters SPI_Params_init(¶ms); params.bitRate = 1000000; params.frameFormat = SPI_POL1_PHA1; params.mode = SPI_MASTER; // Configure the transaction transaction.count = sizeof(txBuf); transaction.txBuf = txBuf; transaction.rxBuf = NULL; // Open the SPI and perform transfer to the first slave handle = SPI_open(Board_SPI0, ¶ms); SPI_transfer(handle, &transaction); // Then switch chip select pin and perform transfer to the second slave //SPI_control(handle, SPICC26XXDMA_SET_CSN_PIN, &csnPin1); //SPI_transfer(handle, &transaction); }
bool LIS3DH_Initialize(void) { SPI_Params spiParams; SPI_init(); // Init SPI and specify non-default parameters SPI_Params_init(&spiParams); spiParams.mode = SPI_MASTER; spiParams.transferMode = SPI_MODE_BLOCKING; //SPI_MODE_CALLBACK; //SPI_MODE_CALLBACK; // SPI_MODE_BLOCKING spiParams.transferCallbackFxn = sbp_spiCallback; spiParams.bitRate = 800000; spiParams.frameFormat = SPI_POL1_PHA1;// Clock to be normally high, write on the falling edge and capture data on the rising edge //SPI_POL1_PHA1; (clock is normally high) //SPI_POL0_PHA0; (clock is normally low) // spiParams.dataSize = 16; spiHandle = SPI_open(MOTIONSNS_SPI, &spiParams); /* params.bitRate = 1000000; params.frameFormat = SPI_POL1_PHA1; params.mode = SPI_MASTER; */ // Open the SPI and perform the transfer // handle = SPI_open(MOTIONSNS_SPI, ¶ms); PINCC26XX_setOutputEnable(SPI_CS, 1); PINCC26XX_setOutputValue(SPI_CS, 1); PINCC26XX_setOutputEnable(SPI_MISO, 0); return LIS3DH_VerifyCommunication(); }
/* * ======== spi_Open ======== * SimpleLink Host Driver API to open a SPI communication interface. */ Fd_t spi_Open(char *ifName, unsigned long flags) { WiFiCC3100_Object *object = wifiHandle->object; SPI_Params spiParams; SPI_Params_init(&spiParams); spiParams.bitRate = object->bitRate; spiParams.transferMode = SPI_MODE_CALLBACK; spiParams.transferCallbackFxn = WiFiCC3100_spiCallbackFxn; object->spiHandle = SPI_open(object->spiIndex, &spiParams); if (object->spiHandle == NULL) { Log_error1("WiFi SPI (%p) could not be initialized\n", object->spiIndex); return (-1); } object->spiState = WiFiCC3100_SPI_IDLE; Log_print1(Diags_USER1, "WiFi SPI (%p) open\n", (Fd_t) object->spiHandle); return ((Fd_t) object->spiHandle); }
// ----------------------------------------------------------------------------- //! \brief This routine initializes the transport layer and opens the port //! of the device. //! //! \param[in] tRxBuf - pointer to NPI TL Tx Buffer //! \param[in] tTxBuf - pointer to NPI TL Rx Buffer //! \param[in] npiCBack - NPI TL call back function to be invoked at the end of //! a SPI transaction //! //! \return void // ----------------------------------------------------------------------------- void NPITLSPI_initializeTransport(Char *tRxBuf, Char *tTxBuf, npiCB_t npiCBack) { SPI_Params spiParams; TransportRxBuf = tRxBuf; TransportTxBuf = tTxBuf; npiTransmitCB = npiCBack; // Configure SPI parameters SPI_Params_init(&spiParams); // Slave mode spiParams.mode = SPI_SLAVE; spiParams.bitRate = SPI_SLAVE_BAUD_RATE; spiParams.frameFormat = SPI_POL1_PHA1; spiParams.transferMode = SPI_MODE_CALLBACK; spiParams.transferCallbackFxn = NPITLSPI_CallBack; // Attempt to open SPI spiHandle = SPI_open(NPI_SPI_CONFIG, &spiParams); return; }
/*! * @brief Function to initialize the CC26XX SPI peripheral specified by the * particular handle. The parameter specifies which mode the SPI * will operate. * * The function will set a dependency on it power domain, i.e. power up the * module and enable the clock. The IOs are allocated. Neither the SPI nor UDMA module * will be enabled. * * @pre SPI controller has been initialized. * Calling context: Task * * @param handle A SPI_Handle * * @param params Pointer to a parameter block, if NULL it will use * default values * * @return A SPI_Handle on success or a NULL on an error or if it has been * already opened * * @sa SPICC26XXDMA_close() */ SPI_Handle SPICC26XXDMA_open(SPI_Handle handle, SPI_Params *params) { /* Use union to save on stack allocation */ union { Semaphore_Params semParams; Hwi_Params hwiParams; } paramsUnion; SPI_Params defaultParams; SPICC26XX_Object *object; SPICC26XX_HWAttrs const *hwAttrs; unsigned int key; /* Get the pointer to the object and hwAttrs */ object = handle->object; hwAttrs = handle->hwAttrs; /* Disable preemption while checking if the SPI is open. */ key = Hwi_disable(); /* Check if the SPI is open already with the base addr. */ if (object->isOpen == true) { Hwi_restore(key); Log_warning1("SPI:(%p) already in use.", hwAttrs->baseAddr); return (NULL); } /* Mark the handle as being used */ object->isOpen = true; Hwi_restore(key); /* If params are NULL use defaults */ if (params == NULL) { /* No params passed in, so use the defaults */ SPI_Params_init(&defaultParams); params = &defaultParams; } Assert_isTrue((params->dataSize >= 4) && (params->dataSize <= 16), NULL); /* Initialize the SPI object */ object->currentTransaction = NULL; object->bitRate = params->bitRate; object->dataSize = params->dataSize; object->frameFormat = params->frameFormat; object->mode = params->mode; object->transferMode = params->transferMode; object->transferTimeout = params->transferTimeout; object->returnPartial = false; #ifdef SPICC26XXDMA_WAKEUP_ENABLED object->wakeupCallbackFxn = NULL; #endif /* Determine if we need to use an 8-bit or 16-bit framesize for the DMA */ object->frameSize = (params->dataSize < 9) ? SPICC26XXDMA_8bit : SPICC26XXDMA_16bit; Log_print2(Diags_USER2,"SPI:(%p) DMA buffer incrementation size: %s", hwAttrs->baseAddr, (object->frameSize) ? (UArg)"16-bit" : (UArg)"8-bit"); /* Register power dependency - i.e. power up and enable clock for SPI. */ Power_setDependency(hwAttrs->powerMngrId); /* Configure the hardware module */ SPICC26XXDMA_initHw(handle); /* CSN is initialized using hwAttrs initially, but can be re-configured later */ object->csnPin = hwAttrs->csnPin; /* Configure IOs after hardware has been initialized so that IOs aren't */ /* toggled unnecessary and make sure it was successful */ if (!SPICC26XXDMA_initIO(handle)) { /* Trying to use SPI driver when some other driver or application * has already allocated these pins, error! */ Log_warning0("Could not allocate SPI pins, already in use."); /* Release power dependency - i.e. potentially power down serial domain. */ Power_releaseDependency(hwAttrs->powerMngrId); /* Mark the module as available */ key = Hwi_disable(); object->isOpen = false; Hwi_restore(key); /* Signal back to application that SPI driver was not succesfully opened */ return (NULL); } /* Create the Hwi for this SPI peripheral. */ Hwi_Params_init(¶msUnion.hwiParams); paramsUnion.hwiParams.arg = (UArg) handle; Hwi_construct(&(object->hwi), (int) hwAttrs->intNum, SPICC26XXDMA_hwiFxn, ¶msUnion.hwiParams, NULL); /* Check the transfer mode */ if (object->transferMode == SPI_MODE_BLOCKING) { Log_print1(Diags_USER2, "SPI DMA:(%p) in SPI_MODE_BLOCKING mode", hwAttrs->baseAddr); /* Create a semaphore to block task execution for the duration of the * SPI transfer */ Semaphore_Params_init(¶msUnion.semParams); paramsUnion.semParams.mode = Semaphore_Mode_BINARY; Semaphore_construct(&(object->transferComplete), 0, ¶msUnion.semParams); /* Store internal callback function */ object->transferCallbackFxn = SPICC26XXDMA_transferCallback; } else { Log_print1(Diags_USER2, "SPI DMA:(%p) in SPI_MODE_CALLBACK mode", hwAttrs->baseAddr); /* Check to see if a callback function was defined for async mode */ Assert_isTrue(params->transferCallbackFxn != NULL, NULL); /* Save the callback function pointer */ object->transferCallbackFxn = params->transferCallbackFxn; } /* Declare the dependency on the UDMA driver */ object->udmaHandle = UDMACC26XX_open(); /* Configure PIN driver for CSN callback in optional RETURN_PARTIAL slave mode */ /* and/or optional wake up on CSN assert slave mode */ if (object->mode == SPI_SLAVE) { PIN_registerIntCb(object->pinHandle, SPICC26XXDMA_csnCallback); PIN_setUserArg(object->pinHandle, (UArg) handle); } Log_print1(Diags_USER1, "SPI:(%p) opened", hwAttrs->baseAddr); /* Register notification functions */ #ifdef SPICC26XXDMA_WAKEUP_ENABLED Power_registerNotify(&object->spiPreObj, Power_ENTERING_STANDBY, (Fxn)spiPreNotify, (UInt32)handle, NULL ); #endif Power_registerNotify(&object->spiPostObj, Power_AWAKE_STANDBY, (Fxn)spiPostNotify, (UInt32)handle, NULL ); return (handle); }