def test_get_predictor_from_lines(self):
BUGSAT1_TLE_LINES = (
"1 40014U 14033E 14294.41438078 .00003468 00000-0 34565-3 0 3930",
"2 40014 97.9781 190.6418 0032692 299.0467 60.7524 14.91878099 18425")
predictor = sources.get_predictor_from_tle_lines(BUGSAT1_TLE_LINES)
position = predictor.get_position(datetime.datetime(2019, 1, 1))
self.assertEqual(position.position_ecef, (-5280.795613274576, -3977.487633239489, -2061.43227648734))
def get_satellite(index, station_names, satlist):
line1, line2 = satlist[index]
TLE_LINES = (line1, line2)
predictor = get_predictor_from_tle_lines(TLE_LINES)
lcd.set_cursor(0,0)
lcd.message("{:<16s}".format(station_names[index]))
return predictor, station_names[index]
def get_predictor(self, for_date=None):
"""
Build an orbit predictor for the satellite, using its known TLEs.
"""
assert self.tles.exists()
if for_date:
best_tle = self.get_closest_tle(for_date)
else:
best_tle = self.tles.order_by('at').last()
return get_predictor_from_tle_lines(best_tle.lines.split('\n'))
def __init__(self, state, parameters, config, timeseries, deployment_days, id):
"""
Constructs an individual satellite based on defined configuration.
"""
self.state = state
self.parameters = parameters
self.config = config
self.timeseries = timeseries
self.deployment_days = deployment_days
self.satstate = {'id': id} # Crewstate is unique to this agent
self.worked_today = False
########################--------------This should move to the weather_lookup.py in the future--------------################
# load pre-defined orbit grids, this is unique for each satellite, a function should be created to automatically calculate
# grid based on the TLE_file/ the name of satellites
sg = self.parameters['methods']['satellite']['Satellite_grid']
wd = self.parameters['working_directory']
Dataset = nc.Dataset(wd+sg, 'r')
self.satgrid = Dataset.variables['sat'][:]
Dataset.close()
# load cloud cover data
cloud = self.parameters['methods']['satellite']['CloudCover']
Dataset = nc.Dataset(wd + cloud, 'r')
self.cloudcover = Dataset.variables['tcc'][:]
Dataset.close()
# build a satellite orbit object
sat = self.parameters['methods']['satellite']['sat']
tlefile = self.parameters['methods']['satellite']['TLE_file']
TLEs = []
with open(wd+tlefile) as f:
for line in f:
TLEs.append(line.rstrip())
i = 0
for x in TLEs:
if x == sat:
break
i += 1
TLE_LINES = (TLEs[i+1], TLEs[i+2])
self.predictor = get_predictor_from_tle_lines(TLE_LINES)
###############################################################################################################################
return
def sate_predictors():
# First tle: The nominal case: LEO orbit sun-sync
# Second tle: Beta angle with no-eclipse months
predictors = {
'nominal_newsat':
('1 45018U 20003C 20059.45818850 .00000954 00000-0 38528-4 0 9996',
'2 45018 97.3318 127.6031 0014006 111.9460 248.3269 15.27107050 6765'
),
'rare_ltan6':
('1 37673U 11024A 20058.76186510 .00000058 00000-0 16774-4 0 9995',
'2 37673 98.0102 67.8905 0000719 69.0278 104.2216 14.72969019468543'
),
}
return {
sate_name: get_predictor_from_tle_lines(tle)
for sate_name, tle in predictors.items()
}
def distCalculation():
act = False
flag = [0]*14
dists_v = [0]*14
i = 0
with open('TLE.txt') as TLE:
predictor = get_predictor_from_tle_lines(TLE)
result = predictor.get_position(datetime.now())
pos_ecef = result[1]
#Rads
lat, lon, h = ecef_to_llh(pos_ecef)
#Degrees
lat = lat*pi/180
lon = lon*pi/180
userLat = -22.412
userLong = -45.46
d = (sqrt(pow((userLat - lat)*60*1852, 2) + pow(userLong - lon*60*1852, 2))/1000);
if(d > 20112):
d = 40024 - d
real_dist = sqrt(pow(d,2)+pow(h,2))
if(real_dist < 14000):
flag[i] = 1
dists_v[i++] = real_dist
act = True
if(act):
message = "Working....."
password = "******"
msgFrom = "*****@*****.**"
msgTo = "*****@*****.**"
server = smtplib.SMTP('smtp.gmail.com: 587')
server.starttls()
server.login(msgFrom, password)
server.sendmail(msgFrom, msgTo, message)
server.quit()
def predict_path(satellite_id, tle, start_date, end_date, step_seconds):
"""
Predict the positions of a satellite during a period of time, with certain step precision.
"""
_, line1, line2 = split_tle(tle)
predictor = get_predictor_from_tle_lines((line1, line2))
assert start_date < end_date
step = timedelta(seconds=step_seconds)
# iterate over time, returning the position at each moment
current_date = start_date
while current_date <= end_date:
# the predictor works with naive dates only
naive_current_date = ensure_naive(current_date)
lat, lon, elevation_km = predictor.get_position(naive_current_date).position_llh
yield Position(lat, lon, elevation_km * 1000,
object_id=satellite_id, at_date=current_date)
current_date += step
def calc_ground_track(id):
cred_file = "secret.json"
setting_file = "settings.json"
g_credentials, g_settings = initialiaze_app(cred_file, setting_file)
start_t = datetime.datetime.now()
tle_lines = get_tle(id, g_credentials)
print(f"PROCESSING TLE: {tle_lines}", file=sys.stderr)
predictor = get_predictor_from_tle_lines(tle_lines)
start_time = datetime.datetime.utcnow()
n_points = int(request.args.get("n-points") or g_settings["n-points"])
time_resolution = str(
request.args.get("time-resolution")
or g_settings["time-resolution"]) + "S"
latlon = ""
if request.args.get("cache") is not None:
#cached version
predictor_c = CacheablePredictor(predictor)
latlon = predict_gt_cacheable(predictor_c, time_resolution, n_points)
else:
latlon = predict_gt(predictor, start_time, time_resolution, n_points)
# DEAD CODE for cartopy
'''
fig = FigureWidget()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.stock_img()
plt.plot(latlon["lon"], latlon["lat"], 'k',
transform=ccrs.Geodetic())
plt.show(fig)
print("latitude:",lat,"longitude:",lon)
'''
end_t = datetime.datetime.now()
duration_req = (end_t - start_t).seconds
print(
f"SERVING THE REQUEST for {n_points} points and resolution of {time_resolution} took || {duration_req} seconds ||",
file=sys.stderr)
return jsonify(latlon.to_dict(orient='split'))
def predict_passes(satellite_id, tle, target, start_date, end_date, min_tca_elevation=None,
min_sun_elevation=None):
"""
Predict the passes of a satellite over a location on TCA between two dates.
"""
_, line1, line2 = split_tle(tle)
predictor = get_predictor_from_tle_lines((line1, line2))
location = target.as_op_location()
start_date = ensure_naive(start_date)
end_date = ensure_naive(end_date)
# this is done like this, because orbit_predictor interprets max_elevation_gt=None as
# an angle and explodes
extra_filters = {}
if min_tca_elevation is not None:
extra_filters['max_elevation_gt'] = min_tca_elevation
passes_iterator = predictor.passes_over(location, start_date, limit_date=end_date,
**extra_filters)
for pass_ in passes_iterator:
azimuth_elevation = sun_azimuth_elevation(
location.latitude_deg, location.longitude_deg, pass_.max_elevation_date,
)
if min_sun_elevation is not None and azimuth_elevation.elevation < min_sun_elevation:
# Sun is too low, skip this pass
continue
yield Pass(
satellite_id=satellite_id,
target_id=target.object_id,
aos=make_aware(pass_.aos, timezone=pytz.utc),
los=make_aware(pass_.los, timezone=pytz.utc),
tca=make_aware(pass_.max_elevation_date, timezone=pytz.utc),
tca_elevation=pass_.max_elevation_deg,
sun_azimuth=azimuth_elevation.azimuth,
sun_elevation=azimuth_elevation.elevation,
)
def _calculate_series(
location: Location, tle: Sequence[str], aos: datetime, los: datetime,
time_step: timedelta
) -> Tuple[Sequence[datetime], Sequence[float], Sequence[float]]:
'''Calculate data for plot diagrams'''
date_series: List[datetime] = []
azimuth_series: List[float] = []
elevation_series: List[float] = []
location = PredictLocation("server", *location)
predictor = get_predictor_from_tle_lines(tle)
date: datetime = aos
while (date <= los):
position = predictor.get_position(date)
az, el = location.get_azimuth_elev_deg(position)
date_series.append(date)
azimuth_series.append(az)
elevation_series.append(el)
date += time_step
return date_series, azimuth_series, elevation_series
def get_predictor(self):
self.predictor = get_predictor_from_tle_lines((self.tle_1, self.tle_2))
return self.predictor
import pyproj
#import orbit-predictor
from orbit_predictor.sources import EtcTLESource
#from orbit_predictor.locations import brazil
from orbit_predictor.sources import get_predictor_from_tle_lines
import datetime
from datetime import datetime
TLE_LINES = (
"1 25544U 98067A 20292.96180177 .00000594 00000-0 18740-4 0 9996",
"2 25544 51.6435 96.0270 0001354 46.8738 91.3465 15.49312758251202")
now = datetime.now()
'''
ano,mes,dia = now.strftime("%Y"),now.strftime("%m"),now.strftime("%d")
h,m,s = now.strftime("%H"),now.strftime("%M"),now.strftime("%S")
'''
predictor = get_predictor_from_tle_lines(TLE_LINES)
pre = predictor.get_position(now)
x = pre[1][0]
y = pre[1][1]
z = pre[1][2]
ecef = pyproj.Proj(proj='geocent', ellps='WGS84', datum='WGS84')
lla = pyproj.Proj(proj='latlong', ellps='WGS84', datum='WGS84')
lon, lat, alt = pyproj.transform(ecef, lla, x, y, z, radians=False)
print(lat, lon, alt)
def _get_satellite_tle(self):
request = requests.get(self.satellite_tle_url)
tle = request.content.decode('utf-8')
lines = tle.split("\n")
predictor = get_predictor_from_tle_lines(tuple(lines[1:3]))
return predictor.get_next_pass(self.location)
