ngcdcsSLX.hpp

Go to the documentation of this file.

#ifndef ngcdcsSLX_H
#define ngcdcsSLX_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
/* 
 * System Headers 
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
 
/*
 * Local Headers 
 */
#include <ngc/core/ngcb.h>
#include <ngc/core/ngcbAddr.h>

#define ngcdcsSLX_MAX_WIN 48
 
/*
 * Multiplexer control register (MCR)
 */
#define ngcdcsSLX_MCR_CHAN      0x03 //< channel selection mask
#define ngcdcsSLX_MCR_CHAN4     0x00 //< 4 channels
#define ngcdcsSLX_MCR_CHAN8     0x01 //< 8 channels
#define ngcdcsSLX_MCR_CHAN16    0x02 //< 16 channels
#define ngcdcsSLX_MCR_CHAN32    0x03 //< 32 channels
#define ngcdcsSLX_MCR_EXTRST    0x04 //< external reset
#define ngcdcsSLX_MCR_NO_REF    0x08 //< disable reference pixels 
#define ngcdcsSLX_MCR_CB_REF_EN 0x10 //< enable ballast capacitors (reference)
#define ngcdcsSLX_MCR_CB_EN     0x20 //< enable ballast capacitors (33-288)
#define ngcdcsSLX_MCR_LSP_EN    0x40 //< enable LSP output
#define ngcdcsSLX_MCR_NO_CLAMP  0x80 //< disable clamp function
 
/*
 * Read-out modes
 */
#define ngcdcsSLX_RM_ITR      0x00 //< integrate-then-read
#define ngcdcsSLX_RM_RR       0x01 //< rolling reset
#define ngcdcsSLX_RM_RDRSTRD  0x02 //< read-reset-read
 
/*
 * Detector control register (DCR)
 */
#define ngcdcsSLX_DCR_RM      0x0f //< read-out mode mask 
#define ngcdcsSLX_DCR_SELECT  0xf0 //< register selection mask 
#define ngcdcsSLX_DCR_MCR     0x10 //< program MCR
#define ngcdcsSLX_DCR_WDR     0x20 //< program WDR
#define ngcdcsSLX_DCR_WRR     0x40 //< program WRR

#define ngcdcsSLX_NROW 256

#define ngcdcsSLX_NCOL 320

#define ngcdcsSLX_NCOL_NO_REF 256

struct ngcdcs_shift_t {
  int numBits;
  
  int array[ngcbSEQ_SHRAM_SIZE];
  
  ngcdcs_shift_t() {Init();}
  
  void Init() {numBits = 0; memset(array, 0, sizeof(array));}

  int TxSize() {
    int n;
    int numBytes = numBits / 8;
    if ((numBits % 8) > 0) numBytes++;
    n = numBytes / 4;
    if ((numBytes % 4) > 0) n++;
    return (n);
  }
}; 

struct ngcdcs_slxrow_t {
  int start;

  int size;

  ngcdcs_slxrow_t() {Clear();}
  
  void Clear() {start = 0; size = 0;}

  int Valid() {return ((start > 0) && (size > 0));}

  friend int operator==(const ngcdcs_slxrow_t &a, const ngcdcs_slxrow_t &b) {
    return ((a.size == b.size) && (a.start == b.start));
  }
};

struct ngcdcs_slxcfg_t {
  short colRst;
  
  short colData;
  
  ngcdcs_slxrow_t rowRst[ngcdcsSLX_MAX_WIN];

  ngcdcs_slxrow_t rowData[ngcdcsSLX_MAX_WIN];

  int readMode;

  int mcr;

  int fullFrame;

  int newCfg;

  int enabled;

  int valid;

  ngcdcs_slxcfg_t() {
    ClearWin();
    readMode = ngcdcsSLX_RM_ITR;
    mcr = ngcdcsSLX_MCR_CHAN32;
    fullFrame = 1;
    newCfg = 0;
    enabled = 0;
    valid = 0;
  }
  
  void ClearWin() {
    int i;
 
    for (i=0;i<ngcdcsSLX_MAX_WIN;i++)
      {
      rowRst[i].Clear();
      rowData[i].Clear();
      }
 
    colRst = 0x0;
    colData = 0x0;
  }

  void ClearRstWin() {
    int i;
    for (i=0;i<ngcdcsSLX_MAX_WIN;i++) rowRst[i].Clear();
    colRst = 0x0;
  }

  void ClearDataWin() {
    int i;
    for (i=0;i<ngcdcsSLX_MAX_WIN;i++) rowData[i].Clear();
    colData = 0x0;
  }

