Intel 8080 kit
Re: Intel 8080 kit
Re: Intel 8080 kit
tapy pisze:Bardziej miałem na myśli pełne 16-bit, więc osobiście poszedłbym w stronę V50, bo jeszcze jest dostępny (V40 też niczego sobie, to taki V20 na sterydach).
V50 to już mikrokontroler z peryferiami w środku. Odpowiednikiem 8086 jest V30. Mam nawet płytę z PC/XT z tym procesorem. Fajnie byłoby znowu się pobawić. Niestety padła mi klawiatura XT, więc jest mały kłopot.
X is work. Y is play. Z is keep your mouth shut."A. Einstein
Re: Intel 8080 kit
Obsługa układu 8255
Wspomniany układ jest bardzo popularnym programowalnym portem równoległym. Zawiera w sobie dwa porty PORTA oraz PORTB jako porty 8-bitowe, które można skonfigurować do pracy jako wejście albo jako wyjście (oba w sposób niezależny). Do tego dochodzi kolejny port (PORTC), który może być podzielony na dwa 4-bitowe, z których każda połówka ma możliwość niezależnego skonfigurowania kierunku pracy. Dodatkowo istnieje możliwość manipulowania pojedynczymi bitami PORTC. Nad tym wszystkim „panuje” rejestr sterujący: zapisy do tego rejestru definiują tryb i kierunek pracy jak również odpowiednie zapisy manipulują pojedynczymi bitami (w zakresie ustawienia na stan jedynki jak i zera). Te dwa podstawowe rodzaje poleceń są rozróżniane jednym bitem w wysyłanych do portu kontrolnego danych: najbardziej znaczący bit = 1 to zapis dotyczący trybu i kierunku pracy wszystkich portów. W sytuacji gdy ten bit = 0, zapis dotyczy ustawienia/zerowania wskazanego bitu PORTC. Ta cecha została wykorzystana w obsłudze alfanumerycznego wyświetlacza LCD jak i do obsługi klawiatury. PORTA i połowa PORTC obsługuje moduł LCD, PORTB i druga połowa PORTC obsługuje klawiaturę matrycową. W przypadku modułu LCD, kierunek pracy PORTA jest konfigurowany w zależności od potrzeb (zapis danych oraz poleceń do LCD to wyjście, odczyt statusu LCD to wejście). Dolna połowa PORTC obsługuje linie sterujące LCD (RS, RW i E). Do obsługi klawiatury, PORTB jest wczytującym stan kolumn klawiatury (zawsze wejściem) oraz druga połowa PORTC wymusza stan na liniach rzędów klawiatury (zawsze wyjściem).
Konfiguracja portów to zapis mvi a , 080h + P8255A_out… , gdzie zawsze jest ustawiony najbardziej znaczący bit (80h) i definiuje kierunki pracy portów w zależności od potrzeb. Port 8255 jest identyfikowany w systemie przez adresy w przestrzeni adresowej IO (LCDPort i KBDPort mają ten sam adres, a istnienie dwóch identyfikatorów zwiększa jedynie czytelność programu źródłowego).
Kod: Zaznacz cały
LCDPort .equ 0A0h
KBDPort .equ 0A0h
( . . . )
P8255PortA .equ 0
P8255PortB .equ 1
P8255PortC .equ 2
P8255Control .equ 3Kod: Zaznacz cały
P8255A_out .equ 0000000b
P8255A_inp .equ 0010000b
P8255B_out .equ 0000000b
P8255B_inp .equ 0000010b
P8255CL_out .equ 0000000b
P8255CH_out .equ 0000000b
P8255CL_inp .equ 0000001b
P8255CH_inp .equ 0001000b
( . . . )
SetLCDOutputDataBus ;procedure SetLCDOutputDataBus ;
;begin (* SetLCDOutputDataBus *)
; LCDPort.PortA := <output> ;
mvi a , 080h + P8255A_out + P8255B_inp + P8255CL_out + P8255CH_out
out LCDPort + P8255Control ;
ret ;end (* SetLCDOutputDataBus *) ;
;*******************************************
SetLCDInputDataBus ;procedure SetLCDInputDataBus ;
;begin (* SetLCDInputDataBus *)
; LCDPort.PortA := <input> ;
mvi a , 080h + P8255A_inp + P8255B_inp + P8255CL_out + P8255CH_out
out LCDPort + P8255Control ;
ret ;end (* SetLCDInputDataBus *) ;Linie sterujące modułem LCD (RS, RW i E) są obsługiwane przez połowę PORTC (jako wyjście) jako niezależne sterowaniu odpowiednimi liniami.
Kod: Zaznacz cały
SetLCDEBit .equ 00000101b
ClrLCDEBit .equ 00000100b
SetLCDRWBit .equ 00000011b
ClrLCDRWBit .equ 00000010b
SetLCDRSBit .equ 00000001b
ClrLCDRSBit .equ 00000000b
( . . . )
EPulse ;procedure EPulse ;
;begin (* EPulse *)
mvi a , SetLCDEBit ; LCDPort.PortC[E]:= 1 ;
out LCDPort + P8255Control ;
call LCDDelay ; LCDDelay ;
mvi a , ClrLCDEBit ; LCDPort.PortC[E]:= 0 ;
out LCDPort + P8255Control ;
ret ;end (* EPulse *) ;
;*******************************************
LCDOutC ;procedure LCDOutC ( Data[A] : byte ) ;
;begin (* LCDOutC *)
push psw ;
call SetLCDOutputDataBus ; SetLCDOutputDataBus ;
mvi a , ClrLCDRSBit ; LCDPort.PortC[RS]:= 0 ;
out LCDPort + P8255Control ;
mvi a , ClrLCDRWBit ; LCDPort.PortC[RW]:= 0 ;
out LCDPort + P8255Control ;
pop psw ;
out LCDPort + P8255PortA ; LCDPort.PortA := Data ;
call EPulse ; EPulse ;
ret ;end (* LCDOutC *) ;Jeżeli chodzi o klawiaturę, to cyklicznie w przerwaniach od czasu poszukiwany jest naciśnięty klawisz. Po wymuszeniu stanu na liniach rzędów wczytywany jest stan kolumn.
Kod: Zaznacz cały
HardvSetRowKbd ;procedure HardvSetRowKbd ( Row[A] : byte ) ;
;begin (* HardvSetRowKbd *)
; case KbdModInstance.RowCounter of
lda KbdModInstance + KbdModInstanceT.RowCounter
cpi 0 ; 0 :
jnz HvdSeRSrv_1 ;
mvi a , 00001000b ; KBDPort.PortC[4] := 0 ;
out KBDPort + P8255Control ;
mvi a , 00001011b ; KBDPort.PortC[5] := 1 ;
out KBDPort + P8255Control ;
mvi a , 00001101b ; KBDPort.PortC[6] := 1 ;
out KBDPort + P8255Control ;
mvi a , 00001111b ; KBDPort.PortC[7] := 1 ;
out KBDPort + P8255Control ;
jmp HvdSeRSrv_0 ;
HvdSeRSrv_1 ;
cpi 1 ; 1 :
jnz HvdSeRSrv_2 ;
mvi a , 00001001b ; KBDPort.PortC[4] := 1 ;
out KBDPort + P8255Control ;
mvi a , 00001010b ; KBDPort.PortC[5] := 0 ;
out KBDPort + P8255Control ;
mvi a , 00001101b ; KBDPort.PortC[6] := 1 ;
out KBDPort + P8255Control ;
mvi a , 00001111b ; KBDPort.PortC[7] := 1 ;
out KBDPort + P8255Control ;
jmp HvdSeRSrv_0 ;
HvdSeRSrv_2 ;
cpi 2 ; 2 :
jnz HvdSeRSrv_3 ;
mvi a , 00001001b ; KBDPort.PortC[4] := 1 ;
out KBDPort + P8255Control ;
mvi a , 00001011b ; KBDPort.PortC[5] := 1 ;
out KBDPort + P8255Control ;
mvi a , 00001100b ; KBDPort.PortC[6] := 0 ;
out KBDPort + P8255Control ;
mvi a , 00001111b ; KBDPort.PortC[7] := 1 ;
out KBDPort + P8255Control ;
jmp HvdSeRSrv_0 ;
HvdSeRSrv_3 ;
cpi 3 ; 3 :
jnz HvdSeRSrv_4 ;
mvi a , 00001001b ; KBDPort.PortC[4] := 1 ;
out KBDPort + P8255Control ;
mvi a , 00001011b ; KBDPort.PortC[5] := 1 ;
out KBDPort + P8255Control ;
mvi a , 00001101b ; KBDPort.PortC[6] := 1 ;
out KBDPort + P8255Control ;
mvi a , 00001110b ; KBDPort.PortC[7] := 0 ;
out KBDPort + P8255Control ;
jmp HvdSeRSrv_0 ;
HvdSeRSrv_4 ; end (* case *) ;
HvdSeRSrv_0 ;
ret ;end (* HardvSetRowKbd *) ;
( . . . )
HardvInpKbd ;function HardvInpKbd : byte[A] ;
;begin (* HardvInpKbd *)
in KBDPort + P8255PortB ; HardvInpKbd := KBDPort.PortB ;
ret ;end (* HardvInpKbd *) ;Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: Intel 8080 kit
Obsługa układu 8250
8250 to układ obsługi transmisji szeregowej z wbudowanym wewnątrz generatorem sygnału taktującego transmisją. Zawiera wewnątrz również podzielnik by uzyskać oczekiwaną prędkość transmisji. W obecnym zastosowaniu układ obsługuje jedynie przesyłanie danych (operowanie liniami modemowymi nie jest aktywowane → wejściowe dla 8250 na schemacie są sprzętowo wysterowane do stanu aktywnego). Nie zaistnieje możliwość zgłoszenia przerwania w wyniku zmian tych linii modemowych (poza tym programowo konfiguruje się ten kontroler jakie generuje on generuje).
Przed rozpoczęciem transmisji należy go odpowiednio skonfigurować. Realizuje to funkcja UARTHardwareInit z jednym parametrem, gdzie do akumulatora należy wpisać podzielnik determinujący prędkość transmisji (dla 9600 bps wynosi on 12). Dodatkowo należy wyczyścić kolejki FIFO nadajnika oraz odbiornika.
Kod: Zaznacz cały
SerialSpeed9600 .equ 12
( . . . )
mvi a , SerialSpeed9600 ; UARTHardwareInit ( SerialSpeed9600 ) ;
call UARTHardwareInit ;
call ResetSerialFifo ; ResetSerialFifo ;
( . . . )
ResetSerialFifo ;procedure ResetSerialFifo ;
;begin (* ResetSerialFifo *)
mvi a , 0 ; UARTReciev . CycFr := 0 ;
sta UARTReciev + RXDRecT.CycFr
sta UARTReciev + RXDRecT.CycTo
; UARTReciev . CycTo := 0 ;
sta UARTTransm + TXDRecT.CycFr
; UARTTransm . CycFr := 0 ;
sta UARTTransm + TXDRecT.CycTo
; UARTTransm . CycTo := 0 ;
mvi a , IdleState ; UARTTransm . State := IdleState ;
sta UARTTransm + TXDRecT.State
ret ;end (* ResetSerialFifo *) ;Zainicjowanie kontrolera 8250 do pracy wymaga wpisania podzielnika prędkości, trybu transmisji, ustawienia wyjściowych linii modemowych oraz określenia jakie przerwania są zgłaszane do 8259. Układ jest 7-komórkowy w przestrzeni adresowej, toteż poszczególne rejestry mają indywidualne adresy w obrębie 8250. Wpisanie podzielnika jest trochę „pokrętne”: w pierwszej kolejności należy wpisać do rejestru sterującego LineControlRegister (ten sam, który służy do określenia trybu transmisji) liczbę 80 hex (ma być ustawiony najbardziej znaczący bit). W kolejnym kroku wpisać do DataRegister (ten sam, do którego wysyła się i odbiera dane szeregowe) część młodszą podzielnika oraz do InterruptEnRegister (ten sam, w którym specyfikuje się generowane przerwania) część starszą (ogólnie podzielnik jest 16-bitowy a do uzyskania prędkości 600 .. 115200 bps jest on jednobajtowy). Później konfiguruje się tryb transmisji, tu używany jest N81 → 8 bitów, bez parzystości i jednym bitem stopu (słowo sterujące w żadnej kombinacji nie zawiera ustawionego najwyższego bitu, więc 8250 nie rozpozna tego zapisu jako późniejszy wpis podzielnika). Przed włączeniem przerwań warto wygarnąć z rejestrów śmieci (aktywacja może spowodować natychmiastowe wygenerowanie przerwania). Na koniec wpis do rejestru InterruptEnRegister określa jakie przerwania generuje 8250 (tu są od nadajnika oraz odbiornika).
Kod: Zaznacz cały
DataRegister .equ 0
InterruptEnRegister .equ 1
InterruptIdRegister .equ 2
LineControlRegister .equ 3
ModemControlRegister .equ 4
LineStatusRegister .equ 5
ModemStatusRegister .equ 6
( . . . )
N81Mode .equ 03h
( . . . )
UARTHardwareInit ;procedure UARTHardwareInit
( SerialSpeed[a] : byte ) ;
;begin (* UARTHardwareInit *)
push psw ;
; (* ustawienie w UART rozszerzenia
; adresowego do zaprogramowania predkosci *)
mvi a , 80h ; Serial8250+LineControlRegister := 80h ;
out Serial8250 + LineControlRegister
; (* mlodszy bajt podzielnika predkosci *)
pop psw ; Serial8250+DataRegister := SerialSpeed ;
out Serial8250 + DataRegister ;
; (* starszy bajt podzielnika predkosci *)
mvi a , 0 ; Serial8250+InterruptEnRegister := 0 ;
out Serial8250 + InterruptEnRegister
; (* zaprogramowania trybu N81Mode *)
mvi a , N81Mode
; Serial8250+LineControlRegister := N81Mode ;
out Serial8250 + LineControlRegister
; (* zaprogramowania stanu linii modemowych→
; wszystkie do stanu aktywnego *)
mvi a , 0bh ; Serial8250+ModemControlRegister := 0BH ;
out Serial8250 + ModemControlRegister
; (* wygarniecie smieci z roznych rejestrow *)
; ? := Serial8250 + LineStatusRegister ;
in Serial8250 + LineStatusRegister
; ? := Serial8250 + ModemControlRegister ;
in Serial8250 + ModemControlRegister
; ? := Serial8250 + DataRegister ;
in Serial8250 + DataRegister
; ? := Serial8250 + InterruptIdRegister ;
in Serial8250 + InterruptIdRegister
; (* zezwolenie dla UART na przerwania od:
; nadajnik + odbiornik *)
mvi a , 03h ; Serial8250 + InterruptEnRegister ; := 03H ;
out Serial8250 + InterruptEnRegister
ret ;end (* UARTHardwareInit *) ;Układ 8250 zgłasza jeden sygnał przerwania (do 8259), jednak by rozpoznać przyczynę przerwania należy wczytać rejestr InterruptIdRegister, gdzie na bitach jest określona przyczyna przerwania. Obsługa przerwania to:
Kod: Zaznacz cały
SerialInterruptService ;ISR SerialInterruptService ;
; var
; IIR : byte ;
; Port : byte ;
;begin (* SerialInterruptService *)
push psw ;
push b ;
push d ;
push h ;
SerIntSrv_0 ; repeat
; IIR := Serial8250+InterruptIdRegister & 07h ;
in Serial8250 + InterruptIdRegister
ani 07h ; if ( IIR & 0x01 ) = 0 then
cpi 1 ;
jz SerIntSrv_5 ; begin
rrc ; IIR := IIR >> 1 ;
ani 03h ;
; case IIR of
cpi 0 ; 0 : (* 0 0 - Modem status *)
jnz SerIntSrv_1 ;
; Port := Serial8250 + ModemStatusRegister ;
in Serial8250 + ModemStatusRegister
jmp SerIntSrv_0 ;
SerIntSrv_1 ; 1 : (* 0 1 - transmitter *)
cpi 1 ;
jnz SerIntSrv_2 ;
lda UARTTransm + TXDRecT.CycFr
; if UARTTransm.CycFr = UARTTransm.CycTo then
lxi h , UARTTransm + TXDRecT.CycTo
cmp m ;
jnz SerIntSrv_11 ;
mvi a , IdleState ; UARTTransm.State := IdleState ;
sta UARTTransm + TXDRecT.State
jmp SerIntSrv_0 ;
SerIntSrv_11 ; else
; begin
lda UARTTransm + TXDRecT.CycFr
; Serial8250+DataRegister:= UARTTransm.Buffer[UARTTransm.CycFr] ;
mov c , a ;
mvi b , 0 ;
lxi h , UARTTransm + TXDRecT.Buffer
dad b ;
mov a , m ;
out Serial8250 + DataRegister
; UARTTransm.CycFr:= UARTTransm.CycFr+1 ;
lxi h , UARTTransm + TXDRecT.CycFr
mov a , m ;
inr a ;
ani TXDBuffSize - 1; UARTTransm.CycFr:=UARTTransm.CycFr mod TXDBuffSize ;
mov m , a ;
jmp SerIntSrv_0 ; end ;
SerIntSrv_2 ;
cpi 2 ; 2 : (* 1 0 - reciever *)
jnz SerIntSrv_3 ; begin
lda UARTReciev + RXDRecT.CycTo
; UARTReciev.Buffer[UARTReciev.CycTo]:= Serial8250+DataRegister ;
mov c , a ;
mvi b , 0 ;
lxi h , UARTReciev + RXDRecT.Buffer
dad b ;
in Serial8250 + DataRegister
mov m , a ;
; UARTReciev.CycTo:=UARTReciev.CycTo+1 ;
lxi h , UARTReciev + RXDRecT.CycTo
mov a , m ;
inr a ;
ani RXDBuffSize - 1; UARTReciev.CycTo:=UARTReciev.CycTo mod RXDBuffSize ;
mov m , a ;
jmp SerIntSrv_0 ; end ;
SerIntSrv_3 ;
cpi 3 ; 3 : (* 1 1 - error *)
jnz SerIntSrv_0 ;
; Port := Serial8250 + LineStatusRegister ;
in Serial8250 + LineStatusRegister
jmp SerIntSrv_0 ; end (* case *) ;
; end
; else
; exit ;
; until false ;
SerIntSrv_5 ;
mvi a , 20h ; end of irq
out Controller8259 ;
pop h ;
pop d ;
pop b ;
pop psw ;
ei ;
ret ;Kontroler transmisji szeregowej opiera się o kolejki FIFO w zakresie nadawania oraz odbierania danych. Ich konstrukcje są następujące:
Kod: Zaznacz cały
IdleState .equ 0
BusyState .equ 1
;-------------------------------------------
TXDBuffSize .equ 128
RXDBuffSize .equ 16
;-------------------------------------------
TXDRecT .struct ; TXDRecT = record
CycFr .byte ; CycFr : byte ;
CycTo .byte ; CycTo : byte ;
State .byte ; State : byte ;
Buffer .byte TXDBuffSize ; Buffer : array [ 0 .. TXDBuffSize - 1 ] of byte ;
.endstruct ; end (* record *) ;
;-------------------------------------------
RXDRecT .struct ; RXDRecT = record
CycFr .byte ; CycFr : byte ;
CycTo .byte ; CycTo : byte ;
Buffer .byte RXDBuffSize ; Buffer : array [ 0 .. RXDBuffSize - 1 ] of byte ;
.endstruct ; end (* record *) ;
;-------------------------------------------
( . . . )
.org RAMSpace
UARTTransm .TXDRecT
UARTReciev .RXDRecTOdbiór danych z 8250 wchodzi do UARTRecv bezwarunkowo (najwyżej dane się nadpiszą), realizacja znajduje się w powyższej funkcji obsługi przerwania. Z tą kolejką FIFO związane są dwie funkcja: sprawdzenia, czy w FIFO są dane do odczytania (SerialDataPresent) oraz odczytanie kolejnego bajtu (GetSerial).
Kod: Zaznacz cały
SerialDataPresent ;function SerialDataPresent : boolean ;
;begin (* SerialDataPresent *)
; if UARTTransm.CycFr = UARTTransm.CycTo then
lxi h , UARTTransm + TXDRecT.CycFr
mov a , m ;
lxi h , UARTTransm + TXDRecT.CycTo
cmp m ;
jnz SerDatPre_0 ;
mvi a , 0 ; SerialDataPresent := false
ret ; esle
SerDatPre_0 ;
mvi a , 1 ; SerialDataPresent := true ;
ret ;end (* SerialDataPresent *) ;
;*******************************
GetSerial ;function GetSerial : byte[a] ;
;var
; Ch[e] : byte ;
;begin (* GetSerial *)
; Ch:=UARTTransm.Buffer[UARTTransm.CycFr] ;
lda UARTTransm + TXDRecT.CycFr
mov c , a ;
mvi b , 0 ;
lxi h , UARTTransm + TXDRecT.Buffer
dad b ;
mov e , m ;
; UARTTransm.CycFr:=(UARTTransm.CycFr+1) mod RXDBuffSize ;
lxi h , UARTTransm + TXDRecT.CycFr
mov a , m ;
inr a ;
ani RXDBuffSize - 1;
mov m , a ;
mov a , e ; GetSerial := Ch ;
ret ;end (* GetSerial *) ;Nadawanie danych do 8250 jest realizowane przez SendSerial. Jeżeli UART nie pracuje, to pierwszy znak trafia bezpośrednio do 8250 (z odnotowaniem, że jest on już zajęty), kolejne dane trafiają do kolejki FIFO. Zawsze jest sprawdzane, czy jest miejsce w FIFO na zapis nowych danych. Jeżeli jest, następuje zapis do FIFO. W przeciwnym wypadku realizowane jest oczekiwanie do chwili, gdy w buforze pojawi się wolne miejsce (w wyniku wygarniania danych z tej kolejki przez obsługę przerwania).
Kod: Zaznacz cały
SendSerial ;procedure SendSerial ( SerialCh : byte ) ;
;var
; NextInx : byte ;
;begin (* SendSerial *)
di ; DisableInt ;
push psw ;
; if UARTTransm . State = IdleState then
lxi h , UARTTransm + TXDRecT.State
mov a , m ;
cpi IdleState ;
jnz SeSer_1 ; begin
mvi a , BusyState ; UARTTransm . State := BusyState ;
mov m , a ;
pop psw ;
; Serial8250 + DataRegister := SerialCh ;
out Serial8250 + DataRegister
ei ; EnableInt ;
ret ; exit ;
; end ;
SeSer_1 ; repeat
; NextInx:=(UARTTransm.CycTo+1) mod TXDBuffSize ;
lda UARTTransm + TXDRecT.CycTo
inr a ;
ani TXDBuffSize - 1 ;
; if NextInx <> UARTTrans . CycFr then
lxi h , UARTTransm + TXDRecT.CycFr
cmp m ;
jz SeSer_2 ; begin
; UARTTrans.Buffer[UARTTrans.CycTo]:=SerialCh ;
lda UARTTransm + TXDRecT.CycTo
mov c , a ;
mvi b , 0 ;
lxi h , UARTTransm + TXDRecT.Buffer
dad b ;
pop psw ;
mov m , a ;
; UARTTransm.CycTo:=(UARTTransm.CycTo+1) mod TXDBuffSize ;
lxi h , UARTTransm + TXDRecT.CycTo
mov a , m ;
inr a ;
ani TXDBuffSize - 1 ;
mov m , a ;
ei ; EnableInt ;
ret ; exit ;
SeSer_2 ; end ;
ei ; EnableInt ;
nop ; Nop ;
nop ; Nop ;
nop ; Nop ;
di ; EisableInt ;
jmp SeSer_1 ; until false ;
;end (* SendSerial *) ;
( . . . )
SendSerialString ;procedure SendSerialString ( String[hl] : array of byte ) ;
;var
; Data : byte ;
; Inx : byte ;
;begin (* SendSerialString *)
; Inx := 0 ;
SeSerStr_0 ; repeat
mov a , m ; Data = String [ Inx ] ;
inx h ; Inx := Inx + 1 ;
cpi 0 ; if Data = 0 then
jnz SeSerStr_1 ;
ret ; exit ;
SeSerStr_1 ;
push h ;
call SendSerial ; SendSerial ( Data ) ;
pop h ;
jmp SeSerStr_0 ; until false ;
;end (* SendSerialString *) ;Prezentacja działania obsługi układu 8250 to:
Kod: Zaznacz cały
SerialHello .defb "Zestaw edukacyjny z procesorem Intel 8080", 0Dh, 0Ah, 0
( . . . )
lxi h , SerialHello ; SendSerialString ( SerialHello ) ;
call SendSerialString ;I zadziałało:
Na obecnym etapie wiadomo, że cały zestaw jest technicznie sprawny (test pamięci RAM również przechodzi z tym samym algorytmem co w poprzedniej iteracji). Teraz zostało trochę potrudzić się nad „systemem operacyjnym”.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: Intel 8080 kit
Uruchomienie ładowanego programu
Jedną z przewidywanych funkcji tego zestawu edukacyjnego jest przećwiczenie ładowanego z zewnątrz programu. By maksymalnie uprościć tą funkcjonalność, program do uruchomienia jest ładowany z zewnątrz (via UART 8250, który jest skonfigurowany na tryb pracy 9600 N81). Są pewne wymagania stawiane ładowanemu programu. Ponieważ kit 8080 ma EPROM 27C128 (16 kB) lokowany jest od adresu 0, to ładowany program ładuje się do pamięci RAM. Początkowa koncepcja podziału całej przestrzeni adresowej 0..16 kB to pamięć EPROM, która wykorzystuje pamięć RAM z przedziału 16 kB..32 kB jako pamięć operacyjną dla EPROM (w tym również stos). Pozostała przestrzeń 32 kB ..64 kB jest przewidziana dla ładowanych programów. Oznacza to, że ładowany program musi być linkowany na ten obszar. Pierwsza (obecna) bardzo uproszczona wersja zakłada, że program jest ładowany do obszaru od adresu 32 kB jak również punkt wejścia do programu znajduje się również w tym miejsce (odpowiednik operacji Reset to start programu od adresu 8000 hex). Również do rozważenia jest możliwość ładowania programu do innego obszaru (ale z zakresu adresowego 32 kB..64 kB, jest to proste do wyczajenia, gdyż w pliku intel-hex jest określona adresacja kodu). Z tym jest związana możliwość uruchomienia programu od innego adresu (do polecenia F5/GO można dorobić możliwość podania adresu).
Pierwszy testowy program jest banalnie prosty, jak na poniższym listingu
Kod: Zaznacz cały
Improved compiler for INTEL 8080/8085 processor, version 2.4 licence: CC BY 3.0
L.NO MEMO CODE SRC
( . . . )
22. .i8080
23. ;
24. 8000 ResetEntry .equ 08000h ;
25. FFFE Stack_top .equ 0fffeh ;
26. 00A8 LEDRegister .equ 0A8h ;
27. ;*******************************************
28. .org ResetEntry ;
29. 8000 C33580 jmp Main ;
30. 8003 03 DemoTable .defb 00000011b ;
31. 8004 06 .defb 00000110b ;
32. 8005 0C .defb 00001100b ;
33. 8006 18 .defb 00011000b ;
34. 8007 30 .defb 00110000b ;
35. 8008 60 .defb 01100000b ;
36. 8009 80 .defb 10000000b ;
37. 800A 60 .defb 01100000b ;
38. 800B 30 .defb 00110000b ;
39. 800C 18 .defb 00011000b ;
40. 800D 0C .defb 00001100b ;
41. 800E 06 .defb 00000110b ;
42. 800F 03 .defb 00000011b ;
43. 8010 00 .defb 00000000b ;
44. ;*******************************************
45. 8011 LEDDemo ;procedure LEDDemo ;
46. ;var
47. ; TmpPtr : word[hl] ;
48. ; TmpCh : byte ;
49. ;begin (* LEDDemo *)
50. 8011 210380 lxi h , DemoTable ; TmpPtr := DemoTable ;
51. 8014 Ledde_3 ; repeat
52. 8014 7E mov a , m ; TmpCh := TmpPtr ^ ;
53. 8015 FE00 cpi 0 ; if TmpCh <> 0 then
54. 8017 CA2580 jz Ledde_1 ; begin
55. 801A D3A8 out LEDRegister ; LEDRegister := TmpCh ;
56. 801C E5 push h ;
57. 801D CD2B80 call DemoDelay ; DemoDelay ;
58. 8020 E1 pop h ;
59. 8021 23 inx h ; TmpPtr := TmpPtr + 1 ;
60. 8022 C31480 jmp Ledde_3 ; end
61. 8025 Ledde_1 ; else
62. 8025 210380 lxi h , DemoTable ; TmpPtr := DemoTable ;
63. 8028 C31480 jmp Ledde_3 ; until false ;
64. ;end (* LEDDemo *) ;
65. ;*******************************************
66. 802B DemoDelay ;procedure DemoDelay ;
67. ;begin (* DemoDelay *)
68. 802B 010030 lxi b , 03000h ;
69. 802E DeDel_0 ;
70. 802E 0B dcx b ;
71. 802F 78 mov a , b ;
72. 8030 B1 ora c ;
73. 8031 C22E80 jnz DeDel_0 ;
74. 8034 C9 ret ;end (* DemoDelay *) ;
75. ;*******************************************
76. 8035 Main ;begin (* main *)
77. 8035 Main_0 ;
78. 8035 CD1180 call LEDDemo ; LEDDemo ;
79. 8038 C33580 jmp Main_0 ; until false ;
80. ;end (* main *).
81. ;*******************************************
82. .end
Close file: D:\prace\i8080kit\i8080test.asm
Compilation :successful
Map information about constants and labels:
LEDRegister CONST=00A8 hex [0000000010101000 bin,168 dec]
ResetEntry CONST=8000 hex [1000000000000000 bin,32768 dec]
Stack_top CONST=FFFE hex [1111111111111110 bin,65534 dec]
DeDel_0 LABEL:802E hex
DemoDelay LABEL:802B hex
DemoTable LABEL:8003 hex
LEDDemo LABEL:8011 hex
Ledde_1 LABEL:8025 hex
Ledde_3 LABEL:8014 hex
Main LABEL:8035 hex
Main_0 LABEL:8035 hex
Code stored in file: D:\prace\i8080kit\i8080test.hexZ tego wydruku z kompilacji widać, że program jest przeznaczony do uruchomienia we właściwym obszarze dla kitu 8080 (ResetEntry .equ 08000h oraz jest .org ResetEntry). Wszystkie etykiety dla instrukcji skoków również są z tego obszaru. Zadaniem programu jest demko z dwoma diodami LED.
Kompilacja tego programu generuje plik z zawartością pamięci w formacie intel-hex.
Kod: Zaznacz cały
:10800000C3358003060C183060806030180C0603FE
:10801000002103807EFE00CA2580D3A8E5CD2B80F9
:10802000E123C31480210380C314800100300B7846
:0B803000B1C22E80C9CD1180C3358085
:00000001FFRealizacja w EPROM załadowania i uruchomienia programu to:
Kod: Zaznacz cały
SelectCommandExecute ;procedure SelectCommandExecute ( Ch[a] : byte ) ;
;begin (* SelectCommandExecute *)
; case Ch of
cpi F1Ch ; F1Ch :
jnz SelCmmEx_1 ;
call LoadProgramFromSerial ; LoadProgramFromSerial ;
call RewindCommandService ; RewindCommandService ;
call SelectCommand ; SelectCommand ;
ret ; exit ;
SelCmmEx_1 ; F2Ch :
( . . . )
cpi F5Ch ;
jnz SelCmmEx_5 ;
call ClrScrLCD ; ClrScrLCD ;
lxi h , ProgramRunning ; WriteTextLCD ( ProgramRunning ) ;
call WriteTextLCD ;
lxi h , 8000h ; call 8000h ;
call CallHLService ;
ret ; exit ;
( . . . )
ret ;end (* SelectCommandExecute *) ;Operacja ładowania kodu via UART zawiera elementarną kontrolę poprawności pliku intel-hex (nie bada jedynie poprawności sumy kontrolnej):
Kod: Zaznacz cały
LoadProgramFromSerial ;procedure LoadProgramFromSerial ;
;var
; Tmp[A] : byte ;
;begin (* LoadProgramFromSerial *)
mvi a , 0 ; SystemInstance.LoadedStatus:=false ;
sta SystemInstance + SystemInstanceT . LoadedStatus
call ClrScrLCD ; ClrScrLCD ;
lxi h , StartLoadingMsg ; WriteTextLCD(StartLoadingMsg) ;
call WriteTextLCD ;
LoProgFrSe_0 ; repeat
call GetHexFileLine ; if not GetHexFileLine then
cpi 1 ;
jz LoProgFrSe_1 ; begin
call NewLineLCD ; NewLineLCD ;
; WriteTextLCD(HexFileformatErrorMsg) ;
lxi h , HexFileformatErrorMsg
call WriteTextLCD ;
call AnyKey ; AnyKey ;
ret ; exit ;
LoProgFrSe_1 ; end ;
mvi a , 0 ; SystemInstance . HexLineIndex := 0 ;
sta SystemInstance + SystemInstanceT . HexLineIndex
call GetHexLineByte ; SystemInstance.BlockSize:=GetHexLineByte ;
sta SystemInstance + SystemInstanceT . BlockSize
call GetHexLineWord ; SystemInstance.LoadAddress:=GetHexLineWord ;
lxi h , SystemInstance + SystemInstanceT . LoadAddress
mov m , e ;
inx h ;
mov m , d ;
call GetHexLineByte ; Tmp := GetHexLineByte ;
cpi 1 ; if Tmp = 1 then
jnz LoProgFrSe_2 ; begin
mvi a , 1 ; SystemInstance.LoadedStatus:=true ;
sta SystemInstance + SystemInstanceT . LoadedStatus
ret ; exit ;
; end
LoProgFrSe_2 ; else
; begin
LoProgFrSe_4 ; while SystemInstance . BlockSize <> 0 do
lda SystemInstance + SystemInstanceT . BlockSize
ora a ;
jz LoProgFrSe_3 ; begin
call GetHexLineByte ; SystemInstance.LoadAddress^:=GetHexLineByte ;
lhld SystemInstance + SystemInstanceT . LoadAddress
mov m , a ;
; SystemInstance.LoadAddress:=SystemInstance.LoadAddress+1 ;
lhld SystemInstance + SystemInstanceT . LoadAddress
inx h ;
shld SystemInstance + SystemInstanceT . LoadAddress
; SystemInstance.BlockSize:=SystemInstance.BlockSize-1 ;
lxi h , SystemInstance + SystemInstanceT . BlockSize
dcr m ;
jmp LoProgFrSe_4 ; end ;
LoProgFrSe_3 ;
jmp LoProgFrSe_0 ; until false ;
;end (* LoadProgramFromSerial *) ;Algorytm reaguje na zapis :00000001FF (blok o kodzie 01hex oznaczający koniec pliku intel-hex).
Procedura ładowania kodu z UART realizuje w pętli wczytanie z UART po jednym wierszu danych, analizuje go i ładuje do pamięci RAM.
Wybrane funkcje to:
Kod: Zaznacz cały
AddToHexLine ;procedure AddToHexLine ( Ch[A] : byte ) ;
;begin (* AddToHexLine *)
mov e , a ;
; if SystemInstance.HexLineIndex<LoadedHexLineSize then
lxi h , SystemInstance + SystemInstanceT.HexLineIndex
mov a , m ;
cpi LoadedHexLineSize ;
jnc AddTHL_0 ; begin
mvi b , 0 ; SystemInstance.LoadedHexLine [SystemInstance.HexLineIndex]:= Ch ;
mov c , a ;
lxi h , SystemInstance + SystemInstanceT.LoadedHexLine
dad b ;
mov m , e ;
; SystemInstance.HexLineIndex:= SystemInstance.HexLineIndex+1 ;
lxi h , SystemInstance + SystemInstanceT.HexLineIndex
inr m ;
AddTHL_0 ; end ;
ret ;end (* AddToHexLine *) ;
;********************************
GetHexFileLine ;function GetHexFileLine : boolean [A] ;
;var
; Ch[A] : byte ;
;begin (* GetHexFileLine *)
mvi a , 0 ; SystemInstance . HexLineIndex := 0 ;
sta SystemInstance + SystemInstanceT . HexLineIndex
GeHxFiLi_0 ; repeat
call SerialDataPresent ; if SerialDataPresent then
cpi 1 ;
jnz GeHxFiLi_0 ; begin
call GetSerial ; Ch := GetSerial ;
cpi ':' ; if Ch = ':' then
jnz GeHxFiLi_0 ; break ;
; end ;
; until false ;
GeHxFiLi_1 ; repeat
call SerialDataPresent ; if SerialDataPresent then
cpi 1 ;
jnz GeHxFiLi_1 ; begin
call GetSerial ; Ch := GetSerial ;
cpi CrCh ; if Ch = CrCh then
jnz GeHxFiLi_2 ; begin
mvi a , 0 ; AddToHexLine ( 0 ) ;
call AddToHexLine ;
jmp GeHxFiLi_1 ; end ;
GeHxFiLi_2 ;
cpi LfCh ; if Ch = LfCh then
jnz GeHxFiLi_3 ; begin
mvi a , 1 ; GetHexFileLine := true ;
ret ; exit ;
GeHxFiLi_3 ; end ;
call AddToHexLine ; AddToHexLine ( Ch ) ;
call HexDigit ; if not HexDigit ( Ch ) then
cpi 1 ;
jnz GeHxFiLi_1 ; begin
mvi a , 0 ; GetHexFileLine := false ;
ret ; exit ;
; end ;
; until false ;
;end (* GetHexFileLine *) ;
;********************************
GetHexLineChar ;function GetHexLineChar : byte [A] ;
;var
; Tmp[A] : byte ;
;begin (* GetHexLineChar *)
; Tmp:= SystemInstance.LoadedHexLine[SystemInstance.HexLineIndex] ;
lda SystemInstance + SystemInstanceT.HexLineIndex
mvi b , 0 ;
mov c , a ;
lxi h , SystemInstance + SystemInstanceT.LoadedHexLine
dad b ;
mov a , m ;
; SystemInstance.HexLineIndex:= SystemInstance.HexLineIndex+1 ;
lxi h , SystemInstance + SystemInstanceT.HexLineIndex
inr m ;
ret ; GetHexLineChar := Tmp ;
;end (* GetHexLineChar *) ;
;********************************
GetHexLineByte ;function GetHexLineByte : byte [A] ;
;var
; ChH : byte ;
; ChL : byte ;
;begin (* GetHexLineByte *)
call GetHexLineChar ; ChH := HexChToBin ( GetHexLineChar ) ;
call HexChToBin ;
push psw ;
call GetHexLineChar ; ChL := HexChToBin ( GetHexLineChar ) ;
call HexChToBin ;
mov b , a ; GetHexLineByte := ChH << 4 + ChL ;
pop psw ;
rlc ;
rlc ;
rlc ;
rlc ;
ora b ;
ret ;end (* GetHexLineByte *) ;
;********************************
GetHexLineWord ;function GetHexLineWord : word [DE] ;
;var
; HiPart : word ;
; LoPart : word ;
;begin (* GetHexLineWord *)
call GetHexLineByte ; HiPart := GetHexLineByte ;
push psw ;
call GetHexLineByte ; LoPart := GetHexLineByte ;
mov e , a ; GetHexLineWord := HiPart << 8 + LoPart ;
pop psw ;
mov d , a ;
ret ;end (* GetHexLineWord *) ;Po uruchomieniu kitu 8080, należy wybrać polecenie ładowania kodu poprzez naciśnięcie przycisku F1.
Zostanie wyświetlony komunikat informacyjny. Po jego ukazaniu się należy wysłać via UART plik zawierający kod programu (nie wcześniej, gdyż strumień znaków zostanie zignorowany).
Do wysłania pliku użyłem trochę leciwego programu (ale ma możliwość prostego wysłania całego pliku).
Należy wybrać klawisz Send File i następnie wskazać plik do wysłania.
Jeżeli program zestawu 8080 nie zgłosi błędu (błąd formatu), to można go uruchomić naciskając przycisk F5/GO, jest komunikat na LCD.
Uruchomiony program działa, gdyż robi to co było w planie: robi demko z dwoma diodami LED.
To pozwala z ekscytacją wnieść kilka udogodnień i rozwijać funkcjonalność.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: Intel 8080 kit
Zakończenie i pauza programu
W trakcie ładowania programu poprzez UART, program wychwytuje jego adres początkowy w pamięci RAM. Nie ma obowiązku, by program zaczynał się w lokacji 8000 hex, może być umieszczony dalej w przestrzeni adresowej. W pliku intel-hex znajduje się informacja, pod jaki adres jest ładowany. Ten punkt wejścia do ładowanego programu jest zapamiętany. Polecenie uruchomienia programu wykorzystuje tą informację.
Uruchomiony program sobie działa, robi co ma zamierzone i ma możliwość zakończenia swojej pracy (by załadować i uruchomić kolejny). Do realizacji tych działań zostały wymyślone odpowiednie ekstrakody. Opierają się one o instrukcję RST 1, gdzie w rejestrze B należy umieścić kod operacji oraz w C dane liczbowe, które zostaną pokazane na wyświetlaczu, co pozwoli na identyfikację miejsca zakończenia lub zatrzymania. Szczegóły są następujące:
Kod: Zaznacz cały
;
; Statusy operacji w A
SuccessEC .equ 0
ErrorEC .equ 1
;
; Funkcje zwiazane z zakonczeniem programu bazuja na instrucji RST 1
;
; B - zawiera polecenie:
ExitProgramEC .equ 1
PasueProgramEC .equ 2
;
; C - zawiera komunikat konczacy jako liczba do wyswietlenia (na LCD)
;
;Teraz tworzony jest program do uruchomienia, który robi jeden cykl demka na diodach LED i się zatrzymuje (robi ekstrakod z operacją zatrzymania programu). Tekst programu to:
Kod: Zaznacz cały
Improved compiler for INTEL 8080/8085 processor, version 2.4 licence: CC BY 3.0
L.NO MEMO CODE SRC
Open file: D:\prace\i8080kit\I8080test_0.asm
( . . . )
22. .i8080
23. .include "\prace\i8080kit\i8080api.asm"
Open file: \prace\i8080kit\i8080api.asm
( . . . )
22. ;
23. ; Statusy operacji w A
24. 0000 SuccessEC .equ 0
25. 0001 ErrorEC .equ 1
26. ;
27. ; Funkcje zwiazane z zakonczeniem programu bazuja na instrucji RST 1
28. ;
29. ; B - zawiera polecenie:
30. 0001 ExitProgramEC .equ 1
31. 0002 PasueProgramEC .equ 2
32. ; C - zawiera komunikat jako liczba do wyswietlenia konczacy (wyswietlany na LCD)
33. ;
Close file: \prace\i8080kit\i8080api.asm
Current file: D:\prace\i8080kit\I8080test_0.asm
24. ;
25. 8000 ResetEntry .equ 08000h ;
26. FFFE Stack_top .equ 0fffeh ;
27. 00A8 LEDRegister .equ 0A8h ;
28. ;*******************************************
29. .org ResetEntry ;
30. 8000 C33980 jmp Main ;
31. 8003 03 DemoTable .defb 00000011b ;
32. 8004 06 .defb 00000110b ;
33. 8005 0C .defb 00001100b ;
34. 8006 18 .defb 00011000b ;
35. 8007 30 .defb 00110000b ;
36. 8008 60 .defb 01100000b ;
37. 8009 80 .defb 10000000b ;
38. 800A 60 .defb 01100000b ;
39. 800B 30 .defb 00110000b ;
40. 800C 18 .defb 00011000b ;
41. 800D 0C .defb 00001100b ;
42. 800E 06 .defb 00000110b ;
43. 800F 03 .defb 00000011b ;
44. 8010 00 .defb 00000000b ;
45. ;*******************************************
46. 8011 LEDDemo ;procedure LEDDemo ;
47. ;var
48. ; TmpPtr : word[hl] ;
49. ; TmpCh : byte ;
50. ;begin (* LEDDemo *)
51. 8011 210380 lxi h , DemoTable ; TmpPtr := DemoTable ;
52. 8014 Ledde_3 ; repeat
53. 8014 7E mov a , m ; TmpCh := TmpPtr ^ ;
54. 8015 FE00 cpi 0 ; if TmpCh <> 0 then
55. 8017 CA2580 jz Ledde_1 ; begin
56. 801A D3A8 out LEDRegister ; LEDRegister := TmpCh ;
57. 801C E5 push h ;
58. 801D CD2F80 call DemoDelay ; DemoDelay ;
59. 8020 E1 pop h ;
60. 8021 23 inx h ; TmpPtr := TmpPtr + 1 ;
61. 8022 C31480 jmp Ledde_3 ; end
62. 8025 Ledde_1 ; else
63. 8025 C9 ret ; exit ;
64. 8026 C31480 jmp Ledde_3 ; until false ;
65. ;end (* LEDDemo *) ;
66. ;*******************************************
67. 8029 Pause ;procedure Pause ;
68. ;begin (* Pause *)
69. 8029 0602 mvi b , PasueProgramEC ;
70. 802B 0E01 mvi c , 1 ;
71. 802D CF rst 1 ;
72. 802E C9 ret ;end (* Pause *) ;
73. ;*******************************************
74. 802F DemoDelay ;procedure DemoDelay ;
75. ;begin (* DemoDelay *)
76. 802F 010030 lxi b , 03000h ;
77. 8032 DeDel_0 ;
78. 8032 0B dcx b ;
79. 8033 78 mov a , b ;
80. 8034 B1 ora c ;
81. 8035 C23280 jnz DeDel_0 ;
82. 8038 C9 ret ;end (* DemoDelay *) ;
83. ;*******************************************
84. 8039 Main ;begin (* main *)
85. 8039 31FEFF lxi sp , Stack_top ;
86. 803C Main_0 ; repeat
87. 803C CD1180 call LEDDemo ; LEDDemo ;
88. 803F CD2980 call Pause ; Pause ;
89. 8042 C33C80 jmp Main_0 ; until false ;
90. ;end (* main *).
91. ;*******************************************
92. .end
Close file: D:\prace\i8080kit\I8080test_0.asm
Compilation :successfulTu warto zwrócić uwagę na funkcję Pause, która realizuje ekstrakod do systemu, którego zadaniem jest zatrzymanie wykonywania programu użytkowego wraz z wyświetleniem odpowiedniego komunikatu.
Wykonanie instrukcji RST 1 odkłada na stos informację o adresie powrotu (jak przykładowo instrukcja call), co pozwala później na wznowienie programu od miejsca zatrzymania.
Z każdym uruchamianym programem wiąże się pojęcie stosu. Program użytkowy może ustawić swój własny wskaźnik stosu. W chwili jego pierwszego uruchomienia (po załadowaniu do pamięci RAM), stos jest ustawiony na koniec fizycznej pamięci RAM, ale można go zmienić. Uruchomienie programu wiąże się z odłączeniem od stosu „systemowego”. Realizacja ekstrakodu zatrzymującego program przełącza stos na „systemowy” z zapamiętaniem stosu użytkowego.
Załadowanie programu do RAM wiąże się z zapamiętaniem dwóch informacji: adresu wejścia do programu (pochodzi z pliku intel-hex) oraz wskaźnika stosu użytkownika (z założenia koniec pamięci RAM).
Kod: Zaznacz cały
CommandExecute ;procedure CommandExecute ( Ch[a] : byte ) ;
;begin (* CommandExecute *)
; case Ch of
cpi F1Ch ; F1Ch :
( . . . )
SelCmmEx_4 ; F5Ch :
cpi F5Ch ;
jnz SelCmmEx_5 ;
call ClrScrLCD ; ClrScrLCD ;
; if SystemInstance . LoadedStatus then
lda SystemInstance + SystemInstanceT . LoadedStatus
ora a ;
jnz SelCmmEx_41 ; begin
lxi h , ProgramNotPresent ; WriteTextLCD ( ProgramNotPresent ) ;
call WriteTextLCD ;
call NewLineLCD ; NewLineLCD ;
lxi h , PressAnyKey ; WriteTextLCD ( PressAnyKey ) ;
call WriteTextLCD ;
call AnyKey ; AnyKey ;
ret ; exit ;
SelCmmEx_41 ; end ;
lxi h , ProgramRunning ; WriteTextLCD ( ProgramRunning ) ;
call WriteTextLCD ;
lxi h , SelCmmEx_0 ; SystemInstance . SysContinueAdr := SelCmmEx_0 ;
shld SystemInstance + SystemInstanceT . SysContinueAdr
lxi h , 0 ; SystemInstance . SysSP := SP ;
dad sp ;
shld SystemInstance + SystemInstanceT . SysSP
; SP := SystemInstance . UserSP ;
lhld SystemInstance + SystemInstanceT . UserSP
sphl ;
; SystemInstanceT . ProgEntry ^ ( ) ;
lhld SystemInstance + SystemInstanceT . ProgEntry
pchl ;
; exit ;
SelCmmEx_5 ; F6Ch :
( . . . )
; end (* case *) ;
SelCmmEx_0 ;
ret ;end (* CommandExecute *) ;Istotną operacją jest jeszcze zapisanie adresu do kontynuowania działania. Program użytkowy jest uruchamiany instrukcją PCHL (skok do miejsca o adresie zapisanym w parze rejestrów HL bez wskazania adresu powrotu). Wykonanie z programu użytkowego instrukcji RST 1 powinno (w sensie systemu nadzorującego) trafić za operacje uruchamiającą program użytkowy, a właściwie na instrukcję wyjścia z funkcji, która wykonała uruchomienie programu użytkowego (by stos się zgodził co do długości). Realizuje to (SelCmmEx_0 jest etykietą przed instrukcją RET).
Kod: Zaznacz cały
lxi h , SelCmmEx_0 ; SystemInstance . SysContinueAdr := SelCmmEx_0 ;
shld SystemInstance + SystemInstanceT . SysContinueAdrObsługa instrukcji RST 1 trafia do procedury:
Kod: Zaznacz cały
SysInt1Service ;procedure SysInt1Service ;
; program exit and pause extracode
; b = option
; c = param
;begin (* SysInt1Service *)
mov a , b ;
cpi ExitProgramEC ; if option = ExitProgramEC then
jnz SysInt1Srv_1 ; begin
di ; DisableInt ;
; SP := SystemInstance . SysSP ;
lhld SystemInstance + SystemInstanceT . SysSP
sphl ;
; PushOnStack ( SystemInstance . SysContinueAdr ) ;
lhld SystemInstance + SystemInstanceT . SysContinueAdr
push h ;
ei ; EnableInt ;
push b ;
call ClrScrLCD ; ClrScrLCD ;
lxi h , ProgramExitMessage ; WriteTextLCD ( ProgramExitMessage ) ;
call WriteTextLCD ;
call NewLineLCD ; NewLineLCD ;
lxi h , ExitMessageCode ; WriteTextLCD ( ExitMessageCode ) ;
call WriteTextLCD ;
pop b ;
mov a , c ; HexCnvByteToStr ( param ) ;
call HexCnvByteToStr ;
; WriteTextLCD ( SystemInstance . Number ) ;
lxi h , SystemInstance + SystemInstanceT . Number
call WriteTextLCD ;
mvi a , 0 ; SystemInstance . LoadedStatus := false ;
sta SystemInstance + SystemInstanceT.LoadedStatus
ret ; exit -> SystemInstance . SysContinueAdr ;
SysInt1Srv_1 ; end ;
cpi PasueProgramEC ; if option = PasueProgramEC then
jnz SysInt1Srv_2 ; begin
di ; DisableInt ;
pop h ; SystemInstance . ProgEntry := PopFromStack ;
shld SystemInstance + SystemInstanceT . ProgEntry
mvi a , 1 ; SystemInstance . ProgEntryStatus := true ;
sta SystemInstance + SystemInstanceT . ProgEntryStatus
lxi h , 0 ; SystemInstance . UserSP := SP ;
dad sp ;
shld SystemInstance + SystemInstanceT . UserSP
; SP := SystemInstance . SysSP ;
lhld SystemInstance + SystemInstanceT . SysSP
sphl ;
; PushOnStack ( SystemInstance . SysContinueAdr ) ;
lhld SystemInstance + SystemInstanceT . SysContinueAdr
push h ;
ei ; EnableInt ;
push b ;
call ClrScrLCD ; ClrScrLCD ;
lxi h , ProgramPauseMessage ; WriteTextLCD ( ProgramPauseMessage ) ;
call WriteTextLCD ;
call NewLineLCD ; NewLineLCD ;
lxi h , ExitMessageCode ; WriteTextLCD ( ExitMessageCode ) ;
call WriteTextLCD ;
pop b ;
mov a , c ; HexCnvByteToStr ( param ) ;
call HexCnvByteToStr ;
; WriteTextLCD ( SystemInstance . Number ) ;
lxi h , SystemInstance + SystemInstanceT . Number
call WriteTextLCD ;
ret ; exit -> SystemInstance . SysContinueAdr ;
SysInt1Srv_2 ; end ;
ret ;end (* SysInt1Service *) ;W operacji zakończenia programu wykonane są jedynie operacje związane z ustawieniem stosu na systemowy oraz ustawiona flaga, że program użytkowy nie jest załadowany do RAM. Powrót do „normalności” to umieszczenie na stosie informacji zapisanych w zmiennej SystemInstance . SysContinueAdr (jako adres wyjścia z procedury uruchamia programu użytkowego) oraz następnie instrukcja RET (trafi ponownie do funkcji realizującej polecenia).
Kod: Zaznacz cały
; PushOnStack ( SystemInstance . SysContinueAdr ) ;
lhld SystemInstance + SystemInstanceT . SysContinueAdr
push h ;
( . . . )
ret ; exit -> SystemInstance . SysContinueAdr ;Bardziej złożoną operacją jest zatrzymanie programu z możliwością jego dalszego wznowienia. W tym przypadku należy pobrać ze stosu adres powrotu (miejsce w programie użytkowym za instrukcją RST 1), który zostaje zapisany jako nowy punkt wejścia do programu użytkowego (ewentualnie kolejne GO wznowi program użytkowy). Kolejną ważna operacją jest zapamiętanie aktualnego wskaźnika stosu (programu użytkowego) i zapisanie tych danych. To daje istotne informacje by wznosić program. Po przełączeniu stosu na „systemowy”, następuje powrót do interpretacji poleceń z klawiatury (identycznie jak w operacji zakończenia programu).
Kod: Zaznacz cały
di ; DisableInt ;
pop h ; SystemInstance . ProgEntry := PopFromStack ;
shld SystemInstance + SystemInstanceT . ProgEntry
mvi a , 1 ; SystemInstance . ProgEntryStatus := true ;
sta SystemInstance + SystemInstanceT . ProgEntryStatus
lxi h , 0 ; SystemInstance . UserSP := SP ;
dad sp ;
shld SystemInstance + SystemInstanceT . UserSP
; SP := SystemInstance . SysSP ;
lhld SystemInstance + SystemInstanceT . SysSP
sphl ;
; PushOnStack ( SystemInstance . SysContinueAdr ) ;
lhld SystemInstance + SystemInstanceT . SysContinueAdr
push h ;
ei ; EnableInt ;
push b ;
call ClrScrLCD ; ClrScrLCD ;
lxi h , ProgramPauseMessage ; WriteTextLCD ( ProgramPauseMessage ) ;
call WriteTextLCD ;
call NewLineLCD ; NewLineLCD ;
lxi h , ExitMessageCode ; WriteTextLCD ( ExitMessageCode ) ;
call WriteTextLCD ;
pop b ;
mov a , c ; HexCnvByteToStr ( param ) ;
call HexCnvByteToStr ;
; WriteTextLCD ( SystemInstance . Number ) ;
lxi h , SystemInstance + SystemInstanceT . Number
call WriteTextLCD ;
ret ; exit -> SystemInstance . SysContinueAdr ;Wszystko działa:
Ładowanie programu użytkowego:
Uruchomienie programu: program robi ledowe demko i ekstrakod zatrzymania:
Można go wznowić, robi demko na ledach i ponownie się zatrzymuje (i tak w kółko).
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: Intel 8080 kit
Ekstrakody do obsługi wyświetlacza oraz klawiatury
Kolejna rozbudowa dotyczy interfejsu do urządzeń wejścia/wyjścia. W oprogramowanie jest wbudowana obsługa wyświetlacza LCD oraz klawiatury. Nie jest uzasadnione, by te działania powielać w programach użytkowych, najprościej wykorzystać już istniejące. Ta prosta koncepcja niesie jeden problem: adresy funkcji do ich obsługi. Rozwiązanie jest wrażliwe na rzeczywiste położenie ich w przestrzeni adresowej. Niby można wynotować aktualne lokacje wybranych funkcji, ale ten stan ma cechę chwilowości, wystarczy drobne zmiana w programie i cała masa funkcji zmieni swoje położenie z przestrzeni adresowej.
Wyjściem z tego jest stworzenie rozwiązania, które jest w swej koncepcji bezadresowe. Tu można posłużyć się instrukcją RST n. Określając w rejestrach odpowiednią funkcję i wykonując instrukcję RST (ta zawsze ma ściśle określone i stałe położenie w przestrzeni adresowej). Jej obsługa w dalszej części może być już rozwiązana w dowolny sposób. Z punku widzenia programu użytkowego nie musi być znana lokalizacja poszczególnych funkcji, które realizuję właściwe działania, natomiast efekt jest taki, że funkcje działają.
Obecna postać pliku opisująca API do środowiska procka 8080 została poszerzona o stałe parametrów do instrukcji RST (sam kilka razy podałem nie ten numer i wyszło, jak wyszło – nie zawsze do czego chciałem).
Kod: Zaznacz cały
;
; C - zawiera komunikat kończący jako liczba do wyświetlenia (na LCD)
;
;****************************************************************************
;
; Funkcje związane z obsługą wyświetlacza LCD bazują na instrukcji RST 2
ScreenControlEC .equ 2
;
; B - zawiera polecenie:
WriteChEC .equ 1 ; w C jest znak
WriteStringEC .equ 2 ; w HL jest adres
ClrScrEC .equ 3
HomeEC .equ 4
NewLineEC .equ 5
SetCursorOnEC .equ 6 ; w C jest BlinkMode (boolean)
SetCursonOffEC .equ 7
SetCursorPosEC .equ 8 ; w C jest pozycja bity 5..0 – kolumna
; bity 7..6 - wiersz
Write8BitHexEC .equ 9 ; w C jest liczba
Write16BitHexEC .equ 10 ; w HL jest liczba
Write8BitBinaryEC .equ 11 ; w C jest liczba
Write16BitBinaryEC .equ 12 ; w HL jest liczba
Write8BitDecimalEC .equ 13 ; w C jest liczba
Write16BitDecimalEC .equ 14 ; w HL jest liczba
Write8BitDecimalU2EC .equ 15 ; w C jest liczba
Write16BitDecimalU2EC .equ 16 ; w HL jest liczba
;W przypadku obsługi LCD są to funkcje do pisania po jednym znaku oraz wypisania ciągu znaków, typowych operacji jak czyszczenie ekranu, zmiana wiersza, sterowanie kursorem. Do tego kompletu dodałem często używane operacje dotyczące pisania po ekranie liczb, które wymagają konwersji z postaci binarnej na znakową. Istnieje możliwość obsługi liczb 8-bitowych oraz 16-bitowych z formatowaniem do postaci binarnej (zero/jeden), do postaci szesnastkowej, dziesiętnej (jako liczb bez znaku) oraz do postaci dziesiętnej jako liczby ze znakiem. Przykładowy program użytkowy wygląda następująco:
Kod: Zaznacz cały
.i8080
.include "\prace\i8080kit\i8080api.asm"
;
ResetEntry .equ 08000h ;
Stack_top .equ 0fffeh ;
;****************************************
.org ResetEntry ;
jmp Main ;
HelloText .defb "Hello, on LCD" , 0
;****************************************
Delay ;procedure Delay ;
;begin (* Delay *)
lxi b , 0h ;
Del_0 ;
dcx b ;
mov a , b ;
ora c ;
jnz Del_0 ;
ret ;end (* Delay *) ;
;*************************************
DemoDelay ;procedure DemoDelay ;
;begin (* DemoDelay *)
call Delay ;
call Delay ;
call Delay ;
call Delay ;
call Delay ;
ret ;end (* DemoDelay *) ;
;*************************************
Main ;begin (* main *)
lxi sp , Stack_top ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , WriteStringEC ; WriteString ( HelloText ) ;
lxi h , HelloText ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write8BitHexEC ; Write8BitHex ( 12h ) ; 12
mvi c , 12h ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write8BitHexEC ; Write8BitHex ( 0AAh ) ; AA
mvi c , 0AAh ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write8BitHexEC ; Write8BitHex ( 055h ) ; 55
mvi c , 055h ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write16BitHexEC ; Write16BitHex ( 01234h ) ; 1234
lxi h , 01234h ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write16BitHexEC ; Write16BitHex ( 06789h ) ; 6789
lxi h , 06789h ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write16BitHexEC ; Write16BitHex ( 0ABCDh ) ; ABCD
lxi h , 0ABCDh ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write8BitDecimalEC ; Write8BitDecimal ( 0ABh ) ; 171
mvi c , 0ABh ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write8BitDecimalEC ; Write8BitDecimal ( 067h ) ; 103
mvi c , 067h ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write16BitDecimalEC ; Write16BitDecimal ( 01267h ) ; 4711
lxi h , 01267h ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write16BitDecimalEC ; Write16BitDecimal ( 0ABCDh ) ; 43981
lxi h , 0ABCDh ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write8BitDecimalU2EC ; Write8BitDecimalU2 ( 0ABh ) ; -85
mvi c , 0ABh ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write8BitDecimalU2EC ; Write8BitDecimalU2 ( 067h ) ; 103
mvi c , 067h ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write16BitDecimalU2EC; Write16BitDecimalU2 ( 01267h ) ; 4711
lxi h , 01267h ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write16BitDecimalU2EC; Write16BitDecimalU2 ( 0ABCDh ) ; -21555
lxi h , 0ABCDh ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst 2 ;
mvi b , Write8BitBinaryEC ; Write8BitBinary ( 0ABh ) ;
mvi c , 0ABh ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write8BitBinaryEC ; Write8BitBinary ( 05Ah ) ;
mvi c , 05Ah ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , Write16BitBinaryEC ; Write16BitBinary ( 0C33Ch ) ;
lxi h , 0C33Ch ;
rst ScreenControlEC ;
call DemoDelay ; DemoDelay ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , ExitProgramEC ; ProgramTerminate ;
mvi c , 0 ;
rst ProgControlEC ;
;end (* main *).
;*************************************
.endPo załadowaniu i uruchomieniu programu, kilka wybranych fotek:
W podobnej technologii rozwiązany jest interfejs do klawiatury. Tu są dostępne operacje pozwalające stwierdzić, czy w kolejce FIFO klawiatury znajduje się znak oraz pozwala wczytać ten znak. Dodatkową funkcję jest usunięcie wszystkich znaków z kolejki FIFO.
Fragment pliku API dotyczący klawiatury to (oprócz identyfikatorów operacji jest zestaw znaków generowanych przez klawiaturę):
Kod: Zaznacz cały
; Funkcje związane klawiaturą bazują na instrukcji RST 3
;
KeybControlEC .equ 3
;
; B - zawiera polecenie:
KeyPressedEC .equ 1 ; odpowiedź: w C jest flaga: 0/nie 0
GetKeyEC .equ 2 ; odpowiedź: w C jest kod znaku
ClearKeybFifoEC .equ 3 ; brak odpowiedzi
;
Digit0Ch .equ '0' ;
Digit1Ch .equ '1' ;
Digit2Ch .equ '2' ;
Digit3Ch .equ '3' ;
Digit4Ch .equ '4' ;
Digit5Ch .equ '5' ;
Digit6Ch .equ '6' ;
Digit7Ch .equ '7' ;
Digit8Ch .equ '8' ;
Digit9Ch .equ '9' ;
DigitACh .equ 'A' ;
DigitBCh .equ 'B' ;
DigitCCh .equ 'C' ;
DigitDCh .equ 'D' ;
DigitECh .equ 'E' ;
DigitFCh .equ 'F' ;
F1Ch .equ 'a' ;
F2Ch .equ 'b' ;
F3Ch .equ 'c' ;
F4Ch .equ 'd' ;
F5Ch .equ 'e' ;
F6Ch .equ 'f' ;
F7Ch .equ 'g' ;
F8Ch .equ 'h' ;
;Przykładowy program do badania klawiatury jest następujący (gdzie warto zwrócić uwagę na punkt wejścia do programu wynoszący 8100 hex).
Kod: Zaznacz cały
.i8080
.include "\prace\i8080kit\i8080api.asm"
;
ResetEntry .equ 08100h ;
Stack_top .equ 0fffeh ;
;
EscCh .equ F8Ch ;
;*******************************************
.org ResetEntry ;
jmp Main ;
HelloText .defb "Hello, on LCD" , 0
;*******************************************
Main ;begin (* main *)
lxi sp , Stack_top ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , WriteStringEC ; WriteString ( HelloText ) ;
lxi h , HelloText ;
rst ScreenControlEC ;
mvi b , NewLineEC ; NewLine ;
rst ScreenControlEC ;
Main_0 ; repeat
mvi b , KeyPressedEC ; if KeyPressed then
rst KeybControlEC ;
mov a , c ;
ora a ;
jz Main_0 ; begin
mvi b , GetKeyEC ; Tmp := ReadKey ;
rst KeybControlEC ;
push b ;
mvi b , WriteChEC ; WriteChLCD ( Tmp ) ;
rst ScreenControlEC ;
pop b ; if Tmp = EscCh then
mov a , c ;
cpi EscCh ;
jnz Main_0 ;
mvi b , ExitProgramEC ; ProgramTerminate ;
mvi c , 3ch ;
rst ProgControlEC ;
; until false ;
;end (* main *).
;*******************************************
.endProgram wyświetla znaki uzyskane z klawiatury oraz kończy pracę po naciśnięcie klawisza F8/ESC (jako komunikat kończący program występuje liczba 3C hex). Po załadowaniu programu występuje komunikat mówiący o punkcie wejścia do programu.
Uruchomienie daje efekt „maszyny do pisania”.
Naciśnięcie ESC kończy działanie programu z wymaganym komunikatem.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: Intel 8080 kit
Pozdrawiam! J23
BOB TAYLOR, PARC
- photin
- Posty: 18
- Rejestracja: niedziela 08 paź 2023, 12:43
- Lokalizacja: Klaudyn-Pruszkow
- Kontaktowanie:
Re: Intel 8080 kit
Jak juz bede mial lokalnego AI, to kaze mu sciagnac wszystkie Twoje posty i doradzac mi na ich podstawie
Re: Intel 8080 kit
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: Intel 8080 kit
UART w programie użytkowym
ekstrakody transmisji szeregowej
Transmisja szeregowa jest jedną z najprostszych form komunikacji z mikroprocesorem. Skoro w układzie uruchomieniowym jest kontroler pozwalający realizować szeregowe przesyłanie danych, to nie jest uzasadnione, by ładowany program użytkowy nie miał możliwości jego wykorzystania. Chociaż pierwotnie jego przeznaczenie było dedykowane do ładowania kodu (chyba nikt nie ma ochoty wpisywać kodu programu z klawiatury → jest to nieoptymalne i bardzo wrażliwe na pomyłki). Można uznać, że układ 8250 jest współdzielony.
Do obsługi transmisji szeregowej również powstały odpowiednie ekstrakody. W tym przypadku dotyczą transmisji znaku jak również dłuższego ciągu znaków (musi być zakończony znakiem o kodzie 0). W drugą stronę jest możliwość sprawdzenia, czy w kolejkach znajdują się jakiekolwiek znaki do wczytania oraz ich wczytanie. Dodatkowo można wyzerować istniejącą kolejkę FIFO związaną z transmisją szeregową. Analogicznie jak poprzednio, jest zdefiniowanych kilka kolejnych stałych dotyczących API transmisji szeregowej (tym razem opartych o instrukcję RST 4):
Kod: Zaznacz cały
; Funkcje związane z UART bazują na instrukcji RST 4
;
UARTControlEC .equ 4
;
; B - zawiera polecenie:
SerialDataPresentEC .equ 1 ; odpowiedź: w C jest flaga: 0/nie 0
GetSerialDataEC .equ 2 ; odpowiedź: w C jest kod znaku
SentSerialCharEC .equ 3 ; w C jest znak
SendSerialStringEC .equ 4 ; w HL jest adres
SerialClearFifoEC .equ 5 ; bez parametrówKrótki program diagnostyczno/prezentacyjny jest następujący:
Kod: Zaznacz cały
.i8080
.include "\prace\i8080kit\i8080api.asm"
;
ResetEntry .equ 08000h ;
Stack_top .equ 0fffeh ;
;
EscCh .equ F8Ch ;
;*******************************************
.org ResetEntry ;
jmp Main ;
HelloText .defb "Hello, on serial" , 0Dh , 0Ah , 0
ProgramExit .defb 0Dh , 0Ah , "Koniec programu" , 0Dh , 0Ah , 0
;*******************************************
Main ;begin (* main *)
lxi sp , Stack_top ;
mvi b , SendSerialStringEC ; SendSerialString ( HelloText ) ;
lxi h , HelloText ;
rst UARTControlEC ;
Main_0 ; repeat
mvi b , SerialDataPresentEC ; if SerialDataPresent then
rst UARTControlEC ;
mov a , c ;
ora a ;
jz Main_0 ; begin
mvi b , GetSerialDataEC ; Tmp := GetSerial ;
rst UARTControlEC ;
mov a , c ; if Tmp = 1Bh (* ESC *) then
cpi 1Bh ;
jnz Main_1 ; begin
mvi b , SendSerialStringEC ; SendSerialString ( ProgramExit ) ;
lxi h , ProgramExit ;
rst UARTControlEC ;
mvi b , ExitProgramEC ; ProgramTerminate ;
mvi c , 0Ch ;
rst ProgControlEC ;
; end ;
Main_1 ;
mvi b , SentSerialCharEC ; SentSerial ( Tmp ) ;
rst UARTControlEC ;
jmp Main_0 ; until false ;
;end (* main *).
;*******************************************
.endTen krótki program wczytuje dane z UART. Każdy wczytany znak jest wysyłany do UART (działa jak maszyna do pisania). Praca programu kończy się po wczytaniu znaku ESC (kod znaku 1B hex).
Po wysłaniu via UART kodu nowego programu, kliknąłem na Clear w okienku nadajnika i odbiornika i uruchomiłem załadowany program (znaki $0D$0A w okienku do wysyłania to znaki CR oraz LF).
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: Intel 8080 kit
Pozdrawiam! J23
BOB TAYLOR, PARC
Re: Intel 8080 kit
j23 pisze:Twój tutorial Kolego Gaweł ma KOLOSALNĄ wartość merytoryczną (i to już na etapie samego listingu kodu). Można tutaj np. zrozumieć podstawy jak pisać sterowniki (drivery) urządzeń - coś co jakieś 30 lat temu BARDZO chciałem umieć, ale wtedy nikt nie miał mnie tego jak nauczyć (a dostępu do wiedzy jak teraz niestety nie było). Patrzę, delektuję się i... nadal uczę. Dzięki!![]()
Pozdrawiam! J23
Nigdy nie spotkałem systemu z 8080. Przydałoby się zbudować ten komputer, żeby wszystkiego dotknąć. Nie mam większości układów użytych w tym projekcie, a zakup pewnie będzie trudny. To są prawdziwe wykopaliska!
Również podziwiam efekty pracy kolegi @gaweł, chociaż jest to praca na pierwszy rzut oka bez sensu. Ma jednak ona wielką wartość poznawczą. W końcu to pierwszy procesor ośmiobitowy (był jeszcze 8008, ale chyba można go pominąć). Ciekawe, czy można gdzieś spotkać "nasz" MCY7880?
X is work. Y is play. Z is keep your mouth shut."A. Einstein
Re: Intel 8080 kit
Zegar pisze:Nigdy nie spotkałem systemu z 8080. Przydałoby się zbudować ten komputer, żeby wszystkiego dotknąć. Nie mam większości układów użytych w tym projekcie, a zakup pewnie będzie trudny. To są prawdziwe wykopaliska!
Mam zapas (kompletny) i jeszcze jedną PCB (ale bez klawiatury), mogę się podzielić z Tobą.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: Intel 8080 kit
Przerwania w programie użytkowym
W zestawie z prockiem 8080 została przewidziana obsługa przerwań, bo to dobre środowisko, by zapoznać się z tą problematyką. Jakakolwiek ich obsługa sprzętowa sprowadza się do podobnych kwestii programowych. Ten zestaw posługuje się kontrolerem 8259, który upraszcza wiele problemów natury sprzętowej. Posiłkowanie się przykładowo układem 8214 nadal generuje podobne rozwiązania w oprogramowaniu (każde przerwanie wymaga ochrony rejestrów procesora).
Ten zestaw oferuje obsługę dwóch przerwań zewnętrznych jak pokazuje rysunek kontrolera przerwań. Występują tu „prawdziwe” przerwania INT1 oraz INT2 (aktywne dla układu 8259 narastającym zboczem, na złączu do zestawu uruchomieniowego są zanegowane → istotnym zboczem generującym przerwanie z układów zewnętrznych jest zbocze opadające). Dodatkowo programowi użytkowemu umożliwia się obsługę przerwania od upływającego czasu.
Te dwa dwa rodzaje przerwań mają swoją specyfikę. Przerwanie od czasu obsługuje sam program nadzorujący (w zakresie obsługi klawiatury), jak pokazuje listing:
Kod: Zaznacz cały
TimeInterruptService ;ISR TimeInterruptService ;
;begin (* TimeInterruptService *)
push psw ;
push b ;
push d ;
push h ;
call KeybService ; KeybService ;
; if SystemInstance . UserTimerIRQServ <> nil then
lhld SystemInstance + SystemInstanceT . UserTimerIRQServ
mov a , h ;
ora l ;
jz TiIntSrv_0 ;
call CallHLService ; SystemInstance . UserTimerIRQServ ;
TiIntSrv_0 ;
call InitTimerInterrupt ; InitTimerInterrupt ( ) ;
mvi a , 20h ; end of irq
out Controller8259 ;
pop h ;
pop d ;
pop b ;
pop psw ;
ei ;
ret ;end (* TimeInterruptService *) ;Występuje tu pełna wymagana obsługa (zapis rejestrów na stos, potwierdzenie zakończenia obsługi przerwania dla 8259 [out na port 8259 kodu 20hex] oraz odtworzenie rejestrów ze stosu i na końcu istotny element: instrukcja EI). Dowiązanie obsługi tego przerwania do programu użytkowego występuje jako wywołanie funkcji, do której wskaźnik jest zapisany w zmiennej SystemInstance . UserTimerIRQServ ;(pod warunkiem, że wskaźnik nie jest pusty). Odpowiedni ekstrakod z programu użytkowego wnosi wskazanie na funkcję obsługi przerwania, które zostaje zapisane w powyższej zmiennej. W każdym przerwaniu od czasu, sprawdzany jest ten wskaźnik oraz ewentualnie następuje wywołanie funkcji wskazanej przez ten wskaźnik. Właściwie to przerwanie należy traktować jako pewnego rodzaju odgałęzienie rzeczywistej obsługi. Z tej racji, w funkcji zgłoszonej przez program użytkowy nie powinna wystąpić instrukcja out Controller8259, gdzie akumulator zawiera 20 hex. Również jak przyjrzeć się dokładniej, to w użytkowej funkcji obsługi przerwanie można pominąć wszelkie instrukcje zapisu na stos (push) oraz odczytu ze stosu (pop), chociaż ich wystąpienie nie będzie błędem.
Do obsługi przerwań do API dodane są następujące możliwości (z instrukcja RST 5 (lub RST IntControlEC):
Kod: Zaznacz cały
; Funkcje związane z obsługą przerwań bazują na instrukcji RST 5
;
IntControlEC .equ 5
;
; B - zawiera polecenie:
InstallTimeIRQEC .equ 1 ; w HL jest adres funkcji obsługi
InstallUserIRQ1EC .equ 2 ; w HL jest adres funkcji obsługi
InstallUserIRQ2EC .equ 3 ; w HL jest adres funkcji obsługi
DeInstallTimeIRQEC .equ 4 ; bez parametrów
DeInstallUserIRQ1EC .equ 5 ; bez parametrów
DeInstallUserIRQ2EC .equ 6 ; bez parametrówDostępne jest „zainstalowanie” funkcji obsługi przerwania dla upływu czasu oraz dwóch funkcji obsługi przerwań INT1 oraz INT2 (te już muszą być zrealizowane w sposób kompletny). Każda zainstalowana funkcja obsługi może zostać odinstalowana, co oznacza, że nie będzie ono obsługiwane z programu użytkowego.
Początkowo funkcje obsługi przerwania INT1 oraz INT2 planowałem zrealizować w podobny sposób jak przerwanie od upływu czasu. Takie rozwiązanie miałoby identyczne cechy, jak by pozbawić użytkownika z ekscytacji z poprawnej obsługi przerwań, zrealizowałem to odmiennie. Nadal funkcję obsługi przerwania należy zainstalować, ale tym razem nie ma żadnej taryfy ulgowej, należy zrealizować wszystko co niezbędne.
Wcześniej tabela wektorów powiązana z układem 8259 znajdowała się w pamięci EPROM i w przypadku przerwania INT1 oraz INT2 wskazywała na funkcje w obszarze programu nadzorcy mając „odgałęzienie” do zgłoszonej użytkowej funkcji obsługi. Obecnie rozwiązanie polega na modyfikacji odpowiednich pozycji tej tabeli. Zaistnienie konieczności modyfikacji tabeli wektorów przerwań zmusza przeniesienia jej do obszaru pamięci RAM. By po włączeniu zasilania nie zawierała ona „głupot”, jest przepisana z pamięci EPROM do RAM i ta jest „podczepiona” pod układ 8259.
Kod: Zaznacz cały
IRQTableSize .equ 32 ;
;***************************************
IRQTablePattern ;
jmp TimeInterruptService ; Obsługa IRQ0 w 8259
nop ; Wypełnienie do 4 bajtów
jmp SerialInterruptService ; Obsługa IRQ1 w 8259
nop ; Wypełnienie do 4 bajtów
jmp ISR_NoIrq ; Obsługa IRQ2 w 8259
nop ; Wypełnienie do 4 bajtów
jmp ISR_NoIrq ; Obsługa IRQ3 w 8259
nop ; Wypełnienie do 4 bajtów
jmp ISR_NoIrq ; Obsługa IRQ4 w 8259
nop ; Wypełnienie do 4 bajtów
jmp ISR_NoIrq ; Obsługa IRQ5 w 8259
nop ; Wypełnienie do 4 bajtów
jmp ISR_NoIrq ; Obsługa IRQ6 w 8259
nop ; Wypełnienie do 4 bajtów
jmp ISR_NoIrq ; Obsługa IRQ7 w 8259
nop ; Wypełnienie do 4 bajtów
( . . . )
mvi b , IRQTableSize ; for Loop := 0 to IRQTableSize - 1 do
lxi d , IRQTablePattern ; IRQTable [ Loop ] := IRQTablePattern [ Loop ] ;
lxi h , IRQTable ;
IniV_0 ;
ldax d ;
mov m , a ;
inx h ;
inx d ;
dcr b ;
mvi a , 0 ;
cmp b ;
jnz IniV_0 ;
( . . . )
.org RAMSpace
IRQTable .byte IRQTableSizeObecnie instalując przerwanie użytkowe należy podmienić w tabeli w RAM odpowiednie adresy. Jeżeli dla 8259 zostanie zgłoszone przerwanie INT2, to zażąda on wykonania instrukcji CALL 8000hex + numer wejścia przerywającego * 4, która z kolei poprowadzi do instrukcji JMP do odpowiedniej lokacji w przestrzeni adresowej. Teraz wystarczy podmienić w RAM w odpowiedniej pozycji adres funkcji zgłoszonej ekstarakodem przez program użytkowy.
Wymaga to jeszcze modyfikacji maski przerwań w układzie 8259 (poprzez wyzerowanie bitu identyfikującego wejście przerywające). By odinstalować przerwanie wystarczy je zamaskować (ustawić odpowiedni bit maski w rejestrze 8259).
Z zakresie obsługi przerwań instalację/deinstalację pokazuje fragment programu:
Kod: Zaznacz cały
SysInt5Service ;procedure SysInt5Service ;
;begin (* SysInt5Service *)
mov a , b ;
cpi InstallTimeIRQEC ; if option = InstallTimeIRQEC then
jnz SysInt5Srv_1 ; begin
; w HL jest adres funkcji obslugi
di ; DisableInt ;
; SystemInstance . UserTimerIRQServ := hl ;
shld SystemInstance + SystemInstanceT . UserTimerIRQServ
ei ; EnableInt ;
jmp SysInt5Srv_0 ; exit ;
SysInt5Srv_1 ; end ;
cpi InstallUserIRQ1EC ; if option = InstallUserIRQ1EC then
jnz SysInt5Srv_2 ; begin
; w HL jest adres funkcji obslugi
di ; DisableInt ;
in Controller8259 + 1 ; Tmp := Controller8259 + 1
ani 01111111b ; Tmp.7 := 0 ;
out Controller8259 + 1 ; Controller8259 + 1 :=Tmp ;
shld IRQTable + 29 ; IRQTable [ 29 .. 30 ] := hl ;
ei ; EnableInt ;
jmp SysInt5Srv_0 ; exit ;
SysInt5Srv_2 ; end ;
cpi InstallUserIRQ2EC ; if option = InstallUserIRQ2EC then
jnz SysInt5Srv_3 ; begin
; w HL jest adres funkcji obslugi
di ; DisableInt ;
in Controller8259 + 1 ; Tmp := Controller8259 + 1
ani 10111111b ; Tmp.6 := 0 ;
out Controller8259 + 1 ; Controller8259 + 1 :=Tmp ;
shld IRQTable + 25 ; IRQTable [ 25 .. 26 ] := hl ;
ei ; EnableInt ;
jmp SysInt5Srv_0 ; exit ;
SysInt5Srv_3 ; end ;
cpi DeInstallTimeIRQEC ; if option = DeInstallTimeIRQEC then
jnz SysInt5Srv_4 ; begin
; bez parametrow
di ; DisableInt ;
lxi h , 0 ; SystemInstance . UserTimerIRQServ := nil ;
shld SystemInstance + SystemInstanceT . UserTimerIRQServ
ei ; EnableInt ;
jmp SysInt5Srv_0 ; exit ;
SysInt5Srv_4 ; end ;
cpi DeInstallUserIRQ1EC ; if option = DeInstallUserIRQ1EC then
jnz SysInt5Srv_5 ; begin
; bez parametrow
di ; DisableInt ;
call DeinstalUserIRQ1 ; DeinstalUserIRQ1 ;
ei ; EnableInt ;
jmp SysInt5Srv_0 ; exit ;
SysInt5Srv_5 ; end ;
cpi DeInstallUserIRQ2EC ; if option = DeInstallUserIRQ2EC then
jnz SysInt5Srv_6 ; begin
; bez parametrow
di ; DisableInt ;
call DeinstalUserIRQ2 ; DeinstalUserIRQ2 ;
ei ; EnableInt ;
jmp SysInt5Srv_0 ; exit ;
SysInt5Srv_6 ; end ;
mvi a , ErrorEC ;
ret ;
SysInt5Srv_0 ;
mvi a , SuccessEC ;
ret ;end (* SysInt5Service *) ;Występują tu funkcje DeinstalUserIRQ1 i DeinstalUserIRQ2. Są one wywołane, by nie powielać kodu, używane są jeszcze w sytuacji, gdy program użytkowy kończy pracę (na wypadek, gdyby program użytkowy „zapomniał” zamknąć używane przerwania).
Kod: Zaznacz cały
SysInt1Service ;procedure SysInt1Service ;
; program exit and pause extracode
; b = option
; c = param
;begin (* SysInt1Service *)
mov a , b ;
cpi ExitProgramEC ; if option = ExitProgramEC then
jnz SysInt1Srv_1 ; begin
( . . . )
call CloseUserPorts ; CloseUserPorts ;
( . . . )
ret ;end (* SysInt1Service *) ;
gdzie występują wspólne funkcje
Kod: Zaznacz cały
CloseUserPorts ;procedure CloseUserPorts ( ) ;
;begin (* CloseUserPorts *)
mvi a , 080h + P8255A_inp + P8255B_inp + P8255CL_inp + P8255CH_inp
out UserPort8255 + P8255Control ;
mvi a , SerialSpeed9600 ; UARTHardwareInit ( SerialSpeed9600 ) ;
call UARTHardwareInit ;
call ResetSerialFifo ; ResetSerialFifo ;
di ; DisableInt ;
call DeinstalUserIRQ1 ; DeinstalUserIRQ1 ;
call DeinstalUserIRQ2 ; DeinstalUserIRQ2 ;
lxi h , 0 ; SystemInstance . UserTimerIRQServ := nil ;
shld SystemInstance + SystemInstanceT . UserTimerIRQServ
ei ; EnableInt ;
ret ;end (* CloseUserPorts *) ;
;**************************************
DeinstalUserIRQ1 ;procedure DeinstalUserIRQ1 ;
;begin (* DeinstalUserIRQ1 *)
in Controller8259 + 1 ; Tmp := Controller8259 + 1
ori 10000000b ; Tmp.7 := 1 ;
out Controller8259 + 1 ; Controller8259 + 1 :=Tmp ;
ret ;end (* DeinstalUserIRQ1 *) ;
;*******************************************
DeinstalUserIRQ2 ;procedure DeinstalUserIRQ2 ;
;begin (* DeinstalUserIRQ2 *)
in Controller8259 + 1 ; Tmp := Controller8259 + 1
ori 01000000b ; Tmp.6 := 1 ;
out Controller8259 + 1 ; Controller8259 + 1 :=Tmp ;
ret ;end (* DeinstalUserIRQ2 *) ;Program testowy/prezentacyjny ma postać:
Kod: Zaznacz cały
.i8080
.include "\prace\i8080kit\i8080api.asm"
;
ResetEntry .equ 08000h ;
Stack_top .equ 0fffeh ;
;
LEDRegister .equ 0A8h ;
;*******************************************
.org ResetEntry ;
jmp Main ;
HelloText .defb "Hello, on LCD" , 0
;*******************************************
MyTimerIRQ ;ISR MyTimerIRQ ;
;begin (* MyTimerIRQ *)
push psw ;
push b ;
push d ;
push h ;
lxi h , IRQCounter ; IRQCounter := IRQCounter + 1 ;
mov a , m ;
inr a ;
mov m , a ;
cpi 10 ; if IRQCounter = 10 then
jnz MTIRQ_0 ; begin
mvi m , 0 ; IRQCounter := 0 ;
lxi h , Counter ; Counter := Counter + 1 ;
mov a , m ;
inr a ;
mov m , a ;
out LEDRegister ; LEDRegister := Counter ;
MTIRQ_0 ; end ;
pop h ;
pop d ;
pop b ;
pop psw ;
ret ;end (* MyTimerIRQ *) ;
;*******************************************
Main ;begin (* main *)
lxi sp , Stack_top ;
mvi a , 0 ; Counter := 0 ;
sta Counter ;
sta IRQCounter ; IRQCounter := 0 ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , WriteStringEC ; WriteString ( HelloText ) ;
lxi h , HelloText ;
rst ScreenControlEC ;
mvi b , NewLineEC ; NewLine ;
rst ScreenControlEC ;
mvi b , InstallTimeIRQEC ; InstallTimeIRQ ( MyTimerIRQ ) ;
lxi h , MyTimerIRQ ;
rst IntControlEC ;
Main_0 ; repeat
mvi b , KeyPressedEC ; if KeyPressed then
rst KeybControlEC ;
mov a , c ;
ora a ;
jz Main_0 ; begin
mvi b , GetKeyEC ; Tmp := ReadKey ;
rst KeybControlEC ;
; break ;
; end ;
; until false ;
Main_1
mvi b , DeInstallTimeIRQEC ; DeInstallTimeIRQ ;
rst IntControlEC ;
Main_2 ; repeat
mvi b , KeyPressedEC ; if KeyPressed then
rst KeybControlEC ;
mov a , c ;
ora a ;
jz Main_2 ; begin
mvi b , GetKeyEC ; Tmp := ReadKey ;
rst KeybControlEC ;
mvi a , 0 ; LEDRegister := 0 ;
out LEDRegister ;
mvi b , ExitProgramEC ; ProgramTerminate ;
mvi c , 55h ;
rst ProgControlEC ;
; end ;
; until false ;
;end (* main *).
;*******************************************
Counter .byte ;
IRQCounter .byte ;
.endJego zadaniem jest zainstalowanie obsługi przerwania od upływu czasu. Ta obsługa inkrementuje na diodach LED licznik (by lepiej było widać, istnieje wstępny preskaler, akcja dotyczy co któregoś przerwania). To objawia się mruganiem LED’ów.
Po naciśnięciu jakiegokolwiek przycisku, program deinstaluje obsługę przerwania (aktualny stan LED’ów zostaje zatrzymany). Kolejne naciśnięcie przycisku kończy działanie programu poprzedzone wyzerowaniem LED’ów.
Uruchomiony program działa zgodnie z oczekiwaniami.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: Intel 8080 kit
”Wyrywanie” programu
Może się tak zdarzyć, że program użytkowy się zapętli. Oczywiście zawsze można zrobić twardy reset, ale to niewiele pomoże w ustaleniu przyczyny. Ideałem byłoby zatrzymanie programu i podejrzeć trochę zmiennych czy choćby stwierdzenie, gdzie się program kręci. Jedyną komplikacją jest, że program nie jest tego świadomy i nie koniecznie ma ochotę się zatrzymać (przekazać sterowanie do programu nadzorcy).
Na taką okoliczność (zmusić program do zatrzymania) wykombinowałem taką oto koncepcję. W przerwaniach od upływu czasu jest obsługiwana klawiatura, która wykrywa specyficzną kombinację naciśniętych przycisków (F4 i F8 jednocześnie), jak pokazuje powyższa fotka). Taka kombinacja nie dokłada znaku do kolejki FIFO klawiatury a jedynie ustawia flagę, że należy wykonać akcję „wyrywania programu”. Tablice przekodowań zostały poszerzone o nową kombinację (generowany kod znaku to BreakCh):
Kod: Zaznacz cały
BreakCh .equ 0AAh ;
( . . . )
Row3EncodeTable .defb 11111110b , Digit0Ch
.defb 11111101b , DigitACh
.defb 11111011b , DigitBCh
.defb 11110111b , DigitFCh
.defb 11101111b , F4Ch
.defb 11011111b , F8Ch
.defb 11001111b , BreakCh
.defb 0 , 0W algorytmie obsługi klawiatury występuje funkcja przekodowania kombinacji bitowych uzyskanych w portu obsługi klawiatury (8255) na kod znaku i w kolejnym kroku wywoływana jest funkcja dodania nowego kodu znaku do kolejki FIFO. Znak nie wchodzi do FIFO tylko ustawia flagę żądania przerwania programu. Ta funkcja ma postać:
Kod: Zaznacz cały
StoreKey ;procedure StoreKey ( NexCh[A] : char ) ;
;begin (* StoreKey *)
cpi BreakCh ; if NexCh = BreakCh then
jnz StoKe_2 ; begin
mvi a , 1 ; SystemInstance . BreakReq := true ;
sta SystemInstance + SystemInstanceT . BreakReq
ret ; exit ;
StoKe_2 ; end ;
( . . . )
ret ;end (* StoreKey *) ;W obsłudze przerwania od upływu czasu jest:
Kod: Zaznacz cały
TimeInterruptService ;ISR TimeInterruptService ;
;begin (* TimeInterruptService *)
push psw ;
push b ;
push d ;
push h ;
call KeybService ; KeybService ;
; if SystemInstance . BreakReq then
lda SystemInstance + SystemInstanceT . BreakReq
ora a ;
jz TiIntSrv_2 ; begin
lxi h , 0 ; HL := SP + 9 ;
dad sp ;
lxi b , 9 ;
dad b ;
mov a , m ; if Memory [ HL ] >= 80h then
ani 80h ;
jz TiIntSrv_3 ; begin
mov b , m ; bc := Memory [ HL ] ;
dcx h ;
mov c , m ;
ldax b ; SystemInstance . BreakOpCode := Memory [ BC ] ;
sta SystemInstance + SystemInstanceT . BreakOpCode
mvi a , 0FFh ; Memory [ BC ] := 0FFh ; (* RST 7 *)
stax b ;
mvi a , 1 ; SystemInstance . OpcodeChanged := true ;
sta SystemInstance + SystemInstanceT . OpcodeChanged
mvi a , 0 ; SystemInstance . BreakReq := false ;
sta SystemInstance + SystemInstanceT . BreakReq
TiIntSrv_3 ; end ;
TiIntSrv_2 ; end ;
( . . . )
call InitTimerInterrupt ; InitTimerInterrupt ( ) ;
mvi a , 20h ; end of irq
out Controller8259 ;
pop h ;
pop d ;
pop b ;
pop psw ;
ei ;
ret ;end (* TimeInterruptService *) ;Możliwe są dwa przypadki: wywołanie obsługi nastąpi z obszaru programu nadzorcy lub programu użytkowego. To jest rozpoznawane po adresie powrotu umieszczonym na stosie. Na początku obsługi na stos poszły wszystkie rejestry, więc adres powrotu jest trochę „zakopany”, trzeba sięgnąć 9 bajtów głębiej w stosunku do szczytu stosu. Jeżeli to będzie liczby większa lub równa 80 hex (jest to starsza część adresu powrotu), to znaczy, że obsługa tego przerwania trafiła z obszaru programu użytkowego. Mając pełny adres powrotu można pobrać bajt tam zapisany i go zachować w zmiennych programu nadzorcy i w to miejsce wstawić instrukcję RST 7 (o kodzie FF hex). Dochodzi zapamiętanie, że kod w programie został podmieniony (nie jest zabronione, by w programie użytkowym wystąpiła instrukcja RST 7, wtedy nie jest podmieniony). Z tej obsługi przerwania następuje standardowa akcja wyjścia, która trafia na instrukcję RST 7.
Kod: Zaznacz cały
SysInt7Service ;procedure SysInt7Service ;
;begin (* SysInt7Service *)
di ; DisableInt ;
; SystemInstance . BreakHL := hl ;
shld SystemInstance + SystemInstanceT . BreakHL
push b ; SystemInstance . BreakBC := bc ;
pop h ;
shld SystemInstance + SystemInstanceT . BreakBC
push d ; SystemInstance . BreakDE := de ;
pop h ;
shld SystemInstance + SystemInstanceT . BreakDE
push psw ; SystemInstance . BreakPSW := af ;
pop h ;
shld SystemInstance + SystemInstanceT . BreakPSW
; if SystemInstance . OpcodeChanged then
lda SystemInstance + SystemInstanceT . OpcodeChanged
ora a ;
jz SysInt7_0 ; begin
pop h ; SystemInstance . BreakPC := PopFromStack - 1 ;
dcx h ;
shld SystemInstance + SystemInstanceT . BreakPC
; SystemInstance . BreakPC ^ := BreakOpCode ;
lda SystemInstance + SystemInstanceT . BreakOpCode
mov m , a ;
jmp SysInt7_1 ; end
SysInt7_0 ; else
; begin
pop h ; SystemInstance . BreakPC := PopFromStack ;
shld SystemInstance + SystemInstanceT . BreakPC
SysInt7_1 ; end
lxi h , 0 ; SystemInstance . BreakSP := SP ;
dad sp ;
shld SystemInstance + SystemInstanceT . BreakSP
mvi a , 1 ; SystemInstance . BreakFlag := true ;
sta SystemInstance + SystemInstanceT . BreakFlag
; SP := SystemInstance . SysSP ;
lhld SystemInstance + SystemInstanceT . SysSP
sphl ;
ei ; EnableInt ;
call ClrScrLCD ; ClrScrLCD ;
lxi h , ProgramBrokenMessage ; WriteTextLCD ( ProgramBrokenMessage ) ;
call WriteTextLCD ;
call NewLineLCD ; NewLineLCD ;
lxi h , PCPrompt ; WriteTextLCD ( PCPrompt ) ;
call WriteTextLCD ;
; HexCnvWordToStr ( SystemInstance . BreakPC ) ;
lhld SystemInstance + SystemInstanceT . BreakPC
xchg ;
call HexCnvWordToStr ;
; WriteTextLCD ( SystemInstance . Number ) ;
lxi h , SystemInstance + SystemInstanceT . Number
call WriteTextLCD ;
lxi h , SPPrompt ; WriteTextLCD ( SPPrompt ) ;
call WriteTextLCD ;
; HexCnvWordToStr ( SystemInstance . BreakSP ) ;
lhld SystemInstance + SystemInstanceT . BreakSP
xchg ;
call HexCnvWordToStr ;
; WriteTextLCD ( SystemInstance . Number ) ;
lxi h , SystemInstance + SystemInstanceT . Number
call WriteTextLCD ;
; call AnyKey ; AnyKey ;
; PushOnStack ( SystemInstance . SysContinueAdr ) ;
lhld SystemInstance + SystemInstanceT . SysContinueAdr
push h ;
ret ;end (* SysInt7Service *) ;Do obsługi RST 7 można trafić na dwa sposoby: wymuszone przez obsługę przerwań od czasu (wtedy podmieniona jest instrukcja) lub przez naturalne wykonanie instrukcji RST 7. W pierwszym przypadku (podmieniona instrukcja), następuje odtworzenie oryginalnej instrukcji, która tam była i przy ewentualnej kontynuacji programu adres powrotu jest „cofnięty” o jeden, by podmieniona instrukcja miała szanse się wykonać. W drugim przypadku adres powrotu jest „naturalny”. Z racji, że powyższą akcję należy traktować w kategoriach obsługi przerwania: wszystkie rejestry są zachowane i sterowanie wraca do programu nadzorującego. Ewentualna kontynuacja działania programu będzie wymagała pełnego odtworzenia rejestrów.
Program diagnostyczno/prezentacyjny inkrementuje liczba na diodach LED. By nie zachodziła „mgła” na LED’ach, to akcja jest znacząco zwolniona. Co któraś iteracja robi naturalne RST 7 w innych przypadkach można z klawiatury zażądać przerwania. Program jest następujący (jak widać jest zapętlony):
Kod: Zaznacz cały
.i8080
.include "\prace\i8080kit\i8080api.asm"
;
ResetEntry .equ 08000h ;
Stack_top .equ 0fffeh ;
;
LEDRegister .equ 0A8h ;
;*******************************************
.org ResetEntry ;
jmp Main ;
HelloText .defb "Hello, on LCD" , 0
;*******************************************
Pause ;procedure Pause ;
;begin (* Pause *)
push b ;
push psw ;
lxi b , 8000h ;
Pause1 ;
dcx b ;
mov a , b ;
ora c ;
jnz Pause1 ;
pop psw ;
pop b ;
ret ;end (* Pause *) ;
;*******************************************
Main ;begin (* main *)
lxi sp , Stack_top ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , WriteStringEC ; WriteString ( HelloText ) ;
lxi h , HelloText ;
rst ScreenControlEC ;
mvi b , NewLineEC ; NewLine ;
rst ScreenControlEC ;
mvi a , 1 ; LEDRegister := 1 ;
out LEDRegister ;
Main_0 ; repeat
out LEDRegister ; LEDRegister := a ;
call Pause ; Pause ;
inr a ; a := a + 1 ;
cpi 25h ;
jnz Main_0 ;
lxi b , 1234h ;
lxi d , 5678h ;
lxi h , 0abcdh ;
rst 7 ;
jmp Main_0 ; until false ;
;end (* main *).
;*******************************************
.endUruchomiony program sam wpada na instrukcję RST 7, na LED’ch jest liczba 24 hex (inkrementowana jest po wyświetleniu).
Ten wariant wynika z naturalnego wykonania instrukcji RST 7, co z drugiej strony potwierdza napis na LCD.
Adres powrotu 8047 hex wskazuje na następną instrukcję za RST 7, co można sprawdzić z wydrukiem z kompilacji:
Inny przypadek to żądanie przerwania programu (F4+F8), na diodach LED jest inna liczba niż „pułapkowa”.
Program został przerwany w innym miejscu:
Tym razem przerwanie trafiło w innym miejscu (adres 8016 hex). Można je zlokalizować na listingu:
Za każdym razem działanie programu może być kontynuowane (przycisk F5) lub zaniechane (przycisk F7).
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: Intel 8080 kit
Śledzenie wykonania programu
Często w trakcie tworzenia programu przydał by się podgląd stanu jego rejestrów. Skoro jest dosyć rozbudowane środowisko do uruchamiania programów, to dodanie takiej funkcjonalności nie stanowi większego problemu. W tym celu do istniejących ekstrakodów został dodany kolejny: RST 6. Teraz w programie wystarczy użyć instrukcji RST 6 (RST TraceControlEC), a program nadzorujący wyświetli na LCD stany wszystkich rejestrów (dokładniej wszystkie się nie mieszczą na ekranie LCD, gdyż użyłem dwuwierszowy po 24 znaki w wierszu, więc nie jest pokazany SP). Wyświetlany jest PC (by było wiadomo, z którego miejsca w programie pochodzą wyświetlone dane), rejestr akumulatora oraz flagi. W drugim wierszu pokazane są pary rejestrów HL, DE i BC. Program po wyświetleniu danych oczekuje na naciśnięcie przycisku (pozwoli to na zwłokę w programie, by przeanalizować/zanotować pokazana informacje na LCD). Po naciśnięciu wykonanie programu wraca do programu użytkowego (jeżeli nie jest to F7). Stan wszystkich rejestrów nie ulega zmianie, więc nie ma potrzeby zachowywania ich przed RST 6 i odtwarzanie po RST 6. Istnieje możliwość w tym kontekście zatrzymania programu poprzez naciśnięcie F7 (program jest usuwany).
Kod: Zaznacz cały
SysInt6Service ;procedure SysInt6Service ;
;begin (* SysInt6Service *)
; SystemInstance . TraceHL := HL ;
shld SystemInstance + SystemInstanceT . TraceHL
push psw ; SystemInstance . TracePSW := AF ;
pop h ;
shld SystemInstance + SystemInstanceT . TracePSW
push b ; SystemInstance . TraceBC := BC ;
pop h ;
shld SystemInstance + SystemInstanceT . TraceBC
push d ; SystemInstance . TraceDE := DE ;
pop h ;
shld SystemInstance + SystemInstanceT . TraceDE
lxi h , 0 ; SystemInstance . TraceSP := SP ;
dad sp ;
shld SystemInstance + SystemInstanceT . TraceSP
pop h ; SystemInstance . TracePC := PC ;
push h ;
shld SystemInstance + SystemInstanceT . TracePC
call ClrScrLCD ; ClrScrLCD ;
lxi h , TracePCPrompt ; WriteTextLCD ( TracePCPrompt ) ;
call WriteTextLCD ;
; HexCnvWordToStr ( SystemInstance . TracePC ) ;
lhld SystemInstance + SystemInstanceT . TracePC
xchg ;
call HexCnvWordToStr ;
; WriteTextLCD ( SystemInstance . Number ) ;
lxi h , SystemInstance + SystemInstanceT . Number
call WriteTextLCD ;
lxi h , TraceAPrompt ; WriteTextLCD ( TraceAPrompt ) ;
call WriteTextLCD ;
; HexCnvByteToStr ( SystemInstance . TracePSW.A ) ;
lhld SystemInstance + SystemInstanceT . TracePSW
mov a , h ;
call HexCnvByteToStr ;
; WriteTextLCD ( SystemInstance . Number ) ;
lxi h , SystemInstance + SystemInstanceT . Number
call WriteTextLCD ;
lxi h , TraceFPrompt ; WriteTextLCD ( TraceFPrompt ) ;
call WriteTextLCD ;
; if SystemInstance . TracePSW.F.S then
lhld SystemInstance + SystemInstanceT . TracePSW
mov a , l ;
ani 80h ;
jz SysInt6Srv_0 ;
mvi a , 'S' ; WriteChLCD ( 'S' ) ;
call WriteChLCD ;
SysInt6Srv_0 ;
; if SystemInstance . TracePSW.F.Z then
lhld SystemInstance + SystemInstanceT . TracePSW
mov a , l ;
ani 40h ;
jz SysInt6Srv_1 ;
mvi a , 'Z' ; WriteChLCD ( 'Z' ) ;
call WriteChLCD ;
SysInt6Srv_1 ;
; if SystemInstance . TracePSW.F.AC then
lhld SystemInstance + SystemInstanceT . TracePSW
mov a , l ;
ani 10h ;
jz SysInt6Srv_2 ;
mvi a , 'A' ; WriteChLCD ( 'A' ) ;
call WriteChLCD ;
mvi a , 'c' ; WriteChLCD ( 'c' ) ;
call WriteChLCD ;
SysInt6Srv_2 ;
; if SystemInstance . TracePSW.F.P then
lhld SystemInstance + SystemInstanceT . TracePSW
mov a , l ;
ani 04h ;
jz SysInt6Srv_3 ;
mvi a , 'P' ; WriteChLCD ( 'P' ) ;
call WriteChLCD ;
SysInt6Srv_3 ;
; if SystemInstance . TracePSW.F.C then
lhld SystemInstance + SystemInstanceT . TracePSW
mov a , l ;
ani 01h ;
jz SysInt6Srv_4 ;
mvi a , 'C' ; WriteChLCD ( 'C' ) ;
call WriteChLCD ;
SysInt6Srv_4 ;
call NewLineLCD ; NewLineLCD ;
lxi h , TraceHLPrompt ; WriteTextLCD ( TraceHLPrompt ) ;
call WriteTextLCD ;
; HexCnvWordToStr ( SystemInstance . TraceHL ) ;
lhld SystemInstance + SystemInstanceT . TraceHL
xchg ;
call HexCnvWordToStr ;
; WriteTextLCD ( SystemInstance . Number ) ;
lxi h , SystemInstance + SystemInstanceT . Number
call WriteTextLCD ;
lxi h , TraceDEPrompt ; WriteTextLCD ( TraceDEPrompt ) ;
call WriteTextLCD ;
; HexCnvWordToStr ( SystemInstance . TraceDE ) ;
lhld SystemInstance + SystemInstanceT . TraceDE
xchg ;
call HexCnvWordToStr ;
; WriteTextLCD ( SystemInstance . Number ) ;
lxi h , SystemInstance + SystemInstanceT . Number
call WriteTextLCD ;
lxi h , TraceBCPrompt ; WriteTextLCD ( TraceBCPrompt ) ;
call WriteTextLCD ;
; HexCnvWordToStr ( SystemInstance . TraceBC ) ;
lhld SystemInstance + SystemInstanceT . TraceBC
xchg ;
call HexCnvWordToStr ;
; WriteTextLCD ( SystemInstance . Number ) ;
lxi h , SystemInstance + SystemInstanceT . Number
call WriteTextLCD ;
call AnyKey ; AnyKey ;
call ReadKey ; if ReadKey = F7Ch then
cpi F7Ch ;
jnz SysInt6Srv_5 ; begin
call ClrScrLCD ; ClrScrLCD ;
lxi h , ProgramTerminated ; WriteTextLCD ( ProgramTerminated ) ;
call WriteTextLCD ;
mvi a , 0 ; SystemInstance . LoadedStatus := false ;
sta SystemInstance + SystemInstanceT . LoadedStatus
; SystemInstance . BreakFlag := false ;
sta SystemInstance + SystemInstanceT . BreakFlag
; SP := SystemInstance . SysSP ;
lhld SystemInstance + SystemInstanceT . SysSP
sphl ;
; PushOnStack ( SystemInstance . SysContinueAdr ) ;
lhld SystemInstance + SystemInstanceT . SysContinueAdr
push h ;
ret ; exit -> to supervisor
SysInt6Srv_5 ; end ;
; PushOnStack ( SystemInstance . TracePSW ) ;
lhld SystemInstance + SystemInstanceT . TracePSW
push h ;
; PushOnStack ( SystemInstance . TraceBC ) ;
lhld SystemInstance + SystemInstanceT . TraceBC
push h ;
; PushOnStack ( SystemInstance . TraceDE ) ;
lhld SystemInstance + SystemInstanceT . TraceDE
push h ;
lhld SystemInstance + SystemInstanceT . TraceHL
pop d ;
pop b ;
pop psw ;
ret ;end (* SysInt6Service *) ;Program testowo/prezentacyjny jest następujący:
Kod: Zaznacz cały
.i8080
.include "\prace\i8080kit\i8080api.asm"
;
ResetEntry .equ 08000h ;
Stack_top .equ 0fffeh ;
;
LEDRegister .equ 0A8h ;
;*******************************************
.org ResetEntry ;
jmp Main ;
HelloText .defb "Hello, on LCD" , 0
;*******************************************
Pause ;procedure Pause ;
;begin (* Pause *)
push b ;
push psw ;
lxi b , 8000h ;
Pause1 ;
dcx b ;
mov a , b ;
ora c ;
jnz Pause1 ;
pop psw ;
pop b ;
ret ;end (* Pause *) ;
;*******************************************
Main ;begin (* main *)
lxi sp , Stack_top ;
mvi b , ClrScrEC ; ScrScrLCD ;
rst ScreenControlEC ;
mvi b , WriteStringEC ; WriteString ( HelloText ) ;
lxi h , HelloText ;
rst ScreenControlEC ;
call Pause ; Pause ;
call Pause ; Pause ;
call Pause ; Pause ;
call Pause ; Pause ;
mvi a , 5Ah ;
scf ;
lxi b , 1234h ;
lxi d , 5678h ;
lxi h , 0abcdh ;
Main_0 ; repeat
sui 58h ;
rst TraceControlEC ; trace registers ;
inr a ;
inx b ;
inx d ;
inx h ;
jmp Main_0 ; until false ;
;end (* main *).
;*******************************************
.endKilka kolejnych zrzutów ekranu:
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: Intel 8080 kit
Dwa w jednym...
… a może być więcej. Ale zanim, to trochę o uruchamianiu załadowanego programu (przycisk F5/GO). W tym poleceniu dodałem możliwość modyfikacji adresu punktu wejścia dla pierwszego uruchomieniu programu.
Po załadowaniu programu do RAM, przed jego uruchomieniem istnieje możliwość zmiany jego adresu (w tym wypadku program nadzorujący pokazuje 8000 hex). Wstępnie proponowany jest standardowy (wynikający z pliku intel-hex) punkt uruchomienia programu, który można edytować.
Dostępne są przyciski Backspace (do kasowania znaku przed kursorem), Enter (do akceptacji wprowadzonej liczby), ESC (do zaniechania modyfikacji z jednoczesnym zrezygnowaniem z uruchomienia programu, który nadal rezyduje w RAM) oraz wszystkie przyciski cyfr szesnastkowych. Po akceptacji weryfikowana jest wprowadzona liczba (musi być z przedziału 8000 hex … FFFF hex). Uruchomienie (od adresu 8000 hex) program ma funkcjonalność „maszyny do pisania” z wykorzystaniem klawiatury i ekranu LCD.
Każdy naciśnięty znak jest przedrukowany na ekran. Użycie ESC kończy działanie programu.
Uruchomienie od innego miejsca realizuje dokładnie tą samą funkcjonalność (maszyny do pisania), z tym, że akcja dotyczy kanału UART.
Tym razem cała komunikacja jest przekierowana na UART, nawet operacja ClearScreen nie zadziałała (na LCD pozostał komunikat wygenerowany przez program nadzorcy).
Wszystko, co zostaje wysłanie do programu via UART wraca do źródła.
Program kończy pracę na ESC.
Można to interpretować, że program załadowany do pamięci ma dwie różne funkcje main. Pierwsza ma punkt wejścia na adresie 8000 hex, druga na adresie 8003 hex.
Kod: Zaznacz cały
.i8080
.include "\prace\i8080kit\i8080api.asm"
;
ResetEntry .equ 08000h ;
Stack_top .equ 0fffeh ;
LEDRegister .equ 0A8h ;
;
.org ResetEntry ;
jmp Main1 ;
jmp Main2 ;
;
ClearScrSrv .word
WriteStrSrv .word
WriteChSrv .word
NewLineSrv .word
DataPresentSrv .word
ReadDataSrv .word
;
HelloText .defb "Hello, on LCD/serial" , 0
;*****************************************
Main1 ;
lxi h , ClearScrrenSrv ; ClearScrSrv := ClearScrrenSrv ;
shld ClearScrSrv ;
lxi h , WriteToLCDService ; WriteStrSrv := WriteToLCDService ;
shld WriteStrSrv ;
lxi h , WriteChToLCDService ; WriteStrSrv := WriteChToLCDService ;
shld WriteChSrv ;
lxi h , NewLineOnLCDService ; NewLineSrv := NewLineOnLCDService ;
shld NewLineSrv ;
lxi h , KeyPressedService ; DataPresentSrv := KeyPressedService ;
shld DataPresentSrv ;
lxi h , ReadKeyService ; ReadDataSrv := ReadKeyServcie ;
shld ReadDataSrv ;
jmp Main ;
;*****************************************
Main2 ;
lxi h , NoActionSrv ; ClearScrSrv := NoActionSrv ;
shld ClearScrSrv ;
lxi h , WriteToUARTService ; WriteStrSrv := WriteToUARTService ;
shld WriteStrSrv ;
lxi h , WriteChToUARTService ; WriteStrSrv := WriteChToUARTService ;
shld WriteChSrv ;
lxi h , NewLineOnUARTService ; NewLineSrv := NewLineOnUARTService ;
shld NewLineSrv ;
lxi h , UARTDataPresentService; DataPresentSrv := UARTDataPresentService ;
shld DataPresentSrv ;
lxi h , UARTReadDataService ; ReadDataSrv := UARTReadDataService ;
shld ReadDataSrv ;
jmp Main ;
;*****************************************
CallHLService ;
pchl ;
;*****************************************
ClearScrrenSrv ;procedure ClearScrrenSrv ;
;begin (* ClearScrrenSrv *)
mvi b , ClrScrEC ; ClrScrLCD ;
rst ScreenControlEC ;
ret ;end (* ClearScrrenSrv *) ;
;*****************************************
WriteToLCDService ;procedure WriteToLCDService(Str[DE]:string);
;begin (* WriteToLCDService *)
mvi b , WriteStringEC ; WriteString ( Str ) ;
xchg ;
rst ScreenControlEC ;
ret ;end (* WriteToLCDService *) ;
;*****************************************
WriteChToLCDService ;procedure WriteChToLCDService (Ch[A]:byte);
;begin (* WriteChToLCDService *)
mov c , a ; WriteChLCD ( Ch ) ;
mvi b , WriteChEC ;
rst ScreenControlEC ;
ret ;end (* WriteChToLCDService *) ;
;*****************************************
NewLineOnLCDService ;procedure NewLineOnLCDService ;
;begin (* NewLineOnLCDService *)
mvi b , NewLineEC ; NewLine ;
rst ScreenControlEC ;
ret ;end (* NewLineOnLCDService *) ;
;*****************************************
KeyPressedService ;function KeyPressedService : byte[A] ;
;begin (* KeyPressedService *)
mvi b , KeyPressedEC ; KeyPressedService := KeyPressed ;
rst KeybControlEC ;
mov a , c ;
ret ;end (* KeyPressedService *) ;
;*****************************************
ReadKeyService ;function ReadKeyService : byte[A] ;
;begin (* ReadKeyService *)
mvi b , GetKeyEC ; Tmp := ReadKey ;
rst KeybControlEC ;
mov a , c ; if Tmp = F8Ch then
cpi F8Ch ;
rnz ; ReadKeyService := Tmp ;
mvi a , 1Bh ; ReadKeyService := 1Bh ;
ret ;end (* ReadKeyService *) ;
;*****************************************
NoActionSrv ;procedure NoActionSrv ;
;begin (* NoActionSrv *)
ret ;end (* NoActionSrv *) ;
;*****************************************
WriteToUARTService ;procedure WriteToUARTService ( Str[DE] : string ) ;
;begin (* WriteToUARTService *)
mvi b , SendSerialStringEC ; SendSerialString ( Str ) ;
xchg ;
rst UARTControlEC ;
ret ;end (* WriteToUARTService *) ;
;*****************************************
WriteChToUARTService ;procedure WriteChToUARTService ( Ch[A] : byte ) ;
;begin (* WriteChToUARTService *)
mvi b , SentSerialCharEC ; SentSerial ( Ch ) ;
mov c , a ;
rst UARTControlEC ;
ret ;end (* WriteChToUARTService *) ;
;*****************************************
NewLineOnUARTService ;procedure NewLineOnUARTService ;
;begin (* NewLineOnUARTService *)
mvi b , SentSerialCharEC ; SentSerial ( 0Dh ) ;
mvi c , 0Dh ;
rst UARTControlEC ;
mvi b , SentSerialCharEC ; SentSerial ( 0Ah ) ;
mvi c , 0Ah ;
rst UARTControlEC ;
ret ;end (* NewLineOnUARTService *) ;
;*****************************************
UARTDataPresentService ;function UARTDataPresentService : byte[A] ;
;begin (* UARTDataPresentService *)
mvi b , SerialDataPresentEC ; UARTDataPresentService := SerialDataPresent ;
rst UARTControlEC ;
mov a , c ;
ret ;end (* UARTDataPresentService *) ;
;*****************************************
UARTReadDataService ;function UARTReadDataService : byte[A] ;
;begin (* UARTReadDataService *)
mvi b , GetSerialDataEC ; UARTReadDataService := GetSerial ;
rst UARTControlEC ;
mov a , c ;
ret ;end (* UARTReadDataService *) ;
;*****************************************
Main ;begin (* main *)
lxi sp , Stack_top ;
lhld ClearScrSrv ; ClearScrSrv ;
call CallHLService ;
lxi d , HelloText ; WriteStrSrv ( HelloText ) ;
lhld WriteStrSrv ;
call CallHLService ;
lhld NewLineSrv ; NewLineSrv ;
call CallHLService ;
Main_0 ; repeat
lhld DataPresentSrv ; if DataPresentSrv then
call CallHLService ;
ora a ;
jz Main_0 ; begin
lhld ReadDataSrv ; Ch := ReadDataSrv ;
call CallHLService ;
cpi 1Bh ; if Ch = 1Bh then
jnz Main_1 ;
mvi b , ExitProgramEC ; ProgramTerminate ;
mvi c , 3ch ;
rst ExitProgramEC ;
Main_1 ;
lhld WriteChSrv ; WriteChSrv ( Ch ) ;
call CallHLService ;
jmp Main_0 ; until false ;
;end (* main *).
;*****************************************
.endW programie odwołania do programu nadzorującego są skonstruowane jako wskaźniki do funkcji, które są inicjowane w odmienny sposób w zależności do punktu wejścia (przy main1 → LCD, przy main2 → UART). W programie głównym wykorzystywane są odpowiednie wskaźniki do funkcji. Ot taka to ciekawostka.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Kto jest online
Użytkownicy przeglądający to forum: Obecnie na forum nie ma żadnego zarejestrowanego użytkownika i 4 gości


