CMSIS_5/CMSIS/DAP/Firmware/Validation/MDK5/test.ini

/******************************************************************************/
/* test.ini: Initialization file to test the debug functionality              */
/******************************************************************************/
/* This file is part of the uVision/ARM development tools.                    */
/* Copyright (c) 2012-2017 Keil Software. All rights reserved.                */
/* This software may only be used under the terms of a valid, current,        */
/* end user license from KEIL for a compatible version of KEIL software       */
/* development tools. Nothing else gives you the right to use this software.  */
/******************************************************************************/

// ensure logging into file is turned off
LOG OFF

// overall test success flag
define int testSuccess;
testSuccess = 0;

// flags to show which particular tests succeeded
define char bpExecSuccess;
bpExecSuccess = 0;
define char bpReadSuccess;
bpReadSuccess = 0;
define char bpWriteSuccess;
bpWriteSuccess = 0;
define char memReadSuccess;
memReadSuccess = 0;
define char memWriteSuccess;
memWriteSuccess = 0;
define char regReadSuccess;
regReadSuccess = 0;
define char regWriteSuccess;
regWriteSuccess = 0;


// function to read and write registers
FUNC void RegReadWrite(void) {
  unsigned long VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9;
  unsigned long VR10, VR11, VR12, VR13, VR14, VR15, VxPSR;
  unsigned long VR_0, VR_1, VR_2, VR_3, VR_4, VR_5, VR_6, VR_7, VR_8, VR_9;
  unsigned long VR_10, VR_11, VR_12, VR_13, VR_14, VR_15, V_xPSR;
  unsigned long bogus;

  bogus = 0x0badF00D;

  printf("Register read started\n");

  // initialize temporary variables with bogus value
  VR0   = bogus;
  VR1   = bogus;
  VR2   = bogus;
  VR3   = bogus;
  VR4   = bogus;
  VR5   = bogus;
  VR6   = bogus;
  VR7   = bogus;
  VR8   = bogus;
  VR9   = bogus;
  VR10  = bogus;
  VR11  = bogus;
  VR12  = bogus;
  VR13  = bogus;
  VR14  = bogus;
  VR15  = bogus;
  VxPSR = bogus;

  // read and save current register values
  VR0   = R0;
  VR1   = R1;
  VR2   = R2;
  VR3   = R3;
  VR4   = R4;
  VR5   = R5;
  VR6   = R6;
  VR7   = R7;
  VR8   = R8;
  VR9   = R9;
  VR10  = R10;
  VR11  = R11;
  VR12  = R12;
  VR13  = R13;
  VR14  = R14;
  VR15  = R15;
  VxPSR = xPSR;

  // print read register values
  printf("R0   = 0x%x\n", VR0);
  printf("R1   = 0x%x\n", VR1);
  printf("R2   = 0x%x\n", VR2);
  printf("R3   = 0x%x\n", VR3);
  printf("R4   = 0x%x\n", VR4);
  printf("R5   = 0x%x\n", VR5);
  printf("R6   = 0x%x\n", VR6);
  printf("R7   = 0x%x\n", VR7);
  printf("R8   = 0x%x\n", VR8);
  printf("R9   = 0x%x\n", VR9);
  printf("R10  = 0x%x\n", VR10);
  printf("R11  = 0x%x\n", VR11);
  printf("R12  = 0x%x\n", VR12);
  printf("R13  = 0x%x\n", VR13);
  printf("R14  = 0x%x\n", VR14);
  printf("R15  = 0x%x\n", VR15);
  printf("xPSR = 0x%x\n", VxPSR);

  // check if all values differ from bogus value
  regReadSuccess =
    (VR0   != bogus) &&
    (VR1   != bogus) &&
    (VR2   != bogus) &&
    (VR3   != bogus) &&
    (VR4   != bogus) &&
    (VR5   != bogus) &&
    (VR6   != bogus) &&
    (VR7   != bogus) &&
    (VR8   != bogus) &&
    (VR9   != bogus) &&
    (VR10  != bogus) &&
    (VR11  != bogus) &&
    (VR12  != bogus) &&
    (VR13  != bogus) &&
    (VR14  != bogus) &&
    (VR15  != bogus) &&
    (VxPSR != bogus);

  if (regReadSuccess != 0) {
    printf("Register read passed\n");
  } else {
    printf("Register read failed\n");
    // there is no reason to test write if read fails
    return;
  }

  printf("Register write started\n");

  // fill all registers with bogus value
  R0   = bogus;
  R1   = bogus;
  R2   = bogus;
  R3   = bogus;
  R4   = bogus;
  R5   = bogus;
  R6   = bogus;
  R7   = bogus;
  R8   = bogus;
  R9   = bogus;
  R10  = bogus;
  R11  = bogus;
  R12  = bogus;
  // register R13-R15 and xPSR on hardware do not accept 0x0badf00d, use 0x0 instead
  R13  = 0x0;
  R14  = 0x0;
  R15  = 0x0;
  xPSR = 0x0;

  // read back into another array 
  VR_0   = R0;
  VR_1   = R1;
  VR_2   = R2;
  VR_3   = R3;
  VR_4   = R4;
  VR_5   = R5;
  VR_6   = R6;
  VR_7   = R7;
  VR_8   = R8;
  VR_9   = R9;
  VR_10  = R10;
  VR_11  = R11;
  VR_12  = R12;
  VR_13  = R13;
  VR_14  = R14;
  VR_15  = R15;
  V_xPSR = xPSR;

  // print the values again
  printf("R0   = 0x%x\n", VR_0);
  printf("R1   = 0x%x\n", VR_1);
  printf("R2   = 0x%x\n", VR_2);
  printf("R3   = 0x%x\n", VR_3);
  printf("R4   = 0x%x\n", VR_4);
  printf("R5   = 0x%x\n", VR_5);
  printf("R6   = 0x%x\n", VR_6);
  printf("R7   = 0x%x\n", VR_7);
  printf("R8   = 0x%x\n", VR_8);
  printf("R9   = 0x%x\n", VR_9);
  printf("R10  = 0x%x\n", VR_10);
  printf("R11  = 0x%x\n", VR_11);
  printf("R12  = 0x%x\n", VR_12);
  printf("R13  = 0x%x\n", VR_13);
  printf("R14  = 0x%x\n", VR_14);
  printf("R15  = 0x%x\n", VR_15);
  printf("xPSR = 0x%x\n", V_xPSR);

  // check if new values are bogus
  regWriteSuccess =
    (VR_0   == bogus) &&
    (VR_1   == bogus) &&
    (VR_2   == bogus) &&
    (VR_3   == bogus) &&
    (VR_4   == bogus) &&
    (VR_5   == bogus) &&
    (VR_6   == bogus) &&
    (VR_7   == bogus) &&
    (VR_8   == bogus) &&
    (VR_9   == bogus) &&
    (VR_10  == bogus) &&
    (VR_11  == bogus) &&
    (VR_12  == bogus) &&
    (VR_13  == 0x0)   &&
    (VR_14  == 0x0)   &&
    (VR_15  == 0x0)   && 
    (V_xPSR == 0x0);

  if (regWriteSuccess != 0) {
    printf("Register write passed\n");
  } else {
    printf("Register write failed\n");
  }

  // write saved values back into registers
  // values are required to be written correctly for the rest of the test
  R0   = VR0;
  R1   = VR1;
  R2   = VR2;
  R3   = VR3;
  R4   = VR4;
  R5   = VR5;
  R6   = VR6;
  R7   = VR7;
  R8   = VR8;
  R9   = VR9;
  R10  = VR10;
  R11  = VR11;
  R12  = VR12;
  R13  = VR13;
  R14  = VR14;
  R15  = VR15;
  xPSR = VxPSR;
}


