Desafio em robótica na UFSC

desafio em robótica
Católica de Santa Catarina

Seu nome
O que motivou você a participar do desafio?
Qual sua experiência com programação ou robótica?
Quais são seus planos para os próximos anos?
Como soube do desafio?

"um conjunto de passos para completar uma
tarefa."
Algoritmo
https://goo.gl/Psp5yU

algoritmos em ciência da
computação
exatidão e eficiência

compressão de áudio e vídeo

http://goo.gl/MMQqlj
O bote pode carregar apenas 2 pessoas por vez.
Apenas a mãe, o pai e o policial podem operar o bote.
A mãe não pode ser deixada sozinha com os filhos.
O pai não pode ser deixado sozinho com as filhas.
O ladrão não pode ser deixado sozinho com ninguém sem o policial.

estrutura sequencial
componentes
1 arduino uno
1 led
1 resistor 220Ω
fim componentes
início
criar novo projeto
procurar por componentes
adicionar componentes
configurar resistor
conectar componentes
iniciar simulação
parar simulação
fim

Algoritmo - Piscar LED
int led = 13; // variável led aponta para porta digital 13
void setup() {
pinMode(led, OUTPUT); // define a porta do LED como saída
}
void loop() {
digitalWrite(led, HIGH); // acende o LED
delay(1000); // espera por 1 segundo
digitalWrite(led, LOW); // apaga o LED
delay(1000); // espera por 1 segundo
}

estrutura condicional IF
se (condição) então
(consequência)
senão [se (outra condição)]
(alternativa)
fim se

Operadores condicionais (operadores lógicos)
== Comparação
!= Diferente
> Maior
< Menor
>= Maior igual
<= Menor igual

http://goo.gl/W9b28c

estrutura condicional
componentes
1 arduino uno
1 led
1 resistor 220Ω
1 resistor 1kΩ
1 push button (botão)
fim componentes
inicio
...
se botão pressionado então
acende LED
senão
apaga LED
fim

componentes
1 arduino uno
1 led
1 resistor 220Ω
1 resistor 1kΩ
1 push button (botão)
fim componentes
inicio
…
se botão pressionado então
acende LED
senão
apaga LED
fim

const int pinoBotao = 2; // botão está no pino 2
const int pinoLED = 13; // LED está no pino 13
int estadoBotao = 0; // variável de controle do botão
void setup() {
pinMode(pinoLED, OUTPUT); // define pino do LED como saída
pinMode(pinoBotao, INPUT); // define pino do botão como entrada
}
void loop() {
estadoBotao = digitalRead(pinoBotao); // atribui valor da variável de estado do botão
if (estadoBotao == HIGH) { // se o botão está pressionado
digitalWrite(pinoLED, HIGH); // acende o LED
} else {
digitalWrite(pinoLED, LOW); // apaga o LED
}
}
Algoritmo - Botão com LED

estrutura de repetição FOR
para (inicialização, condição, passo) faça
(consequência)
fim para

estrutura de repetição FOR
para (prato = 1, prato <= 5, prato + 1) faça
colocar o prato na máquina
fim para

LED PWM
componentes
1 arduino uno
1 led verde
1 resistor 220Ω
fim componentes
início
…
para força de 0 a 255 faça
aplica força ao LED
fim para
para força de 255 a 0
aplica força ao LED
fim para
fim

Algoritmo - LED PWM
int led = 11;
void setup() {
pinMode(led, OUTPUT);
}
void loop() {
for (int i = 0; i <= 255; i++) {
analogWrite(led, i);
delay(15);
}
for (int i = 255; i >= 0; i--) {
analogWrite(led, i);
delay(15);
}
}

estrutura de repetição
componentes
1 arduino uno
1 servo
fim componentes
inicio
…
para cada angulo entre 0 e 180 faça
aplica angulo ao servo
espera 15 milisegundos
fim para
para cada angulo entre 180 e 0 faça
aplica angulo ao servo
espera 15 milisegundos
fim para
fim

#include <Servo.h>
const int ANGULO_MIN = 0;
const int ANGULO_MAX = 180;
const int PINO_SERVO = 2;
int angulo = 0;
Servo servo;
void setup () {
servo.attach(PINO_SERVO);
}
void loop() {
for (angulo = ANGULO_MIN; angulo <= ANGULO_MIN; angulo++) {
servo.write(angulo);
delay(15);
}
}
Algoritmo - Servo

estrutura de repetição WHILE
enquanto (condição verdadeira) faça
consequência
fim enquanto

estrutura de repetição WHILE
enquanto (houver pratos na pilha) faça
retirar um prato da pilha
lavar o prato retirado
fim enquanto

estrutura de repetição DO WHILE
faça
consequência
enquanto (condição verdadeira)

estrutura de repetição DO WHILE
Programador encontrado morto na banheira cinco
dias após ter sido dado como desaparecido. Junto
a ele foi encontrado um shampoo com as seguintes
instruções: Lavar, enxaguar, repetir.

1. Modifique o algoritmo LED PWM
para utilizar a estrutura WHILE

