src/net/threebit/jvr/util/T1Diag.java

Go to the documentation of this file.

package net.threebit.jvr.util;

/*
 * $Id: T1Diag.java,v 1.6 2005/05/24 02:54:32 kevino Exp $
 *
 * Copyright (c) 2003,2004 Kevin O'Donnell
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307,  USA.
 */

import java.io.*;
import java.util.*;
import java.util.logging.Logger;
import net.threebit.jvr.*;

public class T1Diag implements MetaEventListener {

  public static Logger logger = Logger.getLogger("net.threebit.jvr.util");
  public static long start = System.currentTimeMillis();

  int boardCount;
  int[] boardDevs = new int[1024];
  String[] boardNames = new String[1024];
  int[][] dtDevs = new int[1024][24];
  String[][] dtNames = new String[1024][24];

  DX_IOTT[] iottArray;
  DV_TPT[] tpt = new DV_TPT[1];
  DX_XPB xpb;

  int dxDev1;
  int dxDev2;
  boolean recording = false;
  boolean printEvents = false;

  Map alarms = new HashMap();

  BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

  public void printAlarms() {
    synchronized (alarms) {
      for (int x = 0; x < boardCount; x++) {
        String name = boardNames[x];
        List l = (List) alarms.get(name);
        if (l == null) {
          l = new ArrayList();
          alarms.put(name,l);
        }
        String line = name + ":";
        if (l.size() == 0) {
          line += " no alarms";
        }
        for (Iterator i = l.iterator(); i.hasNext(); ) {
          line += " " + i.next();
        }
        print(line);
      }
    }
  }

  public void setAlarm (String board, String alarm, boolean on) {
    synchronized (alarms) {
      List l = (List) alarms.get(board);
      if (l == null) {
        l = new ArrayList();
        alarms.put(board,l);
      }
      if (on) {
        l.remove(alarm);
      }
      else if (!l.contains(alarm)) {
        l.add(alarm);
      }
    }
  }

  public boolean handleEvent (MetaEvent event) throws JVRException {
    String message = null;
    String device = null;
    boolean handled = false;

    if (event.evtdev == dxDev1 || event.evtdev == dxDev2) {
      // TODO
      handled = true;
    }

    // Check boards first.
    for (int x = 0; !handled && x < boardCount; x++) {
      // Event on the board?
      if (event.evtdev == boardDevs[x]) {
        device = boardNames[x];
        handled = true;
        if (event.evttype == dt.DTEV_T1ERRC) {

          int i = ((Integer) event.evtdata).intValue();
          message = jvr.symbolName("DTT1_",i);
    
          if (message.startsWith("DTT1_")) {
            String base = null;
            if (message.indexOf("OK") > -1) {
              base = message.substring(0,message.length()-2);
              setAlarm(boardNames[x],base,true);
            }
            else {
              base = message;
              setAlarm(boardNames[x],base,false);
            }
          }
        }
        break;
      }
      // Event on a board timeslot?
      for (int y = 0; !handled && y < 24; y++) {
        if (event.evtdev == dtDevs[x][y]) {
          handled = true;

          device = dtNames[x][y];

          message = jvr.symbolName("DTEV_",event.evttype);

          if (event.evttype == dt.DTEV_SIG) {
            message += " " + tsBits((int)event.evtdev);
          }

          x = 999;
          break;
        }
      }
    }

    if (message == null) {
      message = ""+event;
    }

    print("(event) " + device + " " + message);
    return true;
  }

  public boolean handleEvent (JVREvent event) throws JVRException {
    print("Ignored: " + event);
    return true;
  }

