apiwnd.cpp

cell phone source code

// ApiWnd.cpp : implementation file
//

#include "stdafx.h"
#include "AtlasMsg.h"
#include "ApiWnd.h"
#include "ApiThread.h"

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

#define DEFAULT_BAUDRATE		CBR_38400

int _iBaudrate[8] = {9600,14400,19200,38400};

#define STATUS_IDLE				0
#define STATUS_WAIT_SIGNATURE	1
#define STATUS_WAIT_ACK			2
#define STATUS_WAIT_DATA		3
#define STATUS_SENDING_DATA		4

#ifdef _PALM_DEBUGGER
HANDLE	g_hHaltedEvent = NULL;
BOOL	g_bRunning = FALSE;
#endif//#ifdef _PALM_DEBUGGER

IMPLEMENT_DYNAMIC(CApiWnd, CWnd)

/////////////////////////////////////////////////////////////////////////////
// CApiWnd

CApiWnd::CApiWnd()
{
	m_iSuggestBaudrateIndex = P_BAUDRATE_115200;
}

CApiWnd::~CApiWnd()
{
}

BOOL CApiWnd::Create()
{
	// Register a custom WndClass and create a window.
	// This must be done because CAudioWnd has a custom cursor, and no icon.
	LPCTSTR lpszApiWndClass =
		AfxRegisterWndClass(CS_HREDRAW | CS_VREDRAW,
			LoadCursor(NULL, IDC_ARROW),
			(HBRUSH)(COLOR_WINDOW+1), NULL);

	return CWnd::CreateEx(0, lpszApiWndClass, _T(""), WS_POPUPWINDOW,
							0, 0, 0, 0, NULL, 0);
}

/////////////////////////////////////////////////////////////////////////////
// CApiWnd protected functions

void CApiWnd::MsgOut()
{
	m_comm.Write((char *)m_msgOut.GetBuf(), m_msgOut.GetLength());
}

void CApiWnd::ProtocolStart()
{
    static WORD w;
    static DWORD dwRetrievedData;
    dwRetrievedData = 0;

    TRACE("CApiWnd::ProtocolStart()\r\n");
    w = MAKEWORD(P_CMD_WAIT_CONNECT, NULL);
	m_iProtocolStatus = STATUS_WAIT_SIGNATURE;
    ::PostThreadMessage((unsigned long)GetCurrentThreadId(), WM_API_COMMAND, (WPARAM)w, (LPARAM)&dwRetrievedData);
}

void CApiWnd::ProtocolStop()
{
    TRACE("CApiWnd::ProtocolStop() \n");
    m_iProtocolStatus = STATUS_IDLE;
	MsgOut();
}

void CApiWnd::ProtocolRun(BYTE * pData, int iLength)
{
	BOOL bDataError;
/*
	CString temp;
//	temp.Format("Data Recieved, iLength : 0x%x\n", iLength);
//	OutputDebugString(temp);
	for(int i = 0; i < iLength; i++)
	{
		temp.Format("0x%02x ", pData[i]);
		OutputDebugString(temp);
	}
	temp.Format("\n");
	OutputDebugString(temp);
*/
	m_msgIn.SetBuf(pData, iLength);
    while (m_msgIn.Unpack(bDataError))
	{
		switch (m_iProtocolStatus)
		{
		case STATUS_IDLE:
			Run_Idle();
			break;

		case STATUS_WAIT_ACK:
			Run_WaitAck();
			break;

		case STATUS_WAIT_DATA:
			Run_WaitData();
			break;

		case STATUS_SENDING_DATA:
			Run_SendingData();
			break;

		case STATUS_WAIT_SIGNATURE:
			Run_WaitSignature();
			break;
		}
	}
	if (bDataError)
	{
		m_comm.Put(P_NAK);
	}
}

void CApiWnd::Run_Idle()
{
#ifdef _PALM_DEBUGGER
	if(m_msgIn.GetType() == P_HLT)
	{
		OutputDebugString("Halted from device\n");
		if(g_hHaltedEvent != NULL)
			::SetEvent(g_hHaltedEvent);
		g_bRunning = FALSE;
	}
#endif//#ifdef _PALM_DEBUGGER
}

void CApiWnd::Run_WaitAck()
{
	switch (m_msgIn.GetType())
	{
	case P_ACK:
        m_msgOut.SetLength(0);
		m_iProtocolStatus = STATUS_IDLE;
		SetEvent(CApiThread::m_hEventProtocol);
		break;

	case P_NAK:
		MsgOut();
		break;

	default:
		break;
	}
}

