Модемы и факс-модемы. Программирование для MS-DOS и Windows

       

Программа CHATINT


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

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

Данная телекоммуникационная программа может работать в двух режимах - активном, когда она сама производит вызов удаленного модема, и пассивном, когда программа находится в режиме ожидания звонка от удаленного модема. Для работы программы в активном режиме необходимо запустить ее с параметром "1", для пассивного режима - "0".

Большинство параметров программы, таких, как номер COM-порта, к которому подключен модем, скорость обмена данными, AT-команды инициализации модема и телефонный номер вызываемого абонента можно настроить через файл конфигурации SETUP.CFG. Образец этого файла представлен в листинге 6.1.

Листинг 6.1. Файл 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

Исходные тексты программы CHATINT включают в себя несколько модулей на языке Си и один модуль на языке ассемблера. Ниже перечислены названия исходных файлов программы:


Имена файлов

Содержит

CHATINT.C

Главная функция программы

MODEM.C

Передача данных модему через COM-порт

TIMER.C

Реализация временных задержек

CONF.C

Чтение и обработка файла конфигурации

SEND_COMM.C

Передача команд модему

TOOLS.C

Набор функций для работы с модулем UART.ASM

UART.ASM

Обработчик прерываний и процедуры низкого уровня

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

Теперь приведем сами исходные тексты программы. Основной модуль программы называется CHATINT.C (см. листинг 6.2). В зависимости от параметра программы этот модуль вызывает функцию Call - для вызова удаленного модема - или функцию Answer - для ответа на приходящие звонки.

Если программа CHATINT запущена без параметров, управление передается функции Hello. Функция Hello отображает на экране справочную информацию. Затем программа завершается.

После окончания сеанса связи вызывается функция Shutdown, которая опускает телефонную трубку и отключает обработчик прерываний.

Функции Call, Answer и Shutdown, выполняют все действия по программированию COM-порта, контроллера прерываний и модема. Данные функции определены в модуле MODEM.C. Исходные тексты модуля MODEM.C приведены в листинге 6.4.

Листинг 6.2. Файл CHATINT.C

//=======================================================

// Основной модуль коммуникационной программы

//=======================================================

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <sys/types.h>

#include "common.h"

#include "modem.h"

#include "timer.h"

#include "tools.h"

//=======================================================

// Функция Hello

//=======================================================

void Hello(void)

{

      printf("Неправильно задан параметр программы \n"

                         "CHATINT n, где n = 1 режим вызова, "



                         "n = 0 режим ответа\n");

      exit(0);

}

// Основная процедура

void main( int argc, char *argv[] ) {

      // Программа должна вызываться  параметром 1 или 0

      if( argc < 2 )

             Hello();

      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();

}

В файле CONF.C определена функция GetConfig, считывающая файл конфигурации SETUP.CFG и заполняющая соответствующими значениями глобальные переменные (см. листинг 6.3).

Функция GetConfig открывает файл конфигурации SETUP.CFG и начинает считывать его содержимое по одной строке. Каждое первое слово из строки сравнивается с ключевыми словами, приведенными в следующей таблице. В случае совпадения заполняется соответствующая глобальная переменная. Глобальные переменные определены в файле MODEM.C (см. листинг 6.4).

Ключевое слово

Глобальная переменная

Описание

Dropline

dropline

Команда модему для разрыва связи с удаленным модемом

Initialize

initialize

Команда инициализации модема

AutoAnswer

autoanswer

Команда инициализации модема для работы в режиме автоответа на приходящие звонки

DialNumber

dialNumber

Номер удаленного модема

DialPrefix

dialPrefix

Префикс для команды набора номера

DialSuffix

dialSuffix

Суффикс для команды набора номера

Device

device

Номер COM-порта, к которому подключен модем

CharDelay

chardelay

Задержка между отдельными символами, передаваемыми модему

DialTimeout

dialTimeout

Интервал времени, за который модем должен набрать номер и установить связь с удаленным модемом

ModemTimeout

modemTimeout

Интервал времени, за который модем должен ответить на передаваемые ему команды

TimeoutAnswer

answerTimeout