  int ValidWin() {
    if (colData != 0)
      {
      int i;
      for (i=0;i<ngcdcsSLX_MAX_WIN;i++)
    {
    if (rowData[i].Valid()) 
      {
      return (1);
      }
    }
      }
    return (0);
  }
}; 

#define ngcdcsSHIFT_MAX 32

class ngcdcsSLX {
public:
  ngcdcs_shift_t shift[ngcdcsSHIFT_MAX];
  
  int fullFrame;

  int enabled;

  ngcdcsSLX() {
    erms_[0] = '\0';
 
    /*
     * Interface enabled
     */
    enabled = 1;
 
    /*
     * Clear control registers
     */
    mcr_ = 0x0;
    dcr_ = 0x0;
 
    /*
     * Clear configuration flags
     */
    ClearCfg();
 
    /*
     * We only support 32-channel mode
     */
    MCR(ngcdcsSLX_MCR_CHAN32);
 
    /*
     * Default read-out mode
     */
    ReadMode(ngcdcsSLX_RM_ITR);
 
    /*
     * Full frame
     */
    FullFrame();
    fullFrame = 1;
 
    /*
     * Clear shift register
     */
    memset(shiftReg, 0, sizeof(shiftReg));
    shiftRegSize = 0;
  }
 
  // Destructor 
  virtual ~ngcdcsSLX() {}

  char *ErrMsg() {return (erms_);}

  void ReadMode(int mode) {
    readMode_ = mode & ngcdcsSLX_DCR_RM;
    dcr_ &= ~ngcdcsSLX_DCR_RM;
    dcr_ |= (char)readMode_;
    rmX_ = 1;
  }
  
  int ReadMode() {return (readMode_);}

  char DCR() {return (dcr_);}

  void MCR(int value) {
    mcr_ = (char)(value & 0xff);
 
    /*
     * We only support 32-channel mode
     */
    mcr_ &= ~ngcdcsSLX_MCR_CHAN;
    mcr_ |= ngcdcsSLX_MCR_CHAN32;
 
    mcrX_ = 1;
  }

  char MCR() {return (mcr_);}

  void FullFrame() {WDRALL(); WRRALL();}

  void ClearWin() {WDRCLR(); WRRCLR(); }

  void ClearCfg() {rmX_ = 0; wdrX_ = 0; wrrX_ = 0; mcrX_ = 0;}

  void Configure() {
    int n;
    
    /*
     * Clear pending shift register instructions
     */
    for (n=0;n<ngcdcsSHIFT_MAX;n++) shift[n].numBits = 0;
 
    if (fullFrame)
      {
      /*
       * Override window requests
       */
      FullFrame();
      }
 
    n = 0;
    if (rmX_)
      {
      int next;
      if (mcrX_) next = ngcdcsSLX_DCR_MCR;
      else if (wdrX_) next = ngcdcsSLX_DCR_WDR;
      else if (wrrX_) next = ngcdcsSLX_DCR_WRR;
      else next = 0;
 
      RM2REG(next);
      shift[n].Init();
      shift[n].array[0] = DCR() & 0xff;
      shift[n].numBits = 8;
      n++;
      rmX_ = 0;
      }
    if (mcrX_)
      {
      int next;
      if (wdrX_) next = ngcdcsSLX_DCR_WDR;
      else if (wrrX_) next = ngcdcsSLX_DCR_WRR;
      else next = 0;
      MCR2REG(next);
      if (n == 0)
    {
    shift[n].Init();
    shift[n].array[0] = DCR() & 0xff;
    shift[n].numBits = 8;
    n++;
    }
      shift[n].Init();
      shift[n].array[0] = shiftReg[0];
      shift[n].numBits = shiftRegSize;
      n++;
      mcrX_ = 0;
      }
    if (wdrX_)
      {
      int next;
      if (wrrX_) next = ngcdcsSLX_DCR_WRR;
      else next = 0;
      WDR2REG(next);
      if (n == 0)
    {
    shift[n].Init();
    shift[n].array[0] = DCR() & 0xff;
    shift[n].numBits = 8;
    n++;
    }
      shift[n].Init();
      memcpy(shift[n].array, shiftReg, sizeof(shiftReg));
      shift[n].numBits = shiftRegSize;
      n++;
      wdrX_ = 0;
      }
    if (wrrX_)
      {
      WRR2REG();
      if (n == 0)
    {
    shift[n].Init();
    shift[n].array[0] = DCR() & 0xff;
    shift[n].numBits = 8;
    n++;
    }
      shift[n].Init();
      memcpy(shift[n].array, shiftReg, sizeof(shiftReg));
      shift[n].numBits = shiftRegSize;
      wrrX_ = 0;
      }
  }

