parallelpro.cpp

包含51单片机并口串口下载线的上位机及下位机的源程序

//////////////////////////////////////////////////////////////////////
// ParallelPro.cpp: implementation of the CParallelPro class.
//这个类负责对并口下载线进行控制，利用"Isp编程方法对象"对器件编程
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "EPro.h"
#include "Pro.h"
#include "ParallelPro.h"
#include "IsPro.h"
#include "At89s51Isp.h"//AT89S51的Isp编程方法


#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CParallelPro::CParallelPro()
{
	//把所有的Isp编程方法对象加入到队列
	m_arIsp.Add(new CAt89s51Isp);

}

CParallelPro::~CParallelPro()
{

}

extern CString m_strAppPath;//应用程序所在的路径

BOOL CParallelPro::InitPort(CPro* pPro,int nPort,int nProType,int nIspSpd)
{	//初始化并口和下载线
	TRACE("CParallelPro::InitPort,ProType:%d,nIspSpd:%d\n",nProType,nIspSpd);
	TRACE("Current Isp:%d\n",m_arIsp.GetSize());
	m_pPro=pPro;
	m_nProType=nProType;
	m_nIspSpd=nIspSpd;
	if(m_bPort=CParallelPort::InitPort())//初始化并口
		pPro->Notify(PRO_INIT_PARALLEL_SEC);
	else
		pPro->Notify(PRO_INIT_PARALLEL_ER);
	m_bThread=FALSE;
	if(nProType==1)//Easy Isp
	{
		CString strEasyIspIni;
		strEasyIspIni=m_strAppPath+"EasyIsp.ini";
		//从EasyIsp.ini文件获得引脚配置信息
		//如果不存在"EasyIsp.ini"文件，则使用默认的下载线配置(老版本的)
		m_nPinMosi=GetPrivateProfileInt("引脚控制","MOSI",14,strEasyIspIni);
		m_nPinMiso=GetPrivateProfileInt("引脚控制","MISO",15,strEasyIspIni);
		m_nPinSck=GetPrivateProfileInt("引脚控制","SCK",1,strEasyIspIni);
		m_nPinRst=GetPrivateProfileInt("引脚控制","RST",16,strEasyIspIni);
		m_nPinLe=GetPrivateProfileInt("引脚控制","LE",17,strEasyIspIni);
		m_nPinOe=GetPrivateProfileInt("引脚控制","OE",2,strEasyIspIni);
		m_nPinR1=GetPrivateProfileInt("引脚控制","R1",3,strEasyIspIni);
		m_nPinR2=GetPrivateProfileInt("引脚控制","R2",4,strEasyIspIni);
		m_bLe=GetPrivateProfileInt("锁存控制(LE)","Enable",1,strEasyIspIni);
		m_b2Le=GetPrivateProfileInt("锁存控制(LE)","Disable",0,strEasyIspIni);
		m_bOe=GetPrivateProfileInt("输出控制(OE)","Enable",0,strEasyIspIni);
		m_b2Oe=GetPrivateProfileInt("输出控制(OE)","Disable",1,strEasyIspIni);
		
	}
	else if(nProType==2)//Atmel ByteBlaster下载线
	{
		m_nPinRst=PIN_SELIN;//PIN_SELIN在ParallelPort做了定义
		m_nPinMosi=PIN_D0;
		m_nPinMiso=PIN_ACK;
		m_nPinSck=PIN_STROBE;
		m_nPinLe=PIN_D2;//不用le,为了延时假定一个不起作用的引脚
		m_bLe=0;
		m_b2Le=0;
		m_nPinOe=0;//不用oe
		m_nPinR1=m_nPinAf=PIN_AUTO;//保留
		m_nPinR2=m_nPinIni=PIN_INIT;//保留

	}
	else if(nProType==3)//Altera ByteBlaster下载线
	{
		m_nPinRst=3;
		m_nPinMosi=8;
		m_nPinMiso=11;
		m_nPinSck=2;
		m_nPinLe=14;//控制74244的le
		m_bLe=0;
		m_b2Le=0;//le常置低电平
		m_nPinOe=0;//没有Oe
		m_nPinR1=0;//
		m_nPinR2=0;//无保留引脚
	}
	SetPinLogic(m_nPinLe,m_bLe);

	for(int n=0;n<m_arIsp.GetSize();n++)//初始化每个"Isp编程方法对象"
		m_arIsp.GetAt(n)->InitIsPro(this);
	return m_bPort;
}

