;########################################################################################
A1
;****************************************************************************************
A1.1. Napisz program, który po każdym naciśnięciu przycisku SW7 jednokrotnie zmieni stan
świecenia diody LED 4 na przeciwny. Puszczenie przycisku ma nie zmieniać stanu świecenia
diody. Załóż, że przed uruchomieniem programu zawartość portu sterującego diodami może być
dowolna. Wskazówka: wykorzystaj instrukcje JB i JNB do badania stanu przycisku.
Instrukcje, które należy wykorzystać: JB, JNB, CPL bit, JMP.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit.

JB P1.4, sw7_off         ;zapewnia zgaszoną diodę
CPL P1.4                 ;na start programu

sw7_off:                        
JB P2.7, sw7_off        ;czeka na sw7
CPL P1.4                ;zmienia stan po sw7

sw7_on:
JNB P2.7, sw7_on        ;czeka az zwolnisz sw7
JB P2.7, sw7_off        ;wraca do czekania na nacisniecie

;****************************************************************************************
A1.2. Napisz podprogram SW2LED, który wyświetla aktualny stan przycisków SW0, SW2, SW4,
SW6 na diodach LED 1, LED 3, LED 5, LED 7. Wciśniętemu przyciskowi ma odpowiadać
zapalona dioda. Program ma nie wpływać na stan diod LED 0, LED 2, LED 4, LED 6. Napisz
prosty program główny, który na początku zgasi diody LED 0 i LED 4 oraz zapali diody LED 2,
LED 6 a następnie jego jedynym zadaniem będzie cyklicznie wywoływanie stworzonego
podprogramu SW2LED.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

start:
MOV P1, #10111011b

petla:
LCALL SW2LED
JMP petla

SW2LED:        ;podprogram
MOV A, P2
RL A
ANL A, #10101010b
MOV R1, A ;zapamietaj A w R1

MOV A, P1 ;stan diod P1 do A
ANL A, #01010101b ;filtrowanie diod 0246
ORL A, R1 ;polaczenie stanu SW i diod 0246

MOV P1, A

RET

;****************************************************************************************
A1.3. Napisz podprogram BLKFILL wypełniający podaną wartością zadaną liczbę komórek we
wskazanym obszarze pamięci. Załóż, że przed wywołaniem podprogramu adres obszaru
pamięci , który ma być wypełniony został wpisany do rejestru R0 a liczba wypełnianych
komórek pamięci została wpisana do rejestru R1 banku rejestrów nr 3. Wartość, którą należy
wypełnić komórki z zadanego obszaru pamięci ma być przekazywana do podprogramu za
pośrednictwem akumulatora. Wskazówka: wykorzystaj tryb adresowania pośredniego bazujący
na rejestrze R0. Napisz krótki program główny, który wykorzysta podprogram BLKFILL do
wypełnienia ośmiu kolejnych komórek z obszaru pamięci danych 00H-07H wartością 066H a
ośmiu kolejnych komórek z obszaru pamięci danych 10H-17H wartością 099H.
Uwaga ! Na początku programu zmień wartość wskaźnika stosu na 02FH.

LJMP 100h ;skacze pod 100h i startuje
ORG 100h ;umieszcze program od 100h
MOV SP, #02Fh ;ustawia wskaznik stosu zgodnie z zadaniem

start:
CLR RS0
CLR RS1
MOV R0, #00h
SETB RS0
SETB RS1
MOV R1, #8
MOV A, #066h

LCALL BLKFILL

JMP start

BLKFILL:
MOV @R0, A

RET

;########################################################################################

A2
;****************************************************************************************
A2.1. Napisz program, który nieustannie wyświetla na diodach LED 0-LED 7 aktualny stan
przycisków SW0-SW7. Wciśniętemu przyciskowi ma odpowiadać zgaszona dioda.
Instrukcje, które należy wykorzystać: MOV, XRL | CPL, JMP.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

start:
MOV A, P2
CPL A
MOV P1, A

JMP start

;****************************************************************************************
A2.2. Napisz program, który po każdorazowym naciśnięciu przycisku SW7 będzie zapalał diodę LED
nr (i-1 mod 8) gasząc przy tym diodę nr (i mod 8). Puszczenie przycisku ma nie zmieniać stanu
świecenia diod. Badanie stanu przycisku SW7 ma odbywać się w programie głównym natomiast
instrukcje zmieniające stan świecenia diod mają być umieszczone w podprogramie LEDCTRL
wywoływanym z programu głównego.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit.

MOV P1, #01111111b ; tutaj mozna zaprogramowac swiecenie

start:
JB P2.7, start
LCALL LEDCTRL

petla:
JNB P2.7, petla

JMP start

LEDCTRL:
MOV A, P1
RR A ;tu ustawiamy kierunkek zaplania/gaszenia
MOV P1, A

RET

;****************************************************************************************
A2.3. Napisz podprogram BLKCMP porównujący zadaną liczbę komórek pamięci w dwóch
wskazanych obszarach pamięci. Załóż, że przed wywołaniem podprogramu adresy obu obszarów
pamięci zostały wpisane odpowiednio do rejestrów R0 i R1 banku rejestrów nr 2. Liczba
porównywanych komórek ma być przekazywana do podprogramu za pośrednictwem
akumulatora. Wskazówka: wykorzystaj tryb adresowania pośredniego bazujący na rejestrach R0
i R1. W przypadku gdy oba wskazane obszary pamięci są identyczne, podprogram ma zwrócić
wartość 0 w akumulatorze oraz wartość 0FFH gdy napotkano różnicę. Napisz krótki program
główny, który wykorzysta podprogram BLKCMP do porównania zawartości ośmiu kolejnych
komórek z obszaru pamięci danych 08H-0FH z zawartością kolejnych komórek położonych
w obszarze pamięci danych 00H-07H. W przypadku gdy oba wskazane obszary pamięci są
identyczne program ma zapalić diodę LED 4.
Uwaga ! Na początku programu zmień wartość wskaźnika stosu na 02FH.

BRAK

;########################################################################################

B1
;****************************************************************************************
B1.1. Napisz program, który nieustannie wyświetla na diodach LED i o numerach parzystych (tj. na
diodach LED 0, LED 2, LED 4, LED 6) stan przycisków SWi o numerach nieparzystych
(tj. przycisków SW1, SW3, SW5, SW7). Wciśniętemu przyciskowi ma odpowiadać zapalona
dioda. Pozostałe diody (tj. diody LED 1, LED 3, LED 5, LED 7) mają być zawsze zapalone.
Instrukcje, które należy wykorzystać: MOV, RR, ANL, JMP.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

