ul_dysn.c

一个linux下rs485驱动程序的源代码

  ret=ul_send_command(ul_fd,0,UL_CMD_NCS,
  		      UL_BFL_NORE*0,buf_out,1);
  while(1)
  { ret=ul_fd_wait(ul_fd,3);
    if(ret<0) return -1;
    if(ret==0)
    { printf("no more SN info\n");
      break;
    }
    ret=ul_acceptmsg(ul_fd,&msginfo);
    if(ret<0) return ret;
    if((msginfo.cmd!=UL_CMD_NCS)
       ||(msginfo.len<3))
    { ul_freemsg(ul_fd);
      continue;
    }
    buf=malloc(msginfo.len);
    ret=ul_read(ul_fd,buf,msginfo.len);
    ul_freemsg(ul_fd);
    if(buf[0]==ULNCS_SID_RPLY)
    { if(msginfo.len>=5)
      { 
	printf("%2d %08lX:  ",msginfo.sadr,(buf[1])+((long)buf[2]<<8)+
			    ((long)buf[3]<<16)+((long)buf[4]<<24));
      	fwrite(buf+5,msginfo.len-5,1,stdout);
      	printf("\n");
        free(buf);
        buf=NULL;
      }
    }
    free(buf);
    buf=NULL;
  }
  if(buf) free(buf);
  buf=NULL;
  ul_close(ul_fd);
  return count;
};

int set_new_adr(int module,unsigned long module_sn,int new_adr)
{ int ret;
  ul_fd_t ul_fd;
  uchar buf_out[10];
  if(module_sn!=0) module=0;
  ul_fd=ul_open(ul_dev_name, NULL);
  if(ul_fd==UL_FD_INVALID) { perror("set_new_adr : uLan open failed");return -1;};
  buf_out[0]=ULNCS_SET_ADDR;	/* SN0 SN1 SN2 SN3 NEW_ADR */
  buf_out[1]=module_sn>>0;
  buf_out[2]=module_sn>>8;
  buf_out[3]=module_sn>>16;
  buf_out[4]=module_sn>>24;
  buf_out[5]=new_adr;
  ret=ul_send_command(ul_fd,module,UL_CMD_NCS,
  		      module?UL_BFL_ARQ:0,buf_out,6);
  ul_close(ul_fd);
  return 1;
}

int adr_nv_save(int module,unsigned long module_sn)
{ int ret;
  ul_fd_t ul_fd;
  uchar buf_out[10];
  ul_fd=ul_open(ul_dev_name, NULL);  
  if(ul_fd==UL_FD_INVALID) { perror("adr_nv_save : uLan open failed");return -1;};
  buf_out[0]=ULNCS_ADDR_NVSV;
  buf_out[1]=module_sn>>0;
  buf_out[2]=module_sn>>8;
  buf_out[3]=module_sn>>16;
  buf_out[4]=module_sn>>24;
  ret=ul_send_command(ul_fd,module,UL_CMD_NCS,
  		      module?UL_BFL_ARQ:0,buf_out,5);
  ul_close(ul_fd);
  return 1;
}

int read_module_sn(int module,unsigned long *read_sn, char **read_info)
{ int ret=1;
  ul_fd_t ul_fd;
  ul_msginfo msginfo;
  uchar buf_out[10];
  uchar buf_in[10];
  int i;
  if(read_info) *read_info=NULL;
  /* Open device */
  ul_fd=ul_open(ul_dev_name, NULL);
  if(ul_fd==UL_FD_INVALID) { perror("read_module_sn : uLan open failed");return -1;};
  /* Set filter */
  memset(&msginfo,0,sizeof(ul_msginfo));
  msginfo.cmd=UL_CMD_NCS;
  msginfo.sadr=module;
  msginfo.flg=UL_BFL_NORE;
  ul_addfilt(ul_fd,&msginfo);
  /* Send identification request */
  buf_out[0]=ULNCS_SID_RQ; /* SN0 SN1 SN2 SN3 */
  ret=ul_send_command(ul_fd,module,UL_CMD_NCS,
  		      module?UL_BFL_ARQ:0,buf_out,1);
  /* wait for request */
  while(1)
  { ret=ul_fd_wait(ul_fd,10);
    if(ret<0) break;
    if(ret==0) { ret=-1; break;}
    ret=ul_acceptmsg(ul_fd,&msginfo);
    if(ret<0) break;
    if((msginfo.cmd!=UL_CMD_NCS)
       ||(msginfo.len<5))
    { ul_freemsg(ul_fd);
      continue;
    }
    ret=ul_read(ul_fd,buf_in,5);
    if(ret!=5) break;
    if(read_info) {
      if((i=msginfo.len-5)&&(*read_info=malloc(i+1))){
        ret=ul_read(ul_fd,*read_info,i);
        if(ret>=0) (*read_info)[ret]=0;
	else {
	  free(*read_info);
	  *read_info=NULL;
	}
      }
    }
    ul_freemsg(ul_fd);
    if(buf_in[0]!=ULNCS_SID_RPLY) continue;
    *read_sn=(buf_in[1])+((long)buf_in[2]<<8)+
            ((long)buf_in[3]<<16)+((long)buf_in[4]<<24);
    break;
  }
  ul_close(ul_fd);
  return ret;
}

