Asemmbler pomoc!!!

0

Czesc wszystkim mam problemi to olbrzymi a mianowicie mam napisac program na zaliczenie po jednym semestrze i nie wiem jak to zrobic zajecia mamy tylko raz w tyg oczywiscie dysponuje kompem i dojsciem do netu mam tez potrzebne ksiazki i kompilator ale jak to zrobic przy takim poziomie jaki pan magister nam narzucil zero podstaw (po 3 spotkaniach koles wymaga od nas pisania programow) nie rozumiem goscia..Bardzo bym prosil o jakąs pomoc nawet najdrobniejszą

Temat pracy:
8. Losowe rysowanie x wypełnionych elips w trybie graf. o zadanym promieniu i środku pierwszej elipsy.
Wywołanie: elipsa.exe

O warunkach niezaliczenia lepiej nie pisac bo to juz porazka jest

bardzo prosze o jaką kolwiek odpowiedz z góry dzieki..pozdrawiam wszystkich

0

Jak na 3 zajeciach wam dopiero zadaje programy, to nic dziwnego, ze zrobic nie mozecie. Nalezaloby zadawac od pierwszych zajec. Asm nie da sie nauczyc w 1 wieczor...
Co do zadania:

  1. Pod jaki procesor? Czy mozna wykorzystac koprocesor?
  2. Jaki tryb graficzny? Moze byc 13h?
  3. Czy mozna korzystac z fragmentow cudzego kodu? (np. procedura generujaca liczby pseudolosowe).

Narysowac elipse jest bardzo latwo korzystajac ze wzroru:
x = x0+acos(t)
y = y0+b
sin(t)
Operacje na koprocesorze wykonuje sie jak na zwyklym stosie (o ile pozostajemy w sferze procesorow x86/87). Np. dla x byloby to cos takiego:
push t
cos
push a
mul
push x0
add
Oczywiscie to jedynie schemat. Musisz sprawdzic konkretne mnemoniki (patrz FAQ i linki do strony Intela).
Co do wypelnienia to mozna zastosowac algorytm przesiewania (patrz dzial Algorytmy).
Jezeli chodzi o wyswietlanie pojedynczego punktu oraz wchodzenie do trybu graficznego to w trybie 13h to na forum juz to bylo (chyba czas napisac o tym oraz o VESIe krotkiego arta).

Hmm, to chyba wszystko co trzeba wiedziec. Powodzenia.

0

Odpowiedz:

ad 1.Procesor np:486
ad 2.Mozna wykozystac koprocesor
ad 3.i mozna kozystac z fragmetow cudzego kodu

Co dalej to nie wiem..jakies wskazowki jak to zaczac moze..prosba bo ja sie w tym gubie..Pozdrawiam

0

