PIC24 en:osa:ref:appendix

OSA : example for PIC10

2008-12-19T13:03:51+03:00

OSA : example for PIC10

Project

This example demonstrates using RTOS OSA under 12-bit microcontroller. Unrar file 3leds.rar into folder "C:\TEST\3LEDS". This programm written under PIC10F222 (you can rebuild it under F202 or 206).

This program forms PWM signals to drive 7-color LED. It slowly changes width of pulses for every LED. There are four speeds of color changing.

Scheme

Here is scheme of device. Controller drives three n-p-n transistors. Every transistor controls LED. Notice that buttons and transistors are connected to same pins.

Button S1 makes red LED active.
Button S2 makes green LED active.
Button S3 makes blue LED active.
Button S4 canges work speed.

Note. Values of resistors R11, R12 and R13 are selected according to used LEDs.

Work description

Program contains three tasks:

Task_Leds - forming pulses to drive LEDs.
Task_Work - forming values of length for each LED.
Task_Buttons - sans buttons.

Task_Leds

This task waits for TMR0 overflow. When overflow occures, all active LEDs are switchs on. Then task waits for TMR0 becames greater than intensity value of each LED and switch corresponding LED off. Program has three variables holding intensity values for each LED. When all LEDs becames switched off, other tasks can get control.

Two other tasks (Task_Work and Task_Button) waits for setting bits bRunTaskWork and bRunTaskButtons respectively. This bits are set by Task_Leds after all LEDs switchs off.

Task_Work

When task gets control, it checks is it time to change intenesity variables. There is a variable Speed. It's value changes every time when task get control. Speed of increasing (speed of intensity changing) are set by two MSB bits of variable Speed (Speed.cSpeed). When 5 lowes bits of variable Speed (Speed.cPrs) overflows, bit Speed.bTimeout becames set and function ChangeIntensity() called. This functions changes intensity values of all LEDs (variables Red, Green and Blue).

Function ChangeIntensity() is not a part of RTOS, thus you can to modify it as you wish to make your own intensity changing style.

Task_Button

This task gets control one time in every 16 milliseconds, when bit bRunTaskButtons becames set. First all pins set as inputs. Then program checks state of pins: if any pin eq. to "0", then corresponding button is pressed. Buttons SW1, SW2 and SW3 set intensity of red, green or blue at maximum, respectively (two other LEDs will be switched off). Button SW4 increases value of Speed.cSpeed by 1. After all buttons checked, task waits for button release. Before exit from task, all pins set as output.

Photos

Configuration file OSAcfg.h

2010-09-24T17:50:52+03:00

Configuration file OSAcfg.h

The file OSAcfg.h must be created for each project. (It is recommended that you place this file in the project folder.) This file is automatically included by the file osa.h. It contains operating system setup data.

In the simplest case this file can be empty.

To simplify creating/modifying OSAcfg.h, you can use the program OSAcfg_Tool

System constants

Constant name	Description
OS_ENABLE_ALL	Includes all services and all system types except user timers (see below)
OS_ENABLE_CSEM	Enables counting semaphores
OS_ENABLE_QUEUE	Enables queues of pointers to messages
OS_ENABLE_SQUEUE	Enables queues of simple messages
OS_QUEUE_SQUEUE_IDENTICAL	This constant can be defined to reduce memory usage when sizes of OST_MSG and OST_SMSG are identical. This can be useful for PIC10, PIC12 and PIC16
OS_ENABLE_CRITICAL_SECTION	Includes codes for using critical sections

Priority control constants

Имя константы	Допустимые значения	Описание
OS_PRIORITY_LEVEL	OS_PRIORITY_NORMAL	(defaul) Normal priority mode with checking tasks in order of creation
	OS_PRIORITY_DISABLED	Disables task priorities. This reduces RAM and ROM usage
	OS_PRIORITY_EXTENDED	In this mode all task will get the control according to their priority
OS_DISABLE_PRIORITY	old style consant	Same as OS_PRIORITY_DISABLE

Timers control constants

