board.cpp

一个完整的RTU程序源码,用DOS平台,支持16串口,在天津港用的很多,8个规约103,modbus,cdt,1801,u4f

	INT8U test_bit, diff;

	if (_TotalBDYm == 0) return;

	if (_TotalBDYm % 8) ym_in_8bit = _TotalBDYm / 8 + 1;
	else ym_in_8bit = _TotalBDYm / 8;

	if (!board_ym_first_sample && check_mtimeout(ym_timer, YM_SAMPLE_GAP)) {

		for (i = 0; i < ym_in_8bit; i++) {
			ym_bit[i] = Get8Ym(YmBoardAdd[i / 4], i % 4);
			test_bit = 0x1;
			diff = ym_bit[i] ^ ym_old_bit[i];
			for (k = 0; k < 8; k++, test_bit <<= 1) {
				if ((diff & test_bit) && (ym_bit[i] & test_bit))
					board_ym_update(i * 8 + k);
			}
			ym_old_bit[i] = ym_bit[i];
		}
	}

	if (board_ym_first_sample) {
		for (i = 0; i < ym_in_8bit; i++)
			ym_bit[i] = ym_old_bit[i] = Get8Ym(YmBoardAdd[i / 4], i % 4);
		ym_timer = get_mtime();
		board_ym_first_sample = FALSE;
	}																		// first sample no soe and bw
}

static void board_ym_update(INT16U dotno)
{
	INT16U dot;

	dot = board_ym_map[dotno];
	if (dot == INVALID) return;

	dbdata.Ym[dot]++;
}

void ymdeal()
{
	boardymget();
}

void board_yk_init(void)
{

	ykreg.ykstate = YKSNONE;
	ykreg.ykcheckresult = YKRNONE;
	ykreg.retflag = FALSE;
}

BOOLEAN make_yk_preset(INT8U cmd, INT8U switch_no, INT8U from)
{
	if (ykreg.doing) {  // previous yk is unfinish
		return (FALSE);
	}
	else {
		switch (from) {
			case PORT1: case PORT2: case PORT3: case PORT4:
			case PORT5: case PORT6: case PORT7: case PORT8:
			case PORT9: case PORT10: case PORT11: case PORT12:
			case PORT13: case PORT14: case PORT15: case PORT0:
				if (from != _DoYkPort) return (FALSE); // port yk is disable
			case WINDOW:
				if (_TotalYk <= 0) return (FALSE);
				ykreg.ykobj = switch_no;
				ykreg.ykcmd = cmd;
				ykreg.yksrc = from;
				ykreg.ykcheckresult = YKRNONE;
				if (!ykselect()) return (FALSE);
				ykreg.doing = TRUE;
				return (TRUE);
			default:
				return (FALSE); // unauthority port
		}
	}
}

void make_yk_exe(INT8U cmd, INT8U switch_no, INT8U from)
{
	if (ykreg.doing) {
		if (ykreg.ykobj == switch_no && ykreg.yksrc == from) {
			ykreg.ykstate = YKSEXEC;
			ykreg.ykexecmd = cmd;
		}
	}
}

BOOLEAN is_yk_return(INT8U portno)
{
	if (ykreg.doing && ykreg.yksrc == portno && ykreg.retflag)
		return(TRUE);
	else return(FALSE);
}

BOOLEAN is_port_yk_doing(INT8U portno)
{
	if (ykreg.doing && port_yk_info.yk_des == portno &&
		ykreg.ykexeman == PORT_YK_SOURCE) return(TRUE);
	else return(FALSE);
}

INT8U get_ykret_code(INT8U portno)
{
	if (ykreg.ykcheckresult == YKROK && ykreg.yksrc == portno)
		return(ykreg.ykcmd);
	else return(0xff);
}

