/*
* ======== WiFiCC3100_open ========
*/
WiFi_Handle WiFiCC3100_open(WiFi_Handle handle, unsigned int spiIndex,
WiFi_evntCallback evntCallback, WiFi_Params *params)
{
unsigned int key;
WiFiCC3100_Object *object = handle->object;
WiFiCC3100_HWAttrs const *hwAttrs = handle->hwAttrs;
union {
#if !defined(MSP430WARE)
Hwi_Params hwiParams;
#endif
Semaphore_Params semParams;
} paramsUnion;
key = Hwi_disable();
if (object->isOpen) {
Hwi_restore(key);
Log_warning0("WiFi Hwi already in use.");
return (NULL);
}
object->isOpen = true;
Hwi_restore(key);
/* Construct semaphores to block read/write transactions. */
Semaphore_Params_init(&(paramsUnion.semParams));
paramsUnion.semParams.mode = Semaphore_Mode_BINARY;
paramsUnion.semParams.instance->name = "WiFi.writeSemaphore";
Semaphore_construct(&(object->writeSemaphore), 0, &(paramsUnion.semParams));
paramsUnion.semParams.instance->name = "WiFi.readSemaphore";
Semaphore_construct(&(object->readSemaphore), 0, &(paramsUnion.semParams));
#if !defined(MSP430WARE)
Hwi_Params_init(&(paramsUnion.hwiParams));
paramsUnion.hwiParams.arg = (UArg) handle;
paramsUnion.hwiParams.enableInt = false;
/* Hwi_construct cannot fail, use NULL instead of an Error Block */
Hwi_construct(&(object->wifiHwi), hwAttrs->irqIntNum,
WiFiCC3100_hostIntHandler, &(paramsUnion.hwiParams), NULL);
#endif
#if defined(MSP430WARE) || defined(MSP432WARE)
MAP_GPIO_clearInterruptFlag(hwAttrs->irqPort, hwAttrs->irqPin);
MAP_GPIO_enableInterrupt(hwAttrs->irqPort, hwAttrs->irqPin);
#else
GPIOIntClear(hwAttrs->irqPort, hwAttrs->irqPin);
GPIOIntEnable(hwAttrs->irqPort, hwAttrs->irqPin);
#endif
/* Store SPI interface parameters */
object->spiIndex = spiIndex;
object->bitRate = params->bitRate;
return (handle);
}
/*
* ======== Board_initDMA ========
*/
void Board_initDMA(void)
{
Error_Block eb;
Hwi_Params hwiParams;
if (!dmaInitialized) {
Error_init(&eb);
Hwi_Params_init(&hwiParams);
Hwi_construct(&(hwiStruct), INT_UDMAERR, Board_errorDMAHwi,
&hwiParams, &eb);
if (Error_check(&eb)) {
System_abort("Couldn't create DMA error hwi");
}
MAP_PRCMPeripheralClkEnable(PRCM_UDMA, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralReset(PRCM_UDMA);
MAP_uDMAEnable();
MAP_uDMAControlBaseSet(dmaControlTable);
dmaInitialized = true;
}
}
/*
* ======== EK_TM4C123GXL_initDMA ========
*/
void EK_TM4C123GXL_initDMA(void) {
Error_Block eb;
Hwi_Params hwiParams;
if (!DMA_initialized) {
Error_init(&eb);
Hwi_Params_init(&hwiParams);
Hwi_construct(&(hwiStruct), INT_UDMAERR, EK_TM4C123GXL_errorDMAHwi,
&hwiParams, &eb);
if (Error_check(&eb)) {
System_abort("Couldn't create DMA error hwi");
}
SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
uDMAEnable();
uDMAControlBaseSet(EK_TM4C123GXL_DMAControlTable);
DMA_initialized = true;
}
}
/*
* ======== WatchdogCC26XX_open ========
*/
Watchdog_Handle WatchdogCC26XX_open(Watchdog_Handle handle, Watchdog_Params *params)
{
unsigned int key;
Hwi_Params hwiParams;
Watchdog_Params watchdogParams;
WatchdogCC26XX_HWAttrs const *hwAttrs;
WatchdogCC26XX_Object *object;
Types_FreqHz freq;
/* get the pointer to the object and hwAttrs */
object = handle->object;
hwAttrs = handle->hwAttrs;
/* disable preemption while checking if the WatchDog is open. */
key = Hwi_disable();
/* Check if the Watchdog is open already with the HWAttrs */
if (object->isOpen == true) {
Hwi_restore(key);
Log_warning1("Watchdog: Handle %x already in use.", (UArg)handle);
return (NULL);
}
object->isOpen = true;
Hwi_restore(key);
/* if params are NULL use defaults. */
if (params == NULL) {
Watchdog_Params_init(&watchdogParams);
params = &watchdogParams;
}
/* initialize the Watchdog object */
object->debugStallMode = params->debugStallMode;
object->resetMode = params->resetMode;
/* 1 second period at default CPU clock frequency */
BIOS_getCpuFreq(&freq);
object->reloadValue = freq.lo/2;
/* Construct Hwi object for Watchdog */
Hwi_Params_init(&hwiParams);
hwiParams.arg = (UArg)handle;
/* setup callback function if defined */
if (params->callbackFxn != NULL) {
Hwi_construct(&(object->hwi), hwAttrs->intNum, params->callbackFxn,
&hwiParams, NULL);
}
/* initialize the watchdog hardware */
// WatchdogIntClear();
WatchdogCC26XX_initHw(handle);
Log_print1(Diags_USER1, "Watchdog: handle %x opened" ,(UArg)handle);
/* register notification functions */
Power_registerNotify(&object->watchdogPreObj, PowerCC26XX_ENTERING_STANDBY, (Fxn)watchdogPreNotify, (uint32_t)handle);
Power_registerNotify(&object->watchdogPostObj, PowerCC26XX_AWAKE_STANDBY, (Fxn)watchdogPostNotify, (uint32_t)handle);
/* return handle of the Watchdog object */
return (handle);
}
//taskFxn
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);
while(1) {
//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 );
//System_printf("ADC: %d\r\n", singleSample);
//printf ("ADC: %d\r\n");
//printf ("ADC\r\n");
}
/*
// 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
UART_write(uHandle, &adcSamples[1], SAMPLESIZE);
// Goto STANDBY forever
Task_sleep(BIOS_WAIT_FOREVER);
*/
}
/*!
* @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);
}
/*
* ======== USBMSCHFatFsTiva_open ========
*/
USBMSCHFatFs_Handle USBMSCHFatFsTiva_open(USBMSCHFatFs_Handle handle,
unsigned char drv,
USBMSCHFatFs_Params *params)
{
unsigned int key;
DRESULT dresult;
FRESULT fresult;
USBMSCHFatFsTiva_Object *object = handle->object;
USBMSCHFatFsTiva_HWAttrs const *hwAttrs = handle->hwAttrs;
union {
Task_Params taskParams;
Semaphore_Params semParams;
GateMutex_Params gateParams;
Hwi_Params hwiParams;
} paramsUnion;
/* Determine if the device was already opened */
key = Hwi_disable();
if (object->driveNumber != DRIVE_NOT_MOUNTED) {
Hwi_restore(key);
return (NULL);
}
/* Mark as being used */
object->driveNumber = drv;
Hwi_restore(key);
/* Store the USBMSCHFatFs parameters */
if (params == NULL) {
/* No params passed in, so use the defaults */
params = (USBMSCHFatFs_Params *) &USBMSCHFatFs_defaultParams;
}
/* Initialize the USB stack for host mode. */
USBStackModeSet(0, eUSBModeHost, NULL);
/* Register host class drivers */
USBHCDRegisterDrivers(0, usbHCDDriverList, numHostClassDrivers);
/* Open an instance of the MSC host driver */
object->MSCInstance = USBHMSCDriveOpen(0, USBMSCHFatFsTiva_cbMSCHandler);
if (!(object->MSCInstance)) {
Log_print0(Diags_USER1,"USBMSCHFatFs: Error initializing the MSC Host");
USBMSCHFatFsTiva_close(handle);
return (NULL);
}
/* Create the Hwi object to service interrupts */
Hwi_Params_init(&(paramsUnion.hwiParams));
paramsUnion.hwiParams.priority = hwAttrs->intPriority;
Hwi_construct(&(object->hwi), hwAttrs->intNum, USBMSCHFatFsTiva_hwiHandler,
&(paramsUnion.hwiParams), NULL);
/* Initialize USB power configuration */
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
/* Enable the USB stack */
USBHCDInit(0, object->memPoolHCD, HCDMEMORYPOOLSIZE);
/* RTOS primitives */
Semaphore_Params_init(&(paramsUnion.semParams));
paramsUnion.semParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&(object->semUSBConnected), 0, &(paramsUnion.semParams));
GateMutex_Params_init(&(paramsUnion.gateParams));
paramsUnion.gateParams.instance->name = "USB Library Access";
GateMutex_construct(&(object->gateUSBLibAccess), &(paramsUnion.gateParams));
paramsUnion.gateParams.instance->name = "USB Wait";
GateMutex_construct(&(object->gateUSBWait), &(paramsUnion.gateParams));
/*
* Note that serviceUSBHost() should not be run until the USB Stack has been
* initialized!!
*/
Task_Params_init(&(paramsUnion.taskParams));
/*
* If serviceTaskStackPtr is null, then Task_construct performs a
* Memory_alloc - requiring a Heap
*/
paramsUnion.taskParams.stack = params->serviceTaskStackPtr;
/*
* If service priority passed in is higher than what is configured by the
* Task module, then use the highest priority available.
*/
if (Task_numPriorities - 1 < params->servicePriority) {
paramsUnion.taskParams.priority = (Task_numPriorities - 1);
}
else {
paramsUnion.taskParams.priority = params->servicePriority;
}
/* If no stack size is passed in, then use the default task stack size */
if (params->serviceTaskStackSize) {
paramsUnion.taskParams.stackSize = params->serviceTaskStackSize;
}
else {
paramsUnion.taskParams.stackSize = Task_defaultStackSize;
}
Task_construct(&(object->taskHCDMain),USBMSCHFatFsTiva_serviceUSBHost,
&(paramsUnion.taskParams), NULL);
/* Register the new disk_*() functions */
dresult = disk_register(drv,
USBMSCHFatFsTiva_diskInitialize,
USBMSCHFatFsTiva_diskStatus,
USBMSCHFatFsTiva_diskRead,
USBMSCHFatFsTiva_diskWrite,
USBMSCHFatFsTiva_diskIOctl);
/* Check for drive errors */
if (dresult != RES_OK) {
Log_error0("USBMSCHFatFs: disk functions not registered");
USBMSCHFatFsTiva_close(handle);
return (NULL);
}
/* Mount the FatFs (this function does not access the SDCard yet...) */
fresult = f_mount(drv, &(object->filesystem));
if (fresult != FR_OK) {
Log_error1("USBMSCHFatFs: drive %d not mounted", drv);
USBMSCHFatFsTiva_close(handle);
return (NULL);
}
Log_print1(Diags_USER1, "USBMSCHFatFs: drive %d opened", drv);
return (handle);
}
/*!
* @brief Function to initialize a given I2C CC26XX peripheral specified by the
* particular handle. The parameter specifies which mode the I2C
* will operate.
*
* After calling the open function, the I2C is enabled. If there is no active
* I2C transactions, the device can enter standby.
*
* @pre The I2CCC26XX_Config structure must exist and be persistent before this
* function can be called. I2CCC26XX has been initialized with I2CCC26XX_init().
* Calling context: Task
*
* @param handle An I2C_Handle
*
* @param params Pointer to a parameter block, if NULL it will use default values.
*
* @return A I2C_Handle on success, or a NULL on an error or if it has been
* already opened.
*
* @note The generic I2C API should be used when accessing the I2CCC26XX.
*
* @sa I2CCC26XX_close(), I2CCC26XX_init(), I2C_open(), I2C_init()
*/
I2C_Handle I2CCC26XX_open(I2C_Handle handle, I2C_Params *params)
{
union {
Hwi_Params hwiParams;
Semaphore_Params semParams;
} paramsUnion;
UInt key;
I2C_Params i2cParams;
I2CCC26XX_Object *object;
I2CCC26XX_HWAttrs const *hwAttrs;
/* Get the pointer to the object and hwAttrs */
object = handle->object;
hwAttrs = handle->hwAttrs;
/* Determine if the device index was already opened */
key = Hwi_disable();
if(object->isOpen == true){
Hwi_restore(key);
return (NULL);
}
/* Mark the handle as being used */
object->isOpen = true;
Hwi_restore(key);
/* Store the I2C parameters */
if (params == NULL) {
/* No params passed in, so use the defaults */
I2C_Params_init(&i2cParams);
params = &i2cParams;
}
/* Configure the IOs early to ensure allocation is allowed (PIN driver and IO config setup only).*/
if (I2CCC26XX_initIO(handle, params->custom)) {
/* If initialization and allocation of IOs failed, log error and return NULL pointer */
Log_print1(Diags_USER1, "I2C: Pin allocation failed, open did not succeed (baseAddr:0x%x)", hwAttrs->baseAddr);
return (NULL);
}
/* Save parameters */
object->transferMode = params->transferMode;
object->transferCallbackFxn = params->transferCallbackFxn;
object->bitRate = params->bitRate;
/* Create Hwi object for this I2C peripheral */
Hwi_Params_init(¶msUnion.hwiParams);
paramsUnion.hwiParams.arg = (UArg)handle;
Hwi_construct(&(object->hwi), hwAttrs->intNum, I2CCC26XX_hwiFxn,
¶msUnion.hwiParams, NULL);
/*
* Create thread safe handles for this I2C peripheral
* Semaphore to provide exclusive access to the I2C peripheral
*/
Semaphore_Params_init(¶msUnion.semParams);
paramsUnion.semParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&(object->mutex), 1, ¶msUnion.semParams);
/*
* Store a callback function that posts the transfer complete
* semaphore for synchronous mode
*/
if (object->transferMode == I2C_MODE_BLOCKING) {
/*
* Semaphore to cause the waiting task to block for the I2C
* to finish
*/
Semaphore_construct(&(object->transferComplete), 0, ¶msUnion.semParams);
/* Store internal callback function */
object->transferCallbackFxn = I2CCC26XX_blockingCallback;
}
else {
/* Check to see if a callback function was defined for async mode */
Assert_isTrue(object->transferCallbackFxn != NULL, NULL);
}
/* Specify the idle state for this I2C peripheral */
object->mode = I2CCC26XX_IDLE_MODE;
/* Clear the head pointer */
object->headPtr = NULL;
object->tailPtr = NULL;
/* Power on the I2C module */
Power_setDependency(hwAttrs->powerMngrId);
/* Initialize the I2C hardware module */
I2CCC26XX_initHw(handle);
/* Register notification functions */
Power_registerNotify(&object->i2cPostObj, Power_AWAKE_STANDBY, (Fxn)i2cPostNotify, (UInt32)handle, NULL );
Log_print1(Diags_USER1, "I2C: Object created 0x%x", hwAttrs->baseAddr);
/* Return the address of the handle */
return (handle);
}