Mapa 3D de rastreamento GPS: 9 etapas

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

Este projeto é um mapa 3D impresso em 3D, com estradas, rios e cidades, com faróis de LED para mostrar a localização de membros da família. Pode mostrar se a criança está ou não na escola ou apenas a localização de ambos os pais. Também podemos usá-lo para prever a que horas os pais chegam em casa, para que o jantar seja feito na hora certa. Também é um projeto geralmente legal para exibir e exibir para a família e amigos.

Espero que você goste de tornar este instrutível ou de descobrir um projeto que fiz

Etapa 1: obter um mapa 3D

Para obter um mapa 3D de sua área, escrevi um instrutível separado para ajudar a guiá-lo durante o processo de confecção de um. O link para o instrutível está aqui:

www.instructables.com/id/Making-a-3D-Print…

Etapa 2: Preparando o Mapa para Inserções de LED

Agora que você tem um mapa 3D, com estradas, cidades e rios, precisamos de uma forma de indicar onde uma pessoa está no mapa. Usei LEDs RG bicolores de 3 mm, porque o objetivo principal do mapa é mostrar onde os pais estão. Em certos locais usei um LED RGB, para me permitir mostrar onde estava o filho mais velho. Há um limite de 28 pinos para saída no Raspberry Pi. Portanto, escolha bem os locais dos LEDs. Acabei usando cerca de 24 deles, então você deve ficar bem.

Para perfurar PLA, descobri que uma broca normal para madeira funcionou bem e tratei é como trataria madeira.

Em locais onde o mapa era muito espesso, eu perfuraria a camada de base com uma broca grande e, em seguida, a camada visível acima com a broca de 3 mm correta.

Etapa 3: Insira os LEDs

Agora que temos orifícios para os LEDs se encaixarem, podemos colá-los. PVA ou Supercola funcionam bem para isso, descobri que PVA correu em torno dele selando-o no lugar, e a supercola também funcionou muito bem. Certifique-se de que, com cada LED, eles fiquem apenas alguns mm no lado visível, porque os LEDs ficam um pouco confusos. Não se preocupe com as pernas na parte de trás, podemos dobrá-las depois de soldadas.

Etapa 4: conecte os LEDs ao Raspberry Pi

Soldei diretamente os LEDs ao Raspberry Pi, no entanto, se você tiver um com um conector pré-soldado ou quiser usar o pi para outra coisa, sugiro usar fios de jumper para cada LED, o que significa que o Pi é removível. Você pode ver que depois de soldar o LED, dobrei as pernas para que não grudassem na parte de trás.

Etapa 5: Teste os LEDs

Para ter certeza de que todos os LEDs estão funcionando, executei um script que passa por cada pino possível e os acende, um de cada vez, que passa para o próximo quando clico em Enter. Isso me permitiu anotar o número do pino em que localização, o que foi muito útil.

importar RPi. GPIO como GPIO

tempo de importação GPIO.setmode (GPIO. BCM) para i no intervalo (0, 28): GPIO.setup (i, GPIO. OUT) para i no intervalo (0, 28): GPIO.output (i, GPIO. HIGH) time.sleep (0.3) GPIO.output (i, GPIO. LOW) print ("Isso foi:" + str (i)) z = raw_input ("Next?")

Enquanto isso acontecia, eu anotava em um arquivo de texto qual pino fazia qual localização e qual cor. Você precisa fazer isso, pois é muito útil na próxima etapa.

Etapa 6: Código para ligar o LED quando solicitado

A forma como fiz este projeto envolve um Raspberry Pi Zero W, com um site básico que permite ativar um alfinete. Isso significava que o Pi 4 principal, que geralmente está ligado e em execução, pode fazer o processamento, e então o pequeno Pi 0 só precisa ativar um pino, tornando as coisas um pouco mais complicadas. Fiz isso porque se adequa à minha configuração e também senti que o Pi 0 pode ser um pouco lento para o que faremos mais tarde.

importar RPi. GPIO como GPIO

