В этой главе мы рассмотрим основные принципы программирования модемов и приведем две коммуникационные программы.
Доступ к модему происходит через последовательный асинхронный порт. При этом для передачи модему команд их необходимо просто записать в регистр данных COM-порта, на котором находится модем. Ответ от модема также поступает через последовательный порт. Передавая модему команды, его можно проинициализировать, перевести в режим автоответа или заставить набрать номер.
Когда модем наберет номер удаленного абонента или когда модему в режиме автоответа придет вызов, он попытается установить связь с удаленным модемом. После установления связи модем передает компьютеру через COM-порт специальное сообщение (см. главу "Система команд hayes-модемов") и переключится из командного режима в режим передачи данных. После этого данные, передаваемые модему, перестают восприниматься им как команды и сразу передаются по телефонной линии на удаленный модем.
Итак, после установления связи с удаленным модемом, коммуникационная программа может начинать обмен данными. Обмен данными так же, как и передача команд, осуществляется через COM-порт. Затем при помощи специальной Escape-последовательности можно переключить модем из режима передачи данных обратно в командный режим и положить трубку (AT-команда ATH0), разорвав связь с удаленным модемом.
Принципы обмена данными с внешними устройствами через COM-порт представлены в главе "Программирование асинхронного адаптера".
Приведем последовательность действий для установления связи и обмена данными через модем.
Проводим инициализацию COM-порта, к которому подключен модем. Для этого программируем регистры микросхемы UART, задавая формат данных (число стоповых битов, длину слова) и скорость обмена. Заметим, что модем будет проводить соединение с удаленным модемом как раз на этой скорости. Чем скорость выше, тем, естественно, быстрее будет происходить обмен с удаленным модемом. Однако при увеличении скорости на плохих телефонных линиях сильно возрастает количество ошибок.
Передавая модему AT-команды через COM-порт, производим его инициализацию. При помощи AT-команд можно установить различные режимы работы модема - выбрать протокол обмена (CCITT или Bell), установить набор диагностических сообщений модема и т.д.
Передаем модему команду набора номера (ATD). В этом случае модем набирает номер и пытается установить связь с удаленным модемом. Или передаем модему команду ATS0 = 1 для перевода его в режим автоответа. После этой команды модем ожидает звонка от удаленного модема, а когда он приходит, пытается установить с ним связь (см. главу "Система команд hayes-модемов").
В зависимости от режима, в котором находится
модем, он может передавать компьютеру различные
сообщения. Например, если модем производит вызов
удаленного модема (AT-команда ATD), то модем может
выдать следующие сообщения:
CONNECT |
успешное соединение |
BUSY |
номер занят |
NO DIALTONE |
на линии отсутствует сигнал коммутатора
|
NO ANSWER |
абонент не отвечает |
NO CARRIER |
неудачная попытка установить связь |
Когда приходит звонок, модем передает
компьютеру сообщение RING, если регистр модема S0
равен нулю. В этом случае для ответа на звонок
надо послать модему команду ATA. Если модем
находится в режиме автоответа и регистр модема S0
не равен нулю, то модем автоматически пытается
ответить на звонок и может выдать следующие
сообщения:
CONNECT |
успешное соединение |
NO DIALTONE |
на линии отсутствует несущая частота от
удаленного модема |
NO CARRIER |
неудачная попытка установить связь. |
Если модем передал компьютеру сообщение CONNECT, значит, он успешно произвел соединение и теперь работает в режиме передачи данных. Теперь все данные, которые вы передадите модему через COM-порт, будут преобразованы модемом в форму, пригодную для передачи по телефонным линиям, и переданы удаленному модему. И наоборот, данные, принятые модемом по телефонной линии, переводятся в цифровую форму и могут быть прочитаны через COM-порт, к которому подключен модем.
Если модем передал компьютеру сообщения BUSY, NO DIALTONE, NO ANSWER, NO CARRIER, значит, произвести соединение с удаленным модемом не удалось и надо попытаться повторить соединение.
После окончания работы коммуникационная программа должна перевести модем в командный режим и передать ему команду положить трубку (ATH0). Для перевода модема в командный режим можно воспользоваться Escape-последовательностью "+++". После того как модем перешел в командный режим, можно опять передавать ему AT-команды.
Низкий уровень сигналов DTR и RTS сообщает модему, что компьютер не готов к приему данных через COM-порт.
При работе с асинхронным последовательным адаптером (COM-портом) вы можете использовать механизм прерываний. Глава "Программирование асинхронного адаптера" содержит теоретические сведения по этому вопросу, а в главе "Коммуникационная программа, использующая прерывания" содержится исходный текст коммуникационной программы, использующей прерывания для работы с COM-портом. Если ваша программа использует прерывания от COM-порта, она должна содержать обработчик прерываний, а также программировать контроллер прерываний для разрешения прерываний.
Так как передача и прием данных модемом представляют собой длительный процесс, то применение прерываний от COM-порта позволяет использовать процессорное время для других нужд.
Сейчас мы приведем, возможно, не очень полезную, но очень простую программу, работающую с модемом. Эта программа может только передавать команды модему. Принимать данные от модема и выполнять другие функции, присущие программам работы с модемом, она не может.
Программа работает следующим образом: сначала устанавливает сигнал DTR, который сообщает модему, что компьютер готов к обмену данными. Далее, не дожидаясь от модема ответного сигнала DSR, начинает передавать команды модему. После передачи всех символов команды модему передается байт с кодом возврата каретки, при приеме которого он выполняет посланную ему команду.
Отметим, что чтение кода возврата этой программой не выполняется, поэтому рано или поздно возникнет ошибка (переполнение буфера).
Приведем сначала исходный текст функций для управления линией DTR:
#include <stdio.h>
/**
*.Name dtr_on
*
*.Title Устанавливает сигнал DTR и RTS.
*
*.Descr Эта функция устанавливает сигналы DTR и RTS
* для заданного COM-порта.
*
*.Proto void dtr_on( unsigned base_address );
*
*.Params unsigned base_address - базовый адрес асинхронного адаптера
*
*.Return не используется
*
*.Sample dtr.c
**/
void dtr_on( unsigned base_address ) {
unsigned char MCR;
// считываем значение регистра управления модемом
MCR = inp( base_address + 4 );
// устанавливаем сигналы DTR и RTS в активное состояние
MCR |= 3;
// записываем новое значение в регистр управления модемом
outp( base_address + 4, MCR );
}
/**
*.Name dtr_off
*
*.Title Сбрасывает сигналы DTR и RTS.
*
*.Descr Эта функция сбрасывает сигналы DTR и RTS
* для заданного COM-порта.
*
*.Proto void dtr_on( unsigned base_address );
*
*.Params unsigned base_address - базовый адрес асинхронного адаптера
*
*.Return не используется
*
*.Sample dtr.c
**/
void dtr_off( unsigned base_address ) {
unsigned char MCR;
// считываем значение регистра управления модемом
MCR = inp( base_address + 4 );
// сбрасываем сигналы DTR и RTS
MCR &= 0xFC;
// записываем новое значение в регистр управления модемом
outp( base_address + 4, MCR );
}
Теперь приведем текст функции to_modem(), обеспечивающей передачу команд модему:
#include "sysp_com.h"
// объявления функций
void com_out( unsigned, char );
void to_modem( unsigned, char* );
/**
*.Name to_modem
*
*.Title Передает модему строку, оканчивающуюся нулем.
*
*.Proto void to_modem( unsigned base_address, char *out_str );
*
*.Params unsigned base_address - базовый адрес асинхронного адаптера,
* на котором находится модем;
*
* char *out_str - массив символов, передаваемый модему,
* заканчивается нулем
*
*.Return не используется
*
**/
void to_modem( unsigned base_address, char *out_str ) {
int i;
// последовательно передаем модему каждый символ из строки
for( i = 0; out_str[i] != '\0'; i++ )
com_out( base_address, out_str[i] );
// заканчиваем передачу строки и посылаем модему код
// возврата каретки, вызывающий исполнение введенной команды
com_out( base_address, 13 );
}
/**
*.Name com_out
*
*.Title Передает модему один символ.
*
*.Descr Эта функция передает один символ.
*
*.Proto void com_out( unsigned base_address, char out_char )( unsigned base_address, char out_char );
*
*.Params unsigned base_address - базовый адрес асинхронного адаптера,
* на котором находится модем;
*
* char out_char - символ, передаваемый модему,
*
*.Return не используется
**/
void com_out( unsigned base_address, char out_char ) {
unsigned char LCR, next;
// ожидаем, пока освободится регистр передатчика
// и можно будет передать следующий байт
for( next = 0; next == 0; )
next = 0x20 & inp( base_address + 5 );
// записываем передаваемый байт в регистр данных
// для последующей его передачи модему
outp( base_address, out_char );
}
Теперь перейдем собственно к самой программе. Как вы можете видеть, она содержит всего несколько строк на Си:
//TEST.C
#include <conio.h>
unsigned com_address( int );
void to_modem( unsigned, char* );
void dtr_on( unsigned );
void main(void) {
unsigned com_adr;
if(( com_adr = com_address( 1 )) < 0 ) exit( com_adr );
// передаем модему сигнал DTR
dtr_on( com_adr );
// набираем телефонный номер
to_modem( com_adr, "AT DP 411 64 17" );
// ожидаем нажатия на любую клавишу
getch();
// сбрасываем сигнал DTR
dtr_off( com_adr );
}
Теперь мы приступим к самому интересному - приведем подробный алгоритм коммуникационной программы, а затем - исходный текст такой программы.
Сначала мы рассмотрим вариант коммуникационной программы без использования прерываний от асинхронного порта. Этот вариант несколько проще, так как нам не надо создавать довольно нетривиальный обработчик для этого прерывания, а также программировать контроллер прерываний.
Итак, приступим. Как мы сказали ранее, первым шагом при программировании модема надо считать инициализацию COM-порта (микросхемы UART), к которому подключен модем.
Сначала надо перевести в неактивное состояние линии DTR и RTS, которые сообщают модему, что компьютер готов к обмену данными. Для этого надо записать нулевое значение в регистр управления модемом:
mov al,0 ; сбрасываем сигналы DTR и RTS
mov dx,MCR ; где MCR - адрес регистра управления модемом
out dx,al
jmp $+2 ; задержка
Затем сбрасываем регистры состояния линии, состояния модема и данных. Это достигается простым считыванием значений этих регистров:
; сбрасываем регистр состояния линии mov dx,LSR ; LSR - адрес регистра состояния линии in al,dx jmp $+2 ; задержка ; сбрасываем регистр состояния модема mov dx,MSR ; где MSR - адрес регистра состояния модема in al,dx jmp $+2 ; задержка ; сбрасываем регистр данных mov dx,DAT ; где DAT - адрес регистра данных in al,dx jmp $+2 ; задержка
Эти регистры необходдимо сбросить для того, чтобы в дальнейшем не мешали старые значения, которые могли остаться от работы других программ. Так, если программа, ранее работавшая с COM-портом, не считала из регистра данных байт, принятый через COM-порт, то он "дождется" запуска нашей программы и попадет в приемный буфер.
После того как мы сбросили регистры UART, можно приступить собственно к инициализации COM-порта. Во время инициализации задается формат данных - длина слова, количество стоповых битов, наличие контроля по четности и скорость обмена.
Для задания скорости обмена данными надо перевести регистр данных и регистр управления прерываниями в режим ввода значения делителя частоты тактового генератора. Этот режим устанавливается записью единицы в старший бит регистра управления:
// переводим регистр данных и регистр управления прерываниями
// в режим ввода значения делителя частоты тактового генератора
ctl = inp(LCR); // LCR - адрес регистра управления
outp(LCR_N, ctl | 0x80); // устанавливаем старший бит регистра
// вычисляем значение для делителя частоты (переменная baud
// определяет скорость обмена, которую мы хотим установить)
switch(baud) {
case 110: div = 1040; break;
case 150: div = 768; break;
case 300: div = 384; break;
case 600: div = 192; break;
case 1200: div = 96; break;
case 2400: div = 48; break;
case 4800: div = 24; break;
case 9600: div = 12; break;
case 19200: div = 6; break;
case 38400: div = 3; break;
case 57600: div = 2; break;
case 115200: div =1; break;
default: return(-1); break;
}
// записываем значение делителя частоты, младший байт в регистр
// данных, старший - в регистр управления прерываниями
outp(ICR, (div >> 8) & 0x00ff); // ICR - адрес регистра
// управления прерываниями
outp(DAT, div & 0x00ff); // DAT - адрес регистра
// данных
// переводим регистр данных и регистр управления прерываниями
// обратно в обычный для них режим
ctl = inp(LCR); // LCR - адрес регистра управления
outp(LCR, ctl & 0x7f); // сбрасываем старший бит регистра
Затем надо определить формат данных. Для этого записываем новое управляющее слово в управляющий регистр:
// записываем новое управляющее слово outp(LCR, 00000011B); // управляющее слово 00000011B устанавливает длину слова 8 бит, // один стоповый бит, отменяет проверку на четность и отменяет // режим фиксации четности (см. главу "Порты асинхронного адаптера")
Последним шагом в инициализации регистров UART можно считать установку регистра управления прерываниями. Хотя наша программа не использует прерывания COM-порта, мы должны специально указать последовательному адаптеру, что он не должен генерировать прерывания.
Чтобы запретить генерацию прерываний, надо просто записать значение ноль в регистр управления прерываниями:
// устанавливаем регистр управления прерываниями
outp(port_adr+ICR, 0); // ICR - адрес регистра
// управления прерываниями
На этом этап инициализации регистров UART можно считать законченным. Теперь COM-порт подготовлен для обмена через него данными с модемом, но модем пока еще не будет воспринимать данные от компьютера. Чтобы перевести его в рабочее состояние, ему передаются сигналы DTR и RTS, сообщающие, что компьютер готов к обмену данными. В ответ на эти сигналы модем должен вернуть компьютеру сигналы DSR и CTS (см. главу "Аппаратная реализация"):
// считываем значение регистра управления модемом mcr = inp( MCR ); // MCR - адрес регистра управления модемом // устанавливаем сигналы DTR и RTS в активное состояние mcr |= 3; // записываем новое значение в регистр управления модемом outp( MCR, mcr );
После этого уже можно передавать модему через COM-порт AT-команды. Таким образом, следующим этапом является уже непосредственно инициализация модема.
Когда выполнена инициализация регистров COM-порта, он готов к обмену данными с модемом. И мы можем передавать модему AT-команды и принимать от него ответ на них.
При инициализации модема с помощью AT-команд можно установить различные параметры и режимы работы модема. Например, можно управлять формой сообщений от модема (цифровая или словесная), включать и выключать динамик модема и т.д. Список таких команд представлен в главе "Система команд hayes-модемов".
Модем выполняет переданные ему команды и возвращает ответ, который вы можете прочитать через COM-порт, к которому подключен модем. Сообщения модема представлены в главе "Система команд hayes-модемов".
Выполнив инициализацию модема, можно перейти к процедуре установки связи. Существует два основных режима установки связи: активный вызов, когда модем сам набирает номер, и режим автоответа, когда модем находится в состоянии ожидания звонка от удаленного модема.
Для активного вызова модемом абонента надо послать модему соответствующую AT-команду. Например, для набора номера 926-76-34 модему посылается следующая команда:
AT DP 926-76-34 <CR>
Восприняв эту команду, модем сразу снимает трубку, набирает номер и пытается установить связь с удаленным модемом. Результат выполнения этой команды можно считать через COM-порт.
Ниже приведен фрагмент кода, который передает модему символы, принятые от клавиатуры и отображает на экране символы, принятые от модема:
while( 1 ) {
if( kbhit() ) {
// если нажата клавиша клавиатуры, считываем ее код
key = getch();
// по нажатию клавиши Esc выходим из данной функции
if( key == 27 )
exit(0);
// если пользователь нажал Enter, передаем модему
// символ перевода строки и возврата каретки
if( key == '\r' )
// посылаем символ в COM-порт
com_out( com_adr, 0xd );
else {
// отображаем символ на экране
putch( key );
// посылаем символ в COM-порт
com_out( com_adr, key );
}
}
// если получены данные от модема, отображаем их на экране
if( from_modem( com_adr, &ch_in ) == 0 )
putch( ch_in );
}
Если модем ответил сообщением CONNECT, значит, он удачно произвел соединение и переключился в режим обмена данными. Теперь для передачи данных удаленному модему их надо просто передавать в COM-порт, к которому подключен модем. Передача и прием данных выполняются так же, как передача команд и прием ответных сообщений от модема. Вы даже можете использовать для этого те же функции.
В случае режима автоответа, модем ожидает звонка от вызывающего модема. Если регистр модема S0 содержит значение ноль, то режим автоответа отключен и, если придет звонок из линии, модем, не снимая трубки, передаст компьютеру сообщение RING. Коммуникационная программа самостоятельно распознает это сообщение и при необходимости снимает трубку и установливает связь, передав модему команду ATA.
Если регистр S0 не равен нулю, то модем пропустит определенное этим регистром число звонков, а затем самостоятельно снимет трубку и установит связь с вызывающим модемом.
В остальном работа коммуникационной программы в режиме автоответа соответствует режиму активного вызова удаленного модема.
Обмен данными с удаленным модемом
Установив связь с удаленным модемом, оба модема переходят в режим обмена данными. Теперь можно начинать передавать и принимать данные. Так же как и в случае командного режима, в режиме обмена данными с удаленным модемом передача и прием данных осуществляются через COM-порт, к которому подключен модем.
В этой главе мы объединим все сказанное выше в одной программе. Программа состоит из следующих модулей:
S_CHAT.C // главная процедура программы COM_ADR.C // определение базового адреса регистров COM-порта RESET.C // сброс регистров микросхемы UART COM_INIT.C // инициализация COM-порта DTR.C // управление сигналами DTR и RTS TO_MODEM.C // передача данных модему через COM-порт EXCHANGE.C // организация диалога с удаленным модемом FROM_MDM.C // прием данных от модема через COM-порт DISP.C // функции для работы с видеопамятью TIMER.C // реализация временных задержек
Рассмотрим подробнее каждый модуль программы. Самый верхний уровень представляет модуль S_CHAT.C. Он содержит определение главной процедуры программы S_CHAT.
Отметим, что включаемые файлы, используемые в этой программе, приведены в приложении "Включаемые файлы для программ".
Модуль S_CHAT.C - это центральный модуль программы, он выполняет все действия по программированию модема и обмена данными с ним, вызывая функции из других модулей. Сначала процедура main() сбрасывает регистры микросхемы UART, вызывая функцию reset() из модуля RESET.C. После того как выполнен сброс регистров, вызывается функция com_init() из модуля COM_INIT.C, которая устанавливает скорость обмена и формат данных - число стоповых бит и режим проверки по четности.
Затем выполняется функция dtr_on(), определенная в модуле DTR.C. Эта функция посылает сигналы DTR и RTS, сообщающие модему о готовности компьютера к обмену данными.
На этом подготовительный этап можно считать завершенным. Теперь уже можно передавать модему данные через COM-порт. Так как при включении питания модем находится в командном режиме, то мы можем передавать ему AT-команды и устанавливать связь с удаленным модемом.
В этой программе при помощи функции to_modem(), определенной в модуле TO_MODEM.C, на модем подается команда "AT M1 DP 251 2762". Эта команда включает динамик модема (AT M1) и набирает номер (AT DP 251 2762). Если модем набрал номер, он переходит в режим обмена данными с удаленным модемом, а если связь установить не удалось (занят номер), модем остается в командном режиме.
Далее, независимо от того, установил модем связь или нет, вызывается функция exchange(), определенная в модуле EXCHANGE.C, которая позволяет передавать модему данные, набранные на клавиатуре, а принятые от модема данные отображать на экране дисплея. При этом нет разницы в том, в каком режиме находится модем. Если он в командном режиме, данные, введенные с клавиатуры, будут восприниматься модемом как команды, а если модем в режиме обмена данными - как данные (т.е. будут передаваться удаленному модему).
Вы можете убрать из программы передачу команды набора номера и сразу после установки сигналов DTR и RTS передавать управление функции exchange(). В этом случае для набора номера вам надо самому ввести с клавиатуры команду ATDP и нужный номер, а затем нажать клавишу Enter.
Для окончания работы программы вам достаточно нажать клавишу ESC. При этом происходит перевод модема в командный режим.
Перевод модема в командный режим осуществляется передачей ему специальной Escape-последовательности "+++". Для этого сначала выполняется временная задержка 2,5 секунды (продолжительность задержки определяется регистром модема S12, по умолчанию одна секунда). Затем при помощи функции com_out() из модуля TO_MODEM.C модему передаются три знака '+' и опять выполняется временная задержка. Временная задержка выполняется функцией delay(), определенной в модуле TIMER.C:
delay(2500); com_out( com_adr, '+' ); com_out( com_adr, '+' ); com_out( com_adr, '+' ); delay(2500);
После того как модем положил трубку, программа сбрасывает сигналы DTR и RTS. На этом выполнение программы завершается.
Итак, модуль S_CHAT.C:
// S_CHAT.C
// простая терминальная программа
#include <conio.h>
#include <time.h>
#include <graph.h>
#include "timer.h"
#include "sysp_com.h"
// используется COM-порт номер 3, для использования
// другого COM-порта измените эту директиву
#define COM_PORT 2 // COM3
// объявления функций
unsigned com_address( int );
int to_modem( unsigned, char* );
int dtr_on( unsigned );
int reset( unsigned );
void disp( char, char );
void disp_string( char*, char );
void exchange( unsigned com_adr );
//
// Главная процедура
//
void main(void) {
AUX_MODE amd;
unsigned com_adr;
char ch_in;
int i, mdm_sts;
// устанавливаем текстовый режим 25*80 символов
_setvideomode( _TEXTC80 );
// очищаем экран дисплея
_clearscreen( _GCLEARSCREEN );
// гасим курсор
_displaycursor( _GCURSOROFF );
disp_string( "(C) Frolov G.V. Телекоммуникационная программа\n\r\n\r", 4 );
// получаем базовый адрес регистров порта COM_PORT
if(( com_adr = com_address( COM_PORT )) < 0 ) exit( com_adr );
// сбрасываем регистры UART
reset( com_adr);
// инициализируем COM-порт: устанавливаем скорость и
// формат данных
amd.baud = 1200L; // скорость обмена
amd.ctl_aux.ctl_word.len = 3; // длина слова
amd.ctl_aux.ctl_word.stop = 0; // число стоп-битов
amd.ctl_aux.ctl_word.parity = 0; // контроль четности
amd.ctl_aux.ctl_word.stuck_parity = 0; // фиксация четности
amd.ctl_aux.ctl_word.en_break_ctl = 0; // установка перерыва
amd.ctl_aux.ctl_word.dlab = 0; // загрузка регистра делителя
// производим инициализацию COM-порта с базовым адресом com_adr
com_init(&amd, com_adr, 0);
// устанавливаем сигнал DTR и RTS
dtr_on( com_adr );
// передаем модему команду набора номера, модем
// набирает номер и производит соединение с удаленным модемом
disp_string( "\n\rВы можете вводить AT-команды, для выхода нажмите ESC\n\r", 12 );
disp_string( "\n\rНабираем номер\n\r", 12 );
if( 0!= to_modem( com_adr, "AT M1 DP 251 27 62" )) exit(3);
// задержка
sleep(1);
// выполняем диалог с удаленным модемом
exchange( com_adr );
disp_string( "\n\rПодождите, я кладу трубку\n\r", 12 );
// передаем модему Escape-последовательность
delay(3000);
com_out( com_adr, '+' );
com_out( com_adr, '+' );
com_out( com_adr, '+' );
delay(3000);
// кладем трубку
to_modem( com_adr, "ATH0" );
sleep(1);
// сбрасываем сигналы DTR и RTS
dtr_off( com_adr );
disp_string( "\n\r\n\rКонец работы\n\r", 4 );
_setvideomode( _DEFAULTMODE );
}
Обратите внимание, что в этой программе жестко указан номер используемого COM-порта, к которому подключается модем. Вам надо перед трансляцией программы изменить в модуле S_CHAT директиву:
#define COM_PORT 2 // используется порт COM3
Указав вместо 2 номер порта, к которому у вас подключен модем. Для порта COM1 надо определить константу COM_PORT как 0, для COM2 - 1, COM3 - 2, COM4 - 3.
По номеру COM-порта, указанному вами, функция com_address() из модуля COM_ADR.C определит адрес базового регистра данного COM-порта. Вычисление базового адреса COM-порта производится в соответствии с областью переменных BIOS:
// COM_ADR.C
#include "sysp_com.h"
/**
*.Name com_address
*
*.Title Определяет адрес заданного COM-порта.
*
*.Descr Эта функция определяет адрес базового регистра
* COM-порта. Адрес берется из области переменных
* BIOS.
*
*.Proto unsigned com_address( int port );
*
*.Params int port - номер асинхронного адаптера:
* 0 - COM1, 1 - COM2, 2 - COM3, 3 - COM4.
*
*.Return Адрес базового регистра асинхронного порта.
* Если порт не установлен, возвращается 0,
* если неправильно задан параметр, то -1.
**/
unsigned com_address( int port ) {
unsigned base_address;
// возвращаем -1, если заданный асинхронный порт
// не COM1, не COM2, не COM3 и не COM4
if(( port > 4 ) || ( port < 0 )) return( -1 );
// считываем из области переменных BIOS базовый адрес данного порта
base_address = *(( unsigned _far * ) FP_MAKE( 0x40, port * 2 ));
return( base_address );
}
Модуль RESET.C содержит определение функции reset(). Функция reset() сбрасывает значения регистров управления модемом, состояния линии, состояния модема и данных.
// RESET.C
#include "uart_reg.h"
// сбрасываем регистр управления модемом, регистр состояния линии,
// регистр данных, регистр состояния модема
int reset(unsigned com_adr) {
unsigned MCR, LSR, MSR, DATREG;
MCR = com_adr + MCR_N;
LSR = com_adr + LSR_N;
MSR = com_adr + MSR_N;
DATREG = com_adr;
_asm {
cli
; сбрасываем регистр управления модемом
mov al,0
mov dx,MCR
out dx,al
nop
nop
nop
; сбрасываем регистр состояния линии
mov dx,LSR
in al,dx
nop
nop
nop
; сбрасываем регистр данных
mov dx,DATREG
in al,dx
nop
nop
nop
; сбрасываем регистр состояния модема
mov dx,MSR
in al,dx
nop
nop
}
}
Модуль COM_INIT.C содержит определение функции com_init(), которая используется нами для инициализации регистров COM-порта. Этой функции вы должны передать структуру типа AUX_MODE (определена в файле sysp_com.h), поля которой определяют скорость обмена и формат данных:
// COM_INIT.C
/**
*.Name com_init
*.Title Инициализация асинхронного адаптера
*
*.Descr Эта функция инициализирует асинхронные
* адаптеры, задавая протокол обмена данными
* и скорость обмена данными.
*
*.Proto int com_init(AUX_MODE *mode, int port, int imask);
*
*.Params AUX_MODE mode - структура, описывающая
* протокол и режим работы порта;
*
* int port - базовый адрес асинхронного адаптера:
*
* int imask - значение для регистра маски
* прерываний
*
*.Return 0 - инициализация выполнена успешно;
* 1 - ошибки в параметрах инициализации.
**/
#include <stdio.h>
#include <conio.h>
#include "sysp_com.h"
#include "uart_reg.h"
int com_init(AUX_MODE *mode, int port_adr, int imask) {
unsigned div;
char ctl;
// Вычисляем значение для делителя
switch (mode->baud) {
case 110: div = 1040; break;
case 150: div = 768; break;
case 300: div = 384; break;
case 600: div = 192; break;
case 1200: div = 96; break;
case 2400: div = 48; break;
case 4800: div = 24; break;
case 9600: div = 12; break;
case 19200: div = 6; break;
case 38400: div = 3; break;
case 57600: div = 2; break;
case 115200: div =1; break;
default: return(-1); break;
}
// Записываем значение делителя частоты
ctl = inp(port_adr+LCR_N);
outp(port_adr+LCR_N, ctl | 0x80);
outp(port_adr+ICR_N, (div >> 8) & 0x00ff);
outp(port_adr, div & 0x00ff);
// Записываем новое управляющее слово
outp(port_adr+LCR_N, mode->ctl_aux.ctl & 0x7f);
// Устанавливаем регистр управления прерыванием
outp(port_adr+ICR_N, imask);
return(0);
}
Для управления сигналами DTR и RTS в модуле DTR.C определены две функции - dtr_on() и dtr_off(). Функция dtr_on() устанавливает сигналы DTR и RTS, а функция dtr_off() сбрасывает их.
// DTR.C
#include <conio.h>
#include "uart_reg.h"
/**
*.Name dtr_on
*
*.Title Устанавливает сигналы DTR и RTS.
*
*.Descr Эта функция устанавливает сигналы DTR и RTS
* для заданного COM-порта.
*
*.Proto void dtr_on( unsigned base_address );
*
*.Params unsigned base_address - базовый адрес асинхронного адаптера
*
*.Return не используется
**/
void dtr_on( unsigned base_address ) {
MCR mc_reg;
// считываем значение регистра управления модемом
mc_reg.byte = inp( base_address + MCR_N );
// устанавливаем сигналы DTR и RTS в активное состояние
mc_reg.bit_reg.dtr = mc_reg.bit_reg.rts = 1;
// записываем новое значение в регистр управления модемом
outp( base_address + MCR_N, mc_reg.byte );
}
/**
*.Name dtr_off
*
*.Title Сбрасывает сигналы DTR и RTS.
*
*.Descr Эта функция сбрасывает сигналы DTR и RTS
* для заданного COM-порта.
*
*.Proto void dtr_on( unsigned base_address );
*
*.Params unsigned base_address - базовый адрес асинхронного адаптера
*
*.Return не используется
**/
void dtr_off( unsigned base_address ) {
MCR mc_reg;
// считываем значение регистра управления модемом
mc_reg.byte = inp( base_address + MCR_N );
// сбрасываем сигналы DTR и RTS
mc_reg.bit_reg.dtr = mc_reg.bit_reg.rts = 0;
// записываем новое значение в регистр управления модемом
outp( base_address + MCR_N, mc_reg.byte );
}
Модуль TO_MODEM.C определяет функции to_modem() и com_out(). Эти функции используются для передачи модему данных через COM-порт.
Функция com_out() позволяет передать на модем только один символ. Передача символа осуществляется следующим образом:
Функция to_modem() позволяет передать модему строку символов. После передачи последнего символа в строке дополнительно передается символ возврата каретки (ASCII-код 13). Эту функцию удобно использовать для передачи модему AT-команд.
Итак, приведем исходный текст модуля TO_MODEM.C:
// TO_MODEM.C
#include "sysp_com.h"
#include "uart_reg.h"
// объявления функций
int com_out( unsigned, char );
int to_modem( unsigned, char* );
/**
*.Name to_modem
*
*.Title Передает модему строку, оканчивающуюся нулем.
*
*.Descr Эта функция передает модему строку, оканчивающуюся нулем.
*
*.Proto void to_modem( unsigned base_address, char *out_str );
*
*.Params unsigned base_address - базовый адрес асинхронного адаптера,
* на котором находится модем;
*
* char *out_str - массив символов, передаваемый модему,
* заканчивается нулем
*
*.Return -1, если нет сигнала DSR от модема
**/
int to_modem( unsigned base_address, char *out_str ) {
int i;
// последовательно передаем модему каждый символ из строки
for( i = 0; out_str[i] != '\0'; i++ )
if( 0 != com_out( base_address, out_str[i] )) return( -1 );
// заканчиваем передачу строки и посылаем модему код
// возврата каретки, вызывающий исполнение введенной команды
com_out( base_address, 13 );
return( 0 );
}
/**
*.Name com_out
*
*.Title Передает модему один символ.
*
*.Descr Эта функция передает один символ.
*
*.Proto void com_out( unsigned base_address, char out_char )
*
*.Params unsigned base_address - базовый адрес асинхронного адаптера,
* на котором находится модем;
*
* char out_char - символ, передаваемый модему,
*
*.Return -1, если нет сигнала DSR от модема
**/
int com_out( unsigned base_address, char out_char ) {
unsigned char next;
int i;
LSR ls_reg;
MSR ms_reg;
// ожидаем, пока модем сообщит о своей готовности
// по линии DSR
for( ms_reg.byte = 0, i = 0;
((ms_reg.bit_reg.dsr == 0) && ( i < 1000)); i++) {
ms_reg.byte = inp( base_address + MSR_N );
}
if( i == 1000 ) return( -1 ); // модем не готов
// ожидаем, пока освободится регистр передатчика
// и можно будет передать следующий байт
for( ls_reg.byte = 0; ls_reg.bit_reg.out_ready == 0; )
ls_reg.byte = inp( base_address + LSR_N );
// записываем передаваемый байт в регистр данных
// для последующей его передачи модему
outp( base_address, out_char );
return( 0 );
}
Функция exchange(), приведенная ниже, выполняет диалог с удаленным модемом. Символы, принимаемые через COM-порт от модема, отображаются на экране, а символы, набираемые на клавиатуре, передаются модему. Для передачи модему данных используется функция com_out() из модуля TO_MODEM.C, а для приема - функция from_modem() из модуля FROM_MDM.C.
// EXCHANGE.C
// функция exchange выполняет диалог с удаленным модемом
// символы, принимаемые через COM-порт от модема, отображаются
// на экране; символы, набираемые на клавиатуре, передаются
// модему также через COM-порт
#include <conio.h>
void exchange( unsigned com_adr );
void disp( char, char );
int com_out( unsigned, char );
void exchange( unsigned com_adr ) {
int flag = 1;
while(flag) {
char ch_in;
unsigned char key;
unsigned i,j;
// если пользователь нажал на клавишу, получаем код
// нажатого символа и передаем его модему
if( kbhit() ) {
key = getch();
// по нажатию клавиши Esc выходим из данной функции
if( key == 27 ) {
flag = 0;
break;
}
// если пользователь нажал Enter, передаем
// символ перевода строки и возврата каретки
if( key == '\r' ) {
// посылаем символ в COM-порт
com_out( com_adr, 0xd );
// отображаем символ на экране
disp(0xd,7);
// посылаем символ в COM-порт
com_out( com_adr, 0xa );
// отображаем символ на экране
disp(0xa,7);
}
else {
// отображаем символ на экране
disp( key, // код символа
15 // его атрибут (интенсивно белый символ
// на черном фоне )
);
// посылаем символ в COM-порт
com_out( com_adr, key );
}
}
// если получены данные от модема, отображаем их на экране
if( from_modem( com_adr, &ch_in ) == 0 )
disp( ch_in, // код символа
2 // его атрибут (зеленый символ
// на черном фоне )
);
}
}
Модуль FROM_MDM.C содержит определение функции from_modem(), которая позволяет получить данные от модема. Это могут быть данные, принятые модемом от удаленного абонента, или ответ модема на переданную ему AT-команду.
Функция from_modem() работает следующим образом: считывает значение регистра состояния линии и проверяет бит D0. Если бит D0 равен нулю, значит, данные получены и готовы для чтения. В этом случае данные считываются через регистр данных и функция возвращает нулевое значение. Если бит D0 равен нулю, то нет данных для чтения и функция from_modem() возвращает значение -1:
// FROM_MDM.C
#include "uart_reg.h"
/**
*.Name from_modem
*
*.Title Получает от модема один символ.
*
*.Descr Эта функция получает от модема через
* COM-порт один символ.
*
*.Proto int from_modem( unsigned base_address, char *in_char )
*
*.Params unsigned base_address - базовый адрес асинхронного адаптера,
* на котором находится модем;
*
* char *in_char - символ, получаемый от модема,
*
*.Return -1 - если нет данных от модема
* 0 - если данные считаны
**/
int from_modem( unsigned base_address, char *in_char ) {
unsigned ls_reg;
char temp;
int ret_num;
temp = 0;
ret_num = -1;
ls_reg = base_address + LSR_N;
_asm {
cli
// проверяем, есть ли у асинхронного адаптера данные,
// готовые для чтения
mov dx, ls_reg
in al,dx
nop
nop
nop
test al,1
// если данных нет, возвращаем -1
jz no_data
// считываем из регистра данных полученный символ
mov dx,base_address
in al,dx
nop
nop
nop
mov temp,al
// возвращаем 0
mov ret_num,0
no_data:
sti
}
*in_char = temp;
return( ret_num );
}
Модуль DISP.C является вспомогательным и определяет функцию disp(), используемую для вывода символов на экран непосредственно через видеопамять. Непосредственный вывод в видеопамять использован нами потому, что функции putch() и printf() работают слишком медленно. На больших скоростях модем может передать в COM-порт несколько новых символов, в то время как функция putch() еще не вывела ни одного.
Если ваша коммуникационная программа будет использовать прерывания, то можно организовать буфер принимаемых данных и при обработке прерываний быстро записывать в него символы, а затем их уже можно выводить на экран медленными функциями типа printf(). В этом случае принимаемые данные не будут пропадать из-за того, что функция printf() не успевает их выводить. Конечно, ведь при поступлении очередного символа выполнение функции printf() прерывается и принятый символ записывается для дальнейшей обработки в буфер!
Мы рассмотрим коммуникационную программу, использующую прерывания от COM-порта в следующей главе, а теперь приведем модуль DISP.C:
// DISP.C
// сегментный адрес видеопамяти
static unsigned video_adr = 0xB800;
// текущее положение
static int cur = 0;
// номер текущей строки * 160
static int line = 0;
// функция disp() используется для вывода символов на экран
// непосредственно через видеопамять;
// подразумевается, что видеоадаптер находится в цветном
// текстовом режиме с разрешением 25*80 символов;
// вывод производится в нулевую страницу видеопамяти
void disp( char outchar, // ASCII-код символа
char attr // атрибут символа
) {
static char save_ch = 0, save_attr = 7;
_asm {
push es
// определяем смещение текущего байта видеопамяти
mov bx,cur
add bx,line
// устанавливаем сегмент видеопамяти
mov ax,video_adr
mov es,ax
// восстанавливаем символ в позиции курсора
// эмулируем курсор символом '_'
mov al,save_ch
mov es:[bx], al
inc bx
mov al,save_attr
mov es:[bx], al
display:
// проверяем управляющие символы CR и LF
cmp outchar, 20h
jb handl
dec bx
// если весь экран заполнен, очищаем его и перемещаемся в
// верхний левый угол экрана
cmp bx,3840
jb send_it
// очищаем экран
mov cx,4000
xor bx,bx
clr_scr:
mov es:[bx], 0
inc bx
loop clr_scr
mov line,0
xor bx,bx
// записываем символ и его атрибут в текущей позиции экрана
send_it:
mov al,BYTE PTR outchar
mov es:[bx], al
inc cur
inc bx
mov al,BYTE PTR attr
mov es:[bx], al
inc cur
jmp end_disp
// обрабатываем управляющие символы CR, LF, Backspace
handl:
cmp outchar, 0xd
jne next_1
add line,160
jmp end_disp
next_1:
cmp outchar, 0xa
jne next_2
mov cur,0
jmp end_disp
next_2:
cmp outchar, 0x8
jne next_3
dec cur
dec cur
jmp end_disp
next_3:
end_disp:
// устанавливаем курсор в новую позицию
mov bx,cur
add bx,line
mov al,es:[bx]
mov save_ch,al
mov al,5fh
mov es:[bx], al
inc bx
mov al,es:[bx]
mov save_attr,al
mov al,7
mov es:[bx], al
pop es
}
}
void disp_string( char *str, char attr ) {
int i;
for( i = 0; str[i]; i++ )
disp( str[i], attr );
}
Вспомогательный модуль TIMER.C содержит определения функций sleep() и delay(). Эти функции используются в программе для организации временных задержек, в частности при передаче модему Escape-последовательности "+++" для перевода его в командный режим.
// TIMER.C
// определены функции sleep и delay, выполняющие временные задержки
#include <time.h>
#include <sys/timeb.h>
#include "timer.h"
/**
*.Name sleep
*
*.Title Приостанавливает выполнение программы
*
*.Descr Эта функция приостанавливает выполнение
* программы на заданное число секунд.
*
*.Proto void sleep(time_t interval)
*
*.Params time_t interval - время задержки в секундах
*
*.Return не используется
*
*.Sample timer.c
**/
void sleep(time_t interval) {
time_t start;
start = time((time_t *)NULL);
// ожидаем, пока пройдет time_t секунд
while ((time((time_t *)NULL) - start) < interval)
delay(1000);
}
/**
*.Name delay
*
*.Title Приостанавливает выполнение программы
*
*.Descr Эта функция приостанавливает выполнение
* программы на заданное число миллисекунд.
*
*.Proto void delay(int milliseconds)
*
*.Params time_t interval - время задержки в миллисекундах
*
*.Return не используется
*
*.Sample timer.c
**/
void delay (int milliseconds) {
struct timeb t;
time_t seconds;
unsigned last;
if (milliseconds == 0)
return;
// определяем текущее время
ftime(&t);
last = t.millitm;
seconds = t.time;
// ожидаем milliseconds миллисекунд
while( milliseconds > 0) {
int count;
// задержка
for ( count = 0; count < 2000; count ++);
// определяем текущее время
ftime(&t);
if (t.time == seconds)
milliseconds -= (t.millitm - last);
else
milliseconds -= 1000 * (int) (t.time - seconds) -
(last - t.millitm);
last = t.millitm;
seconds = t.time;
}
}
Программа, представленная в предыдущей главе, имеет один большой недостаток: она должна постоянно производить опрос регистра состояния линии, с тем чтобы определить момент, когда от модема поступит очередной символ. В результате становится трудной, а иногда невозможной обработка поступающих символов. Например, если вы сразу отображаете символы, получаемые от COM-порта, на экране, то при использовании для этого функции putch() отдельные символы могут быть потеряны. Дело в том, что функция putch() работает слишком медленно и на скоростях 2400 бод и выше модем может успеть передать в COM-порт несколько новых символов, в то время как функция putch() еще не вывела на экран ни одного символа. В этом случае происходит ошибка переполнения входного буфера микросхемы UART (см. бит D2 регистра состояния линии).
Таким образом, имеет смысл организовать прием и передачу символов модему в фоновом режиме, используя прерывания по окончании приема и передачи символа.
Если ваша коммуникационная программа будет использовать прерывания, можно организовать буфер принимаемых и передаваемых данных. Обработчик прерываний должен проанализировать причину прерывания и либо передать в COM-порт очередной символ из буфера передатчика (если прерывание произошло в результате передачи очередного символа), либо считать поступивший символ из регистра данных и записать его в буфер приемника (если прерывание произошло в результате приема от модема очередного символа).
В этом случае процесс обмена идет в фоновом режиме и процессор может спокойно заниматься обработкой принимаемых и передаваемых символов. Если программе понадобится передать данные модему, она может просто записать их в буфер передатчика. Для приема данных она должна считать их из буфера приемника.
Последовательный асинхронный адаптер можно запрограммировать таким образом, что всякий раз, когда он примет или передаст очередной байт, будет выработано соответствующее прерывание.
Прерывания могут вырабатываться асинхронным адаптером в следующих случаях:
Вы можете отдельно запрещать или разрешать эти прерывания. Для этого необходимо установить соответствующие биты в регистре управления прерываниями.
Как приходит прерывание от COM-порта? Как мы
указывали ранее, каждому COM-порту соответствует,
кроме базового адреса его регистров, линия IRQ (см.
главы "Последовательный асинхронный
адаптер" и "COM-порт и номера IRQ"):
COM-порт |
IRQ |
Номер прерывания |
COM1 |
IRQ4 |
INT 0Ch |
COM2 |
IRQ3 |
INT 0Bh |
COM3 |
IRQ4 |
INT 0Ch |
COM4 |
IRQ3 |
INT 0Bh |
Заметим, что в данной таблице представлен только один возможный вариант соответствия номеру COM-порта линии IRQ. Некоторые платы асинхронных адаптеров и некоторые внутренние модемы имеют отдельно перемычки для выбора номера COM-порта (адреса базового регистра) и номера линии IRQ.
Что представляет из себя обработчик прерываний асинхронного адаптера? После вызова обработчика прерываний он должен:
Необходимо выполнить команду sti, для того чтобы разрешить обработку прерываний с более высоким приоритетом, чем прерывание от асинхронного адаптера.
Определить причину прерывания
Для этого следует считать содержимое регистра
идентификации прерываня. Состояние битов D1 D2
определяют причину прерывания:
Биты D2 D1 |
Причина прерывания |
00 |
прерывание по линии состояния; |
01 |
буфер передатчика пуст; |
10 |
данные приняты; |
11 |
изменилось состояние модема. |
В зависимости от того, какое произошло прерывание, его надо соответствующим образом обработать.
Считать регистр состояния линии и конкретизировать причину прерывания (данное прерывание сбрасывается после чтения регистра состояния линии). Если это необходимо, подать основной программе сигнал о произошедшей ошибке с целью ее устранения. Например, в случае определения на линии сигнала BREAK (удаленный модем повесил трубку), надо попытаться возобновить связь.
Очередной символ принят, и его можно считать через регистр данных. Прерывание сбрасывается после чтения регистра данных. Принятый байт необходимо записать в приемный буфер программы, из которого впоследствии его прочитает основная программа. Буфер приемника удобно организовать в виде очереди.
Прерывание происходит в случае, если буфер передатчика пуст и можно передать COM-порту очередной символ. Можно организовать буфер передатчика программы, в который программа будет записывать данные, предназначенные для передачи через COM-порт. В этом случае, когда придет прерывание, надо считать очередной символ из буфера передатчика программы и записать его в регистр данных. Прерывание сбрасывается после записи очередного символа в регистр данных UART. Если нет данных для передачи (программный буфер передатчика пуст), можно запретить это прерывание через регистр управления прерываниями.
Прерывание происходит при изменении состояния входных линий CTS, RI, DCD, DSR. Состояние этих линий можно определить, считав регистр состояния модема. Это прерывание используется для обнаружения звонка на телефонной линии. Прерывание автоматически сбрасывается после чтения регистра состояния модема.
Может случиться, что одновременно произойдет несколько прерываний. В этом случае бит D0 регистра идентификации прерываний равен единице. Тогда перед завершением обработки прерывания необходимо обработать следующее прерывание в соответствии с состоянием битов D1, D2. Так следует поступать до тех пор, пока не будут обработаны все прерывания (бит D0 не станет равен нулю).
Передать контроллеру прерываний команду обработки конца прерывания. Для этого посылается в порт с адресом 20h команда конца прерывания:
mov al,20h out 20h,al
Теперь можно закончить обработку прерывания, выполнив команду iret.
Итак, мы завершили рассмотрение обработчика прерываний. Теперь нам осталось изучить примерный порядок работы коммуникационной программы с использованием прерываний.
Необходимо установить обработчик прерываний, изменив соответствующий элемент таблицы векторов прерываний. Адрес старого обработчика сохраняется в глобальных переменных.
Сначала надо перевести в неактивное состояние линии DTR и RTS. Затем сбросить регистр состояния линии, регистр состояния модема и регистр данных.
После того как мы сбросили регистры UART, можно приступить к инициализации COM-порта. Во время инициализации задается формат данных - длина слова, количество стоповых битов, наличие контроля по четности и скорость обмена.
Последним шагом в инициализации регистров UART является установка регистра управления прерываниями, в который записывается соответствующее значение. Например, чтобы разрешить генерацию прерываний при приеме очередного символа, надо записать значение 01h в регистр управления прерываниями:
// устанавливаем регистр управления прерываниями
outp(port_adr+ICR, 1); // ICR - адрес регистра
// управления прерываниями
На этом этап инициализации регистров UART можно считать законченным. Теперь COM-порт подготовлен для обмена через него данными с модемом, но модем пока еще не будет воспринимать данные от компьютера. Чтобы перевести его в рабочее состояние, надо передать ему сигналы DTR и RTS. В ответ на эти сигналы модем должен вернуть компьютеру сигналы DSR и CTS.
Для того чтобы прерывания от асинхронного адаптера выполнялись, необходимо разрешить прерывание по соответствующей линии IRQ через регистр маски прерываний контроллера прерываний:
// считываем состояние регистра маски прерываний mov dx,21h in dx,al // разрешаем прерывания от порта COM1 and al,11101111b // записываем новое значение в регистр маски прерываний out dx,al
После установки обработчика прерываний и инициализации регистров COM-порта и контроллера прерываний можно передавать модему AT-команды и принимать от него ответ на них. При этом данные можно считывать (записывать) из COM-порта через буфер обработчика прерываний.
Установив связь с удаленным модемом, оба модема переходят в режим обмена данными. Теперь можно начинать передавать и принимать данные.
Передача и прием данных от удаленного модема осуществляются так же, как передача модему команд и прием от него сообщениий.
Для завершения коммуникационной программы, использующей прерывания, необходимо сбросить сигналы DTR и RTS и запретить через контроллер прерываний прерывания от COM-порта:
// считываем состояние регистра маски прерываний mov dx,21h in dx,al // запрещаем прерывания от порта COM1 or al,00010000b // записываем новое значение в регистр маски прерываний out dx,al
Затем нужно восстановить старый вектор обработчика прерываний.
В этой главе мы приведем исходный текст коммуникационной программы CHAT. В отличие от программы CHAT_S данная программа использует для работы с асинхронным адаптером прерывания.
При помощи этой программы можно связаться с удаленным модемом, передавать и принимать от него данные в формате ASCII. Например, вы можете позвонить на станцию BBS и прочитать почтовые сообщения. Передачу и прием файлов программа не поддерживает, иначе пример занимал бы слишком много места.
Данная телекоммуникационная программа может работать в двух режимах - активном, когда она сама производит вызов удаленного модема, и пассивном, когда программа находится в режиме ожидания звонка от удаленного модема. Для работы программы в активном режиме необходимо запустить ее с параметром "1", для пассивного режима - "0".
Большинство параметров программы, таких, как AT-команды инициализации, телефонный номер, скорость обмена и номер COM-порта, можно настроить через файл конфигурации setup.cfg. Образец этого файла представлен ниже:
// строка инициализации для режима активного вызова Initialize ATS0=0Q0E0M1V1X4&C1&D2 // команда, которая переводит модем в командный режим и // кладет трубку Dropline \d\d+++\d\dATH0\n\r\d // строка инициализации для режима ожидания звонка AutoAnswer ATS0=1Q0E0M1V1X4&C1&D2 // префикс телефонного номера DialPrefix \r\pATDP // суффикс телефонного номера DialSuffix // телефонный номер DialNumber 1135810 // номер COM-порта в формате COMn, где n - номер порта Device COM3 // время, отведенное на установку связи с удаленным модемом DialTimeout 30 TimeoutAnswer 30 // временная задержка между сиимволами при передаче CharDelay 0 // время реакции модема на команды ModemTimeout 3 // скорость обмена данными Speed 2400
Программа состоит из следующих модулей:
CHAT.C // главная процедура программы MODEM.C // передача данных модему через COM-порт TIMER.C // реализация временных задержек CONF.C // чтение файла конфигурации SEND_COMM.C // передача команд модему TOOLS.C // набор функций для работы с модулем UART.ASM UART.ASM // обработчик прерываний и процедуры низкого уровня
Теперь приведем сами исходные тексты программы. Основной модуль программы называется CHAT.C. В зависимости от параметра программы этот модуль вызывает функцию call() - режим вызова удаленного модема - или функцию answer() - режим ответа на приходящие звонки. Обе функции, call() и answer(), выполняют все действия по программированию COM-порта, контроллера прерываний и модема. Данные функции определены в модуле MODEM.C.
После окончания связи вызывается функция shutdown(), которая опускает телефонную трубку и отключает обработчик прерываний.
// CHAT.C
// основной модуль коммуникационной программы
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include "mod_link.h"
#include "common.h"
#include "modem.h"
#include "timer.h"
#include "tools.h"
void hello(void) {
printf("неправильно задан параметр программы \n"
"mod_link n, где n = 1 вызов, n = 0 ответ\n");
exit(0);
}
// основная процедура
void main( int argc, char *argv[] ) {
// программа должна вызываться параметром 1 или 0
// 1 - это активный режим, когда программа сама вызывает
// удаленный модем
// 0 - программа находится в режиме автоответа на
// приходящий вызов
if( argc < 2 )
hello();
0 if( strcmp( argv[1], "0") && strcmp( argv[1], "1" ))
hello();
if( !strcmp( argv[1], "1" ) )
// если программа запущена с параметром "1", вызывается
// функция call() из модуля MODEM.C, выполняющая вызов
// удаленного модема
call();
else
// если программа запущена с параметром "0", вызывается
// функция answer(), переключающая модем в режим автоответа
answer();
// освобождаем телефон
shutdown();
}
Данный модуль определяет функции высокого уровня для работы с модемом:
Эти функции вызывают модули более низкого уровня: SEND_COMM.C, TOOLS.C.
// MODEM.C
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include "uart.h"
#include "common.h"
#include "modem.h"
#include "mod_link.h"
#include "timer.h"
#include "tools.h"
#include "conf.h"
char *device = "COM3"; // номер используемого порта в формате
// COMn, где n от 1 до 4
unsigned dialTimeout = 12, // продолжительность ожидания соединения
chardelay = 0, // задержка при передаче между символами
modemTimeout = 3, // таймаут на получение ответа от модема
answerTimeout; // ппродолжительность ожидания звонка
unsigned speed = 2400; // скорость обмена данными
char initialize[80]; // команда инициализации
char dropline[80]; // команда повесить трубку
char autoanswer[80]; // ответ на вызов в режиме автоответа
char dialPrefix[80]; // префикс номера
char dialSuffix[80]; // суффикс номера
char dialNumber[80]; // телефонный номер
static boolean getmodem( const char *brand);
static boolean sendlist( char **list, int timeout, int lasttimeout);
static boolean sendalt( char *string, int timeout);
void exchange( void );
// call
// вызов удаленного пользователя
int call() {
char str[80], buf[80];
char *exp;
int i,j;
// определяем параметры связи (считываем файл конфигурации)
getconfig();
// устанавливаем обработчик прерываний и инициализируем
// регистры UART и контроллера прерываний
if (openline(device, speed))
return FALSE;
// очищаем приемный буфер
while (sread(buf,1,0));
printf("инициализируем модем\n\n");
// передаем модему строку инициализации
// (строка инициализации определяется ключевым словом Initialize
// в файле конфигурации setup.cfg)
sendstr( initialize );
// ожидаем ответа модема
sleep(modemTimeout);
// считываем и отображаем на экране ответное сообщение модема
if( r_count_pending() > 0 ) {
sread(str, i = r_count_pending(), 0);
str[i] = '\0';
for( j = 0; j < i; j++ )
putch( str[j] );
}
// передаем модему команду набора номера
strcpy(buf, dialPrefix);
strcat(buf, dialNumber);
strcat(buf, dialSuffix);
printf( "набираем номер\n\n");
sendstr( buf );
printf( "ожидаем соединение\n\n");
// производим обмен данными с удаленным модемом,
// пока не нажата клавиша ESC
exchange();
return(0);
}
// answer
// отвечает на звонок
int answer( void ) {
char c;
// определяем параметры связи
getconfig();
// устанавливаем обработчик прерываний и инициализируем
// регистры UART и контроллера прерываний
if (openline(device, speed))
exit(-2);
// очищаем приемный буфер
while (sread(&c ,1,0));
printf("инициализируем модем\n\n");
// передаем модему строку инициализации
// (строка инициализации определяется ключевым словом Autoanswer
// в файле конфигурации setup.cfg)
sendstr( autoanswer );
sleep(modemTimeout);
printf("ожидаем звонок\n");
// производим обмен данными с удаленным модемом,
// пока не нажата клавиша ESC
exchange();
return(0);
}
// shutdown
// функция кладет телефонную трубку
void shutdown( void ) {
printf("\n\nсвязь окончена, освобождаем телефон\n");
// передаем команду положить трубку
sendstr( dropline );
// восстанавливаем старый обработчик прерываний
closeline();
}
// slowwrite
// передать символ модему с задержкой, определяемой ключевым
// словом CharDelay в файле конфигурации
void slowwrite( char *s, int len) {
swrite( s , len );
if (chardelay > 0) delay(chardelay);
}
// exchange
// функция выполняет диалог пользователя и удаленного модема
void exchange( void ) {
int flag = 1;
while(flag) {
unsigned char str[80];
unsigned char key;
unsigned i,j;
// если пользователь нажал на клавиатуру, получаем код
// нажатого символа и передаем его модему
if( kbhit() ) {
key = getch();
// по нажатию клавиши Esc выходим из программы
if( key == 27 ) {
ssendbrk( 3 );
flag = 0;
break;
}
if( key == '\r' ) putch( '\n' );
putch(key);
swrite( &key, 1);
}
// если получены данные от модема, отображаем их на экране
if( r_count_pending() > 0 ) {
delay(100);
sread(str, i = r_count_pending(), 0);
str[i] = '\0';
for( j = 0; j < i; j++ )
putch( str[j] );
}
}
}
Модуль CONF.C определяет функцию getconfig(), считывающую файл конфигурации setup.cfg и записывающую считанные значения в глобальные переменные.
Конфигурационный файл может содержать следующие команды:
Initialize [строка инициализации для режима активного вызова] Dropline [команда для освобождения телефона] AutoAnswer [строка инициализации для режима ожидания звонка] DialPrefix [ префикс телефонного номера] DialSuffix [суффикс телефонного номера] DialNumber [телефонный номер] Device [номер COM-порта] DialTimeout [время, отведенное на установку связи с удаленным модемом] TimeoutAnswer [время, отведенное на установку связи с удаленным модемом] CharDelay [временная задержка между символами при передаче] ModemTimeout [время реакции модема на команды] Speed [скорость обмена данными]
Итак, исходный текст модуля CONF.C:
// CONF.C
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "conf.h"
void Number( unsigned *num );
void Token( char *string );
FILE *CfgFile;
char LineBuf[256];
extern char initialize[80];
extern char dropline[80];
extern char autoanswer[80];
extern char dialPrefix[80];
extern char dialSuffix[80];
extern char dialNumber[80];
extern unsigned chardelay;
extern unsigned dialTimeout;
extern unsigned modemTimeout;
extern unsigned answerTimeout;
extern unsigned speed;
extern char *device;
/**
*.Name getconfig
*
*.Title Считывает файл setup.cfg.
*
*.Descr Эта функция считывает данные из файла setup.cfg
*
*.Proto void getconfig(void)
*
*.Params не используется
*
*.Return не используется
**/
void getconfig(void) {
CfgFile=fopen("setup.cfg","r");
if(CfgFile == NULL) {
cprintf("\r\nОтсутствует файл SETUP.CFG.");
exit(-1);
}
// заполняем глобальные переменные
for(;;) {
fgets(LineBuf,255,CfgFile);
if(feof(CfgFile)) break;
STRIP(LineBuf);
if(OPERATOR("Dropline")) Token( dropline );
else if(OPERATOR("Initialize")) Token( initialize );
else if(OPERATOR("AutoAnswerr")) Token( autoanswer );
else if(OPERATOR("DialNumber")) Token( dialNumber );
else if(OPERATOR("DialPrefix")) Token( dialPrefix );
else if(OPERATOR("DialSuffix")) Token( dialSuffix );
else if(OPERATOR("Device")) Token( device );
else if(OPERATOR("CharDelay")) Number( &chardelay );
else if(OPERATOR("DialTimeout")) Number( &dialTimeout );
else if(OPERATOR("ModemTimeout")) Number( &modemTimeout );
else if(OPERATOR("TimeoutAnswer")) Number( &answerTimeout );
else if(OPERATOR("Speed")) Number( &speed );
}
fclose(CfgFile);
}
void Token( char *string ) {
char *next;
next = strcpy( string, strchr( LineBuf, ' ' ) + 1 );
if(next == NULL) string[0] = '\0';
}
void Number( unsigned *num ) {
char buf[80];
strcpy( buf, strchr( LineBuf, ' ' ) + 1 );
*num = atoi( buf );
}
Следующий модуль - SEND_COMM.C определяет функцию sendstr(), которая используется для передачи модему AT-команд.
// SEND_COMM.C
#include <time.h>
#include "common.h"
#include "modem.h"
#include "get_word.h"
#include "timer.h"
#include "tools.h"
#include "total.h"
// writestr
// обработка управляющих символов
static unsigned writestr(register char *s) {
register char last = '\0';
int no_CR = FALSE;
unsigned char digit;
while (*s) {
if (last == '\\') {
last = *s;
switch (*s) {
// задержка на две секунды
case 'd':
case 'D':
sleep(2);
break;
// не передавать символ возврата каретки
// в конце строки
case 'c':
case 'C':
no_CR = TRUE;
break;
// передать символ возврата каретки
case 'r':
case 'R':
slowwrite("\r", 1);
break;
// передать символ возврата каретки
case 'n':
case 'N':
slowwrite("\n", 1);
break;
// задержка 500 миллисекунд
case 'p':
case 'P':
delay(500);
break;
default:
slowwrite(s, 1);
last = '\0';
}
}
else if (*s != '\\')
slowwrite(s, 1);
else
last = *s;
s++;
}
return no_CR;
}
// sendstr
// послать строку в буфер передатчика,
// при этом обрабатываются следующие управляющие символы:
// d (D) - задержка на две секунды
// c (C) - не передавать символ возврата каретки в конце строки
// r (R) - передать символ возврата каретки
// n (N) - передать символ перевода строки
// p (P) - задержка 500 миллисекунд
void sendstr(char *str) {
if(!equal(str,"")) {
if(!writestr(str))
slowwrite("\r", 1);
}
else
slowwrite("\r", 1);
return;
}
Модуль TOOLS.C содержит определения функций для работы с модулем UART.ASM.
// TOOLS.C
//
#include <assert.h>
#include <fcntl.h>
#include <io.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "common.h"
#include "tools.h"
#include "uart.h"
#include "timer.h"
unsigned port_active = FALSE;
static unsigned current_baud;
#define STOPBIT 1
static unsigned hangup_needed = TRUE;
/**
*.Name openline
*
*.Title Устанавливает текущий COM-порт.
*
*.Descr Эта функция устанавливает текущий асинхронный
* порт, с которым в дальнейшем будет происходить обмен.
*
*.Proto int openline(char *name, unsigned baud)
*
*.Params char *name - номер COM-порта
* unsigned baud - скорость обмена данными
*
*.Return не используется
**/
int openline(char *name, unsigned baud) {
int value;
// если порт уже активен, закрываем его
if (port_active)
closeline();
if (sscanf(name, "COM%d", &value) != 1) {
exit(-1);
}
// выбираем текущий COM-порт
select_port(value);
// сохраняем адрес старого обработчика прерываний COM-порта
save_com();
// устанавливаем новый обработчик прерываний COM-порта
install_com();
// программируем текущий COM-порт
// скорость, связь через модем, не проверяем четность
// один стоповый бит
open_com(baud, 'M', 'N', STOPBIT);
// запоминаем скорость
current_baud = baud;
// устанавливаем линию DTR в активное состояние
// (компьютер готов к обмену данными)
dtr_on();
port_active = TRUE;
return( 0 );
}
/**
*.Name sread
*
*.Title Читает символы из COM-порта.
*
*.Descr Эта функция читает заданное число символов
* из буфера приемника асинхронного порта.
*
*.Proto unsigned sread(char *buffer, unsigned wanted, unsigned timeout)
*
*.Params char *buffer - указатель на буфер в который будут записаны символы
* из буфера приемника
* unsigned wanted - число символов, которое надо прочитать
* из буфера приемника
* unsigned timeout - время, отведенное на чтение символов
*
*.Return количество символов, прочитанных из буфера приемника
**/
unsigned sread(char *buffer, unsigned wanted, unsigned timeout) {
time_t start;
hangup_needed = TRUE;
// определяем начальное время
start = time(nil(time_t));
for(;;) {
unsigned int pending;
// определяем число символов в буфере приемника
pending = r_count_pending();
// если в буфере есть необходимое количество символов
if (pending >= wanted) {
unsigned int i;
// считываем из буфера нужное число символов
for (i = 0; i < wanted; i++)
*buffer++ = (char) receive_com();
return pending;
}
// если в буфере приемника меньше символов, чем заказано
// для чтения, проверяем, не иcтекло ли отведенное для чтения
// время
else {
time_t now = time(nil(time_t));
time_t elapsed = now - start;
delay(0);
if (elapsed >= (long) timeout)
return pending;
}
}
}
/**
*.Name swrite
*
*.Title Запись символов в COM-порт.
*
*.Descr Эта функция записывает заданное число символов
* в буфер передатчика асинхронного порта.
*
*.Proto int swrite(char *data, unsigned len)
*
*.Params char *data - указатель на буфер данных
* unsigned len - число символов, которое надо записать
* в буфер передатчика
*
*.Return количество символов, записанных в буфер передатчика
*
*.Sample comlib.c
**/
int swrite(char *data, unsigned int len) {
unsigned int i;
hangup_needed = TRUE;
// записываем входные данные в буфер передатчика
// асинхронного порта
for (i = 0; i < len; i++)
send_com(*data++);
return len;
}
/**
*.Name ssendbrk
*
*.Title Передает сигнал BREAK удаленному модему.
*
*.Proto void ssendbrk()
*
*.Params Не используются.
*
*.Return Не используется.
*
*.Sample comlib.c
**/
void ssendbrk(void) {
break_com();
}
/**
*.Name closeline
*
*.Title Закрывает COM-порт.
*
*.Descr Эта функция восстанавливает старые значения
* векторов прерываний и запрещает прерывания
* от COM-порта.
*
*.Proto void closeline(void)
*
*.Params Не используются.
*
*.Return Не используется.
*
*.Sample comlib.c
**/
void closeline(void) {
int far *stats;
port_active = FALSE;
// отменяем сигнал DTR
dtr_off();
// запрещаем прерывания от COM-порта
close_com();
// восстанавливаем векторы прерываний
restore_com();
}
Вспомогательный модуль TIMER.C содержит определения функций sleep() и delay(). Эти функции используются в программе для организации временных задержек.
// TIMER.C
// определены функции sleep и delay, выполняющие временные задержки
#include <time.h>
#include <sys/timeb.h>
#include "timer.h"
/**
*.Name sleep
*
*.Title Приостанавливает выполнение программы
*
*.Descr Эта функция приостанавливает выполнение
* программы на заданное число секунд.
*
*.Proto void sleep(time_t interval)
*
*.Params time_t interval - время задержки в секундах
*
*.Return не используется
*
*.Sample timer.c
**/
void sleep(time_t interval) {
time_t start;
start = time((time_t *)NULL);
// ожидаем, пока пройдет time_t секунд
while ((time((time_t *)NULL) - start) < interval)
delay(1000);
}
/**
*.Name delay
*
*.Title Приостанавливает выполнение программы
*
*.Descr Эта функция приостанавливает выполнение
* программы на заданное число миллисекунд.
*
*.Proto void delay(int milliseconds)
*
*.Params time_t interval - время задержки в миллисекундах
*
*.Return не используется
*
*.Sample timer.c
**/
void delay (int milliseconds) {
struct timeb t;
time_t seconds;
unsigned last;
if (milliseconds == 0)
return;
// определяем текущее время
ftime(&t);
last = t.millitm;
seconds = t.time;
// ожидаем milliseconds миллисекунд
while( milliseconds > 0) {
int count;
// задержка
for ( count = 0; count < 2000; count ++);
// определяем текущее время
ftime(&t);
if (t.time == seconds)
milliseconds -= (t.millitm - last);
else
milliseconds -= 1000 * (int) (t.time - seconds) -
(last - t.millitm);
last = t.millitm;
seconds = t.time;
}
}
Модуль UART.ASM - это основной модуль программы CHAT. Он содержит обработчик прерываний от COM-порта и функции низкого уровня для работы с ним.
Обработчик прерываний имеет два буфера - буфер приемника и буфер передатчика. Через эти буферы осуществляется обмен данными между программой и обработчиком прерываний. Буферы выполнены в виде очереди.
; ; UART.ASM ; модуль управления модемом и COM-портом нижнего уровня ; ; определяем размеры буфера приемника и передатчика R_SIZE EQU 2048 ; размер приемного буфера S_SIZE EQU 500 ; размер буфера передатчика ; номера обработчиков прерываний INT_COM1 EQU 0Ch ; COM1 INT_COM2 EQU 0Bh ; COM2 INT_COM3 EQU 0Ch ; COM3 INT_COM4 EQU 0Bh ; COM4 ; порты контроллера прерываний 8259 OCR EQU 20H ; управляющий регистр 8259 IMR EQU 21H ; регистр маски прерываний 8259 ; константы для управления контроллером прерываний E_IRQ4 EQU 00010000B D_IRQ4 EQU 11101111B EOI4 EQU 01100100B E_IRQ3 EQU 00001000B D_IRQ3 EQU 11110111B EOI3 EQU 01100011B ; ; область переменных BIOS ; ; адреса базовых регистров последовательных асинхронных адаптеров BIOS_VAR SEGMENT AT 40H rs232_base DW 4 DUP(?) BIOS_VAR ENDS ; ; таблица для каждого COM-порта ; SP_TAB STRUC port DB ? ; 1, 2, 3 или 4 ; параметры для этого уровня прерываний int_com DB ? ; номер прерывания e_irq DB ? d_irq DB ? eoi DB ? ; обработчики прерываний для этого уровня int_hndlr DW ? ; смещение обработчика прерываний old_com_off DW ? ; смещение старого обработчика прерываний old_com_seg DW ? ; сегмент старого обработчика прерываний ; параметры COM-порта installed DB ? ; установлен ли порт на этом компьютере? (1=да,0=нет) baud_rate DW ? device_conn DB ? ; M(Модем), D(Нуль-модем) parity DB ? ; N(ONE), O(DD), E(VEN), S(PACE), M(ARK) stop_bits DB ? ; 1, 2 ; счетчики ошибок error_block DW 8 DUP(?) ; порты 8250 DATREG DW ? ; регистр данных IER DW ? ; регистр управления прерываниями IIR DW ? ; регистр идентификации прерывания LCR DW ? ; регистр управления линией MCR DW ? ; регистр управления модемом LSR DW ? ; регистр состояния линии MSR DW ? ; регистр состояния модема DLL EQU DATREG ; младший регистр делителя DLH EQU IER ; старший регистр делителя ; указатели буферов FIFO ; индекс первого символа в буфере передатчика start_s_data DW ? ; индекс первого свободного элемента буфера передатчика end_s_data DW ? ; индекс первого символа в буфере приемника start_r_data DW ? ; индекс первого свободного элемента буфера приемника end_r_data DW ? ; счетчики количества символов в буферах size_s_data DW ? ; число символов в буфере передатчика size_r_data DW ? ; число символов в буфере приемника ; буфера send_buf DB S_SIZE DUP(?) ; буфер передатчика reciave_buf DB R_SIZE DUP(?) ; буфер приемника SP_TAB ENDS EFRAME EQU error_block+6 ; ошибка синхронизации EPARITY EQU error_block+8 ; ошибка четности EOVFLOW EQU error_block ; произошло переполнение буфера EDSR EQU error_block+12 ; модем не ответил сигналом DSR EOVRUN EQU error_block+2 ; ошибка переполнения EBREAK EQU error_block+4 ; обнаружен запрос на прерывание EXMIT EQU error_block+10 ; ошибка при передаче ECTS EQU error_block+14 ; модем не ответил сигналом CTS ; ; DGROUP GROUP _DATA _DATA SEGMENT public 'DATA' DIV50 DW 2304 ; текущий номер области данных порта CURRENT_AREA DW AREA1 ; область данных для каждого порта AREA1 SP_TAB <1,INT_COM1,E_IRQ4,D_IRQ4,EOI4> ; область данных COM1 AREA2 SP_TAB <2,INT_COM2,E_IRQ3,D_IRQ3,EOI3> ; область данных COM2 AREA3 SP_TAB <3,INT_COM3,E_IRQ4,D_IRQ4,EOI4> ; область данных COM3 AREA4 SP_TAB <4,INT_COM4,E_IRQ3,D_IRQ3,EOI3> ; область данных COM4 _DATA ENDS COM_TEXT SEGMENT PARA public 'CODE' ASSUME cs:COM_TEXT,ds:DGROUP,es:NOTHING public _select_port public _save_com public _install_com public _restore_com public _open_com public _close_com public _dtr_on public _dtr_off public _r_count public _s_count public _receive_com public _send_com public _break_com public _com_errors ; ; выбор активного порта ; [bp+6] - номер порта _select_port PROC FAR push bp mov bp, sp mov ax, [bp+6] ;получаем в ax аргумент функции cmp al,1 ; установлен порт 1? je port1 ; да cmp al,2 ; установлен порт 2? je port2 ; да cmp al,3 ; установлен порт 3? je port3 ; да cmp al,4 ; установлен порт 4? je port4 ; да jmp set_carrent_area port1: mov ax,OFFSET DGROUP:AREA1 ; выбираем область данных COM1 jmp short set_carrent_area port2: mov ax,OFFSET DGROUP:AREA2 ; выбираем область данных COM2 jmp short set_carrent_area port3: mov ax,OFFSET DGROUP:AREA3 ; выбираем область данных COM3 jmp short set_carrent_area port4: mov ax,OFFSET DGROUP:AREA4 ; выбираем область данных COM4 set_carrent_area: ; записываем в переменной CURRENT_AREA смещение ; текущей области данных mov CURRENT_AREA,ax mov sp,bp pop bp ret _select_port ENDP ; ; сохранение текущего вектора прерывания COM-порта ; _save_com PROC FAR push bp mov bp,sp push si ; записываем в si указатель на текущую область данных mov si,CURRENT_AREA push es mov AREA1.int_hndlr,OFFSET int_hndlr1 mov AREA2.int_hndlr,OFFSET int_hndlr2 mov AREA3.int_hndlr,OFFSET int_hndlr3 mov AREA4.int_hndlr,OFFSET int_hndlr4 ; сохраняем старый вектор прерывания mov ah,35H mov al,int_com[si] ; номер прерывания int 21h ; записываем в переменные old_com_off и old_com_seg ; соответственно сегмент и смещение старого вектора прерывания mov old_com_off[si],bx mov bx,es mov old_com_seg[si],bx pop es pop si mov sp,bp pop bp ret _save_com ENDP ; ; install_com: установить активный порт ; ; возвращает в регистре ax - 1 при успешной установке ; и 0 в случае ошибки ; _install_com PROC FAR push bp mov bp,sp push si mov si,CURRENT_AREA push es cmp installed[si],1 jne go_install jmp alredy_ok ; очищаем счетчики ошибок go_install: mov WORD PTR EOVFLOW[si],0 ; переполнение буфера передатчика mov WORD PTR EOVRUN[si],0 ; ошибка переполнения при приеме mov WORD PTR EBREAK[si],0 ; обнаружен запрос на прерывание mov WORD PTR EFRAME[si],0 ; ошибка синхронизации mov WORD PTR EPARITY[si],0 ; ошибка четности mov WORD PTR EXMIT[si],0 ; ошибка при передаче mov WORD PTR EDSR[si],0 ; не получен сигнал DSR mov WORD PTR ECTS[si],0 ; не получен сигнал CTS ; определяем базовый адрес используемого COM порта mov bx,BIOS_VAR mov es,bx ASSUME es:BIOS_VAR cmp port[si],1 ; порт 1? je adr_3F8 cmp port[si],2 ; порт 2? je adr_2F8 cmp port[si],3 ; порт 3? je adr_3E8 cmp port[si],4 ; порт 4? je adr_2E8 int 20H adr_3F8: mov ax,3F8H jmp cmp_bios adr_2F8: mov ax,2F8H jmp cmp_bios adr_3E8: cmp rs232_base+4,0 je adr_3E8_A mov ax,rs232_base+4 jmp cmp_bios adr_3E8_A: mov ax,3E8H mov rs232_base+4,ax jmp cmp_bios adr_2E8: cmp rs232_base+6,0 je adr_2E8_A mov ax,rs232_base+6 jmp cmp_bios adr_2E8_A: mov ax,2E8H mov rs232_base+6,ax ; проверяем, определена ли соответствующая переменная ; BIOS cmp_bios: cmp ax,rs232_base je set_reg_adr cmp ax,rs232_base+2 je set_reg_adr cmp ax,rs232_base+4 je set_reg_adr cmp ax,rs232_base+6 jne bad_exit set_reg_adr: mov bx,DATREG mov cx,7 set_next_reg_adr: mov WORD PTR [si][bx],ax inc ax add bx,2 loop set_next_reg_adr ; устанавливаем вектор прерывания на наш обработчик mov AREA1.int_hndlr,OFFSET int_hndlr1 mov AREA2.int_hndlr,OFFSET int_hndlr2 mov AREA3.int_hndlr,OFFSET int_hndlr3 mov AREA4.int_hndlr,OFFSET int_hndlr4 mov ah,25H mov al,int_com[si] ; номер прерывания mov dx,OFFSET DGROUP:int_hndlr[si] push ds push cs pop ds int 21h pop ds ; поднимаем флаг - порт установлен alredy_ok: mov installed[si],1 pop es ; возвращаем 1 mov ax,1 pop si mov sp,bp pop bp ret ; порт не установлен bad_exit: mov installed[si],0 pop es ; возвращаем 0 mov ax,0 pop si mov sp,bp pop bp ret _install_com ENDP ; ; восстановление векторов прерываний ; _restore_com PROC FAR push bp mov bp,sp push si ; отмечаем COM-порт как неактивный mov si,CURRENT_AREA mov installed[si],0 ; восстанавливаем вектор прерывания mov ah,25H mov al,int_com[si] mov dx,old_com_off[si] mov bx,old_com_seg[si] push ds mov ds,bx int 21h pop ds pop si mov sp,bp pop bp ret _restore_com ENDP ; ; открыть COM порт ; ; сброс буферов передатчика и приемника, ; инициализация регистров UART 8250 ; разрешение прерываний от UART 8250 ; (программирование контроллера прерываний) ; ; [bp+6] = скорость обмена ; [bp+8] = способ соединения - M(Модем), D(Нуль-модем) ; [bp+10] = четность - N(ONE), O(DD), E(VEN), S(PACE), M(ARK) ; [bp+12] = число стоповых бит 1, 2 ; _open_com PROC FAR push bp mov bp,sp push si mov si,CURRENT_AREA ; запрещаем прерывания cli mov ax,[bp+6] mov baud_rate[si],ax mov bh,[bp+8] mov device_conn[si],bh mov bl,[bp+10] mov parity[si],bl mov ch,[bp+12] mov stop_bits[si],CH ; сбрасываем буферы и указатели mov start_s_data[si],0 mov end_s_data[si],0 mov start_r_data[si],0 mov end_r_data[si],0 mov size_s_data[si],0 mov size_r_data[si],0 ; проверяем, установлен ли уже обработчик прерываний test installed[si],1 jnz reset_uart jmp exit_open reset_uart: ; устанавливаем регистры UART 8250 ; сбрасываем регистр управления модемом mov al,0 mov dx,MCR[si] out dx,al jmp $+2 ; сбрасываем регистр состояния линии mov dx,LSR[si] in al,dx jmp $+2 ; сбрасываем регистр данных mov dx,DATREG[si] in al,dx jmp $+2 ; сбрасываем регистр состояния модема mov dx,MSR[si] in al,dx ; определяем делитель частоты тактового генератора mov ax,50 mul DIV50 div baud_rate[si] mov bx,ax ; переключаем регистр данных и регистр управления прерываниями ; для ввода делителя частоты тактового генератора mov dx,LCR[si] mov al,80H out dx,al jmp $+2 ; вводим младший байт делителя частоты тактового генератора mov dx,WORD PTR DLL[si] mov al,bl out dx,al jmp $+2 ; вводим старший байт делителя частоты тактового генератора mov dx,WORD PTR DLH[si] mov al,bh out dx,al jmp $+2 ; определяем четность и число стоповых битов mov al,03H cmp parity[si],'O' jne next1 mov al,0ah jmp short next3 next1: cmp parity[si],'E' jne next2 mov al,1ah jmp short next3 next2: cmp parity[si],'M' jne next3 mov al,2ah next3: test stop_bits[si],2 jz stop1 or al,4 stop1: mov dx,LCR[si] out dx,al ; разрешаем прерывания для 8259 и 8250 ; устанавливаем регистр маски прерываний так, чтобы ; разрешить прерывания от асинхронного порта in al,IMR and al,d_irq[si] out IMR,al ; разрешаем генерацию прерываний при готовности принимаемых ; данных, по состоянию BREAK и по ошибке mov dx,IER[si] mov al,5 out dx,al jmp $+2 ; устанавливаем DTR, RTS, OUT2 mov dx,MCR[si] mov al,0bh out dx,al exit_open: sti pop si mov sp,bp pop bp ret _open_com ENDP ; ; запрещаем прерывания от асинхронного порта ; _close_com PROC FAR push bp mov bp,sp push si mov si,CURRENT_AREA test installed[si],1 jz exit_close ; запрещаем прерывания UART 8250 mov dx,IER[si] mov al,0 out dx,al ; маскируем прерывания от UART mov dx,IMR in al,dx or al,e_irq[si] jmp $+2 out dx,al exit_close: pop si mov sp,bp pop bp ret _close_com ENDP ; ; снимаем сигнал DTR ; _dtr_off PROC FAR push bp mov bp,sp push si pushf push ax push dx push si mov si,CURRENT_AREA test installed[si],1 jz exit_dtr_off ; устанавливаем регистр управления модемом, ; сбрасываем сигналы DTR и RTS mov dx,MCR[si] mov al,08H out dx,al exit_dtr_off: pop si pop dx pop ax popf pop si mov sp,bp pop bp ret _dtr_off ENDP ; ; устанавливаем сигнал DTR ; _dtr_on PROC FAR push bp mov bp,sp push si pushf push ax push dx push si mov si,CURRENT_AREA test installed[si],1 jz exit_dtr_on ; устанавливаем регистр управления модемом, ; устанавливаем сигналы DTR, RTS, OUT2 mov dx,MCR[si] mov al,0bh out dx,al exit_dtr_on: pop si pop dx pop ax popf pop si mov sp,bp pop bp ret _dtr_on ENDP ; ; возвращаем в регистре ax число байт в регистре приемника, ; а в регистре dx общий размер буфера приемника ; _r_count PROC FAR push bp mov bp,sp push si pushf push si mov si,CURRENT_AREA mov ax,0 mov dx,R_SIZE test installed[si],1 jz exit_r_count ; записываем в регистр ax число символов в буфере приемника mov ax,size_r_data[si] exit_r_count: pop si popf pop si mov sp,bp pop bp ret _r_count ENDP ; ; получаем очередной символ из буфера приемника, ; полученный символ удаляется из буфера ; _receive_com PROC FAR push bp mov bp,sp push si pushf push bx push si mov si,CURRENT_AREA mov ax,-1 test installed[si],1 jz exit_receive_com ; возвращаемся, если буфер приемника пуст cmp size_r_data[si],0 je exit_receive_com mov ah,0 mov bx,start_r_data[si] mov al,reciave_buf[si][bx] cmp parity[si],'N' je no_parity ; если производится поверка на четность, то маскируем старший бит and al,7FH no_parity: inc bx cmp bx,R_SIZE jb rec_ptr_no_max mov bx,0 rec_ptr_no_max: mov start_r_data[si],bx dec size_r_data[si] exit_receive_com: pop si pop bx popf pop si mov sp,bp pop bp ret _receive_com ENDP ; ; функция возвращает в регистре ax число свободных байт в ; буфере передатчика, а в регистре dx общий размер буфера передатчика ; _s_count PROC FAR push bp mov bp,sp push si pushf push si mov si,CURRENT_AREA mov ax,0 mov dx,S_SIZE test installed[si],1 jz exit_s_count mov ax,S_SIZE sub ax,size_s_data[si] exit_s_count: pop si popf pop si mov sp,bp pop bp ret _s_count ENDP ; ; поместить символ в буфер передатчика ; [bp+6] - символ ; _send_com PROC FAR push bp mov bp,sp push si mov al,[bp+6] pushf push ax push bx push dx push si mov si,CURRENT_AREA test installed[si],1 jz exit_send_com cmp size_s_data[si],S_SIZE jl no_s_EOVFLOW ; произошло переполнение буфера передатчика inc WORD PTR EOVFLOW[si] jmp short exit_send_com no_s_EOVFLOW: mov bx,end_s_data[si] mov send_buf[si][bx],al inc bx cmp bx,S_SIZE jl no_send_ptr_max mov bx,0 no_send_ptr_max: mov end_s_data[si],bx inc size_s_data[si] ; считываем регистр управления прерываниями mov dx,IER[si] in al,dx ; завершаем функцию, если разрешены прерывания после передачи байта test al,2 jnz exit_send_com ; разрешаем прерывания после передачи байта, после приема байта, ; при обнаружении состояния BREAK и при возникновении ошибки mov al,7 out dx,al exit_send_com: pop si pop dx pop bx pop ax popf pop si mov sp,bp pop bp ret _send_com ENDP ; ; S_local ; _send_local PROC FAR push bp mov bp,sp push si mov al,[bp+6] pushf push ax push bx push si mov si,CURRENT_AREA test installed[si],1 jz SLX cli cmp size_r_data[si],R_SIZE jb L13A inc WORD PTR EOVFLOW[si] jmp short L14 L13A: mov bx,end_r_data[si] mov reciave_buf[si][bx],al inc bx cmp bx,R_SIZE jl L13 mov bx,0 L13: mov end_r_data[si],bx inc size_r_data[si] L14: sti SLX: pop si pop bx pop ax popf pop si mov sp,bp pop bp ret _send_local ENDP ; ; передаем удаленному модему сигнал BREAK ; _break_com PROC FAR push bp mov bp,sp push si pushf push ax push cx push dx mov si,CURRENT_AREA test installed[si],1 jz exit_break_com ; передаем сигнал BREAK mov dx,LCR[si] in al,dx jmp $+2 or al,40h out dx,al mov cx,0C000h do_BREAK: loop do_BREAK and al,0BFh out dx,al exit_break_com: pop dx pop cx pop ax popf pop si mov sp,bp pop bp ret _break_com ENDP ; ; возвращаем в dx:ax указатель на счетчики ошибок ; _com_errors PROC FAR push bp mov bp,sp mov ax,OFFSET DGROUP:CURRENT_AREA add ax,error_block mov dx,ds mov sp,bp pop bp ret _com_errors ENDP ; ; заполняем счетчики ошибок ; set_err PROC NEAR test al,2 jz test1 inc WORD PTR EOVRUN[si] test1: test al,4 jz test2 inc WORD PTR EPARITY[si] test2: test al,8 jz test3 inc WORD PTR EFRAME[si] test3: test al,16 jz exit_set_err inc WORD PTR EBREAK[si] exit_set_err: ret set_err ENDP ; ; протокол модема для передачи данных ; modem_protocol PROC NEAR cmp device_conn[si],'M' jne no_modem ; устанавливаем сигналы DTR, RTS и OUT2 mov dx,MCR[si] mov al,00001011B out dx,al jmp $+2 ; ожидаем, пока модем ответит о готовности сигналом DSR mov cx,1000 mov dx,MSR[si] wait_dsr: in al,dx test al,20H jnz test_cts loop wait_dsr ; модем не ответил сигналом DSR inc WORD PTR EDSR[si] jmp short no_modem test_cts: ; ожидаем, пока модем ответит о готовности сигналом CTS mov cx,1000 wait_cts: in al,dx test al,10H jnz test_lcr loop wait_cts ; модем не ответил сигналом CTS inc WORD PTR ECTS[si] test_lcr: no_modem: ; проверяем, пуст ли регистр хранения передатчика mov dx,LSR[si] in al,dx test al,20H jnz s_reg_empty ; ошибка при передаче inc WORD PTR EXMIT[si] s_reg_empty: ret modem_protocol ENDP ; ; обработчик прерываний от COM1 ; int_hndlr1 PROC FAR push si mov si,OFFSET DGROUP:AREA1 jmp short handle_int ; ; обработчик прерываний от COM2 ; int_hndlr2 PROC FAR push si mov si,OFFSET DGROUP:AREA2 jmp short handle_int ; ; обработчик прерываний от COM3 ; int_hndlr3 PROC FAR push si mov si,OFFSET DGROUP:AREA3 jmp short handle_int ; ; обработчик прерываний от COM4 ; int_hndlr4 PROC FAR push si mov si,OFFSET DGROUP:AREA4 ; ; обработчик прерываний ; handle_int: push ax push bx push cx push dx push bp push di push ds push es mov ax,DGROUP mov ds,ax next_pr: ; передаем контроллеру прерываний команду конца обработки ; прерывания mov dx,OCR mov al,eoi[si] out dx,al next_inter: ; считываем значение регистра идентификации прерывания mov dx,IIR[si] in al,dx ; определяем причину прерывания ; данные приняты и доступны для чтения cmp al,4 je RX_int ; буфер передатчика пуст cmp al,2 je TX_int ; изменилось состояние линий CTS, RI, DCD, DSR cmp al,0 je MSTAT_int ; обнаружено сотояние BREAK или произошла ошибка cmp al,6 je LSTAT_int ; завершаем обработку прерываний jmp FAR PTR exit_handler LSTAT_int: ; считываем регистр сотояния линии и вызываем функцию ; set_err, которая определит причину прерывания mov dx,LSR[si] in al,dx call set_err jmp next_inter MSTAT_int: ; считываем регистр состояния модема mov dx,MSR[si] in al,dx jmp next_inter TX_int: ; смотрим, есть ли данные для передачи модему cmp size_s_data[si],0 jg have_data_for_send ; если буфер передатчика пуст, переустанавливаем регистр ; управления прерываниями mov dx,IER[si] mov al,5 out dx,al jmp next_inter have_data_for_send: ; передаем символ модему в соответствии с состоянием ; линий RS-232-С call modem_protocol ; передаем очередной символ из буфера передатчика mov bx,start_s_data[si] mov al,send_buf[si][bx] mov dx,DATREG[si] out dx,al inc bx cmp bx,S_SIZE jb ptr_no_max mov bx,0 ptr_no_max: mov start_s_data[si],bx dec size_s_data[si] jmp next_inter ; данные приняты и доступны для чтения RX_int: ; считываем принятый байт из регистра данных UART mov dx,DATREG[si] in al,dx cmp size_r_data[si],R_SIZE jl no_r_EOVFLOW ; буфер приемника переполнен, увеличиваем соответствующий ; счетчик ошибок inc WORD PTR EOVFLOW[si] jmp next_inter no_r_EOVFLOW: mov bx,end_r_data[si] mov reciave_buf[si][bx],al inc size_r_data[si] inc bx cmp bx,R_SIZE jb no_max_r_ptr mov bx,0 no_max_r_ptr: mov end_r_data[si],bx jmp next_inter exit_handler: mov al,20h out 20h,al pop es pop ds pop di pop bp pop dx pop cx pop bx pop ax pop si iret int_hndlr4 ENDP int_hndlr3 ENDP int_hndlr2 ENDP int_hndlr1 ENDP COM_TEXT ENDS END
Теперь мы приведем исходные тексты включаемых файлов, используемых нашей программой.
// COMMON.H #define equal(a,b) (!strcmp(a,b)) #define equali(a,b) (!stricmp(a,b)) #define equalni(a,b,n) (!strnicmp(a,b,n)) #define equaln(a,b,n) (!strncmp(a,b,n)) #define nil(type) ((type *)NULL) #define boolean unsigned #define TRUE 1 #define FALSE 0
Файл CONF.H
#define OPERATOR(x) !strncmp(LineBuf,(x),strlen((x))) #define STRIP(x) (x)[strlen(x)-1] = 0;
Файл GET_WORD.H
unsigned expectstr(char *Search, unsigned int Timeout); void sendstr(char *str);
Файл MOD_LINK.H
#define CONN_INITIALIZE 1 #define CONN_CALLUP 2 #define CONN_HOTMODEM 3 #define CONN_ANSWER 4 #define CONN_LOGIN 5 #define CONN_HOTLOGIN 6 #define CONN_PROTOCOL 7 #define CONN_SERVER 8 #define CONN_CLIENT 9 #define CONN_TERMINATE 10 #define CONN_DROPLINE 11 #define CONN_EXIT 12 #define CONN_STATE char
Файл MODEM.H
int call( void ); int answer( void ); void slowwrite( char *s, int len); void shutdown( void ); extern char *device;
Файл TIMER.H
void sleep(time_t interval); void delay(int milliseconds);
Файл TOOLS.H
extern unsigned port_active;
int openline(char *name, unsigned baud);
unsigned int sread(char *buffer,
unsigned int wanted,
unsigned int timeout);
int swrite(char *data, unsigned int len);
void ssendbrk(unsigned int duration);
void closeline(void);
Файл TOTAL.H
#define WHITESPACE " \t\n\r" #define equal(a,b) (!strcmp(a,b)) #define equali(a,b) (!stricmp(a,b)) #define equalni(a,b,n) (!strnicmp(a,b,n)) #define equaln(a,b,n) (!strncmp(a,b,n)) #define nil(type) ((type *)NULL)
Файл UART.H
/** *.Name select_port * *.Title Выбираем используемый COM-порт * *.Descr Эта функция определяет, с каким COM-портом * мы в дальнейшем будем работать. * *.Proto void far select_port(int port) * *.Params int port - номер порта (COM1..COM4) * *.Return не используется * *.Sample comm.asm **/ void far select_port(int); /** *.Name save_com * *.Title Сохраняем старый вектор прерывания COM-порта * *.Descr Эта функция сохраняет адрес старого обработчика * прерываний от COM-порта. * *.Proto void far save_com(void) * *.Params не используется * *.Return не используется **/ void far save_com(void); /** *.Name restore_com * *.Title Восстанавливаем старый вектор прерывания COM-порта * *.Descr Эта функция восстанавливает адрес старого обработчика * прерываний от COM-порта. * *.Proto void far restore_com(void) * *.Params не используется * *.Return не используется **/ void far restore_com(void); /** *.Name install_com * *.Title Устанавливаем свой обработчик прерывания COM-порта * *.Descr Эта функция устанавливает новый обработчик * прерываний от COM-порта. * *.Proto int far install_com(void) * *.Params не используется * *.Return возвращает 1 при успешной установке * и 0 в случае ошибки **/ int far install_com(void); /** *.Name install_com * *.Title Устанавливаем свой обработчик прерывания COM-порта * *.Descr Эта функция устанавливает новый обработчик * прерываний от COM-порта. * *.Proto void far open_com( int baud, int device, * int parity, int stop_bits ) * *.Params int baud - скорость обмена * int device - тип устройства связи: M - модем * D - нуль-модем * int parity - проверка на четность: N - нет проверки * на четность, O - проверка по нечетности, * E - проверка по четности, S - Space, * M - Mark * int stop_bits - количество стоповых бит * *.Return не используется **/ void far open_com( int, int, int, int ); /** *.Name close_com * *.Title Запрещаем прерывания от асинхронного порта COM-порта * *.Descr Эта функция запрещает прерывания от COM-порта * *.Proto void far close_com(void) * *.Params не используется * *.Return не используется **/ void far close_com(void); /* close com port */ /** *.Name dtr_off * *.Title Сбрасываем сигнал DTR * *.Proto void far dtr_off(void) * *.Params не используется * *.Return не используется **/ void far dtr_off(void); /** *.Name dtr_on * *.Title Устанавливаем сигнал DTR * *.Proto void far dtr_on(void) * *.Params не используется * *.Return не используется **/ void far dtr_on(void); /** *.Name r_count * *.Title Определяем состояние буфера приемника * *.Proto long far r_count(void) * *.Params не используется * *.Return в младшем байте - число байт в буфере приемника, * а в старшем - общий размер буфера приемника * **/ long far r_count(void); // макроопределение r_count_size возвращает // общий размер буфера приемника #define r_count_size() ((int)(r_count() >> 16)) // макроопределение r_count_pending возвращает // число байт в буфере приемника #define r_count_pending() ((int)r_count()) /** *.Name receive_com * *.Title Получить один символ из буфера приемника * *.Proto int far receive_com(void) * *.Params не используется * *.Return очередной символ из буфера приемника **/ int far receive_com(void); /** *.Name s_count * *.Title Определяем состояние буфера приемника * *.Proto long far s_count(void) * *.Params не используется * *.Return в младшем байте - число свободных байт в буфере передатчика, * а в старшем - общий размер буфера передатчика * **/ long far s_count(void); // макроопределение s_count_size возвращает // общий размер буфера приемника #define s_count_size() ((int)(s_count() >> 16)) // макроопределение s_count_pending возвращает // число байт в буфере приемника #define s_count_free() ((int)s_count()) /** *.Name send_com * *.Title Передать один символ в буфер передатчика * *.Proto void far send_com(int ch) * *.Params int ch - передаваемый символ * *.Return не используется **/ void far send_com(int); /** *.Name break_com * *.Title Передать сигнал BREAK удаленному модему * *.Proto void far break_com(void) * *.Params не используется * *.Return не используется **/ void far break_com(void); /** *.Name com_errors * *.Title Возвращает указатель на массив счетчиков ошибок * *.Proto int far *far com_errors(void) * *.Params не используется * *.Return не используется **/ int far *far com_errors(void); #define COM_EOVFLOW 0 // переполнен буфер #define COM_EOVRUN 1 // ошибка переполнения при приеме #define COM_EBREAK 2 // обнаружен запрос на прерывание #define COM_EFRAME 3 // ошибка синхронизации #define COM_EPARITY 4 // ошибка четности #define COM_EXMIT 5 // ошибка при передаче #define COM_EDSR 6 // не получен сигнал dsr #define COM_ECTS 7 // не получен сигнал cts
Как мы говорили ранее, одним из преимуществ внешнего модема над внутренним является наличие на его лицевой панели световых индикаторов, по которым можно определить состояние модема.
Мы приведем маленькую резидентную программу, которая отображает на экране дисплея состояние модема. Наша программа компенсирует недостаток внутреннего модема, связанный с отсутствием индикации.
Программу можно также использовать при отладке своих приложений, работающих с COM-портами, так как фактически она отображает состояние регистров микросхемы UART.
Как работает эта программа? Она перехватывает прерывание от таймера (с номером 1Сh) и таким образом получает управление несколько раз в секунду. Затем она считывает значения регистров состояния линии, состояния модема и регистра управления модемом.
По состоянию регистра управления модемом программа определяет состояние линий DTR и RTS, управляющих процессом подтверждения связи. Регистр состояния модема отражает состояние сигналов CTS, DSR, используемых для управления потоком, а также линий RI и DCD. Сигнал RI означает, что пришел вызов от удаленного модема, а сигнал DCD - что модемы установили и поддерживают связь.
После того как программа считает состояние регистров асинхронного порта, она отображает их состояние на экране дисплея. Вывод данных на экран наша программа выполняет путем непосредственного доступа к видеопамяти. При этом данные выводятся, начиная с адреса B800:0000. Если вы собираетесь использовать программу в графических режимах видеоадаптера или отображать данные о сотоянии регистров в другом месте экрана, то вам надо самим изменить процедуру вывода.
После запуска программы в левом верхнем углу экрана появится небольшое окно, в котором будет отображаться состояние линий TD, RD, RTS, CTS, RI, CDC, DTR, DSR:
--T-T-T-T-T-T-T-¬ ¦t¦r¦r¦c¦r¦d¦d¦d¦ ¦d¦d¦t¦t¦i¦c¦t¦s¦ ¦ ¦ ¦s¦s¦ ¦d¦r¦r¦ LT+T+T+T+T+T+T+T- ¦ ¦ ¦ ¦ ¦ ¦ ¦ L---- сигнал DSR ¦ ¦ ¦ ¦ ¦ ¦ L------ сигнал DTR ¦ ¦ ¦ ¦ ¦ L-------- сигнал DCD ¦ ¦ ¦ ¦ L---------- сигнал RI ¦ ¦ ¦ L------------ сигнал CTS ¦ ¦ L-------------- сигнал RTS ¦ L---------------- данные принимаются L------------------ данные передаются
Если какой-нибудь из этих сигналов примет значение логической единицы, то первый символ в названии этого сигнала будет отображаться с заглавной буквы. Например, если модем установил связь и передает данные, будут активными линии TD, RTS, CTS, DCD, DTR и DSR:
T r R C r D D D d d t t i c t s s s d r r
Итак, текст программы:
// LIGHT.C
// сигнальные лампы модема
#include <stdlib.h>
#include <string.h>
#include <dos.h>
// включаемый файл uart_reg.h можно найти в приложении
#include "uart_reg.h"
// отключаем проверку стека и указателей
#pragma check_stack( off )
#pragma check_pointer( off )
// количество прерываний от таймера за одну секунду
#define TICKPERMIN 1092L
char _huge *tsrstack;
char _huge *appstack;
char _huge *tsrbottom;
// объявления функций
void (_interrupt _far *oldtimer)( void );
void _interrupt _far newtimer( void );
void test_com_port( void );
void hello( void );
void help( void );
// определяем указатель на счетчик таймера
long _far *pcurtick = (long _far *)0x0000046cL;
long goaltick;
// следующий массив содержит возможные базовые адреса
// различных последовательных портов
unsigned uart_reg[] = { 0, 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
unsigned com_port;
// главная процедура
void main( int argc, char *argv[] ) {
unsigned tsrsize;
// параметр программы должен содержать номер
// используемого COM-порта
if( argc < 2 ) help();
hello();
_asm mov WORD PTR tsrstack[0], sp
_asm mov WORD PTR tsrstack[2], ss
FP_SEG( tsrbottom ) = _psp;
FP_OFF( tsrbottom ) = 0;
com_port = ( unsigned ) uart_reg[atoi( argv[1] )];
printf( "\nпорт %x\n", com_port );
// определяем момент первой проверки регистров
// асинхронного адаптера
goaltick += TICKPERMIN / 10L;
// переустанавливаем вектор прерывания от таймера
oldtimer = _dos_getvect( 0x1c );
_dos_setvect( 0x1c, newtimer );
// вычисляем размер резидентной части программы
tsrsize = ((tsrstack - tsrbottom) >> 4) + 1;
_dos_freemem( _psp );
// оставляем программу резидентной в памяти
_dos_keep( 0, tsrsize );
}
void hello( void ) {
printf("\n(c) Frolov G.V. Сигнальные лампы\n \n"
" trrcrddd \n"
" ddtticts \n"
" ss drr \n"
" ¦¦¦¦¦¦¦¦ \n"
" ¦¦¦¦¦¦¦L---- сигнал DSR \n"
" ¦¦¦¦¦¦L----- сигнал DTR \n"
" ¦¦¦¦¦L------ сигнал DCD \n"
" ¦¦¦¦L------- сигнал RI \n"
" ¦¦¦L-------- сигнал CTS \n"
" ¦¦L--------- сигнал RTS \n"
" ¦L---------- данные принимаются \n"
" L----------- данные передаются \n"
);
}
void help( void ) {
printf(" Неправильно задан параметр программы - \n"
" пример: LIGHT [1|2|3|4] \n");
exit(0);
}
// обработчик прерываний от таймера
void _interrupt _far newtimer() {
// если пришло время, проверяем регистры COM-порта
if(*pcurtick >= goaltick) {
(*oldtimer)();
// вычисляем время следующей проверки
goaltick += TICKPERMIN / 10L;
// проверяем регистры COM-порта и отображаем их на экране
test_com_port();
}
else
_chain_intr( oldtimer );
}
void test_com_port( void ) {
char data[] = "trrcrddd";
char data2[] = "ddtticts";
char data3[] = " ss drr";
char attr[9];
_asm {
// получаем адрес регистра состояния линии
mov dx,com_port
add dx,LSR_N
in al,dx
// проверяем, пуст ли регистр сдвига передатчика
test al,40h
jz next_1
mov ah,'t'
mov data[0],ah
mov attr[0],0x71
jmp short next_2
next_1:
// если регистр сдвига не пуст, значит, модем
// осуществляет передачу данных
mov ah,'T'
mov data[0],ah
mov attr[0],0x79
next_2:
// проверяем, есть ли данные, готовые для чтения
test al,1
jnz next_3
mov ah,'r'
mov data[1],ah
mov attr[1],0x71
jmp short next_4
next_3:
// если есть данные для чтения, отображаем на экране
// символ 'R'
mov ah,'R'
mov data[1],ah
mov attr[1],0x79
next_4:
// считываем регистр состояния модема
mov dx,com_port
add dx,MSR_N
in al,dx
// определяем состояние линии CTS
test al,10h
jnz next_5
// линия CTS неактивна
mov ah,'c'
mov data[3],ah
mov attr[3],0x72
jmp short next_6
next_5:
// линия CTS активна
mov ah,'C'
mov data[3],ah
mov attr[3],0x7a
next_6:
// определяем состояние линии DSR
test al,20h
jnz next_7
// линия DSR неактивна
mov ah,'d'
mov data[7],ah
mov attr[7],0x72
jmp short next_8
next_7:
// линия DSR активна
mov ah,'D'
mov data[7],ah
mov attr[7],0x7a
next_8:
// определяем состояние линии RI
test al,40h
jnz next_9
// линия RI находится в неактивном состоянии
mov ah,'r'
mov data[4],ah
mov attr[4],0x76
jmp short next_10
next_9:
// линия RI находится в активном состоянии
mov ah,'R'
mov data[4],ah
mov attr[4],0x7e
next_10:
// определяем состояние линии DCD
test al,80h
jnz next_11
// линия DCD неактивна
mov ah,'d'
mov data[5],ah
mov attr[5],0x76
jmp short next_12
next_11:
// линия DCD активна
mov ah,'D'
mov data[5],ah
mov attr[5],0x7e
next_12:
// считываем регистр управления модемом
mov dx,MCR_N
add dx,com_port
in al,dx
// проверяем линию RTS
test al,2
jnz next_13
// линия RTS находится в неактивном состоянии
mov ah,'r'
mov data[2],ah
mov attr[2],0x74
jmp short next_14
next_13:
// линия RTS находится в активном состоянии
mov ah,'R'
mov data[2],ah
mov attr[2],0x7c
next_14:
// проверяем линию DTR
test al,1
jnz next_15
// линия DTR неактивна
mov ah,'d'
mov data[6],ah
mov attr[6],0x74
jmp short next_16
next_15:
// линия DTR активна
mov ah,'D'
mov data[6],ah
mov attr[6],0x7c
next_16:
// отображаем на экране состояние регистров
// вывод на экран происходит непосредственно
// через видеопамять
// сегмент видеопамяти
mov ax,0B800h
mov es,ax
xor si,si
mov di,0
mov cx,8
next_char:
// отображаем на экране очередной символ
// из массива data
mov ah,data[si]
mov es:[di],ah
inc di
// устанавливаем атрибуты этого символа
mov ah,attr[si]
mov es:[di],ah
sti
inc di
inc si
loop next_char
xor si,si
mov di,160
mov cx,8
next_str2:
mov ah,data2[si]
mov es:[di],ah
inc di
mov ah,attr[si]
mov es:[di],ah
sti
inc di
inc si
loop next_str2
xor si,si
mov di,320
mov cx,8
next_str3:
mov ah,data3[si]
mov es:[di],ah
inc di
mov ah,attr[si]
mov es:[di],ah
sti
inc di
inc si
loop next_str3
}
}