Majkel rzekł :
a ) jakis asm.. ale to juz robiles.. przydalby sie jeszcze opis dodawania z przelepnieniem;]
b) jakies przebiegi z roznym wypelnieniem.. tyle pamietam.. ale jakie zadanie z tego... o co halo...
nie mam pojecia...
c) szeregowka.. niby bylo.. ale nie wiem.. jakies podsuwmowanie moze?
d) zadanie 4 dla "koneserow" czytaj nie dla mnie;]

Asembler

oznaczenia :
c – flaga (znacznik) przeniesienia
! - negacja
sp – wskaźnik stosu
[sp] = ax – zapis pod adres sp
^ - xor ( a^a = 0 ; a^(!a) = 1 gdzie a = 1 lub 0)

adc ax, cx ; ax = ax + cx + c
add ax, cx ; ax = ax + cx
sbb ax, cx ; ax = ax – (cx + c)
sub ax, cx ; ax = ax – cx
dec ax ; ax = ax – 1
inc ax ; ax = ax + 1

and ax, cx ; ax = ax & cx
not ax; ax = !ax
or ax, cx ; ax = ax | cx
xor ax, cx ; ax = ax ^ cx

clc ; c = 0
cmc ; c = !c
stc ; c = 1

push ax ; sp = sp + 1 , [sp] = ax
pop ax ; ax = [sp], sp = sp – 1

mov ax, cx ; ax = cx
xchg ax, cx ; ax = cx i cx = ax

mała uwaga: add, adc, sub, sbb zmieniają znacznik c tak, że jeśli po wykonaniu operacji wystąpi
przepełnienie to c = 1; a jeśli nie to c = 0.
or, xor i and zerują znacznik c!

Przykład 1:

mov ax, 0xFFFF

; ax = 0xFFFF ; bx = ? ; cx = ? ; c = ?

add ax, 1

; ax = 0 ; bx = ? ; cx = ? ; c = 1

mov bx, 3

; ax = 0 ; bx = 3 ; cx = ? ; c = 1

adc ax, bx

; ax = 4 ; bx = 3 ; cx = ? ; c = 0

mov cx, 6

; ax = 4 ; bx = 3 ; cx = 6 ; c = 0

sub ax, cx

; ax = 0xFFFE ; bx = 3 ; cx = 6 ; c = 1

xor bx, bx

; ax = 0 ; bx = 0 ; cx = 6 ; c = 0

sbb bx, 1

; ax = 0 ; bx = 0xFFFF ; cx = 6 ; c = 1

sbb ax, 1

; ax = 0xFFFE ; bx = 0xFFFF ; cx = 6 ; c = 1

add cx, 1

; ax = 0xFFFE ; bx = 0xFFFF ; cx = 7 ; c = 0

Przykład 2:

1. mov ax, 1
2. mov bx, 2
3. mov cx, 3
4. push ax
5. push bx
6. push cx
7. pop ax
8. pop cx
9. pop bx

na początku stos wyglada np. tak:

?
?
?

? <= SP

?

?

Po instrukcji nr 3, nadal będzie wyglądał tak samo :) a rejestry : ax = 1; bx = 2; cx = 3
Po instrukcji nr 4 :
ax = 1; bx = 2; cx = 3

?
?

1 <= SP

?

?

?

Po 5 :
ax = 1; bx = 2; cx = 3

?

2 <= SP

1

?

?

?

Po 6:
ax = 1; bx = 2; cx = 3

3 <= SP

2
1

?

?

?

Po 7:
ax = 3; bx = 2; cx = 3

?

2 <= SP

1

?

?

?

Po 8:
ax = 3; bx = 2; cx = 2

?
?

1 <= SP

?

?

?

Po 9:
ax = 3; bx = 1; cx = 2

?
?
?

? <=SP

?

?

Timer:

Mamy sobie generator fgen = 1800 Hz, liczniki 8 bitów chcemy uzyskać 50% wypełnienia i
częstotliwość f = 90 Hz. I szukamy jak ustawić RA i RC :
RA – po doliczeniu przez licznik do tej wartości wyjście zmienia się na przeciwne
RC – po doliczeniu przez licznik do tej wartości wyjście i licznik zerują się (liczy od 0)
Z tego wynika że dla wypełnienia 50% powinniśmy mieć RC = 2*RA. RC kończy okres więc
powinno być ustawione tak, żeby licznik dochodził do tej wartości z daną częstotliwością = 90 razy
na sek. Skoro generator daje nam 1800 Hz to RC = fgen/f = 1800/90. Bo to w sumie działa jak
dzielnik częstotliwości gdzie RC jest dzielnikiem.
RC = 1800/90 = 200
RA = 0.5 * RC = 100
Czyli mieścimy się w liczniku 8 bitowym :)

