Wall - e: teste de motores e primeiro seguidor de linha

//Programa de teste dos motores
// pinos dos motores
int motor_d1 = 4;
int motor_d2 = 5;
int motor_e1 = 6;
int motor_e2 = 7;

//controles dos motores
int veloc = 255; //usar valores de 0 a 255 para controlar a velocidade
int virar = 30; // este valor controla a curva que o robô faz

void setup() {
 //controle de motores
 pinMode (motor_d1, OUTPUT);
 pinMode (motor_d2, OUTPUT);
 pinMode (motor_e1, OUTPUT);
 pinMode (motor_e2, OUTPUT);
}

void loop() {
frente();
delay (3000);
direita();
delay (3000);
esquerda();
delay (3000);
pare();
delay (3000);
}// fim do loop  

// controles dos motores
void frente (){
  analogWrite (motor_d1, veloc);
  analogWrite (motor_d2, 0);
  analogWrite (motor_e1, veloc);
  analogWrite (motor_e2, 0);
}
void re (){
  analogWrite (motor_d1, 0);
  analogWrite (motor_d2, veloc);
  analogWrite (motor_e1, 0);
  analogWrite (motor_e2, veloc);
}

void direita (){
  analogWrite (motor_d1, veloc);
  analogWrite (motor_d2, 0);
  analogWrite (motor_e1, 0);
  analogWrite (motor_e2, veloc);
  delay (virar);
}

void esquerda (){
  analogWrite (motor_d1, 0);
  analogWrite (motor_d2, veloc);
  analogWrite (motor_e1, veloc);
  analogWrite (motor_e2, 0);
 delay (virar);
}

void pare (){
  analogWrite (motor_d1, 0);
  analogWrite (motor_d2, 0);
  analogWrite (motor_e1, 0);
  analogWrite (motor_e2, 0);
}

//---------------------------------------------------------------------------//

// Programa de seguidor de linha inicial

int preto_d_min = 1023;

int preto_e_min = 1023;

int preto_d = 0;

int preto_e = 0;

int x = 0;

int botao;

int t = 45; //regulagem que varia de 0 a 90 - controla o quanto vira

int margem = 0; //regulagem que varia de 0 a 1023

// pinos dos motores

int motor_d1 = 4;

int motor_d2 = 5;

int motor_e1 = 6;

int motor_e2 = 7;

//controles dos motores

int veloc = 255; //usar valores de 0 a 255 para controlar a velocidade

int virar = 30; // este valor controla a curva que o robô faz

void setup() {

  // put your setup code here, to run once:

  pinMode (2, INPUT);

  pinMode (3, INPUT);

  pinMode (A0, INPUT);

  pinMode (13, OUTPUT);

 //controle de motores

 pinMode (motor_d1, OUTPUT);

 pinMode (motor_d2, OUTPUT);

 pinMode (motor_e1, OUTPUT);

 pinMode (motor_e2, OUTPUT);

 

  Serial.begin (9600);

  botao = analogRead (A0);

  Serial.println (botao);

  while(botao>200){

  digitalWrite (13, HIGH);

  delay (300);

  digitalWrite (13, LOW);

  delay (300);

  botao = analogRead (A0);

  }

for (x=10; x>0; x--){

  digitalWrite (13, HIGH);

delay (100);

preto_d = analogRead (A1);

preto_e = analogRead (A2);

if (preto_d<preto_d_min){

  preto_d_min=preto_d;

}

if (preto_e<preto_e_min){

  preto_e_min=preto_e;

}

Serial.println (x);

}

digitalWrite (13, LOW);

Serial.print ("direito= ");

Serial.print (preto_d_min);

Serial.print ("\t");

Serial.print (" esquerdo= ");

Serial.println (preto_e_min);

for (int y=0; y<10; y++){

digitalWrite (13, HIGH);

delay (100);

digitalWrite (13, LOW);

delay (100);

}

delay (3000);

}

