monitor.c

利用单片机仿真JTAG测试驱动程序,可做测试烧录等

TMS_O = 0;    // Start mode select in "low" state
TDI_O = 0;    // Start data output pin in "low" state

       // Direction bits for the JTAG lines
TRST_DDR = 1; // Output
TCLK_DDR = 1; // Output
TMS_DDR = 1;  // Output
TDI_DDR = 1;  // Output
TDO_DDR = 0;  // Input

       // Pullup control bits for JTAG lines
TRST_PE = 0;  // No pullup
TCLK_PE = 0;  // No pullup
TMS_PE = 0;   // No pullup
TDI_PE = 0;   // No pullup
TDO_PE = 1;   // Yes pullup

// Disable internal pullup on IRQ input
IRQSC = 0x10;   // IRQ interrupts disabled, but pin is IRQ function

}

//----------------------------------------
// This sends one character out the "serial port" (COM1).
// It does not make use of interrupts.  It waits until the character is
// done being transmitted before returning.
void transmit_rs232_char(unsigned char a)
{
unsigned char i;

while (SCI1C2 & 0x80) {};     // Wait for end of any strings in transit
i = SCI1S1;                   // Read status register
SCI1D = a;
while (!(SCI1S1 & 0x40)) {};  // Wait for TX Complete bit
}

//----------------------------------------
// This receives one character from the "serial port" (COM1).
// It does not make use of interrupts.  It waits until the character is
// done being received before returning.
// There is no error checking or anything.
unsigned char receive_rs232_char(unsigned char *a)
{
while (!(SCI1S1 & 0x20)) {};  // Wait for character to come
*a = SCI1D;                   // Read character
return(1);
}

//----------------------------------------
// This sends a hex word, four hexadecimal characters
void send_hex_dword(unsigned long data)
{
unsigned char i,j;

for (i=8;i>0;i--) {
    j = (data >> (unsigned char)(4*(i-1))) & 0x0f;  // Mask off one nibble
    if (j>9) j += 55;
    else j += 48;
    transmit_rs232_char(j);
  }
}

//----------------------------------------
// This sends a hex word, four hexadecimal characters
void send_hex_word(unsigned int data)
{
unsigned char i,j;

for (i=4;i>0;i--) {
    j = (data >> (unsigned char)(4*(i-1))) & 0x0f;  // Mask off one nibble
    if (j>9) j += 55;
    else j += 48;
    transmit_rs232_char(j);
  }
}

//----------------------------------------
// This sends a hex byte, two hexadecimal characters
void send_hex_byte(unsigned char data)
{
unsigned char i,j;

for (i=2;i>0;i--) {
    j = (data >> 4*(i-1)) & 0x0f;    // Mask off one nibble
    if (j>9) j += 55;                // If letter...
    else j += 48;                    // If number...
    transmit_rs232_char(j);
  }
}


//----------------------------------------
// This sends a string out the "serial port"
void send_string(unsigned char *text)
{
int i=0;

while (text[i]!=0) transmit_rs232_char(text[i++]);
}

unsigned char get_command(unsigned char *target, unsigned char max_length)
{
unsigned char incoming;
unsigned char i;

  i = 0;
  while (
            (i<(max_length-1))
         && (incoming != 0x0d)
         && receive_rs232_char(&incoming)
         )
  {
    if (incoming == 0x08) {
      if (i>0) {
        i--;  // Delete characters for backspace
        transmit_rs232_char(incoming);  // move back
        transmit_rs232_char(' ');       // blank it out
        transmit_rs232_char(incoming);  // move back
        }
      else transmit_rs232_char(0x07);
      }
    else {
      target[i++] = incoming;
      transmit_rs232_char(incoming);
    } // End of else
  }  // End of while

  target[i] = 0x00;  // Place zero at end of string ("NULL terminate")

  if (i==(max_length-1)) return(2);
  else if (incoming != 0x0d) return(3);
  else return(1);
} // end of get_command()