Время, отведенное на установку связи с удаленным модемом

Speed

speed

Скорость обмена данными через COM-порт

<


По достижении конца файла SETUP.CFG файл закрывается, и функция возвращает управление.

Листинг 6.3. Файл 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];

      // Глобальные переменные, заполняемые функцией GetConfig

      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;

//=============================================================

// Функция GetConfig

//=============================================================

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("AutoAnswer"))  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);

}

//=====================================================

// Функция Token

//=====================================================

void Token( char *string ) {

      char *next;

      next = strcpy( string, strchr( LineBuf, ' ' ) + 1 );

      if(next == NULL) string[0] = '\0';

}

//=====================================================

// Функция Number

//=====================================================

void Number( unsigned *num ) {

      char buf[80];

      strcpy( buf, strchr( LineBuf, ' ' ) + 1 );

      *num = atoi( buf );

}

В файле MODEM.C, представленном на листинге 6.4, определены основные функции высокого уровня для работы с модемом:

Функция

Назначение

Call

Определяет работу программы в режиме вызова удаленного модема

Answer

Определяет работу программы в режиме ответа на приходящие звонки

Shutdown

Выполняет завершение сеанса связи

Exchange

Поддерживает диалог пользователя и удаленного модема.

Эти функции вызывают модули более низкого уровня: SENDCMD.C и TOOLS.C.

Листинг 6.4. Файл MODEM.C

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <sys/types.h>

#include "uart.h"

#include "common.h"

#include "modem.h"

#include "sendcmd.h"

#include "timer.h"

#include "tools.h"

#include "conf.h"

// Номер используемого порта в формате COMn, где n от 1 до 4

char *device = "COM3";

// Продолжительность ожидания соединения

unsigned  dialTimeout = 12;

// Задержка при передаче между символами

unsigned  chardelay = 0;

// Таймаут на получение ответа от модема



unsigned  modemTimeout = 3;

// Продолжительность ожидания звонка

unsigned  answerTimeout;

// Скорость обмена данными

unsigned  speed = 2400;

char initialize[80];    // команда инициализации

char dropline[80];      // команда повесить трубку

char autoanswer[80];    // ответ на вызов в режиме автоответа

char dialPrefix[80];  // префикс номера

char dialSuffix[80];  // суффикс номера

char dialNumber[80];  // телефонный номер

// Прототип функции Exchange

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( RCountPending() > 0 ) {

             SRead(str, i = RCountPending(), 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( );

                         flag = 0;

                         break;

                   }

                   if( key == '\r' ) putch( '\n' );

                   putch(key);

                   SWrite( &key, 1);

             }

             // Если получены данные от модема, отображаем их на экране

             if( RCountPending() > 0 ) {

                   Delay(100);

                   SRead(str, i = RCountPending(), 0);

                   str[i] = '\0';

                   for( j = 0; j < i; j++ )

                         putch( str[j] );

             }

      }

}

Следующий модуль - SENDCMD.C определяет функцию SendStr, которая используется для передачи модему AT-команд. Исходные тексты файла SENDCMD.C приведены в листинге 6.5.

Листинг 6.5. Файл SENDCMD.C

#include <string.h>

#include <time.h>

#include "common.h"

#include "modem.h"

#include "sendcmd.h"

#include "timer.h"

#include "tools.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, представленный в листинге 6.6, содержит определения функций для работы с модулем UART.ASM.

Листинг 6.6. Файл 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;

static unsigned    hangup_needed = TRUE;

#define  STOPBIT  1