// function to write predefined numbers into test_array1
FUNC void MemWrite(unsigned long address) {
  unsigned int i;
  unsigned int val;

  printf("Memory write started\n");
  val = 0x1000;
  for (i = 0; i < 256; i++) {
    _WWORD(address, val);
    val++;
    address += 4;
  }
  printf("Memory write completed\n");
}

// function to read from test_array2 and check if write and read was successful
FUNC void MemRead(unsigned long address) {
  unsigned int i;
  unsigned int val, v;

  printf("Memory read started\n");
  val = 0x1000;
  memReadSuccess = 1;  // assume it is true
  for (i = 0; i < 256; i++) {
    v = _RWORD(address);
    if (v != val) {
      memReadSuccess = 0;
    }
    val++;
    address += 4;
  }
  if (memReadSuccess != 0) {
    printf("Memory read passed\n");
  } else {
    printf("Memory read failed\n");
  }
}


// check execution breakpoint
FUNC void CheckBpExec(unsigned long address) {
  // PC should be at address and value of bpTestCounter variable should be 9

  if ((R15 == address) && (`bpTestCounter == 9)) {
    bpExecSuccess = 1;
  }
  printf("Execution breakpoint (%d): %d\n", `bpTestCounter, bpExecSuccess);
}

// check breakpoint on read
FUNC void CheckBpRead(int test_state) {
  // PC should be at address

  if (`test_state == test_state) {
    bpReadSuccess = 1;
  }
  printf("Breakpoint on read: %d\n",bpReadSuccess);
}


// check breakpoint on write
FUNC void CheckBpWrite(int test_state) {
  // PC should be at address

  if (`test_state == test_state) {
    bpWriteSuccess = 1;
  }
  printf("Breakpoint on write: %d\n", bpWriteSuccess);
}


// evaluate test
FUNC void EvalSuccess(void) {
  char success;

  success = testSuccess &&
            bpExecSuccess && bpReadSuccess && bpWriteSuccess &&
            regReadSuccess && regWriteSuccess &&
            memReadSuccess && memWriteSuccess;

  exec("LOG >.\\test_results.txt");

  // print test results to log file
  if (success) {
    printf("Test passed!\n");
  } else {
    printf("Test failed!\n");
  }

  printf("\nIndividual test results:\n");

  printf("Execution breakpoint: ");
  if (bpExecSuccess) {
    printf("passed\n");
  } else {
    printf("failed\n");
  }

  printf("Breakpoint on read:   ");
  if (bpReadSuccess) {
    printf("passed\n");
  } else {
    printf("failed\n");
  }

  printf("Breakpoint on write:  ");
  if (bpWriteSuccess) {
    printf("passed\n");
  } else {
    printf("failed\n");
  }
  
  printf("Register read:        ");
  if (regReadSuccess) {
    printf("passed\n");
  } else {
    printf("failed\n");
  }

  printf("Register write:       ");
  if (regWriteSuccess) {
    printf("passed\n");
  } else {
    printf("failed\n");
  }

  printf("Memory read:          ");
  if (memReadSuccess) {
    printf("passed\n");
  } else {
    printf("failed\n");
  }

  printf("Memory write:         ");
  if (memWriteSuccess) {
    printf("passed\n");
  } else {
    printf("failed\n");
  }

  printf("Control flow:         ");
  if (testSuccess) {
    printf("passed\n");
  } else {
    printf("failed\n");
  }

  exec("LOG OFF");
}


LOG >.\\test.log                // start logging

RegReadWrite();                 // check register read/write

BK *                            // remove all existing breakpoints
BS \test.c\43, 9                // set execution breakpoint (hit count=9)
G                               // run to break point
CheckBpExec(\test.c\43);        // check execution breakpoint

BK *                            // remove all existing breakpoints
BS READ test_success            // set a read access breakpoint
G                               // run to break point
CheckBpRead(11);                // check breakpoint on read

BK *                            // remove all existing breakpoints
BS WRITE test_success           // set a write access breakpoint
G                               // run to break point
CheckBpWrite(12);               // check breakpoint on write

BK *                            // remove all existing breakpoints
G,\test.c\61                    // run until line 61
MemWrite(&test_array1[0]);      // test memory write

G,\test.c\69                    // run until line 69
memWriteSuccess = `mem_rw_success;  // application memory test result
MemRead(&test_array2[0]);       // test memory read

T 3                             // step 3 times

`test_state -= 16;              // modify 'test_state' application variable

G,\test.c\88                    // run until line 88

testSuccess = `test_success;    // read 'test_success' application variable

LOG OFF                         // stop logging

EvalSuccess();                  // evaluate test results

EXIT                            // exit debug mode