Através da leitura do protocolo OBD2 do carro, é possível receber informações do veículo. Utilizando a DragonBoard 410c começamos a trabalhar neste projeto, e trazemos aqui o caminho detalhado para você reproduzir isso.

Este projeto foi feito em parceria com a #Qualcomm #Embarcados #Linaro #Arrow #BaitaAceleradora que permitiram que tivéssemos acesso aos melhores hardwares, além do contato com os melhores profissionais para contribuir com o desenvolvimento.

Participaram deste projeto:

Marcel Ogando - Hacker - marcelogando@gmail.com
Leandro Alvernaz - Hacker - leandrofga@gmail.com
Thiago Paulino Rodrigues - Marketing - thiago.prodrigues@gmail.com

Temos total interesse em ajudar você a concluir o seu projeto, então não deixe de entrar em contato conosco!

To follow this project in English, click here:

https://www.instructables.com/id/DragonBoard-and-OBD2/

A estrutura deste projeto inclui os seguintes componentes, conforme apresentados na imagem acima:

Qualcomm DragonBoard 410c
ELM327 Bluetooth OBD2 Interface
Dongle USB 3G/4G
Carregador Veicular de Inversão de Tensão (110v)

Step 1: Fazendo O Setup Inicial Da DragonBoard 410c

Utilizando a Qualcomm DragonBoard 410c, iniciamos o projeto com a instalação da distribuição Linaro do Linux, que nos permitiu configuração completa do dispositivo.

Para criar uma imagem do Linaro para a DragonBoard, utilize o Ubuntu, pelo VirtualBox, para usar o FastBoot, que é um aplicativo baseado em Linux. É necessário estar em ambiente Linux para poder instala-lo.

Para instalar o Fastboot, acesse o Terminal da sua Máquina Virtual Ubuntu, e digite:

sudo apt-get android-tools-fastboot

Para instalar o Linaro, precisamos passar por 2 passos muito importantes:
- Instalando o BOOTLOADER
- Nome do arquivo: dragonboard410c_bootloader_emmc_linux-79.zip
  - http://builds.96boards.org/releases/dragonboard410c/linaro/rescue/latest/
  - Retire os arquivos de dentro do ZIP
  - Entra na pasta:
```
cd /NomeDaPasta (caminho da pasta descompactada)
```
  - Fazer o comando:
```
sudo fastboot devices
```
  - Resposta esperada:
```
(hexadecimal) fastboot
```
  - Então digite:
```
sudo ./flashall
```
  - Resposta esperada:
```
finished. total time 1.000s (sem erros)
```
    (sem erros)
- Instalando o Sistema Operacional
  - http://builds.96boards.org/releases/dragonboard410c/linaro/debian/latest/
  - Baixar dois arquivos:
  - boot-linaro-stretch-qcom-snapdragon-arm64-20170607-246.img.gz
    - Este arquivo é a última versão (Junho/17) e o nome futuro pode ser alterado. A base do nome que você deve buscar é “boot-linaro-NomeDaVersão”. Nesta versão o nome é “Stretch” e a anterior foi “Jessie”.
  - linaro-stretch-alip-qcom-snapdragon-arm64-20170607-246.img.gz
    - Este arquivo é a última versão (Junho/17) e o nome futuro pode ser alterado. Procure por “linaro-NomeDaVersão-alip”
  - Retirar os arquivos de dentro do .GZ
  - Entrar na pasta “raiz” em relação aos arquivos compactados
    - exemplo: “/Downloads” que é o local onde os arquivos baixados estão.
  - Entre com os comandos:
```
sudo fastboot devices

sudo fastboot flash boot boot-linaro-NomeDaVersão-qcom-snapdragon-arm64-DATA.img
```
  - Resposta esperada (lembrando que o tempo pode variar):
```
finished. total time: 100.00s
```

Conecte um Mouse, Teclado e um monitor/TV na porta HDMI
Utilize:
- Usuário: linaro
- Senha: linaro
Abra a interface Lxterminal e faça o download da lista de atualizações disponíveis dos pacotes instalados:
```
sudo apt-get update
```
Realize a instalação dos pacotes disponíveis usando o código:
```
sudo apt-get upgrade
```

