Ex Rtos CCSC

C:\Users\W.YACOUB\Desktop\RTOS -CCS-C PIC C\ex_rtos_demo_1_tasks.
c 27 Temmuz 2017 Perembe 14:24

/////////////////////////////////////////////////////////////////////////
//// ex_rtos_demo1_tasks.C ////
//// ////
//// This file demonstrates how to use the ral time operating ////
//// system to schedule tasks and how to use the rtos_run function ////
//// ////
/////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2003 Custom Computer Services ////
//// This source code may only be used by licensed users of the CCS ////
//// C compiler. This source code may only be distributed to other ////
//// licensed users of the CCS C compiler. No other use, ////
//// reproduction or distribution is permitted without written ////
//// permission. Derivative programs created using this software ////
//// in object code form are not restricted in any way. ////
/////////////////////////////////////////////////////////////////////////
#include <18F452.h>
#use delay(clock=20000000)
#use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7)
// this tells the compiler that the rtos functionality will be needed, that
// timer0 will be used as the timing device, and that the minor cycle for
// all tasks will be 100 miliseconds
#use rtos(timer=0,minor_cycle=100ms)
// each function that is to be an operating system task must have the #task
// preprocessor directive located above it.
// in this case, the task will run every second, its maximum time to run must
// be less than or equal to the minor cycle, and there is no need for a
// queue at this point, so no memory will be reserved.
#task(rate=1000ms,max=100ms)
// the function can be called anything that a standard function can be called
void The_first_rtos_task ( )
{
printf("1\n\r");
}
void The_second_rtos_task ( )
{
printf("\t2!\n\r");
}
void The_third_rtos_task ( )
{
printf("\t\t3\n\r");
}
// main is still the entry point for the program

void main ( )
{
// rtos_run begins the loop which will call the task functions above at the
// schedualed time
rtos_run ( );
}
/////////////////////////////////////////////////////////////////////////
//// ex_rtos_demo2_termination.C ////
//// ////
//// This file demonstrates how to use the real time operating ////
//// system rtos_terminate funciton. ////
//// ////
/////////////////////////////////////////////////////////////////////////
-1-
C:\Users\W.YACOUB\Desktop\RTOS -CCS-C PIC C\ex_rtos_demo_1_tasks.c 27 Temmuz 2017 Perembe 14:24
/////////////////////////////////////////////////////////////////////////
#include <18F452.h>
// a counter will be kept

int8 counter;
void The_first_rtos_task ( )
{
printf("1\n\r");
// if the counter has reached the desired value, the rtos will terminate
if(++counter==5)
rtos_terminate ( );
}
void The_second_rtos_task ( )
{
printf("\t2!\n\r");
}
void The_third_rtos_task ( )
{
}
void main ( )
{
// main is the best place to initialize resources the the rtos is dependent
// upon
counter = 0;
rtos_run ( );
// once the rtos_terminate function has been called, rtos_run will return
// program control back to main
printf("RTOS has been terminated\n\r");
}
/////////////////////////////////////////////////////////////////////////
//// ex_rtos_demo3_enable_disable.C ////
//// ////
//// system rtos_enable and rtos_disable functions ////
//// ////
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
#include <18F452.h>
int8 counter;
// now that task names will be passed as parameters, it is best

// to declare function prototypes so that there are no undefined
-2-
// identifier errors from the compiler
void The_first_rtos_task ( );
void The_second_rtos_task ( );
void The_third_rtos_task ( );
void The_first_rtos_task ( ) {
printf("1\n\r");
if(counter==3)
{
// to disable a task, simply pass the task name
// into the rtos_disable function
rtos_disable(The_third_rtos_task);
}
}
void The_second_rtos_task ( ) {
printf("\t2!\n\r");
if(++counter==10) {
counter=0;
// enabling tasks is similar to disabling them
rtos_enable(The_third_rtos_task);
}
}
void The_third_rtos_task ( ) {
}
void main ( ) {
counter = 0;
rtos_run ( );
}
/////////////////////////////////////////////////////////////////////////
//// ex_rtos_demo4_messages.C ////
//// ////
//// systems messaging functions. ////
//// ////
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
#include <18F452.h>
int8 count;
// each task will now be given a two byte queue