Constant name	Description
OS_ENABLE_TTIMERS	Enables task timers and functions to use them
OS_ENABLE_DTIMERS	Enables functions to use dynamic timers
OS_ENABLE_QTIMERS	Enables functions to use queue of timers
OS_STIMERS	Number of static timers. Enables array of static timers
OS_STIMERS_ENABLE_ALLOCATION	Enables functions to assign static timers at run time
OS_STIMERS_OPTIMIZATION_SIZE	Optimizes size of code for processing static timers in OS_Timer (by default it is optimized for speed)
OS_TTIMERS_OPTIMIZATION_SIZE	Optimizes size of code for processing task timers in OS_Timer (by default it is optimized for speed)

Services in interrupts

Constant name	Description
OS_ENABLE_INT_CSEM	Allows the use of binary semaphore services within interrupts
OS_ENABLE_INT_CSEM	Allows the use of counting semaphore services within interrupts
OS_ENABLE_INT_FLAGS	Allows the use of flags within interrupts
OS_ENABLE_INT_MSG	Allows the use of pointer to message services within interrupts
OS_ENABLE_INT_SMSG	Allows the use of simple message services within interrupts
OS_ENABLE_INT_QUEUE	Allows the use of queue services within interrupts
OS_ENABLE_INT_ALL	Enables all constants above

Data contents

Constant name	Description	RAM usage
OS_TASKS	Maximum number of active tasks	2 bytes per task for PIC12 and PIC10 3 bytes per task for PIC16 4 bytes per task for PIC18 20 bytes per task for PIC24 and dsPIC 5 bytes per task for AVR The number of bytes per task will be increased when OS_ENABLE_TTIMERS is defined.
OS_BSEMS	Number of binary semaphores	One byte per eight semaphores (for 8-bit controllers); two bytes per 16 semaphores (for 16-bit controllers)
OS_TIMERS8 (old style)*	Number of 8-bit static timers	1 byte per timer
OS_TIMERS16 (old style)*	Number of 16-bit static timers	2 bytes per timer
OS_TIMERS24 (old style)*	Number of 24-bit static timers	2 bytes per timer
OS_TIMERS32 (old style)*	Number of 32-bit static timers	4 bytes per timer

* - this type of timer is not recommended for use

Data types

Constant name	Default value	Description
OS_TIMER_SIZE	2	Number of bytes per timer (can be 1, 2 or 4)
OS_STIMER_SIZE	OS_TIMER_SIZE	Number of bytes per static timer (can be 1, 2 or 4)
OS_TTIMER_SIZE	OS_TIMER_SIZE	Number of bytes per task timer (can be 1, 2 or 4)
OS_DTIMER_SIZE	OS_TIMER_SIZE	Number of bytes per dynamic timer (can be 1, 2 or 4)
OS_QTIMER_SIZE	OS_TIMER_SIZE	Number of bytes per timer in queue of timers (can be 1, 2 or 4)
OS_CSEM_SIZE	1	Number of bytes per counting semaphore (can be 1, 2 or 4)
OS_SMSG_TYPE*	unsigned char	Type of simple message
OS_MSG_TYPE*	void *	Type of message

* - these types can't be redefined for PIC12.

Data allocation for PIC10, PIC12, PIC16 and PIC18

Allowed OS_BANK_xxx values:

for PIC10, PIC12, PIC16: 0, 1, 2 or 3 - to select bank0, bank1, bank2, bank3.
for PIC18: 0 - "access RAM", not 0 - other RAM.
for PIC24: 0 - "near", not 0 - any RAM
for STM8: 0 - "near", not 0 - any RAM

Constant name	Default value	Description
OS_BANK_OS(1)	0	To allocate all system varables except those individually allocated (see below)
OS_BANK_BSEMS(1)	OS_BANK_OS	To allocate binary semaphores
OS_BANK_TASKS(1)	OS_BANK_OS	To allocate task descriptors
OS_BANK_STIMERS(1)	OS_BANK_TIMERS	To allocate new style static timers
OS_ADDRESS_TASK	-	For mikroC PRO for PIC16: Used to allocate task descriptors at specified address (e.g. 0x120, or 0x190)
OS_BANK_TIMERS (old style)(1),(2)	OS_BANK_OS	To allocate all static timers (old style and new style)
OS_BANK_TIMERS8 (old style)(1),(2)	OS_BANK_TIMERS	To allocate 8-bit timers
OS_BANK_TIMERS16 (old style)(1),(2)	OS_BANK_TIMERS	To allocate 16-bit timers
OS_BANK_TIMERS24 (old style)(1),(2)	OS_BANK_TIMERS	To allocate 24-bit timers
OS_BANK_TIMERS32 (old style)(1),(2)	OS_BANK_TIMERS	To allocate 32-bit timers
OS_BANK_TIMEOUTS (old style)(1),(2)	OS_BANK_TIMERS	To allocate timeout bits for old style static timers

