Het uC/OS-II
This presentation is the property of its rightful owner.
Sponsored Links
1 / 59

Het uC/OS-II RTOS PowerPoint PPT Presentation


  • 162 Views
  • Uploaded on
  • Presentation posted in: General

Het uC/OS-II RTOS. Embedded systeem. Programma voorgrond/achtergrond systeem. Operating systeem nodig ?.

Download Presentation

Het uC/OS-II RTOS

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Het uc os ii rtos

Het uC/OS-II

RTOS


Het uc os ii rtos

Embedded systeem


Het uc os ii rtos

Programma voorgrond/achtergrond systeem


Het uc os ii rtos

Operating systeem nodig ?

De meeste toepassingen (in het bijzonder 8-bit systemen) bestaan uit slechts een programma, en daarom geen behoefte aan een "traditionele" besturingssysteem. ROM monitoren vervangen door het besturingssysteem.

Meer complexe systemen van vandaag vereisen meer complexe besturing en daarom behoefte aan een besturingssysteem van een soort.


Het uc os ii rtos

Type operating systemen

  • monolithische kernel

Desktop (windows,linux,…)

  • microkernel

QNX, minix, symbian OS

  • kleine real-time OS

Kernel in de vorm van een API.


Het uc os ii rtos

Het microCOS-II operating systeem


Het uc os ii rtos

Plaats van het operating systeem


Het uc os ii rtos

MicroC/OS-II

Kenmerken:

  • Multitasking (max. 64 taken)

  • Prioriteit

  • Preemptive

  • Deterministisch

  • portable

  • ROMable, scalable


Het uc os ii rtos

Tekortkomingen:

  • Geen priority inherintance

  • Elke taak heeft een unieke prioriteit.

MicroC/OS-II

Kenmerken:

  • Services : Mailboxes, Queues, Semaphores, fixedsizedmemory partitions, time-related functions

  • Interrupt Management: geneste Interrupt

  • Robuust en betrouwbaar


Het uc os ii rtos

MicroC/OS-II architectuur


Het uc os ii rtos

Taken:

  • Kan 64 taken managen (2 taken voor eigen gebruik)

  • De 4 hoogste en de 4 laagste prioriteiten zijn voor eigen gebruik

  • 56 applicatie taken

  • Hoe lager de waarde van de prioriteit hoe hoger de prioriteit.

  • De taak prioriteit nummer dient ook als de taak identifier


Het uc os ii rtos

Non –preemptivetaak scheduling


Het uc os ii rtos

PreemptiveTaak scheduling


Het uc os ii rtos

Voorbeeld taken.

voidtaak1(void* pdata)

{

while(1)

print a;

}

int main()

{

initialiseer;

creëer taak1;

creëer taak2;

start scheduling;

}

voidtaak2(void* pdata)

{

while(1)

print b;

}


Het uc os ii rtos

Task context switch


Het uc os ii rtos

Task context switch


Het uc os ii rtos

Datastructuur van de ready-list


Het uc os ii rtos

Datastructuur van de ready-list

Voordeel:

  • store/load in constante tijd.

Nadeel:

  • Taken kunnen niet dezelfde prioriteit hebben’

  • Aantal taken is gelimiteerd.


Het uc os ii rtos

Datastructuur na de initialisatie

2 taken(Stat en Idle) die door het OS gebruikt worden


Het uc os ii rtos

Suspended van een taak

Link blijft

bestaan

Bit wordt

gecleared


Het uc os ii rtos

Running

(2)Zoek hoogste

prioriteit in groep

(1)Zoek hoogste

prioriteit groep

(3)Zet state op

running


Het uc os ii rtos

Beheer van de taken

  • Wanneer een taak wordt gemaakt, wordt er een Task Control Block aangewezen, OS_TCB

  • OS_TCB is een data structuur die wordt gebruikt door UC/OS-II de state van een taak bij te behouden wanneer het preempted wordt

  • Alle OS_TCB staan in het RAM

  • Een OS_TCB wordt geïnitialiseerd wanneer een taak wordt gemaakt


Het uc os ii rtos

Task context switch


Het uc os ii rtos

Task context switch

Elke taak heeft een stack waar de bijbehorende informatie wordt opgeslagen.

