Você está na página 1de 28

Fase 2: Comeando com Ardos para Arduino

Grasshopper.iics , 09 de novembro de 2014

CPOL

4.87 13 votos
Tutorial de um novato para o Arduino com Ardos

Baixar MyArduinoTutorial_WithoutArdOS.zip 806 B


Baixar MyArduinoTutorial_ArdOS.zip 869 B

Figura 1: Arquitetura do Conceito Tutorial

Contedo
1. Antecedentes 2. Configurando Desenvolvimento Arduino Environment 2.1 Comeando com o Arduino Development Environment
2.2 Noes bsicas de Arduino C Programa 2.3 Escrevendo nosso Programa de Arduino Primeira 2.3.1 Simples Piscando Programa
2.3.2 Tomando entrada da Porta Serial 2.3.3 Trabalhando com Digital Chaves 2.3.4 Trabalhando com sensores toque
interruptor exemplo 2.3.5 Funes definidas pelo usurio 3. Ardos 3.1 Instalao 3.2 Trabalhando com Ardos 4. Concluso

1. Fundo
Arduino uma plataforma de hardware popular, que destinado a projectos de prototipagem e hobby, mas voc pode ter a certeza de
um projeto mais complexo e divertido hardware com Arduino. placas Arduino tem um microcontrolador central e vrios outros chips e
necessory hardware para comear com seus projetos de hardware e hobby.
Um microcontrolador tpico basicamente executa um nico programa infinitamente. Esse programa pode acessar vrios dispositivos
entradas, sensores, sada e exibio. Por exemplo, um microcontrolador pode ser programado para ler LDR sensor de luz continuesly e
exibir a intensidade da luz em um LCD. Quando a intensidade da luz cai abaixo de certo nvel, pode desencadear uma unidade rel que
liga luzes. Mas todos estes lgica executado em um nico circuito.
No entanto, existem punhado de scenerios tempo real, onde se espera que o microcontrolador para fazer muitas tarefas paralelas. A
execuo paralela de tarefas so mais ou menos em simultneo, o que significa que existe um mecanismo de comutao tarefa que
muda de um subrouting para outro. programa microcontrolador convencionalmente lida com essa simultaneidade atravs do uso
cutelo de temporizador e saltando de uma subrouting para outro. Mas a implementao de uma estratgia de concorrncia efectiva e,
em seguida, compartilhar dados entre a subrotina uma tarefa tediosa.
Considere um controle remoto IR simples com Arduino. Dependendo do cdigo gerado, o dispositivo esperado para executar certas
tarefas. Agora, quando o sinal de IR gerado no conhecido. Esta a entrada asynchrnous. Portanto, o dispositivo no pode continuar
a ouvir o sinal IR. O sinal necessita de ser ligado a interromper pino de tal forma que como e quando o sinal chega, uma ISR chamado,
que pode, em seguida, manipular o sinal de IV.
Agora, considere a instalao de iluminao simples, onde conjuntos de luzes so ligadas e desligadas pelo microcontrolador em uma
ordem especfica. Uma vez que um cdigo IR feita volume de dizer + bytton pressionado de um controlo remoto, em seguida, a
fim de LEDs deve ser mudado. Portanto, deve haver subrotinas separadas para Glowing LEDs, e ento deve haver ISR para lidar com
cdigo de IR. cdigo IR deve immidiately alterar a ordem. Em seguida, as subrotinas para diferentes LEDs deve ser mudado. Assim,
mesmo um IR simples pode ser pensado para ter evento diferente considerar diferentes cdigos IR como sendo evento diferente.
Ao mesmo tempo utilizador pode querer adicionar lgica extra para ele. Digamos que, juntamente com os LEDs, queremos certa
campainha para funcionar. Quando o novo hardware e funes esto a ser adicionado com a lgica existente, novo cdigo inteiro deve
ser reescrito, compilado, testado e otimizado.
A fim de lidar com esses requisitos simultaneidade, impulsividade Evento, Adicionando hardware, Gerenciamento de tarefas de
aplicaes orientadas microcontrolador tempo real, sistemas operacionais em tempo real foram desenvolvidos RTOS.
Um sistema operacional de tempo real um "programa" microcontrolador independente que pode lidar com taks de baixo nvel como
simultaneidade, gerenciamento de tarefas, disparadores de eventos e assim por diante. Quando um pedido desenvolvida com SOTR, o
prprio sistema operativo distribudo com a aplicao como no final do dia, o microcontrolador executa ainda um nico programa!
Assim, podemos pensar em sistema operacional em tempo real como uma biblioteca que pode ser utilizado pelo programa de
microcontrolador e um que lida com baixo nvel "taks especficos do sistema operacional", como o gerenciamento de dispositivos,
comunicao, tarefas e operaes.
Ardos um tal sistema operacional em tempo real para a plataforma Arduino. Destinase a fornecer APIs que ajuda a alcanar grandes
LEVL de paralelismo para os programas Arduino, juntamente com um excelente suporte para a manipulao de eventos e gatilhos.
Neste tutorial veremos o funcionamento bsico com Arduino e depois vamos estender nosso conselho para apoiar Ardos. Vamos comparar
certas aplicaes que esto sendo desenvolvidos sem Ardos e com Ardos e ir comparar seus desempenhos (Consulte a figura 1).
Eu estaria usando placa Arduino Duelmilanova para este totorial qual obtemos por cerca de $ 11 aqui na ndia. Voc tambm pode usar
Arduino Decimilia, placas Uno R3 como par a sua adequao e availibility da placa.

