WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/canDude/Source/Program.cs


using System;
using System.Threading;
using System.Collections.Generic;
using System.Text;
 
///TODO:
// argument -v # (debuglevel)
// argument till konstruktor på alla objekt: debuglevel
 
class Program {
    const byte DEBUG_LEVEL = 3; //0, 1, 2, 3
   
    //connects to candaemon on tcp to send and receive packets
    static DaemonConnection dc;
    //a commandline arguments parser
    static Arguments CommandLine;
    //functions for downloading hex to target
    static Downloader dl;
    //maintains a hexfile
    private static HexFile hf;
   
    static bool aBios=false;        //if commandline says it is a bios update
    static bool aReset=false;       //if commandline says a reset should be sent before downloading to target
    static bool aStart=false;       //if commandline says a start should be sent after downloading to target
    static bool aTerminal=false;    //if commandline says we should start in interactive mode
       
    static bool sNodeid=false;      //true when a nodeid has been parsed
    static bool sHexfile=false;     //true when a hexfile has been specified
       
    static string hexfile=null;     //path to a hexfile
    static byte nodeid=0;           //id of current node
    static string host=null;        //address of candaemon-host
    static int port=1200;           //port of candaemon-host
   
    static void Main(string[] args) {
        bool error = false;
        if (args.Length < 4) {
            //if to few arguments then print info and quit
            printSyntax();
            error = true;
        }
 
        if (!error) {
            //parse commandline arguments
            CommandLine=new Arguments(args);
           
            //check single arguments
            if (CommandLine["b"] == "true") { aBios = true; }
            if (CommandLine["r"] == "true") { aReset = true; }
            if (CommandLine["s"] == "true") { aStart = true; }
            if (CommandLine["t"] == "true") { aTerminal = true; }
           
            //check hexfile argument
            hexfile = CommandLine["f"];
            if (hexfile != null) {
                sHexfile = true;
            }
            if (!aTerminal && !sHexfile && !aReset && !aStart) {
                if (DEBUG_LEVEL>0) { Console.WriteLine("When not in terminal mode a hexfile, a reset or a start parameter must be supplied, I quit"); }
                error = true;
            }
           
            //check nodeid argument
            string node = CommandLine["n"];
            if (node != null) {
                if (!parseNodeId(node)) {
                    error = true;
                }
            }
            if (!aTerminal && !sNodeid) {
                if (DEBUG_LEVEL>0) { Console.WriteLine("When not in terminal mode a nodeid must be supplied, I quit"); }
                error = true;
            }
           
            //check host and port arguments
            host = CommandLine["h"];
            string sPort = CommandLine["p"];
            if ((host == null) || (sPort.Length == 0)) {
                if (DEBUG_LEVEL>0) { printSyntax(); }
                error = true;
            } else {
                try {
                    port = int.Parse(sPort);
                } catch {
                    if (DEBUG_LEVEL>0) { Console.WriteLine("Was not able to parse port, I quit"); }
                    error = true;
                }
            }
        }
       
        if  (!error) {
            //commandline feedback output
            if (DEBUG_LEVEL>2) {
                Console.WriteLine("canDude settings:");
                if (sNodeid) { Console.WriteLine("Nodeaddress: 0x" + String.Format("{0:x2}", nodeid)); }
                Console.WriteLine("Host: {0}:{1}", host, port);
                if (hexfile != null) { Console.WriteLine("Hexfile: {0}", hexfile); }
                Console.Write("Parameters: ");
                if (aBios) { Console.Write("Bios "); }
                if (aReset) { Console.Write("Reset "); }
                if (aStart) { Console.Write("Start "); }
                if (aTerminal) { Console.Write("Terminal"); }
                Console.WriteLine("");
            }
        }
       
        if (!error) {
            //connect to candaemon
            dc = new DaemonConnection();
            if (dc.init(host, port)) {
                if (DEBUG_LEVEL>1) { Console.WriteLine("Connected to candaemon"); }
            } else {
                if (DEBUG_LEVEL>0) { Console.WriteLine("Connection to candaemon could not be established, I quit"); }
                error = true;
            }
            Thread.Sleep(100);
        }
           
        if (!error && aTerminal) {
            //terminal mode (==interactive mode)
            bool success = true;
            //load hexfile if one has been specified as commandline argument
            hf = new HexFile();
            if (sHexfile && success) {
                if (hf.loadHex(hexfile)) {
                    if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile loaded"); }
                } else { success = false; }
            }
           
            if (success) {
                if (DEBUG_LEVEL>1) {
                    Console.WriteLine("");
                    printHelp();        //print available commands
                    Console.WriteLine("");
                }
               
                string instr;
                do {
                    Console.Write("> ");            //a command has been executed, print a new console char
                    instr = Console.ReadLine();     //read std in
                } while (parseInput(instr));        //parse a line from std in
               
                //exit command
            }
        }
 
        if (!error && !aTerminal) {
            //not terminal mode
            bool success = true;
           
            if (sHexfile) {
                //load hexfile (a hexfile must be supplied as commandline argument)
                hf = new HexFile();
                if (hf.loadHex(hexfile)) {
                    if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile loaded"); }
                } else {
                    success = false;
                    if (DEBUG_LEVEL>0) { Console.WriteLine("Hexfile could not be loaded, I quit"); }
                }
            }
           
            //if a hexfile is loaded then start autodownloading sequence
            if (success) {
                bool autosuccess = true;
               
                CanNMT cpn = new CanNMT();
                if (aReset) {
                    //send a reset command (and wait for feedback)
                    if (!cpn.doReset(dc, nodeid)) {
                        if (DEBUG_LEVEL>0) { Console.WriteLine("Target node did not respond to reset, I quit"); }
                        autosuccess = false;
                    }
                }
               
                if (sHexfile && autosuccess) {
                    //send application
                    dl = new Downloader(hf, dc, nodeid, aBios);
                    if (!dl.go()) {
                        if (DEBUG_LEVEL>0) { Console.WriteLine("Error occured during download"); }
                        autosuccess = false;
                    }
                }
               
                if (autosuccess && aStart) {
                    //start application
                    cpn.doStart(dc, nodeid);
                }
               
            }
        }
        if (dc != null) {
            //stop tcp client thread
            dc.stop();
        }
    }
   