start:
MOV A, P2	;port do ACC
RR A	;ACC 1 bit w prawo
ANL A, #01010101b ;ACC and maska
MOV P1, A ;stan w ACC na P1 - sterowanie diodami

JMP start

;****************************************************************************************
B1.2. Napisz program, który po każdorazowym naciśnięciu przycisku SW4 będzie zapalał kolejne
diody LED w kolejności LED 7, LED 6,..., LED 1, LED 0. W sytuacji, gdy wszystkie diody są
już zapalone kolejne naciśnięcie przycisku ma spowodować wygaszenie wszystkich diod LED.
Dalsze naciskanie przycisku SW4 ma powodować działanie takie, jak opisano powyżej.
Puszczenie przycisku SW4 ma nie zmieniać stanu świecenia diod. Badanie stanu przycisku SW4
ma odbywać się w programie głównym natomiast instrukcje zmieniające stan świecenia diod
mają być umieszczone w podprogramie LEDCTRL wywoływanym z programu głównego.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit.

MOV P1, #11111111b ;diody off
MOV R1, #10000000b ;wskaznik do zapalania

start:
JB P2.4, start
LCALL LEDCTRL

petla:
JNB P2.4, petla

JMP start

LEDCTRL:
MOV A, P1 
SUBB A, R1 ;A=A-R1 - zapalam diode
MOV P1, A
MOV A, R1 ;R1 do zeby przesunac
RRC A ;koniecznie przez CARRY!
MOV R1, A ;i zapamietuje do R1
RET


;****************************************************************************************
B1.3. Napisz podprogram BLKCPY kopiujący zadaną liczbę komórek pamięci z jednego wskazanego
obszaru pamięci do drugiego wskazanego obszaru pamięci. Załóż, że przed wywołaniem
podprogramu adresy źródłowego i docelowego obszaru pamięci zostają wpisane odpowiednio do
rejestrów R0 i R1 banku rejestrów nr 3. Liczba kopiowanych komórek ma być przekazywana do
podprogramu za pośrednictwem akumulatora. Wskazówka: wykorzystaj tryb adresowania
pośredniego bazujący na rejestrach R0 i R1. Napisz krótki program główny, który wykorzysta
podprogram BLKCPY do skopiowania ośmiu kolejnych komórek z obszaru pamięci danych
08H-0FH do ośmiu kolejnych komórek położonych w obszarze pamięci danych 00H-07H.
Uwaga ! Na początku programu zmień wartość wskaźnika stosu na 02FH.

BRAK

;########################################################################################


B2
;****************************************************************************************
B2.1. Napisz program, który po każdym naciśnięciu przycisku SW0 jednokrotnie zmieni stan
świecenia diod LED 0-LED 7 na przeciwny. Puszczenie przycisku ma nie zmieniać stanu
świecenia diod. Załóż, że przed uruchomieniem programu zawartość portu sterującego diodami
może być dowolna. Wskazówka: wykorzystaj instrukcje JB i JNB do badania stanu przycisku.
Instrukcje, które należy wykorzystać: JB, JNB, CPL, JMP, MOV.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit. CPL bit.

sw7_off:			
JB P2.0, sw7_off	;czeka na sw0
MOV A, P1	;musi bo CPL tylko na ACC
CPL A		;zmienia stan po sw0
MOV P1, A

sw7_on:
JNB P2.0, sw7_on  ;czeka az zwolnisz sw0
JB P2.0, sw7_off  ;wraca do czekania na nacisniecie


;****************************************************************************************
B2.2. Napisz podprogram SW2LED, który wyświetla aktualny stan przycisków SW0-SW3 na diodach
LED 4-LED 7. Wciśniętemu przyciskowi ma odpowiadać zapalona dioda. Podprogram ma nie
wpływać na stan diod LED 0-LED 3. Napisz prosty program główny, który na początku zapali
diody LED 0-LED 3 a następnie jego jedynym zadaniem będzie cyklicznie wywoływanie
stworzonego podprogramu SW2LED.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

MOV P1, #11110000b

petla:
LCALL SW2LED
JMP petla

SW2LED:
MOV A, P1 ;zapamietaj stany diod
ANL A, #00001111b ;
MOV R1, A ;tymczasowo
MOV A, P2
SWAP A
ANL A, #11110000b
ORL A, R1
MOV P1, A

RET


;****************************************************************************************
B2.3. Napisz program realizujący funkcję licznika dziesiętnego liczącego w dół (tj. liczącego 9, 8, ...,
1, 0, 9, 8,... itd.), który jest wyzwalany przyciskiem SW7. Kolejne naciśnięcia przycisku SW7
mają powodować jednokrotną zmianę stanu licznika. Puszczenie przycisku ma nie zmieniać
stanu licznika. Aktualny stan licznika ma być wyświetlany na wyświetlaczu 7-segmentowym
LED. Kody sterujące wyświetlaczem 7-segmentowym odpowiadające poszczególnym cyfrom
heksadecymalnym podano w dostarczonym pliku "Kody_LED7S.txt".

BRAK

;########################################################################################

C1
;****************************************************************************************
C1.1. Napisz program, który nieustannie wyświetla na diodach LED 0, LED 1, LED 2, LED 3 stan
przycisków SW0, SW1, SW2, SW3. Wciśniętemu przyciskowi ma odpowiadać zgaszona dioda.
Pozostałe diody (tj. diody LED 4, LED 5, LED 6, LED 7) mają być zawsze zapalone. Instrukcje,
które należy wykorzystać: MOV, ANL, CPL | XRL, JMP.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

start:
MOV A, P2	;port do ACC
CPL A	;neguje czyli mam stan na diodach
ANL A, #00001111b ;maska ze 4 sie swieca

MOV P1, A ;stan w ACC na P1 - sterowanie diodami

JMP start


;****************************************************************************************
C1.2. Napisz program, który wyświetli na wyświetlaczu 7-segmentowym LED nr 3 (ten najbardziej z
lewej) liczbę aktualnie naciśniętych przycisków SW. Kody sterujące wyświetlaczem
7-segmentowym odpowiadające poszczególnym cyfrom heksadecymalnym podano w
dostarczonym pliku "Kody_LED7S.txt".
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

MOV P3, #0FFh ;ustawienie DISPLAY 3

