Visão traseira do veículo: 9 etapas (com fotos)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

Por que construímos a visão traseira do veículo?

A colisão de retaguarda tem sido um grande problema. O Centro de Controle de Doenças dos EUA relatou que, de 2001 a 2003, cerca de 7.475 crianças (2.492 por ano) com menos de 15 anos foram tratadas por incidentes de retrocesso em automóveis. Cerca de 300 fatalidades por ano resultam de colisões de backup. Em 2018, todos os carros vendidos nos Estados Unidos exigirão uma câmera de backup obrigatória.

Como resolvemos o problema?

A maioria dos carros no mercado hoje ainda não tem câmera de backup, o que inclui cerca de metade dos carros que estão sendo vendidos nos Estados Unidos hoje, e muito mais da metade no mundo todo. Podemos resolver esse problema instalando uma câmera na parte traseira do carro, usando o espaço da placa.

O Walabot será capaz de detectar a distância do alvo mais próximo do veículo.

A câmera Intel RealSense R200 nos dará mais detalhes sobre o que está sendo visto, incluindo situações de pouca luz.

O kit de desenvolvedor Intel Joule é poderoso o suficiente para executar câmeras RealSense junto com o Walabot. O Raspberry Pi não é poderoso o suficiente para executar uma câmera RealSense 3D, na qual podemos adicionar muito mais recursos no futuro que podem melhorar as funcionalidades do carro. A mesma versão pode ser usada com Pi com uma câmera USB normal, mas não será boa para a noite.

Telefone / tablet Android sendo usado para exibir a câmera de backup, isso é para reduzir o custo de uma tela adicional. A versão iOS pode ser construída mediante solicitação.

Por meio desses componentes, seremos capazes de construir uma visão traseira que mostra ao usuário a parte traseira do carro.

Etapa 1: Reúna os hardwares de que você precisa

1. Intel Joule
2. Walabot Pro
3. Câmera Intel R200 RealSense
4. Telefone / tablet Android que executa 5.0 ou superior
5. Adaptador do carro para saída de plugue e adaptador CA de 12 VCC (isto é para demonstração para ligar o Joule, a versão de produção conterá mecanismo de energia diferente)
6. Hub USB para conectar câmera e Walabot (USB3 para câmera e USB2 para Walabot)
7. DC para AC Direct Plug-in Power Inverter
8. Impressora 3D genérica para imprimir o quadro personalizado da placa de licença

Etapa 2: Instale o Ubuntu no Joule e as bibliotecas necessárias para executá-lo

Já que decidimos seguir o caminho do Linux, siga o guia https://developer.ubuntu.com/core/get-started/intel-joule para instalar o Ubuntu no Joule. O Ubuntu nos dá grande flexibilidade para rodar um sistema operacional real em um chip baseado em IoT.

Etapa 3: Transmita a câmera RealSense

Por estarmos utilizando o telefone / tablet Android para economizar na conta de material, também mais acessível aos usuários, estaremos utilizando a biblioteca de movimento para hospedar a câmera semelhante às câmeras de segurança. Assim que o Ubuntu estiver instalado e conectado ao wi-fi, podemos abrir o terminal e usar o seguinte comando. Primeiro conectamos a câmera ao Joule via porta USB3 e, em seguida, realizamos as seguintes etapas.

uma. Instalando o Motion no Ubuntu:

sudo apt-get updatesudo apt-get install motion

b. Copie os arquivos de configuração:

mkdir.motion sudo cp /etc/motion/motion.conf ~ /.motion / motion.conf

c. Configurando o arquivo, para aqueles que estão familiarizados com o ubuntu podem instalar o Sublime para fazer uma edição de texto mais fácil, caso contrário, podemos editá-lo dentro da linha de comando.

sudo nano ~ /.motion / motion.conf

d. Depois de conectar a câmera R200, podemos alterar as seguintes linhas em motion.conf

Isso é para colocá-lo no modo de segundo plano:

# Inicie no modo daemon (fundo) e libere o terminal (padrão: desligado) daemon ligado

Isso é para usar a visão da câmera RealSense.

