Посоветуйте что-нибудь.

Chingachguka! Chingachguka на сцену. Пусть дла начала свои уроки запостит.

Это точно, начинать надо с Chingachguka

Est takaia bolshaia kniga Toma Svana (Tom Swan) nazivaetsia "programmirovanie v Turbo Assembler". Ochen podrobnoe opisanie. Kucha primerov i poniatno napisannaia.
Rekomenduiu.

О ! Всем привет ! ))

Так что, можно продолжить ?! Оки !
Ниже пошел первый Урок.

Урок 1. Немного порисуем.

Итак, начнем. Запустите tp7(или более младшие версии,
где можно писать asm end; - и компиллер не ругнется).
Tp7 Вы можете взять тут(~550Кил):
http://chat.ru/~vzubko/tp7.zip

Наберите следующий код:

begin
 {Устанавливаем графический режим монитора 13h, 320x200, 256 цветов}
 asm
 mov  ax,0013h
 int  10h
 end;
 asm
 mov  ax,0A000h
 mov  es,ax
 {Рисуем - раз}
 mov  byte ptr es:[320*10+10],12
 mov  byte ptr es:[320*10+11],12
 mov  byte ptr es:[320*10+12],12
 mov  byte ptr es:[320*11+10],12
 mov  byte ptr es:[320*11+11],12
 mov  byte ptr es:[320*11+12],12
 mov  byte ptr es:[320*12+10],12
 mov  byte ptr es:[320*12+11],12
 mov  byte ptr es:[320*12+12],12
 {Рисуем - два}
 mov  byte ptr es:[320*100+100],1
 mov  byte ptr es:[320*101+101],2
 mov  byte ptr es:[320*102+102],3
 mov  byte ptr es:[320*103+103],4
 mov  byte ptr es:[320*104+104],5
 mov  byte ptr es:[320*105+105],6
 end;
 {Ожидаем нажатия клавиши}
 asm
 mov  ah,0
 int  16h
 end;
 {Устанавливаем текстовый режим монитора 03h, 80x25, 16 цветов текста и фона}
 asm
 mov  ax,0003h
 int  10h
 end;
end.

Ага. Теперь скомпиллируйте ЭТО и запустите на выполнение. Что Вы видите ?
(Должны увидеть квадратик и цепочку точек). Нажав клавишу, Вы должны закрыть
графическое окно и вернуться в среду.

НЕбольшое техническое отступление. Синтаксис асм-вставок в tp7.
Асм-вставка начианется псевдооператором "asm". Далее идут сами ассемблерные
команды(Вы должны видеть их зелеными). Завешает блок асм директива
"end;" - как, врочем, и другие логически завершенные блоки в Pascal.

Теперь посмотрим на команды. Их не так много и они довольно одинаковы.
Отбросим пока вот эти три блока, дав им поверхностное объяснение:

 asm
 mov  ax,0013h
 int  10h
 end;

Пока примите, как факт, что для вызова Операционной системы, BIOS или
других программ обычно используются вот такие вот записи(команды):

 mov ax,0013h - это пример ЗАДАНИЯ ПАРАМЕТРОВ, передаваемых другим
программам;
 int 10h - это ВЫЗОВ других программ Вашей машины - здесь это вызов BIOS.

 {Ожидаем нажатия клавиши}
 asm
 mov  ah,0
 int  16h
 end;

 mov ah,0 - это пример ЗАДАНИЯ ПАРАМЕТРОВ, передаваемых другим
программам;
 int 16h - это ВЫЗОВ других программ Вашей машины - здесь это вызов BIOS.

Итак, вернемся к тем командам, которые откомментарены как " {Рисуем - раз}"
и "{Рисуем - два}". Попытайтесь понять, чем они похожи, а чем отличаются...

... Вы должны были заметить, что вот эти команды:

 mov  byte ptr es:[320*10+10],12
 mov  byte ptr es:[320*10+11],12
 ...

в более общем виде можно записать как:

mov byte ptr es:[Что-то],Еще что-то.

Попробуйте самостоятельно поменять эти "Что-то" и "Еще что-то" у нескольких
команд. Посмотрите на результат. Создайте еще несколько подобных  команд.
Проявите фантазию в разумных пределах и насоздавайте еще разных
подобных команд.
Попытайтесь сделать самостоятельно какие-то обобщения по результатам.

А теперь небольшое задание. Исходный пример рисовал нам красный квадратик в
верхнем левом углу экрана. Попробуйте на основе полученного опыта ТОЛЬКО с
помощью команд типа:

mov byte ptr es:[Что-то],Еще что-то.

нарисовать синий прямоугольник, но уже в нижнем правом углу экрана.
Подсказка: обратите внимание вот на этот комментарий:

{Устанавливаем графический режим монитора 13h, 320x200, 256 цветов}

Урок 1 закончен. Решение и некоторые объяснения будут даны в
уроке 2. Да пребудет с Вами Великая Сила !

Урок 2. Основные понятия. Микропроцессор 8086. Решение примера Урока 1
на основе полученных знаний. Косвенная адресация: первый пример.

Итак, начнем этот урок с очень важной штуки. Введем основные определения,
которых будет немного, они будут просты... но это будут самые важные понятия
во всем этом деле !
Итак, чего вообще мы хотим ? Мы хотим научиться разговаривать с Машиной на ее
языке. Поэтому дадим понятие КОМПЬЮТЕРА(Машины), именно так, как она будет
выглядеть для Вас при программировании на ассемблере:

МАШИНА - нечто, состоящие из ПРОЦЕССОРА, ОПЕРАТИВНОЙ ПАМЯТИ и ПОРТОВ
ВВОДА-ВЫВОДА. ПРОЦЕССОР умеет выполнять ПРОГРАММЫ. Раскроем детальнее эти
понятия:

- ОПЕРАТИВНАЯ ПАМЯТЬ: набор ячеек, в котрые можно записывать числа и из которых
можно читать числа.
- ПОРТЫ ВВОДА-ВЫВОДА: набор ячеек, в котрые можно записывать числа и из которых
можно читать числа.
- ПРОЦЕССОР: функция, понимающая и реализующая числа, записанные
в ОПЕРАТИВНОЙ ПАМЯТИ как действия (КОМАНДЫ).
Выполнение команд назовем ПРОГРАММОЙ.

Итак, это важно !!! - нет никаких жестких дисков, джойстиков, мышей ... Есть только
ПРОЦЕССОР, ОПЕРАТИВНАЯ ПАМЯТЬ и ПОРТЫ ВВОДА-ВЫВОДА. Любое наше действие
будет направлено ТОЛЬКО на работу с этими тремя объектами.

Итак, мы определились: есть ОПЕРАТИВНАЯ ПАМЯТЬ, в ней храняться числа, ПРОЦЕССОР
обрабатывает эти числа и выполняет действия, заданные этими числами. Очевидно из
данных нами определений, что эти действия(КОМАНДЫ) в любом случае могут быть
направлены ТОЛЬКО на измение(чтение/запись) ОПЕРАТИВНОЙ ПАМЯТИ и
(или) ПОРТОВ ВВОДА-ВЫВОДА, либо на изменение состояния самого ПРОЦЕССОРА.

В общем виде КОМАНДУ можно представить в таком виде:

Что_Делать:<Как Делать>.

Как_Делать может быть пропущенно(<...>), ибо Что_Делать: ничего не делать
не требует дополнительных сведений. Да, есть такая команда - Ничего_Не_Делать.
Пример из жизни: команда "Лежать" также не требует дополнительных данных.

Таким образом, процессор читает ОПЕРАТИНВУЮ ПАМЯТЬ и трактует прочитанные
числа как команды. Поняв команду, он выполняет заданные в ней действия.
Команды, как уже было сказано, могут сводится к одному или нескольким
из следующих действий:

- Ничего не делать;
- Изменить что-то в ОПЕРАТИВНОЙ ПАМЯТИ;
- Изменить что-то ПОРТАХ;
- Изменить состояние процессора.

Что значит "Изменить что-то в оперативной памяти" ? Это означает изменить те числа,
которые в ней находятся: прочесть их или записать новое значение числа. То же самое
и с портами ввода-вывода.
Что означает "Изменить состояние процессора" ? Это означает повлиять на то, как он будет
трактовать(исполнять, выполнять) КОМАНДЫ.

Вернемся к второй части КОМНАДЫ - "Как Делать". Очевидно, что в ней должно содержаться
указание на область ОПЕРАТИВНОЙ ПАМЯТИ, если мы хотим ее читать/записывать, либо указание
на область ПОРТОВ, если мы хотим читать/записывать в них. Поэтому введем понятие
ЭФФЕКТИВНОГО АДРЕСА - указатель на конкретный элемент памяти, портов или процессора.

