LINUSBot - Line Follower Robot - Controle PID

LINUSBot - Controle PID

Este é um complemento do primeiro posto do LINUSBot.

Agora o controle dos movimentos do seguidor de linha é com PID; controle Proporcional, Integral, Derivativo. Isso torna os movimentos durantes as curvas muito mais suave e durante as retas, ele pode desenvolver maior velocidade, chegando à velocidade máxima.
O controle PID proporciona ao Robot uma "aprendizagem", fazendo com que o robot possa desenvolver melhor nas curvas e retas do circuito.

Agora vamos a uma breve introdução e resumo sobre o controle PID.
Basicamente, este tipo de controlador efetua as seguintes ações:

Sistema PID básico

1 - Controle Proporcional:
Multiplica o "erro" corrente por uma constante Kp.
O "erro", é a diferença entre a saída real e a saída desejada e é realimentado no sistema, ou seja: 
A saída real é subtraída da saída desejada (set point), assim, é calculado o erro.  Esse erro é inserido no controlador PID como entrada, e o controlador PID (calculando os termos P I D), comanda o sistema para tentar eliminar esse erro.
Garantindo assim o ganho necessário para chegar próximo do sinal de saída desejado o mais rápido possível e com a melhor estabilidade do sistema.

2 - Controle Integral:
O termo Integral, multiplica o erro corrente e sua duração por uma constante Ki, fazendo uma somátorio de toda essa informação.
O termo Integral quando somado ao termo Proporcional; acelera o processo de chegar ao estado estacionário do seu sistema, além de proporcionar um sinal mais próximo da saída desejada. Em outras palavras, ele também elimina (ou pelo menos tenta eliminar) a parcela residual de erro e chega mais rápido ao resultado desejado.


3 - Controle Derivativo:
O termo Derivativo, faz com que a razão de mudança do sinal de erro seja multiplicada por uma constante Kd. A intensão é predizer o erro e assim diminuir a taxa com que os erros produzem mudanças no sistema.



Podemos usar os 3 termos juntos para formar um controlador PID, ou suas variaçãoes, tais como:


Controlador P (algumas vezes utilizado):
Neste caso o uso de pequenos vlores da constante Kp é a melhor maneira de conseguir chegar ao valor desejado, mas o seu controle será lento (ele demora pra chegar ao valor desejado).  Se você aumentar o valor de Kp, sobre-impulsos podem ocorrer e o seu sistema ficará estável.



Controlador PI (mais usado):

Ele remove a parcela residual de erro no caso estacionário (melhorando a resposta a transientes), mas neste caso você poderá ter sobre-impulso e também inversão de estado, ocorrendo oscilação do sistema e causando instabilidade, podendo o sistema ser sobre-amortecido,  ou sub-amortecido, ou oscilatório.
Este tipo de controle deixa o sistema mais lento. Usando valores maiores de Ki, é possível deixar o sistema mais rápido, porem aumenta o sobre-impulso diminuíndo a margem de estabilidade do seu sistema.


Controlador PD (raramente utilizado):
Usado para diminuir a magnetude do sobre-impulso dos sistemas que usam Controlador Integral e melhorar a estabilidade do sistema. Porém o controle Derivativo, amplifica a magnetude de ruído do termo de erro do sistema e pode deixar o processo instável. O controlador PD diminui o tempo para chegar ao valor desejado, consideravelmente.... para isso o ganho derivativo Kd deve ser alto. Isso diminui o tempo de controle, porém aumenta a largura de banda do sistema, deixando o sistema susceptível a ruídos.


Controlador PID (algumas vezes utilizado):
Usando PID (combinação de PI+PD), removemos a razão de erro do sistema e diminuímos  o tempo da resposta com uma resposta transistória razoável (sem oscilações ou instabilidades).


Este estudo pode ser encontrado no link: http://www.youtube.com/watch?v=wbmEUi2p-nA

Esta é  o modo básico de implementação de um PID via software:


previous_error = 0
integral = 0 
start:
  error = setpoint - measured_value
  integral = integral + error*dt
  derivative = (error - previous_error)/dt
  output = Kp*error + Ki*integral + Kd*derivative
  previous_error = error
  wait(dt)
  goto start


Veja Mais em: http://en.wikipedia.org/wiki/PID_controller

No projeto do LINUSBot, foi usado os seguintes parãmetros:
Kp = 1/20 
Ki  = 1/10000
Kd = 3/2

O código completo pode ser baixado do link:


http://www.4shared.com/file/iPVAVCwy/LINUSBot_9_3pi_modelo_PID.html

