Introdução ao Arduino

(1)

Introdução ao Arduino

Bruno Silvério Costa

Arduino – O que é? (1)

• É um sistema embarcada de placa única que, juntamente com um conjunto de softwares e frameworks, tornam fácil o desenvolvimento de hardware;

• Definido pelos criadores como “Open Source Electronics Prototyping Plataform”, em

português “Plataforma Open Source de Prototipagem Eletrônica”.

(2)

Arduino – O que é? (2)

• Plataforma possui os seguintes componentes principais:

– Placa base (microcontrolada);

– IDE de desenvolvimento (juntamente com mecanismos para upload de código); – Framework Arduino;

– Shields de expansão (que implementam funções diversas controladas pela placa)

Prof. Bruno Silvério Costa

Preparando o

computador

• Primeiramente, é necessário obter a versão mais recente do software, disponível em

www.arduino.cc;

• Instalar o software, seguindo as instruções apresentadas em tela;

• Plugar a placa Arduino no computador; • Caso o driver da placa não seja localizado

automaticamente pelo sistema, indicar ao plug and play o caminho C:\Program Files

(3)

• Abra o software Arduino (atalho disponível no desktop);

• Vá ao Menu File->Examples->1.Basics e escolha o projeto Blink;

• Vá até o menu File->Upload para iniciar o processo de compilação e transferência para a placa;

• Obs.: Pode ocorrer um erro caso a placa não esteja instalada corretamente ou a porta serial virtual escolhida seja inválida.

Placa UNO rev 3

Pinos de I/O 0-1: Porta Serial 2-7: Digital/PWM Pinos de I/O 8-13: Digital 13: Led Programação ICP (Chips externos em circuito) uC atmega328p uC megaU2 Comunicação USB com o Computador Botão RESET Conector USB Conector de alimentação externa (0-30V) Pinos de I/O Pinos de Alimentação

(4)

AVR (1)

• Chamados de Computadores de Único Chip, os microcontroladores (C) são pequenos

computadores com seus respectivos

componentes necessários embutidos no mesmo chip;

• Por exemplo, estão incluídos no chip microcontrolador:

– Memória RAM (volátil);

– Memória EEPROM (persistente); – Unidades de I/O;

– Controladores de Barramento;

Microcontroladores

AVR (2)

• Os C AVR seguem a arquitetura de Harvard de processadores, ou seja, possuem memória de dados distinta da memória de programa; • Suas portas de I/O podem

ser programadas como entrada ou saída

(5)

• Para utilização de uma porta qualquer, é necessário indicar qual a porta será

trabalhada, qual a direção dos dados (entrada ou saída), realizar um input ou output;

• Exemplo:

– Porta utilizada: Port B

– Direção dos dados: DDRB = saída – Output: output(PortB, valor)

Conhecendo o

Framework (1)

• A programação do Arduino é realizada em linguagem C;

• Existem três sessões básicas disponibilizadas pelo framework no código para a programação:

– Área de inclusões / declarações: espaço no código destinado a declarações de variáveis e include de bibliotecas;

– Função de setup: ajuste das configurações básicas antes da execução propriamente dita:

– Função de loop: conjunto de códigos que são executados ininterruptamente.

(6)

Framework (2)

int led = 13; void setup() { pinMode(led, OUTPUT); } void loop() { digitalWrite(led, HIGH); delay(1000); digitalWrite(led, LOW); delay(1000); }

Área de inclusão/declaração Função de Setup Função de Loop

Conhecendo o

Framework (3)

• Compreendendo o código

int led = 13;//det. qual pino será usado

void setup() { //Função de Setup pinMode(led, OUTPUT);//Determiando que o pino 13

será de saída (OUTPUT) }