2. Configurando Arduino Ambiente de Desenvolvimento


2.1 Comeando com o Arduino Development Environment

Primeiro download mais recente Arduino IDE de Official Software Download Site do Arduini . Usurio do Windows ser capaz de baixar
um instalador. O instalador tem um driver USB FTDI junto com o prprio IDE. Preferem instalar o driver USB. Isto essencial. Sem driver
USB seu IDE no pode se comunicar com o dispositivo de Arduino.
Seguese o Pin Descrio do dispositivo que estou usando.

Figura 2.1: Arduino Diecimilia / Duemilanova com nveis Pin


Uma vez que o software est instalado, conecte o cabo USB do Arduino para o seu laptop. Voc ver uma notificao na bandeja
"instalar o driver". Uma vez que a instalao do driver bem sucedida Abra o Gerenciador de Dispositivos iniciar> clique direito em
Computador cone> Propriedades> Gerenciador de Dispositivos.

Figura 2.2: Gerenciador de Dispositivos Aps Arduino est conectado.


Na seo Portas COM e LPT voc v porta serial USB. Em caso de Arduino Uno R3, voc vai ver Arduino Uno marcador ao longo do
porto. Ao conectar o cabo, voc no vai encontrar mais do porto. Portanto, este o porto em que o seu dispositivo Arduino est
conectado.
Se tiver ligado o dispositivo pela primeira vez, voc vai notar tambm que o LED prximo pino digital 13 est piscando. A maioria das
placas Arduino so prcarregados com um programa de intermitncia que pisca o LED conectado ao pino 13.
Antes de comear com a nossa codificao, precisamos de casal apenas de mais passos para IDE configurao com a placa.
Abra o IDE. Tools> Placas de selecionar a placa que voc est se conectando, como mostrado na figura abaixo.

Figura 2.3: Arduino Jri


Uma vez que a placa selecionado, voc precisa configurar a porta serial correta como voc ter descoberto a partir da figura 2.2

Figura 2.4: Seleo USB Porta Serial no IDE


Antes de ir para a programao das placas vamos aprender alguns princpios simples de programao Arduino C.

2.2 Basics Programa Arduino C de


