Protokoll
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.org/index.php?action=dlattach;topic=187.0;attach=402