Merge origin/master

CourseExamples/src/DisExamples/PduReceiver.java

@@ -17,8 +17,8 @@ public class PduReceiver
     public static void main(String args[])
     {
         PduFactory      factory;
-        MulticastSocket socket = null;
-        InetAddress     address = null;
+        MulticastSocket socket;
+        InetAddress     address;
 		DatagramPacket  packet;
 		
         try

deliverables/src/MV3500Cohort2018JanuaryMarch/FinalProjects/Hanley/HanleyOpenDisEspduSenderFP.java

@@ -44,6 +44,7 @@ public class HanleyOpenDisEspduSenderFP
      *                If in multicast mode, a join() will be done on the multicast address.
      * port: port used for both source and destination.
      * @param args 
+     * @throws FileNotFoundException if csv file not found 
      */
 public static void main(String args[]) throws FileNotFoundException
 {
@@ -51,15 +52,15 @@ public static void main(String args[]) throws FileNotFoundException
     EntityStatePdu espdu = new EntityStatePdu();
     MulticastSocket socket = null; // must be initialized, even if null
     DisTime disTime = DisTime.getInstance(); // TODO explain
-    int alternator = -1;
+//  int alternator = -1;
     
     // ICBM coordinates for my office
-    double lat =   36.595517; 
-    double lon = -121.877000;
+    double lat; // =   36.595517; 
+    double lon; // = -121.877000;
     
     // Default settings. These are used if no system properties are set. 
     // If system properties are passed in, these are over ridden.
-    int port = DIS_DESTINATION_PORT;
+    int         port = DIS_DESTINATION_PORT;
     NetworkMode mode = NetworkMode.BROADCAST;
     InetAddress destinationIp = null; // must be initialized, even if null
     
@@ -157,9 +158,9 @@ public static void main(String args[]) throws FileNotFoundException
     Set<InetAddress> broadcastAddresses;
     // Loop through sending .csv  entities
     String fileName = "Entities.csv";
-    File inputFile  = new File(System.getProperty("user.dir") + File.separator +  //     netbeans project directory
-						 "src/MV3500Cohort2018JanuaryMarch/FinalProjects/Hanley/" // deliverables project subdirectory
-						 + fileName);
+    File inputFile  = new File(System.getProperty("user.dir") + File.separator +    //     netbeans project directory
+						 "src/MV3500Cohort2018JanuaryMarch/FinalProjects/Hanley/" + // deliverables project subdirectory
+						 fileName);
 		Scanner scanner;
 		try {
 			for (int idx = 0; idx < 10; idx++)
@@ -172,13 +173,15 @@ public static void main(String args[]) throws FileNotFoundException
 				scanner.nextLine();
 
 				//this section reads through the .csv and parses it to send out as an espdu.
-				while (scanner.hasNextLine()) {
+				while (scanner.hasNextLine())
+				{
 					String line = scanner.nextLine();
 					//System.out.println(line);
 					String[] splits;
 					splits = line.split(",");
-					if (splits[0].startsWith("#")) {
-						continue;
+					if (splits[0].startsWith("#"))
+					{
+						continue; // skip comment line (for example, table header)
 					}
 					//this section parse each line into the component necessary to build a DIS ESPDU;
 					int kind = Integer.parseInt(splits[3]);
@@ -286,9 +289,10 @@ public static void main(String args[]) throws FileNotFoundException
 					byte[] data = baos.toByteArray();
 
 					broadcastAddresses = getBroadcastAddresses();
-					Iterator it = broadcastAddresses.iterator();
-					while (it.hasNext()) {
-						InetAddress broadcast = (InetAddress) it.next();
+					Iterator iterator = broadcastAddresses.iterator();
+					while (iterator.hasNext())
+					{
+						InetAddress broadcast = (InetAddress) iterator.next();
 						//System.out.println("Sending broadcast datagram packet to " + broadcast);
 						DatagramPacket packet = new DatagramPacket(data, data.length, broadcast, 3000);
 						socket.send(packet);
@@ -308,7 +312,6 @@ public static void main(String args[]) throws FileNotFoundException
 					}
 
 				}
-				//////
 				// Send every 1 sec. Otherwise this will be all over in a fraction of a second.
 				System.out.println("Iteration " + idx);
 				System.out.println("Sleep Time");
@@ -332,33 +335,39 @@ public static void main(String args[]) throws FileNotFoundException
 	 *
 	 * @return set of all broadcast addresses
 	 */
-	public static Set<InetAddress> getBroadcastAddresses() {
+	public static Set<InetAddress> getBroadcastAddresses()
+	{
 		Set<InetAddress> broadcastAddresses = new HashSet<>();
 		Enumeration interfaces;
 
 		try {
 			interfaces = NetworkInterface.getNetworkInterfaces();
 
-			while (interfaces.hasMoreElements()) {
+			while (interfaces.hasMoreElements())
+			{
 				NetworkInterface anInterface = (NetworkInterface) interfaces.nextElement();
 
-				if (anInterface.isUp()) {
-					Iterator it = anInterface.getInterfaceAddresses().iterator();
-					while (it.hasNext()) {
-						InterfaceAddress anAddress = (InterfaceAddress) it.next();
-						if ((anAddress == null || anAddress.getAddress().isLinkLocalAddress())) {
+				if (anInterface.isUp())
+				{
+					Iterator iterator = anInterface.getInterfaceAddresses().iterator();
+					while (iterator.hasNext())
+					{
+						InterfaceAddress anAddress = (InterfaceAddress) iterator.next();
+						if ((anAddress == null || anAddress.getAddress().isLinkLocalAddress()))
+						{
 							continue;
 						}
-
 						//System.out.println("Getting broadcast address for " + anAddress);
 						InetAddress broadcastAddress = anAddress.getBroadcast();
-						if (broadcastAddress != null) {
+						if (broadcastAddress != null)
+						{
 							broadcastAddresses.add(broadcastAddress);
 						}
 					}
 				}
 			}
-		} catch (SocketException e) {
+		} catch (SocketException e)
+		{
 			e.printStackTrace();
 			System.out.println(e);
 		}

deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FDCSendRecieve.java

+package MV3500Cohort2018JulySeptember.FinalProject.FriscoFurrProject;
+
+import java.net.*;
+import java.io.*;
+import java.util.*;
+import edu.nps.moves.dis.*;
+import java.io.IOException;
+import edu.nps.moves.disenum.*;
+import edu.nps.moves.disutil.PduFactory;
+
+public class FDCSendRecieve {
+
+	/**
+	 * Default multicast group address we send on.
+	 */
+	public static final String DEFAULT_MULTICAST_ADDRESS = "239.1.2.3";
+
+	/**
+	 * Default multicast port used, matches Wireshark DIS capture default
+	 */
+	public static final int DEFAULT_MULTICAST_PORT = 3000;
+
+	private int port;
+	InetAddress multicastAddress;
+
+	public static final int MULTICAST_PORT = 3000;
+	public static final String MULTICAST_GROUP = "239.1.2.3";
+	public static final boolean USE_FAST_ESPDU = false;
+
+	public FDCSendRecieve(int port, String multicast) {
+		try {
+			this.port = port;
+			multicastAddress = InetAddress.getByName(multicast);
+			if (!multicastAddress.isMulticastAddress()) {
+				System.out.println("Not a multicast address: " + multicast);
+			}
+		} catch (UnknownHostException e) {
+			System.out.println("Unable to open socket: " + e);
+		}
+	}
+
+	public void run(Pdu pdu) {
+		System.out.println("DisExamples.PduSender started...");
+					short currentPduType = pdu.getPduType();
+					String currentPduTypeName = pdu.getClass().getName();
+					short currentProtocolFamilyID = pdu.getProtocolFamily();
+					String currentPduFamilyName = pdu.getClass().getSuperclass().getSimpleName();
+
+		try {
+			List<Pdu> generatedPdus = new ArrayList<>();
+
+			// Loop through all the enumerated PDU types, create a PDU for each type,
+			// and add that PDU to a list.
+			for (PduType pdu2 : PduType.values()) {
+				Pdu aPdu = null;
+				System.out.println(pdu);
+				
+				//Change the switch statement to the currentPduType from the recieve portion, then when a packet we want comes in, send the CASE file. 
+				
+				switch (pdu2) // using enumeration values from edu.nps.moves.disenum.*
+				{
+
+					case ENTITY_STATE:
+						System.out.println("Case: Enitity_State " + pdu + "\n");
+						aPdu = new EntityStatePdu();
+						EntityStatePdu espdu = (EntityStatePdu) aPdu;
+						Marking marking = new Marking();
+						marking.setCharactersString("PduSender");
+						espdu.setMarking(marking);
+						Vector3Double espduLocation = new Vector3Double();
+						espduLocation.setX(1.0);
+						espduLocation.setY(2.0);
+						espduLocation.setZ(3.0);
+						break;
+
+					case COMMENT:
+						aPdu = new CommentPdu();
+						break;
+
+					case FIRE:
+						aPdu = new FirePdu();
+						break;
+
+					case DETONATION:
+						aPdu = new DetonationPdu();
+						break;
+
+					case COLLISION:
+						aPdu = new CollisionPdu();
+						break;
+
+					case SERVICE_REQUEST:
+						aPdu = new ServiceRequestPdu();
+						break;
+
+					case RESUPPLY_OFFER:
+						aPdu = new ResupplyOfferPdu();
+						break;
+
+					case RESUPPLY_RECEIVED:
+						aPdu = new ResupplyReceivedPdu();
+						break;
+
+					case RESUPPLY_CANCEL:
+						aPdu = new ResupplyCancelPdu();
+						break;
+
+					case REPAIR_COMPLETE:
+						aPdu = new RepairCompletePdu();
+						break;
+
+					case REPAIR_RESPONSE:
+						aPdu = new RepairResponsePdu();
+						break;
+
+					case CREATE_ENTITY:
+						aPdu = new CreateEntityPdu();
+						break;
+
+					case REMOVE_ENTITY:
+						aPdu = new RemoveEntityPdu();
+						break;
+
+					case START_RESUME:
+						aPdu = new StartResumePdu();
+						break;
+
+					case STOP_FREEZE:
+						aPdu = new StopFreezePdu();
+						break;
+
+					case ACKNOWLEDGE:
+						aPdu = new AcknowledgePdu();
+						break;
+
+					case ACTION_REQUEST:
+						aPdu = new ActionRequestPdu();
+						break;
+
+					default:
+						System.out.print("PDU of type " + pdu + " not supported, created or sent ");
+						System.out.println();
+				}
+				if (aPdu != null) {
+					generatedPdus.add(aPdu);
+					System.out.println("APDU container count " + generatedPdus.size());
+				}
+			}
+
+
+
+			// Send the PDUs we created
+			InetAddress localMulticastAddress = InetAddress.getByName(DEFAULT_MULTICAST_ADDRESS);
+			MulticastSocket socket = new MulticastSocket(DEFAULT_MULTICAST_PORT);
+			socket.joinGroup(localMulticastAddress);
+
+			for (int idx = 0; idx < generatedPdus.size(); idx++) {
+				ByteArrayOutputStream baos = new ByteArrayOutputStream();
+				DataOutputStream dos = new DataOutputStream(baos);
+				byte[] buffer;
+
+				Pdu aPdu = generatedPdus.get(idx);
+				aPdu.marshal(dos);
+
+				buffer = baos.toByteArray();
+				DatagramPacket packet = new DatagramPacket(buffer, buffer.length, localMulticastAddress, DEFAULT_MULTICAST_PORT);
+				socket.send(packet);
+				System.out.println("Sent PDU of type " + aPdu.getClass().getName());
+			}
+		} catch (IOException e) {
+			System.out.println(e);
+		}
+	}
+
+	public static void main(String[] args) {
+		
+		//turns on the sender code - might need to move around down into the recieve with the if statements...
+        if (args.length == 2) {
+            FDCSendRecieve sender = new FDCSendRecieve(Integer.parseInt(args[0]), args[1]);
+          //  sender.run();  //needs to be sender.run(pdu) 
+        } else {
+            System.out.println("Usage:   PduSender <port> <multicast group>");
+            System.out.println("Default: PduSender  " + DEFAULT_MULTICAST_PORT + "   " + DEFAULT_MULTICAST_ADDRESS);
+            FDCSendRecieve sender = new  FDCSendRecieve(DEFAULT_MULTICAST_PORT, DEFAULT_MULTICAST_ADDRESS);
+        //    sender.run();
+        }
+    
+		
+		
+		/*  BELOW IS THE RECIEVE CODE  //
+		//                             //
+		//                             //
+		 */                             //
+		PduFactory factory;
+		MulticastSocket socket = null;
+		InetAddress address = null;
+		DatagramPacket packet;
+		short currentPduType;  //will use the curentPduType as the check for sending other packets.
+
+		
+		try {
+			FDCSendRecieve sender = new  FDCSendRecieve(DEFAULT_MULTICAST_PORT, DEFAULT_MULTICAST_ADDRESS);
+			System.out.println("DisExamples.PduReceiver started...");
+			socket = new MulticastSocket(MULTICAST_PORT);
+			address = InetAddress.getByName(MULTICAST_GROUP);
+			socket.joinGroup(address);
+
+			factory = new PduFactory();
+
+			while (true) // Loop infinitely, receiving datagrams
+			{
+				byte buffer[] = new byte[1500]; // typical MTU size
+
+				packet = new DatagramPacket(buffer, buffer.length); // reset
+
+				socket.receive(packet);
+
+				Pdu pdu = factory.createPdu(packet.getData());
+				if (pdu != null) {
+					currentPduType = pdu.getPduType();
+					// if statement might need to go here fix thread shit... 
+					
+//					if(currentPduType == 5 ||currentPduType == 4 )
+//					 {Thread thread;
+//						thread = new Thread(sender.run(pdu));
+//					  thread.start();
+//					 }
+					sender.run(pdu);
+					
+					String currentPduTypeName = pdu.getClass().getName();
+					short currentProtocolFamilyID = pdu.getProtocolFamily();
+					String currentPduFamilyName = pdu.getClass().getSuperclass().getSimpleName();
+
+					StringBuilder message = new StringBuilder();
+					message.append("received DIS PDU: ");
+					message.append("pduType ");
+					if (currentPduType < 10) {
+						message.append(" ");
+					}
+					message.append(currentPduType).append(" ").append(currentPduTypeName);
+					message.append(", protocolFamily ").append(currentProtocolFamilyID);
+					message.append(" ").append(currentPduFamilyName);
+					System.out.println(message.toString());
+					
+				} else {
+					System.out.println("received packet but pdu is null, packet.getData().length=" + packet.getData().length + ", error...");
+				}
+			}
+		} catch (IOException e) {
+			System.out.println("Problem with DisExamples.PduReceiver, see exception trace:");
+			System.out.println(e);
+		} finally {
+			System.out.println("DisExamples.PduReceiver complete.");
+		}
+
+	}
+
+}

deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FFTestEspduSender.java

+package MV3500Cohort2018JulySeptember.FinalProject.FriscoFurrProject;
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+
+import edu.nps.moves.dis.*;
+import edu.nps.moves.disutil.CoordinateConversions;
+import edu.nps.moves.disutil.DisTime;
+
+/**
+ * Creates and sends ESPDUs in IEEE binary format. Adapted from OpenDIS library
+ * example package edu.nps.moves.examples
+ *
+ * @author DMcG
+ */
+public class FFTestEspduSender {
+
+	public static final int NUMBER_TO_SEND = 5000;
+
+	public enum NetworkMode {
+		UNICAST, MULTICAST, BROADCAST
+	};
+
+	/**
+	 * Default multicast group address we send on.
+	 */
+	public static final String DEFAULT_MULTICAST_ADDRESS = "239.1.2.3";
+
+	/**
+	 * Default multicast port used, matches Wireshark DIS capture default
+	 */
+	public static final int DEFAULT_MULTICAST_PORT = 3000;
+
+	/**
+	 * Possible system properties, passed in via -Dattr=val networkMode:
+	 * unicast, broadcast, multicast destinationIp: where to send the packet. If
+	 * in multicast mode, this can be multicast. To determine broadcast
+	 * destination IP, use an online broadcast address calculator, for example
+	 * http://www.remotemonitoringsystems.ca/broadcast.php If in multicast mode,
+	 * a join() will be done on the multicast address. port: port used for both
+	 * source and destination.
+	 *
+	 * @param args
+	 */
+	public static void main(String args[])
+	{
+		System.out.println("DisExamples.EspduSender started... send " + NUMBER_TO_SEND + " ESPDUs, initial index=0");
+		/**
+		 * an entity state pdu
+		 */
+		EntityStatePdu espdu = new EntityStatePdu();
+		MulticastSocket socket = null; // must be initialized, even if null
+		DisTime disTime = DisTime.getInstance(); // TODO explain
+		int alternator = -1;
+
+		// ICBM coordinates for my office
+		double lat = 36.595517;
+		double lon = -121.877000;
+
+		// Default settings. These are used if no system properties are set. 
+		// If system properties are passed in, these are over ridden.
+		int port = DEFAULT_MULTICAST_PORT;
+		NetworkMode mode = NetworkMode.BROADCAST;
+		InetAddress destinationIp = null; // must be initialized, even if null
+
+		try {
+			destinationIp = InetAddress.getByName(DEFAULT_MULTICAST_ADDRESS);
+		} catch (UnknownHostException e) {
+			System.out.println(e + " Cannot create multicast address");
+			System.exit(0);
+		}
+
+		// All system properties, passed in on the command line via -Dattribute=value
+		Properties systemProperties = System.getProperties();
+
+		// IP address we send to
+		String destinationIpString = systemProperties.getProperty("destinationIp");
+
+		// Port we send to, and local port we open the socket on
+		String portString = systemProperties.getProperty("port");
+
+		// Network mode: unicast, multicast, broadcast
+		String networkModeString = systemProperties.getProperty("networkMode"); // unicast or multicast or broadcast
+
+		// Set up a socket to send information
+		try {
+			// Port we send to
+			if (portString != null) 
+			{
+				port = Integer.parseInt(portString);
+			}
+
+			socket = new MulticastSocket(port);
+
+			// Where we send packets to, the destination IP address
+			if (destinationIpString != null) 
+			{
+				destinationIp = InetAddress.getByName(destinationIpString);
+			}
+
+			// Type of transport: unicast, broadcast, or multicast
+			// TODO convert to String constants
+			if (networkModeString != null) {
+				if (networkModeString.equalsIgnoreCase("unicast")) 
+				{
+					mode = NetworkMode.UNICAST;
+				} 
+				else if (networkModeString.equalsIgnoreCase("broadcast")) {
+					mode = NetworkMode.BROADCAST;
+				} 
+				else if (networkModeString.equalsIgnoreCase("multicast")) {
+					mode = NetworkMode.MULTICAST;
+					if (!destinationIp.isMulticastAddress())
+					{
+						throw new RuntimeException("Sending to multicast address, but destination address " + destinationIp.toString() + "is not multicast");
+					}
+					socket.joinGroup(destinationIp);
+				}
+			} // end networkModeString
+		}
+		catch (IOException | RuntimeException e)
+		{
+			System.out.println("Unable to initialize networking. Exiting.");
+			System.out.println(e);
+			System.exit(-1);
+		}
+
+		// Initialize values in the Entity State PDU object. The exercise ID is 
+		// a way to differentiate between different virtual worlds on one network.
+		// Note that some values (such as the PDU type and PDU family) are set
+		// automatically when you create the ESPDU.
+		espdu.setExerciseID((short) 1);
+
+		// The EID is the unique identifier for objects in the world. This 
+		// EID should match up with the ID for the object specified in the 
+		// VMRL/x3d/virtual world.
+		EntityID entityID = espdu.getEntityID();
+		entityID.setSite(1);  // 0 is apparently not a valid site number, per the spec
+		entityID.setApplication(1);
+		entityID.setEntity(2);
+
+		// Set the entity type. SISO has a big list of enumerations, so that by
+		// specifying various numbers we can say this is an M1A2 American tank,
+		// the USS Enterprise, and so on. We'll make this a tank. There is a 
+		// separate project elsehwhere in this project that implements DIS 
+		// enumerations in C++ and Java, but to keep things simple we just use
+		// numbers here.
+		EntityType entityType = espdu.getEntityType();
+		entityType.setEntityKind((short) 1);      // Platform (vs lifeform, munition, sensor, etc.)
+		entityType.setCountry(225);              // USA
+		entityType.setDomain((short) 1);          // Land (vs air, surface, subsurface, space)
+		entityType.setCategory((short) 1);        // Tank
+		entityType.setSubcategory((short) 1);     // M1 Abrams
+		entityType.setSpec((short) 3);            // M1A2 Abrams
+
+		Set<InetAddress> broadcastAddresses;
+		// Loop through sending N ESPDUs
+		try
+		{
+			System.out.println("Sending " + NUMBER_TO_SEND + " ESPDU packets to " + destinationIp.toString());
+			
+			for (int index = 0; index < NUMBER_TO_SEND; index++) {
+				// DIS time is a pain in the uh, neck. DIS time units are 2^31-1 units per
+				// hour, and time is set to DIS time units from the top of the hour. 
+				// This means that if you start sending just before the top of the hour
+				// the time units can roll over to zero as you are sending. The receivers
+				// (escpecially homegrown ones) are often not able to detect rollover
+				// and may start discarding packets as dupes or out of order. We use
+				// an NPS timestamp here, hundredths of a second since the start of the
+				// year. The DIS standard for time is often ignored in the wild; I've seen
+				// people use Unix time (seconds since 1970) and more. Or you can
+				// just stuff idx into the timestamp field to get something that is monotonically
+				// increasing.
+
+				// Note that timestamp is used to detect duplicate and out of order packets. 
+				// That means if you DON'T change the timestamp, many implementations will simply
+				// discard subsequent packets that have an identical timestamp. Also, if they
+				// receive a PDU with an timestamp lower than the last one they received, they
+				// may discard it as an earlier, out-of-order PDU. So it is a good idea to
+				// update the timestamp on ALL packets sent.
+				// An alterative approach: actually follow the standard. It's a crazy concept,
+				// but it might just work.
+				int timestamp = disTime.getDisAbsoluteTimestamp();
+				espdu.setTimestamp(timestamp);
+
+				// Set the position of the entity in the world. DIS uses a cartesian 
+				// coordinate system with the origin at the center of the earth, the x
+				// axis out at the equator and prime meridian, y out at the equator and
+				// 90 deg east, and z up and out the north pole. To place an object on
+				// the earth's surface you also need a model for the shape of the earth
+				// (it's not a sphere.) All the fancy math necessary to do this is in
+				// the SEDRIS SRM package. There are also some one-off formulas for 
+				// doing conversions from, for example, lat/lon/altitude to DIS coordinates.
+				// Here we use those one-off formulas.
+				// Modify the position of the object. This will send the object a little
+				// due east by adding some to the longitude every iteration. Since we
+				// are on the Pacific coast, this sends the object east. Assume we are
+				// at zero altitude. In other worlds you'd use DTED to determine the
+				// local ground altitude at that lat/lon, or you'd just use ground clamping.
+				// The x and y values will change, but the z value should not.
+				//lon = lon + (double)((double)idx / 100000.0);
+				//System.out.println("lla=" + lat + "," + lon + ", 0.0");
+				double direction = Math.pow((double) (-1.0), (double) (index));
+				lon = lon + (direction * 0.00006);
+				System.out.println(lon);
+
+				double disCoordinates[] = CoordinateConversions.getXYZfromLatLonDegrees(lat, lon, 1.0);
+				Vector3Double location = espdu.getEntityLocation();
+				location.setX(disCoordinates[0]);
+				location.setY(disCoordinates[1]);
+				location.setZ(disCoordinates[2]);
+				System.out.println("lat, lon:" + lat + ", " + lon);
+				System.out.println("DIS coord:" + disCoordinates[0] + ", " + disCoordinates[1] + ", " + disCoordinates[2]);
+
+				// Optionally, we can do some rotation of the entity
+				/*
+            Orientation orientation = espdu.getEntityOrientation();
+            float psi = orientation.getPsi();
+            psi = psi + idx;
+            orientation.setPsi(psi);
+            orientation.setTheta((float)(orientation.getTheta() + idx /2.0));
+				 */
+				// You can set other ESPDU values here, such as the velocity, acceleration,
+				// and so on.
+				// Marshal out the espdu object to a byte array, then send a datagram
+				// packet with that data in it.
+				ByteArrayOutputStream baos = new ByteArrayOutputStream();
+				DataOutputStream dos = new DataOutputStream(baos);
+				espdu.marshal(dos);
+
+				FirePdu fire = new FirePdu();
+				fire.set
+				byte[] fireArray = fire.marshal();
+
+				// The byte array here is the packet in DIS format. We put that into a 
+				// datagram and send it.
+				byte[] data = baos.toByteArray();
+
+				broadcastAddresses = getBroadcastAddresses();
+				Iterator iterator = broadcastAddresses.iterator();
+				while (iterator.hasNext())
+				{
+					InetAddress broadcast = (InetAddress) iterator.next();
+					System.out.println("Sending broadcast datagram packet to " + broadcast);
+					DatagramPacket packet = new DatagramPacket(data, data.length, broadcast, port);
+					socket.send(packet);
+					// TODO experiment with these!  8)
+					packet = new DatagramPacket(fireArray, fireArray.length, broadcast, port); // alternate
+					socket.send(packet);
+				}
+
+				// Send every 1 sec. Otherwise all this will be all over in a fraction of a second.
+				Thread.sleep(1000); // msec
+
+				location = espdu.getEntityLocation();
+
+				System.out.println("Espdu #" + index + " EID=[" + entityID.getSite() + "," + entityID.getApplication() + "," + entityID.getEntity() + "]");
+				System.out.println(" DIS coordinates location=[" + location.getX() + "," + location.getY() + "," + location.getZ() + "]");
+				double c[] = {location.getX(), location.getY(), location.getZ()};
+				double lla[] = CoordinateConversions.xyzToLatLonDegrees(c);
+// debug:		System.out.println(" Location (lat/lon/alt): [" + lla[0] + ", " + lla[1] + ", " + lla[2] + "]");
+			}
+		}
+		catch (IOException | InterruptedException e)
+		{
+            System.out.println("Problem with DisExamples.EspduSender, see exception trace:");
+			System.out.println(e);
+		}
+	}
+
+	/**
+	 * A number of sites get all snippy about using 255.255.255.255 for a
+	 * broadcast address; it trips their security software and they kick you off
+	 * their network. (Comcast, NPS.) This determines the broadcast address for
+	 * all connected interfaces, based on the IP and subnet mask. If you have a
+	 * dual-homed host it will return a broadcast address for both. If you have
+	 * some VMs running on your host this will pick up the addresses for those
+	 * as well--e.g. running VMWare on your laptop with a local IP this will also
+	 * pick up a 192.168 address assigned to the VM by the host OS.
+	 *
+	 * @return set of all broadcast addresses
+	 */
+	public static Set<InetAddress> getBroadcastAddresses()
+	{
+		Set<InetAddress> broadcastAddresses = new HashSet<>();
+		Enumeration interfaces;
+
+		try {
+			interfaces = NetworkInterface.getNetworkInterfaces();
+
+			while (interfaces.hasMoreElements())
+			{
+				NetworkInterface anInterface = (NetworkInterface) interfaces.nextElement();
+
+				if (anInterface.isUp())
+				{
+					Iterator iterator = anInterface.getInterfaceAddresses().iterator();
+					while (iterator.hasNext())
+					{
+						InterfaceAddress anAddress = (InterfaceAddress) iterator.next();
+						if ((anAddress == null || anAddress.getAddress().isLinkLocalAddress()))
+						{
+							continue;
+						}
+
+						//System.out.println("Getting broadcast address for " + anAddress);
+						InetAddress broadcastAddress = anAddress.getBroadcast();
+						if (broadcastAddress != null)
+						{
+							broadcastAddresses.add(broadcastAddress);
+						}
+					}
+				}
+			}
+		}
+		catch (SocketException e) 
+		{
+            System.out.println("Problem with DisExamples.EspduSender.getBroadcastAddresses(), see exception trace:");
+			System.out.println(e);
+		}
+		return broadcastAddresses;
+	}
+}

deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FriscoFurrPduSender.java

@@ -52,10 +52,12 @@ public class FriscoFurrPduSender
             // and add that PDU to a list.
             for (PduType pdu : PduType.values()) {
                 Pdu aPdu = null;
-
+				System.out.println(pdu);
                 switch (pdu) // using enumeration values from edu.nps.moves.disenum.*
 				{
+					
                     case ENTITY_STATE:
+						System.out.println("Case: Enitity_State "+pdu+"\n");
                         aPdu = new EntityStatePdu();
 						EntityStatePdu espdu = (EntityStatePdu) aPdu;
 						Marking marking = new Marking();
@@ -138,6 +140,7 @@ public class FriscoFurrPduSender
                 if (aPdu != null)
 				{
                     generatedPdus.add(aPdu);
+					System.out.println("APDU container count "+generatedPdus.size());
                 }
             }