mon_p.c

MOXA 串口驱动编程

/*****************************************************************************/
/* MON_P.C                                                                   */
/*									     */
/* Copyright (c) Moxa Technologies Inc. 1999. All Rights Reserved.	     */
/*									     */
/* Revision history:							     */
/*	12/95	JOSE							     */
/*	12/96	Hsu		Modify for Linux 2.0.0 (C168/C104 ADM)	     */
/*     8/5/99   Casper                                                       */
/*     3/9/2001 Casper          add Industio                                 */
/*****************************************************************************/


#include	<time.h>
#include	<errno.h>

#include	"../mxwinlib/win.h"
#include	"../mxlib/declare.h"
#include	"../global.h"
#include        "mon.h"

#define	MOXA_GETDATACOUNT	(MOXA + 23)
#define	MOXA_GET_MAJOR		(MOXA + 63)

#define Total_Item	7
#define Max_Row 	16
#define Row_Space	10
#define Min_Val 	3
#define Max_Val 	10
#define Card		0
#define CBox		1


struct	Moniter_str {
	int	tick;
	int	rxcnt[MXSER_MAXPORT];
	int	txcnt[MXSER_MAXPORT];
};
typedef struct	Moniter_str	Moniter_t;
typedef struct	Moniter_str *	f_Moniter_t;


/*****************************************************************************/
/* GLOBAL FUNCTIONS							     */
/*****************************************************************************/
int	mon_p_setup(int boards);

/*****************************************************************************/
/* STATIC FUNCTIONS							     */
/*****************************************************************************/
static	int	init_menu(int now_board);
static	void	flush_menu_data(int now_board);
static	void	show_timer(int now_board);
static	void	reset_count();
static int	getdatacnt(struct Moniter_str *logdata);

/*****************************************************************************/
/* STATIC VARIABLES							     */
/*****************************************************************************/
static	int		row_space[Total_Item] = { 10, 10, 8, 8, 10, 8, 8 };
static	int		itemflag[Total_Item] = {
	F_Return,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly
};
static	char		*itemdes[Total_Item] = {
	"",
	"",
	"",
	"",
	"",
	"",
	""
};
static	struct	GEdit3	menu3 = {
	Edit3Type0 | Edit3Type3 | Edit3Type5, -1, -1, Total_Item,
	0, 0, 0,
	{ "PgUp,PgDn:More Ports Home:Reset Count  Esc:Exit  Enter:Port Status"},
	0
};

static	char	*subt_des[] = {
	"           ----------- Rx ------------- ----------- Tx ------------",
	" Device    Char Count  Throughput(BPS)  Char Count  Throughput(BPS)",
	"  name       (bytes)  Interval  Average   (bytes)  Interval  Average"
};

static  char    GTtyName[(MXSER_PORTS_PER_BOARD * MXSER_BOARDS)][30];

static struct mxser_hwconf	Gmxsercfg[MXSER_BOARDS];

static	int	card_type[MXSER_BOARDS], total_card;

static	int	maxrow = 0;
static	struct	Moniter_str	slog_old, slog_s, slog_e;

static	int	interval;
static	time_t	t1, t2, t3;
static	int	port_enable;

