Robotrontechnik-Forum

Registrieren || Einloggen || Hilfe/FAQ || Suche || Mitglieder || Home || Statistik || Kalender || Admins Willkommen Gast! RSS

Robotrontechnik-Forum » Technische Diskussionen » Suche optimale Prüfsumme/Signatur (Z80) » Themenansicht

Autor Thread - Seiten: -1-
000
17.05.2026, 14:13 Uhr
Bert



Hallo Forum!

Ich bin auf der Suche nach einer 'optimalen' Prüfsumme für den KC85.
Optimal bedeutet in diesem Fall:
(A) kurze Laufzeit
(B) eindeutige Signatur, auch bei Datenblöcken mit leerem Inhalt (alles FFs oder alles 0)
(C) ein gewisser Fehlerschutz vor fehlerhaften Bytes oder Burstfehlern
Die Codegröße ist nicht ganz so entscheidend.

Was ich mir schon angeschaut habe:

XOR
Vorteil: schnell (A)
Nachteil: keine eindeutige Signatur bei identischem Inhalt (B) und geringer Fehlerschutz (C)

SUM16
Vorteil: schnell (A)
Nachteil: geringer Fehlerschutz (C)

Fletcher-16
(die Variante mit a = 0, b = 0, M = 255)
Vorteil: guter Fehlerschutz (C und B)
Nachteil: nicht so schnell (A)

Fletcher-16
(die Variante mit a = 0, b = 0, M = 256)
Vorteil: ähnlich schnell wie SUM16 (A)
Nachteil: keine eindeutige Signatur (C)

Fletcher-KC
(die Variante mit a = data[0], b = 0, M = 256)
Vorteil: ähnlich schnell wie SUM16 (A)
Nachteil: kein Standard

Adler-16
(Variante von Fletcher mit a = 1, b = 0, M = 251)
Vorteil: eindeutige Signatur (C)
Nachteil: nur mittelschnell (A)

Alle Algorithmen laufen auf dem PC (C++) und dem KC85 (C und Assembler).

Die Assemblervariante ist i.d.R. fünf bis zehnmal schneller als die C-Variante:


Letztendlich bräuchte ich einen Algorithmus der den Rest der Division (=Modulo-Operation) mit 255 oder 251 schnell ausrechnet um von der Geschwindigkeit in die Nähe von SUM16 zu kommen.

Wer sich da mal angucken will, ich hab die Quelltexte (und mehr) hier abgelegt:
https://github.com/boert/KC85-Programme_in_C/tree/main/Pruefsummenvergleich

Vielleicht hat ja noch jemand eine gute Idee!
--
Viele Grüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
001
17.05.2026, 17:01 Uhr
maleuma



Ich habe in meinem Flash-Programm für CAOS eine modifizierte Fletcher-Routine eingebaut.
Da die Original-Fletcher-Routine für alles 0 und alles FF das gleiche Ergebnis liefert, habe ich statt ADD einfach den Z80-Befehl ADC genommen. Damit ist die Routine genauso schnell, liefert jedoch unterschiedliche Werte bei 00 und FF.
Nachteil: kein Standard und schlechter am PC nachbildbar.

Quellcode:

; Fletcher-Pruefsumme berechnen:
; PE:   HL      Anfangsadresse
;       (PAR1)  Adresse zur Ablage der CRC-Summe
; PA:   DE      CRC
CRCC:   LD      HL,0C000H       ; Anfangsadresse
CRC:    LD      BC,2000H        ; Laenge immer 8 KByte
        LD      DE,'KC'         ; Startwert
; Adjust 16-bit length for 2x8-bit loops
        inc     b               ; BC = 2100H
        dec     bc              ; BC = 20FFH
        inc     c               ; BC = 2000H          Takte:
FLLOOP: ld      a,(hl)          ;                       7
        inc     hl              ;                       6
        add     a,e             ; sum1 += data          4
        ld      e,a             ;                       4
        adc     a,d             ; sum2 += sum1 + cy     4
        ld      d,a             ;                       4
        dec     c               ;                       4
        jp      nz,FLLOOP       ;                       10
        djnz    FLLOOP          ;                       13 (8)


--
Mario.

