Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- jtag:tutorials:start [Sun. 11.03.2018 15:52] – wikiadmin
+++ jtag:tutorials:start [Sun. 11.03.2018 16:44] – wikiadmin
@@ Zeile 25: / Zeile 25: @@
 Desweiteren brauchst Du einen Pegelwandler um die IO-Signale vom Arduino an den Spannungspegel des JTAG-Chips auf dem Testgerät anzupassen. Such auf ebay nach "Pegelwandler TXS0108" und Du wirst was passendes für wenige Euro finden. **HEY, DAS IST WICHTIG** nicht einfach drauf verzichten, sonst grillst Du womöglich gleich Dein Testgerät. ([[nerdwissen_pegelwandler|Nerd-Wissen: Warum braucht man das?]])
-== Verbinde das ganze so ==
+== Hardware-Aufbau mit Arduino und Pegelwandler ==
+Verbinde das ganze so:
+^ Arduino ^ Pegelwandler HS ^ Pegelwandler LS ^ JTAG-Signal ^ Kabelfarbe ^
+| D7  | H1 | L1 | TCK | Gelb |
+| D8  | H2 | L2 | TMS | Grau |
+| D9  | H3 | L3 | TDI | Grün |
+| D10 | H4 | L4 | TDO | Lila |
 <FOTOS>
+== Arduino-Code dazu ==
+Zunächst definieren wird die Signale mit Namen um sie einfach verwenden zu können:
+<code c>
+#define TCK 7
+#define TMS 8
+#define TDI 9
+#define TDO 10
+</code>
+Dann, im ''setup()'' Teil die Signalrichtungen einstellen:
+<code c>
+void setup()
+{
+  pinMode(TCK, OUTPUT);
+  pinMode(TMS, OUTPUT);
+  pinMode(TDO, OUTPUT);
+  pinMode(TDI, INPUT);
+  digitalWrite(TCK, HIGH);
+  digitalWrite(TMS, HIGH);
+  digitalWrite(TDO, HIGH);
+  digitalWrite(TDI, HIGH);
+}
+</code>
+**Damit ist der grundlegende Aufbau der Schnittstelle erledigt!**
 == Was haben wir nun gelernt? ==
@@ Zeile 48: / Zeile 86: @@
   TDI <------------------------------------------------------'
