Câmera IP Robô com MT7688

Trago hoje uma câmera IP robotizada. O que isso significa? Hoje em dia, as câmeras são Pan-tilt, ou seja, com controle direcional e zoom remoto, ou então são fixas. E, essa que vamos falar é diferente: você pode mover essa câmera através de um controle e transmitir a imagem capturada por meio da internet. Nesse projeto utilizo o MT7688 e um arduino que já vem dentro dele.

Vamos, portanto, tratar nessa aula da aplicação com o Linkit Smart Duo, que é o MT7688. Vou te mostrar o Tanque FPV com controle por Web Server. Ainda, mudar Linkit Smart Duo para Station Mode, adicionar Webcam para visão FPV do tanque, adicionar arquivos no Linkit por comandos terminais no Putty, além da comunicação entre o controle e o tanque.

Recursos usados

·         Carcaça de tanque de controle remoto

·         Linkit 7688 Duo

·         1 Câmera Logitech C270

·         1 Servo MG90S

·         1 Driver de motor L298N

·         1 Driver de motor L293D

·         1 Regulador de tensão step-down

·         3 Transistores BC337

·         6 Suportes duplos para bateria

·         12 Bateria de li-ion 4,2v

·         Celular

Montagem

PinOut Linkit Smart 7688 Duo

Linkit Smart 7688 Duo - Arduino Uno

LINKIT PARA STATION MODE

Conectar no Linkit

O Linkit por padrão vem em AP Mode. Mas é necessário utilizar a rede para fazer o download das libs dentro do Linkit, então é preciso mudar para Station Mode para ter acesso a rede.

Ligue o Linkit Smart Duo.

Conecte na rede wifi do Linkit

Logar no Linkit

Acesse o IP padrão no navegador : 192.168.100.1

*Adicione uma senha.

Faça o Login clicando em “Sign In”.

*Salve a senha do Linkit pois será utilizada nos passos a frente.

Atualização do Linkit para a nova versão

Após logar é necessário atualizar o Linkit para a utilização de todos os novos recursos.

Clique nesse link, baixe a versão 0.9.4 e descompacte o zip.

Em “System Information” na parte de “Software Information” clique em “Upgrade Firmware”.

Clique em “Choose the file”, navegue até onde foi descompactado a versão 0.9.4, selecione o arquivo “lks7688.img” e depois em clique em “Upgrade e Restart”.

Linkit de AP Mode para Station Mode

Após a atualização estar concluída, conecte novamente ao Linkit, abra o IP “192.168.100.1” no navegador, logue e clique em “Network”.

Clique em Station Mode, selecione sua rede Wifi, coloque a senha e clique em “Configure e Restart”. Pronto, o Linkit vai reiniciar e ligar em Station Mode.

ADICIONAR WEBCAM PARA VISÃO FPV DO TANQUE

FPV é a sigla em inglês para “First Person View”, que significa visão em primeira pessoa.

Para adicionar a webcam no Linkit é muito simples, é necessário apenas um cabo OTG e conectar o cabo na entrada “USB Host” com a webcam.

ADICIONAR ARQUIVOS NO LINKIT UTILIZANDO O PUTTY

Descobrir IP do Linkit

Após mudar o Linkit de AP para Station mode, o seu IP tambem vai mudar. Para encontrar o novo IP é utilizado o programa gratuito Angry IP Scanner para fazer a varredura dos IPs e encontrar o Linkit.

                O download pode ser feito aqui. 

                Execute o programa e clique em “Iniciar”.

Após terminar de escanear os IPs, procure pelo Nome do Host de “LINKIT”. Assim que encontrar, é possível saber em qual IP o Linkit esta.

Acessar Linkit por SSH

Para acessar o Linkit por SSH é necessário o uso do PutTTY.

                Instale o PutTTY.

Abrir conexão SSH com PuTTY

Abra o PuTTY.

                Digite o IP em que o Linkit está no campo “Host Name (or IP andress)” e clique em “Open”.

Logando no PuTTY

Após abrir a janela do PuTTY informe o login (“root” por padrão) e a senha do Linkit.

Utilizando o PuTTY