Теперь хватит теории, перейдем к  практике. Мы работали в Уроке 1 и будем работать в ближайшее
время с конкретным процессором - 8086 фирмы Intel, выпущенным еще в конце 70-х годов.
Процессор этот выполняет команды, записанные в опеределенного вида памяти, и может,
выполняя команды, изменять определенного вида порты ввода-вывода.
Память эта также есть набор ячеек, в которые можно записывать числа. Каждая ячейка
может хранить числа от 0 до 255. Порты также являются ячейками, в которые можно записывать
/из которых можно читать числа от 0 до 255.
Как храняться числа в этих ячейках ? Каждая из них состоит из 8 так называемых бит. Бит - это нечто,
могущее быть только в двух состояниях  - 0/1(Да/Нет,Триггер ... - как Вам нравиться).
Вспомним, что любое целое и неотрицательное число (0,1,2..10000...) можно разложить по степеням
двойки:

 25 = 16+8+1 = 1*2^4 + 1*2^3 + 0*2^2 + 0*2^1 + 1*2^0 = 1*16+1*8+0*4+0*2+1*1.

Итак, если мы будем трактовать 8 бит каждой такой ячейки, называемой байтом, как
коэффициенты при степени двойки, то получим возможность раскладывать числа
по 8-ми различным степеням:

2^7,2^6... 2^0.

Иначе говоря, каждое число в каждой ячейке оперативной памяти 8086 реализовано
определенным состоянием всех восьми бит этой ячейки:

Число:
         25  65  128  255
Бит0   1    1    0       1
Бит1   0    0    0       1
Бит2   0    0    0       1
Бит3   1    0    0       1
Бит4   1    0    0       1
Бит5   0    0    0       1
Бит6   0    1    0       1
Бит7   0    0    1       1.

Каждая такая ячейка называется байтом.

Итак, в 8086 записываются числа в оперативную память. Процессор может читать
эти числа, трактовать их как команды, понимать из команды, какую ячейку памяти ему
нужно изменять. Как же он это делает ? Очевидно, что ему надо знать
ЭФФЕКТИВНЫЙ АДРЕС команды, ЭФФЕКТИВНЫЙ АДРЕС ячейки, которую указано
поменять в ПАМЯТИ или ПОРТАХ. По большому счету, ЭФФЕКТИВНЫЙ АДРЕС - это номер
ячейки(номер байта) в памяти или портах. Нумерация от нуля. Например, байт(ячейка)
номер 20 содержит значение 22.
Как же процессор формирует этот ЭФФЕКТИВНЫЙ АДРЕС ? (Иными словами, где
хранится и как вычисляется номер байта) ?
Как ни странно, но он делает это весьма замысловатым образом: в процессоре имеются
так называемые РЕГИСТРЫ - это тоже ячейки "памяти" самого процессора,
но размером в СЛОВО(два байта). Можно сказать, что у Процессора есть своя небольшая
память, состоящая из набора слов. Если байт - это ячейка из восьми бит, то слово содержит
целых 16 бит, и в него можно записывать числа от 0 до 65535(посмотрите, как хранятся
числа в ячейках-байтах и поймите, какие числа можно хранить в ячейках из 16 бит). Имея
около десятка таких ячеек-слов, процессор использует некоторые из них для вычисления
ЭФФЕКТИВНОГО АДРЕСА. Вы можете подумать, что номер ячейки памяти, содержащую
текущую выполняемую команду, просто храниться в одном из РЕГИСТРОВ, а после
выполнения текущей команды в него заносится номер следующей команды:

Команда1    Байт1, Байт2,Байт3 команды 1. Номер ячейки  - 230 (Номер байта1).
Регистр_Текущей_Команды равен 230.

После выполнения команды1 процессор начнет выполнять команду2:

Команда2    Байт1, Байт2 команды 2. Номер ячейки  - 233 (Номер байта1).
Регистр_Текущей_Команды равен 233 ?

В какой-то мере у процессора 8086 это так, но в точности - не так !

Скажем вот что: процессор 8086 может работать с памятью размером
в один Мегабайт(примерно миллон ячеек по одному байту). Команды или
какие-то вспомогательные числа могут быть размещены в любой ячейке
с номером от 0 до ~1 миллиона. Т.е. номер текущей выполняемой команды
может быть в этом диапазоне. Процессор может использовать для хранения
этого номера один или несколько из своих регистров размером в слово. Вот
эти регистры, которые есть у него(все они размером в слово):

Сокращенное имя/Полное имя

IP - Instruction Pointer;
CS - Register of Code Segment;
SS - Register of Stack Segment;
SP - Stack Pointer;
ES - Register of Extra Segment;
DS - Register of Data Segment;
AX - Accumulator;
BX - Base Register;
CX - Counter
DX - Data Register;
SI - Source Register;
DI - Destination Register;
BP - Base Pointer;
FLAGS - Flags Register.

Итак, имеем этот набор регистров. Каждый размером в слово. Не обращайте
пока внимание на их названия. Прикинте, как процессор хранит номера ячеек памяти
в них.

Вы могли догадаться, что для хранения номера ячейки недостаточно любого
одного регистра из-за того, что размер памяти 8086 = 1 миллион > максимальное
число, которое можно хранит в одном слове - 65535. Два будет абсолютно достаточно,
ибо число ~один миллион легко раскладывается по степеням двойки вплоть до 20 степени,
а, значит, нам достаточно иметь всего 20 бит для его хранения ... А два регистра
обладают уже 32 битами. Например, можно придумать такую схему размещения
номера байта(ЭФФЕКТИВНОГО АДРЕСА) в двух регистрах:

1-ый регистр - 16 младших(первых) битов числа ЭФФЕКТИВНОГО АДРЕСА;
2-ой регистр - 4 старших(вторая часть) битов.

Но это не так !!! Вот что делает этот хитрый процессор: он использует действительно
два регистра, но значение одного из них он умножает на 16 и к полученному значению
прибавляет значение из другого регистра или самой команды непосредственно:

ЭФФЕКТИВНЫЙ АДРЕС = Регистр1 x 16 + Регистр 2(или непосредственное значение).

Возьмем команду из Урока 1:

 mov  byte ptr es:[320*10+10],12

Эта команда предназначена для того, чтобы записать в ячейку памяти номер
658570 числа 12. Смотрите, что в этой команде задано:

Что_Делать: Записать число в память.
Как Делать:
Число взять из самой команды - 12;
Адрес памяти вычислить, используя регистр es и непосредственное значение,
указанное в команде - 320*10+10;
Размер применика(числа в памяти для записи) - один байт.

Сейчас обратим внимание ТОЛЬКО на то, как 8086 ухитрился вычислить адрес
ячейки памяти из этой команды. Смотрите:

Регистр1 = Регистр ES(в команде так и задано)
Непосредственное значение для прибавки = 320*10+10 (тоже задано в команде)

ЭФФЕКТИВНЫЙ АДРЕС = ES x 16 + 320*10+10 = 658570.
Кто же задал значение регистра ES Ясно дело, что мы ! Мы контролируем
весь процесс выполнения программы процессором ! А как мы это сделали ?
А вот как:

 mov  ax,0A000h
 mov  es,ax

Мы тут задали значение регистра ES - 0A000h = 40960.
Теперь Вы понимаете, что меняя "Что-то" в командах Урока1:

mov byte ptr es:[Что-то],Еще что-то

вы меняли Адрес Ячейки Памяти !

А вот решение задания:

 mov  byte ptr es:[320*160+110],9
 mov  byte ptr es:[320*160+111],9
 mov  byte ptr es:[320*160+112],9
 mov  byte ptr es:[320*161+110],9
 mov  byte ptr es:[320*161+111],9
 mov  byte ptr es:[320*161+112],9
 mov  byte ptr es:[320*162+110],9
 mov  byte ptr es:[320*162+111],9
 mov  byte ptr es:[320*162+112],9

- синий квадратик.

Сейчас у Вас должно возникнуть еще больше вопросов, нежели после
первого урока !!! Но и должно появиться смутное ощущение ПАМЯТИ,
которой Вы можете управлять такими вот командами.

А теперь - на закуску - Косвенная адресация !!!
Уже было сказано, как 8086 может вычислять адрес в памяти:

ЭФФЕКТИВНЫЙ АДРЕС = Регистр1 x 16 + Регистр 2(или непосредственное значение).

Только что мы видели, как он использует непосредственное значение, взятое
из команды. А теперь поглядите, как можно заставить процессор использовать
второй вариант - через использование двух регистров:

 mov  bx,320*180+100 {Заносим значение(число) 320*180+100 в регистр BX}
 mov  byte ptr es:[bx],2 {Изменим память, используя ДВА регистра для адресации}

В последней команде эффективный адрес будет вычислен так:

ЭФФЕКТИВНЫЙ АДРЕС = ES x 16 + BX.

Теперь попробуйте использовать для рисования комнады, использующие
такой способ адресации, например:

{Рисуем - три !!!}
asm
 mov  bx,320*180+100 {Заносим значение(число) 320*180+100 в регистр BX}
 mov  byte ptr es:[bx],2 {Изменим память, используя ДВА регистра для адресации}
 mov  bx,320*180+101 {Заносим значение(число) 320*180+101 в регистр BX}
 mov  byte ptr es:[bx],2 {Изменим память, используя ДВА регистра для адресации}
 mov  bx,320*180+102 {Заносим значение(число) 320*180+102 в регистр BX}
 mov  byte ptr es:[bx],2 {Изменим память, используя ДВА регистра для адресации}
end;

Если Вы выполните этот код, то должны увидеть маленькую зеленую полоску
внизу и посередине экрана.

Задание: попробуйте сделать эту полоску потолще и подлиннее, но используя
именно такие команды - mov byte ptr es:[bx]. Попытайтесь вместо таких команд
использовать уже известные Вам - типа mov  byte ptr es:[320*180+100],2.

Урок 2 закончен.  Некотрые объяснения будут даны в
уроке 3, но вопросов должно быть немеряно !!!
Да пребудет с Вами Великая Сила !

Привет!! Уроки - просто супер! Вот у меня вопрос
В пакете Tasm в отладчике td.exe для отладки существует много способов (пошаговые, бреакпоинтовский и т.д.), для краткости это F4,F7,F8, ну и F9. Так вот чтобы прервать выполнение программы надо нажать сочетание Ctrl+F2 ( Program Reset). НО в режиме отладки F9 программа не останавливается   . Так надо??..Что-то я не пойму...
А отладчик версии 5.0 ( от 21.02.96), я его взял с нового диска   , хотя с тех пор он и не менялся....(ну я имею ввиду 16-разрядный из TASM'а)
Так как мне прервать выполнение программы?(из режима RUN)

Tut mnogo, kto hochet asm uchit. Mojet Chingachguku otdelnuiu formu sdelat? S temami ... Ia bi, naprimer, zahjodil. I primeri interesnie daet. Mojet knigu vipustit "Assembler Chingachguka". Vot eto tochno ne lamievo!

Цитата

AXEL3323 Дата сообщения: 26.3.2002,08:16 Привет!! Уроки - просто супер! Вот у меня вопрос   В пакете Tasm в отладчике td.exe для отладки существует много способов (пошаговые, бреакпоинтовский и т.д.), для краткости это F4,F7,F8, ну и F9. Так вот чтобы прервать выполнение программы надо нажать сочетание Ctrl+F2 ( Program Reset). НО в режиме отладки F9 программа не останавливается    . Так надо??..Что-то я не пойму... А отладчик версии 5.0 ( от 21.02.96), я его взял с нового диска   , хотя с тех пор он и не менялся....(ну я имею ввиду 16-разрядный из TASM'а) Так как мне прервать выполнение программы?(из режима RUN)

Из режима RUN можно использовать CTRL_BREAK. Но !
Если, к примеру, в программе написать замкнутный цикл:

@@Label: jmp @@Label

То нажатие этих клавиш не всегда прервет программу внутри этого кода Потому, что еще выполняются прерывания ...
Отладчик может остановить работу программы двумя способами: установить свой обработчик на клавиатуру(это и есть CTRL_BREAK), но бывает код, вырубающий прерывания/маскирующий прерывания от клавиатуры, а также установить брейкпойнты (это и есть F4...).
Видимо, ты пытаешься отладить программу, которая, к примеру, где-то виснет и ты хочешь, нажав CTRL_F2, ее скинуть, узнав где она зависла ? Рекомендую действовать методом приближения к "багу": устанавливаешь брейки и постепенно доходишь до неверного кода.

Цитата

neutrino Дата сообщения: 26.3.2002,12:12 Tut mnogo, kto hochet asm uchit. Mojet Chingachguku otdelnuiu formu sdelat? S temami ... Ia bi, naprimer, zahjodil. I primeri interesnie daet. Mojet knigu vipustit "Assembler Chingachguka". Vot eto tochno ne lamievo!

Хе, да я в жизни ничего подобного не делал, у меня даже своей странички нету Хотя, может быть, дойдут руки...
К тому же я счас помогаю развивать вот этот сайт http://hi-tech.nsys.by/ - он целиком по асму.

Da, sait nichego, osobenno fanariki na solnechnih batareikah ponravilis. No dolgo gruzitsia.  

Урок 3. Продолжаем работать с памятью. Первый цикл. Изучение
двухкомпонетного адреса.

Упс, как говорит Б.Спирс, ай дид ит эгейн. Ну и мы тоже эгейн. В смысле, снова
поработаем с памятью.
Итак, память. Памяти у нас примерно миллион ячеек по 1 байту. Где-то находятся
байты нашей программы, которую процессор сейчас читает байт за байтом и выполняет,
где-то байты программ БИОС-а, где-то - ДОС-а. Ну а начиная с байта нумер 655360
находится так называемый видеобуфер. Можно сказать по-другому - с номера A0000h.
Это - шестнадцетеричная система исчисления. Эти числа равны: 655360=A0000h, просто они
записаны по-разному. Здесь мы не будем подробно разбирать эту систему, приведем только
пример преобразования числа A0000h в "нормальный" вид:

A0000h = A*16^4+0*16^3+0*16^2+0*16^1+0*16^0 = 10*16^4 = 655360.

h - просто обозначение такой системы исчисления;
A = 10, B = 11, C = 12, D = 13, E = 14, F = 15 - поскольку основанием является 16, то для записи
числа НЕ ХВАТАЕТ чисел "привычной" десятичной системы - 0,1,2,3..9.
Вы вполне можете обойтись виндовым или любым другим калькулятором для
такого рода преобразований.
Ага, так что же такое видеобуфер ? Он же - видеопамять, видеокарта, ... Для
нас нет никаких железок, джемперов, жестких дисков, повторяю !
Есть только память, порты и процессор. Видеобуфер для нас в данном
случае - просто КУСОК ПАМЯТИ. Начинается с байта номер A0000h. Почему же мы
выделяем этот кусок особо ? А вот почему: помните, у нас в Уроке 1 был такой код:

 {Устанавливаем графический режим монитора 13h, 320x200, 256 цветов}
 asm
 mov  ax,0013h
 int  10h
 end;

Всего две команды, а делают сколько ! После их выполнения БИОС сделает так, что
всякая запись чисел в этот видеобуфер приведет к изменениям на мониторе !
Как это происходит ? С нашей стороны "забора" мы пишем в ячейки этого куска памяти
числа. Они там и остаются, пока их не изменить. С другой стороны "забора" сидит
аппаратура, "железо", как ее еще называют, которая СОВЕРШЕННО НЕЗАВИСИМО от
выполнения наших программ начинает трактовать эти числа КАК ЦВЕТА ТОЧЕК монитора.
Это ее БИОС так заставил делать. Переключил в такой режим. Бывают и другие режимы
работы видеокарты-видеоаппаратуры - текстовые там, графические ... Мы в графическом.
Но это все нам неважно. Важно нам только то, как надо писать в эту память числа, чтобы
аппаратура эта нарисовала на их основе изображение на мониторе.
Более детально. Вспомним, что режим у нас - 320x200, 256 цветов. 320 точек по
горизонтали, 200 - по вертикали. Каждая точка может иметь 256 различных цветов.
1 байт памяти как раз может иметь 256 различных состояний. Число в байте номер
A0000h аппаратура трактует как цвет верхнего левого пикселя, число в следующем
байте - как цвет следующего(двигаясь направо) пикселя и так далее. На одну строчку
320 пикселей - значит, и в памяти 320 байт. 321 байт начиная с байта A0000h - это уже
самый левый пиксель второй стороки и так далее:

Номер пикселя по
горизонтали/вертикали - номер байта в памяти
       0             1                2              3
0  A0000h  A0000h+1 A0000h+2 A0000h+3 ...
1  A0000h+320...
2
...

Ага. Нетрудно сообразить, что для всех 320x200 точек монитора требуется
320x200 = 64000 байт памяти. Например, запись в байт с номером
A0000h+320x200-1 приведет к изменению цвета нижнего правого пикселя.
Проверим это. Нарисуем вертикальную горизонтальную линию на мониторе,
желтого цвета, по самой первой строке от левого до правого края монитора.
От уха до уха, так сказать. Для этого мы должны записать
число 14(желтый цвет) в байты с номерами
A0000h,A0000h+1... A0000h+319 - всего 320 последовательных байт.
Вспоминаем, как процессор может делать это:

 mov  ax,0A000h {Заносим в регистр AX число 0A000h}
 mov  es,ax {Копируем число из регистра AX в регистр ES, фактически - 0A000h}
 mov  byte ptr es:[0],14 {Записываем по адресу 0A000hx16+0 байт значением 14}
 mov  byte ptr es:[1],14 {Записываем по адресу 0A000hx16+1 байт значением 14}
 mov  byte ptr es:[2],14 {Записываем по адресу 0A000hx16+2 байт значением 14}
 ...

Не надоело ? Верно, надо делать цикл. Как и в других языках программирования,
в асме тоже есть циклы. Что же за цикл нам нужен ? Цикл из 320 повторений,
в цикле должен вертеться индекс, позволяющий нам записывать СМЕЩЕНИЕ
адреса в команде от 0 до 319. СМЕЩЕНИЕ - это та часть эффективного адреса,
который процессор вычисляет из команды и добавит его к СЕГМЕНТНОМУ
регистру, умноженному на 16:

 mov  byte ptr es:[1],14
 Эффективный адрес =             es * 16           +         1
                                        СЕГМЕНТНАЯ ЧАСТЬ    СМЕЩЕНИЕ.

В этой команде смещение указано явно. Жестко. Сколько бы раз мы не выполнили
эту команду, она запишет байт 14 в одну и ту же ячейку памяти. Если только не
менять значение сегментного регистра es. Почему бы нам не поменять его ?
А вот, например, почему: нетрудно заметить, что ЛЮБОЕ значение в сегментном
регистре es при смещении = 1 нам НИКОГДА не позволит писать в ячеку памяти
номер A0000h(подумайте, почему !. Теперь вспомним, что в Уроке 2 мы проходили
так называемую КОСВЕННУЮ адресацию:

 mov bx,1
 mov byte ptr es:[bx],14 {Записываем по адресу 0A000hx16+bx байт значением 14}.

Процессор использовал для получения смещения регистр ! А регистры мы можем
менять ! Тогда начнем писать цикл:

 mov  ax,0A000h {Заносим в регистр AX число 0A000h}
 mov  es,ax {Копируем число из регистра AX в регистр ES, фактически - 0A000h}
 mov bx,0 {Смещение первой точки равно 0}
 mov byte ptr es:[bx],14
 ADD bx,1 {Добавить к регистру BX 1 !}

Вот, новая команда(ADD) ! До сих пор мы работали с одной командой засылки
значения - mov(от move, англ.). А команда "ADD" (addition, сложить) позволяет
добавлять к приемнику операции (здесь - регистр BX) значение источника - "1".
И регистр BX станет равен 1 !
Что же дальше ? Последуем классическому типу циклов:

repeat  
{Тело цикла}
Until {Условие=TRUE}

Очевидно, что телом цикла у нас выступает команда
закраски - mov byte ptr es:[bx],14. Командой add bx,1 мы изменили регистр BX
и можем анализировать его состояние (Условие=TRUE). Что же мы будем
анализировать ? Если мы хотим задать смещение от 0 до 319, то нам годятся
все значения bx в этом диапазоне, иначе цикл надо прерывать. Делаем это:

add bx,1 {inc(BX) или BX:=BX+1 или BX++}
CMP bx,319 {Сравнить BX и 319}
JBE МЕТКА_НАЧАЛА_ЦИКЛА - @repeat.

Опять, опять новые команды ! Не бойтесь, их вообще не так много, а выучить
их проще простого ! Я обязательно далее раскажу подробно о командах, а пока
лишь вкратце:

CMP bx,319 {COMPARE BX WITH 319}
JBE @repeat {JUMP IF BELOW OR EQUAL}

Вы видите расшифровку сокращений этих команд. CMP-это сравнение.
BX с 319. По результатам этого сравнения мы можем писать команды
переходов. А фактически - приказать процессору перейти на конкретную
команду, да еще и в зависимости от результата сравнения - JBE.
А вот как выглядит весь код:

begin
 {Устанавливаем графический режим монитора 13h, 320x200, 256 цветов}
 asm
 mov  ax,0013h
 int  10h
 end;
 asm
 {Кусок рисования}
 mov ax,0A000h
 mov es,ax
 mov bx,0
@Repeat:
 mov byte ptr es:[bx],14
 add bx,1
 cmp bx,319
 jbe @Repeat
 {Кусок рисования - Закончен}
 end;
 {Ожидаем нажатия клавиши}
 asm
 mov  ah,0
 int  16h
 end;
 {Устанавливаем текстовый режим монитора 03h, 80x25, 16 цветов текста и фона}
 asm
 mov  ax,0003h
 int  10h
 end;
end.

Примечание ! Обратите внимание, что я выделил комментарием содержательную
часть кода, назвав его "Кусок рисования". Далее я не буду приводить весь текст
этой небольшой программы, Вам досточно будет заменить только код, названный
"Кусок рисования". Остальные команды нам пока непонятны и не будут меняться
ближайшее время.

Выполните этот код. Убедитесь в наличии желтой полосы вверху экрана.

Метка начала цикла у нас называется @Repeat. Почему вначале @ ?
Это особенность asm-вставок языка Паскаль. В настоящем ассемблере
Вы можете извращаться так, как вам хочется, хотя это ограничение не слишком
сильное. Вы могли назвать метку @MY_LABEL. Важно одно: Вы сравнили командой
CMP регистр BX с 319, и, если его значение МЕНЬШЕ(BELOW) или(OR)
равно(EQUAL) 319, то передаете управление на эту метку.

Примечание: Вам должно быть непонятно, ОТКУДА команда JBE знает про
результаты выполнения команды сравнения (CMP).

Усложним слегка пример. Хочу, чтобы мы нарисовали желтую полосу не по
первой сверху строке, а по строке номер 160 ! Думаю, Вам понятно, где
начинаются байты, отвечающие этой строке:

Номер пикселя по
горизонтали/вертикали - номер байта в памяти
           0                                     1                               2
160  A0000h+160*320  A0000h+160*320+1 A0000h+160*320+2...

А это означает, что начальное смещение в цикле надо задать просто
не с нуля, а с 160*320:

 {Кусок рисования}
 mov ax,0A000h
 mov es,ax
 mov bx,160*320 {Начальное смещение !}
@Repeat:
 mov byte ptr es:[bx],14
 add bx,1
 cmp bx,160*320+319 {Внимание ! Мы изменили и эту команду !}
 jbe @Repeat
 {Кусок рисования - Закончен}

Воткните этот кусок вместо прежнего и выполните программу. Убедитесь, что
все хоккей - желтая полоса посреди экрана.

Важный момент:

 cmp bx,160*320+319 {Внимание ! Мы изменили и эту команду !}

У нас регистр BX уже меняется не от нуля ! И закончим мы рисовать не тогда,
когда он станет 320, а когда 160*320+320 !

А теперь еще навороченне !!! Мы можем задавать эффективный адрес, варьируя
две компоненты: сегмент и смещение. Только что мы сместили полосу на экране,
меняя смещение. Это было естественно, поскольку мы занесли в регистр es такое
число, что процессор, умножая его на 16, как раз втыкался в начало видеобуфера:

es * 16 = 0A000h * 16 = 0A0000h !

И нам было наглядно задавть смещение от нуля(словно индексация в массиве).
Но мы попробуем устроить себе трабл и использовать другое (не 0A000h)
значение, заносимое в сегментный регистр es, чтобы нарисовать ту же желтую
линию в 160 строке. Нам надо задавть в командах такие вот адреса:

Номер пикселя по
горизонтали/вертикали - номер байта в памяти
           0                                     1                               2
160  A0000h+160*320  A0000h+160*320+1 A0000h+160*320+2...

A0000h бралось ранее из es. Смещения - 160*320+0,1,2.. - из bx.
А можно ли задать так значение es, чтобы смещение, к примеру,
начиналось с 0 ? Вот так:

          0       1     2
160  X+0h  X+1 X+2... - ?

Здесь X - это неизвестное. Оно должно быть получено процессором так:

X = es*16

А ячейки памяти должны иметь одинаковые адреса:

X+0h = A0000h+160*320.

Решая это несложное уравнение, найдем, что X = AC800h = 706560.
Значит, es = AC800h / 16 = AC80h ! И измененный код готов:

 {Кусок рисования}
 mov ax,0AC80h
 mov es,ax
 mov bx,0 {Начальное смещение ! - опять нуль !}
@Repeat:
 mov byte ptr es:[bx],14
 add bx,1
 cmp bx,319 {Внимание ! Мы изменили и эту команду ! - вернули !}
 jbe @Repeat
 {Кусок рисования - Закончен}

Заделаем этот пример понагляднее ! Сначала нарисуем желтую полосу
в строке 160 "обычным" способом - занося перед циклом в регистр es число
0A000h, а потом нарисуем поверх желтой полосы фиолетовую, но уже занося
в es значение 0AC80h ! Вот кодец:

 {Кусок рисования}
 mov ax,0A000h
 mov es,ax
 mov bx,160*320 {Начальное смещение !}
@RepeatYellow:
 mov byte ptr es:[bx],14
 add bx,1
 cmp bx,160*320+319
 jbe @RepeatYellow
 {Остановим программу известным нам способом}
 mov  ah,0
 int  16h
 {Рисуем, но уже другим способом !}
 mov ax,0AC80h
 mov es,ax
 mov bx,0 {Начальное смещение ! - опять нуль !}
@RepeatMagneta:
 mov byte ptr es:[bx],13 {Цвет не желтый !}
 add bx,1
 cmp bx,319
 jbe @RepeatMagneta
 {Кусок рисования - Закончен}

Проверьте этот код !

Ну вот. А теперь я хочу, чтобы Вы выполнили два небольших заданьица:

1) Заполнить ВЕСЬ экран каким-нибудь цветом. Желательно - красным.
2) Нарисовать горизонтальную полосу зеленого цвета в 64 строке экрана:
    - занеся в регистр es адрес начала видеобуфера;
    - занеся в регистр es такое значение, чтобы рисовалась та же полоса в
      64 строке экрана, Но вот смещение Вы бы задавали с нуля !

Не возбраняется, а приветствуется появление Ваших решений до выкладки
Урока 4, где они будут приведены ! Будет неплохо поглядеть на Ваш код
и сделать обсуждам !

Урок 3 закончен.
Да пребудет с Вами Великая Сила !

прога заполняет весь экран красным цветом.


begin
{Устанавливаем графический режим монитора 13h, 320x200, 256 цветов}
asm
mov  ax, 00013h
int  010h
end;
asm
{Кусок рисования}
mov  ax, 0A000h
mov  es, ax
xor  di, di {обнуляем регистр di}
mov  al, 004h
mov  cx, 64000 {счетчик = 64000  =  320 * 200}
rep  stosb {выполняем 64000 раз команду stosb}
         {stosb - помещает значение регистра al в ячейку памяти es:di}
{Кусок рисования - Закончен}
end;
{Ожидаем нажатия клавиши}
asm
mov  ah,0
int  16h
end;
{Устанавливаем текстовый режим монитора 03h, 80x25, 16 цветов текста и фона}
asm
mov  ax,0003h
int  10h
end;
end.

а как тебе такой код?

Цитата

Melancholy Дата сообщения: 08.4.2002,13:24 прога заполняет весь экран красным цветом. {Кусок рисования} mov  ax, 0A000h mov  es, ax xor  di, di {обнуляем регистр di} mov  al, 004h mov  cx, 64000 {счетчик = 64000  =  320 * 200} rep  stosb {выполняем 64000 раз команду stosb} {stosb - помещает значение регистра al в ячейку памяти es:di} {Кусок рисования - Закончен}

Неплохо ! ж)
Видимо, ты знаешь ассемблер на каком-то уровне !
Всего одна ошибка: пропустил команду "cld"
Но код почти на 100% работает !

