On-Line Библиотека www.XServer.ru - учебники, книги, статьи, документация, нормативная литература.
       Главная         В избранное         Контакты        Карта сайта   
    Навигация XServer.ru


Крем краска для временных тату styletattoo.ru.

Загрузка...




 

Программирование модемов

5.1. Основные принципы программирования модемов

5.2. Простейшая программа работы с модемом

5.3. Коммуникационная программа

5.4. Коммуникационная программа, использующая прерывания

5.5. Сигнальные лампы для внутреннего модема

В этой главе мы рассмотрим основные принципы программирования модемов и приведем две коммуникационные программы.

5.1. Основные принципы программирования модемов

Доступ к модему происходит через последовательный асинхронный порт. При этом для передачи модему команд их необходимо просто записать в регистр данных COM-порта, на котором находится модем. Ответ от модема также поступает через последовательный порт. Передавая модему команды, его можно проинициализировать, перевести в режим автоответа или заставить набрать номер.

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

Итак, после установления связи с удаленным модемом, коммуникационная программа может начинать обмен данными. Обмен данными так же, как и передача команд, осуществляется через COM-порт. Затем при помощи специальной Escape-последовательности можно переключить модем из режима передачи данных обратно в командный режим и положить трубку (AT-команда ATH0), разорвав связь с удаленным модемом.

Принципы обмена данными с внешними устройствами через COM-порт представлены в главе "Программирование асинхронного адаптера".

Приведем последовательность действий для установления связи и обмена данными через модем.

  • Инициализация 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

Низкий уровень сигналов DTR и RTS сообщает модему, что компьютер не готов к приему данных через COM-порт.

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

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

5.2. Простейшая программа работы с модемом

Сейчас мы приведем, возможно, не очень полезную, но очень простую программу, работающую с модемом. Эта программа может только передавать команды модему. Принимать данные от модема и выполнять другие функции, присущие программам работы с модемом, она не может.

Программа работает следующим образом: сначала устанавливает сигнал 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 );
*
*.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 );
}

5.3. Коммуникационная программа

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

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

Итак, приступим. Как мы сказали ранее, первым шагом при программировании модема надо считать инициализацию COM-порта (микросхемы UART), к которому подключен модем.

Инициализация COM-порта

Сначала надо перевести в неактивное состояние линии 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

В этой главе мы объединим все сказанное выше в одной программе. Программа состоит из следующих модулей:

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() позволяет передать на модем только один символ. Передача символа осуществляется следующим образом:

  • ожидаем, пока модем сообщит о своей готовности по линии DSR;
  • ожидаем, пока освободится регистр передатчика и можно будет передать следующий байт;
  • записываем передаваемый байт в регистр данных COM-порта для последующей его передачи модему.

Функция 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;
   }
}

5.4. Коммуникационная программа, использующая прерывания

Программа, представленная в предыдущей главе, имеет один большой недостаток: она должна постоянно производить опрос регистра состояния линии, с тем чтобы определить момент, когда от модема поступит очередной символ. В результате становится трудной, а иногда невозможной обработка поступающих символов. Например, если вы сразу отображаете символы, получаемые от COM-порта, на экране, то при использовании для этого функции putch() отдельные символы могут быть потеряны. Дело в том, что функция putch() работает слишком медленно и на скоростях 2400 бод и выше модем может успеть передать в COM-порт несколько новых символов, в то время как функция putch() еще не вывела на экран ни одного символа. В этом случае происходит ошибка переполнения входного буфера микросхемы UART (см. бит D2 регистра состояния линии).

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

Если ваша коммуникационная программа будет использовать прерывания, можно организовать буфер принимаемых и передаваемых данных. Обработчик прерываний должен проанализировать причину прерывания и либо передать в COM-порт очередной символ из буфера передатчика (если прерывание произошло в результате передачи очередного символа), либо считать поступивший символ из регистра данных и записать его в буфер приемника (если прерывание произошло в результате приема от модема очередного символа).

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

Принципы использования прерываний

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

Прерывания могут вырабатываться асинхронным адаптером в следующих случаях:

  • изменилось состояние линии приемника: произошло переполнение приемника, произошла ошибка четности или синхронизации, линия перешла в состояние BREAK;
  • данные приняты и доступны для чтения через регистр данных;
  • регистр передатчика пуст;
  • изменилось состояние модема: изменилось состояние линий CTS, RI, DCD, DSR.

Вы можете отдельно запрещать или разрешать эти прерывания. Для этого необходимо установить соответствующие биты в регистре управления прерываниями.

Как приходит прерывание от 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.

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

Установить обработчик прерываний

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

Инициализация COM-порта

Сначала надо перевести в неактивное состояние линии 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. В отличие от программы 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();
}

Данный модуль определяет функции высокого уровня для работы с модемом:

  • call() - режим вызова удаленного модема,
  • answer() - режим ответа на приходящие звонки,
  • shutdown() - завершение сеанса связи,
  • exchange() - диалог пользователя и удаленного модема.

Эти функции вызывают модули более низкого уровня: 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

5.5. Сигнальные лампы для внутреннего модема

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

Мы приведем маленькую резидентную программу, которая отображает на экране дисплея состояние модема. Наша программа компенсирует недостаток внутреннего модема, связанный с отсутствием индикации.

Программу можно также использовать при отладке своих приложений, работающих с 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

   }
}
Назад       Содержание       Вперёд