Doel contex switch

Om ervoor te zorgen dat de taak die gedwongen wordt de CPU op te geven, verder kan gaan zonder verlies van alle vitale informatie of gegevens


Het uc os ii rtos

Task context switch


Het uc os ii rtos

Task context switch


Het uc os ii rtos

Task context switchvoor een taak wisseling

stacktaak 2

Stack pointer

stacktaak 1

CPU registers bij het switchen

Lokale variabele

taak 1

Taak 2 code adres bij het switchen

Taak 2 lokale variabele bij het switchen

return adres

return adres

Taak 1 is running

Taak 2 wordt runningis ready


Het uc os ii rtos

Task context switchtijdens een taak wisseling

CPU registers bij het switchen

Taak 2 code adres bij het switchen

Taak 2 lokale variabele bij het switchen

Lokale variabele

Return adres

Return adres

Taak 1 stack

Taak 2 stack

Huidige

program

counter

Huidige

CPU

registers

Taak 1 TCB

Taak 1 TCB

Stack pointer

Stack pointer

huidige stackpointer


Het uc os ii rtos

Task context switchna een taak wisseling

Stack pointer

CPU registers bij het switchen

Loacale variabele

taak 2

Taak 1 code adres bij het switchen

Taak 1 lokale variabele bij het switchen

Return adres

return adres

Taak 1 wordt running

is ready

Taak 2 running


Het uc os ii rtos

Task context switch

  • Interrupt (hardware of software) van de context switch

  • Push return adres

  • Push FLAGS register

  • ISR (context switch routine)

    • Push alle registers

    • Sla SP op in TCB (task control block)

    • Select de ready taak met de hoogste prioriteit (Scheduler)

    • Restore de SP van de TCB van de geselecteerde taak

    • Pop alle registers

    • iret (return interrupt, pop FLAGS en return adres)

  • Switch to new task


Het uc os ii rtos

Memory management


Het uc os ii rtos

Het aanvragen van geheugen.

  • Dynamic memory allocation kan verkregen worden door gebruik te maken van malloc() en de free() functies

  • Gebruik van malloc() en de free() in een embedded real-time system is gevaarlijk

    • Eventueel kan fragmentation plaatsvinden

    • Execution time van malloc() en free() zijn nondeterministic.

  • Het uC/OS-II kent geheugen blokken met een vaste grootte toe.

    • Geheugenblokken zijn afkomstig van een partitie die in het geheugen gedeclareerd is.

    • Het alloceren en dealloceren van geheugen gebeurt hierdoor in een continue tijd.

    • Geheugenblokken kunnen verschillende grootte hebben.


Het uc os ii rtos

Het aanvragen van geheugen.

geheugenblokken

multiple memory partitions

memory partition


Het uc os ii rtos

Het aanvragen van geheugen.

Memory Control Block

  • Het uC/OS-II houdt het geheugen bij d.m.v een Memory Control Block (MCB)

  • Elke partitie heeft zijn eigen MCB.

  • Initialisatie wordt gedaan door de functie OS_MemInit() die de gelinkte lijst creeerd.


Het uc os ii rtos

Memory control block.

typedef struct {

void *OSMemAddr; //A

void *OSMemFreeList; //B

INT32U OSMemBlkSize; //C

INT32U OSMemNBlks; //D

INT32U OSMemNFree; //E

} OS_MEM;

Is een pointer naar het begin van de geheugenpartitie.

Is een pointer naar het eerst volgende vrije geheugen ruimte.

Is de grootte van elke geheugenblok in de partitie.

Is het totaal aan geheugenblokken per partitie.

Hoeveel geheugenblokken beschikbaar zijn.


Het uc os ii rtos

Creëren van een partitie OSMemCreate()

OS_MEM *CommTxBuf;

INT8U CommTxPart[100][32];

void main (void)

{

INT8U err;

OSInit();

.

.

CommTxBuf = OSMemCreate(CommTxPart, 100, 32, &err);

.

.

OSStart();

}

  • Vier argumenten zijn vereist

    • Begin addres van de memory partition.

    • Het aantal blocken dat gealloceerd wordt van de partition.

    • De grootte (in bytes) van elk block.

    • Een pointer naar de variabele die de error code bevat.