Правда, в уроке подразумевалось более "незамысловатое" решение.

А как насчет второго задания ?

Вариант 1
begin
{Устанавливаем графический режим монитора 13h, 320x200, 256 цветов}
asm
mov  ax, 00013h
int  010h
end;
asm
{Кусок рисования}
mov  ax, 0A000h
mov  es, ax
mov  di, 320*64
mov  al, 004h
mov  cx, 320
cld {между прочим вероятность, что флажек CF установлен очень мола!!!}
rep  stosb {выполняем 64000 раз команду stosb}
{Кусок рисования - Закончен}
end;
{Ожидаем нажатия клавиши}
asm
mov  ah,0
int  16h
end;
{Устанавливаем текстовый режим монитора 03h, 80x25, 16 цветов текста и фона}
asm
mov  ax,0003h
int  10h
end;
end.
Вариант 2
begin
{Устанавливаем графический режим монитора 13h, 320x200, 256 цветов}
asm
mov  ax, 00013h
int  010h
end;
asm
{Кусок рисования}
mov  ax, 0A000h + 20*64
mov  es, ax
xor  di, di
mov  al, 004h
mov  cx, 320
cld
rep  stosb {выполняем 64000 раз команду stosb}
{Кусок рисования - Закончен}
end;
{Ожидаем нажатия клавиши}
asm
mov  ah,0
int  16h
end;
{Устанавливаем текстовый режим монитора 03h, 80x25, 16 цветов текста и фона}
asm
mov  ax,0003h
int  10h
end;
end.