import time from flask importar Flask, render_template, request, jsonify import os app = Flask (_ name_) p = GPIO.setmode (GPIO. BCM) para i no intervalo (0, 28): GPIO.setup (i, GPIO. OUT) @ app.route ('/') def index (): return request.remote_addr @ app.route ("/ off /") def turn_off (pin): GPIO.output (int (pin), GPIO. LOW) return "Off" @ app.route ("/ off / all") def alloff (): para i no intervalo (0, 28): GPIO.output (i, GPIO. LOW) return "off" @ app.route ("/ on /") def turn_on (pin): GPIO.output (int (pin), GPIO. HIGH) retorna "On" se _name_ == '_main_': app.run (debug = True, host = '0.0. 0,0 ')

A forma como isso funciona é aguardar a url do endereço IP do pi e, em seguida, um on ou off e, em seguida, o número do pin.

salve este código no diretório inicial do Raspberry Pi e nomeie-o como "pin_website.py"

Você precisará definir isso para ser executado automaticamente, para fazer isso, no tipo de terminal: sudo nano / etc / profile

Na parte inferior deste arquivo, adicione "python3 pin_website.py &"

O "&" é essencial, pois faz com que seja executado em segundo plano e, portanto, permite que a inicialização continue

Etapa 7: Como obter localização

Usando o IFTTT, você pode configurar um serviço de forma que, quando o telefone entrar em um determinado local, ele possa enviar um e-mail para você, fazer ping em um endereço da web ou enviar uma mensagem por telegrama.

Etapa 8: Como tudo isso funciona

A configuração que tenho é um Server Pi, hospedando meu site, com encaminhamento de porta e um DNS estático usando o serviço fornecido por https://freedns.afraid.org/. Muito disso é bastante complexo, e você precisa ter uma compreensão do encaminhamento de porta, posso fazer um instrutivo sobre como fazer essa parte em outra ocasião.

Outra maneira de fazer isso é usar o telegrama para enviar mensagens ao pi, ou possivelmente a mais fácil, é configurar um leitor de e-mail que lê os e-mails e recebe atualizações de localização por meio dele.

Não experimentei o bot do Telegram ou um leitor de e-mail, mas existem muitos tutoriais por aí que mostram como fazer.

Aqui está meu código Flask / Python, que é solicitado por webhooks usando IFTTT:

from flask importar Flask, render_template, request, jsonify

import os from datetime import datetime from map import * app = Flask (_ name_) l = 0 setup () @ app.route ('/') def index (): return request.remote_addr @ app.route ('/ mum / enter / ') def mu (local): mum.current_loc (local) return "Obrigado pela atualização, mãe!" @ app.route ("/ dad / enter /") def da (l): dad.current_loc (l) return "Obrigado pela atualização, pai!" @ app.route ("/ child / enter /") def child_enter (l): me.current_loc (l) return "Ei, eu" @ app.route ('/ mãe / saída /') def mume (localização): mum.offline (localização) return "Obrigado pela atualização, mamãe!" @ app.route ("/ dad / exit /") def dade (l): dad.offline (l) return "Obrigado pela atualização, pai!" @ app.route ("/ child / exit /") def child_exit (l): me.offline (l) return "Ei, eu" @ app.route ("/ reset") def redo (): setup () return "Redefinir!" if _name_ == '_main_': app.run (debug = True, host = '0.0.0.0')

e map.py:

importar http.client, urllib.request, urllib.parse, urllib.error, base64