void loop() {

  // put your main code here, to run repeatedly:

int sensor_d = analogRead (A1);

int sensor_e = analogRead (A2);

Serial.print ("direito= ");

Serial.print (sensor_d);

Serial.print ("\t");

Serial.print (" esquerdo= ");

Serial.println (sensor_e);

//siga em frente

if(sensor_d<preto_d_min-margem&&sensor_e<preto_e_min-margem){

frente();

}

//vire a direita

if(sensor_d>preto_d_min-margem&&sensor_e<preto_e_min-margem){

direita();

}

//vire a esquerda

if(sensor_d<preto_d_min-margem&&sensor_e>preto_e_min-margem){

esquerda();

}

//cruzamento

if(sensor_d>preto_d_min-margem&&sensor_e>preto_e_min-margem){

pare();

}

}// fim do loop    

// controles dos motores

void frente (){

  analogWrite (motor_d1, veloc);

  analogWrite (motor_d2, 0);

  analogWrite (motor_e1, veloc);

  analogWrite (motor_e2, 0);

}

void re (){

  analogWrite (motor_d1, 0);

  analogWrite (motor_d2, veloc);

  analogWrite (motor_e1, 0);

  analogWrite (motor_e2, veloc);

}

void direita (){

  analogWrite (motor_d1, veloc);

  analogWrite (motor_d2, 0);

  analogWrite (motor_e1, 0);

  analogWrite (motor_e2, veloc);

  delay (virar);

}

void esquerda (){

  analogWrite (motor_d1, 0);

  analogWrite (motor_d2, veloc);

  analogWrite (motor_e1, veloc);

  analogWrite (motor_e2, 0);

 delay (virar);

}

void pare (){

  analogWrite (motor_d1, 0);

  analogWrite (motor_d2, 0);

  analogWrite (motor_e1, 0);

  analogWrite (motor_e2, 0);

}

Teste Akira com calibração para mínimo

int preto_d_min = 1023;
int preto_e_min = 1023;
int preto_d = 0;
int preto_e = 0;

int x = 0;

int botao;

int t = 45; //regulagem que varia de 0 a 90 - controla o quanto vira
int margem = 0; //regulagem que varia de 0 a 1023


#include <Servo.h>

Servo motor_d;  // create servo object to control a servo
Servo motor_e;              // twelve servo objects can be created on most boards

// controle dos motores
int frente_d = 12;
int frente_e = 118;
int re_d = 118;
int re_e = 12;
int pare = 90;

void setup() {
  // put your setup code here, to run once:
  pinMode (A4, INPUT);
  pinMode (A5, INPUT);
  pinMode (A0, INPUT);
  pinMode (13, OUTPUT);
 //controle de motores
 motor_d.attach(4);  // attaches the servo on pin 9 to the servo object
 motor_e.attach(5);
 motor_d.write (90);
 motor_e.write (90);

  Serial.begin (9600);
  botao = analogRead (A0);
  Serial.println (botao);
  while(botao>200){
  digitalWrite (13, HIGH);
  delay (300);
  digitalWrite (13, LOW);
  delay (300);
  botao = analogRead (A0);
  }

for (x=10; x>0; x--){
  digitalWrite (13, HIGH);
delay (100);
preto_d = analogRead (A1);
preto_e = analogRead (A2);
if (preto_d<preto_d_min){
  preto_d_min=preto_d;
}
if (preto_e<preto_e_min){
  preto_e_min=preto_e;
}
Serial.println (x);
}
digitalWrite (13, LOW);

Serial.print ("direito= ");
Serial.print (preto_d_min);
Serial.print ("\t");
Serial.print (" esquerdo= ");
Serial.println (preto_e_min);

for (int y=0; y<10; y++){
digitalWrite (13, HIGH);
delay (100);
digitalWrite (13, LOW);
delay (100);
}
delay (3000);
}

