485lib.c

The EZ320 utility demonstrates the communication program between host PC and the MR320.

#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#define STX 0x02
#define ETX 0x03
#define NAK 0x15
#define EOT 0x04
#define ACK 0x06
#define ESC 27

extern long HM_total_byte;
extern long HM_pack_cnt;
extern long HM_timeout;
extern int HM_ESC_delay,HM_NAK_delay,HM_disp_cmd,HM_RF,HM_ACK_delay;
extern int HM_enable_ESC,HM_COM_para[4],HM_pack_size;
extern int HM_retry,HM_dnl_disp,HM_upl_disp;
extern int HM_dnl_sub(char *),HM_upl_sub(char *);
extern int far serinit(int portn, int confign);
extern int far serclose(int portn);
extern int far sersend(int portn, int char_c);
extern int far serrecv(int portn);

union REGS regs;
struct SREGS segregs;
unsigned char HM_send_esc(char,char,char *);
unsigned char HM_send_esc1(char,char,unsigned char *,int);
unsigned char HM_resp_485(unsigned char *);
unsigned char HM_send_485_cmd(char,unsigned char *,char,unsigned char *);
unsigned char HM_send_485_cmd1(char,unsigned char *,char,unsigned char *,int);
int HM_ret_resp1(unsigned char);
int HM_FILE1(char,int,char,char *);
int HM_set_tab(char,int,char,char *);
int HM_set_tab1(char,int,char,char *,int);
int HM_TSR();
int HM_inq_status();
int HM_spool_status();
int HM_SUSPEND(int);
int HM_unpack(unsigned char *,unsigned char *);
int HM_pack(unsigned char *,int,unsigned char *);
int HM_read_pack(FILE *,unsigned char *);
int isprint1(char);
int CURR_PORT;

