001package jmri.jmrix.cmri.serial.diagnostic; 002 003import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; 004import java.awt.Container; 005import java.awt.Dimension; 006import java.awt.FlowLayout; 007import java.awt.event.ActionEvent; 008import java.awt.event.ActionListener; 009import javax.swing.BorderFactory; 010import javax.swing.BoxLayout; 011import javax.swing.JComboBox; 012import javax.swing.JLabel; 013import javax.swing.JPanel; 014import javax.swing.Timer; 015import javax.swing.border.Border; 016import jmri.util.StringUtil; 017 018import jmri.jmrix.cmri.CMRISystemConnectionMemo; 019import jmri.jmrix.cmri.serial.SerialMessage; 020import jmri.jmrix.cmri.serial.SerialNode; 021import jmri.jmrix.cmri.serial.SerialReply; 022import jmri.jmrix.cmri.serial.SerialTrafficController; 023 024/** 025 * Frame for running CMRI diagnostics 026 * 027 * @author Dave Duchamp Copyright (C) 2004 028 * @author Chuck Catania Copyright (C) 2018 029 */ 030public class DiagnosticFrame extends jmri.util.JmriJFrame implements jmri.jmrix.cmri.serial.SerialListener { 031 protected int numTestNodes = 0; 032 protected SerialNode[] testNodes = new SerialNode[128]; // Node control blocks 033 protected int[] testNodeAddresses = new int[128]; // ua's of loaded nodes 034 035 protected SerialNode testNode = null; // current node under test 036 public int testNodeAddr = 0; // Address (ua) of selected Node 037 protected String testNodeID = "x"; // text address of selected Node 038 protected int testNodeType = 0; // Test node type e.g SMINI 039 040 JComboBox<String> nodeSelBox = new JComboBox<>(); 041 JComboBox<String> testSelectBox = new JComboBox<>(); 042 043 // member declarations 044 public static final int testType_Outputs = 0, // Write bit pattern to ports 045 testType_Wraparound = 1, // Write bit pattern to port, read and compare bit pattern. Needs loopback cable 046 testType_SendCommand= 2, // Poll node to check for presence, read inputs 047 testType_WriteBytes = 3; // Transmit output byte pattern 048 049 protected int selTestType = testType_Outputs; // Current test suite 050 protected boolean outTest = true; 051 protected boolean wrapTest = false; 052 protected boolean isSMINI = false; 053 protected boolean isUSIC_SUSIC = true; 054 protected boolean isCPNODE = false; 055 // Here add other node types 056 protected int numOutputCards = 2; 057 protected int numInputCards = 1; 058 protected int numCards = 3; 059 protected int numIOXInputCards = 0; 060 protected int numIOXOutputCards= 0; 061 062// protected int ua = 0; // node address 063// protected SerialNode node; 064 protected int outCardNum = 0; 065 protected int obsDelay = 500; 066 protected int inCardNum = 2; 067 protected int filterDelay = 0; 068 // Test running variables 069 protected boolean testRunning = false; 070 protected boolean testSuspended = false; // true when Wraparound is suspended by error 071 protected byte[] outBytes = new byte[256]; 072 protected int curOutByte = 0; // current output byte in output test 073 protected int curOutBit = 0; // current on bit in current output byte in output test 074 protected short curOutValue = 0; // current ofoutput byte in wraparound test 075 protected int nOutBytes = 6; // number of output bytes for all cards of this node 076 protected int begOutByte = 0; // numbering from zero, subscript in outBytes 077 protected int endOutByte = 2; 078 protected int totalOutBytes= 0; 079 protected int portsPerCard = 0; 080 protected byte[] inBytes = new byte[256]; 081 protected byte[] wrapBytes = new byte[4]; 082 protected int nInBytes = 3; // number of input bytes for all cards of this node 083 protected int begInByte = 0; // numbering from zero, subscript in inBytes 084 protected int replyCount= 0; // number of bytes received from a poll 085 086 @SuppressFBWarnings(value = "IS2_INCONSISTENT_SYNC", justification = "unsync access only during initialization") 087 protected int endInByte = 2; 088 089 protected int numErrors = 0; 090 protected int numIterations = 0; 091 protected javax.swing.Timer outTimer; 092 protected javax.swing.Timer wrapTimer; 093 protected javax.swing.Timer pollTimer; 094 095 @SuppressFBWarnings(value = "IS2_INCONSISTENT_SYNC", justification = "unsync access only during initialization") 096 protected boolean waitingOnInput = false; 097 protected boolean waitingResponse = false; 098 099 protected boolean needInputTest = false; 100 protected int count = 20; 101 int debugCount = 0; 102 javax.swing.ButtonGroup testGroup = new javax.swing.ButtonGroup(); 103 javax.swing.JCheckBox invertOutButton = new javax.swing.JCheckBox(Bundle.getMessage("ButtonInvert"), false); 104 javax.swing.JCheckBox invertWrapButton = new javax.swing.JCheckBox(Bundle.getMessage("ButtonInvert"), false); 105 javax.swing.JCheckBox invertWriteButton = new javax.swing.JCheckBox(Bundle.getMessage("ButtonInvert"), false); 106 107 javax.swing.JButton initButton = new javax.swing.JButton(Bundle.getMessage("ButtonInitializeNode")); 108 javax.swing.JButton pollButton = new javax.swing.JButton(Bundle.getMessage("ButtonPollNode")); 109 javax.swing.JButton writeButton = new javax.swing.JButton(Bundle.getMessage("ButtonWriteBytes")); 110 javax.swing.JButton haltPollButton = new javax.swing.JButton("Halt Polling" ); 111 112 javax.swing.JTextField uaAddrField = new javax.swing.JTextField(3); 113 javax.swing.JTextField outCardField = new javax.swing.JTextField(3); 114 javax.swing.JTextField inCardField = new javax.swing.JTextField(3); 115 javax.swing.JTextField obsDelayField = new javax.swing.JTextField(5); 116 javax.swing.JTextField filterDelayField = new javax.swing.JTextField(5); 117 javax.swing.JTextField writeCardField = new javax.swing.JTextField(3); 118 javax.swing.JTextField writeBytesField = new javax.swing.JTextField(9); 119 120 javax.swing.JButton runButton = new javax.swing.JButton(Bundle.getMessage("ButtonRun")); 121 javax.swing.JButton stopButton = new javax.swing.JButton(Bundle.getMessage("ButtonStop")); 122 javax.swing.JButton continueButton = new javax.swing.JButton(Bundle.getMessage("ButtonContinue")); 123 124 javax.swing.JLabel nodeText1 = new javax.swing.JLabel(); 125 javax.swing.JLabel nodeText2 = new javax.swing.JLabel(); 126 javax.swing.JLabel testReqEquip = new javax.swing.JLabel(Bundle.getMessage("NeededEquipmentTitle")); 127 javax.swing.JLabel testEquip = new javax.swing.JLabel(); 128 javax.swing.JLabel nodeReplyLabel = new javax.swing.JLabel(Bundle.getMessage("NodeReplyLabel")); 129 javax.swing.JLabel nodeReplyText = new javax.swing.JLabel(); 130 javax.swing.JLabel writeCardLabel = new javax.swing.JLabel("Out Card:"); 131 javax.swing.JLabel writeBytesLabel = new javax.swing.JLabel("Output Bytes (Hex):"); 132 133 javax.swing.JLabel statusText1 = new javax.swing.JLabel(); 134 javax.swing.JLabel statusText2 = new javax.swing.JLabel(); 135 javax.swing.JLabel compareErr = new javax.swing.JLabel(); 136 137 DiagnosticFrame curFrame; 138 139 private CMRISystemConnectionMemo _memo = null; 140 141 public DiagnosticFrame(CMRISystemConnectionMemo memo) { 142 super(); 143 curFrame = this; 144 _memo=memo; 145 } 146 147 /** 148 * {@inheritDoc} 149 */ 150 @Override 151 public void initComponents() { 152 153 initializeNodes(); 154 nodeSelBox.setEditable(false); 155 if (numTestNodes > 0) { 156 nodeSelBox.addActionListener(new ActionListener() { 157 @Override 158 public void actionPerformed(ActionEvent event) { 159 displayNodeInfo((String) nodeSelBox.getSelectedItem()); 160 } 161 }); 162 } 163 164 // set the frame's initial state 165 setTitle(Bundle.getMessage("DiagnosticTitle") + Bundle.getMessage("WindowConnectionMemo") + _memo.getUserName()); // NOI18N 166 setSize(500, 200); 167 Container contentPane = getContentPane(); 168 contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS)); 169 170 // Test node information 171 //---------------------- 172 JPanel panelNode = new JPanel(); 173 panelNode.setLayout(new BoxLayout(panelNode, BoxLayout.Y_AXIS)); 174 JPanel panelNode1 = new JPanel(); 175 panelNode1.setLayout(new FlowLayout()); 176 panelNode1.add(new JLabel(Bundle.getMessage("LabelNodeAddress"))); 177 panelNode1.add(nodeSelBox); 178 nodeSelBox.setToolTipText(Bundle.getMessage("SelectNodeAddressTip")); 179 panelNode1.add(nodeText1); 180 nodeText1.setText("Node Type/Card Size"); 181 panelNode.add(panelNode1); 182 183 JPanel panelNode2 = new JPanel(); 184 panelNode2.setLayout(new FlowLayout()); 185 nodeText2.setText("Ins and Outs"); 186 panelNode2.add(nodeText2); 187 panelNode.add(panelNode2); 188 189 Border panelNodeBorder = BorderFactory.createEtchedBorder(); 190 Border panelNodeTitled = BorderFactory.createTitledBorder(panelNodeBorder, Bundle.getMessage("TestNodeTitle")); 191 panelNode.setBorder(panelNodeTitled); 192 contentPane.add(panelNode); 193 194 // Set up the test suite buttons 195 //------------------------------ 196 JPanel panelTest = new JPanel(); 197 panelTest.setLayout(new BoxLayout(panelTest, BoxLayout.Y_AXIS)); 198 JPanel panelTest1 = new JPanel(); 199 panelTest1.setLayout(new FlowLayout(FlowLayout.LEADING)); 200 testSelectBox.addItem(Bundle.getMessage("ButtonTestOutput")); 201 testSelectBox.addItem(Bundle.getMessage("ButtonTestLoopback")); 202 testSelectBox.addItem(Bundle.getMessage("ButtonTestSendCommands")); 203 panelTest1.add(testSelectBox); 204 testSelectBox.setToolTipText(Bundle.getMessage("TestTypeToolLabel")); 205 206 // -------------------------- 207 // Set up Halt Polling button 208 // -------------------------- 209 haltPollButton.setVisible(true); 210 haltPollButton.setToolTipText(Bundle.getMessage("HaltPollButtonTip")); 211 haltPollButton.addActionListener(new java.awt.event.ActionListener() { 212 @Override 213 public void actionPerformed(java.awt.event.ActionEvent e) { 214 haltpollButtonActionPerformed(); 215 } 216 }); 217 panelTest1.add(haltPollButton); 218 SerialTrafficController stc = _memo.getTrafficController(); 219 if (stc.getPollNetwork()) { 220 haltPollButton.setText(Bundle.getMessage("HaltPollButtonText")); 221 } else { 222 haltPollButton.setText(Bundle.getMessage("ResumePollButtonText")); 223 } 224 225 panelTest.add(panelTest1); 226 227 JPanel panel11 = new JPanel(); 228 panel11.setLayout(new FlowLayout(FlowLayout.LEFT)); 229 testReqEquip.setText(Bundle.getMessage("NeededEquipmentTitle")); 230 panel11.add(testReqEquip); 231 panel11.add(testEquip); 232 testEquip.setToolTipText(Bundle.getMessage("NeededTestEquipmentTip")); 233 panelTest.add(panel11); 234 235 Border panel1Border = BorderFactory.createEtchedBorder(); 236 Border panel1Titled = BorderFactory.createTitledBorder(panel1Border, Bundle.getMessage("TestTypeTitle")); 237 panelTest.setBorder(panel1Titled); 238 contentPane.add(panelTest); 239 240 // Set up the test setup panel 241 // There are multiple panes depending upon which test type is selected 242 //-------------------------------------------------------------------- 243 JPanel panel2 = new JPanel(); 244 panel2.setLayout(new BoxLayout(panel2, BoxLayout.Y_AXIS)); 245 246 // Panel for the Output test suite 247 JPanel panel21 = new JPanel(); 248 panel21.setLayout(new FlowLayout()); 249 panel21.add(new JLabel(" " + Bundle.getMessage("OutCardLabel"))); 250 panel21.add(outCardField); 251 outCardField.setToolTipText(Bundle.getMessage("OutCardToolTip")); 252 outCardField.setText("0"); 253 panel21.add(invertOutButton); 254 invertOutButton.setToolTipText(Bundle.getMessage("InvertToolTip")); 255 panel21.add(new JLabel(" " + Bundle.getMessage("ObservationDelayLabel"))); 256 panel21.add(obsDelayField); 257 obsDelayField.setToolTipText(Bundle.getMessage("ObservationDelayToolTip")); 258 obsDelayField.setText(Integer.toString(obsDelay)); 259 260 // Panel for the Loopback test 261 JPanel panel22 = new JPanel(); 262 panel22.setLayout(new FlowLayout()); 263 panel22.add(new JLabel(Bundle.getMessage("InCardToolLabel"))); 264 panel22.add(inCardField); 265 panel22.add(invertWrapButton); 266 invertWrapButton.setToolTipText(Bundle.getMessage("InvertToolTip")); 267 inCardField.setToolTipText(Bundle.getMessage("InCardToolTip")); 268 inCardField.setText("2"); 269 panel22.add(new JLabel(" " + Bundle.getMessage("FilteringDelayLabel"))); 270 panel22.add(filterDelayField); 271 filterDelayField.setToolTipText(Bundle.getMessage("FilteringDelayToolTip")); 272 filterDelayField.setText("0"); 273 274 // Panel for the Node command packets 275 JPanel panel23 = new JPanel(); 276 panel23.setLayout(new FlowLayout(FlowLayout.LEFT)); 277 panel23.add(initButton); 278 initButton.addActionListener(new java.awt.event.ActionListener() { 279 @Override 280 public void actionPerformed(java.awt.event.ActionEvent e) { 281 sendInitalizePacket(); 282 } 283 }); 284 pollButton.addActionListener(new java.awt.event.ActionListener() { 285 @Override 286 public void actionPerformed(java.awt.event.ActionEvent e) { 287 pollButtonActionPerformed(e); 288 } 289 }); 290 291 JPanel panel23a = new JPanel(); 292 panel23a.setLayout(new FlowLayout(FlowLayout.LEFT)); 293 panel23a.add(pollButton); 294 panel23a.add(nodeReplyLabel); 295 panel23a.add(nodeReplyText); 296 297 JPanel panel24 = new JPanel(); 298 panel24.setLayout(new FlowLayout(FlowLayout.LEFT)); 299 panel24.add(writeButton); 300 writeButton.addActionListener(new java.awt.event.ActionListener() { 301 @Override 302 public void actionPerformed(java.awt.event.ActionEvent e) { 303 sendButtonActionPerformed(e); 304 } 305 }); 306 panel24.add(writeCardLabel); 307 panel24.add(writeCardField); 308 writeCardField.setText("0"); 309 panel24.add(invertWriteButton); 310 panel24.add(writeBytesLabel); 311 panel24.add(writeBytesField); 312 writeBytesField.setText("0"); 313 314 // Panel for the Poll node with inputs display 315 JPanel panel25 = new JPanel(); 316 panel25.setLayout(new FlowLayout()); 317 318 panel2.add(panel21); 319 320 panel2.add(panel22); 321 panel22.setVisible(false); 322 323 panel2.add(panel23); 324 panel23.setVisible(false); 325 panel2.add(panel23a); 326 panel23a.setVisible(false); 327 panel2.add(panel24); 328 panel24.setVisible(false); 329 330 panel2.add(panel25); 331 panel25.setVisible(false); 332 333 Border panel2Border = BorderFactory.createEtchedBorder(); 334 Border panel2Titled = BorderFactory.createTitledBorder(panel2Border, Bundle.getMessage("TestSetUpTitle")); 335 panel2.setBorder(panel2Titled); 336 contentPane.add(panel2); 337 338 // Add the button listeners to display the appropriate test options 339 //----------------------------------------------------------------- 340 testSelectBox.addActionListener(new ActionListener() { 341 @Override 342 public void actionPerformed(ActionEvent event) { 343 selTestType = testSelectBox.getSelectedIndex(); 344 switch (selTestType) { 345 case testType_Outputs: 346 testEquip.setText(Bundle.getMessage("OutputTestEquipment")); 347 panel21.setVisible(true); 348 panel22.setVisible(false); 349 panel23.setVisible(false); 350 panel23a.setVisible(false); 351 panel24.setVisible(false); 352 panel25.setVisible(false); 353 runButton.setEnabled(true); 354 stopButton.setEnabled(true); 355 continueButton.setVisible(false); 356 displayNodeInfo(testNodeID); 357 break; 358 case testType_Wraparound: 359 testEquip.setText(Bundle.getMessage("WrapTestEquipment")); 360 panel21.setVisible(true); 361 panel22.setVisible(true); 362 panel23.setVisible(false); 363 panel23a.setVisible(false); 364 panel24.setVisible(false); 365 panel25.setVisible(false); 366 invertOutButton.setVisible(false); 367 runButton.setEnabled(true); 368 stopButton.setEnabled(true); 369 continueButton.setVisible(true); 370 invertWrapButton.setSelected(testNodeType == SerialNode.CPNODE); 371 displayNodeInfo(testNodeID); 372 break; 373 case testType_SendCommand: 374 testEquip.setText(Bundle.getMessage("SendCommandEquipment")); 375 panel21.setVisible(false); 376 panel22.setVisible(false); 377 panel23.setVisible(true); 378 panel23a.setVisible(true); 379 panel24.setVisible(true); 380 panel25.setVisible(false); 381 runButton.setEnabled(false); 382 stopButton.setEnabled(false); 383 continueButton.setVisible(false); 384 displayNodeInfo(testNodeID); 385 break; 386 case testType_WriteBytes: 387 testEquip.setText(Bundle.getMessage("WriteBytesEquipment")); 388 panel21.setVisible(false); 389 panel22.setVisible(false); 390 panel23.setVisible(false); 391 panel23a.setVisible(false); 392 panel24.setVisible(false); 393 panel25.setVisible(true); 394 displayNodeInfo(testNodeID); 395 break; 396 default: 397 log.debug("default case in testSelectBox switch"); 398 } 399 } 400 }); 401 402 // Set up the status panel 403 //------------------------ 404 JPanel panel3 = new JPanel(); 405 panel3.setLayout(new BoxLayout(panel3, BoxLayout.Y_AXIS)); 406 407 JPanel panel31 = new JPanel(); 408 panel31.setLayout(new FlowLayout()); 409 statusText1.setText(Bundle.getMessage("StatusLine1")); 410 statusText1.setVisible(true); 411 statusText1.setMaximumSize(new Dimension(statusText1.getMaximumSize().width, 412 statusText1.getPreferredSize().height)); 413 panel31.add(statusText1); 414 415 JPanel panel32 = new JPanel(); 416 panel32.setLayout(new FlowLayout()); 417 statusText2.setText(Bundle.getMessage("StatusLine2", Bundle.getMessage("ButtonRun"))); 418 statusText2.setVisible(true); 419 statusText2.setMaximumSize(new Dimension(statusText2.getMaximumSize().width, 420 statusText2.getPreferredSize().height)); 421 panel32.add(statusText2); 422 423 JPanel panel33 = new JPanel(); 424 panel33.setLayout(new FlowLayout()); 425 compareErr.setText(" "); //Bundle.getMessage("StatusLine1")); 426 compareErr.setVisible(true); 427 compareErr.setMaximumSize(new Dimension(compareErr.getMaximumSize().width, 428 compareErr.getPreferredSize().height)); 429 panel33.add(compareErr); 430 431 panel3.add(panel31); 432 panel3.add(panel32); 433 panel3.add(panel33); 434 435 Border panel3Border = BorderFactory.createEtchedBorder(); 436 Border panel3Titled = BorderFactory.createTitledBorder(panel3Border, Bundle.getMessage("StatusTitle")); 437 panel3.setBorder(panel3Titled); 438 contentPane.add(panel3); 439 440 // Set up Continue, Stop, Run buttons 441 //----------------------------------- 442 JPanel panel4 = new JPanel(); 443 panel4.setLayout(new FlowLayout()); 444 continueButton.setText(Bundle.getMessage("ButtonContinue")); 445 continueButton.setVisible(false); 446 continueButton.setToolTipText(Bundle.getMessage("ContinueTestToolTip")); 447 continueButton.addActionListener(new java.awt.event.ActionListener() { 448 @Override 449 public void actionPerformed(java.awt.event.ActionEvent e) { 450 continueButtonActionPerformed(e); 451 } 452 }); 453 panel4.add(continueButton); 454 stopButton.setText(Bundle.getMessage("ButtonStop")); 455 stopButton.setVisible(true); 456 stopButton.setToolTipText(Bundle.getMessage("StopToolTip")); 457 panel4.add(stopButton); 458 stopButton.addActionListener(new java.awt.event.ActionListener() { 459 @Override 460 public void actionPerformed(java.awt.event.ActionEvent e) { 461 stopButtonActionPerformed(e); 462 } 463 }); 464 runButton.setText(Bundle.getMessage("ButtonRun")); 465 runButton.setVisible(true); 466 runButton.setToolTipText(Bundle.getMessage("RunTestToolTip")); 467 panel4.add(runButton); 468 runButton.addActionListener(new java.awt.event.ActionListener() { 469 @Override 470 public void actionPerformed(java.awt.event.ActionEvent e) { 471 runButtonActionPerformed(e); 472 } 473 }); 474 contentPane.add(panel4); 475 476 if (numTestNodes > 0) { 477 // initialize for the first time 478 displayNodeInfo((String) nodeSelBox.getSelectedItem()); 479 } 480 testSelectBox.setSelectedIndex(selTestType); 481 addHelpMenu("package.jmri.jmrix.cmri.serial.diagnostic.DiagnosticFrame", true); 482 483 // pack for display 484 pack(); 485 } 486 487 /** 488 * Initialize configured nodes and set up the node select combo box. 489 */ 490 public void initializeNodes() { 491 String str = ""; 492 // clear the arrays 493 for (int i = 0; i < 128; i++) { 494 testNodeAddresses[i] = -1; 495 testNodes[i] = null; 496 } 497 // get all configured nodes 498 SerialNode node = (SerialNode) _memo.getTrafficController().getNode(0); 499 int index = 1; 500 while (node != null) 501 { 502 testNodes[numTestNodes] = node; 503 testNodeAddresses[numTestNodes] = node.getNodeAddress(); 504 str = Integer.toString(testNodeAddresses[numTestNodes]); 505 nodeSelBox.addItem(str); 506 if (index == 1) { 507 testNode = node; 508 testNodeAddr = testNodeAddresses[numTestNodes]; 509 testNodeID = "y"; // to force first time initialization 510 } 511 numTestNodes++; 512 // go to next node 513 node = (SerialNode) _memo.getTrafficController().getNode(index); 514 index++; 515 } 516 } 517 518 /** 519 * Method to handle selection of a Node for info display. 520 * @param nodeID Node ID. 521 */ 522 public void displayNodeInfo(String nodeID) { 523 if (!nodeID.equals(testNodeID)) { 524 // The selected node is changing - initialize it 525 int aTestNum = Integer.parseInt(nodeID); 526 SerialNode s = null; 527 for (int k = 0; k < numTestNodes; k++) { 528 if (aTestNum == testNodeAddresses[k]) { 529 s = testNodes[k]; 530 } 531 } 532 if (s == null) { 533 // serious trouble, log error and ignore 534 log.error("Cannot find Node {} in list of configured Nodes.", nodeID); 535 return; 536 } 537 // have node, initialize for new node 538 testNodeID = nodeID; 539 testNode = s; 540 testNodeAddr = aTestNum; 541 // prepare the information line 542 int bitsPerCard = testNode.getNumBitsPerCard(); 543// int numInputCards = testNode.numInputCards(); 544// int numOutputCards = testNode.numOutputCards(); 545// int numIOXInputCards = 0; 546// int numIOXOutputCards= 0; 547 548 testNodeType = testNode.getNodeType(); 549 String s1 = "", 550 s2 = ""; 551 switch (testNodeType) 552 { 553 case SerialNode.SMINI: 554 bitsPerCard = testNode.getNumBitsPerCard(); 555 numInputCards = testNode.numInputCards(); 556 numOutputCards = testNode.numOutputCards(); 557 numIOXInputCards = 0; 558 numIOXOutputCards= 0; 559 560 nodeText1.setText(" SMINI - " + bitsPerCard + " " + Bundle.getMessage("BitsPerCard")); 561 nodeText2.setText(numInputCards + " " + Bundle.getMessage("InputCard") + 562 ", " + numOutputCards + " " + Bundle.getMessage("OutputCard") + "s"); 563 break; 564 case SerialNode.USIC_SUSIC: 565 bitsPerCard = testNode.getNumBitsPerCard(); 566 numInputCards = testNode.numInputCards(); 567 numOutputCards = testNode.numOutputCards(); 568 numIOXInputCards = 0; 569 numIOXOutputCards= 0; 570 if(numInputCards > 1) s1 = "s"; 571 if(numOutputCards > 1) s2 = "s"; 572 nodeText1.setText(" USIC_SUSIC - " + bitsPerCard + " " + Bundle.getMessage("BitsPerCard")); 573 nodeText2.setText(numInputCards + " " + Bundle.getMessage("InputCard") + s1 + 574 ", " + numOutputCards + " " + Bundle.getMessage("OutputCard") + s2); 575 break; 576 case SerialNode.CPNODE: 577 bitsPerCard = testNode.getNumBitsPerCard(); 578 numInputCards = testNode.numInputCards(); //2; 579 numOutputCards = testNode.numOutputCards(); //2; 580 numIOXInputCards = testNode.numInputCards() - 2; 581 numIOXOutputCards= testNode.numOutputCards()- 2; 582 if(numInputCards > 1) s1 = "s"; 583 if(numOutputCards > 1) s2 = "s"; 584 nodeText1.setText(" CPNODE - " + bitsPerCard + " " +Bundle.getMessage("BitsPerCard")); 585 nodeText2.setText(numInputCards + " " + Bundle.getMessage("InputCard") + s1 + 586 ", " + numOutputCards + " " + Bundle.getMessage("OutputCard") + s2 + 587 " IOX: " + numIOXInputCards + " " + Bundle.getMessage("InputsTitle") + 588 ", " + numIOXOutputCards + " " + Bundle.getMessage("OutputsTitle")); 589 invertWrapButton.setSelected(testNodeType == SerialNode.CPNODE); 590 break; 591 case SerialNode.CPMEGA: 592 numIOXInputCards = 0; 593 numIOXOutputCards= 0; 594 nodeText1.setText("CPMEGA - " + bitsPerCard + " " + Bundle.getMessage("BitsPerCard")); 595 break; 596 default: 597 nodeText1.setText("Unknown Node Type "+testNodeType); 598 break; 599 } 600// here insert code for new types of C/MRI nodes 601 } 602 statusText1.setVisible(true); 603 statusText2.setVisible(true); 604 605 } 606 607 /** 608 * Handle run button in Diagnostic Frame. 609 * @param e unused. 610 */ 611 public void runButtonActionPerformed(java.awt.event.ActionEvent e) { 612 // Ignore button if test is already running 613 if (!testRunning) { 614 // Read the user entered data, and report any errors 615 if (readSetupData()) { 616 if (outTest) { 617 // Initialize output test 618 if (initializeOutputTest()) { 619 // Run output test 620 runOutputTest(); 621 } 622 } else if (wrapTest) { 623 // Initialize wraparound test 624 if (initializeWraparoundTest()) { 625 // Run wraparound test 626 runWraparoundTest(); 627 } 628 } 629 } 630 } 631 } 632 633 /** 634 * Read data in Diagnostic Frame, get node data, and test 635 * for consistency. 636 * If errors are found, the errors are noted in the status panel 637 * of the Diagnostic Frame. 638 * 639 * @return 'true' if no errors are found, 'false' if errors are found 640 */ 641 protected boolean readSetupData() { 642 // determine test type 643// outTest = outputButton.isSelected(); 644// wrapTest = wrapButton.isSelected(); 645 switch(selTestType) 646 { 647 case testType_Outputs: 648 outTest = true; 649 wrapTest= false; 650 break; 651 case testType_Wraparound: 652 outTest = false; 653 wrapTest= true; 654 break; 655 case testType_SendCommand: 656 case testType_WriteBytes: 657 outTest = false; 658 wrapTest= false; 659 break; 660 default: 661 log.debug("default case in testSelectBox switch"); 662 } 663 664 // get the SerialNode corresponding to this node address 665 testNode = (SerialNode) _memo.getTrafficController().getNodeFromAddress(testNodeAddr); 666 if (testNode == null) { 667 statusText1.setText(Bundle.getMessage("DiagnosticError3")); 668 statusText1.setVisible(true); 669 return (false); 670 } 671 // determine if node is SMINI, USIC_SUSIC, or 672 int type = testNode.getNodeType(); 673 isSMINI = (type == SerialNode.SMINI); 674 isUSIC_SUSIC = (type == SerialNode.USIC_SUSIC); 675 isCPNODE = (type == SerialNode.CPNODE); 676 // Here insert code for other type nodes 677 // initialize numInputCards, numOutputCards, and numCards 678 numOutputCards = testNode.numOutputCards(); 679 numInputCards = testNode.numInputCards(); 680 numCards = numOutputCards + numInputCards; 681 682 // read setup data - Out Card field 683 try { 684 outCardNum = Integer.parseInt(outCardField.getText()); 685 } catch (Exception e) { 686 statusText1.setText(Bundle.getMessage("DiagnosticError4")); 687 statusText1.setVisible(true); 688 return (false); 689 } 690 // Check for consistency with Node definition 691 if (isUSIC_SUSIC) { 692 if ((outCardNum < 0) || (outCardNum >= numCards)) { 693 statusText1.setText(Bundle.getMessage("DiagnosticError5", Integer.toString(numCards - 1))); 694 statusText1.setVisible(true); 695 return (false); 696 } 697 if (!testNode.isOutputCard(outCardNum)) { 698 statusText1.setText(Bundle.getMessage("DiagnosticError6")); 699 statusText1.setVisible(true); 700 return (false); 701 } 702 } 703 if (isSMINI && ((outCardNum < 0) || (outCardNum > 1))) { 704 statusText1.setText(Bundle.getMessage("DiagnosticError7")); 705 statusText1.setVisible(true); 706 return (false); 707 } 708 if (isCPNODE && (!testNode.isOutputCard(outCardNum+2))) { 709 statusText1.setText(Bundle.getMessage("DiagnosticError6")); 710 statusText1.setVisible(true); 711 return (false); 712 } 713 714 if (outTest) { 715 // read setup data - Observation Delay field 716 try { 717 obsDelay = Integer.parseInt(obsDelayField.getText()); 718 } catch (Exception e) { 719 statusText1.setText(Bundle.getMessage("DiagnosticError8")); 720 statusText1.setVisible(true); 721 return (false); 722 } 723 } 724 725 if (wrapTest) { 726 // read setup data - In Card field 727 try { 728 inCardNum = Integer.parseInt(inCardField.getText()); 729 } catch (Exception e) { 730 statusText1.setText(Bundle.getMessage("DiagnosticError9")); 731 statusText1.setVisible(true); 732 return (false); 733 } 734 // Check for consistency with Node definition 735 if (isUSIC_SUSIC) { 736 if ((inCardNum < 0) || (inCardNum >= numCards)) { 737 statusText1.setText(Bundle.getMessage("DiagnosticError10", Integer.toString(numCards - 1))); 738 statusText1.setVisible(true); 739 return (false); 740 } 741 if (!testNode.isInputCard(inCardNum)) { 742 statusText1.setText(Bundle.getMessage("DiagnosticError11")); 743 statusText1.setVisible(true); 744 return (false); 745 } 746 } 747 if (isSMINI && (inCardNum != 2)) { 748 statusText1.setText(Bundle.getMessage("DiagnosticError12")); 749 statusText1.setVisible(true); 750 return (false); 751 } 752 753 // read setup data - Filtering Delay field 754 try { 755 filterDelay = Integer.parseInt(filterDelayField.getText()); 756 } catch (Exception e) { 757 statusText1.setText(Bundle.getMessage("DiagnosticError13")); 758 statusText1.setVisible(true); 759 return (false); 760 } 761 } 762 763 // complete initialization of output card 764 portsPerCard = (testNode.getNumBitsPerCard()) / 8; 765 766 if (testNodeType != SerialNode.CPNODE) 767 begOutByte = (testNode.getOutputCardIndex(outCardNum)) * portsPerCard; 768 else 769 begOutByte = (testNode.getOutputCardIndex(outCardNum+2)) * portsPerCard; 770 771 endOutByte = begOutByte + portsPerCard - 1; 772 nOutBytes = numOutputCards * portsPerCard; 773 774 // if wraparound test, complete initialization of the input card 775 if (wrapTest) { 776 begInByte = (testNode.getInputCardIndex(inCardNum)) * portsPerCard; 777 endInByte = begInByte + portsPerCard - 1; 778 nInBytes = numInputCards * portsPerCard; 779 } 780 return (true); 781 } 782 783 /** 784 * Handle continue button in Diagnostic Frame. 785 * @param e unused. 786 */ 787 public void continueButtonActionPerformed(java.awt.event.ActionEvent e) { 788 if (testRunning && testSuspended) { 789 testSuspended = false; 790 if (wrapTest) { 791 statusText1.setText(Bundle.getMessage("StatusRunningWraparoundTest")); 792 statusText1.setVisible(true); 793 } 794 } 795 } 796 797 /** 798 * Handle Stop button in Diagnostic Frame. 799 * @param e unused. 800 */ 801 public void stopButtonActionPerformed(java.awt.event.ActionEvent e) { 802 // Ignore button push if test is not running, else change flag 803 if (testRunning) { 804 if (outTest) { 805 stopOutputTest(); 806 } else if (wrapTest) { 807 stopWraparoundTest(); 808 } 809 testRunning = false; 810 } 811 } 812 813 /** 814 * Halt Poll button handler 815 * Polling should be halted when executing diagnostics so as not to 816 * interfere with the test sequences. 817 */ 818 public void haltpollButtonActionPerformed() { 819 SerialTrafficController stc = _memo.getTrafficController(); 820 stc.setPollNetwork(!stc.getPollNetwork()); 821 if (stc.getPollNetwork()) 822 haltPollButton.setText(Bundle.getMessage("HaltPollButtonText")); 823 else 824 haltPollButton.setText(Bundle.getMessage("ResumePollButtonText")); 825 } 826/** 827 * Initialize an Output Test. 828 * If errors are found, the errors are noted in the status panel of the Diagnostic Frame. 829 * 830 * @return 'true' if successfully initialized, 'false' if errors are found 831 * Added synchronized 832 */ 833 synchronized protected boolean initializeOutputTest() { 834 // clear all output bytes for this node 835 for (int i = 0; i < nOutBytes; i++) { 836 outBytes[i] = 0; 837 } 838 // check the entered delay--if too short an overrun could occur 839 // where the computer program is ahead of buffered serial output 840 if (obsDelay < 250) { 841 obsDelay = 250; 842 } 843 // Set up beginning LED on position 844 curOutByte = begOutByte; 845 curOutBit = 0; 846 // Send initialization message 847 _memo.getTrafficController().sendSerialMessage((SerialMessage) testNode.createInitPacket(), curFrame); 848 try { 849 // Wait for initialization to complete 850 wait(1000); 851 } catch (InterruptedException e) { 852 // means done 853 log.debug("interrupted"); 854 return false; 855 } 856 // Initialization was successful 857 numIterations = 0; 858 testRunning = true; 859 return true; 860 } 861 862 /** 863 * Run an Output Test. 864 */ 865 protected void runOutputTest() { 866 // Set up timer to update output pattern periodically 867 outTimer = new Timer(obsDelay, new ActionListener() { 868 @Override 869 public void actionPerformed(ActionEvent evnt) { 870 if (testRunning && outTest) { 871 int[] outBitPattern = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; 872 String[] portID = {"A", "B", "C", "D"}; 873 874 // set new pattern 875 // Invert bit polarity if selected (usefull for Common Anode LEDs) 876 if (invertOutButton.isSelected()) 877 for (int i=0; i<8; i++) { outBitPattern[i] = (~outBitPattern[i]); } 878 879 outBytes[curOutByte] = (byte) outBitPattern[curOutBit]; 880 // send new pattern 881 SerialMessage m = createOutPacket(); 882 m.setTimeout(50); 883 _memo.getTrafficController().sendSerialMessage(m, curFrame); 884 // update status panel to show bit that is on 885 statusText1.setText(Bundle.getMessage("StatusLine3", portID[curOutByte - begOutByte], Integer.toString(curOutBit))); 886 statusText1.setVisible(true); 887 StringBuilder st = new StringBuilder(); 888 for (int i = begOutByte; i <= endOutByte; i++) { 889 st.append(" "); 890 for (int j = 0; j < 8; j++) { 891 if ((i == curOutByte) && (j == curOutBit)) { 892 st.append("1 "); 893 } else { 894 st.append("0 "); 895 } 896 } 897 } 898 statusText2.setText(st.reverse().toString()); //statusText2 899 statusText2.setVisible(true); 900 // update bit pattern for next entry 901 curOutBit++; 902 if (curOutBit > 7) { 903 // Move to the next byte 904 curOutBit = 0; 905 outBytes[curOutByte] = 0; 906 curOutByte++; 907 if (curOutByte > endOutByte) { 908 // Pattern complete, recycle to first byte 909 curOutByte = begOutByte; 910 numIterations++; 911 } 912 } 913 } 914 } 915 }); 916 917 // start timer 918 outTimer.start(); 919 } 920 921 /** 922 * Stop an Output Test. 923 */ 924 protected void stopOutputTest() { 925 if (testRunning && outTest) { 926 // Stop the timer 927 outTimer.stop(); 928 // Update the status 929 statusText1.setText(Bundle.getMessage("StatusLine4", Integer.toString(numIterations))); 930 statusText1.setVisible(true); 931 statusText2.setText(" "); 932 statusText2.setVisible(true); 933 } 934 } 935 936 /** 937 * Transmit an Initialize message to the test node. 938 * 939 * @return 'true' if message sent successfully 940 */ 941 synchronized protected boolean sendInitalizePacket() { 942 // Send initialization message 943 _memo.getTrafficController().sendSerialMessage((SerialMessage) testNode.createInitPacket(), curFrame); 944 try { 945 // Wait for initialization to complete 946 wait(1000); 947 } catch (InterruptedException e) { 948 log.debug("interrupted"); 949 return false; 950 } 951 952 return true; 953 } 954 955 /** 956 * Initialize a Wraparound Test. 957 * If errors are found, the errors are noted in the status panel of the Diagnostic 958 * Frame. 959 * 960 * @return 'true' if successfully initialized, 'false' if errors are found 961 */ 962 synchronized protected boolean initializeWraparoundTest() { 963 // clear all output bytes for this node 964 for (int i = 0; i < nOutBytes; i++) { 965 outBytes[i] = 0; 966 } 967 // Set up beginning output values 968 curOutByte = begOutByte; 969 curOutValue = 0; 970 971 if (!sendInitalizePacket()) 972 return false; 973 974 // Clear error count 975 numErrors = 0; 976 numIterations = 0; 977 // Initialize running flags 978 testRunning = true; 979 testSuspended = false; 980 waitingOnInput = false; 981 needInputTest = false; 982 count = 50; 983 compareErr.setText(" "); 984 985 return true; 986 } 987 988 /** 989 * Run a Wraparound Test. 990 */ 991 protected void runWraparoundTest() { 992 // Display Status Message 993 statusText1.setText(Bundle.getMessage("StatusRunningWraparoundTest")); 994 statusText1.setVisible(true); 995 996 // Set up timer to update output pattern periodically 997 wrapTimer = new Timer(100, new ActionListener() { 998 @Override 999 public void actionPerformed(ActionEvent evnt) { 1000 if (testRunning && !testSuspended) { 1001 if (waitingOnInput) { 1002 count--; 1003 if (count == 0) { 1004 statusText2.setText(Bundle.getMessage("StatusLine5")); 1005 statusText2.setVisible(true); 1006 } 1007 } else { 1008 // compare input with previous output if needed 1009 if (needInputTest) { 1010 needInputTest = false; 1011 boolean comparisonError = false; 1012 // compare input and output bytes 1013 int j = 0; 1014 for (int i = begInByte; i <= endInByte; i++, j++) 1015 { 1016 if (invertWrapButton.isSelected()) { inBytes[i] = (byte) ~inBytes[j]; 1017 } 1018 1019 if (inBytes[i] != wrapBytes[j]) { 1020 comparisonError = true; 1021 } 1022 } 1023 if (comparisonError) { 1024 // report error and suspend test 1025 statusText1.setText(Bundle.getMessage("StatusLine6", 1026 Bundle.getMessage("ButtonStop"), Bundle.getMessage("ButtonContinue"))); 1027 statusText1.setVisible(true); 1028 StringBuilder st = new StringBuilder(Bundle.getMessage("StatusLine7pt1")); 1029 for (int i = begOutByte; i <= endOutByte; i++) { 1030 st.append(" "); 1031 st.append(Integer.toHexString((outBytes[i]) & 0x000000ff).toUpperCase()); 1032 } 1033 st.append(" "); // spacer 1034 st.append(Bundle.getMessage("StatusLine7pt2")); 1035 for (int i = begInByte; i <= endInByte; i++) { 1036 st.append(" "); 1037 st.append(Integer.toHexString((inBytes[i]) & 0x000000ff).toUpperCase()); 1038 } 1039 compareErr.setText(st.toString()); //statusText2 1040 compareErr.setVisible(true); 1041 numErrors++; 1042 testSuspended = true; 1043 return; 1044 } 1045 } 1046 1047 // send next output pattern 1048 outBytes[curOutByte] = (byte) curOutValue; 1049 if (isSMINI) { 1050 // If SMINI, send same pattern to both output cards 1051 if (curOutByte > 2) { 1052 outBytes[curOutByte - 3] = (byte) curOutValue; 1053 } else { 1054 outBytes[curOutByte + 3] = (byte) curOutValue; 1055 } 1056 } 1057 SerialMessage m = createOutPacket(); 1058 // wait for signal to settle down if filter delay 1059 m.setTimeout(50 + filterDelay); 1060 _memo.getTrafficController().sendSerialMessage(m, curFrame); 1061 1062 // update Status area 1063 short[] outBitPattern = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; 1064 String[] portID = {"A", "B", "C", "D"}; 1065 StringBuilder st = new StringBuilder(Bundle.getMessage("PortLabel")); 1066 StringBuilder bp = new StringBuilder(" "); 1067 st.append(portID[curOutByte - begOutByte]); 1068 st.append(", "); 1069 st.append(Bundle.getMessage("PatternLabel")); 1070 for (int j = 0; j < 8; j++) { 1071 if ((curOutValue & outBitPattern[j]) != 0) { 1072 bp.append("1 "); 1073 } else { 1074 bp.append("0 "); 1075 } 1076 } 1077 // Reverse the displayed output string to put bit zero on the right 1078 //----------------------------------------------------------------- 1079 statusText2.setText(st.toString()+bp.reverse().toString()); //statusText2 1080 statusText2.setVisible(true); 1081 1082 // set up for testing input returned 1083 int k = 0; 1084 for (int i = begOutByte; i <= endOutByte; i++, k++) { 1085 wrapBytes[k] = outBytes[i]; 1086 } 1087 waitingOnInput = true; 1088 needInputTest = true; 1089 count = 50; 1090 // send poll 1091 _memo.getTrafficController().sendSerialMessage( 1092 SerialMessage.getPoll(testNodeAddr), curFrame); 1093 1094 // update output pattern for next entry 1095 curOutValue++; 1096 if (curOutValue > 255) { 1097 // Move to the next byte 1098 curOutValue = 0; 1099 outBytes[curOutByte] = 0; 1100 if (isSMINI) { 1101 // If SMINI, clear ports of both output cards 1102 if (curOutByte > 2) { 1103 outBytes[curOutByte - 3] = 0; 1104 } else { 1105 outBytes[curOutByte + 3] = 0; 1106 } 1107 } 1108 curOutByte++; 1109 if (curOutByte > endOutByte) { 1110 // Pattern complete, recycle to first port (byte) 1111 curOutByte = begOutByte; 1112 numIterations++; 1113 } 1114 } 1115 } 1116 } 1117 } 1118 }); 1119 1120 // start timer 1121 wrapTimer.start(); 1122 } 1123 1124 /** 1125 * Stop a Wraparound Test. 1126 */ 1127 protected void stopWraparoundTest() { 1128 if (testRunning && wrapTest) { 1129 // Stop the timer 1130 wrapTimer.stop(); 1131 // Update the status 1132 statusText1.setText(Bundle.getMessage("StatusLine8", Integer.toString(numErrors))); 1133 statusText1.setVisible(true); 1134 statusText2.setText(Bundle.getMessage("StatusLine9", Integer.toString(numIterations))); 1135 statusText2.setVisible(true); 1136 } 1137 } 1138 1139 /** 1140 * Create an Transmit packet (SerialMessage). 1141 * @return loaded packet to transmit 1142 */ 1143 SerialMessage createOutPacket() { 1144 // Count the number of DLE's to be inserted 1145 int nDLE = 0; 1146 for (int i = 0; i < nOutBytes; i++) { 1147 if ((outBytes[i] == 2) || (outBytes[i] == 3) || (outBytes[i] == 16)) { 1148 nDLE++; 1149 } 1150 } 1151 // Create a Serial message and add initial bytes 1152 SerialMessage m = new SerialMessage(nOutBytes + nDLE + 2); 1153 m.setElement(0, testNodeAddr + 65); // node address 1154 m.setElement(1, 84); // 'T' 1155 // Add output bytes 1156 int k = 2; 1157 for (int i = 0; i < nOutBytes; i++) { 1158 // perform C/MRI required DLE processing 1159 if ((outBytes[i] == 2) || (outBytes[i] == 3) || (outBytes[i] == 16)) { 1160 m.setElement(k, 16); // DLE 1161 k++; 1162 } 1163 // add output byte 1164 m.setElement(k, outBytes[i]); 1165 k++; 1166 } 1167 return m; 1168 } 1169 1170 /** 1171 * Handle poll node button in Diagnostic Frame. 1172 * @param e unused. 1173 */ 1174 public synchronized void pollButtonActionPerformed(java.awt.event.ActionEvent e) { 1175 portsPerCard = (testNode.getNumBitsPerCard()) / 8; 1176 begInByte = (testNode.getInputCardIndex(inCardNum)) * portsPerCard; 1177 endInByte = begInByte + portsPerCard; 1178 nInBytes = numInputCards * portsPerCard; 1179 1180 needInputTest = true; 1181 waitingOnInput = true; 1182 waitingResponse = false; 1183 count = 30; 1184 1185 // send poll 1186 _memo.getTrafficController().sendSerialMessage(SerialMessage.getPoll(testNodeAddr), curFrame); 1187 statusText2.setText(""); 1188 nodeReplyText.setText(""); 1189 1190 // display input data bytes or timeout 1191 pollNodeReadReply(); 1192 } 1193 1194 1195 /** 1196 * Run a Poll/Response Test. 1197 * Returns number of bytes read or a timeout 1198 */ 1199 protected synchronized void pollNodeReadReply() { 1200 // Set up timer to poll the node and report data or a timeout 1201 pollTimer = new Timer(100, new ActionListener() { 1202 @Override 1203 public void actionPerformed(ActionEvent evnt) { 1204 if (waitingOnInput) { 1205 count--; 1206 if (count == 0) { 1207 nodeReplyText.setText(Bundle.getMessage("PollTimeOut")); 1208 waitingOnInput = false; 1209 pollTimer.stop(); 1210 return; 1211 } 1212 } 1213 else 1214 { 1215 if (waitingResponse) 1216 { 1217 nodeReplyText.setText(Bundle.getMessage("InByteCount",replyCount)); 1218 nodeReplyText.setVisible(true); 1219 waitingOnInput = false; 1220 pollTimer.stop(); 1221 return; 1222 } 1223 } 1224 } 1225 }); 1226 1227 // start timer 1228 pollTimer.start(); 1229 waitingResponse = true; 1230 } 1231 1232 /** 1233 * Transmit bytes to selected output card starting with out card number 1234 * for number of bytes entered. 1235 * If inverted checked, data is flipped. 1236 * @param e unused. 1237 */ 1238 public synchronized void sendButtonActionPerformed(java.awt.event.ActionEvent e) { 1239 1240 portsPerCard = (testNode.getNumBitsPerCard()) / 8; 1241 byte b[] = StringUtil.bytesFromHexString(writeBytesField.getText()); 1242 totalOutBytes = (numOutputCards*portsPerCard); 1243 statusText1.setText(" "); 1244 1245 // Validate number of bytes entered 1246 if (b.length == 0) { 1247 statusText1.setText(Bundle.getMessage("WriteBytesError1")); 1248 return; 1249 } 1250 if (b.length > portsPerCard) { 1251 statusText1.setText(Bundle.getMessage("WriteBytesError2",portsPerCard)); 1252 return; 1253 } 1254 outCardNum = Integer.parseInt(writeCardField.getText()); 1255 1256 if (testNodeType != SerialNode.CPNODE) 1257 { 1258 if (!testNode.isOutputCard(outCardNum)) { 1259 statusText1.setText(Bundle.getMessage("DiagnosticError6")); 1260 return; 1261 } 1262 begOutByte = (testNode.getOutputCardIndex(outCardNum)) * portsPerCard; 1263 } 1264 else 1265 { 1266 if (!testNode.isOutputCard(outCardNum+2)) { 1267 statusText1.setText(Bundle.getMessage("DiagnosticError6")); 1268 return; 1269 } 1270 begOutByte = (testNode.getOutputCardIndex(outCardNum+2)) * portsPerCard; 1271 } 1272 // Zero the output buffer 1273 int zero = (invertWriteButton.isSelected()) ? -1:0; 1274 1275 for (int i=0; i<totalOutBytes; i++) 1276 { 1277 outBytes[i] = (byte) zero; 1278 } 1279 1280 int j=begOutByte; 1281 for (int i=0; i<portsPerCard; i++) 1282 { 1283 outBytes[j] = (invertWriteButton.isSelected()) ? (byte) ~b[i]: (byte) b[i]; 1284 j++; 1285 } 1286 nOutBytes = totalOutBytes; 1287 1288 SerialMessage m = createOutPacket(); 1289 m.setTimeout(50); 1290 _memo.getTrafficController().sendSerialMessage(m, curFrame); 1291 } 1292 1293 /** 1294 * {@inheritDoc} 1295 */ 1296 @Override 1297 public void message(SerialMessage m) { 1298 } // Ignore for now 1299 1300 /** 1301 * Reply notification implementing SerialListener interface 1302 */ 1303 @Override 1304 public synchronized void reply(SerialReply l) { 1305 // Test if waiting on this input 1306 if (waitingOnInput && (l.isRcv()) && (testNodeAddr == l.getUA())) { 1307 // This is a receive message for the node being tested 1308 for (int i = begInByte; i <= endInByte; i++) { 1309 // get data bytes, skipping over node address and 'R' 1310 inBytes[i] = (byte) l.getElement(i + 2); 1311 } 1312 replyCount = (l.getNumDataElements()-2); 1313 1314 waitingOnInput = false; 1315 } 1316 } 1317 1318 /** 1319 * Stop operation when window closing 1320 */ 1321 @Override 1322 public void windowClosing(java.awt.event.WindowEvent e) { 1323 if (testRunning) { 1324 if (outTest) { 1325 stopOutputTest(); 1326 } else if (wrapTest) { 1327 stopWraparoundTest(); 1328 } 1329 } 1330 super.windowClosing(e); 1331 } 1332 1333 private final static org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(DiagnosticFrame.class); 1334}