  int Key(const char *name, const char *value) {
    char tmp[128];
    char ermsLoc[128];
    int keyIdx[8];
    int n;
    char v[256];
    int idx;
 
    strcpy(v, value);
    for (n=0;n<(int)strlen(v);n++)
      {
      if ((v[n] == '_') || (v[n] == ',') || (v[n] == '|')) v[n] = ' ';
      }
 
    strcpy(tmp, name);   
    if (ngcbKeyIdx(tmp, &n, keyIdx, ermsLoc) != ngcbSUCCESS)
      {
      sprintf(ErrMsg(), "invalid keyword <%s> - %s", name, 
          ermsLoc);
      return (ngcbFAILURE);
      }
    idx = keyIdx[1];
 
    if (strcmp(tmp, "SLX.ENA") == 0)
      {
      if (strcmp(v, "T") == 0) enabled = 1;
      else if (strcmp(v, "F") == 0) enabled = 0;
      else
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      }
    else if (strcmp(tmp, "SLX.MCR") == 0)
      {
      int intVal;
      if (!ngcbFmt2Int(v, &intVal))
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      MCR(intVal);
      }
    else if (strcmp(tmp, "SLX.REFPIX") == 0)
      {
      int intVal = MCR();
      if (strcmp(v, "T") == 0) intVal &= ~ngcdcsSLX_MCR_NO_REF;
      else if (strcmp(v, "F") == 0) intVal |= ngcdcsSLX_MCR_NO_REF;
      else
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      MCR(intVal);
      }
    else if (strcmp(tmp, "SLX.EXTRST") == 0)
      {
      int intVal = MCR();
      if (strcmp(v, "T") == 0) intVal |= ngcdcsSLX_MCR_EXTRST;
      else if (strcmp(v, "F") == 0) intVal &= ~ngcdcsSLX_MCR_EXTRST;
      else
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      MCR(intVal);
      }
    else if (strcmp(tmp, "SLX.CBENA") == 0)
      {
      int intVal = MCR();
      if (strcmp(v, "T") == 0) intVal |= ngcdcsSLX_MCR_CB_EN;
      else if (strcmp(v, "F") == 0) intVal &= ~ngcdcsSLX_MCR_CB_EN;
      else
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      MCR(intVal);
      }
    else if (strcmp(tmp, "SLX.CBREFENA") == 0)
      {
      int intVal = MCR();
      if (strcmp(v, "T") == 0) intVal |= ngcdcsSLX_MCR_CB_REF_EN;
      else if (strcmp(v, "F") == 0) intVal &= ~ngcdcsSLX_MCR_CB_REF_EN;
      else
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      MCR(intVal);
      }
    else if (strcmp(tmp, "SLX.LSPENA") == 0)
      {
      int intVal = MCR();
      if (strcmp(v, "T") == 0) intVal |= ngcdcsSLX_MCR_LSP_EN;
      else if (strcmp(v, "F") == 0) intVal &= ~ngcdcsSLX_MCR_LSP_EN;
      else
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      MCR(intVal);
      }
    else if (strcmp(tmp, "SLX.CLAMP") == 0)
      {
      int intVal = MCR();
      if (strcmp(v, "T") == 0) intVal &= ~ngcdcsSLX_MCR_NO_CLAMP;
      else if (strcmp(v, "F") == 0) intVal |= ngcdcsSLX_MCR_NO_CLAMP;
      else
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      MCR(intVal);
      }
    else if (strcmp(tmp, "SLX.MODE") == 0)
      {
      ngcbToLower(v);
      if (strcmp(v, "itr") == 0) ReadMode(ngcdcsSLX_RM_ITR);
      else if (strcmp(v, "rolling") == 0) ReadMode(ngcdcsSLX_RM_RR);
      else if (strcmp(v, "rdrstrd") == 0) ReadMode(ngcdcsSLX_RM_RDRSTRD);
      else
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      }
    else if (strcmp(tmp, "SLX.WIN") == 0)
      {
      if (strcmp(v, "F") == 0) fullFrame = 1;
      else if (strcmp(v, "T") == 0) fullFrame = 0; 
      else
    {
    int intVal;
    if (sscanf(v, "%10d", &intVal) < 1)
      {
      sprintf(ErrMsg(), "invalid keyword value <%s>", name);
      return (ngcbFAILURE);
      }
    if (intVal) fullFrame = 1; 
    else fullFrame = 0;
    }
      }
    else if (strcmp(tmp, "SLX.DCOL") == 0)
      {
      if (idx > 10)
    {
    sprintf(ErrMsg(), "column index out of range [1,10]");
    return (ngcbFAILURE);
    }
      if (strcmp(v, "T") == 0)
    {
    if (!wdrX_) WDRCLR();
    if (idx <= 0) WDRCOL_ON();
    else WDRCOL_ON(idx - 1);
    }
      else if (strcmp(v, "F") == 0)
    {
    if (!wdrX_) WDRCLR();
    if (idx <= 0) WDRCOL_OFF();
    else WDRCOL_OFF(idx - 1);
    }
      else
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      }
    else if (strcmp(tmp, "SLX.RCOL") == 0)
      {
      if (idx > 10)
    {
    sprintf(ErrMsg(), "column index out of range [1,10]");
    return (ngcbFAILURE);
    }
      if (strcmp(v, "T") == 0)
    {
    if (!wrrX_) WRRCLR();
    if (idx <= 0) WRRCOL_ON();
    else WRRCOL_ON(idx - 1);
    }
      else if (strcmp(v, "F") == 0)
    {
    if (!wrrX_) WRRCLR();
    if (idx <= 0) WRRCOL_OFF();
    else WRRCOL_OFF(idx - 1);
    }
      else
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      }
    else if (strcmp(tmp, "SLX.COL") == 0)
      {
       if (idx > 10)
    {
    sprintf(ErrMsg(), "column index out of range [1,10]");
    return (ngcbFAILURE);
    }
      if (strcmp(v, "T") == 0)
    {
    if (!wdrX_) WDRCLR();
    if (!wrrX_) WRRCLR();
    if (idx <= 0)
      {
      WDRCOL_ON();
      WRRCOL_ON();
      }
    else
      {
      WDRCOL_ON(idx - 1);
      WRRCOL_ON(idx - 1);
      }
    }
      else if (strcmp(v, "F") == 0)
    {
    if (!wdrX_) WDRCLR();
    if (!wrrX_) WRRCLR();
    if (idx <= 0)
      {
      WDRCOL_OFF();
      WRRCOL_OFF();
      }
    else
      {
      WDRCOL_OFF(idx - 1);
      WRRCOL_OFF(idx - 1);
      }
    }
      else
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      }
    else if (strcmp(tmp, "SLX.ROW") == 0)
      {
      int sy, ny;
      if (sscanf(v, "%10d %10d", &sy, &ny) < 2)
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      if (!wdrX_) WDRCLR();
      if (!wrrX_) WRRCLR();
      WDRROW(sy - 1, ny);
      WRRROW(sy - 1, ny);
      }
    else if (strcmp(tmp, "SLX.DROW") == 0)
      {
      int sy, ny;
      if (sscanf(v, "%10d %10d", &sy, &ny) < 2)
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      if (!wdrX_) WDRCLR();
      WDRROW(sy - 1, ny);
      }
    else if (strcmp(tmp, "SLX.RROW") == 0)
      {
      int sy, ny;
      if (sscanf(v, "%10d %10d", &sy, &ny) < 2)
    {
    sprintf(ErrMsg(), "invalid keyword value <%s>", name);
    return (ngcbFAILURE);
    }
      if (!wrrX_) WRRCLR();
      WRRROW(sy - 1, ny);
      }
    
    return (ngcbSUCCESS);
  }

