1

INSTITUTO FEDERAL DE EDUCAÇÃO DE SÃO PAULO – CAMPUS

CUBATÃO ROTEIRO DE AULAS DE MICROCONTROLADORES

DISCIPLINA MICROCONTROLADORES – APOSTILA 3

ARDUINO

Organizado por Prof. Walter Borysow

O QUE É O ARDUINO?

Arduino é uma plataforma física de computação de código aberto baseado numa simples

placa microcontroladora, e um ambiente de desenvolvimento para escrever o código para a

placa.

O Arduino pode ser usado para desenvolver objetos interativos, admitindo entradas de

uma série de sensores ou chaves, e controlando uma variedade de luzes, motores ou outras

saídas físicas. Projetos do Arduino podem ser independentes, ou podem se comunicar com

software rodando em seu computador (como Flash, Processing, MaxMSP.). Os circuitos

podem ser montados à mão ou comprados pré-montados; o software de programação de

código-livre pode ser baixado de graça.

(Fonte: O que é Arduino? | Projeto 39 - projeto39.wordpress.com/o-arduino )

A linguagem de programação do Arduino é essencialmente C/C++, compatível com DEV-

C++, conforme a “Lista de Instruções do Arduino” abaixo apresentada.

O núcleo microcontrolador é um AtmelAVR, nas suas várias versões megaAVR,

conforme por exemplo o datasheet abaixo do ATmega 168/328. Porém existem versões de

plataformas Arduino disponíveis no mercado baseadas em PIC.

2

3

PINAGEM:

Microcontrolador ATmega328

Voltagem operacional 5V

Voltagem de alimentação (recomendada) 7-12V

Voltagem de alimentação (limites) 6-20V

Pinos I/O digitais 14 (dos quais 6 podem ser saídas PWM)

Pinos de entrada analógica 6

Corrente contínua por pino I/O 40 mA

Corrente contínua para o pino 3.3V 50 mA

Memória flash 32 KB (2KB usados para o bootloader)

SRAM 2 KB

EEPROM 1 KB

Velocidade de clock 16 MHz

.

. .

4

Alimentação O Arduino pode ser alimentado pela conexão USB (cabo D) ou por qualquer fonte de

alimentação externa. A fonte de alimentação é selecionada automaticamente.

A alimentação externa (não-USB) pode ser tanto de uma fonte ou de uma bateria.

A fonte pode ser conectada com um plug de 2,1mm (centro positivo) no conector de

alimentação. Cabos vindos de uma bateria podem ser inseridos nos pinos Gnd (terra) e Vin

(entrada de voltagem) do conector de alimentação.

A placa pode operar com uma alimentação externa de 6 a 20 volts. Entretanto, se a

alimentação for inferior a 7 volts o pino 5V pode fornecer menos de 5 volts e a placa pode

ficar instável. Se a alimentação for superior a 12 volts o regulador de voltagem pode

super-aquecer e avariar a placa. A alimentação recomendada é de 7 a 12 volts.

Os pinos de alimentação são:

VIN. Entrada de alimentação para a placa Arduino quando uma fonte externa for utilizada.

Você pode fornecer alimentação por este pino ou, se usar o conector de alimentação,

acessar a alimentação por este pino.

I / O DIGITAL + PWM LED pino 13

Input ANALÓGICO

5

5V. A fonte de alimentação utilizada para o microcontrolador e para outros componentes

da placa. Pode ser proveniente do pino Vin através de um regulador on-board ou ser

fornecida pelo USB ou outra fonte de 5 volts (centro positivo).

3V3. Alimentação de 3,3 volts fornecida pelo chip FTDI. A corrente máxima é de 50 mA.

GND. Pino terra.

Memória

O ATmega328 tem 32 KB de memória flash para armazenar código (dos quais 2 KB são

utilizados pelo bootloader), além de 2 KB de SRAM e 1 KB of EEPROM (que pode ser

lida e escrita através da biblioteca EEPROM ).

Entrada e Saída Cada um dos 14 pinos digitais da placa Arduino pode ser usado como entrada ou saída