start:
MOV R1, #8 ;licznik petli SW
MOV R2, #0 ;ilosc wcisnietych SW
MOV A, P2 ;stan SW do ACC
liczenie:
RLC A
JNC guzik_on
powrot1:
DJNZ R1, liczenie

MOV A, R2
LCALL GET_CODE_7SEG
MOV P1, A
JMP start


;podprogramy
guzik_on:
INC R2
JMP powrot1

GET_CODE_7SEG:
ANL A, #0FH
INC A
MOVC A, @A+PC
RET

DB 0C0H ; 0
DB 0F9H ; 1
DB 0A4H ; 2
DB 0B0H ; 3
DB 099H ; 4
DB 092H ; 5
DB 082H ; 6
DB 0F8H ; 7
DB 080H ; 8
DB 090H ; 9
DB 088H ; A
DB 083H ; B
DB 0C6H ; C
DB 0A1H ; D
DB 086H ; E
DB 08EH ; F




;****************************************************************************************
C1.3. Napisz program realizujący funkcję 4-bitowego licznika liczącego mod 11 w górę (tj. liczącego
0, 1, 2, ..., 8, 9, 10, 0,1, 2,... itd.), który jest wyzwalany przyciskiem SW0. Kolejne naciśnięcia
przycisku SW0 mają powodować zmianę stanu licznika. Aktualny stan licznika ma być
wyświetlany w kodzie heksadecymalnym na wyświetlaczu 7-segmentowym LED. Kody
sterujące wyświetlaczem 7-segmentowym odpowiadające poszczególnym cyfrom
heksadecymalnym podano w dostarczonym pliku "Kody_LED7S.txt".

BRAK

;########################################################################################


C2
;****************************************************************************************
C2.1. Napisz program, który nieustannie wyświetla na diodach LED i o numerach parzystych (tj. na
diodach LED 0, LED 2, LED 4, LED 6) stan przycisków SWi o numerach parzystych
(tj. przycisków SW0, SW2, SW4, SW6). Wciśniętemu przyciskowi ma odpowiadać zgaszona
dioda. Pozostałe diody (tj. diody LED 1, LED 3, LED 5, LED 7) mają być zawsze zapalone.
Instrukcje, które należy wykorzystać: MOV, ANL, CPL | XRL, JMP.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

start:
MOV A, P2	;port do ACC
CPL A	;neguje czyli mam stan na diodach
ANL A, #b ;maska ze 4 sie swieca

MOV P1, A ;stan w ACC na P1 - sterowanie diodami

JMP start



;****************************************************************************************
C2.2. Napisz podprogram SW2LED, który wyświetla aktualny stan przycisków SW1, SW3, SW5,
SW7 na diodach LED 0, LED 2, LED 4, LED 6. Wciśniętemu przyciskowi ma odpowiadać
zgaszona dioda. Program ma nie wpływać na stan diod LED 1, LED 3, LED 5, LED 7. Napisz
prosty program główny, który na początku zapali diody LED 1, LED 3, LED 5, LED 7 a
następnie jego jedynym zadaniem będzie cyklicznie wywoływanie stworzonego podprogramu
SW2LED.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

start:
MOV P1, #01010101b

petla:
LCALL SW2LED
JMP petla

SW2LED:	;podprogram
MOV A, P2
CPL A
RR A
ANL A, #01010101b ;po masce pamieta stan 0246
MOV R1, A ;zapamietaj A w R1

MOV A, P1 ;stan diod P1 do A
ANL A, #10101010b ;filtrowanie diod 0246
ORL A, R1 ;polaczenie stanu SW i diod 0246

MOV P1, A

RET



;****************************************************************************************
C2.3. Napisz podprogram BLKCAS, którego działanie ma zależeć od stanu flagi F0 w słowie PSW.
Jeżeli flaga F0 w słowie stanu PSW ma wartość 0 to podprogram ma zerować zadaną liczbę
komórek we wskazanym obszarze pamięci. Załóż, że przed wywołaniem podprogramu adres
obszaru pamięci, który ma być wyzerowany został wpisany do rejestru R0 banku rejestrów nr 1.
Liczba zerowanych komórek pamięci ma być przekazywana do podprogramu za pośrednictwem
akumulatora. Jeżeli flaga F0 w słowie stanu PSW ma wartość 1 to podprogram ma wypełnić
zadaną liczbę komórek we wskazanym obszarze pamięci kolejnymi liczbami rozpoczynając od
wartości 0. Załóż, że przed wywołaniem podprogramu adres obszaru pamięci, który ma być
wypełniony został wpisany do rejestru R0 banku rejestrów nr 1. Liczba wypełnianych komórek
pamięci ma być przekazywana do podprogramu za pośrednictwem akumulatora. Wskazówka:
wykorzystaj tryb adresowania pośredniego bazujący na rejestrze R0.
Uwaga ! Na początku programu zmień wartość wskaźnika stosu na 02FH.

BRAK

;########################################################################################


D1
;****************************************************************************************
D1.1. Napisz program, który nieustannie wyświetla na diodach LED 0, LED 1, LED 2, LED 3 stan
przycisków SW4, SW5, SW6, SW7. Program ma jednocześnie nieustannie wyświetlać na
diodach LED 4, LED 5, LED 6, LED 7 stan przycisków SW0, SW1, SW2, SW3. Wciśniętemu
przyciskowi ma odpowiadać zapalona dioda.
Instrukcje, które należy wykorzystać: MOV, SWAP, JMP.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

start:
MOV A, P2	;port do ACC
SWAP A	;neguje czyli mam stan na diodach

MOV P1, A ;stan w ACC na P1 - sterowanie diodami

JMP start



;****************************************************************************************
D1.2. Napisz podprogram SW2LED, który nieustannie wyświetla aktualny stan przycisków SW4-SW7
na diodach LED 0-LED 3. Wciśniętemu przyciskowi ma odpowiadać zgaszona dioda.
Podprogram ma nie wpływać na stan diod LED 4-LED 7. Napisz prosty program główny, który
na początku zgasi diody LED 4-LED 7 a następnie jego jedynym zadaniem będzie cyklicznie
wywoływanie stworzonego podprogramu SW2LED.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

MOV P1, #11110000b

petla:
LCALL SW2LED
JMP petla

SW2LED:
MOV A, P1 ;zapamietaj stany diod
ANL A, #11110000b ;maska do tego
MOV R1, A ;tymczasowo
MOV A, P2
SWAP A
ANL A, #00001111b
ORL A, R1
MOV P1, A

