FreeRTOS

sistema operatiu

FreeRTOS és un sistema operatiu de temps real (RTOS: sigles de Real-Time Operating System) de petita mida, portable, preferent i de codi obert per a sistemes encastats.[1] Està dissenyat per a ser prou petit per a funcionar en un microcontrolador, tot i que el seu ús no només es limita a aplicacions de microcontroladors.

Infotaula de programariFreeRTOS
Logo freeRTOS.png
Desenvolupador(s)Real Time Engineers Ltd.
Versió estable10.0.1 / 20 desembre 2017; fa 2 anys (2017-12-20)
Estat actualActual
PlataformaARM (ARM7, ARM9, Cortex-M3, Cortex-M4, Cortex-A), Atmel AVR, AVR32, HCS12, MicroBlaze, Cortus (APS1, APS3, APS3R, APS5, FPF3, FPS6, FPS8), MSP430, PIC, Renesas H8/S, SuperH, RX, x86, 8052, Coldfire, V850, 78K0R, sèrie Fujitsu MB91460, sèrie Fujitsu MB96340, Nios II, Cortex-R4, TMS570, RM4x
Tipus de nucliMicrokernel
LlicènciaLlicència MIT
Més informació
Lloc webWeb oficial
Modifica les dades a Wikidata

FreeRTOS, de la mà de Real Time Engineers Ltd.,[2] suporta 35 arquitectures i ha rebut més de 113.000 descàrregues durant el 2014.[3] Es desenvolupa professionalment, la qualitat està estrictament controlada, és robust, suportat i es pot incrustar gratuïtament en productes comercials sense cap requisit que exposi el codi font del propietari.

FreeRTOS és gratuït i es distribueix sota una llicència GPL modificada amb una excepció opcional sense el pagament de regalies, aquesta llicència no obliga als desenvolupadors a publicar el codi de les seves aplicacions, però sí que requereix per mantenir el nucli FreeRTOS open source. L'excepció permet als usuaris propietaris del codi que aquest segueixi sent de codi tancat, mantenint el nucli en si, com de codi obert, el que facilita l'ús de FreeRTOS en programari de propietat.

El nombre de tasques que s'executen a la vegades i la seva prioritat està limitat només pel material. La programació és un sistema de cues basat en els semàfors i les mutex. Es basa en el model Round-Robin amb gestió de prioritats. Dissenyat per a ser molt compacte, es compon d'alguns arxius en C i no implementa cap controlador de maquinari.


DefinicióModifica

FreeRTOS és un sistema operatiu de temps real open source desenvolupat per Real Time Engineers Ltd.[4]

El seu disseny és deliberadament minimalista perquè pugui ser instal·lat en sistemes petits. La imatge binària del nucli pesa entre 4KB i 9KB[5] (4.3KB compilat en ARM7). El kit mínim només té unes poques funcions per a la gestió de tasques i memòria, a més a més de la implementació de cues, semàfors i exclusions mutues (mutex).[4]

Es poden executar un nombre il·limitat de tasques de manera simultània i sense restricció.[4]

ImplementacióModifica

FreeRTOS està dissenyat per ser petit i simple. El nucli en si consta de només tres o quatre arxius C. Per fer que el codi sigui llegible, fàcil de portar, i mantenible. Està escrit majoritàriament en C, però hi ha algunes funcions d'ensamblatge incloses per a quan siguin necessàries (en la seva majoria en les rutines del planificador específic de l'arquitectura).[6]

  • Mida del codi de FreeRTOS
- RTOS Code Text: 15 KB
- RTOS Data: 151 B
- Task Stack & Heap. BSS: 6000 B
  • Fitxes .c/.h del FreeRTOS 7
- list.c: 191 linies
- queue.c: 1600 linies
- tasks.c: 2477 linies
- semphr.h: 733 linies
- port.c / portmacro.h / portable.h: 799 + 140 + 182 linies <- Plataforma especifica!

FreeRTOS proporciona mètodes per a diversos subprocessos o tasques, exclusions mútues, semàfors i temporitzadors de programari. Es proporciona una manera tickless per a aplicacions de baixa potència. Suporta les prioritats en els threads. A més hi ha quatre esquemes d'assignació de memòria proporcionats:

  • només d'assignació;
  • d'assignació i alliberació amb un algorisme molt simple i ràpid;
  • amb un algorisme més complex, però d'assignació i alliberació més ràpida i amb coalescència de memòria;
  • i una llibreria amb C d'assignació i alliberació amb algun tipus de protecció d'exclusió mútua.

No hi ha cap de les característiques més avançades que es troben típicament en els sistemes operatius com Linux o Microsoft Windows, com controladors de dispositius, gestió de memòria avançada, comptes d'usuari i xarxes. L'èmfasi està en la compacitat i la velocitat d'execució. FreeRTOS pot se pensat com una "biblioteca de subprocessos" en lloc d'un "sistema operatiu", tot i que la interfície de línia d'ordres i POSIX-com IO abstracció complements estan disponibles.

