Sobre este projecto

O Arduino IDE e meio ambiente tem muitos drivers e bibliotecas disponveis dentro de
um alcance de armas, mas o ambiente Arduino se limita apenas a configurao () e
loop () e no suporta multi-tasking de forma eficaz.

Este um simples fcil de usar e robusta aplicao, FreeRTOS que s pode calo para o
Arduino IDE como uma biblioteca e permitir o uso das melhores partes de ambos os
ambientes, sem problemas.

fundo

A maioria dos sistemas operacionais aparecem para permitir que vrios programas ou
tpicos para executar ao mesmo tempo. Isso chamado de multi-tasking. Na realidade,
cada ncleo do processador s pode ser a execuo de um nico programa em qualquer
ponto no tempo. Uma parte do sistema operacional chamado o programador
responsvel por decidir qual o programa a ser executado quando, e fornece a iluso de
execuo simultnea, alternando rapidamente entre cada programa.

O planejador em um Sistema Operacional em Tempo Real (RTOS) projetado para

fornecer uma previsvel (normalmente descrito como determinista) padro de execuo.
Isto particularmente interessante para os sistemas embarcados, como os dispositivos
Arduino, como sistemas integrados tm muitas vezes requisitos de tempo real.

Programadores em tempo real tradicionais, como o programador utilizado em

FreeRTOS , alcanar o determinismo, permitindo que o usurio atribua uma prioridade
a cada segmento de execuo. O planejador, ento, usa a prioridade de saber qual
segmento de execuo para executar seguinte. Em FreeRTOS, um segmento de
execuo chamado de T perguntar.

Vamos comear

Vamos fazer Arduino FreeRTOS incrivelmente fcil de usar por VOTAO em

Codebender .

De outra forma...

Em primeiro lugar no gerenciador de Arduino IDE Biblioteca, a partir da verso 1.6.8,

procure a Biblioteca FreeRTOS ao abrigo do tipo: "Contribuio" eo Tema: "Tempo de
espera".

Certifique-se de que o mais recente FreeRTOS Biblioteca lanamento est instalado. A

partir de escrita que v8.2.3-14.

Em seguida, sob a do esboo> Incluir menu Biblioteca, garantir que a biblioteca

FreeRTOS est includo no seu esboo. Um novo esboo vazio ser parecido com este.
Compilar e carregar este esboo vazio para seu dispositivo 1284p Arduino Uno / Yun /
Leonardo / mega ou Goldilocks. Isto ir mostrar-lhe o quanto de seu flash consumida
pelo programador FreeRTOS. Como um guia a seguinte informao foi compilado
usando Arduino v1.6.7 + no Windows 10.

// Device: loop() -> FreeRTOS | Additional Program Storage

// Uno: 450 -> 7328 | 21%
// Goldilocks: 504 -> 7386 | 6%
// Leonardo: 4002 -> 10766 | 24%
// Yun: 3910 -> 10760 | 24%
// Mega: 642 -> 9466 | 3%

Nesta fase FreeRTOS j est em execuo no seu dispositivo.

Prximos passos

Agora carregar e testar o esboo Blink, com um sistema operacional em tempo real
subjacente simplesmente atravs da insero de #include <Arduino_FreeRTOS.h> no
incio do esboo. Isso tudo o que h para ter FreeRTOS funcionando em seus esboos.

O prximo passo explorar os recursos fornecidos por um RTOS total dentro do

Arduino IDE.

Blink_AnalogRead.ino uma boa maneira de comear uma vez que combina dois
exemplos Arduino bsicos, Blink e analogRead em um esboo com duas tarefas
distintas. Ambas as tarefas exercer as suas funes, gerido pelo programador FreeRTOS.
Este esboo pode ser encontrado na pasta Exemplos do Arduino IDE.

Se voc estiver interessado em aplicaes de baixa potncia ou bateria , fcil de usar

FreeRTOS para apoiar os modos de reduo de potncia AVR ATMEGA.

Artigos posteriores cobrir o uso de semforos para proteger os recursos de hardware

(como o porto de srie), filas para transferir dados entre as tarefas, ou temporizadores
para gerir atrasos exatas e tempos de espera. O FreeRTOS Introduo pgina tem lotes
de mais informaes sobre como usar os recursos avanados, e fornece exemplos de
demonstrao . Alm disso, muitos mais exemplos de aplicaes AVR FreeRTOS esto
disponveis, que podem ser simplesmente convertido para usar o ambiente Arduino.
Cdigo

Blink_AnalogRead.ino Arduino
Estes so dois desenhos bsicos a partir dos exemplos Built-in Arduino IDE,
combinados em um esboo multitarefa usando dois FreeRTOS Tarefas.

#include <Arduino_FreeRTOS.h>

// define two tasks for Blink & AnalogRead

void TaskBlink( void *pvParameters );
void TaskAnalogRead( void *pvParameters );

// the setup function runs once when you press reset or power the
board
void setup() {

// Now set up two tasks to run independently.

xTaskCreate(
TaskBlink
, (const portCHAR *)"Blink" // A name just for humans
, 128 // Stack size
, NULL
, 2 // priority
, NULL );

xTaskCreate(
TaskAnalogRead
, (const portCHAR *) "AnalogRead"
, 128 // This stack size can be checked & adjusted by reading
Highwater
, NULL
, 1 // priority
, NULL );

// Now the task scheduler, which takes over control of scheduling

individual tasks, is automatically started.
}

void loop()
{
// Empty. Things are done in Tasks.
}

/*--------------------------------------------------*/
/*---------------------- Tasks ---------------------*/
/*--------------------------------------------------*/

void TaskBlink(void *pvParameters) // This is a task.

{
(void) pvParameters;

// initialize digital pin 13 as an output.

 pinMode(13, OUTPUT);

for (;;) // A Task shall never return or exit.

{
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage
level)
vTaskDelay( 1000 / portTICK_PERIOD_MS ); // wait for one second
digitalWrite(13, LOW); // turn the LED off by making the
voltage LOW
vTaskDelay( 1000 / portTICK_PERIOD_MS ); // wait for one second
}
}

void TaskAnalogRead(void *pvParameters) // This is a task.

{
(void) pvParameters;

// initialize serial communication at 9600 bits per second:

Serial.begin(9600);

for (;;)
{
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// print out the value you read:
Serial.println(sensorValue);
vTaskDelay(1); // one tick delay (15ms) in between reads for
stability
}
}