P.S. Что ты имеешь введу "почти на 100% работает"?

Ну что ж, все верно !

А под этими "почти 100%" я и имел в виду флажок направления.
Думаю, хоть вероятность и мала, но все-таки есть


ЗЫ А еще кто-нибудь сможет решить ?

Цитата(Chingachguk @ 08.4.2002, 17:06)

ЗЫ А еще кто-нибудь сможет решить ?

У меня есть старые наработки на асме - графические процедуры
для разных режимов...
Может кинуть сюда кое-что? Там и работа с портами...

Можешь кинуть и мне на мыло!
мой мыл

>Alex101  Написано: 28.5.2002,22:34    
>Цитата (Chingachguk @ 08.4.2002,176)
>>ЗЫ А еще кто-нибудь сможет решить ?
>У меня есть старые наработки на асме - графические процедуры
>для разных режимов...
>Может кинуть сюда кое-что? Там и работа с портами...

Вообще я пытался уроки написать ... До портов не дошло дело
Графика тут постольку поскольку - я ж не демки рисовать ...

Так что кидай рядом, видимо ! Тему создавай ! Или мне на мыл тоже
Может, и я в тему допишу И народ !

Ето круто, а как енту прогу в чистом асме оформить?

begin
{Устанавливаем графический режим монитора 13h, 320x200, 256 цветов}
asm
mov  ax, 00013h
int  010h
end;
asm
{Кусок рисования}
mov  ax, 0A000h
mov  es, ax
mov  di, 320*64
mov  al, 004h
mov  cx, 320
cld {между прочим вероятность, что флажек CF установлен очень мола!!!}
rep  stosb {выполняем 64000 раз команду stosb}
{Кусок рисования - Закончен}
end;
{Ожидаем нажатия клавиши}
asm
mov  ah,0
int  16h
end;
{Устанавливаем текстовый режим монитора 03h, 80x25, 16 цветов текста и фона}
asm
mov  ax,0003h
int  10h
end;
end.
Вариант 2
begin
{Устанавливаем графический режим монитора 13h, 320x200, 256 цветов}
asm
mov  ax, 00013h
int  010h
end;
asm
{Кусок рисования}
mov  ax, 0A000h + 20*64
mov  es, ax
xor  di, di
mov  al, 004h
mov  cx, 320
cld
rep  stosb {выполняем 64000 раз команду stosb}
{Кусок рисования - Закончен}
end;
{Ожидаем нажатия клавиши}
asm
mov  ah,0
int  16h
end;
{Устанавливаем текстовый режим монитора 03h, 80x25, 16 цветов текста и фона}
asm
mov  ax,0003h
int  10h
end;
end.

Цитата(neutrino @ 25.3.2002, 12:48)

Est takaia bolshaia kniga Toma Svana (Tom Swan) nazivaetsia "programmirovanie v Turbo Assembler". Ochen podrobnoe opisanie. Kucha primerov i poniatno napisannaia. Rekomenduiu.

Искал я на поисковиках строку "Том Сван" - не находит.   Может подскажешь где найти  

Chingachgukу пора писать книгу.Однозначно.

http://www.kalashnikoff.ru/

Вы и
WASM.RU
Незабывайте...

P.S
Чинганчук. Ах, незнал, незнал!!!
Чтож ты так скромничаешь?

Wasm оно ток недавно...эт 2 сайта слили...а он давно статьи писал на дZене

напиши по подробнее для чего нужна команда int

Как правило, в системе существуют одновременно кроме программы пользователя различные системные программы и обработчики прерывания.

Разумеется, это необязательно - можно писать самодостаточные программы, совершенно ни в ком не нуждающиеся.

Однако как правило программа запускается ОС и часто вызывает сервисы ОС. В свою очередь ОС вызывает программы БИОС(дос-семейства) или собственные обработчики (WinNT, Unix) или и те и другие (Win98) прерываний для доступа к устройствам (дискам, звуковой карте и проч.).

Как организовать вызовы таких обработчиков ? Ставим задачу: пусть выполняется программа пользователя и существуют аппаратные прерывания от таймера. При возникновении прерывания процессор (он не может выполнять одновременно несколько программ) должен "временно отложить" выполнение программы пользователя, выполнить некую "программу обработки события прерывания от таймера" и вернуться к выполнению основной программы; при этом он должен:

- обеспечить "прозрачность" работы программы-обработчика относительно программы пользователя, т.е. не нарушить работу основной программы;
- уметь вернуть управление пользовательской программе без разрушения оной.
- Знать, где находится программа-обработчик прерывания.

Начнем с конца. В процессоре 8086 для конкретизации места обработчиков прерываний в памяти в памяти начиная с адреса 0 расположена ТАБЛИЦА АДРЕСОВ обработчиков прерываний. Каждый адрес дальний (far), он состоит из сегмента обработчика и его смещения в этом сегменте. В таблице 256 элементов. Размер каждого адреса 4 байта: seg:offset. Заполняет эту таблицу адресами обработчиков кто угодно: bios - своими адресами, дос-другим, вирус - своими ;)

