You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
284 lines
11 KiB
284 lines
11 KiB
import re
|
|
import socket
|
|
from flask import Flask, request
|
|
from twilio.twiml.messaging_response import MessagingResponse
|
|
import time
|
|
import threading
|
|
|
|
app = Flask(__name__)
|
|
|
|
# APRS-IS login info
|
|
serverHost = 'rotate.aprs2.net'
|
|
serverPort = 14580
|
|
aprsUser = 'CALLSIGN' # Login call
|
|
aprsCall = None # Default RF Call
|
|
aprsPass = 'PASS'
|
|
text = 'Satellite Beacon'
|
|
symbol_chart = '\\' # Replace with your desired symbol chart (e.g., '/', '\\', '!', etc.)
|
|
symbol = 'S' # Replace with your desired symbol (e.g., 'S', 'O', 'P', etc.)
|
|
|
|
|
|
aprs_sock = None # Define the socket outside the try-except block
|
|
|
|
def load_alias_map_from_file():
|
|
alias_map = {}
|
|
print("Opening File")
|
|
with open('/root/app/map.txt', 'r') as file:
|
|
print("File Opened")
|
|
for line in file:
|
|
parts = line.strip().split(',')
|
|
if len(parts) == 2:
|
|
phone_number, aprs_callsign = parts
|
|
alias_map[phone_number] = aprs_callsign
|
|
return alias_map
|
|
|
|
def update_alias_map_file(alias_map):
|
|
map_file_path = '/root/app/map.txt'
|
|
|
|
# Read the existing data from the file
|
|
with open(map_file_path, 'r') as file:
|
|
existing_data = file.readlines()
|
|
|
|
# Update or add entries in the existing data
|
|
updated_data = []
|
|
for line in existing_data:
|
|
parts = line.strip().split(',')
|
|
if len(parts) == 2:
|
|
phone_number, aprs_callsign = parts
|
|
updated_call = alias_map.get(phone_number, aprs_callsign)
|
|
updated_line = "{},{}\n".format(phone_number, updated_call)
|
|
updated_data.append(updated_line)
|
|
# Add new entries for numbers not already in the alias map
|
|
for phone_number, aprs_callsign in alias_map.items():
|
|
if not any(line.startswith(f"{phone_number},") for line in updated_data):
|
|
updated_data.append("{},{}\n".format(phone_number, aprs_callsign))
|
|
|
|
# Write the updated data back to the file
|
|
with open(map_file_path, 'w') as file:
|
|
file.writelines(updated_data)
|
|
|
|
print("Wrote to file")
|
|
|
|
|
|
def connect_to_aprs_server():
|
|
global aprs_sock
|
|
while True:
|
|
try:
|
|
# Create and connect the APRS-IS socket
|
|
aprs_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
aprs_sock.connect((serverHost, serverPort))
|
|
login_str = 'user {} pass {} vers SatGate 0.1b\r\n'.format(aprsUser, aprsPass)
|
|
aprs_sock.send(login_str.encode())
|
|
response = aprs_sock.recv(1024).decode('utf-8')
|
|
print('APRS-IS login response:', response)
|
|
return
|
|
except Exception as e:
|
|
print('Error connecting to APRS-IS:', e)
|
|
time.sleep(1) # Wait for a while before attempting reconnection
|
|
|
|
|
|
# Function to send a keepalive APRS packet
|
|
def send_keepalive_packet():
|
|
global aprs_sock # Declare aprs_sock as global
|
|
while True:
|
|
if aprs_sock:
|
|
keepalive_packet = '#\r\n'
|
|
try:
|
|
aprs_sock.send(keepalive_packet.encode())
|
|
print("Keepalive Sent")
|
|
except Exception as e:
|
|
print("Error sending keepalive:", e)
|
|
aprs_sock.close()
|
|
aprs_sock = None # Close and reset the socket
|
|
connect_to_aprs_server() # Attempt reconnection
|
|
else:
|
|
connect_to_aprs_server() # If socket is not active, attempt reconnection
|
|
time.sleep(30)
|
|
|
|
# Function to send a beacon APRS packet
|
|
def send_beacon_packet():
|
|
global aprs_sock # Declare aprs_sock as global
|
|
while True:
|
|
if aprs_sock:
|
|
beacon_packet = 'SATGTE>NA7Q:!4610.49N\\12334.72WSMotorola Defy Satellite Gateway - NA7Q\r\n'
|
|
try:
|
|
aprs_sock.send(beacon_packet.encode())
|
|
print("Beacon Sent")
|
|
except Exception as e:
|
|
print("Error sending beacon:", e)
|
|
aprs_sock.close()
|
|
aprs_sock = None # Close and reset the socket
|
|
connect_to_aprs_server() # Attempt reconnection
|
|
else:
|
|
connect_to_aprs_server() # If socket is not active, attempt reconnection
|
|
time.sleep(600)
|
|
|
|
|
|
def latitude_to_ddmm(value):
|
|
degrees = int(value)
|
|
minutes_decimal = (value - degrees) * 60
|
|
abs_minutes = abs(minutes_decimal)
|
|
minutes = round(abs_minutes, 2)
|
|
|
|
# Ensure that degrees and minutes have leading zeros
|
|
degrees_str = "{:02d}".format(abs(degrees))
|
|
minutes_str = "{:05.2f}".format(abs(minutes))
|
|
|
|
# Ensure that the latitude always has at least 4 digits before the decimal point
|
|
lat_ddmm = "{}{}".format(degrees_str, minutes_str)
|
|
while len(lat_ddmm.split('.')[0]) < 4:
|
|
lat_ddmm = "0" + lat_ddmm
|
|
|
|
return lat_ddmm
|
|
|
|
def longitude_to_ddmm(value):
|
|
degrees = int(value)
|
|
minutes_decimal = (value - degrees) * 60
|
|
abs_minutes = abs(minutes_decimal)
|
|
minutes = round(abs_minutes, 2)
|
|
|
|
# Ensure that degrees and minutes have leading zeros
|
|
degrees_str = "{:03d}".format(abs(degrees))
|
|
minutes_str = "{:05.2f}".format(abs(minutes))
|
|
|
|
# Ensure that the longitude always has at least 5 digits before the decimal point
|
|
lon_ddmm = "{}{}".format(degrees_str, minutes_str)
|
|
while len(lon_ddmm.split('.')[0]) < 5:
|
|
lon_ddmm = "0" + lon_ddmm
|
|
|
|
return lon_ddmm
|
|
|
|
def send_aprs_packet(callsign, lat, lon, text):
|
|
lat_ddmm = latitude_to_ddmm(lat)
|
|
lon_ddmm = longitude_to_ddmm(lon)
|
|
aprs_packet = '{}>APRS:!{}{}{}{}{}{}{}\r\n'.format(callsign, lat_ddmm, "N" if lat >= 0 else "S",symbol_chart, lon_ddmm, "E" if lon >= 0 else "W", symbol, text)
|
|
|
|
|
|
try:
|
|
aprs_sock.sendall(aprs_packet.encode())
|
|
print('Sent APRS packet:', aprs_packet.strip())
|
|
except Exception as e:
|
|
print('Error sending APRS packet:', e)
|
|
|
|
@app.route('/sms', methods=['POST'])
|
|
def webhook():
|
|
global aprsCall # Declare aprsCall as a global variable
|
|
|
|
incoming_sms = request.form.get('Body', '')
|
|
latitude = None
|
|
longitude = None
|
|
comment = ""
|
|
|
|
# Log incoming message
|
|
print('Received Message:', incoming_sms)
|
|
|
|
# Extract the sender's phone number from the Twilio request headers
|
|
from_number_header = request.form.get('From', '').lstrip('+')
|
|
|
|
# Load the alias map from the file
|
|
alias_map = load_alias_map_from_file()
|
|
|
|
# Extract the phone number in the format "From: +15032985265"
|
|
#from_number_match = re.search(r'From:\s*\+(\d+)', incoming_sms)
|
|
#from_number = from_number_match.group(1).lstrip('+') if from_number_match else from_number_header
|
|
#print('Sender\'s Phone Number:', from_number)
|
|
|
|
from_number_match = re.search(r'From:\s*\+(\d+)', incoming_sms)
|
|
from_number = from_number_match.group(1).lstrip('+') if from_number_match else from_number_header
|
|
print('from_number_match:', from_number_match)
|
|
print('from_number_header:', from_number_header)
|
|
print('Final Sender\'s Phone Number:', from_number)
|
|
|
|
|
|
|
|
# Look up the APRS callsign in the alias map based on the phone number
|
|
aprsCall = alias_map.get(from_number, None)
|
|
print('APRS Callsign for this number:', aprsCall)
|
|
|
|
|
|
# Extract the APRS call sign following the "@" symbol (ignores double quotes)
|
|
at_sign_match = re.search(r'@([^"]+)', incoming_sms)
|
|
if at_sign_match:
|
|
new_aprsCall = at_sign_match.group(1).strip().upper() # Extract and convert aprsCall to uppercase
|
|
print('Updated aprsCall:', new_aprsCall)
|
|
|
|
# Update the alias map if the new aprsCall is not in it
|
|
for number, call in alias_map.items():
|
|
if call == aprsCall:
|
|
alias_map[number] = new_aprsCall
|
|
print('Updated alias map:', alias_map)
|
|
|
|
# If the from_number is not in the alias map, add it with the new APRS call
|
|
if from_number not in alias_map:
|
|
alias_map[from_number] = new_aprsCall
|
|
print('Added new entry to alias map:', alias_map)
|
|
|
|
# Set the new aprsCall
|
|
aprsCall = new_aprsCall
|
|
|
|
# Update the map file with the new data
|
|
update_alias_map_file(alias_map)
|
|
|
|
if from_number:
|
|
print('Found From Number:', from_number_header)
|
|
|
|
# Process the message as needed
|
|
# Example: Extract latitude, longitude, and comment from the message
|
|
#lat_long_comment_match = re.search(r'(-?\d+\.\d+),(-?\d+\.\d+)\s*([^"]+)', incoming_sms)
|
|
lat_long_comment_match = re.search(r'(-?\d+\.\d+)\s*,\s*(-?\d+\.\d+)\s*([^"]+)', incoming_sms)
|
|
|
|
|
|
if lat_long_comment_match:
|
|
latitude = float(lat_long_comment_match.group(1))
|
|
longitude = float(lat_long_comment_match.group(2))
|
|
comment = lat_long_comment_match.group(3).strip()
|
|
|
|
# If the comment is "undefined," use the default comment 'text'
|
|
if comment.lower() == "undefined":
|
|
comment = text
|
|
|
|
print('Detected Lat Long: ({}, {})'.format(latitude, longitude))
|
|
print('Detected Comment:', comment)
|
|
|
|
# Convert latitude and longitude to DDMM.MM format without dashes
|
|
lat_ddmm = latitude_to_ddmm(latitude)
|
|
long_ddmm = longitude_to_ddmm(longitude)
|
|
|
|
print('Converted Lat Long to DDMM.MM: {}, {}'.format(lat_ddmm, long_ddmm))
|
|
print('{}/{}'.format(lat_ddmm, long_ddmm))
|
|
print('APRS Comment:', comment)
|
|
|
|
# Send APRS packet using the mapped callsign 'aprsCall' only if it's found in the alias map
|
|
if aprsCall in alias_map.values():
|
|
send_aprs_packet(aprsCall, latitude, longitude, comment)
|
|
else:
|
|
print("APRS Callsign not found in alias map. Skipping APRS packet.")
|
|
|
|
else:
|
|
print('No Lat Long and Comment detected.')
|
|
|
|
else:
|
|
print('No From Number detected.')
|
|
|
|
response = MessagingResponse()
|
|
return str(response)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
connect_to_aprs_server() # Initial connection
|
|
|
|
|
|
# Start a thread to send keepalive packets
|
|
print("Start thread for keepalive")
|
|
keepalive_thread = threading.Thread(target=send_keepalive_packet)
|
|
keepalive_thread.daemon = True
|
|
keepalive_thread.start()
|
|
|
|
# Start a thread to send beacon packets
|
|
print("Start thread for beacons")
|
|
beacon_thread = threading.Thread(target=send_beacon_packet)
|
|
beacon_thread.daemon = True
|
|
beacon_thread.start()
|
|
|
|
print("run host")
|
|
app.run(host='0.0.0.0', port=5000, debug=False)
|