// 3. Subroutines Section
// MAIN: Mandatory for a C Program to be executable
int main(void){
TExaS_Init(SW_PIN_PF40, LED_PIN_PF31,ScopeOn); // activate grader and set system clock to 80 MHz
PortF_Init(); // Init port PF4 PF3 PF1
EnableInterrupts(); // enable interrupts for the grader
while(1){
SetReady();
WaitForASLow();
ClearReady();
Delay1ms(10);
WaitForASHigh();
Delay1ms(250);
SetVT();
Delay1ms(250);
ClearVT();
// Follows the nine steps list above
// a) Ready signal goes high
// b) wait for switch to be pressed
// c) Ready signal goes low
// d) wait 10ms
// e) wait for switch to be released
// f) wait 250ms
// g) VT signal goes high
// h) wait 250ms
// i) VT signal goes low
}
}
globle void EnvClear(
void *theEnv)
{
struct callFunctionItem *theFunction;
/*==========================================*/
/* Activate the watch router which captures */
/* trace output so that it is not displayed */
/* during a clear. */
/*==========================================*/
#if DEBUGGING_FUNCTIONS
EnvActivateRouter(theEnv,WTRACE);
#endif
/*===================================*/
/* Determine if a clear is possible. */
/*===================================*/
ConstructData(theEnv)->ClearReadyInProgress = TRUE;
if ((ConstructData(theEnv)->ClearReadyLocks > 0) ||
(ConstructData(theEnv)->DanglingConstructs > 0) ||
(ClearReady(theEnv) == FALSE))
{
PrintErrorID(theEnv,"CONSTRCT",1,FALSE);
EnvPrintRouter(theEnv,WERROR,"Some constructs are still in use. Clear cannot continue.\n");
#if DEBUGGING_FUNCTIONS
EnvDeactivateRouter(theEnv,WTRACE);
#endif
ConstructData(theEnv)->ClearReadyInProgress = FALSE;
return;
}
ConstructData(theEnv)->ClearReadyInProgress = FALSE;
/*===========================*/
/* Call all clear functions. */
/*===========================*/
ConstructData(theEnv)->ClearInProgress = TRUE;
for (theFunction = ConstructData(theEnv)->ListOfClearFunctions;
theFunction != NULL;
theFunction = theFunction->next)
{
if (theFunction->environmentAware)
{ (*theFunction->func)(theEnv); }
else
{ (* (void (*)(void)) theFunction->func)(); }
}
/*=============================*/
/* Deactivate the watch router */
/* for capturing output. */
/*=============================*/
#if DEBUGGING_FUNCTIONS
EnvDeactivateRouter(theEnv,WTRACE);
#endif
/*===========================================*/
/* Perform periodic cleanup if the clear was */
/* issued from an embedded controller. */
/*===========================================*/
if ((UtilityData(theEnv)->CurrentGarbageFrame->topLevel) && (! CommandLineData(theEnv)->EvaluatingTopLevelCommand) &&
(EvaluationData(theEnv)->CurrentExpression == NULL) && (UtilityData(theEnv)->GarbageCollectionLocks == 0))
{
CleanCurrentGarbageFrame(theEnv,NULL);
CallPeriodicTasks(theEnv);
}
/*===========================*/
/* Clear has been completed. */
/*===========================*/
ConstructData(theEnv)->ClearInProgress = FALSE;
#if DEFRULE_CONSTRUCT
if ((DefruleData(theEnv)->RightPrimeJoins != NULL) ||
(DefruleData(theEnv)->LeftPrimeJoins != NULL))
{ SystemError(theEnv,"CONSTRCT",1); }
#endif
/*============================*/
/* Perform reset after clear. */
/*============================*/
EnvReset(theEnv);
}
globle void Clear()
{
struct callFunctionItem *theFunction;
/*==========================================*/
/* Activate the watch router which captures */
/* trace output so that it is not displayed */
/* during a clear. */
/*==========================================*/
#if DEBUGGING_FUNCTIONS
ActivateRouter(WTRACE);
#endif
/*===================================*/
/* Determine if a clear is possible. */
/*===================================*/
ClearReadyInProgress = TRUE;
if (ClearReady() == FALSE)
{
PrintErrorID("CONSTRCT",1,FALSE);
PrintRouter(WERROR,"Some constructs are still in use. Clear cannot continue.\n");
#if DEBUGGING_FUNCTIONS
DeactivateRouter(WTRACE);
#endif
ClearReadyInProgress = FALSE;
return;
}
ClearReadyInProgress = FALSE;
/*===========================*/
/* Call all clear functions. */
/*===========================*/
ClearInProgress = TRUE;
for (theFunction = ListOfClearFunctions;
theFunction != NULL;
theFunction = theFunction->next)
{ (*theFunction->func)(); }
/*=============================*/
/* Deactivate the watch router */
/* for capturing output. */
/*=============================*/
#if DEBUGGING_FUNCTIONS
DeactivateRouter(WTRACE);
#endif
/*===========================================*/
/* Perform periodic cleanup if the clear was */
/* issued from an embedded controller. */
/*===========================================*/
if ((CurrentEvaluationDepth == 0) && (! EvaluatingTopLevelCommand) &&
(CurrentExpression == NULL))
{ PeriodicCleanup(TRUE,FALSE); }
/*===========================*/
/* Clear has been completed. */
/*===========================*/
ClearInProgress = FALSE;
}
globle BOOLEAN EnvClear_PY(
void *theEnv)
{
struct callFunctionItem *theFunction;
/*==========================================*/
/* Activate the watch router which captures */
/* trace output so that it is not displayed */
/* during a clear. */
/*==========================================*/
#if DEBUGGING_FUNCTIONS
EnvActivateRouter(theEnv,WTRACE);
#endif
/*===================================*/
/* Determine if a clear is possible. */
/*===================================*/
ConstructData(theEnv)->ClearReadyInProgress = TRUE;
if (ClearReady(theEnv) == FALSE)
{
PrintErrorID(theEnv,"CONSTRCT",1,FALSE);
EnvPrintRouter(theEnv,WERROR,"Some constructs are still in use. Clear cannot continue.\n");
#if DEBUGGING_FUNCTIONS
EnvDeactivateRouter(theEnv,WTRACE);
#endif
ConstructData(theEnv)->ClearReadyInProgress = FALSE;
return FALSE;
}
ConstructData(theEnv)->ClearReadyInProgress = FALSE;
/*===========================*/
/* Call all clear functions. */
/*===========================*/
ConstructData(theEnv)->ClearInProgress = TRUE;
for (theFunction = ConstructData(theEnv)->ListOfClearFunctions;
theFunction != NULL;
theFunction = theFunction->next)
{
if (theFunction->environmentAware)
{ (*theFunction->func)(theEnv); }
else
{ (* (void (*)(void)) theFunction->func)(); }
}
/*=============================*/
/* Deactivate the watch router */
/* for capturing output. */
/*=============================*/
#if DEBUGGING_FUNCTIONS
EnvDeactivateRouter(theEnv,WTRACE);
#endif
/*===========================================*/
/* Perform periodic cleanup if the clear was */
/* issued from an embedded controller. */
/*===========================================*/
if ((EvaluationData(theEnv)->CurrentEvaluationDepth == 0) && (! CommandLineData(theEnv)->EvaluatingTopLevelCommand) &&
(EvaluationData(theEnv)->CurrentExpression == NULL))
{ PeriodicCleanup(theEnv,TRUE,FALSE); }
/*===========================*/
/* Clear has been completed. */
/*===========================*/
ConstructData(theEnv)->ClearInProgress = FALSE;
return TRUE;
}
globle int EnvBload(
void *theEnv,
char *fileName)
{
long numberOfFunctions;
unsigned long space;
int error;
char IDbuffer[20];
char constructBuffer[CONSTRUCT_HEADER_SIZE];
struct BinaryItem *biPtr;
struct callFunctionItem *bfPtr;
/*================*/
/* Open the file. */
/*================*/
if (GenOpenReadBinary(theEnv,"bload",fileName) == 0) return(FALSE);
/*=====================================*/
/* Determine if this is a binary file. */
/*=====================================*/
GenReadBinary(theEnv,IDbuffer,(unsigned long) strlen(BloadData(theEnv)->BinaryPrefixID) + 1);
if (strcmp(IDbuffer,BloadData(theEnv)->BinaryPrefixID) != 0)
{
PrintErrorID(theEnv,"BLOAD",2,FALSE);
EnvPrintRouter(theEnv,WERROR,"File ");
EnvPrintRouter(theEnv,WERROR,fileName);
EnvPrintRouter(theEnv,WERROR," is not a binary construct file.\n");
GenCloseBinary(theEnv);
return(FALSE);
}
/*=======================================*/
/* Determine if it's a binary file using */
/* a format from a different version. */
/*=======================================*/
GenReadBinary(theEnv,IDbuffer,(unsigned long) strlen(BloadData(theEnv)->BinaryVersionID) + 1);
if (strcmp(IDbuffer,BloadData(theEnv)->BinaryVersionID) != 0)
{
PrintErrorID(theEnv,"BLOAD",3,FALSE);
EnvPrintRouter(theEnv,WERROR,"File ");
EnvPrintRouter(theEnv,WERROR,fileName);
EnvPrintRouter(theEnv,WERROR," is an incompatible binary construct file.\n");
GenCloseBinary(theEnv);
return(FALSE);
}
/*====================*/
/* Clear environment. */
/*====================*/
if (BloadData(theEnv)->BloadActive)
{
if (ClearBload(theEnv) == FALSE)
{
GenCloseBinary(theEnv);
return(FALSE);
}
}
/*=================================*/
/* Determine if the KB environment */
/* was successfully cleared. */
/*=================================*/
if (ClearReady(theEnv) == FALSE)
{
GenCloseBinary(theEnv);
EnvPrintRouter(theEnv,WERROR,"The ");
EnvPrintRouter(theEnv,WERROR,APPLICATION_NAME);
EnvPrintRouter(theEnv,WERROR," environment could not be cleared.\n");
EnvPrintRouter(theEnv,WERROR,"Binary load cannot continue.\n");
return(FALSE);
}
/*==================================*/
/* Call the list of functions to be */
/* executed before a bload occurs. */
/*==================================*/
for (bfPtr = BloadData(theEnv)->BeforeBloadFunctions;
bfPtr != NULL;
bfPtr = bfPtr->next)
{
if (bfPtr->environmentAware)
{ (*bfPtr->func)(theEnv); }
else
{ (* (void (*)(void)) bfPtr->func)(); }
}
/*====================================================*/
/* Read in the functions needed by this binary image. */
/*====================================================*/
BloadData(theEnv)->FunctionArray = ReadNeededFunctions(theEnv,&numberOfFunctions,&error);
if (error)
{
GenCloseBinary(theEnv);
AbortBload(theEnv);
return(FALSE);
}
/*================================================*/
/* Read in the atoms needed by this binary image. */
/*================================================*/
ReadNeededAtomicValues(theEnv);
/*===========================================*/
/* Determine the number of expressions to be */
/* read and allocate the appropriate space */
/*===========================================*/
AllocateExpressions(theEnv);
/*==========================================================*/
/* Read in the memory requirements of the constructs stored */
/* in this binary image and allocate the necessary space */
/*==========================================================*/
for (GenReadBinary(theEnv,constructBuffer,(unsigned long) CONSTRUCT_HEADER_SIZE);
strncmp(constructBuffer,BloadData(theEnv)->BinaryPrefixID,CONSTRUCT_HEADER_SIZE) != 0;
GenReadBinary(theEnv,constructBuffer,(unsigned long) CONSTRUCT_HEADER_SIZE))
{
intBool found;
/*================================================*/
/* Search for the construct type in the list of */
/* binary items. If found, allocate the storage */
/* needed by the construct for this binary image. */
/*================================================*/
found = FALSE;
for (biPtr = BsaveData(theEnv)->ListOfBinaryItems;
biPtr != NULL;
biPtr = biPtr->next)
{
if (strncmp(biPtr->name,constructBuffer,CONSTRUCT_HEADER_SIZE) == 0)
{
if (biPtr->bloadStorageFunction != NULL)
{
(*biPtr->bloadStorageFunction)(theEnv);
found = TRUE;
}
break;
}
}
/*==========================================*/
/* If the construct type wasn't found, skip */
/* the storage binary load information for */
/* this construct. */
/*==========================================*/
if (! found)
{
GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long));
GetSeekCurBinary(theEnv,(long) space);
if (space != 0)
{
EnvPrintRouter(theEnv,WDIALOG,"\nSkipping ");
EnvPrintRouter(theEnv,WDIALOG,constructBuffer);
EnvPrintRouter(theEnv,WDIALOG," constructs because of unavailibility\n");
}
}
}
/*======================================*/
/* Refresh the pointers in expressions. */
/*======================================*/
RefreshExpressions(theEnv);
/*==========================*/
/* Read in the constraints. */
/*==========================*/
ReadNeededConstraints(theEnv);
/*======================================================*/
/* Read in the constructs stored in this binary image. */
/*======================================================*/
for (GenReadBinary(theEnv,constructBuffer,(unsigned long) CONSTRUCT_HEADER_SIZE);
strncmp(constructBuffer,BloadData(theEnv)->BinaryPrefixID,CONSTRUCT_HEADER_SIZE) != 0;
GenReadBinary(theEnv,constructBuffer,(unsigned long) CONSTRUCT_HEADER_SIZE))
{
intBool found;
/*==================================================*/
/* Search for the function to load the construct */
/* into the previously allocated storage. If found, */
/* call the function to load the construct. */
/*==================================================*/
found = FALSE;
for (biPtr = BsaveData(theEnv)->ListOfBinaryItems;
biPtr != NULL;
biPtr = biPtr->next)
{
if (strncmp(biPtr->name,constructBuffer,CONSTRUCT_HEADER_SIZE) == 0)
{
if (biPtr->bloadFunction != NULL)
{
(*biPtr->bloadFunction)(theEnv);
found = TRUE;
}
break;
}
}
/*==========================================*/
/* If the construct type wasn't found, skip */
/* the binary data for this construct. */
/*==========================================*/
if (! found)
{
GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long));
GetSeekCurBinary(theEnv,(long) space);
}
}
/*=================*/
/* Close the file. */
/*=================*/
GenCloseBinary(theEnv);
/*========================================*/
/* Free up temporary storage used for the */
/* function and atomic value information. */
/*========================================*/
if (BloadData(theEnv)->FunctionArray != NULL)
{
genlongfree(theEnv,(void *) BloadData(theEnv)->FunctionArray,
(unsigned long) sizeof(struct FunctionDefinition *) * numberOfFunctions);
}
FreeAtomicValueStorage(theEnv);
/*==================================*/
/* Call the list of functions to be */
/* executed after a bload occurs. */
/*==================================*/
for (bfPtr = BloadData(theEnv)->AfterBloadFunctions;
bfPtr != NULL;
bfPtr = bfPtr->next)
{
if (bfPtr->environmentAware)
{ (*bfPtr->func)(theEnv); }
else
{ (* (void (*)(void)) bfPtr->func)(); }
}
/*=======================================*/
/* Add a clear function to remove binary */
/* load when a clear command is issued. */
/*=======================================*/
BloadData(theEnv)->BloadActive = TRUE;
EnvAddClearFunction(theEnv,"bload",(void (*)(void *)) ClearBload,10000);
/*=============================*/
/* Return TRUE to indicate the */
/* binary load was successful. */
/*=============================*/
return(TRUE);
}
bool Clear(
Environment *theEnv)
{
struct voidCallFunctionItem *theFunction;
GCBlock gcb;
/*=====================================*/
/* If embedded, clear the error flags. */
/*=====================================*/
if (EvaluationData(theEnv)->CurrentExpression == NULL)
{ ResetErrorFlags(theEnv); }
SetErrorValue(theEnv,NULL);
/*===================================*/
/* Determine if a clear is possible. */
/*===================================*/
ConstructData(theEnv)->ClearReadyInProgress = true;
if ((ConstructData(theEnv)->ClearReadyLocks > 0) ||
(ConstructData(theEnv)->DanglingConstructs > 0) ||
(ClearReady(theEnv) == false))
{
PrintErrorID(theEnv,"CONSTRCT",1,false);
WriteString(theEnv,STDERR,"Some constructs are still in use. Clear cannot continue.\n");
ConstructData(theEnv)->ClearReadyInProgress = false;
return false;
}
ConstructData(theEnv)->ClearReadyInProgress = false;
/*========================================*/
/* Set up the frame for tracking garbage. */
/*========================================*/
GCBlockStart(theEnv,&gcb);
/*===========================*/
/* Call all clear functions. */
/*===========================*/
ConstructData(theEnv)->ClearInProgress = true;
for (theFunction = ConstructData(theEnv)->ListOfClearFunctions;
theFunction != NULL;
theFunction = theFunction->next)
{ (*theFunction->func)(theEnv,theFunction->context); }
/*================================*/
/* Restore the old garbage frame. */
/*================================*/
GCBlockEnd(theEnv,&gcb);
CallPeriodicTasks(theEnv);
/*===========================*/
/* Clear has been completed. */
/*===========================*/
ConstructData(theEnv)->ClearInProgress = false;
#if DEFRULE_CONSTRUCT
if ((DefruleData(theEnv)->RightPrimeJoins != NULL) ||
(DefruleData(theEnv)->LeftPrimeJoins != NULL))
{ SystemError(theEnv,"CONSTRCT",1); }
#endif
/*============================*/
/* Perform reset after clear. */
/*============================*/
Reset(theEnv);
return true;
}
