1ª Competição de Robôs Autônomos Seguidores de linha

A 1ª competição de robôs autônomos seguidores de linha está chegando, e os alunos Daniel de Castro e Laryssa Abreu já estão se aquecendo para levar o título de campeão! 

Não perca seu tempo, agende seu horário!

Módulo RFID

A identificação por rádio frequência ou RFID (Radio Frequency IDentification), é uma tecnologia de comunicação que utiliza ondas eletromagnéticas para poder identificar, ler e gravar informações de forma automática com o intuito de agilizar e automatizar processos.

Os leitores RFID (conhecidos como transceptores) ficam transmitindo uma requisição de identificação para as tags, e as que estão dentro da frequência e ao alcance do mesmo, responde com um código de identificação.

A forma mais comum de utilização do RFID é na identificação de produtos, onde uma tag pode conter informações como código do produto, procedência, data de validade, fabricante, etc. Mas a sua utilização não se restringe a isso. Podemos usar etiquetas RFID em animais para fins de rastreamento, em veículos no conhecido sistema Sem Parar, em passaportes, rastreamento de cargas, controle de acesso e em várias outras aplicações.

 Módulo RFID RC522 para Arduino. É capaz de ler tags que operam na frequência de 13,56 Mhz, e suporta cartões do tipo Mifare1 S50, Mifare1 S70  Mifare Ultralight, Mifare Pro e Mifare DESFire.

Controle de acesso com RFID

Utilizando o Arduino, podemos montar um controle de acesso que verifica o número da TAG e libera (ou não), a passagem por uma cancela controlada por um servo motor. No esquema abaixo foi utilizado o motor microservo 9G.

Esse controle de acesso utiliza o circuito abaixo, lembrando mais uma vez que a alimentação do módulo RFID é feita por meio do pino 3.3V, e o servo motor é alimentado por 5V, por isso atenção na montagem para não inverter as ligações:

Fonte: 

http://www.arduinoecia.com.br/2014/12/controle-de-acesso-modulo-rfid-rc522.html

http://labdegaragem.com/profiles/blogs/tutorial-utilizando-leitor-e-tags-rfid

Observação: Alunos interessados no hackathon da UNIMED, o RFID pode ser necessário na elaboração do projeto. 

Robô para 1ª Competição de seguidor de linha Newton

Robô autônomo seguindo um pequeno trajeto.

Observação: Este é exatamente o robô que sera utilizado na 1ª Competição de seguidor de linha da Newton!

Marcação de horário para treinamento da 1ª Competição de Seguidor de Linha da Newton

Pessoal, inscrevam-se pelo blog para que suas equipes possam treinar para a competição. Lembrando que ela ocorrerá nos dias 26 e 27 de abril. O agendamento é feito neste link:

Esperamos vocês aqui!!!

Robô para 1ª Competição de seguidor de linha Newton

Estruturas de Controle - Arduino

Estruturas de controle são blocos de instruções que alteram o fluxo de execução do código de um programa. Com elas é possível fazer coisas como executar comandos diferentes de acordo com uma condição ou repetir uma série de comandos várias vezes, por exemplo.
A seguir nós veremos algumas das estruturas de controle mais comuns usadas nas linguagens de programação em geral. Vamos também modificar o nosso programa de teste para exemplificar melhor como essas estruturas funcionam.

While

O while é uma estrutura que executa um conjunto de comandos repetidas vezes enquanto uma determinada condição for verdadeira. While em inglês quer dizer "enquanto", e pronuncia-se "uái-ou". Ele segue o seguinte formato:

while(condição) {
    ...
}

Vamos então fazer uma modificação no nosso programa para exemplificar melhor como o while funciona. O nosso objetivo agora é fazer o LED piscar três vezes, depois esperar cinco segundos, piscar mais três vezes e assim por diante. Nós vamos mudar o conteúdo da função loop() para o seguinte:

  // Variável para contar o número de vezes que o LED piscou
  int i = 0;
  
  // Pisca o LED três vezes
  while(i < 3) {
    digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED, acendendo-o
    delay(1000);             // Espera 1000 milissegundos (um segundo)
    digitalWrite(led, LOW);  // Atribui nível lógico baixo ao pino do LED, apagando-o
    delay(1000);             // Espera 1000 milissegundos (um segundo)
    i = i + 1;               // Aumenta o número de vezes que o LED piscou
  }
  
  delay(5000);               // Espera 5 segundos para piscar o LED de novo

