/******************************************************************************
|
*
|
* (C) Copyright WDI 2010
|
*
|
******************************************************************************
|
*
|
* FILE: epp.h
|
*
|
* PROJECT: AFT Sensors
|
*
|
* SUBPROJECT: .
|
*
|
* Description: Embedded part configuration protocol.
|
* Protocol design for accessing configuration of the part.
|
*
|
******************************************************************************
|
*
|
* Change Activity
|
* Defect Date Developer Description
|
* Number DD/MM/YYYY Name
|
* ======= ========== ================ =======================================
|
* 21/09/2009 Andrew L. Initial version
|
* 02/11/2010 Chris O.
|
* 15/11/2010 Chris O. Added synchronization objects for
|
* multithreaded applications
|
*
|
*****************************************************************************/
|
|
#pragma once
|
|
#include "atf_def.h"
|
|
#define DtTypeSize(dt) (((dt)&DtDataType)==DtDwordEnm ? 4 : (((dt)&DtDataType)>>4))
|
#define DtGetDataType(dt) ((dt)&DtDataType)
|
#define INVALID_IDX -1
|
|
typedef enum
|
{
|
ErrOK = 0,
|
ErrNoAccess = 1,
|
ErrWrongType = 2,
|
ErrOutOfBound = 3,
|
ErrInvalid = 4,
|
ErrUnavailable = 5,
|
ErrNotSupported = 6,
|
ErrSntaxError = 7,
|
ErrNoresources = 8,
|
ErrInternal = 9,
|
ErrOperFailed = 10,
|
ErrTimeout = 11,
|
ErrChksum = 12,
|
ErrUnknown
|
} EppErrorCodes;
|
|
#define ErrNamesTab const char * g_eppErrorNames[] = \
|
{ \
|
"0-ErrOK", \
|
"1-ErrNoAccess", \
|
"2-ErrWrongType", \
|
"3-ErrOutOfBound", \
|
"4-ErrInvalid", \
|
"5-ErrUnknown", \
|
"6-ErrNotSupported", \
|
"7-ErrSntaxError", \
|
"8-ErrNoresources", \
|
"9-ErrInternal", \
|
"10-ErrOperFailed", \
|
"11-ErrTimeout", \
|
"12-ErrChksum", \
|
"ErrUnknown" \
|
};
|
|
#ifdef __cplusplus
|
#include "tserial.h"
|
#include "logger.h"
|
|
typedef unsigned char Combuf_Char;
|
|
class CEpp : public Tserial
|
{
|
// communication buffer
|
enum { MAX_COM_BUFFER_SIZE = 5000 };
|
Combuf_Char* p_commBuff;
|
|
public:
|
// query code for data types
|
enum
|
{
|
QcParamInfo = 1,
|
QcParamName = 2,
|
QcParamComment = 3,
|
QcParamError = 4, // most recent error code visible on this parameter
|
QcReadTime = 5, // time in seconds parameter was read most recently
|
QcWriteTime = 6, // time in seconds parameter was written most recently
|
QcValueCurrent = 7,
|
QcValueMax = 8,
|
QcValueMin = 9,
|
QcValueSetDate = 10,
|
QcEnumValueExclusive = 11,
|
QcEnumValueCombined = 12,
|
QcEnumName = 13,
|
QcEnumAllParamInfo = 15,
|
};
|
// #define TagGetTag(tg) ((tg)&0xf)
|
|
|
// session commands
|
enum
|
{
|
SessionCmdRead = 'R',
|
SessionCmdWrite = 'W',
|
SessionCmdReadResponse = 'r',
|
};
|
// transport commands
|
enum
|
{
|
TransportCodingBinaryLittleEndian = 'l',
|
TransportCodingBinaryBigEndian = 'b',
|
TransportCodingAsciiStx = '<',
|
TransportCodingAsciiEtx = '>',
|
TransportAck = 'A',
|
TransportNak = 'N'
|
};
|
|
// com port timeouts for operations taking long period of time
|
enum
|
{
|
MicroStepTimeout = 10000,
|
MakeZeroTimeout = 6000,
|
SaveToSensorTimeout = 8000,
|
MagnifChangeTimeout = 1000,
|
MotorParamTimeout = 10000
|
};
|
|
#define EPPENTERFUN(funname) saveToLog2(CLogger::LogLow, "%s%s", funname, " - entered\n");
|
#define EPPEXITFUN(funname) saveToLog2(CLogger::LogLow, "%s%s", funname, " - exited\n");
|
#define EPPLOGMSG(pLogMsg, LogLev) saveToLog(pLogMsg, LogLev);
|
#define EPPLOGMSG2(LogLev, format, ...) saveToLog2(LogLev, format, __VA_ARGS__);
|
|
// constructor & destructor
|
CEpp () : Tserial(), m_pLogger(NULL), p_commBuff(NULL)
|
{
|
m_pFun = (ErrorFunctionPtr)0;
|
m_pFunLocale = 0;
|
InitializeCriticalSection(&m_cs);
|
}
|
CEpp (CLogger *pLogger) : Tserial(), p_commBuff(NULL)
|
{
|
m_pLogger = pLogger;
|
m_pFun = (ErrorFunctionPtr)0;
|
m_pFunLocale = 0;
|
InitializeCriticalSection(&m_cs);
|
}
|
|
~CEpp()
|
{
|
Close();
|
DeleteCriticalSection(&m_cs);
|
}
|
|
// serial port, communication
|
int Open (const char *port_arg, int rate_arg);
|
// close port
|
void Close ();
|
|
// reuse port that is already opened
|
void Attach (HANDLE h);
|
// leave handle opened, assuming someone else needs it
|
void Detach ();
|
|
typedef void (*ErrorFunctionPtr)(void* locale, bool bReading, EppErrorCodes err,int bid, int pid, EppDataType tag, int num, int offset);
|
private:
|
ErrorFunctionPtr m_pFun;
|
void* m_pFunLocale;
|
public:
|
void PrintfError (void* locale, bool bReading, EppErrorCodes err, int bid, int pid, EppDataType tag, int num, int offset);
|
|
void RegisterErrorFunction (ErrorFunctionPtr pFun, void* pFunLocale)
|
{
|
m_pFun = pFun;
|
m_pFunLocale = pFunLocale;
|
}
|
|
// ------- generic interface --------------------
|
static const char* errName (EppErrorCodes err);
|
|
// read the content of the element. returns ErrOK if all is fine, or other
|
// error otherwise
|
EppErrorCodes _ReadArray (void *to, int bid, int pid, EppDataType tag, int num = 1, int offset = 0);
|
EppErrorCodes ReadArray (void *to, int bid, int pid, EppDataType tag, int num = 1, int offset = 0)
|
{
|
EppErrorCodes err = _ReadArray (to, bid, pid, tag, num, offset);
|
if (serial_handle!=INVALID_HANDLE_VALUE && err!=ErrOK && err!=ErrUnavailable)
|
{
|
PrintfError(m_pFunLocale, true, err, bid, pid, tag, num, offset);
|
}
|
if (err==ErrOperFailed)
|
{
|
int bide = 0, pide = 0, err = 0;
|
if (ReadMostRecentRetcode (&bide, &pide, (EppErrorCodes*)(&err))==ErrOK)
|
{
|
EPPLOGMSG2(CLogger::LogAll, "%s%c%s%d%s%d%s",
|
"ATF Last Read Error: id=(", isalpha(bide) ? bide : '?', ", ", pide, ") Err=", err, ".\n");
|
}
|
}
|
return err;
|
}
|
// sets the value of the single element
|
EppErrorCodes _WriteArray (void *from, int bid, int pid, EppDataType tag, int num = 1, int offset = 0);
|
EppErrorCodes WriteArray (void *from, int bid, int pid, EppDataType tag, int num = 1, int offset = 0)
|
{
|
if (DtGetDataType(tag)==DtNoDataEnm)
|
{
|
num=0;
|
offset = 0;
|
}
|
EppErrorCodes err = _WriteArray (from, bid, pid, tag, num, offset);
|
if (serial_handle!=INVALID_HANDLE_VALUE && err!=ErrOK && err!=ErrUnavailable)
|
{
|
PrintfError(m_pFunLocale, false, err, bid, pid, tag, num, offset);
|
}
|
if (err==ErrOperFailed)
|
{
|
int bide = 0, pide = 0, err = 0;
|
if (ReadMostRecentRetcode (&bide, &pide, (EppErrorCodes*)(&err))==ErrOK)
|
{
|
EPPLOGMSG2(CLogger::LogAll, "%s%c%s%d%s%d%s",
|
"ATF Last Read Error: id=(", isalpha(bide) ? bide : '?', ", ", pide, ") Err=", err, ".\n");
|
}
|
/* * * * This is code sample for testing only
|
if (ReadIdError (bid, pid,(EppErrorCodes*)(&err))==ErrOK)
|
{
|
EPPLOGMSG2(CLogger::LogLow, "%s%c%s%d%s%d%s",
|
"ATF Last Write Error 2: id=(", isalpha(bide) ? bid : '?', ", ", pid, ") Err=", err, ".\n");
|
}
|
EppDataType tag;
|
int num;
|
int ver;
|
if (ReadIdCommInfo (bid, pid, &tag, &num, &ver)==ErrOK)
|
{
|
EPPLOGMSG2(CLogger::LogLow, "%s%c%s%d%s%d%s%d%s%d%s",
|
"ATF Last Write Error Tag: id=(", isalpha(bide) ? bid : '?', ", ", pid, "), tag=", tag, ", num=", num, ", ver=", ver, ".\n");
|
}
|
*/
|
}
|
return err;
|
}
|
|
typedef enum
|
{
|
IsEppVerUnknow = 0,
|
IsEppVerCheck = 1,
|
IsEppVerBasic = 2,
|
IsEppVerSupport = 3
|
} EppVer_Mode;
|
static EppVer_Mode s_m_ev; // epp protocol version
|
|
bool EppVerCheck();
|
|
// reads information describing the type of data used for particular communication register
|
inline EppErrorCodes ReadIdCommInfo (int bid, int pid, EppDataType *ptag, int *pnum, int *pversion)
|
{
|
short commTable[4];
|
|
if (!EppVerCheck()) return ErrNotSupported;
|
EppErrorCodes err = _ReadArray (commTable, bid, pid, (EppDataType)(QcParamInfo|DtWordEnm), 3, 0);
|
|
if (err==ErrOK)
|
{
|
*ptag = (EppDataType)(commTable[0]);
|
*pnum = commTable[1];
|
*pversion = commTable[2];
|
}
|
|
return err;
|
}
|
|
// reads most recent status returned with particular command
|
inline EppErrorCodes ReadIdError (int bid, int pid, EppErrorCodes* perr)
|
{
|
short commTable[4];
|
|
if (!EppVerCheck()) return ErrNotSupported;
|
EppErrorCodes err = _ReadArray (commTable, bid, pid, (EppDataType)(QcParamError|DtWordEnm), 1);
|
|
if (err==ErrOK)
|
{
|
*perr = (EppErrorCodes)(commTable[0]);
|
}
|
|
return err;
|
}
|
|
typedef struct // element describing most recent communication error
|
{
|
short iError; // error that has been reported addressing iMostRecentField
|
short iField; // field that had been addressed most recently
|
short iLen; // number of elements accessed in most recent command
|
short iOffset; // offset in most recent command
|
short iType; // type of the acecss and data field used in most recent command
|
} CommMostRecent;
|
|
// reads most recent return code assigned by sensor
|
inline EppErrorCodes ReadMostRecentRetcode (int *pbid, int *ppid, EppErrorCodes* perr)
|
{
|
CommMostRecent commErr;
|
|
if (!EppVerCheck()) return ErrNotSupported;
|
EppErrorCodes err = _ReadArray (&commErr, 's', 20, DtWordEnm, 2);
|
|
if (err==ErrOK)
|
{
|
*pbid = (commErr.iField >> 8) & 0xff;
|
*ppid = commErr.iField & 0xff;
|
*perr = (EppErrorCodes)(commErr.iError);
|
}
|
|
return err;
|
}
|
|
// restore communication.
|
// returns: 0-failed, 1-app running, 2-boot loader reset to app
|
int RecoverSensor();
|
|
// check for Ack character received from the other side
|
int PingAck();
|
|
// resets sensor
|
int Reset();
|
|
EppErrorCodes _ChangeCommTimeouts(DWORD dwTimeout);
|
EppErrorCodes _ResetCommTimeouts();
|
EppErrorCodes _ChangeCommBaudrate(DWORD dwBaudRate);
|
EppErrorCodes _GetCommBaudrate(DWORD *dwBaudrate);
|
inline bool isSerialConnection() {return serial_handle != INVALID_HANDLE_VALUE ? true : false; }
|
EppErrorCodes sendCmnd(Combuf_Char *pToSend, Combuf_Char *pToRecv = NULL, int iTimeout = 0, int iExpByteNum = 0);
|
|
// logging
|
CLogger *m_pLogger;
|
void saveToLog(const char *pLogMsg, CLogger::LogLevels iLogLevel);
|
void saveToLog2(CLogger::LogLevels iLogLevel, char *pFormat, ...);
|
inline void setLogger(CLogger *pLogger) { m_pLogger = pLogger; }
|
|
private:
|
CRITICAL_SECTION m_cs;
|
};
|
|
|
// simple critical section class
|
#ifndef __AFXMT_H__ // defined if MIcrosoft afxmt.h is included
|
class CCriticalSection
|
{
|
private:
|
CRITICAL_SECTION m_cs;
|
const bool m_bIsLocalCs;
|
public:
|
CCriticalSection() : m_bIsLocalCs(false) {
|
InitializeCriticalSection(&m_cs);
|
}
|
CCriticalSection(CRITICAL_SECTION &cs) : m_bIsLocalCs (true) {
|
m_cs = cs;
|
}
|
~CCriticalSection() {
|
if (m_bIsLocalCs) DeleteCriticalSection(&m_cs);
|
}
|
void Lock() {
|
EnterCriticalSection(&m_cs);
|
}
|
void Unlock() {
|
LeaveCriticalSection(&m_cs);
|
}
|
};
|
#endif
|
|
// this class maintains an array of CEpp objects and track availability in current thread
|
class CEppArr
|
{
|
public:
|
enum { MAX_EPP_NUM = 8 };
|
static CEpp gs_epp_arr[MAX_EPP_NUM]; // global table of CEpp
|
private:
|
static bool gs_epp_allocated_arr[MAX_EPP_NUM]; // indicate if object is already allocated
|
static CCriticalSection gs_cs; // to faciliate table identification
|
static __declspec( thread ) int gst_epp_index; // current index per thread
|
|
public:
|
static int Open (const char *port_arg, int rate_arg);
|
static void Close ();
|
|
static inline int SetCurrentEppIndex(int idx)
|
{
|
if (idx>=0
|
&& idx<MAX_EPP_NUM
|
&& gs_epp_allocated_arr[idx])
|
{
|
gst_epp_index = idx;
|
return ErrOK;
|
}
|
return ErrOperFailed;
|
}
|
static inline int GetCurrentEppIndex() { return gst_epp_index; }
|
static inline CEpp* Epp()
|
{
|
if (gst_epp_index>=0
|
&& gst_epp_index<MAX_EPP_NUM
|
&& gs_epp_allocated_arr[gst_epp_index])
|
{
|
return &gs_epp_arr[gst_epp_index];
|
}
|
else if (gst_epp_index==INVALID_IDX
|
&& gs_epp_allocated_arr[0]
|
&& !gs_epp_allocated_arr[1])
|
{
|
// we have 0 index used, while 1 is not and gst_epp_index was never set. This is
|
// a typical situation when thread other then one which opened com port
|
// is attempting to communicate and SetCurrentEppIndex() was not explicitly called.
|
// to make live easier lets do to here
|
gst_epp_index = 0;
|
return &gs_epp_arr[gst_epp_index];
|
}
|
return NULL;
|
}
|
};
|
|
// for compatibility with older code which is using a single thread single atf object
|
static CEpp& g_epp = CEppArr::gs_epp_arr[0];
|
|
#define CEPPARR_DECLARE_CURRENT_OR_RETURN \
|
CEpp *pEpp = CEppArr::Epp(); \
|
if (!pEpp) return ErrNoresources;
|
|
#define CEPPARR_DECLARE_CURRENT_OR_RETURN_BOOL \
|
CEpp *pEpp = CEppArr::Epp(); \
|
if (!pEpp) return false;
|
|
|
|
#endif // __cplusplus
|