Het uc os ii rtos

Data structuur na een geslaagde OSMemCreate()


Het uc os ii rtos

Aanmaken van taken

void (*task)(void *pd),

void *pdata,

INT8U OSTaskCreate ( )

{

}

, INT8U prio

OS_STK *ptos

void (*task)(void *pd) pointer naar de taak

void *pdata pointer naar de argumenten van de taak

OS_STK *ptos =>pointer naar de top van de stack

int8U prio => prioriteit


Het uc os ii rtos

Bewerken van taken

OSTaskDel()

OSTaskDelReq()

OSTaskSuspend()

OSTaskResume()

Quick reference:

http://sigpromu.org/brett/elec3730/quickref.html


Het uc os ii rtos

Interproces communicatiemessage box


Het uc os ii rtos

Interproces communicatiemessage queue


Het uc os ii rtos

Message Queue Management


Het uc os ii rtos

Een Message Queue als een circulare buffer van pointers


Het uc os ii rtos

C code

Het creeeren van een message queue.

OS_EVENT *OSQCreate(void **start, INT8U size);

#define RIJGROOTTE 5

OS_EVENT *postrijev;

void* postrij[RIJGROOTTE];

postrijev=OSQCreate(postrij,RIJGROOTTE);


Het uc os ii rtos

C code

Het schrijven in een message queue.

INT8U OSQPost(OS_EVENT *pevent, void *msg);

INT8U rt;

OS_EVENT *postrijev;

typedef struct {

char c;

int i;

}dubbel;

dubbel boodschap={1,’i’}

rt=OSQPost(postrijev,&boodschap);

if(rt==OS_NO_ERR)


Het uc os ii rtos

C code

Het lezen uit een message queue.

void *OSQPend(OS_EVENT *pevent, INT16U timeout, INT8U *err);

OS_EVENT *postrijev;

typedef struct {

char c;

int i;

}dubbel;

INT8U fout;

dubbel *p_ontv

p_ontv=(dubbel*)OSQPend(postrijev,0,&fout);

p_ontv= OSQPend( );


Het uc os ii rtos

Porting uC/OS-II


Het uc os ii rtos

Een processor kan uC / OS-II draaien, indien aan de volgende eisen voldaan wordt

Er moet een C compiler voor de microcontroller zijn.

Interrupts moeten in C gedisabled en ge-enabled kunnen worden.

De processor moet interrupt ondersteunen en ondersteunt intervallen tussen de 10 en de 100 Hz.

De processor moet instructies hebben voor het laden en opslaan van de stack pointer en andere CPU-registers, hetzij op de stack of in het geheugen.


Het uc os ii rtos

Setting the value of 2 #define constants (OS_CPU.H)

Declaring 11 data types (OS_CPU.H)

Declaring 2 #define macros (OS_CPU.H)

Writing 10 simple functions in C (OS_CPU_C.C)

Writing 4 assembly language functions (OS_CPU_A.ASM)


Het uc os ii rtos

OS_CPU.H

#ifdef OS_CPU_GLOBALS

#define OS_CPU_EXT

#else

#define OS_CPU_EXT extern

#endif

/*

*********************************************************************************************************

* DATA TYPES

* (Compiler Specific)

*********************************************************************************************************

*/

typedef unsigned char BOOLEAN;

typedef unsigned char INT8U; /* Unsigned 8 bit quantity */ (1)

typedef signed char INT8S; /* Signed 8 bit quantity */

typedef unsigned int INT16U; /* Unsigned 16 bit quantity */

typedef signed int INT16S; /* Signed 16 bit quantity */

typedef unsigned long INT32U; /* Unsigned 32 bit quantity */

typedef signed long INT32S; /* Signed 32 bit quantity */

typedef float FP32; /* Single precision floating point */ (2)

typedef double FP64; /* Double precision floating point */

typedef unsigned int OS_STK; /* Each stack entry is 16-bit wide */

/*

*********************************************************************************************************

* Processor Specifics

*********************************************************************************************************

*/

#define OS_ENTER_CRITICAL() ??? /* Disable interrupts */ (3)