Primeiro nós declaramos uma variável i. Essa variável vai contar quantas vezes o LED já piscou desde o início do programa ou desde a última pausa de cinco segundos. Nós vamos inicializar essa variável com zero porque no início da função loop() o LED ainda não piscou nenhuma vez sob essas condições.
Em seguida nós inserimos o comando while, que deve ser seguido de uma condição definida entre parênteses. Enquanto essa condição for verdadeira, todo o bloco de comandos entre os caracteres { e } é executado repetidamente. No caso do nosso programa, enquanto o número de "piscadas" do LED (representado pela variável i) for menor do que três, nós continuamos a executar os comandos que fazem o LED piscar. Isso é representado pela expressão i < 3 dentro dos parênteses.
Entre os caracteres { e } nós colocamos o código que faz o LED piscar, como anteriormente, mas não podemos nos esquecer de somar 1 à variável que conta o número de "piscadas". Isso é feito na seguinte linha de código:

    i = i + 1;               // Aumenta o número de vezes que o LED piscou

Veja que após executar todos os comandos entre { e }, sempre teremos na variável i o número de vezes que o LED piscou desde o início da função loop(). Vamos percorrer a sequência de passos executada cada vez que a função loop() é chamada:

1. Atribuímos 0 à variável i: o LED ainda não piscou nenhuma vez.
2. Comparamos se i < 3: como 0 é menor do que 3, executamos os comandos entre { e }:
   1. Executamos os comandos para acender e apagar o LED.
   2. Somamos 1 à variável i, tornando-a 1: sabemos que o LED piscou uma vez.
3. Voltamos ao início do while e comparamos se i < 3: como 1 é menor do que 3, executamos os comandos entre { e } novamente:
   1. Executamos os comandos para acender e apagar o LED.
   2. Somamos 1 à variável i, tornando-a 2: sabemos que o LED piscou duas vezes.
4. Voltamos ao início do while e comparamos se i < 3: como 2 é menor do que 3, executamos os comandos entre { e } novamente:
   1. Executamos os comandos para acender e apagar o LED.
   2. Somamos 1 à variável i, tornando-a 3: sabemos que o LED piscou três vezes.
5. Voltamos ao início do while e comparamos se i < 3: como 3 não é menor do que 3, não executamos mais os comandos entre { e } e prosseguimos à próxima instrução.
6. Esperamos cinco segundos por meio da chamada delay(5000).

Após esses passos, chegamos ao final da função loop(), e como já sabemos, ela é chamada novamente pelo sistema do Arduino. Isso reinicia o ciclo, executando os passos acima indefinidamente.
Rode o programa modificado com as instruções acima no seu Arduino e tente variar o número de "piscadas" e o número

For

Agora que nós já aprendemos o comando while, fica muito fácil aprender o comando for, pois ele é quase a mesma coisa. Vamos modificar o conteúdo da função loop() como fizemos acima, porém usando o for no lugar do while:

  // Variável para contar o número de vezes que o LED piscou
  int i;
  
  // Pisca o LED três vezes
  for(i = 0; i < 3; i++) {
    digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED, acendendo-o
    delay(1000);             // Espera 1000 milissegundos (um segundo)
    digitalWrite(led, LOW);  // Atribui nível lógico baixo ao pino do LED, apagando-o
    delay(1000);             // Espera 1000 milissegundos (um segundo)
  }
  
  delay(5000);               // Espera 5 segundos para piscar o LED de novo

A primeira modificação que fizemos foi declarar a variável i sem inicializá-la com o valor 0. Nós podemos fazer isso porque o comando for fará isso para a gente. Ele segue o seguinte formato:

for(inicialização; condição; finalização) {
    ...
}

Vamos descrever cada item separadamente:

• Condição: é uma expressão verificada repetidamente, de forma idêntica à condição entre parênteses do while. Enquanto ela for verdadeira, os comandos entre { e } continuam sendo executados.
• Inicialização: é um comando executado apenas uma vez no início do comando for.
• Finalização: é um comando executado repetidas vezes ao final de cada execução dos comandos entre { e }.

