Centro De Comando Emergenze - Erupção De Vulcão E Terremotos: 7 Passi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

Progetto accademico per assistere a un progetto di collaborazione attraverso Internet per la divulgazione di danni naturali, per potersi permettere un rilevamento dei risultati attraverso i sensori IOT di temperatura, luminosità, oscillazione (inclinazione) e botão de pânico. Non c'è un progetto di collaborazione previo integrazione con Twitter e applicazioni con supporto mqtt per l'attivazione degli avvisi.

Diante una possibilità di accedere a soluzioni diverse, caberá um centro de operações avaliar se un'informazione può essere corretta evitando di falsificare i dispositivi automatici e disponi di una possibilità di fakenews. Tal tomada de decisão é cruciale diante ao pânico que um alarme falso pode gerar.

Como solução de alerta de mensagem estamos considerando o uso do envio de SMS, alerta através de cliente mqtt, email, sirene e twitter.

O projeto contou com uso de recursos da AWS incluindo IOT CORE, EC2 e SNS

Sensori di DragonBord 410c

clientes android mqtt

Sendo todo desenvolvido em python

Autori:

Diego Fernandes dos Santos – [email protected]

Gabriel Piovani Moreira dos Santos – [email protected]

Gustavo Venancio Luz – [email protected]

Paulo Henrique Almeida Santos – [email protected]

Passaggio 1: Dragonbord 410c - Pubblicazione dei sensori - Analogico

Abaixo o codigo de publicação dos sensors analógicos, os sensors de temperatura e luminosit à configuratodos para que assim que detectarem uma variação fora do padrão pré stabelecido enviarem um alerta attravés do protocolo mqtt sinalizando um evento.

Este alerta começa a contagem regressiva que pode ser suspensa ou acelerada pelo operador.

O contador para o alerta come un contagio regressiva em 60 seguntos, e todo novo alerta detectado decresce o contador em 20 segundos.

programma rodando dentro da dragon borad 410c

#!/usr/bin/python3import spidev from libsoc import gpio from time import sleep

# Importa lib per comunicacao com MOSQUITTO import paho.mqtt.client as mqtt

spi = spidev. SpiDev() spi.open(0, 0) spi.max_speed_hz=10000 spi.mode = 0b00 spi.bits_per_word = 8

#Usando una porta ADC1 channel_select1=[0x01, 0x80, 0x00]

#Para usar a porta ADC2 use o seguinte vetor de configuração channel_select2=[0x01, 0xA0, 0x00]

def on_connect(mqttc, obj, flags, rc): print("rc: " + str(rc))

def on_message(mqttc, obj, msg): print(msg.topic + " " + str(msg.qos) + " " + str(msg.payload))

def on_publish(mqttc, obj, mid): print("Message Id: " + str(mid) + "\n") pass

# Criamos o client e setamos suas configuracoes mqttc = mqtt. Client()

mqttc.on_message = on_message mqttc.on_connect = on_connect mqttc.on_publish = on_publish

pub = mqtt. Client("grupo3")

# Conexao com localhost, uma vez que testamos fora do labredes. broker_address ="34.230.74.201"

pub.connect(broker_address)

if _name_=='_main_': gpio_cs = gpio. GPIO(18, gpio. DIRECTION_OUTPUT)

con gpio.request_gpios([gpio_cs]): contador=0 adc_value_old=0 adc_value2_old=0 mentre contador < 50: gpio_cs.set_high() sleep(0.00001) gpio_cs.set_low() rx = spi.xfer(channel_select1) gpio_cs.set_high() contattore = contattore + 1 valore_adc = (rx[1] << 8) & 0b1100000000 valore_adc = valore_adc | (rx[2] & 0xff) adc_value = (((adc_value * 5) / 1024) - 0.5) * 100 print("Temperatura: %f\n" % adc_value) pub.publish("temperatura", str(adc_value)) # teste para acionar contador do alarme, teste ultima leitura + 5%