    static private void printSyntax() {
        Console.WriteLine("Syntax: program.exe [options] -h <host> -p <port>");
        Console.WriteLine("Host and port are host and port of canDaemon, most likely localhost and 1200.");
        Console.WriteLine("Options:");
        Console.WriteLine("  -f <hexfile>   Specify a file to be loaded to target.");
        Console.WriteLine("  -n <nodeid>    Id of target node, hex or decimal.");
        Console.WriteLine("  -t             Enter terminal mode.");
        Console.WriteLine("  -r             Reset node before loading target.");
        Console.WriteLine("  -s             Start node after loading target.");
        Console.WriteLine("  -b             Program hex as bios, use with caution.");
    }
   
    static private void printHelp() {
        Console.WriteLine("canDude commands:");
        Console.WriteLine("load [<hexfile>] - reload hexfile or load new hexfile");
        Console.WriteLine("node <nodeid>    - specify id of target node, hex or decimal");
        Console.WriteLine("reset            - reset node");
        Console.WriteLine("start            - start application in node (no feedback yet)");
        Console.WriteLine("go               - start download application to target");
        Console.WriteLine("go bios          - start download bios to target, use with caution");
        Console.WriteLine("help             - prints this help");
        Console.WriteLine("exit or quit     - exit program");
    }  
   
    static private bool parseNodeId(string node) {
        // the goal here is to find a byte from 0-255 in a string, format in decimal (0-255) or in hex (0x0-0xff)
        // this is probably not done very neat
        sNodeid = false;
        if (node.Length > 0) {
            try {
                nodeid = byte.Parse(node);
                sNodeid = true;
            } catch {}
        }
        if (node.Length > 2) {
            if (node.Substring(0, 2).Equals("0x")) {
                if (node.Length == 3) {
                    try {
                        nodeid = byte.Parse(node.Substring(2, 1), System.Globalization.NumberStyles.HexNumber);
                        sNodeid = true;
                    } catch {
                        if (DEBUG_LEVEL>0) { Console.WriteLine("nodeadress parse error 1"); }
                        return false;
                    }
                } else if (node.Length == 4) {
                    try {
                        nodeid = byte.Parse(node.Substring(2, 2), System.Globalization.NumberStyles.HexNumber);
                        sNodeid = true;
                    } catch {
                        if (DEBUG_LEVEL>0) { Console.WriteLine("nodeadress parse error 2"); }
                        return false;
                    }
                } else if (node.Length > 4) {
                    try {
                        nodeid = byte.Parse(node.Substring(2, 2), System.Globalization.NumberStyles.HexNumber);
                        sNodeid = true;
                    } catch {
                        if (DEBUG_LEVEL>0) { Console.WriteLine("nodeadress parse error 2"); }
                        return false;
                    }
                } else {
                    if (DEBUG_LEVEL>0) { Console.WriteLine("nodeadress parse error 3"); }
                    return false;
                }
            }
        }
       
        return true;
    }
   