#task(rate=1000ms,max=100ms,queue=2)
// the function rtos_msg_poll will return the number of messages in the
-3-
// current tasks queue
// always make sure to check that their is a message or else the read
// function will hang
if(rtos_msg_poll ( )>0){
// the function rtos_msg_read, reads the first value in the queue
printf("messages recieved by task1 : %i\n\r",rtos_msg_read ( ));
// the funciton rtos_msg_send, sends the value given as the
// second parameter to the function given as the first
rtos_msg_send(The_second_rtos_task,count);
count++;
}
}
rtos_msg_send(The_first_rtos_task,count);
if(rtos_msg_poll ( )>0){
printf("messages recieved by task2 : %i\n\r",rtos_msg_read ( ));
count++;
}
}
void main ( ) {
count=0;
rtos_run();
}
/////////////////////////////////////////////////////////////////////////
//// ex_rtos_demo_5_yield.C ////
//// ////
//// rtos_yield function. ////
//// ////
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
#include <18F452.h>
int count=0;
// rtos_yield allows the user to break out of a task at a given point
// and return to the same ponit when the task comes back into context
while(TRUE){
count++;
rtos_msg_send(The_second_rtos_task,count);
rtos_yield ( );
}
}
if(rtos_msg_poll( ))
{
printf("count is : %i\n\r",rtos_msg_read ( ));
}
-4-
}
void main ( ) {
rtos_run();
}
/////////////////////////////////////////////////////////////////////////
//// ex_rtos_demo_6_semaphores.C ////
//// ////
//// rtos_signal and rtos_wait function to handle resources ////
//// ////
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
#include <18F452.h>
// a semaphore is simply a shared system resource

// in the case of this example, the semaphore will be the red LED
int8 sem;
#define RED PIN_B5
int i;
// this will decrement the semaphore variable to zero which signals
// that no more user may use the resource
rtos_wait(sem);
for(i=0;i<5;i++){
output_low(RED); delay_ms(20); output_high(RED);
rtos_yield ( );
}
// this will inrement the semaphore variable to zero which then signals
// that the resource is available for use
rtos_signal(sem);
}
int i;
rtos_wait(sem);
for(i=0;i<5;i++){
output_high(RED); delay_ms(20); output_low(RED);
rtos_yield ( );
}
rtos_signal(sem);
}
void main ( ) {
// sem is initialized to the number of users allowed by the resource
// in the case of the LED and most other resources that limit is one
sem=1;
rtos_run();
}
-5-
/////////////////////////////////////////////////////////////////////////
//// ex_rtos_demo_7_await.C ////
//// ////
//// systems rtos_await function ////
//// ////
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
#include <18F452.h>
#define RED PIN_B5

#define GREEN PIN_A5
int8 count;
// rtos_await simply waits for the given expression to be true
// if it is not true, it acts like an rtos_yield and passes the system
// to the next task
rtos_await(count==10);
output_low(GREEN); delay_ms(20); output_high(GREEN);
count=0;
}
count++;
}
void main ( ) {
count=0;
rtos_run();
}
/////////////////////////////////////////////////////////////////////////
//// ex_rtos_demo_8_Statistics.C ////
//// ////
//// systems statistics featuers ////
//// ////
/////////////////////////////////////////////////////////////////////////
-6-
/////////////////////////////////////////////////////////////////////////
#include <18F452.h>
#use rtos(timer=0,minor_cycle=100ms,statistics)
// This structure must be defined inorder to retrieve the statistical

