P3R3 - Robô na Escolap3r3.com/wp-content/uploads/2015/08/Oficina-Arduino-e-Programacao.pdf · Arduino é uma plataforma de prototipagem eletrônica aberta baseada na flexibilidade,

Robô na Escola - UFPA – 2015 Autor: Yuri Chaves Freimann

1

2015

Tutorial

Arduino e

Programação

P3R3 - Robô na Escola


2

Coordenador

Marco José de Sousa

Colaboradora - Diretora Escola Estadual Luiz Nunes Direito

Maria de Belém Miranda de Souza

Bolsista - LAPS Laboratório de Processamento de Sinais

Adalbery Rodrigues Castro

Bolsista – GVA Grupo de Vibrações e Acústica

Gustavo da Silva Vieira de Melo

Bolsista – Graduando Engenharia da Computação

Alisson Ricardo da Silva Souza

Equipe de Desenvolvimento


Alexandre Van Der Vem

Edson de Jesus Rodrigues Gonçalves

José Heitor Linhares Mariano

Yuri Chaves Freimann

Colaboradores

Arthur William da Silva Ramos

Ítalo de Cassio do Nascimento Sousa

Wederson Medeiros Silva

Projeto Gráfico


Edson de Jesus Rodrigues Gonçalves

Realização:

Apoio:


3

Sumário

1 Introdução.................................................................................... 4

2 Histórico sobre Computadores..................................................... 4

3 Definição de Arduino................................................................... 6

3.1 Hardware de Arduino.................................................... 6

3.2 Programação (histórico)................................................. 7

3.3 Programação Arduino.................................................... 8

3.4 Exemplos de Projetos com Arduino............................... 10

3.4.1 Acendendo e Apagando o Led....................... 10

3.4.2 Dados na porta serial....................................... 11

3.4.3 Acendendo e apagando um led com PWM..... 11

3.4.4 Utilizando o sensor de linha............................ 12

3.4.5 Utilizando o ultrassom..................................... 13

3.4.6 Utilizando motor de corrente continua............ 14

3.4.7 Utilizando servo motor.................................... 15

4 Código exemplo do Robô............................................................. 15

5 Bibliografia................................................................................... 17


4

1. Introdução

O surgimento do computador vem de muito tempo atrás. Acerca de dois mil anos

atrás os gregos tinham equipamentos que podiam ser considerados como computadores

de hoje em dia, é claro que esses equipamentos não eram exatamente iguais aos

computadores de hoje, mas eles tinham uma coisa em comum: processavam

informações.

Naquela época não havia se descoberto a eletricidade, ou seja, esses equipamentos

funcionavam mecanicamente, com algum mecanismo que processava informações. A

partir da descoberta da eletricidade, é que surgiram os computadores eletrônicos que

conhecemos até hoje. O primeiro computador eletrônico era muito grande, mas depois

de um tempo, a eletrônica dentro do computador ficou menor e os computadores

ficaram menores.

Todo computador eletrônico tem a parte de software e a parte do hardware. O

software é responsável pelos programas do computador. Já o hardware é a parte física

do computador, ou seja, a eletrônica. Os programas são um conjunto de instruções feitas

pelo programador por uma linguagem de programação para que a máquina processe.

2. Histórico sobre Computadores

Desde a Grécia antiga, já existia computadores, como por exemplo, o mecanismo

Antikythera, que foi encontrado em 1901 por mergulhadores em um navio romano

naufragado na costa da Grécia. Esse computador provavelmente tem cerca de 2 mil

anos, é do tamanho de um notebook e possui diversas engrenagens dentro dele

conforme mostra a Figura 1. Ele servia para prever eclipses solares e calcular as datas

de olimpíadas na Grécia antiga.

Figura 1 – Mecanismo Antikythera. BBC

Durante a segunda Guerra mundial, muitas maquinas estavam sendo criadas para

quebrar o código das mensagens inimigas. Dentre essas maquinas a que se destacou foi

de Alan Turing. Alan Turing criou a famosa teoria de “Maquina de Turing”, que diz que

através de um numero finito de operações, é possível resolver problemas

computacionais de diversas ordens. A maquina de Turing foi implementada através da

criação do computador Colossus, em 1946 conforme mostra a Figura 2.


