public SensorEditForm(StateItem item)
{
InitializeComponent();
mItem = item as WSNSensor;
txtSensorName.Text = mItem.Name;
foreach (SensorType type in Enum.GetValues(typeof(SensorType)))
{
cmbSensorType.Items.Add(type.ToString());
if (type == mItem.NodeType)
this.cmbSensorType.SelectedItem = type.ToString();
}
}
public SensorEditForm(StateItem item)
{
InitializeComponent();
mItem = item as WSNSensor;
txtSensorName.Text = mItem.Name;
foreach (SensorType type in Enum.GetValues(typeof(SensorType)))
{
cmbSensorType.Items.Add(type.ToString());
if (type == mItem.NodeType)
{
this.cmbSensorType.SelectedItem = type.ToString();
}
}
}
/// <summary>
/// Generate the intermediate arcs that link between sensors
/// eg: Output1 --> Channel1_2
/// </summary>
/// <param name="docOut"></param>
/// <param name="transitions"></param>
/// <param name="places"></param>
/// <param name="arcs"></param>
/// <param name="localNetwork"></param>
public static void buildConnOutSensorUN(XmlDocument docOut, XmlElement transitions, XmlElement places, XmlElement arcs, LocalNetwork localNetwork)
{
float x, y;
foreach (WSNSensor sensor in localNetwork.mSensors)
{
foreach (WSNChannel channel in localNetwork.mChannels)
{
WSNSensor fromS = (WSNSensor)channel.From;
if (fromS.ID != sensor.ID)
{
continue;
}
// No need for ConnIn and UniIn on the generated PN
//String transName = "UniIn" + channel.ID;
//WSNPNData outSData = localNetwork.getMapping(sensor.ID);
//WSNPNData inSData = localNetwork.getMapping(channel.ID);
//x = (outSData.getOutNodePosition().X + inSData.getInNodePosition().X) / 2f;
//y = (outSData.getOutNodePosition().Y + inSData.getInNodePosition().Y) / 2f;
//XmlElement trans = buildTransistion(docOut, transName, x, y);
//transitions.AppendChild(trans);
//arcs.AppendChild(buildArc(
// docOut, outSData.getOutNodeName(), transName,
// (x + outSData.getOutNodePosition().X) / 2f, (y + outSData.getOutNodePosition().Y) / 2f));
//String placeName = "ConnIn" + channel.ID;
//x = inSData.getInNodePosition().X - 1f;
//y = inSData.getInNodePosition().Y;
//XmlElement place = buildPlace(docOut, placeName, x, y);
//places.AppendChild(place);
//arcs.AppendChild(buildArc(
// docOut, transName, placeName, x - 0.5f, y));
//arcs.AppendChild(buildArc(
// docOut, placeName, inSData.getInNodeName(), x - 0.15f, y));
WSNPNData outSData = localNetwork.getMapping(sensor.ID);
WSNPNData inSData = localNetwork.getMapping(channel.ID);
x = (outSData.getOutNodePosition().X + inSData.getInNodePosition().X) / 2f;
y = (outSData.getOutNodePosition().Y + inSData.getInNodePosition().Y) / 2f;
arcs.AppendChild(buildArc(docOut, outSData.getOutNodeName(), inSData.getInNodeName(), x - 0.5f, y));
}
}
}
/// <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());
}
protected override void LoadStates(XmlElement procNode)
{
XmlElement sensors = (XmlElement)procNode.ChildNodes[0];
WSNSensor canvasSensor = null;
foreach (XmlElement xmlSen in sensors.ChildNodes)
{
canvasSensor = new WSNSensor(StateCounter);
canvasSensor.LoadFromXml(xmlSen);
AddSingleCanvasItem(canvasSensor);
AddSingleCanvasItem(canvasSensor.labelItems);
}
}
/// <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 receive place on abstract sensor
/// </summary>
/// <param name="canvas">Canvas contain sensor/channel item</param>
/// <param name="places">places list</param>
/// <param name="channels">channel list</param>
/// <param name="sensors">sensor list</param>
/// <param name="ws">sensor item</param>
/// <param name="transition">trans contain channels instance</param>
/// <param name="isSensorAbstract">mark sensor abstract</param>
/// <param name="isChannelAbstract">mark channel abstract</param>
public static void embedReceiveAbstractSensor(WSNCanvas canvas, IList<WSNChannel> channels, WSNSensor ws, XmlElement transition)
{
switch (ws.NodeType)
{
case SensorType.Source:
setXmlNodeData(transition, "Guard", GBK_SENSOR_SOURCE_TRANSITION_BROADCASTING);
setXmlNodeData(transition, "Program", initSensorSource(channels, ws.ID));
break;
case SensorType.Intermediate:
setXmlNodeData(transition, "Guard", String.Format(GBK_SENSOR_INTER_TRANSITION_BROADCASTING, ws.ID));
setXmlNodeData(transition, "Program", initSensorAbstractSend(channels, ws.ID));
break;
default:
break;
}
}
/// <summary>
/// Embed code to sensor
/// </summary>
/// <param name="data">Sensor data</param>
/// <param name="sensor">Sensor object</param>
/// <param name="channels">Channel Object list</param>
/// <param name="sensorAbstract">Flag sensor has abstracted</param>
public static void embedCodeToSensor(WSNPNData data, WSNSensor sensor, IList<WSNChannel> channels, bool sensorAbstract)
{
XmlNode transition;
switch (sensor.NodeType)
{
case SensorType.Source:
if (sensorAbstract && Build.mMode == NetMode.BROADCAST)
break;
transition = getTransition(data, "Send", sensor.ID);
setXmlNodeData(transition, "Guard", GBK_SENSOR_SOURCE_SEND);
setXmlNodeData(transition, "Program", initSensorSource(channels, sensor.ID));
break;
case SensorType.Intermediate:
if (sensorAbstract)
break;
// Receive transition
transition = getTransition(data, "Receive", sensor.ID);
setXmlNodeData(transition, "Program", String.Format(PBK_SENSOR_INTERFULL_RECEIVE, sensor.ID));
setXmlNodeData(transition, "Guard", String.Format(GBK_SENSOR_INTERFULL_RECEIVE, sensor.ID));
// Send transition
transition = getTransition(data, "Send", sensor.ID);
setXmlNodeData(transition, "Program", initSensorSend(channels, sensor.ID));
// Congestion transition
transition = getTransition(data, "Congestion", sensor.ID);
setXmlNodeData(transition, "Guard", String.Format(GBK_SENSOR_INTERFULL_CONGESTION, sensor.ID));
break;
case SensorType.Sink:
transition = getTransition(data, "Receive", sensor.ID);
setXmlNodeData(transition, "Program", String.Format(PBK_SENSOR_SINK_RECEIVE, sensor.ID));
break;
default:
break;
}
}
/// <summary>
/// Combine code for connector on broadcast mode
/// </summary>
/// <param name="transition">trans contain channels instance</param>
/// <param name="ws">sensor item</param>
/// <param name="_channels">channel list</param>
public static void buildCodeBroadcastConnector(XmlElement transition, WSNSensor ws, List<WSNChannel> _channels)
{
do
{
XmlNode xmlGuard = transition.SelectSingleNode("./Guard");
XmlNode xmlProgram = transition.SelectSingleNode("./Program");
// full sensor
StringBuilder guardBuild = new StringBuilder();
StringBuilder progBuild = new StringBuilder();
guardBuild.Append("false");
String subPartternGuard = "(!net.isFullChannel({0}, {1}) && net.getChannelBS({0}, {1}) > 0)";
foreach (WSNChannel wc in _channels)
{
if (((WSNSensor)wc.From).ID == ws.ID)
{
guardBuild.Append(" || ");
guardBuild.Append(String.Format(subPartternGuard, ws.ID, ((WSNSensor)wc.To).ID));
progBuild.Append(String.Format("Main{0} = 1;\n", wc.ID));
}
}
xmlGuard.InnerText = "";
} while (false);
}
/// <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);
}
/// <summary>
/// Embed code to sensor
/// </summary>
/// <param name="data">Sensor data</param>
/// <param name="sensor">Sensor object</param>
/// <param name="channels">Channel Object list</param>
/// <param name="sensorAbstract">Flag sensor has abstracted</param>
public static void embedCodeToSensor(WSNPNData data, WSNSensor sensor, IList <WSNChannel> channels, bool sensorAbstract)
{
XmlNode transition;
int id = sensor.ID;
switch (sensor.NodeType)
{
case SensorType.Source:
if (sensorAbstract)
{
break;
}
//if (Build.mMode == NetMode.UNICAST || Build.mMode == NetMode.MULTICAST)
//{
// // {0} - sensor id / {1} - pkg/q of sensor id / {2} - grp
// StringBuilder grpChannels = new StringBuilder();
// foreach (WSNChannel channel in channels)
// {
// if (((WSNSensor)channel.From).ID != id)
// continue;
// grpChannels.AppendFormat("\n\nsub = util.getMin(pkg, sqr{0});", id);
// grpChannels.AppendFormat("\nb{0} = b{0} + sub;", channel.ID);
// grpChannels.Append("\npkg = pkg - sub;");
// }
// transition = getTransition(data, "Send", id);
// setXmlNodeData(transition, "Program",
// String.Format(PROGRAM_SENSOR_SEND_UN, id, "pkg", grpChannels));
// setXmlNodeData(transition, "Guard", "pkg > 0");
// break;
//}
break;
case SensorType.Intermediate:
// Not code inside sensor abstracted
if (sensorAbstract)
{
break;
}
//if (Build.mMode == NetMode.UNICAST || Build.mMode == NetMode.MULTICAST)
//{
// StringBuilder grpChannels = new StringBuilder();
// String queue = "q" + id;
// foreach (WSNChannel channel in channels)
// {
// if (((WSNSensor)channel.From).ID != id)
// continue;
// grpChannels.AppendFormat("\n\nsub = util.getMin({0}, sqr{1});", queue, id);
// grpChannels.AppendFormat("\nb{0} = b{0} + sub;", channel.ID);
// grpChannels.AppendFormat("\n{0} = {0} - sub;", queue);
// }
// transition = getTransition(data, "Send", id);
// setXmlNodeData(transition, "Program",
// String.Format(PROGRAM_SENSOR_SEND_UN, id, queue, grpChannels));
// setXmlNodeData(transition, "Guard", String.Format("{0} > 0", queue));
//}
// Receive transition
transition = getTransition(data, "Receive", id);
setXmlNodeData(transition, "Program", String.Format(PROGRAM_SENSOR_RECEIVE, id));
setXmlNodeData(transition, "Guard", String.Format("b{0} > 0 && b{0} <= S_MAX_BUFFER", id));
// Congestion transition
transition = getTransition(data, "Congestion", id);
setXmlNodeData(transition, "Guard", String.Format("b{0} > S_MAX_BUFFER", id));
break;
//// Send transition
//transition = getTransition(data, "Send", id);
//setXmlNodeData(transition, "Guard", String.Format("q{0} > 0", id));
//setXmlNodeData(transition, "Program", "");
//break;
case SensorType.Sink:
transition = getTransition(data, "Receive", id);
setXmlNodeData(transition, "Program", String.Format("q{0} = q{0} + b{0};\nb{0} = 0;", id));
break;
default:
break;
}
}