char *sn_hist_fname="ulan_sn.his";

int check_sn_in_sn_hist(unsigned long new_sn, unsigned long *pmax_sn)
{ 
  int    ret=1;
  char   *line=NULL;
  size_t linelen=0;
  unsigned long old_sn, max_sn=0;
  FILE   *F;

  if((F=fopen(sn_hist_fname,"r"))==NULL){
    return errno==ENOENT?0:-3;
  }
  while(getdelim(&line,&linelen,'\n',F)>=0){
    if(sscanf(line,"%lX",&old_sn)>0) {
      if(old_sn>max_sn) max_sn=old_sn;
      if(new_sn&&(old_sn==new_sn)) ret=-1;
    }
  }
  if(line) free(line);
  if(pmax_sn) *pmax_sn=max_sn;
  return ret;
}

int interactive_sn_set(void)
{
  unsigned long old_sn, new_sn, max_sn=0;
  char   *info;
  int    ret;
  time_t sn_time;
  struct tm *sn_tm;
  char   *p,*line=NULL;
  size_t linelen=0;
  FILE   *F;
  
  while(1){
    printf("\nListing conected modules\n");
    print_modules_dyn();
    printf("select module address: ");
    if(getdelim(&line,&linelen,'\n',stdin)<0) break; 
    if(sscanf(line,"%d",&module)<1) break;
    printf("\n");
    if(read_module_sn(module,&old_sn,&info)<0){
      printf("Cannot connect module\n");
      continue;
    }
    printf("Module %d with old SN %08lX info : %s\n",
            module,old_sn,info);
    ret=check_sn_in_sn_hist(0,&max_sn);
    while(1){
      new_sn=max_sn+1;
      printf("New SN [%08lX]: ",new_sn);
      if(getdelim(&line,&linelen,'\n',stdin)<0) break;
      for(p=line;*p&&(*p<=' ');p++);
      if(*p){
	if(sscanf(line,"%lX",&new_sn)<0){
          printf("Bad SN format - press a key\n");
	  continue;
	}
      }
      ret=check_sn_in_sn_hist(new_sn,&max_sn);
      if(ret==-1){
          printf("SN already taken\n");
	  continue;
      }
      if(ret<0){
          printf("Problem with SN history file\n");
	  continue;
      }
      break;
    }
    printf("\n");
    if(set_new_sn(module,new_sn)<0) {
      printf("Cannot write SN - press a key\n");
      if(getdelim(&line,&linelen,'\n',stdin)<0) break;
      continue;
    }
    if((F=fopen(sn_hist_fname,"a"))==NULL)
    {
      printf("Cannot open uLan SN history file\n");
      if(getdelim(&line,&linelen,'\n',stdin)<0) break;
      continue;
    }
    time(&sn_time);
    sn_tm=localtime(&sn_time);
    fprintf(F,"%08lX\t%04d-%02d-%02d\t%s\n",new_sn,
            (int)sn_tm->tm_year+1900,(int)sn_tm->tm_mon+1,
	    (int)sn_tm->tm_mday,info);
    fclose(F);
    printf("SN changed\n");
    printf("Reset device and press a key\n");
    if(getdelim(&line,&linelen,'\n',stdin)<0) break;
  }
  if(line) free(line);
  return 0;
}


int debug_kernel(int debug_msk)
{ int ret;
  ul_fd_t ul_fd;
  ul_fd=ul_open(ul_dev_name, NULL);
  if(ul_fd==UL_FD_INVALID) { perror("send_cmd_go : uLan open failed");return -1;};
  ret=ul_drv_debflg(ul_fd,debug_msk);
  ul_close(ul_fd);
  return ret;
};