Аппаратно прерывания имеют свои номера: те процессор в момент прерывания знает лишь:

1) Произошло прерывание;
2) Номер прерывания.

Далее по номеру прерывания он вычисляет адрес обработчика по ТАБЛИЦЕ АДРЕСОВ:

Номер прерывания x 4 = Адрес в памяти Адреса Обработчика;

Извлекая найденный адрес, Он передает на него управление и запоминает в стеке адрес той точки основной программы, которая выполнялась на момент прерывания, чтобы вернуться к ней впоследствии, а также регистр флагов:

Действия процессора по сохранению контекста прерванной программы:

push  Flags
push  segment
push  offset

jmp   dword ptr 0000:[Номер прерывания x 4]

Вызванный обработчик прерывания может сразу же вернуть управление прерванной программе одной командой:

iret

Которая пользуясь сохраненным контекстом прерванной программы на стеке (выше) вернет управление:

Действия процессора по возвращению управлению прерванной программе:

Flags <- Флаги со стека
Восстановить стек
jmp на сохраненный адрес в стеке.

Таким образом, в памяти находятся программы, выполняющиеся в момент того или иного прерывания.

А теперь ответ на вопрос. Их можно вызывать программно. Те не процессор переключает задачу на них, а сам программист специальной командой int:

int NN, NN - Номер прерывания, опкод 0xCD,0xNN (2 байта).

После выполнения этой команды ДЕЙСТВИЯ ПРОЦЕССОРА АБСОЛЮТНО ЭКВИВАЛЕНТЫ его реакции на аппартное прерывание.

Разумеется, вызвать код обработчика можно не только командой int, а и call far, jmp far, retf... и т.д. Просто так удобнее ;)

Таким образом появляется возможность вызывать сервисы ОС, БИОС и всякие другие через Таблицу Адресов прерываний. Это удобно прежде всего тем, что вызов можно осуществить лишь ЗНАЯ НОМЕР ПРЕРЫВАНИЯ (иногда говорят "номер вектора") в отличии от того случая, когда вызов осуществляется по заданному адресу. Так, например в ОСь Linux осуществляется всего лишь вызовом int 80h в отличии от других Unix, где, к примеру, системную программу можно вызвать через дальний call:

call 0000007 ; Вызов системы в одном из unix.

ДОС может быть вызван по нескольким прерываниям:

int 20h, int 21h, int 23h, int 24h, ... ,int 25h, int 26h...

БИОС:

int 10h, int 13h, int 15h, ...

А вот в winNT можно вызвать систему также, в отличии от win98:

int 2Eh ; Вызов WinNT и ее наследников из пользовательского кода.

Почему в уроке 3 вы написали что видеобуфер начинаеться с A0000h, а в программе надо записывать 0A000h?

Потому, что в программе мы оперируем содержимым сегментного регистра для доступа к памяти:

mov  ax,0a000h
mov  es,ax

в то время как процессор вычисляет адрес ячейки памяти следующим образом:

Адрес = Сегментный регистр(es - тот, который используется) x 16 + смещение.

Собственно, об этом я и писал где-то тама ;)

Как  считать значение ячейки и вывести её значения на экран.Допустим 1beh  

Вот подпрограмма, которая позволяет сформировать изображение строки по адресу ds:[di] числа в регистре ax в шестнадцатеричном представлении:

HexChar proc near
 pusha ; Внимание: команды процессора 286. В паскале нужен ключ {G+}
 mov  cx,4
 mov  bx,offset TabHex
@GetHex:
 rol  ax,4
 push ax
 and  al,0fh
 xlat
 mov  [di],al
 inc  di
 pop  ax
 loop @GetHex
 popa
 retn
TabHex  db '0123456789abcdef'
HexChar endp

А вот пример вызова этой процедуры: пусть мы хотим вывести содержимое регистра es:


 mov  ax,es
 mov  di,offset MyString+4
 call   HexChar

MyString db 'es: ?$'

После этого мы можем легко вывести ее на экран:

 mov  ah,09h
 mov  dx,offset MyString
 int    21h

Win95chih модифицируйте а потом в нет выложите и все дела и будет мир играть в войну

Chingachguk, в чём различая вывода на экран в режиме записи 1 и 2, если можно, на примере поясни...

Цитата

Snick_Y2K Дата сообщения: 13.12.2002,00:24 Chingachguk, в чём различая вывода на экран в режиме записи 1 и 2, если можно, на примере поясни...

Я не совсем понял, что ты имеешь в виду. Если ты про то, что

Цитата

{Кусок рисования} mov ax,0AC80h mov es,ax mov bx,0 {Начальное смещение ! - опять нуль !} @Repeat: mov byte ptr es:[bx],14 add bx,1 cmp bx,319 {Внимание ! Мы изменили и эту команду ! - вернули !} jbe @Repeat {Кусок рисования - Закончен}

так тут (собственно, в уроке 3 про это и рассказывается) идет речь о том, в процессоре адрес ячейки памяти формируется из двух частей - регистров: сегментного и смещения:

Адрес = сегментный регистр * 16 + регистр смещения;

Причем смещение может быть задано в самой команде или же построено даже из комбинации нескольких регистров (максимум - 2-х) и смещения !

Таким образом, раз мы задаем адрес из двух частей, то мы можем играться обеими частями таким образом, то общий адрес будет одним и тем же !

Вот там-то и был пример этого: можем рисовать одно и то же (заносить в одну и ту же память числа) двумя способами(или большим числом):

1. Задав сегмент равным 0A000h:

Цитата

{Кусок рисования} mov ax,0A000h mov es,ax mov bx,160*320 {Начальное смещение = 160*320, линия 160} @Repeat: mov byte ptr es:[bx],14 add bx,1 cmp bx,319+160*320 jbe @Repeat {Кусок рисования - Закончен}

2. Так, как приведено выше, те в сегментный регистр заноситься другое число, но такое, что:

0A000h x 16 + 320*160 = 0AC80h x 16 + 0
    |                                  |
   es                                 es

Вот пример установки режима записи 2:

Код

MOV DX,3CEH  ;указываем на регистр адреса MOV AL,5  ;инедксируем регистр 5 OUT DX,AL  ;посылаем индекс INC DX  ;указываем на регистр режима MOV AL,2  ;выбираем режим записи 2 OUT DX,AL  ;устанавливаем режим

Код

;---рисуем красную точку в левом верхнем углу экрана MOV AX,0A000H  ;адрес буфера MOV ES,AX  ; MOV BX,0  ;указываем на первый байт буфера ;---установка регистра маски битов MOV DX,3CEH  ;указываем на адресный регистр MOV AL,8  ;регистр маски битов OUT DX,AL  ;адресуем регистр INC DX  ;указываем на регистр данных MOV AL,10000000B  ;маскируем все биты, кроме 7-го OUT DX,AL  ;посылаем данные ;---рисуем красную точку MOV AL,ES:[BX]  ;заполняем регистры задвижки MOV AL,4  ;красный цвет MOV ES:[BX],AL  ;рисуем точку

Режим записи 1:  

Код

;---копируем строку в следующую строку MOV CX,80  ;число байтов в строке MOV BX,0  ;начинаем с 1-го байта буфера MOV AX,0A000H  ;адрес буфера MOV ES,AX  ; NEXT_BYTE: MOV AL,ES:[BX]  ;заполняем задвижку MOV ES:[BX]+80,AL  ;выводим в следующую строку INC BX  ;переходим к следующему байту LOOP NEXT_BYTE  ;

с точкой всё выходит, но при попытке создать линию, в режиме записи 2 на экран выдается какая-то хрень, а точнее точки находящиеся на расстоянии, а в графическом режиме 0013h и того хуже...

Цитата(Chingachguk @ 09.11.2002, 11:40)

Вот подпрограмма, которая позволяет сформировать изображение строки по адресу ds:[di] числа в регистре ax в шестнадцатеричном представлении: ...

Если немного оптимизировать:

HexChar proc near
 pusha ; Внимание: команды процессора 286. В паскале нужен ключ {G+}
 mov  cx,4
;;  mov  bx,offset TabHex
@GetHex:
 rol  ax,4
 push ax
 and  al,0fh
;;  xlat
;; Тут:
 cmp  al, 10
 sbb  al, 69h
 das
;; ---
 mov  [di],al
 inc  di
 pop  ax
 loop @GetHex
 popa
 retn
;; TabHex  db '0123456789abcdef'
HexChar endp

to Snick_Y2K:

У меня где-то дома валялся код для работы с битовыми плоскостями, все никак не донесу ;) Но будет ! А в 13h режиме вроде тока палитру менять через порты можна ;) Точки делать нужно просто через mov(movs).

to NightGoblin:

Ага, это известная фича. А вот слабо оптимизнуть вот эта:

Цитата

