\section{CTCPIPConnector Klassenreferenz}
\label{classCTCPIPConnector}\index{CTCPIPConnector@{CTCPIPConnector}}
low level routine for fps - connector  


{\tt \#include $<$tcpipconnector.hpp$>$}

Klassendiagramm f\"{u}r CTCPIPConnector::\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=5cm]{classCTCPIPConnector}
\end{center}
\end{figure}
\subsection*{\"{O}ffentliche Methoden}
\begin{CompactItemize}
\item 
{\bf CTCPIPConnector} ()\label{classCTCPIPConnector_a0}

\begin{CompactList}\small\item\em initalize mutex for send\_\-data this ensures that only a data block will be sent at one time \item\end{CompactList}\item 
virtual {\bf $\sim$CTCPIPConnector} ()\label{classCTCPIPConnector_a1}

\begin{CompactList}\small\item\em frees the mutex handle for send data \item\end{CompactList}\item 
virtual bool {\bf initialize} (const short TCPport, const char $\ast$p\-IPAddress)
\begin{CompactList}\small\item\em initialize connection to the gateway \item\end{CompactList}\item 
bool {\bf Read\-Eeprom\-Data} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em send a read eeprom request \item\end{CompactList}\item 
bool {\bf Send\-Read\-Eeprom\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em send a read eeprom confirmation \item\end{CompactList}\item 
bool {\bf Read\-Program\-Data} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em send a read program memory request \item\end{CompactList}\item 
bool {\bf Send\-Read\-Program\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em send a read program confirmation \item\end{CompactList}\item 
bool {\bf Read\-Ram\-Data} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em send a read ram request \item\end{CompactList}\item 
bool {\bf Send\-Read\-Ram\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em send a read ram confirmation \item\end{CompactList}\item 
bool {\bf Write\-Eeprom\-Data} (ADDRESS\_\-TYPE n\-Address, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em send a write eeprom request \item\end{CompactList}\item 
bool {\bf Send\-Write\-Eeprom\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em send a write eeprom confirmation \item\end{CompactList}\item 
bool {\bf Write\-Program\-Data} (ADDRESS\_\-TYPE n\-Address, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em send a write program memory request \item\end{CompactList}\item 
bool {\bf Send\-Write\-Program\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em send a write program memory confirmation \item\end{CompactList}\item 
bool {\bf Write\-Ram\-Data} (ADDRESS\_\-TYPE n\-Address, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em send a write ram request \item\end{CompactList}\item 
bool {\bf Send\-Write\-Ram\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em send a write ram confirmation \item\end{CompactList}\item 
bool {\bf Send\-Status\-Info} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, std::vector$<$ unsigned char $>$ auc\-Data)
\begin{CompactList}\small\item\em send a status information command \item\end{CompactList}\item 
bool {\bf terminate} (void)
\begin{CompactList}\small\item\em close the current connection \item\end{CompactList}\item 
{\bf CCOMConnector} $\ast$ {\bf Get\-COMPort} (void) const
\begin{CompactList}\small\item\em get access to the associated COM port \item\end{CompactList}\item 
void {\bf Set\-COMPort} ({\bf CCOMConnector} $\ast$p\-Msg)
\begin{CompactList}\small\item\em Set associated COM port parameters. \item\end{CompactList}\item 
bool {\bf Is\-Connected} (void) const
\begin{CompactList}\small\item\em Is\-Connected returns the connection state of the connection. \item\end{CompactList}\end{CompactItemize}
\subsection*{Gesch\"{u}tzte Methoden}
\begin{CompactItemize}
\item 
void {\bf Receive} (void $\ast$p\-Data, long Data\-Len)
\begin{CompactList}\small\item\em implemented pure virtual function from CTCPIPReceive \item\end{CompactList}\item 
virtual void {\bf Read\-Eeprom\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)=0
\begin{CompactList}\small\item\em this function will be called if a read eeprom request was received \item\end{CompactList}\item 
virtual void {\bf Read\-Program\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)=0
\begin{CompactList}\small\item\em this function will be called if a read program request was received \item\end{CompactList}\item 
virtual void {\bf Read\-Ram\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)=0
\begin{CompactList}\small\item\em this function will be called if a read ram request was received \item\end{CompactList}\item 
virtual void {\bf Write\-Eeprom\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)=0
\begin{CompactList}\small\item\em this function will be called if a write eeprom request was received \item\end{CompactList}\item 
virtual void {\bf Write\-Program\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)=0
\begin{CompactList}\small\item\em this function will be called if a write program request was received \item\end{CompactList}\item 
virtual void {\bf Write\-Ram\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)=0
\begin{CompactList}\small\item\em this function will be called if a write ram request was received \item\end{CompactList}\item 
virtual void {\bf Read\-Eeprom\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)=0
\begin{CompactList}\small\item\em this function will be called if a read eeprom confirmation was received \item\end{CompactList}\item 
virtual void {\bf Read\-Program\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)=0
\begin{CompactList}\small\item\em this function will be called if a read program confirmation was received \item\end{CompactList}\item 
virtual void {\bf Read\-Ram\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)=0
\begin{CompactList}\small\item\em this function will be called if a read ram confirmation was received \item\end{CompactList}\item 
virtual void {\bf Write\-Eeprom\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)=0
\begin{CompactList}\small\item\em this function will be called if a write eeprom confirmation was received \item\end{CompactList}\item 
virtual void {\bf Write\-Program\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)=0
\begin{CompactList}\small\item\em this function will be called if a write program confirmation was received \item\end{CompactList}\item 
virtual void {\bf Write\-Ram\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)=0
\begin{CompactList}\small\item\em this function will be called if a write ram confirmation was received \item\end{CompactList}\item 
virtual void {\bf Status\-Info} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)=0
\begin{CompactList}\small\item\em this function will be called if a status information was received \item\end{CompactList}\item 
void {\bf Set\-Use\-Crc\-Check} (const bool b\-Use\-Crc)
\begin{CompactList}\small\item\em set use of crc check while receiving data \item\end{CompactList}\item 
bool {\bf Get\-Use\-Crc\-Check} (void) const
\begin{CompactList}\small\item\em Gives the crc check flag back. \item\end{CompactList}\end{CompactItemize}
\subsection*{Gesch\"{u}tzte Attribute}
\begin{CompactItemize}
\item 
bool {\bf m\_\-b\-Rcv\-Raw\-Data}\label{classCTCPIPConnector_p0}

\item 
bool {\bf m\_\-b\-Rcv\-Raw\-Data\-Finished}\label{classCTCPIPConnector_p1}

\item 
char {\bf m\_\-s\-Rcv\-Raw\-Data\-String} [200]\label{classCTCPIPConnector_p2}

\end{CompactItemize}
\subsection*{Private Methoden}
\begin{CompactItemize}
\item 
void {\bf Call\-Message\-Func} (const {\bf CCommandstring} \&o\-Commandstring)
\begin{CompactList}\small\item\em call the function corresponding to the overgiven commasn block \item\end{CompactList}\item 
bool {\bf send\_\-data} ({\bf CCommandstring::Cmd\-Code} Command, ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em sends the overgiven command to the fps \item\end{CompactList}\end{CompactItemize}
\subsection*{Private Attribute}
\begin{CompactItemize}
\item 
{\bf CStatemaschine} {\bf m\_\-o\-Statemaschine}\label{classCTCPIPConnector_r0}

\begin{CompactList}\small\item\em statemaschine to handle command blocks \item\end{CompactList}\item 
std::vector$<$ unsigned char $>$ {\bf m\_\-auc\-Received\-Data}\label{classCTCPIPConnector_r1}

\begin{CompactList}\small\item\em received data \item\end{CompactList}\item 
HANDLE {\bf m\_\-h\-Send\-Block}\label{classCTCPIPConnector_r2}

\begin{CompactList}\small\item\em Mutex. Lock to ensure that only one command string will be send at a time. \item\end{CompactList}\item 
bool {\bf m\_\-b\-Use\-Crc\-Check}\label{classCTCPIPConnector_r3}

\begin{CompactList}\small\item\em flag : true = use crc check while receiving data \item\end{CompactList}\item 
{\bf CCOMConnector} $\ast$ {\bf m\_\-p\-COMPort}\label{classCTCPIPConnector_r4}

\begin{CompactList}\small\item\em use a direct COM port connection for FPS access \item\end{CompactList}\end{CompactItemize}


\subsection{Ausf\"{u}hrliche Beschreibung}
low level routine for fps - connector 

\begin{Desc}
\item[Zu beachten:]you have to write a class inheriting these class. In the new class you must implement the following pure virtual functions :\par
\par
 virtual void Read\-Eeprom\-Data\-Req( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length )= 0;\par
 \par
 virtual void Read\-Program\-Data\-Req( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length )= 0;\par
 \par
 virtual void Read\-Ram\-Data\-Req( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length )= 0;\par
 \par
 virtual void Write\-Eeprom\-Data\-Req( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length,\par
 const std::vector$<$unsigned char$>$\& auc\-Data )= 0;\par
 \par
 virtual void Write\-Program\-Data\-Req( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length,\par
 const std::vector$<$unsigned char$>$\& auc\-Data )= 0;\par
 \par
 virtual void Write\-Ram\-Data\-Req( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length,\par
 const std::vector$<$unsigned char$>$\& auc\-Data )= 0;\par
 \par
 virtual void Read\-Eeprom\-Data\-Cnf( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length,\par
 const std::vector$<$unsigned char$>$\& auc\-Data )= 0;\par
 \par
 virtual void Read\-Program\-Data\-Cnf( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length,\par
 const std::vector$<$unsigned char$>$\& auc\-Data )= 0;\par
 \par
 virtual void Read\-Ram\-Data\-Cnf( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length,\par
 const std::vector$<$unsigned char$>$\& auc\-Data )= 0;\par
 \par
 virtual void Write\-Eeprom\-Data\-Cnf( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length )= 0;\par
 \par
 virtual void Write\-Program\-Data\-Cnf( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length )= 0;\par
 \par
 virtual void Write\-Ram\-Data\-Cnf( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length )= 0;\par
 \par
 virtual void Status\-Info( ADDRESS\_\-TYPE n\-Address,\par
 unsigned int ui\-Length,\par
 const std::vector$<$unsigned char$>$\& auc\-Data )= 0;\par
\par
\end{Desc}
These functions will be called if a appriviate command block is received

\begin{Desc}
\item[Version:]1.0 \end{Desc}
\begin{Desc}
\item[Autor:]Ingo Fr\"{o}hlich \end{Desc}




\subsection{Dokumentation der Elementfunktionen}
\index{CTCPIPConnector@{CTCPIPConnector}!CallMessageFunc@{CallMessageFunc}}
\index{CallMessageFunc@{CallMessageFunc}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void CTCPIPConnector::Call\-Message\-Func (const {\bf CCommandstring} \& {\em o\-Commandstring})\hspace{0.3cm}{\tt  [private]}}\label{classCTCPIPConnector_d0}


call the function corresponding to the overgiven commasn block 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em command}]string \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!GetCOMPort@{GetCOMPort}}
\index{GetCOMPort@{GetCOMPort}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CCOMConnector}$\ast$ CTCPIPConnector::Get\-COMPort (void) const\hspace{0.3cm}{\tt  [inline]}}\label{classCTCPIPConnector_a17}


get access to the associated COM port 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]pointer to COM port class (is NULL, if communication via TCP/Modem) \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!GetUseCrcCheck@{GetUseCrcCheck}}
\index{GetUseCrcCheck@{GetUseCrcCheck}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Get\-Use\-Crc\-Check (void) const\hspace{0.3cm}{\tt  [protected]}}\label{classCTCPIPConnector_b15}


Gives the crc check flag back. 

\begin{Desc}
\item[R\"{u}ckgabe:]true: use crc check \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!initialize@{initialize}}
\index{initialize@{initialize}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::initialize (const short {\em TCPport}, const char $\ast$ {\em p\-IPAddress})\hspace{0.3cm}{\tt  [virtual]}}\label{classCTCPIPConnector_a2}


initialize connection to the gateway 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em portnumber}]\item[{\em ip-address}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true connection established \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!IsConnected@{IsConnected}}
\index{IsConnected@{IsConnected}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Is\-Connected (void) const}\label{classCTCPIPConnector_a19}


Is\-Connected returns the connection state of the connection. 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em -}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true if connection established, otherwise false \end{Desc}


Erneute Implementation von {\bf CTCPIPComm} {\rm (S.\,\pageref{classCTCPIPComm_a3})}.\index{CTCPIPConnector@{CTCPIPConnector}!ReadEepromData@{ReadEepromData}}
\index{ReadEepromData@{ReadEepromData}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Read\-Eeprom\-Data (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})}\label{classCTCPIPConnector_a3}


send a read eeprom request 

use this function to read data from the eeprom of the fps \begin{Desc}
\item[Zu beachten:]use Wait\-For\-Data to wait for the confirmation with the wanted data\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]to start reading \item[{\em number}]of bytes to read \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!ReadEepromDataCnf@{ReadEepromDataCnf}}
\index{ReadEepromDataCnf@{ReadEepromDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Read\-Eeprom\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b7}


this function will be called if a read eeprom confirmation was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \item[{\em received}]data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d12})}.\index{CTCPIPConnector@{CTCPIPConnector}!ReadEepromDataReq@{ReadEepromDataReq}}
\index{ReadEepromDataReq@{ReadEepromDataReq}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Read\-Eeprom\-Data\-Req (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b1}


this function will be called if a read eeprom request was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d6})}.\index{CTCPIPConnector@{CTCPIPConnector}!ReadProgramData@{ReadProgramData}}
\index{ReadProgramData@{ReadProgramData}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Read\-Program\-Data (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})}\label{classCTCPIPConnector_a5}