Piszesz funkcje:

  1. Inicjalizujaca tryb graficzny InitGraph (patrz forum)
  2. Ustawiajaca punkt na ekranie SetPixel (patrz forum)
  3. Funkcje wyliczajace wspolrzedne x, y elipsy (Ellipse)
    x=x0+acos(t), y=y0+bsin(t)
    x0, y0 to wspolrzedne srodka elipsy. a, b - to polosie elipsy. t przebiega wartosci od 0 do pi. Wykorzystaj koprocesor do wyliczenia tych wartosci (FAQ->dokumentacja referencyjna procesorow intela->funkcje zaczynajace sie od F). Zaokraglij liczby do wartosci calkowitych (takze odpowiednie funkcje koprocesora).
  4. Napisz funkcje wypelniania przez przesiewanie Fill (a dokladniej przepisz na asm to, co jest w dziale Algorytmy).
  5. Znajdz procedure generujaca liczby losowe (np. z biblioteki http://webster.cs.ucr.edu/AoA/DOS/stdlib.zip)
  6. Wykonaj algorytm:
    a. InitGraph(13h)
    b. Dla kazdej elipsy
    c. Wylosuj x0, y0, a, b czy co tam jeszcze potrzebujesz
    d. for t := 0 to pi do
    e. (x, y) := Ellipse(x0, y0, t)
    f. SetPixel(x, y, kolor)
    g. Fill(x0, y0, kolor, kolor_wypelnienia)

Koniec.
Więcej to musialbym juz napisac za ciebie kod.

0

Dzieki wielkie bardzo to mi wystarczy mysle nie wiem zobacze moze sobie poradze a jak cos to napisze na forum najwyzej..jeszcze raz dzieki..Pozdrawiam

0

No spoko algorytm przesiewania jest tylko teraz pytanie jak go przerobić żeby działał w assemblerze????

0

Bezposrednie, brzydkie, szybkie tlumaczenie (TASM):

fill_seed PROC
ARG x: WORD, y: WORD, edge_color: WORD, color: WORD
	call getpixel, x, y
	cmp ax, edge_color
	je koniec
	cmp ax, color
	je koniec
	call putpixel, x, y, color
	mov ax, y
	dec ax
	call fill_seed, x, ax, edge_color, color
	mov ax, y
	inc ax
	call fill_seed, x, ax, edge_color, color
	mov ax, x
	dec ax
	call fill_seed, ax, y, edge_color, color
	mov ax, x
	inc ax
	call fill_seed, ax, y, edge_color, color
koniec:
	ret
ENDP
0

Dobra zorobione dzieki wielkie:a o to kod programu:
[code]
.MODEL small,pascal
.STACK 0ffffh
.486
.DATA

napis db "Ile dodatkowych elips ma zostac wyswietlonych? ",'$'
napis1 db "Podaj wsp X pierwszej elipsy (0-320): ",'$'
napis2 db "Podaj wsp Y pierwszej elipsy (0-200): ",'$'
napis3 db "Podaj rozmiar polprostej X: ",'$'
napis4 db "Podaj rozmiar polprostej Y: ",'$'
pomoc db "Program rysujacy x wypelnionych elips",13,10
db "Uzytkownik podaje wspolrzedne srodka pierwszej elipsy,",13,10
db "oraz wielkosc obu polprostych",13,10,'$'
ent db 13,10,'$'
parametr db 3 DUP ('$')
liczba db 10 DUP ('$')
kolor db 9
x0 dw 50
y0 dw 50
x dw 0
y dw 0
ppx dw 5
ppy dw 5
ile_elips dw 0
RndHi dw ?
RndLo dw ?
Seed dw 1h
oneten dq 0.01
.CODE
jmp Start

Random PROC
mov bx,Seed
add bx,9248h
ror bx,1
ror bx,1
ror bx,1
mov Seed,bx
mov ax,RndHi
sub ax,RndLo
mul bx
mov ax,dx
add ax,RndLo
ret
ENDP Random

ZamienNaliczbe PROC
mov di,offset liczba ;do DI adres bufora z ciagiem cyfr
xor bx,bx
mov bl,byte ptr ds:[di+1]
add bl,2
add bx,di
mov al,'$'
mov byte ptr ds:[bx], al
mov bx,10 ;do BX wkladamy 10
xor ax,ax ;zerujemy AX
xor dx,dx ;zerujemy DX
add di,2
mov cl,liczba[1] ;do CX wkladamy 5 - tyle cyfr max moze miec
przez_10: ;nasza liczba
cmp byte ptr ds:[di],'$';sprawdzamy czy to juz koniec cyfr
je nie_koniec
mul bx ;mnozymy cyfre w AX przez BX=10
mov dl,byte ptr ds:[di] ;wkladamy do dl nasz znak z bufora
sub dl,30h ;odejmujemy stala 30h i dostajemy cyfre
add ax,dx ;dodajemy otrzymana cyfre w DX do AX
xor dx,dx ;zerujemy DX
nie_koniec:
inc di ;zwiekszamy offset bufora o 1
loop przez_10 ;powtarzamy instrukcje 5 razy
ret
ZamienNaLiczbe ENDP

SetPixel PROC ;al -> kolor, cx -> X, dx -> Y
push bx
mov ah,0Ch
mov bx,01h
int 10h
pop bx
ret
SetPixel ENDP

Ellipse PROC
finit
fldz
mov cx,0
rysujElipse:
fld st
fcos
fimul [ppx]
fiadd [x0]
frndint
fistp [x]
fld st
fsin
fimul [ppy]
fiadd [y0]
frndint
fistp [y]
fadd [oneten]
push cx
mov al,[kolor]
mov cx,[x]
mov dx,[y]
call SetPixel
pop cx
inc cx
cmp cx,6284
jne rysujElipse
ret
Ellipse ENDP

Fill PROC

ret
Fill ENDP

DrukujEnter PROC
mov ah,09h
mov dx,offset ent
int 21h
ret
DrukujEnter ENDP

WczytajLiczby PROC
mov ah,09h
mov dx,offset napis
int 21h
mov ah,0ah
mov dx,offset liczba
int 21h
call ZamienNaLiczbe
mov [ile_elips],ax
call DrukujEnter
mov ah,09h
mov dx,offset napis1
int 21h
mov ah,0ah
mov dx,offset liczba
int 21h
call ZamienNaLiczbe
mov [x0],ax
call DrukujEnter
mov ah,09h
mov dx,offset napis2
int 21h
mov ah,0ah
mov dx,offset liczba
int 21h
call ZamienNaLiczbe
mov [y0],ax
call DrukujEnter
mov ah,09h
mov dx,offset napis3
int 21h
mov ah,0ah
mov dx,offset liczba
int 21h
call ZamienNaLiczbe
mov [ppx],ax
call DrukujEnter
mov ah,09h
mov dx,offset napis4
int 21h
mov ah,0ah
mov dx,offset liczba
int 21h
call ZamienNaLiczbe
mov [ppy],ax
mov ax,[ile_elips]
add ax,[x0]
add ax,[y0]
add ax,[ppx]
add ax,[ppy]
mov [Seed],ax
ret
WczytajLiczby ENDP

fill_seed PROC
ARG xx: WORD, yy: WORD, edge_color: WORD, color: WORD
mov ah,0dh
mov bx,1
mov cx,xx
mov dx,yy
int 10h

mov bx,edge_color
cmp al,bl
je koniec
mov bx,color
cmp al,bl
je koniec
mov ax,color
mov cx,xx
mov dx,yy
call SetPixel
mov ax, yy
dec ax
call fill_seed, xx, ax, edge_color, color
mov ax, yy
inc ax
call fill_seed, xx, ax, edge_color, color
mov ax, xx
dec ax
call fill_seed, ax, yy, edge_color, color
mov ax, xx
inc ax
call fill_seed, ax, yy, edge_color, color
koniec:
ret
ENDP

Start:
mov ax,@data
mov ds,ax

;uruchomiony program w DOSie posiada PSP (Program Segment Prefix),
;jest on tworzony podczas ladowania programu
;pod offsetem 80h znajduje sie liczba znakow podanych jako parametry
xor di,di ;potrzebny index,bedzie wskazywal kolejny element parametru
mov bx,80h ;sprawdzamy czy istnieje
mov cl,es:[bx] ;jakikolwiek parametr
cmp cl,0 ;jesli nie to wykonuj program normalnie
jne czytajp1
jmp go
czytajp1:
inc bx ;parametry zaczynaja sie od 81h
mov dl,es:[bx] ;wczytujemy go do dl
mov parametr[di],dl ;a nastepnie do bufora
inc di
loop czytajp1
cmp parametr[1],'/' ;sprawdzamy czy podany parametr
je czytajp2 ;jest poprawny
jmp go
czytajp2:
cmp parametr[2],'?' ;jesli tak to wyswietlamy pomoc
jne go
mov ah,09h
mov dx,offset pomoc
int 21h
jmp NieRysuj

go:
call WczytajLiczby

mov ax,0013h
int 10h

call Ellipse
xor ax,ax
mov al,kolor
mov bx,ax
inc bx
call fill_seed, x0, y0, ax, ax
mov cx,[ile_elips]
cmp cx,1
je NieRysuj
;sub cx,1
Rysuj:
push cx
mov [RndHi],270
mov [RndLo],50
call Random
mov [x0],ax
mov [RndHi],150
mov [RndLo],50
call Random
mov [y0],ax
mov [RndHi],15
mov [RndLo],1
call Random
mov [kolor],al

call Ellipse
xor ax,ax
mov al,kolor
mov bx,ax
inc bx
call fill_seed, x0, y0, ax, ax
pop cx
loop Rysuj

NieRysuj:
mov ah,08h
int 21h
mov ax,0003h
int 10h

mov ah,4Ch
int 21h

END Start
[/code]
Może się przyda..

// tagi plizzz [mf]

1 użytkowników online, w tym zalogowanych: 0, gości: 1