usando as funções de pinMode(),digitalWrite(), e digitalRead(). Eles operam com 5 volts.

Cada pino pode fornecer ou receber um máximo de 40 mA e tem um resistor pull-up

interno (desconectado por padrão) de 20-50 kOhms.

Além disso, alguns pinos têm funções especializadas:

Serial: 0 (RX) e 1 (TX). Usados para receber (RX) e transmitir (TX) dados seriais TTL.

Estes pinos são conectados aos pinos correspondentes do chip serial FTDI USB-to-TTL.

External Interrupts: 2 e3. Estes pinos podem ser configurados para disparar uma

interrupção por um baixo valor, uma elevação ou falling edge ou uma mudança de valor.

Veja a função attachInterrupt() para mais detalhes.

PWM: 3, 5, 6, 9, 10, e 11 marcados com #). Fornecem uma saída analógica PWM de 8-bit

com a função analogWrite().

SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estes pinos suportam comunicação SPI,

que embora compatível com o hardware, não está incluída na linguagem do Arduino.

LED: 13. Há um LED já montado e conectado ao pino digital 13. Quando o pino está no

valor HIGH, o LED acende; quando o valor está em LOW, ele apaga.

O Arduino tem 6 entradas analógicas e cada uma delas tem uma resolução de 10 bits (i.e.

1024 valores diferentes). Por padrão, elas medem de 0 a 5 volts, embora seja possível

mudar o limite superior usando o pino AREF e um pouco de código de baixo nível.

AREF. Referência de voltagem para entradas analógicas. Usados com analogReference().

Reset. Envie o valor LOW para resetar o microcontrolador. Tipicamente utilizados para

adicionar um botão de reset aos shields que bloqueiam o que há na placa.

Veja também mapeando entre os pinos do Arduino e as portas do ATmega 68 e referência

do ATmega328 (Arduino UNO).

6

Comunicação Com o Arduino a comunicação com um computador, com outro Arduino ou com outros

microcontroladores é muito simplificada. O ATmega328 permite comunicação serial no

padrão UART TTL (5V), que está disponível nos pinos digitais 0 (RX) e 1 (TX). Um chip

FTDI FT232RL na placa encaminha esta comunicação serial através do USB e os drives

FTDI (incluído no software do Arduino) fornece uma porta COM virtual para o software

no computador. O software Arduino inclui um monitor serial que permite que dados

simples de texto sejam enviados à placa Arduino. Os LEDs RX e TX da placa piscam

quando os dados estão sendo transferidos ao computador pelo chip FTDI e a conexão USB

(mas não quando há comunicação serial pelos pinos 0 e 1).

A biblioteca SoftwareSerial permite comunicação serial por quaisquer dos pinos digitais.

O ATmega328 também oferece suporte aos padrões de comunicação I2C (TWI) e SPI. O

software do Arduino inclui uma biblioteca Wire para simplificar o uso do bus I2C; veja

a documentação no site do Wiring para mais detalhes. Para usar a comunicação SPI veja a

folha de informações do ATmega328.

Programação

O Arduino pode ser programado com o software Arduino (download). Para mais detalhes

veja referência e tutoriais.

O ATmega328 no Arduino vem pré-gravado com um bootloader que permite enviar novos

programas sem o uso de um programador de hardware externo. Ele se comunica utilizando

o protocolo original STK500 (referência, C header files).

Você também pode programar o ATmega328 através do ICSP (In-Circuit Serial

Programming) header; veja instruções para mais detalhes.

Reset automático (Software)

Algumas versões anteriores do Arduino requerem um reset físico (pressionando o botão de

reset na placa) antes de carregar um sketch. O Arduino é projetado de modo a permitir que

isto seja feito através do software que esteja rodando no computador conectado. O

software Arduino usa esta característica para permitir carregar o programa simplesmente

pressionando o botão "upload" no ambiente Arduino.

Proteção contra sobrecorrente USB

O Arduino tem um polifusível resetável que protege a porta USB do seu computador

contra curto-circuito e sobrecorrente. Apesar da maioria dos computadores possuírem