2. Modifique o algoritmo LED PWM
para utilizar a estrutura DO WHILE

revisão aula 1
componentes
aluno(a)s muito querido(a)s e comportado(a)s
2 professores nem tão engraçados
fim componentes
inicio
introdução a algoritmos
introdução ao arduino
projetos muito loucos com Arduino
introdução à internet das coisas
exemplo com arduino
apresentação do desafio
apresentação do simulador 123d.circuits
estrutura sequencial
estruturas de repetição
exercicios
introdução a PWM
fim

exercício final
(vale um adesivo para quem terminar primeiro)

Crie um projeto Arduino para simular um semáforo com
efeito fade.
Luz verde deve permanecer totalmente acesa por 5 segundos
Luz amarela deve permanecer totalmente acesa por 2 segundos
Luz vermelha deve permanecer totalmente acesa por 7 segundos
Cada passo do fade out deve durar 15 milisegundos

até a próxima!
tem uma hora apenas e quer aprender mais sobre programação
https://goo.gl/OjCn5m
projetos legais
http://goo.gl/rCya1d (Instructables)
simulador
http://goo.gl/c3fG2B (123d.circuits)
algoritmos
https://goo.gl/Psp5yU (Khan Academy)
meu e-mail
natambarbosa@gmail.com
meu twitter
@natabarbosa

atribuição (relembrando)
Variáveis tem um tipo
int x;
Variáveis podem receber um valor
x = 9;

operadores aritméticos (relembrando)
Operador Exemplo Resultado
+ a = 2 + 1 3
- b = 4 - 2 2
* c = 9 * 9 81
/ d = c / a 27
% d % 5 2
Variáveis do topo int são definidas com valor 0 por padrão.

chega de simulador.
vamos lá pra fora!

1. Emite pulso
2. Para de emitir pulso
3. Mede tamanho do pulso retornado como distância até objeto
mais próximo
4. Converte distância para centímetros

● 1 sensor na frente
● 1 sensor atrás
● 0 = branco, 1024 = preto

● Sentido horário e antihorário
● Controle de velocidade via PWM
● Motor para entrega de cédulas em máquinas caça níquel

● Sentido horário e antihorário
● Controle de velocidade via PWM
● Esteira de cédulas em máquinas caça níquel

● Permite controlar 2 motores DC
● Ligado em 12v
● Fornece 5v para o Arduino

● Bateria do robô
● Feita com Lithium de baterias de notebook

#include "motor.h"
#include "sensor_ultrasonico.h"
#include "sensor_reflexo.h"

const int ULTRASONICO_LEITURA = 9;
const int ULTRASONICO_EMISSAO = 8;
sensorUltrasonico ultrasonico;
...
ultrasonico = iniciaSensorUltrasonico(ULTRASONICO_LEITURA, ULTRASONICO_EMISSAO);
...
long distancia = leUltrasonico(ultrasonico);

const int REFLEXO_FRENTE_AN = 1;
const int REFLEXO_COSTAS_AN = 0;
sensorReflexo reflexo;
...
reflexo = iniciaSensorReflexo(REFLEXO_FRENTE_AN, REFLEXO_COSTAS_AN);
...
long reflexoFrente = leituraReflexo(LEITURA_REFLEXO_FRENTE, reflexo);
long reflexoCostas = leituraReflexo(LEITURA_REFLEXO_COSTAS, reflexo);

const int PWM_MOTOR_1 = 6;
const int CONTROLE_MOTOR_1_DIR_1 = 7;
const int DIRECAO_FRENTE = 8;
const int DIRECAO_ESQUERDA = 4;
const int DIRECAO_DIREITA = 6;
const int DIRECAO_PARADO = 5;
const int DIRECAO_REVERSO = 2;
...
motores = iniciaMotores(PWM_MOTOR_1,
PWM_MOTOR_2,
CONTROLE_MOTOR_1_DIR_1,
CONTROLE_MOTOR_2_DIR_2);
...
controlaMotores(motores, DIRECAO_REVERSO, 1, 1, 1200); // 1 = potência, 1200 = tempo
controlaMotores(motores, DIRECAO_FRENTE, 1, 1, 0);
controlaMotores(motores, DIRECAO_ESQUERDA, 0.5, 0.5, 0); // 0.5 = potência, 0 = tempo
controlaMotores(motores, DIRECAO_DIREITA, 0.5, 0.5, 0);

INVERTER MOTOR
componentes
1 arduino uno
1 controlador de motor
2 motores
1 sensor ultra-sônico
fim componentes
início
…
inclui bibliotecas
inicia componentes
se algo está 10cm ou menos à frente do sensor então
inverter motores
senão
liga motores para frente
fim se
fim
#include "motor.h"

#include "motor.h"
driverMotor motores;
// Pinos
const int DIRECAO_REVERSO = 2;
...
Algoritmo - Inverter Motor