Dicas: O Linaro tem um boot extremamente rápido, e uma comunidade bastante engajada para solução de problemas.

Step 2: Fazendo O GPS Da DragonBoard 410c Localizar Seu Dispositivo

Comece com a instalação dos aplicativos que servirão de cliente para o GPS, sendo eles o GNSS-GPSD, o GPSD e o GPSD-CLIENTS. Faça isso usando o comando:

sudo apt-get install gnss-gpsd gpsd gpsd-clients

Com ele instalado, você precisará rodar alguns comandos para iniciar o aplicativo, são eles:

sudo systemctl start qdsp-start.service
sudo systemctl start gnss-gpsd.service
sudo systemctl start qmi-gps-proxy.service

Leve sua DragonBoard 410c para um local aberto, com visada para o céu, e digite no terminal:

gpsmon –n

Pelos testes realizados, o tempo médio até as informações começarem a aparecer na tela, é de cerca de 10 minutos. Isso varia muito da localização da DragonBoard, quantidade de prédios ao seu redor, além de outras barreiras naturais que possam atrapalhar a recepção do sinal do GPS.

Para conseguir capturar essas informações e mandar para a núvem, utilize o código abaixo, alterando o endereço do seu website:

conectaGPS.py
Download

Step 3: Instalando O Dongle USB 3G/4G

Existem algumas formas de fazer a DragonBoard 410c acessar a rede 3G/4G:

Instalando um Shield / BreakoutBoard com Modem GSM e slot para SimCard;
Utilizar um Dongle USB 3G/4G;

Para este projeto optamos pelo Dongle USB 3G/4G da Huawei modelo E3272, pela facilidade de obter este dispositivo.

Para configurar o modem, você poderá utilizar o terminal (com a aplicação WVDial), porém o jeito mais fácil é utilizar a própria Interface Gráfica do Usuário (GUI) do Linaro. Faça da seguinte forma:

Com o Dongle USB conectado, clicar com botão direito no ícone de “redes” no canto inferior direito da tela.
“Edit Connections” > “Add”
Escolha a opção: “Mobile Broadband”
Clique em “Create”

Siga a tela de instalação do sistema operacional, conforme imagens acima, configurando a operadora de telefonia conforme sim card comprado. Para criação deste projeto, utilizamos um Sim Card da Tim (e um modem inicialmente vendido pela Vivo).

Step 4: Transformando a DragonBoard 410c Em Hotspot / Access Point WiFi

Para utilizar a DragonBoard 410c como um roteador wifi (agora que você já configurou a conectividade com a internet), a maneira mais simples é utilizar a própria interface do sistema. Siga os passos abaixo:

Clique no botão direito no ícone de “redes” no canto inferior direito.
“Edit Connections” > “Add”
Escolha a opção “WiFi”
Clique em “Create”

Coloque o nome da rede que você quer criar no campo "SSID" e depois altere o “Mode” para “Hotspot”.

Para garantir o funcionamento:

Vá na aba “IPv4 Settings”
Veja se o “Method” está marcado como “Shared to other computers”

Step 5: Acessando a DragonBoard 410c Por SSH Sem Fio, Utilizando O Hotspot

Criamos um jeito de acessar a placa remotamente, independente da forma que ela esteja conectada, não dependendo de estar próximo a Dragonboard para conectar diretamente à ela, ou ao wifi em que ela esteja conectada. Este é o método de conexão dos servidores Linux da Amazon.

Começamos instalando o Auto SSH, utilizando o código abaixo.

sudo apt-get install gcc make

wget http://www.harding.motd.ca/autossh/autossh-1.4e.tgz

tar -xf autossh-1.4e.tgz

cd autossh-1.4e

./configure

make

sudo make install

Agora vamos gerar uma chave criptografada com padrão de segurança RSA. Esta chave serve para que a pessoa que a tenha, tenha autorização para acessar a instância do endpoint exclusivo no Linux, através do IP público do modem 3G, objetivo principal deste passo. Na sequência, o código faz a copia da chave para o repositório de chaves confiáveis do Linux, garantindo ainda mais confiança para a conexão.

ssh-keygen -t rsa

scp ~/.ssh/id_rsa.pub user@remote_server:.ssh/authorized_keys