CIsPro* CParallelPro::GetIsPro(BYTE FID)
{	//查找支持该FID的"Isp编程方法对象"
	for(int n=0;n<m_arIsp.GetSize();n++)
		if(m_arIsp.GetAt(n)->FID==FID)
			return m_pIsPro=m_arIsp.GetAt(n);
			//设置当前"Isp编程方法对象"指针
	return NULL;
}

void CParallelPro::DetectPro(int FID)
{
	if(m_bPort)
		if(GetIsPro(FID)!=NULL)//查询是否支持该FID
		{
			m_pPro->Notify(PRO_AVAILABLE);//查询成功，通知"编程器就绪"
			return;
		}
	m_pPro->Notify(PRO_INVALID);//查询失败
}

void CParallelPro::ReadSign(BYTE FID)//读特征字
{
	if(m_bThread)//如果上一次操作线程还没结束
	{
		m_pPro->Notify(PRO_INVALID);
		return;
	}
	if(GetIsPro(FID)==NULL)//查询是否支持该FID
	{
		m_pPro->Notify(PRO_WORK_INVALID);
		return;
	}
	m_nCurWork=1;//当前操作标识
	AfxBeginThread(ProWorkThread,this);
}

void CParallelPro::Erase(BYTE FID)
{
	if(m_bThread)//如果上一次操作线程还没结束
	{
		m_pPro->Notify(PRO_INVALID);
		return;
	}
	if(GetIsPro(FID)==NULL)//查询是否支持该FID
	{
		m_pPro->Notify(PRO_WORK_INVALID);
		return;
	}
	m_nCurWork=2;//当前操作标识
	AfxBeginThread(ProWorkThread,this);
}

void CParallelPro::BeginWrite(BYTE FID)
{
	if(m_bThread)//如果上一次操作线程还没结束
	{
		m_pPro->Notify(PRO_INVALID);
		return;
	}
	if(GetIsPro(FID)==NULL)//查询是否支持该FID
	{
		m_pPro->Notify(PRO_WORK_INVALID);
		return;
	}
	m_nCurWork=3;//当前操作标识
	AfxBeginThread(ProWorkThread,this);
}

void CParallelPro::BeginRead(BYTE FID)
{
	if(m_bThread)//如果上一次操作线程还没结束
	{
		m_pPro->Notify(PRO_INVALID);
		return;
	}
	if(GetIsPro(FID)==NULL)//查询是否支持该FID
	{
		m_pPro->Notify(PRO_WORK_INVALID);
		return;
	}
	m_nCurWork=4;//当前操作标识
	AfxBeginThread(ProWorkThread,this);
}

void CParallelPro::LockBit(BYTE FID,int nBit)
{
	if(m_bThread)//如果上一次操作线程还没结束
	{
		m_pPro->Notify(PRO_INVALID);
		return;
	}
	if(GetIsPro(FID)==NULL)//查询是否支持该FID
	{
		m_pPro->Notify(PRO_WORK_INVALID);
		return;
	}
	m_nLockBits=nBit;
	m_nCurWork=5;//当前操作标识
	AfxBeginThread(ProWorkThread,this);
}