void loop() {//Função de loop

digitalWrite(led, HIGH);//Escrevendo o valor digital HIGH (1) no pino 13

delay(1000);//Aguardando 1000 ms

digitalWrite(led, LOW); //Escrevendo o valor digital LOW (0) no pino 13

delay(1000); //Aguardando 1000 ms }//retorna para loop

(7)

• O código feito em Arduino segue as diretrizes do Framework, mas é desenvolvido em

linguagem C;

• Dessa forma, muitos dos comandos C são válidos para o desenvolvimento em Arduino; • A seguir serão apresentados os comandos

iniciais válidos para o desenvolvimento;

Comandos Arduino (2)

• Não se utiliza a estrutura de programa principal do C. O próprio framework faz o preenchimento. • Comandos de seleção – If – Switch-case • Comandos de repetição – For – While – Do while

(8)

Comandos Arduino (3)

• Os pinos podem ser: de 1 a 13 e de A0 a A5, conforme apresenta a placa Arduino UNO; • Comandos de entrada de dados

– pinMode(pino, INPUT); – variavel=digitalRead(pino); – variavel=analogRead(pino);

• Comandos de saída de dados

– pinMode(pino, OUTPUT); – digitalWrite(pino, HIGH/LOW); – analogWrite(pino, VALOR[0-255]);

Comandos Arduino (4)

• Em alguns momentos, para viabilização da entrada de dados, é necessário configurar resistores de pull-up ou pull-down ligados aos pinos do microcontrolador;

(9)

• Para os microcontroladores AVR, isso pode ser feito diretamente em software;

• O pull-up pode ser feito com o comando:

– digitalWrite(pino, HIGH);

• O pull-down pode ser feito com o comando:

– digitalWrite(pino, LOW);

Comandos Arduino (6)

• Comando de temporização

– delay(tempo_ms);//aguarda um determinado tempo em ms

– millis();// retorna o tempo em ms desde o inicio do sistema

(10)

Comandos Arduino (7)

• Comando de temporização

– delay(tempo_ms);//aguarda um determinado tempo em ms

– millis();// retorna o tempo em ms desde o inicio do sistema

Comandos Arduino (8)

• Operações aritméticas

– Funcionam de forma análoga ao C

• A = B + C; • A = B – C; • A = B * C; • A = B / C; • A = B % C;

– As precedências inerentes às operações funcionam normalmente. É possível a

(11)

• Operações aritméticas

– Funcionam de forma análoga ao C

• A = B + C; • A = B – C; • A = B * C; • A = B / C; • A = B % C;

– As precedências inerentes às operações funcionam normalmente. É possível a

determinação externa através de parentização;

Exercício 1

• Modifique o código do Projeto Blink para que o led pisque de rápido a lento continuamente; • Obs.: adote o delay inicial de 10 ms;

(12)

Resposta Exercício 1

int led = 13; int count =0; int delay2 = 10; void setup() { pinMode(led, OUTPUT); } void loop() { for(int j=1;j<=15;j++) for(int i=0;i<5;i++) { digitalWrite(led, HIGH); delay(delay2*j); digitalWrite(led, LOW); delay(delay2*j); }

} Prof. Bruno Silvério Costa

PWM (1)

• PWM (Pulse With Modulation) é uma técnica que permite a geração de resultados

analógicos partindo de sinais digitais. A média da potência do sinal digital determina o sinal analógico médio;

• Muito utilizado na alteração de brilho de lâmpadas e leds, bem como no controle de motores CC;

(13)

• Utilizar uma saída digital para valores

analógicos, possibilita a conversão do sinal analógico em PWM;

• Por exemplo, pode-se construir um código para o led L de maneira que ele fique com um brilho pulsante. Para isso, basta gerar uma onda senoidal lenta;

• Esse código é visto a seguir: Prof. Bruno Silvério Costa

PWM (3)

int ledPin = 11;//led a pulsar float sinVal;//valor do seno

int ledVal;//valor a ser escrito no pino 11 void setup(){

pinMode(ledPin, OUTPUT);///pino 11 como saida }

void loop(){

for(int x=0; x<180; x++){//varia de 0º a 180º

sinVal=(sin(x*(3.14159/180)));//calcula valor do seno ledVal=int(sinVal*255);//valor entre 0 e 255

analogWrite(ledPin, ledVal);//escreve na porta pwm delay(20);//aguarda 20 ms

(14)

Display LCD (1)

• Existem diversos displays LCDs

comercializados. Dentre eles o mais comum é o 1602 (16 colunas x 2 linhas);

• O Arduino possui um driver apropriado para tramalhar com uma grande quantidade de displays, bastando configurar a instância do mesmo para o tipo correto a ser trabalhado; • Utilizaremos o display MGD1602B;

(15)

• É necessário definir inicialmente quais serão os pinos utilizados no Arduino como interface para o display;

Display LCD (4)

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);//pinos a serem usados pelo display no Arduino

int posicao=15; void setup() {

lcd.begin(16, 2);//Número de colunas x linhas do display }

void loop() {

lcd.setCursor(0, 0);//Aponta cursor para coluna 0 x linha 0

lcd.print(" ");//Apaga linha

lcd.setCursor(0, 1);//Aponta cursor para coluna 0 x linha 1

(16)

Display LCD (5)

for(int i=15;i>=0;i--)//Desliza a string "Display LCD" da direita para a esquerda no display

{

lcd.setCursor(i, 0);//Aponta cursor para coluna 0 x linha 1 delay(300);//Aguarda 300 ms

lcd.print("Display LCD ");//escreve no display }

for(int i=0;i<=15;i++)//Preenche progressivamente a linha inferior com "+"

{

lcd.setCursor(i, 1);//Aponta cursor para coluna 0 x linha 1 delay(100);//Aguarda 100 ms

lcd.print("*");//escreve no display }

delay(1000);//Aguarda 1000 ms para recomeçar }

Comunicação Serial

• Determinação da taxa de transmissão/recepção

– Serial.begin(9600);//valor em bps

• Envio de dados

– Seria.print(“String”);//envia uma string sem o caracter de return

– Serial.println(“String”); //envia uma string com o caracter de return

(17)

• Todo teclado funciona como uma grande matriz, onde as teclas correspondem a intersecções entre linhas e colunas;

Teclado Matricial(2)

• De forma análoga ao display, também existe um driver a ser utilizado com o teclado disponível no Arduino;

• Como o driver é genérico, também precisa ser configurado para trabalhar corretamente; • São utilizados 7 pinos, dos quais, três

(18)

Teclado Matricial(3)

#include <Keypad.h>

const byte ROWS = 4; //quatro linhas const byte COLS = 3; //três colunas

char keys[ROWS][COLS] = { //Define a aparência do teclado {'1','2','3'},

{'4','5','6'}, {'7','8','9'}, {'#','0','*'} };

byte rowPins[ROWS] = {A0, A1, A2, A3}; //conectar aos pinos das linhas do teclado

byte colPins[COLS] = {8, 7, 6}; //conectar aos pinos das colunas do teclado

Teclado Matricial(4)

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );//criando instância do teclado

void setup(){

Serial.begin(9600);//Ajustando taxa de comunicação serial }

void loop(){

char key = keypad.getKey();//lendo uma tecla

if (key != NO_KEY){//caso alguma tecla tenha sido apertada Serial.println(key);//envie qual foi a tecla para o computador }

(19)

• Placas de expansão/interface disponibilizadas para Arduino;

Sensores (1)

• Os sensores, de maneira geral, são componentes eletrônicos sensíveis a eventos da natureza;

• Existem sensores para uma grande gama de aplicações. Destacam-se:

– Sensores de luminosidade (LDRs, Fototransistores); – Sensores de som (capsulas de eletreto);

– Sensores de obstáculos e presença (IR, reflexivos, ultrasônicos, reed NA);

– Sensores de temperatura (RDT); – Sensores de umidade;

– Sensores de posição (bússola eletrônica, GPS);

(20)

Sensores (2)

• Todos os sensores apontados podem ser utilizados com o Arduino;

• Alguns depende de um conhecimento mais aprofundado de eletrônica;

• Existe uma grande quantidade de sensores disponível em SHIELDs Arduino;

Sensores (3)

• Sensor IR reflexivo

– Identifica obstáculos que reflitam a radiação IR; – Muito utilizado para dar ao Arduino uma capacidade

limitada de “visão”, já que é possível perceber o objeto, sem tocá-lo (pode-se utilizar ultrasom também);

(21)

• O sensor oferece uma saída digital, possibilitando seu tratamento facilitado no Arduino, conforme código a seguir:

int sensor=2;

digitalWrite(sensor, HIGH); //pull-up para sensor

pinMode(sensor, INPUT);//pino 2 como entrada

valor_sensor =

digitalRead(sensor);//leitura do valor do pino

Servo motores (1)

• Motores CC com circuitos associados, permitindo o controle da movimentação

angular do mesmo, além do ganho em torque; • Servo motores podem ser adaptados para

permitir apenas a indicação de sentido (horário, anti-horário) e o estado parado;

(22)

Servo motores (2)

• Para manipulação de servo motores no Arduino, é preciso apenas de um código bastante simples, além da utilização da biblioteca apropriada;

#include <Servo.h>

const int parado=90; const int horario=0; const int antihorario=180;

const int pino=2; Servo motor; motor.attach(pino); motor.write(horario); delay(5000); motor.write(horario); delay(5000); motor.write(parado); delay(5000);

Robô seguidor de linha

(1)

• Desloca-se sobre uma linha preta no solo, convergindo o centro do robô para cima da linha. Muito utilizado na indústria;

(23)

• Interligações:

Robô seguidor de linha

(3)

• Sensor IR reflexivo Comum

(-)

Saída FT Alimentação (+)

(24)

(4)

#include <Servo.h>

const int sensor_dir = 7; // sensor esquerdo const int sensor_esq = 8; // sensor esquerdo const int mDir=6;

const int mEsq=5; const int buzzer=3;

int status_sensor_esq=0;//monitor de mudança de status

int status_sensor_dir=0;//monitor de mudança de status

//Variáveis para acumulação dos valores dos sensores int s_esq=1, s_dir=1;

//Servo-motores Servo motorDir; Servo motorEsq;

Robô seguidor de linha

(5)

int posDir=0; int posEsq=0;

const int paradoE=86; const int paradoD=89; const int frenteE=0; const int frenteD=179; const int atrasE=180; const int atrasD=0;

void aviso_som(){

for (int i=0;i<1;i++){

digitalWrite(buzzer, HIGH); delay(10);

digitalWrite(buzzer, LOW); }

(25)

// Verificando resultado pela porta serial s_esq = digitalRead(sensor_esq); s_dir = digitalRead(sensor_dir); if(status_sensor_esq!=s_esq){ Serial.print("\nSensor Esquerdo=" ); Serial.print(s_esq); status_sensor_esq=s_esq; aviso_som(); return 1; } if(status_sensor_dir!=s_dir){ Serial.print("\nSensor Direito=" ); Serial.print(s_dir); status_sensor_dir=s_dir; aviso_som(); return 1; } return 0; }

Robô seguidor de linha

(7)

void agente_reativo_simples(Servo motor_dir, Servo motor_esq, int sEsq, int sDir){

int sE = digitalRead(sEsq); int sD = digitalRead(sDir); int temp=status(); if ((sE==1)&&(sD==1)){ motor_dir.write(paradoD); motor_esq.write(paradoE); }else if ((sE==0)&&(sD==0)){ motor_dir.write(frenteD); motor_esq.write(frenteE); }else if((sE==0)&&(sD==1)){ motor_dir.write(frenteD); motor_esq.write(paradoE); }else if((sE==1)&&(sD==0)){ motor_dir.write(paradoD); motor_esq.write(frenteE); }

(26)

(7)

void setup() {

// Inicializando a comunicação serial em 9600 bps: Serial.begin(9600);

digitalWrite(sensor_dir, HIGH); //pull-up para sensor direito digitalWrite(sensor_esq, HIGH); //pull-up para sensor esquerdo

motorDir.attach(mDir); motorEsq.attach(mEsq); }

void loop() {

agente_reativo_simples(motorDir, motorEsq, sensor_esq, sensor_dir); status();

}

Shield de rede (1)

• Permite a comunicação entre o Arduino e um computador, utilizando para isso o protocolo Ethernet. O Arduino implementa a pilha TCP/IP;

(27)

#include <Ethernet.h>

// Enter a MAC address and IP address for your controller below. // The IP address will be dependent on your local network: byte mac[] = {

0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; IPAddress ip(192,168,1,177);

EthernetServer server(80); void setup() {

// Open serial communications and wait for port to open: Serial.begin(9600);

while (!Serial) {

; // wait for serial port to connect. Needed for Leonardo only }

// start the Ethernet connection and the server: Ethernet.begin(mac, ip);

server.begin();

Serial.print("server is at "); Serial.println(Ethernet.localIP()); }

Shield de rede (3)

void loop() {

// listen for incoming clients

EthernetClient client = server.available(); if (client) {

Serial.println("new client");

// an http request ends with a blank line boolean currentLineIsBlank = true; while (client.connected()) { if (client.available()) { char c = client.read(); Serial.write(c);

// if you've gotten to the end of the line (received a newline // character) and the line is blank, the http request has ended, // so you can send a reply

if (c == '\n' && currentLineIsBlank) { // send a standard http response header client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html");

client.println("Connection: close"); // the connection will be closed after completion of the response

(28)

Shield de rede (4)

client.println("Refresh: 5"); // refresh the page automatically every 5 sec

client.println();

client.println("<!DOCTYPE HTML>"); client.println("<html>");

// output the value of each analog input pin for (int analogChannel = 0; analogChannel < 6;

analogChannel++) {

int sensorReading = analogRead(analogChannel); client.print("analog input "); client.print(analogChannel); client.print(" is "); client.print(sensorReading); client.println("<br />"); } client.println("</html>"); break; }

Shield de rede (5)

if (c == '\n') {

currentLineIsBlank = true; // you're starting a new line

}

else if (c != '\r') {

// you've gotten a character on the current line currentLineIsBlank = false;

} } }

delay(1); // give the web browser time to receive the data

client.stop(); // close the connection: Serial.println("client disonnected"); }

(29)