proteção interna própria, o fusível proporciona uma proteção extra. Se mais de 500mA

foram aplicados na porta USB, o fusível irá automaticamente interromper a conexão até

que o curto ou a sobrecarga seja removida.

7

Fonte: www.poli.br/curso sobre Arduino

NOTA: Ao conectar a placa Arduino, é solicitada a configuração da conexão USB, que

deve ser o driver fornecido pelo fabricante da placa (arquivo .inf), e deve ser instalada na

COM3.

Exemplo de programa (pisca-led)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// início do código byte LED = 13; void setup () { pinMode ( LED, OUTPUT ); } void loop () { digitalWrite ( LED, HIGH ); delay ( 500 ); digitalWrite ( LED, LOW ); delay ( 500 ); } // fim do código

Na linha 2 do nosso código, nós escrevemos “byte LED = 13;”. Isto informa ao

compilador para separar um espaço de um byte na memória, atribuir o rótulo “LED” a este

espaço, e em seguida escrever o valor decimal 13 no mesmo.

8

Outro programa: button -led e pisca-led

/*

Button

Turns on and off a light emitting diode(LED) connected to digital

pin 13, when pressing a pushbutton attached to pin 2.

The circuit:

* LED attached from pin 13 to ground

* pushbutton attached to pin 2 from +5V

* 10K resistor attached to pin 2 from ground

* Note: on most Arduinos there is already an LED on the board attached to pin 13.

created 2005

by DojoDave <http://www.0j0.org>

modified 30 Aug 2011

by Tom Igoe

This example code is in the public domain:http://www.arduino.cc/en/Tutorial/Button

*/

// constants won't change. They're used here to set pin numbers:

const int buttonPin = 2; // the number of the pushbutton pin

const int ledPin12 = 12; // the number of the LED pin

// Pin 13 has an LED connected on most Arduino boards.

// give it a name:

int led = 13; // led da placa

// variables will change:

int buttonState = 0; // variable for reading the pushbutton status

void setup() {

// initialize the LED pin as an output:

pinMode(ledPin12, OUTPUT);

// initialize the pushbutton pin as an input:

pinMode(buttonPin, INPUT);

pinMode(led, OUTPUT); // LED da placa

}

// O PROGRAMA PRINCIPAL É UM LOOP

void loop(){

// pisca o led da placa.

digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)

delay(1000); // wait for a second

digitalWrite(led, LOW); // turn the LED off by making the voltage LOW

delay(2000);

// read the state of the pushbutton value:

buttonState = digitalRead(buttonPin);

// check if the pushbutton is pressed.

// if it is, the buttonState is HIGH:

if (buttonState == HIGH) {

// turn LED on:

digitalWrite(ledPin12, HIGH);

}

else {

// turn LED off:

digitalWrite(ledPin12, LOW);

}

}

9

O AMBIENTE DE DESENVOLVIMENTO ARDUINO

10

Conjunto de instruções C – Arduino (compatível com DEV-C++) Fonte: Tutorial Arduino.pdf - www.isegi.unl.pt/docentes/vlobo/escola.../Tutorial%20Arduino

Funções Base void setup() Descrição: Esta função apenas é executada uma vez e é normalmente utilizada para executar a inicialização de variáveis, a inicialização da utilização bibliotecas (não confundir com declaração de bibliotecas), a definição dos pinos (como input ou output), o início do uso de comunicação série, entre outros. Exemplo: (1) int botao=3; // Declaração de uma variável do tipo integer, com o nome “botao” inicializada com o valor “3”. (2) void setup() { (3) Serial.begin(9600); // Permite a inicialização da comunicação Série (4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT” (5) } (6) void loop(){ (7) (……….) (8) }

