neax_drv.c

仿真测试接口程序。根据电总《用户接入网管理功能与管理接口技术规范》之《与112集中受理系统接口规范》

					if (strstr(str, str_access_ok) != NULL)
					{
						result = 0;
						break;
					}
					else
					{
						if (strstr(str, str_access_not_ok) != NULL)
						{
							if (strstr(str, str_access_line_busy) != NULL)
							{
								result = 1;
								break;
							}
							else if (strstr(str, str_access_lock_out) != NULL)
							{
								/* result=2;          *//* Lock Out */
								result = 0;			/* Test anyway, Lock Out */
								break;
							}
						}
					}
					break;
				}
			}
			else
				q = 0;
		}
	}
	str[r] = '\0';

#ifdef DEBUG
	fprintf(lp, "\nsend Access string OK!\n");
	fflush(lp);
#endif
	if (result == 0)
	{
#ifdef DEBUG
		fprintf(lp, "\nAccess line OK!\n");
#endif
		*stat = STAT_ACCESS_STATE;
	}
	else if (result == 1 || result == 2 || result == 3)
	{
#ifdef DEBUG
		fprintf(lp, "Line busy!\n");
#endif
	}
	return (result);
}

/*********************************************************
Function:int f_access_state(int port_fd, int *stat)
Narrative:
	Send access state command to switch.

Param:	int port_fd	- socket id
	int *stat - a pointer to test state

Return:	0   OK.
	-1	An error of hangup occur when reading.
	-2	No fd ready when timeout.
	-3	An error occur when performing poll or read.
*********************************************************/
int f_access_state(int port_fd, int *stat)
{
	struct pollfd pollfdsp[1];
	char ch;
	int p, q, rc, ret;
	int result;										/* 1 - off hook   2 - on hook */
	char str_off_hook[] =
	{0x42, 0x60, 0x0d, 0x00};
	char str_on_hook[] =
	{0x42, 0x61, 0x0d, 0x00};

	pollfdsp[0].fd = port_fd;
	pollfdsp[0].events = POLLIN;
	pollfdsp[0].revents = 0;

	/* send Access State string to switch port */
	writeport(port_fd, str_access_state);
	p = 0;
	q = 0;
	while (1)
	{
		ret = poll(pollfdsp, 1, 8000);
		if (ret < 0)
			return (-3);
		if (ret == 0)
			return (-2);

		if (pollfdsp[0].revents & POLLIN)
		{
			rc = read(port_fd, &ch, 1);
			if (rc <= 0)
				return (-3);

			if (ch == '\0')
				continue;

			if (ch == str_off_hook[p])
			{
				++p;
				if (p == strlen(str_off_hook))
				{
					poll(0, 0, 10);
					result = 1;						/* result=1  off hook */
					break;
				}
			}
			else
				p = 0;

			if (ch == str_on_hook[q])
			{
				++q;
				if (q == strlen(str_on_hook))
				{
					poll(0, 0, 10);
					result = 2;						/* result=1  off hook */
					break;
				}
			}
			else
				q = 0;
		}
	}
#ifdef DEBUG
	fprintf(lp, "\nsend Access State string OK!\n");
	fflush(lp);
#endif
	if (result == 1)
	{
		/* deal with off hook */
#ifdef DEBUG
		fprintf(lp, "on hook\n");
#endif
		*stat = STAT_DCV_AB;
		return (0);
	}
	else if (result == 2)
	{
		/* deal with on hook */
#ifdef DEBUG
		fprintf(lp, "off hook\n");
#endif
		*stat = STAT_DCV_AB;
		return (0);
	}
}

