Escolar Documentos
Profissional Documentos
Cultura Documentos
Smidt Andre Crepaldi Geiger PDF
Smidt Andre Crepaldi Geiger PDF
So Carlos
Junho/2013
1
IMPLEMENTAO DE UMA
PLATAFORMA ROBTICA
CONTROLADA REMOTAMENTE
UTILIZANDO O ARDUINO
So Carlos
2013
Sumrio
Resumo............................................................................................................................................................ 9
Abstract ..........................................................................................................................................................10
Captulo 1: Introduo ....................................................................................................................................11
Captulo 2: Metodologia .................................................................................................................................15
2.1 Materiais e mtodos .................................................................................................................................. 15
2.2. Arduino ..................................................................................................................................................... 15
2.3. Plataforma Robtica ................................................................................................................................. 17
2.3.1. Rob ....................................................................................................................................................... 17
2.3.2. Plataforma de Controle.......................................................................................................................... 18
2.4. Sensores .................................................................................................................................................... 19
2.4.1. Sensores no Rob .................................................................................................................................. 19
2.4.2. Sensores na plataforma de controle ...................................................................................................... 21
2.4.2.1. Controle do Playstation ............................................................................................................... 21
2.4.2.2. Controle Nintendo Wii ................................................................................................................ 22
2.4.2.3. Controle atravs do Android ....................................................................................................... 23
2.5. Perifricos de Comunicao ...................................................................................................................... 27
2.6. Atuadores .................................................................................................................................................. 29
2.6.1. Motores DC ............................................................................................................................................ 29
2.6.2. Servos..................................................................................................................................................... 32
2.7. Comandos e decises ................................................................................................................................ 34
2.7.1. Comandos .............................................................................................................................................. 34
2.7.2. Decises ................................................................................................................................................. 35
Captulo 3: Implementao .............................................................................................................................41
3.1. Software do rob ...................................................................................................................................... 41
3.1.1. droid_v4 ................................................................................................................................................. 41
3.1.2. manual_servo ........................................................................................................................................ 42
3.1.3. automatic_mode.................................................................................................................................... 42
3.1.4. comandos_buzzer .................................................................................................................................. 42
3.1.5. set_pin ................................................................................................................................................... 43
3.1.6. timer2_sonar ......................................................................................................................................... 43
Resumo
Com a popularizao dos microcontroladores e do open hardware (hardware livre),
a construo de unidades robticas tornou-se economicamente vivel. A construo de um
rob envolve o uso de conceitos relacionados com hardware, software e mecnica, que
necessitam estarem integrados atravs de um microcontrolador, para coordenar os
perifricos do rob. Neste trabalho, propomos o projeto e a montagem de um rob mvel de
pequeno
porte
controlado
remotamente,
utilizando
plataforma
Arduino
microcontrolador ATMega328.
Abstract
Along with the popularization of microcontrollers and open hardware, the construction
of robotic units has become economically viable. The construction of a robot involves the use
of concepts related to hardware, software and mechanics that need to be integrated trough a
microcontroller to coordinate the peripherals of the robot. In this work we propose the project
and the assembly of a remote controlled small scale mobile robot using the Arduino platform
and the ATMega328 microcontroller.
10
Captulo 1: Introduo
A popularizao dos microcontroladores, junto com a queda dos custos de
componentes eletrnicos, baterias e motores, possibilitaram o desenvolvimento de
pequenas plataformas robticas de custo acessvel.
11
Esse processo de integrao pode ser visto em literaturas como [5], [6] e [7] onde
so demonstradas outras possibilidades de plataformas robticas, diferentes das
apresentadas acima, nesses artigos so apresentados alguns dos conhecimentos
necessrios para a construo de uma unidade robtica de mdio porte, bem como a
integrao necessria para conectar todos os perifricos do rob ao seu microcontrolador e
sistemas de controle implementados.
Figura 3 Rob.
escolha
desse
microcontrolador
se
deve
principalmente
seguintes
Estrutura em alumnio servo controlada com dois graus de liberdade, ver Figura 24.
13
14
Captulo 2: Metodologia
2.1 Materiais e mtodos
A plataforma controlvel formada por um carro robtico de dois andares com dois
motores DC e duas caixas de reduo, um Arduino Uno com ATMega328, uma ponte H que
utiliza o CI L298N, um mdulo sonar HC-SR04, dois servos-motores, um mdulo de
comunicao RF (radiofrequncia), um mdulo de comunicao Bluetooth e as baterias
necessrias.
2.2. Arduino
Arduino [1] uma plataforma de prototipao eletrnica open-source flexvel que
utiliza o microcontrolador ATMega328. O Arduino pode receber sinais de vrios sensores
eletrnicos e lidar com essas informaes para controlar motores, luzes, servos e qualquer
outro atuador. O modelo utilizado no rob o Arduino UNO (figura 5).
N
Figura 5 Arduino
15
Tenso de operao
5V
7 12 V
6 20 V
Pinos digitais
Pinos analgicos
Clock
16 MHz
RISC: Reduced Instruction Set Computer ou Computador com conjunto reduzido de instrues
EEPROM: Electrically-Erasable Programmable Read-Only Memory um tipo de memria no
voltil e que pode ser reescrita um nmero limite de vezes.
4
SRAM: Static Random Access Memory um tipo de memria voltil de acesso randmico.
5
USART: Universal Synchronous/Asynchronous Receiver/Transmitter utilizado para realizar a
comunicao serial com o microcontrolador.
6
SPI: Serial Peripheral Interface utilizado para implementar comunicao serial com o
microcontrolador.
7
AD: Analgico Digital
8
Utilizado para forar um reset no microcontrolar, reiniciando seu programa.
3
16
O cdigo estruturado para esse rob, em sua essncia, um loop infinito onde
realizada uma leitura dos sensores (ver seo 2.4) e dos perifricos de comunicao (ver
seo 2.5), e, com base nessas informaes, so acionados seus atuadores (ver seo 2.6).
2.3.2. Plataforma de Controle
18
2.4. Sensores
Sensores so dispositivos que possibilitam coletar informaes a cerca de algum
fenmeno, transformando elas em dados que possam ser processados por um
microcontrolador.
A plataforma criada conta com um sonar, o mdulo HC-SR04 [9]. Com esse
dispositivo possvel medir a distncia de um objeto que se encontra em sua frente. Um
19
pulso ultrassnico emitido pelo dispositivo, se reflete sobre o objeto e retorna para o sonar
e, com base no tempo decorrido entre a emisso e a recepo do pulso, possvel
determinar a distncia do objeto.
Voltagem de Operao
DC 5 V
Alcance Mximo
4m
Corrente de Operao
15 mA
Alcance Mnimo
2 cm
Frequncia de Operao
40 Hz
ngulo de Medio
15
Dimenso
45 x 20 x 15 mm
O sonar utilizado na plataforma desenvolvida para evitar que o rob colida com
objetos em sua frente. O mesmo se encontra estruturado sobre uma estrutura de alumnio
presa a dois servos, formando um sistema do tipo pan & tilt (ver seo 2.6.2), possibilitando
que o mesmo seja apontado em diversas posies.
HLT significa High-Level Time, tempo em que o pino ECHO est no nvel lgico um. O fabricante
considera a velocidade do som constante em 340 m/s.
20
A empresa Sony ao criar esse controle para a sua plataforma de videogames utilizou
um protocolo de comunicao prprio, criado para aquele console, assim, para realiza a
comunicao entre o Arduino e o controle e necessrio utilizar uma biblioteca denominada
PS2X_lib_v1.0, presente em [10], onde implementado os protocolos de comunicao
para conseguir ler os dados do controle.
Pino 1 data
Transmite um sinal sncrono de 8 bits na borda de descida do clock com os
estados dos botes e joysticks do controle.
Pino 2 command
Recebe um sinal de 8 bits na borda de descida do clock. Contador do DATA.
Pino 5 VCC
A tenso de operao do controle 5 V, suportando correntes de at 750 mA.
21
Pino 6 ATT
Usado para ativar o controle, como um chip select.
Pino 7 CLK
Gera o sinal que mantm o sincronismo entre o controle e o microcontrolador.
Pino 9 - ACK
Recebe o sinal que o microcontrolador envia quando termina de receber os
dados.
2.4.2.2. Controle Nintendo Wii
O valor indicado pelo acelermetro passado para o rob, que traduz essas
informaes em comandos para manipular os motores presentes na plataforma
(servomecanismo e motores das rodas).
22
10
23
ZT-05
Verso Bluetooth
V2.0+EDR
Classe de Potncia
Classe II (at 10 m)
Tenso de Operao
5V
Interface
UART
24
Debaixo dos botes mencionados h mais dois botes. Quando o primeiro deles
(Automatic Mode) pressionado, enviado para o rob o cdigo que indica a chamada da
rotina que possibilita o rob andar de forma autnoma sem colidir com objetos prximos, o
que possvel com o uso do mdulo sonar. Para interromper o modo autnomo, basta clicar
em algum dos outros comandos presentes na interface.
Quando o boto Buzzer pressionado, o rob emite um pequeno som do tipo bip".
Na interface criada, est presente uma caixa do tipo checkbox, e, quando a mesma
ativada, comandos referentes movimentao do rob so enviados para o mesmo, usando
como base os dados retornados pelos acelermetros do celular, ou seja, ativando essa
checkbox, passa-se a controlar o rob com base na posio do smartphone. A seguir as
possveis posies so mostradas:
Para uma boa leitura dos dados do acelermetro e simplificao do software criado,
necessrio que no se misture dois comandos ao mesmo tempo, ou seja, inclinar o
smartphone para frente e para direita ao mesmo tempo, ir gerar valores invlidos, com
25
muito erro agregado por parte dos acelermetros. Para um controle preciso da plataforma
dessa maneira, necessrio realizar um movimento de cada vez.
26
Frequncia de operao
418-455 MHz
Modulao
GFSK
Intervalo de frequncia
200 kHz
Potncia transmitida
20 mW
Sensibilidade recebida
-113 dBm
Umidade de operao
10-90%
Temperatura de operao
-30-85C
Tenso de alimentao
3,5-5,5 V
Corrente transmitida
< 42 mA
Corrente recebida
< 28 mA
Distncia de transmisso
< 5 A
Dimenso
37,5 x 18,3 x 7 mm
27
Para o funcionamento correto dos mdulos necessrio configurar ambos para que
operem sobre a mesma frequncia e mesmo baudrate11. O procedimento de configurao
ocorre utilizando o software RF-Magic fornecido pelo fabricante (Figura 18) e o adaptador
USB necessrio para ligar os mdulos ao computador (Figura 19). Os parmetros utilizados
para configurao so mostrados na Figura 18, a nica exceo o parmetro de RF
frequency onde foi utilizando a frequncia 433Mhz.
11
28
2.6. Atuadores
2.6.1. Motores DC
Parmetros da Caixa de
Reduo
DC 3 V
Rotao
5000 RPM
Corrente suportada
80-100 mA
Taxa de reduo
1:220
20 RPM
14 RPM
Torque de sada
1 kg.cm
Corrente suportada
110-130 mA
29
Tenso de Alimentao
At 50 V
Tenso lgica
At 7 V
Corrente de sada
2 A/canal
25 W
Temperatura da juno
-25 a 130 C
12
Spark (fasca, em ingls) pequenas fascas que ocorrem dentro do motor, devido a sua dinmica
de funcionamento.
13
Circuito Integrado
30
Os pinos IN1, IN2, IN3 e IN4 so usados para realizar o controle de direo de
rotao dos motores e os pinos ENA e ENB recebem os sinais de PWM14 emitidos pelo
Arduino para girar os motores.
Podemos ver no esquemtico que os pinos IN1 e IN2, assim como o IN3 e IN4, esto
ligados ao mesmo sinal, porm um passa por um inversor antes de chegar ao
microcontrolador e o outro no. Isso foi feito para reduzir (de quatros para dois) o nmero de
pinos de controle necessrios.
14
31
IN1
IN2
IN3
IN4
Direo
Trs
Esquerda
Direita
Frente
2.6.2. Servos
A plataforma criada conta com dois servos de 9g da Tower Pro, como o da figura 23.
Detalhes sobre essa estrutura podem ser vistos no modelo feito no Google Sketchup
na figura 23.
32
Junto estrutura foi colocada tambm uma pequena ponta de caneta laser, que
pode ser acionada para indicar, de forma aproximada, a direo para qual sentido o mdulo
sonar est posicionado (vide figura 25).
33
Comandos
Playstation
Andar p/ frente
Cima
Andar p/ trs
Baixo
Girar p/ direita
Direita
Girar p/ esquerda
Esquerda
Parar
Quadrado
Modo automtico
Controle completo
pan & tilt
Cima
Baixo
Direita
Esquerda
Boto Stop
N/I
Checkbox
L1 + Joystick2
N/I
N/I
L2 + Joystick1
L2 + Joystick2
Buzzer
Laser
R1
R2
Liga estao de
controle
N/I
Conectar Bluetooth
C + Z + inclinar
controle para frente
C + Z + inclinar
controle para trs
C + Z + rotacionar
controle no sentido
horrio
C + Z + rotacionar
controle no sentido
anti-horrio
C + Z + controle na
posio neutra
Celular
Bola
Synch
Nintendo Wii
C + rotacionar
controle
Z + rotacionar
controle
N/I
N/I
Boto Buzzer
N/I
N/I
Boto Sync
N/I
Boto Bluetooth
N/I
N/I
34
2.7.2. Decises
Esta seo descreve os principais eventos realizados pelo rob quando um novo
comando recebido. As entradas e como elas interagem com a dinmica da plataforma so
mostradas a seguir:
Andar para frente
Quando o rob recebe o comando de andar para frente, as seguintes aes internas
so realizadas:
35
Essa condio mantida durante 100 ms. Se antes disso um novo comando no
chegar, a plataforma ajusta os PWM dos motores para zero, parando o rob.
Quando o rob recebe o comando de andar para trs, as seguintes aes internas
so realizadas:
- O sinal de PWM dos motores ajustado para 255 (8 bits) em seu duty cicle.
Essa condio mantida durante 100 ms. Se antes disso um novo comando no
chegar, a plataforma ajusta os PWM dos motores para zero, parando o rob.
Girar para direita
15
36
- O sinal de PWM dos motores ajustado para 255 (8 bits) em seu duty cicle.
Essa condio mantida durante 100 ms. Se antes disso um novo comando no
chegar, a plataforma ajusta os PWM dos motores para zero, parando o rob.
Parar
O valor inicial da semente utilizada para gerar os nmeros aleatrios igual leitura
do pino analgico A2, que, como no se encontra conectado a nenhum dispositivo (ver
Anexo I), contm rudo, e assim o cdigo no gera sempre a mesma sequncia.
37
Buzzer
O pino D8 do Arduino fica no nvel lgico zero por 10 ms, retornando para o nvel
lgico um em seguida. O pino est conectado a um buzzer, que gera um pequeno apito do
tipo bip.
Laser
O pino D13 do Arduino fica no nvel lgico um, fechando o circuito eltrico onde se
encontra a ponta da caneta laser. Quando o pino est em nvel lgico zero, o laser
desligado.
16
38
Sync
O Sync um processo que ocorre automaticamente entre o rob e a plataforma de
controle, quando so ligados nessa ordem.
O sync um caractere de controle que enviado para o rob para indicar quem
est controlando-o (a plataforma de controle ou o celular com Android). Se nenhum
caractere recebido, o rob no ativado e permanece aguardando esse sinal.
39
40
Captulo 3: Implementao
3.1. Software do rob
O software criado foi desenvolvido na ferramenta Arduino IDE em linguagem C e
conta com seis arquivos-fonte, com os mtodos e operaes necessrios para coordenar
todos os perifricos do rob.
Os arquivos so:
- droid_v4
- manual_servo
- automatic_mode
- comandos_buzzer
- set_pin
- timer2_sonar
3.1.1. droid_v4
41
3.1.2. manual_servo
Contm a implementao dos mtodos necessrios para lidar com o controle dos
servos no sistema de pan & tilt e verificar se os mesmos esto sendo usados.
3.1.3. automatic_mode
3.1.4. comandos_buzzer
42
3.1.5. set_pin
chamando
os
3.1.6. timer2_sonar
O sistema foi estruturado com essa condio para que, em caso de perda de
comunicao, a plataforma no continue andando sem controle.
- Droid_controle_v4
- playstation_search_cmd
- wiinunchuck_search_cmd
- command
3.2.1. Droid_controle_v4
controle (ver Figura 4) acende. Caso contrrio, o led permanece apagado indicando que no
foi possvel iniciar a comunicao.
O mtodo loop() realiza a leitura dos dados do controle e envia o comando recebido
para a plataforma robtica. Esse processo ocorre a cada 70 ms.
3.2.2. playstation_search_cmd
Contm os mtodos que analisa a string obtida com a leitura dos dados do controle
do Playstation e chama os mtodos contidos no arquivo command para enviar o comando
correspondente.
3.2.3. wiinunchuck_search_cmd
Anlogo ao playstation_search_cmd, mas os mtodos so referentes a leitura dos
dados do controle do Wii.
3.2.4. command
Comando
Cdigo
Andar p/ frente
Andar p/ trs
Girar p/ direita
Girar p/ esquerda
Parar
Modo automtico
Buzzer
Laser
Servos
44
O cdigo fonte desenvolvido para a plataforma encontra-se no anexo III e anexo IV,
na Figura 29, mostrado o fluxograma do cdigo de controle do rob, podemos observar a
presena dos dois mtodos principais do Arduino, void setup() e void loop(), representadas
respectivamente pelos retngulos azul e vermelho e as principais operaes realizadas
dentro dessas funes.
45
46
Captulo 4: Resultados
O desenvolvimento desse trabalho teve inicio com alguns testes em bancada para
descobrir como se realizava o controle de motores DC utilizando o Arduino, Figura 31, e ao
longo dos meses foi sendo adicionada novas funcionalidades a plataforma.
O sistema com o sonar funciona bem para a tarefa de medir distancias, evitando
colises frontais da plataforma com objetos presente no meio em que a mesma esta
andando. O sonar acoplado sobre o sistema de pan & tilt, possibilita aponta-lo em diversas
direes, independentemente do sentido de deslocamento da plataforma, ou seja, possvel
andar com a plataforma para um sentido e apontar o sonar para outro, isso permite uma
maior flexibilidade para realizar medidas em relao a um sistema utilizando sonar fixo, por
exemplo.
Podemos ver na tabela fornecida por [12], que o sonar apresenta um alcance mnimo
de 2 cm e mximo de 4 m, com um ngulo de medida de 15 graus. Esse ngulo, na medida
realizada pelo dispositivo, acaba introduzindo erros quando o objeto comea a se distanciar
do sonar. Isso ocorre devido ao fato que rea vista pelo sonar comea a aumentar (vide
figura 32), permitindo que demais elementos presentes no mesmo ambiente venham a
influenciar a medida realizada pelo sonar.
47
O uso dos acelermetros, tanto do celular quanto do controle de Nintendo Wii, para
controlar o rob, sofrem muito com efeitos de rudos em suas medies, devido a sua
48
sensibilidade, para corrigir esse tipo de problema uma alternativa seria a implementao de
filtros, ou isolar os movimentos do acelermetro. Na plataforma no foi implementado um
filtro para essa operao, por isso se realizou a isolao dos movimentos quando utilizando
o acelermetro.
49
50
O mtodo autnomo pode ser expandido para lidar com colises laterias, utilizando a
movimentao que o sistema de pan & tilt possibilita para o sonar. Mtodos utilizando outras
heursticas podem ser implementando, fazendo com que o rob tome uma deciso sobre
para qual lado ele deve andar, quando um objeto se encontra na frente do sonar, e no
sortear um lado para andar como foi implementado.
51
52
Captulo 6: Concluses
Para realizar a construo de uma pequena plataforma robtica necessrio
solucionar diversos pequenos problemas de hardware, software e mecnica, para que o
conjunto final realize as tarefas desejadas, essa integrao ocorre com o uso de um
microcontrolador.
A construo dessa unidade robtica foi um grande desafio e com bons resultados,
aps a sua implementao. O controle mais eficaz para se utilizar o rob o de Playstation,
consequentemente o melhor sistema de comunicao, dentro dessa implementao, o
sistema de RF. O controle utilizando o Smartphone eficiente por no depender da estao
de controle, sendo assim um controle mais universal em relao aos outros.
conhecimento obtido durante o curso de graduao. A robtica acaba sendo uma tima
maneira de introduzir esse universo de conhecimento de uma maneira prtica funcional e
didtica. Agregando assim grande valor tcnico, terico e cientifico obtido com o
desenvolvimento dessa plataforma robtica.
54
Laser,
mdulo
sonar
(HC-SR04)
os
perifricos
de
comunicao
(APC220/Bluetooth).
55
56
57
58
|
|
|
|
|
|
|
|
|
|
7 - Trigger Sonar
8 - buzzer *apita em LOW , foi ligado
9
10
11
12
13
Servo X
Servo Y
dir1PinA
dir1PinB
laser
A3 A4 A5 -
// servos
//sonar
// Timer2OverFlow
FRENTE 0
TRAS 1
DIREITA 2
ESQUERDA 3
PARADO 4
// motor 1
#define dir1PinA 11
#define speedPinA 6//10
//motor 2
#define dir1PinB 12
#define speedPinB 5//9
//botoes, leds, buzzer, laser
#define buzzerPin 8
#define led_synch A0
#define laserPin 13
long timebuzzer;// usando junto com o sonar
/* =========> led_synch <=========
* 1) se estiver piscando rapido -> Esperando synch do controle
* 2) se estiver acesso
-> Sonar esta detectando algo
* 3) se estiver apagado
-> Sonar nao esta detectando algo
*/
//servos
#define pinServoX 9
#define pinServoY 10
Servo Servo_x;
Servo Servo_y;
unsigned long time_to_detach_servo;
//sonar
#define TRIGGER_PIN 7
#define ECHO_PIN
4
#define MAX_DISTANCE 200 // distancia maxima sonar
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
unsigned long time_last_read;
// tempo em que se realizou a ultima leitura do sensor
int valid_dist_sonar = -1;
//leitura valida do sonar usado para parar o carrinho
com distancia minima
59
$ => RF controle
& => bluetooth
q => RF pc
para
60
/*
Serial.print("Timer_OverFlow: ");
Serial.println(time_overFlow);
*/
time_last_read = time_to_detach_servo = millis();
do// pegar uma medida valida do sonar
{
valid_dist_sonar = sonar_read();
}
while( valid_dist_sonar == -1 );//inicializando o sonar
comando ='*';
Serial.println("\nOK Ready to run");
digitalWrite(led_synch , LOW);//ready to run
}
void loop()
{
comando ='*';
if( Serial.available() > 0 )
{
comando = Serial.read();
delay(2);
}
switch(comando)
{
case 'w' :
frente(&direcao);
break;
case 's':
tras(&direcao);
break;
case 'd':
direita(&direcao);
break;
case 'a' :
esquerda(&direcao);
break;
case 'p' : // parar
parar(&direcao);
break;
case 'W' : //debug teclado
frenteW(&direcao);
break;
case 'S': //debug teclado
trasS(&direcao);
break;
case 'D': //debug teclado
direitaD(&direcao);
break;
case 'A' : //debug teclado
esquerdaA(&direcao);
break;
case 'b' : //buzzer
buzzer();
break;
case '%' : // entrar no servo mode
if( Servo_x.attached() == true && Servo_y.attached() == true)// so entra se os servos
estiverem attached
61
{
manual_servoMode();
}
else // senao tiverem attached , attach os servos
{
Servo_y.attach(pinServoY);
Servo_x.attach(pinServoX);
time_to_detach_servo = millis();
}
break;
case 'r' : // reset
resetFunc();
break;
case 'u' :
automaticMode();
break;
case 'l' :
digitalWrite(laserPin, digitalRead(laserPin) ^ 1 );
break;
}
if_necessary_detach_servo();
sonar_verify_rotine();//safe distance rotine
sonar_stop_with_control(safe_dist);
#ifdef RANGE_RF_TEST
if( millis() - TimeSend_ack > 700 )
{
Serial.println(send_value++);
TimeSend_ack = millis();
}
#endif
}
void read_input_and_set_param(char input_string[] ,int *param1 , int *param2 , int *param3)
{
int i = 0;
delay(12);//ausencia causa problemas na comunicacao
while( Serial.available() > 0 )
{
char aux = (char)Serial.read();
if( aux != ',' )
input_string[i++] = aux;
else // iremos obter o param1
{
input_string[i] = '\0';
*param1 = atoi(input_string);
i = 0;
while( Serial.available() > 0 )// lendo pwmA
{
aux = (char)Serial.read();
if( aux != ',' )
input_string[i++] = aux;
else
{
input_string[i] = '\0';
*param2 = atoi(input_string);
i = 0;
while( Serial.available() > 0 )// lendo pwmB
{
aux = (char)Serial.read();
if( aux != '\n' )
input_string[i++] = aux;
62
else
{
input_string[i] = '\0';
*param3 = atoi(input_string);
//
break;
Serial.println(param3);
}
}
}
}
}
}
}
ARQUIVO manual_servo.pde
char pos_stick[20] = "*"; // armazena em char as posicoes do joystick
int num_stick2[2] = {
90 , 90 }; // armazena em int a posicao dos joystick
void manual_servoMode()
{
delay(5);
int i = 0;
int pos_x;
int pos_y;
read_input_and_set_param(pos_stick , &nada , &pos_x , &pos_y);
if( nada == 2 )
Nunchuck_command(pos_x,pos_y);
else
{
pos_x = map(pos_x , 0 , 255 , 180 , 0 );
pos_y = map(pos_y , 0 , 255 , 180 , 0 );
Servo_x.write(pos_x);
Servo_y.write(pos_y);
Serial.print("x ");
Serial.print(Servo_x.read(),DEC);
Serial.print("y ");
Serial.println(Servo_y.read(),DEC);
delay(20);
}
}
void servo_setup(int x_ini , int y_ini)
{
Servo_y.attach(pinServoY);
Servo_x.attach(pinServoX);
Servo_x.write(x_ini);
Servo_y.write(y_ini);
delay(20);
time_to_detach_servo = millis();
}
void if_necessary_detach_servo()
{
if( millis() - time_to_detach_servo > 1000 ) // time_to_detach_servo eh atualizada somente
quando se utiliza o servo no modo manual
{
63
Servo_y.detach();
Servo_x.detach();
}
}
ARQUIVO automatic_mode.pde
int automaticMode ()
{
int state_led = LOW;
long blink_led_time =
Servo_y.attach(pinServoY);
Servo_x.attach(pinServoX);
set_servos_frente();
randomSeed(analogRead(3));
while(1)
{
sonar_verify_rotine();//safe distance rotine
sonar_stop_automatic_mode(25);// distancia de reacao
if( Serial.available() > 0 )// qualquer comando volta pra o modo manual
return 0;
blink_led_time = blink_led_automatic_mode( blink_led_time);
}
Serial.println("Automatic Mode End");
}
void sonar_stop_automatic_mode(byte safe_dist)
{
if( valid_dist_sonar <= safe_dist && valid_dist_sonar > 2
alguma coisa esta perto
{
64
aplly_vel(pwmA, pwmB);
}
}
void set_servos_frente()
{
Servo_x.write(108);
Servo_y.write(180);
}
void set_servos_tras()
{
Servo_x.write(108);
Servo_y.write(0);
}
void set_servo_esquerda_extremo_tras()
{
Servo_x.write(0);
Servo_y.write(0);//posicionando servo y
}
void set_servo_esquerda_extremo_frente()
{
Servo_x.write(180);
Servo_y.write(180);//posicionando servo y
}
void set_servo_direita_extremo_tras()
{
Servo_x.write(180);
Servo_y.write(0);//posicionando servo y
}
void set_servo_direita_extremo_frente()
{
Servo_x.write(0);
Servo_y.write(180);//posicionando servo y
}
ARQUIVO comandos_buzzer.pde
void frente(int *direcao)
{
*direcao = FRENTE;
// Serial.println(*direcao);
setpin_frente();
aplly_vel(pwmA, pwmB);
MsTimer2::start();
}
void tras(int *direcao)
{
*direcao = TRAS;
// Serial.println(*direcao);
setpin_tras();
aplly_vel(pwmA, pwmB);
MsTimer2::start();
}
void direita(int *direcao)
{
*direcao = DIREITA;
// Serial.println(*direcao);
setpin_direita();
aplly_vel(pwmA, pwmB);
MsTimer2::start();
}
void esquerda(int *direcao)
65
{
*direcao = ESQUERDA;
// Serial.println(*direcao);
setpin_esquerda();
aplly_vel(pwmA, pwmB);
MsTimer2::start();
}
void parar( int *direcao)
{
*direcao = PARADO;
// Serial.println(*direcao);
aplly_vel(0, 0);
}
void frenteW(int *direcao)
{
*direcao = FRENTE;
// Serial.println(*direcao);
setpin_frente();
aplly_vel(PWMA, PWMB);
MsTimer2::start();
}
void trasS(int *direcao)
{
*direcao = TRAS;
// Serial.println(*direcao);
setpin_tras();
aplly_vel(PWMA, PWMB);
MsTimer2::start();
}
void direitaD(int *direcao)
{
*direcao = DIREITA;
// Serial.println(*direcao);
setpin_direita();
aplly_vel(PWMA, PWMB);
MsTimer2::start();
}
void esquerdaA(int *direcao)
{
*direcao = ESQUERDA;
// Serial.println(*direcao);
setpin_esquerda();
aplly_vel(PWMA, PWMB);
MsTimer2::start();
}
void aplly_vel(int pwmA , int pwmB)
{
analogWrite(speedPinA , pwmA);
analogWrite(speedPinB, pwmB);
}
void buzzer()
{
digitalWrite(buzzerPin, LOW);
delayMicroseconds(10000);
digitalWrite(buzzerPin, HIGH);
delayMicroseconds(10000); // acho que pode tirar esse cara
}
ARQUIVO: set_pin.pde
66
void setpin_frente()
{
motorA_frente();
motorB_frente();
}
void setpin_tras()
{
motorA_tras();
motorB_tras();
}
void setpin_direita()
{
motorA_frente();
motorB_tras();
}
void setpin_esquerda()
{
motorA_tras();
motorB_frente();
}
void pinMode_setup()
{
//botoes , leds, buzzer
pinMode(buzzerPin, OUTPUT);
digitalWrite(buzzerPin, HIGH);
pinMode(led_synch, OUTPUT);
pinMode(laserPin, OUTPUT);
//motor A
pinMode(dir1PinA, OUTPUT);
//pinMode(dir2PinA, OUTPUT);
pinMode(speedPinA, OUTPUT);
//motor B
pinMode(dir1PinB, OUTPUT);
// pinMode(dir2PinB, OUTPUT);
pinMode(speedPinB, OUTPUT);
pinMode(2,INPUT);//interrupcao 0
pinMode(3,INPUT);//interrupcao 1
}
void motorA_frente()
{
digitalWrite(dir1PinA, HIGH);
}
void motorA_tras()
{
digitalWrite(dir1PinA, LOW);
}
void motorB_frente()
{
digitalWrite(dir1PinB, HIGH);
}
void motorB_tras()
{
digitalWrite(dir1PinB, LOW);
}
ARQUIVO timer2_sonar.pde
67
68
//Nunchuck
//for v1.6 Controle PsOne
// nesse caso ela eh usada apena para fazer o sync entre o carro e o controle
// pois os sync entre o controle e o arduino nano ocorre na funcao setup()
void(* resetFunc) (void) = 0; //declare reset function @ address 0
PS2X ps2x; // create PS2 Controller Class
//right now, the library does NOT support hot pluggable controllers, meaning
//you must always either restart your Arduino after you conect the controller,
//or call config_gamepad(pins) again after connecting the controller.
//led que indica se o controle esta funcionando ou nao
#define led_ok 13//A0
//defines do controle
#define botao_start PSB_START
#define botao_select PSB_SELECT
#define
#define
#define
#define
botao_cima PSB_PAD_UP
botao_direita PSB_PAD_RIGHT
botao_esquerda PSB_PAD_LEFT
botao_baixo PSB_PAD_DOWN
botao_X PSB_BLUE
botao_quadrado PSB_PINK
botao_circulo PSB_RED
botao_triangulo PSB_GREEN
69
void setup()
{
pinMode( led_ok , OUTPUT);
Serial.begin(9600);
//iniciando controle do playstation
//Conexao do dos fios: branco, azul(marrom)1,azul(marrom)2, verde
error = ps2x.config_gamepad(12,11,10,3, !true, !true);
//GamePad(clock, command,
attention, data, Pressures?, Rumble?) check for error
serch_error(error);
type = ps2x.readType();
//serch_type(type);
delay(10);
//inicializando controle Wii
nunchuk_init();
delay(20);
nunchuk_get_data();// escrevendo no buffer de saida do wii pela primeira vez
delay(300);
Serial.println("Controle Wii ... OK\nSynch Completo$");
Serial.print("$");
}
void loop()
{
if(error == 1) //playstation nao encontrado
{
digitalWrite(led_ok , HIGH);
return;
}
else { //DualShock Controller
digitalWrite(led_ok , LOW); // indicando que esta tudo certo com o controle
//lendo playstation
delay(tempo_para_inicio_envio/2);
ps2x.read_gamepad();
//lendo wii
delay(tempo_para_inicio_envio/4);
nunchuk_get_data();
//Hierarquia de comandos iniciais:
//
// 1) Nunchuck com botoes C e Z presionados
// 2) Botao C do nunchuck (mutuamente exclusivo em relacao ao botao Z)
// 3) Botao Z do nunchuck
// 4) Controle do playstation
if( nunchuk_cbutton() && nunchuk_zbutton() )
{
WiiNunchkMode_CarControl();
}
else
{
if( nunchuk_cbutton() )
{
WiiNunchkMode_x();
}
else if (nunchuk_zbutton() )
{
WiiNunchkMode_y();
}
else
{
delay(tempo_para_inicio_envio/4);
search_command();
}
}
}
delay(tempo_minimo_comunicacao);
70
}
void print_f()
{
Serial.print("caccelx: ");
Serial.print(nunchuk_caccelx());
Serial.print(" caccely: ");
Serial.print(nunchuk_caccely());
Serial.print(" caccelz: ");
Serial.print( nunchuk_caccelz());
Serial.print(" joy: ");
Serial.print(nunchuk_joyangle());
Serial.print(" roll: ");
Serial.print(nunchuk_rollangle());
Serial.print(" pitch: ");
Serial.println(nunchuk_pitchangle());
}
void serch_error(int error )
{
if(error == 0)
Serial.print("Controle Playstation ... OK\n");
else if(error == 1)
Serial.println("WARNING: NO CONTROLLER FOUND, CHECK WIRING\n");
else if(error == 2)
Serial.println("WARNING: CONTROLLER FOUND BUT NOT ACCEPTING COMMANDS\n");
else if(error == 3)
Serial.println("WARNING: CONTROLLER REFUSING TO ENTER PRESSURES MODE, MAY NOT SUPPORT
IT\n");
}
void serch_type(int type)
{
switch(type)
{
case 0:
Serial.println("UNKNOWN CONTROLLER TYPE");
break;
case 1:
Serial.println("DUALSHOCK CONTROLLER FOUND");
break;
case 2:
Serial.println("NO DUALSHOCK CONTROLLER FOUND");
break;
}
}
/*============================================================================*/
/*=========================> Nunchuk Library <================================*/
/*============================================================================*/
/*
* File : wiinunchuk.h V0.9
* Author: Tim Teatro
* Date : Feb 2012
*
* Description:
*
*
Library to set up and poll a Wii nunchuk with Arduino. There are
* many libraries available to do this, none of which I really liked.
* I was fond of Tod Kurt's, but his was incomplete as it did not work
* with knockoff nunchuks, it did not consider the least significant
* bits of accelerometer data and didn't have any advanced functions
* for processing the data such as calculating pitch and roll angles.
*
*
* Provides functions:
* void nunchuk_setpowerpins()
* void nunchuk_init()
* int nunchuk_get_data()
* void nunchuk_calibrate_joy()
* inline unsigned int nunchuk_zbutton()
71
72
73
74
75
ARQUIVO playstation_search_cmd.pde
void search_command()
{
if(ps2x.Button(botao_select)) // envia comando de soft rest para o carro
{
select();
}
else if(ps2x.Button(botao_quadrado))
// parar
{
quadrado();
}
else if(ps2x.Button(botao_cima)) // andar para frente
{
botao_cima_command();
}
else if(ps2x.Button(botao_direita))// rotacionar para direita
{
botao_direita_command();
}
else if(ps2x.Button(botao_esquerda))// rotacionar para esquerda
{
botao_esquerda_command();
}
76
ARQUIVO wiinunchuck_search_cmd.pde
//intervalos
//
Y
X
//
cima: -120
direta: +105
//
baixo: +120
esquerda: -105
void WiiNunchkMode_y()
{
int pos_y = nunchuk_pitchangle();
//filtrando
if( pos_y > 35 )
pos_y = 35;
if( pos_y < -35 )
pos_y = -35;
pos_y = map( pos_y , -30 , 35 , 1 ,179 );
Serial.print("%2,0");
Serial.println(pos_y);
Serial.print(",");
77
void WiiNunchkMode_x()
{
int pos_x = nunchuk_rollangle();
// Serial.print("\t pos x: ");
// Serial.println(pos_x);
if( pos_x > 53 )
pos_x = 53;
if( pos_x < -20 )
pos_x = -20;
pos_x = map( pos_x , -20 , 53 , 1 ,179 );
Serial.print("%2,");
Serial.print(pos_x);
Serial.println(",0");
}
void WiiNunchkMode_CarControl()
{
int pos_y = nunchuk_pitchangle();
if( pos_y > 35 )
{
pos_y = 35;
}
if( pos_y < 0 )
{
pos_y = 0;
}
int pos_x = nunchuk_rollangle();
//Serial.print("\t ");
// Serial.println(pos_x);
if( pos_x > 54 )// direita
{
pos_x = 54;
}
if( pos_x < -27 )// esquerda
{
pos_x = -27;
}
if( pos_x == 54 )
botao_direita_command();
else if( pos_x == -27 )
botao_esquerda_command();
else if( pos_y == 35 )
botao_cima_command();
else if( pos_y == 0 )
botao_baixo_command();
else
quadrado(); //parar sempre !
}
78
Arquivo command.pde
int t = 10;
void start()
{
resetFunc();
}
void select()
{
Serial.print("r");
}
void quadrado()
{
Serial.print("p");
}
void botao_cima_command()
{
Serial.print("w");
}
void botao_direita_command()
{
Serial.print("d");
}
void botao_esquerda_command()
{
Serial.print("a");
}
void botao_baixo_command()
{
Serial.print("s");
}
void circulo()
{
Serial.print("u");
}
void buzzer()
{
Serial.print("b");
}
void laser()
{
Serial.print("l");
delay(200);
}
void L1()
{
Serial.print("%"); // char para indicar servoMode
int pos_y2 = ps2x.Analog(PSS_RY);
int pos_x2 = ps2x.Analog(PSS_RX);
Serial.print("0,"); // just for comunication
Serial.print(pos_x2);
Serial.print(",");
Serial.println(pos_y2);
}
79
void L2()
{
Serial.print("%"); // char para indicar servoMode
int pos_y2 = ps2x.Analog(PSS_LY);
int pos_x2 = ps2x.Analog(PSS_RX);
Serial.print("0,");
Serial.print(pos_x2);
Serial.print(",");
Serial.println(pos_y2);
}
//========> IMPLEMENTACAO COMANDO ESPECIAIS(COMPOSTOS)
void L1_and_L2()
{
Serial.print("@");
de
de
de
de
comando
comando
comando
comando
para
para
para
para
80
Referncias
[1] Arduino.
Disponvel em:< http://arduino.cc/ >
Acesso em 16 de Abril. 2013.
[4] Monk, Simon. 30 Arduino Projects for the Evil Genius. New York: McGraw-Hill, 2010.
[5] C. Cardeira and J. S. Da Costa "A low cost mobile robot forengineering education",
IECON Proc., pp.2162 -2167 2005
[6] J. Hau-Shiue and L. Kai-Yew Design and control of a two-wheel self-balancing robot
using the arduino microcontroller board, in Control and Automation (ICCA), 2013 10th IEEE
International Conference on, pp. 634 639.
[7] P. Dong, G. Bilbro, and M. Chow, "Controlling a path-tracking unmanned ground vehicle
with a field-programmable analog array," in Advanced Intelligent Mechatronics. Proceedings,
2005 IEEE/ASME International Conference on. IEEE, pp. 1263-1268.
[8] Atmel.
Disponvel em: < http://www.atmel.com/devices/atmega328.aspx >
Acesso em 16 de Abril. 2013.
[11] Tim Teatro. A libray for using the Wii Nunchuck in Arduino Sketches.
Disponvel em: < http://www.timteatro.net/2012/02/10/a-library-for-using-the-wii-nunchuk-in-arduino-sketches/ >
Acesso em 16 de Abril. 2013
82