ykclass.cpp

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

#include "ykclass.h"
#include "extern.h"

void CYk::init()
{
	int i;

	ykreg.ykstate = YKSNONE;
	ykreg.ykcheckresult = YKRNONE;
	ykreg.retflag = FALSE;
	for (i = 1, yk_source_start_dot[0] = 0; i < YK_SOURCE_NO; i++)
		yk_source_start_dot[i] = yk_source_start_dot[i - 1] + datasource.yk[i - 1];

	ioport = hardwareset[4].address;
}

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:
				if (yk_enable[from] == FALSE) return (FALSE); // port yk is disable
			case WINDOW:
				if (datasource.total[3] <= 0) return (FALSE);
				ykreg.ykobj = switch_no;
				ykreg.ykcmd = cmd;
				ykreg.yksrc = from;
				ykreg.ykcheckresult = YKRNONE;
				if (!yk.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 CYk::ykselect()
{
	if (datasource.yk[BOARD_YK_SOURCE] > 0 && ykreg.ykobj < datasource.yk[BOARD_YK_SOURCE]) {
		ykreg.ykexeman = BOARD_YK_SOURCE;
		ykreg.ykstate = YKSPRESET;
		return (TRUE);
	}

	if (datasource.yk[PORT_YK_SOURCE] > 0 && ykreg.ykobj >= yk_source_start_dot[PORT_YK_SOURCE]
		&& ykreg.ykobj - yk_source_start_dot[PORT_YK_SOURCE] < datasource.yk[PORT_YK_SOURCE]) {
		ykreg.ykexeman = PORT_YK_SOURCE;
		ykreg.ykstate = YKSPRESET;
		return (TRUE);
	}
	return (FALSE);
}

void CYk::boardyk()
{
	INT8U operation, yknoinbyte;
	INT8U byteaddr, readoper, test = 0x01;
	INT8U ykboardaddr[] = {0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0};

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

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

	if (ykreg.ykstate == YKSPRESET) {
		outportb(ioport + 1, ykboardaddr[boardno] + yknoinboard);
		outportb(ioport + 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;
			outportb(ioport + 2, operation & byteaddr);   //for readback
			pcheck.state = PRDBACK;
			ykreg.timer = 0;
			ykreg.timerlimit = 1;
		}

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

		if (pcheck.state == PCHECK && ykreg.timer > ykreg.timerlimit)	{
			readoper = inportb(ioport) & 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 = yk_escape_time * 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 = yk_time[ykreg.ykobj][0] * 18;
					operation = BOARDHJ;
				}
				else {
					ykreg.timerlimit = yk_time[ykreg.ykobj][1] * 18;
					operation = BOARDTJ;
				}

				operation |= BOARDZJ;
				outportb(ioport + 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 CYk::boardykreset()
{
	outportb(ioport + 1, 0x00);
	outportb(ioport + 2, 0x8f);
}

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

	if (ykreg.ykstate == YKSPRESET) {
		ykreg.timer = 0;
		ykreg.timerlimit = 20 * 10;
		INT8U port_yk_no = ykreg.ykobj - yk_source_start_dot[PORT_YK_SOURCE];
		port_yk_info.yk_des = yk_define[port_yk_no][0] - 1;
		port_yk_info.dev_no = yk_define[port_yk_no][1];
		port_yk_info.type = yk_define[port_yk_no][2];
		port_yk_info.yk_no = yk_define[port_yk_no][3];
		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 = yk_escape_time * 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 CYk::doyk()
{
	boardyk();
	portyk();
}