Gdyby było f = 9 Hz to RC = 2000 i RA = 1000, to już nie mieści się w 8 bitach więc łączymy w
kaskadę 2 liczniki. I teraz problemik : jeśli oba są ustawione w tryb Waveform czyli ten gdzie się
ustawia RA i RC to trzeba na pierwszym liczniku ustawić taki dzielnik, żeby drugi dał radę zliczyć
resztę. Ogólnie RC1*RC2 = fgen/f trzeba to tak dobrać, żeby żaden nie przekroczył 256, dla
naszego przykładu wystarczy: RC1 = 10 RA1 = 5 oraz RC2 = 200 RA2 = 100. Nie jestem pewien
ale dla pierwszego licząc od generatora powinno być wypełnienie 50% niezależnie od zadanego, a
na drugim – zadane.
Jeśli za to pierwszy będzie capture a drugi waveform to mamy podobny wzorek OCR1*RC2 =
fgen/f czyli OCR1 = 10 a RC2 i RA2 jak wyżej.

No to teraz przykład, bez kaskady bo wątpię żeby dał takie ciulstwo (a jak da to chyba jest to dość
jasne jak to zrobić nie ? :D )

fgen = 10 MHz
f = 200 Hz
licznik 16 bit
wypełnienie 25%

RC = 10 000 000 / 200 = 50000 < 65536 czyli mieści się w liczniku
RA = (1 – 0.25)*RC = 37500

Interpretacja tych wartości :
RA = 37500 taktów generatora będzie 0 na wyjściu, potem zmieni się na 1 i przez kolejne RC-RA
= 12500 taktów będzie się utrzymywała ta 1 na wyjściu, po czym licznik się zresetuje i na wyjściu
znowu będzie 0 i tak w kółko. Razem daje nam to 50000 taktów na jeden okres syg. wyjściowego
Czyli tak jakby na jeden okres wyjściowy przypada 50000 okresów wejściowych, stąd wzór RC =
fgen/f.

Szeregówka:

Ponoć Czyż powiedział że bajt/sek = baud / dł_ramki , on to sprawdza więc przyjąłbym to za fakt :)
Ramka asynchroniczna:
Bit startu | dane (5 – 8 bitow) | kontr. Parz. | bit(y) stopu
dane są pisane od LSB czyli liczba 33 = 0100001 powinna być zapisana : 1000010
kontr parzystości:
jeśli ODD - nieparzysta liczba jedynek w danych i bicie kontr. Parz
jeśli EVEN – parzysta liczba jedynek w danych i bicie kontr. Parz
jeśli NONE – nie ma tego bitu

Wartość bitu kontroli parzystości:

Ilość jedynek w danych

ODD

EVEN

parzyście

1

0

nieparzyście

0

1

Programy ... no takie jak na poprzednich terminach :)

PRZYKŁADY DO ROZWIĄZANIA!

Ad1)
wypisać ax,bx,cx, flage c i stosik po instrukcji „adc ax” i po „xor bx,bx”
Stos na starcie wygląda tak:

?
?
?
?

? <=SP

?

mov ax, 0xDD
mov bx, 0x01
mov cx, 0x00
push ax
push bx
push cx
sub cx, bx
adc ax, 1
and ax, 0xF0
or bx, 0xBB
add ax, bx
pop ax
xor bx,bx
pop cx
pop bx

Ad2)
a) Częstotliwość generatora 2GHz, wypełnienie 20%, częstotliwość wyjściowa 100MHz
b) Częstotliwość generatora 2MHz, wypełnienie 80%, częstotliwość wyjściowa 100Hz
c) Częstotliwość generatora 1.6kHz, wypełnienie 50%, częstotliwość wyjściowa 8Hz

Ad3)
Odbieracie ramke o postaci
Start | 3*dane | Koniec
start i koniec = 1 bajt
odebrać ramkę, zsumować wszystkie bajty danych i jeśli parzysta suma to odesłać kompletną ramkę
z danymi 0xFF667C (3 bajty)
jeśli nie to dane = 0x000001 (3bajty)