void reset_yk(INT8U portno)
{
	if (portno == ykreg.yksrc) {
		ykreg.timer = ykreg.timerlimit = 0;
		ykreg.ykstate = YKSNONE;
		ykreg.ykcheckresult = YKRNONE;
		ykreg.retflag = FALSE;
		ykreg.doing = FALSE;
		ykreg.ykexecmd = YKCNONE;
		pcheck.state = PNONE;
	}
}

BOOLEAN ykselect(void)
{
	if (_TotalBDYk > 0 && ykreg.ykobj < _TotalYk
		&& YkDefine[ykreg.ykobj].portno == BOARD_SOURCE) {
		ykreg.ykexeman = BOARD_YK_SOURCE;
		ykreg.ykstate = YKSPRESET;
		return (TRUE);
	}

	if (_TotalYk - _TotalBDYk > 0 && ykreg.ykobj < _TotalYk
		&& YkDefine[ykreg.ykobj].portno > 0 && YkDefine[ykreg.ykobj].portno <= MAX_PORT) {
		ykreg.ykexeman = PORT_YK_SOURCE;
		ykreg.ykstate = YKSPRESET;
		return (TRUE);
	}
	return (FALSE);
}

static const INT8U ykboardaddr[] = {0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0};

void boardyk(void)
{
	INT8U operation, yknoinbyte;
	INT8U byteaddr, readoper, test = 0x01;


// yk isn't in progress
	if (!ykreg.doing) return;
	if (ykreg.ykexeman != BOARD_YK_SOURCE) return;

	INT8U boardno = YkDefine[ykreg.ykobj].info / 16;
	INT8U yknoinboard = YkDefine[ykreg.ykobj].info % 16;
	if (ykreg.ykcmd == YKCCLOSE) operation = BOARDHJ;
	else operation = BOARDTJ;

	if (ykreg.ykstate == YKSPRESET) {
		outp(_dio2base + 1, ykboardaddr[boardno] + yknoinboard);
		outp(_dio2base + 2, operation);
		pcheck.state = PFORRD;
		ykreg.ykstate = YKSCHECK;
		ykreg.timer = 0;
		ykreg.timerlimit = 1;
	}

	if (ykreg.ykstate == YKSCHECK) {
		if (pcheck.state == PFORRD && ykreg.timer > ykreg.timerlimit)	{
			if (yknoinboard <= 0x07) byteaddr = YK07CODE;
			else byteaddr = YK8FCODE;
			outp(_dio2base + 2, operation & byteaddr);   //for readback
			pcheck.state = PRDBACK;
			ykreg.timer = 0;
			ykreg.timerlimit = 1;
		}

		if (pcheck.state == PRDBACK && ykreg.timer > ykreg.timerlimit) {
			pcheck.readobj = inp(_dio2base);				  //Readback and test operation
			byteaddr = YKSTATECODE;
			outp(_dio2base + 2, operation & byteaddr);
			pcheck.state = PCHECK;
			ykreg.timer = 0;
			ykreg.timerlimit = 1;
		}

		if (pcheck.state == PCHECK && ykreg.timer > ykreg.timerlimit)	{
			readoper = inp(_dio2base) & 0x07;
			if (yknoinboard > 0x07)	yknoinbyte = yknoinboard - 8;
			else yknoinbyte = yknoinboard;

			test <<= yknoinbyte;
			test = ~test;
			if ((pcheck.readobj != test) ||
				(ykreg.ykcmd == YKCCLOSE && readoper != 0x05) ||
				(ykreg.ykcmd == YKCTRIP && readoper != 0x06)) {
				boardykreset();

				ykreg.ykstate = YKSNONE;
				ykreg.ykcheckresult = YKRERROR;
				ykreg.retflag = TRUE;
			}
			else {
				ykreg.timer = 0;
				ykreg.timerlimit = _YkEscapeTime * 18;
				ykreg.ykcheckresult = YKROK;
				ykreg.ykstate = YKSEXEC;
				ykreg.retflag = TRUE;
			}
		}
	}

	if (ykreg.ykstate == YKSEXEC) {
		if (ykreg.timer < ykreg.timerlimit) {

			if (ykreg.ykexecmd == YKCEXEC) {
				ykreg.ykstate = YKSCANCEL;
				ykreg.timer = 0;
				if (ykreg.ykcmd == YKCCLOSE)	{
					ykreg.timerlimit = 2 * 18;
					operation = BOARDHJ;
				}
				else {
					ykreg.timerlimit = 2 * 18;
					operation = BOARDTJ;
				}

				operation |= BOARDZJ;
				outp(_dio2base + 2, operation);
			}

			if (ykreg.ykexecmd == YKCESC) {
				boardykreset();
				reset_yk(ykreg.yksrc);
			}
		}
		else {
			boardykreset();
			reset_yk(ykreg.yksrc);
			ykreg.ykcheckresult = YKRTOUT;
		}
	}

	if (ykreg.ykstate == YKSCANCEL && ykreg.timer > ykreg.timerlimit) {
		boardykreset();
		reset_yk(ykreg.yksrc);
	}
}

