I8085 - emulator procesora

Postautor: **gaweł** » wtorek 03 paź 2023, 00:18

Emulator procesora i8085

em8085-00.jpg

Nadeszła w końcu ta chwila, by zająć się stworzeniem softu dla generatora opartego na procku i8085. Ot wala mi się kilka takich w szufladzie, więc uznałem, że to dobry pomysł, by zatrudnić ich do jakiegoś działania. Sprzęciora już nawet zrobiłem, więc pora na kolejny krok do celu. Jakiś czas tam napisałem sobie program, który kompiluje program w asm i generuje kod binarny w formacie hex. Być może i są jakieś niekomercyjne narzędzia pozwalające na tworzenie softu dla tych procków. Prawdę mówiąc to specjalnie nie szukałem. Zacząłem nawet tworzyć kawałek softu, jednak zaczęło mi się trochę kaszanić w programie. Bo to człowiek już dawno nie pisał w asemblerze, a tu w dodatku jeszcze takim trochę dziwnym, gdyż będąc przyzwyczajony do składni zilogowej, która jest jasna i klarowna, to należy wrócić do składni inteloskiej. Ta już nie jest tak elegancka, ale nie ma co narzekać i wytykać intelowi jakieś uwagi. Chłopcy zrobili to jak zrobili i tyle.
Rozwiązaniem tego problemu jest posiadanie emulatora działania procka: czy to sprzętowego czy programowego. W kwestii emulatorów sprzętowych, to … są absolutnie poza zasięgiem. Ten procek był na topie jakieś 50 lat tamu i dzisiaj, nawet jeżeli takowe istnieją to będą kosztowały majątek. Pozostaje rozwiązanie w wariancie emulatora programowego. Generalnie nie jest to jakiś wielki problem, ot program jak program, jest to napisania. Pozostaje kwestia dostępu do właściwej wiedzy. Tu staje się przydatna moja stara książka, która wniosła wiele w rozumienie techniki mikroprocesorowej: praca zbiorowa, „Modułowe systemy mikrokomputerowe”.

em8085-01.jpg

W owej książce jest podana lista instrukcji procka i8080 i rozszerzenia dla procka i8085 (oczywista, że najwięcej miejsca jest poświęcone Z80). Ogólnie wiadomo, że Z80 jest kompatybilny pod względem kodów binarnych z prockami intela dysponując jednak znacząco większą liczbą instrukcji. Ano zostało to zrobione poprzez wykorzystanie „dziur” w kodach intelowych (tych od i8080). Procek i8085 również wykorzystał wolne miejsca, gdyż doszły dwie instrukcje (RIM i SIM). No więc będąc wyposażony w szczegółową wiedzę, postanowiłem stworzyć program emulatora.

em8085-02.jpg

Jednak coś mnie tknęło i postanowiłem podane informacje zweryfikować. Dotarłem do oryginalnej dokumentacji tego procka:

em8085-03.png

gdzie jasno jest postawiona sprawa, że praca zbiorowa jest polskim nadużyciem i mija się trochę z prawdą. Poza tym jest więcej istotnych szczegółów, których znajomość jest niezbędna do stworzenia poprawnie działającego programu.

em8085-04.png

No i oczywista, jest lista instrukcji wraz z ich kodami. No i nawet bez okularów widać, że procek nie realizuje instrukcji opisanych w polskiej książce.

em8085-05.png

Powstał mały dylemat: kto mówi prawdę? Tu nie wahałem się zbytnio i zaufałem oryginalnym publikacjom. Przykładowo kod CB hex będący dla ziloga prefiksem rozszerzenia do operacji bitowych, czy ED hex jako rozszerzenie do wielu ciekawych i przydatnych instrukcji czy DD hex i FD hex jako prefiksy do instrukcji operujących na rejestrach indeksowych, których w prockach intelowych nie ma. Te kody (i kilka innych) to są dziury dla procka i8085. Swoją drogą ciekawe co zrobi procek i8085, jak go się przymusi do wykonania tych instrukcji. To może być ciekawy temat badawczy, bo jak coś takiego zbadać? Procek może to olać, zawisnąć a może zrobić coś innego i tajemniczego. No może to kiedyś sprawdzę.
No więc stworzyłem sobie program do śledzenia wykonania programu dla procka i8085. Napisałem go sobie w pascalu (lazarus).

em8085-06.png

Moim celem jest stworzenie narzędzia pozwalającego na diagnostykę w szerokim zakresie. Wymaga to określenia dla programu wielu informacji, gdyż program wyłapuje przykładowo zapis do pamięci EPROM, odczyt/zapis z pamięci nieistniejącej (gdyż nie ma obowiązku, by do procka była przypięta pamięć wypełniająca całą przestrzeń adresową). Podobnie są monitorowane użycia portów we/wy. Należy wcześniej określić jakie adresy portów są używane i symulacja wykonania programu dla procka i8085 się zatrzyma, jeżeli nie zostaną wyspecyfikowane „legalne” adresy portów. By nie wklepywać tego za każdym razem, jest plik opisujący projekt (symulacji). Oczywiście, wszystkie szczegóły można w dowolnej chwili zmodyfikować.
Przykładowy projekt: w okienku projektu wyświetlone są wszystkie szczegóły dotyczące środowiska, w którym jest uruchamiany program.

em8085-07.png

System prockowy składa się z pamięci EPROM (lub innej nieulotnej) lokowanej w przestrzeni od 0000 hex do 7FFF hex oraz pamięć RAM lokowana od 8000 hex do FFFF hex. W sumie obie pamięci wypełniają całą przestrzeń. Dodatkowo występują porty wejścia, porty wyjścia (jak przykładowo i8212) czy porty wyjścia/wejścia (jak przykładowo i8255). Dla jednych dostępne są jedynie instrukcje IN, dla innych jedynie OUT lub dla tych trzecich zarówno IN jak i OUT. Również program emulatora wspiera obsługę przerwań. Może to być kontroler zbudowany na bazie i8214, który generuje instrukcje RST 1 … RST 7 lub przerwania połówkowe, które są zintegrowane w samym procku. No i oczywiście przerwanie niemaskowalne TRAP. Te przerwania (niemaskowalne oraz połówkowe) mogą być nieużywane w systemie (ze stałym sygnałem wymuszonym przez odpowiednie przyłączenie wejścia do masy lub VCC), toteż istnieje możliwość, że klikanie na przycisk do zgłaszania przerwania pozostanie bez reakcji.

Manual:

MCS-80, MCS-85 family users manual, 1983 (INTEL).pdf

Postautor: **phill2k** » wtorek 03 paź 2023, 20:31

A ja znalazłem takie cudeńka, może będą pomocne.

Intel-MCS-85 Users Manual 1978
Intel MCS85-SDK documentation and utility ROM source code & binary for the 8085 microprocessor.
8080 8085 Software Design
Assembly Language for the 8085

Postautor: **gaweł** » wtorek 03 paź 2023, 23:01

phill2k pisze:A ja znalazłem takie cudeńka, może będą pomocne.

No dzięki, ale już napisałem własny program

.

Deasemblacja

Dysponując programem binarnym (w zapisie intel-hex), fajnie by było, by na ekranie było widać co się dzieje: co program robi, gdzie jest. Pierwszą czynnością po wczytaniu kodu hex, jest jego desemblacja. Generalnie taka operacja nie jest jednoznaczna, gdyż trudno jest wyrokować o sensie zawartości przykładowo pary rejestrów HL. To może być adres skoku jak w instrukcji PCHL [w wersji zilogowej JP (HL)], to może być adres operandu w instrukcji arytmetycznej lub wręcz może pełnić rolę akumulatora w arytmetyce 16-bitowej. Ładując program intelowski do pamięci program zaczyna proces deasemblacji. Początek jest wiadomo w którym miejscu: adres 0. I tak instrukcja po instrukcji tłumaczony jest kod na prawdopodobną wersję źródłową. Napisałem prawdopodobną, gdyż nie ma gwarancji, że ta czynność będzie zgodna z intencjami autora, a te są tu zawsze nadrzędne. Algorytm deasemblacji jest rekurencyjny (to najprostsza implementacja). I posiłkuje się stałą tablicą opisującą kody instrukcji. Jest wykorzystywana do symulacji działania oraz do deasemblacji.

em8085-11.png

Patrząc na tą tablicę z istotnego obecnie punktu widzenia (deasemblacja) tabela zawiera liczbę bajtów jakie zajmuje każda instrukcja oraz informację o „zaburzeniach” realizacji instrukcji. Większość instrukcji ma flagę kontynuacji (deasemblacji), przykładowo: ( OpCodeSize : 1 ; Operation : PUSH_D_Operation ; OpCodeName : 'push d' ; Operand : VoidOperand ; OpCodeFlag : ContinueFlag ) , i oznacza, że po deasemblacji tej sztuki jedziemy dalej. Niektóre instrukcje zawierają flagę rozgałęzienia (wszystkie skoki warunkowe, wywołania warunkowe i bezwarunkowe) wykonanie programu skoczy gdzieś lub nie, ale zawsze istnieje możliwość wykonania bezpośrednio kolejnej instrukcji w kodzie, przykładowo: ( OpCodeSize : 3 ; Operation : CALL_Operation ; OpCodeName : 'call ' ; Operand : Direct16Operand ; OpCodeFlag : EntryFlag ) , i oznacza, że po deasemblacji tej sztuki wywoływana jest rekurencyjnie akcja deasemblacji od adresu wskazanego w operandzie i również jedziemy dalej. W instrukcji skoku bezwarunkowego JMP, kończona je bieżąca deasemblacja (program skoczy gdzieś i nie wróci do następnej instrukcji) i startuje rekurencyjnie deasemblacja na adres skoku. Innym wariantem instrukcji są takie, które jedynie kończą deasemblację bieżącego fragmentu i robią skok w miejsce nieokreślone w operandzie, jak RET, czy PCHL. Przykładowy opis to: ( OpCodeSize : 1 ; Operation : RET_Operation ; OpCodeName : 'ret' ; Operand : VoidOperand ; OpCodeFlag : BreakFlag ) .
Jeżeli w projekcie są wskazania na obsługę przerwań, to inicjowana jest deasemblacja na stałe adresy związane z obsługą tych przerwań. Ponieważ nie ma obowiązku, by program obsługiwał przerwania, gdyż to może być trenowany jakiś fragment programu, to nie ma potrzeby deasemblować punktów wejścia do obsługi przerwań. To nawet może okazać się szkodliwe, gdyż istnieje szansa powstania konfliktów: obsługa przerwania może trafić w środek wielobajtowej instrukcji i wtedy to powstaje już kaszana.
Ten algorytm „przechodzi” każde rozgałęzienie programu intelowego, więc to co zostało „nie tykane” może stanowić obszar danych stałych. Program konwertuje te obszary do postaci define byte. Oczywiście w tym wszystkim jest jeden wyjątek: instrukcja PCHL, które realizuje skok, tylko nie wiadomo dokąd (na etapie deaseblacji). W ten oto sposób mogą być „wykryte” fragmenty martwego kodu, który nigdy nie ma szans na wykonanie. Przykładowo (fragment mojego generatora losowego):