Agora dentro do PuTTY é necessário digitar os comandos para posicionar e adicionar os arquivos e bibliotecas dentro do Linkit.

                Como o Linkit é capaz de rodar um sistema operacional Linux, os comandos digitados são os mesmo digitados em um terminal linux.

                A preparação do Linkit para os arquivos estarem nos diretórios corretos é feita a partir de uma sequência de comandos no terminal Linux.

Lista de comandos Linux no PuTTY

Copie os seguintes comandos no PuTTY respeitando a ordem:

COMUNICAÇÃO DO PROJETO

init.cgi (python)

COMUNICAÇÃO DA PÁGINA WEB

Comunicação entre a página HTML e o node

Após cada comando na página, esse comando é enviado via WebSocket para o arquivo node para ocorrer o pré-processamento dos dados.

                Esses dados são enviados pela porta 8001, setado nos arquivos index.html e fpvtanque.js, para alterar a porta basta mudar em ambos os arquivos.

COMUNICAÇÃO ENTRE NODE E O ARDUINO VIA SERIAL

Após o arquivo node receber dados da página, os dados são tratados e enviados via Serial para o arduino.

                O arduino recebe via serial os dados e seta os pinos.

INICIALIZAR O WEBSERVER

Inicializar comunicação

Para inicializar a comunicação, montar a página e transmitir o vídeo da webcam é necessário digitar o IP do linkit seguido de “/cgi-bin/init.cgi”.

                               <IP Linkit>/cgi-bin/init.cgi

                Como por exemplo o Linkit localizado no IP 192.168.0.117 a URL ficaria o seguinte:

                               192.168.0.117/cgi-bin/init.cgi

                É possível também alterar a resolução e a quantidade de frames pela URL utilizando “r” e o “f” de parâmetros, como por exemplo, resolução de 640x480 e com 30 frames ficaria:

                               192.168.0.117/cgi-bin/init.cgi?r=320x240&f=30

Exemplo do navegador

Após carregar a página clique em “tanque” para abrir o controle do tanque com a visão em primeira pessoa da webcam.

Controle do tanque (navegador)

Para controlar a velocidade e direção do tanque basta clicar e arrastar para direção desejada.

                Quanto maior a seta, maior a velocidade.

Controle do tanque (celular)

PREPARANDO ARDUINO IDE

Para preparar o Arduino IDE, você deve abrir a IDE Arduino, ir até preferências da IDE e clicar em Addicional Boards Manager URL’s ou URLs adicionais para gerenciadores de Placas

Adicione a seguinte url e clique em OK:

http://download.labs.mediatek.com/package_mtk_linkit_smart_7688_index.json

Abra o gerenciador de placas da IDE clicando em Ferramentas -> Placa -> Gerenciador de Placas. Digite linkit na busca e instale a LinkIt Smart 7688 Duo.

CÓDIGO

Declarações e variáveis

//Include do servo
#include <Servo.h>
Servo servoCamera;
//Pinos dos PWM
#define PinS 3 //servo
#define PinT 5 //motor torre
#define PinMD 6 //motor direito
#define PinME 13  //motor esquerdo
//Pinos dos Motores das Esteiras
#define MDA 20  //motor direito A
#define MDB 21  //motor direito B
#define MEA 22  //motor esquerdo A
#define MEB 23  //motor esquerdo B
//Pinos dos Motores da Torre
#define MTA 18  //motor torre A
#define MTB 19  //motor torre B
//Pinos dos Leds
#define LED1 14  
#define LED2 15  
#define LED3 16
//Váriaveis para controle dos LEDS
bool aux=false;
int tower = 0;

Setup

void setup()
{ 
  //Serial para informar valores
  Serial.begin(115200); 
  //Serial para comunicação com o arquivo node que recebe os comandos
  Serial1.begin(115200); 
  
  //Setando os pinos de saida
  pinMode(PinMD, OUTPUT);
  pinMode(PinME, OUTPUT);
  pinMode(MDA, OUTPUT);
  pinMode(MDB, OUTPUT);
  pinMode(MEA, OUTPUT);
  pinMode(MEB, OUTPUT);
  pinMode(MTA, OUTPUT);
  pinMode(MTB, OUTPUT);   
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  
  //Setando valores Iniciais dos pinos
  digitalWrite(MDA,LOW);
  digitalWrite(MDB,LOW);
  digitalWrite(MEA,LOW);
  digitalWrite(MEB,LOW);
  digitalWrite(MTA,LOW);
  digitalWrite(MTB,LOW);
  servoCamera.attach(PinS);
  servoCamera.write(30);
  analogWrite(PinT,125);  
}