//----------------------------------------
// This function parses one hex byte from the command line, and returns
// the actual numeric value of it.  No error checking is performed!
unsigned char parse_hex_byte(unsigned char *cmd)
{
unsigned char k;
unsigned char j;  // return value

  while (cmd[ci] == ' ') ci++;  // Scan through white space
  j = cmd[ci] - 0x30;           // Convert from ASCII to hex number
  if (j>9) j-=7;                // Handle [A..F]
  if (j>15) j-=32;              // Handle "lower caseness"
  j = j << 4;                   // First digit is 16 place
  ci++;
  k = cmd[ci] - 0x30;           // Convert from ASCII to hex number
  if (k>9) k-=7;                // Handle [A..F]
  if (k>15) k-=32;              // Handle "lower caseness"
  j = j + k;                    // Second digit is "ones" place
  ci++;
  return(j);
}

//----------------------------------------
// This function parses one hex word from the command line, and returns
// the actual numeric value of it.  No error checking is performed!
unsigned int parse_hex_word(unsigned char *cmd)
{
unsigned char i;  // index variable
unsigned char k;  // digit value
unsigned int  j;  // return value

  j = 0;                        // Clear out return value
  while (cmd[ci] == ' ') ci++;  // Scan through white space
  for (i=0;i<4;i++)
  {
    k = cmd[ci] - 0x30;         // Convert from ASCII to hex number
    if (k>9) k-=7;              // Handle [A..F]
    if (k>15) k-=32;            // Handle "lower caseness"
    j = j << 4;                 // Make room for next digit..
    j = j + k;                  // Add digit.
    ci++;
  }
  return(j);
}


//----------------------------------------
// This function parses one 32 bit hex dword from the command line.
// The actual numeric value is returned.  No error checking is performed!
unsigned long parse_hex_dword(unsigned char *cmd)
{
unsigned char i;  // index variable
unsigned char k;  // digit value
unsigned long j;  // return value

  j = 0;                        // Clear out return value
  while (cmd[ci] == ' ') ci++;  // Scan through white space
  for (i=0;i<8;i++)
  {
    k = cmd[ci] - 0x30;         // Convert from ASCII to hex number
    if (k>9) k-=7;              // Handle [A..F]
    if (k>15) k-=32;            // Handle "lower caseness"
    j = j << 4;                 // Make room for next digit..
    j = j + k;                  // Add digit.
    ci++;
  }
  return(j);
}


//----------------------------------------
void cmd_help()
{
  send_string("\n\rCommands available:");
  send_string("\n\r  d                  Data Register");
  send_string("\n\r  i                  Instruction Register.");
  send_string("\n\r  t                  TAP test.");
  send_string("\n\r  help               This help screen.");
  send_string("\n\r  jtag               Toggle TRST state.");
  send_string("\n\r  read aa nn         Read nn dwords from address aa.");
  send_string("\n\r  write aa dddddddd  Write data dd to address aa.");
  send_string("\n\r  state              Show state of TDI pin");
  send_string("\n\r");
}


// This command toggles the state of the TRST pin
void jtag_reset()
{
  TMS_O = 1;
  trst_state ^= 1;  // Toggle the state
  TRST_O = trst_state;
  if (trst_state == 0) send_string("\n\rTRST is now LOW, resetting");
  else
  {
    send_string("\n\rTRST is now HIGH");
    TMS_O = 0;
    tap_send_clk();
    TMS_O = 1;
    tap_send_clk();  // Go to Select_DR_Scan state    
  }
  
  
} // end of trst_toggle()

// This command displays the state of the TDO_I pin
void show_state()
{
unsigned char s;

  s = TDO_I;
  if (s==1) send_string("\n\rTDO is HIGH");
  else send_string("\n\rTDO is LOW");
} // end of trst_toggle()


// This command reads from the memory area, and displays the contents.
void cmd_read(unsigned char *cmd)
{
unsigned char aa,nn,i;
unsigned long *dptr,dd;

  while (cmd[ci] != ' ') ci++;  // Scan through remainder of command word
  aa = parse_hex_byte(cmd);     // Get address
  nn = parse_hex_byte(cmd);     // Get quantity to read
  dptr = DR_O;
  dptr += aa;
  send_string("\n\rData readout: ");
  for (i=0;i<nn;i++)
  {
    dd = *dptr++;
    send_string("\n\r");
    send_hex_byte(aa++);
    send_string(" ");
    send_hex_dword(dd);
  }
} // end of cmd_read()