if adc_value_old==0: adc_value_old=adc_value if adc_value > (adc_value_old*1.05): pub.publish("ALARME", "ON") print ("Allarme temperatura") adc_value_old=adc_value sleep(1)

gpio_cs.set_high() sleep(0.00001) gpio_cs.set_low() rx = spi.xfer(channel_select2) gpio_cs.set_high() contador = contador + 1 adc_value2 = (rx[1] << 8) & 0b1100000000 adc_value2 = adc_value2 | (rx[2] & 0xff) adc_value2 = adc_value2 /10 print(" Luminosidade: %f\n" % adc_value2) pub.publish("luminosidade", str(adc_value2))

# teste para acionar contador do alarme, teste ultima leitura + 50%

if adc_value2_old==0: adc_value2_old=adc_value2 if adc_value2 > (adc_value2_old*1.5): pub.publish("ALARME", "ON") print ("Alarmado Luminosidade") adc_value2_old=adc_value2 sleep(3)

Passaggio 2: Sensori digitali - Pubblicazione

codice per la pubblicazione dei sensori digitali

Os sensors digitais neste projeto foram o tilte que detecta os tremores e o botão para simular o use de um botão de pânico.

Quando rileva un'anomalia o un botão de pânico pressionado a contagem regressiva é iniciada.

programma rodando dentro da dragon borad 410c

from libsoc_zero. GPIO import Buttonfrom libsoc_zero. GPIO import Tilt from time import sleep import paho.mqtt.client as mqtt import sys

def on_connect(mqttc, obj, flags, rc): print("Conectado " + str(rc))

def on_message(mqttc, obj, msg): print(msg.topic + " " + str(msg.qos) + " " + str(msg.payload))

def on_publish(mqttc, obj, mid): # print("ID messaggio: " + str(mid) + "\n") pass

def detectaTilt(): count = 0 sleep_count = 0 while True: try: tilt.wait_for_tilt(1) tranne: sleep_count += 1 else: count += 1 sleep_count += 1 if sleep_count > 999: break

print("count:", count) if count>200: pub = mqttc.publish("TERREMOTO", "ON") pub = mqttc.publish("SISMOGRAFO", str(count)) # Criamos o client e setamos suas configuraci mqttc = mqtt. Client()

mqttc.on_message = on_message mqttc.on_connect = on_connect mqttc.on_publish = on_publish

argomento = "gruppo3"

# Conexao com localhost, uma vez que testamos fora do labredes. mqttc.connect("34.230.74.201", 1883)

tilt = Tilt('GPIO-A')

btn = Pulsante('GPIO-C')

while True: sleep(0.25) detectaTilt() if btn.is_pressed(): pub = mqttc.publish("PANICO", "ON") print("Botao ON") sleep(1) pub = mqttc.publish("PANICO ", "OFF") # else: # pub = mqttc.publish("PANICO", "OFF") # print("Botao OFF")

Fase 3: Codigo Para Acionamento Sirene

Codice per la sottoscrizione per l'attivazione di SIRENE, programma inserito nella dragon board 410c

# Importa lib para comunicacao com MOSCHITTOimport paho.mqtt.client as mqtt

from libsoc_zero. GPIO import LED from time import sleep led = LED('GPIO-E') #led.off()

# Define o que fazer ao conectar def on_connect(client, obj, flags, rc): print("ConexÃÆ'£o estabelecida com broker")

# Define o que fazer ao receber uma mensagem def on_message(client, obj, message): print("LED " + str(message.payload.decode("utf-8"))) if str(message.payload.decode("utf-8")) == "on": print("Sirene ligada") led.on() else: print("Sirene apagada") led.off()

# IP do broker broker_address = "34.230.74.201"

# Cria o cliente sub = mqtt. Client("grupo3")

sub.connect(broker_address)

sub.on_message = on_message sub.on_connect = on_connect

# Increve no topico sub.subscribe("SIRENE", qos=0)

# Loop para escuta sub.loop_forever()

Passaggio 4: Codigo Twitter - Post

Codice per la pubblicazione su twitter assim que acionado o alarme.

codice rodando na macchina virtuale da AWS EC2