Obtenha todos os arquivos necessários no GitHub:
https://github.com/Arduinobymyself/LINUSBot.git


Veja o vídeo do LINUSBot em ação e confira os resultados.

http://www.youtube.com/watch?v=FKq6WeBBH14

Dúvidas e sugestões para: arduinobymyself@gmail.com

CUBO de LEDs 3x3x3

CUBO de LEDs 3 x 3 x 3


Bem vindos!
Este é o meu primeiro projeto do Cubo de LEDs 3x3x3.
Este projeto foi baseado no projeto do colega GZIP: "LED Cube and Arduino Lib".
Vá até o site http://www.instructables.com/id/LED-Cube-and-Arduino-Lib/?ALLSTEPS,
Neste site, você encontrará todos os detalhes de construção do Cubo de LEDs e ainda a bibliotéca para Arduino com código exemplo.

No meu caso, eu tenho dois programas com diferentes efeitos para o Cubo de LEDs e diferentes estilos de programação.

O primeiro sketch ativa a comunicação serial e imprime o nome do efeito que está sendo executado.

O segundo sketch tem novos efeitos, usando uma outra codificação. Este código foi baseado no projeto do nosso colega "Stringstretcher" e pode ser encontrado no link abaixo.

http://www.instructables.com/id/3X3-LED-Cube-Programming-tips-Arduino-based/?ALLSTEPS

Os códigos e a bibliotéca, podem ser baixados diretamente do 4shared:


http://www.4shared.com/file/O4NfNmJw/MyLEDCube_1.html
http://www.4shared.com/file/yz2Oma8p/MyLEDCube_4.html


http://www.4shared.com/zip/GfdglOVq/LedCube.html


Todos os aquivos necessários estão aqui:

https://github.com/Arduinobymyself/LEDCube3x3x3.git

DIAGRAMA:

Detalhes de ligação dos pinos do arduino na placa de LEDs

VÍDEO:

Abaixo o vídeo de funcionamento do cubo de LED.
Está em Ingles, pois o blog está migrando para o site "Instructables".

Espero que gostem.
Qualquer dúvida entrem em contato e façam seus comentários no youtube e no blog.

Dúvidas e sugestões para: arduinobymyself@gmail.com

Obrigado a todos.

http://www.youtube.com/watch?v=IEv1FGR6Yhc

FOTOS:

L298N Ponte H Dupla - Breakout board feito em casa

L298N Breakout Board

Este é o projeto da Ponte H dupla com o CI L298N Multiwatt15.

A ponte H já foi discutida em outros tópicos deste blog, dessa forma não é objetivo deste posto entrar em detalhes. Vou ensinar, como construir uma Ponte H usando o CI L298 diretamente numa placa padrão perfurada, sem corroer uma placa de circuito impresso. Vamos então diretamente ao assunto.

Veja o original no meu Instructables: http://www.instructables.com/id/Dual-H-Bridge-L298-Breakout-Board-Homemade/

Passo 1 - Reúna todos os materiais necessários:

1 x placa perfurada padrão com 13x26 furos ou 3,5x7,0 cm;
1 x circuito integrado L298N;
1 x dissipador de calor (se for usar a ponte H para grandes correntes);
2 x AK300/3 - conector borne aparafusável;
1 x pin Header 8 vias, femea (como o do Arduino);
8 x diodos 1N4001;
2 x resistores de 0,47Ohm/2W;
2 x capacitores 100nF poliéster metalizado;
Fios, cabos, solda e ferramentas.

Passo 2 - Preparação da placa e componentes:

Corte, desbaste, lime, lixe e limpe a placa perfurada a ser utilizada.

Dobre e limpe os contatos/terminais dos componentes a ser utilizado.

Passo 3 - Identificar Furação:

Identifique na placa perfurada, toda a furação que será utilizada. Use o diagrama do projeto para esta etapa.

Passo 4 - Soldar Componentes:

Solde os componentes na placa, de acordo com o posicionamento indicado no projeto.
Solde-os em grupo, como por exemplo:
Primeiro os diodos; depois os conectores AK300/3 e PinHead; depois os resistores e capacitores; por último o CI L298N.

Passo 5 - Trilhas Soldadas:

Use o diagrama do projeto para soldar os pontos da placa perfurada de modo a fazer as trilhas entre os componentes.

Passo 6 - Trilhas Fiadas:

Use o diagrama do projeto para soldar os fios nas camadas superior e inferior, de modo a formar as trilhas com fios.