/**

*.Name     OpenLine

*

*.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-порт

      SelectPort(value);

      // Сохраняем адрес старого обработчика прерываний COM-порта

      SaveCom();

      // Устанавливаем новый обработчик прерываний COM-порта

      InstallCom();

      // Программируем текущий COM-порт

      // скорость, связь через модем, не проверяем четность

      // один стоповый бит

      OpenCom(baud, 'M', 'N', STOPBIT);

      // Запоминаем скорость

      current_baud = baud;

      // Устанавливаем линию DTR в активное состояние

      // (компьютер готов к обмену данными)

      DtrOn();

      port_active = TRUE;

      return( 0 );

}

/**

*.Name    SRead

*

*.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 = RCountPending();

             // Если в буфере ессть необходимое количество символов

             if (pending >= wanted) {

                   unsigned int i;

                   // Считывааем из буфера нужное число символов

                   for (i = 0; i < wanted; i++)

                         *buffer++ = (char) ReceiveCom();

                   return pending;

             }

             // Если в буфере приемника меньше символов, чем заказано

             // для чтения, проверяем, не истекло ли отведенное для

             // чтения время

             else {

                   time_t   now     = time(nil(time_t));

                   time_t   elapsed = now - start;

                   Delay(0);

                   if (elapsed >= (long) timeout)

                         return pending;

             }

      }

}

/**

*.Name     SWrite

*

*.Descr    Функция записывает заданное число символов

*          в буфер передатчика асинхронного порта.

*

*.Proto    int SWrite(char *data, unsigned len)

*

*.Params   char *data - указатель на буфер данных

*

*          unsigned len - число символов, которое надо записать

*                         в буфер передатчика

*

*.Return   количество символов записанных в буфер передатчика

**/

int SWrite(char *data, unsigned int len) {

      unsigned int i;

      hangup_needed = TRUE;

      // Записываем входные данные в буфер передатчика



      // асинхронного порта

      for (i = 0; i < len; i++)

             SendCom(*data++);

      return len;

}

/**

*.Name         SSendBrk

*

*.Title        Передает сигнал BREAK удаленному модему.

*

*.Proto        void SSendBrk()

*

*.Params       Не используются.

*

*.Return       Не используется.

**/

void SSendBrk(void)  {

      BreakCom();

}

/**

*.Name         CloseLine

*

*.Descr        Функция восстанавливает старые значение

*              векторов прерываний и запрещает прерывания

*              от COM-порта.

*

*.Proto        void CloseLine(void)

*

*.Params       Не используются.

*

*.Return       Не используется.

**/

void CloseLine(void) {

      int far *stats;

      port_active = FALSE;

      // Отменяем сигнал DTR

      DtrOff();

      // Запрещаем прерывания от COM-порта

      CloseCom();

      // Восстанавливаем вектора прерываний

      RestoreCom();

}

Вспомогательный модуль TIMER.C (см. листинг 6.7) содержит определения функций Sleep и Delay. Эти функции используются в программе для организации временных задержек.

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

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

Листинг 6.7. Файл TIMER.C

#include <time.h>

#include <stdio.h>

#include <sys/timeb.h>

#include "timer.h"

/**

*.Name    Sleep

*

*.Descr   Функция приостанавливает выполнение

*         программы на заданное число секунд.

*

*.Proto   void Sleep(time_t interval)

*

*.Params  time_t interval - время задержки в секундах

*

*.Return  Не используется

**/

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

*

*.Descr   Функция приостанавливает выполнение

*         программы на заданное число милисекунд.

*

*.Proto   void Delay(int milliseconds)

*

*.Params  time_t interval - время задержки в милисекундах

*

*.Return  Не используется

**/

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;

      }

}

Включаемый файл COMMON. H содержит макроопределения нескольких функций, предназначенных для работы со строками. Исходный текст файла COMMON.H содержится в листинге 6.8.

Листинг 6.8. Файл 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 (см. листинг 6.9) содержит макроопределения OPERATOR и STRIP, используемые в модуле CONF.C, а также описание функции GetConfig.

Листинг 6.9. Файл CONF.H

#define OPERATOR(x)          !strncmp(LineBuf,(x),strlen((x)))

#define STRIP(x)              (x)[strlen(x)-1] = 0;



void GetConfig(void);

Модуль UART.ASM - это основной модуль программы CHAT. Он содержит обработчик прерываний от COM-порта и функции низкого уровня для работы с ним. Исходный текст модуля UART.ASM представлен в листинге 6.10.

Обработчик прерываний имеет два буфера - буфер приемника и буфер передатчика. Через эти буферы осуществляется обмен данными между программой и обработчиком прерываний. Буферы выполнены в виде очереди.