  public void run (String[] args) {
    // Add self as event listener
    jvr.addEventListener(this);

    // Open all of the available T1 boards.
    int index = 0;
    print("Opening T1 Boards:");
    while (true) {
      index ++;
      String name = "dtiB"+index;
      int dev;
      try {
        dev = dt.open(name,0);
        boardCount++;
      }
      catch (Throwable t) {
        index--;
        break;
      }
      boardDevs[index-1] = dev;
      boardNames[index-1] = name;
      print("  " + name);
      try {
        dt.setevtmsk(
          dev,
          dt.DTG_T1ERREVT,
          dt.DTEC_OOF | dt.DTEC_LOS | dt.DTEC_DPM | dt.DTEC_BPVS | dt.DTEC_BVCS | 
          dt.DTEC_ECS | dt.DTEC_RYEL | dt.DTEC_RCL | dt.DTEC_RCLX | dt.DTEC_FERR | 
          dt.DTEC_B8ZSD | dt.DTEC_RBL | dt.DTEC_RLOS | dt.DTEC_RED | dt.DTEC_LOOPBACK_CFA | dt.DTEC_DCHAN_CFA,
          dt.DTA_SETMSK
        );
      }
      catch (Throwable t) {
        print("Error setting up board: " + name);
        logger.throwing(getClass().getName(),"run",t);
      }
      String dtName = null;
      try {
        // open the 24 timeslots
        dtDevs[index-1] = new int[24];
        dtNames[index-1] = new String[24];
        for (int x = 1; x <= 24; x++) { // <= 24
          dtName = name + "T" + x;
          dtDevs[index-1][x-1] = dt.open(dtName,0);
          dtNames[index-1][x-1] = dtName;
          dt.setevtmsk(
            dtDevs[index-1][x-1],
            dt.DTG_SIGEVT,
            dt.DTMM_AON | dt.DTMM_AOFF | dt.DTMM_BON | dt.DTMM_BOFF | dt.DTMM_WINK,
            dt.DTA_SETMSK
          );
        }
      }
      catch (Throwable t) {
        print("Error setting up channel: " + dtName);
        logger.throwing(getClass().getName(),"run",t);
      }
    }
    print("");

    try {
      print("Opening dxxxB1C1");
      dxDev1 = dx.open("dxxxB1C1",0);
      dx.stopch(dxDev1,dx.EV_SYNC);
      print("Opening dxxxB1C2");
      dxDev2 = dx.open("dxxxB1C2",0);
      dx.stopch(dxDev2,dx.EV_SYNC);
    }
    catch (Throwable t) {
      print("Error opening DX resources");
      logger.throwing(getClass().getName(),"run",t);
    }

    print("");
    while (true) {
      try {
        prompt("t1diag");
        String command = in.readLine();
        if (command == null) { continue; }
        if (command.equals("")) { continue; }
        if (command.equals("h")) {
          printHelp();
        }
        if (command.equals("q")) {
          System.exit(0);
        }
        if (command.equals("e")) {
          printEvents = !printEvents;
          print("Print Events: " + printEvents);
        }
        if (command.equals("b")) {
          printBits();
        }
        if (command.equals("a")) {
          printAlarms();
        }
        if (command.equals("s")) {
          setTSBits();
        }
        if (command.equals("l")) {
          doListen();
        }
        if (command.equals("d")) {
          doScriptedDial();
        }
        if (command.equals("m")) {
          doDial();
        }
        if (command.equals("r")) {
          doRecord();
        }
      }
      catch (Throwable t) {
        t.printStackTrace();
        try { Thread.sleep(100); } catch (Throwable ignore) { }
      }
    }
  }

  public void doScriptedDial() throws JVRException {
  }

  public void doDial() throws JVRException {
    prompt("Number");
    String number = getString();

    DX_CAP cap;
    cap = new DX_CAP();
    cap.ca_nbrdna = 3;
    cap.ca_intflg = dx.DX_PAMDOPTEN;
    cap.ca_pamd_spdval = (byte) dx.PAMD_ACCU;
    cap.ca_hedge = 1;

    print("Dialing '"+number+"'");
    dx.dial(dxDev1,number,cap,dx.EV_ASYNC|dx.DX_CALLP);
  }

  public void doRecord() throws JVRException {
    if (recording) {
      dx.stopch(dxDev2, dx.EV_SYNC);
      print("Recording stopped");
      recording = false;
    }
    else {
      prompt("Filename");
      String filename = getString();

      tpt[0] = new DV_TPT();
      tpt[0].tp_type = dx.IO_EOT;
      tpt[0].tp_termno = dx.DX_MAXTIME;
      tpt[0].tp_length = 9000;
      tpt[0].tp_flags = dx.TF_MAXTIME;

      xpb = new DX_XPB();
      xpb.wFileFormat = dx.FILE_FORMAT_WAVE;
      xpb.wDataFormat = dx.DATA_FORMAT_PCM;
      xpb.nSamplesPerSec = dx.DRT_11KHZ;
      xpb.wBitsPerSample = 8;

      iottArray = DX_IOTT.newArray(1);
      iottArray[0].io_type = dx.IO_DEV;
      iottArray[0].io_fhandle = dx.fileopen(
        filename,
        dx.WIN32_O_CREAT|dx.WIN32_O_RDWR|dx.WIN32_O_BINARY,
        dx.WIN32_S_IREAD|dx.WIN32_S_IWRITE
      );

      dx.reciottdata(dxDev2,iottArray,tpt,xpb,dx.EV_ASYNC);
      recording = true;
      print("Recording started");
    }
  }

