public ChannelEditForm(Route route, LTSCanvas canvas, NetMode mode)
{
do
{
InitializeComponent();
mChannel = (WSNChannel)route;
mMode = mode;
mCanvas = canvas;
List <LTSCanvas.CanvasItemData> canvasItems = canvas.itemsList;
foreach (LTSCanvas.CanvasItemData itemData in canvasItems)
{
if (itemData.Item is StateItem)
{
this.cmbSource.Items.Add(itemData.Item);
this.cmbDest.Items.Add(itemData.Item);
if (itemData.Item.Equals(route.From))
{
this.cmbSource.SelectedItem = itemData.Item;
}
if (itemData.Item.Equals(route.To))
{
this.cmbDest.SelectedItem = itemData.Item;
}
}
}
if (!mMode.Equals(NetMode.MULTICAST))
{
txtSensorsConn.Visible = false;
lblSensorsConn.Visible = false;
break;
}
StringBuilder subConn = new StringBuilder();
subConn.Append(((WSNSensor)mChannel.To).ID.ToString());
foreach (int item in mChannel.SubIdList)
{
subConn.Append("," + item);
}
txtSensorsConn.Text = subConn.ToString();
} while (false);
}
/// <summary>
/// Initialize code for sensor in multicast mode
/// </summary>
/// <param name="channel">Channel object</param>
/// <returns>Program's code of transition source</returns>
private static string initSendMulticast(WSNChannel channel, Boolean sensorAbstracted)
{
string id = channel.ID;
StringBuilder ret = new StringBuilder();
WSNSensor fSensor = (WSNSensor)channel.From;
ret.AppendFormat("var sub = util.getMin(b{0}, r{0});", id);
ret.AppendFormat("\n{0} = {0} + sub;", (sensorAbstracted ? "q" : "b") + ((WSNSensor)channel.To).ID);
foreach (int sensorID in channel.SubIdList)
{
ret.AppendFormat("\n{0} = {0} + sub;", (sensorAbstracted ? "q" : "b") + sensorID);
}
ret.AppendFormat("\nb{0} = b{0} - sub;", id);
ret.AppendFormat("\n\nif (b{0} > 0)\n\tMain{0} = 1;", id);
return(ret.ToString());
}
/// <summary>
/// Generate PN xml file from KWSN model
/// </summary>
/// <param name="abstractSensor">if Sensors are abstracted</param>
/// <param name="abstractChannel">if Channel are abstracted</param>
/// <returns>PN xml</returns>
public override XmlDocument GenerateXML(params bool[] values)
{
do
{
if (values == null || values.Count() != 3)
{
DevLog.e(TAG, "Incorrect input params");
break;
}
bool abstractSensor = values[0];
bool abstractChannel = values[1];
bool improved = values[2];
bool blError = false;
XmlElement models = mDocOut.CreateElement(XmlTag.TAG_MODELS);
mXRoot.AppendChild(models);
foreach (WSNCanvas canvas in mCanvas)
{
List <WSNSensor> sensors = new List <WSNSensor>(); // sensors list from canvas
List <WSNChannel> channels = new List <WSNChannel>(); // channel list from canvas
StringBuilder ltlSensorCongestion = new StringBuilder(); // LTL for check on sensor
StringBuilder ltlChannelCongestion = new StringBuilder(); // LTL for check on channel
int maxSensorId = 0;
List <Int32> sensorCheckIds = new List <Int32>();
foreach (LTSCanvas.CanvasItemData item in canvas.itemsList) // get the sensors list
{
if (item.Item is WSNSensor)
{
WSNSensor add = (WSNSensor)item.Item;
add.locateX = item.Item.X / 120;
add.locateY = item.Item.Y / 120;
if (mMinX == 0 || add.locateX < mMinX)
{
mMinX = add.locateX;
}
if (mMinY == 0 || add.locateY < mMinY)
{
mMinY = add.locateY;
}
sensors.Add(add.Clone());
if (add.ID > maxSensorId)
{
maxSensorId = add.ID;
}
// Append LTL for sensor congestion
if (abstractSensor || add.NodeType != SensorType.Intermediate)
{
continue;
}
sensorCheckIds.Add(add.ID);
}
}
// Add LTL check congestion on sensor
int interCnt = sensorCheckIds.Count;
if (interCnt > 0)
{
ltlSensorCongestion.Append("#assert System |= []!(");
for (int i = 0; i < interCnt - 1; i++)
{
ltlSensorCongestion.Append(String.Format("Congestion{0} || ", sensorCheckIds[i]));
}
ltlSensorCongestion.Append(String.Format("Congestion{0});", sensorCheckIds[interCnt - 1]));
}
// Get the channels list
foreach (Route route in canvas.diagramRouter.routes)
{
if (route is WSNChannel)
{
WSNChannel channel = (WSNChannel)route;
channel.Type = getChannelType(Build.mMode);
channels.Add(channel.Clone());
}
}
XmlElement topology = mDocOut.CreateElement(XmlTag.TAG_TOPOLOGY);
topology.SetAttribute(XmlTag.ATTR_mID, mExtendInfo.mID.ToString());
topology.SetAttribute(XmlTag.ATTR_NUMOFSENSORS, mExtendInfo.mNumberSensor.ToString());
topology.SetAttribute(XmlTag.ATTR_NUMOFPACKETS, mExtendInfo.mNumberPacket.ToString());
topology.SetAttribute(XmlTag.ATTR_AVGBUFFER, mExtendInfo.mSensorMaxBufferSize.ToString());
topology.SetAttribute(XmlTag.TAG_MODE, Build.mMode.ToString());
topology.SetAttribute(XmlTag.TAG_ABSTRACTEDLEVEL, (abstractSensor ? "0" : "1") + (abstractChannel ? "0" : "1"));
foreach (WSNSensor sensor in sensors) // append sensor to topology
{
topology.AppendChild(sensor.WriteToXml(mDocOut));
}
foreach (WSNChannel channel in channels) // append channel to topology
{
topology.AppendChild(channel.WriteToXml(mDocOut));
}
XmlElement model = mDocOut.CreateElement(XmlTag.TAG_MODEL);
XmlElement places = mDocOut.CreateElement(XmlTag.TAG_PLACES);
XmlElement transitions = mDocOut.CreateElement(XmlTag.TAG_TRANSITIONS);
XmlElement arcs = mDocOut.CreateElement(XmlTag.TAG_ARCS);
models.AppendChild(model);
model.AppendChild(topology);
model.AppendChild(places);
model.AppendChild(transitions);
model.AppendChild(arcs);
do
{
WSNPNData data = null;
float xStartPos = 0;
float yStartPos = 0;
Hashtable mapData = new Hashtable();
bool localSensorAbstract;
foreach (WSNSensor sensor in sensors)
{
////// Force keep source sensor in case unicast or multicast
//localSensorAbstract = abstractSensor;
//if (sensor.NodeType == SensorType.Source
// && abstractSensor && (Build.mMode == NetMode.UNICAST || Build.mMode == NetMode.MULTICAST))
// localSensorAbstract = false;
data = sensor.GeneratePNXml(mDocPNRes, sensor.ID.ToString(), abstractSensor, sensor.locateX - mMinX, sensor.locateY - mMinY);
if (data == null)
{
DevLog.e(TAG, "Failed to generate the sensor PN xml nodes");
blError = true;
break;
}
mapData[sensor.ID] = data;
xStartPos += XPOSITION_SHIFT;
// 20151113-lqv-change model
// Embed code for sensor
BuildUtils.embedCodeToSensor(data, sensor, channels, abstractSensor);
addPNData(data, ref places, ref transitions, ref arcs);
// Then find the channel connected with this sensor
foreach (WSNChannel channel in channels)
{
WSNSensor sensorFrom = (WSNSensor)channel.From;
if (sensorFrom.ID != sensor.ID)
{
continue;
}
// compute positon for channel
xStartPos = (channel.From.AbsoluteX + channel.To.AbsoluteX) / 240;
yStartPos = (channel.From.AbsoluteY + channel.To.AbsoluteY) / 240;
data = channel.GeneratePNXml(mDocPNRes, channel.ID, abstractChannel, xStartPos - mMinX, yStartPos - mMinY, channel.ProbabilityPathCongestion);
if (data == null)
{
DevLog.d(TAG, "Failed to generate the sensor PN xml nodes");
blError = true;
break;
}
mapData[channel.ID] = data;
xStartPos += XPOSITION_SHIFT; // Shift x position
yStartPos += YPOSITION_SHIFT; // Shift y position
// 20151113-lqv-changle model
BuildUtils.embedCodeToChannel(data, channel, abstractChannel, abstractSensor);
addPNData(data, ref places, ref transitions, ref arcs);
} // foreach
if (blError == true)
{
break;
}
} // foreach
if (blError == true)
{
break;
}
LocalNetwork localNetwork = new LocalNetwork(mapData, abstractSensor, abstractChannel, sensors, channels);
switch (Build.mMode) // build connector by mode
{
case NetMode.BROADCAST:
BuildUtils.buildConnOutSensorBR(mDocOut, transitions, places, arcs, localNetwork);
if (improved)
{
BuildUtils.buildConnInSensorImprove(mDocOut, transitions, places, arcs, localNetwork);
break;
}
BuildUtils.buildConnInSensor(mDocOut, transitions, places, arcs, localNetwork);
break;
case NetMode.UNICAST:
BuildUtils.buildConnOutSensorUN(mDocOut, transitions, places, arcs, localNetwork);
// Not support improved in unicast mode
BuildUtils.buildConnInSensor(mDocOut, transitions, places, arcs, localNetwork);
break;
case NetMode.MULTICAST:
BuildUtils.buildConnOutSensorMC(mDocOut, transitions, places, arcs, localNetwork);
BuildUtils.buildConnInSensor(mDocOut, transitions, places, arcs, localNetwork);
//if (improved)
//{
// BuildUtils.buildConnInSensorImprove(mDocOut, transitions, places, arcs, localNetwork);
// break;
//}
//BuildUtils.buildConnInSensor(mDocOut, transitions, places, arcs, localNetwork);
break;
default:
break;
}
#region Update model properties
// update the property
model.SetAttribute(XmlTag.ATTR_NAME, canvas.ProcessName);
model.SetAttribute(XmlTag.ATTR_PRO_PARAM, "");
model.SetAttribute(XmlTag.ATTR_ZOOM, "1");
model.SetAttribute(XmlTag.TAG_MODEL_PRO_PCOUNTER, "0");
model.SetAttribute(XmlTag.TAG_MODEL_PRO_TCOUNTER, "0");
#endregion
mDocOut.Save(mFileName); // save document
} while (false);
// Add LTL check congestion on channel
if (abstractChannel == false && channels.Count > 0)
{
ltlChannelCongestion.Append("#assert System |= []!(");
for (int i = 0; i < channels.Count - 1; i++)
{
ltlChannelCongestion.AppendFormat("Congestion{0} || ", channels[i].ID);
}
ltlChannelCongestion.AppendFormat("Congestion{0});", channels[channels.Count - 1].ID);
}
// add declaration
mDeclaration.InnerXml = String.Format(mDocPNRes.GetElementsByTagName(
XmlTag.TAG_DECLARATION)[0].InnerXml,
BuildUtils.buildDeclaration(mExtendInfo, sensors, channels),
ltlSensorCongestion.ToString(), // LTL for check on sensor
ltlChannelCongestion.ToString()); // LTL for check on channel
}
} while (false);
return(mDocOut);
}
/// <summary>
/// Combine code for channel
/// </summary>
/// <param name="data">Channel data</param>
/// <param name="channel">Channel item</param>
/// <param name="channelAbstract"></param>
/// <param name="sensorAbstract"></param>
public static void embedCodeToChannel(WSNPNData data, WSNChannel channel, bool channelAbstract, bool sensorAbstract)
{
do
{
string id = channel.ID;
XmlNode transition; // get xml node to transition then edit content
WSNSensor fSensor = (WSNSensor)channel.From;
WSNSensor tSensor = (WSNSensor)channel.To;
bool isSource = (fSensor.NodeType == SensorType.Source);
if (channelAbstract)
{
switch (Build.mMode)
{
case NetMode.BROADCAST:
{
// {0} - channel id - {1} - b1/q1 of sensor - {2} sensor/main
transition = getTransition(data, "Channel", id);
string program = String.Format(PROGRAM_CHANNEL_RECEIVE_BR,
channel.ID, (sensorAbstract ? "q" : "b") + tSensor.ID, "BrOut");
setXmlNodeData(transition, "Program", program);
setXmlNodeData(transition, "Guard",
String.Format("b{0} > 0 && b{0} <= C_MAX_BUFFER", channel.ID));
break;
}
case NetMode.UNICAST:
{
// {0} - channel id, {1} pkg/qk of from sensor, {2} from sensor id, {3} to sensor id
transition = getTransition(data, "Channel", id);
//setXmlNodeData(transition, "Program",
//String.Format(PROGRAM_CHANNEL_ASTRACTION, id, isSource ? "pkg" : ("q" + fSensor.ID), fSensor.ID, tSensor.ID));
setXmlNodeData(
transition,
"Program",
String.Format(
PROGRAM_CHANNEL_ASTRACTION,
isSource ? "pkg" : ("q" + fSensor.ID),
fSensor.ID,
tSensor.ID));
//setXmlNodeData(transition, "Guard", String.Format("b{0} <= C_MAX_BUFFER", id));
break;
}
case NetMode.MULTICAST:
{
// {0} - channel id, {1} pkg/qk of from sensor, {2} from sensor id, {3} to sensor id, {4} grp
transition = getTransition(data, "Channel", id);
StringBuilder programCode = new StringBuilder();
programCode.AppendFormat("\n\tb{0} = b{0} + sub;", tSensor.ID);
foreach (int sensorID in channel.SubIdList)
{
programCode.AppendFormat("\n\tb{0} = b{0} + sub;", sensorID);
}
transition = getTransition(data, "Channel", id);
setXmlNodeData(transition, "Program",
String.Format(PROGRAM_CHANNEL_ASTRACTION_MC, id, isSource ? "pkg" : ("q" + fSensor.ID), fSensor.ID, tSensor.ID, programCode.ToString()));
setXmlNodeData(transition, "Guard", String.Format("b{0} <= C_MAX_BUFFER", id));
break;
}
default:
break;
}
break;
}
// Same code inside congestion transition
// Embed code for transition's congestion
transition = getTransition(data, "Congestion", id);
setXmlNodeData(transition, "Guard", String.Format("b{0} > C_MAX_BUFFER || q{0} > C_MAX_QUEUE", id));
setXmlNodeData(transition, "Program", String.Format("Input{0}", tSensor.ID));
switch (channel.Type)
{
case ChannelType.Broadcast:
{
transition = getTransition(data, "Send", id);
string program = String.Format(PROGRAM_CHANNEL_RECEIVE_BR,
channel.ID,
(sensorAbstract ? "q" : "b") + tSensor.ID, "Main");
setXmlNodeData(transition, "Program", program);
setXmlNodeData(transition, "Guard",
String.Format("b{0} > 0 && b{0} <= C_MAX_BUFFER", channel.ID));
break;
}
case ChannelType.Unicast:
{
// {0} channel id, {1} pkg/qk of from sensor id
transition = getTransition(data, "Receive", id);
//setXmlNodeData(transition, "Program",
// String.Format(PROGRAM_CHANNEL_RECEIVE_UNI, id, isSource ? "pkg" : ("q" + fSensor.ID)));
setXmlNodeData(transition, "Program",
String.Format(PROGRAM_CHANNEL_RECEIVE_UNI, fSensor.ID));
setXmlNodeData(transition, "Guard",
isSource ? "pkg > 0" : String.Format("b{0} > 0 && b{0} <= S_MAX_BUFFER && q{0} > 0 && q{0} <= C_MAX_QUEUE", fSensor.ID));
// Embed code for transition's send
// {0} - channel ID / {1} - to sensor ID / {2} b/q - {3} pkg/q of sensor - {4} - sensor/output - {5} from sensor id
// transition = getTransition(data, "Send", id);
// setXmlNodeData(transition, "Program",
// String.Format(PROGRAM_CHANNEL_SEND, id, tSensor.ID, sensorAbstract ? "q" : "b"));
// setXmlNodeData(transition, "Guard", String.Format("b{0} > 0 && b{0} <= C_MAX_BUFFER", id));
break;
}
case ChannelType.Multicast:
{
// {0} channel id, {1} pkg/qk of from sensor id
transition = getTransition(data, "Receive", id);
setXmlNodeData(transition, "Program",
String.Format(PROGRAM_CHANNEL_RECEIVE_UNI, id, isSource ? "pkg" : ("q" + fSensor.ID)));
setXmlNodeData(transition, "Guard",
isSource ? "pkg > 0" : String.Format("q{0} > 0 && q{0} <= S_MAX_BUFFER", fSensor.ID));
// Embed code for transition's send
transition = getTransition(data, "Send", channel.ID);
setXmlNodeData(transition, "Program", initSendMulticast(channel, sensorAbstract));
setXmlNodeData(transition, "Guard", String.Format("b{0} > 0 && b{0} <= C_MAX_BUFFER", id));
break;
}
default:
break;
}
} while (false);
}