/*********************************************************
Function:int f_test_process(int port_fd, int *stat, TESTMSG * testmsg)
Narrative:
	Send test command to switch and get test value.

Param:	int port_fd	- socket id
	int *stat - a pointer to test state
	TESTMSG * testmsg	- struct of test message

Return:	0   OK.
	-1	An error of hangup occur when reading.
	-2	No fd ready when timeout.
	-3	An error occur when performing poll or read.
*********************************************************/
int f_test_process(int port_fd, int *stat, TESTMSG * testmsg)
{
	struct pollfd pollfdsp[1];
	char ch;
	char *test_str;
	char str[256];
	int p, rc, ret;
	int flag;
	int C, D;
	char XXX[4];
	float result, X, A;
	int i;

	pollfdsp[0].fd = port_fd;
	pollfdsp[0].events = POLLIN;
	pollfdsp[0].revents = 0;

	/* send test string to switch port */
	switch (*stat)
	{
	case STAT_DCV_AB:
		++*stat;
		return (0);
		test_str = str_DCV_AB;
		break;
	case STAT_DCV_BG:
		test_str = str_DCV_BG;
		break;
	case STAT_DCV_AG:
		test_str = str_DCV_AG;
		break;
	case STAT_ACV_AB:
		++*stat;
		return (0);
		test_str = str_ACV_AB;
		break;
	case STAT_ACV_BG:
		test_str = str_ACV_BG;
		break;
	case STAT_ACV_AG:
		test_str = str_ACV_AG;
		break;
	case STAT_BAT_AB:
		++*stat;
		return (0);
		test_str = str_BAT_AB;
		break;
	case STAT_CUR_BG:
		++*stat;
		return (0);
		test_str = str_CUR_BG;
		break;
	case STAT_CUR_AG:
		++*stat;
		return (0);
		test_str = str_CUR_AG;
		break;
	case STAT_CAP_AB:
		test_str = str_CAP_AB;
		break;
	case STAT_CAP_BG:
		test_str = str_CAP_BG;
		break;
	case STAT_CAP_AG:
		test_str = str_CAP_AG;
		break;
	case STAT_RES_AB:
		test_str = str_RES_AB;
		break;
	case STAT_RES_BG:
		test_str = str_RES_BG;
		break;
	case STAT_RES_AG:
		test_str = str_RES_AG;
		break;
	}
	writeport(port_fd, test_str);
	flag = 0;
	p = 0;
	while (1)
	{
		ret = poll(pollfdsp, 1, 8000);
		if (ret < 0)
			return (-3);
		if (ret == 0)
			return (-2);

		if (pollfdsp[0].revents & POLLIN)
		{
			rc = read(port_fd, &ch, 1);
			if (rc <= 0)
				return (-3);

			if (ch == '\0')
				continue;

			/* fprintf(lp,"%02X,%c\n",ch,ch); */

			if (!flag && ch != '\x40')
				continue;
			else
			{
				if (ch == '\x40')
					flag = 1;
				str[p] = ch;
				++p;
				if (p == 18)
				{
					str[p] = '\0';

					if (f_split_data(str, &A, XXX, &C, &D) == -1)
					{
#ifdef DEBUG
						fprintf(lp, "splite data fail!\n");
#endif
					}
					result = f_get_result(A, XXX, C, D);

#ifdef DEBUG
					fprintf(lp, "stat:%d ", *stat);
					for (i = 0; i < strlen(str); ++i)
					{
						fprintf(lp, "%02X,", (unsigned char) str[i]);
					}
					fprintf(lp, "\nA=%2f,XXX=%c%c%c,C=%d,D=%d,result=%9.3f\n", A, XXX[0] + '0', XXX[1] + '0', XXX[2] + '0', C, D, result);
					fflush(lp);
#endif
					switch (*stat)
					{
					case STAT_DCV_AB:
						/* skip */
						break;
					case STAT_DCV_BG:
						sprintf(str, "%8.3f", result);
						strcpy(testmsg->TestResult.RG2_DCvol, str);		/*dr5:b-ground voltage */
						break;
					case STAT_DCV_AG:
						sprintf(str, "%8.3f", result);
						strcpy(testmsg->TestResult.TG2_DCvol, str);		/*dr4:a-ground voltage */
						break;
					case STAT_ACV_AB:
						/* skip */
						break;
					case STAT_ACV_BG:
						sprintf(str, "%8.3f", result);
						strcpy(testmsg->TestResult.RG_ACvol, str);	/*af2:b-ground AC voltage */
						break;
					case STAT_ACV_AG:
						sprintf(str, "%8.3f", result);
						strcpy(testmsg->TestResult.TG_ACvol, str);	/*af1:a-ground AC voltage */
						break;
					case STAT_BAT_AB:
						/* skip */
						break;
					case STAT_CUR_BG:
						/* skip */
						sprintf(str, "%7.3f", result);
						strcpy(testmsg->TestResult.RG_Line, str);		/*lc2:b-ground line circuit */
						break;
					case STAT_CUR_AG:
						/* skip */
						sprintf(str, "%7.3f", result);
						strcpy(testmsg->TestResult.TG_Line, str);		/*lc1:a-ground line circuit */
						break;
					case STAT_CAP_AB:
						sprintf(str, "%8.3f", result);
						strcpy(testmsg->TestResult.TR_cap, str);	/*ac4:a-b capacity */
						break;
					case STAT_CAP_BG:
						sprintf(str, "%8.3f", result);
						strcpy(testmsg->TestResult.RG_cap, str);	/*ac6:b-ground capacity */
						break;
					case STAT_CAP_AG:
						sprintf(str, "%8.3f", result);
						strcpy(testmsg->TestResult.TG_cap, str);	/*ac5:a-ground capacity */
						break;
					case STAT_RES_AB:
						sprintf(str, "%9.3f", result);
						strcpy(testmsg->TestResult.TR2_DCres, str);		/*dr1:a-b resistant */
						break;
					case STAT_RES_BG:
						sprintf(str, "%9.3f", result);
						strcpy(testmsg->TestResult.RG2_DCres, str);		/*dr3:b-ground resistant */
						break;
					case STAT_RES_AG:
						sprintf(str, "%9.3f", result);
						strcpy(testmsg->TestResult.TG2_DCres, str);		/*dr2:a-ground resistant */
						break;
					}
					++*stat;

					if (*stat == STAT_FINISH)		/* send end test string to stop test */
					{
						writeport(port_fd, str_end_test);
						poll(0, 0, 100);
					}

					return (0);
				}
			}
		}														/* end if */
	}															/* end while */
}																/* end f_test_process */