Podemos então verificar que o for nada mais é do que um while acrescido de um comando de inicialização e um comando de finalização. Para o nosso programa de teste, esses comandos são, respectivamente:

• i = 0: inicializa a contagem do número de "piscadas".
• i++: soma 1 à variável i ao final da execução dos comandos entre { e }; nesse caso ele é equivalente ao comando i = i + 1. O operador ++ é chamado de operador de incremento, e é muito usado na linguagem C++.

Se executarmos o programa acima no Arduino, veremos que o resultado é o mesmo que obtivemos com o programa que fizamos anteriormente utilizando o while.

If

O if é uma das estruturas mais básicas de programação em geral. If significa "se" em inglês, e é exatamente isso que ele faz: ele verifica uma expressão e, apenas se ela for verdadeira, executa um conjunto de comandos. Em linguagem natural, ele executa uma lógica do tipo: "se isso for verdadeiro, então faça aquilo"
Para ilustrar, vamos modificar o nosso programa de exemplo para que ele faça a mesma coisa que fizemos com o while e o for acima, porém vamos fazer isso usando um if, que segue o seguinte formato:

if(condição) {
    ...
}

A lógica é muito simples: sempre que a condição vor verdadeira, os comandos entre { e } são executados, caso contrário o programa prossegue sem executá-los. Vamos ver então como fica a função loop():

// Variável para contar o número de vezes que o LED piscou
int i = 0;

void loop() {
  digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED, acendendo-o
  delay(1000);             // Espera 1000 milissegundos (um segundo)
  digitalWrite(led, LOW);  // Atribui nível lógico baixo ao pino do LED, apagando-o
  delay(1000);             // Espera 1000 milissegundos (um segundo)
  
  i++;                     // Incrementa o número de "piscadas"
  if(i == 3) {
    delay(5000);           // Espera 5 segundos para piscar o LED de novo  
    i = 0;                 // Reinicia o contador de número de "piscadas"
  }
}

Aqui a lógica é um pouco diferente: nós vamos manter a função loop() piscando o LED como no programa original, porém vamos inserir uma espera adicional de 5 segundos após cada 3 piscadas. Para isso, criamos uma variável i fora da função loop(); ela precisa ser declarada de fora da função para poder reter o seu valor entre cada execução da função loop(). Chamamos isso de variável global. Quando a variável é declarada dentro do corpo da função, ela não retém o valor etnre cada execução, sendo reiniciada a cada vez que a função é re-executada. Chamamos isso de variável local.
Nós usaremos então essa variável global i para contar, novamente, o número de vezes que o LED acendeu e apagou. Na declaração da variável, nós a inicializamos com o valor 0 para indicar que o LED não acendeu nenhuma vez ainda. A função loop() então começa a ser executada, acendendo e apagando o LED. Para contar o número de vezes que o LED piscou, nós adicionamos a seguinte linha de código:

  i++;                     // Incrementa o número de "piscadas"

Em seguida utilizamos o if para verificar se acabamos de acender o LED pela terceira vez. Para isso, usamos a expressão i == 3 na condição do ìf. Se essa expressão for verdadeira, isso que dizer que o LED já acendeu 3 vezes, então inserimos uma pausa adicional de 5 segundos com a chamada delay(5000) e reiniciamos a contagem do número de "piscadas" novamente com o seguinte comando:

    i = 0;                 // Reinicia o contador de número de "piscadas"

A partir daí a função loop() continua sendo chamada e o ciclo se inicia novamente.

If-Else

O if-else, também conhecido como if-then-else, pode ser visto como uma extensão do comando if. Else em inglês significa "caso contrário", e ele faz exatamente o que o nome diz: "se isso for verdadeiro, então faça aquilo, caso contrário, faça outra coisa". Ele segue o seguinte formato:

if(condição) {
   ...
} else {
   ...
}