FreeRTOS implementa múltiples threads tenint la crida al programa host a un mètode thread tick a intervals curts regulars. El mètode thread tick canvia tasques en funció de la prioritat i un esquema de planificació round-robin. L'interval usual és de 1/1000 d'un segon a 1/100 d'un segon, a través d'una interrupció d'un temporitzador de maquinari, però aquest interval es canvia sovint per adaptar-se a una aplicació particular.

La descàrrega conté configuracions i demostracions preparades per a tots els ports i compilador, el que permet el disseny ràpid d'aplicacions. El lloc FreeRTOS.org també conté una gran quantitat de documentació i tutorials RTOS (manuals addicionals i tutorials disponibles per una tarifa a partir de USD25), detalls del disseny RTOS.

ArquitecturaModifica

Gestió de tasquesModifica

Les tasques són implementades en funcions C. L'única cosa que tenen d'especial és el seu prototip, que és un procediment que pren un punter nul com a paràmetre. Generalment s'executen en un bucle infinit i no surten.

 
Tasques en estat d'execució (Running) i en estat de no execució (Not Running)

Una única definició de la funció de tasques pot ser utilitzada per crear qualsevol nombre de tasques, on cada tasca creada es torna una instància d'execució independent, amb la seva pròpia pila i la seva còpia de qualsevol variable automàtica definida dins de la tasca en si.[7]

Hi ha moltes funcions disponibles per a la gestió de tasques: [8]

  • Creació de tasques (vTaskCreate())
  • Destrucció (vTaskDelete())
  • Gestió de prioritats (uxTaskPriorityGet(), vTaskPrioritySet())
  • Retard / rependre ((vTaskDelay(), vTaskDelayUntil(), vTaskSuspend(), vTaskResume(), vTaskResumeFromISR())

La seva estructura genèrica és la següent:

void vATaskFunction( void *pvParameters )
{
    for( ;; )
    {
        -- Afegir el codi de la vostra tasca aquí --
    }
}
 
Diagrama d'estats d'una tasca

Una aplicació pot estar formada de moltes tasques. Si el microcontrolador que executa l'aplicació només conté un nucli, aleshores només podrà estar executant una tasca cada vegada. Això implica que la tasca només pot existir en un de dos possibles estats, en execució (Running) i sense estar en execució (Not Running).

Quan una tasca està en estat d'execució (Running) el processador està, realment, executant el seu codi. Quan una tasca no està en estat d'execució (Not Running) la tasca està inactiva, el seu estat es queda guardat preparat per a quan es reprengui l'execució la propera vegada que el planificador decideixi que aquesta tasca ha d'entrar en estat d'execució (Running). Quan una tasca reprèn l'execució ho fa, exactament, des de la instrucció que estava a punt d'executar abans que deixés d'estar en estat d'execució (Running).[9]

PlanificacióModifica

La programació de tasques té com a objectiu decidir quina tasca en estat de "Preparada" (Ready) s'ha d'executar en un determinat moment. FreeRTOS aconsegueix aquest objectiu assignant les prioritats a les tasques quan aquestes es creen. La prioritat d'una tasca és l'únic element que el planificador té en compte per a decidir quina tasca és seleccionada.[10]

 
Seqüència d'execució de tasques

Prioritat de tasquesModifica

FreeRTOS implementa una prioritat a les tasques per a poder tractar diverses tasques de programació. Aquesta prioritat és un número que s'assigna a la tasca mentre es crea o es canvia manualment utilitzant les funcions:

  • vTaskPriorityGet()
  • vTaskPrioritySet()

El nombre màxim disponible de prioritats s'estableix mitjançant el "define" MAX_PRIORITIES ubicat en el fitxer FreeRTOSConfig.h. FreeRTOS no limita el valor màxim que aquesta constant pot prendre, però quant més alt sigui la quantitat de prioritats més recursos es consumiran, per això és recomanable mantenir el nombre de prioritats al mínim possible. Aquesta gestió de tasques permet la implementació de l'algorisme Rate Monotonic [11] per a la planificació de tasques: les tasques que s'executin amb més freqüència tindran prioritats més altes, en canvi, les tasques que s'executin amb menys freqüència tindran prioritats més baixes.[12]

SemàforsModifica

Un semàfor binari comú RTOS funciona de la següent manera: les tasques poden cridar a dues funcions, TakeSemaphore i ReleaseSemaphore. Si una tasca ha cridat TakeSemaphore per prendre el semàfor i no ha cridat a ReleaseSemaphore per a alliberar-lo, aleshores qualsevol altra tasca que cridi a TakeSemaphore serà bloquejada fins que la primera tasca cridi a ReleaseSemaphore.

Només una tasca pot prendre al semàfor a la vegada.[13]

Gestió de cuesModifica

Les cues són un mecanisme subjacent més enllà de totes les comunicacions de tasques o la sincronització en un entorn FreeRTOS. Aquestes són un tema important per a entendre com és inevitable tenir la possibilitat de construir una aplicació complexa amb tasques que treballin entre elles. Són un mitjà per emmagatzemar un nombre finit (anomenat "longitud") de dades de mida fixa. Tenen la capacitat de ser llegides i escrites per diverses tasques diferents, i no pertanyen a cap tasca en particular. Una cua és, normalment, una FIFO.[14]

ReferènciesModifica