/*****************************************************************************/
/*	FUNCTIONS							     */
/*****************************************************************************/
int	mon_p_setup(int boards)
{
	int	i, c, exit_flag=0, flag;
	int	need_prepare = 1, old_space_ndx;
	int	key;
        int     now_board= 0;

	interval = 3;
	t1 = time((time_t *)&t3);
	if ( (old_space_ndx = init_menu(now_board)) < 0 ) {
	    confirm("No monitor message is available");
	    return (-1);
	}
	mw_edit3init(&menu3);
	for ( i=0; i<3; i++ ) {
	    mw_wgotoxy(menu3.wid, 1, i + 2);
	    mw_wputsc(menu3.wid, (uchar *)subt_des[i], strlen(subt_des[i]),
		      menu3.wid->norm_c);
	}
	while ( exit_flag == 0 ) {
	    if ( need_prepare ) {
		flush_menu_data(now_board);
		edit3_flush_data(&menu3);
		show_timer(now_board);
		need_prepare = 0;
	    }
	    switch ( mw_edit3() ) {
	    case K_ESC:
		exit_flag = 1;
		break;
	    case K_ENTER:
		c = menu3.item[menu3.act_item].act_item;
		if ( c == 0 )
		    flag = MON_TOP;
		else if ( c == (maxrow - 1) )
		    flag = MON_BOTTOM;
		else
		    flag = MON_NORMAL;
		while ( (i = mon_pa_setup(menu3.item[0].str[c],
                        interval, flag, now_board, c)) != 0 ) {
		    if ( i < 0 && c > 0 )
			c--;
		    if ( i > 0 && c < maxrow - 1 )
			c++;
		    if ( c == 0 )
			flag = MON_TOP;
		    else if ( c == (maxrow - 1) )
			flag = MON_BOTTOM;
		    else
			flag = MON_NORMAL;
		}
		menu3.item[menu3.act_item].act_item = c;
		need_prepare = 1;
		break;
            case K_PGUP:
                if(now_board!=0){
                    now_board--;
		    reset_count();
                    need_prepare = 1;
	            release_space(old_space_ndx);
	            mw_edit3end();
	            old_space_ndx = init_menu(now_board);
	            mw_edit3init(&menu3);
	            for ( i=0; i<3; i++ ) {
	                mw_wgotoxy(menu3.wid, 1, i + 2);
	                mw_wputsc(menu3.wid, (uchar *)subt_des[i], strlen(subt_des[i]),
		        menu3.wid->norm_c);
                    }
                }
                break;
                
            case K_PGDOWN:
                if(now_board < boards-1){
                    now_board++;
		    reset_count();
                    need_prepare = 1;
	            release_space(old_space_ndx);
	            mw_edit3end();
	            old_space_ndx = init_menu(now_board);
	            mw_edit3init(&menu3);
	            for ( i=0; i<3; i++ ) {
	                mw_wgotoxy(menu3.wid, 1, i + 2);
	                mw_wputsc(menu3.wid, (uchar *)subt_des[i], strlen(subt_des[i]),
		        menu3.wid->norm_c);
                    }
                }
                break;
            
	    case '+':
		if ( interval < Max_Val )
		    interval++;
		show_timer(now_board);
		break;
	    case '-':
		if ( interval > Min_Val )
		    interval--;
		show_timer(now_board);
		break;
	    case K_HOME :
		reset_count();
		need_prepare = 1;
		break;
	    default:
		if ( time((time_t *)&t3) - t2 < interval )
		    break;
		flush_menu_data(now_board);
		edit3_flush_data(&menu3);
		show_timer(now_board);
		break;
	    }
	}
	release_space(old_space_ndx);
	mw_edit3end();
	return(0);
}

static int init_menu(int now_board)
{
	int	i, j, k, old_space_ndx, bits;
        int     ports;

        ports = mxser_numports[Gmxsercfg[now_board].board_type-1];

	maxrow = ports;
	if ( getdatacnt(&slog_old) < 0 )
	    return(-1);
	slog_s = slog_old;
	old_space_ndx = get_space_ndx();
	j = sizeof(struct GItem3) * Total_Item;
	menu3.item = (struct GItem3 *)get_space(j);
	menu3.x = 5;
	menu3.y = 5;
	for ( i=0; i<Total_Item; i++ ) {
	    menu3.item[i].flag = itemflag[i];
	    menu3.item[i].des = itemdes[i];
	    menu3.item[i].act_item = 0;
	    menu3.item[i].total = maxrow;
	    /* jose: to fit for each column space */
	    for ( j=0; j<maxrow; j++ ) {
		menu3.item[i].len[j] = row_space[i];
		menu3.item[i].str[j] = get_space(row_space[i] + 1);
		for ( k=0; k<row_space[i]; k++ )
		    menu3.item[i].str[j][k] = ' ';
		menu3.item[i].str[j][k] = 0;
	    }
	}
	menu3.act_item = 1;
        for (j=0; j<maxrow; j++){
	    sprintf(menu3.item[0].str[j], "%s", GTtyName[now_board * 8 + j]);
        }

	return(old_space_ndx);
}

static void flush_menu_data(int now_board)
{
	int	i, j, b;
        int     ports,id;

        ports = mxser_numports[Gmxsercfg[now_board].board_type-1];
        
	getdatacnt(&slog_e);
	t2 = time((time_t *)&t3);
	for ( i=0, j=0; i<ports, j<maxrow; i++ ) {
	    b = t2 - t1;
	    if ( b == 0 )
		b = 1;
            id = now_board * MXSER_PORTS_PER_BOARD + i;
	    sprintf(menu3.item[1].str[j], "%10d",
		    slog_e.rxcnt[id] - slog_old.rxcnt[id]);
	    sprintf(menu3.item[2].str[j], "%8d",
		    (slog_e.rxcnt[id] - slog_s.rxcnt[id]) / interval);
	    sprintf(menu3.item[3].str[j], "%8d",
		    (slog_e.rxcnt[id] - slog_old.rxcnt[id]) / b);
	    sprintf(menu3.item[4].str[j], "%10d",
		    slog_e.txcnt[id] - slog_old.txcnt[id]);
	    sprintf(menu3.item[5].str[j], "%8d",
		    (slog_e.txcnt[id] - slog_s.txcnt[id]) / interval);
	    sprintf(menu3.item[6].str[j], "%8d",
		    (slog_e.txcnt[id] - slog_old.txcnt[id]) / b);
	    j++;
	}
	slog_s = slog_e;
}