Kod: Zaznacz cały

Improved compiler for INTEL 8080/8085 processor, version 2.0, licence: CC BY 3.0

  L.NO MEMO    CODE         SRC

Open file: D:\lazarus_project\I8080\T8080.ASM
    1.                 ; 
    2.                         .i8085
    3. 0000            ResetEntry   .equ 0000h
    4.                         .org ResetEntry
    5. 0000 F3                 di
    6. 0001 310000             lxi sp,0
    7. 0000            Stack_top       .equ   0h
    8. 0004 F3                 di                               ;
    9. 0005 310000             lxi     sp , Stack_top           ;
   10.                 ;
   11. 0008 CD1F00             call    Init_random              ;
   12. 000B CD2C00             call    CreateNewRandom          ;
   13.                 ;
   14. 000E CD5900             call    Init_variable            ;
   15. 0011 CD5A00             call    Init_hardware            ;
   16. 0014 CD5B00             call    Init_envir               ;
   17.                 ;.
   18. 0017            Stop_prg                                 ;
   19. 0017 C31700             jmp     Stop_prg                 ;
   20.                 ;***************************************************
   21. 001A            Martwy_kod
   22. 001A 00                 nop                              ;
   23. 001B 00                 nop                              ;
   24. 001C 00                 nop                              ;
   25. 001D 00                 nop                              ;
   26. 001E 00                 nop                              ;
   27.                 ;***************************************************
   28. 001F            Init_random                              ;
   29. 001F 210080             lxi     h , RandomSeed           ;
   30. 0022 110280             lxi     d , RandomV              ;
   31. 0025 7E                 mov     a , m                    ;
   32. 0026 12                 stax    d                        ;
   33. 0027 23                 inx     h                        ;
   34. 0028 13                 inx     d                        ;
   35. 0029 7E                 mov     a , m                    ;          
   36. 002A 12                 stax    d                        ;
   37. 002B C9                 ret                              ;
   38.                 ;***************************************************
   39.                 ;    RandomV = ( ( MultConst * RandomV ) + AddConst ) ;
   40.                 ;    MultConst = 129, AddConst = 9
   41. 002C            CreateNewRandom
   42.                 ;function CreateNewRandom ( ) : word [HL]
   43. 002C 110280             lxi     d , RandomV              ;
   44. 002F 1A                 ldax    d                        ;
   45. 0030 6F                 mov     l , a                    ;
   46. 0031 13                 inx     d                        ;
   47. 0032 1A                 ldax    d                        ;
   48. 0033 67                 mov     h , a                    ;
   49. 0034 E5                 push    h                        ;
   50. 0035 C1                 pop     b                        ;
   51. 0036 CD5100             call    ShiftLBC                 ;
   52. 0039 CD5100             call    ShiftLBC                 ;
   53. 003C CD5100             call    ShiftLBC                 ;
   54. 003F CD5100             call    ShiftLBC                 ;
   55. 0042 CD5100             call    ShiftLBC                 ;
   56. 0045 CD5100             call    ShiftLBC                 ;
   57. 0048 CD5100             call    ShiftLBC                 ;
   58. 004B 09                 dad     b                        ;
   59. 004C 010900             lxi     b , 09h                  ;
   60. 004F 09                 dad     b                        ;
   61. 0050 C9                 ret                              ;
   62.                 ;***************************************************
   63. 0051            ShiftLBC                                 ;
   64.                 ;function ShiftLBC ( Arg [BC] : word ) : word [BC]
   65. 0051 79                 mov     a , c                    ;
   66. 0052 B7                 ora     a                        ;
   67. 0053 17                 ral                              ;
   68. 0054 4F                 mov     c , a                    ;
   69. 0055 78                 mov     a , b                    ;
   70. 0056 17                 ral                              ;
   71. 0057 47                 mov     b , a                    ;
   72. 0058 C9                 ret                              ;
   73.                 ;***************************************************
   74. 0059            Init_variable                            ;
   75. 0059 C9                 ret                              ;
   76.                 ;***************************************************
   77. 005A            Init_hardware                            ;
   78. 005A C9                 ret                              ;
   79.                 ;***************************************************
   80. 005B            Init_envir                               ;
   81. 005B C9                 ret                              ;
   82.                         .org    08000h                   ;
   83. 8000            RandomSeed      .word   1                ;
   84. 8002            RandomV         .word   1                ;
   85.                          .end                             ;
Close file: D:\lazarus_project\I8080\T8080.ASM

Compilation :successful

Zawiera fragment kodu, do którego nie prowadzi żadna droga w trakcie wykonania programu. Jego deasemblacja to:

em8085-12.png

Jednak czasami jest to informacja nie do końca prawdziwa. Przykładowo:

Kod: Zaznacz cały

Improved compiler for INTEL 8080/8085 processor, version 2.0, licence: CC BY 3.0

  L.NO MEMO    CODE         SRC

Open file: D:\lazarus_project\I8080\T8080.ASM
    1.                 ;
    2.                         .i8085
    3. 0000            ResetEntry   .equ 0000h
    4. 007B            Data8           .equ 123
    5.                         .org ResetEntry
    6. 0000 F3                 di
    7. 0001 310000             lxi sp,0
    8. 0004 210A00             lxi h,subr
    9. 0007 E9                 pchl
   10. 0008 00                 nop   ; to jest martwy kod
   11. 0009 00                 nop   ; to jest martwy kod
   12. 000A            subr:
   13. 000A CE7B               ACI Data8
   14. 000C 8F                 ADC A
   15. 000D 88                 ADC B
   16. 000E 89                 ADC C
   17. 000F 8A                 ADC D
   18. 0010 8B                 ADC E
   19. 0011 8C                 ADC H
   20. 0012 8D                 ADC L
   21. 0013 EB                 XCHG
   22. 0014 8E                 ADC M
   23. 0015 87                 ADD A
   24. 0016 80                 ADD B
   25. 0017 81                 ADD C
   26. 0018 82                 ADD D
   27. 0019 83                 ADD E
   28. 001A 84                 ADD H
   29. 001B 85                 ADD L
   30. 001C 86                 ADD M
   31. 001D C67B               ADI Data8
   32. 001F A7                 ANA A
   33. 0020 A0                 ANA B
   34. 0021 A1                 ANA C
   35. 0022 A2                 ANA D
   36. 0023 A3                 ANA E
   37. 0024 A4                 ANA H
   38. 0025 A5                 ANA L
   39. 0026 A6                 ANA M
   40. 0027 E67B               ANI Data8
   41. 0029 2F                 CMA
   42. 002A 3F                 CMC
   43. 002B BF                 CMP A
   44. 002C B8                 CMP B
   45. 002D B9                 CMP C
   46. 002E BA                 CMP D
   47. 002F BB                 CMP E
   48. 0030 BC                 CMP H
   49. 0031 BD                 CMP L
   50. 0032 BE                 CMP M
   51. 0033 C33300     Loop    JMP Loop
   52.                  .end
Close file: D:\lazarus_project\I8080\T8080.ASM

Compilation :successful

Daje następujący wynik:

em8085-13.png

Do zaznaczonego fragmentu nie prowadzi żadna jawna ścieżka wywołania a prawdziwa rzeczywistość wyjaśni się dopiero w trakcie symulacji wykonania programu. Zaistnienie zdarzenia, gdzie następuje próba wykonania czegoś, co zostało zakwalifikowane jako blok stałych danych, generuje zatrzymanie i pytanie, czy „mamy ochotę to naprawić”.

em8085-14.png

Istnieje taka możliwość i realizowana jest deasemblacja „w biegu”. Fragment tego fragmentu nadal pozostaje oznaczony jako martwy kod (tym razem już prawdziwy).

em8085-15.png

Istnieje możliwość zapisania do pliku wyniku deasemblacji po kliknięciu prawym klawiszem myszki.

em8085-16.png

Powstała postać „źródłowa” jest następująca:

Kod: Zaznacz cały

; ***************************************
; ** Deasemblacja kodu procesora i8085 **
; ** przez program emulatora I8085     **
; ** Licencja: CC BY 3.0               **
; ***************************************
       .org 00000h
L0000: di
       lxi sp,00000h   ; 00000
       lxi h,0000Ah   ; 00010
       pchl
       .defb 000h  ; 000
       .defb 000h  ; 000
L000A: aci 07Bh   ; 123
       adc a
       adc b
       adc c
       adc d
       adc e
       adc h
       adc l
       xchg
       adc m
       add a
       add b
       add c
       add d
       add e
       add h
       add l
       add m
       adi 07Bh   ; 123
       ana a
       ana b
       ana c
       ana d
       ana e
       ana h
       ana l
       ana m
       ani 07Bh   ; 123
       cma
       cmc
       cmp a
       cmp b
       cmp c
       cmp d
       cmp e
       cmp h
       cmp l
       cmp m
L0033: jmp L0033
       .end

I tak to wyszła nieoczekiwanie fajna funkcja dotycząca wyłapywania martwego kodu.

Postautor: **gaweł** » wtorek 03 paź 2023, 23:12

Dzięki

phill2k, pozycja 8080 8085 Software Design okazała się nawet całkiem ciekawa.

Postautor: **tapy** » czwartek 05 paź 2023, 12:40

gaweł pisze: Te kody (i kilka innych) to są dziury dla procka i8085.

