MyCommDoc.cpp

// MyCommDoc.cpp : implementation of the CMyCommDoc class
//

#include "stdafx.h"
#include "MyComm.h"
#include "MyCommDoc.h"

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

/////////////////////////////////////////////////////////////////////////////
// CMyCommDoc

IMPLEMENT_DYNCREATE(CMyCommDoc, CDocument)

BEGIN_MESSAGE_MAP(CMyCommDoc, CDocument)
    //{{AFX_MSG_MAP(CMyCommDoc)
        // NOTE - the ClassWizard will add and remove mapping macros here.
        //    DO NOT EDIT what you see in these blocks of generated code!
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMyCommDoc construction/destruction

CMyCommDoc::CMyCommDoc()
{
    // TODO: add one-time construction code here
    m_ComAction = FALSE;

    m_intPort     = 1;
    m_intBaudRate = 9600;
    m_intDataBits = 8;
    m_cParity     ='N';
    m_intStopBits = 0;

    m_IsReceiveHex = TRUE;
    m_IsSendHex = TRUE;
    m_CommTimeout.ReadIntervalTimeout = 1;  //units ms
    m_CommTimeout.ReadTotalTimeoutMultiplier = 0;
    m_CommTimeout.ReadTotalTimeoutConstant = 0;
    m_CommTimeout.WriteTotalTimeoutMultiplier = 0;
    m_CommTimeout.WriteTotalTimeoutConstant = 0;

    m_TXCount = 0;
    m_RXCount = 0;
    int i;
    for(i=0;i<COMMANDCOUNT;i++)
    {
        m_Command[i].m_IsHex = FALSE;
        m_Command[i].m_isScript = FALSE;
    }
    
    m_historyIndex = 0;

}

CMyCommDoc::~CMyCommDoc()
{
}

BOOL CMyCommDoc::OnNewDocument()
{
    if (!CDocument::OnNewDocument())
        return FALSE;

    // TODO: add reinitialization code here
    // (SDI documents will reuse this document)

    return TRUE;
}



/////////////////////////////////////////////////////////////////////////////
// CMyCommDoc serialization

void CMyCommDoc::Serialize(CArchive& ar)
{
    //
    // 2. 去掉快捷键 2008-1-14
    // 3. 增加是否是脚本功能,及16进制 2008-1-15
    // 4. 增加结果窗口的值 2008-1-18
    //
    //
    int ver; 
    int count;
    if (ar.IsStoring())
    {
        // TODO: add storing code here
        
        ver = 5;
        ar<<ver;  //version
        ar<<m_intPort;
        ar<<m_intBaudRate;
        ar<<m_intStopBits;
        ar<<m_intStopBits;
        ar<<m_cParity;
        ar<<m_intDataBits;
        
        //Timeout
        ar<<m_CommTimeout.ReadIntervalTimeout;
        ar<<m_CommTimeout.ReadTotalTimeoutMultiplier;
        ar<<m_CommTimeout.ReadTotalTimeoutConstant;
        ar<<m_CommTimeout.WriteTotalTimeoutMultiplier;
        ar<<m_CommTimeout.WriteTotalTimeoutConstant;
        
        count = COMMANDCOUNT;
        ar<<count;
        for(int i=0;i<count-1;i++)
        {
            ar<<m_Command[i].m_strName;
            //ar<<m_Command[i].m_ShutChar; ver=2 去掉
            ar<<m_Command[i].m_strCommand;
            ar<<m_Command[i].m_IsHex;  //ver=3
            ar<<m_Command[i].m_isScript; //ver=3
                    
        };

        ar<<m_IsReceiveHex;
        ar<<m_IsSendHex;
        ar<<m_strProtocol;
        ar<< m_strReceiveValue; //ver=4 2008-1-18

                
    }
    else
    {
        // TODO: add loading code here
        ar>>ver;
        ar>>m_intPort;
        ar>>m_intBaudRate;
        ar>>m_intStopBits;
        ar>>m_intStopBits;
        ar>>m_cParity;
        ar>>m_intDataBits;

        //Timeout
        ar>>m_CommTimeout.ReadIntervalTimeout;
        ar>>m_CommTimeout.ReadTotalTimeoutMultiplier;
        ar>>m_CommTimeout.ReadTotalTimeoutConstant;
        ar>>m_CommTimeout.WriteTotalTimeoutMultiplier;
        ar>>m_CommTimeout.WriteTotalTimeoutConstant;

        ar>>count;
        for(int i=0;i<count-1;i++)
        {
            ar>>m_Command[i].m_strName;
            if (ver < 2) 
            {
                char myc;
                ar>>myc;
            }
            ar>>m_Command[i].m_strCommand;
            if (ver>2)
            {
                ar>>m_Command[i].m_IsHex;
                ar>>m_Command[i].m_isScript;
            }    
        };

        ar>>m_IsReceiveHex;
        ar>>m_IsSendHex;
        ar>>m_strProtocol;

        //ver=4
        if (ver>3)
        {
            ar>>m_strReceiveValue;
        }
        


    };
}

BOOL CMyCommDoc::OpenComm(CWnd * POwner)
{
    if (m_Comm.InitPort(POwner,m_intPort,m_intBaudRate,m_cParity,
        m_intDataBits,m_intStopBits
        /*
        m_CommTimeout.ReadIntervalTimeout,
        m_CommTimeout.ReadTotalTimeoutConstant,
        m_CommTimeout.ReadTotalTimeoutMultiplier,
        m_CommTimeout.WriteTotalTimeoutMultiplier,
        m_CommTimeout.WriteTotalTimeoutConstant*/))
    {
        m_Comm.StartMonitoring();
        return TRUE;
    }
    else
        return FALSE;
}
void CMyCommDoc::CloseComm()
{
    m_Comm.ClosePort();
    m_Comm.StopMonitoring();
}

