def setpathloss(self, numnodes): """ Send EMANE pathloss events to connect all NEMs in a chain. """ if self.session.emane.version < self.session.emane.EMANE091: service = emaneeventservice.EventService() e = emaneeventpathloss.EventPathloss(1) old = True else: if self.session.emane.version == self.session.emane.EMANE091: dev = "lo" else: dev = self.session.obj("ctrlnet").brname service = EventService(eventchannel=("224.1.2.8", 45703, dev), otachannel=None) old = False for i in range(1, numnodes + 1): rxnem = i # inform rxnem that it can hear node to the left with 10dB noise txnem = rxnem - 1 if txnem > 0: if old: e.set(0, txnem, 10.0, 10.0) service.publish(emaneeventpathloss.EVENT_ID, emaneeventservice.PLATFORMID_ANY, rxnem, emaneeventservice.COMPONENTID_ANY, e.export()) else: e = PathlossEvent() e.append(txnem, forward=10.0, reverse=10.0) service.publish(rxnem, e) # inform rxnem that it can hear node to the right with 10dB noise txnem = rxnem + 1 if txnem > numnodes: continue if old: e.set(0, txnem, 10.0, 10.0) service.publish(emaneeventpathloss.EVENT_ID, emaneeventservice.PLATFORMID_ANY, rxnem, emaneeventservice.COMPONENTID_ANY, e.export()) else: e = PathlossEvent() e.append(txnem, forward=10.0, reverse=10.0) service.publish(rxnem, e)
def setpathloss(self, numnodes): """ Send EMANE pathloss events to connect all NEMs in a chain. """ if self.session.emane.version < self.session.emane.EMANE091: service = emaneeventservice.EventService() e = emaneeventpathloss.EventPathloss(1) old = True else: if self.session.emane.version == self.session.emane.EMANE091: dev = "lo" else: dev = self.session.obj("ctrlnet").brname service = EventService(eventchannel=("224.1.2.8", 45703, dev), otachannel=None) old = False for i in xrange(1, numnodes + 1): rxnem = i # inform rxnem that it can hear node to the left with 10dB noise txnem = rxnem - 1 if txnem > 0: if old: e.set(0, txnem, 10.0, 10.0) service.publish(emaneeventpathloss.EVENT_ID, emaneeventservice.PLATFORMID_ANY, rxnem, emaneeventservice.COMPONENTID_ANY, e.export()) else: e = PathlossEvent() e.append(txnem, forward=10.0, reverse=10.0) service.publish(rxnem, e) # inform rxnem that it can hear node to the right with 10dB noise txnem = rxnem + 1 if txnem > numnodes: continue if old: e.set(0, txnem, 10.0, 10.0) service.publish(emaneeventpathloss.EVENT_ID, emaneeventservice.PLATFORMID_ANY, rxnem, emaneeventservice.COMPONENTID_ANY, e.export()) else: e = PathlossEvent() e.append(txnem, forward=10.0, reverse=10.0) service.publish(rxnem, e)
#!/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)
#!/usr/bin/env python from emanesh.events import EventService from emanesh.events import PathlossEvent # # create the event service service = EventService(('224.1.2.8', 45703, 'emanenode0')) # # create an event setting the pathloss between 1 & 10 event = PathlossEvent() event.append(9, forward=900) event.append(7, forward=900) # # publish the event service.publish(9, event) service.publish(7, event) # # create an event setting the pathloss between 9 & 10 event = PathlossEvent() event.append(9, forward=90) event.append(10, forward=90) # # publish the event service.publish(9, event) service.publish(10, event)
pathlossdB = args[1] try: pathlossdB = float(pathlossdB) except: print >>sys.stderr,"invalid pathloss format:",args[1] exit(1) if nems[0] == 0: print >>sys.stderr,"0 is not a valid NEMID" exit(1) if options.target: targets = options.target else: targets = nems if options.reference: references = options.reference else: references = nems for i in targets: event = PathlossEvent() for j in nems: if i != j and j in references: event.append(j,forward=pathlossdB) service.publish(i,event)
exit(1) else: print >> sys.stderr, "invalid location component:", param exit(1) if nems[0] == 0: print >> sys.stderr, "0 is not a valid NEMID" exit(1) if options.target: targets = options.target else: targets = [0] if options.reference: references = options.reference else: references = nems for i in targets: event = LocationEvent() for j in nems: if j in references: try: event.append(j, **kwargs) except Exception, exp: print >> sys.stderr, "error:", exp exit(1) service.publish(i, event)
class TrackServer: """Read ptracks data through a multicast address and update the position of aircraft nodes on a MySQL database. """ update_interval = 1.0 log_file = "track_server.log" log_level = logging.DEBUG net_tracks = "235.12.2.4" net_iface = "ctrl0" db_name = 'atn_sim' db_user = '******' db_pass = '******' db_host = '172.17.255.254' tracks = {} def __init__(self, config="track_server.cfg"): # Logging logging.basicConfig(filename=self.log_file, level=self.log_level, filemode='w', format='%(asctime)s %(levelname)s: %(message)s') self.logger = logging.getLogger("trackserver") # Configuration file self.config = None if os.path.exists(config): self.config = ConfigParser.ConfigParser() self.config.read(config) if self.config.has_option("Database", "db_user"): self.db_user = self.config.get("Database", "db_user") if self.config.has_option("Database", "db_pass"): self.db_pass = self.config.get("Database", "db_pass") if self.config.has_option("Database", "db_host"): self.db_host = self.config.get("Database", "db_host") if self.config.has_option("Database", "db_name"): self.db_name = self.config.get("Database", "db_name") # DB connection with general purposes self.db = MySQLdb.connect(self.db_host, self.db_user, self.db_pass, self.db_name) # DB connection specific for thread _process_msg() self.db_process = MySQLdb.connect(self.db_host, self.db_user, self.db_pass, self.db_name) # DB connection specific for thread _update() self.db_update = MySQLdb.connect(self.db_host, self.db_user, self.db_pass, self.db_name) # Emane service self.service = EventService(('224.1.2.8', 45703, self.net_iface)) # Queue of unprocessed messages from track generator self.msg_queue = deque([]) # List of NEMs available in the simulation self.nems = [] def start(self): self.logger.info("Initiating server") self._init_nodes_table() self._init_nems_table() self._init_mapings() # t1 = threading.Thread(target=self._update_from_emane, args=()) t1 = threading.Thread(target=self._update_from_tracks, args=()) t2 = threading.Thread(target=self.listen, args=()) t3 = threading.Thread(target=self._process_queue, args=()) t1.start() t2.start() t3.start() self.db.close() def stop(self): pass def listen(self): # Retrieving list of nodes nodes = emane_utils.get_all_locations() for n in nodes: self.nems.append(n["nem"]) if len(nodes) == 0: self.logger.error("Cannot read nodes' positions from Emane") # IP address of incoming messages ip = ni.ifaddresses(self.net_iface)[2][0]['addr'] sock = mcast_socket.McastSocket(local_port=1970, reuse=True) sock.mcast_add(self.net_tracks, ip) self.logger.info("Waiting for track messages on %s:%d" % (self.net_tracks, 1970)) while True: data, sender_addr = sock.recvfrom(1024) # Inserting received messages in the queue self.msg_queue.append(data) def _process_queue(self): while True: if len(self.msg_queue) == 0: time.sleep(0.5) continue else: self._process_msg(self.msg_queue.popleft()) 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]))
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, '') ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect('node-1', username='******', password='******') stdin, stdout, stderr = ssh.exec_command("ping -c 400 -i 0.2 radio-2") ping_output = stdout.readlines() ssh.close() #time.sleep(5) stat = cpc.getStatistic(3, '') numUpstreamPacketsBroadcastDrop0 = stat[ 'numUpstreamPacketsBroadcastDrop0'][0]
if os.path.isfile(args[0]): schedule = TDMASchedule(args[0]) else: print >>sys.stderr, "unable to open:",args[0] exit(1) else: print >>sys.stderr, "invalid number of arguments" exit(1) eventService = EventService((options.group,options.port,options.device)) info = schedule.info() structure = schedule.structure() frameDefaults = schedule.defaultsFrame(); for nodeId in info: event = TDMAScheduleEvent(**schedule.defaults()) for frameIndex in info[nodeId]: for slotIndex,args in info[nodeId][frameIndex].items(): defaults = args for key,value in frameDefaults[frameIndex].items(): defaults["frame." + key] = value event.append(frameIndex,slotIndex,**defaults) if structure != None: event.structure(**structure) eventService.publish(nodeId,event)
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)
if os.path.isfile(args[0]): schedule = TDMASchedule(args[0]) else: print >> sys.stderr, "unable to open:", args[0] exit(1) else: print >> sys.stderr, "invalid number of arguments" exit(1) eventService = EventService((options.group, options.port, options.device)) info = schedule.info() structure = schedule.structure() frameDefaults = schedule.defaultsFrame() for nodeId in info: event = TDMAScheduleEvent(**schedule.defaults()) for frameIndex in info[nodeId]: for slotIndex, args in info[nodeId][frameIndex].items(): defaults = args for key, value in frameDefaults[frameIndex].items(): defaults["frame." + key] = value event.append(frameIndex, slotIndex, **defaults) if structure != None: event.structure(**structure) eventService.publish(nodeId, event)
#!/usr/bin/env python from emanesh.events import EventService from emanesh.events import PathlossEvent # create the event service service = EventService(('224.1.2.8',45703,'emanenode0')) # create an event setting the pathloss between 1 & 10 event = PathlossEvent() event.append(1,forward=90) event.append(10,forward=90) # publish the event service.publish(1,event) service.publish(10,event) # create an event setting the pathloss between 9 & 10 event = PathlossEvent() event.append(9,forward=90) event.append(10,forward=90) # publish the event service.publish(9,event) service.publish(10,event)