-Will man also nur die Daten eines bestimmten Chips lesen oder schreiben, muss man wissen an welcher Stelle der Chain sich dieser befindet.
+Die Befehls- und Taktleitung (TMS, TCK) liegt an allen Chips parallel an, was bedeutet das immer alle den gleichen Betriebszustand einnehmen werden.
+== Daten an TDI einlesen ==
-Die Befehls- und Taktleitung liegt an allen parallel an, was bedeutet das immer alle den gleichen Betriebszustand einnehmen werden.
+Die Norm definiert das der Logikpegel (Bit) von TDI bei der steigenden Flanke von TCK in das Schieberegister übernommen wird. Solange TCK also '0' ist, kann TDI von aussen anglegt werden. In Arduino-Code säh das so aus: <code c>
+digitalWrite(TCK, LOW); // wer auch immer vor uns TDI einstellt, kann dies nun nach herzenslust tun...
+digitalWrite(TCK, HIGH); // Hier ist der Spaß vorbei, nun ist der Signalpegel an TDI bindend und darf nicht mehr verändert werden!
+bit = digitalRead(TDI); // Wir können das Bit einlesen und in unser "Schieberegister" stellen.
+data = (data << 1) & bit;
+</code>
+== Daten auf TDO senden ==
+Bei der fallenden Flanke von TCK wird das nächste Bit vom Schieberegister an TDO ausgegeben.
+<code c>
+digitalWrite(TCK, HIGH); // Ausgangszustand
+bit = data & 1;
+digitalWrite(TDO, bit);
+digitalWrite(TCK, LOW);
+data >> 1;
+</code>
+== Daten auf TMS senden ==
-Mit JTAG kann man mehr als einen Chip verbinden. Diese sind dabei datentechnisch in Reihe geschaltet und man nennt das eine "JTAG-Chain". Man kann sich das wie eine Verkettung von Schieberegistern vorstellen:
+TMS ist unidirektional, also eine reine Sendeleitung aus sicht des Test-Adapters und eine reine Empfangsleitung aus Sicht der JTAG-Controller (Chips). Das Bit am TMS-Pin wird bei der steigenden Flanke von TCK von den JTAG-Controllern aller in der Chain befindlichen Chips übernommen und der Zustand der internen Statemachine entsprechend geändert.
+<code c>
+bit = x; // 0 oder 1
+digitalWrite(TCK, LOW);
+digitalWrite(TMS, bit);
+digitalWrite(TCK, HIGH);
+</code>
-Die Kommunikation vom Testadapter (unserem Arduino) mit der Chain erfolgt also seriell. Jeder Chip enthält seinen eigenen JTAG-Controller. Sein Betriebsmodus bestimmt, was mit den einfließenden Daten an TDI zu tun ist und welche Daten an TDO anliegen. Dieser Modus wird über die separate TMS-Leitung eingestellt, ebenfalls seriell.
+== Welche Betriebszustände kennt der JTAG-Controller und wozu dienen diese? ==
-Zur Synchronisation dient das Clocksignal TCK. Bei der steigenden, bzw. fallenden Flanke des Signals werden bestimmte Ein-, Ausgangssignale verarbeitet. Man muss wissen das TCK und TMS im Gegensatz zu TDI und TDO bei allen JTAG-Chips einer Chain parallel anliegen. Man steuert also über TMS nicht nur einen Chip sondern alle und der Betriebszustand ist immer für alle gleich.
+Nach dem einschalten befindet sich der JTAG-Controller im Betriebszustand "Test-Logic-Reset". Solange am TMS-Pin ein HIGH-Pegel anliegt wird dieser Zustand nicht verlassen, egal wieviele Takte an TCK passieren. Man nennt diesen Zustand einen "stabilen Zustand". Stabil, weil man so an TDI Daten hineintakten kann, ohne das sich dadurch der Zustand ändert.
-===== Anzahl der JTAG-Controller einer Chain bestimmen =====
+In diesem Zustand passiert JTAG-mäßig einfach nichts. Der Chip macht was er will oder soll ohne das wir darauf Einfluß nehmen. Eine Statemachine beschreibt die stabilen Zustände und den Übergang dort hin. (Nerd-Wissen ...)
-Es gilt als erstes herauszufinden wieviele Chips in einer Chain verkettet sind. Das ist die Basis für alle weiteren Untersuchungen. Später wirst Du das verstehen!
+Für uns ist wichtig, das man über TMS den Controller dazu veranlassen kann, entweder das Datenregister (''DR'') zwischen TDI und TDO zu verbinden, oder das Befehlsregister (''IR''). Sobald man das getan hat, gehen die an TDI eingetakteten Bits in das jeweilige Register. Hat man alle Bits so eingetaktet, weist man den Controller über TMS an die Daten zu übernehmen. Im Falle vom Befehlsregister wird dann ein bestimmter Betriebszustand angenommen.
+Die JTAG-Norm definiert hier nur wenige:
+  * ''BYPASS'' - Dieser Befehl veranlasst den Chip ein 1-Bit Register zwischen TDI und TDO zu legen. Die darin befindlichen Daten irgnoriert der Chip. Bei jedem Takt wird also das zuletzt darin befindliche Bit auf TDO gelegt und das an TDI in das Register übernommen.
+  * ''EXTTEST'' - Zwischen TDI und TDO wird das sog. "Boundary Scan Register" (BSR) geschaltet. Damit können die IO-Pins des Chips abgefragt oder gesetzt werden.
+  * ''SAMPLE/PRELOAD''
+Darüber hinaus unterstützen manche Chips auch noch diese:
+  * ''IDCODE'' - Es wird ein spezielles register zwiscneh TDI und TDO geschaltet, welches einen 32-Bit breiten Identifizierungscode des Chips enthält.
+  * ''INTEST'' - Wie EXTTEST, jedoch werden nicht die physikalischen Pins gelesen oder beschrieben, sondern die Signale der Core-Logic.
+----
+Will man also nur die Daten eines bestimmten Chips lesen oder schreiben, muss man wissen an welcher Stelle der Chain sich dieser befindet.
+Mit JTAG kann man mehr als einen Chip verbinden. Diese sind dabei datentechnisch in Reihe geschaltet und man nennt das eine "JTAG-Chain". Man kann sich das wie eine Verkettung von Schieberegistern vorstellen:
+Die Kommunikation vom Testadapter (unserem Arduino) mit der Chain erfolgt also seriell. Jeder Chip enthält seinen eigenen JTAG-Controller. Sein Betriebsmodus bestimmt, was mit den einfließenden Daten an TDI zu tun ist und welche Daten an TDO anliegen. Dieser Modus wird über die separate TMS-Leitung eingestellt, ebenfalls seriell.
+Zur Synchronisation dient das Clocksignal TCK. Bei der steigenden, bzw. fallenden Flanke des Signals werden bestimmte Ein-, Ausgangssignale verarbeitet. Man muss wissen das TCK und TMS im Gegensatz zu TDI und TDO bei allen JTAG-Chips einer Chain parallel anliegen. Man steuert also über TMS nicht nur einen Chip sondern alle und der Betriebszustand ist immer für alle gleich.
+===== Anzahl der JTAG-Controller einer Chain bestimmen =====
+Es gilt als erstes herauszufinden wieviele Chips in einer Chain verkettet sind. Das ist die Basis für alle weiteren Untersuchungen. Später wirst Du das verstehen!
 Nach dem einschalten des Chips befindet sich der Controller im Zustand "Test-Logic Reset". Im Modus "Shift IR" verbindet der Controller das Befehlsregister an TDI+TDO. Dann kann man einen JTAG-Befehl senden. Oder im Modus "Shift DR" die Scandaten des Chips auslesen oder einschreiben. Dazu später mehr.