#!/usr/bin/env python #---------------------------------------- ----------------- # twitter-post-status # - invia un messaggio di stato al tuo diario #--- --------------------------------------------------- ------------------ import paho.mqtt.subscribe as subscribe

tempo di importazione

da importazione twitter *

#------------------------------------------------- ---------------------- # quale dovrebbe essere il nostro nuovo status? #------------------------------------------------- ---------------------- new_status = "#Terremoto Procure uma zona segura - teste"

#------------------------------------------------- ---------------------- # carica le nostre credenziali API #------------------------------------ -------------------------------------------------- importare sys sys.path.append(".") import config

#------------------------------------------------- ---------------------- # crea oggetto API twitter #-------- -------------------------------------------------- twitter = Twitter(auth = OAuth('senha removida))

#------------------------------------------------- ---------------------- # posta un nuovo stato # documenti API twitter: https://dev.twitter.com/rest/reference/post/statu… #------------------------------------------------- --------

while 1: m = subscribe.simple("twitteralarme", hostname="172.31.83.191", mantenuto=False) if m.topic=="twitteralarme" e str(m.payload.decode("utf-8")) =="on": risultati = twitter.statuses.update(status = (new_status)+str(time.time())) # print("stato aggiornato: %s" % new_status)

Passaggio 5: Centro De Comando

sempre que acionado um dispositivo manuale o rilevato um alerta manual do usuário é acionada um contagem regressiva para envio de mensagem. O operador pode cancelar o envio ou acionar o envio imediato do alerta.

Per utilizzare dasboard utilizamos um android do telefone para compor a mesa de operação do centro de comando.

codice rodando na macchina virtuale da AWS EC2

import paho.mqtt.client as pahoimport paho.mqtt.subscribe as subscribe import paho.mqtt.publish as publish import json import time import sei import ssl da time import sleep

argomenti = ['#']

gatilho=0 hora_disparo=0 publish.single("ACIONADO", "OFF", qos=1, hostname="172.31.83.191") publish.single("sensor1", "OFF", qos=1, hostname="172.31.83.191") publish.single("sensor2", "OFF", qos=1, hostname="172.31.83.191")

connflag = False

def on_connect(client, userdata, flags, rc): global connflag connflag = True print(connflag) print("Risultato restituito dalla connessione: " + str(rc))

def on_message(client, userdata, msg): # print("teste") print(msg.topic+" "+str(msg.payload))

def on_log(client, userdata, level, buf): print(msg.topic+" "+str(msg.payload))

mqttc = paho. Client("Broker_MSG") mqttc.on_connect = on_connect mqttc.on_message = on_message

awshost = "data.iot.us-east-1.amazonaws.com" awsport = 8883 clientId = "a2rczvc6ni8105" thingName = "Ufscar2018" caPath = "aws-iot-rootCA.crt" certPath = "9e85dfd42a-certificate.pem. crt" keyPath = "9e85dfd42a-private.pem.key" mqttc.tls_set(caPath, certfile=certPath, keyfile=keyPath, cert_reqs=ssl. CERT_REQUIRED, tls_version=ssl. PROTOCOL_TLSv1_2, cipherschost=awsv1_2, ciphersc., keepalive=60) mqttc.loop_start()

while 1: hora=time.time() sleep(.1) publish.single("LEDTERREMOTO", "on", qos=1, hostname="172.31.83.191")

# if connflag ==True: # mqttc.publish("message", json.dumps({'message':"TERREMOTO"}), qos=1) if gatilho==1: publish.single("TEMPO", str (round(hora_disparo-hora, 0)), qos=1, hostname="172.31.83.191") publish.single("LEDTERREMOTO", "on", qos=1, hostname="172.31.83.191") else: publish.single("TEMPO", "99", qos=1, hostname="172.31.83.191") # print(" ") if (hora>hora_disparo) and (gatilho==1): # print("TERREMOTO") # print(connflag) if connflag == True: # mqttc.publish("message", json.dumps({'message':"TERREMOTO"}), qos=1) # mqttc.publish("message", "TERREMOTO ", qos=1) mqttc.publish("message", json.dumps("TERREMOTO - PROCURE UMA ZONA SEGURA"), qos=1)