void loop() {
  // put your main code here, to run repeatedly:
int sensor_d = analogRead (A1);
int sensor_e = analogRead (A2);
Serial.print ("direito= ");
Serial.print (sensor_d);
Serial.print ("\t");
Serial.print (" esquerdo= ");
Serial.println (sensor_e);

//siga em frente
if(sensor_d<preto_d_min-margem&&sensor_e<preto_e_min-margem){
motor_d.write(frente_d);
motor_e.write(frente_e);
}
//vire a direita
if(sensor_d>preto_d_min-margem&&sensor_e<preto_e_min-margem){
motor_d.write(re_d);
motor_e.write(frente_e);
delay(t);
}
//vire a esquerda
if(sensor_d<preto_d_min-margem&&sensor_e>preto_e_min-margem){
motor_d.write(frente_d);
motor_e.write(re_e);
delay(t);
}
//cruzamento
if(sensor_d>preto_d_min-margem&&sensor_e>preto_e_min-margem){
motor_d.write(pare);
motor_e.write(pare);
}


}// fim do loop  

Akira seguidor de linha 2016 calibração branco e preto

//Versão corrigida para uso dos botões e com as informações de motor
//controles de calibração
int branco_d = 0;
int branco_e = 0;
int preto_d = 0;
int preto_e = 0;
int ldr_d;
int ldr_e;
int x = 0;
int botao;
int calibracao_d;
int calibracao_e;

int margem = 0; //controle proporcional do robô para ajuste de sensibilidade

// Controle d configuração dos motores
int frente_d = 30;
int frente_e = 150;
int re_d = 150;
int re_e = 30;
int pare = 90;

//controle de velocidade do robô
int t=15;

#include <Servo.h>
Servo motor_d;
Servo motor_e;
//pinos e variaveis
int emisor=11;
int receptor=12;
long cml,duracao;

void setup (){
Serial.begin(9600);
motor_d.attach(4);
motor_e.attach(5);
pinMode(13,OUTPUT);
pinMode(emisor,OUTPUT);
pinMode(receptor,INPUT);

//motor parado
motor_d.write(pare);
motor_e.write(pare);
//calibração
 botao = analogRead (A0);
  Serial.println (botao);
  while(botao>200){
  digitalWrite (13, HIGH);
  delay (300);
  digitalWrite (13, LOW);
  delay (300);
  botao = analogRead (A0);
  Serial.println (botao);
  }
for (x=0; x<10; x++){
  digitalWrite (13, HIGH);
delay (100);
ldr_d = analogRead (A1);
ldr_e = analogRead (A2);
branco_d = branco_d + ldr_d;
branco_e = branco_e + ldr_e;
Serial.println (x);
}
digitalWrite (13, LOW);
branco_d = branco_d/10;
branco_e = branco_e/10;
Serial.print ("branco direito= ");
Serial.print (branco_d);
Serial.print ("\t");
Serial.print ("branco esquerdo= ");
Serial.println (branco_e);
delay(5000);
Serial.println (x);
  botao = analogRead (A0);
  Serial.println (botao);
  while(botao>200){
  digitalWrite (13, HIGH);
  delay (300);
  digitalWrite (13, LOW);
  delay (300);
  botao = analogRead (A0);
  }
for (x=10; x>0; x--){
  digitalWrite (13, HIGH);
delay (100);
ldr_d = analogRead (A1);
ldr_e = analogRead (A2);
preto_d = preto_d + ldr_d;
preto_e = preto_e + ldr_e;
Serial.println (x);
}
digitalWrite (13, LOW);
preto_d = preto_d/10;
preto_e = preto_e/10;

Serial.print ("preto direito= ");
Serial.print (preto_d);
Serial.print ("\t");
Serial.print ("preto esquerdo= ");
Serial.println (preto_e);
delay(3000);

for (int y=0; y<10; y++){
digitalWrite (13, HIGH);
delay (250);
digitalWrite (13, LOW);
delay (250);
}

}