Para exemplificar, vamos usar o programa do for que mostramos acima, mas vamos dessa vez fazer o LED acender e apagar quatro vezes antes de dar uma pausa de cinco segundos. Depois vamos fazer com que na terceira de cada uma dessas quatro "piscadas", o LED acenda por um período mais curto. Dentro da função loop(), teremos o seguinte:

  // Variável para contar o número de vezes que o LED piscou
  int i;
  
  // Pisca o LED três vezes
  for(i = 0; i < 3; i++) {
    if(i == 2) {
      digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED, acendendo-o
      delay(200);              // Espera 200 milissegundos (um segundo)
      digitalWrite(led, LOW);  // Atribui nível lógico baixo ao pino do LED, apagando-o
      delay(1800);             // Espera 1800 milissegundos (um segundo)
    } else {
      digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED, acendendo-o
      delay(1000);             // Espera 1000 milissegundos (um segundo)
      digitalWrite(led, LOW);  // Atribui nível lógico baixo ao pino do LED, apagando-o
      delay(1000);             // Espera 1000 milissegundos (um segundo)
    }
  }
  
  delay(5000);               // Espera 5 segundos para piscar o LED de novo

Aqui o que fazemos é, toda vez que vamos acender o LED, verificar se é a terceira vez que isso acontece, por meio do comando if com a condição i == 2. Se essa expressão for verdadeira, isso quer dizer que já acendemos o LED duas vezes e estamos prestes a acendê-lo pela terceira vez; nesse caso mudamos o tempo que o LED fica acaso para um valor menor, de 0,2 segundo (uma redução de 0,8 segundo) e o tempo que ele fica apagado para um valor maior, de 1,8 segundos (aumento de 0,8 segundo).
Mas e se essa não for a terceira vez que o LED está sendo acionado? É aí que entra o else: se a condição do if for verdadeira, o bloco de comandos entre { e } logo após o if é executado, caso contrário, o bloco entre { e } após o else é executado. Isso quer dizer que para a primeira, segunda e quarta "piscadas" será usado o tempo padrão de um segundo.

Fonte:  www.circuitar.com.br/tutoriais/programacao-para-arduino-primeiros-passos/#estruturas-de-controle

Módulo Ponte H

O que é uma Ponte H?

Na maioria das abordagens em robótica faz-se necessária a utilização de motores DC em diversos tipos de locomoção de robôs, movimentação de braços mecânicos, etc. Os motores DC (direct current ou corrente continua) são cargas indutivas que, em geral, demandam uma quantidade de corrente superior à que as portas do Arduino conseguem fornecer.

Exemplo de motor DC

Sendo assim, não devemos ligar estes motores diretamente nas portas do Arduino pois se o motor demandar uma corrente acima de 40mA nas portas digitais (máxima fornecida pelo Arduino) pode queimar a porta e danificar a placa.

Para solucionar a questão da alta corrente poderíamos usar transistores, porém é importante que seja possível controlar o sentido de giro do motor, função que não se faz possível usando apenas um transistor já que para inverter o sentido de giro devemos inverter a polaridade da alimentação do motor (onde era positivo se põe negativo e vice-versa). Um transistor só seria suficiente para ligar e desligar o motor.

Para resolver nosso problema utilizamos um famoso circuito conhecido como Ponte H que nada mais é que um arranjo de 4 transistores. Este circuito é uma elegante solução por ser capaz de acionar simultaneamente dois motores controlando não apenas seus sentidos, como também suas velocidades. Além de seu uso ser simples no Arduino.

Mas como funciona a Ponte H? Porque este nome?

As pontes H em possuem este nome devido ao formato que é montado o circuito, semelhante a letra H. O circuito utiliza quarto chaves (S1, S2, S3 e S4) que são acionadas de forma alternada, ou seja, (S1-S3) ou (S2-S4), veja as figuras abaixo. Dependendo da configuração entre as chaves teremos a corrente percorrendo o motor hora por um sentido, hora por outro.

Circuito Ponte H

Quando nenhum par de chaves está acionado, o motor está desligado (a). Quando o par S1-S3 é acionado a corrente percorre S1-S3 fazendo com que o motor gire em um sentido (b). Já quando o par S2-S4 é acionado a corrente percorre por outro caminho fazendo com que o motor gire no sentido contrário (c).

Modulo de Ponte H

Esses módulos são muito utilizados em aplicações de robótica. Eles possuem dimensões pequenas e já possuem o circuito básico para o uso do CI, o que facilita na acomodação do módulo no robô ou em outros projetos e a sua utilização.