send a read program memory request 

use this function to read data from the program memory of the fps \begin{Desc}
\item[Zu beachten:]use Wait\-For\-Data to wait for the confirmation with the wanted data\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]to start reading \item[{\em number}]of bytes to read \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!ReadProgramDataCnf@{ReadProgramDataCnf}}
\index{ReadProgramDataCnf@{ReadProgramDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Read\-Program\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b8}


this function will be called if a read program confirmation was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \item[{\em received}]data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d13})}.\index{CTCPIPConnector@{CTCPIPConnector}!ReadProgramDataReq@{ReadProgramDataReq}}
\index{ReadProgramDataReq@{ReadProgramDataReq}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Read\-Program\-Data\-Req (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b2}


this function will be called if a read program request was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d7})}.\index{CTCPIPConnector@{CTCPIPConnector}!ReadRamData@{ReadRamData}}
\index{ReadRamData@{ReadRamData}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Read\-Ram\-Data (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})}\label{classCTCPIPConnector_a7}


send a read ram request 

use this function to read data from the ram of the fps \begin{Desc}
\item[Zu beachten:]use Wait\-For\-Data to wait for the confirmation with the wanted data\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]to start reading \item[{\em number}]of bytes to read \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!ReadRamDataCnf@{ReadRamDataCnf}}
\index{ReadRamDataCnf@{ReadRamDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Read\-Ram\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b9}


this function will be called if a read ram confirmation was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \item[{\em received}]data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d14})}.\index{CTCPIPConnector@{CTCPIPConnector}!ReadRamDataReq@{ReadRamDataReq}}
\index{ReadRamDataReq@{ReadRamDataReq}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Read\-Ram\-Data\-Req (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b3}


this function will be called if a read ram request was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d8})}.\index{CTCPIPConnector@{CTCPIPConnector}!Receive@{Receive}}
\index{Receive@{Receive}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void CTCPIPConnector::Receive (void $\ast$ {\em p\-Data}, long {\em Data\-Len})\hspace{0.3cm}{\tt  [protected, virtual]}}\label{classCTCPIPConnector_b0}


