classdevice.cpp

C实现模拟与或非门的逻辑电路

#include "StdAfx.h"
#include "Classdevice.h"
#include "Datastruct.h"
#include "Linklist.h"

//计算出持续时间
void Device::Calculasttime()
{
	LinkList optr = output;
	int temp;	
	(optr->data).lasttime = (optr->data).sumtime;
	temp = (optr->data).sumtime;
	
	while (1)
	{	
		optr = optr->next;
		if(optr == NULL)
			break;
		(optr->data).lasttime = (optr->data).sumtime-temp;
		temp = (optr->data).sumtime;
	}
}

//合并相邻相同的信号
void Device::Delcommon()
{
	LinkList ptr1, ptr2;                       //用于遍历比较相邻信号
	ptr1 = output;
	ptr2 = ptr1->next;
	while (ptr2 != 0)
	{
		if (ptr1->data.value == ptr2->data.value)
		{
			ptr1->data.sumtime = ptr2->data.sumtime;
			ListDelete(output,ptr1);
			ptr2 = ptr1->next;
		} 
		else
		{
			ptr1 = ptr2;
			ptr2 = ptr1->next;
		}
	}
}

//延时
void Device::Delay()
{
	LinkList ptr = output;
	if (ptr->data.value == true)                  //如果无延时时先输出高电平
	{
		ListInsertFirst(output, false, delaytime);
	}
	else
	{
		while (ptr->next != 0)
		{
			ptr->data.sumtime += delaytime;
			ptr = ptr->next;
		}
	}
}

//获得输出
LinkList Device::GetOutput()
{
	return output;
}

//为input1赋值
void Device::SetInput1(LinkList systeminput)
{
	input1 = systeminput;
}

//为input2赋值
void Device::SetInput2(LinkList systeminput)
{
	input2 = systeminput;
}

//标记输出
void Device::SetOutputTag()
{
	outputtag = true;
}

//标记输入一
void Device::SetInputTag1()
{
	inputtag1 = true;
}

//标记输入二
void Device::SetInputTag2()
{
	inputtag2 = true;
}

//判断是否两个输入都已经被赋值，是则返回true,否则返回false
bool Device::Ifinput()
{
	if (inputtag1 == true && inputtag2 ==true)
	{
		return true;
	} 
	else
	{
		return false;
	}
}

//判断输出是否已经计算出，是则返回true,否则返回false
bool Device::Ifoutput()
{
	if (outputtag == true)
	{
		return true;
	} 
	else
	{
		return false;
	}
}

//与门构造函数，为output加结点并初始化为零
DeviceAND::DeviceAND()
{
	delaytime = 10;                              //初始化延迟时间
	inputtag1 = false;
	inputtag2 = false;
	outputtag = false;
	output = new LNode;
	output->next = 0;
	output->data.lasttime = 0;
	output->data.sumtime = 0;
	output->data.value = 0;
}

//*************************
//或门构造函数，为output加结点并初始化为零
DeviceOR::DeviceOR()
{
	delaytime = 10;                              //初始化延迟时间
	inputtag1 = false;
	inputtag2 = false;
	outputtag = false;
	output = new LNode;
	output->next = 0;
	output->data.lasttime = 0;
	output->data.sumtime = 0;
	output->data.value = 0;
}

//与非门构造函数，为output加结点并初始化为零
DeviceNAND::DeviceNAND()
{
	delaytime = 15;                              //初始化延迟时间
	inputtag1 = false;
	inputtag2 = false;
	outputtag = false;
	output=new LNode;
	output->next = 0;
	output->data.lasttime = 0;
	output->data.sumtime = 0;
	output->data.value = 0;
}

//异或门构造函数，为output加结点并初始化为零
DeviceXOR::DeviceXOR()
{
	delaytime = 20;                             //初始化延迟时间
	inputtag1 = false;
	inputtag2 = false;
	outputtag = false;
	output = new LNode;
	output->next = 0;
	output->data.lasttime = 0;
	output->data.sumtime = 0;
	output->data.value = 0;
}

//同或门构造函数，为output加结点并初始化为零
DeviceNXOR::DeviceNXOR()
{
	delaytime = 20;                             //初始化延迟时间
	inputtag1 = false;
	inputtag2 = false;
	outputtag = false;
	output = new LNode;
	output->next = 0;
	output->data.lasttime = 0;
	output->data.sumtime = 0;
	output->data.value = 0;
}