Dieser Beitrag wurde am 17.05.2026 um 20:33 Uhr von maleuma editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
002
17.05.2026, 20:19 Uhr
Bert



Das ADC statt ADD bringt an der Stelle leider nicht viel.
Wenn man die Startwerte wieder auf '0' setzt, entspricht das Ergebnis dem SUM16-Algorithmus.
--
Viele Grüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
003
17.05.2026, 21:12 Uhr
maleuma



Ich habe den SUM16-Algorithmus einmal bei mir eingebaut. Ich bekomme aber andere Ergebnisse als bei meinem Fletcher-ADC. Sowohl mit Startwert "KC" als auch mit Startwert 0.

Bei SUM16 wird bei einem Übertrag der H-Teil nur incrementiert.
Bei Fletcher wird im H-Teil die komplette Summe des Low-Teils aufsummiert.
Oder habe ich das falsch verstanden?
--
Mario.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
004
17.05.2026, 23:59 Uhr
kaiOr

Avatar von kaiOr

Alles ein wenig zusammenstampfen geht doch immer.

Quellcode:
;;  (lightly unflexible) Fletcher-16 checksum, mod 255
;;
;; Input:
;;  H = Data address / 100h
;;  B = Data length / 100h
;;
;; Output:
;;  DE = Fletcher-16
;;  HL,BC,AF are modified
fletcher_255:
        ld      a,b
        add     a,h
        ld      b,a
        ld      l,0
        ld      c,l             ; mobile Null
        ld      d,c             ; Start-
        ld      e,c             ; wert
fletcher16_loop:
        ld      a,e
        add     a,(hl)
        adc     a,c
        ld      e,a
        add     a,d
        adc     a,c
        ld      d,a
        inc     l
;; 1x loop unrolling, no problem because L starts even
        ld      a,e
        add     a,(hl)
        adc     a,c
        ld      e,a
        add     a,d
        adc     a,c
        ld      d,a
        inc     l
        jp      nz,fletcher16_loop
        inc     h
        ld      a,h
        cp      b
        jp      nz,fletcher16_loop

        ; d = d mod 255
        dec     l
        ld      a,d
        cp      l
        jr      c,$+3
        inc     d
        ; e = e mod 255
        ld      a,e
        cp      l
        jr      c,$+3
        inc     e

        ret

ca. 186ms

EDIT2: Daten vom Stack holen geht noch einen Hauch schneller:

Quellcode:
;;  (lightly unflexible) Fletcher-16 checksum, mod 255
;;
;; Input:
;;  H = Data address / 100h
;;  B = Data length / 100h
;;
;; Output:
;;  DE = Fletcher-16
;;  HL,BC,AF are modified
spos    equ     0B77Eh          ; freier RAM
cnt     equ     spos-1
fletcher_255:
        xor     a               ; clear CY
        ld      c,a             ; mobile Null
        ld      a,b
        rra
        ld      b,c
        jr      nc,skip         ; gerade?
        ld      b,128
        inc     a
skip    ld      (cnt),a
        ld      l,c
        ld      d,c             ; Start-
        ld      e,c             ; wert
        di
        ld      (spos),sp
        ld      sp,hl
fletcher16_loop:
        pop     hl
        ld      a,e
        add     a,l
        adc     a,c
        ld      e,a
        add     a,d
        adc     a,c
        ld      d,a
        ld      a,e
        add     a,h
        adc     a,c
        ld      e,a
        add     a,d
        adc     a,c
        ld      d,a
        djnz    fletcher16_loop
        ld      hl,cnt
        dec     (hl)
        jp      nz,fletcher16_loop
        ld      sp,(spos)
        ei

        ; d = d mod 255
        dec     b
        ld      a,d
        cp      b
        jr      c,$+3
        inc     d
        ; e = e mod 255
        ld      a,e
        cp      b
        jr      c,$+3
        inc     e

        ret

ca. 183ms

Gruß,
Kai

Dieser Beitrag wurde am 18.05.2026 um 11:58 Uhr von kaiOr editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
Seiten: -1-     [ Technische Diskussionen ]  



Robotrontechnik-Forum

powered by ThWboard 3 Beta 2.84-php5
© by Paul Baecher & Felix Gonschorek