/*********************************************************
Function:int f_split_data(char *str, float *A, char *XXX, int *C, int *D)
Narrative:
	Split recieved string to get expected string.

Param:	char *str - recieve test result.
	float *A - a pointer to sign of value(+ ro -).
	char *XXX - a pointer to test value.
	int *C - a pointer to exponential.
	int *D - a pointer to unit.

Return:	0   OK.
	-1	Invalid data.
*********************************************************/
int f_split_data(char *str, float *A, char *XXX, int *C, int *D)
{
/* 0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17
   40,61,0D,40,6B,0D,40,6B,0D,40,6B,0D,40,60,0D,40,64,0D */
	if (str[1] < '\x60' || str[1] > '\x6b' ||
			str[4] < '\x60' || str[4] > '\x6b' ||
			str[7] < '\x60' || str[7] > '\x6b' ||
			str[10] < '\x60' || str[10] > '\x6b' ||
			str[13] < '\x60' || str[13] > '\x6b' ||
			str[16] < '\x60' || str[16] > '\x6b')
		return (-1);								/* invalid data */

	if (str[1] > '\x61')
		*A = -1.0;
	else
		*A = 1.0;
	XXX[0] = str[4] - '\x60';
	XXX[1] = str[7] - '\x60';
	XXX[2] = str[10] - '\x60';
	XXX[3] = '\0';
	*C = str[13] - '\x60';
	*D = str[16] - '\x60';
	return (0);
}

/*********************************************************
Function:float f_get_result(float A, char *XXX, int C, int D)
Narrative:
	Get value of 12 specialities from received string from switch.

Param:	float A - sign of value.
	char *XXX - a pointer to test value.
	int C - exponential.
	int D - unit.

Return:	None.
*********************************************************/
float f_get_result(float A, char *XXX, int C, int D)
{
	float result;
	float X;
	if (XXX[0] == '\x0b' && XXX[1] == '\x0b' && XXX[2] == '\x0b')
		result = 0;
	else if (XXX[0] == '\x0a' && XXX[1] == '\x0a' && XXX[2] == '\x0a')
		result = 99999;
	else
	{
		X = (float) (XXX[0] * 100 + XXX[1] * 10 + XXX[2]);
		result = (X / 1000 * f_mypower(C - 1)) * A;
		if (D == 1)
			result /= 1000.0;
		else if (D == 8)
			result *= 1000.0;
	}
	return (result);
}

/*********************************************************
Function:float f_mypower(int C)
Narrative:
	Get multiplication coefficient.

Param:	int C - label of multiplication coefficient

Return:	val	Multiplication coefficient	
*********************************************************/
float f_mypower(int C)
{
	int i;
	float val;
	if (C == 0)
		return (1);
	else if (C > 0)
	{
		val = 1;
		for (i = 0; i < C; ++i)
			val *= 10;
	}
	else
	{
		val = 1;
		C *= -1;
		for (i = 0; i < C; ++i)
			val /= 10;
	}
	return (val);
}

/*********************************************************
Function:int neax_conn_switch(int port_fd)
Narrative:
	Detect if interface to switch runs well by sending a wakeup signal or a command.

Param:	int port_fd	- socket id
 
Return:	0	OK.
	-1	No fd ready when timeout.
	-2	an error occur.
********************************************************/
int neax_conn_switch(int port_fd)
{
	int ret;
	int ret_val;
	int stat;
	int char_cnt;
	struct tm *ctime;
	time_t lt;

	/* stat=STAT_START; */
#ifdef DEBUG
	lt = time(NULL);
	ctime = localtime(&lt);
	lp = backup_log("./neax_drv.log");
	fprintf(lp, "\n>>> Start Neax-61 Test at %4d.%02d.%02d %02d:%02d:%02d <<<\n", ctime->tm_year > 90 ? ctime->tm_year + 1900 : ctime->tm_year + 2000, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
	fflush(lp);
#endif
	do_wakeup1_flag = 0;
	stat = STAT_WAKEUP2;
	ret = f_send_wakeup2(port_fd, &stat, &char_cnt);
	if (stat != STAT_ACCESS)
	{
		stat = STAT_WAKEUP1;
		do_wakeup1_flag = 1;
		ret = f_send_wakeup1(port_fd, &stat);
		ret = f_send_wakeup2(port_fd, &stat, &char_cnt);
		if (stat == STAT_ACCESS)
			ret_val = 0;
		else if (char_cnt == 0)
			ret_val = -1;							/* no char received */
		else
			ret_val = -2;							/* received char, but not we expected */
	}
	else
		ret_val = 0;

	writeport(port_fd, str_release);	/* release */

#ifdef DEBUG
	lt = time(NULL);
	ctime = localtime(&lt);
	fprintf(lp, "Now stat: %d\n", stat);
	fprintf(lp, "\n>>> Stop Neax-61 Test at %4d.%02d.%02d %02d:%02d:%02d <<<\n", ctime->tm_year > 90 ? ctime->tm_year + 1900 : ctime->tm_year + 2000, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
	fflush(lp);
#endif

	return ret_val;
}