public void WriteXml(XmlWriter writer)
{
writer.WriteAttributeString("Description", Description);
writer.WriteAttributeString("Url", Url);
writer.WriteAttributeString("Ports", Ports);
writer.WriteAttributeString("AutoConnect", AutoConnect.ToString());
}
public void SaveSettings()
{
new XDocument(
new XElement(Tag_Root,
new XElement(Tag_NamedPipeAddress, NamedPipeAddress),
new XElement(Tag_AutoConnect, AutoConnect.ToString()),
new XElement(Tag_TimePaddingForLoop, TimePaddingForLoop.ToString()),
new XElement(Tag_LoopSelection, LoopSelection.ToString()),
new XElement(Tag_LoopNumber, LoopNumber.ToString()),
new XElement(Tag_PlayMode, PlayMode.ToString()),
new XElement(Tag_Volume,
new XElement(Tag_VolumeValue, VolumeValue.ToString()),
new XElement(Tag_VolumeMute, VolumeMute.ToString())),
new XElement(Tag_Documents, DocumentByDocumentGuid.Select(x =>
new XElement(Tag_Document, new XAttribute(Att_Document_Id, x.Key), new XElement(Tag_Document_Name, x.Value.Name), new XElement(Tag_Media, x.Value.Media)))),
new XElement(Tag_MinimalSeverityToShowInLog, MinimalSeverityToShowInLog.ToString()),
new XElement(Tag_Window,
new XElement(Tag_Top, WindowTop.ToString()),
new XElement(Tag_Left, WindowLeft.ToString()),
new XElement(Tag_Width, WindowWidth.ToString()),
new XElement(Tag_Height, WindowHeight.ToString()),
new XElement(Tag_Maximized, WindowMaximized.ToString()),
new XElement(Tag_AlwaysOnTop, AlwaysOnTop.ToString())),
new XElement(Tag_VlcLibPath, VlcLibPath),
new XElement(Tag_DoNotAskAgain, FontMissingWindowDoNotAskAgain.ToString()))
).Save(SettingsPath);
}
public void AutoC()
{
if (!PublicMethod.Instance.IsExecuteSystemCMD("autoc"))
{
var a = new AutoConnect();
a.autoc();
}
}
private void ToolSMI_Zdlj_Click(object sender, EventArgs e)
{
if (!PublicMethod.Instance.IsExecuteSystemCMD(""))
{
ConnectManager.CleanSelcol();
var a = new AutoConnect();
a.autoc();
}
}
public void Save(string path)
{
System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
System.Xml.XmlElement project_root = doc.CreateElement("Root");
{
var e = doc.CreateElement("Target");
e.AppendChild(doc.CreateTextNode(Target.ToString()));
project_root.AppendChild(e);
}
{
var e = doc.CreateElement("Port");
e.AppendChild(doc.CreateTextNode(Port.ToString()));
project_root.AppendChild(e);
}
{
var e = doc.CreateElement("AutoConnect");
e.AppendChild(doc.CreateTextNode(AutoConnect.ToString()));
project_root.AppendChild(e);
}
{
var e = doc.CreateElement("SendOnLoad");
e.AppendChild(doc.CreateTextNode(SendOnLoad.ToString()));
project_root.AppendChild(e);
}
{
var e = doc.CreateElement("SendOnEdit");
e.AppendChild(doc.CreateTextNode(SendOnEdit.ToString()));
project_root.AppendChild(e);
}
{
var e = doc.CreateElement("SendOnSave");
e.AppendChild(doc.CreateTextNode(SendOnSave.ToString()));
project_root.AppendChild(e);
}
doc.AppendChild(project_root);
var dec = doc.CreateXmlDeclaration("1.0", "utf-8", null);
doc.InsertBefore(dec, project_root);
// For failing to save
try
{
doc.Save(path);
}
catch
{
}
}
/// <summary>
/// 自动建连接
/// </summary>
/// <param name="strObjID">第一个设备</param>
/// <param name="endObjID">第二个设备</param>
private static void AutoTopology(ObjectId strObjID, ObjectId endObjID)
{
try
{
var at = new AutoConnect();
at.autocbyobjid(strObjID, endObjID);
}catch (Exception ex)
{
LogManager.Instance.Error(ex + "自动建连接关系错误！");
}
}
public void SaveSettings()
{
new XDocument(
new XElement(Tag_Root,
new XElement(Tag_NamedPipeAddress, NamedPipeAddress),
new XElement(Tag_AutoConnect, AutoConnect.ToString()),
new XElement(Tag_MinimalSeverityToShowInLog, MinimalSeverityToShowInLog.ToString()),
new XElement(Tag_Window,
new XElement(Tag_Top, WindowTop.ToString()),
new XElement(Tag_Left, WindowLeft.ToString()),
new XElement(Tag_Width, WindowWidth.ToString()),
new XElement(Tag_Height, WindowHeight.ToString()),
new XElement(Tag_Maximized, WindowMaximized.ToString()),
new XElement(Tag_AlwaysOnTop, AlwaysOnTop.ToString())))
).Save(SettingsPath);
}
private void ProcessAutoConnectMessage(AutoConnectMessageType autoConnectMessageType)
{
AutoConnect?.Invoke(new AutoConnectMessage(autoConnectMessageType));
}
/// <summary>
/// Validates and processes any command-line arguments that were passed in. Invalid arguments will halt program execution.
/// </summary>
/// <param name="args">Command-line parameters</param>
static void ProcessArguments(string[] args)
{
port.name = String.Empty;
// switch to lower case and remove '/', '--' and '-' from beginning of arguments - we can process correctly without them
for (int i = 0; i < args.Count(); i++)
{
args[i] = (args[i].TrimStart('/', '-')).ToLower();
}
// sort the parameters so that they get processed in order of priority (i.e. 'quiet' option gets processed before something that would normally result in console output, etc.)
Array.Sort(args, new ArgumentSorter());
// iterate through command-line arguments
foreach (string arg in args)
{
// split argument into components based on 'key:value' formatting
string[] argument = arg.Split(':');
// help
if (argument[0].StartsWith("h") || argument[0].StartsWith("?"))
{
ShowHelp();
ExitProgram(silent: true);
}
// list available ports
else if (argument[0].StartsWith("l"))
{
// get a list of all available ports
availablePorts = (SimplySerial.GetSerialPorts()).OrderBy(p => p.num).ToList();
if (availablePorts.Count >= 1)
{
Console.WriteLine("\nPORT\tVID\tPID\tDESCRIPTION");
Console.WriteLine("------------------------------------------------------------");
foreach (ComPort p in availablePorts)
{
Console.WriteLine("{0}\t{1}\t{2}\t{3}",
p.name,
p.vid,
p.pid,
(p.board.isCircuitPython) ? (p.board.make + " " + p.board.model) : p.description
);
}
Console.WriteLine("");
}
else
{
Console.WriteLine("\nNo COM ports detected.\n");
}
ExitProgram(silent: true);
}
// quiet (no output to console other than comes in via serial)
else if (argument[0].StartsWith("q"))
{
SimplySerial.Quiet = true;
}
// the remainder of possible command-line arguments require two parameters, so let's enforce that now
else if (argument.Count() < 2)
{
ExitProgram(("Invalid or incomplete argument <" + arg + ">\nTry 'ss.exe help' to see a list of valid arguments"), exitCode: -1);
}
// preliminary validate on com port, final validation occurs towards the end of this method
else if (argument[0].StartsWith("c"))
{
string newPort = argument[1].ToUpper();
if (!argument[1].StartsWith("COM"))
{
newPort = "COM" + argument[1];
}
port.name = newPort;
autoConnect = AutoConnect.ONE;
}
// validate baud rate, terminate on error
else if (argument[0].StartsWith("b"))
{
// these are the baud rates we're supporting for now
string[] availableBaudRates = new string[] { "1200", "2400", "4800", "7200", "9600", "14400", "19200", "38400", "57600", "115200" };
if (availableBaudRates.Contains(argument[1]))
{
baud = Convert.ToInt32(argument[1]);
}
else
{
ExitProgram(("Invalid baud rate specified <" + argument[1] + ">"), exitCode: -1);
}
}
// validate parity, terminate on error
else if (argument[0].StartsWith("p"))
{
if (argument[1].StartsWith("e"))
{
parity = Parity.Even;
}
else if (argument[1].StartsWith("m"))
{
parity = Parity.Mark;
}
else if (argument[1].StartsWith("n"))
{
parity = Parity.None;
}
else if (argument[1].StartsWith("o"))
{
parity = Parity.Odd;
}
else if (argument[1].StartsWith("s"))
{
parity = Parity.Space;
}
else
{
ExitProgram(("Invalid parity specified <" + argument[1] + ">"), exitCode: -1);
}
}
// validate databits, terminate on error
else if (argument[0].StartsWith("d"))
{
int newDataBits = Convert.ToInt32(argument[1]);
if ((newDataBits > 3) && (newDataBits < 9))
{
dataBits = newDataBits;
}
else
{
ExitProgram(("Invalid data bits specified <" + argument[1] + ">"), exitCode: -1);
}
}
// validate stopbits, terminate on error
else if (argument[0].StartsWith("s"))
{
if (argument[1] == "0")
{
stopBits = StopBits.None;
}
else if (argument[1] == "1")
{
stopBits = StopBits.One;
}
else if (argument[1] == "1.5")
{
stopBits = StopBits.OnePointFive;
}
else if (argument[1] == "2")
{
stopBits = StopBits.Two;
}
else
{
ExitProgram(("Invalid stop bits specified <" + argument[1] + ">"), exitCode: -1);
}
}
// validate auto connect, terminate on error
else if (argument[0].StartsWith("a"))
{
if (argument[1].StartsWith("n"))
{
autoConnect = AutoConnect.NONE;
}
else if (argument[1].StartsWith("o"))
{
autoConnect = AutoConnect.ONE;
}
else if (argument[1].StartsWith("a"))
{
autoConnect = AutoConnect.ANY;
}
else
{
ExitProgram(("Invalid auto connect setting specified <" + argument[1] + ">"), exitCode: -1);
}
}
// an invalid/incomplete argument was passed
else
{
ExitProgram(("Invalid or incomplete argument <" + arg + ">\nTry 'ss.exe -help' to see a list of valid arguments"), exitCode: -1);
}
}
Console.Clear();
if (autoConnect == AutoConnect.ANY)
{
Output("<<< Attemping to connect to any avaiable COM port. Use CTRL-X to cancel >>>");
}
else if (autoConnect == AutoConnect.ONE)
{
Console.Clear();
if (port.name == String.Empty)
{
Output("<<< Attempting to connect to first available COM port. Use CTRL-X to cancel >>>");
}
else
{
Output("<<< Attempting to connect to " + port.name + ". Use CTRL-X to concel >>>");
}
}
// if we made it this far, everything has been processed and we're ready to proceed!
}
public void TestSolve()
{
var ps = new Collection <ProvidedSocket>();
ps.Add(new ProvidedSocket()
{
Types = new Collection <string>()
{
"A"
}, Label = "ps1"
});
ps.Add(new ProvidedSocket()
{
Types = new Collection <string>()
{
"B"
}, Label = "ps2"
});
ps.Add(new ProvidedSocket()
{
Types = new Collection <string>()
{
"C"
}, Label = "ps3"
});
ps.Add(new ProvidedSocket()
{
Types = new Collection <string>()
{
"D"
}, Label = "ps4"
});
ps.Add(new ProvidedSocket()
{
Types = new Collection <string>()
{
"O"
}, Label = "ps5"
});
var mbDefs = new List <MainboardDefinition>()
{
ModelTest.CreateMainboardDef("happy", ps)
};
var moDefs = new List <ModuleDefinition>()
{
ModelTest.CreateModuleDef(Guid.Parse("015DF700-5A47-4282-BD91-BFD024D038FC"), "m1su1", "A", false),
ModelTest.CreateModuleDef(Guid.Parse("9AB4B04B-A31B-4E8C-82E6-532456B8C0A0"), "m2su1", "B,C", false),
ModelTest.CreateModuleDef(Guid.Parse("3B5F45A2-EE5A-4FE7-83E6-900D7096F0E2"), "m3su1", "B,A", false),
ModelTest.CreateModuleDef(Guid.Parse("5FE253D2-3B61-4F84-8F4B-8B9B05AEE0AE"), "m4su1", "D", false),
//ModelTest.CreateModuleDef(Guid.Parse("A5C823F5-88B8-4F33-BE2F-9D1956C9ED9C"),"m5su1","D",true),
//ModelTest.CreateModuleDef(Guid.Parse("3FF4E16B-2DAD-4B93-BCF3-5FE359F95079"),"m6su1","O",true),
};
GadgeteerDefinitionsManager.Instance.Initialize(mbDefs, moDefs);
var store = new Store(typeof(GadgeteerDSLDomainModel));
var tx = store.TransactionManager.BeginTransaction();
var mainboard = new Mainboard(store);
mainboard.Name = "happy";
mainboard.CreateSockets();
var modules = new Collection <Module>();
var ids = new Collection <Guid>();
ids.Add(Guid.Parse("015DF700-5A47-4282-BD91-BFD024D038FC"));
ids.Add(Guid.Parse("9AB4B04B-A31B-4E8C-82E6-532456B8C0A0"));
ids.Add(Guid.Parse("3B5F45A2-EE5A-4FE7-83E6-900D7096F0E2"));
ids.Add(Guid.Parse("5FE253D2-3B61-4F84-8F4B-8B9B05AEE0AE"));
//ids.Add(Guid.Parse("A5C823F5-88B8-4F33-BE2F-9D1956C9ED9C"));
//ids.Add(Guid.Parse("3FF4E16B-2DAD-4B93-BCF3-5FE359F95079"));
foreach (var guid in ids)
{
var m = new Module(store)
{
ModuleDefinitionId = guid
};
m.CreateSocketUses();
modules.Add(m);
}
//Basic test where all works
using (var tx2 = store.TransactionManager.BeginTransaction())
{
var socketUses = from o in modules from su in o.SocketUses select su;
var b1 = AutoConnect.Solve(mainboard, socketUses);
Assert.IsTrue(b1, "Complex connection");
tx2.Rollback();
}
// Test where there are mutiple optional sockets with the same type
/*
* using (var tx2 = store.TransactionManager.BeginTransaction())
* {
* (GadgeteerDefinitionsManager.Instance.Modules.Last().Sockets[0].Types[0] as SingleSocketType).Value = "D";
* var socketUses = from o in modules from su in o.SocketUses select su;
* var b1 = AutoConnect.Solve(mainboard, socketUses);
* Assert.IsTrue(b1, "Multiple optional sockets with the same type");
* Assert.IsNotNull(modules[3].SocketUses[0].Socket);
* tx2.Rollback();
* }
*/
// Test where an optional socket cannot connect
/*
* using (var tx2 = store.TransactionManager.BeginTransaction())
* {
* (GadgeteerDefinitionsManager.Instance.Modules.Last().Sockets[0].Types[0] as SingleSocketType).Value = "Z";
* var socketUses = from o in modules from su in o.SocketUses select su;
* var b1 = AutoConnect.Solve(mainboard, socketUses);
* Assert.IsTrue(b1, "Optional socket cannot connect");
* tx2.Rollback();
* }
*/
//Start from a partially connected state
using (var tx2 = store.TransactionManager.BeginTransaction())
{
modules[0].SocketUses[0].Socket = mainboard.Sockets[0];
var socketUses = from o in modules from su in o.SocketUses select su;
var b1 = AutoConnect.Solve(mainboard, socketUses);
Assert.IsTrue(b1, "Partial connection");
tx2.Rollback();
}
using (var tx2 = store.TransactionManager.BeginTransaction())
{
(GadgeteerDefinitionsManager.Instance.Modules.First().Sockets[0].Types[0] as SingleSocketType).Value = "E";
var socketUses = from o in modules from su in o.SocketUses select su;
var b1 = AutoConnect.Solve(mainboard, socketUses);
Assert.IsFalse(b1, "A module that cannot connect to the mainboard");
tx2.Rollback();
}
using (var tx2 = store.TransactionManager.BeginTransaction())
{
(GadgeteerDefinitionsManager.Instance.Modules.First().Sockets[0].Types[0] as SingleSocketType).Value = "A";
GadgeteerDefinitionsManager.Instance.Mainboards.First().ProvidedSockets.RemoveAt(3);
mainboard.CreateSockets();
var socketUses = from o in modules from su in o.SocketUses select su;
var b1 = AutoConnect.Solve(mainboard, socketUses);
Assert.IsFalse(b1, "Not enough sockets on the mainboard");
tx2.Rollback();
}
tx.Rollback();
store.Dispose();
}