autossh -M 0 -q -f -N -i /home/pi/.ssh/id_rsa -o "ServerAliveInterval 60" -o "ServerAliveCountMax 3" -R 2222:localhost:22 user@remote_server

Com isso, acabamos de transformar a DragonBoard 410c em um servidor cloud! \o/

Step 6: Ligando a DragonBoard 410c Ao OBD Do Seu Carro Via Bluetooth – Passo 1/2

A interface de comunicação com os carros é feita através da porta OBD2. A informação que transita nesta porta precisa ser traduzida, e para isso precisamos de um interpretador que trate os dados. Há duas opções para este hardware: ELM327 ou STN1170.

Para este projeto, utilizamos um dispositivo Bluetooth com chip baseado em ELM327.

Importante destacar que a disponibilidade deste hardware não necessariamente representa a versão ORIGINAL do ELM327. A maior parte disponível está na versão 1.5, que foi quando o chip original foi clonado e colocado a venda no mercado. O chipset original está na versão 2.2. A evolução deste versionamento traz ao chip mais informações sobre os carros mais novos. É importante saber disso, pois dependendo dos testes realizados, poderá ou não conseguir obter determinadas informações de veículos mais novos.

De posse do seu dispositivo OBD2 Bluetooth, encontre a porta OBD2 do seu carro. Ela pode estar localizada logo abaixo do volante, no console central ou perto da caixa de fusíveis. O local varia bastante entre as montadoras e modelos. Uma opção para localizar é usar esta ferramenta: https://www.hum.com/port

Acesse a DragonBoard 410c com SSH, utilizando seu Notebook (lembrando que agora você está no carro, e não possui mais uma tela para conectar a placa).

Assim que o dispositivo OBD2 Bluetooth for inserido no conector do carro, siga os passos abaixo para ter controle da conectividade bluetooth:

sudo bluetoothctl
pairable on
agent on
default-agent
scan on

Neste momento é importante que você copie o MAC Address pois precisará para os próximos passos.

Digite:

trust MACADDRESS
pair MACADDRESS

Neste momento deve aparecer uma solicitação para digitar o PIN de pareamento do Bluetooth OBD2.

O PIN geralmente é 1234 ou 0000

Após a tela de sucesso de conexão, digitando este comando, você sai do programa controlador do Bluetooth digitando:

quit

Agora é preciso fazer um "BIND" do dispositivo com a porta serial:

sudo rfcomm bind 0 MACADDRESS 1

Para validar o sucesso da operação digite:

ls /dev

A porta “Rfcomm0" deve estar na lista.

Step 7: Ligando a DragonBoard 410c Ao OBD Do Seu Carro Via Bluetooth – Passo 2/2

Objetivo deste passo é garantir o funcionamento da comunicação entre os dispositivos:

ELM327, DragonBoard 410c e Veículo

Baixe a aplicação “Screen” para enviar mensagens pela Porta Serial

sudo apt-get install screen

A Porta Serial será usada para envio e recebimento de Comandos AT entre a DragonBoard 410c e o ELM327.

Para saber mais sobre Comandos AT, acesse: http://elmelectronics.com/ELM327/AT_Commands.pdf

ATENÇÃO:

Tome muito cuidado nesta parte! Todas as informações enviadas para o dispositivo conectado ao carro, poderão ser interpretadas e enviadas ao carro de maneira errada e ocasionar o mal-funcionamento do seu carro! Estude bastante os comandos antes de tentar inovar nos comandos. Recomendamos que siga as instruções abaixo detalhadamente.

Siga a sequência de comandos abaixo para dar início à comunicação:

Esta função fará abrir o terminal de comunicação serial.
```
screen /dev/rfcomm0
```

Assim que o terminal carregar, digite os comandos abaixo nesta sequência (e entenda o que cada um deles faz):

Reinicia o dispositivo. As vezes você precisará fazer isso.
```
ATZ
```
Liga a funcionalidade de quebra de linha nos comandos, facilitando a visualização.
```
ATL1
```
Liga os cabeçalhos dos comandos.
```
ATH1
```
Liga o espaçamento entre palavras.
```
ATS1
```
Define o protocolo de comunicação do carro para “Automático”.
```
ATSP0
```

Teste de comunicação Final:

Digite no console:
```
ATI
```
Ele deve retornar “ELM327 v1.5” ou a versão do ELM do seu dispositivo.
Isso prova que o ELM327 está comunicando com a placa sem problemas, e podemos prosseguir.

Dica

Para sair da aplicação “Screen” é necessário apertar: Ctrl-A seguido de Ctrl-D

Step 8: Ligando a DragonBoard 410c Ao OBD Do Seu Carro Usando PyOBD

PyOBD é uma biblioteca de Python específica para comunicação com o padrão OBD2 dos veículos. Com ela, podemos extrair diversas informações da rede de comunicação do carro, incluindo dados como velocidade e até mesmo erros da parte elétrica.

Para esta etapa, precisamos garantir que as seguintes bibliotecas estejam instaladas no Linaro da sua DragonBoard 410c:

PIP – Gerenciador de módulos do Python
```
sudo apt-get install python-pip
```
SetupTools – gestor de arquivos de instalação
```
sudo pip install -U pip setuptools
```
Wheel – formatador de arquivos para instalação
```
sudo apt-get install python-wheel
```
OBD – biblioteca para interpretação de dados OBD
```
sudo apt-get python-obd
```
GPS – biblioteca com dados do gps
```
sudo pip install gps
```
Requests – módulo de solicitações
```
sudo pip install requests
```

Para saber se a biblioteca de Python está funcionando corretamente, precisamos rodar os comandos:

sudo python

Neste momento o cursor do terminal vai mudar para este ícone “>>>” indicando que o programa está rodando Python. Podemos começar a digitar os comandos para serem interpretados conforme abaixo.

Comece importando a biblioteca
```
import obd
```
Para fazer a conexão com a porta serial use o comando
```
connection = obd.OBD(“/dev/rfcomm0”)
```
Para descobrir se o Python está conseguindo extrair informações do carro, passando pelo Bluetooth, ELM327 até chegar no carro, digite:
```
connection.protocol_name()
```

Step 9: Extraindo Informações Do Carro Usando Python

Vamos criar um arquivo chamado: OBD.py, conforme instruções abaixo e código na sequência.

Importamos a biblioteca OBD para dentro do Python para iniciar as conexões.

Por motivos desconhecidos, a primeira conexão com nosso hardware, falha sempre. Na segunda tentativa, funciona sempre. Por isso, no código verá que há duas linhas de conexão (con).

Seguindo o funcionamento do código, com a conexão feita, iniciamos um loop infinito que busca os dados do OBD, formata de acordo com os parâmetros estabelecidos. Depois cria a URL, utilizando Query String, para que possa enviar ao servidor utilizando o método POST.

No exemplo abaixo pegamos as seguintes informações:

RPM
Velocidade
Odômetro *

As funções para captura dos dados utilizam dois parâmetros. Por exemplo, usando [1][12] estamos buscando [módulo] [PID]. Esta lista pode ser encontrada em: https://github.com/brendan-w/python-OBD/blob/master/obd/commands.py

Por último, a humm a URL com todas as informações são concatenadas e adicionadas em um arquivo, chamado "obd_data.dat".

Código para OBD.py:

import obd
import time

odoInicial = -1
paramOdo = 0

#Conect OBD
print "Primeira conexao"
con = obd.OBD("/dev/rfcomm0")
print "Segunda conexao"
con = obd.OBD("/dev/rfcomm0")

while True:
        respRPM = con.query(obd.commands[1][12])
        print respRPM
        respVelo = con.query(obd.commands[1][13])
        print respVelo
        respOdo = con.query(obd.commands[1][49])
        print respOdo

        paramRPM = int(float(str(respRPM).replace(" revolutions_per_minute","")))
        paramVelo = int(float(str(respVelo).replace(" kph","")))
        paramOdo = int(float(str(respOdo).replace(" kilometer", "")))

        url = "http://www.website.com/OBD?vel="+str(paramVelo)+"&rpm="+str(paramRPM)+"&odo="+str(paramOdo)+"\n"
        
        time.sleep(0.2)
        print url
        file = open("obd_data.dat","a+")
        file.write(url)
        file.close()
        print url

Depois da conexão e captura dos dados, vamos criar o arquivo chamado: envia_OBD.py