implemented pure virtual function from CTCPIPReceive 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em pointer}]to buffer to store received data in \item[{\em length}]( in bytes ) of the buffer \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPComm\-Receive} {\rm (S.\,\pageref{classCTCPIPCommReceive_b0})}.\index{CTCPIPConnector@{CTCPIPConnector}!send_data@{send\_\-data}}
\index{send_data@{send\_\-data}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::send\_\-data ({\bf CCommandstring::Cmd\-Code} {\em Command}, ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})\hspace{0.3cm}{\tt  [private]}}\label{classCTCPIPConnector_d1}


sends the overgiven command to the fps 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em command}]code of the command to send \item[{\em address}]in fps \item[{\em length}]of the data to be readed or written \item[{\em the}]data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true data was sent correctly \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!SendReadEepromDataCnf@{SendReadEepromDataCnf}}
\index{SendReadEepromDataCnf@{SendReadEepromDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Send\-Read\-Eeprom\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})}\label{classCTCPIPConnector_a4}


send a read eeprom confirmation 

\begin{Desc}
\item[Zu beachten:]use this function to simulate the reaction of a fps device\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em confirmed}]address \item[{\em readed}]data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!SendReadProgramDataCnf@{SendReadProgramDataCnf}}
\index{SendReadProgramDataCnf@{SendReadProgramDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Send\-Read\-Program\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})}\label{classCTCPIPConnector_a6}