RET



;****************************************************************************************
D1.3. Napisz program realizujący funkcję 4-bitowego licznika binarnego liczącego w dół i w górę,
który jest wyzwalany przyciskami SW0 i SW7. Kolejne naciśnięcia przycisku SW0 mają
powodować zwiększanie stanu licznika natomiast kolejne naciśnięcia przycisku SW7 mają
powodować zmniejszanie stanu licznika. Ponadto, gdy przycisk SW0 jest wciśnięty, to program
ma ignorować naciśnięcia przycisku SW7. Podobnie, gdy przycisk SW7 jest wciśnięty, to
program ma ignorować naciśnięcia przycisku SW0. Puszczenie przycisku SW0 i/lub SW7 nie
ma powodować zmiany stanu licznika. Aktualny stan licznika ma być wyświetlany na
wyświetlaczu 7-segmentowym LED. Kody sterujące wyświetlaczem 7-segmentowym
odpowiadające poszczególnym cyfrom heksadecymalnym podano w dostarczonym pliku
"Kody_LED7S.txt".

BRAK


;########################################################################################


D2
;****************************************************************************************
D2.1. Napisz program, który nieustannie wyświetla na diodach LED i o numerach nieparzystych (tj. na
diodach LED 1, LED 3, LED 5, LED 7) stan przycisków SWi o numerach nieparzystych
(tj. przycisków SW1, SW3, SW5, SW7). Wciśniętemu przyciskowi ma odpowiadać zapalona
dioda. Pozostałe diody (tj. diody LED 0, LED 2, LED 4, LED 6) mają być zawsze zgaszone.
Instrukcje, które należy wykorzystać: MOV, ORL, JMP.
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

start:
MOV A, P2	;port do ACC
ORL A, #01010101b ;odpowiednia maska
MOV P1, A ;stan w ACC na P1 - sterowanie diodami

JMP start




;****************************************************************************************
D2.2. Napisz program, który nieustannie wyświetla na wyświetlaczu 7-segmentowym LED nr 3 (ten
najbardziej z lewej) numer naciśniętego przycisku SW. Załóż, że w danej chwili może być
wciśnięty tylko jeden przycisk. Kody sterujące wyświetlaczem 7-segmentowym odpowiadające
poszczególnym cyfrom heksadecymalnym podano w dostarczonym pliku "Kody_LED7S.txt".
Instrukcje, których nie należy wykorzystywać: SETB bit, CLR bit, CPL bit, JB, JNB.

MOV P3, #0FFh ;ustawienie DISPLAY 3

start:
MOV R2, #0 ;numer wcisnietego SW
MOV A, P2 ;stan SW do ACC
liczenie:
RRC A
INC R2
JC liczenie

DEC R2
MOV A, R2
LCALL GET_CODE_7SEG
MOV P1, A
JMP start


;podprogramy

GET_CODE_7SEG:
ANL A, #0FH
INC A
MOVC A, @A+PC
RET

DB 0C0H ; 0
DB 0F9H ; 1
DB 0A4H ; 2
DB 0B0H ; 3
DB 099H ; 4
DB 092H ; 5
DB 082H ; 6
DB 0F8H ; 7
DB 0FFH ; nic nie swieci/wcisniete



;****************************************************************************************
D2.3. Napisz program realizujący funkcję 4-bitowego licznika binarnego liczącego w dół i w górę,
który jest wyzwalany przyciskiem SW7. Kolejne naciśnięcia przycisku SW7 mają powodować
jednokrotną zmianę stanu licznika. Puszczenie przycisku SW7 nie ma powodować zmiany stanu
licznika. Kierunek zliczania ma natomiast zależeć od stanu przycisku SW0. Gdy przycisk SW0
jest wciśnięty, to licznik ma liczyć w górę a gdy przycisk SW0 jest puszczony, to licznik ma
liczyć w dół. Aktualny stan licznika ma być wyświetlany na wyświetlaczu 7-segmentowym
LED. Kody sterujące wyświetlaczem 7-segmentowym odpowiadające poszczególnym cyfrom
heksadecymalnym podano w dostarczonym pliku "Kody_LED7S.txt".

BRAK

;##################################################################################################
;##################################################################################################


WSTI przykładowe zadania na kolokwium
;****************************************************************************************
1. Napisz program, który naprzemiennie zapala diody o numerach parzystych i nieparzystych
tj. gdy zapalone są diody o indeksach parzystych (nieparzystych) to zgaszone mają być
diody o indeksach nieparzystych (parzystych). Zmiana stanu świecenia diod LED ma
zachodzić co 1s. Wykorzystaj załączony podprogram „Delay_10ms” - który wprowadza
opóźnienie n*10ms, gdzie n to liczba którą należy wpisać do akumulatora przed
wywołaniem podprogramu.

MOV P1, #01010101b

start:
MOV ACC, #100; krotnosc wykonania delay
LCALL DELAY_10MS
MOV A, P1
CPL A
MOV P1, A
JMP start

DELAY_10MS:
MOV R2, #50
MOV R3, #100

petla:
DJNZ R2, petla
MOV R2, #50
DJNZ R3, petla
DEC A
JNZ DELAY_10MS

RET





;****************************************************************************************
2. Napisz program, który wyświetla na diodach LED stan przycisków. Wciśniętemu
przyciskowi ma odpowiadać zapalona dioda.

start:

MOV P1, P2

JMP start


;****************************************************************************************

3. Napisz program, który po każdorazowym naciśnięciu przycisku nr 0 będzie zapalał diodę
nr i mod 8 gasząc przy tym diodę nr i-1 mod 8.

MOV P1, #11111110b ; tutaj mozna zaprogramowac swiecenie

start:
JB P2.0, start
LCALL LEDCTRL

petla:
JNB P2.0, petla

JMP start

LEDCTRL:
MOV A, P1
RL A ;tu ustawiamy kierunkek zaplania/gaszenia
MOV P1, A

RET

;****************************************************************************************
4. Napisz program, który po każdorazowym naciśnięciu przycisku nr 0 będzie zapalał kolejne
diody LED. W sytuacji, gdy wszystkie diody są już zapalone kolejne naciśnięcie przycisku
ma spowodować wygaszenie wszystkich diod LED. Dalsze naciskanie przycisku nr 0 ma
powodować działanie takie, jak opisano powyżej.