void loop() Descrição: Esta funç~o faz um “loop” sucessivo (como o próprio nome indica), ou seja, todos os comandos existentes no interior desta função são sucessivamente repetidos, o que pode permitir a leitura sucessiva de portas, a leitura sucessiva de parâmetros provenientes de sensores externos e actuar de acordo com as condições estabelecidas, entre muitas outras aplicações, bastando apenas ter criatividade. Exemplo: (1) int botao=3,val; // Declaração de uma variável do tipo integer, com o nome “botao” inicializada com o valor “3” e de uma variável do mesmo tipo com o nome “val” (2) void setup() { (3) Serial.begin(9600); // Permite a inicialização da comunicação Série (4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT” (5) pinMode(13,OUTPUT); // Permite definir o pino 13 como “OUTPUT” (6) } (7) void loop(){ (8) val=analogRead(botao); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val” (9) if(val>=500){ // Ciclo if que testa a condição – “val>=500” (maior ou igual a 500) (10) digitalWrite(13,HIGH); // Se a condição for verificada, é atribuído ao pino digital 13 a condição “HIGH” (5 V) (11) } (12) } Nota: As funções atrás descritas têm de ser necessariamente do tipo “void”, ou seja, não podem retornar qualquer valor depois da sua execução.

11

Resumindo As funções “void setup()”e “void loop()” são de carácter obrigatório, ou seja, mesmo que não necessária a sua utilização deverão constar no código utilizado. E apenas serão chamadas funções externas que constem na função “void loop()”. Exemplo: Declaração de variáveis globais; void setup(){ Instrução 1; Instrução 2; (….) } void loop(){ Instrução 6; Instrução 9; Função1(); (….) }

Ciclo If…….else Descrição: É utilizado para descrever uma condição, ou seja, quando uma variável for: igual, maior, menor ou diferente (de acordo com a declaração efectuada) que um determinado valor é executada uma determinada condição. Podem-se usar vários ciclos if….else encadeados, de forma a verificar diversas condições. Sintaxe: if(condição){ Instrução 1; Instrução 2; (…..) } else{ Instrução 3; Instrução 4; (…..) } A utilização da instrução else no ciclo if é dispensável, podendo apenas tomar a forma: if(condição){ Instrução 1; Instrução 2; (…..) } A condição acima referida pode ser descrita das seguintes formas:

.

12

Ciclo for Descrição: Esta instrução é utilizada quando se quer efectuar uma instrução ou conjunto de instruções um determinado número de vezes. Um exemplo possível de aplicação é o preenchimento de um vector (array), com dados provenientes de entradas analógicas. Sintaxe: for(inicialização; condição; incremento a efectuar){ Instrução 1; Instrução 2; (….) } A inicialização é apenas efectuada uma vez, no início do ciclo. Cada vez que o ciclo é efectuado a condição é testada. Caso a condição se verifique é efectuado o incremento, caso a condição não se verifique o ciclo termina a sua execução. A condição, referida anteriormente, é declarada à semelhança da condição utilizada no ciclo if. O exemplo abaixo mostra um exemplo de implementação do ciclo for, face às “regras” expostas acima. Exemplo: (1) int entrada_analogica=3,val,f[10],i; // Declaração de uma variável do tipo integer, com o nome “entrada_analogica” inicializada com o valor “3”, de variáveis do mesmo tipo com o nome “val” e “i” não inicializada, e de um vector “f[]” com 11 posições de memória do mesmo tipo (integer). (2) void setup() { (3) Serial.begin(9600); // Permite a inicialização da comunicação Série (4) pinMode(entrada_analogica,INPUT); // Permite definir o pino 3 como “INPUT” (5) } (6) void loop(){ (7) for(i=0;i<=10;i++){ // Ciclo for que é percorrido 11 vezes, “i<=10” com i a começar no valor “0” (8) val=analogRead(entrada_analogica); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val” Arduino (9) f[i]=val; //Atribui o valor da variável “val” ao vector “f[i]”, ou seja, permite preencher o vector com 11 valores do pino analógico 3

(10) } (11) }