Esta parte do código fica mais simples. Começamos importando bibliotecas relacionadas à solicitações/envio de dados, usando RESTFUL.

Criamos um while para enviar através de POST a URL da primeira linha do arquivo que populado anteriormente pelo OBD.py. Depois disso, para evitar que o dado seja enviado mais de uma vez, ela apaga esta linha do arquivo.

Código para o arquivo OBD.py:

import requests
import time

while True:
    try:
        time.sleep(0.2)
        url = ''
        with open('obd_data.dat','r') as fin:
            data = fin.read().splitlines(True)
            url = data[0]
        requests.post(url)
        with open('obd_data.dat', 'w') as fout:
            fout.writelines(data[1:])
    except:
        print 'exception'

Caso tenha algum problema copiando estes códigos, baixe os arquivos abaixo:

Step 10: Repetição De Scripts E Armazenamento De Dados Capturados Do Carro

Tudo o que foi feito até agora era orientado a garantir que a DragonBoard fizesse comunicação com os diferentes componentes da solução, como a comunicação 3G, WiFi, Bluetooth, Dados do GPS, entre outros.

Vamos usar o código abaixo para editar o arquivo 'rc.local', que já tem algumas funções e comandos pré-definidos, e fica no diretório '/etc'. Para fazer a edição, use o comando:

sudo nano /etc/rc.local

Agora precisamos configurar a inicialização de todos os processos, serviços e funções, criando rotinas para que funcionem automaticamente ao iniciar a Dragonboard. Vamos utilizar o BASH para fazer isso. O BASH (Bourne-Again-SHell) é um aplicativo para interpretação de comandos Unix.

No próximo código, que tem comandos BASH, você precisará inserir o MacAddress do seu dispositivo OBD/Bluetooth, e também precisa ter bastante cuidado para garantir que o código seja colocado sempre antes do comando "exit 0" que é a resposta de sucesso do sistema.

if [ ! -f /etc/ssh/ssh_host_rsa_key ]
then
    systemctl stop ssh.socket||true
    dpkg-reconfigure openssh-server
fi
sudo systemctl start qdsp-start.service
rfcomm bind 0 MACADDRESS 1
sudo python /home/linaro/Documents/FadaDoCarro/conectaGPS.py &
sudo python /home/linaro/Documents/FadaDoCarro/OBD.py &
sudo python /home/linaro/Documents/FadaDoCarro/envia_OBD.py &
exit 0

A partir de agora, sempre que a placa for iniciada, ela já vai se conectar através do 3G e enviar os dados de GPS e OBD para o servidor escolhido.

Step 11: Dificuldades Encontradas

Listamos abaixo algumas barreira que encontramos ao longo do desenvolvimento do projeto, que resolvemos antes de criar este Instructable, mas que é importante alertá-lo, caso esteja tendo dificuldades também.

PyOBD
- É preciso ter muito cuidado na hora de transmitir os dados e comunicar com o carro. Nas primeira tentativas, quando a comunicação ainda não era estável com o dispositivo, enviamos alguns comandos para o carro, e acabamos causando algum problema na ECU. Neste momento o câmbio automático não aceitava mais mudanças, ficou travado. Além disso, as luzes do painel começaram a piscar aleatoriamente. A solução para este evento que ocasionamos foi o desligamento dos cabos da bateria, mantendo assim por 15 minutos. Desta forma, forçamos o reset completo das ECUs do carro, retornando ele ao estágio original de fábrica, portanto cancelando qualquer comando que tenhamos enviado erroneamente pela porta OBD.

Linaro
- Tivemos um problema de boot no Linaro, quando aleatoriamente o OS reiniciava. Este problema foi resolvido ao longo do desenvolvimento do projeto, pela equipe do Linaro, que soltou uma atualização, e já construímos este tutorial utilizando a informação mais atualizada.

GPS na DragonBoard
- A Qualcomm Dragonboard 410c não tem antenas GPS internas, e para melhor recepção de sinal, é preciso instalar o conector e adquirir uma antena externa. Para fazer este procedimento, siga os passos propostos pela própria Qualcomm: https://developer.qualcomm.com/qfile/29467/lm80-p0436-42_add_ufl_ant_and_valid_gps_on_android_app_note.pdf