i8085 nie ma dziur w liście rozkazów, są tam zdefiniowane i jednolite dla każdego producenta instrukcje o których intel nie był łaskaw wspomnieć, by nie utrzymywać popularności procesorów 8-bit po premierze swojego 8086, a które były zawarte już w pierwszych maskach NMOS tego procesora. 8085 to niechciane dziecko marketingu tej firmy. Na tym forum o nich wspomniałem, a do tych instrukcji przyznaje się tylko kanadyjska firma Tundra, reszta producentów o nich milczy.

Postautor: **gaweł** » piątek 06 paź 2023, 00:00

tapy pisze:i8085 nie ma dziur w liście rozkazów, są tam zdefiniowane i jednolite dla każdego producenta instrukcje o których intel nie był łaskaw wspomnieć, by nie utrzymywać popularności procesorów 8-bit po premierze swojego 8086, a które były zawarte już w pierwszych maskach NMOS tego procesora. 8085 to niechciane dziecko marketingu tej firmy. Na tym forum o nich wspomniałem, a do tych instrukcji przyznaje się tylko kanadyjska firma Tundra, reszta producentów o nich milczy.

A faktycznie, przypominam sobie. Ściągnąłem PDF Tundry i porównałem z informacją w książce "Modułowe systemy mikroprocesorowe". Generalnie informacje są zbieżna i występuje jedynie różnica w nazwie dwóch instrukcji. W dokumentacji Tundry podane są informacje o zachowaniu się wskaźników, co dla emulatora jest niezmiernie istotne i rozszerzę swój program emulatora o nowe instrukcje. Będzie super.

Postautor: **gaweł** » piątek 06 paź 2023, 20:09

Korekta do nowych możliwości

em8085-20.png

Jak obiecałem, tak i robię, ale pojawił się niespodziewany problem (chyba, że czegoś nie rozumiem). Otóż, w dokumentacji "nieautoryzowanych" instrukcji jest:

em8085-21.png

W instrukcji LHLX występuje jednobajtowy operand i to się kłóci z moim wyobrażeniem. Z opisu nie wynika, by ta instrukcja wymagała operandu, więc WTF?

Postautor: **tapy** » piątek 06 paź 2023, 21:11

To jakiś chochlik, instrukcja jest jednobajtowa w nomenklaturze ziloga wyglądała by tak: LD HL, (DE)

Postautor: **gaweł** » piątek 06 paź 2023, 22:06

tapy pisze:To jakiś chochlik...

No popatrz, każdy może się pomylić. Dokumentacja zapewne ma kilkadziesiąt lat i nikt nie zauważył...? Jak na wszystko trzeba uważać

W każdym bądź razie już zmodyfikowałem swój kompiler, by akceptował nowe instrukcje i można było bardziej przetestować emulator, w końcu ktoś musi wygenerować rozszerzone kody. Kompiler działa:

Kod: Zaznacz cały

Improved compiler for INTEL 8080/8085 processor, version 2.1, licence: CC BY 3.0

  L.NO MEMO    CODE         SRC