Passo 7 - Testes:



Para testar, foi usado o chassis do BUGBot para formar um carro controlado via BlueTooth o "Carro_BT-Bot (para o controle via android foi usado o programa "Blue Control" disponível no Market.

Conexões do arduino ao módulo BlueTooth:
Arduino -> BlueTooth
0 RX -> TX
1 TX -> RX
GND -> GND
VCC -> VCC

Conexões do Arduino ao módulo PONTE-H:
Arduino -> Ponte H
10 -> IN1
11 -> IN2
5   -> IN3
6   -> IN4
VCC -> VCC
GND -> GND

Conexões da PONTE-H aos Motores:
O1 -> pino 1 do motor 1 (direita)
O2 -> pino 2 do motor 1 (direita)
O3 -> pino 1 do motor 2 (esquerda)
O4 -> pino 2 do motor 2 (esquerda)

Conexões da PONTE-H:
VS -> +9V
GND -> GND

Diagrama esquemático:


Na figura você pode observar o diagrama da Ponte-H
e no link você pode baixar o original para Eagle Cad de uma versão mais aprimorada.

http://www.4shared.com/file/T17oVW-z/PONTE_H_L298N.html

http://www.4shared.com/file/6VdOTgv5/PONTE_H_L298N.html

Software utilizado:

Abaixo o software completo, e também o link para download.


http://www.4shared.com/file/YJX6-1UT/BlueTooth_Bot_R1.html

/*
#################################################################################
#   File:                          BlueTooth_Bot_R1.pde                                     
#   Micro controller:     Arduino UNO ou Teensy++ 2.0
#   Language:               Wiring / C /Processing /Fritzing / Arduino IDE  
#
# Objectives:               A bluetooth controlled cart
#          
# Funcionamento:       Just a simple test of the home L298N breakout Board
#
#
#   Author:             Marcelo Moraes
#   Date:                13/02/13
#   Place:              Sorocaba - SP - Brazil
#
#################################################################################

  This project contains code to the public domain.
The modification is permitted without notice.
*/




// definição de variáveis, constantes e valores

int inA1 = 10; // Pins for the PONTE-H
int inA2 = 11;
int inB1 = 5;
int inB2 = 6;



// Arduino initialization
void setup(){
  // Serial communication initialization
  Serial.begin(9600);
  // at the beginning motors stopped
  set_motors(0,0);
}

// loop principal do programa
void loop(){

  if (Serial.available() > 0){// if serial data are available
    char varC = Serial.read(); // reading the serial port data

    if(varC == 'U'){ // move forward
      set_motors(80,75);
      delay(1000);
      set_motors(0,0);
    }
    if(varC == 'D'){ // move backward
      set_motors(-80,-75);
      delay(1000);
      set_motors(0,0);
    }
    if(varC == 'C'){ // stopped
      set_motors(0,0);
    }
    if(varC == 'R'){ // turn right
      set_motors(80,-80);
      delay(500);
      set_motors(0,0);
    }
    if(varC == 'L'){ // turn left
      set_motors(-80,80);
      delay(500);
      set_motors(0,0);
    }
  }
}
//FIM DA COMPILAÇÃO


// running motors
void set_motors(int left_speed, int right_speed){
  if(right_speed >= 0 && left_speed >= 0){
    analogWrite(inA1, 0);
    analogWrite(inA2, right_speed);
    analogWrite(inB1, 0);
    analogWrite(inB2, left_speed);
  }
  if(right_speed >= 0 && left_speed < 0){
    left_speed = -left_speed;
    analogWrite(inA1, 0);
    analogWrite(inA2, right_speed);
    analogWrite(inB1, left_speed);
    analogWrite(inB2, 0);
  }
  if(right_speed < 0 && left_speed >= 0){
    right_speed = -right_speed;
    analogWrite(inA1, right_speed);
    analogWrite(inA2, 0);
    analogWrite(inB1, 0);
    analogWrite(inB2, left_speed);
  }
  if(right_speed < 0 && left_speed < 0){
    right_speed = -right_speed;
    left_speed = -left_speed;
    analogWrite(inA1, right_speed);
    analogWrite(inA2, 0);
    analogWrite(inB1, left_speed);
    analogWrite(inB2, 0);
  }
}




Vídeo:

Como fiz originalmente para o site Instructables, o vídeo está num Inglês (um tanto quanto pobre), mas é entendível.

Assista no youtube: http://youtu.be/0conwkmiAoM

Dúvidas e sugestões para: arduinobymyself@gmail.com