UINT CParallelPro::ProWorkThread(LPVOID pParam)
{	//编程器(下载线)操作线程
	CParallelPro* pParlPro=(CParallelPro*)pParam;
	CPro* pPro=pParlPro->m_pPro;
	CIsPro* pIsPro=pParlPro->m_pIsPro;
	pParlPro->m_bThread=TRUE;
	TRACE("m_nCurWork:%d\n",pParlPro->m_nCurWork);
	pParlPro->SetPinLogic(pParlPro->m_nPinOe,pParlPro->m_bOe);
	//解除高阻状态
	pIsPro->PreparePro();//编程前的准备工作
	switch(pParlPro->m_nCurWork)//根据当前操作标识调用函数
	{
	case 1://读特征字
		pIsPro->ReadSign(pPro->SignByte);
		//调用"Isp编程方法对象"中的编程方法
		pIsPro->ProOver();//编程结束后的工作
		pParlPro->m_bThread=FALSE;
		pPro->CheckChip();
		break;
	case 2://擦除器件
		pIsPro->Erase();
		//调用"Isp编程方法对象"中的编程方法
		pIsPro->ProOver();//编程结束后的工作
		pParlPro->m_bThread=FALSE;
		pPro->Notify(PRO_ERASE);
		break;
	case 3://写器件
		pPro->m_nDataLength=pPro->GetMinLength(pPro->m_pWriteBuf,0x10000);
		pIsPro->PreparePro();
		for(pPro->m_nAddr=0;pPro->m_nAddr<pPro->m_nDataLength;pPro->m_nAddr++)
		{
			if(!pIsPro->Write(pPro->m_pWriteBuf[pPro->m_nAddr],pPro->m_nAddr))
			{//调用"Isp编程方法对象"中的编程方法
				pIsPro->ProOver();//编程结束后的工作
				pPro->Notify(PRO_WRITE_ER);
				pParlPro->m_bThread=FALSE;
				return -1;
			}
			if(pPro->m_nAddr%0x0f==0)
				pPro->Notify(PRO_WRITE_BLOCK);
		}
		pIsPro->ProOver();
		pParlPro->m_bThread=FALSE;
		pPro->Notify(PRO_WRITE_OVER);
		break;
	case 4://读器件
		if(!pPro->m_bCheck)
			pPro->m_nDataLength=pPro->GetCurChip()->RomSize*1024;
		if(pPro->m_nDataLength==0)
		{
			pPro->Notify(PRO_READ_OVER);
			TRACE("ReadRomThread(...) Over\n");
			break;
		}
		for(pPro->m_nAddr=0;pPro->m_nAddr<pPro->m_nDataLength;pPro->m_nAddr++)
		{
			pPro->m_pReadBuf[pPro->m_nAddr]=pIsPro->Read(pPro->m_nAddr);
			//调用"Isp编程方法对象"中的编程方法
			if(pPro->m_nAddr%0x0f==0)
				pPro->Notify(PRO_READ_BLOCK);
		}
		pIsPro->ProOver();//编程结束后的工作
		pParlPro->m_bThread=FALSE;
		pPro->Notify(PRO_READ_OVER);
		break;
	case 5://写锁定位
		pIsPro->LockBit(pParlPro->m_nLockBits);
		//调用"Isp编程方法对象"中的编程方法
		pIsPro->ProOver();//编程结束后的工作
		pParlPro->m_bThread=FALSE;
		pPro->Notify(PRO_LOCK_BIT);
		break;
	default:
		pParlPro->m_bThread=FALSE;
		break;
	}
	//编程结束
	pParlPro->SetPinLogic(pParlPro->m_nPinOe,pParlPro->m_b2Oe);
	//高阻状态
	return 0;
}


BOOL CParallelPro::GetMiso()//得到MISO引脚的电平
{
	if(m_nIspSpd==2)
	{
		return GetPinLogic(m_nPinMiso);
	}
	else if(m_nIspSpd==1)
	{
		SetPinLogic(m_nPinLe,m_bLe);//开启锁存
		return GetPinLogic(m_nPinMiso);
	}
	else
	{
		SetPinLogic(m_nPinLe,m_bLe);//开启锁存
		for(int n=0;n<=1000;n++)//延时
		{
		}
		SetPinLogic(m_nPinLe,m_b2Le);//关闭锁存
		return GetPinLogic(m_nPinMiso);
	}
}

void CParallelPro::SetMosi(BOOL bLogic)
{
		
	if(bLogic)
		SetPinH(m_nPinMosi);
	else
		SetPinL(m_nPinMosi);
	if(m_nIspSpd==2)
	{
		return;
	}
	else if(m_nIspSpd==1)
	{
		SetPinLogic(m_nPinLe,m_bLe);//开启锁存
		return;
	}
	else
	{
		SetPinLogic(m_nPinLe,m_bLe);//开启锁存
		for(int n=0;n<=1000;n++)//延时
		{
		}
		SetPinLogic(m_nPinLe,m_b2Le);//关闭锁存
	}
}

