API tools faq
paste
Guest User

jtag knock EXTEST

a guest
Jul 4th, 2020
315
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 12.24 KB | None | 0 0
raw download clone embed print report
  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. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!