Loop

void loop()
{ 
  //Se a serial recebida do node for válida
  if(Serial1.available()){ 
    //Desliga o LED2 
    digitalWrite(LED2,LOW);
    //Recebe o componente
    char c= Serial1.read();
    //Recebe o número que ira setar o componente
    int n = Serial1.parseInt();
    
    switch(c){      
      case 'm':{ //motor direito
        Serial.println("############################################");
        Serial.println("Motor Direita:"+ String(n));
        //faz o mapeamento do valor pwm
        int m = map(n,0,100,0,255);
        //se for menor que 40, seta um valor minimo para não engasgar e gastar bateria
        if(m>0 && m<40)
          m=40;
        //escreve valor no motor
        analogWrite(PinMD,m);
        break;
      }
      case 'n':{ //motor esquerdo
        Serial.println("Motor Esquerda:"+ String(n));
        //faz o mapeamento do valor pwm
        int m = map(n,0,100,0,255);
        //se for menor que 40, seta um valor minimo para não engasgar e gastar bateria
        if(m>0 && m<40)
        if(m>0 && m<40)
          m=40;
        //escreve valor no motor
        analogWrite(PinME,m);
        break;
      }
      case 'f':{ 
        Serial.println("Frente:"+ String(n));
        if(n>0){
          //Tanque vai pra frente
          digitalWrite(MDA,HIGH);
          digitalWrite(MDB,LOW);
          digitalWrite(MEA,HIGH);
          digitalWrite(MEB,LOW);
        }
        else{
          if(n<0){
            //Tanque vai pra tras
            digitalWrite(MDA,LOW);
            digitalWrite(MDB,HIGH);
            digitalWrite(MEA,LOW);
            digitalWrite(MEB,HIGH);
          }
          else{
            //Tanque para
            digitalWrite(MDA,LOW);
            digitalWrite(MDB,LOW);
            digitalWrite(MEA,LOW);
            digitalWrite(MEB,LOW);
          }
        }
        break;
      }
      case 't':{
        Serial.println("Torre Esquerda:"+ String(n));
        if(n>0){
          tower=1;
          //Acende o LED3
          digitalWrite(LED3,HIGH);
          //Torre vai pra direita
          digitalWrite(MTA,HIGH);
          digitalWrite(MTB,LOW);
         
        }else{
          //Se a torre tiver indo pra direita e parou, o LED3 volta a ficar Apagado
          if(tower ==1){
            digitalWrite(LED3,LOW);
          }
          //Torre para
          digitalWrite(MTA,LOW);
        }
         
        break;
      }
      case 'y':{
        Serial.println("Torre Direita:"+ String(n));
        if(n>0){
          tower=2; 
          //Acende o LED3         
          digitalWrite(LED3,HIGH);
          //Torre vai para esquerda
          digitalWrite(MTA,LOW);
          digitalWrite(MTB,HIGH);
          
        }else{
          //Se a torre tiver indo pra esquerda e parou, o LED3 volta a ficar Apagado
          if(tower ==2){
            digitalWrite(LED3,LOW);
          }
          //Torre para
          digitalWrite(MTB,LOW);
        }
        
        break;
      }
      case 's':{
        Serial.println("Servo:"+ String(n));
        //Mapeia PWM do Servo
        int m = map(n,0,100,0,255);
        //Seta valor do Servo
        servoCamera.write(m);
        break;
      }
      case 'w':{
        //Conexão Node com o Arduino feita
        digitalWrite(LED1,HIGH);
        break;
      }
      default:{
        Serial.println("Default:"+ String(n));
      }
     
    }
    digitalWrite(LED2,HIGH);     
  }
  else{
    //Pisca LED até ter algum comando
    digitalWrite(LED1,aux);
    aux=!aux;
    delay(500);
  }
 
}

FAÇA O DOWNLOAD DOS ARQUIVOS:

PDF

INO