def move_node(service, coordinates):
for i in range(0, len(coordinates)):
if i == 0:
continue
# if i==1 or i==2 or i== 20 or i==21:
# n = 4
# if i==1 or 1==21:
# height = 0.0
else:
n = 10
height = 1800.0
a2gNEM7.height = 1800
for counter in range(0, n):
counter = float(counter)/n
lon = coordinates[i-1][0] + counter * (coordinates[i][0] - coordinates[i-1][0])
lat = coordinates[i-1][1] + counter * (coordinates[i][1] - coordinates[i-1][1])
message_sdt("node node-02 position" + " " + str(lon)[0:7] + "," + str(lat)[0:7] + "")
message_sdt(b"wait 50.0")
a2gNEM7.latitude = lat
a2gNEM7.longitude = lon
# create an event setting plane position only for NEM 12 (comm is precomputed)
event = LocationEvent()
event.append(12, latitude=lat, longitude=lon, altitude=height)
service.publish(0, event)
update_a2g_pathlosses(service)
time.sleep(0.01)
time.sleep(5)
def publish_loc(n, x, y, z, session, verbose=False):
loc = LocationEvent()
lat, lon, alt = session.location.getgeo(x, y, z)
if verbose:
print 'Publishing location event: lat=%s,lon=%s,alt=%s' % (
str(lat), str(lon), str(alt))
loc.append(n, latitude=lat, longitude=lon, altitude=alt)
session.emane.service.publish(0, loc)
def publish_loc(nem, x, y, z, session, verbose=False):
loc = LocationEvent()
lat,lon,alt = session.location.getgeo(x, y, z)
rtx, rty, rtz = session.location.getxyz(lat, lon, alt)
if verbose:
session.info('Publishing location event for nem %d: (%.1f %.1f %.1f) -> (%.6f %.6f %.6f) (diff rt %d %d %d)' \
%(nem,x,y,z,lat,lon,alt, x-rtx,y-rty,z-rtz))
if int(x-rtx) > 0 or int(y-rty) > 0 or int(z - rtz) > 0: raise Exception("Error converting between coordinate systems!")
loc.append(nem, latitude=lat,longitude=lon, altitude=alt)
session.emane.service.publish(0, loc)
def setnemposition(self, netif, x, y, z):
''' Publish a NEM location change event using the EMANE event service.
'''
if self.session.emane.service is None:
if self.verbose:
self.info("position service not available")
return
nemid = self.getnemid(netif)
ifname = netif.localname
if nemid is None:
self.info("nemid for %s is unknown" % ifname)
return
(lat, long, alt) = self.session.location.getgeo(x, y, z)
if self.verbose:
self.info("setnemposition %s (%s) x,y,z=(%d,%d,%s)"
"(%.6f,%.6f,%.6f)" % \
(ifname, nemid, x, y, z, lat, long, alt))
if self.session.emane.version >= self.session.emane.EMANE091:
event = LocationEvent()
else:
event = emaneeventlocation.EventLocation(1)
# altitude must be an integer or warning is printed
# unused: yaw, pitch, roll, azimuth, elevation, velocity
alt = int(round(alt))
if self.session.emane.version >= self.session.emane.EMANE091:
event.append(nemid, latitude=lat, longitude=long, altitude=alt)
self.session.emane.service.publish(0, event)
else:
event.set(0, nemid, lat, long, alt)
self.session.emane.service.publish(
emaneeventlocation.EVENT_ID, emaneeventservice.PLATFORMID_ANY,
emaneeventservice.NEMID_ANY, emaneeventservice.COMPONENTID_ANY,
event.export())
def setnemposition(self, netif, x, y, z):
''' Publish a NEM location change event using the EMANE event service.
'''
if self.session.emane.service is None:
if self.verbose:
self.info("position service not available")
return
nemid = self.getnemid(netif)
ifname = netif.localname
if nemid is None:
self.info("nemid for %s is unknown" % ifname)
return
(lat, long, alt) = self.session.location.getgeo(x, y, z)
if self.verbose:
self.info("setnemposition %s (%s) x,y,z=(%d,%d,%s)"
"(%.6f,%.6f,%.6f)" % \
(ifname, nemid, x, y, z, lat, long, alt))
if self.session.emane.version >= self.session.emane.EMANE091:
event = LocationEvent()
else:
event = emaneeventlocation.EventLocation(1)
# altitude must be an integer or warning is printed
# unused: yaw, pitch, roll, azimuth, elevation, velocity
alt = int(round(alt))
if self.session.emane.version >= self.session.emane.EMANE091:
event.append(nemid, latitude=lat, longitude=long, altitude=alt)
self.session.emane.service.publish(0, event)
else:
event.set(0, nemid, lat, long, alt)
self.session.emane.service.publish(emaneeventlocation.EVENT_ID,
emaneeventservice.PLATFORMID_ANY,
emaneeventservice.NEMID_ANY,
emaneeventservice.COMPONENTID_ANY,
event.export())
def init_nodes(service):
#message_sdt(b"reset")
message_sdt(b"bgbounds 35.54,32.75,35.01,33.02")
message_sdt(("sprite base_station image %s size 52,25" %
(os.path.join(project_dir, 'base_station.png'))))
message_sdt(b"node node-01 type base_station label blue")
message_sdt(b"node node-01 position 35.0195,32.7625")
message_sdt(("sprite plane image %s size 52,25" %
(os.path.join(project_dir, 'plane.png'))))
message_sdt(b"node node-02 type plane label blue")
message_sdt(b"node node-02 position 35.0433,32.8119")
message_sdt(b"link node-01,node-02,wifi")
message_sdt(("sprite soldier image %s size 52,25" %
(os.path.join(project_dir, 'soldier.gif'))))
message_sdt(b"node node-03 type soldier label blue")
message_sdt(b"node node-03 position 35.088425,33.010963")
message_sdt(b"node node-06 type soldier label blue")
message_sdt(b"node node-06 position 35.147439,33.015844")
# create an event setting base station position
event = LocationEvent()
event.append(11, latitude=32.7625, longitude=35.0195, altitude=457.000000)
service.publish(0, event)
# create an event setting plane position
event = LocationEvent()
event.append(12, latitude=32.8119, longitude=35.0433, altitude=500.000000)
service.publish(0, event)
#
# # set 1 men position
# event = LocationEvent()
radioNEMs.append(NEM(1, 33.010763, 35.088425))
radioNEMs.append(NEM(2, 33.011863, 35.088425))
radioNEMs.append(NEM(3, 33.012963, 35.088425))
# # set 2 men position
# event = LocationEvent()
radioNEMs.append(NEM(4, 33.015644, 35.147439))
radioNEMs.append(NEM(5, 33.018744, 35.147439))
radioNEMs.append(NEM(6, 33.015844, 35.140439))
update_radio_pathlosses(service)
update_89_pathloss(service)
update_a2g_pathlosses(service)
def setnempositions(self, moved_netifs):
''' Several NEMs have moved, from e.g. a WaypointMobilityModel
calculation. Generate an EMANE Location Event having several
entries for each netif that has moved.
'''
if len(moved_netifs) == 0:
return
if self.session.emane.service is None:
if self.verbose:
self.info("position service not available")
return
if self.session.emane.version >= self.session.emane.EMANE091:
event = LocationEvent()
else:
event = emaneeventlocation.EventLocation(len(moved_netifs))
i = 0
for netif in moved_netifs:
nemid = self.getnemid(netif)
ifname = netif.localname
if nemid is None:
self.info("nemid for %s is unknown" % ifname)
continue
(x, y, z) = netif.node.getposition()
(lat, long, alt) = self.session.location.getgeo(x, y, z)
if self.verbose:
self.info("setnempositions %d %s (%s) x,y,z=(%d,%d,%s)"
"(%.6f,%.6f,%.6f)" % \
(i, ifname, nemid, x, y, z, lat, long, alt))
# altitude must be an integer or warning is printed
alt = int(round(alt))
if self.session.emane.version >= self.session.emane.EMANE091:
event.append(nemid, latitude=lat, longitude=long, altitude=alt)
else:
event.set(i, nemid, lat, long, alt)
i += 1
if self.session.emane.version >= self.session.emane.EMANE091:
self.session.emane.service.publish(0, event)
else:
self.session.emane.service.publish(
emaneeventlocation.EVENT_ID, emaneeventservice.PLATFORMID_ANY,
emaneeventservice.NEMID_ANY, emaneeventservice.COMPONENTID_ANY,
event.export())
def move_node(service, coordinates):
for i in range(0, len(coordinates)):
if i == 0:
continue
for counter in range(0, 2000):
counter = float(counter) / 2000
lon = coordinates[i - 1][0] + counter * (coordinates[i][0] -
coordinates[i - 1][0])
lat = coordinates[i - 1][1] + counter * (coordinates[i][1] -
coordinates[i - 1][1])
os.system(sdtcmd_path + " " + "node node-02 position" + " " +
str(lon)[0:7] + "," + str(lat)[0:7])
os.system(sdtcmd_path + " " + "wait 50.0")
# create an event setting plane position
event = LocationEvent()
event.append(12, latitude=lat, longitude=lon, altitude=500.000000)
service.publish(0, event)
event = LocationEvent()
event.append(7, latitude=lat, longitude=lon, altitude=500.000000)
service.publish(0, event)
time.sleep(0.01)
time.sleep(20)
def setnempositions(self, moved_netifs):
""" Several NEMs have moved, from e.g. a WaypointMobilityModel
calculation. Generate an EMANE Location Event having several
entries for each netif that has moved.
"""
if len(moved_netifs) == 0:
return
if self.session.emane.service is None:
if self.verbose:
self.info("position service not available")
return
if self.session.emane.version >= self.session.emane.EMANE091:
event = LocationEvent()
else:
event = emaneeventlocation.EventLocation(len(moved_netifs))
i = 0
for netif in moved_netifs:
nemid = self.getnemid(netif)
ifname = netif.localname
if nemid is None:
self.info("nemid for %s is unknown" % ifname)
continue
(x, y, z) = netif.node.getposition()
(lat, long, alt) = self.session.location.getgeo(x, y, z)
if self.verbose:
self.info(
"setnempositions %d %s (%s) x,y,z=(%d,%d,%s)"
"(%.6f,%.6f,%.6f)" % (i, ifname, nemid, x, y, z, lat, long, alt)
)
# altitude must be an integer or warning is printed
alt = int(round(alt))
if self.session.emane.version >= self.session.emane.EMANE091:
event.append(nemid, latitude=lat, longitude=long, altitude=alt)
else:
event.set(i, nemid, lat, long, alt)
i += 1
if self.session.emane.version >= self.session.emane.EMANE091:
self.session.emane.service.publish(0, event)
else:
self.session.emane.service.publish(
emaneeventlocation.EVENT_ID,
emaneeventservice.PLATFORMID_ANY,
emaneeventservice.NEMID_ANY,
emaneeventservice.COMPONENTID_ANY,
event.export(),
)
def _process_msg(self, data):
FT_TO_M = 0.3048
KT_TO_MPS = 0.51444444444
message = data.split("#")
# ex: 101#114#1#7003#-1#4656.1#-16.48614#-47.947058#210.8#9.7#353.9#TAM6543#B737#21653.3006492
msg_ver = int(message[0])
msg_typ = int(message[1])
if msg_typ != 114:
return
msg_num = int(message[2]) # node id
msg_ssr = message[3]
msg_spi = int(message[4]) # if spi > 0, SPI=ON, otherwise SPI=OFF
msg_alt = float(message[5]) # altitude (feet)
msg_lat = float(message[6]) # latitude (degrees)
msg_lon = float(message[7]) # longitude (degrees)
msg_vel = float(message[8]) # velocity (knots)
msg_cbr = float(message[9]) # climb rate (m/s)
msg_azm = float(message[10]) # azimuth (degrees)
msg_csg = message[11] # callsign
msg_per = message[12] # aircraft performance type
msg_tim = float(message[13]) # timestamp (see "hora de inicio")
if msg_num in self.track2nem:
nemid = self.track2nem[msg_num]
else:
nemid = msg_num
if nemid not in self.nems:
# Current track does not exists in the simulation
return
#
# Update node's physical parameters using Emane API
#
event = LocationEvent()
event.append(nemid,
latitude=msg_lat,
longitude=msg_lon,
altitude=msg_alt * FT_TO_M,
azimuth=msg_azm,
magnitude=msg_vel * KT_TO_MPS,
elevation=0.0)
self.service.publish(0, event)
#
# Update local variables
#
obj = {
'latitude': msg_lat,
'longitude': msg_lon,
'altitude': msg_alt * FT_TO_M,
'pitch': 0.0,
'roll': 0.0,
'yaw': 0.0,
'azimuth': msg_azm,
'elevation': 0.0,
'magnitude': msg_vel * KT_TO_MPS,
}
self.tracks[nemid] = obj
#
# Update transponder's parameters using database shared memory
#
try:
cursor = self.db_process.cursor()
cursor.execute(
"SELECT callsign, performance_type, ssr_squawk FROM transponder WHERE nem_id=%d"
% nemid)
result = cursor.fetchone()
if result is None:
return
db_callsign = result[0]
db_perftype = result[1]
db_squawk = result[2]
if db_callsign[
0] != msg_csg or db_perftype != msg_per or db_squawk != msg_ssr:
sql = "UPDATE transponder SET callsign='%s', performance_type='%s', ssr_squawk='%s' " \
"WHERE nem_id=%d" % (msg_csg, msg_per, msg_ssr, nemid)
cursor.execute(sql)
self.db_process.commit()
cursor.close()
except MySQLdb.Error, e:
logging.warn("listen(): MySQL Error [%d]: %s" %
(e.args[0], e.args[1]))
def handleLocation(nemId, eventId, data, uuid, sequence):
e = LocationEvent()
e.restore(data)
header(nemId, eventId, data, 'Location', uuid, sequence)
for i in e:
print " ", i
def main():
global conf_file
global node_conf_file
global ENABLE_TIMEKEEPER
global max_tdf
global topo_size
os.system("sudo chmod -R 777 /tmp")
os.system("sudo rm -rf /tmp/emane")
if is_root() == 0:
print "Must be run as root"
sys.exit(-1)
arg_list = sys.argv
if len(arg_list) == 1:
conf_file = cwd + "/conf/emane.conf"
node_conf_file = cwd + "/conf/node.conf"
else:
i = 1
while i < len(arg_list):
if arg_list[i] == "-D":
ENABLE_TIMEKEEPER = 0
else:
ENABLE_TIMEKEEPER = 1
conf_files_dir = arg_list[1]
if os.path.isdir(conf_files_dir) == True:
conf_file = conf_files_dir + "/emane.conf"
node_conf_file = conf_files_dir + "/node.conf"
if os.path.exists(conf_file) == False or os.path.exists(
node_conf_file) == False:
print "Config files do not exist"
sys.exit(-1)
else:
print "Config directory specified is incorrect"
sys.exit(-1)
i = i + 1
Node, run_time, n_nodes, eventmanagergroup, timeslice = configure()
topo_size = n_nodes
# create experiment-data directory
with open(cwd + "/experiment-data/exp-info.txt", "w") as f:
f.write("Conf file path : " + conf_file + "\n")
f.write("Node Conf file : " + node_conf_file + "\n")
f.write("Run time : " + str(run_time) + "\n")
f.write("N_nodes : " + str(n_nodes) + "\n")
# copy node_config file and emane_conf file
os.system("mkdir -p " + cwd + "/experiment-data")
start_LXCs()
print "Timeslice = ", timeslice
print "Setting initial location values to all lxcs ..."
nemid = 1
temp_list = eventmanagergroup.split(":")
eventmanagergroupaddress = temp_list[0]
eventmanagergroupport = int(temp_list[1])
service = EventService(
(eventmanagergroupaddress, eventmanagergroupport, 'br0'))
event = LocationEvent()
i = 1
while i <= n_nodes:
pathlossevt = PathlossEvent()
j = 1
while j <= n_nodes:
if i != j:
pathlossevt.append(j, forward=90, reverse=90)
j = j + 1
i = i + 1
while nemid <= n_nodes:
event.append(nemid,
latitude=Node[nemid]["lattitude"],
longitude=Node[nemid]["longitude"],
altitude=Node[nemid]["altitude"])
nemid = nemid + 1
service.publish(0, event)
time.sleep(2)
print "Location events published. All nodes set to initial positions. Waiting for 30 sec for routing updates to stabilize"
time.sleep(50)
# Timekeeper portion
freeze_quantum = 1000000 # in nano seconds
nemid = 1
while nemid <= n_nodes:
pid = int(getpidfromname("node-" + str(nemid)))
print "PID of node ", nemid, " = ", pid, " TDF = ", Node[nemid]["tdf"]
if pid != -1 and ENABLE_TIMEKEEPER == 1:
dilate_all(pid, Node[nemid]["tdf"])
addToExp(pid)
if max_tdf < Node[nemid]["tdf"]:
max_tdf = Node[nemid]["tdf"]
nemid += 1
lxc_pid = int(getpidfromname("node-1"))
if os.path.exists(cwd + "/exp_finished.txt"):
os.unlink(cwd + "/exp_finished.txt")
# send commands to execute to each LXC
nemid = 1
while nemid <= n_nodes:
if nemid % 2 == 0:
process = subprocess.Popen([
"python", "lxc_command_dispatcher.py",
str(0),
str(nemid), Node[nemid]["cmd"]
])
else:
process = subprocess.Popen([
"python", "lxc_command_dispatcher.py",
str(1),
str(nemid), Node[nemid]["cmd"]
])
nemid += 1
print "Set freeze_quantum = ", freeze_quantum * max_tdf
if ENABLE_TIMEKEEPER == 1 and max_tdf >= 1:
set_cpu_affinity(int(os.getpid()))
set_cbe_experiment_timeslice(freeze_quantum * max_tdf)
print "Timekeeper synchronizing ..."
synchronizeAndFreeze()
startExp()
print "Synchronized CBE experiment started ..."
start_time = int(get_current_virtual_time_pid(int(lxc_pid)))
prev_time = start_time
print "Experiment start time", start_time, " local Time = " + str(
datetime.now())
sys.stdout.flush()
else:
print "Experiment Started with TimeKeeper disabled - Ignoring TDF settings"
try:
k = 0
while True:
if ENABLE_TIMEKEEPER == 1:
curr_time = int(get_current_virtual_time_pid(int(lxc_pid)))
if curr_time - start_time >= run_time:
break
else:
if curr_time - prev_time >= 1:
k = k + (curr_time - prev_time)
print k, " secs of virtual time elapsed"
prev_time = curr_time
else:
if k >= run_time:
break
k = k + 1
print k, " secs of real time elapsed"
# sleep until runtime expires
time.sleep(1)
except KeyboardInterrupt:
pass
# stop Exp
print "Stopping Synchronized experiment, local time = " + str(
datetime.now())
if ENABLE_TIMEKEEPER == 1:
stopExp()
time.sleep(10)
stop_LXCs(max_tdf)
def handleLocation(nemId,eventId,data,uuid,sequence):
e = LocationEvent()
e.restore(data)
header(nemId,eventId,data,'Location',uuid,sequence)
for i in e:
print " ",i
def init_nodes(service):
# os.system(sdtcmd_path + " " + "reset")
os.system(sdtcmd_path + " " +
"sprite base_station image base_station.png size 52,25")
os.system(sdtcmd_path + " " + "node node-01 type base_station label blue")
os.system(sdtcmd_path + " " + "node node-01 position 35.0195,32.7625")
os.system(sdtcmd_path + " " + "sprite plane image plane.png size 52,25")
os.system(sdtcmd_path + " " + "node node-02 type plane label blue")
os.system(sdtcmd_path + " " + "node node-02 position 35.0433,32.8119")
os.system(sdtcmd_path + " " + "link node-01,node-02,wifi")
os.system(sdtcmd_path + " " +
"sprite soldier image soldier.gif size 52,25")
os.system(sdtcmd_path + " " + "node node-03 type soldier label blue")
os.system(sdtcmd_path + " " + "node node-03 position 35.088425,33.010963")
os.system(sdtcmd_path + " " + "node node-06 type soldier label blue")
os.system(sdtcmd_path + " " + "node node-06 position 35.147439,33.015844")
# create an event setting base station position
event = LocationEvent()
event.append(11, latitude=32.7625, longitude=35.0195, altitude=457.000000)
service.publish(0, event)
# create an event setting plane position
event = LocationEvent()
event.append(12, latitude=32.8119, longitude=35.0433, altitude=500.000000)
service.publish(0, event)
event = LocationEvent()
event.append(7, latitude=32.8119, longitude=35.0433, altitude=500.000000)
service.publish(0, event)
# set 1 men position
event = LocationEvent()
event.append(1, latitude=33.010763, longitude=35.088425, altitude=8.00000)
service.publish(0, event)
event = LocationEvent()
event.append(2, latitude=33.010863, longitude=35.088425, altitude=8.00000)
service.publish(0, event)
event = LocationEvent()
event.append(3, latitude=33.010963, longitude=35.088425, altitude=8.00000)
service.publish(0, event)
event = LocationEvent()
event.append(8, latitude=33.010963, longitude=35.088425, altitude=8.00000)
service.publish(0, event)
# set 2 men position
event = LocationEvent()
event.append(4, latitude=33.015644, longitude=35.147439, altitude=8.00000)
service.publish(0, event)
event = LocationEvent()
event.append(5, latitude=33.015744, longitude=35.147439, altitude=8.00000)
service.publish(0, event)
event = LocationEvent()
event.append(6, latitude=33.015844, longitude=35.147439, altitude=8.00000)
service.publish(0, event)
event = LocationEvent()
event.append(9, latitude=33.015844, longitude=35.147439, altitude=8.00000)
service.publish(0, event)
time.sleep(20)
#!/usr/bin/env python
from emanesh.events import EventService
from emanesh.events import LocationEvent
# create the event service
service = EventService(('224.1.2.8',45703,'emanenode0'))
# create an event setting 10's position
event = LocationEvent()
event.append(10,latitude=40.031290,longitude=-74.523095,altitude=3.000000)
# publish the event
service.publish(0,event)
def init_nodes(service):
#send schedule
os.system("emaneevent-tdmaschedule /home/ubuntu/Desktop/emane-tutorial/23aliakim/schedule.xml -i emanenode0")
#message_sdt(b"reset")
message_sdt(b"")
message_sdt(b"bgbounds 34.54,31.15,34.8,31.26")
message_sdt(("sprite base_station image %s size 52,25" % (os.path.join(project_dir,'base_station.png'))))
message_sdt(b"node node-01 type base_station label blue")
message_sdt(b"node node-01 position 34.7572,31.2414")
message_sdt(("sprite plane image %s size 52,25" % (os.path.join(project_dir,'plane.png'))))
message_sdt(b"node node-02 type plane label blue")
#cmdString = "b\"node node-02 position " + str(LOCATION_AIRPORT_LON) + "," + str(LOCATION_AIRPORT_LAT) + "\""
message_sdt(b"node node-02 position 34.6784,31.2256")
message_sdt(b"link node-01,node-02,wifi")
message_sdt(("sprite soldier image %s size 52,25" % (os.path.join(project_dir,'soldier.gif'))))
message_sdt(b"node node-07 type soldier label blue")
#cmdString = "b\"node node-07 position " + str(LOCATION_SOLDIER_1_LON) + "," + str(LOCATION_SOLDIER_1_LAT) + "\""
message_sdt(b"node node-07 position 34.5285,31.1643")
message_sdt(b"node node-08 type soldier label blue")
#cmdString = "b\"node node-08 position " + str(LOCATION_SOLDIER_2_LON) + "," + str(LOCATION_SOLDIER_2_LAT) + "\""
message_sdt(b"node node-08 position 34.5324,31.1643")
message_sdt(b"node node-03 type soldier label blue")
#cmdString = "b\"node node-03 position " + str(LOCATION_SOLDIER_3_LON) + "," + str(LOCATION_SOLDIER_3_LAT) + "\""
message_sdt(b"node node-03 position 34.5320,31.1639")
message_sdt(b"node node-04 type soldier label blue")
#cmdString = "b\"node node-04 position " + str(LOCATION_SOLDIER_4_LON) + "," + str(LOCATION_SOLDIER_4_LAT) + "\""
message_sdt(b"node node-04 position 34.5313,31.1630")
message_sdt(b"node node-05 type soldier label blue")
#cmdString = "b\"node node-05 position " + str(LOCATION_SOLDIER_5_LON) + "," + str(LOCATION_SOLDIER_5_LAT) + "\""
message_sdt(b"node node-05 position 34.5334,31.1633")
message_sdt(b"node node-06 type soldier label blue")
#cmdString = "b\"node node-06 position " + str(LOCATION_SOLDIER_6_LON) + "," + str(LOCATION_SOLDIER_6_LAT) + "\""
message_sdt(b"node node-06 position 34.5338,31.1630")
# create an event setting base station position
event = LocationEvent()
event.append(11, latitude=31.2414, longitude=34.7572, altitude=15.000000)
service.publish(0, event)
# create an event setting plane position
event = LocationEvent()
event.append(12, latitude=LOCATION_PLANE_GROUND_LAT, longitude=LOCATION_PLANE_GROUND_LON, altitude=0.000000)
service.publish(0, event)
#
# # set 1 men position
# event = LocationEvent()
radioNEMs.append(NEM(1, LOCATION_SOLDIER_1_LAT, LOCATION_SOLDIER_1_LON, 1.5))
radioNEMs.append(NEM(2, LOCATION_SOLDIER_2_LAT, LOCATION_SOLDIER_2_LON, 1.5))
radioNEMs.append(NEM(3, LOCATION_SOLDIER_3_LAT, LOCATION_SOLDIER_3_LON, 1.5))
# # set 2 men position
# event = LocationEvent()
radioNEMs.append(NEM(4, LOCATION_SOLDIER_4_LAT, LOCATION_SOLDIER_4_LON, 1.5))
radioNEMs.append(NEM(5, LOCATION_SOLDIER_5_LAT, LOCATION_SOLDIER_5_LON, 1.5))
radioNEMs.append(NEM(6, LOCATION_SOLDIER_6_LAT, LOCATION_SOLDIER_6_LON, 1.5))
update_radio_pathlosses(service)
update_8_9_13_14_15_16_pathloss(service)
update_a2g_pathlosses(service)
parameters['frequencyHz'] = 2347000000
parameters['bandwidthHz'] = 20e6
parameters['systemnoisefloordB'] = 4
parameters['txpowerdB'] = 0
parameters['txgaindB'] = 0
parameters['rxgaindB'] = 0
# create an event setting 10's position
n = 3
distances = np.zeros(n)
rates = np.zeros(n)
dlat_array = 10**-5 * np.linspace(300, 800, n)
for i in range(n):
dlat = dlat_array[i]
event = LocationEvent()
event.append(1, latitude=lator, longitude=lonor, altitude=3.000000)
event.append(2,
latitude=lator + dlat,
longitude=lonor,
altitude=3.000000)
distances[i] = distance(lator, lonor, lator + dlat, lonor)
parameters['distanceM'] = distances[i]
time.sleep(2)
print "-------------------------------------"
print "Distance: ", distances[i]
service.publish(0, event)
cpc = ControlPortClient('node-1', 47000)
cpc.clearStatistic(3, '')
cpc.clearStatistic(2, '')