Open file: D:\microgeek\asm8080\T8085.ASM
    1.                 ; 
    2.                 ;  ***************************************************
    3.                 ;  *                                                 *
    4.                 ;  *                                                 *
    5.                 ;  *    zbior instrukcji mikroprocesora 8085         *
    6.                 ;  *                                                 *
    7.                 ;  *                                                 *
    8.                 ;  ***************************************************
    9.                 ; 
   10.                         .i8085
   11.                         .org 0
   12. 1234            Data16  .equ 1234h
   13. 0056            Data8   .equ 56h
   14. 0000 48656C6C   Hello   .defb   'Hello world'
       0004 6F20776F
       0008 726C64
   15. 000B 76                 HLT                              ; 76
   16. 000C CE56               ACI Data8                        ; CE56
   17. 000E 8F                 ADC A                            ; 8F
   18. 000F 88                 ADC B                            ; 88
   19. 0010 89                 ADC C                            ; 89
   20. 0011 8A                 ADC D                            ; 8A
   21. 0012 8B                 ADC E                            ; 8B
   22. 0013 8C                 ADC H                            ; 8C
   23. 0014 8D                 ADC L                            ; 8D
   24. 0015 8E                 ADC M                            ; 8E
   25. 0016 87                 ADD A                            ; 87
   26. 0017 80                 ADD B                            ; 80
   27. 0018 81                 ADD C                            ; 81
   28. 0019 82                 ADD D                            ; 82
   29. 001A 83                 ADD E                            ; 83
   30. 001B 84                 ADD H                            ; 84
   31. 001C 85                 ADD L                            ; 85
   32. 001D 86                 ADD M                            ; 86
   33. 001E C656               ADI Data8                        ; C656
   34. 0020 A7                 ANA A                            ; A7
   35. 0021 A0                 ANA B                            ; A0
   36. 0022 A1                 ANA C                            ; A1
   37. 0023 A2                 ANA D                            ; A2
   38. 0024 A3                 ANA E                            ; A3
   39. 0025 A4                 ANA H                            ; A4
   40. 0026 A5                 ANA L                            ; A5
   41. 0027 A6                 ANA M                            ; A6
   42. 0028 E656               ANI Data8                        ; E656
   43. 002A CD3412             CALL Data16                      ; CD3412
   44. 002D DC3412             CC Data16                        ; DC3412
   45. 0030 FC3412             CM Data16                        ; FC3412
   46. 0033 2F                 CMA                              ; 2F
   47. 0034 3F                 CMC                              ; 3F
   48. 0035 BF                 CMP A                            ; BF
   49. 0036 B8                 CMP B                            ; B8
   50. 0037 B9                 CMP C                            ; B9
   51. 0038 BA                 CMP D                            ; BA
   52. 0039 BB                 CMP E                            ; BB
   53. 003A BC                 CMP H                            ; BC
   54. 003B BD                 CMP L                            ; BD
   55. 003C BE                 CMP M                            ; BE
   56. 003D D43412             CNC Data16                       ; D43412
   57. 0040 C43412             CNZ Data16                       ; C43412
   58. 0043 F43412             CP Data16                        ; F43412
   59. 0046 EC3412             CPE Data16                       ; EC3412
   60. 0049 FE56               CPI Data8                        ; FE56
   61. 004B E43412             CPO Data16                       ; E43412
   62. 004E CC3412             CZ Data16                        ; CC3412
   63. 0051 27                 DAA                              ; 27
   64. 0052 09                 DAD B                            ; 09
   65. 0053 19                 DAD D                            ; 19
   66. 0054 29                 DAD H                            ; 29
   67. 0055 39                 DAD SP                           ; 39
   68. 0056 3D                 DCR A                            ; 3D
   69. 0057 05                 DCR B                            ; 05
   70. 0058 0D                 DCR C                            ; 0D
   71. 0059 15                 DCR D                            ; 15
   72. 005A 1D                 DCR E                            ; 1D
   73. 005B 25                 DCR H                            ; 25
   74. 005C 2D                 DCR L                            ; 2D
   75. 005D 35                 DCR M                            ; 35
   76. 005E 0B                 DCX B                            ; 0B
   77. 005F 1B                 DCX D                            ; 1B
   78. 0060 2B                 DCX H                            ; 2B
   79. 0061 3B                 DCX SP                           ; 3B
   80. 0062 F3                 DI                               ; F3
   81. 0063 FB                 EI                               ; FB
   82. 0064 76                 HLT                              ; 76
   83. 0065 DB56               IN Data8                         ; DB56
   84. 0067 D356               OUT Data8                        ; D356
   85. 0069 3C                 INR A                            ; 3C
   86. 006A 04                 INR B                            ; 04
   87. 006B 0C                 INR C                            ; 0C
   88. 006C 14                 INR D                            ; 14
   89. 006D 1C                 INR E                            ; 1C
   90. 006E 24                 INR H                            ; 24
   91. 006F 2C                 INR L                            ; 2C
   92. 0070 34                 INR M                            ; 34
   93. 0071 03                 INX B                            ; 03
   94. 0072 13                 INX D                            ; 13
   95. 0073 23                 INX H                            ; 23
   96. 0074 33                 INX SP                           ; 33
   97. 0075 DA3412             JC Data16                        ; DA3412
   98. 0078 FA3412             JM Data16                        ; FA3412
   99. 007B C33412             JMP Data16                       ; C33412
  100. 007E D23412             JNC Data16                       ; D23412
  101. 0081 C23412             JNZ Data16                       ; C23412
  102. 0084 F23412             JP Data16                        ; F23412
  103. 0087 EA3412             JPE Data16                       ; EA3412
  104. 008A E23412             JPO Data16                       ; E23412
  105. 008D CA3412             JZ Data16                        ; CA3412
  106. 0090 3A3412             LDA Data16                       ; 3A3412
  107. 0093 0A                 LDAX B                           ; 0A
  108. 0094 1A                 LDAX D                           ; 1A
  109. 0095 2A3412             LHLD Data16                      ; 2A3412
  110. 0098 013412             LXI B,Data16                     ; 013412
  111. 009B 113412             LXI D,Data16                     ; 113412
  112. 009E 213412             LXI H,Data16                     ; 213412
  113. 00A1 313412             LXI SP,Data16                    ; 313412
  114. 00A4 7F                 MOV A,A                          ; 7F
  115. 00A5 78                 MOV A,B                          ; 78
  116. 00A6 79                 MOV A,C                          ; 79
  117. 00A7 7A                 MOV A,D                          ; 7A
  118. 00A8 7B                 MOV A,E                          ; 7B
  119. 00A9 7C                 MOV A,H                          ; 7C
  120. 00AA 7D                 MOV A,L                          ; 7D
  121. 00AB 7E                 MOV A,M                          ; 7E
  122. 00AC 47                 MOV B,A                          ; 47
  123. 00AD 40                 MOV B,B                          ; 40
  124. 00AE 41                 MOV B,C                          ; 41
  125. 00AF 42                 MOV B,D                          ; 42
  126. 00B0 43                 MOV B,E                          ; 43
  127. 00B1 44                 MOV B,H                          ; 44
  128. 00B2 45                 MOV B,L                          ; 45
  129. 00B3 46                 MOV B,M                          ; 46
  130. 00B4 4F                 MOV C,A                          ; 4F
  131. 00B5 48                 MOV C,B                          ; 48
  132. 00B6 49                 MOV C,C                          ; 49
  133. 00B7 4A                 MOV C,D                          ; 4A
  134. 00B8 4B                 MOV C,E                          ; 4B
  135. 00B9 4C                 MOV C,H                          ; 4C
  136. 00BA 4D                 MOV C,L                          ; 4D
  137. 00BB 4E                 MOV C,M                          ; 4E
  138. 00BC 57                 MOV D,A                          ; 57
  139. 00BD 50                 MOV D,B                          ; 50
  140. 00BE 51                 MOV D,C                          ; 51
  141. 00BF 52                 MOV D,D                          ; 52
  142. 00C0 53                 MOV D,E                          ; 53
  143. 00C1 54                 MOV D,H                          ; 54
  144. 00C2 55                 MOV D,L                          ; 55
  145. 00C3 56                 MOV D,M                          ; 56
  146. 00C4 5F                 MOV E,A                          ; 5F
  147. 00C5 58                 MOV E,B                          ; 58
  148. 00C6 59                 MOV E,C                          ; 59
  149. 00C7 5A                 MOV E,D                          ; 5A
  150. 00C8 5B                 MOV E,E                          ; 5B
  151. 00C9 5C                 MOV E,H                          ; 5C
  152. 00CA 5D                 MOV E,L                          ; 5D
  153. 00CB 5E                 MOV E,M                          ; 5E
  154. 00CC 67                 MOV H,A                          ; 67
  155. 00CD 60                 MOV H,B                          ; 60
  156. 00CE 61                 MOV H,C                          ; 61
  157. 00CF 62                 MOV H,D                          ; 62
  158. 00D0 63                 MOV H,E                          ; 63
  159. 00D1 64                 MOV H,H                          ; 64
  160. 00D2 65                 MOV H,L                          ; 65
  161. 00D3 66                 MOV H,M                          ; 66
  162. 00D4 6F                 MOV L,A                          ; 6F
  163. 00D5 68                 MOV L,B                          ; 68
  164. 00D6 69                 MOV L,C                          ; 69
  165. 00D7 6A                 MOV L,D                          ; 6A
  166. 00D8 6B                 MOV L,E                          ; 6B
  167. 00D9 6C                 MOV L,H                          ; 6C
  168. 00DA 6D                 MOV L,L                          ; 6D
  169. 00DB 6E                 MOV L,M                          ; 6E
  170. 00DC 77                 MOV M,A                          ; 77
  171. 00DD 70                 MOV M,B                          ; 70
  172. 00DE 71                 MOV M,C                          ; 71
  173. 00DF 72                 MOV M,D                          ; 72
  174. 00E0 73                 MOV M,E                          ; 73
  175. 00E1 74                 MOV M,H                          ; 74
  176. 00E2 75                 MOV M,L                          ; 75
  177. 00E3 3E56               MVI A,Data8                      ; 3E56
  178. 00E5 0656               MVI B,Data8                      ; 0656
  179. 00E7 0E56               MVI C,Data8                      ; 0E56
  180. 00E9 1656               MVI D,Data8                      ; 1656
  181. 00EB 1E56               MVI E,Data8                      ; 1E56
  182. 00ED 2656               MVI H,Data8                      ; 2656
  183. 00EF 2E56               MVI L,Data8                      ; 2E56
  184. 00F1 3656               MVI M,Data8                      ; 3656
  185. 00F3 00                 NOP                              ; 00
  186. 00F4 B7                 ORA A                            ; B7
  187. 00F5 B0                 ORA B                            ; B0
  188. 00F6 B1                 ORA C                            ; B1
  189. 00F7 B2                 ORA D                            ; B2
  190. 00F8 B3                 ORA E                            ; B3
  191. 00F9 B4                 ORA H                            ; B4
  192. 00FA B5                 ORA L                            ; B5
  193. 00FB B6                 ORA M                            ; B6
  194. 00FC F656               ORI Data8                        ; F656
  195. 00FE E9                 PCHL                             ; E9
  196. 00FF C1                 POP B                            ; C1
  197. 0100 D1                 POP D                            ; D1
  198. 0101 E1                 POP H                            ; E1
  199. 0102 F1                 POP PSW                          ; F1
  200. 0103 C5                 PUSH B                           ; C5
  201. 0104 D5                 PUSH D                           ; D5
  202. 0105 E5                 PUSH H                           ; E5
  203. 0106 F5                 PUSH PSW                         ; F5
  204. 0107 17                 RAL                              ; 17
  205. 0108 1F                 RAR                              ; 1F
  206. 0109 D8                 RC                               ; D8
  207. 010A C9                 RET                              ; C9
  208. 010B 07                 RLC                              ; 07
  209. 010C F8                 RM                               ; F8
  210. 010D D0                 RNC                              ; D0
  211. 010E C0                 RNZ                              ; C0
  212. 010F F0                 RP                               ; F0
  213. 0110 E8                 RPE                              ; E8
  214. 0111 E0                 RPO                              ; E0
  215. 0112 0F                 RRC                              ; 0F
  216. 0113 C7                 RST 0                            ; C7
  217. 0114 CF                 RST 1                            ; CF
  218. 0115 D7                 RST 2                            ; D7
  219. 0116 DF                 RST 3                            ; DF
  220. 0117 E7                 RST 4                            ; E7
  221. 0118 EF                 RST 5                            ; EF
  222. 0119 F7                 RST 6                            ; F7
  223. 011A FF                 RST 7                            ; FF
  224. 011B C8                 RZ                               ; C8
  225. 011C 9F                 SBB A                            ; 9F
  226. 011D 98                 SBB B                            ; 98
  227. 011E 99                 SBB C                            ; 99
  228. 011F 9A                 SBB D                            ; 9A
  229. 0120 9B                 SBB E                            ; 9B
  230. 0121 9C                 SBB H                            ; 9C
  231. 0122 9D                 SBB L                            ; 9D
  232. 0123 9E                 SBB M                            ; 9E
  233. 0124 DE56               SBI Data8                        ; DE56
  234. 0126 223412             SHLD Data16                      ; 223412
  235. 0129 F9                 SPHL                             ; F9
  236. 012A 323412             STA Data16                       ; 323412
  237. 012D 02                 STAX B                           ; 02
  238. 012E 12                 STAX D                           ; 12
  239. 012F 37                 STC                              ; 37
  240. 0130 97                 SUB A                            ; 97
  241. 0131 90                 SUB B                            ; 90
  242. 0132 91                 SUB C                            ; 91
  243. 0133 92                 SUB D                            ; 92
  244. 0134 93                 SUB E                            ; 93
  245. 0135 94                 SUB H                            ; 94
  246. 0136 95                 SUB L                            ; 95
  247. 0137 96                 SUB M                            ; 96
  248. 0138 D656               SUI Data8                        ; D656
  249. 013A EB                 XCHG                             ; EB
  250. 013B AF                 XRA A                            ; AF
  251. 013C A8                 XRA B                            ; A8
  252. 013D A9                 XRA C                            ; A9
  253. 013E AA                 XRA D                            ; AA
  254. 013F AB                 XRA E                            ; AB
  255. 0140 AC                 XRA H                            ; AC
  256. 0141 AD                 XRA L                            ; AD
  257. 0142 AE                 XRA M                            ; AE
  258. 0143 EE56               XRI Data8                        ; EE56
  259. 0145 E3                 XTHL                             ; E3
  260. 0146 20                 RIM                              ; 20
  261. 0147 30                 SIM                              ; 30
  262. 0148 10                 ARHL                             ; 10
  263. 0149 08                 DSUB                             ; 08
  264. 014A DD3412             JNUI Data16                      ; DD3412
  265. 014D FD3412             JUI Data16                       ; FD3412
  266. 0150 2856               LDHI Data8                       ; 2856
  267. 0152 3856               LDSI Data8                       ; 3856
  268. 0154 ED                 LHLX                             ; ED
  269. 0155 18                 RDEL                             ; 18
  270. 0156 CB                 RSTV                             ; CB
  271. 0157 D9                 SHLX                             ; D9
  272.                  .end
Close file: D:\microgeek\asm8080\T8085.ASM

Compilation :successful


Map information about constants and labels:
Data16                           CONST=1234 hex [0001001000110100 bin,4660 dec]
Data8                            CONST=0056 hex [0000000001010110 bin,86 dec]
Hello                            LABEL:0000 hex


Code stored in file: D:\microgeek\asm8080\T8085.hex

Poprawiony kompiler (opisany <tutaj>):

I8080.7z

Postautor: **Zegar** » sobota 07 paź 2023, 12:26

Dzięki za ten temat. Oderwałem się na chwilę od moich zabawek.

Jednak jest coś, co mnie męczy: czy jest ktoś, kto miał przyjemność używać CA85?

CA85.jpg

Pobawiłbym się...

Postautor: **gaweł** » sobota 07 paź 2023, 19:02

O kurcze... SA80

CA85.jpg

SA80, miałem okazję tego dotknąć na studiach. Nawet czas by się zgadzał, pierwsza połowa lat 80-tych. Znajomy naukowiec robił badania (a przy okazji doktorat) na politechnice. Tak jakoś wyszło, że mu pomagałem troszkę. Robił jakieś pomiary, były przetworniki AC. Bosze, myśmy na tym próbowali implementować zmienny przecinek... To były szalone czasy, ale z drugiej strony fascynujące.
A tak przy okazji, to był mój poligon za Z80.

Postautor: **Zegar** » sobota 07 paź 2023, 19:38

sa01.jpeg

Z CA80 miałem kontakt w technikum. Nauczyciel podstaw automatyki był kolegą Stanisława Gardynika. Studiowali razem, a potem spotykali się na "Perskim". Przychodził do szkoły ze swoim SA80, ale był też szkolny egzemplarz (praca dyplomowa sprzed 2-3 lat). Tak mnie zaciekawił, że chciałem mieć swój, więc przywoził mi z Warszawy części po kilka scalaków na miesiąc, aż uzbierał się cały. W tym czasie "szkolny" miałem w domu. Kiedy mój był gotowy, okazało się, że wyświetla "CA80" - była to nowa wersja. Mam go do dzisiaj, ale CA85 mnie ominął.