send a read program confirmation 

\begin{Desc}
\item[Zu beachten:]use this function to simulate the reaction of a fps device\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em confirmed}]address \item[{\em readed}]data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!SendReadRamDataCnf@{SendReadRamDataCnf}}
\index{SendReadRamDataCnf@{SendReadRamDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Send\-Read\-Ram\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})}\label{classCTCPIPConnector_a8}


send a read ram confirmation 

\begin{Desc}
\item[Zu beachten:]use this function to simulate the reaction of a fps device\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em confirmed}]address \item[{\em readed}]data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!SendStatusInfo@{SendStatusInfo}}
\index{SendStatusInfo@{SendStatusInfo}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Send\-Status\-Info (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, std::vector$<$ unsigned char $>$ {\em auc\-Data})}\label{classCTCPIPConnector_a15}


send a status information command 

\begin{Desc}
\item[Zu beachten:]use this function to simulate the reaction of a fps device. These command will be sent by a fps device during startup and in case of an error\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em confirmed}]address \item[{\em length}]of \char`\"{}written\char`\"{} data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!SendWriteEepromDataCnf@{SendWriteEepromDataCnf}}
\index{SendWriteEepromDataCnf@{SendWriteEepromDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Send\-Write\-Eeprom\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})}\label{classCTCPIPConnector_a10}