void CParallelPro::SetRst(BOOL bLogic)
{
	
	if(bLogic)
		SetPinH(m_nPinRst);
	else
		SetPinL(m_nPinRst);
	if(m_nIspSpd==2)
	{
		return;
	}
	else if(m_nIspSpd==1)
	{
		SetPinLogic(m_nPinLe,m_bLe);//开启锁存
		return;
	}
	else
	{
		SetPinLogic(m_nPinLe,m_bLe);//开启锁存
		for(int n=0;n<=1000;n++)//延时
		{
		}
		SetPinLogic(m_nPinLe,m_b2Le);//关闭锁存
	}
}

void CParallelPro::SetSck(BOOL bLogic)
{
	if(bLogic)
		SetPinH(m_nPinSck);
	else
		SetPinL(m_nPinSck);
	if(m_nIspSpd==2)
	{
		return;
	}
	else if(m_nIspSpd==1)
	{
		SetPinLogic(m_nPinLe,m_bLe);//开启锁存
		return;
	}
	else
	{
		SetPinLogic(m_nPinLe,m_bLe);//开启锁存
		for(int n=0;n<=1000;n++)//延时
		{
		}
		SetPinLogic(m_nPinLe,m_b2Le);//关闭锁存
	}
}


void CParallelPro::SckBytes(int nBytes)//通过下载线与器件通信
{
	for(int n=0;n<nBytes;n++)
	{	
		SetSck(0);
		SetMosi((OutBuf[n] & 0x80));//SCK为低电平时，发送一位
		SetSck(1);
		if(GetMiso())//SCK为搞电平时，接收一位
		{
		
			InBuf[n]=InBuf[n] | 0x80;
		}
		else
		{	
			InBuf[n]=InBuf[n] & 0x7f;
		}
		SetSck(0);
		SetMosi((OutBuf[n] & 0x40));
		SetSck(1);
		if(GetMiso())
		{
		
			InBuf[n]=InBuf[n] | 0x40;
		}
		else
		{	
			InBuf[n]=InBuf[n] & 0xbf;
		}
		SetSck(0);

		SetMosi((OutBuf[n] & 0x20));
		SetSck(1);
		if(GetMiso())
		{
		
			InBuf[n]=InBuf[n] | 0x20;
		}
		else
		{	
			InBuf[n]=InBuf[n] & 0xdf;
		}
		SetSck(0);

		SetMosi((OutBuf[n] & 0x10));
		SetSck(1);
		if(GetMiso())
		{
		
			InBuf[n]=InBuf[n] | 0x10;
		}
		else
		{	
			InBuf[n]=InBuf[n] & 0xef;
		}
		SetSck(0);

		SetMosi((OutBuf[n] & 0x08));
		SetSck(1);
		if(GetMiso())
		{
		
			InBuf[n]=InBuf[n] | 0x08;
		}
		else
		{	
			InBuf[n]=InBuf[n] & 0xf7;
		}
		SetSck(0);

		SetMosi((OutBuf[n] & 0x04));
		SetSck(1);
		if(GetMiso())
		{
		
			InBuf[n]=InBuf[n] | 0x04;
		}
		else
		{	
			InBuf[n]=InBuf[n] & 0xfb;
		}
		SetSck(0);

		SetMosi((OutBuf[n] & 0x02));
		SetSck(1);
		if(GetMiso())
		{
		
			InBuf[n]=InBuf[n] | 0x02;
		}
		else
		{	
			InBuf[n]=InBuf[n] & 0xfd;
		}
		SetSck(0);

		SetMosi((OutBuf[n] & 0x01));
		SetSck(1);
		if(GetMiso())
		{
		
			InBuf[n]=InBuf[n] | 0x01;
		}
		else
		{	
			InBuf[n]=InBuf[n] & 0xfe;
		}
		SetSck(0);
	}
}