void loop (){
sonar();
int sensor_d=analogRead(A1);
int sensor_e=analogRead(A2);


Serial.print(sensor_d);
Serial.print("\t");
Serial.println(sensor_e);
Serial.print("\t");
Serial.println(cml);

//siga em frente
if(sensor_d<preto_d&&sensor_e<preto_e){
motor_d.write(frente_d);
motor_e.write(frente_e);
delay (t);
}
//vire a direita
if(sensor_d>preto_d&&sensor_e<preto_e){
motor_d.write(re_d);
motor_e.write(frente_e);
delay(t);
}
if(sensor_d<preto_d&&sensor_e>preto_e){
motor_d.write(frente_d);
motor_e.write(re_e);
delay(t);
}
if(sensor_d>preto_d&&sensor_e>preto_e){
motor_d.write(pare);
motor_e.write(pare);
}
/*inicio do desviar
if(cml<5){
 //parar
 motor_d.write(90);
 motor_e.write(90);
 delay(500);
 //virar a esquerda
 motor_d.write(0);
 motor_e.write(0);
 delay(1100);
 //andar
 motor_d.write(180);
 motor_e.write(0);
 delay(1700);
//virar a direita
 motor_d.write(180);
 motor_e.write(180);
 delay(1100);
 //andar
 motor_d.write(180);
 motor_e.write(0);
 delay(1700);
 //virar a esquerda
 motor_d.write(0);
 motor_e.write(0);
 delay(1100);
}
*/
}//fim do loop

int sonar(){
  digitalWrite(emisor,LOW);
  delayMicroseconds(2);
  digitalWrite(emisor,HIGH);
  delayMicroseconds(10);
  digitalWrite(emisor,LOW);
  duracao= pulseIn(receptor,HIGH);
  cml=microsecondstocentimeters(duracao);
  return cml;
}

long microsecondstocentimeters(long microseconds){
return microseconds/29/2;
}

Controle da garra do akira com suavização

#include <Servo.h>

Servo garra_d;
Servo garra_e;
Servo elevador;

int x =0;
float pos_d = 90;
int pos_e= 115;
int controle = 50;
int z=0;
int pos_elev=130;

void setup()
{
garra_d.attach(6);
garra_e.attach (7);
elevador.attach (8);
garra_d.write (pos_d);
garra_e.write (pos_e);
elevador.write (pos_elev);
Serial.begin (9600);
}

void loop()
{
  //abaixa a garra
for (z=0; z<=40;z++){
  elevador.write (pos_elev);
  pos_elev = pos_elev-1;
  Serial.println (pos_elev);
  delay (25);
}
delay (5000);
//subir a garra
for (z=40; z>=0;z--){
  elevador.write (pos_elev);
  pos_elev = pos_elev+1;
  Serial.println (pos_elev);
  delay (25);
}
delay (5000);
//abrir a garra
for (x=0; x<=controle;x++){
  Serial.print (pos_d);
  Serial.print ("\t");
  Serial.println (pos_e);
  garra_d.write (pos_d);
  garra_e.write (pos_e);
  delay (25);
  pos_d = pos_d+1.7;
  pos_e = pos_e-1;
}
delay (5000);
//fechar a garra
for (x=controle; x>=0;x--){
  Serial.print (pos_d);
  Serial.print ("\t");
  Serial.println (pos_e);
  garra_d.write (pos_d);
  garra_e.write (pos_e);
  delay (25);
  pos_d = pos_d-1.7;
  pos_e = pos_e+1;
}
delay (5000);
}//fim do loop

Depois de executar este programa, tornar cada for uma função void para controlar a garra:
void abrir_garra();
void fechar_garra();
void elevar_garra();
void abaixar_garra();

Acrescentar a função do servo e testar com objeto a distância de ser pego na garra.

Seguidor de linha com calibração

#include <Servo.h>

int x = 0;

int preto_d_min=1023;

int preto_e_min=1023;

// torna o sensor mais sensível

int margem= 25;

int sensor_d;

int sensor_e;

// controle dos motores: aqui tem q colocar o resultado do teste de motores

Servo motor_d;

Servo motor_e;

int frente_d = 45;

int re_d= 135;

int frente_d = 135;

int re_d= 45;

int virar = 150;

int t= 15;