Ciclo switch / case Descrição: É normalmente utilizada para declarar uma lista de casos possíveis, para uma determinada variável, sendo verificado cada caso e é apenas executado quando a variável respeitar a condição declarada. Sintaxe: switch(variável){ case 1: Instrução a executar quando variável for 1 (variável == 1) break; case 2: Instrução a executar quando variável for 2 (variável == 2) break; (…..) default: Conjunto de instruções a executar se nenhuma das condições for verificada. A utilização desta condição é opcional. break; } É necess|rio utilizar a instruç~o “break” caso se pretenda sair do ciclo após a condição ser verificada. Caso contrário, vai continuar a ser executado o ciclo a partir da condição verificada. Exemplo: (1) int entrada_analogica=3,val; // Declaração de uma variável do tipo integer, com o nome “entrada_analogica” inicializada com o valor “3” e de uma variável do mesmo tipo com o nome “val”

13

(2) void setup() { (3) Serial.begin(9600); // Permite a inicialização da comunicação Série (4) pinMode(entrada_analogica,INPUT); // Permite definir o pino 3 como “INPUT” (5) pinMode(13,OUTPUT); // Permite definir o pino 13 como “OUTPUT” (6) } (7) void loop(){ (8) val=analogRead(entrada_analogica); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val” (9) switch(val){ // Ciclo switch, sendo “val” a variável a “testar” (10)case 500: // condição de “teste”, se val == 500 (igual a 500) (11) digitalWrite(13,HIGH); // Se a condição da linha 10 se verificar, esta instrução é executada (12) break; // Instrução que permite terminar o ciclo (13) default: // Se nenhuma das condições se verificar (o seu uso é opcional) (14) digitalWrite(13,LOW); // Instrução que é executada se a condição do ciclo switch não se verificar (15) } (16) }

Ciclo while Descrição: É normalmente utilizado para efectuar um “loop” sucessivo até uma determinada condição se verificar. Caso essa condição se deixe de verificar o ciclo termina. Em casos em que a condição não se verifica, estamos perante um ciclo infinito (semelhante { funç~o “void loop()”). Sintaxe: while(condição){ Instrução 1; Instrução 2; (…..) } É necessário fazer com que a condição se torne falsa, caso se queira finalizar o ciclo para executar outras instruções. Pois caso contrário o ciclo vai ser executado indefinidamente. Exemplo: (1) int entrada_analogica=3,val,i=0,f[10]; // Declaração de uma variável do tipo integer, com o nome “entrada_analogica” inicializada com o valor “3”, de variáveis do mesmo tipo com o nome “val” não inicializada, “i” inicializada com o valor “0” e de um vector “f[]” com 11 posições de memória do mesmo tipo (integer). (2) void setup() { (3) Serial.begin(9600); // Permite a inicialização da comunicação Série (4) pinMode(entrada_analogica,INPUT); // Permite definir o pino 3 como “INPUT” (5) } (6) void loop(){ (7) while(i<=10){ // ciclo while, com a condição “i<=10” (8) val=analogRead(entrada_analogica); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val” (9) f[i]=val; //Atribui o valor da variável “val” ao vector “f[i]”, ou seja, permite preencher o vector com valores provenientes do pino analógico 3

(10) i++; // Incremento do valor de “i” inicialmente a zero, instrução semelhante a “i=i+1” (11) } (12) }

14

Ciclo do….while Descrição: Bastante semelhante ao ciclo “while”, sendo a principal diferença o facto da condição ser testada apenas no fim do ciclo e não no início do ciclo. Ou seja, mesmo que a condição seja falsa o ciclo vai ser sempre executado uma vez. Sintaxe: do{ Instrução 1; Instrução 2; (…..) } while(condição); Exemplo: (1) int entrada_analogica=3,val,i=0,f[10]; // Declaração de uma variável do tipo integer, com o nome “entrada_analogica” inicializada com o valor “3”, de uma variável do mesmo tipo com o nome “val” não inicializada, “i” inicializada com o valor “0” e de um vector “f[]” com 11 posições de memória do mesmo tipo (integer). (2) void setup() { (3) Serial.begin(9600); // Permite a inicialização da comunicação Série (4) pinMode(entrada_analogica,INPUT); // Permite definir o pino 3 como “INPUT” (5) } (6) void loop(){ (7) do{ // Permite definir o inicio do ciclo (8) val=analogRead(entrada_analogica); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val” (9) f[i]=val: //Atribui o valor da variável “val” ao vector “f[i]”, ou seja, permite preencher o vector com valores provenientes do pino analógico 3

(10) i++; // Incremento do valor de “i” inicialmente a zero, instrução semelhante a “i=i+1” (11)} (12) while(i<=10); // Se a condição se verificar repete o ciclo, caso não se verifique o ciclo termina (13) }

Tipos de variáveis disponíveis Variável do Tipo Boolean Descrição: Uma variável deste tipo apenas pode tomar dois valores distintos - “true” ou “false”. Esta vari|vel reserva 1 Byte de memória para a sua utilização. Sintaxe: boolean vari|vel = “valor”; Quando é referido acima a “valor”, est|-se a referir a “true” ou “false”.

15

Variável do tipo byte Descrição: Armazena um número do tipo unsigned, compreendido entre 0 e 255. Ocupando, como o próprio nome indica, 1 Byte na memória (8 Bits). Sintaxe: byte variável = valor; Exemplos: byte exemplo = B0000001; // Armazena o valor em binário que corresponde ao valor “1” em decimal byte exemplo_2 = 1; // Semelhante ao exemplo anterior, mas armazenando o valor directamente em decimal

Variável do tipo int vs unsigned int Descrição: Este tipo de variável (integer) permite guardar um valor inteiro de 2 bytes, ou seja, um número inteiro com valor compreendido entre -32768 e 32767. Podemos também declarar a variável int, como sendo do tipo unsigned. Ao declarar uma variável do tipo unsigned, deixamos de ter parte negativa passando a poder armazenar valores compreendidos entre 0 e 65535. Sintaxe: int variável = valor; unsigned int variável = valor; Exemplos: int exemplo = -150; // Declara um variável do tipo “int” e atribui-lhe o valor de “-150” unsigned int exemplo_1 = 65000; // Declara um variável do tipo “unsigned int” e atribui-lhe o valor de “65000”

Input/Output - digital pinMode() Descrição: Ao recorrer a esta instrução, é possível configurar o modo de comportamento de um determinado pino. Possibilitando assim defini-lo como input ou output, esta definição normalmente é efectuada recorrendo à função “void setup()”. Sintaxe: pinMode(Número do pino, Modo); O “Modo” acima descrito pode ser definido da seguinte forma:

INPUT”

OUTPUT” Exemplo: (1) int botao=3,val; // Declaração de uma variável do tipo integer, com o nome “botao” inicializada com o valor “3” e de uma variável do mesmo tipo com o nome “val” não inicializada com nenhum valor (2) void setup() { (3) Serial.begin(9600); // Permite a inicialização da comunicação Série (4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT” (5) pinMode(13,OUTPUT); // Permite definir o pino 13 como “OUTPUT” (6) } (7) void loop(){ (8) val=analogRead(botao); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val” (9) if(val>=500) // Ciclo if que testa a condição – “val>=500” (maior ou igual a 500) (10) digitalWrite(13,HIGH); // Se a condição for verificada, é atribuído ao pino digital 13 a condição “HIGH” (5 V) (11) } (12) }

16

digitalWrite() Descrição: Possibilita, nos pinos configurados como output através da instrução “pinMode”, estabelecer a saída dos respectivos pinos com o valor lógico 1 (HIGH – 5 V) ou com o valor lógico 0 (LOW – 0V) Sintaxe: digitalWrite(Número do pino, Modo); O “Modo” acima descrito, pode ser definido como:

HIGH”

LOW” Exemplo: (1) int botao=3,val; // Declaração de uma variável do tipo integer, com o nome “botao” inicializada com o valor “3” e de uma variável do mesmo tipo com o nome “val” não inicializada com nenhum valor (2) void setup() { (3) Serial.begin(9600); // Permite a inicialização da comunicação Série (4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT” (5) pinMode(13,OUTPUT); // Permite definir o pino 13 como “OUTPUT” (6) } (7) void loop(){ (8) val=analogRead(botao); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val” (9) if(val>=500) // Ciclo if que testa a condição – “val>=500” (maior ou igual a 500) (10) digitalWrite(13,HIGH); // Se a condição for verificada, é atribuído ao pino digital 13 a condição “HIGH” (5 V) (11) } (12) }

digitalRead() Descrição: Possibilita a leitura de uma entrada digital específica, retornando um valor no formato integer (int). Se obtivermos um valor de retorno de “1”, estamos perante uma leitura do tipo “HIGH” (valor lógico 1). Se tal não se verificar, e tivermos um valor de retorno igual a “0”, estamos perante uma leitura do tipo “LOW” (valor lógico 0). Sintaxe: Variável do tipo integer = digitalRead(Número do pino); Exemplo: (1) int botao=3,val; // Declaração de uma variável do tipo integer, com o nome “botao” inicializada com o valor “3” e de uma variável do mesmo tipo com o nome “val” não inicializada com nenhum valor (2) void setup() { (3) Serial.begin(9600); // Permite a inicialização da comunicação Série (4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT” (5) pinMode(13,OUTPUT); // Permite definir o pino 13 como “OUTPUT” (6) } (7) void loop(){ (8) val=digitalRead(botao); // Permite a leitura do valor do pino 3 digital atribuindo o seu valor à variável “val” (9) if(val==1) // Ciclo if que testa a condição – “val>=500” (maior ou igual a 500) (10) digitalWrite(13,HIGH); // Se a condição for verificada, é atribuído ao pino digital 13 a condição “HIGH” (5 V) (11) } (12) else{ // Caso a condição do ciclo if não se verifique (13) digitalWrite(13,LOW); // Se a condição não for verificada, é atribuído ao pino digital 13 a condição “LOW” (0 V) (14) } (15) }

17

Input/Output - analógico

analogRead() Descrição: Possibilita a leitura do valor analógico do pino especificado, com um conversor A/D possuindo uma

resolução de 10 bits. O que leva a que um valor compreendido entre 0 e 5 V, esteja compreendido entre os

valores inteiros (int) 0 e 1023 (2,5 V = 512).

Sintaxe: Variável do tipo integer = analogRead(Número do pino); Obs. : Pinos analógicos são automaticamente definidos como entradas (A0 até A5) Exemplo: (1) int botao=3,val; // Declaração de uma variável do tipo integer, com o nome “botao” inicializada com o valor “3” e de uma variável do mesmo tipo com o nome “val” não inicializada com nenhum valor (2) void setup() { (3) Serial.begin(9600); // Permite a inicialização da comunicação Série (4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT” (6) } (7) void loop(){ (8) val=analogRead(botao); // Permite a leitura analógica do valor do pino 3analógico atribuindo o seu valor à variável “val” (9) if(val>=500) // Ciclo if que testa a condição – “val>=500” (maior ou igual a 50 0 = 50% do sinal analógico) (10) digitalWrite(13,HIGH); // Se a condição for verificada, é atribuído ao pino digital 13 a condição “HIGH” (5 V) (11) } (12) }

analogWrite() - PWM Descrição: Possibilita a utilização dos pinos PWM (Pulse Width Modulation) da placa Arduino. O sinal PWM mantém-se até ser modificado através de uma outra instrução que afecte esse pino, a frequência do sinal PWM criado é de ≅490 . Sintaxe: analogWrite(Número do pino, valor); Obs.= pinos marcados com ‘#’ = 3,5,6,9,10,11.

O “valor” referido anteriormente varia entre 0 (sempre desligado), até ao valor 255 (que representa um sinal de 5

V constante). Exemplo: (1) int botao=3,val; // Declaração de uma variável do tipo integer, com o nome “botao” analógico inicializada com o valor de pino “3” e de uma variável do mesmo tipo com o nome “val” não inicializada com nenhum valor, para

guardar o valor analógico. (2) void setup() { (3) Serial.begin(9600); // Permite a inicialização da comunicação Série (4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT” (6) } (7) void loop(){ (8) val=analogRead(botao); // Permite a leitura analógica do valor do pino 3 analógico atribuindo o seu valor à variável “val” (9) if(val>=500) // Ciclo if que testa a condição – “val>=500” (maior ou igual a 500) (10) analogWrite(9,255); // Instrução com a mesma função que “digitalWrite(9,HIGH)” (11) } (12) else{ (13) analogWrite(9,0); // Instrução com a mesma função que “digitalWrite(9,LOW)” (14) } (15) }

18

PWM A capacidade de utilizar Pulse Width Modulation (PWM), é muito importante, pois permite obter uma tensão analógica a partir de um sinal digital, ou seja, de um sinal que apenas pode assumir o estado lógico 0 (0V) ou 1 (5

V). O conceito de PWM é utilizado para referir sinal que possua uma frequência constante e um “duty cicle” variável. Se for necessário modificar a frequência, utilizar o comando delay(ms). O duty cicle é definido pelo valor analogWrite(9,0) = pino PWM #9, duty cicle = 0, isto é, saída zero, até 255, duty cicle máximo, 100%, tensão constante 5 V. Ex.= analogWrite(9,128) = duty cycle 50%. Ref.: livro Primeiros passos com o Arduino, de Massimo Banzi EXEMPLO DE CONTROLE DE ACENDIMENTO DO LED NO PINO 13 (5) pinMode(13,OUTPUT); // Permite definir o pino 13 como “OUTPUT” (6) } (7) void loop(){ (8) val=analogRead(botao); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val” (9) if(val>=500) // Ciclo if que testa a condição – “val>=500” (maior ou igual a 500) (10) digitalWrite(13,HIGH); // Se a condição for verificada, é atribuído ao pino digital 13 a condição “HIGH” (5 V) (12) else (13) digitalWrite(13,LOW); // Se a condição não for verificada, é atribuído ao pino digital 13 a condição “LOW” (0 V) (14) }

Tempo delay (milisegundos) Descrição: Possibilita efectuar uma pausa ao programa em execução, por uma quantidade de milisegundos especificada. Útil para manter um estado durante uma certa quantidade de tempo. Sintaxe: delay(tempo que deseja efectuar a pausa – ms); Exemplo: (1) int led_pin=13; // Declaração de uma variável do tipo integer com o nome “led_pin”, sendo-lhe atribuída o valor “13” (2) void setup() { (4) pinMode(led_pin,OUTPUT); // Permite definir o pino 13 como “OUTPUT” (5) Serial.begin(9600); // Permite a inicialização da comunicação Série (6) } (7) void loop(){ (8) digitalWrite(led_pin,HIGH); // É atribuído ao pino digital 13 a condição “HIGH” (5 V) (9) delay(200); // É efectuado um delay de 200 ms, antes de efectuar a próxima instrução

.

19

(10) digitalWrite(led_pin,LOW); // É atribuído ao pino digital 13 a condição “LOW” (0 V) (11) delay(600); // É efectuado um delay de 600 ms, antes de efectuar a próxima instrução, neste caso a função “void loop()” recomeça (12) }

delayMicroseconds (microsegundos) Descrição: Possibilita efectuar uma pausa ao programa em execução, por uma quantidade de microsegundos especificada. Sintaxe:

delayMicroseconds(tempo que deseja efectuar a pausa – s); Exemplo: (1) int led_pin=13; // Declaração de uma variável do tipo integer com o nome “led_pin”, sendo-lhe atribuída o valor “13” (2) void setup() { (4) pinMode(led_pin,OUTPUT); // Permite definir o pino 13 como “OUTPUT” (5) Serial.begin(9600); // Permite a inicialização da comunicação Série (6) } (7) void loop(){ (8) digitalWrite(led_pin,HIGH); // É atribuído ao pino digital 13 a condição “HIGH” (5 V)

(9) delayMicroseconds(200); // É efectuado um delay de 200 s, antes de efectuar a próxima instrução (10) digitalWrite(led_pin,LOW); // É atribuído ao pino digital 13 a condição “LOW” (0 V)

(11) delayMicroseconds(600); // É efectuado um delay de 600 s, antes de efectuar a próxima instrução, neste caso a função “void loop()” recomeça (12) }