(1) - has no effect when using CCS, mikroC PRO, or AVR
(2) - this type of timer is not recommended for use

OSA : Error list

2009-09-02T12:54:27+03:00

OSA : Error list

#1 : Unknown compiler!

OSA can be built only under comilers:

HI-TECH PICC STD
HI-TECH PICC18 STD
Microchip C18
Microchip C30
CCS PICC
microC PRO for PIC

Other compilers are not supported yet.

#2 : Constants OS_xxx_BANK are not allowed now (use OS_BANK_xxx instead)

This means that you defined old-style constant for allocation OSA variables in file OSAcfg.h. New-style names are prefixed by "OS_BANK_". See configuration.

#3 .. #12 : Incorrect OS_BANK_xxx value (should be 0, 1, 2 or 3)

You define one or several OS_BANK_xxx constants in OSAcfg.h with incorrect value. Allowed values 0, 1, 2 and 3 only.

#13 : OST_TIMER is not supported! Use OS_TIMER_SIZE instead

This means that you defined old-style constant. OST_TIMER is not supported now. In old OSA versions this constant could be used to redefine type of timers, where type was given directly (e.g. char, unsigned long). Now you can redefine timer's type by setting it's size. For example:

#define OS_TIMER_SIZE    4      // Timer's type will be unsigned long

#14 .. #15 : Can't redefine name OST_xxx in 'OSAcfg.h'. Use OS_xxx_TYPE instead.

Since 90200 types of OST_MSG and OST_SMSG can be redefined only trougth new constants OS_MSG_TYPE and OS_SMSG_TYPE. The reason is below:

OST_MSG was defined as:

#define OST_MSG    void *

When you define several variables of this type:

OST_MSG msg1, msg2, msg3;

compiler makes substitute:

void * msg1, msg2, msg3;

As you see, only msg1 will be pointer to void, while msg2 and msg3 will be just void.

Situation could be corrected by relacing type definition by:

typedef void * OST_MSG;

But in this case user can't to redefine this type. At this reason type of MSG is redefined in OSAcfg.h not directly, but througth constant:

#define OS_MSG_TYPE     int *

and then OST_MSG defined in OSA.h:

typedef OS_MSG_TYPE   OST_MSG;

#16 : Incorrect OS_CSEM_SIZE value (m.b. only 1, 2 or 4)! (see OSAcfg.h)

You entered incorrect size for variables of counting semaphore type. Allowed values:

1 - for unsigned char
2 - for unsigned int
4 - for unsigned long

#17 .. #20 : Bad OS_xxx size (must be 1, 2 or 4)

You entered incorrect size for timer variables. Allowed values:

1 - for unsigned char
2 - for unsigned int
4 - for unsigned long

OSA : Appendix

2009-05-26T20:59:55+03:00

OSA : Appendix

2010-10-07T13:58:22+03:00

OSA : (UNDER_CONSTRUCTION)

2010-10-07T13:58:23+03:00

OSA usage example: QUARTET

2008-12-20T01:48:42+03:00

OSA usage example: QUARTET

Project

Program quartet synthesizes melody by given notes (it plays part of J.S.Bach N1067). Unpack file quartet4.rar into foulder "C:\TEST\QUARTET". This project is written for PIC16F628A.

This program generates 4-channel melody, using 8-bit PWM at 78 KHz. Music is played with four samples: bass, violin and two guitars (of course, my samples are very different from reality). Each channel can be switched ON or OFF by switches.

Here is MP3 (download), recorded from device's output.

Scheme

The scheme of device is below. 8-bit digital signal from PWM through RC-filter R22-C3 and volume regulator R24 goes to headphones.

Switch SW1 switchs bass ON/OFF.
Switch SW2 switchs voilin ON/OFF.
Switch SW3 switchs first guitar ON/OFF.
Switch SW4 switchs second guitar ON/OFF.

Description

Program consists of four files:

quartet_main.c - main program: tasks and notes working functions.
music.c - contains frequencies table and notelists for each channel.
sinus.c - contains three arrays with sinus data for each instrument (bass, violin, guitar).
interrupt.c - interrupt function. It contains code of synthesizer (called every 100 us).