void led(){

digitalWrite (13, HIGH);

delay (500);

digitalWrite (13, LOW);

delay (500);

digitalWrite (13, HIGH);

delay (500);

digitalWrite (13, LOW);

delay (500);

digitalWrite (13, HIGH);

delay (500);

digitalWrite (13, LOW);

delay (500);

}

void loop( ){

pinMode (13, OUTPUT);

led();

// aqui se realiza a calibração

for (x=0; x<10; x++){

delay (50);

sensor_d = analogRead (A6);

sensor_e = analogRead (A5);

if (sensor_d<preto_d_min){

preto_d_min = sensor_d;

}

if (sensor_e<preto_e_min){

preto_e_min = sensor_e;

}

}// fim do for

led();

motor_d.attach (4);

motor_e.attach (5);

led();

}//fim do setup

void loop( ){

sensor_d = analogRead (A6);

sensor_e = analogRead (A5);

if (sensor_d<preto_d_min+margem&&sensor_e<preto_e_min){

motor_d.write (frente_d);

motor_e.write (frente_e);

delay (t);

}

if (sensor_d>preto_d_min+margem&&sensor_e<preto_e_min){

motor_d.write (re_d);

motor_e.write (frente_e);

delay (virar);

}

if (sensor_d<preto_d_min+margem&&sensor_e>preto_e_min){

motor_d.write (frente_d);

motor_e.write (re_e);

delay (virar);

}

if (sensor_d>preto_d_min+margem&&sensor_e>preto_e_min){

motor_d.write (90);

motor_e.write (90);

delay (100);

}

}//fim do loop

cedula de votação elza

Cédula de votação Elza

Controle de abrir e fechar a garra

#include <Servo.h>

Servo garra_d;
Servo garra_e;
Servo elevador;

int emissor=10;
int receptor=9;
long cm, duracao;

int aberto_d= 0;
int aberto_e= 0;
int fechado_d=0;
int fechado_e=0;
int abaixa = 0;
int levanta = 90;

int x;
int distancia;

void setup(){
pinMode (emissor, OUTPUT);
pinMode (receptor, INPUT);

garra_d.attach (9);
garra_e.attach (10);
elevador.attach (11);

garra_d.write (aberto_d);
garra_e.write (aberto_e);
elevador.write (levanta);
}

void loop(){

distancia = sonar();
  Serial.print(inches);
  Serial.print("in, ");
  Serial.print(cm);
  Serial.print("cm");
  Serial.println();
  delay(100);

if (distancia>5 cm){
Serial.println ("sem objeto a frente");
garra_d.write (aberto_d);
garra_e.write (aberto_e);
elevador.write (levanta);
digitalWrite (13, HIGH);
}

if (distancia<5 cm){
Serial.println ("objeto a frente");
digitalWrite (13, LOW);
elevador.write (abaixa);
garra_d.write (fechado_d);
garra_e.write (fechado_e);
}

}

int sonar (){
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(pingPin, LOW);

  duracao = pulseIn(pingPin, HIGH);

  cm = microsecondsToCentimeters(duracao);


}


long microsecondsToCentimeters(long microseconds) {
  return microseconds / 29 / 2;
}

Arenas da OBR 2015

#include <Servo.h>

Servo garra_d;

Servo garra_e;

Servo elevador;

int aberto_d=0;

int aberto_e=0;

int fechado_d=90;

int fechado_e=90;

int levantar = 0;

int abaixar = 0;

int x;

void setup() {

  // put your setup code here, to run once:

garra_d.attach (8);

garra_e.attach (9);

elevador.attach (10);

garra_d.write (aberto_d);

garra_e.write (aberto_e);

elevador.write (levantar);

x=aberto+d;

}

void loop() {

  // put your main code here, to run repeatedly:

delay (1500);

for (x=aberto; x<fechado_d; x++){

garra_d.write (aberto_d+x);

garra_e.write (aberto_e-x);

delay (15);

}

delay (2000);

for (x=fechado_d; x>aberto_d; x--){

garra_d.write (fechado_d-x);

garra_e.write (fechado_e+x);

delay (15);

}

}