MOV P1, #11111111b ;diody off
MOV R1, #10000000b ;wskaznik do zapalania

start:
JB P2.0, start
LCALL LEDCTRL

petla:
JNB P2.0, petla

JMP start

LEDCTRL:
MOV A, P1 
SUBB A, R1 ;A=A-R1 - zapalam diode
MOV P1, A
MOV A, R1 ;R1 do zeby przesunac
RRC A ;koniecznie przez CARRY!
MOV R1, A ;i zapamietuje do R1
RET

;****************************************************************************************
5. Napisz program, który wyświetli na wyświetlaczu 7-segmentowym LED nr 0 (ten
najbardziej z prawej) numer naciśniętego przycisku. Załóż, że w danej chwili może być
wciśnięty tylko jeden przycisk.

MOV P3, #0E7h ;ustawienie DISPLAY 3

start:
MOV R2, #0 ;numer wcisnietego SW
MOV A, P2 ;stan SW do ACC
liczenie:
RRC A
INC R2
JC liczenie

DEC R2
MOV A, R2
LCALL GET_CODE_7SEG
MOV P1, A
JMP start


;podprogramy

GET_CODE_7SEG:
ANL A, #0FH
INC A
MOVC A, @A+PC
RET

DB 0C0H ; 0
DB 0F9H ; 1
DB 0A4H ; 2
DB 0B0H ; 3
DB 099H ; 4
DB 092H ; 5
DB 082H ; 6
DB 0F8H ; 7
DB 0FFH ; nic nie swieci/wcisniete
;****************************************************************************************
6. Napisz program, który wyświetli na wyświetlaczu 7-segmentowym LED nr 0 (ten
najbardziej z prawej) numer naciśniętego przycisku. Załóż, że w danej chwili może być
wciśniętych kilka przycisków. W takiej sytuacji

BRAK
;****************************************************************************************
7. Napisz program realizujący funkcję 4-bitowego licznika binarnego liczącego mod 16
(tj. liczącego od 0 do 15), który jest wyzwalany przyciskiem nr 7. Kolejne naciskanie
przycisku nr 7 ma powodować inkrementację stanu licznika. Aktualny stan licznika ma być
wyświetlany na wyświetlaczu 7-segmentowym LED.

BRAK
;****************************************************************************************
8. Napisz program, który wyświetli na wyświetlaczu 7-segmentowym LED liczbę aktualnie
naciśniętych przycisków klawiatury matrycowej.

BRAK
;****************************************************************************************
9. Napisz podprogram BLKCPY kopiujący zadaną liczbę komórek pamięci z jednego
wskazanego obszaru pamięci do drugiego wskazanego obszaru pamięci. Załóż, że przed
wywołaniem podprogramu adresy źródłowego i docelowego obszaru pamięci zostają
wpisane odpowiednio do rejestrów R0 i R1 banku rejestrów nr 3. Liczba kopiowanych
komórek ma być przekazywana do podprogramu za pośrednictwem akumulatora.
Wskazówka: wykorzystaj tryb adresowania pośredniego bazujący na rejestrach R0 i R1.
Napisz krótki program główny, który wykorzysta podprogram BLKCPY do skopiowania
ośmiu kolejnych komórek z obszaru pamięci danych 08H-0FH do kolejnych komórek
położonych w obszarze pamięci danych 00H-07H.

BRAK
;****************************************************************************************
10. Napisz podprogram cyklicznie wyświetlający na czterech kolejnych wyświetlaczach
7-segmentowych zawartość czterech kolejnych komórek pamięci. Adres pierwszej komórki
pamięci ma być przekazywany do podprogramu za pośrednictwem akumulatora.
Podprogram ma być tak, aby nie zakłócić działania programu głównego (tj. trzeba zawartość
odpowiednich rejestrów przechować na stosie). Wskazówka: wykorzystaj tryb adresowania
pośredniego bazujący na rejestrach R0.

start:

;Display 0
CLR P3.3
CLR P3.4
MOV A, #0
LCALL GET_LICZBA
ANL A, #00001111b
LCALL GET_CODE_7SEG
MOV P1, A

;Display 1
SETB P3.3
CLR P3.4
MOV A, #0
LCALL GET_LICZBA
SWAP A
ANL A, #00001111b
LCALL GET_CODE_7SEG
MOV P1, A

;Display 2
CLR P3.3
SETB P3.4
MOV A, #1
LCALL GET_LICZBA
ANL A, #00001111b
LCALL GET_CODE_7SEG
MOV P1, A

;Display 3
SETB P3.3
SETB P3.4
MOV A, #1
LCALL GET_LICZBA
SWAP A
ANL A, #00001111b
LCALL GET_CODE_7SEG
MOV P1, A

JMP start

GET_CODE_7SEG:
ANL A, #0FH
INC A
MOVC A, @A+PC
RET

DB 0C0H ; 0
DB 0F9H ; 1
DB 0A4H ; 2
DB 0B0H ; 3
DB 099H ; 4
DB 092H ; 5
DB 082H ; 6
DB 0F8H ; 7
DB 080H ; 8
DB 090H ; 9
DB 088H ; A
DB 083H ; B
DB 0C6H ; C
DB 0A1H ; D
DB 086H ; E
DB 08EH ; F

GET_LICZBA:
INC A
MOVC A, @A+PC
RET

DB 0A4H ; 1 i 0 bajt
DB 027H ; 3 i 2 bajt
;****************************************************************************************


;##################################################################################################
;##################################################################################################


LABORATORIUM 1
;****************************************************************************************
1. Napisz program, który  na przemian włącza i wyłącza diodę świecącą LED 0. 
W tym celu wykorzystaj rozkazy operujące na bitach: SETB oraz CLR oraz jedną z instrukcji skoku LJMP, AJMP,  SJMP. Dla zmniejszenia 
częstotliwości migania diody możesz użyć (kilku) instrukcji NOP.

LJMP 100H	;niekonieczne
ORG 100H	;to jest

petla:
CLR P1.0
NOP;
NOP;
NOP;
SETB P1.0

JMP petla






;****************************************************************************************
2. W zadaniu 1 zastąp instrukcje NOP pętlami opóźniającymi.
 W tym celu wykorzystaj instrukcje MOV oraz DJNZ. Czas opóźnienia w mikrosekundach wpisz do rejestru R2. Możesz ustawić 
różne czasy świecenia i nieświecenia diody.

start:
MOV R2, #10
CLR P1.0

skok1:
DJNZ R2, skok1
	