void boardykreset(void)
{
	outp(_dio2base + 1, 0x00);
	outp(_dio2base + 2, 0x8f);
}

void portyk(void)
{
	if (!ykreg.doing) return;
	if (ykreg.ykexeman != PORT_YK_SOURCE) return;

	if (ykreg.ykstate == YKSPRESET) {
		ykreg.timer = 0;
		ykreg.timerlimit = 20 * 10;
		port_yk_info.yk_des = YkDefine[ykreg.ykobj].portno - 1;
		port_yk_info.dev_no = YkDefine[ykreg.ykobj].devno;
		port_yk_info.type = YkDefine[ykreg.ykobj].type;
		port_yk_info.yk_no = YkDefine[ykreg.ykobj].info;
		port_yk_info.yk_cmd = ykreg.ykcmd;
		port_yk_info.Y_PRESET = TRUE;
		port_yk_info.Y_CHECK = FALSE;
		port_yk_info.check_result = YKRNONE;
		ykreg.ykstate = YKSCHECK;
	}

	if (ykreg.ykstate == YKSCHECK) {
		if (port_yk_info.Y_CHECK) {
			if (port_yk_info.check_result == YKROK) {
				ykreg.ykstate = YKSEXEC;
				ykreg.timer = 0;
				ykreg.timerlimit = _YkEscapeTime * 20;
				ykreg.ykcheckresult = YKROK;
				ykreg.retflag = TRUE;
				port_yk_info.Y_CHECK = FALSE;
			}
			else {
				ykreg.ykcheckresult = YKRERROR;
				ykreg.ykstate = YKSNONE;
				ykreg.retflag = TRUE;
				port_yk_info.Y_CHECK = FALSE;
			}
			return;
		}

		if (ykreg.timer > ykreg.timerlimit) {
			ykreg.ykcheckresult = YKRTOUT;
			ykreg.ykstate = YKSNONE;
			ykreg.retflag = TRUE;
			port_yk_info.Y_CHECK = FALSE;
		}
	}

	if (ykreg.ykstate == YKSEXEC) {
		if (ykreg.timer < ykreg.timerlimit) {
			if (ykreg.ykexecmd == YKCEXEC) {
				ykreg.ykstate = YKSNONE;
				port_yk_info.Y_EXEC = TRUE;
				reset_yk(ykreg.yksrc);
			}
			if (ykreg.ykexecmd == YKCESC) {
				ykreg.ykstate = YKSNONE; //ESC
				port_yk_info.Y_ESC = TRUE;
				reset_yk(ykreg.yksrc);
			}
		}
		else {
			ykreg.ykstate = YKSNONE;
			port_yk_info.Y_ESC = TRUE;
			ykreg.ykcheckresult = YKRTOUT;
			reset_yk(ykreg.yksrc);
		}
	}
}

void doyk(void)
{
	boardyk();
	portyk();
}