Existem várias opções disponíveis no mercado, com tamanhos e especificações diferentes. Algumas especificações são importantes ao escolher seu módulo, são elas:

• Especificação de potência máxima fornecida;
• Tensão máxima suportada;
• Corrente máxima suportada;
• Tensão lógica.

 

Módulo Ponte H com CL L298N

Agora que já sabemos como a Ponte H funciona, vamos entender  na prática como podemos usá-las em conjunto com o Arduino. Para isso iremos usar o módulo com CI L298N.

Entradas e Saídas

Para começa vamos entender função de cada pino bem como deve ser utilizado.

Entradas e saídas do módulo

• Motor A e Motor B: Conectores para os dois motores
• 6-35V: Porta para alimentação da placa com tensão entre 6 a 35V.
• Ativa 5V: Quando jumpeado, a placa utilizará o regulador de tensão integrado para fornecer 5v (na porta 5v) quando a porta 6-35V estiver sendo alimentada por uma tensão entre 6 e 35V. Neste caso, não se deve alimentar a porta 5V pois pode danificar os componentes. A tensão fornecida na porta 5V pode ser usada para alimentar o Arduino, por exemplo.
• 5v: Em casos de não haver fonte de alimentação com mais de 6V podemos alimentar a placa com 5V por esta porta.
• Ativa MA: Quando jumpeado aciona o motor A com velocidade máxima. Para controlar a velocidade do motor A basta remover o jumper e alimentar o pino com uma tensão entre 0 e 5v, onde 0V é a velocidade mínima (parado) e 5V a velocidade máxima.
• Ativa MB: Quando jumpeado aciona o motor B com velocidade máxima. Para controlar a velocidade do motor B basta remover o jumper e alimentar o pino com uma tensão entre 0 e 5v, onde 0V é a velocidade mínima (parado) e 5V a velocidade máxima.
• IN1 e IN2:são utilizados para controlar o sentido do motor A;
• IN3 e IN4: são utilizados para controlar o sentido do motor B;

Veja que agora, no lugar das chaves S1-S3 e S2-S4 temos os pinos IN1 e IN2. Onde IN1 corresponde às chaves S1-S3 e a IN2 às chaves S3-S4.

Para controlar o sentido, temos as seguintes combinações para o motor A(IN1 e IN2)

Tabela de combinações

Para o motor B (IN3 e IN4), a tabela funciona da mesma forma.

Ponte H com Arduino – Exemplo de Código Básico

Vamos fazer um exemplo para testar na pratica a ponte h. Neste primeiro exercício queremos testar o controle do sentido de giro dos motores A e B através do Arduino.

Para este exemplo, utilizaremos:

• Arduino UNO
• Ponte H
• 2 Motores DC 12V (pode ser feito com apenas 1)
• Fonte alimentação de 12V