  public void doListen() throws JVRException {
    prompt("DX resource 1 (dialing) or 2 (recording)");
    int i = getInt(); if (i == -1) { return; }
    int dev = dxDev1;
    if (i == 2) {
      dev = dxDev2; 
      prompt("  Listen to DT device or voice device? [DT,v]");
      String s = getString();
      if (s.equals("v")) {
        dx.listen(dxDev2, dx.getxmitslot(dxDev1));
        return;
      }
    }
    print("i = " + i + ", dev = " + dev);

    print("Set Timeslot TX bits");
    print("");
    printBoards();
    print("");
    prompt("Enter board");
    int board = getInt(); if (board == -1) { return; }
    if (board < 0 || board >= boardCount) { return; }
    prompt("Enter timeslot (1-24)");
    int ts = getInt(); if (board == -1) { return; }
    ts --;

    dx.listen(dev, dt.getxmitslot(dtDevs[board][ts]));
    if (i == 1) {
      dt.listen(dtDevs[board][ts], dx.getxmitslot(dev));
    }
  }

  public void printHelp() {
    print("h - Help");
    print("a - Print current alarms");
    print("b - Print TS bits (all)");
    print("d - Perform a test dial");
    print("e - Toggle event printing");
    print("l - Connect DX resource to a timeslot");
    print("m - Dial using a DX resource (manual)");
    print("q - Quit");
    print("r - Start/Stop recording");
    print("s - Set TX bits on a timeslot");
  }

  public void printBits() throws JVRException {
    print("Status of RX/TX bits");
    for (int x = 0; x < boardCount; x++) {
      for (int y = 0; y < 24; y++) {
        String name = dtNames[x][y];
        int dev = dtDevs[x][y];
        print("  " + name + " " + tsBits(dev));
      }
    }
  }

  public static void main (String[] args) {
    T1Diag t1Diag = new T1Diag();
    t1Diag.run(args);
  }

  public String tsBits (int dev) throws JVRException {
    long tsbits = dt.ATDT_TSSGBIT(dev);
    int ar, br, ax, bx;
    ar = (tsbits & dt.DTSG_RCVA)>0 ? 1 : 0;
    br = (tsbits & dt.DTSG_RCVB)>0 ? 1 : 0;
    ax = (tsbits & dt.DTSG_XMTA)>0 ? 1 : 0;
    bx = (tsbits & dt.DTSG_XMTB)>0 ? 1 : 0;
    return "{rx: " + ar + "/" + br + " tx: " + ax + "/" + bx + "}";
  }

  public static double dur() {
    double d = System.currentTimeMillis() - start;
    return d/1000;
  }

  public static void prompt (String prompt) {
    System.out.print(dur() + " " + prompt + " > ");
  }

  public static void prompt() {
    System.out.print(dur() + " > ");
  }

  public static void print (String line) {
    System.out.println(dur() + " " + line);
  }

  public void setTSBits() throws JVRException {
    print("Set Timeslot TX bits");
    print("");
    printBoards();
    print("");
    prompt("Enter board");
    int board = getInt(); if (board == -1) { return; }
    if (board < 0 || board >= boardCount) { return; }
    prompt("Enter timeslot (1-24)");
    int ts = getInt(); if (board == -1) { return; }
    ts --;
    print("");
    print("Select TX combination to set");
    print("");
    print("[1] A=0, B=0");
    print("[2] A=0, B=1");
    print("[3] A=1, B=0");
    print("[4] A=1, B=1");
    int setting = 0;
    while (setting != -1) {
      String bits = tsBits(dtDevs[board][ts]);
      print("");
      prompt("Q to finish " + bits + " ");
      setting = getInt(); if (setting == -1) { return; }
      int bitmask = 0;
      switch (setting) {
        case 1:
          bitmask = dt.DTB_AOFF|dt.DTB_BOFF;
          break;
        case 2:
          bitmask = dt.DTB_AOFF|dt.DTB_BBIT;
          break;
        case 3:
          bitmask = dt.DTB_ABIT|dt.DTB_BOFF;
          break;
        case 4:
          bitmask = dt.DTB_ABIT|dt.DTB_BBIT;
          break;
      }
      dt.settssig(dtDevs[board][ts],bitmask,dt.DTA_SETMSK);
    }
  }

  public String getString() {
    try {
      return in.readLine();
    }
    catch (IOException e) {
      logger.throwing(getClass().getName(),"getString",e);
      return null;
    }
  }

  public int getInt() {
    try {
      return Integer.valueOf(in.readLine()).intValue();
    }
    catch (Throwable t) {
      return -1;
    }
  }

  public void printBoards() {
    for (int x = 0; x < boardCount; x++) {
      String s = "";
      if (x < 10) { s += " "; }
      print("[" + s + x + "] " + boardNames[x]);
    }
  }

}

---