5

Figura 2 – Colossus. Wikipedia

A primeira geração de computadores aconteceu de 1946 até 1959 e essa geração

foi marcada pelas válvulas eletrônicas, os computadores eram muito grandes,

consumiam muita energia elétrica e geravam muito calor. Esses computadores tinham

capacidade de processamento muito limitada, necessitavam de muitas manutenções e

eram usados somente para cálculos.

Em 1946, foi criado pelos cientistas norte-americanos John Eckert e John

Mauchly, o primeiro computador eletrônico digital de proposito geral do mundo, o

ENIAC (Eletronic Numerical Integrator and Computer ou Computador e Integrador

Numérico Eletrônico). O ENIAC pesava 30 toneladas, tinha 140 metros quadrados,

mais de 18 mil válvulas e gastava 140 mil Watts. Sua capacidade de processamento era

muito mais rápida que os computadores da época, ele era capaz de realizar 5 mil adições

por segundo. Era um computador decimal com 20 acumuladores como memoria e podia

armazenar um número decimal de até 10 dígitos. Operou até 1955. O ENIAC pode ser

visto na Figura 3.

Figura 3 – ENIAC (Eletronic Numerical Integrator and Computer).

A segunda geração de computadores aconteceu de 1959 até 1964 e essa geração

foi marcada pelos transistores, os computadores eram menores, mais rápidos,

consumiam menos energia elétrica e geravam menos calor comparado com os da

primeira geração. Esses computadores tinham vários transistores instalados em placas


6

de circuito impresso, eliminando a necessidade de muitos fios elétricos como na

primeira geração. Essa geração deu inicio aos microcomputadores.

A terceira geração de computadores aconteceu de 1964 até 1970 e essa geração

foi marcada pelos circuitos integrados, os computadores eram menores e mais rápidos,

comparado com os da segunda geração. Esses computadores tinham vários circuitos

integrados, que permitia interligar diferentes hardwares. Os circuitos integrados são

pequenos chips de silício que contém milhares transistores. Essa geração deu inicio a

microeletrônica.

A quarta geração de computadores começou em 1970 e vai até hoje em dia, essa

geração é marcada pelos circuitos integrados em larga escala, os computadores são

menores, mais rápidos, tem mais transistores e mais circuitos integrados, comparado

com os da terceira geração. Essa geração é marcada pelo advento dos

microprocessadores e computadores pessoais.

Em 1976, foi lançado nos EUA por Steve Jobs o que pode ser considerado o

primeiro computador pessoal com interface gráfica, o Apple I. O Apple I era uma placa

de circuito impresso com vários chips. Para formar um computador pessoal completo

com interface gráfica era necessário colocar gabinete, fonte e monitor nele. O Apple I,

já com o gabinete e teclado montados, pode ser visto na Figura 4.

Figura 4 – Apple I com gabinete e teclado montado.

3. Definição de Arduino

Arduino é uma plataforma de prototipagem eletrônica aberta baseada na

flexibilidade, facilidade de usar hardware e software. É destinado a artistas, designers,

inventores e qualquer pessoa interessada em criar objetos ou ambientes interativos.

Existem diversas placas Arduino, a que será trabalhada nesta apostila é o Arduino Uno

conforme mostra a Figura 5.


7

Figura 5 – Arduino Uno. Arduino

3.1 - O hardware do Arduino

Figura 6 – O Hardware do Arduino Uno. Robotizando

Existem 3 maneiras de alimentar com tensão o Arduino Uno, pelo cabo USB,

por uma fonte de alimentação externa ou pelos pinos de alimentação do Arduino. Para

se passar os programas do computador para o Arduino, é necessário que o computador

esteja conectado com Arduino através do cabo USB. Com isso, o computador passa

também a alimenta o Arduino. Com uma fonte de tensão externa AC-DC ou uma

bateria, é possível conectar na entrada do Arduino, ou nos pinos de alimentação Vin e

Gnd. É recomendável que a fonte de tensão externa seja de no mínimo 7V até no

máximo 12V.

Os outros pinos de alimentação servem para alimentar um circuito elétrico, os 3

Gnd servem como terra do circuito, o 5V fornece uma tensão de 5V e o de 3V3, um

