Protokoll

From Enterprise Wiki
Revision as of 09:54, 3 May 2010 by Szipucsu (talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

Tasztillesztő

Protokol

Az egész protokol az EP taszt --nem használt-- 10..15 címét használja.

A bootloader addig (és csak addig) aktív, amíg ilyen címeket kap. Az elsõ "igazi" EP-taszt címre (0..9) a mûködése befejezõdik.

Van tehát 6-féle kódunk, ezek egyenként:

[font=Courier New]0A: EADDR (cím beállítása) 0B: EBIT1 (1-es bit küldése) 0C: EBIT0 (0-s bit küldése 0D: EDATA (RAM adat cseréje) 0E: EFLSH (flash, vagy EEPROM írása) 0F: ELAST (utolsó kód?)[/font]

A válasz-adatokat a normál taszt-emu táblába teszem. Ami ezután az U27 bemenetén olvasható, [b]a következõ alkalommal[/b] . Miért is? Mert a Z80-nal a kommunikáció OUT-IN párossal történik. Az OUT (B5),0A..0F hatására megy valamelyik programrészre, ami beírja a taszt-emu táblát, ugyanúgy, mint normál mûködés esetén. A taszt-emu táblából viszont IT rutin-nal kérdezhetõ le az adat, vagyis a következõ OUT hatására teszi ki az adatot.

[quote] Miért nem azonnal? Egyrészt, mert nincs "azonnal". Idõt kéne definiálni rá, hogy leghamarabb mikor kerülne ki az adat. Ami igencsak változó, a legtöbb esetben gyorsabban, mint ahogy a Z80 új utasítást hajt végre ;) , de pl. az EEPROM írás 30 msec körüli. Másrészt, mert akkor csak egyféle adatot tudnék küldeni, mindig. Így viszont az emu-ramból egyszerre többféle is kiolvasható. [/quote]


Minden egyes címre elõször azonnal 00-t tesz az emuram[0F]-re (tehát a Z80-nal OUT (B5),0F / IN (B5)-re FF olvasható), majd amikor elvégezte a feladatot, akkor egy kódot (rendszerint u.azt a címet) teszi ki.

Az adatok cseréje tehát az egyik irányban (EP->uC) bitenként, míg a másik irányba (uC->EP) byte-onként történik. A bootloader 1 shift regisztert, pár egyéb regisztert és egy 64 byte-os RAM területet használ ehhez. Valamint természetesen a normál emu-RAM területet.

[font=Courier New] progdataw: ... 16 bites (shift) adatregister progaddrw: ... 16 bites címregiszter progcnt: ..... 8 bites adatszámláló (valójában biteket is számol) bufptr: ...... pointer a belsõ pufferre tab_ram: ..... ez maga a puffer is egyben lastcode: .... 8 bites adat, amivel lekérdezhetõ, mi is történt [/font] Van még egy timer is (kb. 120 msec), amit az elsõ belépéskor indítok, és minden EFLSH újraindítja.


C (szerû) szintakszist használok itt, elnézést, ha valakinek nem egyértelmû


0A..0F: emuram[0F] = 0 lastcode = funkció (0A..0F) call func


A funkciók


[font=Courier New]EBIT1 (0B): progdataw = progdataw * 2 + 1 emu[0B] = EEPROM[progaddr] emu[0C] = FLASH[progaddr++] progcnt = progcnt+1


EBIT0 (0C): progdataw = progdataw * 2 + 0 emu[0C] = FLASH[progaddr++] progcnt = progcnt+1


EADDR (0A): progaddrw = progdataw bufptr = tab_ram progcnt = 0


EDATA (0D): progcnt = 0 : emu[0D] = *bufptr++ ....... !=0 : bufptr túlcsordult ? lastcode |= D0 ............. egyébként: ................... *bufptr++ = LOW(progdataw) ................... ++progcnt



EFLSH (0E): timer lejárt ? .......... lastcode |= 0x10 progcnt != 32 ? ..........lastcode |= 0x20 progaddr -= progcnt progaddr != progdata ? .. lastcode |= 0x40 progaddr hibás ? ........ lastcode |= 0x40 bufptr != tabram ? ...... lastcode |= 0x80

lastcode < 0x10 : ......progaddr < 0x200 : EEPROM írása tabram-ból, 32 byte .......................: FLASH ----------- " ------------ ......timer újrindítása


A címnek 0x800-nál kisebbnek kell lenni, és az alsó 5 bit 0 kell legyen. Egyébként hibás. A buftr = tabram EADDR esetén keletkezik, EDATA viszont elrontja. Írás tehát csak akkor lehetséges, ha a sorrend EADDR, aztán (32-szer) EBITx volt.


ELAST (0F): emuram[0F] <- lastcode [/font]



A használat tehát a következõ:

--OLVASÁS-- EBITx funkciókkal 16 bitet át kell vinni. EADDR átteszi ezt címmé. Ezután

az EEPROM tartalmát folyamatos EBIT1 küldözgetésével lehet olvasni, ...vagy... a FLASH tartalmát folyamatos EBIT0 küldözgetésével lehet olvasni, ...vagy... tabRAM tartalmát folyamatos EDATA adja vissza (itt a cím értéke nem számít, de KELL az EADDR! Az EBITx viszont kihagyható)


--ÍRÁS-- eloször mindig a tabRAM-ba 1. EADDR 2. (8-szor) EBITx, majd EDATA, ez egyetlen byte-ot ír 3. (2) ismételve max. 64-szer, de FLASH és EEPROM írása csak az elsõ 32 byte-ból történik Ha csak a tabRAM-ot akarjuk írni, akkor ennyi.

4. FLASH, ill. EEPROM irása: a) címet be kell állítani: (16-szor) EBITx, majd EADDR b) még egyszer ki kell adni a címet, pontosan 32 db EBITx hívással c) EFLSH

[quote] Miért pont 32 byte? Mert ennek a uC-nek ekkora a belsõ lapmérete, egyszerre ennyi adatot ír a flash-be. Ez EEPROM-nál nem igaz, de egyrészt így jóval rövidebb a kód, másrészt újabb restrikció a protokolban, ami itt jól jön. [/quote]

ELAST az egész folyamat közben bármikor kiadható, az itt olvasott értékkel ellenõrizhetõ, hogy milyen hívás történt utoljára, és sikeres volt-e.


Az emuram-ba írt érték valójában nem az, amit az Z80 "lát", mert az EP-ben használt 373-as IC (az U27) kicsit zagyván használja a lábait. Mindenki 573-ast használt helyette, amikor már tehette (és akkor nem kéne annyi átkötés sem a uC beépítésekor).

in
76543210
out
65210347

A 7-es bitbõl tehát 6-os bitet, a 6-os bitbõl 5-ös bitet stb. kell "gyártani", a Z80 kódban.

A normál mûködést ez azért nem zavarja, mert már eleve "visszakavart" értékeket írok ki, a tasztdefiníciós értékek így készültek (epkeys.h)


Ha valaki jobban érti a forráskódot  :wink: : http://www.enterpriseforever.com/index.php?action=dlattach;topic=187.0;attach=402