Postautor: **gaweł** » sobota 07 paź 2023, 19:49

No to jesteś stary zawodnik w te klocki :lol:

Postautor: **Zegar** » sobota 07 paź 2023, 20:05

gaweł pisze:No to jesteś stary zawodnik w te klocki

Pierwszy-CA80-arch.png

IMG_20190810_145747.jpg

Postautor: **phill2k** » sobota 07 paź 2023, 21:12

Do kompletu - 8080 8085 Software Design Book 2

Postautor: **gaweł** » poniedziałek 09 paź 2023, 14:59

Kolejne rozszerzenia i korekty

em8085-31.png

W związku z tym, że zostają uwzględnione "nieoficjalne" instrukcje, program emulatora ulega modyfikacji i rozszerzeniu. Z dokumentacji wynika, że dochodzą dwa wskaźniki w rejestrze PSW: V - wskaźnik nadmiaru w operacjach w kodzie U2 oraz UI - wskaźnik nadmiaru dla operacji INX i DCX. Trochę mnie to dziwi i niepokoi, gdyż wskaźnik nadmiaru dotyczy operacji w kodzie U2. Znaczy, że inkrementacja i dekrementacji par rejestrów musi być traktowana jako operacja ze znakiem, jakie to ma zastosowanie?
Dodatkowo zaistnienie instrukcji RSTV (obsługa przerwania w sytuacji wystąpienia nadmiaru V) generuje powstanie kolejnego wektora przerwań z punktem wejścia do obsługi na adresie 40 hex. To z kolei poszerza możliwość konfiguracji projektu o obsługę przerwania od takiego zdarzenia.

Postautor: **gaweł** » wtorek 10 paź 2023, 17:37

Konfiguracja

em8085-41.png

Po uruchomieniu programu emulatora, mamy możliwość otwarcia istniejącego projektu lub utworzenie nowego. Po kliknięciu na „Nowy proj.” program poprosi o wszystkie niezbędne informacje. Należą do nich:

nazwa projektu:
em8085-42.png
nazwa pliku z kodem binarnym programu:
em8085-43.png
określenie przestrzeni adresowej pamięci ROM (na program) – od .. do
em8085-44.png
em8085-45.png
określenie przestrzeni adresowej pamięci RAM – od .. do
em8085-46.png
em8085-47.png

Daje to minimalną konfigurację środowiska. Dodatkowo można dodać zestaw portów we, wy lub we/wy klikając na „Dodaj el.”, gdzie istnieje możliwość dodania określonego typu informacji, przykładowo portów we:

em8085-48.png

i w dalszej kolejności zakresu adresowego portów:

em8085-49.png

em8085-50.png

Przycisk „Konf. Przerw.” służy do określenia przerwań, jakie są obsługiwane w programie. Wśród znanych dotychczas przerwań pojawia się nowe. Program został rozbudowany o kolejną pozycję: przerwania od nadmiaru arytmetycznego: RSTV.

em8085-51.png

Wszystkie wprowadzone dane środowiskowe są wyświetlone w okienku:

em8085-52.png

Można je zapisać do pliku i posiłkować się tym plikiem na przyszłość.
Teraz pozostało załadować kod programu (znana pliku jest już znana). Przy tej operacji sprawdzana jest zgodność wklepanych danych z załadowanym kodem. Głównie chodzi tu o obsługę przerwań, gdzie każde z nich ma swój indywidualny adres obsługi – w ładowanym kodzie na adresach specyfikowanych przerwań musi wystąpić kod programu.

em8085-53.png

Oczywiście program nie jest w stanie sprawdzić na tym etapie, czy rzeczywiście jest to kod obsługi przerwań. Program emulatora jest jedynie narzędziem wsparcia i nie zwalnia „od myślenia” użytkownika.
Przykładowa postać źródłowa programu intelowego jest następująca:

em8085-54.png

Emulator „zauważył”, że w kodzie binarnym programu w lokacji adresowej przewidzianej do obsługi przerwania coś jest.

Postautor: **gaweł** » sobota 14 paź 2023, 17:59

Emulacja programu

Program ciągle się rozwija i ulega zmianom. Jednocześnie przechodzi testy. Ponieważ pewne działania wymagają określonej kolejności (w sensie klikania na przyciski, gdyż przykładowo trudno kliknąć na „wykonaj krok” jeżeli nie jest załadowany program), to jego działanie zostało rozbudowane o funkcjonalność „wskazującą na możliwy kolejny krok”. Obecnie po uruchomieniu programu mamy dostępne przyciski pozwalające na utworzenie lub otwarcie pliku projektu. Istnieje również możliwość upuszczenia nazwy pliku projektu na formę programu, co jest równoznaczne z otwarciem tego konkretnego pliku.

em8085-61.png

Jako przykład będę posługiwał się następującym plikiem źródłowym (który należy skompilować by uzyskać program binarny). Zawiera on obsługą przerwań sprzętowych i jakiś tam zestaw instrukcji (które właściwie nie tworzą jakiegoś sensownego programu, na to przyjdzie czas później).

Kod: Zaznacz cały

; 
;  ***************************************************
;  *                                                 *
;  *    zbior instrukcji mikroprocesora 8080         *
;  *                                                 *
;  ***************************************************
; 
;        .i8080
        .i8085
ResetEntry   .equ 0000h
RST1Entry       .equ 0008h
RST2Entry       .equ 0010h
RST3Entry       .equ 0018h
RST4Entry       .equ 0020h
TRAPEntry   .equ 0024h
RST5Entry       .equ 0028h
RST55Entry      .equ 002Ch
RST6Entry       .equ 0030h
RST65Entry      .equ 0034h
RST7Entry       .equ 0038h
RST75Entry      .equ 003Ch
;
Data8   .equ 56h
        .org ResetEntry
        di
        lxi sp,0
        jmp StartProg
        .org RST1Entry
        jmp RST1Service
        .org RST2Entry
        jmp RST2Service
        .org RST3Entry
        jmp RST3Service
        .org RST4Entry
        jmp RST4Service
        .org TRAPEntry
        jmp TRAPService
        .org RST5Entry
        jmp RST5Service
        .org RST55Entry
        jmp RST55Service
        .org RST6Entry
        jmp RST6Service
        .org RST65Entry
        jmp RST65Service
        .org RST7Entry
        jmp RST7Service
        .org RST75Entry
        jmp RST75Service
RST1Service
        nop
        nop
        ei
        ret
RST2Service
        nop
        nop
        ei
        ret
RST3Service
        nop
        nop
        ei
        ret
RST4Service
        nop
        nop
        ei
        ret
TRAPService
        jmp TRAPService
        ret
RST5Service
        nop
        nop
        ei
        ret
RST55Service
        nop
        nop
        ei
        ret
RST6Service
        nop
        nop
        ei
        ret
RST65Service
        nop
        nop
        ei
        ret
RST7Service
        nop
        nop
        ei
        ret
RST75Service
        nop
        nop
        mvi a,10h
        sim
        ei
        ret
StartProg
        di
        ei
loop
        call subr
        jmp  loop