# Dispositivo de vídeo a ser usado para captura (padrão / dev / video0) # para FreeBSD padrão é / dev / bktr0 videodevice / dev / video2

Alterar a largura e a altura, 1280 x 720 funcionou muito bem para mim, mas você pode brincar com as dimensões para ver o que se adapta às suas necessidades.

# Largura da imagem (pixels). Intervalo válido: Dependente da câmera, padrão: 352 largura 1280 # Altura da imagem (pixels). Intervalo válido: dependente da câmera, padrão: 288 altura 720

Eu defino isso para 30, quanto mais alto você definir o número, mais poder de computação será necessário. Você pode experimentar para ver qual é o benchmark para ele, mas 30 funcionou muito bem para mim.

# Número máximo de quadros a serem capturados por segundo. # Intervalo válido: 2-100. Padrão: 100 (quase sem limite). taxa de quadros 30

Uma vez que estamos sempre fluindo de volta do carro, podemos definir uma porta dedicada, usamos 5001

############################################################### ########### # Servidor de transmissão ao vivo ############################################ ################################ # O servidor mini-http escuta esta porta para solicitações (padrão: 0 = desativado) stream_port 5001 # Qualidade do jpeg (em porcentagem) imagens produzidas (padrão: 50) stream_quality 50 # Quadros de saída a 1 fps quando nenhum movimento é detectado e aumenta para a # taxa fornecida por stream_maxrate quando o movimento é detectado (padrão: desligado) stream_motion off # Velocidade máxima de quadros para fluxos de fluxo (padrão: 1) stream_maxrate 60 # Restringir conexões de fluxo apenas para localhost (padrão: ativado) stream_localhost desativado

Você pode então executar ifconfig e descobrir o endereço IP e executar no terminal, a porta será 5001.

movimento

Se não houver erros, é fácil verificar a câmera do seu computador usando o ip, corrigir os erros, como problemas de permissão, se houver.

Assim que for executado, podemos adicioná-lo ao aplicativo de inicialização do Ubuntu.

Inicialização de movimento para câmera

motion.conf está sendo anexado na seção de código, você pode verificar mais configurações lá.

Etapa 4: configurar o Walabot

Com a câmera no lugar, ainda precisamos configurar o walabot, que pode detectar a distância entre o veículo e o objeto atrás, dando uma visão clara de como devemos

a, baixe o arquivo deb em

Siga as instruções de https://api.walabot.com/_install.html#_linuxInstall para instalar a API do Walabot para que possa ser importada para projetos Python.

Há um erro no site na parte onde está instalando a API Walabot https://walabot.com/api/_pythonapi.html#_installingwalabotapi onde está escrito

python -m pip “/usr/share/walabot/python/WalabotAPI-1.0.21.tar.gz”

Isso deveria ser

python -m pip install "/usr/share/walabot/python/WalabotAPI-1.0.21.tar.gz"

b. conectar o Walabot Pro via USB 2, não consegui fazer o usb3 funcionar, mas o usb2 funciona bem conectando-se ao linux. Como o Joule tem apenas uma porta USB3, conecte uma porta USB2 adicional para acomodar o Walabot Pro aqui

c. Teste o projeto Walabot, como https://github.com/Walabot-Projects/Walabot-Senso … executando o seguinte comando na pasta

python SensorTargets.py

Isso deve ser um bom teste para ver se o Walabot está funcionando corretamente, bem como para medir a distância em coisas que você deseja. O exemplo DistanceMeasure não foi muito consistente na medição e zPosCm parece ser extremamente preciso, então decidi usar o zPosCM para a demonstração.

d. Ainda precisamos passar os dados para o display do dispositivo, já que estamos rodando isso no android para reduzir custo de material, podemos usar sockets. Usamos o seguinte código para configurar o socket e udp em python.

MYPORT = 5002 import sys, tempo do socket import * s = socket (AF_INET, SOCK_DGRAM) s.bind (('', 0)) s.setsockopt (SOL_SOCKET, SO_REUSEADDR, 1) s.setsockopt (SOL_SOCKET, SO_BROADCAST, 1)

O comando a seguir transmitirá dados na atualização

