//==============================================================================
//
//  AVRcard - Monitor
//
//==============================================================================
//
//  This firmware source code is for free. You can redistribute, copy and
//  modify it. It is distributed in the hope that it will be useful,
//  but without any warranty.
//
//  Check the applications section of www.avrcard.com for updates and further
//  information on this project.
//
//  Have fun.
//
//  Hans Kallen, www.avrcard.com, August 2003
//
//==============================================================================
//
//  Version  Date       Author  Changes
//  -------  ---------- ------- ------------------------------
//  1.1      01.05.2003 HK      Initial public release
//
//  Compiler
//  --------
//  AVRco Rev. 5.35 or higher (by www.e-lab.de)
//
////////////////////////////////////////////////////////////////////////////////

Unit monitor;

interface
// global part

uses ds1307;

{--------------------------------------------------------------}
{ Const Declarations }
const

{$IDATA}
{--------------------------------------------------------------}
{ Type Declarations }
type
  TeMonitorPortSel =(eMonitorPort1,eMonitorPort2);
  TMonitorCommand = record
                      mId   : byte;
                      mText : string[15];
                    end;
                    
{--------------------------------------------------------------}
{ Var Declarations }
var monUserCommand : pipe[2] of byte;

{--------------------------------------------------------------}
{ functions }

// select serial port for monitor and other port for transparent mode
procedure monSetSerPort(serPortSel : TeMonitorPortSel);

// reads an input byte value
function monGetByte: byte;

// reads an input byte value in bcd format
function monGetBcdByte: byte;

// reads an input byte value in hex format
function monGetHexByte: byte;

// reads an input word address
function monGetAddr: word;

// reads an input string
procedure monGetString(dest: pointer to string; count: byte);

// attach command array
procedure monAttachCommandArray(pFirstArrayItem : pointer to TMonitorCommand; numItems : byte);

// terminal monitor process
process Monitor(80, 80: iData);

implementation
// local part

{--------------------------------------------------------------}
{ Type Declarations }
type

{--------------------------------------------------------------}
{ Const Declarations }
const
  monArrayLen : byte = 11;
  ramAddr : byte = %01010000;

structconst
  monArray : array[0..monArrayLen-1] of TMonitorCommand
           =((mId:  1; mText: '?'),       // display this help text
             (mId:  2; mText: 'help'),    // display this help text
             (mId:  3; mText: 'dt'),      // display current date and time
             (mId:  4; mText: 'st'),      // set date and time
             (mId:  5; mText: 'wr'),      // write hex byte to fram
             (mId:  6; mText: 'wrtxt'),   // write text to fram
             (mId:  7; mText: 'rdump'),   // fram hex dump
             (mId:  8; mText: 'sp'),      // show i/o ports
             (mId:  9; mText: 'wd'),      // write port data direction
             (mId: 10; mText: 'wp'),      // write port bit
             (mId: 11; mText: 'reg'));    // read control registers

{--------------------------------------------------------------}
{ Var Declarations }
{$IDATA}
var //userCallback  : TMonitorCallback;
    pCommandArray : pointer to TMonitorCommand;
    monItemCount  : byte;
    monItemLen    : byte;
    regPointer    : pointer;

{--------------------------------------------------------------}
{ functions }

// attach command array
procedure monAttachCommandArray(pFirstArrayItem : pointer to TMonitorCommand; numItems : byte);
//--------------------------------------------------------------
begin
  pCommandArray := pFirstArrayItem;
  monItemCount := numItems;
  monItemLen := byte(sizeof(TMonitorCommand));
end;

// get a user command item id
function monGetUserCommandId(str : string[15]) : byte;
//--------------------------------------------------------------
var pTemp : pointer to TMonitorCommand;
    count : byte;
begin
  for count:=0 to monItemCount-1 do
    pTemp := pCommandArray + word((count) * monItemLen);
    if str = pTemp^.mText then return(pTemp^.mId); endif;
  endfor;
  return(0);
end;

function monGetCommandId(str : string[15]) : byte;
//--------------------------------------------------------------
var count : byte;
begin
  for count:=0 to monArrayLen-1 do
    if str = monArray[count].mText then return(monArray[count].mId); endif;
  endfor;
  return(0);