subr
        di
        ei
        in 123
        in 0
        in 1
        in 2
        in 3
        in 038h
        out 123
        out 0
        out 1
        out 2
        out 3
        out 1Ah
        lhld lhldop
        shld shldop
        lxi h,5aa5h
   xthl
        xthl
        lxi h,089abh                     ;
        rim
        mvi a,08h
        sim
        rim
        mov a,m
        inx h
        mov b,m
        inx h
        mov c,m
        inx h
        mov d,m
        inx h
        mov e,m
        xchg
        ACI Data8                        ; CE56
        ADC A                            ; 8F
        ADC B                            ; 88
        ADC C                            ; 89
        ADC D                            ; 8A
        ADC E                            ; 8B
        ADC H                            ; 8C
        ADC L                            ; 8D
        xchg
        ADC M                            ; 8E
        ADD A                            ; 87
        ADD B                            ; 80
        ADD C                            ; 81
        ADD D                            ; 82
        ADD E                            ; 83
        ADD H                            ; 84
        ADD L                            ; 85
        ADD M                            ; 86
        ADI Data8                        ; C656
        ANA A                            ; A7
        ANA B                            ; A0
        ANA C                            ; A1
        ANA D                            ; A2
        ANA E                            ; A3
        ANA H                            ; A4
        ANA L                            ; A5
        ANA M                            ; A6
        ANI Data8                        ; E656
        CMA                              ; 2F
        CMC                              ; 3F
        CMP A                            ; BF
        CMP B                            ; B8
        CMP C                            ; B9
        CMP D                            ; BA
        CMP E                            ; BB
        CMP H                            ; BC
        CMP L                            ; BD
        CMP M                            ; BE
        DAA                              ; 27
        DAD B                            ; 09
        DAD D                            ; 19
        DAD H                            ; 29
        DAD SP                           ; 39
        DCR A                            ; 3D
        DCR B                            ; 05
        DCR C                            ; 0D
        DCR D                            ; 15
        DCR E                            ; 1D
        DCR H                            ; 25
        DCR L                            ; 2D
        DCX B                            ; 0B
        DCX D                            ; 1B
        DCX H                            ; 2B
        DCX SP                           ; 3B
        DI                               ; F3
        EI                               ; FB
        IN Data8                         ; DB56
        OUT Data8                        ; D356
        INR A                            ; 3C
        INR B                            ; 04
        INR C                            ; 0C
        INR D                            ; 14
        INR E                            ; 1C
        INR H                            ; 24
        INR L                            ; 2C
        INX B                            ; 03
        INX D                            ; 13
        INX H                            ; 23
        INX SP                           ; 33
        LDA Data16                       ; 3A3412
        LDAX B                           ; 0A
        LDAX D                           ; 1A
        LHLD Data16                      ; 2A3412
        LXI B,Data16                     ; 013412
        LXI D,Data16                     ; 113412
        LXI H,Data16                     ; 213412
        MOV A,A                          ; 7F
        MOV A,B                          ; 78
        MOV A,C                          ; 79
        MOV A,D                          ; 7A
        MOV A,E                          ; 7B
        MOV A,H                          ; 7C
        MOV A,L                          ; 7D
        MOV A,M                          ; 7E
        MOV B,A                          ; 47
        MOV B,B                          ; 40
        MOV B,C                          ; 41
        MOV B,D                          ; 42
        MOV B,E                          ; 43
        MOV B,H                          ; 44
        MOV B,L                          ; 45
        MOV B,M                          ; 46
        MOV C,A                          ; 4F
        MOV C,B                          ; 48
        MOV C,C                          ; 49
        MOV C,D                          ; 4A
        MOV C,E                          ; 4B
        MOV C,H                          ; 4C
        MOV C,L                          ; 4D
        MOV C,M                          ; 4E
        MOV D,A                          ; 57
        MOV D,B                          ; 50
        MOV D,C                          ; 51
        MOV D,D                          ; 52
        MOV D,E                          ; 53
        MOV D,H                          ; 54
        MOV D,L                          ; 55
        MOV D,M                          ; 56
        MOV E,A                          ; 5F
        MOV E,B                          ; 58
        MOV E,C                          ; 59
        MOV E,D                          ; 5A
        MOV E,E                          ; 5B
        MOV E,H                          ; 5C
        MOV E,L                          ; 5D
        MOV E,M                          ; 5E
        MOV H,A                          ; 67
        MOV H,B                          ; 60
        MOV H,C                          ; 61
        MOV H,D                          ; 62
        MOV H,E                          ; 63
        MOV H,H                          ; 64
        MOV H,L                          ; 65
        MOV H,M                          ; 66
        MOV L,A                          ; 6F
        MOV L,B                          ; 68
        MOV L,C                          ; 69
        MOV L,D                          ; 6A
        MOV L,E                          ; 6B
        MOV L,H                          ; 6C
        MOV L,L                          ; 6D
        MOV L,M                          ; 6E
        MOV M,A                          ; 77
        MOV M,B                          ; 70
        MOV M,C                          ; 71
        MOV M,D                          ; 72
        MOV M,E                          ; 73
        MOV M,H                          ; 74
        MOV M,L                          ; 75
        MVI A,Data8                      ; 3E56
        MVI B,Data8                      ; 0656
        MVI C,Data8                      ; 0E56
        MVI D,Data8                      ; 1656
        MVI E,Data8                      ; 1E56
        MVI H,Data8                      ; 2656
        MVI L,Data8                      ; 2E56
        MVI M,Data8                      ; 3656
        NOP                              ; 00
        ORA A                            ; B7
        ORA B                            ; B0
        ORA C                            ; B1
        ORA D                            ; B2
        ORA E                            ; B3
        ORA H                            ; B4
        ORA L                            ; B5
        ORA M                            ; B6
        ORI Data8                        ; F656
        PUSH B                           ; C5
        PUSH D                           ; D5
        PUSH H                           ; E5
        PUSH PSW                         ; F5
        POP PSW                          ; F1
        POP H                            ; C1
        POP D                            ; D1
        POP B                            ; E1
        RAL                              ; 17
        RAR                              ; 1F
        RC                               ; D8
        RLC                              ; 07
        RM                               ; F8
        RNC                              ; D0
        RNZ                              ; C0
        RP                               ; F0
        RPE                              ; E8
        RPO                              ; E0
        RRC                              ; 0F
        RST 0                            ; C7
        RST 1                            ; CF
        RST 2                            ; D7
        RST 3                            ; DF
        RST 4                            ; E7
        RST 5                            ; EF
        RST 6                            ; F7
        RST 7                            ; FF
        RZ                               ; C8
        SBB A                            ; 9F
        SBB B                            ; 98
        SBB C                            ; 99
        SBB D                            ; 9A
        SBB E                            ; 9B
        SBB H                            ; 9C
        SBB L                            ; 9D
        SBB M                            ; 9E
        SBI Data8                        ; DE56
        SHLD Data16                      ; 223412
        SPHL                             ; F9
        STA Data16                       ; 323412
        STAX B                           ; 02
        STAX D                           ; 12
        STC                              ; 37
        SUB A                            ; 97
        SUB B                            ; 90
        SUB C                            ; 91
        SUB D                            ; 92
        SUB E                            ; 93
        SUB H                            ; 94
        SUB L                            ; 95
        SUB M                            ; 96
        SUI Data8                        ; D656
        XCHG                             ; EB
        XRA A                            ; AF
        XRA B                            ; A8
        XRA C                            ; A9
        XRA D                            ; AA
        XRA E                            ; AB
        XRA H                            ; AC
        XRA L                            ; AD
        XRA M                            ; AE
        XRI Data8                        ; EE56
        XTHL                             ; E3
        RIM                              ; 20
        SIM                              ; 30
        RET                              ; C9
lhldop  .defw   1234h
        .org 08000h
Data16   .word
shldop  .word
.end

Po otwarciu pliku projektu istnieje możliwość jego modyfikacji lub załadowania kodu programu binarnego.

em8085-62.png

Oczywiście zmienia się zestaw dostępnych operacji. Jeżeli projekt nie jest modyfikowany można załadować program binarny klikając na „Ładuj hex” (jego nazwa jest już wpisana z plik projektu). Jeżeli w trakcie symulacji zostaną dostrzeżone własne błędy, to można zmodyfikować program źródłowy (ten dla intela), skompilować i ponownie kliknąć na „Ładuj hex” (nie ma konieczności zamykania programu emulatora lub ponownego otwierania projektu). Po załadowaniu kodu, program jest deasemblowany i jest postać jest pokazana w okienku.

em8085-63.png

W tym przykładzie wszystkie skoki i wywołania są „jawne”, więc nie ma „potencjalnych” martwych kodów. Po kliknięciu na „Krok” lub „Uruchom” program staruje i nie ma już możliwości „grzebania” w konfiguracji projektu. By wrócić do tej możliwości program należy zatrzymać klikając na „Zatrzymaj” (to nic, że program „stoi”, gdyż został puszczony krokowy, ale jest w kontekście <uruchomiony>, więc będzie wymagał zatrzymania, by stały się dostępne pewne jego funkcje). Załadowanie wskaźnika stosu powoduje, że zostaje wyświetlony stos – zawartość pamięci wskazana przez rejestr SP. Stos jest pokazany oczywiście „od tyłu” i widać tu dosyć przypadkowe wartości. Funkcją programu jest wypełnienie wszystkich pamięci RAM losową zawartością po każdym kliknięciu na „Reset”. Załadowanie kodu programu (Ładuj hex) również jest połączone z automatycznym resetem.

em8085-64.png

Wykonanie instrukcji EI DI (odblokowanie przerwań), sygnalizuje możliwość przyjęcia klasycznych (w sensie procka i8080) przerwań sprzętowych.

em8085-65.png

Kliknięcie na przerwanie niemaskowalne (TRAP) powoduje skod do jego obsługi, która zatrzymuje program w ciasnej pętli (skok do samego siebie).

em8085-66.png

Fajnie jest wiedzieć, co i gdzie zaszło? Co to wiadomo: TRAP, ale gdzie? Po kliknięciu prawym klawiszem z powstałego menu wybieramy „Kolejka wywołań”.

em8085-67.png

Wyświetlona jest istniejąca kolejka wywołań: normalnych wywołań oraz obsługi przerwań.

em8085-68.png

Pokazany tekst można sobie zapisać do pliku, co może być pomocne przy analizie programu. Ponieważ program został zatrzymany w obsłudze przerwań, to pozostaje jedynie przycisk „Reset” i wszystko wraca na początek.
Załadowanie czegokolwiek z pamięci do jakiegokolwiek rejestru pokazuje docelowe lub źródłowe miejsce w pamięci w okienku danych. To wyświetlenie jest takim krokiem w „przyszłość”, stan pokazanego obszaru danych jest jeszcze przed wykonaniem instrukcji. Poniżej LHLD z podanym adresem 1AB hex pokazuje, że do pary HL zostanie wpisane 1234 hex (starsza część jest na starszym adresie).

em8085-69.png

Przed kolejną instrukcją SHLD w okienku danych pokazana jest zawartość pamięci jeszcze przed wykonaniem instrukcji, która jest losowa (bo to pamięć RAM wypełniona losowo w wyniku akcji reset).

em8085-70.png

Ponieważ kolejna instrukcja ładuje do HL stałą i program próbuje pokazać, gdzie to wskazuje, to nie widać skutku operacji zapisu.

em8085-71.png

Możliwym wyjściem jest kliknięcie prawym klawiszem i z powstałego menu wybrać:

em8085-72.png

am był adres 8002 hex, więc taki zostaje wpisany.

em8085-73.png

Wcześniej było C994 hex, teraz tam jest 1234 hex.

em8085-74.png

By wrócić, wystarczy kliknąć na pole HL.

em8085-75.png

Identycznie kliknięcie na DE lub BC również pokazuje w okienku pamięć adresowaną przez odpowiednie pary rejestrów. Również programowe załadowanie czegokolwiek do tych par rejestrów daje w reakcji wyświetlenie danych zawartych w przestrzeni adresowej.

Postautor: **gaweł** » niedziela 15 paź 2023, 17:31

Modyfikacja stanów rejestrów

Po załadowaniu kodu programu do pamięci emulatora (po wcześniejszym otwarciu projektu), program można puścić na żywioł. Istotną funkcją emulatora jest „pilnowanie” by wszystko szło właściwie oraz zgłaszanie „nadużyć”.

em8085-81.png

Przykładowo, zaistniało naruszenie przestrzeni pamięci ROM, gdyż zapis czegokolwiek w ten obszar jest niedopuszczalny.

em8085-82.png

Wykonanie programu zostało zatrzymane z odpowiednim komunikatem. Problem wygenerowała instrukcja DCR M, której zadaniem jest dekrementacja bajtu pamięci o adresie wskazanym zawartością pary rejestrów HL. Wskazuje on na obszar pamięci ROM. Odczyt z tego obszaru jest możliwy, jednak zapis tam technicznie nie jest możliwy.

em8085-83.png

Podobna sytuacja wystąpiła nieco później. Przed instrukcją MVI M,…. została załadowana para rejestrów HL, ale w wyniku „własnej pomyłki” to nie jest właściwa wartość w tej parze rejestrów.

em8085-84.png