  void Preset(ngcdcs_slxcfg_t &cfg) {
    /*
     * Read-out mode
     */
    ReadMode(cfg.readMode);
 
    /*
     * Multiplexer control register
     */
    MCR(cfg.mcr);
    
    if (cfg.fullFrame || !cfg.ValidWin())
      {
      /*
       * Full frame read-out
       */
      FullFrame(); fullFrame = 1;
      }
    else
      {
      int i;
 
      /*
       * Clear window mappings
       */
      ClearWin(); fullFrame = 0;
 
      /*
       * Program column register
       */
      for (i=0;i<10;i++)
    {
    if (cfg.colData & (1 << i)) WDRCOL_ON(i);
    if (cfg.colRst & (1 << i)) WRRCOL_ON(i);
    }
 
      /*
       * Program row registers
       */
      for (i=0;i<ngcdcsSLX_MAX_WIN;i++)
    {
    if (cfg.rowData[i].Valid())
      {
      WDRROW(cfg.rowData[i].start - 1, cfg.rowData[i].size);
      }
    if (cfg.rowRst[i].Valid())
      {
      WRRROW(cfg.rowRst[i].start - 1, cfg.rowRst[i].size);
      }
    }
      }
  }
 
  void GetDim(int *sx, int *sy, int *nx, int *ny) {
    int i, j;
    
    *sx = 1; *sy = 1; *nx = 0; *ny = 0;
    if (mcr_ & ngcdcsSLX_MCR_NO_REF)
      {
      for (j=1;j<8;j++)
    {
    if (wdrCol_[0] & (1 << j)) (*nx) += 32;
    else if (*nx == 0) (*sx) += 32;
    }
      if (wdrCol_[1] & 0x1) (*nx) += 32;
      else if (*nx == 0) (*sx) += 32;
      }
    else
      {
      for (j=0;j<8;j++)
    {
    if (wdrCol_[0] & (1 << j)) (*nx) += 32;
    else if (*nx == 0) (*sx) += 32;
    }
      for (j=0;j<2;j++)
    {
    if (wdrCol_[1] & (1 << j)) (*nx) += 32;
    else if (*nx == 0) (*sx) += 32;
    }
      }
 
    for (i=0;i<32;i++)
      {
      for (j=0;j<8;j++)
    {
    if (wdrRow_[i] & (1 << j)) (*ny)++;
    else if (*ny == 0) (*sy)++;
    }
      }
  }
 