void CApiWnd::Run_WaitData()
{
	switch (m_msgIn.GetType())
	{
	case P_DATA:
        
        m_iProtocolStatus = STATUS_IDLE;
	case P_DATA_UNFINISHED:
        m_msgOut.SetLength(0);
		SetEvent(CApiThread::m_hEventProtocol);
		break;
    case P_CMD:
     {
        switch(m_msgIn.GetCmdCode())
        {
        case P_CMD_GET_REG:
            {
                int iGetRegValue;
                iGetRegValue = m_msgIn.GetCmdVal();
                memcpy(m_pBuf, &iGetRegValue , sizeof(iGetRegValue));
                SendAck();
                break; 
            }

        }
        m_msgOut.SetLength(0);
        m_iProtocolStatus = STATUS_IDLE;
		SetEvent(CApiThread::m_hEventProtocol);
        break;         
     }
	default:
		break;
	}
}

void CApiWnd::SendAck()
{
	m_comm.Put(P_ACK);
}

void CApiWnd::SendDc1()
{
	m_iProtocolStatus = STATUS_IDLE;
	m_msgIn.Reset();
	m_comm.Put(P_DC1);
}

void CApiWnd::Run_SendingData()
{
	switch (m_msgIn.GetType())
	{
	case P_ACK:
        m_msgOut.SetLength(0);
		m_iProtocolStatus = STATUS_IDLE;
		SetEvent(CApiThread::m_hEventProtocol);
		break;

	case P_NAK:
		MsgOut();
		break;

	default:
		break;
	}
}

void CApiWnd::Run_WaitSignature()
{
	switch (m_msgIn.GetType())
	{
	case P_NAK:
        TRACE("CApiWnd::Run_WaitSignature()--Got response from devie, connect ok!\r\n");
        m_msgOut.SetLength(0);
		m_iProtocolStatus = STATUS_IDLE;
		SetEvent(CApiThread::m_hEventProtocol);
		break;

	default:
		break;
	}
}

BEGIN_MESSAGE_MAP(CApiWnd, CWnd)
	//{{AFX_MSG_MAP(CApiWnd)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	ON_WM_NCDESTROY()
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_COMMPORT_COM1_DATA, OnCommPortData)
	ON_MESSAGE(WM_COMMPORT_ERROR, OnCommPortError)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CApiWnd connection operations

BOOL CApiWnd::Connect(int iConnectType, int iBaudrateType)
{
	/*if (iConnectType == P_CONNECT_COM1)			m_strConnect = _T("COM1");
	else if (iConnectType == P_CONNECT_COM2)	m_strConnect = _T("COM2");*/
	m_strConnect.Format("COM%d",iConnectType+1);
    TRACE("try to connect %s\r\n",m_strConnect);
	m_iSuggestBaudrateIndex = _iBaudrate[iBaudrateType];

	if (m_comm.Open(GetSafeHwnd(), m_iSuggestBaudrateIndex , m_strConnect) == FALSE)
		return FALSE;

    TRACE("Open  m_strConnect sucessful!\r\n");
	ProtocolStart();
	return TRUE;
}

void CApiWnd::Disconnect()
{
	if (m_comm.IsConnected())
	{
		ProtocolStop();
		m_comm.Close();
	}
}

BOOL CApiWnd::IsConnected()
{
	return m_comm.IsConnected();
}

int CApiWnd::GetDataValue()
{
	int iVal = 0;
	char * p = (char *)m_msgIn.GetVData();

	if (m_msgIn.GetVDataLength() == sizeof(int))
	{
		memcpy((char *)&iVal, p, sizeof(int));
		SendAck();
	}
	else
	{
		SendDc1();
	}
	return iVal;
}

void CApiWnd::SendCommand(WPARAM wParam, LPARAM lParam)
{
	WORD w = LOWORD(wParam);
	int iCmdCode = LOBYTE(w);
	int iCmdReg = HIBYTE(w);
	int iLength = HIWORD(wParam);
    
#ifdef _PALM_DEBUGGER
	WORD iIndex = HIWORD(wParam);
#endif//#ifdef _PALM_DEBUGGER

	switch (iCmdCode)
	{
	case P_CMD_SET_REG:
		m_msgOut.PackCmdSetReg(iCmdReg, (int)lParam);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_CMD_GET_REG:

        m_pBuf = (PBYTE)lParam;
		m_msgOut.PackCmdGetReg(iCmdReg);
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;

	case P_CMD_ACTION:
		m_msgOut.PackCmdAction(iCmdReg, (int)lParam);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_CMD_SET_VDATA:
		m_msgOut.PackCmdSetVData(iCmdReg, (BYTE *)lParam, iLength);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_CMD_GET_VDATA:
		m_msgOut.PackCmdGetVData(iCmdReg);
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;
    case P_CMD_WAIT_CONNECT:
        {

            if(STATUS_WAIT_SIGNATURE == m_iProtocolStatus && *((DWORD *)lParam) < 4000)
            {
                TRACE("Send wait connect message,count %d\r\n",*((DWORD *)lParam));
                (*((DWORD *)lParam)) ++;
                m_msgOut.PackCmdWaitConnect();
                ::PostThreadMessage((unsigned long)GetCurrentThreadId(), WM_API_COMMAND, (WPARAM)wParam, (LPARAM)lParam);
                Sleep(1);

            }
            else
            {
               //nothing to output, direct return.
               TRACE("Need not send wait connect message!\r\n");
               return;
            }
                
        }
        break;

#ifdef _PALM_DEBUGGER
	case P_CMD_DEBUG:
		PackDebugCommand(iCmdReg, iIndex, lParam);
		break;
#endif//#ifdef _PALM_DEBUGGER
	}
	MsgOut();
}

