Registrador de impacto para veículos: 18 etapas (com fotos)

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

O Registrador de Impacto foi projetado para registrar o impacto sofrido no veículo durante a condução ou parado. Os impactos são armazenados no banco de dados na forma de leituras, bem como de vídeo / imagem. Com o impacto, o usuário remoto pode ser verificado em tempo real, e o usuário remoto pode assistir ao vídeo salvo ou ter acesso remoto à câmera pi e assistir aos eventos de acordo.

Etapa 1: Peças e acessórios

(1) Raspberry Pi 3 ou melhor: potência computacional necessária

(2) Chapéu de framboesa pi sense

(3) Câmera Raspberry Pi / câmera USB

(4) Cartão de memória com a imagem raspbian mais recente (deve suportar nó vermelho, quase todas as imagens mais recentes sim)

(5) Fonte de alimentação de pelo menos 2,1 A (usei banco de bateria para operação autônoma no carro)

Etapa 2: Descrição das peças: chapéu dos sentidos

O Sense HAT tem uma matriz de LED RGB 8 × 8, um joystick de cinco botões e inclui os seguintes sensores:

• Giroscópio
• Acelerômetro
• Magnetômetro
• Temperatura
• Barométrico
• pressão
• Umidade

Mais informações sobre como trabalhar com o sense hat podem ser obtidas nos seguintes links: Sense_Hat

API para sense hat está hospedada em: Sense_hat_API

O código para a programação do sense hat é abordado em etapas posteriores. O código Sense-hat também pode ser simulado em um simulador hospedado em: Sense-hat simulator

Etapa 3: Montagem: Registrador de impacto

• A montagem é mais simples, pois o chapéu do sensor precisa ser empilhado sobre o pi (os parafusos de montagem designados são fornecidos com o chapéu do sensor).
• A câmera USB ou a câmera pi podem ser conectadas. No tutorial, a câmera pi é considerada e, consequentemente, a codificação é realizada para a mesma.
• Insira o cartão de memória e configure o código Python e o nó-vermelho (a configuração e o código são abordados nas etapas seguintes)

A imagem acima mostra a câmera pi conectada através de um cabo de fita plana ao pi

Etapa 4: Montagem: Registrador de impacto no painel do carro

Para montar o gravador, usei fita dupla-face, a vantagem é que o gravador pode ser facilmente colocado em diferentes posições, a que melhor se adequar ao seu carro.

Outra câmera é montada verticalmente como mostrado, usando a mesma fita dupla-face, O próximo passo é conectar uma fonte de energia (banco de energia de 10.000 mAH) junto com uma conexão de internet pronta

A conexão com a Internet deve ser necessária para o aplicativo MQTT (os detalhes para MQTT são cobertos em etapas posteriores)

Etapa 5: Registrador de impacto: trabalho e aplicações

A partir do chapéu do sentido, a aceleração e o giroscópio são usados para verificar se os valores brutos estão além do limite definido no código.

Acelerômetro: O acelerômetro informa a quantidade de força gravitacional (força G) atuando em cada um dos eixos x, y e z, se qualquer eixo medir mais de 1G de força, então o movimento rápido pode ser detectado. (observe que o eixo apontando para baixo teria valor de 1g e deve ser considerado de acordo no código python).

Giroscópio; O giroscópio é usado para medir o movimento angular, ou seja, durante uma curva fechada, o sensor pode ser ativado (depende da configuração do código), de modo que uma pessoa girando bruscamente no veículo seria pega !!

Qualquer ativação do limite definido também é exibida na matriz de LED do chapéu de detecção como "!" em vermelho para aceleração e verde para ativação do giroscópio

Etapa 6: Descrição do software: Nó vermelho

Node-RED é uma ferramenta de programação baseada em fluxo, originalmente desenvolvida pela IBM Emerging Technology Servicesteam e agora uma parte da JS Foundation.

Mais informações sobre o nó vermelho podem ser obtidas no seguinte link: nó-vermelho

Para o nosso caso, usaríamos node -red para as atividades seguintes

(1) Interagir com os joysticks para iniciar as funções da câmera

(2) Monitorar os impactos no veículo e retransmitir as informações para o usuário final, empregando MQTT e ainda aceitando os comandos do usuário final por meio de MQTT e iniciando a aplicação necessária em pi

(3) Executar alguns procedimentos básicos, como desligamento do pi

As etapas seguintes fornecem informações detalhadas para o diagrama de fluxo implementado no nó vermelho

Observe que os diagramas de fluxo de nó vermelho interagem com o código Python, portanto, a última parte cobre os aspectos do código Python

Etapa 7: noções básicas de Node-red

Certas etapas básicas são destacadas para iniciar o Node-red rapidamente, mas sim o node-red é muito simples para começar e trabalhar nos aplicativos.

• Iniciando Node-red: https:// localhost: 1880.
• Iniciando Node-red quando pi está conectado à internet https:// endereço ip>: 1880

Etapa 8: Nó vermelho: Fluxo _1a