  // Return data column configuration
  int DCOL() {return (wdrCol_[0] | wdrCol_[1] << 8);}
 
  // Return reset column configuration
  int RCOL() {return (wrrCol_[0] | wrrCol_[1] << 8);}
 
  // Return data row configuration
  void DROW(ngcdcs_slxrow_t *w) {Reg2Row_(wdrRow_, w);}
 
  // Return reset row configuration
  void RROW(ngcdcs_slxrow_t *w) {Reg2Row_(wrrRow_, w);}
 
protected: 
  int shiftReg[ngcbSEQ_SHRAM_SIZE];
  
  int shiftRegSize;

  void RM2REG(int nextSelect = 0) {
    dcr_ &= (char)~ngcdcsSLX_DCR_SELECT;
    dcr_ |= (char)(nextSelect & ngcdcsSLX_DCR_SELECT);    
    shiftRegSize = 0;
  }

  void MCR2REG(int nextSelect = 0) {
    /*
     * We only support 32-channel mode
     */
    mcr_ &= ~ngcdcsSLX_MCR_CHAN;
    mcr_ |= ngcdcsSLX_MCR_CHAN32;
 
    dcr_ &= (char)~ngcdcsSLX_DCR_SELECT;
    dcr_ |= (char)(nextSelect & ngcdcsSLX_DCR_SELECT);    
    shiftReg[0] = (dcr_ & 0xff) | (mcr_ & 0xff) << 8;
    shiftRegSize = 16;
    dcr_ &= (char)~ngcdcsSLX_DCR_SELECT;
    dcr_ |= ngcdcsSLX_DCR_MCR;
  }

  void WDR2REG(int nextSelect = 0) {
    dcr_ &= (char)~ngcdcsSLX_DCR_SELECT;
    dcr_ |= (char)(nextSelect & ngcdcsSLX_DCR_SELECT);
    Win2Shift_(wdrRow_, wdrCol_);
    dcr_ &= (char)~ngcdcsSLX_DCR_SELECT;
    dcr_ |= ngcdcsSLX_DCR_WDR;
  }

  void WRR2REG(int nextSelect = 0) {
    dcr_ &= (char)~ngcdcsSLX_DCR_SELECT;
    dcr_ |= (char)(nextSelect & ngcdcsSLX_DCR_SELECT);
    Win2Shift_(wrrRow_, wrrCol_);
    dcr_ &= (char)~ngcdcsSLX_DCR_SELECT;
    dcr_ |= ngcdcsSLX_DCR_WRR;
  }

  void WDRALL() {
    wdrCol_[0] = (char)0xff; wdrCol_[1] = (char)0x3;
    memset(wdrRow_, 0xff, sizeof(wdrRow_));
    wdrX_ = 1;
  }

  void WRRALL() {
    wrrCol_[0] = (char)0xff; wrrCol_[1] = (char)0x3;
    memset(wrrRow_, 0xff, sizeof(wdrRow_));
    wrrX_ = 1;
  }