Możliwe jest dokonanie modyfikacji bez potrzeby edycji programu źródłowego i jego kompilacji (no chyba, że będzie to zachodzić wielokrotnie, to wtedy jest to bardziej uzasadnione). Można dokonać korekty każdego pokazanego niżej rejestru:

em8085-85.png

Operacja zmiany zawartości rejestrów jest możliwa w sytuacji zatrzymanego programu lub gdy program jest puszczany krokowo. Należy kliknąć na wybrany rejestr i wprowadzić szesnastkowo nową wartość. Zmiany par rejestrów są realizowane przez dwie zmiany zawartości pojedynczych rejestrów (starsza część jest z lewej strony, młodsza z prawej strony). Zmiana rejestru BC, DE, HL jednocześnie wyświetla zawartość pamięci danych wskazaną przez modyfikację rejestrów składowych. Również możliwa jest zmiana zawartości wskaźnika stosu, jednak tu trzeba zachować czujność, bo może to doprowadzić, że program się zgubi (po przykładowo wykonaniu instrukcji RET). Pewnym ograniczeniom podlega modyfikacja rejestru PC. Istnieją instrukcje jednobajtowe, dwubajtowe oraz składające się z trzech bajtów. Wymagane jest by trafić zawsze na pierwszy bajt instrukcji (po deasemblacji wiadomo, gdzie zaczyna się każda instrukcja). W tym miejscu program nie da sobie zrobić krzywdy.

em8085-86.png

Wpisanie przykładowo do PC wartości 13C wskazuje na drugi bajt instrukcji LXI (czyli operand tej instrukcji).

Postautor: **gaweł** » niedziela 22 paź 2023, 13:07

Break point’y w programie

W emulatorze nie może zabraknąć funkcji związanych z pułapkami zwanymi break pointy. By to uzyskać to należy mieć załadowany program (ten w intelu).

em8085-91.png

W okienku z programem „przewinąć się” do punktu, w którym wykonanie programu ma zostać wstrzymane i zrobić tam dwuklik. Miejsce to zostaje oznaczone gwiazdką. Ponowny dwuklik w tym miejscu zdejmuje z tej instrukcji pułapkę. Jeżeli wskazana instrukcja nie była oznaczona flagą pułapki, to zostanie ona ustawiona, jeżeli była oznaczona flagą pułapki, to zostaje zdjęta. Pułapek można w programie ustawić dowolną ilość. Efektem operacji pułapkowej jest przestawienie podświetlenia w okienku programu (co nie zmienia wartości zapisanej w rejestrze PC). By wrócić należy użyć prawego klawisza myszki i wybrać opcję „Skocz do miejsca wskazanego przez PC”. I wszystko wraca do normy.

em8085-92.png

Uruchomienie programu „na żywioł” (przycisk <Uruchom>) zatrzymuje wykonanie programu we wskazanym miejscu (program jest przed wykonaniem instrukcji). By przejść przez ten punkt należy kliknąć przycisk <Krok>.

em8085-93.png

Przy pracy krokowej wykonanie zawsze przechodzi przez pułapki bez zatrzymania wykonania.

em8085-94.png

By usunąć pułapki należy kliknąć prawym klawiszem myszki i wybrać <Usuń wszystkie pułapki>.

em8085-95.png

Jeżeli ktoś ma ochotę poeksperymentować z programem, to … zapraszam.

I8085emul_2023_10_22.7z

Postautor: **gaweł** » piątek 27 paź 2023, 21:49

Obsługa przerwań w emulatorze

em8085_90.png

Emulator procka realizuje obsługę przerwań opartą o prosty (ale skuteczny) kontroler i8214. Jego zadaniem (w kooperacji w parze z i8212) jest wypracowanie odpowiedniej instrukcji, która jest zgłaszana w chwili akceptacji przyjęcia przerwania przez procka. Schemat takiego rozwiązania jest następujący:

em8085_91.png

Akceptacja przez procka przerwania prowadzi do wystawienia na szynie danych jednej z możliwych instrukcji RST n (no może z wyjątkiem RST 0, bo to będzie tożsame z resetem).
I dokładnie taka filozofia działania jest zawarta w emulatorze. Kliknięcie na jeden z przycisków zgłoszenia przerwania generuje sygnał do kontrolera.

em8085_92.png

Jeżeli jest zezwolenie na obsługę przerwań, to ta obsługa sprowadza się do „zasymulowania” wykonania odpowiedniego wariantu instrukcji RST n (dokładnie jak na schemacie wyżej). Także przycisk RST1 generuje instrukcję RST 1, i tak dalej aż do przycisku RST7,który generuje instrukcję RST 7. Obsługa przerwań połówkowych jest zrealizowana trochę odmiennie: na stos wędruje bieżąca zawartość rejestru PC i następuje wpisanie do rejestru PC odpowiedniego adresu wynikającego z obsługiwanego przerwania. Każde przerwanie RST1 .. RST7 oraz połówkowe (z wyjątkiem RST 7.5) gasi „lampkę” sygnalizującą zgłoszenie przerwania na przycisku), RST 7.5 wymaga potwierdzenia (odpowiednie zaklęcie w instrukcji SIM). Za każdym razem również emulator sam z siebie blokuje przyjęcie kolejnych przerwań (robi DI).
Symulacja bardziej rozbudowanego układu obsługi przerwań i8259 nie jest zrealizowana.
Obsługa przerwania niemaskowalnego TRAP (w nomenklaturze Ziloga: NMI) przebiega podobnie do przerwań połówkowych. Na stos wędruje stan rejestru PC i następnie do jego wpisywany jest odpowiednia adres związany z obsługą tego przerwania.

Postautor: **gaweł** » niedziela 05 lis 2023, 21:49

Operacje na portach

Używając emulatora, wyszło mi, że warto go trochę poprawić. Otóż, operacje na portach są sygnalizowane komunikatem w okienku, gdzie należy kliknąć <OK>. Na dłuższą metę to trochę nużące, więc postanowiłem trochę udoskonalić swój program. Na formie doszedł CheckBox określający, czy program ma informować o dokonanej transmisji na port (jak dotychczas), czy nie informować o tym zdarzeniu.

em8085-101.png

Jeżeli „ptaszek” nie jest zaznaczony, to wszystko jedzie po cichu. Oczywiście istnieje możliwość sprawdzenia, co takiego poszło na porty. W tym celu należy kliknąć prawym klawiszem i wybrać właściwą pozycję:

em8085-102.png

W reakcji zostają wyświetlone wszystkie dokonane dotychczas operacje na portach, przykładowo:

em8085-103.png

gdzie jest podany adres portu i co latało na styku do portu. Literka „O” sygnalizuje operację wyjścia, literka „I” dotyczy operacji wejścia. Dalej po znaku ‘:’ jest transmitowana wartość w zapisie szesnastkowym. W przypadku, gdy dane są w zakresie znaków pisarskich (ISO-7), to w nawiasach kwadratowych jest pokazany znak. Istnieje możliwość zapisu tych danych do pliku.
Ulepszona wersja programu jest dostępna tutaj:

I8085emul_2023_11_05.7z

Postautor: **tapy** » sobota 06 kwie 2024, 18:24

Na amerykańskim forum "Vintage Computer Federation" odnalazłem dyskusję o nieudokumentowanych instrukcjach 8085 i domniemanych przyczynach nieujawniania ich przez Intela. Prawdopodobnie instrukcje zostały w 8085 zaimplementowane przez inżynierów w celu ułatwienia budowy języków wyższego rzędu (do czego się świetnie nadają - nadal uważam, że są lepszym pomysłem niż zastosowane przez Ziloga rejestry indeksowe), ale były one w konflikcie do nowo powstającego 8086, który nie posiadał podobnych instrukcji co powodowałoby problemy z automatycznym przenoszeniem kodu 8085 do 8086. Po premierze 8086 w powszechnym użyciu była translacja 8080->8086, by zapewnić sobie z marszu bibliotekę oprogramowania na nową architekturę. W załączniku inny, niż dokumentacja Tundra, który opisuje te nowe i zarazem tajne

instrukcje.

Postautor: **gaweł** » środa 22 maja 2024, 23:36

Wskaźnik przepełnienia
w operacjach dodawania

Kwestia wskaźnika nadmiaru w operacjach w kodzie U2 okazała się troszkę złożona. Postanowiłem sprawdzić wynalezioną w necie formułę i w tym celu napisałem drobny program w C na PC-ta. Ponieważ program jest „jednorazowego użytku” nie dbałem o zbytnią finezję.

Kod: Zaznacz cały

#include <stdio.h>
#include <stdlib.h>

static FILE * OutFile ;  

static unsigned char Conv ( unsigned short Arg )
{
  signed short ArgSig ;
  char Str [ 10 ] ;
  ArgSig = Arg & 0xFF ;
  if ( Arg & 0x80 )
  {
     ArgSig |= 0xFF00 ;
  } /* if */ ;
  if ( Arg & 0x80 )
    Str [ 0 ] = '1' ;
  else
    Str [ 0 ] = '0' ;
  if ( Arg & 0x40 )
    Str [ 1 ] = '1' ;
  else
    Str [ 1 ] = '0' ;
  if ( Arg & 0x20 )
    Str [ 2 ] = '1' ;
  else
    Str [ 2 ] = '0' ;
  if ( Arg & 0x10 )
    Str [ 3 ] = '1' ;
  else
    Str [ 3 ] = '0' ;
  if ( Arg & 0x08 )
    Str [ 4 ] = '1' ;
  else
    Str [ 4 ] = '0' ;
  if ( Arg & 0x04 )
    Str [ 5 ] = '1' ;
  else
    Str [ 5 ] = '0' ;
  if ( Arg & 0x02 )
    Str [ 6 ] = '1' ;
  else
    Str [ 6 ] = '0' ;
  if ( Arg & 0x01 )
    Str [ 7 ] = '1' ;
  else
    Str [ 7 ] = '0' ;
  Str [ 8 ] = 0 ;
  fprintf ( OutFile , "%d [%s]" , ArgSig , Str ) ;
}



static unsigned char not ( unsigned char Arg )
{
 if ( Arg )
   return ( 0 ) ;
else
  return ( 1 ) ;
}