int HM_TSR()
{
   regs.x.ax =0x3566;
   int86x(0x21,&regs,&regs,&segregs);
   if ((regs.x.bx == 0) || (segregs.es == 0)) return(0);
   return(1);
}
int HM_inq_status()
{
   if (HM_TSR() == 0) return(2);
   regs.h.al =1;
   regs.h.ah =2;
   int86(0x66,&regs,&regs);
   return(regs.h.al);
}
int HM_spool_status()
{
   if (HM_TSR() == 0) return(3);
   regs.h.al =12;
   int86(0x66,&regs,&regs);
   return(regs.h.al);
}
void HM_time_delay(int period)
{
   union REGS regs;
   long t_start,t_stop,td,i;

   regs.h.ah = 0x2c;   intdos(&regs,&regs);
   t_start = regs.h.dh * 100 + regs.h.dl;
   do {
      regs.h.ah = 0x2c;   intdos(&regs,&regs);
      t_stop = regs.h.dh * 100 + regs.h.dl;
      td = t_stop - t_start;
      if (td < 0) td = 6000+td;
      for (i=0;i<3600;i++) i = i;
   } while (td < period);
   return;
}
int HM_SUSPEND(int type)
{
   if (HM_TSR() == 0) return(0);
   if ((type == 0) && (HM_inq_status() == 0)) return(0);
   regs.h.al =0;                        // Get inquire status
   regs.h.ah = type;
   int86(0x66,&regs,&regs);
   if (type == 0)                       // suspend to stop polling
   {
      do {                              // Waiting until real stop inquire
         regs.h.al =1;
         regs.h.ah = 2;
         int86(0x66,&regs,&regs);
         if (regs.h.al == 0) break;
         HM_time_delay(3);
      } while ((regs.h.al != 0) && (HM_spool_status() != 2));
   }
   return(1);
}
int HM_parameter(int port,int baud,int stop,int data,int parity)
{
   int ret;

   if ((port < 1) || (port > 4)) return(2);   // if out of port range exit
   if ((baud < 0) || (baud > 9)) return(2);
      HM_COM_para[port-1] = baud << 4;

   if (stop == 0) ret=ret;
   else if (stop == 1) HM_COM_para[port-1] |= 0x02;
   else return(2);

   if (data == 0) ret=ret;
   else if (data == 1) HM_COM_para[port-1] |= 0x01;
   else return(2);

   if (parity == 0) ret=ret;
   else if (parity == 1) HM_COM_para[port-1] |= 0x04;
   else if (parity == 2) HM_COM_para[port-1] |= 0x0c;
   else return(2);

   return(0);
}
int HM_unpack(unsigned char *str_i,unsigned char *str_o)
{
   int i,cnt;

   cnt = 0;
   i = 0;
   while (str_i[i] != 0)
   {
      if (str_i[i] != 0x5c) str_o[cnt] = str_i[i];
      else
      {
        i++;
        if (str_i[i] == 0x5c)
           str_o[cnt] = str_i[i];
        else if ((str_i[i] >= 0x80) && (str_i[i] < 0x0a0))
           str_o[cnt] = str_i[i] & 0x7f;
        else if ((str_i[i] >= 0x20) && (str_i[i] <= 0x7f))
           str_o[cnt] = str_i[i] | 0x80;
      }
      i++;
      cnt++;
   }
   str_o[cnt] = 0;
   return(cnt);
}
int HM_poll(int port,char addr,unsigned char *str,int *len)
{
   unsigned char ch,buff[256];
   int nak_cnt,tag=1;

   nak_cnt = 0;
   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   while (tag)
   {
     tag=0;
     serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
     sersend(CURR_PORT,(int)STX);
     sersend(CURR_PORT,(int)addr+0x80);
     if (HM_disp_cmd == 1) printf("\nPC:%.2x %.2x",STX,addr+0x80);
     if (HM_RF == 1)
     {  sersend(CURR_PORT,(int)0x0d);
        sersend(CURR_PORT,(int)0x0a);
       if (HM_disp_cmd == 1) printf("%.2x %.2x",0x0d,0x0a);
     }
     ch = HM_resp_485(buff);                               // 3.0
     serclose(CURR_PORT);
     HM_SUSPEND(1);
     HM_time_delay(HM_ESC_delay);
     switch(ch)
     {
        case EOT : return(7);                             // No data for polling
        case ACK : return(5);
        case NAK : if (++nak_cnt > 3) return(3);
                   else
		   {
                      HM_time_delay(HM_NAK_delay);
                      tag =1;
                   }
                   break;
        case ETX : if (buff[0] == 27)
                 {
                    if (buff[1] == '2')
                    {
                       switch (buff[2])
                       {
                          case 0x01 : return(0x10);
                          case 0x02 : return(0x11);
                          case 0x08 : return(0x12);
                          case 0x10 : return(0x13);
                          case 0x20 : return(0x14);
                          case 0x40 : return(0x15);
                          case 0x80 : return(0x16);
			  default   : return(5);
                       }
                    }
                    else if (buff[1] == '1')
                    {
                       switch (buff[2])
                       {
                          case 0x00 : return(0x20);
                          case 0x01 : return(0x21);
                          case 0x04 : return(0x22);
                          case 0x05 : return(0x23);
                          default   : return(5);
                       }
                    }
                    else return(5);
                 }
                 else
                 {
		    *len = HM_unpack(buff,str);
                    return(0);
                 }
        default  : return(HM_ret_resp1(ch));
     }
   }
}
int HM_coldstart(int port,char addr)
{
   unsigned char temp_buff[256],cc;
   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HM_send_485_cmd('H',"",addr,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   return(HM_ret_resp1(cc));
}
int HM_power_save_on(int port,char addr)
{
   unsigned char temp_buff[256],cc;
   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   sersend(CURR_PORT,0);
   temp_buff[0] = 0;
   cc=HM_send_485_cmd('8',temp_buff,addr,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   return(HM_ret_resp1(cc));
}
int HM_power_save_off(int port,char addr)
{
   unsigned char temp_buff[256],cc;
   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   sersend(CURR_PORT,0);
   temp_buff[0] = 0;
   cc=HM_send_485_cmd('7',temp_buff,addr,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   return(HM_ret_resp1(cc));
}
int HM_warmstart(int port,char addr)
{
   unsigned char temp_buff[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HM_send_485_cmd('A',"",addr,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   return(HM_ret_resp1(cc));
}
int HM_320_record(int port,char addr,unsigned char *str)
{
   unsigned char temp_buff[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HM_send_485_cmd('?',str,addr,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   return(HM_ret_resp1(cc));
}
int HM_pack(unsigned char *str_i,int len,unsigned char *str_o)                                       // 3.0
{
   int i,cnt;

   i = cnt = 0;
   while (i < len)
   {
      if (str_i[i] < 0x20)
      {
         str_o[cnt++] = 0x5c;
         str_o[cnt++] = str_i[i] | 0x80;
      }
      else if (str_i[i] >= 0xA0)
      {
        if (str_i[i] == 0xdc)            // 0xDC
          str_o[cnt++] = str_i[i];
	else
        {
          str_o[cnt++] = 0x5c;
          str_o[cnt++] = str_i[i] & 0x7f;
        }
      }
      else if (str_i[i] == 0x5c)                 // '/'
      {
         str_o[cnt++] = str_i[i];
         str_o[cnt++] = str_i[i];
      }
      else str_o[cnt++] = str_i[i];
      if (cnt >= HM_pack_size+6) i=1000;
      i++;
   }
   str_o[cnt] = 0;
   return(cnt);
}
int HM_send_data(int port,char addr,unsigned char *str,int len)
{
   unsigned char temp_buff[256],cc,temp_buff1[256];

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   HM_pack(str,len,temp_buff1);
   cc=HM_send_485_cmd('0',temp_buff1,addr,temp_buff);                  // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   return(HM_ret_resp1(cc));
}
int HM_send_esc_cmd(int port,char addr,char cmd,unsigned char *str)
{
   unsigned char temp_buff[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HM_send_485_cmd(cmd,str,addr,temp_buff);                  // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   return(HM_ret_resp1(cc));
}
int HM_directory(int port,char addr,char *str)
{
   unsigned char temp_buff[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HM_send_485_cmd('D',"",addr,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   switch (cc)
   {
      case ETX : strcpy(str,temp_buff+2);  return(0);
      case ACK : return(5);
      default  : return(HM_ret_resp1(cc));
   }
}
int HM_sendback(int port,char addr,char *stro,char *stri)
{
   unsigned char temp_buff[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HM_send_485_cmd('9',stro,addr,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   stri[0] = 0;
   switch (cc)
   {
      case ETX : strcpy(stri,temp_buff+2);  return(0);
      case ACK : return(5);
      default  : return(HM_ret_resp1(cc));
   }
}
//
int HM_erase(int port,char addr,char *str)
{
    return(HM_FILE1('E',port,addr,str));
}
int HM_exec(int port,char addr,char *str)
{
    return(HM_FILE1('X',port,addr,str));
}
int HM_autoboot(int port,char addr,char *str)
{
    return(HM_FILE1('O',port,addr,str));
}
int HM_FILE1(char cmd,int port,char addr,char *str)
{
    unsigned char cc;
    unsigned char temp_buff[256];

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HM_send_485_cmd(cmd,str,addr,temp_buff);                  // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   switch (cc)
   {
      case ETX : switch(temp_buff[2])
                 {
                    case 00 : return(0);
                    case 01 : return(0x30);
		    case 02 : return(0x31);
                    default : return(5);
                 }
      default  : return(HM_ret_resp1(cc));
   }
}
int HM_set_address(int port,char addr,char n_addr)
{
   unsigned char tempbuff[256],aa[10],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   sprintf(aa,"%c",toupper(n_addr));
   cc=HM_send_485_cmd('5',aa,addr,tempbuff);                   // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   switch (cc)
   {
      case ETX : switch(tempbuff[2])
                 {
                    case 00 : return(0);
                    case 01 : return(2);
                    default : return(5);
		 }
                 return(0);
      case ACK : return(5);
      default  : return(HM_ret_resp1(cc));
   }
}
int HM_exec_file(int port,char addr,char *fname)
{
   unsigned char tempbuff[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HM_send_485_cmd('I',"",addr,tempbuff);                   // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   switch (cc)
   {
      case ETX : if (tempbuff[2] == 1) return(35);
                 strcpy(fname,tempbuff+2);  return(0);
      case ACK : return(5);
      default  : return(HM_ret_resp1(cc));
   }
}
int HM_file_exist(int port,char addr,char *fname)
{
   unsigned char tempbuff[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HM_send_485_cmd('J',fname,addr,tempbuff);                   // 3.0
   serclose(CURR_PORT);
   HM_SUSPEND(1);
   switch (cc)
   {
      case ETX : if (tempbuff[2] == 0) return(0);
                 else return(0x30);
      case ACK : return(5);
      default  : return(HM_ret_resp1(cc));
   }
}
int HM_ram_size(int port,char addr,int *t_size,int *e_size,int *f_size)
{
   unsigned char buf[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   HM_SUSPEND(0);
   serinit(CURR_PORT,HM_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HM_send_485_cmd('G',"",addr,buf);                   // 3.0
   serclose(CURR_PORT);