133 lines
4.7 KiB
C
133 lines
4.7 KiB
C
// os.h
|
|
// Runs on LM4F120/TM4C123/MSP432
|
|
// A very simple real time operating system with minimal features.
|
|
// Daniel Valvano
|
|
// March 24, 2016
|
|
|
|
/* This example accompanies the book
|
|
"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
|
|
Programs 4.4 through 4.12, section 4.2
|
|
|
|
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/
|
|
*/
|
|
|
|
|
|
#ifndef __OS_H
|
|
#define __OS_H 1
|
|
|
|
|
|
// ******** OS_Init ************
|
|
// Initialize operating system, disable interrupts
|
|
// Initialize OS controlled I/O: periodic interrupt, bus clock as fast as possible
|
|
// Initialize OS global variables
|
|
// Inputs: none
|
|
// Outputs: none
|
|
void OS_Init(void);
|
|
|
|
//******** OS_AddThreads ***************
|
|
// Add six main threads to the scheduler
|
|
// Inputs: function pointers to six void/void main threads
|
|
// Outputs: 1 if successful, 0 if this thread can not be added
|
|
// This function will only be called once, after OS_Init and before OS_Launch
|
|
int OS_AddThreads(void(*thread0)(void),
|
|
void(*thread1)(void),
|
|
void(*thread2)(void),
|
|
void(*thread3)(void),
|
|
void(*thread4)(void),
|
|
void(*thread5)(void));
|
|
|
|
//******** OS_AddPeriodicEventThread ***************
|
|
// Add one background periodic event thread
|
|
// Typically this function receives the highest priority
|
|
// Inputs: pointer to a void/void event thread function
|
|
// period given in units of OS_Launch (Lab 3 this will be msec)
|
|
// Outputs: 1 if successful, 0 if this thread cannot be added
|
|
// It is assumed that the event threads will run to completion and return
|
|
// It is assumed the time to run these event threads is short compared to 1 msec
|
|
// These threads cannot spin, block, loop, sleep, or kill
|
|
// These threads can call OS_Signal
|
|
// In Lab 3 this will be called exactly twice
|
|
int OS_AddPeriodicEventThread(void(*thread)(void), uint32_t period);
|
|
|
|
//******** OS_Launch ***************
|
|
// Start the scheduler, enable interrupts
|
|
// Inputs: number of clock cycles for each time slice
|
|
// Outputs: none (does not return)
|
|
// Errors: theTimeSlice must be less than 16,777,216
|
|
void OS_Launch(uint32_t theTimeSlice);
|
|
|
|
//******** OS_Suspend ***************
|
|
// Called by main thread to cooperatively suspend operation
|
|
// Inputs: none
|
|
// Outputs: none
|
|
// Will be run again depending on sleep/block status
|
|
void OS_Suspend(void);
|
|
|
|
// ******** OS_Sleep ************
|
|
// place this thread into a dormant state
|
|
// input: number of msec to sleep
|
|
// output: none
|
|
// OS_Sleep(0) implements cooperative multitasking
|
|
void OS_Sleep(uint32_t sleepTime);
|
|
|
|
// ******** OS_InitSemaphore ************
|
|
// Initialize counting semaphore
|
|
// Inputs: pointer to a semaphore
|
|
// initial value of semaphore
|
|
// Outputs: none
|
|
void OS_InitSemaphore(int32_t *semaPt, int32_t value);
|
|
|
|
// ******** OS_Wait ************
|
|
// Decrement semaphore and block if less than zero
|
|
// Lab2 spinlock (does not suspend while spinning)
|
|
// Lab3 block if less than zero
|
|
// Inputs: pointer to a counting semaphore
|
|
// Outputs: none
|
|
void OS_Wait(int32_t *semaPt);
|
|
|
|
// ******** OS_Signal ************
|
|
// Increment semaphore
|
|
// Lab2 spinlock
|
|
// Lab3 wakeup blocked thread if appropriate
|
|
// Inputs: pointer to a counting semaphore
|
|
// Outputs: none
|
|
void OS_Signal(int32_t *semaPt);
|
|
|
|
// ******** OS_FIFO_Init ************
|
|
// Initialize FIFO.
|
|
// One event thread producer, one main thread consumer
|
|
// Inputs: none
|
|
// Outputs: none
|
|
void OS_FIFO_Init(void);
|
|
|
|
// ******** OS_FIFO_Put ************
|
|
// Put an entry in the FIFO.
|
|
// Exactly one event thread puts,
|
|
// do not block or spin if full
|
|
// Inputs: data to be stored
|
|
// Outputs: 0 if successful, -1 if the FIFO is full
|
|
int OS_FIFO_Put(uint32_t data);
|
|
|
|
// ******** OS_FIFO_Get ************
|
|
// Get an entry from the FIFO.
|
|
// Exactly one main thread get,
|
|
// do block if empty
|
|
// Inputs: none
|
|
// Outputs: data retrieved
|
|
uint32_t OS_FIFO_Get(void);
|
|
|
|
#endif
|