Guest User

jtag knock EXTEST

a guest
Jul 4th, 2020
41
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <EEPROM.h>
  2.  
  3. #define MAX4xR 4096
  4. #define MAXREG8 375
  5.  
  6. #define TCK_PIN 2
  7. #define TMS_PIN 3
  8. #define TDI_PIN 4
  9. #define TDO_PIN 5
  10. #define PROBE_PIN 6
  11. #define PROBE_ANALOG_PIN A0
  12. #define JTAG_ANALOG_PIN A1
  13. #define V_ANALOG_PIN A2
  14. #define I_ANALOG_PIN A3
  15. #define LED 13
  16.  
  17. // Use macros from avr/sfr_defs.h #define _BV(bit) (1 << (bit))
  18. // A - must be defined as uint8_t*
  19. #define setBit(A,k)   ( A[(k/8)] |= _BV(k%8) )
  20. #define clrBit(A,k)   ( A[(k/8)] &= ~_BV(k%8) )            
  21. #define getBit(A,k)   ( (A[(k/8)] & _BV(k%8)) >> (k%8) )
  22.  
  23. #define j_Clock(x, y) j_Clock_fast(x, y)
  24. //#define j_Clock(x, y) j_Clock_slow(x, y)
  25.  
  26. struct j_EepromObject {
  27.   uint32_t BOUNDLN;
  28.   uint32_t INSTRLN;
  29.   uint32_t SAMPLE;
  30. };
  31.  
  32. int BDRlen, IRlen, nDevices;
  33. char inByte = 0;
  34. char regState = 0;
  35. char preChar[4] = {'-', '\\', '|', '/'};
  36. uint8_t preCharCount = 0;
  37. uint32_t BOUNDLN = 1488; // BOUNDARY_LENGTH
  38. uint32_t INSTRLN = 10;   // INSTRUCTION_LENGTH
  39. uint32_t SAMPLE = 0x00000005;
  40. uint32_t EXTEST = 0x0000000F;
  41. uint32_t DRcontrol = 1207;
  42. uint32_t DRoutput = 1208;
  43. j_EepromObject j_Eeprom;
  44. uint32_t idcode[10];     // IDCODE_REGISTER = 4-bit Version + 16-bit Part Number + 11-bit Manufacturer's ID + "1" Mandatory LSB
  45. uint8_t dr0[MAXREG8];
  46. uint8_t dr1[MAXREG8];
  47. uint8_t dr2[MAXREG8];
  48.  
  49. uint8_t j_Clock_slow(uint8_t TDI, uint8_t TMS) {
  50.   uint8_t result;
  51.   digitalWrite(TDI_PIN, TDI);
  52.   digitalWrite(TMS_PIN, TMS);
  53.   result = digitalRead(TDO_PIN);
  54.   digitalWrite(TCK_PIN, HIGH);
  55.   digitalWrite(TCK_PIN, LOW);
  56.   return result;
  57. }
  58.  
  59. // Only if ALL pins map to PORTD
  60. uint8_t j_Clock_fast(uint8_t TDI, uint8_t TMS) {
  61.   uint8_t result, tempPORTD;
  62.   tempPORTD = PORTD;
  63.   if (TDI == 0) tempPORTD &= ~_BV(TDI_PIN); else tempPORTD |= _BV(TDI_PIN);
  64.   if (TMS == 0) tempPORTD &= ~_BV(TMS_PIN); else tempPORTD |= _BV(TMS_PIN);
  65.   PORTD = tempPORTD;
  66.   result = (PIND >> TDO_PIN) & 0x01;  // result = digitalRead(TDO_PIN)
  67.   tempPORTD |= _BV(TCK_PIN);          //digitalWrite(TCK_PIN, HIGH)
  68.   PORTD = tempPORTD;
  69.   tempPORTD &= ~_BV(TCK_PIN);         //digitalWrite(TCK_PIN, LOW);
  70.   PORTD = tempPORTD;
  71.   return result;
  72. }
  73.  
  74. void j_RunIdle_ShiftIR() {
  75.   j_Clock(0, 1); j_Clock(0, 1); j_Clock(0, 0); j_Clock(0, 0);
  76. }
  77. void j_RunIdle_ShiftDR() {
  78.   j_Clock(0, 1); j_Clock(0, 0); j_Clock(0, 0);
  79. }
  80. void j_Exit1xx_RunIdle() {
  81.   j_Clock(0, 1); j_Clock(0, 0);
  82. }
  83. void j_Shiftxx_RunIdle() {
  84.   j_Clock(0, 1);
  85.   j_Exit1xx_RunIdle();
  86. }
  87. void j_Any_Reset_RunIdle() {
  88.   for(int i = 0; i < 10; i++) j_Clock(0, 1);
  89.   j_Clock(0, 0);
  90. }
  91.  
  92. // From ShiftXR => ?RegLen? =>  return to RunIdle
  93. int j_GetChainLength() {
  94.   int i;
  95.   for(i = 0; i < MAX4xR; i++)    j_Clock(0, 0);        // empty the chain (fill it with 0's)
  96.   for(i = 0; i < MAX4xR; i++) if(j_Clock(1, 0)) break; // feed the chain with 1's
  97.   j_Shiftxx_RunIdle();
  98.   return (i == MAX4xR) ? 0 : i;
  99. }
  100. // From ShiftXR => Send <len> bits Data from p[] => return to RunIdle
  101. void j_SendData(uint8_t* p, int len){
  102.   for (int i = 0; i < len; i++){
  103.     j_Clock(getBit(p, i), (len - i) == 1); // at last bit set TMS=1
  104.   }
  105.   j_Exit1xx_RunIdle();
  106. }
  107. // From ShiftXR => Read <len> bits Data into p[] => return to RunIdle
  108. void j_ReadData(uint8_t* p, int len) {
  109.   for (int i = 0; i < len; i++){
  110.     //clrBit(p, i);
  111.     if (j_Clock(0, ((len - i) == 1))) setBit(p, i); // at last bit set TMS=1
  112.   }
  113.   j_Exit1xx_RunIdle();
  114. }
  115.  
  116. // From RunIdle => ShiftIR => put data to IR => return to RunIdle
  117. void j_SetIR(uint32_t ir, uint8_t len) {
  118.   j_RunIdle_ShiftIR();
  119.   j_SendData((uint8_t*) &ir, len);
  120. }
  121. // From RunIdle => ShiftDR => put data to DR => return to RunIdle
  122. void j_SetDR(uint8_t* p, int len) {
  123.   j_RunIdle_ShiftDR();
  124.   j_SendData(p, len);
  125. }
  126. // From RunIdle => ShiftDR => get data from DR => return to RunIdle
  127. void j_GetDR(uint8_t* p, int len) {
  128.   j_RunIdle_ShiftDR();
  129.   j_ReadData(p, len);
  130. }
  131.  
  132. void jInfoScan() {
  133.   j_Any_Reset_RunIdle();
  134.   j_RunIdle_ShiftIR();
  135.   IRlen = j_GetChainLength();
  136.   // we are in BYPASS mode since j_GetChainLength filled the IR chain full of 1's
  137.   // now we can easily determine the number of devices (= DR chain length when all the devices are in BYPASS mode)
  138.   j_RunIdle_ShiftDR();
  139.   nDevices = j_GetChainLength();
  140.   // read the IDCODEs (assume all devices support IDCODE, so read 32 bits per device)
  141.   j_Any_Reset_RunIdle(); // equal JTAG Instruction: IDCODE
  142.   j_GetDR((uint8_t*) idcode, (32 * nDevices));
  143.   j_Any_Reset_RunIdle();
  144.   j_SetIR(SAMPLE, INSTRLN);
  145.   j_RunIdle_ShiftDR();
  146.   BDRlen = j_GetChainLength();
  147.   j_Any_Reset_RunIdle();
  148.   EEPROM.get(0x00, j_Eeprom);
  149.   Serial.println("");
  150.   Serial.print("JTAG Voltage = "); Serial.print(analogRead(JTAG_ANALOG_PIN) * 5.0 / 1023); Serial.println("V");
  151.   Serial.print("SEMPLE inst code = 0x"); Serial.print(SAMPLE, HEX);
  152.     Serial.print("/0x"); Serial.print(SAMPLE, HEX);
  153.     Serial.print("/0x"); Serial.println(j_Eeprom.SAMPLE, HEX);
  154.   Serial.print("IR chain length = "); Serial.print(IRlen);
  155.     Serial.print("/"); Serial.print(INSTRLN);
  156.     Serial.print("/"); Serial.println(j_Eeprom.INSTRLN);
  157.   Serial.print("DR bound ch len = "); Serial.print(BDRlen);
  158.     Serial.print("/"); Serial.print(BOUNDLN);
  159.     Serial.print("/"); Serial.println(j_Eeprom.BOUNDLN);
  160.   Serial.print("Number of device(s) = "); Serial.println(nDevices);
  161.   for (int k = 0; k < nDevices; k++){
  162.     Serial.print(" device #");
  163.     Serial.print(k);
  164.     Serial.print(" IDCODE: 0x");
  165.     Serial.println(idcode[k], HEX);
  166.   }
  167. }
  168.  
  169. void setup() {
  170.   pinMode(LED, OUTPUT);
  171.   pinMode(PROBE_PIN, INPUT);
  172.   pinMode(TCK_PIN, OUTPUT);
  173.   pinMode(TMS_PIN, OUTPUT);
  174.   pinMode(TDI_PIN, OUTPUT);
  175.   pinMode(TDO_PIN, INPUT);
  176.   Serial.begin(115200);
  177.   //while (!Serial) { ;} // wait for serial port to connect. Needed for native USB port only
  178.   for (uint32_t i = 0; i < (BOUNDLN / 8 + 1); i++) {dr2[i] = 0xFF;}
  179. }
  180.  
  181. void loop() {
  182.   pinMode(PROBE_PIN, INPUT);
  183.   digitalWrite(LED, digitalRead(PROBE_PIN));   // turn the LED on|off
  184.   if (Serial.available() > 0) {
  185.     inByte = Serial.read();
  186.     if (inByte == '1') {
  187.       regState = '1';
  188.       Serial.println("Start Slow j_Clock...");
  189.     }
  190.     else if (inByte == '2') {
  191.       regState = '2';
  192.       Serial.println("Start Fast j_Clock...");
  193.     }
  194.     else if (inByte == '3') {
  195.       regState = '3';
  196.       Serial.println("Start Voltage Monitor...");
  197.     }
  198.     else if (inByte == 'w') {
  199.       regState = 'w';
  200.       Serial.println("Write some data to EEPROM.");
  201.       j_Eeprom.SAMPLE = SAMPLE;
  202.       j_Eeprom.INSTRLN = IRlen;
  203.       j_Eeprom.BOUNDLN = BDRlen;
  204.       EEPROM.put(0x00, j_Eeprom);
  205.     }
  206.     else if (inByte == 'r') {
  207.       regState = 'r';
  208.       Serial.println("Read data from EEPROM.");
  209.       EEPROM.get(0x00, j_Eeprom);
  210.       SAMPLE = j_Eeprom.SAMPLE;
  211.       INSTRLN = j_Eeprom.INSTRLN;
  212.       BOUNDLN = j_Eeprom.BOUNDLN;
  213.     }
  214.     else if (inByte == 'h') {
  215.       regState = 'h';
  216.       Serial.println("");
  217.       Serial.println("Write HELP block here...");
  218.     }
  219.     else if (inByte == 's') {
  220.       regState = 's';
  221.       Serial.println("Enter new value for SAMPLE instruction:");
  222.       Serial.setTimeout(10000);
  223.       SAMPLE = strtoul((Serial.readStringUntil('\r')).c_str(),NULL,16);
  224.       Serial.print("SAMPLE = 0x"); Serial.println(SAMPLE, HEX);
  225.     }
  226.     else if (inByte == 'i') {
  227.       regState = 'i';
  228.       jInfoScan();
  229.     }
  230.     else if (inByte == 'm') {
  231.       regState = 'm';
  232.       Serial.println("Set Monitor mode");
  233.       j_Any_Reset_RunIdle();
  234.       j_SetIR(SAMPLE, INSTRLN);
  235.     }
  236.     else if (inByte == 'b') {
  237.       regState = 'b';
  238.       Serial.println("Set Block some pins");
  239.       for (uint32_t i = 0; i < (BOUNDLN / 8 + 1); i++) {dr2[i] = 0xFF;}
  240.       j_Any_Reset_RunIdle();
  241.       j_SetIR(SAMPLE, INSTRLN);
  242.     }
  243.     else if (inByte == 'l') {
  244.       regState = 'l';
  245.       Serial.println("List all Blocked pins:");
  246.       int j = 0;
  247.       for (uint32_t i = 0; i < BOUNDLN; i++) {
  248.         if (getBit(dr2, i) == 0) {
  249.           Serial.print(i);
  250.           Serial.print(" ");
  251.           j++;
  252.         }
  253.       }
  254.       if (j != 0) Serial.println("");
  255.     }
  256.     else if (inByte == 'e') {
  257.       if (regState == 'e') regState = 'E'; else regState = 'e';
  258.       Serial.println("Set EXTEST mode");
  259.       pinMode(PROBE_PIN, INPUT);
  260.       for (uint32_t i = 0; i < (BOUNDLN / 8 + 1); i++) {dr2[i] = 0x00;}
  261.       j_Any_Reset_RunIdle();
  262.       j_SetIR(SAMPLE, INSTRLN);
  263.       j_GetDR(dr2, BOUNDLN);
  264.       for (uint32_t i = 0; i < (BOUNDLN / 8 + 1); i++) {dr0[i] = dr2[i]; dr1[i] = dr2[i];}
  265.       clrBit(dr0, DRcontrol);
  266.       clrBit(dr0, DRoutput);
  267.       clrBit(dr1, DRcontrol);
  268.       setBit(dr1, DRoutput);
  269.       j_SetDR(dr2, BOUNDLN); /*
  270.       Thus, when the change to the EXTEST instruction takes place in the
  271.       Update-IR controller state, known data will be driven immediately from
  272.       the component onto its external connections.
  273.       */
  274.       j_SetIR(EXTEST, INSTRLN);
  275.     }
  276.   }
  277.   if (regState == 'e') {
  278.     j_SetDR(dr0, BOUNDLN);
  279.     delay(900);
  280.     j_SetDR(dr1, BOUNDLN);
  281.     delay(100);
  282.   }
  283.   if (regState == 'E') {
  284.     int i;
  285.     uint32_t v = 0;
  286.     //uint32_t i_0 = 0;
  287.     //uint32_t i_1 = 0;
  288.     uint32_t i_0d = 0;
  289.     uint32_t i_1d = 0;
  290.     v = analogRead(V_ANALOG_PIN);
  291.     Serial.print("Voltage = "); Serial.print(v * 5.0 * (6.82 + 3.32) / (1023 * 3.32), 2);
  292.     Serial.print("(V)   ");
  293.     for(i = 0; i < 100; i++) {
  294.       j_SetDR(dr0, BOUNDLN);
  295.       //i_0 = i_0 + analogRead(I_ANALOG_PIN);
  296.       delay(1);
  297.       i_0d = i_0d + analogRead(I_ANALOG_PIN);
  298.       j_SetDR(dr1, BOUNDLN);
  299.       //i_1 = i_1 + analogRead(I_ANALOG_PIN);
  300.       delay(1);
  301.       i_1d = i_1d + analogRead(I_ANALOG_PIN);
  302.     }
  303.     //Serial.print("(V)   i0 = "); Serial.print(i_0); Serial.print("/"); Serial.print(i_0d);
  304.     //Serial.print("  i1 = "); Serial.print(i_1); Serial.print("/"); Serial.print(i_1d);
  305.     Serial.print("I0 = "); Serial.print(i_0d);
  306.     Serial.print("  I1 = "); Serial.print(i_1d);
  307.     //Serial.print("  i1-i0 = "); Serial.print(int(i_1) - int(i_0));
  308.     Serial.print("  I1-I0 = "); Serial.print(int(i_1d) - int(i_0d));
  309.     Serial.println(" (10uA)");
  310.   }
  311.   if (regState == 'm') {
  312.     for (uint32_t i = 0; i < (BOUNDLN / 8 + 1); i++) {dr0[i] = 0x00; dr1[i] = 0x00;}
  313.     pinMode(PROBE_PIN, OUTPUT);
  314.     digitalWrite(PROBE_PIN, 0);
  315.     j_GetDR(dr0, BOUNDLN);
  316.     digitalWrite(PROBE_PIN, 1);
  317.     j_GetDR(dr1, BOUNDLN);
  318.     pinMode(PROBE_PIN, INPUT);
  319.     int j = 0;
  320.     for (uint32_t i = 0; i < BOUNDLN; i++) {
  321.       if ((getBit(dr0, i) != getBit(dr1, i)) && getBit(dr2, i)) {
  322.         if (j == 0){
  323.           preCharCount++;
  324.           Serial.write(preChar[preCharCount & 0x03]);
  325.           Serial.print(" ");
  326.         }
  327.         Serial.print(i);
  328.         Serial.print(" ");
  329.         j++;
  330.       }
  331.     }
  332.     if (j != 0) Serial.println("");
  333.   }
  334.   else if (regState == 'b') {
  335.     for (uint32_t i = 0; i < (BOUNDLN / 8 + 1); i++) {dr0[i] = 0x00; dr1[i] = 0x00;}
  336.     j_GetDR(dr0, BOUNDLN);
  337.     j_GetDR(dr1, BOUNDLN);
  338.     int j = 0;
  339.     for (uint32_t i = 0; i < BOUNDLN; i++) {
  340.       if ((getBit(dr0, i) != getBit(dr1, i)) && getBit(dr2, i)) {
  341.         clrBit(dr2, i);
  342.         Serial.print(i);
  343.         Serial.print(" ");
  344.         j++;
  345.       }
  346.     }
  347.     if (j != 0) Serial.println("");
  348.   }
  349.   else if (regState == '1') {
  350.     int i;
  351.     for(i = 0; i < MAX4xR; i++) j_Clock_slow(((i >> 1) & 0x01), (i & 0x01));
  352.   }
  353.   else if (regState == '2') {
  354.     int i;
  355.     for(i = 0; i < MAX4xR; i++) j_Clock_fast(((i >> 1) & 0x01), (i & 0x01));
  356.   }
  357.   else if (regState == '3') {
  358.     int i;
  359.     uint32_t v = 0;
  360.     uint32_t i_Z = 0;
  361.     uint32_t i_0 = 0;
  362.     uint32_t i_1 = 0;
  363.     for(i = 0; i < 1000; i++) {
  364.       v = v + analogRead(V_ANALOG_PIN);
  365.       i_Z = i_Z + analogRead(I_ANALOG_PIN);
  366.       pinMode(PROBE_PIN, OUTPUT);
  367.       digitalWrite(PROBE_PIN, 0);
  368.       i_0 = i_0 + analogRead(I_ANALOG_PIN);
  369.       digitalWrite(PROBE_PIN, 1);
  370.       i_1 = i_1 + analogRead(I_ANALOG_PIN);
  371.       pinMode(PROBE_PIN, INPUT);
  372.     }
  373.     Serial.print("Voltage = "); Serial.print(v * 5.0 * (6.82 + 3.32) / (1023000 * 3.32), 4); Serial.print("V     ");
  374.     Serial.print("iZ = "); Serial.print(i_Z); Serial.print("  ");
  375.     Serial.print("i0 = "); Serial.print(i_0); Serial.print("  ");
  376.     Serial.print("i1 = "); Serial.print(i_1); Serial.print("  ");
  377.     Serial.print("i0 - i1 = "); Serial.print(int(i_0) - int(i_1)); Serial.println(" uA");
  378.   }
  379. }
RAW Paste Data