; Форматирование десятичного числа  mov  di,offset NumBuff  xor  ax,ax  mov  al,[si].Head  call DecChar ... DecChar proc near  pusha  mov  cx,5  mov  bx,10000 @GetDec:  xor  dx,dx  div  bx  add  al,'0'  mov  [di],al  inc  di  push dx  xor  dx,dx  mov  ax,bx  mov  bx,10  div  bx  mov  bx,ax  pop  ax  loop @GetDec  popa  retn DecChar endp

2 Chingachguk:

Честно говоря, реально оптимизировать, наверное, действительно слабо Но я тут порылся немножко, нашел одно место... Если где приемник с источником спутаю - мне пришлось с Intel'а на AT&T переводить и обратно, так как с nasm разбираться, а тем более ставить DOS, лень... В общем, так должно быть немножко быстрее... Да, заодно сделал на 32-битных регистрах, так что максимальное значение числа 4G вместо 64K

Код

DecChar32 proc near pushad xor ecx, ecx mov cl, 10 mov ebx, 1000000000 GetDec32: xor edx, edx div ebx add al, 30h mov byte ptr [edi], al inc edi push edx mov eax, ebx mov edx, 429496730 mul edx mov ebx, edx pop eax loop GetDec32 popad ret DecChar32 endp

Вопрос: как наиболее универсально инициализировать звуковуху? То есть, предполагается, что в системе стоит нечто совместимое с SB и работа идет с ним или же нет?
Ситуация такая: был (и сейчас есть) эмуль ZX Spectrum под DOS в защищенном режиме. Хочется перевести его под DPMI, а винда его как раз поддерживает. В dos'е тоже можно запустить cwsdpmi.exe - и вот вам dpmi под dos. Так вот, в досе ясное дело как работать с звуковухой, а вот в винде он не везде эмулируется или эмулируется, но через зад.
Есть ли универсальный способ работы со звуковухой и в досе, и в виндах?

P.S. Если кто хочет, выложу всякие процедурки для работы с экраном.

P.P.S. А причем, извиняюсь, этот ... паскаль? Он к асму вообще никакого отношения не имеет, разве что только всего лишь поддерживает...

Цитата

Есть ли универсальный способ работы со звуковухой и в досе, и в виндах?

смотря какие винды, хотя лучше попробовать впихнуть в этот эмуль свои нормальные процедуры для работы со звуковой картой.

Цитата

P.S. Если кто хочет, выложу всякие процедурки для работы с экраном.

Говорю только за себя. Мне лично не нужно.

Цитата

P.P.S. А причем, извиняюсь, этот ... паскаль? Он к асму вообще никакого отношения не имеет, разве что только всего лишь поддерживает...

Не всем легко сразу пересесть на ассемблер, а когда знаешь паскаль, то с ассемблерными вставками проще понять как это работает(по крайней мере на первых порах).

Цитата

смотря какие винды, хотя лучше попробовать впихнуть в этот эмуль свои нормальные процедуры для работы со звуковой картой

Желательно любые винды. Но в 98-х поддержки SB в DOS-окне у меня почему-то нет (звуковуха - Audigy), а вот в XP есть, но с горем пополам. То есть, кто-то определяет, а кто-то нет, более того, звук, если и есть, то очень прерывистый, до тех пор, пока не повысишь приоритет до real time, но тогда уже ничего нельзя делать - просто сидеть и смотреть в экран...

Цитата

а когда знаешь паскаль, то с ассемблерными вставками проще понять как это работает

В смысле? Когда знаешь "волшебные" слова BEGIN и END ?

Цитата(ARTi @ 07.1.2003, 13:51)

Желательно любые винды. Но в 98-х поддержки SB в DOS-окне у меня почему-то нет (звуковуха - Audigy), а вот в XP есть, но с горем пополам. То есть, кто-то определяет, а кто-то нет, более того, звук, если и есть, то очень прерывистый, до тех пор, пока не повысишь приоритет до real time, но тогда уже ничего нельзя делать - просто сидеть и смотреть в экран...

Как правило, делается это через DMA - тогда таких проблем не будет. Общий принцип такой - пишешь в память кусок файла (.wav например), потом даешь звуковухе команду считывать данные оттуда через DMA (прямой доступ к памяти). Когда она доходит до конца, вызывает прерывание, обработчик которого пишет в память следующий кусок и так далее. Если очень надо, могу замылить файлик, воспроизводящий один .wav под DOS - не свой, правда, но, надеюсь, пойдет

NightGoblin
Спасибо, но я, в общем-то, в курсе . Просто в моей проге до этого даже дело не доходит (автодетект никак не может определить irq), а в других всяких там игрушках под дос, где, я думаю, все делается как раз правильно, звук прерывистый и искаженный.
В принципе, я вот думаю - ну сделаю я этот автодетект, но у меня, видимо, будет такой же искаженный звук как и везде. А привязываться именно к винде не хотелось бы.

[offtopic]

Кстати, я вот смотрю - книга Зубкова С. В. - хорошая, стало быть, штука, раз ее все примером приводят Я правда в ней опечаток нашел несколько штук (в кодах), но мне так тоже очень даже помогла в освоении этого нехитрого, но, вместе с тем, коварного языка

Да, книга Зубкова - достаточно крутая, вот если б ее лет эдак 7-8 назад...
А то все так: документаций нет - добываешь инфу кропотливым трудом и намеренными страданиями ;), а потом - бац! - так необходимая когда-то дока тут как тут!

Мне очень помогла книга В.Ю. Пирогова. До нее я асм знал, а писать не умел.

Вот это супер прога )

Код

asm @a1:cli jmp@a1 end;

Отключает свсе регистры компа...))
Хотя думаю это несложно. Сам я когда паскаль учисл (немного), интересовался асемблером т.к. на паскале изварённый метод работы с прерываниями, а асма удобнее...
правда сам почти нечего не знаю... но не чего, зато дельфи учу

Цитата

Отключает свсе регистры компа...))

Не регистры, а в win98 вводит в транс драйвер, вирутализирующий флаг прерываний VIF ;)
В NT++ это уже не работает. А в досе просто cli, @L:jmp @L достаточно.

мда сразу видно ассемблер знает =)
блин я разрываюсь...то дельфи, до ещё, что, та ассемблер=))

А вложенные циклы как можно сделать? Например, линии через одну нарисовать.

Народ, может быть будем задавать вопросы, типа:

Цитата

А вложенные циклы как можно сделать? Например, линии через одну нарисовать.

в отдельной теме? а здесь только будут уроки.

Цитата

Народ, может быть будем задавать вопросы, типа: QUOTE  А вложенные циклы как можно сделать? Например, линии через одну нарисовать.  в отдельной теме? а здесь только будут уроки.

Не, я думаю - нормально. Ведь он задал вопрос по урокам...

Вот вложенные циклы: с декрементом счетчика (cx) и инкрементом (si) ...

Цитата

const   StartX  = 50;   StartY  = 50;   LenLines = 70;   LinesNum =  5;   LinesCol = 35;   StepY    =  7; begin   {Устанавливаем графический режим монитора 13h, 320x200, 256 цветов}   asm   mov  ax,0013h   int  10h   end;   asm   mov  ax,0A000h   mov  es,ax   {Рисуем линиии через одну при помощи вложенных циклов}   mov  bx,StartY   mov  si,0 {Счетчик числа линий} @@OutLines:   {Вычисляем координату начала очередной линии: 320*y+StartX}   mov  ax,320   mul  bx   add  ax,StartX   mov  di,ax   mov  cx,LenLines   {Вложенный цикл}   @@OutLine:       mov  byte ptr es:[di],LinesCol       inc  di       dec  cx       cmp  cx,0       jnz  @@OutLine   {Переходим к следующей линии}   add  bx,StepY   inc  si   cmp  si,LinesNum   jb  @@OutLines   end;   {Ожидаем нажатия клавиши}   asm   mov  ah,0   int  16h   end;   {Устанавливаем текстовый режим монитора 03h, 80x25, 16 цветов текста и фона}   asm   mov  ax,0003h   int  10h   end; end.

Вот тоже написал
Жду замечаний, комментариев.
И вопрос- а как можно было бы соединять линиями эти точки, если использовать ещё и паскаль- то понятно, а на чистом ассемблере?

Код

const  col=10; begin asm  mov  ax,0013h  int  10h  mov ax, 0000h  int 33h  mov ax, 0001h  int 33h  mov bx,0A000h  mov es,bx @@Cic:  xor dx,dx  xor cx,cx  mov ax, 0003h  int 33h  shr cx,1  mov ax,320  mul dx  add ax,cx  mov bx,ax  mov byte ptr es:[bx],col  mov ax,bx  sub bx,1  mov byte ptr es:[bx],col  mov bx,ax  add bx,1  mov byte ptr es:[bx],col  mov bx,ax  sub bx,320  mov byte ptr es:[bx],col  mov bx,ax  sub bx,321  mov byte ptr es:[bx],col  mov bx,ax  sub bx,319  mov byte ptr es:[bx],col  mov bx,ax  add bx,320  mov byte ptr es:[bx],col  mov bx,ax  add bx,321  mov byte ptr es:[bx],col  mov bx,ax  add bx,319  mov byte ptr es:[bx],col  mov ah,01h  int 16h jz @@Cic  mov  ax,0003h  int  10h end; end.