    static private bool parseInput(string instr) {
        //parse commands entered on std in
        if (instr.Equals("reset")) {        //reset command, send a reset to current node
            if (sNodeid) {
                dc.flushData();
                CanNMT cpn = new CanNMT();
                cpn.doReset(dc, nodeid);
            } else {
                if (DEBUG_LEVEL>0) { Console.WriteLine("No nodeid has been specified"); }
            }
        }
        else if (instr.Equals("start")) {   //start command, send a start to current node
            if (sNodeid) {
                CanNMT cpn = new CanNMT();
                cpn.doStart(dc, nodeid);
            } else {
                if (DEBUG_LEVEL>0) { Console.WriteLine("No nodeid has been specified"); }
            }
        }
        else if (instr.StartsWith("go")) {  //downloading command
            bool dlBios = false;
            bool error = true;
            if (instr.Equals("go bios")) {  //if bios should be downloaded
                dlBios = true;
                error = false;
            } else if (instr.Equals("go")) {    //is an application should be downloaded
                error = false;
            }
           
            if (!sNodeid) {
                if (DEBUG_LEVEL>0) { Console.WriteLine("No nodeid has been specified"); }
                error = true;
            }
            if (!sHexfile) {
                if (DEBUG_LEVEL>0) { Console.WriteLine("No hexfile has been specified"); }
                error = true;
            }
           
            CanNMT cpn = new CanNMT();
            if (!error && aReset) {             //commandline arguments specified that a reset should be done before download
                //send a reset command (and wait for feedback)
                if (!cpn.doReset(dc, nodeid)) {
                    if (DEBUG_LEVEL>0) { Console.WriteLine("Target node did not respond to reset"); }
                    error = true;
                }
            }
               
            if (!error) {
                //send application
                dc.flushData();
                dl = new Downloader(hf, dc, nodeid, dlBios);
                if (!dl.go()) {
                    if (DEBUG_LEVEL>0) { Console.WriteLine("Error occured during download"); }
                    error = true;
                }
            }
               
            if (!error && aStart) {             //commandline arguments specified that a start should be done after download
                //start applikation
                cpn.doStart(dc, nodeid);
            }
           
        }
        else if (instr.StartsWith("load")) {    //load hexfile or reload current hexfile
            if (instr.Length > 5) {
                //second argument is a hexfile, this file should be loaded
                hexfile = instr.Substring(5);
                if (hf.loadHex(hexfile)) {
                    sHexfile = true;
                    if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile loaded"); }
                } else {
                    if (DEBUG_LEVEL>0) { Console.WriteLine("Hexfile could not be loaded"); }
                }
            } else {
                //reload current hexfile. if a hexfile already has been specified
                if (sHexfile) {
                    if (hf.loadHex(hexfile)) {
                        if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile reloaded"); }
                    } else {
                        if (DEBUG_LEVEL>0) { Console.WriteLine("Hexfile could not be reloaded"); }
                    }
                } else {
                    if (DEBUG_LEVEL>0) { Console.WriteLine("No hexfile has been specified"); }
                }
               
            }
        }
        else if (instr.StartsWith("node")) {
            //change nodeid
            if (instr.Length > 5) {
                //second argument is nodeid
                string node = instr.Substring(5);
                parseNodeId(node);
            }
            if (DEBUG_LEVEL>1) { Console.WriteLine("NodeId is 0x"+ String.Format("{0:x2}", nodeid)); }
        }
        else if (instr.Equals("help")) {
            printHelp();
        }
        else if (instr.Equals("exit") || instr.Equals("quit") || instr.Equals("q")) {
            return false;
        }
        else {
            Console.WriteLine("Unknown command.");
        }
       
        return true;
    }
   
}
 