quartet_main.c described below.

Program consists of 5 tasks. Four of them are "musicants", and fifth is "conductor" that sinchronize first four tasks.

Sound control

To control sound type TSound defined in quartet_main.c. Variables of this type contains all sound information for "musicant":

current note;
notelist;
is "musicant" in pause;
is "musicant" repeats fragment;

for "conductor":

when it must give next command to "musicant";
did "musicant" stop playing (reach end of nitelist)

for synthesiser:

current sound frequency;
time of playing current note (to form envelope for signal).

"Musicants"

There are four "musicants" in program: Task_BASS, Task_VIOLIN, Task_GUITAR1, Task_GUITAR2. All time "musicants" wait for command from "conductor" (binary semaphore). When getting command, "musicant" reads next note from his notelist, plays it (task forms data for synthesizer).

Note produced in NoteWork() function, witch gets variable of sound control TSound in parameters. Using data of this variable function reads next note (or instruction: repeat, pause, ect.) and makes several operations to form parameters to synthesizer, in addition this function forms duration varianble. This variable decreases on every command from "conductor".

When "musicant" reaches the end of notelist, he informs "conductor" about it (task clears corresponding bit in flag variable flags_Playing). After that "musicant" begins to wait for "conductor's" command to restart music (binary semaphore BS_START). When "musicant" gets it, he goes to begin of notelist (sound control variable re-initializates) and sends "conductor's" command to next"musicant".

"Conductor"

Taks_CONDUCTOR ("conductor") has priority lower then "musicants". "Conductor" counts ticks like metronome and looks to ensure that all "musicants" get commands at correct time. Task_CONDUCTOR gets control every 150 ms. On every execution it checks for music state. When "conductor" determines that all "musicants" stopped to play (all bits in flag variable flag_Playing are cleared), he sends command to "musicants" to restart musig from the begin.

Two words about synthesizer

Sinthesizer is placed into interrupt routine if file interrupt.c. Interrupt takes all sound control variables and forms digital signal. To make this work it has:

three tables of sound patterns for each sample: bass[], violin[], guitar[] (see sinus.c). This arrays contains one sinus period per each sample.
envelope formulas (see comments FORMING_SIGNAL_xxx): attack, release, ect.
macro for fast multiplication (char) = high( (signed char)*(unsigned char) ), to multiply sinus value by enveloping amplitude.

All four current values of sound are summed up, and then result is divided by four. After that result copies into m_cDAC variable. On next start of interrupt routine this variable will be copied into PWM buffer register CCPR1L (two least significant bits are copied into bits CCP1X and CCP1Y of CCP1CON register).

About notelists

Few information about notelist will help you to create your music.

File music.c contains definitions for notes: C0, C0_, D0, D0_, ect. There are definitons for 57 frequencies (four with half octaves). When we create note in notelist (arrays notelist_xxx) using macro play(), we can to set note only with 5 bits (32 notes). Therefore there is possibleness to set base octave (macro setbase()). Note duration is selected using only 2 bits, so only four durations can be set. If you need note with longest duration, you can use either macro pause() (pauses sound by several ticks) or macro playmore() (continue playing sound for several ticks).

Notelist must be ended with macro stop() to avoid reading unitializes memory cells.

OSA : Memory usage

2010-06-14T11:53:29+03:00

OSA : Memory usage

These tables allow you to predict average ROM and RAM usage so that you can choose an appropriate microcontroller for your project.

The test program OSA\TEST\TEST_SIZE was used.

Compiler	min	normal	full
Hi-tech PICC
PIC12 (PIC10)	153 / 11	250 / 14	363 / 14
PIC16 (PIC12)	152 / 8	258 / 11	396 / 13
PIC18	336 / 7	548 / 10	982 / 16
Hi-tech PICC PRO
PIC16 (enhanced)	169 / 6	291 / 10	385 / 10
Microchip C
PIC18	598 / 7	862 / 10	1214 / 16
PIC24 (dsPIC)	846 / 10	1065 / 16	1305 / 16
MikroC
PIC16	180 / 14	307 / 17	474 / 17
PIC18	426 / 11	746 / 16	1136 / 17
CCS PICC
PIC16	254 / ..	399 / ..	573 / ..
PIC18	436 / ..	696 / ..	1046 / ..
WinAVR
AVR	602 / 8	1030 / 13	1348 / 15
IAR
AVR	550 / 8	958 / 13	1108 / 15