Это сообщение отредактировал(а) Mikel - 26.2.2003, 03:28

Вот так:

Цитата

const   col=10;   colline=14; procedure line256(color:byte; x2,y2,x3,y3: word);   begin   asm   push bp   mov  si,x2   mov  dx,y2   mov  bx,x3   mov  ax,y3   push ax   push dx   mov  ax,dx   mov  di,320   mul  di   add  ax,si   mov  di,ax   pop  dx   pop  ax   sub  bx,si   sub  ax,dx   mov  si,bx   mov  bx,ax   mov  cx,si   mov  ax,bx   cmp  cx,0   jge  @1   neg  cx @1:   cmp  ax,0   jge  @2   neg  ax @2:   cmp  cx,ax   jae  @3   xchg cx,ax @3:   cld   mov  al,color   mov  bp,cx   test cx,cx   jz @@Ex @line:  push di         push ax         mov  ax,si         imul cx         idiv bp         add  di,ax         mov  ax,bx         imul cx         idiv bp         mov  dx,320         imul dx         add  di,ax         pop  ax         stosb         pop  di         loop @line @@ex:   pop bp   end;   end; var   StartFlag: byte;   CurrX:    word;   CurrY:    word;   LastX:    word;   LastY:    word; begin asm mov  ax,0013h int  10h mov ax, 0000h int 33h mov ax, 0001h int 33h mov bx,0A000h mov es,bx {Флаг: последней точки нет в начале} mov  StartFlag,0 @@Cic: xor  dx,dx xor  cx,cx mov  ax,0003h int  33h shr  cx,1 {Запоминаем координаты текущей точки} mov  word ptr CurrX,cx mov  word ptr CurrY,dx mov  ax,320 mul  dx add  ax,cx mov  bx,ax {mov  byte ptr es:[bx],col mov  byte ptr es:[bx-1],col mov  byte ptr es:[bx+1],col mov  byte ptr es:[bx-320],col mov  byte ptr es:[bx-321],col mov  byte ptr es:[bx-319],col mov  byte ptr es:[bx+320],col mov  byte ptr es:[bx+321],col mov  byte ptr es:[bx+319],col} {Проверяем, первое ли вхождение} cmp  byte ptr StartFlag,0 mov  byte ptr StartFlag,1 jz  @@NoDrawLastPoint {Рисуем линию от текущей точки к предидущей } {Оформляем стек вызова процедуры на языке Паскаль} mov  ax,colline push ax push word ptr CurrX push word ptr CurrY push word ptr LastX push word ptr LastY call line256 @@NoDrawLastPoint: {Запоминаем текущую точку} mov  cx,word ptr CurrX mov  dx,word ptr CurrY mov  word ptr LastX,cx mov  word ptr LastY,dx mov  ah,01h int  16h jz  @@Cic mov  ax,0003h int  10h end; end.

Следует заметить, что код процедуры line256 я писал давно, когда только начал изучение ассемблера ;)

Спасибо, Chingachguk, очень круто, мне понравилось, да... странно, ноя тоже взялся за етот непростой труд - туториалы Круто объясняешь, я по моему хуже...
:-((( мою версию покачто моно взять на
Моя версия

Спасибо, если дашь коментарий... можешь написать мне на [email protected]

Извини, что не посмотрел сразу, Dark

Обязательно гляну и отпишу !

Ну самое простое должно быть наверное вот так :

begin
{Устанавливаем графический режим монитора 13h, 320x200, 256 цветов}
asm
mov ax, 00013h
int 010h
end;
asm
{Кусок рисования}
mov ax, 0A000h
mov es, ax
mov bx,0
@rep:
mov byte ptr es:[bx],4
add bx,1
cmp bx,200*320-1
jbe @rep
end;
{Ожидаем нажатия клавиши}
asm
mov ah,0
int 16h
end;
{Устанавливаем текстовый режим монитора 03h, 80x25, 16 цветов текста и фона}
asm
mov ax,0003h
int 10h
end;
end.

sorry, я немного подтормозил с ответом... =)

Цитата

{Кусок рисования} mov ax, 0A000h mov es, ax mov bx,0 @rep: mov byte ptr es:[bx],4 add bx,1 cmp bx,200*320-1 jbe @rep end;

Это ты закрашиваешь весь экран красным цветом ? Да, можно и так. А можно и так:

Цитата

mov  cx,320*200 xor  di,di ; di=0 mov  al,4 ; al=color cld rep  movsb

или даже так:

Цитата

mov  cx,320*200/2 xor  di,di ; di=0 mov  ax,4+256*4 ; al,ah=color cld rep  movsw

А вот сможешь ли ты нарисовать линию в этом графическом режиме ? Входные данные: (X1,Y1) и (X2,Y2) - точки.

Киньте что-нибудь по написанию резидентов, а еще лучше, если кому не трудно, киньте код следующей проги , очень надо:

Сохранение/восстановление экрана
При нажатии одной из клавиш видеопамять текущей страницы текстового экрана(вместе с атрибутами) сохраняется в памяти. При нажатии другой комбинации клавиш в текущую видеостраницу загружается ранее запомненная копия.

Помогите, просто нет времени писать самому

Цитата

.286 VectorKeyboard equ 09h HotKey        equ 1208h ; alt+Scroll Lock, 0208h - left alt Color          equ 45    ; Color Of Frame text segment byte public assume cs:text,ds:text org  100h begin: ; Go to ini part   jmp  @@InitWatcher @@NewInt09Handler:   pusha   push ds   push es   push cs   pop  ds   MOV  AX,40h   MOV  ES,AX   xor  bx,bx   MOV  AX,ES:[0017h]   and  ax,HotKey ; AND  AL,3   cmp  ax,HotKey ; CMP  AL,3   JNZ  @Exit   XOR  TESTT,1   JZ  @@RestoreScreen   pusha   push ds   pop  es   push 0b800h   pop  ds   xor  si,si   mov  di,offset SavePage   mov  cx,80*25   cld   rep  movsw   push cs   pop  ds   popa   MOV  BH,Color   jmp  @@DisplayFrame @@RestoreScreen:   pusha   push 0b800h   pop  es   mov  si,offset SavePage   xor  di,di   mov  cx,80*25   cld   rep  movsw   popa @@DisplayFrame:   MOV  AX,1001h   INT  10H   call Sound @EXIT:   PUSHF   CALL DWORD PTR OLD_9H   pop  es   POP  DS   popa   IRET ; Sound proc Sound Proc near   pusha   mov  al,0B6H   out  43h,al   MOV  AX,0110dH   OUT  42H,AL   MOV  AL,AH   OUT  42H,AL   IN    AL,61H   OR    AL,3   OUT  61h,AL   xor  CX,CX @Wait:    loop  @Wait   and  AL,11111100b   OUT  61H,AL   popa   retn Sound Endp OLD_9H        dd ? TESTT          db 0 SavePage      db 80*25*2 dup(?) ; ; Initialization part ********************************************************* ; @@InitWatcher:   mov  dx,offset Start   call @@Message ; Set keyboard handler   mov  ax,(35H shl 8) + VectorKeyboard   int  21h        ; Get old HookedVector to es:bx   mov  word ptr OLD_9H,bx   mov  word ptr OLD_9H+2,es   mov  dx,offset @@NewInt09Handler   mov  ah,25h   int  21H        ; Set new Vector ; Terminate and stay resident   mov  dx,offset @@InitWatcher   int  27h @@Message:   mov  ah,09h   int  21h   retn Start          db 'Start !',13,10,'$' Text Ends end begin

Chingochguk ! Я прилежно исследовал первые 3 урока , сделал все домашние
задания и смиренно жду 4-й урок.

Хм. Я давно думал что-то написать в продолжение, вот только не решил, что именно. Смысл в том, что начальная теория, я считаю, изложена и далее должна идти практика. Практика позволит закрепить знания и улучшить технику. Вопрос в том, какая именно практика: порты ввода-вывода, работа с прерываниями, передача и получение параметров в/из ассемблерного кода из/в язык Паскаль (или Си) или вообще что-то типа написания кода загрузчика (MBR-сектор).

Вообщем, пишите Ваши пожелания - что именно Вы бы хотели узнать о Машине - и, возможно, мы сделаем это на языке ассемблера ;)

Помогите зарегистрированному Ламмеру с прогой Ассемблер!

Chingachguk, вот я бы хотел изучить работу с внешними устройствами - объяснишь заодно и порты, и прерывания =) А потом бы хотел загрузчик. Вот тебе пожелания - надеюсь, ты их осуществишь в ближайшем времени, за что я тебе заранее благодарен

О'кей ;)

Приянто к сведению ;)

Shuricksoft, на wasm.ru сейчас идет серия статей про загрузчики...