MOV R2, #10
SETB P1.0

skok2:
DJNZ R2, skok2

JMP START



;****************************************************************************************

3. Rozbuduj program z zadania 2. 
Do wprowadzenia opóźnienia 10ms wykorzystaj dwie zagnieżdżone pętle operujące na rejestrach R2 i R3.

start:
MOV R2, #50
MOV R3, #100
CLR P1.0

skok1:
DJNZ R2, skok1
MOV R2, #50
DJNZ R3, skok1
	
MOV R2, #50
MOV R3, #100
SETB P1.0

skok2:
DJNZ R2, skok2
MOV R2, #50
DJNZ R3, skok2

JMP start

;****************************************************************************************
4. Przekształć program z zadania 4 tak, 
aby opóźnienie realizowane było w postaci procedury DELAY_10MS umieszczonej za ostatnią instrukcją programu głównego. Wykorzystaj jedną z instrukcji LCALL lub ACALL oraz 
instrukcję RET.

start:

CLR P1.0
LCALL DELAY_10ms
SETB P1.0
LCALL DELAY_10ms

JMP START

DELAY_10ms:

MOV R2, #50
MOV R3, #100

petla:
DJNZ R2, petla
MOV R2, #50
DJNZ R3, petla

RET

;****************************************************************************************
5. Przerób procedurę DELAY_10MS tak, aby 
powodowała opóźnienie o czasie równym wielokrotności 10ms. Krotność stanowi parametr wywołania procedury i powinna być umieszczona przed jej wywołaniem w akumulatorze. 
Czas opóźnienia w zmodyfikowanym programie głównym powinien teraz wynosić 0.5s.

start:

CLR P1.0
MOV ACC, #50; krotnosc wykonania delay
LCALL DELAY_10MS

SETB P1.0
MOV ACC, #50; krotnosc wykonania delay
LCALL DELAY_10MS
JMP START

DELAY_10MS:
MOV R2, #50
MOV R3, #100

petla:
DJNZ R2, petla
MOV R2, #50
DJNZ R3, petla
DEC A
JNZ DELAY_10MS

RET

;****************************************************************************************
6. Uprość procedurę z zadania 5 wykorzystując 
instrukcję CPL do negowania stanu wyprowadzenia sterującego diodą.

start:

CPL P1.0
MOV ACC, #50; krotnosc wykonania delay
LCALL DELAY_10MS

JMP START

DELAY_10MS:
MOV R2, #50
MOV R3, #100

petla:
DJNZ R2, petla
MOV R2, #50
DJNZ R3, petla
DEC A
JNZ DELAY_10MS

RET

;****************************************************************************************
7. Korzystając z doświadczeń zebranych przy 
realizacji zadań 1-6 napisz program, który cyklicznie zapala kolejno pojedynczą diodę od góry do dołu. Wykorzystaj instrukcję RL.

MOV P1, #11111110b


start:
MOV ACC, P1
RL A
MOV P1, ACC
LCALL DELAY_10MS


JMP start

DELAY_10MS:
MOV R2, #50
MOV R3, #100
petla:
DJNZ R2, petla
MOV R2, #50
DJNZ R3, petla

RET

;****************************************************************************************
8. Przerób program napisany w punkcie 7, 
tak aby zapalona dioda „wędrowała”od góry do dołu i z powrotem. Wykorzystaj instrukcje RLC, RRC, SETB C, CLR C, JC, JNC.

MOV P1, #11111110b
SETB C 

w_dol:
MOV ACC, P1
RLC A
MOV P1, ACC
LCALL DELAY_10MS
JC w_dol

w_gore:
MOV ACC, P1
RRC A
MOV P1, ACC
LCALL DELAY_10MS
JC w_gore

JMP w_dol

DELAY_10MS:
MOV R2, #50
MOV R3, #100
petla:
DJNZ R2, petla
MOV R2, #50
DJNZ R3, petla

RET

;****************************************************************************************
9. Przerób program napisany w punkcie 8 tak, 
aby kolejne diody się zapalały począwszy od góry aż zapalą się się wszystkie. Następnie diody kolejno powinny gasnąć począwszy od dołu, aż zgasną wszystkie.

w_dol:
CLR C
MOV ACC, P1
RLC A
MOV P1, ACC
;LCALL DELAY_10MS
JC w_dol

w_gore:
SETB C
MOV ACC, P1
RRC A
MOV P1, ACC
;LCALL DELAY_10MS
JNC w_gore

JMP w_dol

DELAY_10MS:
MOV R2, #50
MOV R3, #100
petla:
DJNZ R2, petla
MOV R2, #50
DJNZ R3, petla

RET


;****************************************************************************************
10. Przerób  program napisany w punkcie 9 tak, 
aby diody kolejno zapalały się a następnie kolejno gasły w kierunku od góry do dołu albo w kierunku od dołu do góry – zależnie od tego czy jest wciśnięty przycisk 0 
w zestawie przycisków (Switch bank).

start:

JB P2.0, w_dol_zapalamy
JNB P2.0, w_gore_zapalamy

w_dol_zapalamy:
CLR C
MOV ACC, P1
RLC A
MOV P1, ACC
;LCALL DELAY_10MS
JC w_dol_zapalamy

w_gore_gasimy:
SETB C
MOV ACC, P1
RRC A
MOV P1, ACC
;LCALL DELAY_10MS
JNC w_gore_gasimy

JMP start

w_gore_zapalamy:
CLR C
MOV ACC, P1
RRC A
MOV P1, ACC
;LCALL DELAY_10MS
JC w_gore_zapalamy

w_dol_gasimy:
SETB C
MOV ACC, P1
RLC A
MOV P1, ACC
;LCALL DELAY_10MS
JNC w_dol_gasimy

JMP start

DELAY_10MS:
MOV R2, #50
MOV R3, #100
petla:
DJNZ R2, petla
MOV R2, #50
DJNZ R3, petla

RET

;****************************************************************************************


;##################################################################################################
;##################################################################################################


LABORATORIUM 2
;****************************************************************************************
1. Napisz procedurę zamieniającą 4-bitową liczbę 
binarną na odpowiadający jej kod dla wskaźnika 7-segmentowego LED. Pamiętaj, że diody wskaźnika zapalane są przez podanie stanu 0 na odpowiednie bity portu P1 mikrokontrolera.
 W procedurze wykorzystaj dyrektywę asemblera DB do zdefiniowania tablicy konwersji liczb binarnych z przedziału 0..15 na odpowiadające im kody 
