/*
* ======== main ========
*/
int main(void)
{
Task_Params taskParams;
/* Call board init functions */
Board_initGeneral();
Board_initGPIO();
Board_initSDSPI();
/* Construct file copy Task thread */
Task_Params_init(&taskParams);
taskParams.stackSize = TASKSTACKSIZE;
taskParams.stack = &task0Stack;
Task_construct(&task0Struct, (Task_FuncPtr)taskFxn, &taskParams, NULL);
/* Turn on user LED */
GPIO_write(Board_LED0, Board_LED_ON);
System_printf("Starting the FatSD Raw example\n");
/* Start BIOS */
BIOS_start();
return (0);
}
/*
* ======== main ========
*/
int main(void)
{
/* Call board init functions */
Board_initGeneral();
Board_initGPIO();
Board_initUART();
/* Construct BIOS objects */
Task_Params taskParams;
Task_Params_init(&taskParams);
taskParams.stackSize = TASKSTACKSIZE;
taskParams.stack = &task0Stack;
taskParams.instance->name = "echo";
Task_construct(&task0Struct, (Task_FuncPtr)echoFxn, &taskParams, NULL);
/* Turn on user LED */
GPIO_write(Board_LED0, Board_LED_ON);
/* Start BIOS */
BIOS_start();
return (0);
}
int main(void)
{
Task_Params taskParams;
/* Call board init functions */
Board_initGeneral();
memoryInit(spiHandle, 6250);
// Board_initWatchdog();
/* Construct heartBeat Task thread */
Task_Params_init(&taskParams);
taskParams.arg0 = 1000000 / Clock_tickPeriod;
taskParams.stackSize = TASKSTACKSIZE;
taskParams.stack = &task0Stack;
Task_construct(&task0Struct, (Task_FuncPtr)heartBeatFxn, &taskParams, NULL);
/* Open LED pins */
ledPinHandle = PIN_open(&ledPinState, ledPinTable);
if(!ledPinHandle) {
System_abort("Error initializing board LED pins\n");
}
//IOCPortConfigureSet(PIN_SPI_MOSI, PORTID, PIN-CONFIG); // oklart om och hur denna funkar.
//IOCPortConfigureSet(DIOn, PORTID, PIN-CONFIG);
//PIN_setOutputValue(ledPinHandle, Board_LED1, 1);
/* Start BIOS */
BIOS_start();
return (0);
}
/*
* ======== main ========
*/
int main(void)
{
Task_Params taskParams;
/* Call board init functions */
Board_initGeneral();
Board_initGPIO();
// Board_initI2C();
// Board_initSDSPI();
// Board_initSPI();
// Board_initUART();
// Board_initUSB(Board_USBDEVICE);
// Board_initWatchdog();
// Board_initWiFi();
/* Construct heartBeat Task thread */
Task_Params_init(&taskParams);
taskParams.arg0 = 1000;
taskParams.stackSize = TASKSTACKSIZE;
taskParams.stack = &task0Stack;
Task_construct(&task0Struct, (Task_FuncPtr)heartBeatFxn, &taskParams, NULL);
/* Turn on user LED */
GPIO_write(Board_LED0, Board_LED_ON);
System_printf("Starting the example\nSystem provider is set to SysMin. "
"Halt the target to view any SysMin contents in ROV.\n");
/* SysMin will only print to the console when you call flush or exit */
System_flush();
/* Start BIOS */
BIOS_start();
return (0);
}
/*
* ======== main ========
*/
Int main()
{
/* Call board init functions */
Board_initGeneral();
/* Construct BIOS objects */
Task_Params taskParams;
HeapBuf_Params heapBufParams;
HeapMem_Params heapMemParams;
/* Construct writer/reader Task threads */
Task_Params_init(&taskParams);
taskParams.stackSize = TASKSTACKSIZE;
taskParams.stack = &task0Stack;
Task_construct(&task0Struct, (Task_FuncPtr)task0Fxn, &taskParams, NULL);
taskParams.stack = &task1Stack;
Task_construct(&task1Struct, (Task_FuncPtr)task1Fxn, &taskParams, NULL);
/* Construct two heaps to be used by two separate tasks for alloc and free. */
HeapBuf_Params_init(&heapBufParams);
heapBufParams.blockSize = HEAPBUFSIZE / 2;
heapBufParams.numBlocks = 2;
heapBufParams.align = 8;
heapBufParams.buf = heapBufBuffer;
heapBufParams.bufSize = HEAPBUFSIZE;
HeapBuf_construct(&heapBufStruct, &heapBufParams, NULL);
task0Heap = HeapBuf_handle(&heapBufStruct);
HeapMem_Params_init(&heapMemParams);
heapMemParams.size = HEAPMEMSIZE;
heapMemParams.minBlockAlign = 8;
heapMemParams.buf = heapMemBuffer;
HeapMem_construct(&heapMemStruct, &heapMemParams);
task1Heap = HeapMem_handle(&heapMemStruct);
System_printf("Memory example started.\n");
BIOS_start(); /* Does not return */
return(0);
}
/*********************************************************************
* @fn HostTestApp_createTask
*
* @brief Task creation function for the Host Test App.
*
* @param none
*
* @return none
*/
void HostTestApp_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = htaTaskStack;
taskParams.stackSize = HTA_TASK_STACK_SIZE;
taskParams.priority = HTA_TASK_PRIORITY;
Task_construct(&htaTask, HostTestApp_taskFxn, &taskParams, NULL);
}
/*********************************************************************
* @fn trainingTag_createTask
*
* @brief Task creation function for the Simple BLE Peripheral.
*
* @param None.
*
* @return None.
*/
void TrainingTag_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = tTagTaskStack;
taskParams.stackSize = TTG_TASK_STACK_SIZE;
taskParams.priority = TTG_TASK_PRIORITY;
Task_construct(&tTagTask, trainingTag_taskFxn, &taskParams, NULL);
}
/*********************************************************************
* @fn Thermometer_createTask
*
* @brief Task creation function for the Time Application.
*
* @param none
*
* @return none
*/
void Thermometer_createTask(void)
{
Task_Params taskParams;
// Configure task.
Task_Params_init(&taskParams);
taskParams.stack = Thermometer_taskStack;
taskParams.stackSize = THERMOMETER_TASK_STACK_SIZE;
taskParams.priority = THERMOMETER_TASK_PRIORITY;
Task_construct(&Thermometer_task, Thermometer_taskFxn, &taskParams, NULL);
}
/*********************************************************************
* @fn SimpleBLEPeripheral_createTask
*
* @brief Task creation function for the Simple Proprietary Beacon.
*
* @param None.
*
* @return None.
*/
void SimpleBLEPeripheral_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = spbTaskStack;
taskParams.stackSize = SPB_TASK_STACK_SIZE;
taskParams.priority = SPB_TASK_PRIORITY;
Task_construct(&spbTask, SimplePropBeacon_taskFxn, &taskParams, NULL);
}
/*********************************************************************
* @fn DualImageConcept_createTask
*
* @brief Task creation function for the Dual Image Concept.
*
* @param None.
*
* @return None.
*/
void DualImageConcept_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = dicTaskStack;
taskParams.stackSize = DIC_TASK_STACK_SIZE;
taskParams.priority = DIC_TASK_PRIORITY;
Task_construct(&dicTask, DualImageConcept_taskFxn, &taskParams, NULL);
}
/*********************************************************************
* @fn HeartRate_createTask
*
* @brief Task creation function for the Heart Rate.
*
* @param none
*
* @return none
*/
void HeartRate_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = HeartRate_taskStack;
taskParams.stackSize = HEARTRATE_TASK_STACK_SIZE;
taskParams.priority = HEARTRATE_TASK_PRIORITY;
Task_construct(&HeartRate_task, HeartRate_taskFxn, &taskParams, NULL);
}
void Adc_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = Adc_taskStack;
taskParams.stackSize = 512;
taskParams.priority = 3;
Task_construct(&Adc_task, Adc_entry, &taskParams, NULL);
}
/*********************************************************************
* @fn SensorTagTmp_createTask
*
* @brief Task creation function for the SensorTag
*
* @param none
*
* @return none
*/
void Keys_createTask(void)
{
Task_Params taskParames;
// Create the task for the state machine
Task_Params_init(&taskParames);
taskParames.stack = keysTaskStack;
taskParames.stackSize = KEYS_TASK_STACK_SIZE;
taskParames.priority = KEYS_TASK_PRIORITY;
Task_construct(&keysTask, keysTaskFxn, &taskParames, NULL);
}
/**
* @brief Task creation function for the GAP Observer Role.
*
* @param none
*
* @return none
*/
void GAPObserverRole_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = gapObserverRoleTaskStack;
taskParams.stackSize = GAPOBSERVERROLE_TASK_STACK_SIZE;
taskParams.priority = GAPOBSERVERROLE_TASK_PRIORITY;
Task_construct(&gapObserverRoleTask, gapObserverRole_taskFxn, &taskParams, NULL);
}
/*********************************************************************
* @fn simpleTopology_createTask
*
* @brief Task creation function for the Simple BLE Peripheral.
*
* @param None.
*
* @return None.
*/
void SimpleTopology_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = sbmTaskStack;
taskParams.stackSize = SBT_TASK_STACK_SIZE;
taskParams.priority = SBT_TASK_PRIORITY;
Task_construct(&sbmTask, simpleTopology_taskFxn, &taskParams, NULL);
}
/*********************************************************************
* @fn SimpleBLEBroadcaster_createTask
*
* @brief Task creation function for the Simple BLE Broadcaster.
*
* @param none
*
* @return none
*/
void SimpleBLEBroadcaster_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = sbbTaskStack;
taskParams.stackSize = SBB_TASK_STACK_SIZE;
taskParams.priority = SBB_TASK_PRIORITY;
Task_construct(&sbbTask, SimpleBLEBroadcaster_taskFxn, &taskParams, NULL);
}
/*******************************************************************************
* @fn SensorTag_createTask
*
* @brief Task creation function for the SensorTag.
*
* @param none
*
* @return none
*/
void SensorTag_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = sensorTagTaskStack;
taskParams.stackSize = ST_TASK_STACK_SIZE;
taskParams.priority = ST_TASK_PRIORITY;
Task_construct(&sensorTagTask, SensorTag_taskFxn, &taskParams, NULL);
}
/*********************************************************************
* @fn SensorTagBar_createTask
*
* @brief Task creation function for barometer sensor
*
* @param none
*
* @return none
*/
void SensorTagBar_createTask(void)
{
Task_Params taskParames;
// Create the task for the state machine
Task_Params_init(&taskParames);
taskParames.stack = sensorTaskStack;
taskParames.stackSize = SENSOR_TASK_STACK_SIZE;
taskParames.priority = SENSOR_TASK_PRIORITY;
Task_construct(&sensorTask, sensorTaskFxn, &taskParames, NULL);
}
/**
* @brief Task creation function for the GAP Central Role.
*
* @param none
*
* @return none
*/
void GAPCentralRole_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = gapCentralRoleTaskStack;
taskParams.stackSize = GAPCENTRALROLE_TASK_STACK_SIZE;
taskParams.priority = GAPCENTRALROLE_TASK_PRIORITY;
Task_construct(&gapCentralRoleTask, gapCentralRole_taskFxn, &taskParams, NULL);
}
/*********************************************************************
* @fn HidEmuKbd_createTask
*
* @brief Task creation function for the HID emulated keyboard.
*
* @param none
*
* @return none
*/
void HidEmuKbd_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = hidEmuKbdTaskStack;
taskParams.stackSize = HIDEMUKBD_TASK_STACK_SIZE;
taskParams.priority = HIDEMUKBD_TASK_PRIORITY;
Task_construct(&hidEmuKbdTask, HidEmuKbd_taskFxn, &taskParams, NULL);
}
/*********************************************************************
* @fn RunningSensor_createTask
*
* @brief Task creation function for the Running Sensor application.
*
* @param none
*
* @return none
*/
void RunningSensor_createTask(void)
{
Task_Params taskParams;
// Configure task.
Task_Params_init(&taskParams);
taskParams.stack = rscTaskStack;
taskParams.stackSize = RSC_TASK_STACK_SIZE;
taskParams.priority = RSC_TASK_PRIORITY;
Task_construct(&rscTask, RunningSensor_taskFxn, &taskParams, NULL);
}
/*********************************************************************
* @fn glucCollCentral_createTask
*
* @brief Task creation function for the Glucose collector.
*
* @param none
*
* @return none
*/
void glucCollCentral_createTask(void)
{
Task_Params taskParams;
// Configure task
Task_Params_init(&taskParams);
taskParams.stack = glucCollCentralTaskStack;
taskParams.stackSize = GLUCOLL_TASK_STACK_SIZE;
taskParams.priority = GLUCOLL_TASK_PRIORITY;
Task_construct(&glucCollCentralTask, glucCollCentral_taskFxn,
&taskParams, NULL);
}
// -----------------------------------------------------------------------------
//! \brief Task creation function for LCD
//!
//! \return void
// -----------------------------------------------------------------------------
void LCDTask_createTask(void)
{
memset(&lcdTaskStack, 0xDD, sizeof(lcdTaskStack));
// Configure and create the LCD task.
Task_Params lcdTaskParams;
Task_Params_init(&lcdTaskParams);
lcdTaskParams.stack = lcdTaskStack;
lcdTaskParams.stackSize = LCDTASK_STACK_SIZE;
lcdTaskParams.priority = LCDTASK_PRIORITY;
Task_construct(&lcdTaskStruct, LCDTask_Fxn, &lcdTaskParams, NULL);
}
int main(void) {
//Initialize pins, turn on GPIO module
PIN_init(BoardGpioInitTable);
//Initialize task
Task_Params params;
Task_Params_init(¶ms);
params.priority = TASK_PRI;
params.stackSize = TASK_STACK_SIZE;
params.stack = taskStack;
Task_construct(&taskStruct, taskFxn, ¶ms, NULL);
// Construct semaphore used for pending in task
Semaphore_Params sParams;
Semaphore_Params_init(&sParams);
sParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&sem, 0, &sParams);
hSem = Semaphore_handle(&sem);
BIOS_start();
}
/*
* ======== main ========
*/
Void main()
{
PIN_init(BoardGpioInitTable);
//enable iCache prefetching
VIMSConfigure(VIMS_BASE, TRUE, TRUE);
// Enable cache
VIMSModeSet(VIMS_BASE, VIMS_MODE_ENABLED);
#ifndef POWER_SAVING
/* Set constraints for Standby, powerdown and idle mode */
Power_setConstraint(Power_SB_DISALLOW);
Power_setConstraint(Power_IDLE_PD_DISALLOW);
#endif // POWER_SAVING
//Initialize task
Task_Params params;
Task_Params_init(¶ms);
params.priority = TASK_PRI;
params.stackSize = TASK_STACK_SIZE;
params.stack = taskStack;
//semaphore init
Semaphore_Params sParams;
Semaphore_Params_init(&sParams);
sParams.mode = Semaphore_Mode_BINARY;
/* Initialize ICall module */
ICall_init();
/* Start tasks of external images - Priority 5 */
ICall_createRemoteTasks();
/* Kick off profile - Priority 3 */
GAPRole_createTask();
SimpleBLEPeripheral_createTask();
//Contruct task
Task_construct(&taskStruct, taskFxn, ¶ms, NULL);
// Construct semaphore used for pending in task ADC
Semaphore_construct(&sem, 0, &sParams);
hSem = Semaphore_handle(&sem);
#ifdef FEATURE_OAD_BIM
{
uint8_t counter;
uint32_t *vectorTable = (uint32_t*) 0x20000000;
uint32_t *flashVectors = &__vector_table;
// Write image specific interrupt vectors into RAM vector table.
for(counter = 0; counter < 15; ++counter)
{
*vectorTable++ = *flashVectors++;
}
}
#endif //FEATURE_OAD_BIM
/* enable interrupts and start SYS/BIOS */
BIOS_start();
}
/*
* ======== 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);
}