O Flow _1a monitora quaisquer alterações no arquivo CSV e com base nas alterações, ou seja, impacto detectado, a gravação de vídeo da câmera é configurada para o modo ligado e, posteriormente, o usuário é informado pela Internet de que ocorreu um impacto

Etapa 9: Nó Vermelho: Fluxo_1b

Nesse fluxo, a gravação de vídeo pode ser iniciada a qualquer momento, bastando pressionar o joystick

Etapa 10: Nó vermelho: Flow_2a

Nesse fluxo, sempre que uma nova imagem ou vídeo é armazenado / carregado no diretório, a informação é retransmitida ao usuário cadastrado pela internet

Etapa 11: Nó vermelho: Flow_2b

Este fluxo é projetado principalmente para o usuário remoto, de modo a controlar o dispositivo da seguinte maneira

(a) dispositivo de desligamento

(b) tirar fotos

(c) Gravar vídeos

(d) iniciar o código principal (o código do datalogger é o código principal que calcula o impacto)

Etapa 12: Nó vermelho; Flow_3

O fluxo é projetado para acesso local, de forma a iniciar o código principal ou dispositivo de desligamento

Etapa 13: MQTT

MQTT (Message Queuing Telemetry Transport) é um protocolo TCP / IP, no qual o editor e o assinante interagem.

Em nosso caso, Pi é o editor, enquanto o aplicativo instalado em nosso moblile / PC deve ser o assinante.

Desta forma, na geração de qualquer impacto, as informações são retransmitidas remotamente para o usuário (uma conexão de Internet funcional é obrigatória)

Mais informações sobre MQTT podem ser acessadas no seguinte link: MQTT

Para começar a usar o MQTT, primeiro precisamos nos registrar, para o tutorial que usei o cloudmqtt (www.cloudmqtt.com), há um plano gratuito em "gato bonito", isso é tudo.

Depois de registrar, crie uma instância diga "pi" após a qual você obterá os seguintes detalhes

• Nome do servidor
• porta
• nome do usuário
• senha

Os itens acima são necessários durante a assinatura pelo celular / pc

Para meu aplicativo, usei o aplicativo MQTT da google play store (versão Android)

Etapa 14: MQTT: assinante

O aplicativo MQTT em execução no celular (versão Android)

O impacto detectado em pi são retransmitidos de volta

Etapa 15: MQTT: Editando Propriedades em Node-red

Em nó vermelho, após selecionar o nó MQTT, "Nome do servidor" e "tópico" a serem mencionados. Isso deve ser o mesmo na extremidade do assinante

Etapa 16: o código Python:

A funcionalidade do código é de acordo com o fluxograma anexado

Etapa 17: O Código Final

O código python está anexado

A fim de fazer nosso script python rodar a partir do terminal, precisamos torná-los executáveis como chmod + x datalogger.py, além do topo do código deve conter a seguinte linha "shebang" #! / usr / bin / python3 (isso é necessário para executar funções de node-red)

#! / usr / bin / python3 // shebang linefrom sense_hat import SenseHat de datetime import datetime from csv import writer import RPi. GPIO como GPIO from time import sleep

sense = SenseHat ()

importar csv

timestamp = datetime.now ()

atraso = 5 // o atraso é definido para armazenar dados no arquivo data.csv vermelho = (255, 0, 0) verde = (0, 255, 0) amarelo = (255, 255, 0)

# GPIO.setmode (GPIO. BCM)

# GPIO.setup (17, GPIO. OUT)

def get_sense_impact ():

sense_impact = acc = sense.get_accelerometer_raw () sense_impact.append (acc ["x"]) sense_impact.append (acc ["y"]) sense_impact.append (acc ["z"])

giroscópio = sense.get_gyroscope_raw ()

sense_impact.append (gyro ["x"]) sense_impact.append (gyro ["y"]) sense_impact.append (gyro ["z"])

return sense_impact

def impact (): // função para detectar impacto # GPIO.setmode (GPIO. BCM) # GPIO.setup (4, GPIO. OUT) acceleration = sense.get_accelerometer_raw () x = acceleration ['x'] y = acceleration ['y'] z = aceleração ['z'] x = abs (x) y = abs (y) z = abs (z)

giroscópio = sense.get_gyroscope_raw ()

gyrox = gyro ["x"] gyroy = gyro ["y"] gyroz = gyro ["z"]

girox = redondo (girox, 2)

giro = redondo (giro, 2) giro = redondo (giro, 2)

impact = get_sense_impact ()

se x> 1,5 ou y> 1,5 ou z> 1,5: // os valores são definidos após a iteração na estrada real podem ser alterados de acordo para diferentes tipos e habilidades de direção com aberto ('impact.csv', 'w', nova linha = ' ') como f: data_writer = writer (f) data_writer.writerow ([' acc x ',' acc y ',' acc z ',' giroscópio x ',' giroscópio y ',' giroscópio z ']) #GPIO. output (4, GPIO. HIGH) sense.clear () sense.show_letter ("!", vermelho) data_writer.writerow (impacto)