Опишем функции, определенные в модуле UART.ASM.

Функция

Назначение

SelectPort

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

SaveCom

Сохраняет адрес старого обработчика прерываний от COM-порта. Функция не имеет параметров и не возвращает никакого значения.

RestoreCom

Восстанавливает адрес старого обработчика прерываний от COM-порта, ранее сохраненного функцией SaveCom.

InstallCom

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

OpenCom

Инициализирует регистры асинхронного адаптера. Первый параметр функции baud определяет скорость обмена данными через COM-порт. Второй параметр - device задает тип устройства связи: Для модемов он должен содержать код символа 'M', а для нуль-модема - 'D'. Третий параметр parity - управляет проверкой на четность. Если он содержит код символа 'N' - проверка не производится, 'O' - выполняется проверка по нечетности, 'E' - проверка по четности, 'S' - бит четности всегда сброшен и 'M' - бит четности установлен. Последний параметр - stop_bits - задает количество стоповых битов.

CloseCom

Запрещает прерывания от COM-порта. После ее вызова обмен данными через COM-порт прекращается.

DtrOn

Устанавливает сигнал DTR

DtrOff

Сбрасывает сигнал DTR

RCount

Проверяет состояние буфера приемника. Младший байт значения, возвращаемого функцией, определяет количество байтов в буфере приемника, а старший - общий размер буфера приемника.

ReceiveCom

Читает один символ из буфера приемника и возвращает его значение.

SCount

Возвращает в младшем байте число свободных байтов в буфере передатчика, а в старшем - общий размер буфера передатчика.

SendCom

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

BreakCom

Переводит передающую линию в состояние BREAK.

ComErrors

Возвращает указатель на массив счетчиков ошибок. Во включаемом файле UART.H определен набор констант для доступа к отдельным полям этого массива.

<


Листинг 6.10. Файл UART.ASM

;  Определяем размеры буфера приемника и передатчика

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

; **** Область данных для каждого порта ****

; Область данных COM1

      AREA1 SP_TAB   <1,INT_COM1,E_IRQ4,D_IRQ4,EOI4>

; Область данных COM2

      AREA2 SP_TAB   <2,INT_COM2,E_IRQ3,D_IRQ3,EOI3>

; Область данных COM3

      AREA3 SP_TAB   <3,INT_COM3,E_IRQ4,D_IRQ4,EOI4>

; Область данных COM4

      AREA4 SP_TAB   <4,INT_COM4,E_IRQ3,D_IRQ3,EOI3>



_DATA  ENDS

COM_TEXT    SEGMENT PARA public 'CODE'

      ASSUME   cs:COM_TEXT,ds:DGROUP,es:NOTHING

      public   _SelectPort

      public   _SaveCom

      public   _InstallCom

      public   _RestoreCom

      public   _OpenCom

      public   _CloseCom

      public   _DtrOn

      public   _DtrOff

      public   _RCount

      public   _SCount

      public   _ReceiveCom

      public   _SendCom

      public   _BreakCom

      public   _ComErrors

;=======================================================

; Выбор активного порта

;  [bp+6] - номер порта

_SelectPort   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

_SelectPort   ENDP

;=======================================================

; Сохранение текущего вектора COM прерывания

_SaveCom      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

_SaveCom      ENDP

;=======================================================

; InstallCom: установить активный порт

;

; Возвращает в регистре ax - 1 при успешной установке

; и 0 в случае ошибки

;

_InstallCom   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

_InstallCom   ENDP

;=======================================================

; Восстановление векторов прерываний

;

_RestoreCom   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

_RestoreCom   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

;

_OpenCom   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

_OpenCom     ENDP

;=======================================================

; Запрещаем прерывания от асинхронного порта

_CloseCom     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

_CloseCom     ENDP

;=======================================================

; Снимаем сигнал DTR

_DtrOff     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

_DtrOff     ENDP

;=======================================================

; Устанавливаем сигнал DTR

_DtrOn 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

_DtrOn ENDP

;=======================================================

; Возвращаем в регистре ax число байтов в регистре приемника,

; а в регистре dx общий размер буфера приемника

_RCount   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

_RCount   ENDP