send a write eeprom confirmation 

\begin{Desc}
\item[Zu beachten:]use this function to simulate the reaction of a fps device\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em confirmed}]address \item[{\em length}]of \char`\"{}written\char`\"{} data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!SendWriteProgramDataCnf@{SendWriteProgramDataCnf}}
\index{SendWriteProgramDataCnf@{SendWriteProgramDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Send\-Write\-Program\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})}\label{classCTCPIPConnector_a12}


send a write program memory confirmation 

\begin{Desc}
\item[Zu beachten:]use this function to simulate the reaction of a fps device\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em confirmed}]address \item[{\em length}]of \char`\"{}written\char`\"{} data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!SendWriteRamDataCnf@{SendWriteRamDataCnf}}
\index{SendWriteRamDataCnf@{SendWriteRamDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Send\-Write\-Ram\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})}\label{classCTCPIPConnector_a14}


send a write ram confirmation 

\begin{Desc}
\item[Zu beachten:]use this function to simulate the reaction of a fps device\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em confirmed}]address \item[{\em length}]of \char`\"{}written\char`\"{} data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!SetCOMPort@{SetCOMPort}}
\index{SetCOMPort@{SetCOMPort}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void CTCPIPConnector::Set\-COMPort ({\bf CCOMConnector} $\ast$ {\em p\-Msg})\hspace{0.3cm}{\tt  [inline]}}\label{classCTCPIPConnector_a18}


Set associated COM port parameters. 

Use this if not the standard communication via TCP/Modem is to be used. Uses a direct communictaion via serial port. \begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em pointer}]to COM port class or NULL for TCP/Modem communication \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!SetUseCrcCheck@{SetUseCrcCheck}}
\index{SetUseCrcCheck@{SetUseCrcCheck}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void CTCPIPConnector::Set\-Use\-Crc\-Check (const bool {\em b\-Use\-Crc})\hspace{0.3cm}{\tt  [protected]}}\label{classCTCPIPConnector_b14}


