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  wskaz
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 :)
PRZYKA
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)