A seguir a estrutura bsica do programa Arduino.
vaziosetup(){
//colocaroseucdigodeconfiguraoaqui,paraexecutarumavez:
}
vazioloop(){
//coloqueocdigoprincipalaqui,paraexecutarrepetidamente:

setup() executado uma vez quando voc reiniciar o dispositivo, ou restrat o dispositivo, ou conectar o cabo USB. loop()
corre continuesly. lgica principal deve ser implementada dentro de loop.
Arduino Duemilanova / Diecimilia / Uno R3 daqui em diante ir se referir simplesmente como Arduino placa tem 14 IP Digital dos
pinos. Cada pino pode ser programa separadamente. Um PIN pode ser no modo de sada ou modo de entrada que precisa ser
especificada na configurao usando

pinMode(PIN_NO,OUTPUT) ou pinMode(PIN_NO,INPUT);
modo de entrada usado quando voc ligar um interruptor para um pino e quer o pino para ler o estado. Estes pinos digitais no modo
de entrada s pode reconhecer a entrada nvel lgico como 0 e 1. PIN_NO varia de 013, dependendo do pino que voc est
programando.
voc pode escrever a sada lgica em um pino no modo de sada ou pode ler o valor no pino 1 ou 0, usando
digitalWrite(PIN_NO,HIGH)/digitalWrite(PIN_NO,LOW)e intn=digitalRead(PIN_NO), respectivamente.
Alguns pinos nos portos digitais so marcados como PWM como 10 e 11 na figura. Eles podem ser usados para gerar impulso de
porta de diferente ciclo de trabalho. Pin PWM pode ser programado para produzir impulso de porta quadrado perfeito de ciclos de
funcionamento especficas usando analogWrite(PIN_NO,byteValue)Onde byteValue pode ser betweet 0 a 255, onde 255
represts mais altos ou 100% ciclo de trabalho. PWM pinos podem ser usados para controlar motores DC controle de velocidade preciso
ou intensidade controle de lmpadas elctricas atravs MOSFETs / IGBTs e assim por diante.
Arduino tem seis pinos de leitura analgico 0 a 5 em frente s portas digitais. Estes so pinos de entrada que esto ligados para 10
bits ADC. Sensores podem ser diretamente ligado a estes pinos. Arduino pode ler a tenso no pino com
intvalue=analogRead(ANALOG_PIN_NO)
O software vem com uma biblioteca de srie, atravs do qual outros programas podem se comunicar com Arduino usando
comunicao serial. Arduino IDE tambm vem com um monitor de srie atravs do qual se pode testar a comunicao serial.
Para inicializar a comunicao serial, na funo de configurao preciso inicializar o objeto de comunicao serial com
Serial.begin(BAUD_RATE)Taxa de transmisso varia nos mltiplos de 96200. Serial.print("msg"),
Serial.println("msg"), Serial.write(someVariable)so funes comuns por meio do qual a placa pode gravar
dados na porta serial que pode ser lido por qualquer programa externo capaz de comunicar com o dispositivo atravs da porta serial.

intv=Serial.read() usada para ler dados de porta serial escrito por outros programas na porta serial.
delay(delayInMilli); usado para fazer a prxima instruo de espera para delayinMilli perodo de tempo que especificado
em milissegundos.
A maior parte da ferragem entrada e sada de base pode ser realizada utilizando comandos acima.

2.3 Escrevendo nosso Programa Primeira Arduino


Tendo chegado um pouco de idia sobre a programao Arduino, vamos agora passar a parte mais interessante, a codificao.
Agora abra seu IDE a partir do cone de atalho desktop ou a partir de arquivos de programas. Voc vai ver o IDE com um esboo
padro. O programa C que ns escrevemos para Arduino conhecido como um esboo.
Ento, vamos fazer nossas mos sujas com Arduino codificao sem hardware externo. Vamos alterar o tempo de piscar para 1s no
perodo e 1seg off perodo.

2.3.1 Programa Piscando Simples


O programa bastante simples e no precisam de explicao.
vaziosetup()
{
pinMode(13,OUTPUT);
//colocaroseucdigodeconfiguraoaqui,paraexecutarumavez:
}
vazioloop()
{
//Coloqueocdigoprincipalaqui,paraexecutarrepetidamente:
digitalWrite(13,HIGH);
atraso(1000);
digitalWrite(13,LOW);
atraso(1000);
}
Tendo escrito e gravado o programa, clique no boto Upload, como mostrado na figura a seguir para carregar o esboo na placa.
simples assim.

Figura 2.5: Carregando o esboo no Conselho.


isso a. agora voc vai ver o LED associado ao pino 13 est a piscar com atraso de 1 seg.
Ento voc comea a entender como microcontrolador funciona. Certo? Como sobre a entrada do usurio? Diga quando o usurio d
um atravs da porta serial, o LED deve brilhar. Quando o usurio d entrada como 0, o LED deve ser desligado.
Ento, para fazer upload de esboo voc no precisa salvlo. No entanto, gostaria de sugerirlhe para guardar o esboo com algum
nome significativo. Quando voc salva o esboo, a pasta ser criada com o nome do desenho e o esboo ino ser colocado dentro da
pasta.

2.3.2 Tomando entrada da Porta Serial


Primeiro, vamos estabelecer uma comunicao de srie. Vamos estabelecer uma comunicao serial com o dispositivo usando o
comando Serial.begin. Serial.available()Retorna true se os dados esto sendo escritos por outro dispositivo na porta. Ento,
vamos primeiro verificar para dados seriais e se presente, vamos imprimilos.

vaziosetup()
{
pinMode(13,OUTPUT);
//colocaroseucdigodeconfiguraoaqui,paraexecutarumavez:
Serial.begin(19200);
}
vazioloop()
{
Se(Serial.available())
{
intn=Serial.read();
Serial.println(N);
}
}
Depois de fazer o upload do esboo, para verificar o resultado que voc precisa para abrir a janela Monitor de srie usando Ctrl + Shift
+ M ou opo de menu Ferramentas do.

Figura 2.6: Usando o Monitor Serial


Uma vez que voc abrir a janela, tipo 1 no painel de entrada superior e entra, voc ver 49, e para 0, voc ver 48. O que significa que o
monitor de srie leva entrada ascii do teclado. Vamos primeiro convertlo em nmero normal subtraindo 48 e, em seguida,
implementar e fora da lgica.
Aqui vai o programa.
vaziosetup()
{
pinMode(13,OUTPUT);
//colocaroseucdigodeconfiguraoaqui,paraexecutarumavez:
Serial.begin(19200);
Serial.println("Insira1paratransformarLEDe0paradesliglo");
}
vazioloop()
{

Se(Serial.available())
{
intn=Serial.read();
//Serial.println(N);
N=N48;

se(n==0)
{
Serial.println("LEDOFF");
digitalWrite(13,LOW);
}
outracoisase(n==1)
{
Serial.println("LEDON");
digitalWrite(13,HIGH);
}
outro
{
Serial.println("Apenas0e1permitidocomoinput");
}
}
}
Quando voc carrega o cdigo e executar atravs do monitor de srie voc pode ver que o LED ligado quando a entrada 1, continua
se at que voc d entrada como 0 e permanece zero.

Figura 2.7: Sada de Ligar e desligar off LED de entrada de srie

2.3.3 Switches de Trabalho com o Digital


A idia do artigo para ensinarlhe truques Arduino sem muito de hardware para que voc possa se acostumar com o ambiente de
programao com facilidade.
Um interruptor Digital simbolicamente representada como figura seguinte. Dois pontos A e B so ligados quando o interruptor est
fechado e no est conectado quando o interruptor aberto. Existem diferentes maneiras como a abertura e fechamento controlado
que inclui relayes, botes de presso, chaves de alavanca etc.

2.8: Simple Interruptor Digital


Voc pode obter vrias opes compatveis com Arduino. Mas eu vou te mostrar como implementar uma lgica de comutao apenas
com um simples fio.

Figura 2.9: Troca simples com um fio de ligao nico.


Tomamos um fio de conexo para conectar + 3v pino na porta de alimentao para outro pin digamos 8, como mostrado na figura
acima, ento sempre que a conexo feita, 8 ter mesma tenso que de outro pino isto lgico 1, quando voc tirar o fio e conect
lo ao cho, 8 ser interruptor aberto e ter lgica 0. quando a chave fechada, o LED deve acender, quando o interruptor aberto, ele
deve parar de incandescncia. Este no um interruptor ideal, mas um pouco de manipulao para a obteno do desejado nvel lgico
para validar um programa.
vaziosetup()
{
pinMode(13,OUTPUT);

pinMode(8,ENTRADA);
//colocaroseucdigodeconfiguraoaqui,paraexecutarumavez:
Serial.begin(19200);
Serial.println("Insira1paratransformarLEDe0paradesliglo");
}
vazioloop()
{Intn=0;
n=digitalRead(8);
Se(n==0)
{
digitalWrite(13,LOW);
}
outracoisase(n==1)
{
digitalWrite(13,HIGH);
}
delay(200);//paraevitaroexcessodevotaoatravsdaleituracontinueslydadosporturios
}

delayNo final importante. Sem ela, o microcontrolador tem que pesquisar continuesly o pino que resulta na degradao do
desempenho. Voc pode alterar o valor de atraso, dependendo de suas necessidades de aplicao.

2.3.4 Trabalhando com sensores toque interruptor Exemplo


Citar:

Um sensor converte o parmetro fsico por exemplo: temperatura, presso arterial, humidade, velocidade, etc. num sinal que
pode ser medido electricamente

Existem diferentes tipos de sensores para medir diferentes actividades fsicas que inclui a intensidade da luz, temparature, humidade e
assim por diante. Esta pgina wiki dlhe uma lista elaborada de sensores.
Um dos aspectos importantes de dispositivos de microcontroladores ler os dados do sensor e tomar decises em conformidade.
Assim, tambm deve aprender a lidar com sensores. Mas como este tutorial tudo sobre a aprendizagem Arduino sem muito de
hardware externo, vamos usar novamente certo conceito simples de entender como o sensor funciona.

Os pinos analgicos em Arduino est conectado a 10 bit ADC. Isso significa que a tenso analgica nos pinos vai ser convertido em
valor digital de 10 bits. O que significa para uma entrada 5v analgico, um pino sensor ir ler 1024.
Agora corpo humano tem diferena de potencial de terra. Arduino sensvel o suficiente para detectar essa diferena de potencial.
Ento, se ns tocar o pino analgico com o nosso corpo, ele vai ter diferena de potencial do nosso corpo. Como diferena de potencial
do corpo atribudo ao sinal de ECG que tem periodicidade, como voltagem ir variar entre alto a baixo.
Tambm tenso medido entre um ponto e o cho. tenso do corpo que adquirida pelos pinos tero terra como terra que no
comum para a terra do microcontrolador. Assim, haver diferena enorme potencial. Nosso programa deve levar isso em considerao.
Ento, vamos colocar o fio no pino analgico 5 e escrever nosso programa para obter tenso analgica no pino 5.

Figura 2.10: fio ligado a Analog Pin 5


vaziosetup()
{
pinMode(13,OUTPUT);
pinMode(12,OUTPUT);
digitalWrite(12,HIGH);
pinMode(8,ENTRADA);
//colocaroseucdigodeconfiguraoaqui,paraexecutarumavez:
Serial.begin(19200);
Serial.println("Insira1paratransformarLEDe0paradesliglo");
}
vazioloop()
{Intn=0;
n=analogRead(5);
Serial.println(N);
atraso(500);
}
E a sua sada do Monitor Serial deve ser algo como abaixo.

Figura 2.11: Sada do Monitor Serial of Reading Analog Pin


Voc poderia ter esperado 0 na sada, porque voc no est fornecendo qualquer tenso no pino em outras palavras o pino um
circuito aberto. Mas porque puxar para cima registo no pino analgico, a carga de lixo coletado que exibido como sada analgica.
Agora, quando voc segurar o fio como 2,12

Figura 2.12: Serial Sada do Monitor Quando a tenso do corpo fornecido para Arduino Analog Pin 5

Se traar os valores em excell, voc obtm o grfico seguinte.

Figura 2.13: Grfico de tenso do corpo


A fim de minimizar o efeito das variaes, vamos agora tomar avaerage de 10 leituras como o nosso valor Sensor.
vaziosetup()
{
pinMode(13,OUTPUT);
pinMode(12,OUTPUT);
digitalWrite(12,HIGH);
pinMode(8,ENTRADA);
//colocaroseucdigodeconfiguraoaqui,paraexecutarumavez:
Serial.begin(19200);
Serial.println("Insira1paratransformarLEDe0paradesliglo");
}
ints=0;
inti=1;
inta=0;
vaziolao()
{Intn=0;
n=analogRead(5);
s=s+n;
um=s/I;
i++;
Se(i>10)
{
i=1;
s=0;
}
Serial.println(a);
atraso(500);
}
Lembrese que a nossa tenso corpo ser diferente e assim ser a tenso porta aberta dos dispositivos, para que voc no pode obter
resultado exato como dado aqui, mas voc vai ter resultado muito similar.

Figura 2.14: Grfico de modificao da tenso do corpo.


Este muito mais estvel. Podemos ver que ambos os valores so maiores do que 700 ou menos de 200. Agora obter um grfico com
uma mdia de valores do sensor quando voc no tocar o pino como em 2.16.

2.15: Circuito Aberto Analog Pin 5 Mdia Tenso Graph


Isto fantstico. Porque agora temos a tenso de "no tocar" entre 250 e 500.
Ento agora podemos disparar um evento quando a tenso for superior a 600 ou desce abaixo de 200? Sim, ns podemos e vamos
acionar a luz do LED em quando tocamos o pino e desliglo quando lanarmos o pino.
//InterruptordetoquePrograma.ToquePin5paraligarLED,lanamentoparadesligar
vaziosetup()
{
pinMode(13,OUTPUT);
pinMode(12,OUTPUT);
digitalWrite(12,HIGH);
pinMode(8,ENTRADA);
//colocaroseucdigodeconfiguraoaqui,paraexecutarumavez:
Serial.begin(19200);
Serial.println("Insira1paratransformarLEDe0paradesliglo");
}
ints=0;
inti=1;
inta=0;
vaziolao()
{Intn=0;
n=analogRead(5);
s=s+n;
um=s/I;

i++;
Se(i>10)
{
i=1;
s=0;
}
Serial.println(a);
se(a>650||uma<200)
{
digitalWrite(13,HIGH);
}
outro
{
digitalWrite(13,LOW);
}
atraso(500);
}

2.3.5 Funes Definidas pelo Usurio


Tal como em qualquer ambiente de programao eficiente, Arduino tambm fornecer funes para manter o cdigo limpo e de ser
capaz de chamlo, em vez de repetir o cdigo embutido. funes Arduino so como funes normais do programa C e se comporta
exatamente como subrotinas em programas de nvel de montagem.
Vimos Serial, Switch e Sensor conduzido dentro e fora do LED. Vamos colocar togather tudo. Vamos desenvolver um programa onde
podemos ligar o LED tanto por trs meios e pode desligar usando apenas comandos de srie.
anularSerialLogic()
{
intn=0;
se(Serial.available())
{
n=Serial.read();
Serial.println(N);
n=n48;
se(!n=10)//CdigoparaEnter
{
se(n==0)
{
Serial.println("LEDOFF");
digitalWrite(13,LOW);
}
outracoisase(n==1)
{
Serial.println("LEDON");
digitalWrite(13,HIGH);
}
outro
{
Serial.print("Apenas0e1permitidocomoinput");
Serial.println(N);
}
}

}
}
anularSwitchLogic()
{
intn=0;
n=digitalRead(8);
Se(n==0)
{
//DigitalWrite(13,LOW);
//Estamosdesligandoapenasatravsdecomandosdesrie
}
elsese(n==1)
{
digitalWrite(13,HIGH);

}
}
ints=0;
inti=1;
inta=0;
vazioSensorLogic()
{
intn=0;
n=analogRead(5);
s=s+n;
um=s/I;
i++;
Se(i>10)
{
//Imprimirovalorumemcada5Second
Serial.println(a);
i=1;
s=0;
}
//Serial.println(a);

se(a>650||uma<200)
{
digitalWrite(13,HIGH);
}
outro
{
//DigitalWrite(13,LOW);
//NoTurningoffaqui:)
}
}
vaziosetup()
{
pinMode(13,OUTPUT);
pinMode(12,OUTPUT);
digitalWrite(12,HIGH);
pinMode(8,ENTRADA);
//colocaroseucdigodeconfiguraoaqui,paraexecutarumavez:
Serial.begin(19200);
Serial.println("Insira1paratransformarLEDe0paradesliglo");
}
vazioloop()
{
SerialLogic();
SwitchLogic();
SensorLogic();
atraso(500);
}
Assim voc pode ver que ns realmente fez trs funes: SerialLogic(), SensorLogic(), SwitchLogic()que lida com a
On off atravs da porta serial, ligar atravs do toque e ligar conectando + 3v ao pino 12, respectivamente.
De loop()estamos apenas chamando essas funes. Voc tambm pode ver que no estamos imprimindo cada valor de srie aqui,
em vez de colocar apenas uma vez em Avery 5 seg leitura par .5sec, impresso aps 10 leituras.
Tecnicamente estamos esperando todas as trs funes para executar "paralelamente" simultaneamente no ? Mas devido natureza
do programa de C, no ser executada em srie, uma aps a outra na ordem de chamada. Correto? Ento, no temos apoio paralelismo
aqui.
Neste momento voc pode pensar de cada funo como uma tarefa, onde cada tarefa executada conjunto de instrues.
Agora vamos adicionar pouco de tempero. Vamos tambm piscar do LED para 5 vezes, uma vez em cada 10 segundos cada, juntamente
com a lgica existente.
Ento aqui o nosso novo programa com BlinkLogic()

anularSerialLogic()
{
intn=0;
se(Serial.available())
{
n=Serial.read();

Serial.println(N);
n=n48;
se(!n=10)//CdigoparaEnter
{
se(n==0)
{
Serial.println("LEDOFF");
digitalWrite(13,LOW);
}
outracoisase(n==1)
{
Serial.println("LEDON");
digitalWrite(13,HIGH);
}
outro
{
Serial.print("Apenas0e1permitidocomoinput");
Serial.println(N);
}
}

}
}
anularSwitchLogic()
{
intn=0;
n=digitalRead(8);
Se(n==0)
{
//DigitalWrite(13,LOW);
//Estamosdesligandoapenasatravsdecomandosdesrie
}
elsese(n==1)
{
digitalWrite(13,HIGH);
}
}
ints=0;
inti=1;
inta=0;
vazioSensorLogic()
{
intn=0;
n=analogRead(5);
s=s+n;
um=s/I;
i++;
Se(i>10)
{
//Imprimirovalorumemcada5Second
Serial.println(a);
i=1;
s=0;
}
//Serial.println(a);

se(a>650||uma<200)
{
digitalWrite(13,HIGH);
}
outro
{
//DigitalWrite(13,LOW);
//NoTurningoffaqui:)
}
}
anularBlinkLogic()
{
Serial.println("Intermitente");
para(intj=0;j<5;j++)
{
digitalWrite(13,HIGH);
atraso(500);
digitalWrite(13,LOW);

atraso(500);
}
Serial.println("IntermitenteEnds");
}
vaziosetup()
{
pinMode(13,OUTPUT);
pinMode(12,OUTPUT);
digitalWrite(12,HIGH);
pinMode(8,ENTRADA);
//colocaroseucdigodeconfiguraoaqui,paraexecutarumavez:
Serial.begin(19200);
Serial.println("Insira1paratransformarLEDe0paradesliglo");
}
intt=0;
nulaloop()
{
SerialLogic();
SwitchLogic();
SensorLogic();
T++;
Se(t>=10)
{
BlinkLogic();
t=0;
}
atraso(500);
}
Ter um olhar para a sada deste programa:

Figura 2.16: Resultado do Blink, Sensor, Switch, lgica Serial colocar no mesmo cdigo
A sada realmente expe o problema de programas Arduino convencionais. Podemos ver que no apenas as tarefas no so executados
em cocorrente tambm que eles esto bloqueando na natureza.
Mais uma observao que voc pode fazer durante a execuo do programa que, se voc quer um piscar 5 segundos aps cada 10
segundos, eles no aparecem aps exatos 10 segundos como a lgica tem de suportar os atrasos de outras partes executoras. O que

significa que a programao perfeita no possvel com programas Arduino . Arduino tem uma biblioteca de temporizador que faz
com que a programao melhor, mas multitarefa ainda uma tarefa difcil.
Vamos introduzir Ardos no prximo captulo e mostrar como superar esses problemas usando o OS.

3. Ardos
3.1 Instalao
Ardos distribudo como uma biblioteca Arduino. Primeiros Ardos baixar aqui . Renomeie o arquivo Zip como ArdOS.zip. Isso ocorre
porque Arduino no suporta caracteres especiais, como , SPACE ao instalar um pacote / biblioteca. Agora clique em Esboo menu>
Adicionar biblioteca e selecione o pacote compactado baixado e renomeado.

Figura 3.1: Instalao Ardos


Uma vez feito isso, voc vai ver Ardos na lista de bibliotecas quando voc passar o mouse opo de biblioteca de importao no menu
esboo sobre.

Figura Sucesso 3.2 Instalao de Ardos

3.2 Trabalhando com Ardos


Vamos primeiro escrever um exemplo simples de Ardos e depois vamos modelar o nosso programa complexo desenvolvida no ponto 2
com Ardos.
Em um espao em branco do esboo de importao Library> Ardos. Ele ir incluir seguintes arquivos de cabealho.
#include<kernel.h>#include<mutex.h>#include<Queue.h>#include<sema.h>

Voc pode facilmente tornarse que Kernel sero compilados junto com seu cdigo. Mutex fornece mtodos para exclussion mtua
importante para paralelismo de tarefas, filas gere fila de tarefas, sema gere os semforos. Semforos so os bloqueios utilizados,
enquanto um recurso compartilhado entre vrias tarefas. kernel fornece mtodos para a programao, gerenciamento de tarefas,
compartilhamento de recursos, manipulao de interrupo e assim por diante.
programas Ardos deve incorporar lgica de programao dentro de tarefas com assinatura
vaziotarefa(vazio*p)
De setup()tarefas mtodo deve ser inicializado e colocado dentro de uma fila. loop()No deve conter qualquer cdigo como
toda looping ser cuidada por Kernel. Como do kernel lida com tarefas, tarefas deve implementar loops infinitos para permitir que as
tarefas a executar infinitamente.
#include<kernel.h>#include<Queue.h>#include<sema.h>#defineNUM_TASKS2
vaziotask1(vaziop*)

decharbuffer[16];
noassinadocarvosreg;
intn=0;
enquanto(1)
{
sprintf(buffer,"Tempo:%lu",OSticks());
Serial.println(buffer);
OSSleep(500);
}
}
vaziotask2(vazio*p)
{
unsignedintpausa=(unsignedint)p;
caracteredebuffer[16];
enquanto(1)
{
digitalWrite(13,HIGH);
sprintf(buffer,"==>Time:%lu",OSticks());
Serial.println(buffer);
Serial.println("LEDHIGH");

OSSleep(pausa);
sprintf(buffer,"==>Time:%lu",OSticks());
Serial.println(buffer);
digitalWrite(13,LOW);
Serial.println("LEDLOW");
OSSleep(pausa);
}
}
vaziosetup()
{
OSInit(NUM_TASKS);

Serial.begin(19200);
pinMode(13,OUTPUT);

OSCreateTask(0,task1,NULL);
OSCreateTask(1,task2,(vazio*)250);

OSRun();
}
vazioloop()
{
//Vazio
}
Aqui ns usamos duas tarefas: task1 e task2. task1 apenas imprime tempo em termos de carrapatos. pisca TASK2 LED em um valor
especfico passado como parmetro e tambm imprime On e Off estado com a respectiva tempo. Ambas as tarefas so destinadas a
executar continuesly atravs de while(1)estrutura de Loop. Em vez de usar delayusamos OSSleep()a funo que lida com o
atraso com preciso sem bloquear outras tarefas. Primeiro, uma fila de tarefas inicializado com OSInita funo. As tarefas so
colocados em fila de tarefas usando OSCreateTaskfuno. O primeiro parmetro id tarefa, segundo parmetro o nome da
funo de tarefa eo terceiro parmetro passado para a tarefa.
Pinos digitais e de comunicao serial inicializada em forma ususal antes da inicializao das tarefas. Uma vez feito isso, o programa
executado atravs Ardos multitarefa ambiente usando OSRun().
A sada do programa acima como mostrado abaixo.