elif gyrox> 1.5 or gyroy> 1.5 or gyroz> 1.5: // os valores são definidos olhando para a velocidade na qual as curvas são iniciadas com open ('impact.csv', 'w', newline = '') como f: data_writer = writer (f) data_writer.writerow (['acc x', 'acc y', 'acc z', 'giroscópio x', 'giroscópio y', 'giroscópio z']) # GPIO.output (4, GPIO. ALTO) sense.clear () sense.show_letter ("!", Verde) data_writer.writerow (impacto)

outro:

# GPIO.output (4, GPIO. LOW) sense.clear ()

def get_sense_data (): // função para registrar e armazenar valores do sensor sense_data =

sense_data.append (sense.get_temperature ()) sense_data.append (sense.get_pressure ()) sense_data.append (sense.get_humidity ())

orientação = sense.get_orientation ()

sense_data.append (orientação ["yaw"]) sense_data.append (orientação ["pitch"]) sense_data.append (orientação ["roll"])

acc = sense.get_accelerometer_raw ()

sense_data.append (acc ["x"]) sense_data.append (acc ["y"]) sense_data.append (acc ["z"]) mag = sense.get_compass_raw () sense_data.append (mag ["x"]) sense_data.append (mag ["y"]) sense_data.append (mag ["z"])

giroscópio = sense.get_gyroscope_raw ()

sense_data.append (gyro ["x"]) sense_data.append (gyro ["y"]) sense_data.append (gyro ["z"])

sense_data.append (datetime.now ())

retornar sense_data

com open ('data.csv', 'w', newline = '') como f:

data_writer = escritor (f)

data_writer.writerow (['temp', 'pres', 'hum', 'yaw', 'pitch', 'roll', 'acc x', 'acc y', 'acc z', 'mag x', ' mag y ',' mag z ',' giroscópio x ',' giroscópio y ',' giroscópio z ',' data e hora '])

enquanto verdadeiro:

print (get_sense_data ()) para o evento em sense.stick.get_events (): # Verifique se o joystick foi pressionado se event.action == "pressionado": # Verifique em qual direção se event.direction == "up": # sense.show_letter ("U") # seta para cima aceleração = sense.get_accelerometer_raw () x = aceleração ['x'] y = aceleração ['y'] z = aceleração ['z'] x = redondo (x, 0) y = redondo (y, 0) z = redondo (z, 0)

# Atualize a rotação da tela dependendo de qual caminho para cima o if x == -1: sense.set_rotation (90) elif y == 1: sense.set_rotation (270) elif y == -1: sense.set_rotation (180) else: sense.set_rotation (0) sense.clear () t = sense.get_temperature () t = round (t, 1) mensagem = "T:" + str (t) sense.show_message (mensagem, text_colour = red, scroll_speed = 0.09) elif event.direction == "down": acceleration = sense.get_accelerometer_raw () x = aceleração ['x'] y = aceleração ['y'] z = aceleração ['z'] x = round (x, 0) y = redondo (y, 0) z = redondo (z, 0)

# Atualize a rotação da tela dependendo de qual caminho para cima o if x == -1: sense.set_rotation (90) elif y == 1: sense.set_rotation (270) elif y == -1: sense.set_rotation (180) else: sense.set_rotation (0) # sense.show_letter ("D") # Seta para baixo sense.clear () h = sense.get_humidity () h = round (h, 1) message = "H:" + str (h) sense.show_message (message, text_colour = green, scroll_speed = 0,09) p = sense.get_pressure () p = round (p, 1) mensagem = "P:" + str (p) sense.show_message (mensagem, text_colour = amarelo, scroll_speed = 0,09)

# elif event.direction == "left":

# acceleration = sense.get_accelerometer_raw () # x = acceleration ['x'] #y = acceleration ['y'] #z = acceleration ['z'] # x = round (x, 0) # y = round (y, 0) # z = redondo (z, 0)

# Atualize a rotação da tela dependendo de qual caminho para cima // Não usado e controlado por node-red #if x == -1: sense.set_rotation (90) #elif y == 1: sense.set_rotation (270) #elif y == -1: sense.set_rotation (180) #else: sense.set_rotation (0) # sense.show_letter ("L") # Seta para a esquerda # elif event.direction == "right": # sense.show_letter ("K") # Seta para a direita # elif event.direction == "middle": # sense.clear ()

impacto()

data = get_sense_data ()

dt = data [-1] - timestamp se dt.seconds> delay: data_writer.writerow (data) timestamp = datetime.now ()

Etapa 18: monitoramento de vídeo ao vivo

O Impact Recorder também pode ser usado para monitorar o vídeo ao vivo, já que o vídeo pode ser iniciado a qualquer hora e em qualquer lugar por meio do MQTT

usaríamos o VLC player para transmitir vídeos, por padrão no último raspbian o VLC é pré-instalado, caso contrário, instale o vlc como em

Mais informações sobre a visualização do fluxo da rede podem ser acessadas através do fluxo da rede VLC

Obrigado por ler !!

O gravador de impacto pode fazer muito mais.

Cuidado com o próximo espaço para análise de campo magnético ao realizar o mapeamento de obstáculos