;=======================================================

; Получаем очередной символ из буфера приемника,

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

_ReceiveCom 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

_ReceiveCom ENDP

;=======================================================

; Функция возвращает в регистре ax число свободных байт в

; буфере передатчика, а в регистре dx общий размер буфера

; передатчика

_SCount   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

_SCount   ENDP

;=======================================================

; Поместить символ в буфер передатчика

;  [bp+6] - символ

_SendCom      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

_SendCom      ENDP

;=======================================================

; S_local

;

_SendLocal 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

_SendLocal ENDP

;=======================================================

; Передаем удаленному модему сигнал "BREAK"

;

_BreakCom     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

_BreakCom     ENDP



;=======================================================

; Возвращаем в dx: ax указатель на счетчики ошибок

;

_ComErrors 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

_ComErrors ENDP

;=======================================================

; Заполняем счетчики ошибок

;

SetErr   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

SetErr   ENDP

;=======================================================

; Протокол модема для передачи данных

;

ModemProtocol 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

ModemProtocol 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    ; SAVE si

      mov   si,OFFSET DGROUP:AREA3

      jmp   short handle_int

;=======================================================

; Обработчик прерываний от COM4

;

int_hndlr4 PROC  FAR

      push  si    ; SAVE 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,6

      je    LSTAT_int

      ; Обнаружено состояние "BREAK" или произошла ошибка

      cmp   al,0

      je    MSTAT_int

      ; Завершаем обработку прерываний

      jmp   FAR PTR exit_handler

LSTAT_int:

      ; Считываем регистр сотояния линии и вызываем функцию

      ; set_err, которая определит причину прерывания

      mov   dx,LSR[si]

      in    al,dx

      call  SetErr

      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  ModemProtocol

      ; Передаем очередной символ из буфера передатчика

      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

Включаемый файл SENDCMD.H, представленный в листинге 6.11, содержит описания функций ExpectStr и SendStr. Эти функции были нами определены в модуле SENDCMD.C.

Листинг 6.11. Файл SENDCMD.H

unsigned         ExpectStr(char *Search, unsigned int Timeout);

void                        SendStr(char *str);

Включаемый файл MODEM.H (см. листинг 6.13) содержит описание функций Call, Answer, SlowWrite и ShutDown, определенных в модуле MODEM.C.



Листинг 6.12. Файл MODEM.H

int        Call( void );

int        Answer( void );

void           SlowWrite( char *s, int len);

void           ShutDown( void );

extern char *device;

Включаемый файл MODEM.H (см. листинг 6.14) содержит описание функций Sleep и Delay, определенных в модуле TIMER.C, и предназначенных для организации временных задержек.

Листинг 6.13. Файл TIMER.H

void Sleep(time_t interval);

void Delay(int milliseconds);

Включаемый файл TOOLS.H (см. листинг 6.15) содержит описание функций, определенных в модуле TOOLS.C.

Листинг 6.14. Файл 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(void);

void CloseLine(void);

Включаемый файл UART.H (см. листинг 6.14) содержит описание функций, определенных в модуле UART.ASM и констант COM_E, используемых для определения причины ошибок COM-порта.

Листинг 6.15. Файл UART.H

void far SelectPort(int);

void far SaveCom(void);

void far RestoreCom(void);

int  far InstallCom(void);

void far OpenCom( int, int, int, int );

void far CloseCom(void);

void far DtrOff(void);

void far DtrOn(void);

long far RCount(void);

// Макроопределение RCountSize возвращает

// общий размер буфера приемника

#define RCountSize() ((int)(RCount() >> 16))

// Макроопределение RCountPending возвращает

// число байтов в буфере приемника

#define RCountPending() ((int)RCount())

int  far ReceiveCom(void);

long far SCount(void);

// Макроопределение SCountSize возвращает

// общий размер буфера приемника

#define SCountSize() ((int)(SCount() >> 16))

// Макроопределение SCountFree возвращает

// число байтов в буфере приемника

#define SCountFree() ((int)SCount())

void far SendCom(int);

void far BreakCom(void);

int  far *far ComErrors(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


Содержание раздела