tensão de 3,3V. A CPU do Arduino Uno, é o microprocessador Atmel ATmega328, os

programas são armazenados na memoria flash do microprocessador que tem 32KB. A

memoria flash, é uma memoria volátil, ou seja, os dados gravados podem muito bem ser

substituídos. O microprocessador então processa os programas.

O Arduino Uno possui 14 portas digitais e 6 portas analógicas. Essas 14 portas

digitais podem funcionar como entrada ou saída digital. O pino digital tem dois estados


8

que são: 0 que é sem tensão e 1 que é com tensão. Não ha como saber o valor exato

desta tensão. Já as 6 portas analógicas podem funcionar tanto como entradas analógicas

como também entrada ou saída digital. Os pinos 3, 5, 6, 9, 10 e 11 são PWM, que

significa saída analógica, muito usada para controlar velocidades de motores. O pino

analógico tem vários estados que dependem do valor exato da tensão. Os pinos 0 e 1,

são os pinos da porta serial, o 0 RX é usado para receber dados, já o 1 TX, para

transmitir dados.

Existem placas de circuito impresso que são conectados no Arduino Uno, para

aumentar suas funções. Essas placas são chamadas de Shields que significa escudos.

Em comparação com o computador de hoje em dia, um Shield seria uma impressora. O

Arduino Motor Shield como mostra a figura 7, é um shield que serve para controlar

motores.

Figura 7 – Arduino Motor Shield. Arduino

3.2 - Programação (histórico)

O surgimento da programação vem de muito tempo atrás. As pessoas fazem suas

atividades de acordo com programas que o computador executa. Os programas são

instruções em uma linguagem que o computador entenda. Essas instruções são feitas

primeiro em português, que é o algoritmo, para depois ser escrito em uma linguagem de

programação. Um exemplo de algoritmo pode ser visto abaixo:

início

função setup()

início

pino 13saida

fim

função loop()

início

pino 131

espera 1 segundo

pino 130

espera 1 segundo

fim

fim.

3.3 - A programação do Arduino

A programação do Arduino é feita em um ambiente de desenvolvimento

integrado de software (IDE). Esse ambiente é um programa onde se faz os códigos e


9

transfere para uma placa Arduino. Um código de Arduino contém varias instruções que

são em inglês. A placa Arduino segue essas instruções. Essas instruções são chamadas

de funções.

Todo programa de Arduino tem duas funções, uma que é a void setup() e a

outra que é a void loop(). A void setup() é uma função que é executada apenas quando

começa o programa e serve para configurar os pinos da placa e estabelecer a

comunicação serial com um computador. A outra void loop() é uma função que executa

os comandos que são colocados nela infinitamente.

A função pinMode(numero do pino, Input/Output) é colocada na void setup()

e serve para configurar um pino como sendo saída ou entrada. A função

digitalWrite(numero do pino, 0/1) é colocada na void loop() e serve para escrever em

um pino digital 0 ou 1(0V ou 5V). A função digitalRead(numero do pino) é colocada

na void loop() e serve para ler em um pino digital 0 ou 1(0V ou 5V).

A função analogWrite(numero do pino, 0 a 255) é colocada na void loop() e

serve para escrever em um pino analógico ou PWM um valor entre 0 até 255(0V até

5V). A função analogRead(numero do pino) é colocada na void loop() e serve para ler

em um pino analógico um valor entre 0 até 255(0V até 5V). As variáveis podem ser int

que é um inteiro, long que é um inteiro maior, byte que é um inteiro entre 0 e 255 e

float que é um fracionário.

Existem as funções de tempo que são: delay(ms), delayMicroseconds(us) e

millis(). A delay(ms) para o programa por um período de milissegundos. A

delayMicroseconds(us) para o programa por um período de uns microssegundos. Por

ultimo a millis() guarda o tempo em milissegundos desde que a placa Arduino foi

ligada.

Para saber quanto tempo um pino digital passa de um estado para outro através

da função pulseIn(pino, valor, espera), onde os parâmetros são pino que é o numero

do pino, valor do pulso que será medido e espera(opcional) que determina apos

microssegundos a função vai executar. Essa função retorna o tempo em microssegundos

que um determinado pino digital muda de 0 para 1 ou vice-versa.

A comunicação serial é feita através dos comandos: Serial.begin(taxa),