wskaźnika 7-segmentowego LED. Do odczytu w/w tablicy wykorzystaj instrukcję: MOV A, @A+PC. 
Struktura procedury: 
GET_COD_7SEG: 
… ciało procedury... 
RET 
DB 0C0H ; kod wskaźnika 7-segmentowego dla cyfry '0' 
…
DB 08Eh ; kod wskaźnika 7-segmentowego dla cyfry 'F'


MOV R1, #0

start:
MOV ACC, R1
LCALL GET_CODE_7SEG
MOV P1, ACC

INC R1
JMP start

GET_CODE_7SEG:
ANL ACC, #00001111b ;maskowanie starszych bitow w bajcie
INC ACC ;omija RET'a
MOVC A, @A+PC
RET

DB 0C0H ; 0
DB 0F9H ; 1
DB 0A4H ; 2
DB 0B0H ; 3
DB 099H ; 4
DB 092H ; 5
DB 082H ; 6
DB 0F8H ; 7
DB 080H ; 8
DB 090H ; 9
DB 088H ; A
DB 083H ; B
DB 0C6H ; C
DB 0A1H ; D
DB 086H ; E
DB 08EH ; F






;****************************************************************************************
2. Wykorzystując podprogram GET_COD_7SEG 
napisz program realizujący funkcję licznika 4 bitowego. Stan licznika ma być wyświetlany na prawym skrajnym wskaźniku 7 segmentowym LED. Stan licznika ma się zmieniać 
co 1s. W celu realizacji jednosekundowego opóźnienia wykorzystaj dostarczoną procedurę DELAY_10MS.

MOV R1, #0
CLR P3.3
CLR P3.4

start:
MOV ACC, R1
LCALL GET_CODE_7SEG
MOV P1, ACC

MOV ACC, #100 ;ustawiam ile razy ma sie odbyc delay_10ms
LCALL DELAY_10ms

INC R1
JMP start

GET_CODE_7SEG:
ANL ACC, #00001111b ;maskowanie starszych bitow w bajcie
INC ACC ;omija RET'a
MOVC A, @A+PC
RET

DB 0C0H ; 0
DB 0F9H ; 1
DB 0A4H ; 2
DB 0B0H ; 3
DB 099H ; 4
DB 092H ; 5
DB 082H ; 6
DB 0F8H ; 7
DB 080H ; 8
DB 090H ; 9
DB 088H ; A
DB 083H ; B
DB 0C6H ; C
DB 0A1H ; D
DB 086H ; E
DB 08EH ; F

DELAY_10MS:
MOV R2, #50
MOV R3, #100

petla:
DJNZ R2, petla
MOV R2, #50
DJNZ R3, petla
DEC A
JNZ DELAY_10MS

RET



;****************************************************************************************

3. Przerób program z punktu 2 tak, 
aby licznik liczył w górę lub w dół – zależnie od stanu przycisku „switch 0”.

MOV R1, #0
CLR P3.3
CLR P3.4

start:

MOV ACC, R1
LCALL GET_CODE_7SEG
MOV P1, ACC
MOV ACC, #1 ;ustawiam ile razy ma sie odbyc delay_10ms
LCALL DELAY_10ms

JB P2.0, licz_up
JNB P2.0, licz_down

licz_up:
INC R1
JMP start

licz_down:
DEC R1
JMP start

GET_CODE_7SEG:
ANL ACC, #00001111b ;maskowanie starszych bitow w bajcie
INC ACC ;omija RET'a
MOVC A, @A+PC
RET

DB 0C0H ; 0
DB 0F9H ; 1
DB 0A4H ; 2
DB 0B0H ; 3
DB 099H ; 4
DB 092H ; 5
DB 082H ; 6
DB 0F8H ; 7
DB 080H ; 8
DB 090H ; 9
DB 088H ; A
DB 083H ; B
DB 0C6H ; C
DB 0A1H ; D
DB 086H ; E
DB 08EH ; F

DELAY_10MS:
MOV R2, #50
MOV R3, #100

petla:
DJNZ R2, petla
MOV R2, #50
DJNZ R3, petla
DEC A
JNZ DELAY_10MS

RET

;****************************************************************************************
4. Napisz podprogram wyświetlający na 
wyświetlaczu LED w postaci heksadecymalnej wartość 2 bajtowej liczby binarnej. Przyjmij, że adres pierwszej z komórek pamięci zawierających w/w liczbę przekazywany 
jest do podprogramu za pośrednictwem akumulatora.

start:

;Display 0
CLR P3.3
CLR P3.4
MOV A, #0
LCALL GET_LICZBA
ANL A, #00001111b
LCALL GET_CODE_7SEG
MOV P1, A
MOV A, #1; krotnosc wykonania delay
LCALL DELAY_10MS

;Display 1
SETB P3.3
CLR P3.4
MOV A, #0
LCALL GET_LICZBA
SWAP A
ANL A, #00001111b
LCALL GET_CODE_7SEG
MOV P1, A
MOV A, #1
LCALL DELAY_10MS

;Display 2
CLR P3.3
SETB P3.4
MOV A, #1
LCALL GET_LICZBA
ANL A, #00001111b
LCALL GET_CODE_7SEG
MOV P1, A
MOV A, #1
LCALL DELAY_10MS

;Display 3
SETB P3.3
SETB P3.4
MOV A, #1
LCALL GET_LICZBA
SWAP A
ANL A, #00001111b
LCALL GET_CODE_7SEG
MOV P1, A
MOV A, #1
LCALL DELAY_10MS

JMP start

GET_CODE_7SEG:
ANL A, #0FH
INC A
MOVC A, @A+PC
RET

DB 0C0H ; 0
DB 0F9H ; 1
DB 0A4H ; 2
DB 0B0H ; 3
DB 099H ; 4
DB 092H ; 5
DB 082H ; 6
DB 0F8H ; 7
DB 080H ; 8
DB 090H ; 9
DB 088H ; A
DB 083H ; B
DB 0C6H ; C
DB 0A1H ; D
DB 086H ; E
DB 08EH ; F

DELAY_10MS:

MOV R2, #50
MOV R3, #100

petla:
DJNZ R2, petla
MOV R2, #50
DJNZ R3, petla
DEC ACC
JNZ DELAY_10MS
RET

GET_LICZBA:
INC A
MOVC A, @A+PC
RET

