ELV UP2000 Protokoll

Aus der Mikrocontroller.net Artikelsammlung, mit Beiträgen verschiedener Autoren (siehe Versionsgeschichte)
Wechseln zu: Navigation, Suche

Dieser Artikel beschreibt das Protokoll des Programmiergerätes UP2000 des Versandhauses und Verlags ELV.

Einleitung[Bearbeiten]

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[Bearbeiten]

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).

Ü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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

SetLED (0x2B)[Bearbeiten]

Schaltet die LEDs des Programmers. Bits 0 und 1 des DataBytes repräsentieren je eine LED.

Message
0x2B DB1
         DB1: 0=off, 1=on - Bit 0: grüne LED
                            Bit 1: rote LED 

SetBaudRate (0x2D)[Bearbeiten]

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)[Bearbeiten]

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)[Bearbeiten]

Zu- oder abschalten der Programmierspannung Vpp.

Message
0x31 DB1
         DB1 = 0x30: Vpp aus
         DB1 = 0x31: Vpp ein

SetVppValue (0x32)[Bearbeiten]

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)[Bearbeiten]

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)[Bearbeiten]

Debug-Nachricht?

Message
0x34 DB1 DB2 DB3

(0x35)[Bearbeiten]

Debug-Nachricht?

Message
0x35 DB1 DB2

(0x36)[Bearbeiten]

Debug-Nachricht?

Message
0x36

(0x37)[Bearbeiten]

Debug-Nachricht?

Message
0x37

GetPinStatus (0x38)[Bearbeiten]

Abfragen der Pins des Textool-Sockels.

Message
0x38

DisconnectTarget (0x39)[Bearbeiten]

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)[Bearbeiten]

Ü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)[Bearbeiten]

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

ConnectTarget (0x43)[Bearbeiten]

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)[Bearbeiten]

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

ReadTarget (0x45)[Bearbeiten]

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

BlankTest (0x4C)[Bearbeiten]

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

GetStatus (0x53)[Bearbeiten]

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

GetResultOfRB (0x55)[Bearbeiten]

(Unsicher) Get Result Of ReadBuffer

Message
0x55

SetAddrWidth (0x61)[Bearbeiten]

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)[Bearbeiten]

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)[Bearbeiten]

Debug-Nachricht. Fragt die Konfiguration der Adressleitungen bezüglich der Textool-Pins ab.

Message
0x63

SetDataWidth (0x64)[Bearbeiten]

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)[Bearbeiten]

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)[Bearbeiten]

Debug-Nachricht. Fragt die Konfiguration der Datenleitungen bezüglich der Textool-Pins ab.

Message
0x66

ACK[Bearbeiten]

Das ist die allgemeine Acknowledge-Antwort.

Message
ACK AckSubType
0x06 0x20

SendBuffer[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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: 0x01  
0x0B 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: 0x00  
0x12 Flash S MCS51
   Security Flags 
   programmieren:
     DB5: 0x80  
     DB6: 0x01  
   Baustein löschen:
     DB5: 0xA8  
     DB6: 0x00  
0x13 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: 0x00  
0x14 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..n
   PINy 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..n
   PINy 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, NB
   Baustein löschen:
     DB5: 0x80  
     DB6: 0x00  
0x18 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[Bearbeiten]

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[Bearbeiten]

Lesen[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

Protokoll für des Leertest.

         PC                                                                  UP2000
  SetupDevice                ---------------------------->
                                                 <-------------------------   ACK
  BlankTest                  ---------------------------->
                                                 <-------------------------   ACK
                                                 <-------------------------   k-mal SendStatus
  DisconnectTarget           ---------------------------->
                                                 <-------------------------   ACK
  GetStatus                  ---------------------------->
                                                 <-------------------------   SendStatus

Löschen[Bearbeiten]

Protokoll für das Löschen des Bausteins.

         PC                                                                  UP2000
  SetupDevice                ---------------------------->
                                                 <-------------------------   ACK
  WriteTarget                ---------------------------->
                                                 <-------------------------   ACK
                                                 <-------------------------   k-mal SendStatus
  DisconnectTarget           ---------------------------->
                                                 <-------------------------   ACK
  GetStatus                  ---------------------------->
                                                 <-------------------------   SendStatus

Flag setzen[Bearbeiten]

Protokoll für das Setzen von Flags oder Security Bits.

         PC                                                                  UP2000
  SetupDevice                ---------------------------->
                                                 <-------------------------   ACK
  WriteTarget                ---------------------------->
                                                 <-------------------------   ACK
  DisconnectTarget           ---------------------------->
                                                 <-------------------------   ACK
  GetStatus                  ---------------------------->
                                                 <-------------------------   SendStatus

Spannungsabgleich[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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

Referenzen und Links[Bearbeiten]