int CMyCommDoc::AddHistory(CommCommand Command)
{
    if (m_historyIndex>=COMMANDCOUNT)  //=20
    {    
        CommCommand myCommand;
        for (int i=1;i<COMMANDCOUNT;i++)
        {
            m_HistoryCommand[i-1].m_IsHex = m_HistoryCommand[i].m_IsHex;
            m_HistoryCommand[i-1].m_isScript = m_HistoryCommand[i].m_isScript;
            m_HistoryCommand[i-1].m_strCommand = m_HistoryCommand[i].m_strCommand;
            m_HistoryCommand[i-1].m_strName = m_HistoryCommand[i].m_strName;
        }
        // end
        m_HistoryCommand[m_historyIndex-1].m_IsHex = Command.m_IsHex;
        m_HistoryCommand[m_historyIndex-1].m_isScript = Command.m_isScript;
        m_HistoryCommand[m_historyIndex-1].m_strCommand = Command.m_strCommand;
        m_HistoryCommand[m_historyIndex-1].m_strName = Command.m_strName;
    }
    else{
        m_HistoryCommand[m_historyIndex].m_IsHex = Command.m_IsHex;
        m_HistoryCommand[m_historyIndex].m_isScript = Command.m_isScript;
        m_HistoryCommand[m_historyIndex].m_strCommand = Command.m_strCommand;
        m_HistoryCommand[m_historyIndex].m_strName = Command.m_strName;
        m_historyIndex++;
    }    
    return m_historyIndex;
    
}

int CMyCommDoc::GetHistoryIndex()
{
    return m_historyIndex;
}

// bool SendData(LPCTSTR lpszData, const int nLength)    - 串口发送函数
// int RecvData(LPTSTR lpszData, const int nSize)    - 串口接收函数
BOOL CMyCommDoc::SendByXmodem(LPCTSTR lpszData, const int nLength, const int nRetryTimes)
{
    char szPacket[XMODEM_BLOCK_HEAD_SIZE + XMODEM_BLOCK_NO_SIZE + 
          XMODEM_BLOCK_BODY_SIZE + XMODEM_BLOCK_CHK_SIZE];
    char szRecvBuff[128];
    char cPartNo = 0;
    char cChkSum = 0;
    int nRetry   = 0;
    int nTemp1, nTemp2;
    
    // Notify Destination of Data Transfer
    sprintf(szPacket, "%c", XMODEM_STA);
    m_Comm.SendData(szPacket, 1);
    Sleep(100);
    if (m_Comm.RecvData(szRecvBuff, sizeof(szRecvBuff)) && szRecvBuff[0] == XMODEM_NAK)
    {
        // Send Data
        for (nTemp1 = 0; nTemp1 < nLength; nTemp1 += XMODEM_BLOCK_BODY_SIZE)
        {

            //1.Make One Packet 
            memset(szPacket, NULL, sizeof(szPacket));
            if (cPartNo == 0xFF)
                cPartNo = 0;
            else
                cPartNo++;
            cChkSum = 0;
            szPacket[0] = XMODEM_SOH;
            szPacket[1] = cPartNo;
            szPacket[2] = 0xFF - cPartNo;
            for (nTemp2 = 0; nTemp2 < XMODEM_BLOCK_BODY_SIZE; nTemp2++)
            {
                if ((nTemp1 + nTemp2) < nLength)
                    szPacket[XMODEM_BLOCK_HEAD_SIZE + XMODEM_BLOCK_NO_SIZE + nTemp2] = *(lpszData + nTemp1 + nTemp2);
                else
                    szPacket[XMODEM_BLOCK_HEAD_SIZE + XMODEM_BLOCK_NO_SIZE + nTemp2] = XMODEM_EOF;
                cChkSum += szPacket[XMODEM_BLOCK_HEAD_SIZE + XMODEM_BLOCK_NO_SIZE + nTemp2];
            }
            szPacket[sizeof(szPacket) - 1] = cChkSum;

            //2.Send Packet
            m_Comm.SendData(szPacket, sizeof(szPacket));
            while (true)
            {
                Sleep(10);
                if (m_Comm.RecvData(szRecvBuff, sizeof(szRecvBuff)))
                {
                    // Affirmative Answer
                    if (szRecvBuff[0] == XMODEM_ACK)
                        break;
                    // Negative Answer
                    else
                        if (szRecvBuff[0] == XMODEM_NAK)
                        {
                            m_Comm.SendData(szPacket, sizeof(szPacket));
                            nRetry++;
                        }
                }
                if (nRetry >= nRetryTimes)
                {
                    // Cancel Transfer
                    sprintf(szPacket, "%c%c%c%c%c", XMODEM_CAN, XMODEM_CAN, XMODEM_CAN, XMODEM_CAN, XMODEM_CAN);
                    m_Comm.SendData(szPacket, 5);
                    return false;
                }
            }
        } // end form
    } //end if
    
    // Transfer Done
    sprintf(szPacket, "%c%c%c%c%c", XMODEM_EOT, XMODEM_EOT, XMODEM_EOT, XMODEM_EOT, XMODEM_EOT);
    m_Comm.SendData(szPacket, 5);
    return true;    
}
/////////////////////////////////////////////////////////////////////////////
// CMyCommDoc diagnostics

#ifdef _DEBUG
void CMyCommDoc::AssertValid() const
{
    CDocument::AssertValid();
}

void CMyCommDoc::Dump(CDumpContext& dc) const
{
    CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMyCommDoc commands