Serial.end(), Serial.available(), Serial.read(), Serial.print(valor, formato) e

Serial.println(valor, formato). A Serial.begin(taxa) é colocada na void setup() e serve

para estabelecer a comunicação serial e o parâmetro taxa significa a velocidade com que

as informações serão transmitidas. A Serial.end() é colocada na void setup() e serve

para desabilitar a comunicação serial. A Serial.available() é colocada na void loop() e

serve para saber se tem alguma coisa na porta serial. A Serial.read() é colocada na void

loop() e serve para ler alguma coisa na porta serial. A Serial.print(valor, formato) é

colocada na void loop() e serve para imprimir alguma coisa na porta serial. A

Serial.println(valor, formato) faz a mesma coisa só que pulando uma linha.

É possível instalar bibliotecas no ambiente de desenvolvimento integrado de

software. Existem diversas bibliotecas disponíveis na internet. Tudo que se precisa fazer

é colocar a biblioteca em uma pasta chamada libraries. Com uma biblioteca é possível

colocar mais funções em um programa. No programa é preciso incluir a biblioteca com

a função #include<nomedabiblioteca>.


10

Em um programa Arduino existem diversas funções logicas como: se, senão,

escolha, caso, enquanto, faça e para. Essas funções servem para dar instruções ao

Arduino. Elas são escritas em inglês no programa e são: if, else, switch, case, while, do

e for.

3.4 - Exemplos de projetos com o Arduino

Acendendo e apagando o led da porta digital 13 que é o led L no Arduino Uno.

Figura 8 – Código Exemplo.

Neste código, primeiro é definida uma variável do tipo inteira que é led e recebe

o valor 13 que é o numero do pino. Na função void setup(), essa variável é colocada

como saída. Por ultimo na função void loop() o pino é colocado em estado alto, espera 1

segundo, é colocado em estado baixo, espera mais 1 segundo e começa tudo novamente.


11

Recebendo e escrevendo dados na porta serial

Figura 9 – Código Exemplo.

Neste código, primeiro é definido uma variável do tipo inteira que é

incomingByte e recebe o valor 0. Na função void setup(), é iniciada a porta serial. Por

ultimo na função void loop(), se tiver alguma coisa na porta serial a variável

incomingByte vai receber o que tem lá e será impresso o que tem nessa variável na

porta serial.

Acendendo e apagando um led com PWM.

Figura 10 - Código Exemplo.


12

Neste código, primeiro é definida uma variável do tipo inteira que é i e recebe o

valor 0, depois é colocado a função void ledOn(). Na função void setup(), o pino digital

10 é colocado como saída. Na função void ledOn() o pino digital irá receber o valor de

i. Por ultimo na função void loop() tem um laço for para a variável i que vai de 0 a 255 e

chama a função ledOn() e outro laço for para a variável i que vai de 255 a 0 e também

chama a função ledOn().

Utilizando o sensor de linha.


Neste código, primeiro é definida uma variável do tipo inteira que é led e recebe

o valor 13 que é o numero do pino. Na função void setup() a porta serial é iniciada e

essa variável é colocada como saída. Por ultimo na função void loop() é definido uma

variável do tipo inteira que é sensorValue, essa variável vai receber o valor de um

sensor de linha colocado no pino analógico A0, esse valor será impresso na porta serial,

se esse valor for menor ou igual a 100, o led acende caso contrario ele permanece

apagado.


13

Utilizando o ultrassom.


Neste código, é utilizado o sensor ultrassom que consiste em um emissor e um

receptor de frequências muito alta, da faixa do ultrassom. O emissor é chamado de

trigger e o receptor é o echo. Para se calcular a distancia do sensor até um obstáculo, é

preciso enviar um sinal pelo trigger e calcular quanto tempo leva para bater no

obstáculo e voltar para o echo. Como esse tempo é de ida e de volta, tem que ser

dividido por 2. A velocidade do som no ar é aproximadamente 340m/s, com isso através

da formula V=S/t é possível saber a distancia. Após algumas conversões de unidades

para que o resultado saia em cm temos que dividir o tempo em 29.4.


14

Utilizando motor de corrente continua.


Nesse código, primeiro são definidas 6 variáveis do tipo inteira que são:

motorPin, incPin, decPin, val, incButton e decButton. As variáveis motorPin, incPin e

decPin recebem os valores 3, 4 e 5 respectivamente que são os numeros das portas

digitais, já a variavel val recebe o valor 0 e as variáveis incButton e decButton, o estado

logico baixo. Na função void setup() os pinos digitais 4 e 5 são colocados como entrada

que são dois botões e o pino digital 3 como saída que é um motor de corrente continua,

o motor é desligado e é iniciado a porta serial. Por ultimo, na função void loop(), as

variáveis incButton e decButton recebem o estado logico dos pinos digitais 4 e 5

respectivamente, se o estado logico da variável incButton for alto, incrementa a variável

val, se o estado logico da variável decButton for alto, decrementa a variável val,

imprime na porta serial o valor de val, da uma pausa de 100ms e escreve no pino digital

3 que é o motor de corrente continua o valor de val.


15

Utilizando servo motor.


Nesse código, primeiro é incluído a biblioteca do servo motor Servo.h, que já se

encontra no software do Arduino, é definido uma variável do tipo servo que é motor1 e

uma variável do tipo inteiro que é pos e recebe 0. Na função void setup(), é utilizado

uma função da biblioteca que é motor1.attach(8), essa função associa o pino digital 8 ao

servo motor. Por ultimo na função void loop() é construído um laço for para a variável

pos que é a posição e vai de 0 até 180º e chama uma função da biblioteca que é

motor1.write(pos), essa função escreve a posição no servo motor, pausa por 15ms e

depois tem outro laço for para a mesma variável que vai de 180º a 0 e chama a mesma

função da biblioteca que é motor1.write(pos) e pausa novamente por 15ms.

4. Código Exemplo para Robô

// Sweep

// by BARRAGAN

<http://barraganstudio.com>

// This example code is in the public

domain.

#include <Servo.h>

#define SERVO_R 9

#define SERVO_L 10

#define SENSOR_D_TRIGG 5

#define SENSOR_D_ECHO 4

#define SENSOR_R A4

#define SENSOR_L A3

#define SENSOR_D_MIN 10

#define SENSOR_D_MAX 100

#define SENSOR_D_STEP 5

#define MOVE_F 7

#define MOVE_S 0

#define MOVE_B 3

#define MOVE_LF 6

#define MOVE_RF 5

#define MOVE_LB 2

#define MOVE_RB 1

#define MOVE_SPINL 8

#define MOVE_SPINR 9


16

#define STATE_SCAPE 0

#define STATE_SEARCH 1

#define STATE_ATTACK 2

#define SEARCH_INTERVAL 10

#define SCAPE_INTERVAL 8

#define ATTACK_INTERVAL 10

#define SENSORD_LIMIAR 50

#define SENSORD_DIFF 5

Servo servoR;

Servo servoL;

int movement; // variable to store robo

direction

unsigned long sensorD;

unsigned long sensorDOld;

int sensorDOFF;

int sensorDON;

int sensorL;

int sensorR;

int sensorLBase;

int sensorRBase;

int state;

int currentTime;

// Functions:

void MotorSetup();

void SensorSetup();

void Sense();

void Think();

void Move();

// Setup for all:

void setup() {

Serial.begin(9600);

randomSeed(analogRead(A0));

MotorSetup();

delay(1000);

delay(1000);

delay(1000);

delay(1000);

delay(1000);

SensorSetup();

state = STATE_SEARCH;

movement = int(random(5,8)); // Escolha

um movimento aleatorio

currentTime = SEARCH_INTERVAL;

Move();

}

void loop() {

Sense();

Think();

Move();

delay(100);

if(currentTime>0)

currentTime--;

}

// Implementation:

void MotorSetup(){

servoR.attach(SERVO_R);

servoL.attach(SERVO_L);

servoR.write(90);

servoL.write(90);

movement = MOVE_S;

}

void SensorSetup(){

pinMode(SENSOR_D_TRIGG,OUTPUT);

pinMode(SENSOR_D_ECHO,INPUT);

digitalWrite(SENSOR_D_TRIGG,LOW);

delay(1);

sensorD = 0;

Sense();

sensorLBase = sensorL+sensorL/2; //

tolerancias de +50% do preto inicial

sensorRBase = sensorR+sensorR/2;

sensorDOld = 400;

}