//通过输入得到输出
bool Device::GetResponse()
{
	LinkList ptr1, ptr2;                        //两个指针用于遍历两个输入信号
	LinkList optr = output;
	LinkList temp;
	int currenttime;                             //已经计算过的时间
	ptr1 = input1;
	ptr2 = input2;
	while (ptr1 != 0 || ptr2 != 0)
	{
		if (ptr1->data.sumtime < ptr2->data.sumtime)//若信号一扫描的慢一些
		{
			currenttime = ptr1->data.sumtime;
			optr->data.sumtime = currenttime;
			optr->data.value = LogicExpression(ptr1->data.value, ptr2->data.value);
			ptr1 = ptr1->next;
		} 
		else if (ptr1->data.sumtime > ptr2->data.sumtime)//若信号一快一些
		{
			currenttime =  ptr2->data.sumtime;
			optr->data.sumtime = currenttime;
			optr->data.value = LogicExpression(ptr1->data.value, ptr2->data.value);
			ptr2 = ptr2->next;
		} 
		else//若相同
		{
			currenttime = ptr2->data.sumtime;
			optr->data.sumtime = currenttime;
			optr->data.value = LogicExpression(ptr1->data.value, ptr2->data.value);
			ptr1 = ptr1->next;
			ptr2 = ptr2->next;
		}

		if(ptr1 != 0 || ptr2 != 0)
		{
			temp = new LNode;
			temp->next = 0;
			optr->next = temp;
			optr = optr->next;
		}
		
	}

	Delcommon();	
	Calculasttime();
	Delay();
	Calculasttime();

	return true;
}

bool Device::LogicExpression(bool A, bool B)
{
	return A && B;
}

//与门逻辑表达式
bool DeviceAND::LogicExpression(bool A, bool B)
{
	return A && B;
}

//或门逻辑表达式
bool DeviceOR::LogicExpression(bool A, bool B)
{
	return A || B;
}

//与非门逻辑表达式
bool DeviceNAND :: LogicExpression(bool A, bool B)
{
	return !(A && B);
}

//异或门逻辑表达式
bool DeviceXOR::LogicExpression(bool A,bool B)
{
	return ((!A) && B) || (A && (!B));
}

//同或门逻辑表达式
bool DeviceNXOR::LogicExpression(bool A,bool B)
{
	return (A && B) || ((!A) && (!B));
}


void DeviceNOT::Delay()
{
	LinkList ptr = output;
	if (ptr->data.value == true)                    //如果无延时时先输出高电平
	{
		ListInsertFirst(output, false, delaytime);
	}
	else
	{
		while (ptr->next != 0)
		{
			ptr->data.sumtime += delaytime;
			ptr = ptr->next;
		}
	}
}

//非门获取输出
LinkList DeviceNOT::GetOutput()
{
	return output;
}

//非门为input赋值
void DeviceNOT::SetInput(LinkList systeminput)
{
	input = systeminput;
}

void DeviceNOT::SetInputTag()
{
	inputtag = true;
}

void DeviceNOT::SetOutputTag()
{
	outputtag = true;
}
//判断是否输入已经被赋值，是则返回true,否则返回false
bool DeviceNOT::Ifinput()
{
	if (inputtag == true)
	{
		return true;
	} 
	else
	{
		return false;
	}
}

//判断输出是否已经计算出，是则返回true,否则返回false
bool DeviceNOT::Ifoutput()
{
	if (outputtag == true)
	{
		return true;
	} 
	else
	{
		return false;
	}
}

DeviceNOT::DeviceNOT()
{
	delaytime = 5;                              //初始化延迟时间
	inputtag = false;
	outputtag = false;
	output = new LNode;
	output->next = 0;
	output->data.lasttime = 0;
	output->data.sumtime = 0;
	output->data.value = 0;
}

void DeviceNOT::Calculasttime()
{
	LinkList optr = output;
	int temp;	
	(optr->data).lasttime = (optr->data).sumtime;
	temp = (optr->data).sumtime;
	
	while(1)
	{	
		optr = optr->next;
		if(optr == NULL)
			break;
		(optr->data).lasttime = (optr->data).sumtime-temp;
		temp = (optr->data).sumtime;
	}
}

bool DeviceNOT::GetResponse()
{
	LinkList ptr;                                 //指针用于遍历输入信号
	LinkList optr = output;
	LinkList temp;
	ptr = input;
	while (ptr != 0)
	{
		optr->data.sumtime = ptr->data.sumtime;
		optr->data.lasttime = optr->data.lasttime;
		optr->data.value =! (ptr->data.value);
		ptr = ptr->next;
		
		if(ptr != 0)
		{
			temp = new LNode;
			temp->next = 0;
			optr->next = temp;
			optr = optr->next;
		}		
	}
	Calculasttime();
	Delay();
	Calculasttime();
	return true;
}