Rev 586	Rev 655
1	using System;	1	using System;
2	using System.Threading;	2	using System.Threading;
3	using System.Collections.Generic;	3	using System.Collections.Generic;
4	using System.Text;	4	using System.Text;
5		5
6	///TODO:	6	///TODO:
7	// argument -v # (debuglevel)	7	// argument -v # (debuglevel)
8	// argument till konstruktor på alla objekt: debuglevel	8	// argument till konstruktor på alla objekt: debuglevel
9		9
10	class Program {	10	class Program {
11	const byte DEBUG_LEVEL = 3; //0, 1, 2, 3	11	const byte DEBUG_LEVEL = 3; //0, 1, 2, 3
12		12
13	//connects to candaemon on tcp to send and receive packets	13	//connects to candaemon on tcp to send and receive packets
14	static DaemonConnection dc;	14	static DaemonConnection dc;
15	//a commandline arguments parser	15	//a commandline arguments parser
16	static Arguments CommandLine;	16	static Arguments CommandLine;
17	//functions for downloading hex to target	17	//functions for downloading hex to target
18	static Downloader dl;	18	static Downloader dl;
19	//maintains a hexfile	19	//maintains a hexfile
20	private static HexFile hf;	20	private static HexFile hf;
21		21
22	static bool aBios=false; //if commandline says it is a bios update	22	static bool aBios=false; //if commandline says it is a bios update
23	static bool aReset=false; //if commandline says a reset should be sent before downloading to target	23	static bool aReset=false; //if commandline says a reset should be sent before downloading to target
24	static bool aStart=false; //if commandline says a start should be sent after downloading to target	24	static bool aStart=false; //if commandline says a start should be sent after downloading to target
25	static bool aTerminal=false; //if commandline says we should start in interactive mode	25	static bool aTerminal=false; //if commandline says we should start in interactive mode
26		26
27	static bool sNodeid=false; //true when a nodeid has been parsed	27	static bool sNodeid=false; //true when a nodeid has been parsed
28	static bool sHexfile=false; //true when a hexfile has been specified	28	static bool sHexfile=false; //true when a hexfile has been specified
29		29
30	static string hexfile=null; //path to a hexfile	30	static string hexfile=null; //path to a hexfile
31	static byte nodeid=0; //id of current node	31	static byte nodeid=0; //id of current node
32	static string host=null; //address of candaemon-host	32	static string host=null; //address of candaemon-host
33	static int port=1200; //port of candaemon-host	33	static int port=1200; //port of candaemon-host
34		34
35	static void Main(string[] args) {	35	static void Main(string[] args) {
36	bool error = false;	36	bool error = false;
37	if (args.Length < 4) {	37	if (args.Length < 4) {
38	//if to few arguments then print info and quit	38	//if to few arguments then print info and quit
39	printSyntax();	39	printSyntax();
40	error = true;	40	error = true;
41	}	41	}
42		42
43	if (!error) {	43	if (!error) {
44	//parse commandline arguments	44	//parse commandline arguments
45	CommandLine=new Arguments(args);	45	CommandLine=new Arguments(args);
46		46
47	//check single arguments	47	//check single arguments
48	if (CommandLine["b"] == "true") { aBios = true; }	48	if (CommandLine["b"] == "true") { aBios = true; }
49	if (CommandLine["r"] == "true") { aReset = true; }	49	if (CommandLine["r"] == "true") { aReset = true; }
50	if (CommandLine["s"] == "true") { aStart = true; }	50	if (CommandLine["s"] == "true") { aStart = true; }
51	if (CommandLine["t"] == "true") { aTerminal = true; }	51	if (CommandLine["t"] == "true") { aTerminal = true; }
52		52
53	//check hexfile argument	53	//check hexfile argument
54	hexfile = CommandLine["f"];	54	hexfile = CommandLine["f"];
55	if (hexfile != null) {	55	if (hexfile != null) {
56	sHexfile = true;	56	sHexfile = true;
57	}	57	}
58	if (!aTerminal && !sHexfile && !aReset && !aStart) {	58	if (!aTerminal && !sHexfile && !aReset && !aStart) {
59	if (DEBUG_LEVEL>0) { Console.WriteLine("When not in terminal mode a hexfile, a reset or a start parameter must be supplied, I quit"); }	59	if (DEBUG_LEVEL>0) { Console.WriteLine("When not in terminal mode a hexfile, a reset or a start parameter must be supplied, I quit"); }
60	error = true;	60	error = true;
61	}	61	}
62		62
63	//check nodeid argument	63	//check nodeid argument
64	string node = CommandLine["n"];	64	string node = CommandLine["n"];
65	if (node != null) {	65	if (node != null) {
66	if (!parseNodeId(node)) {	66	if (!parseNodeId(node)) {
67	error = true;	67	error = true;
68	}	68	}
69	}	69	}
70	if (!aTerminal && !sNodeid) {	70	if (!aTerminal && !sNodeid) {
71	if (DEBUG_LEVEL>0) { Console.WriteLine("When not in terminal mode a nodeid must be supplied, I quit"); }	71	if (DEBUG_LEVEL>0) { Console.WriteLine("When not in terminal mode a nodeid must be supplied, I quit"); }
72	error = true;	72	error = true;
73	}	73	}
74		74
75	//check host and port arguments	75	//check host and port arguments
76	host = CommandLine["h"];	76	host = CommandLine["h"];
77	string sPort = CommandLine["p"];	77	string sPort = CommandLine["p"];
78	if ((host == null) \|\| (sPort.Length == 0)) {	78	if ((host == null) \|\| (sPort.Length == 0)) {
79	if (DEBUG_LEVEL>0) { printSyntax(); }	79	if (DEBUG_LEVEL>0) { printSyntax(); }
80	error = true;	80	error = true;
81	} else {	81	} else {
82	try {	82	try {
83	port = int.Parse(sPort);	83	port = int.Parse(sPort);
84	} catch {	84	} catch {
85	if (DEBUG_LEVEL>0) { Console.WriteLine("Was not able to parse port, I quit"); }	85	if (DEBUG_LEVEL>0) { Console.WriteLine("Was not able to parse port, I quit"); }
86	error = true;	86	error = true;
87	}	87	}
88	}	88	}
89	}	89	}
90		90
91	if (!error) {	91	if (!error) {
92	//commandline feedback output	92	//commandline feedback output
93	if (DEBUG_LEVEL>2) {	93	if (DEBUG_LEVEL>2) {
94	Console.WriteLine("canDude settings:");	94	Console.WriteLine("canDude settings:");
95	if (sNodeid) { Console.WriteLine("Nodeaddress: 0x" + String.Format("{0:x2}", nodeid)); }	95	if (sNodeid) { Console.WriteLine("Nodeaddress: 0x" + String.Format("{0:x2}", nodeid)); }
96	Console.WriteLine("Host: {0}:{1}", host, port);	96	Console.WriteLine("Host: {0}:{1}", host, port);
97	if (hexfile != null) { Console.WriteLine("Hexfile: {0}", hexfile); }	97	if (hexfile != null) { Console.WriteLine("Hexfile: {0}", hexfile); }
98	Console.Write("Parameters: ");	98	Console.Write("Parameters: ");
99	if (aBios) { Console.Write("Bios "); }	99	if (aBios) { Console.Write("Bios "); }
100	if (aReset) { Console.Write("Reset "); }	100	if (aReset) { Console.Write("Reset "); }
101	if (aStart) { Console.Write("Start "); }	101	if (aStart) { Console.Write("Start "); }
102	if (aTerminal) { Console.Write("Terminal"); }	102	if (aTerminal) { Console.Write("Terminal"); }
103	Console.WriteLine("");	103	Console.WriteLine("");
104	}	104	}
105	}	105	}
106		106
107	if (!error) {	107	if (!error) {
108	//connect to candaemon	108	//connect to candaemon
109	dc = new DaemonConnection();	109	dc = new DaemonConnection();
110	if (dc.init(host, port)) {	110	if (dc.init(host, port)) {
111	if (DEBUG_LEVEL>1) { Console.WriteLine("Connected to candaemon"); }	111	if (DEBUG_LEVEL>1) { Console.WriteLine("Connected to candaemon"); }
112	} else {	112	} else {
113	if (DEBUG_LEVEL>0) { Console.WriteLine("Connection to candaemon could not be established, I quit"); }	113	if (DEBUG_LEVEL>0) { Console.WriteLine("Connection to candaemon could not be established, I quit"); }
114	error = true;	114	error = true;
115	}	115	}
116	Thread.Sleep(100);	116	Thread.Sleep(100);
117	}	117	}
118		118
119	if (!error && aTerminal) {	119	if (!error && aTerminal) {
120	//terminal mode (==interactive mode)	120	//terminal mode (==interactive mode)
121	bool success = true;	121	bool success = true;
122	//load hexfile if one has been specified as commandline argument	122	//load hexfile if one has been specified as commandline argument
123	hf = new HexFile();	123	hf = new HexFile();
124	if (sHexfile && success) {	124	if (sHexfile && success) {
125	if (hf.loadHex(hexfile)) {	125	if (hf.loadHex(hexfile)) {
126	if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile loaded"); }	126	if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile loaded"); }
127	} else { success = false; }	127	} else { success = false; }
128	}	128	}
129		129
130	if (success) {	130	if (success) {
131	if (DEBUG_LEVEL>1) {	131	if (DEBUG_LEVEL>1) {
132	Console.WriteLine("");	132	Console.WriteLine("");
133	printHelp(); //print available commands	133	printHelp(); //print available commands
134	Console.WriteLine("");	134	Console.WriteLine("");
135	}	135	}
136		136
137	string instr;	137	string instr;
138	do {	138	do {
139	Console.Write("> "); //a command has been executed, print a new console char	139	Console.Write("> "); //a command has been executed, print a new console char
140	instr = Console.ReadLine(); //read std in	140	instr = Console.ReadLine(); //read std in
141	} while (parseInput(instr)); //parse a line from std in	141	} while (parseInput(instr)); //parse a line from std in
142		142
143	//exit command	143	//exit command
144	}	144	}
145	}	145	}
146		146
147	if (!error && !aTerminal) {	147	if (!error && !aTerminal) {
148	//not terminal mode	148	//not terminal mode
149	bool success = true;	149	bool success = true;
150		150
151	if (sHexfile) {	151	if (sHexfile) {
152	//load hexfile (a hexfile must be supplied as commandline argument)	152	//load hexfile (a hexfile must be supplied as commandline argument)
153	hf = new HexFile();	153	hf = new HexFile();
154	if (hf.loadHex(hexfile)) {	154	if (hf.loadHex(hexfile)) {
155	if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile loaded"); }	155	if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile loaded"); }
156	} else {	156	} else {
157	success = false;	157	success = false;
158	if (DEBUG_LEVEL>0) { Console.WriteLine("Hexfile could not be loaded, I quit"); }	158	if (DEBUG_LEVEL>0) { Console.WriteLine("Hexfile could not be loaded, I quit"); }
159	}	159	}
160	}	160	}
161		161
162	//if a hexfile is loaded then start autodownloading sequence	162	//if a hexfile is loaded then start autodownloading sequence
163	if (success) {	163	if (success) {
164	bool autosuccess = true;	164	bool autosuccess = true;
165		165
166	CanNMT cpn = new CanNMT();	166	CanNMT cpn = new CanNMT();
167	if (aReset) {	167	if (aReset) {
168	//send a reset command (and wait for feedback)	168	//send a reset command (and wait for feedback)
169	if (!cpn.doReset(dc, nodeid)) {	169	if (!cpn.doReset(dc, nodeid)) {
170	if (DEBUG_LEVEL>0) { Console.WriteLine("Target node did not respond to reset, I quit"); }	170	if (DEBUG_LEVEL>0) { Console.WriteLine("Target node did not respond to reset, I quit"); }
171	autosuccess = false;	171	autosuccess = false;
172	}	172	}
173	}	173	}
174		174
175	if (sHexfile && autosuccess) {	175	if (sHexfile && autosuccess) {
176	//send application	176	//send application
177	dl = new Downloader(hf, dc, nodeid, aBios);	177	dl = new Downloader(hf, dc, nodeid, aBios);
178	if (!dl.go()) {	178	if (!dl.go()) {
179	if (DEBUG_LEVEL>0) { Console.WriteLine("Error occured during download"); }	179	if (DEBUG_LEVEL>0) { Console.WriteLine("Error occured during download"); }
180	autosuccess = false;	180	autosuccess = false;
181	}	181	}
182	}	182	}
183		183
184	if (autosuccess && aStart) {	184	if (autosuccess && aStart) {
185	//start application	185	//start application
186	cpn.doStart(dc, nodeid);	186	cpn.doStart(dc, nodeid);
187	}	187	}
188		188
189	}	189	}
190	}	190	}
191	if (dc != null) {	191	if (dc != null) {
192	//stop tcp client thread	192	//stop tcp client thread
193	dc.stop();	193	dc.stop();
194	}	194	}
195	}	195	}
196		196
197	static private void printSyntax() {	197	static private void printSyntax() {
198	Console.WriteLine("Syntax: program.exe [options] -h <host> -p <port>");	198	Console.WriteLine("Syntax: program.exe [options] -h <host> -p <port>");
199	Console.WriteLine("Host and port are host and port of canDaemon, most likely localhost and 1200.");	199	Console.WriteLine("Host and port are host and port of canDaemon, most likely localhost and 1200.");
200	Console.WriteLine("Options:");	200	Console.WriteLine("Options:");
201	Console.WriteLine(" -f <hexfile> Specify a file to be loaded to target.");	201	Console.WriteLine(" -f <hexfile> Specify a file to be loaded to target.");
202	Console.WriteLine(" -n <nodeid> Id of target node, hex or decimal.");	202	Console.WriteLine(" -n <nodeid> Id of target node, hex or decimal.");
203	Console.WriteLine(" -t Enter terminal mode.");	203	Console.WriteLine(" -t Enter terminal mode.");
204	Console.WriteLine(" -r Reset node before loading target.");	204	Console.WriteLine(" -r Reset node before loading target.");
205	Console.WriteLine(" -s Start node after loading target.");	205	Console.WriteLine(" -s Start node after loading target.");
206	Console.WriteLine(" -b Program hex as bios, use with caution.");	206	Console.WriteLine(" -b Program hex as bios, use with caution.");
207	}	207	}
208		208
209	static private void printHelp() {	209	static private void printHelp() {
210	Console.WriteLine("canDude commands:");	210	Console.WriteLine("canDude commands:");
211	Console.WriteLine("load [<hexfile>] - reload hexfile or load new hexfile");	211	Console.WriteLine("load [<hexfile>] - reload hexfile or load new hexfile");
212	Console.WriteLine("node <nodeid> - specify id of target node, hex or decimal");	212	Console.WriteLine("node <nodeid> - specify id of target node, hex or decimal");
213	Console.WriteLine("reset - reset node");	213	Console.WriteLine("reset - reset node");
214	Console.WriteLine("start - start application in node (no feedback yet)");	214	Console.WriteLine("start - start application in node (no feedback yet)");
215	Console.WriteLine("go - start download application to target");	215	Console.WriteLine("go - start download application to target");
216	Console.WriteLine("go bios - start download bios to target, use with caution");	216	Console.WriteLine("go bios - start download bios to target, use with caution");
217	Console.WriteLine("help - prints this help");	217	Console.WriteLine("help - prints this help");
218	Console.WriteLine("exit or quit - exit program");	218	Console.WriteLine("exit or quit - exit program");
219	}	219	}
220		220
221	static private bool parseNodeId(string node) {	221	static private bool parseNodeId(string node) {
222	// the goal here is to find a byte from 0-255 in a string, format in decimal (0-255) or in hex (0x0-0xff)	222	// the goal here is to find a byte from 0-255 in a string, format in decimal (0-255) or in hex (0x0-0xff)
223	// this is probably not done very neat	223	// this is probably not done very neat
224	sNodeid = false;	224	sNodeid = false;
225	if (node.Length > 0) {	225	if (node.Length > 0) {
226	try {	226	try {
227	nodeid = byte.Parse(node);	227	nodeid = byte.Parse(node);
228	sNodeid = true;	228	sNodeid = true;
229	} catch {}	229	} catch {}
230	}	230	}
231	if (node.Length > 2) {	231	if (node.Length > 2) {
232	if (node.Substring(0, 2).Equals("0x")) {	232	if (node.Substring(0, 2).Equals("0x")) {
233	if (node.Length == 3) {	233	if (node.Length == 3) {
234	try {	234	try {
235	nodeid = byte.Parse(node.Substring(2, 1), System.Globalization.NumberStyles.HexNumber);	235	nodeid = byte.Parse(node.Substring(2, 1), System.Globalization.NumberStyles.HexNumber);
236	sNodeid = true;	236	sNodeid = true;
237	} catch {	237	} catch {
238	if (DEBUG_LEVEL>0) { Console.WriteLine("nodeadress parse error 1"); }	238	if (DEBUG_LEVEL>0) { Console.WriteLine("nodeadress parse error 1"); }
239	return false;	239	return false;
240	}	240	}
241	} else if (node.Length == 4) {	241	} else if (node.Length == 4) {
-		242	try {
-		243	nodeid = byte.Parse(node.Substring(2, 2), System.Globalization.NumberStyles.HexNumber);
-		244	sNodeid = true;
-		245	} catch {
-		246	if (DEBUG_LEVEL>0) { Console.WriteLine("nodeadress parse error 2"); }
-		247	return false;
-		248	}
-		249	} else if (node.Length > 4) {
242	try {	250	try {
243	nodeid = byte.Parse(node.Substring(2, 2), System.Globalization.NumberStyles.HexNumber);	251	nodeid = byte.Parse(node.Substring(2, 2), System.Globalization.NumberStyles.HexNumber);
244	sNodeid = true;	252	sNodeid = true;
245	} catch {	253	} catch {
246	if (DEBUG_LEVEL>0) { Console.WriteLine("nodeadress parse error 2"); }	254	if (DEBUG_LEVEL>0) { Console.WriteLine("nodeadress parse error 2"); }
247	return false;	255	return false;
248	}	256	}
249	} else {	257	} else {
250	if (DEBUG_LEVEL>0) { Console.WriteLine("nodeadress parse error 3"); }	258	if (DEBUG_LEVEL>0) { Console.WriteLine("nodeadress parse error 3"); }
251	return false;	259	return false;
252	}	260	}
253	}	261	}
254	}	262	}
255		263
256	return true;	264	return true;
257	}	265	}
258		266
259	static private bool parseInput(string instr) {	267	static private bool parseInput(string instr) {
260	//parse commands entered on std in	268	//parse commands entered on std in
261	if (instr.Equals("reset")) { //reset command, send a reset to current node	269	if (instr.Equals("reset")) { //reset command, send a reset to current node
262	if (sNodeid) {	270	if (sNodeid) {
263	dc.flushData();	271	dc.flushData();
264	CanNMT cpn = new CanNMT();	272	CanNMT cpn = new CanNMT();
265	cpn.doReset(dc, nodeid);	273	cpn.doReset(dc, nodeid);
266	} else {	274	} else {
267	if (DEBUG_LEVEL>0) { Console.WriteLine("No nodeid has been specified"); }	275	if (DEBUG_LEVEL>0) { Console.WriteLine("No nodeid has been specified"); }
268	}	276	}
269	}	277	}
270	else if (instr.Equals("start")) { //start command, send a start to current node	278	else if (instr.Equals("start")) { //start command, send a start to current node
271	if (sNodeid) {	279	if (sNodeid) {
272	CanNMT cpn = new CanNMT();	280	CanNMT cpn = new CanNMT();
273	cpn.doStart(dc, nodeid);	281	cpn.doStart(dc, nodeid);
274	} else {	282	} else {
275	if (DEBUG_LEVEL>0) { Console.WriteLine("No nodeid has been specified"); }	283	if (DEBUG_LEVEL>0) { Console.WriteLine("No nodeid has been specified"); }
276	}	284	}
277	}	285	}
278	else if (instr.StartsWith("go")) { //downloading command	286	else if (instr.StartsWith("go")) { //downloading command
279	bool dlBios = false;	287	bool dlBios = false;
280	bool error = true;	288	bool error = true;
281	if (instr.Equals("go bios")) { //if bios should be downloaded	289	if (instr.Equals("go bios")) { //if bios should be downloaded
282	dlBios = true;	290	dlBios = true;
283	error = false;	291	error = false;
284	} else if (instr.Equals("go")) { //is an application should be downloaded	292	} else if (instr.Equals("go")) { //is an application should be downloaded
285	error = false;	293	error = false;
286	}	294	}
287		295
288	if (!sNodeid) {	296	if (!sNodeid) {
289	if (DEBUG_LEVEL>0) { Console.WriteLine("No nodeid has been specified"); }	297	if (DEBUG_LEVEL>0) { Console.WriteLine("No nodeid has been specified"); }
290	error = true;	298	error = true;
291	}	299	}
292	if (!sHexfile) {	300	if (!sHexfile) {
293	if (DEBUG_LEVEL>0) { Console.WriteLine("No hexfile has been specified"); }	301	if (DEBUG_LEVEL>0) { Console.WriteLine("No hexfile has been specified"); }
294	error = true;	302	error = true;
295	}	303	}
296		304
297	CanNMT cpn = new CanNMT();	305	CanNMT cpn = new CanNMT();
298	if (!error && aReset) { //commandline arguments specified that a reset should be done before download	306	if (!error && aReset) { //commandline arguments specified that a reset should be done before download
299	//send a reset command (and wait for feedback)	307	//send a reset command (and wait for feedback)
300	if (!cpn.doReset(dc, nodeid)) {	308	if (!cpn.doReset(dc, nodeid)) {
301	if (DEBUG_LEVEL>0) { Console.WriteLine("Target node did not respond to reset"); }	309	if (DEBUG_LEVEL>0) { Console.WriteLine("Target node did not respond to reset"); }
302	error = true;	310	error = true;
303	}	311	}
304	}	312	}
305		313
306	if (!error) {	314	if (!error) {
307	//send application	315	//send application
308	dc.flushData();	316	dc.flushData();
309	dl = new Downloader(hf, dc, nodeid, dlBios);	317	dl = new Downloader(hf, dc, nodeid, dlBios);
310	if (!dl.go()) {	318	if (!dl.go()) {
311	if (DEBUG_LEVEL>0) { Console.WriteLine("Error occured during download"); }	319	if (DEBUG_LEVEL>0) { Console.WriteLine("Error occured during download"); }
312	error = true;	320	error = true;
313	}	321	}
314	}	322	}
315		323
316	if (!error && aStart) { //commandline arguments specified that a start should be done after download	324	if (!error && aStart) { //commandline arguments specified that a start should be done after download
317	//start applikation	325	//start applikation
318	cpn.doStart(dc, nodeid);	326	cpn.doStart(dc, nodeid);
319	}	327	}
320		328
321	}	329	}
322	else if (instr.StartsWith("load")) { //load hexfile or reload current hexfile	330	else if (instr.StartsWith("load")) { //load hexfile or reload current hexfile
323	if (instr.Length > 5) {	331	if (instr.Length > 5) {
324	//second argument is a hexfile, this file should be loaded	332	//second argument is a hexfile, this file should be loaded
325	hexfile = instr.Substring(5);	333	hexfile = instr.Substring(5);
326	if (hf.loadHex(hexfile)) {	334	if (hf.loadHex(hexfile)) {
327	sHexfile = true;	335	sHexfile = true;
328	if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile loaded"); }	336	if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile loaded"); }
329	} else {	337	} else {
330	if (DEBUG_LEVEL>0) { Console.WriteLine("Hexfile could not be loaded"); }	338	if (DEBUG_LEVEL>0) { Console.WriteLine("Hexfile could not be loaded"); }
331	}	339	}
332	} else {	340	} else {
333	//reload current hexfile. if a hexfile already has been specified	341	//reload current hexfile. if a hexfile already has been specified
334	if (sHexfile) {	342	if (sHexfile) {
335	if (hf.loadHex(hexfile)) {	343	if (hf.loadHex(hexfile)) {
336	if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile reloaded"); }	344	if (DEBUG_LEVEL>1) { Console.WriteLine("Hexfile reloaded"); }
337	} else {	345	} else {
338	if (DEBUG_LEVEL>0) { Console.WriteLine("Hexfile could not be reloaded"); }	346	if (DEBUG_LEVEL>0) { Console.WriteLine("Hexfile could not be reloaded"); }
339	}	347	}
340	} else {	348	} else {
341	if (DEBUG_LEVEL>0) { Console.WriteLine("No hexfile has been specified"); }	349	if (DEBUG_LEVEL>0) { Console.WriteLine("No hexfile has been specified"); }
342	}	350	}
343		351
344	}	352	}
345	}	353	}
346	else if (instr.StartsWith("node")) {	354	else if (instr.StartsWith("node")) {
347	//change nodeid	355	//change nodeid
348	if (instr.Length > 5) {	356	if (instr.Length > 5) {
349	//second argument is nodeid	357	//second argument is nodeid
350	string node = instr.Substring(5);	358	string node = instr.Substring(5);
351	parseNodeId(node);	359	parseNodeId(node);
352	}	360	}
353	if (DEBUG_LEVEL>1) { Console.WriteLine("NodeId is 0x"+ String.Format("{0:x2}", nodeid)); }	361	if (DEBUG_LEVEL>1) { Console.WriteLine("NodeId is 0x"+ String.Format("{0:x2}", nodeid)); }
354	}	362	}
355	else if (instr.Equals("help")) {	363	else if (instr.Equals("help")) {
356	printHelp();	364	printHelp();
357	}	365	}
358	else if (instr.Equals("exit") \|\| instr.Equals("quit") \|\| instr.Equals("q")) {	366	else if (instr.Equals("exit") \|\| instr.Equals("quit") \|\| instr.Equals("q")) {
359	return false;	367	return false;
360	}	368	}
361	else {	369	else {
362	Console.WriteLine("Unknown command.");	370	Console.WriteLine("Unknown command.");
363	}	371	}
364		372
365	return true;	373	return true;
366	}	374	}
367		375
368	}	376	}
369		377

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/canDude/Source/Program.cs – Rev 586 → 655