#ifdef _PALM_DEBUGGER
void CApiWnd::PackDebugCommand(int iSubCode, WORD iIndex, LPARAM lParam)
{
	switch(iSubCode)
	{
	case P_DEBUG_READ_SFR_DATA:
		m_msgOut.PackCmdDebugReadSfrData();
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;

	case P_DEBUG_WRITE_SFR_DATA:
		m_msgOut.PackCmdDebugWriteSfrData();
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_DEBUG_READ_IDATA:
		m_msgOut.PackCmdDebugReadIdata();
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;

	case P_DEBUG_READ_CON_BUF:
		m_msgOut.PackCmdDebugReadConBuf();
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;

	case P_DEBUG_WRITE_BLOCK:
		m_msgOut.PackCmdDebugWriteBlock(iIndex, (BYTE *)lParam);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_DEBUG_READ_BLOCK:
		m_msgOut.PackCmdDebugReadBlock(iIndex, (WORD)lParam);
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;

	case P_DEBUG_READ_PALM_REG:
		m_msgOut.PackCmdDebugReadPalmReg(iIndex);
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;

	case P_DEBUG_WRITE_PALM_REG:
		m_msgOut.PackCmdDebugWritePalmReg(iIndex, (BYTE)lParam);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_DEBUG_SET_BREAKPOINT:
		m_msgOut.PackCmdDebugSetBreakpoint(iIndex);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_DEBUG_REMOVE_BREAKPOINT:
		m_msgOut.PackCmdDebugRemoveBreakpoint(iIndex);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_DEBUG_SET_STEP_BREAKPOINT:
		m_msgOut.PackCmdDebugSetStepBreakpoint(iIndex);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_DEBUG_GO:
		m_msgOut.PackCmdDebugGo();
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_DEBUG_DUMP_SDRAM:
		m_msgOut.PackCmdDebugDumpSDRAM(iIndex, (BYTE)lParam);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_DEBUG_LOAD_SDRAM:
		m_msgOut.PackCmdDebugLoadSDRAM(iIndex, (BYTE)lParam);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_DEBUG_READ_DMX:
		m_msgOut.PackCmdDebugReadDMX();
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;

	case P_DEBUG_READ_DMY:
		m_msgOut.PackCmdDebugReadDMY();
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;

	case P_DEBUG_READ_DMC:
		m_msgOut.PackCmdDebugReadDMC();
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;

	case P_DEBUG_READ_PMIN:
		m_msgOut.PackCmdDebugReadPMIn();
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;

	case P_DEBUG_READ_PM:
		m_msgOut.PackCmdDebugReadPM();
		m_iProtocolStatus = STATUS_WAIT_DATA;
		break;

	case P_DEBUG_DUMP_SM:
		m_msgOut.PackCmdDebugDumpSM((BYTE) iIndex, (BYTE *)lParam);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;

	case P_DEBUG_FORMAT_SM:
		m_msgOut.PackCmdDebugFormatSM((BYTE )lParam);
		m_iProtocolStatus = STATUS_WAIT_ACK;
		break;
	}
}
#endif//#ifdef _PALM_DEBUGGER

void CApiWnd::SendData(WPARAM wParam, LPARAM lParam)
{
	DWORD w = (DWORD)wParam;
	int iType = LOWORD(w);
	int iLength = HIWORD(w);
	BYTE * p = (BYTE *)lParam;

	if (iType == P_DATA)
	{
		m_msgOut.PackLastData(p, iLength);
	}
	else	// if (iType == P_DATA_UNFINISHED)
	{
		m_msgOut.PackUnfinishedData(p, iLength);
	}
	MsgOut();
	m_iProtocolStatus = STATUS_SENDING_DATA;
}

/////////////////////////////////////////////////////////////////////////////
// CApiWnd message handlers

void CApiWnd::OnCommPortData(WPARAM wParam, LPARAM lParam)
{
	int iLength = (int)wParam;
	BYTE * p = (BYTE *)lParam;
	CString strOutput = "", str;

/*	if (iLength < 40)
	{
		for (int i = 0; i < iLength; i ++)
		{
			str.Format("%02x", p[i]);
			strOutput += str;
		}
		strOutput += "\n";
		OutputDebugString(strOutput);
	}
*/
	ProtocolRun(p, iLength);
	free(p);
}

void CApiWnd::OnCommPortError(WPARAM, LPARAM)
{
	m_comm.Close();
}

void CApiWnd::OnNcDestroy()
{
	CWnd::OnNcDestroy();
	AfxPostQuitMessage(0);
}