int main ( int argc , char * argv [ ] )
{
  unsigned short Arg1 ;
  unsigned short Arg2 ;
  unsigned short Result ;
  unsigned char Arg1Flag ;
  unsigned char Arg2Flag ;
  unsigned char ResultFlag ;
  unsigned char VFlag ;
  signed char Arg1Ch [ 2 ];
  signed char Arg2Ch [ 2 ] ;
  signed char ResultCh [ 2 ] ;
  signed char VCh [ 2 ] ;
  OutFile = fopen ( "vflag.txt" , "w" ) ;
  fprintf ( OutFile , "* * * Sprawdzenie formuly na wskaznik przepelnienia w operacjach dodawania * * *\n\n" ) ;
  Arg1Ch [ 1 ] = 0 ;
  Arg2Ch [ 1 ] = 0 ;
  ResultCh [ 1 ] = 0 ;
  VCh [ 1 ] = 0 ;
  for ( Arg1 = 0 ; Arg1 <= 0xFF ; Arg1++ )
  {
    for ( Arg2 = 0 ; Arg2 <= 0xFF ; Arg2++ )
     {
       Result = Arg1 + Arg2 ;
      Arg1Ch [ 0 ] = '0' ;
      Arg2Ch [ 0 ] = '0' ;
      ResultCh [ 0 ] = '0' ;
      VCh [ 0 ] = '0' ;
      Arg1Flag = 0 ;
      if ( Arg1 & 0x80 )
      {
        Arg1Flag = 1 ;
        Arg1Ch [ 0 ] = '1' ;
      } ;
      Arg2Flag = 0 ;
      if ( Arg2 & 0x80 )
      {
        Arg2Flag = 1 ;
        Arg2Ch [ 0 ] = '1' ;
      } ;
      ResultFlag = 0 ;
      if ( Result & 0x80 )
      {
        ResultFlag = 1 ;
        ResultCh [ 0 ] = '1' ;
      } ;
      VFlag = ( Arg1Flag & Arg2Flag & not ( ResultFlag ) ) |
              ( not ( Arg1Flag ) & not ( Arg2Flag ) & ResultFlag ) ;
      if ( VFlag )
      {
        VCh [ 0 ] = '1' ;
        Conv ( Arg1 ) ;
        fprintf ( OutFile , " + " ) ;
        Conv ( Arg2 ) ;
        fprintf ( OutFile , " = " ) ;
        Conv ( Result ) ;
        fprintf ( OutFile , "  A1 Sign = %s  A2 Sign = %s  R Sign = %s   V = %s \n" , Arg1Ch , Arg2Ch , ResultCh , VCh ) ;
      } ;
    } /* for */ ;
  } /* for */ ;
  fclose ( OutFile ) ;
  return 0 ;
}

Początkowo robiłem wydruk każdej operacji, ale wyszło tego takie mnóstwo, że postanowiłem drukować do pliku jedynie te przypadki, które generują nadmiar w operacjach dodawania.
Pomimo tego, wyszło również całkiem sporo (fragment):

Kod: Zaznacz cały

* * * Sprawdzenie formuly na wskaznik przepelnienia w operacjach dodawania * * *

1 [00000001] + 127 [01111111] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
2 [00000010] + 126 [01111110] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
2 [00000010] + 127 [01111111] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
3 [00000011] + 125 [01111101] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
3 [00000011] + 126 [01111110] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
3 [00000011] + 127 [01111111] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
4 [00000100] + 124 [01111100] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
4 [00000100] + 125 [01111101] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
4 [00000100] + 126 [01111110] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
4 [00000100] + 127 [01111111] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
5 [00000101] + 123 [01111011] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
5 [00000101] + 124 [01111100] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
5 [00000101] + 125 [01111101] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
5 [00000101] + 126 [01111110] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
5 [00000101] + 127 [01111111] = -124 [10000100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
6 [00000110] + 122 [01111010] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
6 [00000110] + 123 [01111011] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
6 [00000110] + 124 [01111100] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
6 [00000110] + 125 [01111101] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
6 [00000110] + 126 [01111110] = -124 [10000100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
6 [00000110] + 127 [01111111] = -123 [10000101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
7 [00000111] + 121 [01111001] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
7 [00000111] + 122 [01111010] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
7 [00000111] + 123 [01111011] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
7 [00000111] + 124 [01111100] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
7 [00000111] + 125 [01111101] = -124 [10000100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
7 [00000111] + 126 [01111110] = -123 [10000101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
7 [00000111] + 127 [01111111] = -122 [10000110]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
8 [00001000] + 120 [01111000] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
8 [00001000] + 121 [01111001] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
8 [00001000] + 122 [01111010] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
8 [00001000] + 123 [01111011] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
8 [00001000] + 124 [01111100] = -124 [10000100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
8 [00001000] + 125 [01111101] = -123 [10000101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
8 [00001000] + 126 [01111110] = -122 [10000110]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
8 [00001000] + 127 [01111111] = -121 [10000111]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
9 [00001001] + 119 [01110111] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
9 [00001001] + 120 [01111000] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
9 [00001001] + 121 [01111001] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
9 [00001001] + 122 [01111010] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
9 [00001001] + 123 [01111011] = -124 [10000100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
9 [00001001] + 124 [01111100] = -123 [10000101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
9 [00001001] + 125 [01111101] = -122 [10000110]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
9 [00001001] + 126 [01111110] = -121 [10000111]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
9 [00001001] + 127 [01111111] = -120 [10001000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
10 [00001010] + 118 [01110110] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
10 [00001010] + 119 [01110111] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
10 [00001010] + 120 [01111000] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
10 [00001010] + 121 [01111001] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
10 [00001010] + 122 [01111010] = -124 [10000100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
10 [00001010] + 123 [01111011] = -123 [10000101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
10 [00001010] + 124 [01111100] = -122 [10000110]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
10 [00001010] + 125 [01111101] = -121 [10000111]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
10 [00001010] + 126 [01111110] = -120 [10001000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
10 [00001010] + 127 [01111111] = -119 [10001001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
11 [00001011] + 117 [01110101] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
11 [00001011] + 118 [01110110] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
11 [00001011] + 119 [01110111] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
11 [00001011] + 120 [01111000] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
11 [00001011] + 121 [01111001] = -124 [10000100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
11 [00001011] + 122 [01111010] = -123 [10000101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
11 [00001011] + 123 [01111011] = -122 [10000110]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
11 [00001011] + 124 [01111100] = -121 [10000111]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
11 [00001011] + 125 [01111101] = -120 [10001000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
11 [00001011] + 126 [01111110] = -119 [10001001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
11 [00001011] + 127 [01111111] = -118 [10001010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 116 [01110100] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 117 [01110101] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 118 [01110110] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 119 [01110111] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 120 [01111000] = -124 [10000100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 121 [01111001] = -123 [10000101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 122 [01111010] = -122 [10000110]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 123 [01111011] = -121 [10000111]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 124 [01111100] = -120 [10001000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 125 [01111101] = -119 [10001001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 126 [01111110] = -118 [10001010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
12 [00001100] + 127 [01111111] = -117 [10001011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 115 [01110011] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 116 [01110100] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 117 [01110101] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 118 [01110110] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 119 [01110111] = -124 [10000100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 120 [01111000] = -123 [10000101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 121 [01111001] = -122 [10000110]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 122 [01111010] = -121 [10000111]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 123 [01111011] = -120 [10001000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 124 [01111100] = -119 [10001001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 125 [01111101] = -118 [10001010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 126 [01111110] = -117 [10001011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
13 [00001101] + 127 [01111111] = -116 [10001100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 114 [01110010] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 115 [01110011] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 116 [01110100] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 117 [01110101] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 118 [01110110] = -124 [10000100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 119 [01110111] = -123 [10000101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 120 [01111000] = -122 [10000110]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 121 [01111001] = -121 [10000111]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 122 [01111010] = -120 [10001000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 123 [01111011] = -119 [10001001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 124 [01111100] = -118 [10001010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 125 [01111101] = -117 [10001011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 126 [01111110] = -116 [10001100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
14 [00001110] + 127 [01111111] = -115 [10001101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 113 [01110001] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 114 [01110010] = -127 [10000001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 115 [01110011] = -126 [10000010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 116 [01110100] = -125 [10000011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 117 [01110101] = -124 [10000100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 118 [01110110] = -123 [10000101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 119 [01110111] = -122 [10000110]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 120 [01111000] = -121 [10000111]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 121 [01111001] = -120 [10001000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 122 [01111010] = -119 [10001001]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 123 [01111011] = -118 [10001010]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 124 [01111100] = -117 [10001011]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 125 [01111101] = -116 [10001100]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 126 [01111110] = -115 [10001101]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
15 [00001111] + 127 [01111111] = -114 [10001110]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1 
16 [00010000] + 112 [01110000] = -128 [10000000]  A1 Sign = 0  A2 Sign = 0  R Sign = 1   V = 1

Jak popatrzeć na to wszystko, to czasami wyniki rzeczywiście są dziwaczne.

Formuła na wskaźnik V to:

vflagform.png

Sprawdziłem odpowiednio dużo przypadków wydrukowanych przez program. Sprawdziło się. Przykładowo: 7 dec + 127 dec = 134 dec, ale 134 dec = 86 hex.

8085Vfl_01.png

Dla 8-bitów w U2 to będzie -122 dec → wynik rachunków jest poprawny (poprawny w sensie operacji na bitach, ale zostaje ustawiona flaga nadmiaru V, więc sumarycznie jest do ….).

8085Vfl_02.png

Niestety dla operacji odejmowania się nie sprawdza, ale mam już podejrzenia, jak powinna ona wyglądać.

Postautor: **gaweł** » czwartek 23 maja 2024, 09:23

Wskaźnik V

m6800-0.png

Znalazłem potwierdzenie swoich eksperymentów i przypuszczeń. Stworzony program posiłkował się dokładnie taką formułą obliczania wskaźnika, jaka jest podana w dokumentacji do procka MC6800.
W przypadku dodawania:

m6800-1.png

W przypadku odejmowania:

m6800-2.png

No to już wszystko wiadomo.

microgeek.eu

I8085 - emulator procesora

I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Re: I8085 - emulator procesora

Kto jest online