#define OS_EXIT_CRITICAL() ??? /* Enable interrupts */

#define OS_STK_GROWTH 1 /* Define stack growth: 1 = Down, 0 = Up */ (4) 1 #define

#define OS_TASK_SW() ??? (5)


Het uc os ii rtos

OS_Enter_Critical() and OS_Exit_Critical()

Os_Enter_Critcal();

//uC/OS-II kritische code sectie

Os_Exit_Critcal();

Macros voor enable en disable interrupt

#define Os_Enter_Critcal() DI

#define Os_Exit_Critcal() SEI

#define Os_Enter_Critcal() \

asm(“ PUSH PSW”); \

asm(“DI”);

#define Os_Exit_Critcal() DI

asm(“ POP PSW”); \

asm(“EI”);


Het uc os ii rtos

OS_STK *OSTaskStkInit() (void (*task)(void *pd),void *pdata,

OS_STK *ptos, INIT16U opt);

{

  • simulate call to function with an argument(i.e. pdata);

  • Simulate ISR vector;

  • Setup stack frame to contain desiredinitial values of all registers;

  • Return new top-of-stack pointer to caller;

    }

void MyTask (void *pdata)

{

/* Do something with argument pdata’ */

for (;;) {

/* Task code */

}

}

Voor een uC/OS-II port zullen een aantal eenvoudige

C functies moeten worden herschreven

OSTaskStkInit()

Deze functie wordt aangeroepen door o.a. OSTaskCreate() om de stack van een taak te initialiseren.


Het uc os ii rtos

OSTaskStkInit()

OS_STK *OSTaskStkInit() (void (*task)(void *pd),

void *pdata,

OS_STK *ptos,

INIT16U opt);

{

simulate call to function with an argument (i.e. pdata);

Simulate ISR vector;

Setup stack frame to contain desired initial values of all registers;

Return new top-of-stack pointer to caller;

}


Het uc os ii rtos

Stackframe geinitialiseerd met pdata.


Het uc os ii rtos

Context Switch

  • Om een ready task running te maken moeten alle processor registers van de task’s stack terug gezet worden en een “return from interrupt” terug gezet worden.

  • OS_TASk_SW(): is een macro welke altijd wordt aangeroepen van task-level code. De OS_TASK_SW() moet een interrupt simuleren.Het maakt een software interrupt (in assembler code) en zet de interrupt vector naar de OSCtxSw() (assembler programma)

  • OSIntExit() wordt gebruikt bij een context switch wanneer bij een ISR die een taak met een hogere prioriteit laat uitvoeren.


Het uc os ii rtos

Context Switch

  • OS_CPU_A.ASM

    • OSStartHighRdy()

    • OSCtxSw()

    • OSIntCtxSw()

    • OSTickISR()

OSStartHighRdy() wordt aangeroepen door OSStart() om de taak met de hoogste prioriteit te laten starten.

Voordat OSStart() aangeroepen kan worden moet minimaal 1 taak gecreëerd zijn.


Het uc os ii rtos

OSTickISR()

uC/OS-II eist een periodieke tijd voor het bijhouden van delays en time-outs

Een ”ticker interrupts” moet geenabled worden nadat de multitasking is gestart, dat gebeurd na het aanroepen van OSStart().

Wanneer de ticker interrupt wordt geenabled voor de aanroeping van OSStart(), kan het systeem crashen.

void main(void)

{

.

OSInit(); /* Initialize µC/OS-II */

.

/* Application initialization code ... */

/* ... Create at least on task by calling OSTaskCreate() */

.

.

Enable TICKER interrupts; /* DO NOT DO THIS HERE!!! */

.

.

OSStart(); /* Start multitasking */

}


Het uc os ii rtos

Aangeven dat je in een interrupt zit

Save sp in huidige taak

Verantwoordelijk voor de interne timers

Pseudocode for tick ISR

void OSTickISR(void)

{

Save processor registers;

Call OSIntEnter() or increment OSIntNesting;

if (OSIntNexting == 1){

OSTCBCur->OSTCBStkPtr = Stack Pointer;

}

clear interrupting device;

Call OSTimeTick();

Call OSIntExit();

Restore processor registers;

Execute a return from interrupt instruction;

}


  • Login