static int getdatacnt(logdata)
struct	Moniter_str	*logdata;
{
	int	fd, i;

	fd = open("/dev/mxser", O_RDWR);
	if ( fd < 0 )
	    return(-1);
	ioctl(fd, MOXA_GETDATACOUNT, logdata);
	close(fd);
	return(0);
}

static void show_timer(int now_board)
{
	char	tmp[80], str[60];
	time_t	i;
	int	hr, min, sec;
        int     w;

	i = time((time_t *)&t3) - t1;
	sec = i % 60;
	min = i / 60;
	hr = min / 60;
	min = min % 60;
	mw_wcolor(menu3.wid, D_A_Normal);
        sprintf(str, "     Board #%d :%s",
                     now_board+1,
                     mxser_brdname[Gmxsercfg[now_board].board_type-1]);

	w = menu3.wid->w - 2;
	for ( i=0; i<w; i++ )
		tmp[i] = ' ';
	tmp[i] = 0;
	mw_wcputs(menu3.wid, 1, (uchar *)tmp);
	sprintf(tmp, "Time[%02d:%02d:%02d]%-32s Interval %d sec <+/->", 
		hr, min, sec, str, interval); 
	mw_wcputs(menu3.wid, 1, (uchar *)tmp);
}

static void reset_count()
{
	getdatacnt(&slog_old);
	slog_s = slog_old;
	t1 = time((time_t *)&t3);
}

void read_tty(int now_major)
{
        FILE    *fd;
        char    ttystr[40];
        char    s1[20],s2[20],s3[20],s4[20],s7[20],s8[20],s9[20];
        char    tmp[100];
        int     major, minor;
        int     i,ch;
	
	
	for(i=0; i<(MXSER_PORTS_PER_BOARD * MXSER_BOARDS); i++){
		sprintf( GTtyName[i], "Port %d", i);
	}

	//use grep will take a long time on redhat 9 (30 is too much)
        //sprintf(tmp,"ls -al /dev | grep %d > /tmp/mon.tmp 2> /dev/null",
        sprintf(tmp,"ls -al /dev > /tmp/mon.tmp 2> /dev/null",
                        now_major);
        system(tmp);

        fd = fopen("/tmp/mon.tmp", "r");
	if(fd<0) {
		return;
	}

        do{
            i = 0;
            do{
                ch = fgetc(fd);
                if((ch==-1) || (ch=='\n')){
                    tmp[i] = 0;
                    break;
                }else{
                    tmp[i++] = ch;
                }
            }while(1);
            if(ch==-1)
                break;
            sscanf(tmp,"%s %s %s %s %d, %d %s %s %s %s",
                      s1,s2,s3,s4,&major,&minor,s7,s8,s9,ttystr);
	    if(s1[0] != 'c')
		continue;
            if(major!=now_major)
                continue;
            if(minor>=(MXSER_PORTS_PER_BOARD * MXSER_BOARDS))
                continue;

            if(strlen(ttystr) >= 10)
                ttystr[9] = 0;
            strcpy(GTtyName[minor], ttystr);
        }while(1);
        fclose(fd);
        system("rm -f /tmp/mon.tmp 2> /dev/null");
        
}


void main_end()
{
	mw_wend();
}

int main()
{
	int	fd, ret;
        int     i;
        int     boards;
        int     major;
        
	if((fd = open("/dev/mxser", O_RDWR)) < 0){
	    printf("open /dev/mxser fail\n");
	    return 1;
	}
	ret = ioctl(fd, MOXA_GET_CONF , Gmxsercfg);
	if(ret != 0){
	    printf("ioctl fail,ret=%d\n",ret);
	    return 1;
	}
	ioctl(fd, MOXA_GET_MAJOR, &major);
	close(fd);

        read_tty(major);

        boards = 0;
	for(i=0; i<MXSER_BOARDS; i++){
	    if(Gmxsercfg[i].board_type!=-1)
                boards++;
	}
	if(!boards){
	    printf("No any MOXA Smartio/Industio Family board installed.\n");
	    return 1;
	}

	space_init();	
	mw_winit();
        
	mon_p_setup(boards);
	
	mw_wend();

        return 0;
}