// -----------------------------------------------------------------------------
//! \brief This routine closes the transport layer
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITL_closeTL(void)
{
_npiCSKey_t key;
key = NPIUtil_EnterCS();
// Clear NPI Task Call backs
memset(&taskCBs, 0, sizeof(taskCBs));
// Free Transport Layer RX/TX buffers
npiBufSize = 0;
NPIUTIL_FREE(npiRxBuf);
NPIUTIL_FREE(npiTxBuf);
// Close Transport Layer
transportClose();
#ifdef POWER_SAVING
// Close PIN Handle
PIN_close(hNpiHandshakePins);
#ifdef NPI_SW_HANDSHAKING_DEBUG
PIN_close(hNpiProfilingDebugPin);
#endif //NPI_SW_HANDSHAKING
// Release Power Management
NPITL_relPM();
#endif //POWER_SAVING
NPIUtil_ExitCS(key);
}
/*******************************************************************************
* @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++;
}
// -----------------------------------------------------------------------------
//! \brief This routine is used to handle an MRDY transition from a task
//! context. Certain operations such as UART_read() cannot be
//! performed from a HWI context
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITL_handleRemRdyEvent(void)
{
_npiCSKey_t key;
key = NPIUtil_EnterCS();
//If the UART port is closed, then open it
if(HS_GPIO_STATE & handshakingState)
{
NPITL_setPM();
//Close the GPIO, then
//Open the UART
PIN_close(hNpiHandshakePins);
transportOpen(npiTLParams.portBoardID,
&npiTLParams.portParams.uartParams,
NPITL_transmissionCallBack, NPITL_chirpRecievedCB);
handshakingState |= HS_WAITFORCHIRP|HS_UART_STATE;
//Clear GPIO flag, we are no longer in this state
handshakingState &= ~HS_GPIO_STATE;
}
else
{
//Once UART is open
//Handle the RemRdy Event
transportRemRdyEvent();
}
NPIUtil_ExitCS(key);
}
// -----------------------------------------------------------------------------
//! \brief This routine closes the transport layer
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITL_closeTL(void)
{
_npiCSKey_t key;
key = NPIUtil_EnterCS();
// Clear NPI Task Call backs
memset(&taskCBs, 0, sizeof(taskCBs));
// Free Transport Layer RX/TX buffers
npiBufSize = 0;
NPIUTIL_FREE(npiRxBuf);
NPIUTIL_FREE(npiTxBuf);
// Close Transport Layer
transportClose();
#if (NPI_FLOW_CTRL == 1)
// Clear mrdy and srdy PIN IDs
remRdyPIN = (IOID_UNUSED & IOC_IOID_MASK); // Set to 0x000000FF
locRdyPIN = (IOID_UNUSED & IOC_IOID_MASK); // Set to 0x000000FF
// Clear PIN IDs from PIN Configuration
npiHandshakePinsCfg[REM_RDY_PIN_IDX] &= ~remRdyPIN;
npiHandshakePinsCfg[LOC_RDY_PIN_IDX] &= ~locRdyPIN;
// Close PIN Handle
PIN_close(hNpiHandshakePins);
// Release Power Management
NPITL_relPM();
#endif // NPI_FLOW_CTRL = 1
NPIUtil_ExitCS(key);
}
// -----------------------------------------------------------------------------
//! \brief This routine calls the UART transport open
//!
//! \param[in] initiatorState - Whether the UART is being opened by initiator
//! or responder. 1 - initiator 0 - responsder
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITL_openTransportPort(hsTransactionRole role)
{
NPITL_setPM();
// Close the RxPin
PIN_close(hNpiUartRxPin);
transportOpen(npiTLParams.portBoardID,
&npiTLParams.portParams.uartParams, role);
trasnportLayerState = TL_busy;
}
/**
* @fn SBL_resetTarget
*
* @brief Forces target device to boot from flash image instead of SBL. This
* function can be called before SBL_open() or after SBL_open()
*
* @param rstPinID - Board Pin ID of reset PIN
* @param blPinID - Board Pin ID of boot loader PIN
*
* @return uint8_t - SBL_SUCCESS, SBL_FAILURE
*/
uint8_t SBL_resetTarget(uint32_t rstPinID, uint32_t blPinID)
{
uint8_t openedPins = 0;
if (hsblPins == NULL)
{
// Must open pins if SBL_open() has not yet been called
openedPins = 1;
// Assign PIN IDs to reset and bl
rstPIN = (rstPinID & IOC_IOID_MASK);
blPIN = (blPinID & IOC_IOID_MASK);
// Add PIN IDs to PIN Configuration
sblPinsCfg[RST_PIN_IDX] |= rstPIN;
sblPinsCfg[BL_PIN_IDX] |= blPIN;
// Initialize SBL Pins
hsblPins = PIN_open(&sblPins, sblPinsCfg);
if (hsblPins == NULL)
{
return SBL_FAILURE;
}
}
// Guarantee that Boot Loader Pin is high during reset toggle
PIN_setOutputValue(hsblPins, blPIN, 1);
// Set reset PIN low
PIN_setOutputValue(hsblPins, rstPIN, 0);
SBL_utilDelay(15);
// Release Reset PIN
PIN_setOutputValue(hsblPins, rstPIN, 1);
// Must close Pins if opened in function
if (openedPins)
{
// Clear SBL PIN IDs
rstPIN = (IOID_UNUSED & IOC_IOID_MASK); // Set to 0x000000FF
blPIN = (IOID_UNUSED & IOC_IOID_MASK); // Set to 0x000000FF
// Clear PIN IDs from PIN Configuration
sblPinsCfg[RST_PIN_IDX] &= ~rstPIN;
sblPinsCfg[BL_PIN_IDX] &= ~blPIN;
// Close PIN Handle
PIN_close(hsblPins);
hsblPins = NULL;
}
return SBL_SUCCESS;
}
/*******************************************************************************
* @fn devpkLcdClose
*
* @brief Turns of the display and releases the LCD control pins
*
* @return true if success
*/
void devpkLcdClose(void)
{
if (hLcdPin != NULL)
{
// Turn off the display
PIN_setOutputValue(hLcdPin,Board_DEVPK_LCD_DISP,0);
PIN_close(hLcdPin);
hLcdPin = NULL;
bspSpiClose();
}
}
/*!
* @brief Function to close a given CC26XX I2C peripheral specified by the
* I2C handle.
*
* After calling the close function, the I2C is disabled.
*
* @pre I2CCC26XX_open() has to be called first.
* Calling context: Task
*
* @param handle An I2C_Handle returned by I2C_open()
*
* @note The generic I2C API should be used when accessing the I2CCC26XX.
*
* @sa I2CCC26XX_open(), I2C_close(), I2C_open()
*/
void I2CCC26XX_close(I2C_Handle handle)
{
unsigned int key;
I2CCC26XX_Object *object;
I2CCC26XX_HWAttrs const *hwAttrs;
/* Get the pointer to the object and hwAttrs */
hwAttrs = handle->hwAttrs;
object = handle->object;
/* Check to see if a I2C transaction is in progress */
Assert_isTrue(object->headPtr == NULL, NULL);
/* Deallocate pins */
PIN_close(hPin);
/* Mask I2C interrupts */
I2CMasterIntDisable(hwAttrs->baseAddr);
/* Disable the I2C Master */
I2CMasterDisable(hwAttrs->baseAddr);
/* Release power constraint*/
threadSafeStdbyDisRelease();
/* Power off the I2C module */
Power_releaseDependency(hwAttrs->powerMngrId);
Hwi_destruct(&(object->hwi));
Semaphore_destruct(&(object->mutex));
if (object->transferMode == I2C_MODE_BLOCKING) {
Semaphore_destruct(&(object->transferComplete));
}
/* Unregister power post notification object */
Power_unregisterNotify(&object->i2cPostObj);
/* Mark the module as available */
key = Hwi_disable();
object->isOpen = false;
Hwi_restore(key);
Log_print1(Diags_USER1, "I2C: Object closed 0x%x", hwAttrs->baseAddr);
return;
}
/**
* @fn SBL_close
*
* @brief Closes SBL port
*
* @param None.
*
* @return uint8_t - SBL_SUCCESS, SBL_FAILURE
*/
uint8_t SBL_close(void)
{
// Clear SBL PIN IDs
rstPIN = (IOID_UNUSED & IOC_IOID_MASK); // Set to 0x000000FF
blPIN = (IOID_UNUSED & IOC_IOID_MASK); // Set to 0x000000FF
// Clear PIN IDs from PIN Configuration
sblPinsCfg[RST_PIN_IDX] &= ~rstPIN;
sblPinsCfg[BL_PIN_IDX] &= ~blPIN;
// Close PIN Handle
PIN_close(hsblPins);
hsblPins = NULL;
// Close SBL Transport Layer
SBL_TL_close();
return SBL_SUCCESS;
}
/*!
* @brief Function to close a given CC26XX SPI peripheral specified by the
* SPI handle.
*
* Will disable the SPI, disable all SPI interrupts and release the
* dependency on the corresponding power domain.
*
* @pre SPICC26XXDMA_open() has to be called first.
* Calling context: Task
*
* @param handle A SPI_Handle returned from SPI_open()
*
* @sa SPICC26XXDMA_open
*/
void SPICC26XXDMA_close(SPI_Handle handle)
{
unsigned int key;
SPICC26XX_Object *object;
SPICC26XX_HWAttrs const *hwAttrs;
/* Get the pointer to the object and hwAttrs */
hwAttrs = handle->hwAttrs;
object = handle->object;
/* Release the uDMA dependency and potentially power down uDMA. */
UDMACC26XX_close(object->udmaHandle);
/* Deallocate pins */
PIN_close(object->pinHandle);
/* Disable the SPI */
SSIDisable(hwAttrs->baseAddr);
/* Destroy the Hwi */
Hwi_destruct(&(object->hwi));
/* Release power dependency on SPI. */
Power_releaseDependency(hwAttrs->powerMngrId);
if (object->transferMode == SPI_MODE_BLOCKING) {
Semaphore_destruct(&(object->transferComplete));
}
/* Unregister power notification objects */
#ifdef SPICC26XXDMA_WAKEUP_ENABLED
Power_unregisterNotify(&object->spiPreObj);
#endif
Power_unregisterNotify(&object->spiPostObj);
/* Mark the module as available */
key = Hwi_disable();
object->isOpen = false;
Hwi_restore(key);
Log_print1(Diags_USER1, "SPI:(%p) closed", hwAttrs->baseAddr);
}
// -----------------------------------------------------------------------------
//! \brief This routine closes the transport layer
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITL_closeTL(void)
{
_npiCSKey_t key;
key = NPIUtil_EnterCS();
// Clear NPI Task Call backs
memset(&taskCBs, 0, sizeof(taskCBs));
// Free Transport Layer RX/TX buffers
npiBufSize = 0;
NPIUTIL_FREE(npiRxBuf);
NPIUTIL_FREE(npiTxBuf);
// Close the RxPin
PIN_close(hNpiUartRxPin);
// Close UART transport Layer
transportClose();
trasnportLayerState = TL_closed;
NPITL_relPM();
NPIUtil_ExitCS(key);
}
void taskFxn(UArg a0, UArg a1) {
Hwi_Params hwiParams;
Hwi_Params_init(&hwiParams);
hwiParams.enableInt = true;
Hwi_construct(&hwi, INT_AUX_ADC, adcIsr, &hwiParams, NULL);
UART_Params uParams;
// Initialize default values
UART_Params_init(&uParams);
// Configure custom data, don't care about read params as not used
// 115.2kBaud, Text, blocking mode
uHandle = UART_open(Board_UART,&uParams);
// Set up pins
pinHandle = PIN_open(&pinState, alsPins);
// Enable clock for ADC digital and analog interface (not currently enabled in driver)
AUXWUCClockEnable(AUX_WUC_MODCLKEN0_SOC_M|AUX_WUC_MODCLKEN0_AUX_ADI4_M);
// Connect AUX IO7 (DIO23) as analog input. Light sensor on SmartRF06EB
AUXADCSelectInput(ADC_COMPB_IN_AUXIO7);
// Set up ADC
AUXADCEnableSync(AUXADC_REF_FIXED, AUXADC_SAMPLE_TIME_2P7_US, AUXADC_TRIGGER_MANUAL);
// Disallow STANDBY mode while using the ADC.
Power_setConstraint(Power_SB_DISALLOW);
uint8_t currentSample = 0;
while(currentSample < SAMPLECOUNT) {
//Sleep 100ms in IDLE mode
Task_sleep(100 * 1000 / Clock_tickPeriod);
// Trigger ADC sampling
AUXADCGenManualTrigger();
// Wait in IDLE until done
Semaphore_pend(hSem, BIOS_WAIT_FOREVER );
adcSamples[currentSample++] = singleSample;
}
// Disable ADC
AUXADCDisable();
// Allow STANDBY mode again
Power_releaseConstraint(Power_SB_DISALLOW);
// Restore pins to values in BoardGpioTable
PIN_close(pinHandle);
// Log data through UART
uint8_t i;
for(i = 0; i<SAMPLECOUNT; i++ ) {
UART_write(uHandle, &adcSamples[i], SAMPLESIZE);
}
// Goto STANDBY forever
Task_sleep(BIOS_WAIT_FOREVER);
}