Figura 3.3: O resultado do nosso programa Primeiro Multi Tasking Ardos


No entanto, enquanto trabalhava com o Kernel e RTOS, voc deve ser muito particular sobre seu projeto, a quantidade de tempo que
um recurso pode demorar. Se um recurso precisa ser compartilhado por duas tarefas o cuidado deve ser adotado.
Para verificar quo crtica a programao Ardos apenas adicione o seguinte duas linhas no seu task1 e tentar executar:
n=analogRead(5);
Serial.println(N);
Obviamente, voc precisa declarar n antes while. Quando voc corre, voc pode no ver o resultado de impresso desejado de valor
pino analgico.
No entanto, se aumentar a taxa de transmisso para 115200 e implementar analgico lido em mais uma tarefa, que nos daria resultado
perfeito.
Confira o seguinte cdigo:
#include<kernel.h>#include<Queue.h>#include<sema.h>#defineNUM_TASKS4
vaziotask1(vaziop*)

{
decharbuffer[16];
noassinadocarvosreg;
intn=0;
enquanto(1)
{

sprintf(buffer,"Tempo:%lu",OSticks());
Serial.println(buffer);
OSSleep(1000);
}
}
vaziotask2(vazio*p)

{
unsignedintpausa=(unsignedint)p;
caracteredebuffer[16];
enquanto(1)
{
digitalWrite(13,HIGH);
//sprintf(buffer,"==>Time:%lu",OSticks());
//Serial.println(buffer);
//Serial.println("LEDHIGH");

OSSleep(pausa);
//Sprintf(buffer,"==>Time:%lu",OSticks());
//Serial.println(buffer);
digitalWrite(13,LOW);
//Serial.println("LEDLOW");
OSSleep(pausa);
}
}
vaziotask3(vazio*p)
{
caracterebuff1[16];
intn1=0;
quando(1)
{
n1=analogRead(5);
n1=map(n1,0,1023,0,255);
sprintf(buff1,"APV:%d",n1);
Serial.println(buff1);
OSSleep(1000);
}
}
vaziosetup()
{
OSInit(NUM_TASKS);

Serial.begin(115200);
pinMode(13,OUTPUT);
OSCreateTask(0,task3,NULL);
OSCreateTask(1,task1,NULL);
OSCreateTask(2,task2,(vazio*)1000);
OSCreateTask(3,task1,NULL);
OSRun();
}
vazioloop()
{
//Vazio
}
O resultado deste programa vai lhe dar importantes insights de por que a funo anterior no funcionou. Muitas tarefas podem
paralelamente tentar escrever na porta serial.