end;

function monGetByte: Byte;
//--------------------------------------------------------------
var
   i: Byte;
   c: Char;
   st: String[4];
begin
   i:= 0;
   repeat
      c:= SerInp;
      if(c >= #$30) and(c <= #$39) then
         write(serout, c);
         inc(i); st[i]:= c;
      endif;
   until c = #$0D;
   st[0]:= char(i);
   return(StrToInt(st));
end;

function monGetBcdByte: Byte;
//--------------------------------------------------------------
var
   i: Byte;
   c: Char;
   st: String[4];
begin
   i:= 0;
   repeat
      c:= SerInp;
      if(c >= #$30) and(c <= #$39) then
         write(serout, c);
         inc(i); st[i]:= c;
      endif;
   until c = #$0D;
   st[0]:= char(i);
   i:=((Byte(st[1]) - $30) shl 4) +(Byte(st[2]) - $30);
   return(i);
end;

function monGetHexByte: Byte;
//--------------------------------------------------------------
var
  c: Char;
  b: Byte;
begin
  c:= Upcase(SerInp);
  write(serout, c);
  if c > #$39 then
    b:=(Byte(c) - $37) * 16;
  else
    b:=(Byte(c) - $30) * 16;
  endif;
  c:= Upcase(SerInp);
  write(serout, c);
  if c > #$39 then
    b:= b + Byte(c) - $37;
  else
    b:= b + Byte(c) - $30;
  endif;
  return(b);
end;

function monGetAddr: Word;
//--------------------------------------------------------------
var
   i: Byte;
   w: Word;
   c: Char;
begin
   i:= 4; w:= 0;
   repeat
      c:= Upcase(SerInp);
      write(serout, c);
      dec(i);
      if c > #$39 then
          w:= w +((Word(c) - $37) shl i * 4);
      else
          w:= w +((Word(c) - $30) shl i * 4);
      endif;
   until(c = #$0D) or(i = 0);
   return(w);
end;

procedure monGetString(dest: Pointer to String; count: Byte);
//--------------------------------------------------------------
var
   i: Byte;
   c: Char;
begin
   i:= 0;
   repeat
      c:= SerInp;
      if(c = #$0D)or(c = #$1B) then break;
      else
         write(serout, c);
         inc(i); dest^[i]:= c;
      endif;
   until(c = #$0D)or(c = #$1B)or(c = #17) or(i = count);
   dest^[0]:= char(i);
end;

procedure monHexDump(Adr: Word);
//--------------------------------------------------------------
var
  i, j, v: Byte;
  a: Word;
begin
  I2COut(ramAddr, Adr);
  writeln(serout);
  for i:= 0 to 15 do
    write(serout, ByteToHex(ramAddr and %00000111) + ', ');
    write(serout, ByteToHex(byte(Adr div 256)) + ByteToHex(byte(Adr mod 256)) + ' = ');
    for j:= 0 to 15 do
      I2CInp(ramAddr, v);
      write(serout, ByteToHex(v) + ' ');
    endfor;
    I2COut(ramAddr, Adr);
    for j:= 0 to 15 do
      I2CInp(ramAddr, v);
      if(v >= $20) and(v < $7F) then
        write(serout, Char(v));
      else
        write(serout, '.');
      endif;
    endfor;
    writeln(serout);
    Adr:= Adr + 16;
  endfor;
end;

procedure monShowIOPortDDR(ddr : byte);
//--------------------------------------------------------------
var count : byte;
begin
  for count := 7 downto 0 do
    if (ddr and (1 shl count)) > 0 then
      write(serout, 'o ');
    else
      write(serout, 'i ');
    endif;
  endfor;
end;

procedure monShowIOPortStat(stat : byte);
//--------------------------------------------------------------
var count : byte;
begin
  for count := 7 downto 0 do
    if (stat and (1 shl count)) > 0 then
      write(serout, '1 ');
    else
      write(serout, '0 ');
    endif;
  endfor;
end;

procedure monShowIOPortPullUp(ddr : byte; stat : byte);
//--------------------------------------------------------------
var count : byte;
begin
  for count := 7 downto 0 do
    if (ddr and (1 shl count)) > 0 then
      write(serout, '- ');
    else
      if (stat and (1 shl count)) > 0 then
        write(serout, 'y ');
      else
        write(serout, 'n ');
      endif;
    endif;
  endfor;
end;

procedure monHelpText;
//--------------------------------------------------------------
begin
  writeln(serout);
  writeln(serout, 'functions:');
  writeln(serout, '--------------------------------------------------');
  writeln(serout, '?<cr>      : display this help text');
  writeln(serout, 'help<cr>   : display this help text');
  writeln(serout, '<ctrl><q>  : serial port transparent mode (on/off)');
  writeln(serout, 'dt<cr>     : display current date and time');
  writeln(serout, 'st<cr>     : set date and time');
  writeln(serout, 'wr<cr>     : write hex byte to fram');
  writeln(serout, 'wrtxt<cr>  : write text to fram');
  writeln(serout, 'rdump<cr>  : fram hex dump');
  writeln(serout, 'sp<cr>     : show i/o port');
  writeln(serout, 'wd<cr>     : write i/o  port data direction');
  writeln(serout, 'wp<cr>     : write i/o port bit');
  writeln(serout, 'reg<cr>    : read control registers');
end;

// sends hello message to user
procedure monSayHello(port : TeMonitorPortSel);
//--------------------------------------------------------------
var text : string[2];
begin
  if port = eMonitorPort1 then text := '1'; else text := '2'; endif;
  writeln(serout);
  writeln(serout, '------------------');
  writeln(serout, '  www.AVRcard.com');
  writeln(serout, '------------------');
  writeln(serout, 'terminal monitor running at serial port ' + text + '...');
end;

// get all actual control registers
procedure monPrintRegs;
//--------------------------------------------------------------
var c : char;
begin
  writeln(serout);
  writeln(serout,'ucsr1c = ' + bytetobin(ucsr1c));
  writeln(serout,'udr2   = ' + bytetobin(udr2));
  writeln(serout,'usr2   = ' + bytetobin(usr2));
  writeln(serout,'ucsr1a = ' + bytetobin(ucsr1a));
  writeln(serout,'ucsr1b = ' + bytetobin(ucsr1b));
  writeln(serout,'ucr2   = ' + bytetobin(ucr2));
  writeln(serout,'ubrr1l = ' + bytetobin(ubrr1l));
  writeln(serout,'ubrr2  = ' + bytetobin(ubrr2));
  writeln(serout,'ubrr1h = ' + bytetobin(ubrr1h));
  writeln(serout,'ucsr0c = ' + bytetobin(ucsr0c));
  writeln(serout,'ucsrc  = ' + bytetobin(ucsrc));
  writeln(serout,'press any key...'); c:= serinp;
  writeln(serout,'ubrr0h = ' + bytetobin(ubrr0h));
  writeln(serout,'ubrrh  = ' + bytetobin(ubrrh));
  writeln(serout,'tccr3c = ' + bytetobin(tccr3c));
  writeln(serout,'tccr3a = ' + bytetobin(tccr3a));
  writeln(serout,'tccr3b = ' + bytetobin(tccr3b));
  writeln(serout,'tcnt3h = ' + bytetobin(tcnt3h));
  writeln(serout,'tcnt3l = ' + bytetobin(tcnt3l));
  writeln(serout,'ocr3ah = ' + bytetobin(ocr3ah));
  writeln(serout,'ocr3al = ' + bytetobin(ocr3al));
  writeln(serout,'ocr3bh = ' + bytetobin(ocr3bh));
  writeln(serout,'press any key...'); c:= serinp;
  writeln(serout,'ocr3bl = ' + bytetobin(ocr3bl));
  writeln(serout,'ocr3ch = ' + bytetobin(ocr3ch));
  writeln(serout,'ocr3cl = ' + bytetobin(ocr3cl));
  writeln(serout,'icr3h  = ' + bytetobin(icr3h));
  writeln(serout,'icr3l  = ' + bytetobin(icr3l));
  writeln(serout,'etimsk = ' + bytetobin(etimsk));
  writeln(serout,'etifr  = ' + bytetobin(etifr));
  writeln(serout,'tccr1c = ' + bytetobin(tccr1c));
  writeln(serout,'ocr1ch = ' + bytetobin(ocr1ch));
  writeln(serout,'ocr1cl = ' + bytetobin(ocr1cl));
  writeln(serout,'press any key...'); c:= serinp;
  writeln(serout,'twcr   = ' + bytetobin(twcr));
  writeln(serout,'twdr   = ' + bytetobin(twdr));
  writeln(serout,'twar   = ' + bytetobin(twar));
  writeln(serout,'twsr   = ' + bytetobin(twsr));
  writeln(serout,'twbr   = ' + bytetobin(twbr));
  writeln(serout,'osccal = ' + bytetobin(osccal));
  writeln(serout,'xmcra  = ' + bytetobin(xmcra));
  writeln(serout,'xmcrb  = ' + bytetobin(xmcrb));
  writeln(serout,'eicra  = ' + bytetobin(eicra));
  writeln(serout,'spmcsr = ' + bytetobin(spmcsr));
  writeln(serout,'press any key...'); c:= serinp;
  writeln(serout,'spmcr  = ' + bytetobin(spmcr));
  writeln(serout,'portg  = ' + bytetobin(portg));
  writeln(serout,'ddrg   = ' + bytetobin(ddrg));
  writeln(serout,'ping   = ' + bytetobin(ping));
  writeln(serout,'portf  = ' + bytetobin(portf));
  writeln(serout,'ddrf   = ' + bytetobin(ddrf));
  writeln(serout,'sreg   = ' + bytetobin(sreg));
  writeln(serout,'sph    = ' + bytetobin(sph));
  writeln(serout,'spl    = ' + bytetobin(spl));
  writeln(serout,'xdiv   = ' + bytetobin(xdiv));
  writeln(serout,'press any key...'); c:= serinp;
  writeln(serout,'rampz  = ' + bytetobin(rampz));
  writeln(serout,'eicr   = ' + bytetobin(eicr));
  writeln(serout,'eicrb  = ' + bytetobin(eicrb));
  writeln(serout,'eimsk  = ' + bytetobin(eimsk));
  writeln(serout,'eifr   = ' + bytetobin(eifr));
  writeln(serout,'timsk  = ' + bytetobin(timsk));
  writeln(serout,'tifr   = ' + bytetobin(tifr));
  writeln(serout,'mcucr  = ' + bytetobin(mcucr));
  writeln(serout,'mcusr  = ' + bytetobin(mcusr));
  writeln(serout,'tccr0  = ' + bytetobin(tccr0));
  writeln(serout,'press any key...'); c:= serinp;
  writeln(serout,'tcnt0  = ' + bytetobin(tcnt0));
  writeln(serout,'ocr0   = ' + bytetobin(ocr0));
  writeln(serout,'assr   = ' + bytetobin(assr));
  writeln(serout,'tccr1a = ' + bytetobin(tccr1a));
  writeln(serout,'tccr1b = ' + bytetobin(tccr1b));
  writeln(serout,'tcnt1h = ' + bytetobin(tcnt1h));
  writeln(serout,'tcnt1l = ' + bytetobin(tcnt1l));
  writeln(serout,'ocr1ah = ' + bytetobin(ocr1ah));
  writeln(serout,'ocr1al = ' + bytetobin(ocr1al));
  writeln(serout,'ocr1bh = ' + bytetobin(ocr1bh));
  writeln(serout,'press any key...'); c:= serinp;
  writeln(serout,'ocr1bl = ' + bytetobin(ocr1bl));
  writeln(serout,'icr1h  = ' + bytetobin(icr1h));
  writeln(serout,'icr1l  = ' + bytetobin(icr1l));
  writeln(serout,'tccr2  = ' + bytetobin(tccr2));
  writeln(serout,'tcnt2  = ' + bytetobin(tcnt2));
  writeln(serout,'ocr2   = ' + bytetobin(ocr2));
  writeln(serout,'ocdr   = ' + bytetobin(ocdr));
  writeln(serout,'wdtcr  = ' + bytetobin(wdtcr));
  writeln(serout,'eearh  = ' + bytetobin(eearh));
  writeln(serout,'eearl  = ' + bytetobin(eearl));
  writeln(serout,'press any key...'); c:= serinp;
  writeln(serout,'eedr   = ' + bytetobin(eedr));
  writeln(serout,'eecr   = ' + bytetobin(eecr));
  writeln(serout,'porta  = ' + bytetobin(porta));
  writeln(serout,'ddra   = ' + bytetobin(ddra));
  writeln(serout,'pina   = ' + bytetobin(pina));
  writeln(serout,'portb  = ' + bytetobin(portb));
  writeln(serout,'ddrb   = ' + bytetobin(ddrb));
  writeln(serout,'pinb   = ' + bytetobin(pinb));
  writeln(serout,'portc  = ' + bytetobin(portc));
  writeln(serout,'ddrc   = ' + bytetobin(ddrc));
  writeln(serout,'press any key...'); c:= serinp;
  writeln(serout,'pinc   = ' + bytetobin(pinc));
  writeln(serout,'portd  = ' + bytetobin(portd));
  writeln(serout,'ddrd   = ' + bytetobin(ddrd));
  writeln(serout,'pind   = ' + bytetobin(pind));
  writeln(serout,'spdr   = ' + bytetobin(spdr));
  writeln(serout,'spsr   = ' + bytetobin(spsr));
  writeln(serout,'spcr   = ' + bytetobin(spcr));
  writeln(serout,'udr1   = ' + bytetobin(udr1));
  writeln(serout,'usr1   = ' + bytetobin(usr1));
  writeln(serout,'ucr1   = ' + bytetobin(ucr1));
  writeln(serout,'press any key...'); c:= serinp;
  writeln(serout,'ubrr1  = ' + bytetobin(ubrr1));
  writeln(serout,'ubrr0l = ' + bytetobin(ubrr0l));
  writeln(serout,'acsr   = ' + bytetobin(acsr));
  writeln(serout,'admux  = ' + bytetobin(admux));
  writeln(serout,'adcsr  = ' + bytetobin(adcsr));
  writeln(serout,'adch   = ' + bytetobin(adch));
  writeln(serout,'adcl   = ' + bytetobin(adcl));
  writeln(serout,'porte  = ' + bytetobin(porte));
  writeln(serout,'ddre   = ' + bytetobin(ddre));
  writeln(serout,'pine   = ' + bytetobin(pine));
  writeln(serout,'pinf   = ' + bytetobin(pinf));
end;

{--------------------------------------------------------------}
{ processes }

process Monitor(80, 80: iData);
//--------------------------------------------------------------
var
  c                           : char;
  cmdId,count,bInput,mask,reg : byte;
  w                           : word;
  trspMode, bRes, firstStart  : boolean;
  time                        : TTime;
  date                        : TDate;
  text                        : string[15];
  shortString                 : string[2];
  shortString2                : string[2];
  serPort1Sel, serPort2Sel    : TeMonitorPortSel;

begin
  SerPortSelect := byte(serPort1Sel);  // switch serial port
  if firstStart then monSayHello(serPort1Sel); firstStart := false; endif;
  if trspMode then
    // port 1 input
    if SerStat then
      c := SerInp;
      if c = #17 then
        writeln(serout, 'transparent mode off!');
        trspMode := false;
      else
        SerPortSelect := byte(serPort2Sel);
        write(serout, c);
      endif;
    endif;
    // port 2 input
    SerPortSelect := byte(serPort2Sel);
    if SerStat then
      c := SerInp;
      SerPortSelect := byte(serPort1Sel);
      write(serout, c);
    endif;
  else
    writeln(serout);
    write(serout, '> ');
    WaitPipe(RxBuffer);
    text[1] := ' ';
    monGetString(@text,15);
    if char(text[1]) = #17 then
      writeln(serout);
      if trspMode = false then
        writeln(serout, 'transparent mode on!');
        trspMode := true;
      endif;
    else
      cmdId := monGetCommandId(text);
      case cmdId of
        1 : monHelpText;
            pipesend(monUserCommand,0);
            suspend(Monitor); |
        2 : monHelpText;
            pipesend(monUserCommand,0);
            suspend(Monitor); |
        3 : writeln(serout);
            bRes := rtcGetDateString(@text);
            if bRes then writeln(serout, text); endif;
            bRes := bRes OR rtcGetTimeString(@text);
            if bRes then
              writeln(serout, text);
            else
              writeln(serout, '*** error reading clock chip ***');
            endif; |
            
        4 : writeln(serout);
            write(serout,'> dd:');
            if rtcSetDay(monGetByte) then
              write(serout,' mm:');
              rtcSetMonth(monGetByte);
              write(serout,' yy:');
              rtcSetYear(monGetByte);
              write(serout,' wd:');
              rtcSetWeekDay(monGetByte);
              writeln(serout);
              write(serout,'hh:');
              rtcSetHour(monGetByte);
              write(serout,' mm:');
              rtcSetMinute(monGetByte);
              write(serout,' ss:');
              rtcSetSecond(monGetByte);
              writeln(serout);
            else
              writeln(serout, '*** error writing clock chip ***');
            endif; |

        5 : writeln(serout);
            write(serout, '> addr(hex word):');
            w:= Word(monGetHexByte) * 256 + Word(monGetHexByte);
            writeln(serout);
            write(serout, '> value(hex byte):');
            I2COut(ramAddr, w, monGetHexByte); |

        6 : writeln(serout);
            write(serout, '> addr(hex word):');
            w:= Word(monGetHexByte) * 256 + Word(monGetHexByte);
            writeln(serout);
            writeln(serout, '> text(end with <cr>):');
            repeat
              c:= SerInp;
              write(serout, c);
              I2COut(ramAddr, w, c);
              inc(w);
            until c = #13;
            writeln(serout); |

        7 : writeln(serout);
            write(serout, '> addr(hex word):');
            w:= Word(monGetHexByte) * 256 + Word(monGetHexByte);
            writeln(serout);
            monHexDump(w);  |
            

        8 : writeln(serout);
            write(serout, '> port(a..f):');
            monGetString(@shortString,1);
            writeln(serout);
            shortString[1] := upcase(shortString[1]);
            if shortString[1] in ['A'..'F'] then
              writeln(serout);
              writeln(serout,'Port' + shortString + '(pin 7..0):');
              writeln(serout,'-------------------------------------------');
              write(serout,'DDR' + shortString + '    : ');
              case shortString[1] of
                'A' : monShowIOPortDDR(DDRA); |
                'B' : monShowIOPortDDR(DDRB); |
                'C' : monShowIOPortDDR(DDRC); |
                'D' : monShowIOPortDDR(DDRD); |
                'E' : monShowIOPortDDR(DDRE); |
                'F' : monShowIOPortDDR(DDRF); |
              endcase;
              writeln(serout);
              write(serout,'pull up : ');
              case shortString[1] of
                'A' : monShowIOPortPullUp(DDRA,PortA); |
                'B' : monShowIOPortPullUp(DDRB,PortB); |
                'C' : monShowIOPortPullUp(DDRC,PortC); |
                'D' : monShowIOPortPullUp(DDRD,PortD); |
                'E' : monShowIOPortPullUp(DDRE,PortE); |
                'F' : monShowIOPortPullUp(DDRF,PortF); |
              endcase;
              writeln(serout);
              write(serout,'stat    : ');
              case shortString[1] of
                'A' : monShowIOPortStat(PinA); |
                'B' : monShowIOPortStat(PinB); |
                'C' : monShowIOPortStat(PinC); |
                'D' : monShowIOPortStat(PinD); |
                'E' : monShowIOPortStat(PinE); |
                'F' : monShowIOPortStat(PinF); |
              endcase;
              writeln(serout);
            else
              writeln(serout, 'port out of range');
            endif; |
            
        9 : writeln(serout);
            write(serout, '> port(a..f): ');
            monGetString(@shortString,2);
            writeln(serout);
            shortString[1] := upcase(shortString[1]);
            if shortString[1] in ['A'..'F'] then
              mask := %11111111;
              case shortString[1] of
                'A' : regPointer := @DDRA; |
                'B' : regPointer := @DDRB; |
                'C' : regPointer := @DDRC; |
                'D' : regPointer := @DDRD;
                      mask := %11110000; |
                'E' : regPointer := @DDRE;
                      mask := %11111100; |
                'F' : regPointer := @DDRF; |
              endcase;
              write(serout, 'bit(0..7): ');
              bInput := monGetByte;
              writeln(serout);
              if bInput in [0..7] then
                reg := mask and (1 shl bInput);
                if reg > 0 then
                  write(serout, 'i/o: ');
                  monGetString(@shortString2,2);
                  writeln(serout);
                  shortString2[1] := upcase(shortString2[1]);
                  if (shortString2[1]='I') or (shortString2[1]='O') then
                    if shortString2[1] = 'I' then
                      regPointer^ := regPointer^ and (not reg);
                      write(serout, 'internal pull up y/n: ');
                      monGetString(@shortString2,2);
                      writeln(serout);
                      shortString2[1] := upcase(shortString2[1]);
                      if (shortString2[1]='N') or (shortString2[1]='Y') then
                        case shortString[1] of
                          'A' : regPointer := @PortA; |
                          'B' : regPointer := @PortB; |
                          'C' : regPointer := @PortC; |
                          'D' : regPointer := @PortD; |
                          'E' : regPointer := @PortE; |
                          'F' : regPointer := @PortF; |
                        endcase;
                        if shortString2[1] = 'N' then
                          regPointer^ := regPointer^ and (not reg);
                        else
                          regPointer^ := regPointer^ or reg;
                        endif;
                      else
                        writeln(serout, 'no pull up selected');
                      endif;
                    else
                      regPointer^ := regPointer^ or reg;
                    endif;
                  else
                    writeln(serout, 'i/o out of range');
                  endif;
                else
                  writeln(serout);
                  writeln(serout, 'rejected(internally used ports)');
                endif;
              else
                writeln(serout, 'pin out of range');
              endif;
            else
              writeln(serout, 'port out of range');
            endif; |

        10: writeln(serout);
            write(serout, '> port(a..f): ');
            monGetString(@shortString,2);
            writeln(serout);
            shortString[1] := upcase(shortString[1]);
            if shortString[1] in ['A'..'F'] then
              mask := %11111111;
              case shortString[1] of
                'A' : regPointer := @PortA; |
                'B' : regPointer := @PortB; |
                'C' : regPointer := @PortC; |
                'D' : regPointer := @PortD;
                      mask := %11110000; |
                'E' : regPointer := @PortE;
                      mask := %11111100; |
                'F' : regPointer := @PortF; |
              endcase;
              write(serout, ' bit(0..7): ');
              bInput := monGetByte;
              writeln(serout);
              if bInput in [0..7] then
                reg := mask and (1 shl bInput);
                if reg > 0 then
                  write(serout, ' 1/0: ');
                  if boolean(monGetByte) = true then
                    regPointer^ := regPointer^ or reg;
                  else
                    regPointer^ := regPointer^ and (not reg);
                  endif;
                else
                  writeln(serout);
                  writeln(serout, 'rejected(internally used ports)');
                endif;
              else
                writeln(serout, 'bit out of range');
              endif;
            else
              writeln(serout, 'port out of range');
            endif;
            writeln(serout); |
            
        11: monPrintRegs; |
      else
        cmdId := monGetUserCommandId(text);
        if cmdId > 0 then
          pipesend(monUserCommand,cmdId);
          suspend(Monitor);
        endif;
      endcase;
    endif;
  endif; // transparent mode
end;

// select serial port for monitor and other port for transparent mode
procedure monSetSerPort(serPortSel : TeMonitorPortSel);
//--------------------------------------------------------------
begin
  if serPortSel = eMonitorPort1 then
    Monitor.serPort1Sel := eMonitorPort1;
    Monitor.serPort2Sel := eMonitorPort2;
  else
    Monitor.serPort1Sel := eMonitorPort2;
    Monitor.serPort2Sel := eMonitorPort1;
  endif;
  monSayHello(serPortSel);
end;

initialization
// at StartUp
  Monitor.trspMode := false;
  Monitor.firstStart := true;
  Monitor.serPort1Sel := eMonitorPort1;
  Monitor.serPort2Sel := eMonitorPort2;
  pCommandArray := nil;
  monItemCount := 0;
  monItemLen := 0;

// finalization          // optional
// at System_ShutDown
end monitor.