...
void setup(){
PWM_MOTOR_2,
Serial.begin(9600);
}
void loop(){
Serial.print("distância: ");
Serial.print(distancia);
Serial.println("cm");
if (distancia <= 10) {
controlaMotores(motores, DIRECAO_REVERSO, 1, 1, 1200);
} else {
}
Algoritmo - Inverter Motor

PARAR MOTOR
componentes
1 arduino uno
2 motores
2 sensores reflexo
fim componentes
início
…
inclui bibliotecas
inicia componentes
se a cor branca é detectada então
parar motores
senão
liga motores
fim se
fim
#include "motor.h"

#include "motor.h"
sensorReflexo reflexo;
// Pinos
const int DIRECAO_PARADO = 5;
const int REFLEXO_FRENTE_AN = 1;
const int REFLEXO_COSTAS_AN = 0;
const int COR_BRANCO_LIMITE = 550;
const int LEITURA_REFLEXO_FRENTE = 1;
const int LEITURA_REFLEXO_COSTAS = 2;
...
Algoritmo - Parar Motor

...
void setup(){
PWM_MOTOR_2,
reflexo = iniciaSensorReflexo(REFLEXO_FRENTE_AN, REFLEXO_COSTAS_AN);
Serial.begin(9600);
}
void loop(){
long reflexoFrente = leituraReflexo(LEITURA_REFLEXO_FRENTE, reflexo);
long reflexoCostas = leituraReflexo(LEITURA_REFLEXO_COSTAS, reflexo);
if (reflexoFrente < COR_BRANCO_LIMITE || reflexoCostas < COR_BRANCO_LIMITE) {
controlaMotores(motores, DIRECAO_PARADO, 1, 1, 0);
} else {
}
}
Algoritmo - Parar Motor

POTÊNCIA DO MOTOR RELATIVA À DISTÂNCIA
componentes
1 arduino uno
2 motores
1 sensor ultra-sônico
fim componentes
início
…
inclui bibliotecas
inicia componentes
inicia motor com potência relativa à distância do objeto mais próximo
fim
#include "motor.h"

#include "motor.h"
// Pinos
...
Algoritmo - Potência relativa à distância

...
void setup(){
PWM_MOTOR_2,
Serial.begin(9600);
}
void loop(){
float potencia = (float) (1.0 - ( (float) distancia) / 255.0);
Serial.print("distância: ");
Serial.print(distancia);
Serial.println("cm");
Serial.print("potência: ");
Serial.print(potencia);
if (potencia >= 0 && potencia <= 1) {
controlaMotores(motores, DIRECAO_FRENTE, potencia, potencia, 1200);
}
}
Algoritmo - Potência relativa à distância

revisão aula 2
componentes
aluno(a)s muito querido(a)s e comportado(a)s
2 professores muito engraçados
1 robô matador
fim componentes
inicio
correção de exercícios
prêmios de robótica da catolica sc
apresentação do projeto dos alunos
apresentação do protótipo
apresentação dos componentes
apresentação das bibliotecas de programação
exercicios
fim

até a próxima!
projeto dos colegas: Oficina de Arduino Joinville
https://www.facebook.com/groups/oficinadearduinojoinville/
meu e-mail
natambarbosa@gmail.com
meu twitter
@natabarbosa

RobotChallenge Vienna
Mini Sumo

Site da Competição
http://goo.gl/BvFeTg

Regras Básicas
➔ 1 robô por equipe
➔ Objetivo = empurrar o oponente para fora do dojô
➔ 1 round = 1 minuto
➔ 1 partida = no máximo 3 rounds
➔ O primeiro a fazer 2 pontos ganha a partida

Regras de Tempo
➔ Robôs devem permanecer paralisados por 5 segundos ao início de cada round
➔ Tempo máximo de partida sem acréscimos = 3 minutos
➔ Tempo máximo de partida com acréscimos = 4 minutos e 30 segundos
➔ Acréscimo de 30 segundos ao tempo de round pode ser concedido pelo juíz
➔ Caso o tempo limite seja excedido antes de alguma equipe fazer 2 pontos, a equipe com 1 ponto
ganha a partida

Pode
Modificar o programa entre partidas
Entrar na área de competição entre rounds
para manusear o robô
Trocar bateria do robô entre partidas
Torcer para o robô
Comemorar vitórias
Chorar por derrota
NÃO pode
Modificar o programa entre rounds
Entrar na área de competição durante um
round
Paralisação do robô por mais de 5
segundos, exceto no início do round
(ponto para o oponente)
Demorar mais do que 30 segundos para
começar novo round
Insultar a equipe adversária ou insultar o
robô oponente
Contestar a decisão do juíz

Resultado
1° Lugar: Os Newbinha (Colégio Estadual Juracy Maria Brosing)
2° Lugar: AACD (E.E.B. Alicia Bittencourt Ferreira e E.E.B. Marli Maria de Souza)
3° Lugar: LTF (Colégio Estadual Juracy Maria Brosing)
4° Lugar: Alexitimia
5° Lugar: Heber Core e Paranauê
Resultados Completos: http://goo.gl/hxiEPm

Desafio em robótica na UFSC

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (16)

Destaque

Destaque (20)

Semelhante a Desafio em robótica na UFSC

Semelhante a Desafio em robótica na UFSC (20)

Desafio em robótica na UFSC