Subversion Repositories HomeAutomation

Rev

Rev 655 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | SVN | RSS feed

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