  void WDRCLR() {
    memset(wdrCol_, 0x00, sizeof(wdrCol_));
    memset(wdrRow_, 0x00, sizeof(wdrRow_));
    wdrX_ = 1;
  }

  void WRRCLR() {
    memset(wrrCol_, 0x00, sizeof(wdrCol_));
    memset(wrrRow_, 0x00, sizeof(wdrRow_));
    wrrX_ = 1;
  }
  
  void WDRROW(int sy, int ny) {
    AdjustRow_(&sy, &ny);
    Row2Reg_(sy, ny, wdrRow_);
  }

  void WRRROW(int sy, int ny) {
    AdjustRow_(&sy, &ny);
    Row2Reg_(sy, ny, wrrRow_);
  }

  void WDRCOL_ON() {wdrCol_[0] = (char)0xff; wdrCol_[1] = (char)0x3;}

  void WRRCOL_ON() {wrrCol_[0] = (char)0xff; wrrCol_[1] = (char)0x3;}

  void WDRCOL_OFF() {wdrCol_[0] = (char)0x0; wdrCol_[1] = (char)0x0;}

  void WRRCOL_OFF() {wrrCol_[0] = (char)0x0; wrrCol_[1] = (char)0x0;}

  void WDRCOL_ON(int n) {Col2Reg_(n, wdrCol_);}

  void WRRCOL_ON(int n) {Col2Reg_(n, wrrCol_);}

  void WDRCOL_OFF(int n) {ColRemove_(n, wdrCol_);}

  void WRRCOL_OFF(int n) {ColRemove_(n, wrrCol_);}
 
private:
  char erms_[256];

  int readMode_;

  char dcr_;

  char mcr_;

  char wdrCol_[2];

  char wdrRow_[32];

  char wrrCol_[2];

  char wrrRow_[32];

  int rmX_;

  int mcrX_;

  int wrrX_;

  int wdrX_;

  void AdjustRow_(int *sy, int *ny) {
   if (*sy < 0) *sy = 0;
    if (*sy >= ngcdcsSLX_NROW) *sy = ngcdcsSLX_NROW - 1;
    if ((*sy + *ny) > ngcdcsSLX_NROW) *ny = ngcdcsSLX_NROW - *sy;
  }

  void Col2Reg_(int n, char *reg) {
    if (n < 0) n = 0;
    if (n > 9) n = 9;
    if (n > 7) reg[1] |= (char)(1 << (n - 8));
    else reg[0] |= (char)(1 << n);
  }
  
  void ColRemove_(int n, char *reg) {
    if ((n < 0) || (n > 9)) return;
    if (n > 7) reg[1] &= (char)~(1 << (n - 8));
    else reg[0] &= (char)~(1 << n);
  }
  
  void Row2Reg_(int start, int n, char *reg) {
    int i, s;
    char *r;
    
    s = start % 8;
    r = reg + (start / 8);
    for (i=start;i<(start+n);i++)
      {
      *r |= (char)(1 << s);
      s = (s + 1) % 8;
      if (s == 0) r++;
      }
  }
  
  void Reg2Row_(char *reg, ngcdcs_slxrow_t *w) {
    int n = 0;
    int sy = 1;
    int ny = 0;
    int i, j;
 
    for (i=0;i<32;i++)
      {
      for (j=0;j<8;j++)
    {
    if (reg[i] & (1 << j)) ny++;
    else if (ny == 0) sy++;
    else
      {
      w[n].start = sy;
      w[n++].size = ny;
      sy += ny + 1;
      ny = 0;
      }
    }
      }
  }

  void Win2Shift_(char *wr, char *wc) {
    int *r = &shiftReg[0];
    int i;
    int s = 8;
 
    *r = dcr_ & 0xff;
 
    for (i=0;i<32;i++)
      {
      *r |= (wr[i] & 0xff) << s;
      s = (s + 8) % 32;
      if (s == 0) r++;
      }
 
    if (mcr_ & ngcdcsSLX_MCR_NO_REF)
      {
      char b = (char)(((wc[0] >> 1) & 0x7f) | ((wc[1] & 0x1) << 7));
      *r |= (b & 0xff) << s;
      shiftRegSize = 272;
      }
    else
      {
      *r |= (wc[0] & 0xff) << s;
      s = (s + 8) % 32;
      if (s == 0) r++;
      *r |= (wc[1] & 0xff) << s;
      shiftRegSize = 274;
      }
  }
 
};
 
#endif