int testmain6(void){ // Testmain6
volatile unsigned long delay;
OS_Init(); // initialize, disable interrupts
delay = add(3,4);
SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOB; // activate port B
delay = SYSCTL_RCGC2_R; // allow time to finish activating
GPIO_PORTB_DIR_R |= 0x07; // make PB2, PB1, PB0 out
GPIO_PORTB_DEN_R |= 0x07; // enable digital I/O on PB2, PB1, PB0
SignalCount1 = 0; // number of times s is signaled
SignalCount2 = 0; // number of times s is signaled
SignalCount3 = 0; // number of times s is signaled
WaitCount1 = 0; // number of times s is successfully waited on
WaitCount2 = 0; // number of times s is successfully waited on
WaitCount3 = 0; // number of times s is successfully waited on
OS_InitSemaphore(&s,0); // this is the test semaphore
OS_AddPeriodicThread(&Signal1,1,(799*TIME_1MS)/1000,0); // 0.799 ms, higher priority
OS_AddPeriodicThread(&Signal2,2,(1111*TIME_1MS)/1000,1); // 1.111 ms, lower priority
NumCreated = 0 ;
NumCreated += OS_AddThread(&Thread6,128,6); // idle thread to keep from crashing
NumCreated += OS_AddThread(&OutputThread,128,2); // results output thread
NumCreated += OS_AddThread(&Signal3,128,2); // signalling thread
NumCreated += OS_AddThread(&Wait1,128,2); // waiting thread
NumCreated += OS_AddThread(&Wait2,128,2); // waiting thread
NumCreated += OS_AddThread(&Wait3,128,2); // waiting thread
OS_Launch(TIME_1MS); // 1ms, doesn't return, interrupts enabled in here
return 0; // this never executes
}
int testmain6(void){ // Testmain6
volatile unsigned long delay;
OS_Init(); // initialize, disable interrupts
delay = add(3,4);
SignalCount1 = 0; // number of times s is signaled
SignalCount2 = 0; // number of times s is signaled
SignalCount3 = 0; // number of times s is signaled
WaitCount1 = 0; // number of times s is successfully waited on
WaitCount2 = 0; // number of times s is successfully waited on
WaitCount3 = 0; // number of times s is successfully waited on
OS_InitSemaphore(&s,0); // this is the test semaphore
OS_AddPeriodicThread(&Signal1,(799*TIME_1MS)/1000,0); // 0.799 ms, higher priority
OS_AddPeriodicThread(&Signal2,(1111*TIME_1MS)/1000,1); // 1.111 ms, lower priority
NumCreated = 0 ;
NumCreated += OS_AddThread(&Thread6,128,6); // idle thread to keep from crashing
NumCreated += OS_AddThread(&OutputThread,128,2); // results output thread
NumCreated += OS_AddThread(&Signal3,128,2); // signalling thread
NumCreated += OS_AddThread(&Wait1,128,2); // waiting thread
NumCreated += OS_AddThread(&Wait2,128,2); // waiting thread
NumCreated += OS_AddThread(&Wait3,128,2); // waiting thread
OS_Launch(TIMESLICE); // 1ms, doesn't return, interrupts enabled in here
return 0; // this never executes
}
int testmain5(void){ // Testmain5
volatile unsigned long delay;
OS_Init(); // initialize, disable interrupts
NumCreated = 0 ;
NumCreated += OS_AddThread(&Thread6,128,2);
NumCreated += OS_AddThread(&Thread7,128,1);
OS_AddPeriodicThread(&TaskA,(TIME_1MS*111)/100,0); // 1 ms, higher priority
OS_AddPeriodicThread(&TaskB,TIME_1MS,1); // 2 ms, lower priority
OS_Launch(TIMESLICE); // 2ms, doesn't return, interrupts enabled in here
return 0; // this never executes
}
int testmain2(void){ // testmain2
OS_Init(); // initialize, disable interrupts
NumCreated = 0 ;
NumCreated += OS_AddThread(&Thread1b,128,1);
NumCreated += OS_AddThread(&Thread2b,128,1);
NumCreated += OS_AddThread(&Thread3b,128,3);
OS_AddPeriodicThread(&Dummy1, PERIOD, 1);
OS_AddPeriodicThread(&Dummy2, PERIOD, 2);
OS_Launch(TIMESLICE); // doesn't return, interrupts enabled in here
return 0; // this never executes
}
// --------------------------- OS_Launch -----------------------------
void OS_Launch(unsigned long timeSlice){
SysTick_InitInt(timeSlice); //For preemptive context switching
OS_AddPeriodicThread(&RunTimeUpdate, 2, 128);
OS_AddPeriodicThread(&DecrementSleep, 2, 1);
OS_AddThread(&NoCrash,128,7); //to guarantee there is always a thread in the actives list
OS_AddThread(&OS_Display,128,1);
OS_AddThread(&OS_ProcessInterpreter,128,3);
RunPt = Actives;
StartOS();
EnableInterrupts();
}
//*******************final user main DEMONTRATE THIS TO TA**********
int main(void){
OS_Init(); // initialize, disable interrupts
PortE_Init();
DataLost = 0; // lost data between producer and consumer
NumSamples = 0;
MaxJitter = 0; // in 1us units
//********initialize communication channels
OS_MailBox_Init();
OS_Fifo_Init(128); // ***note*** 4 is not big enough*****
ST7735_InitR(INITR_REDTAB); // initialize LCD
UART_Init(); // initialize UART
//*******attach background tasks***********
OS_AddSW1Task(&SW1Push,2);
// OS_AddSW2Task(&SW2Push,2); // add this line in Lab 3
ADC_Init(4); // sequencer 3, channel 4, PD3, sampling in DAS()
OS_AddPeriodicThread(&DAS,PERIOD,1); // 2 kHz real time sampling of PD3
NumCreated = 0 ;
// create initial foreground threads
NumCreated += OS_AddThread(&Interpreter,128,2);
NumCreated += OS_AddThread(&Consumer,128,1);
NumCreated += OS_AddThread(&PID,128,3); // Lab 3, make this lowest priority
OS_Launch(TIME_2MS); // doesn't return, interrupts enabled in here
return 0; // this never executes
}
/*
===================================================================================================
COMMAND HANDLER :: ledTogglerHandler
- enables the periodic led toggler task
- return success value
===================================================================================================
*/
int ledTogglerHandler(char** tokens, uint8_t numTokens){
if (ledTogglerEnabled){
printf("ERROR: Toggler already running!\n\n");
return CMD_FAILURE;
}
// verify correct number of arguments
if (numTokens < 3) {
printf("ERROR: Incorrect number of args.\n\n");
printf(" Usage: ledToggler [period in ms]\n\n");
return CMD_FAILURE;
}
// parse arguments to integers
int period = atoi(tokens[2]);
// verify argument range
if (period < 1 || period > 1000000){
printf("ERROR: Period must be positive and less than 1,000,000 ms.\n\n");
return CMD_FAILURE;
}
// actually do what we want
OS_AddPeriodicThread(ledTogglerTask, period, 0);
printf(" Enabling PF3 toggler with a %dms period...\n\n", period);
ledTogglerEnabled = true;
return CMD_SUCCESS;
}
//*******************final user main DEMONTRATE THIS TO TA**********
int main(void){
// Set the clocking to run from PLL at 50 MHz
SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
OS_Init(); // initialize, disable interrupts
DataLost = 0; // lost data between producer and consumer
NumSamples = 0;
MaxJitter = 0; // OS_Time in 20ns units
MinJitter = 10000000;
//********initialize communication channels
OS_MailBox_Init();
OS_Fifo_Init(32); // ***note*** 4 is not big enough*****
//*******attach background tasks***********
OS_AddButtonTask(&ButtonPush,2);
OS_AddPeriodicThread(&DAS,PERIOD,0); // 2 kHz real time sampling
NumCreated = 0 ;
// create initial foreground threads
NumCreated += OS_AddThread(&Interpreter,128,2);
NumCreated += OS_AddThread(&Consumer,128,1);
NumCreated += OS_AddThread(&PID,128,3);
OS_Launch(TIMESLICE); // doesn't return, interrupts enabled in here
return 0; // this never executes
}
//*******************final user main DEMONTRATE THIS TO TA**********
int main(void){ // lab 3 real main
OS_Init(); // initialize, disable interrupts
DataLost = 0; // lost data between producer and consumer
NumSamples = 0;
//********initialize communication channels
OS_MailBox_Init();
OS_Fifo_Init(32); // ***note*** 4 is not big enough*****
//*******attach background tasks***********
OS_AddButtonTask(&ButtonPush,2);
OS_AddDownTask(&DownPush,3);
OS_AddPeriodicThread(&DAS,1,PERIOD,0); // 2 kHz real time sampling
NumCreated = 0 ;
// create initial foreground threads
NumCreated += OS_AddThread(&Interpreter,128,2);
NumCreated += OS_AddThread(&Consumer,128,1);
NumCreated += OS_AddThread(&PID,128,3);
OS_Launch(TIMESLICE); // doesn't return, interrupts enabled in here
return 0; // this never executes
}
int Testmain5(void){ // Testmain5
volatile unsigned long delay;
SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOB; // activate port B
delay = SYSCTL_RCGC2_R; // allow time to finish activating
GPIO_PORTB_DIR_R |= 0x07; // make PB2, PB1, PB0 out
GPIO_PORTB_DEN_R |= 0x07; // enable digital I/O on PB2, PB1, PB0
OS_Init(); // initialize, disable interrupts
NumCreated = 0 ;
NumCreated += OS_AddThread(&Thread6,128,2);
NumCreated += OS_AddThread(&Thread7,128,1);
OS_AddPeriodicThread(&TaskA,TIME_1MS,0); // 1 ms, higher priority
OS_AddPeriodicThread(&TaskB,2*TIME_1MS,1); // 2 ms, lower priority
OS_Launch(TIMESLICE); // 2ms, doesn't return, interrupts enabled in here
return 0; // this never executes
}
// main program to test the file system (eFile.c)
int filesystem_testmain(void) {
OS_Init(); // initialize, disable interrupts
//*******attach background tasks***********
OS_AddPeriodicThread(&disk_timerproc,10*TIME_1MS,0); // time out routines for disk
// TODO - add threads for testing
OS_Launch(TIMESLICE);
return 0;
}
int testmain4(void){ // Testmain4
Count4 = 0;
OS_Init(); // initialize, disable interrupts
NumCreated = 0 ;
OS_AddPeriodicThread(&BackgroundThread1d,1,PERIOD,0);
OS_AddButtonTask(&BackgroundThread5d,2);
NumCreated += OS_AddThread(&Thread2d,128,2);
NumCreated += OS_AddThread(&Thread3d,128,3);
NumCreated += OS_AddThread(&Thread4d,128,3);
OS_Launch(TIMESLICE/16); // doesn't return, interrupts enabled in here
return 0; // this never executes
}
void Thread2c(void){
OS_InitSemaphore(&Readyc,0);
Count1 = 0; // number of times signal is called
Count2 = 0;
Count5 = 0; // Count2 + Count5 should equal Count1
NumCreated += OS_AddThread(&Thread5c,128,3);
OS_AddPeriodicThread(&BackgroundThread1c,1,TIME_1MS,1);
for(;;){
OS_Wait(&Readyc);
Count2++; // Count2 + Count5 should equal Count1, Count5 may be 0
}
}
// main program to measure the bandwidth of the SD card
// measure the maximum rate at which you can continuously write to the SD card
// output to unused GPIO pins
int bandwidth_write_testmain(void) {
OS_Init(); // initialize, disable interrupts
//*******attach background tasks***********
OS_AddPeriodicThread(&disk_timerproc,10*TIME_1MS,0); // time out routines for disk
// add threads for testing
OS_AddThread(&write_test, 128, 0); // this thread adds SH_Shell when it's done
OS_Launch(TIMESLICE);
return 0;
}
// main program to measure the bandwidth of the SD card
// measure the maximum rate at which you can continuously read from the SD card
// output to unused GPIO pins
int read_main(void) {
OS_Init(); // initialize, disable interrupts
//*******attach background tasks***********
OS_AddPeriodicThread(&disk_timerproc,10,0); // time out routines for disk
// add threads for testing
OS_AddThread(&read_test, 128, 0);
OS_Launch(TIMESLICE);
return 0;
}
// simple test main
int simple_test_main(void) {
OS_Init(); // initialize, disable interrupts
UART_Init();
//*******attach background tasks***********
OS_AddPeriodicThread(&disk_timerproc,10,0); // time out routines for disk
OS_AddThread(&TestFile, 128, 1);
OS_Launch(TIMESLICE);
return 0;
}
//******************* test main2 **********
// SYSTICK interrupts, period established by OS_Launch
// Timer interrupts, period established by first call to OS_AddPeriodicThread
int testmain2(void){
OS_Init(); // initialize, disable interrupts
//*******attach background tasks***********
OS_AddPeriodicThread(&disk_timerproc,10*TIME_1MS,0); // time out routines for disk
NumCreated = 0 ;
// create initial foreground threads
NumCreated += OS_AddThread(&TestFile,128,1);
NumCreated += OS_AddThread(&IdleTask,128,3);
OS_Launch(10*TIME_1MS); // doesn't return, interrupts enabled in here
return 0; // this never executes
}
//*******************lab 5 main **********
int realmain(void){ // lab 5 real main
OS_Init(); // initialize, disable interrupts
Running = 0; // robot not running
DataLost = 0; // lost data between producer and consumer
NumSamples = 0;
//********initialize communication channels
OS_Fifo_Init(512); // ***note*** 4 is not big enough*****
ADC_Collect(0, 1000, &Producer); // start ADC sampling, channel 0, 1000 Hz
//*******attach background tasks***********
OS_AddButtonTask(&ButtonPush,2);
OS_AddDownTask(&DownPush,3);
OS_AddPeriodicThread(disk_timerproc,10*TIME_1MS,5);
NumCreated = 0 ;
// create initial foreground threads
NumCreated += OS_AddThread(&Interpreter,128,2);
NumCreated += OS_AddThread(&IdleTask,128,7); // runs when nothing useful to do
OS_Launch(TIMESLICE); // doesn't return, interrupts enabled in here
return 0; // this never executes
}
void Interpreter(void) // just a prototype, link to your interpreter
{
uint32_t stringSize;
uint32_t adcVoltage;
uint8_t deviceChosen;
uint8_t taskAddedBefore = 0;
uint8_t commandChosen = -1;
char message[MESSAGELENGTH] = "";
OutCRLF();
UART_OutString("Input Command: ");
while(1){
OutCRLF();
//UART_OutString("Commands: 0 - ADC, 1 - LCD, 2 - Time");
OutCRLF();
commandChosen = UART_InChar();
switch(commandChosen)
{
case '0':
OutCRLF();
UART_OutString("ADC Voltage = ");
//ADC_Open(4);
adcVoltage = (ADC_In() *3300) / 4095; //convert to mV
UART_OutUDec(adcVoltage);
OutCRLF();
break;
case '1':
OutCRLF();
UART_OutString("Enter LCD device 0 or 1: ");
deviceChosen = UART_InUDec();
OutCRLF();
UART_OutString("Enter message: ");
UART_InString(message, MESSAGELENGTH);
OutCRLF();
stringSize = strlen(message);
if(stringSize > 20)
{
OutCRLF();
UART_OutString("String too long...");
OutCRLF();
}
LCD_test(deviceChosen, message); //prints to lcd
OutCRLF();
break;
case '2':
if(!taskAddedBefore){
OS_AddPeriodicThread(dummy, 5, 1);
taskAddedBefore = 1;
}
OutCRLF();
UART_OutUDec(OS_ReadPeriodicTime());
OutCRLF();
break;
case '3':
UART_OutString("NumSamples: ");
UART_OutUDec(NumSamples);
OutCRLF();
break;
case '4':
UART_OutString("Jitter: ");
UART_OutUDec(MaxJitter);
OutCRLF();
break;
case '5':
UART_OutString("DataLost: ");
UART_OutUDec(DataLost);
OutCRLF();
break;
case '6':
UART_OutString("FilterWork: ");
UART_OutUDec(FilterWork);
OutCRLF();
break;
case '7':
UART_OutString("NumCreated: ");
UART_OutUDec(NumCreated);
OutCRLF();
break;
case '8':
for(int i = 0; i<64; i++)
{
UART_OutUDec(x[i]);
OutCRLF();
}
break;
default:
UART_OutString("Incorrect command!");
break;
}
//adcSample = ADC_In();
//ST7735_SetCursor(0,0);
//ST7735_OutUDec(adcSample);
}
}