Prossiga com a montagem conforme esquema abaixo (caso você use apenas um motor, basta desconsiderar o motor B:
Garanta que seu Arduino e a fonte externa estejam desligados durante a montagem.

Esquema de montagem do exemplo

Agora vamos à implementação do programa. Dessa forma, dentro da IDE Arduino: escreva o seguinte código e ao final clique em Upload para que o programa seja transferido para seu Arduino.

/*Pinagem do arduino*/

//motor A

int IN1 = 2 ;

int IN2 = 3 ;

//motor B

int IN3 = 4 ;

int IN4 = 5 ;

//Inicializa Pinos

void setup(){

     pinMode(IN1,OUTPUT);

     pinMode(IN2,OUTPUT);

     pinMode(IN3,OUTPUT);

     pinMode(IN4,OUTPUT);

}

void loop(){

 /*Inicio dos Estados do motor A*/

     //Sentido Horario

    digitalWrite(IN1,HIGH);

    digitalWrite(IN2,LOW);

    delay(5000);

 //Freia Motor

    digitalWrite(IN1,HIGH);

    digitalWrite(IN2,HIGH);

    delay(5000);

 //Sentido Anti-Horario

    digitalWrite(IN1,LOW);

    digitalWrite(IN2,HIGH);

    delay(5000);

//Freia Motor

    digitalWrite(IN1,HIGH);

    digitalWrite(IN2,HIGH);

    delay(5000);

 /*Fim dos Estados do motor A*/

 /*Inicio dos Estados do motor B*/

   //Sentido Horario

    digitalWrite(IN3,HIGH);

    digitalWrite(IN4,LOW);

    delay(5000);

   //Freia Motor

    digitalWrite(IN3,HIGH);

    digitalWrite(IN4,HIGH);

    delay(5000);

  //Sentido Anti-Horario

    digitalWrite(IN3,LOW);

    digitalWrite(IN4,HIGH);

    delay(5000);

  //Freia Motor

    digitalWrite(IN3,HIGH);

    digitalWrite(IN4,HIGH);

    delay(5000);</pre>

/*Fim dos Estados do motor B*/

}



Fonte: http://blog.vidadesilicio.com.br/arduino/modulo-ponte-h-l298n-arduino/

Sensor "Seguidor de Linha"

A utilização de robôs para a exploração de locais inseguros para seres humanos vem sendo cada vez mais frequente. Estes equipamentos são criados para se comportarem de forma autônoma e responderem de acordo com o ambiente em que se localizam sem qualquer intervenção de um operador humano. 

Os sensores seguidores de linha são um tipo de sensor de presença e podem ser utilizados para a construção de carrinhos seguidores de linha (robôs seguidores de linha). Normalmente utilizados em competições de robôs seguidores de linha criadas por estudantes de engenharia, sua função é fazer com que o robô seja capaz de identificar uma linha desenhada no chão (normalmente uma linha preta sobre um piso branco), seguindo-a até completar um circuito previamente desenhado. O mesmo princípio de funcionamento poderia ser utilizado em robôs de inspeção que precisam se deslocar de forma autônoma em terrenos que possuem padrões em seu piso. Neste caso, bastaria programar o robô para que o padrão existente fosse reconhecido a partir dos sinais entregues pelo sensor seguidor de linha.

O sensor infravermelho (IR) possui um circuito transmissor e um receptor, posicionados um ao lado do outro. Quanto um objeto ou pessoa passa em frente ao sensor, o sinal IR é refletido e detectado pelo receptor, que coloca o pino de saída em nível baixo (LOW), e aciona um led localizado na parte traseira do sensor.

Você pode alterar a distância de detecção e a sensibilidade do sensor girando os parafusos também localizado na parte traseira. O ajuste fica entre 3 e 80cm. Esse sensor pode ser facilmente utilizado não só com o Arduino como também com outros microcontroladores.

Veja a seguir um sketch para arduino imprimindo determinada frase se a linha for detectada ou não pelo sensor seguidor de linha.

//definindo a porta 8 para o sensor.

#define IR_F 8

void setup() {

    Serial.begin(9600);

//Seta o pino IR-F como entrada
    pinMode(IR_F, INPUT);

}

void loop()
{

int ValorSensor=digitalRead(IR_F);

            if (ValorSensor==1)

           {

                        Serial.println("Linha Detectada!!!");

}

else

{

        Serial.println("Linha NÃO Detectada!!!");

}

}


Veja a seguir um vídeo mostrando o funcionamento do sensor de linha.

 Fonte: 

• http://blog.filipeflop.com/sensores/sensor-infravermelho-arduino.html
• http://labdeeletronica.com.br/sensor-de-linha-arduino/

1ª Competição de Robôs Autônomos Seguidores de Linha

O Centro Universitário Newton Paiva convida os alunos para participar da 1ª Competição de Robôs Autônomos Seguidores de Linha, com o intuito de promover a disseminação e compartilhamento do conhecimento de prototipagem eletrônica e robótica nesta instituição e na comunidade.

A modalidade da competição é de robôs seguidores de linha, onde estes deverão ser autônomos e utilizar apenas os componentes fornecidos pela organização do evento. Veja no vídeo abaixo um exemplo de robôs seguidores de linha.

Os grupos participarão de rodadas eliminatórias em tomadas de tempos em um circuito a ser divulgado nos dias da competição. Os grupos poderão ser formados por alunos de quaisquer cursos do Centro Universitário Newton Paiva, e conter até no máximo 8 alunos.

Para mais informações consulte o regulamento e faça sua inscrição: 

Inscrição: Clique aqui!

Regulamento: Clique aqui!