Test modes:

min (minimal services set)
- priorities are OFF
- allowed: binary semaphores, flags, messages
normal (most usual services set)
- priorities are ON
- task timers are enabled
- allowed: binary semaphores, flags, messages
- waiting with exit on timeout services are enabled
full (full services set, except user timers)
- priorities are ON
- task timers are enabled
- allowed: binary semaphores, counting semaphores, flags, messages, queues
- waiting with exit on timeout services are enabled
- critical sections enabled

(All modes support services for switching context, waiting for events, controlling tasks, enabling/disabling interrupts)

Notes:

size of ROM shown in machine words for PIC10, PIC12 and PIC16 and in bytes for other;
for MCC18 initialization code is included;
for MCC30 initialization code is included;
all test were compiled with maximum optimization;
task size is not included:
- 2 bytes (+timer) for PICC12
- 3 bytes (+timer) for PICC16
- 3 bytes (+timer) for PICC16F1xxx
- 4 bytes (+timer) for PICC18
- 4 bytes (+timer) for MCC18
- 20 bytes (+timer) for MCC30
- 10 bytes (+timer) for WinAVR
- 5 bytes (+timer) for IAR for AVR
memory usage can be reduced by disabling priority and by using one byte timers (see OSAcfg.h).

OSA : Speed characteristics

2011-01-22T15:03:01+03:00

OSA : Speed characteristics

Here is an information to determine the time required by OSA to switch from one task to another for different chips under different compilers and priority modes.

How to use this table? First you have to find your compiler and your priority mode in table and get the value. Then this value should be multiplied by nomber of active tasks and then multiplied by time per instruction cycle.

Compiler	PRIORITY_DISABLED	PRIORITY_NORMAL	PRIORITY_EXTENDED
PIC10 (PIC12)
Hi-tech PICC	54*N	84*N	-
PIC16 (PIC12)
HT-PICC STD	49*N	80*N	123*N
HT-PICC PRO (PIC1xF1xxx)	39*N	64*N	80*N
microC PRO	74*N	119*N	224*N
CCS PICC	62*N	107*N	167*N
PIC18
HT-PICC18 STD	45*N	70*N	85*N
MPLAB C18	55*N	96*N	117*N
microC PRO	73*N	99*N	187*N
CCS PICC	49*N	88*N	101*N
PIC24 (dsPIC)
MPLAB C30	60*N	87*N	113*N
AVR
WinAVR	108*N	172*N	190*N
IAR	100*N	148*N	177*N
STM8
Cosmic	35*N	58*N	71*N
IAR	93*N	118*N	238*N
Raisonance	61*N	80*N	120*N

N - namber of active tasks

An example 1 of determination Source data:

Microcontroller PIC16F628
Compiler HT PICC STD
4 tasks (N = 4)
Extended priority level (OS_PRIORITY_EXTENDED)
Frequency 20 MHz (time of instruction cycle = 200 ns)

The needed value for our compiler, priority mode and compiler is 123*N. The average time of switching between tasks (time from OS_Yield() execution in one task to other task get the control) is:

t = 123 * 4 * 200ns = 492 * 200ns = 98.4 us

An example 2 of determination Source data:

Microcontroller STM8S105C6
Compiler Cosmic
8 tasks (N = 8)
Normal priority level (OS_PRIORITY_NORMAL)
Frequency 16 MHz (time of instruction cycle = 62.5 ns)

The needed value for our compiler, priority mode and compiler is 58*N. The average time of switching between tasks is:

t = 58 * 8 * 62.5ns = 464 * 62.5ns = 29 us

2008-10-31T00:43:43+03:00

task_stack_size: размер стека задачи в машинных словах (количество элементов в массиве стека)
param: параметр передаваемый в функцию задачи

H2

qwer qwer qwer

H3

void main (void)
{
    OS_Init();
    OS_CreateTask(0, Task1);
    for (;;) OS_Sched();
}

H4

aaa
bbb
ccc
- caa
- cbb
ddd

aaa
bbb
ccc
- caa
- cbb
ddd

a	b	c
aaa	bbb

A	B	C
aa	bb

A	B	C
aa	bb