// This command writes data to the memory area.
void cmd_write(unsigned char *cmd)
{
unsigned char aa;
unsigned long *dptr,dd;

  while (cmd[ci] != ' ') ci++;  // Scan through remainder of command word
  aa = parse_hex_byte(cmd);
  dd = parse_hex_dword(cmd);
  dptr = DR_O;     // Set base address
  dptr += aa;
  *dptr = dd;
} // end of cmd_write()

//----------------------------------------
// This function never ends.  It contains the main loop which obtains commands
// from the user and interprets them.  It calls the various functions which
// implement the commands also.
void process_commands()
{
unsigned char cmd[CMD_LINE_LENGTH];  // Holds the command line
unsigned char i;

while (1) {
    send_string("\n\r--> ");
    i = get_command(cmd,CMD_LINE_LENGTH);
    switch (i) {
      case 0 : send_string("\n\rWhat?");
               break;
      case 2 : send_string("\n\rOverrun!");
               break;
      case 3 : send_string("\n\rCharacter receive error...");
               break;
      case 1 :
               send_string("\n\r");
               send_string(cmd);
               send_string("\n\r");
               ci = 0;
               while (cmd[ci] == ' ') ci++;  // remove leading spaces
               switch (cmd[ci]) {
               case 0x0d: send_string("\n\rExcuse you...");
                          break;
               case 'd' : tap_send_dr();
                          break;
               case 'h' : cmd_help();
                          break;
               case 'i' : tap_send_ir();
                          break;
               case 'j' : jtag_reset();
                          break;
               case 'r' : cmd_read(cmd);
                          break;
               case 't' : tap_test();
                          break;
               case 'w' : cmd_write(cmd);
                          break;
               case 's' : show_state();
                          break;
               default  : send_string("\n\rUnrecognized command");
                          break;
               } // end of switch (cmd[ci])
    } // end of switch(i)
  } // end of while(1)
} // end of process_commands()

//============================================================================

void main(void)
{
  DisableInts;
  init_micro_ports();
  // Initialize the ICG (internal clock generator)
  ICGC1 = 0x28;  // internal reference, FLL prescale is 64
  ICGC2 = 0x70;  // MFD multiply by 18, RFD divide by 2.
  ICGTRM = 0x56; // Set oscillator trim to middle range.
  WaitNms(100);  // Wait for ICG settling...
  PTFDD_PTFDD0 = 1;  // Make port F pins (LEDs) outputs
  PTFDD_PTFDD1 = 1;  // Make port F pins (LEDs) outputs
  PTFDD_PTFDD2 = 1;  // Make port F pins (LEDs) outputs
  PTFDD_PTFDD3 = 1;  // Make port F pins (LEDs) outputs
  PTFD_PTFD0 = 0;    // Keep the LEDs off for now
  PTFD_PTFD1 = 0;    // Keep the LEDs off for now
  PTFD_PTFD2 = 0;    // Keep the LEDs off for now
  PTFD_PTFD3 = 0;    // Keep the LEDs off for now
  while (!(ICGS1 & 0x08)) {  // Indicate ICG error by flashing LEDs...
    PTFD_PTFD0 = 0;  // Light up LEDs
    PTFD_PTFD1 = 0;
    PTFD_PTFD2 = 0;
    PTFD_PTFD3 = 0;
    WaitNms(100);
    PTFD_PTFD0 = 1;  // Light up LEDs
    PTFD_PTFD1 = 1;
    PTFD_PTFD2 = 1;
    PTFD_PTFD3 = 1;
    WaitNms(100);
  };  // wait for lock

  Timer_Init();
  Com1_Init();
  send_string("\n\rWelcome: Monitor command menu.");
  send_string("\n\rEnter command, 'h' for help");
  process_commands();
   
}