DB 0A4H ; 1 i 0 bajt
DB 027H ; 3 i 2 bajt

;****************************************************************************************


;##################################################################################################
;##################################################################################################


LABORATORIUM 3
;****************************************************************************************
1. Napisz podprogram obsługi klawiatury matrycowej. 
W symulatorze EdSim51 wiersze klawiatury są sterowane przez linie 0-3 portu P0. 
Natomiast wyjścia kolumn tej klawiatury są podłączone do wejść 4-6 portu P0. 
Podprogram ma zwracać numer przyciśniętego klawisza w akumulatorze. Dla „gwiazdki” 
i „kratki” program ma odpowiednio zwracać 0Ah oraz 0Bh.


LJMP 100H
ORG 100H

MOV R0, #0

KeyFound EQU F0

;wiersz 0
CLR P0.0
SETB P0.1
SETB P0.2
SETB P0.3

CALL ColumnScan
JB KeyFound, koniec

;wiersz 1
ORL P0, #0x0F
CLR P0.1

CALL ColumnScan
JB KeyFound, koniec

;wiersz 2
ORL P0, #0FH
CLR P0.2

CALL ColumnScan
JB KeyFound, koniec

;wiersz 3
ORL P0, #0x0F
CLR P0.3

CALL ColumnScan
JB KeyFound, koniec

koniec:

RET


ColumnScan:

JNB P0.4, SetKf
INC R0

JNB P0.5, SetKf
INC R0

JNB P0.6, SetKf
INC R0

SetKf:
SETB KeyFound

RET




;****************************************************************************************
2. Wykorzystaj powyższy podprogram do napisania programu  
wyświetlającego symbol naciśniętego przycisku na wyświetlaczu 7-segmentowym. Naciśnięcie "gwiazdki"
i "kratki" ma odpowiednio powodować zapalenie kropki dziesiętnej oraz poziomej kreski 
(segment 'g' wyświetlacza siedmiosegmentowego).

LJMP 100H
ORG 100H

KeyFound EQU F0

START:

CALL ScanKeypad
JMP START

;-----------------

ScanKeypad:

MOV R0, #0
CLR KeyFound

;wiersz 0
CLR P0.0
SETB P0.1
SETB P0.2
SETB P0.3

CALL ColumnScan
JB KeyFound, koniec

;wiersz 1
ORL P0, #0x0F
CLR P0.1

CALL ColumnScan
JB KeyFound, koniec

;wiersz 2
ORL P0, #0FH
CLR P0.2

CALL ColumnScan
JB KeyFound, koniec

;wiersz 3
ORL P0, #0x0F
CLR P0.3

CALL ColumnScan
JB KeyFound, koniec

koniec:

RET


ColumnScan:

JNB P0.4, SetKf
INC R0

JNB P0.5, SetKf
INC R0

JNB P0.6, SetKf
INC R0

RET

SetKf:
SETB KeyFound

RET



;****************************************************************************************

3. Rozbuduj podprogram obsługi klawiatury
 o mechanizmy eliminacji wpływu drgań styków przycisków klawiatury..

LJMP 100H
ORG 100H

KeyFound EQU F0

START:

CALL ScanKeypad
MOV A, R0
CALL GET_COD7
MOV P1, A

JMP START

;-----------------

ScanKeypad:

MOV R0, #0
CLR KeyFound

;wiersz 0
CLR P0.0
SETB P0.1
SETB P0.2
SETB P0.3

CALL ColumnScan
JB KeyFound, koniec

;wiersz 1
ORL P0, #0x0F
CLR P0.1

CALL ColumnScan
JB KeyFound, koniec

;wiersz 2
ORL P0, #0FH
CLR P0.2

CALL ColumnScan
JB KeyFound, koniec

;wiersz 3
ORL P0, #0x0F
CLR P0.3

CALL ColumnScan
JB KeyFound, koniec

koniec:

RET


ColumnScan:

JNB P0.4, SetKf
INC R0

JNB P0.5, SetKf
INC R0

JNB P0.6, SetKf
INC R0

RET

SetKf:
SETB KeyFound

RET

GET_COD7:

ANL A, #0x0F
INC A
MOVC A, @A+PC

RET  

DB 0C0H ; 0
DB 0F9H ; 1
DB 0A4H ; 2
DB 0B0H ; 3
DB 099H ; 4
DB 092H ; 5
DB 082H ; 6
DB 0F8H ; 7
DB 080H ; 8
DB 090H ; 9
DB 088H ; A
DB 083H ; B
DB 0C6H ; C
DB 0A1H ; D
DB 086H ; E
DB 08EH ; F

;****************************************************************************************
4. Przerób podprogram obsługi klawiatury 
w procedurę obsługi przerwania pochodzącego od klawiatury.

LJMP 100H

ORG 0013H
CALL ScanKeypad
RETI

;----------------

ORG 100H

KeyFound EQU F0

; zad 4 IE, IP, TCON z dokumentacji

;wlaczenie obslugi przerwan
SETB EA
SETB EX1

START:
ANL P0, #0F0H
;CALL ScanKeypad

JMP START

;-----------------

ScanKeypad:
MOV R0, #0
CLR KeyFound

;wiersz 0
CLR P0.0
SETB P0.1
SETB P0.2
SETB P0.3

CALL ColumnScan
JB KeyFound, koniec

;wiersz 1
ORL P0, #0x0F
CLR P0.1

CALL ColumnScan
JB KeyFound, koniec

;wiersz 2
ORL P0, #0FH
CLR P0.2

CALL ColumnScan
JB KeyFound, koniec

;wiersz 3
ORL P0, #0x0F
CLR P0.3

CALL ColumnScan
JB KeyFound, koniec

koniec:

MOV A, R0
CALL GET_COD7
MOV P1, A

RET


ColumnScan:

JNB P0.4, SetKf
INC R0

JNB P0.5, SetKf
INC R0

JNB P0.6, SetKf
INC R0

RET

SetKf:
SETB KeyFound

RET

GET_COD7:

ANL A, #0x0F
INC A
MOVC A, @A+PC

RET  

DB 0BFH ; hash kreska
DB 0C0H ; 0
DB 07FH ; gwiazdka kropka
DB 090H ; 9
DB 080H ; 8
DB 0F8H ; 7
DB 082H ; 6
DB 092H ; 5
DB 099H ; 4
DB 0B0H ; 3
DB 0A4H ; 2
DB 0F9H ; 1
DB 0FFH ; pusto

;****************************************************************************************