static void
usage(void)
{
  printf("usage: ul_lcabsp <parameters> <hex_file>\n");
  printf("  -d, --uldev  <name>      name of uLan device [/dev/ulan]\n");
  printf("  -m, --module <num>       messages from/to module\n");
  printf("  -p, --print  <max>       print modules to max address\n");
  printf("  -P, --print-dyn          print dynamic address capable modules\n");
  printf("  -D  --debug-kernel <m>   flags to debug kernel\n");
  printf("  -o, --oi-var <oid>=<v>   uLan OI variable set\n");
  printf("  -o, --oi-var <oid>?      uLan OI variable read\n");
  printf("  -S, --set-sn <ser-num>   set serial number\n");
  printf("  -n, --no-permanent	     no permanent SN change\n");
  printf("  -a, --set-adr <adr>      set new module address\n");
  printf("  -A, --set-adrnvsv <adr>  set and store address to EEPROM\n");
  printf("  -i, --interactive        interactive SN setup\n");
  printf("  -V, --version            show version\n");
  printf("  -h, --help               this usage screen\n");
}

int main(int argc,char *argv[])
{
  static struct option long_opts[] = {
    { "uldev", 1, 0, 'd' },
    { "module",1, 0, 'm' },
    { "print", 1, 0, 'p' },
    { "print-dyn", 0, 0, 'P' },
    { "version",0,0, 'V' },
    { "help",  0, 0, 'h' },
    { "debug-kernel", 1, 0, 'D' },
    { "oi-var",1, 0, 'o' },
    { "set-sn",1, 0, 'S' },
    { "no-permanent",1, 0, 'n' },
    { "set-adr",1, 0, 'a' },
    { "set-adrnvsv",1, 0, 'A' },
    { "interactive",0, 0, 'i' },
    { 0, 0, 0, 0}
  };
  int  opt;
  char c;

 #ifndef HAS_GETOPT_LONG
  while ((opt = getopt(argc, argv, "d:m:p:PVhS:na:A:iD:o:")) != EOF)
 #else
  while ((opt = getopt_long(argc, argv, "d:m:p:PVhS:na:A:iD:o:",
			    &long_opts[0], NULL)) != EOF)
 #endif
    switch (opt) {
    case 'd':
      ul_dev_name=optarg;
      break;
    case 'm':
      module = strtol(optarg,NULL,0);
      break;
    case 'p':
      prt_modules = strtol(optarg,NULL,0);
      break;
    case 'P':
      prt_modules_dyn = 1;
      break;
    case 'D':
      debugk = strtol(optarg,NULL,0);
      debugk_flg=1;
      break;
    case 'V':
      fputs("uLan Dynamic and Serial Number Management pre alpha\n", stdout);
      exit(0);
    case 'o':
      oi_var_fl=1;
      oi_var_rd=0;
      oi_var_aoid=optarg;
      oi_var_val=strpbrk(optarg,":=?");
      if(oi_var_val)
      { c=*oi_var_val;
        *(oi_var_val++)=0;
        switch(c)
        { case '?':
	    oi_var_val=NULL;
	    oi_var_rd=1;
            break;
        }
      }
      break;
    case 'S':
      new_sn_flg=1;
      new_sn=strtol(optarg,NULL,16);
      break;
    case 'n':
      no_permanent_flg=1;
      break;
    case 'a':
      new_adr_flg=1;
      new_adr=strtol(optarg,NULL,0);
      break;
    case 'A':
      new_adr_flg=1;
      new_adr=strtol(optarg,NULL,0);
      new_adrnvsv_flg=1;
      break;
    case 'i':
      interactive_flg=1;
      break;
    case 'h':
    default:
      usage();
      exit(opt == 'h' ? 0 : 1);
    }

  if(new_adr_flg||new_adrnvsv_flg) {
    if(!module&&!new_sn_flg) {
      printf("Cannot set address when old address and SN undefined\n");
      return 1;
    }
    if(!new_sn&&!new_sn_flg) {
      if(read_module_sn(module,&new_sn,NULL)<0){
        printf("Cannot read module %d serial number\n",module);
        return 1;
      }
      printf("Module %d, SN %8lX will be readdressed to %d\n",
             module,new_sn,new_adr);
    }
    set_new_adr(module,new_sn,new_adr);
    if(new_adrnvsv_flg) {
      adr_nv_save(new_adr,new_sn);
    }
    new_sn_flg=0;
  }

  if(debugk_flg) debug_kernel(debugk);

  if(new_sn_flg) set_new_sn(module,new_sn);

  if(prt_modules) print_modules(prt_modules);
  
  if(prt_modules_dyn) print_modules_dyn();
  
  if(interactive_flg) interactive_sn_set();
  
  if(oi_var_fl) oi_var_test(oi_var_aoid,oi_var_val,NULL,NULL);
  
  return 0;
}