hladu357
/
Taltech_rtos
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Taltech_rtos/Lab4_Fitness_4C123/Lab4.c

784 lines
28 KiB
C
Raw Permalink Blame History

// Lab4.c
// Runs on either MSP432 or TM4C123
// Starter project to Lab 4. Take sensor readings, process the data,
// and output the results. Specifically, this program will
// measure steps using the accelerometer, audio sound amplitude using
// the microphone, temperature using the TMP006, and light using the
// OPT3001.
// Daniel and Jonathan Valvano
// August 22, 2016
/* This example accompanies the books
"Embedded Systems: Real Time Interfacing to ARM Cortex M Microcontrollers",
ISBN: 978-1463590154, Jonathan Valvano, copyright (c) 2016
"Embedded Systems: Real-Time Operating Systems for ARM Cortex-M Microcontrollers",
ISBN: 978-1466468863, Jonathan Valvano, copyright (c) 2016
"Embedded Systems: Introduction to the MSP432 Microcontroller",
ISBN: 978-1512185676, Jonathan Valvano, copyright (c) 2016
"Embedded Systems: Real-Time Interfacing to the MSP432 Microcontroller",
ISBN: 978-1514676585, Jonathan Valvano, copyright (c) 2016
Copyright 2016 by Jonathan W. Valvano, valvano@mail.utexas.edu
You may use, edit, run or distribute this file
as long as the above copyright notice remains
THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED
OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
VALVANO SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL,
OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
For more information about my classes, my research, and my books, see
http://users.ece.utexas.edu/~valvano/
*/
#include <stdint.h>
#include "BSP.h"
#include "Profile.h"
#include "Texas.h"
#include "CortexM.h"
#include "os.h"
uint32_t sqrt32(uint32_t s);
#define THREADFREQ 1000 // frequency in Hz of round robin scheduler
//---------------- Global variables shared between tasks ----------------
uint32_t Time; // elasped time in 100 ms units
uint32_t Steps; // number of steps counted
uint32_t Magnitude; // will not overflow (3*1,023^2 = 3,139,587)
// Exponentially Weighted Moving Average
uint32_t EWMA; // https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
uint16_t SoundData; // raw data sampled from the microphone
int32_t SoundAvg;
uint32_t SoundRMS; // Root Mean Square average of most recent sound samples
uint32_t LightData; // 100 lux
int32_t TemperatureData; // 0.1C
// semaphores
int32_t NewData; // true when new numbers to display on top of LCD
int32_t LCDmutex; // exclusive access to LCD
int32_t I2Cmutex; // exclusive access to I2C
int ReDrawAxes = 0; // non-zero means redraw axes on next display task
enum plotstate{
Accelerometer,
Microphone,
Temperature,
Light
};
enum plotstate PlotState = Accelerometer;
//color constants
#define BGCOLOR LCD_BLACK
#define AXISCOLOR LCD_ORANGE
#define MAGCOLOR LCD_YELLOW
#define EWMACOLOR LCD_CYAN
#define SOUNDCOLOR LCD_CYAN
#define LIGHTCOLOR LCD_RED
#define TEMPCOLOR LCD_LIGHTGREEN
#define TOPTXTCOLOR LCD_WHITE
#define TOPNUMCOLOR LCD_ORANGE
//------------ end of Global variables shared between tasks -------------
//---------------- Task0 samples sound from microphone ----------------
// High priority thread run by OS in real time at 1000 Hz
#define SOUNDRMSLENGTH 1000 // number of samples to collect before calculating RMS (may overflow if greater than 4104)
int16_t SoundArray[SOUNDRMSLENGTH];
int32_t TakeSoundData; // binary semaphore
int32_t ADCmutex; // access to ADC
// *********Task0*********
// Task0 measures sound intensity
// Periodic main thread runs in real time at 1000 Hz
// collects data from microphone, high priority
// Inputs: none
// Outputs: none
void Task0(void){
static int32_t soundSum = 0;
static int time = 0;// units of microphone sampling rate
SoundRMS = 0;
while(1){
OS_Wait(&TakeSoundData); // signaled by OS every 1ms
TExaS_Task0(); // record system time in array, toggle virtual logic analyzer
Profile_Toggle0(); // viewed by the logic analyzer to know Task0 started
OS_Wait(&ADCmutex);
BSP_Microphone_Input(&SoundData);
OS_Signal(&ADCmutex);
soundSum = soundSum + (int32_t)SoundData;
SoundArray[time] = SoundData;
time = time + 1;
if(time == SOUNDRMSLENGTH){
SoundAvg = soundSum/SOUNDRMSLENGTH;
soundSum = 0;
OS_Signal(&NewData); // makes task5 run every 1 sec
time = 0;
}
}
}
/* ****************************************** */
/* End of Task0 Section */
/* ****************************************** */
//---------------- Task1 measures acceleration ----------------
// Event thread run by OS in real time at 10 Hz
int32_t TakeAccelerationData;
uint32_t LostTask1Data; // number of times that the FIFO was full when acceleration data was ready
uint16_t AccX, AccY, AccZ; // returned by BSP as 10-bit numbers
#define ALPHA 128 // The degree of weighting decrease, a constant smoothing factor between 0 and 1,023. A higher ALPHA discounts older observations faster.
// basic step counting algorithm is based on a forum post from
// http://stackoverflow.com/questions/16392142/android-accelerometer-profiling/16539643#16539643
enum state{ // the step counting algorithm cycles through four states
LookingForMax, // looking for a local maximum in current magnitude
LookingForCross1, // looking for current magnitude to cross average magnitude, minus a constant
LookingForMin, // looking for a local minimum in current magnitude
LookingForCross2 // looking for current magnitude to cross average magnitude, plus a constant
};
enum state AlgorithmState = LookingForMax;
#define LOCALCOUNTTARGET 5 // The number of valid measured magnitudes needed to confirm a local min or local max. Increase this number for longer strides or more frequent measurements.
#define AVGOVERSHOOT 25 // The amount above or below average a measurement must be to count as "crossing" the average. Increase this number to reject increasingly hard shaking as steps.
// *********Task1*********
// Task1 collects data from accelerometer in real time
// Periodic main thread runs in real time at 10 Hz
// Inputs: none
// Outputs: none
void Task1(void){uint32_t squared;
// initialize the exponential weighted moving average filter
BSP_Accelerometer_Input(&AccX, &AccY, &AccZ);
Magnitude = sqrt32(AccX*AccX + AccY*AccY + AccZ*AccZ);
EWMA = Magnitude; // this is a guess; there are many options
Steps = 0;
LostTask1Data = 0;
while(1){
OS_Wait(&TakeAccelerationData); // signaled by OS every 100ms
TExaS_Task1(); // records system time in array, toggles virtual logic analyzer
Profile_Toggle1(); // viewed by the logic analyzer to know Task1 started
OS_Wait(&ADCmutex);
BSP_Accelerometer_Input(&AccX, &AccY, &AccZ);
OS_Signal(&ADCmutex);
squared = AccX*AccX + AccY*AccY + AccZ*AccZ;
if(OS_FIFO_Put(squared) == -1){ // makes Task2 run every 100ms
LostTask1Data = LostTask1Data + 1;
}
Time++; // in 100ms units
}
}
/* ****************************************** */
/* End of Task1 Section */
/* ****************************************** */
//---------------- Task2 calculates steps and plots data on LCD ----------------
// Main thread scheduled by OS round robin preemptive scheduler
// accepts data from accelerometer, calculates steps, plots on LCD
// If no data are lost, the main loop in Task2 runs exactly at 10 Hz, but not in real time
#define ACCELERATION_MAX 1400
#define ACCELERATION_MIN 600
#define SOUND_MAX 900
#define SOUND_MIN 300
#define LIGHT_MAX 2000
#define LIGHT_MIN 0
#define TEMP_MAX 1023
#define TEMP_MIN 0
void drawaxes(void){
OS_Wait(&LCDmutex);
if(PlotState == Accelerometer){
BSP_LCD_Drawaxes(AXISCOLOR, BGCOLOR, "Time", "Mag", MAGCOLOR, "Ave", EWMACOLOR, ACCELERATION_MAX, ACCELERATION_MIN);
} else if(PlotState == Microphone){
BSP_LCD_Drawaxes(AXISCOLOR, BGCOLOR, "Time", "Sound", SOUNDCOLOR, "", 0, SoundData+100, SoundData-100);
} else if(PlotState == Temperature){
BSP_LCD_Drawaxes(AXISCOLOR, BGCOLOR, "Time", "Temp", TEMPCOLOR, "", 0, TEMP_MAX, TEMP_MIN);
} else if(PlotState == Light){
BSP_LCD_Drawaxes(AXISCOLOR, BGCOLOR, "Time", "Light", LIGHTCOLOR, "", 0, LIGHT_MAX, LIGHT_MIN);
}
OS_Signal(&LCDmutex); ReDrawAxes = 0;
}
void Task2(void){uint32_t data;
uint32_t localMin; // smallest measured magnitude since odd-numbered step detected
uint32_t localMax; // largest measured magnitude since even-numbered step detected
uint32_t localCount; // number of measured magnitudes above local min or below local max
localMin = 1024;
localMax = 0;
localCount = 0;
drawaxes();
while(1){
data = OS_FIFO_Get();
TExaS_Task2(); // records system time in array, toggles virtual logic analyzer
Profile_Toggle2(); // viewed by the logic analyzer to know Task2 started
Magnitude = sqrt32(data);
EWMA = (ALPHA*Magnitude + (1023 - ALPHA)*EWMA)/1024;
if(AlgorithmState == LookingForMax){
if(Magnitude > localMax){
localMax = Magnitude;
localCount = 0;
} else{
localCount = localCount + 1;
if(localCount >= LOCALCOUNTTARGET){
AlgorithmState = LookingForCross1;
}
}
} else if(AlgorithmState == LookingForCross1){
if(Magnitude > localMax){
// somehow measured a very large magnitude
localMax = Magnitude;
localCount = 0;
AlgorithmState = LookingForMax;
} else if(Magnitude < (EWMA - AVGOVERSHOOT)){
// step detected
Steps = Steps + 1;
localMin = 1024;
localCount = 0;
AlgorithmState = LookingForMin;
}
} else if(AlgorithmState == LookingForMin){
if(Magnitude < localMin){
localMin = Magnitude;
localCount = 0;
} else{
localCount = localCount + 1;
if(localCount >= LOCALCOUNTTARGET){
AlgorithmState = LookingForCross2;
}
}
} else if(AlgorithmState == LookingForCross2){
if(Magnitude < localMin){
// somehow measured a very small magnitude
localMin = Magnitude;
localCount = 0;
AlgorithmState = LookingForMin;
} else if(Magnitude > (EWMA + AVGOVERSHOOT)){
// step detected
Steps = Steps + 1;
localMax = 0;
localCount = 0;
AlgorithmState = LookingForMax;
}
}
if(ReDrawAxes){
drawaxes();
ReDrawAxes = 0;
}
OS_Wait(&LCDmutex);
if(PlotState == Accelerometer){
BSP_LCD_PlotPoint(Magnitude, MAGCOLOR);
BSP_LCD_PlotPoint(EWMA, EWMACOLOR);
} else if(PlotState == Microphone){
BSP_LCD_PlotPoint(SoundData, SOUNDCOLOR);
} else if(PlotState == Temperature){
BSP_LCD_PlotPoint(TemperatureData, TEMPCOLOR);
} else if(PlotState == Light){
BSP_LCD_PlotPoint(LightData, LIGHTCOLOR);
}
BSP_LCD_PlotIncrement();
OS_Signal(&LCDmutex);
}
}
/* ****************************************** */
/* End of Task2 Section */
/* ****************************************** */
//------------Task3 handles switch input, buzzer output-------
// *********Task3*********
// Main thread scheduled by OS round robin preemptive scheduler
// real-time task, signaled on touch
// with bouncing, may also be called on release
// checks the switches, updates the mode, and outputs to the buzzer and LED
// Inputs: none
// Outputs: none
int32_t SwitchTouch;
void Task3(void){
uint8_t current;
OS_InitSemaphore(&SwitchTouch,0); // signaled on touch button1
OS_EdgeTrigger_Init(&SwitchTouch, 3);
while(1){
OS_Wait(&SwitchTouch); // OS signals on touch
TExaS_Task3(); // records system time in array, toggles virtual logic analyzer
Profile_Toggle3(); // viewed by the logic analyzer to know Task3 started
OS_Sleep(10); // debounce the switches
current = BSP_Button1_Input();
if(current == 0){ // Button1 was pressed
BSP_Buzzer_Set(512); // beep for 20ms
OS_Sleep(20);
BSP_Buzzer_Set(0);
if(PlotState == Accelerometer){
PlotState = Microphone;
} else if(PlotState == Microphone){
PlotState = Temperature;
} else if(PlotState == Temperature){
PlotState = Light;
} else if(PlotState == Light){
PlotState = Accelerometer;
}
ReDrawAxes = 1; // redraw axes on next call of display task
}
OS_EdgeTrigger_Restart();
}
}
/* ****************************************** */
/* End of Task3 Section */
/* ****************************************** */
//------------Task4 measures temperature-------
// *********Task4*********
// Main thread scheduled by OS round robin preemptive scheduler
// measures temperature
// Inputs: none
// Outputs: none
void Task4(void){int32_t voltData,tempData;
int done;
while(1){
TExaS_Task4(); // records system time in array, toggles virtual logic analyzer
Profile_Toggle4(); // viewed by the logic analyzer to know Task4 started
OS_Wait(&I2Cmutex);
BSP_TempSensor_Start();
OS_Signal(&I2Cmutex);
done = 0;
OS_Sleep(1000); // waits about 1 sec
while(done == 0){
OS_Wait(&I2Cmutex);
done = BSP_TempSensor_End(&voltData, &tempData);
OS_Signal(&I2Cmutex);
}
TemperatureData = tempData/10000;
}
}
/* ****************************************** */
/* End of Task4 Section */
/* ****************************************** */
/* ------------------------------------------ */
//------- Task5 displays text on LCD -----------
/* ------------------------------------------ */
// If no data are lost, the main loop in Task5 runs exactly at 1 Hz, but not in real time
// *********Task5*********
// Main thread scheduled by OS round robin preemptive scheduler
// updates the text at the top and bottom of the LCD
// Inputs: none
// Outputs: none
void Task5(void){int32_t soundSum;
OS_Wait(&LCDmutex);
BSP_LCD_DrawString(0, 0, "Temp=", TOPTXTCOLOR);
BSP_LCD_DrawString(0, 1, "Step=", TOPTXTCOLOR);
BSP_LCD_DrawString(10, 0, "Light=", TOPTXTCOLOR);
BSP_LCD_DrawString(10, 1, "Sound=", TOPTXTCOLOR);
OS_Signal(&LCDmutex);
while(1){
OS_Wait(&NewData);
TExaS_Task5(); // records system time in array, toggles virtual logic analyzer
Profile_Toggle5(); // viewed by the logic analyzer to know Task5 started
soundSum = 0;
for(int i=0; i<SOUNDRMSLENGTH; i=i+1){
soundSum = soundSum + (SoundArray[i] - SoundAvg)*(SoundArray[i] - SoundAvg);
}
SoundRMS = sqrt32(soundSum/SOUNDRMSLENGTH);
OS_Wait(&LCDmutex);
BSP_LCD_SetCursor(5, 0); BSP_LCD_OutUFix2_1(TemperatureData, TEMPCOLOR);
BSP_LCD_SetCursor(5, 1); BSP_LCD_OutUDec4(Steps, MAGCOLOR);
BSP_LCD_SetCursor(16, 0); BSP_LCD_OutUDec4(LightData, LIGHTCOLOR);
BSP_LCD_SetCursor(16, 1); BSP_LCD_OutUDec4(SoundRMS, SOUNDCOLOR);
BSP_LCD_SetCursor(16,12); BSP_LCD_OutUDec4(Time/10, TOPNUMCOLOR);
//debug code
if(LostTask1Data){
BSP_LCD_SetCursor(0, 12); BSP_LCD_OutUDec4(LostTask1Data, BSP_LCD_Color565(255, 0, 0));
}
//end of debug code
OS_Signal(&LCDmutex);
}
}
/* ****************************************** */
/* End of Task5 Section */
/* ****************************************** */
//---------------- Task6 measures light ----------------
// *********Task6*********
// Main thread scheduled by OS round robin preemptive scheduler
// Task6 measures light intensity
// Inputs: none
// Outputs: none
void Task6(void){ uint32_t lightData;
int done;
while(1){
TExaS_Task6(); // records system time in array, toggles virtual logic analyzer
Profile_Toggle6(); // viewed by the logic analyzer to know Task6 started
OS_Wait(&I2Cmutex);
BSP_LightSensor_Start();
OS_Signal(&I2Cmutex);
done = 0;
OS_Sleep(800); // waits about 0.8 sec
while(done == 0){
OS_Wait(&I2Cmutex);
done = BSP_LightSensor_End(&lightData);
OS_Signal(&I2Cmutex);
}
LightData = lightData/100;
}
}
/* ****************************************** */
/* End of Task6 Section */
/* ****************************************** */
//---------------- Task7 dummy function ----------------
// *********Task7*********
// Main thread scheduled by OS round robin preemptive scheduler
// Task7 does nothing but never blocks or sleeps
// Inputs: none
// Outputs: none
uint32_t Count7;
void Task7(void){
Count7 = 0;
while(1){
Count7++;
WaitForInterrupt();
}
}
/* ****************************************** */
/* End of Task7 Section */
/* ****************************************** */
//---------------- Step 6 ----------------
// Step 6 is to implement the fitness device by combining the
// OS functions that were implemented and tested in the earlier
// steps with the user tasks in this file. Completing this
// step will give you your grade, so remember to change the
// second parameter in TExaS_Init() to your 4-digit number.
// Task Purpose When to Run
// Task0 microphone periodically exactly every 1 ms
// Task1 accelerometer periodically exactly every 100 ms
// Task2 plot on LCD after Task1 finishes
// Task3 switch/buzzer whenever button 1 touched
// Task4 temperature periodically every 1 sec
// Task5 numbers on LCD after Task0 runs SOUNDRMSLENGTH times
// Task6 light periodically every 800 ms
// Task7 dummy no timing requirement
// Remember that you must have exactly one main() function, so
// to work on this step, you must rename all other main()
// functions in this file.
int main(void){
OS_Init();
Profile_Init(); // initialize the 7 hardware profiling pins
BSP_Button1_Init();
BSP_Button2_Init();
BSP_RGB_Init(0, 0, 0);
BSP_Buzzer_Init(0);
BSP_LCD_Init();
BSP_LCD_FillScreen(BSP_LCD_Color565(0, 0, 0));
BSP_LightSensor_Init();
BSP_TempSensor_Init();
Time = 0;
OS_InitSemaphore(&NewData, 0); // 0 means no data
OS_InitSemaphore(&LCDmutex, 1); // 1 means free
OS_InitSemaphore(&I2Cmutex, 1); // 1 means free
OS_InitSemaphore(&TakeSoundData,0);
OS_InitSemaphore(&ADCmutex,1);
BSP_Microphone_Init();
BSP_Accelerometer_Init();
OS_InitSemaphore(&TakeAccelerationData,0);
OS_FIFO_Init(); // initialize FIFO used to send data between Task1 and Task2
OS_AddThreads(&Task0,0, &Task1,1, &Task2,2, &Task3,3,
&Task4,3, &Task5,3, &Task6,3, &Task7,4);
OS_PeriodTrigger0_Init(&TakeSoundData,1); // every 1 ms
OS_PeriodTrigger1_Init(&TakeAccelerationData,100); //every 100ms
// when grading change 1000 to 4-digit number from edX
TExaS_Init(GRADER, 8864 ); // initialize the Lab 4 grader
// TExaS_Init(LOGICANALYZER, 1000); // initialize the Lab 4 logic analyzer
OS_Launch(BSP_Clock_GetFreq()/THREADFREQ); // doesn't return, interrupts enabled in here
return 0; // this never executes
}
/* ****************************************** */
/* End of Step 6 Section */
/* ****************************************** */
// Newton's method
// s is an integer
// sqrt(s) is an integer
uint32_t sqrt32(uint32_t s){
uint32_t t; // t*t will become s
int n; // loop counter
t = s/16+1; // initial guess
for(n = 16; n; --n){ // will finish
t = ((t*t+s)/t)/2;
}
return t;
}
//---------------- Step 1 ----------------
// Step 1 is to extend OS_AddThreads from Lab 4 to handle eight
// main threads, add a status field to the TCB, and rewrite
// the scheduler to handle priority.
// Task Type When to Run
// TaskA data producer periodically every 20 ms (sleep)
// TaskB data consumer after TaskA finishes
// TaskC data producer periodically every 50 ms (sleep)
// TaskD data consumer after TaskC finishes
// TaskE data producer periodically every 100 ms (sleep)
// TaskF data consumer after TaskE finishes
// TaskG low level task, runs a lot
// TaskH low level task, never runs
// Remember that you must have exactly one main() function, so
// to work on this step, you must rename all other main()
// functions in this file.
int32_t sAB,sCD,sEF;
int32_t CountA,CountB,CountC,CountD,CountE,CountF,CountG,CountH;
void TaskA(void){ // producer highest priority
CountA = 0;
while(1){
CountA++;
TExaS_Task0();
Profile_Toggle0();
OS_Signal(&sAB); // TaskB can proceed
OS_Sleep(20);
}
}
void TaskB(void){ // consumer
CountB = 0;
while(1){
CountB++;
OS_Wait(&sAB); // signaled by TaskA
TExaS_Task1();
Profile_Toggle1();
}
}
void TaskC(void){ // producer
CountC = 0;
while(1){
CountC++;
TExaS_Task2();
Profile_Toggle2();
OS_Signal(&sCD); // TaskD can proceed
OS_Sleep(50);
}
}
void TaskD(void){ // consumer
CountD = 0;
while(1){
CountD++;
OS_Wait(&sCD); // signaled by TaskC
TExaS_Task3();
Profile_Toggle3();
}
}
void TaskE(void){ // producer
CountE = 0;
while(1){
CountE++;
TExaS_Task4();
Profile_Toggle4();
OS_Signal(&sEF); // TaskF can proceed
OS_Sleep(100);
}
}
void TaskF(void){ // consumer
CountF = 0;
while(1){
CountF++;
OS_Wait(&sEF); // signaled by TaskE
TExaS_Task5();
Profile_Toggle5();
}
}
void TaskG(void){ // dummy
CountG = 0; // this should run a lot
while(1){
CountG++;
}
}
void TaskH(void){ // dummy
CountH = 0; // this one should never run
while(1){
CountH++;
}
}
int main_step1(void){
OS_Init();
Profile_Init(); // initialize the 7 hardware profiling pins
OS_InitSemaphore(&sAB, 0);
OS_InitSemaphore(&sCD, 0);
OS_InitSemaphore(&sEF, 0);
OS_AddThreads(&TaskA,0, &TaskB,1, &TaskC,2, &TaskD,3,
&TaskE,4, &TaskF,5, &TaskG,6, &TaskH,7);
TExaS_Init(LOGICANALYZER, 1000); // initialize the Lab 4 grader
// TExaS_Init(GRADESTEP1, 1000); // initialize the Lab 4 grader
OS_Launch(BSP_Clock_GetFreq()/1000);
return 0; // this never executes
}
/* ****************************************** */
/* End of Step 1 Section */
/* ****************************************** */
//---------------- Step 2 ----------------
// Step 2 id to extend the OS to implement OS_PeriodTrigger0_Init
// and OS_PeriodTrigger1_Init.
// Task Type When to Run
// TaskI data producer periodically every 20 ms(timer)
// TaskJ data consumer after TaskI finishes
// TaskK data producer periodically every 50 ms(timer)
// TaskL data consumer after TaskK finishes
// TaskM data producer periodically every 100 ms(sleep)
// TaskN data consumer after TaskL finishes
// TaskO low level task runs a lot
// TaskP low level (never runs)
// Remember that you must have exactly one main() function, so
// to work on this step, you must rename all other main()
// functions in this file.
int32_t sIJ,sKL,sMN;
int32_t sI,sK;
int32_t CountI,CountJ,CountK,CountL,CountM,CountN,CountO,CountP;
void TaskI(void){ // producer highest priority
CountI = 0;
while(1){
OS_Wait(&sI); // signaled by OS every 20ms
CountI++;
TExaS_Task0();
Profile_Toggle0();
OS_Signal(&sIJ); // TaskJ can proceed
}
}
void TaskJ(void){ // consumer
CountJ = 0;
while(1){
CountJ++;
OS_Wait(&sIJ); // signaled by TaskI
TExaS_Task1();
Profile_Toggle1();
}
}
void TaskK(void){ // producer
CountK = 0;
while(1){
OS_Wait(&sK); // signaled by OS every 50ms
CountK++;
TExaS_Task2();
Profile_Toggle2();
OS_Signal(&sKL); // TaskL can proceed
}
}
void TaskL(void){ // consumer
CountL = 0;
while(1){
CountL++;
OS_Wait(&sKL); // signaled by TaskL
TExaS_Task3();
Profile_Toggle3();
}
}
void TaskM(void){ // producer
CountM = 0;
while(1){
CountM++;
TExaS_Task4();
Profile_Toggle4();
OS_Signal(&sMN); // TaskN can proceed
OS_Sleep(100);
}
}
void TaskN(void){ // consumer
CountN = 0;
while(1){
CountN++;
OS_Wait(&sMN); // signaled by TaskM
TExaS_Task5();
Profile_Toggle5();
}
}
void TaskO(void){ // dummy
CountO = 0; // this should run a lot
while(1){
CountO++;
}
}
void TaskP(void){ // dummy
CountP = 0; // this one should never run
while(1){
CountP++;
}
}
int main_step2(void){
OS_Init();
Profile_Init(); // initialize the 7 hardware profiling pins
OS_InitSemaphore(&sI, 0);
OS_InitSemaphore(&sK, 0);
OS_InitSemaphore(&sIJ, 0);
OS_InitSemaphore(&sKL, 0);
OS_InitSemaphore(&sMN, 0);
OS_PeriodTrigger0_Init(&sI,20); // every 20 ms
OS_PeriodTrigger1_Init(&sK,50); // every 50ms
OS_AddThreads(&TaskI,0, &TaskJ,1, &TaskK,2, &TaskL,3,
&TaskM,4, &TaskN,5, &TaskO,6, &TaskP,7);
TExaS_Init(LOGICANALYZER, 1000); // initialize the Lab 4 grader
// TExaS_Init(GRADESTEP2, 1000); // initialize the Lab 4 grader
OS_Launch(BSP_Clock_GetFreq()/1000);
return 0; // this never executes
}
/* ****************************************** */
/* End of Step 2 Section */
/* ****************************************** */
//---------------- Step 3 ----------------
// Step 3 is to extend the OS to implement OS_EdgeTrigger_Init
// Task Type When to Run
// TaskI data producer periodically every 20 ms(timer)
// TaskJ data consumer after TaskI finishes
// TaskK data producer periodically every 50 ms(timer)
// TaskL data consumer after TaskK finishes
// TaskQ data producer runs on touch button1
// TaskR data consumer after TaskQ finishes
// TaskO low level task runs a lot
// TaskP low level (never runs)
// Remember that you must have exactly one main() function, so
// to work on this step, you must rename all other main()
// functions in this file.
int32_t sQR;
int32_t sQ;
int32_t CountQ,CountR;
void TaskQ(void){ // producer
CountQ = 0;
while(1){
OS_Wait(&sQ); // signaled in OS on button1 touch
CountQ++;
TExaS_Task4();
Profile_Toggle4();
OS_Signal(&sQR); // TaskQ can proceed
}
}
void TaskR(void){ // consumer
CountR = 0;
while(1){
OS_Wait(&sQR); // signaled by TaskQ
TExaS_Task5();
Profile_Toggle5();
CountR++;
OS_Sleep(10);
OS_EdgeTrigger_Restart();
}
}
int main_step3(void){
OS_Init();
Profile_Init(); // initialize the 7 hardware profiling pins
OS_InitSemaphore(&sI, 0);
OS_InitSemaphore(&sK, 0);
OS_InitSemaphore(&sQ, 0);
OS_InitSemaphore(&sIJ, 0);
OS_InitSemaphore(&sKL, 0);
OS_InitSemaphore(&sQR, 0);
OS_PeriodTrigger0_Init(&sI,50); // every 50 ms
OS_PeriodTrigger1_Init(&sK,200); // every 200ms
OS_EdgeTrigger_Init(&sQ,2);
OS_AddThreads(&TaskI,0, &TaskJ,1, &TaskK,2, &TaskL,3,
&TaskQ,4, &TaskR,5, &TaskO,6, &TaskP,7);
TExaS_Init(LOGICANALYZER, 1000); // initialize the Lab 4 grader
// TExaS_Init(GRADESTEP3, 1000); // initialize the Lab 4 grader
OS_Launch(BSP_Clock_GetFreq()/1000);
return 0; // this never executes
}
/* ****************************************** */
/* End of Step 3 Section */
/* ****************************************** */
Reference in New Issue View Git Blame Copy Permalink