void Sense(){

// Read SR04 and stores the distance[cm]

in sensorD:

digitalWrite(SENSOR_D_TRIGG,HIGH);

delayMicroseconds(15);

digitalWrite(SENSOR_D_TRIGG,LOW);

sensorDOld=sensorD;

sensorD =

pulseIn(SENSOR_D_ECHO,HIGH);

sensorD /= 58;

// Read line sensors:

sensorL = analogRead(SENSOR_L);

sensorR = analogRead(SENSOR_R);

}

void Think(){

// Testa se o robo atinge a faixa branca:

if(sensorL>sensorLBase ||

sensorR>sensorRBase) {

currentTime = SCAPE_INTERVAL;

if(state!=STATE_SCAPE){


17

state = STATE_SCAPE;

Serial.println("SET STATE_SCAPE");

if(sensorL>sensorLBase){

movement = MOVE_LF;

Serial.println("MOVE_LF");

}

else{

movement = MOVE_RF;

Serial.println("MOVE_RF");

}

}

else{

if(movement==MOVE_LF &&

sensorR>sensorRBase){

movement=MOVE_LB;

}

if(movement==MOVE_RF &&

sensorL>sensorLBase){

movement=MOVE_RB;

} }

return;

}

// Verifica se o tempo de estado expirou.

Em caso positivo assume o estado search:

if(currentTime>0){

return;

}

// Assume o estado de ataque se a

distancia lida for inferior da distancia base:

if(sensorD<SENSORD_LIMIAR ||

sensorD>(sensorDOld+SENSORD_DIFF){

Serial.println("SET STATE_ATTACK");

state = STATE_ATTACK;

currentTime = ATTACK_INTERVAL;

movement = MOVE_F;

return;

}

currentTime = SEARCH_INTERVAL;

if(state==STATE_SCAPE)

{

movement = MOVE_F;

}

else

{

movement = int(random(5,8)); //

Escolha de movimento aleatorio para

frente, esquerda ou direita

}

state = STATE_SEARCH;

Serial.println("SET STATE_SEARCH");

}

void Move(){

switch(movement){

case MOVE_RB: servoR.write(0);

servoL.write(90); break;

case MOVE_LB: servoR.write(90);


case MOVE_B: servoR.write(0);


case MOVE_RF: servoR.write(180);


case MOVE_LF: servoR.write(90);


case MOVE_F: servoR.write(180);


case MOVE_SPINL: servoR.write(0);


case MOVE_SPINR: servoR.write(180);


default:

servoR.write(90); servoL.write(90);

break;

}}

Nesse código, tem um exemplo de um robô autônomo sumô, a ideia básica

consiste em criar uma função void sense(), uma função void think() e uma função void

move() e chama-las na função void loop(). A função void sense() é responsável pelos

sensores, a função void think() determina um movimento a partir dos dados dos

sensores e por ultimo a função void move() movimenta o robô.

5. Bibliografia

http://www.bbc.com/portuguese/videos_e_fotos/2012/05/120511_computador_grecia_f

n.shtml

http://www.tecmundo.com.br/tecnologia-da-informacao/1697-a-historia-dos-

computadores-e-da-computacao.htm

http://www.arduino.cc/

http://labdegaragem.com/

Livro Arduino Básico. Autor: Michael McRoberts.

Livro Experimentos com o Arduino. Autor: João Alexandre da Silveira.

http://www.bbc.com/portuguese/videos_e_fotos/2012/05/120511_computador_grecia_fn.shtml

http://www.bbc.com/portuguese/videos_e_fotos/2012/05/120511_computador_grecia_fn.shtml

http://www.tecmundo.com.br/tecnologia-da-informacao/1697-a-historia-dos-computadores-e-da-computacao.htm

http://www.tecmundo.com.br/tecnologia-da-informacao/1697-a-historia-dos-computadores-e-da-computacao.htm

http://www.arduino.cc/

http://labdegaragem.com/

Documents

P3R3 - Robô na Escolap3r3.com/wp-content/uploads/2015/08/Oficina-Arduino-e-Programacao.pdf · Arduino é uma plataforma de prototipagem eletrônica aberta baseada na flexibilidade,