# print("test SNS") # publish.single("LED", "on", hostname="172.31.83.191") publish.single("SIRENE", "on", qos=1, hostname="172.31. 83.191") publish.single("TEMPO", "TERREMOTO", qos=1, hostname="172.31.83.191") publish.single("ACIONADO", "OFF", qos=1, hostname="172.31.83.191") publish.single("twitteralarme", "on", qos=1, hostname="172.31.83.191") publish.single("twitter", "TERREMOTO - PROCURE UMA ZONA SEGURA", qos=1, hostname="172.31.83.191") gatilho=0 sleep(5) m = subscribe.simple(topics, hostname="172.31.83.191", mantenuto=False) if m.topic=="ACIONADO" e str(m.payload.decode(" utf-8"))=="OFF": gatilho=0 print("cancelado") if m.topic=="medico" e str(m.payload.decode("utf-8"))=="on ": if connflag == True: mqttc.publish("medico", json.dumps("MEDICOS - EMERGENCIA TERREMOTO"), qos=1) if m.topic=="bombeiro" e str(m.payload.decode("utf-8"))=="on": if connflag == True: mqttc.publish("bombeiro", json.dumps("BOMBEIRO - EMERGENCIA TERREMOTO"), qos=1) if m.topic==" ambulanza" e str(m.payloa d.decode("utf-8"))=="on": if connflag == True: mqttc.publish("ambulancia", json.dumps("AMBULANCIA - EMERGENCIA TERREMOTO"), qos=1) if m. topic=="urgente" e str(m.payload.decode("utf-8"))=="on": publish.single("ACIONADO", 1, qos=1, hostname="172.31.83.191") gatilho=1 hora_disparo=time.time()+5 if str(m.payload.decode("utf-8"))=="ON": if gatilho==1: print("acelerado 20") hora_disparo=hora_disparo -20 else: print("Acionado") publish.single("ACIONADO", 1, qos=1, hostname="172.31.83.191") gatilho=1 hora_disparo=time.time()+60

Passaggio 6: Codigo Twitter - Monitoraggio

código monitoração do twitter, pesquisa post na regiao de sorocaba

codice rodando na macchina virtuale da AWS EC2

n

da twitter import *import config import paho.mqtt.publish as publish

dal tempo importa il sonno

twitter = Twitter(auth = OAuth(config.access_key, config.access_secret, config.consumer_key, config.consumer_secret))

latitudine = -23.546211 longitudine = -46.637840 alcance = 50 risultati = 1

publish.single("twitter_alarm", "ON", hostname="34.230.74.201")

result_count = 0 last_id = Nessuno flag = 0

for i in range(60): #------------------------------------------------------- ---------------- # eseguire una ricerca basata su latitudine e longitudine # documenti API twitter: https://dev. twitter.com/rest/reference/get/search… #------------------------------------- ---------------------------------- prova: query = twitter.search.tweets(q = "#Terremoto", geocode = "%f, %f, %dkm" % (latitudine, longitudine, alcance), max_id = last_id) print("leu")

tranne: print("erro acesso twitter") break

per risultato in query["stati"]:

#------------------------------------------------- ---------------------- # elabora un risultato solo se ha una geolocalizzazione #----------------- --------------------------------------------------- ---- if result["geo"]: result_count += 1 last_id = result["id"] sleep(1) if result_count == resultados: flag += 1 publish.single("twitter_alarme", "ON", hostname="34.230.74.201") publish.single("twitter", "TERREMOTO - DETECTADO", hostname="34.230.74.201") break

Fase 7: Estrutura AWS

Utilizamos uma maquina virtual rodando ubuntu na estrutura AWS EC2

Utilizza un AWS IOT CORE per il servizio di MQTT e configuralo come conforme o tipo di messaggio

Utilizzo degli argomenti di AWS SNS che sono stati utilizzati per AWS IOT CORE