/*
* ======== main ========
*/
Void main()
{
Swi_Params swiParams;
Task_Params taskParams;
Clock_Params clkParams;
Swi_Params_init(&swiParams);
swiParams.arg0 = 1;
swiParams.arg1 = 0;
swiParams.priority = 2;
swiParams.trigger = 0;
swi0 = Swi_create(swi0Fxn, &swiParams, NULL);
swiParams.arg0 = 2;
swiParams.arg1 = 0;
swiParams.priority = 1;
swiParams.trigger = 3;
swi1 = Swi_create(swi1Fxn, &swiParams, NULL);
Task_Params_init(&taskParams);
taskParams.priority = 1;
Task_create (tsk0Fxn, &taskParams, NULL);
Clock_Params_init(&clkParams);
clkParams.startFlag = TRUE;
Clock_create(clk0Fxn, 2, &clkParams, NULL);
sem0 = Semaphore_create(0, NULL, NULL);
BIOS_start();
}
void lcdSetup() {
Semaphore_Params mySemParams;
Clock_Params myClkParams;
/* Use pull up on button inputs to save power */
pinMode(PUSH1, INPUT_PULLUP);
pinMode(PUSH2, INPUT_PULLUP);
/* Both buttons post the semaphore */
attachInterrupt(PUSH1, button1Interrupt, FALLING);
attachInterrupt(PUSH2, button2Interrupt, FALLING);
/* set LCD's EXTMODE low (sadly this is the UART Rx pin too) */
digitalWrite(12, 0);
/* turn off MPU power */
digitalWrite(22, 0);
/* put flash into power down mode */
SPI.begin();
SPI.transfer((uint8_t)32, 0xb9);
SPI.end();
/* power down the tmp007 */
Wire.begin();
tmp007.begin(TMP007_CFG_1SAMPLE);
tmp007.write16(TMP007_CONFIG, TMP007_CFG_ALERTEN | TMP007_CFG_TRANSC | TMP007_CFG_1SAMPLE);
Wire.end();
Semaphore_Params_init(&mySemParams);
mySem = Semaphore_create(0, &mySemParams, NULL);
Clock_Params_init(&myClkParams);
myClkParams.period = 100000; /* one second */
myClkParams.startFlag = true;
/* comment out for steady state power testing */
Clock_create(myClkFunc, 0, &myClkParams, NULL);
/* set to 1970 plus 45 years */
Seconds_set(secondsOffset);
myScreen.begin(); /* also calls SPI.begin() */
myScreen.setFont(1);
myScreen.text(10, 10, "Hello!");
myScreen.flush();
SPI.end(); /* to save power */
/* Say Hello for 1 second */
delay(1000);
SPI.begin();
myScreen.clear();
SPI.end(); /* to save Power */
}
/*
* ======== main ========
*/
Int main()
{
Clock_Params clkParams;
Task_Params tskParams;
Mailbox_Params mbxParams;
Semaphore_Params semParams;
/* Create a one-shot Clock Instance with timeout = 5 system time units */
Clock_Params_init(&clkParams);
clkParams.startFlag = TRUE;
clk1 = Clock_create(clk0Fxn, 5, &clkParams, NULL);
/* Create an one-shot Clock Instance with timeout = 10 system time units */
Clock_Params_init(&clkParams);
clkParams.startFlag = TRUE;
clk2 = Clock_create(clk1Fxn, 10, &clkParams, NULL);
/* create an Event Instance */
evt = Event_create(NULL, NULL);
/* create a Semaphore Instance */
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_BINARY;
semParams.event = evt;
semParams.eventId = Event_Id_01;
sem = Semaphore_create(0, &semParams, NULL);
/* create a Mailbox Instance */
Mailbox_Params_init(&mbxParams);
mbxParams.readerEvent = evt;
mbxParams.readerEventId = Event_Id_02;
mbx = Mailbox_create(sizeof(MsgObj), 2, &mbxParams, NULL);
/* create a writer task */
Task_Params_init(&tskParams);
tskParams.priority = 1;
tskParams.arg0 = (UArg) mbx;
Task_create(writer, &tskParams, NULL);
/* create a reader task */
Task_create(reader, &tskParams, NULL);
BIOS_start(); /* does not return */
return(0);
}
int main(void)
{
/* Call board init functions. */
Board_initGeneral();
Board_initGPIO();
// Board_initI2C();
// Board_initSDSPI();
// Board_initSPI();
// Board_initUART();
// Board_initWatchdog();
Clock_Params clockParams;
Clock_Handle myClock;
Error_Block eb;
Task_Handle task0;
Task_Params taskParams;
Task_Params_init(&taskParams);
int j;
for(j=0; j<17; j++) {
buff1[j] = ' ';
buff2[j] = ' ';
}
Error_init(&eb);
Clock_Params_init(&clockParams);
clockParams.period = 100;
clockParams.startFlag = TRUE;
myClock = Clock_create(LCD_print, 10, &clockParams, &eb);
if(myClock == 0)
{
System_abort("F****n clock");
}
LCD_init();
task0 = Task_create(heartBeatFxn, &taskParams, &eb);
// sample_screen();F
/* 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");
//GPIO_write(4,1);
/* SysMin will only print to the console when you call flush or exit */
System_flush();
/* Start BIOS */
BIOS_start();
return (0);
}
/*
* ======== main ========
*/
Void main()
{
Clock_Handle clk2;
Clock_Params clkParams;
/* Create a periodic Clock Instance with period = 5 system time units */
Clock_Params_init(&clkParams);
clkParams.period = 5;
clkParams.startFlag = TRUE;
clkParams.arg = (UArg)0x5555;
Clock_create(clk0Fxn, 5, &clkParams, NULL);
/* Create an one-shot Clock Instance with timeout = 11 system time units */
clkParams.period = 0;
clkParams.startFlag = FALSE;
clkParams.arg = (UArg)0x6666;
clk2 = Clock_create(clk1Fxn, 11, &clkParams, NULL);
Clock_start(clk2);
BIOS_start();
}
/*
* ======== main ========
*/
int main(void)
{
Clock_Handle clkHandle;
Clock_Params clkParams;
/* Call board init functions */
Board_initGeneral();
Board_initGPIO();
Board_initUART();
/* Turn on user LED */
GPIO_write(Board_LED0, Board_LED_OFF);
GPIO_write(Board_LED1, Board_LED_ON);
GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, GPIO_PIN_0);
System_printf("Hello World\n");
/* SysMin will only print to the console when you call flush or exit */
System_flush();
/* Create a periodic Clock Instance with period = 5 system time units */
Clock_Params_init(&clkParams);
clkParams.period = 1000;
clkParams.startFlag = TRUE;
Clock_create(clk0Fxn, 5, &clkParams, NULL);
/* Create an one-shot Clock Instance with timeout = 11 system time units */
clkParams.period = 0;
clkParams.startFlag = FALSE;
clkHandle = Clock_create(clk1Fxn, 11, &clkParams, NULL);
Clock_start(clkHandle);
/* Start BIOS */
BIOS_start();
return (0);
}
void OneMsTaskTimer::start(uint32_t timer_index) {
Clock_Params clockParams;
Error_Block eb;
Error_init(&eb);
if (myClock == NULL){
Clock_Params_init(&clockParams);
clockParams.period = (uint32_t)1000 / (uint64_t)Clock_tickPeriod;
clockParams.startFlag = FALSE;
clockParams.arg = (UArg)0x5555;
myClock = Clock_create(OneMsTaskTimer_int, clockParams.period, &clockParams, &eb);
}
Clock_start(myClock);
}
void Clock::begin(void (*ClockFunction)(void), uint32_t ClockTimeOut_ms, uint32_t ClockPeriod_ms)
{
Error_Block eb;
Error_init(&eb);
Clock_Params_init(&ClockParams);
ClockParams.startFlag = false; // Requires Clock_start
// ClockParams.period = microsecondsToClockCycles(ClockPeriod_ms); // ms to be translated into ticks
// ClockHandle = Clock_create( (Clock_FuncPtr)ClockFunction, microsecondsToClockCycles(ClockTimeOut_ms), &ClockParams, &eb);
// Surprisingly, period already defined in ms for ClockParams.period andClockTimeOut_ms
ClockParams.period = ClockPeriod_ms;
ClockHandle = Clock_create( (Clock_FuncPtr)ClockFunction, ClockTimeOut_ms, &ClockParams, &eb);
if (ClockHandle == NULL)
{
// Serial.println("*** Clock create failed");
System_abort("Clock create failed");
}
}
/**************************************************************************************************
* @fn macBackoffTimerInit
*
* @brief Intializes backoff timer.
*
* @param none
*
* @return none
**************************************************************************************************
*/
MAC_INTERNAL_API void macBackoffTimerInit(void)
{
macPrevPeriodRatCount = macBackoffTimerRollover = 0;
/* backoffTimerTrigger has to be set to maximum possible value of
* macBackoffTimerRollover value initially.
* Otherwise, incorrect backoffTimerTrigger value shall be compared
* all the time in macBackoffTimerUpdateWakeup() function, casting
* incorrect vote.
*/
backoffTimerTrigger = MAC_BACKOFF_TIMER_DEFAULT_NONBEACON_ROLLOVER;
MAC_RADIO_CLEAR_BACKOFF_COUNT();
#if defined USE_ICALL || defined OSAL_PORT2TIRTOS
// Clear events
macBackoffTimerEvents = 0;
#ifdef USE_ICALL
// Register hook function to handle events.
if (!osal_eventloop_hook)
{
/* Don't overwrite if the hook is already set up.
* Note that the hook might have been set up to perform other things
* as well in which case the other hook function has to call
* macBackoffTimerEventHandler.
*/
osal_eventloop_hook = macBackoffTimerEventHandler;
}
#endif /* USE_ICALL */
macBackoffTimerImpending = FALSE;
#ifdef USE_ICALL
/* Start timer just to initialize the timer ID to reuse in the module.
* This also serves the purpose of allocating resources upfront,
* in order to prevent a case of running out of timer resource
* when the timer has to be started.
* Note that macBackoffTimerSetRollover() may trigger setting timer
* and hence the timer set up must happen before macBackoffTimerSetRollover()
* call. */
if (ICall_setTimer(1, macBackoffTimerICallTimerCback, NULL,
&macBackoffTimerICallTimerID) != ICALL_ERRNO_SUCCESS)
{
MAC_ASSERT(0);
}
#endif /* USE_ICALL */
#ifdef OSAL_PORT2TIRTOS
if (!macBackoffWakeupClock)
{
/* Creates a wakeup clock */
Clock_Params params;
Clock_Params_init(¶ms);
params.startFlag = FALSE;
params.period = 0;
macBackoffWakeupClock =
Clock_create((Clock_FuncPtr) macBackoffTimerICallTimerCback,
1, ¶ms, NULL);
MAC_ASSERT(macBackoffWakeupClock);
/* No need to stop clock, the clock event will reprogram next wake time */
}
#endif /* OSAL_PORT2TIRTOS */
/* Note that macPwrVote() is called done from macBackoffTimerSetRollover()
* call and hence there is no need to make the call here. */
#endif /* defined USE_ICALL || defined OSAL_PORT2TIRTOS */
macBackoffTimerSetRollover(MAC_BACKOFF_TIMER_DEFAULT_NONBEACON_ROLLOVER);
/* Since interrupt disable/enable mechanism is not implemented for backoff
* timer trigger interrupt for CC26xx, comparator value has to be set
* so that the timer trigger interrupt is not triggered.
* See comment inside macBackoffTimerCancelTrigger() for relevant
* information */
MAC_RADIO_BACKOFF_SET_COMPARE(backoffTimerTrigger);
}
Int32 NullSrcLink_drvCreate(NullSrcLink_Obj * pObj,
NullSrcLink_CreateParams * pPrm)
{
Int32 status;
UInt32 chId, frameId;
Clock_Params clockParams;
System_LinkChInfo *pChInfo;
FVID2_Frame *pFrame;
#ifdef SYSTEM_DEBUG_SWMS
Vps_printf(" %d: NULL_SRC: Create in progress !!!\n", Utils_getCurTimeInMsec());
#endif
memcpy(&pObj->createArgs, pPrm, sizeof(pObj->createArgs));
UTILS_assert(pPrm->inputInfo.numCh <= SYSTEM_MAX_CH_PER_OUT_QUE);
status = Utils_bufCreate(&pObj->bufOutQue, FALSE, FALSE);
UTILS_assert(status == FVID2_SOK);
if (pPrm->timerPeriod == 0 || pPrm->timerPeriod > 200)
pPrm->timerPeriod = 16;
Clock_Params_init(&clockParams);
clockParams.period = pPrm->timerPeriod;
clockParams.arg = (UArg) pObj;
pObj->timer = Clock_create(NullSrcLink_drvTimerCb,
pPrm->timerPeriod, &clockParams, NULL);
UTILS_assert(pObj->timer != NULL);
pObj->info.numQue = 1;
pObj->info.queInfo[0].numCh = pPrm->inputInfo.numCh;
pChInfo = &pPrm->inputInfo.chInfo[0];
pObj->outFormat.channelNum = 0;
pObj->outFormat.width = pChInfo->width;
pObj->outFormat.height = pChInfo->height;
pObj->outFormat.pitch[0] = pChInfo->pitch[0];
pObj->outFormat.pitch[1] = pChInfo->pitch[1];
pObj->outFormat.pitch[2] = pChInfo->pitch[2];
pObj->outFormat.fieldMerged[0] = FALSE;
pObj->outFormat.fieldMerged[1] = FALSE;
pObj->outFormat.fieldMerged[2] = FALSE;
pObj->outFormat.dataFormat = pChInfo->dataFormat;
pObj->outFormat.scanFormat = pChInfo->scanFormat;
pObj->outFormat.bpp = FVID2_BPP_BITS16;
pObj->outFormat.reserved = NULL;
status = Utils_memFrameAlloc(&pObj->outFormat, pObj->outFrames, 1);
UTILS_assert(status == FVID2_SOK);
NullSrcLink_fillDataPattern(&pObj->outFormat, pObj->outFrames, 1);
#ifndef SYSTEM_USE_TILER
if (pObj->createArgs.tilerEnable)
{
Vps_printf("NULLSRC:!!WARNING.FORCIBLY DISABLING TILER since tiler is disabled at build time");
pObj->createArgs.tilerEnable = FALSE;
}
#endif
for (chId = 0; chId < pPrm->inputInfo.numCh; chId++)
{
memcpy(&pObj->info.queInfo[0].chInfo[chId],
&pPrm->inputInfo.chInfo[chId],
sizeof(pPrm->inputInfo.chInfo[chId]));
pObj->info.queInfo[0].chInfo[chId].memType = VPS_VPDMA_MT_NONTILEDMEM;
if (pObj->createArgs.tilerEnable)
{
pObj->info.queInfo[0].chInfo[chId].memType = VPS_VPDMA_MT_TILEDMEM;
}
pObj->chNextFid[chId] = 0;
}
for (frameId = 0;
frameId < pPrm->inputInfo.numCh * SYSTEM_LINK_FRAMES_PER_CH; frameId++)
{
pFrame = &pObj->outFrames[frameId];
memcpy(pFrame, &pObj->outFrames[0], sizeof(*pFrame));
pFrame->appData = &pObj->frameInfo[frameId];
memset(&pObj->frameInfo[frameId], 0, sizeof(pObj->frameInfo[frameId]));
status = Utils_bufPutEmptyFrame(&pObj->bufOutQue, pFrame);
UTILS_assert(status == FVID2_SOK);
}
#ifdef SYSTEM_DEBUG_SWMS
Vps_printf(" %d: NULL_SRC: Create Done !!!\n", Utils_getCurTimeInMsec());
#endif
return FVID2_SOK;
}
/*
* ======== main ========
*/
Int main(Void) {
/*Task_Handle taskHandle;
Task_Params taskParams;
Error_Block eb;*/
short merge = 0;
char *temp = (char *) &merge;
Get_EvnString(); /// got enviroment form flash 0x80000
/* Call board init functions */
Board_initGeneral();
Board_initGPIO();
Board_initEMAC();
Board_initUART();
INIT_UART1_Printf();
System_printf("Starting the Array Mang\nSystem provider is set to "
"SysMin. Halt the target and use ROV to view output.\n");
/* SysMin will only print to the console when you call flush or exit */
System_flush();
Log_info0("Create TCP task");
// Create TCP task
Task_Handle TCP_taskHandle;
Task_Params TCP_taskParams;
Error_Block TCP_eb;
Task_Params_init(&TCP_taskParams);
Error_init(&TCP_eb);
TCP_taskParams.stackSize = 10240; //8192;
TCP_taskParams.priority = 2;
TCP_taskHandle = Task_create((Task_FuncPtr) tcpHandler, &TCP_taskParams,
&TCP_eb);
if (TCP_taskHandle == NULL) {
UARTprintf("main: Failed to create tcpHandler Task\n");
}
TCP_Periodic_Link_time.Updata_Period[1] = G_ENVCONFIG.Pollingtime[0];
TCP_Periodic_Link_time.Updata_Period[0] = G_ENVCONFIG.Pollingtime[1];
*temp = TCP_Periodic_Link_time.Updata_Period[0];
*(temp + 1) = TCP_Periodic_Link_time.Updata_Period[1];
test_merge = merge;
//UARTprintf((const char*)"\n\n\n\n----Array Pollingtime = %d----\n\n\n\n\n",merge);
TCP_Periodic_Link_time.TCP_Link_Period[0] = 0x3c; // TCP LINK Period
TCP_Periodic_Link_time.TCP_Link_Period[1] = 0x00;
//Timer-periodic
Clock_Params clockParams;
Error_Block eb_timer;
Error_init(&eb_timer);
Clock_Params_init(&clockParams);
clockParams.period = merge * Time_Tick;
clockParams.startFlag = TRUE;
Periodic_Handle = Clock_create(TimeTick_Periodic, First_Periodic_time,
&clockParams, &eb_timer);
if (Periodic_Handle == NULL) {
System_abort("Clock create failed");
}
//Timer-Time_Stamp
Clock_Params_init(&clockParams);
clockParams.period = TimeStamp_time;
clockParams.startFlag = TRUE;
AM_Timer_Handle = Clock_create(TimeTick_TimeStamp, 1, &clockParams,
&eb_timer);
if (AM_Timer_Handle == NULL) {
System_abort("Clock create failed");
}
/* Start BIOS */
BIOS_start();
return (0);
}
//*****************************************************************************
//
//! Festo Station Task.
//!
//! This task function do all the work related to controlling the Festo
//! Station. The task will first initialize the Driver and then run a infinite
//! loop, waiting and processing external events.
//!
//! \return None.
//
//*****************************************************************************
Void _task_FESTO(UArg arg0, UArg arg1)
{
// initialize driver
FestoStationDriver DriverInstance;
FestoStationDriver* Driver = &DriverInstance;
Festo_Driver_Init(Driver);
uint32_t EventPosted;
DisplayMessage MessageObject;
MessageObject.ScreenID = 0;
MessageObject.uptimeSeconds = 0;
MessageObject.piecesProcessed = 0;
MessageObject.blackAccepted = 0;
MessageObject.blackRejected = 0;
MessageObject.plasticAccepted = 0;
MessageObject.plasticRejected = 0;
MessageObject.orangeAccepted = 0;
MessageObject.orangeRejected = 0;
MessageObject.piecesProcessedPerSecond = 0;
MessageObject.heightCalibrated = 230;
MessageObject.upperHeightCalibrated = 245;
MessageObject.lowerHeightCalibrated = 227;
time_t t1 = time(NULL);
strcpy((char*) MessageObject.timeString, asctime(localtime(&t1)));
uint32_t uptimeSeconds = 0;
uint32_t piecesProcessed = 0;
uint32_t blackAccepted = 0;
uint32_t blackRejected = 0;
uint32_t plasticAccepted = 0;
uint32_t plasticRejected = 0;
uint32_t orangeAccepted = 0;
uint32_t orangeRejected = 0;
uint32_t metallicAccepted = 0;
uint32_t metallicRejected = 0;
uint32_t piecesProcessedPerSecond = 0;
uint32_t *ColourAccepted;
uint32_t *ColourRejected;
uint32_t *MaterialAccepted;
uint32_t *MaterialRejected;
uint8_t colour = 0;
uint8_t material = 0;
uint32_t i = 0;
uint32_t FestoState = 0;
// 0 = stopped
// 1 = idle
// 2 = initial state
// 10 = cal
int32_t LowerLimit = 1200;
int32_t UpperLimit = 1500;
int32_t Uptime = 0;
int32_t Time0 = 0;
int32_t Time1 = 0;
uint8_t Running = 0;
Clock_Params clockParams;
Clock_Handle myClock;
Clock_Params_init(&clockParams);
clockParams.arg = (UArg) Board_ACTUATOR_EJECTOR;
myClock = Clock_create(_Festo_Deactivate_Ejector, 200, &clockParams, NULL);
uint32_t heightMeasured = 0;
uint32_t heightCalibratedADC = 1380;
uint32_t heightCalibrated10mm = 225;
//float ConvertFactor = 0.1*MessageObject.heightCalibrated/1200;
GPIO_write(Board_LED0, Board_LED_OFF);
GPIO_write(Board_LED1, Board_LED_OFF);
GPIO_write(Board_LED2, Board_LED_ON);
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
Clock_start(Clock_1_sec);
while(1)
{
EventPosted = Event_pend(FestoEvents,
Event_Id_NONE,
FESTO_EVENT_BUTTON_UP + FESTO_EVENT_BUTTON_DOWN +
FESTO_EVENT_BUTTON_SELECT + FESTO_EVENT_RISER_DOWN +
FESTO_EVENT_RISER_UP + FESTO_EVENT_ADC_FINISH +
FESTO_EVENT_PIECE_IN_PLACE + FESTO_EVENT_EJECTOR_FINISHED +
FESTO_EVENT_TICK + FESTO_EVENT_COOLDOWN +
FESTO_EVENT_PIECE_NOT_IN_PLACE,
FESTO_TIMEOUT);
if (EventPosted & FESTO_EVENT_BUTTON_UP)
{
if (FestoState == 0)
{
Festo_Control_Driver(Driver, FESTO_ENABLED);
FestoState = 1;
Running = 1;
GPIO_write(Board_LED0, Board_LED_ON);
GPIO_write(Board_LED1, Board_LED_OFF);
GPIO_write(Board_LED2, Board_LED_OFF);
MessageObject.ScreenID = 1;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
Time0 = Clock_getTicks();
}
else if (FestoState == 12)
{
MessageObject.heightCalibrated++;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
else if (FestoState == 13)
{
MessageObject.upperHeightCalibrated++;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
else if (FestoState == 14)
{
MessageObject.lowerHeightCalibrated++;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
}
else if (EventPosted & FESTO_EVENT_BUTTON_DOWN)
{
if (FestoState == 1)
{
Festo_Control_Ejector(Driver, FESTO_EJECTOR_RETRACT);
Festo_Control_Platform(Driver, FESTO_PLATFORM_LOWER);
Festo_Control_Driver(Driver, FESTO_DISABLED);
FestoState = 0;
Running = 0;
GPIO_write(Board_LED0, Board_LED_OFF);
GPIO_write(Board_LED1, Board_LED_OFF);
GPIO_write(Board_LED2, Board_LED_ON);
MessageObject.ScreenID = 0;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
else if (FestoState == 12)
{
MessageObject.heightCalibrated--;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
else if (FestoState == 13)
{
MessageObject.upperHeightCalibrated--;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
else if (FestoState == 14)
{
MessageObject.lowerHeightCalibrated--;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
}
else if (EventPosted & FESTO_EVENT_BUTTON_SELECT)
{
if (FestoState == 0)
{
GPIO_write(Board_LED0, Board_LED_OFF);
GPIO_write(Board_LED1, Board_LED_ON);
GPIO_write(Board_LED2, Board_LED_OFF);
Festo_Control_Driver(Driver, FESTO_ENABLED);
FestoState = 10;
MessageObject.ScreenID = 2;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
Festo_Control_Ejector(Driver, FESTO_EJECTOR_RETRACT);
if (Festo_Sense_Riser_Down(Driver) != 1)
{
Festo_Control_Platform(Driver, FESTO_PLATFORM_LOWER);
}
else
{
FestoState = 11;
MessageObject.ScreenID = 3;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
}
else if (FestoState == 11)
{
FestoState = 12;
MessageObject.ScreenID = 4;
MessageObject.heightCalibrated = 230;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
else if (FestoState == 12)
{
FestoState = 13;
Festo_Control_Platform(Driver, FESTO_PLATFORM_RAISE);
Event_post(FestoEvents, FESTO_EVENT_ADC_START);
}
else if (FestoState == 13)
{
FestoState = 14;
MessageObject.ScreenID = 6;
MessageObject.lowerHeightCalibrated = 227;
UpperLimit = MessageObject.upperHeightCalibrated *
(1.0 * heightCalibratedADC)/(1.0 * heightCalibrated10mm);
System_printf("Upper Limit Cal: %d for %d *0.1 mm\n", UpperLimit, MessageObject.upperHeightCalibrated);
System_flush();
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
else if (FestoState == 14)
{
FestoState = 15;
MessageObject.ScreenID = 7;
LowerLimit = MessageObject.lowerHeightCalibrated *
(1.0 * heightCalibratedADC)/(1.0 * heightCalibrated10mm);
System_printf("Lower Limit Cal: %d for %d *0.1 mm\n", LowerLimit, MessageObject.lowerHeightCalibrated);
System_flush();
Festo_Control_Ejector(Driver, FESTO_EJECTOR_RETRACT);
Festo_Control_Platform(Driver, FESTO_PLATFORM_LOWER);
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
else if (FestoState == 15)
{
FestoState = 0;
MessageObject.ScreenID = 0;
GPIO_write(Board_LED0, Board_LED_OFF);
GPIO_write(Board_LED1, Board_LED_OFF);
GPIO_write(Board_LED2, Board_LED_ON);
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
else
{
}
}
else if (EventPosted & FESTO_EVENT_RISER_UP)
{
if (FestoState == 3)
{
if (Festo_Sense_Piece_Placed(Driver) == 1)
{
FestoState = 4;
// wait estabilize
for (i = 0; i < 1000000; i++);
Event_post(FestoEvents, FESTO_EVENT_ADC_START);
}
else
{
FestoState = 1;
Festo_Control_Ejector(Driver, FESTO_EJECTOR_RETRACT);
Festo_Control_Platform(Driver, FESTO_PLATFORM_LOWER);
}
}
else if (FestoState == 13)
{
Event_post(FestoEvents, FESTO_EVENT_ADC_START);
}
else
{
}
}
else if (EventPosted & FESTO_EVENT_RISER_DOWN)
{
if (FestoState == 2)
{
if (Festo_Sense_Piece_Placed(Driver) == 1)
{
// get a lot of samples
for (i = 0; i < 1200; i++)
{
// this waits to get a reliable reading. If the reading is different from before, reset.
if (colour != Festo_Sense_Piece_Colour(Driver) ||
material != Festo_Sense_Piece_Material(Driver))
{
i = 0;
}
colour = Festo_Sense_Piece_Colour(Driver);
material = Festo_Sense_Piece_Material(Driver);
}
FestoState = 3;
Festo_Control_Platform(Driver, FESTO_PLATFORM_RAISE);
}
else
{
FestoState = 1;
}
}
if (FestoState == 5)
{
Festo_Control_Ejector(Driver, FESTO_EJECTOR_EXTEND);
Clock_start(myClock);
}
if (FestoState == 6)
{
Festo_Control_Ejector(Driver, FESTO_EJECTOR_RETRACT);
Clock_start(myClock);
FestoState = 7;
}
if (FestoState == 10)
{
FestoState = 11;
MessageObject.ScreenID = 3;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
}
else if (EventPosted & FESTO_EVENT_ADC_FINISH)
{
if (Mailbox_pend(ADCMailbox, &heightMeasured, BIOS_NO_WAIT))
{
Festo_Sense_Set_Piece_Height(Driver, heightMeasured);
}
else
{
Event_post(FestoEvents, FESTO_EVENT_ADC_START);
}
if (FestoState == 4)
{
if (colour == FESTO_COLOR_ORANGE && material == FESTO_PIECE_OTHER)
{
ColourAccepted = &orangeAccepted;
ColourRejected = &orangeRejected;
MaterialAccepted = &plasticAccepted;
MaterialRejected = &plasticRejected;
}
else if (colour == FESTO_COLOR_OTHER && material == FESTO_PIECE_OTHER)
{
ColourAccepted = &blackAccepted;
ColourRejected = &blackRejected;
MaterialAccepted = &plasticAccepted;
MaterialRejected = &plasticRejected;
}
else if (material == FESTO_PIECE_METALLIC)
{
ColourAccepted = NULL;
ColourRejected = NULL;
MaterialAccepted = &metallicAccepted;
MaterialRejected = &metallicRejected;
}
else
{
ColourAccepted = NULL;
ColourRejected = NULL;
MaterialAccepted = NULL;
MaterialRejected = NULL;
}
if (heightMeasured < UpperLimit && heightMeasured > LowerLimit)//withn range
{
if (ColourAccepted != NULL)
{
(*ColourAccepted)++;
}
if (MaterialAccepted != NULL)
{
(*MaterialAccepted)++;
piecesProcessed++;
}
FestoState = 6;
System_printf("Piece is acceptable\n");
System_flush();
Festo_Control_Ejector(Driver, FESTO_EJECTOR_EXTEND);
Clock_start(myClock);
}
else // out of range
{
if (ColourAccepted != NULL)
{
(*ColourRejected)++;
}
if (MaterialAccepted != NULL)
{
(*MaterialRejected)++;
piecesProcessed++;
}
System_printf("Piece is NOT acceptable\n");
System_flush();
FestoState = 5;
Festo_Control_Platform(Driver, FESTO_PLATFORM_LOWER);
}
}
else if (FestoState == 13)
{
heightCalibratedADC = heightMeasured;
heightCalibrated10mm = MessageObject.heightCalibrated;
System_printf("ADC Cal: %d for %d *0.1 mm\n", heightCalibratedADC, heightCalibrated10mm);
System_flush();
MessageObject.ScreenID = 5;
MessageObject.upperHeightCalibrated = 245;
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
}
else if (EventPosted & FESTO_EVENT_EJECTOR_FINISHED)
{
if (FestoState == 6)
{
Festo_Control_Platform(Driver, FESTO_PLATFORM_LOWER);
Clock_start(myClock);
}
else if (FestoState == 7)
{
FestoState = 1;
}
else
{
Festo_Control_Ejector(Driver, FESTO_EJECTOR_RETRACT);
Clock_start(myClock);
FestoState = 7;
}
}
else if (EventPosted & FESTO_EVENT_TICK)
{
if (Running)
{
Time1 = Clock_getTicks();
Uptime += (Time1 - Time0);
Time0 = Time1;
uptimeSeconds = Uptime * 0.001;
piecesProcessedPerSecond = 100 * piecesProcessed/(0.016667*uptimeSeconds);
MessageObject.piecesProcessed = piecesProcessed;
MessageObject.blackAccepted = blackAccepted;
MessageObject.blackRejected = blackRejected;
MessageObject.plasticAccepted = plasticAccepted;
MessageObject.plasticRejected = plasticRejected;
MessageObject.orangeAccepted = orangeAccepted;
MessageObject.orangeRejected = orangeRejected;
MessageObject.piecesProcessedPerSecond = piecesProcessedPerSecond;
MessageObject.uptimeSeconds = uptimeSeconds;
MessageObject.metalAccepted = metallicAccepted;
MessageObject.metalRejected = metallicRejected;
}
Seconds_set(Seconds_get()+1);
t1 = time(NULL);
strcpy((char*) MessageObject.timeString, asctime(localtime(&t1)));
Mailbox_post(DisplayMailbox, &MessageObject, BIOS_NO_WAIT);
}
else if (EventPosted & FESTO_EVENT_PIECE_NOT_IN_PLACE)
{
if (FestoState <= 4)
{
FestoState = 1;
Festo_Control_Ejector(Driver, FESTO_EJECTOR_RETRACT);
Festo_Control_Platform(Driver, FESTO_PLATFORM_LOWER);
}
}
else
{
if (FestoState == 1)
{
if (Festo_Sense_Piece_Placed(Driver) == 1)
{
FestoState = 2;
if (Festo_Sense_Riser_Down(Driver) == 0)
{
Festo_Control_Platform(Driver, FESTO_PLATFORM_LOWER);
}
else
{
Event_post(FestoEvents, FESTO_EVENT_RISER_DOWN);
}
}
}
}
Task_sleep(100);
}
}
Int main()
{
Task_Handle signal_task;
Clock_Params clkParams;
Timer_Params user_sys_tick_params;
Timer_Handle user_sys_tick_timer;
Error_Block eb;
#ifdef MODEL_PROFILING
int32_t t_begin, t_end;
#endif
Error_init(&eb);
/* Create a periodic Clock Instance with period = 1 system time units */
Clock_Params_init(&clkParams);
clkParams.period = 1;
clkParams.startFlag = TRUE;
Clock_create(rt_task, 2, &clkParams, NULL);
/* Create timer for user system tick */
Timer_Params_init(&user_sys_tick_params);
model_is_running = 0.0;
if(model_tsamp <= 0.0)
model_tsamp = MODEL_TSAMP;
user_sys_tick_params.period = (uint32_t)(model_tsamp * USEC_PER_SEC);
user_sys_tick_params.periodType = Timer_PeriodType_MICROSECS;
user_sys_tick_params.arg = 1;
user_sys_tick_timer = Timer_create(1,
(ti_sysbios_hal_Timer_FuncPtr)Clock_tick,
&user_sys_tick_params, NULL);
if (user_sys_tick_timer == NULL)
System_abort("Unable to create user system tick timer!");
signal_task = (Task_Handle)signal_init(&eb);
if (signal_task == NULL)
System_abort("Signal task: Task_create() failed!\n");
#ifdef MODEL_PROFILING
mdaq_profile_init();
t_begin = mdaq_profile_read_timer32();
#endif
/* Init model */
NAME(MODEL, _init)();
#ifdef MODEL_PROFILING
t_end = mdaq_profile_read_timer32();
mdaq_profile_save(t_end - t_begin,0);
#endif
/* Open mdaqnet and wait for connection */
mdaqnet_open();
model_is_running = 1.0;
BIOS_start();
}
/* Function: main =============================================================
*
* Abstract:
* Execute model on a generic target such as a workstation.
*/
int_T main(int_T argc, const char *argv[])
{
/* External mode */
// rtParseArgsForExtMode(argc, argv);
/*******************************************
* warn if the model will run indefinitely *
*******************************************/
#if MAT_FILE==0 && EXT_MODE==0
printf("warning: the simulation will run with no stop time; "
"to change this behavior select the 'MAT-file logging' option\n");
fflush(NULL);
#endif
(void)printf("\n** starting the model **\n");
/************************
* Initialize the model *
************************/
rt_InitModel();
/* External mode */
rtSetTFinalForExtMode(&rtmGetTFinal(RT_MDL));
rtExtModeCheckInit(NUMST);
Clock_Params clkParams;
Timer_Params user_sys_tick_params;
Timer_Handle user_sys_tick_timer;
/* Create timer for user system tick */
Timer_Params_init(&user_sys_tick_params);
user_sys_tick_params.period = STEP_SIZE;
user_sys_tick_params.periodType = Timer_PeriodType_MICROSECS;
user_sys_tick_params.arg = 1;
user_sys_tick_timer = Timer_create(1,
(ti_sysbios_hal_Timer_FuncPtr)Clock_tick, &user_sys_tick_params, NULL);
if(user_sys_tick_timer == NULL)
{
System_abort("Unable to create user system tick timer!");
}
/* Create a periodic Clock Instance with period = 1 system time units */
Clock_Params_init(&clkParams);
clkParams.period = 1;
clkParams.startFlag = TRUE;
Clock_create(clk0Fxn, 10, &clkParams, NULL);
// rtExtModeWaitForStartPkt(rtmGetRTWExtModeInfo(RT_MDL),
// NUMST,
// (boolean_T *)&rtmGetStopRequested(RT_MDL));
/***********************************************************************
* Execute (step) the model. You may also attach rtOneStep to an ISR, *
* in which case you replace the call to rtOneStep with a call to a *
* background task. Note that the generated code sets error status *
* to "Simulation finished" when MatFileLogging is specified in TLC. *
***********************************************************************/
// while (rtmGetErrorStatus(RT_MDL) == NULL &&
// !rtmGetStopRequested(RT_MDL)) {
//
// // rtExtModePauseIfNeeded(rtmGetRTWExtModeInfo(RT_MDL),
// // NUMST,
// // (boolean_T *)&rtmGetStopRequested(RT_MDL));
//
// if (rtmGetStopRequested(RT_MDL)) break;
//
// /* external mode */
// rtExtModeOneStep(rtmGetRTWExtModeInfo(RT_MDL),
// NUMST,
// (boolean_T *)&rtmGetStopRequested(RT_MDL));
//
// rt_OneStep();
// }
rtExtModeC6000Startup(rtmGetRTWExtModeInfo(RT_MDL),
NUMST,
(boolean_T *)&rtmGetStopRequested(RT_MDL));
BIOS_start();
}
