Curso Robótica – #4 – Primeira Programação

Se o nosso robot já estiver em 3 rodas, podemos levar com segurança a parte principal do curso ou a programação. Nós não vamos usar uma biblioteca pronta, vamos escrever tudo junto de um esboço vazio. Graças a isso, os problemas descritos podem ser facilmente aplicados a outros projetos.

Também vamos lidar com um problema frequente que surge quando construímos os primeiros robots.

 

Nesta fase, presumo que todos já se familiarizaram com a shield usada, que descrevi na segunda parte deste curso. Além do mais, ao lado do seu computador já deve ter um robot complexo que está pronto para a programação.

O curso se concentrará na construção e programação de robots , portanto, não há espaço para descrição dos fundamentos do Arduino. Pessoas que terão problemas com o básico da programação tentarão se referir aos locais apropriados do curso Arduino.

Para não danificar o robot e dirigir…

Antes de o robot se mover, vale a pena implementar alguns hábitos que reduzirão significativamente a chance de danos à estrutura. Durante a programação, desconecte a fonte de alimentação das unidades (usando o jumper apropriado no eixo). Graças a este robot, entre outros ele não vai cair da mesa…

void stopMotors() {
  analogWrite(L_PWM, 0); //Wylaczenie silnika lewego
  analogWrite(R_PWM, 0); //Wylaczenie silnika prawego
}

Programa pronto com funções

O programa básico que permitirá fácil diversão com o robot se parece com isso:

#define L_PWM 5
#define L_DIR 4
#define R_PWM 6
#define R_DIR 9
#define PWM_MAX 165
 
void setup() {
  //Konfiguracja pinow od mostka H
  pinMode(L_DIR, OUTPUT);
  pinMode(R_DIR, OUTPUT);
  pinMode(L_PWM, OUTPUT);
  pinMode(R_PWM, OUTPUT);
}
 
void loop() {
 
}
 
void leftMotor(int V) {
  if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia)
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(L_DIR, 0); //Kierunek: do przodu
    analogWrite(L_PWM, V); //Ustawienie predkosci 
  } else {
    V = abs(V); //Funkcja abs() zwroci wartosc V  bez znaku
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(L_DIR, 1); //Kierunek: do tyłu
    analogWrite(L_PWM, V); //Ustawienie predkosci    
  }
}
 
void rightMotor(int V) {
  if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia)
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(R_DIR, 0); //Kierunek: do przodu
    analogWrite(R_PWM, V); //Ustawienie predkosci 
  } else {
    V = abs(V); //Funkcja abs() zwroci wartosc V  bez znaku
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(R_DIR, 1); //Kierunek: do tyłu
    analogWrite(R_PWM, V); //Ustawienie predkosci    
  }
}
 
void stopMotors() {
  analogWrite(L_PWM, 0); //Wylaczenie silnika lewego
  analogWrite(R_PWM, 0); //Wylaczenie silnika prawego
}

Movimentos possíveis do robot

Agora vale a pena considerar os movimentos que um robot pode fazer. Nós temos uma unidade aqui, que consiste em dois motores controlados independentemente. Sem volantes, por isso não podemos falar sobre a direção aqui como num carro.

rightMotor(0); //Prawy wyłączony
leftMotor(60); //Lewy do przodu z 60% predkosci

No entanto, esse método de fazer turnovers é 
usado muito raramente.

Turnovers no local

Uma das possibilidades mais interessantes é o turnover realizado literalmente no lugar. Nosso robot também será capaz de fazer isso. É o suficiente para as rodas girarem em direções opostas:

Para executar tais manobras, os seguintes comandos devem ser emitidos. Para turnover à esquerda:

rightMotor(60); //Prawy do przodu z 60% predkosci
leftMotor(-60); //Lewy do tyłu z 60% predkosci

Para o turno certo:

rightMotor(-60); //Prawy do tyłu z 60% predkosci
leftMotor(60); //Lewy do przodu z 60% predkosci

Claro, outras opções também são possíveis. Ao controlar os motores em velocidades diferentes, poderemos navegar pelas curvas, etc. Encorajo-o a verificar os métodos descritos acima na prática. Deixe-me saber nos comentários se tem algum efeito interessante! Todos os materiais de vídeo são especialmente bem vindos!

Testes de possíveis movimentos na prática

Agora pode escrever programas que irão verificar como o robot lida com o passeio. A realização do percurso de amostra é como se segue:

#define L_PWM 5
#define L_DIR 4
#define R_PWM 6
#define R_DIR 9
#define PWM_MAX 165
 
void setup() {
  //Konfiguracja pinow od mostka H
  pinMode(L_DIR, OUTPUT);
  pinMode(R_DIR, OUTPUT);
  pinMode(L_PWM, OUTPUT);
  pinMode(R_PWM, OUTPUT);
}
 
void loop() {
  leftMotor(60); //Jazda do przodu z predkoscią 60%
  rightMotor(60); 
  delay(1000); //Jazda przez sekunde
  
  leftMotor(-50); //Obrot w miejscu z predkoscią 50%
  rightMotor(50); 
  delay(2000); //Czas trwania obrotu 2 sekundy
  
  leftMotor(-80); //Jazda do tyłu z predkoscią 80%
  rightMotor(-80); 
  delay(1000); //Jazda do tyłu przez sekunde
}
 
void leftMotor(int V) {
  if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia)
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(L_DIR, 0); //Kierunek: do przodu
    analogWrite(L_PWM, V); //Ustawienie predkosci 
  } else {
    V = abs(V); //Funkcja abs() zwroci wartosc V  bez znaku
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(L_DIR, 1); //Kierunek: do tyłu
    analogWrite(L_PWM, V); //Ustawienie predkosci    
  }
}
 
void rightMotor(int V) {
  if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia)
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(R_DIR, 0); //Kierunek: do przodu
    analogWrite(R_PWM, V); //Ustawienie predkosci 
  } else {
    V = abs(V); //Funkcja abs() zwroci wartosc V  bez znaku
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(R_DIR, 1); //Kierunek: do tyłu
    analogWrite(R_PWM, V); //Ustawienie predkosci    
  }
}
 
void stopMotors() {
  analogWrite(L_PWM, 0); //Wylaczenie silnika lewego
  analogWrite(R_PWM, 0); //Wylaczenie silnika prawego
}

Abaixo pode ver as tentativas com outros programas e configurações, eu encorajo toda a gente a fazer estes testes:

Por que o robot “não pode” ir direto?

Muitos iniciantes são muito triste quando o comando “para a frente” vê que o robot não se comporta como esperado.

Isso resultará num passeio de curva. Infelizmente, será, mas não é uma coisa má. Existem muitas razões. Lembre-se que os motores, engrenagens e rodas são elementos mecânicos… Nada é perfeito. Um motor será sempre um pouco mais rápido, uma transmissão colocará um pouco mais de resistência.

A soma de tais erros fará com que o robot sempre se transforme em um lado. Dirigir em linha reta é uma tarefa bastante complicada. As construções que precisam seguir em frente são equipadas com unidades mais caras, e sensores que realmente medem a velocidade do motor são frequentemente adicionados. O uso de programas mais avançados permite que você siga em frente.

“Curva” não é um problema de todo!

Dirigir em linha reta é necessário em algumas situações. Agora estamos testando o comportamento do robot com operações rigidamente programadas, de modo que a condução no arco será visível.

Na próxima parte do curso, adicionaremos sensores mecânicos de obstáculos que protegerão o robot contra colisão com a parede. Em vez de dirigir cegamente em direção a um obstáculo, ele poderá reagir ao ambiente e alterar a velocidade dos motores.


Se a diferença nas revoluções do motor for relativamente grande ou incomodar muito alguém, você poderá tentar corrigir o erro no programa. Apenas reduza alguns PWM_MAX para um mecanismo mais rápido. No entanto, esta solução pode revelar-se fatal. Eu os recomendo apenas na forma de testes. Durante as outras partes do curso, não precisa se preocupar com isso.

Tarefa adicional 4.2

Escreva um programa que segue a seguinte rota:

 

Tarefa Adicional 4.3

Escreva um programa que execute a tarefa de aumentar e diminuir suavemente a velocidade:

Sumário

Nesta parte do curso, revivemos o nosso veículo, que agora pode navegar pelas rotas programadas. Como parte do exercício, recomendo que escreva alguns programas, graças aos quais o robot poderá superar trajetórias imaginadas por os nossos leitores, como dirigir um retângulo, uma elipse, girar etc.

No próximo artigo, trataremos de sensores mecânicos de obstáculos, que permitirão a primeira condução autónoma do nosso veículo. Desta vez ele será capaz de evitar obstáculos sozinho!

Comentários

Deixe uma resposta

O seu endereço de email não será publicado. Campos obrigatórios marcados com *