set use of crc check while receiving data 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em true}]: use crc check \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!StatusInfo@{StatusInfo}}
\index{StatusInfo@{StatusInfo}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Status\-Info (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b13}


this function will be called if a status information was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \item[{\em received}]data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d18})}.\index{CTCPIPConnector@{CTCPIPConnector}!terminate@{terminate}}
\index{terminate@{terminate}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::terminate (void)}\label{classCTCPIPConnector_a16}


close the current connection 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation was successfull \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!WriteEepromData@{WriteEepromData}}
\index{WriteEepromData@{WriteEepromData}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Write\-Eeprom\-Data (ADDRESS\_\-TYPE {\em n\-Address}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})}\label{classCTCPIPConnector_a9}


send a write eeprom request 

use this function to write data to the eeprom of the fps \begin{Desc}
\item[Zu beachten:]use Wait\-For\-Data to wait for the confirmation\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]to start writing \item[{\em number}]of bytes to write \item[{\em data}]to write \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!WriteEepromDataCnf@{WriteEepromDataCnf}}
\index{WriteEepromDataCnf@{WriteEepromDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Write\-Eeprom\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b10}


this function will be called if a write eeprom confirmation was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d15})}.\index{CTCPIPConnector@{CTCPIPConnector}!WriteEepromDataReq@{WriteEepromDataReq}}
\index{WriteEepromDataReq@{WriteEepromDataReq}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Write\-Eeprom\-Data\-Req (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b4}


this function will be called if a write eeprom request was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \item[{\em received}]data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d9})}.\index{CTCPIPConnector@{CTCPIPConnector}!WriteProgramData@{WriteProgramData}}
\index{WriteProgramData@{WriteProgramData}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Write\-Program\-Data (ADDRESS\_\-TYPE {\em n\-Address}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})}\label{classCTCPIPConnector_a11}


send a write program memory request 

use this function to write data to the program memory of the fps \begin{Desc}
\item[Zu beachten:]use Wait\-For\-Data to wait for the confirmation\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]to start writing \item[{\em number}]of bytes to write \item[{\em data}]to write \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!WriteProgramDataCnf@{WriteProgramDataCnf}}
\index{WriteProgramDataCnf@{WriteProgramDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Write\-Program\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b11}


this function will be called if a write program confirmation was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d16})}.\index{CTCPIPConnector@{CTCPIPConnector}!WriteProgramDataReq@{WriteProgramDataReq}}
\index{WriteProgramDataReq@{WriteProgramDataReq}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Write\-Program\-Data\-Req (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b5}


this function will be called if a write program request was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \item[{\em received}]data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d10})}.\index{CTCPIPConnector@{CTCPIPConnector}!WriteRamData@{WriteRamData}}
\index{WriteRamData@{WriteRamData}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool CTCPIPConnector::Write\-Ram\-Data (ADDRESS\_\-TYPE {\em n\-Address}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})}\label{classCTCPIPConnector_a13}


send a write ram request 

use this function to write data to the ram of the fps \begin{Desc}
\item[Zu beachten:]use Wait\-For\-Data to wait for the confirmation\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]to start writing \item[{\em number}]of bytes to write \item[{\em data}]to write \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true request was sent successfully \end{Desc}
\index{CTCPIPConnector@{CTCPIPConnector}!WriteRamDataCnf@{WriteRamDataCnf}}
\index{WriteRamDataCnf@{WriteRamDataCnf}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Write\-Ram\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b12}


this function will be called if a write ram confirmation was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d17})}.\index{CTCPIPConnector@{CTCPIPConnector}!WriteRamDataReq@{WriteRamDataReq}}
\index{WriteRamDataReq@{WriteRamDataReq}!CTCPIPConnector@{CTCPIPConnector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void CTCPIPConnector::Write\-Ram\-Data\-Req (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classCTCPIPConnector_b6}


this function will be called if a write ram request was received 

\begin{Desc}
\item[Zu beachten:]because this is a pure virtual function you have to implement the function by yourself\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address \item[{\em received}]data length \item[{\em received}]data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert in {\bf Cfps} {\rm (S.\,\pageref{classCfps_d11})}.

Die Dokumentation f\"{u}r diese Klasse wurde erzeugt aufgrund der Dateien:\begin{CompactItemize}
\item 
tcpipconnector.hpp\item 
tcpipconnector.cpp\end{CompactItemize}