// information
struct rtos_stats {
int32 task_total_ticks; // number of ticks the task has used
int16 task_min_ticks; // the minimum number of ticks used
int16 task_max_ticks; // the maximum number of ticks ueed
int16 hns_per_tick; // us = (ticks*hns_per_tic)/10
};
struct rtos_stats stats;
rtos_stats(The_second_rtos_task,&stats);
printf ( "\n\r" );
printf ( "task_total_ticks : %Lius\n\r" ,
(int32)(stats.task_total_ticks)*stats.hns_per_tick );
printf ( "task_min_ticks : %Lius\n\r" ,
(int32)(stats.task_min_ticks)*stats.hns_per_tick );
printf ( "task_max_ticks : %Lius\n\r" ,
(int32)(stats.task_max_ticks)*stats.hns_per_tick );
printf ("\n\r");
}
int i, count = 0;
while(TRUE) {
if(rtos_overrun(the_second_rtos_task)) {
printf("The Second Task has Overrun\n\r\n\r");
count=0;
}
else
count++;
for(i=0;i<count;i++)
delay_ms(50);
rtos_yield();
}
}
void main ( ) {
rtos_run ( );
}
/////////////////////////////////////////////////////////////////////////
//// ex_rtos_demo_9_basic_kernal.C ////
//// ////
//// This file demonstrates how to create a basic command line ////
//// using the serial port without having to stop the RTOS ////
//// operation. This can also be considered a semi kernal for ////
//// the RTOS. ////
//// ////
/////////////////////////////////////////////////////////////////////////
-7-
/////////////////////////////////////////////////////////////////////////
#include <18F452.h>
#define RED PIN_B5

#define GREEN PIN_A5
#include <string.h>
// this character array will be used to take input from the prompt
char input [ 30 ];
// this will hold the current position in the array
int index;
// this will signal to the kernal that input is ready to be processed
int1 input_ready;
// different commands
char en1 [ ] = "enable1";
char en2 [ ] = "enable2";
char dis1 [ ] = "disable1";
char dis2 [ ] = "disable2";
void The_kernal ( );
// serial interupt
#int_rda
void serial_interrupt ( )
{
if(index<29) {
input [ index ] = getc ( ); // get the value in the serial recieve reg
putc ( input [ index ] ); // display it on the screen
if(input[index]==0x0d){ // if the input was enter
putc('\n');
input [ index ] = '\0'; // add the null character
input_ready=TRUE; // set the input read variable to true
index=0; // and reset the index
}
else if (input[index]==0x08){
if ( index > 1 ) {
putc(' ');
putc(0x08);
index-=2;
}
}
index++;
}
else {
putc ( '\n' );
putc ( '\r' );
input [ index ] = '\0';
index = 0;
input_ready = TRUE;
}
}
-8-
}
output_low(GREEN); delay_ms(20); output_high(GREEN);
}
void The_kernal ( ) {
while ( TRUE ) {
printf ( "INPUT:> " );
while(!input_ready)
rtos_yield ( );
printf ( "%S\n\r%S\n\r", input , en1 );
if ( !strcmp( input , en1 ) )

rtos_enable ( The_first_rtos_task );
else if ( !strcmp( input , en2 ) )
rtos_enable ( The_second_rtos_task );
else if ( !strcmp( input , dis1 ) )
rtos_disable ( The_first_rtos_task );
else if ( !strcmp ( input , dis2 ) )
rtos_disable ( The_second_rtos_task );
else
printf ( "Error: unknown command\n\r" );
input_ready=FALSE;
index=0;
}
}
void main ( ) {
// initialize input variables
index=0;
input_ready=FALSE;
// initialize interrupts
enable_interrupts(int_rda);
enable_interrupts(global);
rtos_run();
}
-9-

Ex Rtos CCSC

Uploaded by

Copyright:

Available Formats

Ex Rtos CCSC

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Ex Rtos CCSC

Uploaded by

Copyright:

Available Formats

C:\Users\W.YACOUB\Desktop\RTOS -CCS-C PIC C\ex_rtos_demo_1_tasks.

c 27 Temmuz 2017 Perembe 14:24

// main is still the entry point for the program

// a counter will be kept

// now that task names will be passed as parameters, it is best

// each task will now be given a two byte queue

// a semaphore is simply a shared system resource

#define RED PIN_B5

// This structure must be defined inorder to retrieve the statistical

#define RED PIN_B5

printf ( "%S\n\r%S\n\r", input , en1 );

if ( !strcmp( input , en1 ) )

You might also like