acklib.c

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

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

extern long HA_total_byte;
extern long HA_pack_cnt;
extern long HA_timeout;
extern int HA_ESC_delay,HA_NAK_delay,HA_disp_cmd,HA_ACK_delay;
extern int HA_enable_ESC,HA_COM_para[4],HA_pack_size;
extern int HA_retry,HA_dnl_disp,HA_upl_disp;
extern int HA_dnl_sub(char *);
extern int HA_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;

int HA_FILE1(char,int,char *);
int HA_set_tab(char,int,char *);
int HA_set_tab1(char,int,char *,int);
int HA_read_pack(FILE *,unsigned char *);
int HA_ret_resp1(unsigned char);
unsigned char HA_send_485_cmd(char,unsigned char *,unsigned char *);
unsigned char HA_send_esc(char,unsigned char *);
unsigned char HA_send_485_cmd1(char,unsigned char *,unsigned char *,int);
unsigned char HA_send_esc1(char,unsigned char *,int);
unsigned char HA_resp_485(unsigned char *);
int HA_unpack(unsigned char *,unsigned char *);
int HA_pack(unsigned char *,int,unsigned char *);                                       // 3.0
int HA_isprint1(char);

int CURR_PORT;

int HA_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);
      HA_COM_para[port-1] = baud << 4;

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

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

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

   return(0);
}
void HA_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 HA_poll(int port,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;
   while (tag)
   {
     tag = 0;
     serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
     sersend(CURR_PORT,(int)STX);
     sersend(CURR_PORT,(int)ESC);
     sersend(CURR_PORT,(int)ETX);
     if (HA_disp_cmd == 1) printf("\nPC:%.2x %.2x %.2x",STX,ESC,ETX);
     ch = HA_resp_485(buff);                               // 3.0
     serclose(CURR_PORT);
     HA_time_delay(HA_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
                   {
                      HA_time_delay(HA_NAK_delay);
                      tag = 1;;
                   }              
                   break;	
        case ETX : *len = HA_unpack(buff,str);
                   return(0);
        default  : return(HA_ret_resp1(ch));
     }
   }  
}
int HA_coldstart(int port)
{
   unsigned char temp_buff[256],cc;
   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HA_send_485_cmd('H',"",temp_buff);                   // 3.0
   serclose(CURR_PORT);
   return(HA_ret_resp1(cc));
}
int HA_power_save_on(int port)
{
   unsigned char temp_buff[256],cc;
   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   sersend(CURR_PORT,0);
   temp_buff[0] = 0;
   cc=HA_send_485_cmd('8',temp_buff,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   return(HA_ret_resp1(cc));
}
int HA_power_save_off(int port)
{
   unsigned char temp_buff[256],cc;
   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   sersend(CURR_PORT,0);
   temp_buff[0] = 0;
   cc=HA_send_485_cmd('7',temp_buff,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   return(HA_ret_resp1(cc));
}
int HA_warmstart(int port)
{
   unsigned char temp_buff[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HA_send_485_cmd('A',"",temp_buff);                   // 3.0
   serclose(CURR_PORT);
   return(HA_ret_resp1(cc));
}
int HA_320_record(int port,unsigned char *str)
{
   unsigned char temp_buff[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HA_send_485_cmd('?',str,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   return(HA_ret_resp1(cc));
}
int HA_send_data(int port,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;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   HA_pack(str,len,temp_buff1);
   cc=HA_send_485_cmd('0',temp_buff1,temp_buff);                  // 3.0
   serclose(CURR_PORT);
   return(HA_ret_resp1(cc));
}
int HA_directory(int port,char *str)
{
   unsigned char temp_buff[256],cc;

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

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HA_send_485_cmd('9',stro,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   stri[0] = 0;
   switch (cc)
   {
      case ETX : strcpy(stri,temp_buff+2);  return(0);
      case ACK : return(5);
      default  : return(HA_ret_resp1(cc));
   }
}
//
int HA_FILE1(char cmd,int port,char *str)
{
    unsigned char cc;
    unsigned char temp_buff[256];

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HA_send_485_cmd(cmd,str,temp_buff);                  // 3.0
   serclose(CURR_PORT);
   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(HA_ret_resp1(cc));
   }
}
int HA_erase(int port,char *str)
{
    return(HA_FILE1('E',port,str));
}
int HA_exec(int port,char *str)
{
    return(HA_FILE1('X',port,str));
}
int HA_autoboot(int port,char *str)
{
    return(HA_FILE1('O',port,str));
}
int HA_exec_file(int port,char *fname)
{
   unsigned char tempbuff[256],cc;

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

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HA_send_485_cmd('J',fname,tempbuff);                   // 3.0
   serclose(CURR_PORT);
   switch (cc)
   {
      case ETX : if (tempbuff[2] == 0) return(0);
                 else return(0x30);
      case ACK : return(5);
      default  : return(HA_ret_resp1(cc));
   }
}
int HA_ram_size(int port,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;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HA_send_485_cmd('G',"",buf);                   // 3.0
   serclose(CURR_PORT);
   *f_size = (buf[8]-'0')*100 + (buf[9]-'0')*10 + buf[10]-'0';
   *e_size = (buf[5]-'0')*100 + (buf[6]-'0')*10 + buf[7]-'0';
   *t_size = (buf[2]-'0')*100 + (buf[3]-'0')*10 + buf[4]-'0';
   if (cc == ACK) return(5);
   else if (cc == ETX) return(0);
   return(cc);
}
int HA_ups(int port)
{
   unsigned char temp_buff[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HA_send_485_cmd('F',"",temp_buff);                   // 3.0
   serclose(CURR_PORT);
   return(HA_ret_resp1(cc));
}
int HA_exe_size(int port,int size)
{
    unsigned char temp_buff[256],cc;
    int i;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   sprintf(temp_buff,"%3d",size);
   for (i=0;i<3;i++) if (temp_buff[i] == ' ') temp_buff[i] = '0';
   cc=HA_send_485_cmd('F',temp_buff,temp_buff);            // 3.0
   serclose(CURR_PORT);
   switch (cc)
   {
      case ETX : switch(temp_buff[2])
                 {
                    case 0 : return(0);
                    case 1 : return(0x40);
                    case 2 : return(0x41);
                    default : return(5);
                 }
      default  : return(HA_ret_resp1(cc));
   }
}
int HA_keypad(int port,int status)
{
   unsigned char temp_buff[256],cc;

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   temp_buff[0] = status+'0';
   temp_buff[1] = 0;
   cc=HA_send_485_cmd('K',temp_buff,temp_buff);                   // 3.0
   serclose(CURR_PORT);
   return(HA_ret_resp1(cc));
}
int HA_term_tab(int port,char *str)
{
    return(HA_set_tab1('T',port,str,15));
}
int HA_comm_tab(int port,char *str)
{
    return(HA_set_tab('C',port,str));
}
int HA_dev_tab(int port,char *str)
{
    return(HA_set_tab('V',port,str));
}
int HA_bar_tab(int port,char *str)
{
    return(HA_set_tab('B',port,str));
}
int HA_date_time(int port,char *str)
{
    return(HA_set_tab('M',port,str));
}
int HA_password(int port,char *str)
{
    return(HA_set_tab('P',port,str));
}
int HA_key_alias(int port,char key,char type,char *alias)
{
    unsigned char temp_buff[256];
    sprintf(temp_buff,"%c%c%s",key,type,alias);
    return(HA_set_tab('S',port,temp_buff));
}
int HA_set_tab(char cmd,int port,char *str)
{
    unsigned char cc;
    unsigned char temp_buff[256];

   if ((port < 1) || (port > 4)) return(2); else CURR_PORT = port-1;
   serinit(CURR_PORT,HA_COM_para[CURR_PORT]);    // initial COM parameter
   cc=HA_send_485_cmd(cmd,str,temp_buff);                  // 3.0
   serclose(CURR_PORT);
   switch (cc)
   {
      case ETX : switch(temp_buff[2])
		 {
		    case 00 : return(0);
		    case 01 : return(2);
		    default : return(5);
		 }
      default  : if (temp_buff[0]==ESC && temp_buff[1]=='C'){
		    switch(temp_buff[2]){	//just patchs
			case 0: return(0);
			case 1: return(2);
			default:return(5);