s.sendto (str (alvos [0].zPosCm), ('255.255.255.255', MYPORT))

e. Quando isso for feito, podemos configurá-lo no aplicativo de inicialização

f. O Walabot agora está configurado e transferindo dados via UDP, o código python completo pode ser visto na área de anexo de código. A captura de tela abaixo é a impressão de como deveria ser quando não há nenhuma área. O código está anexado na seção de código.

Etapa 5: Criação de ponto de acesso Wi-Fi a partir do Joule

Estamos criando nosso próprio ponto de acesso wi-fi para o dispositivo Android para transferir dados. Usar o seguinte comando no início irá configurá-lo automaticamente. Isso está sendo usado para Ubuntu 16.04 ou posterior, pois está sendo usado. Iremos conectar isso automaticamente através do aplicativo Android na próxima etapa. Use este comando nos aplicativos de inicialização.

dispositivo nmcli wi-fi hotspot con-name veículo-visão traseira ssid veículo-visão traseira banda bg senha safedriving

Dentro do arquivo python do walabot, também iremos atualizá-lo, enviando mensagem udp para dispositivos que estão conectados via hotspot privado. Isso é para garantir que nenhum pacote seja perdido.

out = os.popen ('ip neigh'). read (). splitlines () para i, linha em enumerar (out, start = 1): ip = line.split ('') [0] s.sendto (str (alvos [0].zPosCm), (ip, MYPORT))

Etapa 6: Construindo Android como tela de exibição

O aplicativo Android foi desenvolvido para exibir o dispositivo, principalmente porque reduz a lista de materiais, caso contrário, uma tela separada pode ser cara e difícil de instalar. Para este projeto, podemos usar telefone / tablet Android.

O Android se concentra em 3 partes que fizemos anteriormente,

• Conecte-se ao ponto de acesso wi-fi criado por meio do dispositivo IoT (Intel Joule)
• Transmita a câmera RealSense via movimento por wi-fi
• Medindo a distância do alvo Walabot até o udp

Depois de configurar tudo e instalar o aplicativo Android (código aberto aqui), você poderá ver a câmera funcionando junto com o walabot

Etapa 7: Teste de tudo

Agora que tudo está funcionando, devemos ter uma configuração básica de todos os componentes anexados. Quando iniciamos a placa Joule, o ponto de acesso deve ser configurado automaticamente, o aplicativo de movimento e walabot iniciará junto com ele e, quando ligarmos nosso aplicativo para Android, poderemos transmitir a partir da câmera. Isso significa que o teclado / mouse e o monitor não são mais necessários para o funcionamento do dispositivo IoT. Se ocorrer algum problema neste momento, como bibliotecas não instaladas corretamente, devemos corrigi-lo antes de prosseguir para a próxima etapa.

A impressão 3D da caixa que pode conter a câmera é muito importante.

Ao construir o Hardware, devemos ter nosso invólucro impresso em 3D personalizado pronto para a câmera. Como este é um protótipo, ele pode ficar um pouco solto, mas quando construirmos o suporte da placa do carro personalizado, esperamos que todos os componentes estejam dentro do suporte.

Etapa 8: Teste em um carro real

Agora que fizemos tudo funcionar, poderemos testá-lo em um carro real. Como este é um protótipo, as coisas podem ser um pouco difíceis, usamos fita adesiva para alguns dos componentes.

Para ligar o Joule IoT Kit, usamos um Power Inverter DC para AC Direct Plug-in e, em seguida, simplesmente ligamos uma longa tomada de energia ao porta-malas.

Teremos a parte frontal e a parte traseira. Este é apenas um protótipo agora, a próxima versão integraria os chips dentro do suporte da placa.

E para a parte frontal, podemos usar um suporte para telefone ou apenas fita adesiva para Android Tablet.

Etapa 9: use no mundo

Usando essa ferramenta, podemos fazer o back-up do carro com segurança para outros carros e monitorar os pedestres. Você pode assistir ao vídeo de demonstração no início. O objetivo do projeto é incentivar práticas de direção mais seguras.

Você pode verificar o projeto em