ELV UP2000 Protokoll
Dieser Artikel beschreibt das Protokoll des Programmiergerätes UP2000 des Versandhauses und Verlags ELV.
Einleitung
Der Verlag ELV brachte um 1995 ein Universalprogrammiergerät UP95 heraus, das später zum UP2000 durch neue Software aktualisiert werden konnte. Mit der Aktualisierung wurde die Auswahl der verfügbaren Bausteine vergößert und das Protokoll erweitert. Für viele alte Speicherbausteine und Mikrokontroller leistet dieses Gerät noch gute Dienste.
In diesem Artikel wird das analysierte Protokoll zwischen PC und Programmiergerät vorgestellt. Sämtliche Angaben beruhen auf Informationen, die beim Protokollieren der seriellen Übertragungen gemacht wurden und auf Analyse der als Hex-Datei vorliegenden Firmware ("99125 Version 24.hex"). Sie werden ohne Gewährleistung auf Richtigkeit oder Vollständigkeit dargestellt. Alle Namen sind frei erfunden und haben möglicherweise nichts mit der vom Entwickler beabsichtigten Funktion zu tun. Die zu Grunde liegende Software gibt es hier[1].
Serielle Schnittstelle
Die Verbindung vom PC zum UP2000 erfolgt über RS232[2]. Mindestens RxD, TxD und CTS müssen kontaktiert sein sein.
Als Geschwindigkeiten werden vom UP2000 die Baudraten 9600 Baud, 19200 Baud, 38400 Baud und 57600 Baud unterstützt (siehe auch Baudrate einstellen). Initial kommuniziert der UP2000 mit 9600 Baud. Bei allen Baudraten werden 2 Stoppbits und ungerade Parität (ODD) verwendet.
Über CTS (Clear To Send) signalisiert der UP2000 dem PC, daß er zum Empfang von Daten bereit ist. Das entsprechende PC-Programm muß also den Status prüfen und darf nur Daten senden, solange CTS aktiv ist.
Rahmenaufbau
Der Informationsaustauch zwischen UP2000 und PC geschieht durch Austausch von Datensätzen (Frames) variabler Länge. Jeder Frame ist dabei durch ein Startzeichen und ein Endezeichen gekennzeichnet. Dazwischen befinden sich die mit FrameData bezeichnenten Daten.
- PC sendet Datensatz zu UP2000 (Request Frame):
01 (SORF) FrameData 04 (EORF)
SORF - Start Of Request Frame
EORF - End Of Request Frame
- UP2000 antwortet mit Datensatz an PC (Answer Frame);
02 (SOAF) FrameData 03 (EOAF)
SOAF - Start Of Answer Frame
EOAF - End Of Answer Frame
Fluchtzeichen und Fluchtsequenzen
Die Charakter, die zum Einschließen der Frames verwendet werden, dürfen innerhalb dieser nicht auftauchen. Deshalb werden sie mittels Fluchtzeichen umschrieben. Das Fluchtzeichen (oder Escapezeichen, hier 0x10) selbst muß auch umschrieben werden.
Es gelten folgende Ersetzungen:
- für Request Frame:
(SORF) 0x01 --> 0x10 0x11
(EORF) 0x04 --> 0x10 0x14
(ESC) 0x10 --> 0x10 0x20
- für Answer Frame:
(SOAF) 0x02 --> 0x10 0x12
(EOAF) 0x03 --> 0x10 0x13
(ESC) 0x10 --> 0x10 0x20
Die Berechnung der Checksummen (siehe Berechnung des CRC), die Bestandteil der FrameData sind, erfolgt im Sender vor dem Ersetzen mit Fluchtzeichen, entsprechend müssen im Empfänger vor dem Prüfen der Checksumme alle Fluchtsequenzen aufgehoben werden.
Nachrichten
Alle Nachrichten (FrameData) haben folgenden Aufbau:
FrameData Message CRC-16 MsgType DataByte1 .. DataByteN CRCH CRCL
MsgType - Message Type
CRCH - CRC-16 high byte
CRCL - CRC-16 low byte
Je nach Nachrichtentyp sind 0 (Null) bis N Datenbytes möglich.
- Nachrichtentypen für Request Frames
Message Type Message Name 0x2B SetLED 0x2D SetBaudRate 0x30 SetVcc6V 0x31 SetVppState 0x32 SetVppValue 0x33 SetPinState 0x34 ? 0x35 ? 0x36 ? 0x37 ? 0x38 GetPinStatus 0x39 DisconnectTarget 0x41 WriteBuffer 0x42 ReadBuffer 0x43 ConnectTarget 0x44 WriteTarget 0x45 ReadTarget 0x4C BlankTest 0x53 GetStatus 0x55 GetResultOfRB 0x61 SetAddrWidth 0x62 SetAddrPin 0x63 GetAddrPinConfig 0x64 SetDataWidth 0x65 SetDataPin 0x66 GetDataPinConfig
- Nachrichtentypen für Answer Frames
Message Type Message Subtype Message Name 0x06 0x20 ACK 0x06 0x44 SendBuffer 0x06 0x55 SendResultOfRB 0x06 0x61 SendAddrPinConfig 0x06 0x62 SendDataPinConfig 0x06 0x78 SendStatus 0x15 - NACK
Beschreibung der einzelnen Nachrichtentypen
SetLED (0x2B)
Schaltet die LEDs des Programmers. Bits 0 und 1 des DataBytes repräsentieren je eine LED.
Message 0x2B DB1
DB1: 0=on, 1=off - Bit 0: grüne LED
Bit 1: rote LED
SetBaudRate (0x2D)
Die Baudrate der seriellen Schnittstelle kann mit diesem Kommando gesetzt werden. DB1 und DB2 enthalten den gleichen Wert.
Message 0x2D DB1 DB2
DB1, DB2 = 0x30: 9600 Baud
DB1, DB2 = 0x31: 19200 Baud
DB1, DB2 = 0x32: 38400 Baud
DB1, DB2 = 0x33: 57600 Baud
SetVcc6V (0x30)
Mit dieser Nachricht ist es möglich die Versorgungsspannung Vcc zwischen 5 V und 6 V umzuschalten.
Message 0x30 DB1
DB1 = 0x30: Vcc 5V
DB1 = 0x31: Vcc 6V
SetVppState (0x31)
Zu- oder abschalten der Programmierspannung Vpp.
Message 0x31 DB1
DB1 = 0x30: Vpp aus
DB1 = 0x31: Vpp ein
SetVppValue (0x32)
Setzen der Programmierspannung Vpp. Der Wert des Datenbytes DB1 wird dabei in den Digital-Analog-Wandler IC AD7524 (IC4) geschrieben.
Message 0x32 DB1
DB1 < 9: Rückgabe NACK mit Error-Code 0x36 DB1 = 9: nutze den schon bekannten Wert DB1 > 9: übermittelter Wert wird in den DAC geschrieben und gemerkt
Beispielwerte für DB1 und resultierende Programmierspannung Vpp (exemplarabhängig!):
- 0xA -> 1,94V; 0x6E -> 11,5V; 0x96 -> 15,6V; 0xFA -> 25,4V.
SetPinState (0x33)
Mit dieser Nachricht kann der Pinstatus jedes Pins des Textoolsockels gesetzt werden.
Message 0x33 DB1 DB2
DB1: Textool-Pinnummer (kodiert) Pin1 -> 0x30, Pin2 -> 0x31, .., Pin40 -> 0x57
DB2: Pinstatus 0x30 = LOW, 0x31 = FREE, 0x32 = HIGH, 0x33 = SPECIAL
(0x34)
Debug-Nachricht?
Message 0x34 DB1 DB2 DB3
(0x35)
Debug-Nachricht?
Message 0x35 DB1 DB2
(0x36)
Debug-Nachricht?
Message 0x36
(0x37)
Debug-Nachricht?
Message 0x37
GetPinStatus (0x38)
Abfragen der Pins des Textool-Sockels.
Message 0x38
- Antwort-Frame: SendPinStatus, NACK
DisconnectTarget (0x39)
Alle Pins des Textool-Sockels werden auf FREI (Tristate) geschaltet. Diese Nachricht bildet den Abschluß einer jeden Lese-, Schreib- oder Testsequenz.
Message 0x39
WriteBuffer (0x41)
Übertragen von Daten vom PC zum UP2000 internen Pufferspeicher.
Message 0x41 DB1 DB2 DB3 .. DB130
DB1: Puffer-Startadresse (16-bit) HIGH-Byte
DB2: Puffer-Startadresse (16-bit) LOW-Byte
DB3 .. DB130: max. 128 Datenbytes
ReadBuffer (0x42)
Anforderung gespeicherter Daten aus dem UP2000 internen Pufferspeicher und übertragen zum PC.
Message 0x42 DB1 DB2 DB3
DB1: Puffer-Startadresse (16-bit) HIGH-Byte
DB2: Puffer-Startadresse (16-bit) LOW-Byte
DB3: Länge - 1 + 0x80
Bsp.: Anforderung von 32 Bytes: DB3 -> 0x9F
Anforderung von 53 Bytes: DB3 -> 0xB4
Anforderung von 128 Bytes: DB3 -> 0xFF
- Antwort-Frame: SendBuffer, NACK
ConnectTarget (0x43)
Diese Nachricht (Länge 112 Bytes) wird zu Beginn einer jeden Lese-, Schreib- oder Testsequenz gesendet. Damit werden die Pins und Spannungen am Textool-Sockel konfiguriert.
Message 0x43 wdtA wdtD Wpp Wcc V6V TppH TppL TnpH TnpL Loop DB1 DB2 DB3 DB4 DB5 DB6 DB7 DB8 DB9 DB10 DB11 DB12 DB13 DB14 DB15 DB16 DB17 DB18 DB19 DB20 DB21 A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16 A17 A18 A19 A20 A21 A22 A23 D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 D13 D14 D15 PIN1 PIN2 PIN3 PIN4 PIN5 PIN6 PIN7 PIN8 PIN9 PIN10 PIN11 PIN12 PIN13 PIN14 PIN15 PIN16 PIN17 PIN18 PIN19 PIN20 PIN21 PIN22 PIN23 PIN24 PIN25 PIN26 PIN27 PIN28 PIN29 PIN30 PIN31 PIN32 PIN33 PIN34 PIN35 PIN36 PIN37 PIN38 PIN39 PIN40
wdtA: Adressbreite (max. 0x18)
wdtD: Datenbreite (max. 0x10)
Wpp: DAC-Wert für Vpp im Programmierbetrieb, siehe Berechnung der DAC-Werte
Wcc: DAC-Wert für Vpp im Normalbetrieb, siehe Berechnung der DAC-Werte
V6V: 0 - Versorgungsspannung 5V beim Programmieren
1 - Versorgungsspannung 6V beim Programmieren
TppH,TppL: Programmierimpulslänge kodiert als 16-Bit-Zahl, siehe Berechnung Impulslänge
TnpH,TnpL: Nachprogrammierimpulslänge kodiert als 16-Bit-Zahl, siehe Berechnung Impulslänge
Loop: Anzahl der Durchläufe.
DB1 .. DB21: Algorithmus spezifische Daten, siehe Kodierung der Algorithmen
A0 .. A23: Zuordnung der Adresspins. Der Inhalt des entsprechenden Bytes
gibt den Textool-Pin 1 .. 40 an. 0xFF bedeutet unbelegt.
D0 .. D15: Zuordnung der Datenpins. Der Inhalt des entsprechenden Bytes
gibt den Textool-Pin 1 .. 40 an. 0xFF bedeutet unbelegt.
PIN1 .. PIN40: Pin Konfiguration
0x30 - LOW
0x31 - FREE, Tristate
0x32 - HIGH
0x33 - SPECIAL (Vpp,ProgPuls,ReadPuls, usw.)
Einige Bausteine benötigen zum schreiben, lesen, löschen oder Security Flag
setzen bestimmte Codes an bestimmten Pins,
siehe dazu Algorithmen, Spalte ConnectTarget (Mx Pin)
WriteTarget (0x44)
Schreiben des UP2000 internen Puffers in das Target ab Startadresse für Länge Bytes. Länge darf maximal 0x2000 sein. Mit diesem Kommando können (sofern vorhanden) auch Fuses gesetzt oder gelöscht werden. Dafür enthalten DB5, DB6 an Stelle der Längen spezielle Informationen, siehe Algorithmen
Message 0x44 DB1 DB2 .. DB6
DB1: Startadresse (24-bit) HIGH-Byte
DB2: Startadresse (24-bit) MID-Byte
DB3: Startadresse (24-bit) LOW-Byte
DB4: Programmieralgorithmus, siehe Algorithmen
DB5, DB6: Länge AND 0x7FFF (16-bit),
Ausnahmen (Werte > 0x7FFF) siehe Algorithmen, Spalte WriteTarget
- Antwort-Frame: ACK, SendStatus, NACK
ReadTarget (0x45)
Auslesen eines Bereiches ab Startadresse für Länge Bytes des Target in den UP2000 internen Puffer. Länge darf maximal 0x2000 sein.
Message 0x45 DB1 DB2 .. DB6
DB1: Startadresse (24-bit) HIGH-Byte
DB2: Startadresse (24-bit) MID-Byte
DB3: Startadresse (24-bit) LOW-Byte
DB4: Lesealgorithmus, siehe Algorithmen
DB5: Länge (16-bit) HIGH-Byte
DB6: Länge (16-bit) Low-Byte
- Antwort-Frame: ACK, SendStatus, NACK
BlankTest (0x4C)
Mit dieser Nachricht wird der Leer-Test ab Startadresse für Länge Bytes ausgeführt. Danach kann das Ergebnis mittels GetStatus abgefragt werden und wird mit SendStatus zurück übermittelt.
Message 0x4C DB1 DB2 .. DB7
DB1: Startadresse (24-bit) HIGH-Byte
DB2: Startadresse (24-bit) MID-Byte
DB3: Startadresse (24-bit) LOW-Byte
DB4: Leertestalgorithmus, siehe Algorithmen
DB5: Länge (24-bit) HIGH-Byte
DB6: Länge (24-bit) MID-Byte
DB7: Länge (24-bit) LOW-Byte, immer 0x00
- Antwort-Frame: ACK, SendStatus, NACK
GetStatus (0x53)
Diese Nachricht dient zum Abfragen von internen Zuständen des Programmers, z.B. den des Tasters, ob gerade ein Zugriff auf den Baustein erfolgt oder das Ergebnis des letzten BlankTests.
Message 0x53
- Antwort-Frame: SendStatus, NACK
GetResultOfRB (0x55)
(Unsicher) Get Result Of ReadBuffer
Message 0x55
- Antwort-Frame: SendResultOfRB, NACK
SetAddrWidth (0x61)
Debug-Nachricht. Setzt die Adressbreite des Zielbausteins.
Message 0x61 DB1
DB1: Adressbreite kodiert mit Offset 0x30
gültige Werte: {0x30 (0 - bit)} .. 0x48 (24 bit)
ungültiger Wert erzeugt NACK mit Fehlercode 0x36
SetAddrPin (0x62)
Debug-Nachricht. Verknüpft ein Pin des Textool Sockels mit einer Adressleitung.
Message 0x62 DB1 DB2
DB1: Adressleitung A0 .. A23 kodiert mit Offset 0x30
gültige Werte: A0 --> 0x30, A1 --> 0x31, .., A23 --> 0x47
DB2: Textool-Pin 1 .. 40 kodiert mit Offset 0x2F
gültige Werte: Pin1 -> 0x30, Pin2 -> 0x31, .., Pin40 -> 0x57
ungültige Werte erzeugen NACK mit Fehlercode 0x36
GetAddrPinConfig (0x63)
Debug-Nachricht. Fragt die Konfiguration der Adressleitungen bezüglich der Textool-Pins ab.
Message 0x63
- Antwort-Frame: SendAddrPinConfig, NACK
SetDataWidth (0x64)
Debug-Nachricht. Setzt die Datenbreite des Zielbausteins.
Message 0x64 DB1
DB1: Datenbreite kodiert mit Offset 0x30
gültige Werte: {0x30 (0 - bit)} .. 0x10 (16 bit)
ungültiger Wert erzeugt NACK mit Fehlercode 0x36
SetDataPin (0x65)
Debug-Nachricht. Verknüpft ein Pin des Textool Sockels mit einer Datenleitung.
Message 0x65 DB1 DB2
DB1: Datenleitung D0 .. D15 kodiert mit Offset 0x30
gültige Werte: D0 --> 0x30, D1 --> 0x31, .., D15 --> 0x3F
DB2: Textool-Pin 1 .. 40 kodiert mit Offset 0x2F
gültige Werte: Pin1 -> 0x30, Pin2 -> 0x31, .., Pin40 -> 0x57
ungültige Werte erzeugen NACK mit Fehlercode 0x36
GetDataPinConfig (0x66)
Debug-Nachricht. Fragt die Konfiguration der Datenleitungen bezüglich der Textool-Pins ab.
Message 0x66
- Antwort-Frame: SendDataPinConfig, NACK
ACK
Das ist die allgemeine Acknowledge-Antwort.
Message ACK AckSubType 0x06 0x20
SendBuffer
Acknowledge-Antwort auf ReadBuffer.
Message ACK AckSubType Data 0x06 0x44 DB1 DB2 .. DB128
Es werden maximal 128 Datenbytes übertragen. Die genaue Anzahl ergibt sich aus der in ReadBuffer gemachten Anfrage.
SendResultOfRB
Acknowledge-Antwort auf GetResultOfRB. (Unsicher) Sendet das Ergebnis des Leseprozesses vom Target-IC zum UP2000 internen Pufferspeicher.
Message ACK AckSubType Data 0x06 0x55 DB1 DB2 DB3 DB4
DB1 .. DB4: 0x00 - kein Lesefehler
SendAddrPinConfig
Das ist die Acknowledge-Antwort auf einen GetAddrPinConfig.
Message ACK AckSubType Data 0x06 0x61 DB1 DB2 .. DB24
DBn: entspricht der Adressleitung + 1: A0 -> DB1, A1 -> DB2, .. , A23 -> DB24
in DBn steht (kodiert) der zugeordnete
Textool-Pin: Pin1 -> 0x30, Pin2 -> 0x31, .., Pin40 -> 0x57
SendDataPinConfig
Das ist die Acknowledge-Antwort auf einen GetDataPinConfig.
Message ACK AckSubType Data 0x06 0x62 DB1 DB2 .. DB16
DBn: entspricht der Datenleitung + 1: D0 -> DB1, D1 -> DB2, .., D15 -> DB16
in1 DBn steht (kodiert) der zugeordnete
Textool-Pin: Pin1 -> 0x30, Pin2 -> 0x31, .. , Pin40 -> 0x57
SendPinStatus
Das ist die Acknowledge-Antwort auf einen GetPinStatus.
Message ACK AckSubType Data 0x06 0x6C DB1 DB2 DB3 DB4 DB5
Zuordnung der Pins zu den DatenBytes:
Bit 7: Bit 6: Bit 5: Bit 4: Bit 3: Bit 2: Bit 1: Bit 0:
DB1: PIN_12 PIN_11 PIN_10 PIN_09 PIN_08 PIN_07 PIN_06 PIN_05
DB2: PIN_20 PIN_19 PIN_18 PIN_17 PIN_16 PIN_15 PIN_14 PIN_13
DB3: PIN_28 PIN_27 PIN_26 PIN_25 PIN_24 PIN_23 PIN_22 PIN_21
DB4: PIN_36 PIN_35 PIN_34 PIN_33 PIN_32 PIN_31 PIN_30 PIN_29
DB5: PIN_04 PIN_03 PIN_02 PIN_01 PIN_40 PIN_39 PIN_38 PIN_37
Das Bit ist 0, wenn zugehöriger PIN_xx LO ist. In allen anderen Fällen (PIN_xx = HI,
Special, FREE) ist das entsprechende Bit gesetzt.
SendStatus
Acknowledge-Antwort. Diese Nachricht wird als Antwort auf verschiedene Request-Nachrichten verwendet. Zum einen schickt sie der Programmer mehrfach nach ReadTarget und zeigt damit den Fortschritt des Übertragens der Daten vom Zielbaustein in den UP2000 internen Pufferspeicher an (Addr_xx zählt hoch). Zum anderen wird diese Nachricht als Antwort auf einen GetStatus verwendet.
Message ACK AckSubType Data 0x06 0x78 DB1 DB2 DB3 DB4 DB5
DB1: 0x24
DB2: Status - Bit 0: Tasterstatus 0 - frei
1 - gedrückt
Bit 1: I(Vcc) zu hoch
Bit 2: I(Vpp) zu hoch
Bit 3: ?
Bit 4: 0 - Lesen-Algorithmus oder
Schreiben-Algorithmus oder
BlankCheck-Algorithmus arbeitet
1 - Textool Sockel frei
Bit 5: 0 - Baustein nicht leer
1 - Baustein ist leer
Bit 6: 0
Bit 7: 1
DB3: Adresse (24-bit) LOW-Byte
DB4: Adresse (24-bit) MID-Byte
DB5: Adresse (24-bit) HIGH-Byte
NACK
Das ist die allgemeine Negative Acknowledge-Antwort.
Message 0x15 DB1
DB1: Fehlercode - 0x34 Unknown Message Type
0x36 Parameter Value Out Of Range
Kodierung der Lese-, Programmier- und Testalgorithmen
In den Nachrichten WriteTarget, ReadTarget und BlankTest wird der zu verwendende Algorithmus entsprechend des Ziel-ICs in einem Byte kodiert. Einige Nachrichten benötigen je nach Algorithmus zusätzliche Informationen. Diese sind hier ebenfalls dargestellt. Zum besseren Verständnis der einzelnen Werte, siehe auch die zur PC-Software mitgelieferten *.up-Beschreibungsdateien.
Byte Algorithmus DataBytes der Nachricht ConnectTarget Codierung des Sub-Algorithmus in Nachricht WriteTarget 0x01 Standard DB1: Prog Puls Pin, NB DB2: Read Puls Pin, NB DB6: Vpp Pin, NB
0x01 Standard 2 pass 0x02 Vpp Extra Standard 2 pass 0x02 Vpp Extra Standard 0x05 2716 0x06 IIC DB1: SDA Pin, NB DB2: SCL Pin, NB
0x07 Microwire DB1: SDA Pin, NB DB2: SCL Pin, NB DB3: SDI Pin, NB DB4: SCE Pin, NB DB9,DB10: MW Read Code DB11,DB12: MW Enable Code DB13,DB14: MW Disable Code DB15,DB16 MW Erase Code DB17,DB18: MW Write Code
0x08 PIC seriell ?
0x09 PIC parallel ?
0x0A MCS51 DB1: Prog Puls Pin, NB DB2: Read Puls Pin, NB DB6: Vpp Pin, NB PINy: Mx Pin, x=1..n
PINy hat Wertigkeit 2(x-1) Binäre Kodierung der nächsten Aktion (schreiben, lesen, löschen, verify,..), ausgelöst durch WriteTarget. Schreibe aus *.up Datei für 0 - 0x30, 1 - 0x32 in Piny.
Security Flags programmieren: DB5: 0x80 DB6: 0x010x0B MCS 75x DB1: Prog Puls Pin, NB DB3: ALE Pin, NB DB6: Vpp Pin, NB DB7: ModH DB8: ModL ModH, ModL kodieren als 16-bit Zahl den Modus, d.h die nächste Aktion (schreiben, lesen, löschen, verify,..), ausgelöst durch WriteTarget.
0x0C P-EEPROM Standard DB1: Prog Puls Pin, NB DB2: Read Puls Pin, NB
0x0D P-EEPROM Data Polling 0x0F P-EEPROM Ready/Busy DB1: Prog Puls Pin, NB DB2: Read Puls Pin, NB DB3: ALE Pin, NB
0x10 SAMSUNG-OTP DB1: SDA Pin, NB DB2: SCL Pin, NB DB5: Vdd Pin, NB DB6: Vpp Pin, NB
0x11 Flash MCS51 DB1: Prog Puls Pin, NB DB2: Read Puls Pin, NB DB3: Busy Pin, NB DB6: Vpp Pin, NB PINy: Mx Pin, x=1..n
PINy hat Wertigkeit 2(x-1) Binäre Kodierung der nächsten Aktion (schreiben, lesen, löschen, verify,..), ausgelöst durch WriteTarget. Schreibe aus *.up Datei für 0 - 0x30, 1 - 0x32 in Piny.
Security Flags programmieren: DB5: 0x80 DB6: 0x01 Baustein löschen: DB5: 0x90 DB6: 0x000x12 Flash S MCS51 Security Flags programmieren: DB5: 0x80 DB6: 0x01 Baustein löschen: DB5: 0xA8 DB6: 0x000x13 Flash HS MCS51 DB1: Prog Puls Pin, NB DB2: Read Puls Pin, NB DB3: Busy Pin, NB DB5: CLOCK Pin, NB PINy: Mx Pin, x=1..n
PINy hat Wertigkeit 2(x-1) Binäre Kodierung der nächsten Aktion (schreiben, lesen, löschen, verify,..), ausgelöst durch WriteTarget. Schreibe aus *.up Datei für 0 - 0x30, 1 - 0x32 in Piny.
Security Flags programmieren: DB5: 0x80 DB6: 0x01 Baustein löschen: DB5: 0x90 DB6: 0x000x14 ZiLog 1 DB1: Prog Puls Pin, NB DB2: Read Puls Pin, NB DB4: Clear Pin, NB DB5: Clock Pin, NB DB6: Vpp Pin, NB DB8: Kodieren des Sub-Algorithmus 0x0: lesen 0x0: schreiben 0x0: verifizieren 0x0: Blanktest 0xB: EPROM protect 0xC: Autolatch 0xD: Low EMI 0xE: EPROM test 0xF: Watchdog PINy: Mx Pin, x=1..nPINy hat Wertigkeit 2(x-1) Ternäre Kodierung der nächsten Aktion (schreiben, lesen, löschen, verify,..), ausgelöst durch WriteTarget. Schreibe aus *.up Datei für L - 0x30, H - 0x32, P - 0x33 in Piny.
0x15 ZiLog 2 DB1: Prog Puls Pin, NB DB2: Read Puls Pin, NB DB6: Vpp Pin, NB DB8: Kodieren des Sub-Algorithmus 0x0: lesen 0x0: schreiben 0x0: verifizieren 0x0: Blanktest 0xA: EPROM protect 0xD: RC Osc 0x11: RAM protect PINy: Mx Pin, x=1..nPINy hat Wertigkeit 2(x-1) Ternäre Kodierung der nächsten Aktion (schreiben, lesen, löschen, verify,..), ausgelöst durch WriteTarget. Schreibe aus *.up Datei für L - 0x30, H - 0x32, P - 0x33 in Piny.
0x16 S-IIC DB1: SDA Pin, NB DB2: SCL Pin, NB
0x17 FLASH EPROM DB1: Prog Puls Pin, NB DB2: Read Puls Pin, NB DB3: Sub-Algorithmus 0x00: Baustein lesen, schreiben, löschen 0x01: Security Flag setzen 0x02: Security Flag löschen DB4: SCE Pin, NB DB8: Page, NBBaustein löschen: DB5: 0x80 DB6: 0x000x18 FLASH BYTE EPROM DB1: Prog Puls Pin, NB DB2: Read Puls Pin, NB DB4: SCE Pin, NB
NB - nullbasiert: Das Datum wird als Wert - 1 eingetragen, d.h. ist in der *.up Konfigurationsdatei ein Wert mit 1 angegeben, wird 0 übertragen, für einen Wert 2 erfolgt die Übertragung von 1, usw.
Berechnung des CRC
Als CRC kommt ein 16-Bit Cyclic Redundancy Check mit dem Generator-Polynom 0x1021 zur Anwendung. Der CRC wird beginnend mit dem Startkennzeichen der Frames (01 oder 02) über den MsgType und -sofern vorhanden- alle DataBytes berechnet. Zusätzlich werden 2 Null-Bytes in die Berechnung einbezogen.
Zur Berechnung kann folgendes Pascal-Programm (genauer die Funktion CRC16ofUP2000frame) verwendet werden:
program CRC16_UP2000;
// Demo-Programm zur Berechnung des CRC16 im Protokoll des
// ELV Programmers UP2000
// Autor: HTs 06/2021
uses
sysutils;
//Testdaten zum verifizieren:
const
rf: array[0..10] of byte = ( $01, $45, $00, $00, $00, $05, $02, $10, $7C, $3B, $04);
af: array[0..5] of byte = ( $02, $06, $20, $E0, $A4, $03);
function CRC16ofUP2000frame(frame: array of byte):word;
const
CRC16polynom: Word = $1021;
var
crc: word;
i: longint;
procedure calcCRC16(b: byte);
var
n: longint;
b1: byte;
k: longint;
begin {calcCRC16}
for n := 0 to 7 do
begin
b1 := byte(b shl n) div 128; //Test auf Bit b(7-n)=1 nach b1
k := (crc shl 1) + b1 ;
crc := (k and $ffff);
if k > $ffff then
crc:= crc xor CRC16polynom;
end;
end; {calcCRC16}
begin {CRC16ofUP2000frame}
crc := frame[0]; // initialisiere crc mit erstem Byte aus Array
for i:=1 to length(frame)-4 do
calcCRC16(frame[i]);
calcCRC16(0); //es werden 2 x crc-Berechnung aus Null angehaengt,
calcCRC16(0); //
result := crc;
end; {CRC16ofUP2000frame}
begin
writeln ('crc rf: ', IntToHex(CRC16ofUP2000frame(rf),4)); //Ergebnis: 7C3B
writeln ('crc af: ', IntToHex(CRC16ofUP2000frame(af),4)); //Ergebnis: E0A4
end.
Protokolle
Lesen
Protokoll für Baustein lesen
PC UP2000
SetupDevice ---------------------------->
<------------------------- ACK
n-mal (8k-Blöcke):
+-> m-mal (128 Byte Blöcke):
| ReadTarget ---------------------------->
| <------------------------- ACK
| <------------------------- k-mal SendStatus
| ReadBuffer 0 ---------------------------->
| <------------------------- SendBuffer
| ReadBuffer 80 ---------------------------->
| <------------------------- SendBuffer
| ReadBuffer 100 ---------------------------->
| <------------------------- SendBuffer
| :
| :
| ReadBuffer max1F80 ---------------------------->
| <------------------------- SendBuffer
+----------------------------------- nein -- alles gelesen?
| ja
v
GetResultOfRB ---------------------------->
<------------------------- SendResultOfRB
DisconnectTarget ---------------------------->
<------------------------- ACK
GetStatus ---------------------------->
<------------------------- SendStatus
Schreiben
Protokoll für Baustein schreiben
PC UP2000
SetupDevice ---------------------------->
<------------------------- ACK
n-mal (8k-Blöcke):
+-> m-mal (128 Byte Blöcke):
| WriteBuffer 0 ---------------------------->
| <------------------------- ACK
| WriteBuffer 80 ---------------------------->
| <------------------------- ACK
| WriteBuffer 100 ---------------------------->
| <------------------------- ACK
| :
| :
| WriteBuffer max1F80 ---------------------------->
| <------------------------- ACK
| WriteTarget ---------------------------->
| <------------------------- ACK
| <------------------------- k-mal SendStatus
+----------------------------------- nein -- alles geschrieben?
| ja
v
DisconnectTarget ---------------------------->
<------------------------- ACK
GetStatus ---------------------------->
<------------------------- SendStatus
Vergleichen
Protokoll für Bausteininhalt mit Inhalt des PC-Buffers vergleichen.
Dies entspricht dem Protokoll für das Lesen mit dem Unterschied, daß im Anschluß die gelesenen Daten mit denen im PC-Pufferspeicher verglichen werden.
Leertest
Protokoll für des Leertest.
PC UP2000
SetupDevice ---------------------------->
<------------------------- ACK
BlankTest ---------------------------->
<------------------------- ACK
<------------------------- k-mal SendStatus
DisconnectTarget ---------------------------->
<------------------------- ACK
GetStatus ---------------------------->
<------------------------- SendStatus
Löschen
Protokoll für das Löschen des Bausteins.
PC UP2000
SetupDevice ---------------------------->
<------------------------- ACK
WriteTarget ---------------------------->
<------------------------- ACK
<------------------------- k-mal SendStatus
DisconnectTarget ---------------------------->
<------------------------- ACK
GetStatus ---------------------------->
<------------------------- SendStatus
Flag setzen
Protokoll für das Setzen von Flags oder Security Bits.
PC UP2000
SetupDevice ---------------------------->
<------------------------- ACK
WriteTarget ---------------------------->
<------------------------- ACK
DisconnectTarget ---------------------------->
<------------------------- ACK
GetStatus ---------------------------->
<------------------------- SendStatus
Spannungsabgleich
Es folgt ein Beispiel für einen Protokollablauf zum Bestimmen der Werte W5V und W20V (siehe Berechnung der DAC-Werte). Nach jeder Nachricht 01 32 .. 04 ist die Spannung am Pin 1 gegenüber Pin 20 zu bestimmen und ggf. das Datenbyte in der nächsten Nachricht anzupassen, bis die gewünschte Spannung erreicht ist.
Da die Nachrichten für dieses Beispiel alle sehr kurz sind, wurden sie hier detailliert als einzelne Bytes mit Start- und Endekennung und der Prüfsumme dargestellt.
PC UP2000
Pin 0 auf "Spezial" --- 01 33 30 33 E9 E4 04 --->
<--- 02 06 20 E0 A4 03 --- ACK
Pin 20 auf "Spezial" --- 01 33 43 33 B4 EE 04 --->
<--- 02 06 20 E0 A4 03 --- ACK
SetVppState - Vpp ein --- 01 31 31 27 E6 04 ------>
<--- 02 06 20 E0 A4 03 --- ACK
SetVppValue 0x32 ~ 5V --- 01 32 32 42 D6 04 ------>
<--- 02 06 20 E0 A4 03 --- ACK
SetVppValue 0xC9 ~ 20V --- 01 32 C9 1C A2 04 ------>
<--- 02 06 20 E0 A4 03 --- ACK
SetVppValue 0xC8 ~ 20V-Δ --- 01 32 C8 0C 83 04 ------>
<--- 02 06 20 E0 A4 03 --- ACK
SetVppValue 0xC7 ~ 20V-2*Δ --- 01 32 C7 FD 6C 04 ------>
<--- 02 06 20 E0 A4 03 --- ACK
DisconnectTarget --- 01 39 94 4B 04 --------->
<--- 02 06 20 E0 A4 03 --- ACK
Berechnung der DAC-Werte
Der Ladewert für den Digital-Analog-Wandler zur Bereitstellung der Programmierspannung Vpp wird durch Zweipunktabgleich ermittelt. Dazu werden die Größen W5V und W20V (jeweits 8-bit Zahl) ermittelt (Protokoll Spannungsabgleich), bei denen sich am Vpp-Pin jeweils 5V bzw. 20V gegen GND einstellen, und auf dem PC gemerkt.
Für die Programmierung eines bestimmten IC werden daraus die DAC-Werte Wcc und Wpp wie folgt berechnet:
(W20V - W5V) (Vcc - 5V)
Wcc = --------------------------- + W5V
(20V-5V)
(W20V - W5V) (Vpp - 5V)
Wpp = --------------------------- + W5V
(20V-5V)
Vcc: Spannung am Vpp-Pin während Normalbetrieb (Lesen,..),
diese Größe ist gewöhnlich 5V, d.h Wcc = W5V
Vpp: Programmierspannung lt. Datenblatt
W20V: DAC Wert, der für 20V DAC-Spannung ermittelt wurde
W5V: DAC Wert, der für 5V DAC-Spannung ermittelt wurde
Die Werte Wcc und Wpp werden in der Nachricht ConnectTarget an das Programmiergerät übermittelt.
Berechnung Impulslänge
Programmierimpulslänge (Tpp) und Nachprogrammierimpulslänge (Tnp) werden als 16-bit Zahl in der Nachricht ConnectTarget übermittelt. Der Wert dieser Zahl ist 0 (Null) für 0µs, 1 für Werte 1µs..38µs und errechnet sich für Werte > 38µs wie folgt:
Txp = trunc( Time[µs] * 0.1575 - 5 )
Die Zeit ist in der Einheit µs einzusetzen.
Glossar
Begriff Erkärung Answer-Frame Nachricht vom UP2000 zum PC Request-Frame Nachricht vom PC zum UP2000 Target IC im Textool-Sockel Vcc Versorgungsspannung des zu programmierenden ICs Vpp Programmierspannung des zu programmierenden ICs