Figura 3.4: Conflito de recursos entre as tarefas


Isto proporciona uma compreenso importante de como o cdigo deve ser concebida. Deve ser cuidadosamente escrita, a fim de
minimizar a realizao de qualquer recurso partilhado por mais tempo por qualquer nica tarefa.
Como o software est em fase beta ainda h alguns bugs. No declarar variveis locais com o mesmo nome em funes diffrent. Meios
no declarar uma varivel pelo nome n em task2 task1 e. Tarefas no reconhecem o estado de variveis globais. Ento, se voc declarar
uma varivel global e esperar que a ser usado em suas tarefas, ento, que no o que acontece aqui. Na verdade tarefas so incapazes
de reconhecer variveis globais. H mais algumas questes, mas voc pode cuidadosamente codificar para superar esses.
Aqui a nossa implementao do cdigo que desenvolveu na seo 3 reescrito com Ardos. Escusado ser dizer que o cdigo executa
muito melhor em termos de paralelismo, disparador de eventos e programao.
#include<kernel.h>#include<mutex.h>#include<Queue.h>#include<sema.h>vazioSerialLogic(
vaziop*)

{
intn2=0;
quando(1)
{
Se(Serial.available())
{
n2=Serial.read();
Serial.println(N2);
n2=N248;
se(!n2=10)//CdigoparaEnter
{
se(==n20)
{
Serial.println("OFFSERIAL");
digitalWrite(13,LOW);
}
outracoisase(==n21)
{
Serial.println("ONSERIAL");

digitalWrite(13,HIGH);
}

}
OSSleep(500);
}
}
vazioSwitchLogic(vaziop*)
{
intn3=0;
quando(1)
{
n3=digitalRead(8);

Se(N3==0)
{
//DigitalWrite(13,LOW);
//Estamosdesligandoapenasatravsdecomandosdesrie
}
elsese(==n31)
{
Serial.println("LIGAR");
digitalWrite(13,HIGH);
}
OSSleep(500);
}
}
ints=0;
inti;
inta=0;
nulaSensorLogic(vazio*p)
{
intN4=0;
enquanto(1)
{
4=analogRead(5);

Se(N4>750||N4<50)
{
Serial.println("SENSORON");
digitalWrite(13,HIGH);
}
outro
{
//DigitalWrite(13,LOW);
//NoTurningoffaqui:)
}
OSSleep(1000);
}
}
vazioBlinkLogic(vaziop*)
{

enquanto(1)
{
Serial.println("Intermitente");

para(intj=0;j<2;j++)
{
digitalWrite(13,HIGH);
OSSleep(500);
digitalWrite(13,LOW);
OSSleep(500);
}
Serial.println("IntermitenteEnds");
OSSleep(20000);
}
}
vaziosetup()
{
pinMode(13,OUTPUT);
pinMode(12,OUTPUT);
digitalWrite(12,HIGH);

pinMode(8,ENTRADA);
//colocaroseucdigodeconfiguraoaqui,paraexecutarumavez:
Serial.begin(115200);
//Serial.println("Enter1paratransformarLEDe0paradesliglo");

OSInit(4);

OSCreateTask(0,SerialLogic,NULL);
OSCreateTask(1,SwitchLogic,NULL);
OSCreateTask(2,SensorLogic,NULL);
OSCreateTask(3,BlinkLogic,NULL);
OSRun();
}
intt=0;
nulaloop()
{

}
Eu tive que reescrever SensorLogic por causa da incapacidade do sistema operacional para lidar com varivel global. A seguir a sada

Figura 3.5: Sensor, Switch, Blink e da lgica de srie em Ardos


L voc ver que Ardos facilita a eficincia e preciso agendar os eventos e multitarefa diferentes tarefas. Voc pode brincar com outra
lgica e ver como Ardos funciona.

4. Concluso
Neste artigo ns aprendemos como comear com os seus placas Arduino e codificao. Aprendemos os aspectos importantes do
conselho nomeadamente deteco, controle e comunicao serial. Ns, ento, aprendeu a usar Ardos e migrou uma soluo a partir do
esboo Arduino convencional para Ardos. Ardos no s proporciona boas caractersticas de multitarefa, mas ao mesmo tempo, ele
tambm oferece um bom compartilhamento de recursos usando Mutex e semforos. Como o objetivo deste tutorial era para guilo
fcil migrao de programas de esboo para programas Ardos, considerei recursos multitarefa do OS. Voc pode conferir os exemplos

de semforo e mutex e pode brincar com os exemplos. Ardos ainda est em fase beta e eu listei alguns inconvenientes. No entanto,
essas desvantagens no tornar o sistema operacional instvel. cuidados pouco na codificao pode superar as deficincias do sistema
operacional. Alm disso, o objetivo do tutorial era para cobrir a maior parte dos aspectos da programao Arduino sem usar qualquer
hardware externo. Uma vez que voc est confiante de ambiente Arduino, voc pode obter algum hardware barato como LM35, LDR,
Relays, BC548, 5V Motors, LEDs e pode experimentar diferentes lgicas.

Licena
Este artigo, juntamente com qualquer cdigofonte associado e arquivos, est licenciado sob o cdigo do projeto Open License CPOL

Compartilhar
Sobre o autor
Grasshopper.iics
CEO Idias Integradas
ndia

gasshopper.iics um grupo de programadores como o esprito e alunos em codeproject. O objetivo bsico manter em contato e
ser notificado quando um membro contribui com um artigo, para verificar com a tecnologia e compartilhar o que sabemos. Ns
somos os "estudantes" de codeproject.
Este grupo gerenciado por Rupam Das, um autor ativo aqui. Outros membros notveis incluem Ranjan que se estende suas mos
ajudando a nmero inestimvel de autores em seus artigos e escreve algumas grandes artigos a si mesmo.
Rupam Das o mentor da Grasshopper Rede, fundador e CEO da Integrated ideias Consultancy Services, uma empresa de
consultoria de pesquisa na ndia. Ele tem sido parte de projectos em vrias tecnologias, incluindo Matlab, C #, Android, OpenCV,
Drupal, Omnet ++, C legado, vb, gcc, NS2, Arduino, framboesaPI. Off tarde, ele fez as pazes com o fato de que ele ama C # mais do
que qualquer outra coisa, mas ainda golpeado no estilo legado de codificao.
Rupam ama algoritmo e prefere processamento de imagem, Inteligncia Artificial e Engenharia Biomdica sobre outras tecnologias.
Ele frustrado com sua pobre escrita e habilidades "gramtica", mas feliz que codificao de polir essas frustraes.
Tipo de grupo: Organizao
118 membros

Voc pode tambm estar interessado em ...


o seu banco de dados pronto para a era do Big
Data?

Internet das coisas Arquitetura de Segurana

Fase 4: Guia completo para iniciantes para a


plataforma de hardware Arduino Para DIY

Bringing Up Arduino 101 marca Genuino 101 fora


os EUA no Ubuntu sob VMware

Fase 3: Vivo Estao de tempo com Arduino e


ThingSpeak

Ligar a Microsoft Azure com o NodeRED

Comentrios e discusses
2 mensagens foram postadas para este artigo Visita http://www.codeproject.com/Articles/834674/StageGettingStartedWith
ArdOSforArduino para postar e visualizar os comentrios sobre este artigo, ou clique aqui para obter uma viso de impresso com
mensagens.
Link permanente | Publicidade | Privacidade | Termos de Uso | Mvel
Web02 | 2.8.161026.1 | ltima atualizao novembro 2014 9

Selecione o idioma
Artigo de Copyright 2014 por Grasshopper.iics
Tudo o resto de Copyright CodeProject , 19992016