import ast, json import time import threading import os params = urllib.parse.urlencode ({}) last_loc = 0 dlast_loc = 0 mlast_loc = 0 def setup (): conn = http.client. HTTPSConnection ('freedns.afraid.org') conn.request ("GET", str ("/ dynamic / update.php? ZmFpOWlJQ29QczhiOW1iYWJoNVdVcG9HOjE5MTM2ODU2")) response = conn.getresponse () conn = http.client. HTTPConnection ('192.168.1.251:5000' "GET", str ("/ off / all")) response = conn.getresponse () f = open ("pin", "w") f.write (str (-1)) f.close () f = open ("pind", "w") f.write (str (-1)) f.close () f = open ("pinm", "w") f.write (str (-1)) f.close () classe mãe: def current_loc (l): global last_loc locs = {"llansantffraid": 4, "oswestry": 5, "lynclys": 8, "home": 9, "shrewsbury": 11, "llanymynech": 13, "quatro cruzes": 18, "llandrinio": 25, "welshpool": 27} f = open ("pin", "w") f.write (str (-1)) f.close () time. sleep (1) conn = http.client. HTTPConnection ('192.168.1.251:5000') conn.request ("GET", str ("/ off /") + str (last_loc)) response = conn.getrespons e () conn = http.client. HTTPConnection ('192.168.1.251:5000') conn.request ("GET", str ("/ on /") + str (locs [l])) resposta = conn.getresponse () last_loc = locs [l] def offline (l): global last_loc locs = {"llansantffraid": 4, "oswestry": 5, "lynclys": 8, "home": 9, "shrewsbury": 11, "llanymynech ": 13," quatro cruzes ": 18," llandrinio ": 25," welshpool ": 27} conn = http.client. HTTPConnection ('192.168.1.251:5000') conn.request (" GET ", str (" / off / ") + str (last_loc)) response = conn.getresponse () f = open (" pin "," w ") f.write (str (locs [l])) f.close () os.system ("python3 flash.py &") class dad: locs = {"welshpool": 3, "lynclys": 1, "home": 23, "shrewsbury": 0, "llanymynech": 6, "quatro cruzes": 15, "llandrinio": 10, "welshpool": 24} def current_loc (l): global dlast_loc locs = {"welshpool": 3, "lynclys": 1, "home": 23, "shrewsbury": 0, " llanymynech ": 6," quatro cruzes ": 15} f = open (" pind "," w ") f.write (str (-1)) f.close () time.sleep (1) conn = http.client. HTTPConnection ('192.168.1.251:5000') conn.reques t ("GET", str ("/ off /") + str (dlast_loc)) response = conn.getresponse () conn = http.client. HTTPConnection ('192.168.1.251:5000') conn.request ("GET", str ("/ on /") + str (locs [l])) response = conn.getresponse () dlast_loc = locs [l] def offline (l): global dlast_loc locs = {"welshpool": 3, "lynclys ": 1," home ": 23," shrewsbury ": 0," llanymynech ": 6," quatro cruzes ": 15," llandrinio ": 10} conn = http.client. HTTPConnection ('192.168.1.251:5000') conn.request ("GET", str ("/ off /") + str (dlast_loc)) response = conn.getresponse () f = open ("pind", "w") f.write (str (locs [l])) f.close () os.system ("python3 flashd.py &") class me: def current_loc (l): global mlast_loc locs = {"home": 22, "school": 2, "oswestry": 14} f = open ("pinm", "w") f.write (str (-1)) f.close () time.sleep (1) conn = http.client. HTTPConnection ('192.168.1.251:5000 ') conn.request ("GET", str ("/ off /") + str (mlast_loc)) response = conn.getresponse () conn = http.client. HTTPConnection (' 192.168.1.251:5000 ') conn.request ("GET", str ("/ on /") + str (lo cs [l])) response = conn.getresponse () mlast_loc = locs [l] def offline (l): global dlast_loc locs = {"home": 22, "school": 2, "oswestry": 14} conn = http.client. HTTPConnection ('192.168.1.251:5000') conn.request ("GET", str ("/ off /") + str (mlast_loc)) response = conn.getresponse () f = open ("pinm", "w") f.write (str (locs [l])) f.close () os.system ("python3 flashm.py &")

Etapa 9: Construa o seu com a inspiração do meu projeto

Então eu sei que a etapa anterior vai ser muito difícil de entender, então vou deixá-la mostrando como fazer o mapa, e poder ter um pi framboesa que liga e desliga os LEDs. Agora você precisa criar um script Python que, usando IFTTT, envia um e-mail para você. Então você precisa encontrar um e-mail que leia um pedaço de código, o que é bastante fácil (google it). Depois de ler um e-mail e encontrar a localização de um dos pais, use as declarações 'if' para descobrir qual pino ativar.

No mapa, uma luz piscando significa que eles acabaram de sair da área

A maneira de ligar os LEDs em outro pi do python é a seguinte:

importar http.client, urllib.request, urllib.parse, urllib.error, base64

params = urllib.parse.urlencode ({}) conn = http.client. HTTPConnection ('192.168.1.251:5000') #altere com o endereço IP do mapa raspberry pi conn.request ("GET", str ("/ off / 2 ")) # isso desativa o pino número 2 response = conn.getresponse () # isso solicita a URL e, em seguida, o mapa pi lê isso e desativa o pino número 2

Basicamente, espero que você possa usar o que fiz com meu mapa 3D como inspiração para fazer seu próprio mapa de rastreamento GPS.