\section{Cfps Klassenreferenz}
\label{classCfps}\index{Cfps@{Cfps}}
contains all functions working with the fps  


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

Klassendiagramm f\"{u}r Cfps::\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=5cm]{classCfps}
\end{center}
\end{figure}
\subsection*{\"{O}ffentliche Typen}
\begin{CompactItemize}
\item 
enum {\bf VERBINDUNG} \{ {\bf MODEM}, 
{\bf NETZWERK}, 
{\bf RS232}
 \}
\begin{CompactList}\small\item\em possible types of connection \item\end{CompactList}\item 
enum {\bf CONVERT\_\-TO} \{ {\bf SPEC}, 
{\bf MV}, 
{\bf MM}
 \}
\begin{CompactList}\small\item\em possible working units \item\end{CompactList}\end{CompactItemize}
\subsection*{\"{O}ffentliche Methoden}
\begin{CompactItemize}
\item 
{\bf Cfps} ()
\begin{CompactList}\small\item\em Create the required Events ( use for synchronization with the receive thread ). \item\end{CompactList}\item 
virtual {\bf $\sim$Cfps} ()\label{classCfps_a1}

\begin{CompactList}\small\item\em Closed Handles for Events ( use for synchronization with the receive thread ). \item\end{CompactList}\item 
{\bf VERBINDUNG} {\bf Get\-Current\-Connection\-Type} (void) const
\item 
void {\bf Set\-Current\-Connection\-Type} (const {\bf VERBINDUNG} e\-New\-Connection\-Type)
\item 
void {\bf Get\-Callnumber} (char $\ast$pc\-Callnumber, unsigned int uc\-Buf\-Len)
\begin{CompactList}\small\item\em delivers the current number to call by a modem \item\end{CompactList}\item 
void {\bf Set\-Callnumber} (char $\ast$pc\-New\-Callnumber)
\begin{CompactList}\small\item\em sets the current number to call by a modem \item\end{CompactList}\item 
bool {\bf Get\-Operating\-State} (int \&Flags)
\begin{CompactList}\small\item\em delivers the current operation flags \par
\par
 structure : \par
\par
 bit meaning \par
\par
 0 switch between operation mode ( 0 = Bereich, 1 = Schaltpunkt ) \par
 1 --- \par
 2 --- \par
 3 --- \par
 4 --- \par
 5 Update : ( set by fps device when sampling finished ) \par
 6 Record : start sampling if bit set \par
 7 Re\-Calc : transfer values from fps input buffer to fps work buffer \par
 \item\end{CompactList}\item 
bool {\bf Set\-Operating\-State} (int Flags)
\begin{CompactList}\small\item\em Sets the current operating state ( see Get\-Operation\-State for details ). \item\end{CompactList}\item 
bool {\bf Read\-Sensor} ({\bf SENSOR\_\-TYPE} \&Current\-Sensor\-Values)
\begin{CompactList}\small\item\em Delivers the current values in the fps input buffer into the overgiven structure of type {\bf SENSOR\_\-TYPE}{\rm (S.\,\pageref{structSENSOR__TYPE})} \par
\par
 structure of {\bf SENSOR\_\-TYPE}{\rm (S.\,\pageref{structSENSOR__TYPE})} ( defined in the file {\bf fps.hpp}{\rm (S.\,\pageref{fps_8hpp})} ) \par
\par
 struct {\bf SENSOR\_\-TYPE}{\rm (S.\,\pageref{structSENSOR__TYPE})}\par
 \{\par
 int open; value which means state AUF ( open )\par
 int c; \char`\"{}     \char`\"{} \char`\"{}     \char`\"{} C\par
 int b; \char`\"{}     \char`\"{} \char`\"{}     \char`\"{} B\par
 int a; \char`\"{}     \char`\"{} \char`\"{}     \char`\"{} A\par
 int closed; \char`\"{}     \char`\"{} \char`\"{}     \char`\"{} ZU ( closed )\par
 \};. \item\end{CompactList}\item 
bool {\bf Write\-Sensor} ({\bf SENSOR\_\-TYPE} New\-Sensor\-Values)
\begin{CompactList}\small\item\em Writes the overgiven values into the fps input buffer ( see Read\-Sensor for details ). \item\end{CompactList}\item 
bool {\bf Read\-Interpolated\-Sensor} ({\bf SENSOR\_\-TYPE} \&Current\-Sensor\-Values)
\begin{CompactList}\small\item\em Read in the fps working buffer ( see Read\-Sensor for more details ). \item\end{CompactList}\item 
bool {\bf Get\-Out\-Of\-Range\-Flags} (int \&Flags)
\begin{CompactList}\small\item\em delivers the \char`\"{}out of range\char`\"{} flags\par
 \par
 structure\par
 \par
 bit meaning ( if set )\par
 \par
 0 Unterspannung ( low voltage )\par
 1 \"{U}berspannung ( high voltage )\par
 2 Untertemperatur ( low temperature )\par
 3 \"{U}bertemperatur ( high temperature )\par
 4 ---\par
 5 ---\par
 6 ---\par
 7 ---\par
 \item\end{CompactList}\item 
bool {\bf Fetch\-Stuetz\-Array\-From\-Fps} (void)
\begin{CompactList}\small\item\em delivers the stored stuetzstellen ( data points ) from the fps device the read in values are stored in the {\bf CFps\-Convert}{\rm (S.\,\pageref{classCFpsConvert})} class, so you can do some converting right after this \item\end{CompactList}\item 
bool {\bf Store\-Stuetz\-Array\-In\-Fps} (void)
\begin{CompactList}\small\item\em stores the current used stuetzstellen ( data points ) into the fps device \item\end{CompactList}\item 
void {\bf Get\-Tolerance} (float \&f\-Unter\-Tolerance, float \&f\-Ueber\-Tolerance)
\begin{CompactList}\small\item\em read in the tolerance values ( this value is stored in the fps in the place of the last stuetzstelle \item\end{CompactList}\item 
void {\bf Save\-Tolerance} (float f\-Unter\-Tolerance, float f\-Ueber\-Tolerance)
\begin{CompactList}\small\item\em saves the tolance value in the fps ( this value is stored in the place of the last stuetzstelle \item\end{CompactList}\item 
bool {\bf Get\-Sensor\-Samples} (float Sen\-Samp[640], unsigned int ui\-Begin=0, unsigned int ui\-Length=640)
\begin{CompactList}\small\item\em delivers the sample of sensor data from the last sampling ( see Get\-Operating\-State for more details ) \item\end{CompactList}\item 
bool {\bf Get\-Voltage\-Samples} (float Voltage\-Sample[640], unsigned int ui\-Begin=0, unsigned int ui\-Length=640)
\begin{CompactList}\small\item\em delivers the sample of voltage data from the last sampling ( see Get\-Operating\-State for more details ) \item\end{CompactList}\item 
bool {\bf Get\-Port\-BSamples} (int Port\-BSample[640], unsigned int ui\-Begin=0, unsigned int ui\-Length=640)
\begin{CompactList}\small\item\em delivers the sample of Port\-B data from the last sampling ( see Get\-Current\-State for more details ) \item\end{CompactList}\item 
bool {\bf Get\-Current\-Sensor\-Value} (float \&Cur\-Sen, {\bf CONVERT\_\-TO} e\-Convert\-To=SPEC)
\begin{CompactList}\small\item\em delivers the current sensor value \item\end{CompactList}\item 
bool {\bf Get\-Current\-Voltage} (float \&Cur\-Operating\-Voltage)
\begin{CompactList}\small\item\em delivers the current voltage of the fps device ( in m\-V ) \item\end{CompactList}\item 
bool {\bf Get\-Current\-Temperature} (float \&Current\-Temperature)
\begin{CompactList}\small\item\em delivers the current temperature of the fps device ( in 176C ) \item\end{CompactList}\item 
bool {\bf Get\-Port\-B} (int \&Flags)
\begin{CompactList}\small\item\em delivers the current state of the fps device\par
 \par
 bit meaning\par
 0 ---\par
 1 ---\par
 2 ---\par
 3 offen ( open )\par
 4 C\par
 5 B\par
 6 A\par
 7 zu ( closed )\par
 8 ---\par
 9 ---\par
 10 ---\par
 11 ---\par
 12 ---\par
 13 ---\par
 14 ---\par
 15 ---\par
 \item\end{CompactList}\item 
bool {\bf Start\-Sampling} (void)
\begin{CompactList}\small\item\em starts the sampling of sensor, voltage and portb data a value will be measured every 30 milliseconds 640 measures will be taken at all \item\end{CompactList}\item 
bool {\bf Is\-Sampling\-Done} (bool \&b\-Done)
\begin{CompactList}\small\item\em tests if the sampling is already done \item\end{CompactList}\item 
bool {\bf Reset\-Ex} (void)
\begin{CompactList}\small\item\em resets the Out\-Of\-Range\-Flags writes back the week and year of the production of the fps devise and their serial number \item\end{CompactList}\item 
bool {\bf Get\-Service\-Info} (int \&Week, int \&Year, int \&Serialnumber)
\begin{CompactList}\small\item\em delivers the week and year of the production of the fps device and their serialnumber \item\end{CompactList}\item 
bool {\bf Password\-Login} (char $\ast$sz\-Ip\-Address, char $\ast$sz\-Password, unsigned int ui\-Base\-Port, unsigned int ui\-Portnumber)
\begin{CompactList}\small\item\em handle the password login use the routine to connect to a password protected gateway \item\end{CompactList}\item 
void {\bf Get\-Call\-Number} (char $\ast$pc\-Call\-Number, unsigned int ui\-Buf\-Len)
\begin{CompactList}\small\item\em delivers the currently used call number for a modem connection \item\end{CompactList}\item 
void {\bf Set\-Call\-Number} (char $\ast$pc\-New\-Call\-Number)
\begin{CompactList}\small\item\em sets the currently used call number for a modem connection \item\end{CompactList}\item 
bool {\bf Init\-Modem} (void)
\begin{CompactList}\small\item\em connect to modem \item\end{CompactList}\item 
virtual bool {\bf initialize} (void)
\begin{CompactList}\small\item\em init socket connection \item\end{CompactList}\item 
void {\bf Get\-Modem\-Init\-String} (char $\ast$pc\-Modem\-Init\-String, unsigned int Buf\-Len)
\begin{CompactList}\small\item\em delivers the string which will be send to modem for initializing ( at commands ) \item\end{CompactList}\item 
void {\bf Set\-Modem\-Init\-String} (char $\ast$pc\-New\-Modem\-Init\-String)
\begin{CompactList}\small\item\em sets the string which will be send to modem for initializing ( at commands ) \item\end{CompactList}\item 
void {\bf Get\-Modem\-Dial\-String} (char $\ast$pc\-Modem\-Dial\-String, unsigned int Buf\-Len)
\begin{CompactList}\small\item\em delivers the string which will be send to modem for dialing ( at commands ) \item\end{CompactList}\item 
void {\bf Set\-Modem\-Dial\-String} (char $\ast$pc\-New\-Modem\-Dial\-String)
\begin{CompactList}\small\item\em sets the string which will be send to modem for dialing ( at commands ) \item\end{CompactList}\item 
void {\bf Get\-Modem\-Ok\-String} (char $\ast$pc\-Modem\-Ok\-String, unsigned int Buf\-Len)
\begin{CompactList}\small\item\em the modem answers the initializing by sending a string Use this routine to get the string which will be interpreted as a correct initialisation default : OK \item\end{CompactList}\item 
void {\bf Set\-Modem\-Ok\-String} (char $\ast$pc\-Modem\-Ok\-String)
\begin{CompactList}\small\item\em the modem answers the initializing by sending a string Use this routine to set the string which will be interpreted as a correct initialisation default : OK \item\end{CompactList}\item 
void {\bf Get\-Modem\-Connect\-String} (char $\ast$pc\-Modem\-Connect\-String, unsigned int Buf\-Len)
\begin{CompactList}\small\item\em the modem answers the try to connect to another modem by sending a string Use this routine to get the string which will be interpreted as a correct connection default : CONNECT \item\end{CompactList}\item 
void {\bf Set\-Modem\-Connect\-String} (char $\ast$pc\-Modem\-Connect\-String)
\begin{CompactList}\small\item\em the modem answers the try to connect to another modem by sending a string Use this routine to set the string which will be interpreted as a correct connection default : CONNECT \item\end{CompactList}\item 
unsigned int {\bf Get\-Modem\-Init\-Timeout} (void) const
\begin{CompactList}\small\item\em delivers the timeout value for initializing the modem \item\end{CompactList}\item 
void {\bf Set\-Modem\-Init\-Timeout} (const unsigned int ui\-New\-Time\-Out)
\begin{CompactList}\small\item\em sets the timeout value for initializing the modem \item\end{CompactList}\item 
unsigned int {\bf Get\-Modem\-Dial\-Timeout} (void) const
\begin{CompactList}\small\item\em delivers the timeout value for establishing a connection with other modem ( dialing ) \item\end{CompactList}\item 
void {\bf Set\-Modem\-Dial\-Timeout} (const unsigned int ui\-New\-Timeout\-Value)
\begin{CompactList}\small\item\em sets the timeout value for establishing a connection with other modem ( dialing ) \item\end{CompactList}\item 
void {\bf Set\-Tcp\-Ip\-Address} (char const $\ast$pc\-Ip\-Address)
\begin{CompactList}\small\item\em sets the tcpipaddress of the fps -device \item\end{CompactList}\item 
void {\bf Get\-Tcp\-Ip\-Address} (char $\ast$pc\-Ip\-Address, SIZE\_\-T Buf\-Len)
\begin{CompactList}\small\item\em delivers the tcpipaddress of the fps -device \item\end{CompactList}\item 
void {\bf Set\-Tcp\-Ip\-Port} (unsigned int ui\-New\-Port)
\begin{CompactList}\small\item\em sets the communication port \item\end{CompactList}\item 
unsigned int {\bf Get\-Tcp\-Ip\-Port} (void)
\begin{CompactList}\small\item\em delivers the communication port the default port is 5000 \item\end{CompactList}\item 
void {\bf Set\-Base\-Port} (const unsigned int n\-Base\-Port)
\begin{CompactList}\small\item\em Set the base port of TCP/IP connection for login. \item\end{CompactList}\item 
unsigned int {\bf Get\-Base\-Port} (void) const
\begin{CompactList}\small\item\em Get the base port of TCP/IP connection for login. \item\end{CompactList}\item 
void {\bf Set\-Rcv\-Time\-Out} (const DWORD dw\-New\-Time\-Out)
\begin{CompactList}\small\item\em sets timeout ( for receiving data ) \item\end{CompactList}\item 
DWORD {\bf Get\-Rcv\-Time\-Out} (void) const
\begin{CompactList}\small\item\em delivers the timeout for receiving data default 5 seconds \item\end{CompactList}\item 
void {\bf Read\-Profile\-File} (const std::string \&s\-Filename)
\begin{CompactList}\small\item\em read address data from profile file \item\end{CompactList}\item 
void {\bf Read\-Profile\-File\-Connection\-Type} (const std::string \&s\-Filename)
\begin{CompactList}\small\item\em read connection type from profile file and set it in the class data. \item\end{CompactList}\item 
void {\bf Write\-Profile\-File} (std::string s\-Filename)
\begin{CompactList}\small\item\em write address data to profile file \item\end{CompactList}\item 
bool {\bf Fetch\-Data} (RECEIVED\_\-TYPE \&Command, ADDRESS\_\-TYPE \&n\-Address, unsigned int \&ui\-Length, std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em encapsolated functions in {\bf CRcv\-Buffer}{\rm (S.\,\pageref{classCRcvBuffer})} \item\end{CompactList}\item 
bool {\bf Store\-Data} (const RECEIVED\_\-TYPE Command, const ADDRESS\_\-TYPE n\-Address, const unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data=std::vector$<$ unsigned char $>$::vector())
\begin{CompactList}\small\item\em encapsolated functions in {\bf CRcv\-Buffer}{\rm (S.\,\pageref{classCRcvBuffer})} \item\end{CompactList}\end{CompactItemize}
\subsection*{\"{O}ffentliche Attribute}
\begin{CompactItemize}
\item 
{\bf CFps\-Convert} {\bf m\_\-o\-Convert}\label{classCfps_o0}

\begin{CompactList}\small\item\em handle stuetzstellen ( data points ) for converting voltage to mm use this object to convert between :\par
 \par
 native and spec ( depends on what is currently used ( switch with Set\-Measure\-Mode ) )\par
 spec and native\par
 m\-V and mm\par
 mm and m\-V\par
 native and m\-V\par
 native and mm\par
 m\-V and native\par
 mm and native\par
 \item\end{CompactList}\end{CompactItemize}
\subsection*{Gesch\"{u}tzte Methoden}
\begin{CompactItemize}
\item 
bool {\bf Read\-Fps\-Eeprom} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em read in a block of data from eeprom memory from fps device the received data will be stored in m\_\-Eeprom \item\end{CompactList}\item 
bool {\bf Read\-Fps\-Program} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em read in a block of data from program memory from fps device the received data will be stored in m\_\-Program \item\end{CompactList}\item 
bool {\bf Read\-Fps\-Ram} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em read in a block of data from ram memory from fps device the received data will be stored in m\_\-Ram \item\end{CompactList}\item 
bool {\bf Write\-Fps\-Eeprom} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, std::vector$<$ unsigned char $>$ auc\-Data)
\begin{CompactList}\small\item\em write a block of data to eeprom memory in the fps device \item\end{CompactList}\item 
bool {\bf Write\-Fps\-Program} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, std::vector$<$ unsigned char $>$ auc\-Data)
\begin{CompactList}\small\item\em write a block of data to program memory in the fps device \item\end{CompactList}\item 
bool {\bf Write\-Fps\-Ram} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, std::vector$<$ unsigned char $>$ auc\-Data)
\begin{CompactList}\small\item\em write a block of data to ram memory in the fps device \item\end{CompactList}\item 
RECEIVED\_\-TYPE {\bf Wait\-For\-Data} (void)
\begin{CompactList}\small\item\em wait for incoming data timeout = internal timeout \item\end{CompactList}\end{CompactItemize}
\subsection*{Private Methoden}
\begin{CompactItemize}
\item 
{\bf Cfps} (const {\bf Cfps} \&New\-Object)\label{classCfps_d0}

\begin{CompactList}\small\item\em don't use a copy constructor ( therefor it's private ) \item\end{CompactList}\item 
{\bf Cfps} \& {\bf operator=} (const {\bf Cfps} \&Old\-Object)\label{classCfps_d1}

\begin{CompactList}\small\item\em don't use an assign operator ( therefor it's private ) \item\end{CompactList}\item 
bool {\bf Read\-Data\-Point\-Header} (void)
\begin{CompactList}\small\item\em read in header information from fps \item\end{CompactList}\item 
bool {\bf Read\-Data\-Points} (void)
\begin{CompactList}\small\item\em read in data points from fps \item\end{CompactList}\item 
bool {\bf Write\-Data\-Point\-Header} (void)
\begin{CompactList}\small\item\em write header information to fps \item\end{CompactList}\item 
bool {\bf Write\-Data\-Points} (void)
\begin{CompactList}\small\item\em write data points to fps \item\end{CompactList}\item 
void {\bf Read\-Eeprom\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em this function will be call when a Read\-Eeprom\-Req was received It sends a signal to the working thread. \item\end{CompactList}\item 
void {\bf Read\-Program\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em this function will be call when a Read\-Program\-Req was received It sends a signal to the working thread. \item\end{CompactList}\item 
void {\bf Read\-Ram\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em this function will be call when a Read\-Ram\-Req was received It sends a signal to the working thread. \item\end{CompactList}\item 
void {\bf Write\-Eeprom\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em this function will be call when a Write\-Eeprom\-Req was received It sends a signal to the working thread. \item\end{CompactList}\item 
void {\bf Write\-Program\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em this function will be call when a Write\-Program\-Req was received It sends a signal to the working thread. \item\end{CompactList}\item 
void {\bf Write\-Ram\-Data\-Req} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em this function will be call when a Write\-Ram\-Req was received \item\end{CompactList}\item 
void {\bf Read\-Eeprom\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em this function will be call when a Read\-Eeprom\-Cnf was received \item\end{CompactList}\item 
void {\bf Read\-Program\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em this function will be call when a Read\-Program\-Cnf was received \item\end{CompactList}\item 
void {\bf Read\-Ram\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em this function will be call when a Read\-Ram\-Cnf was received \item\end{CompactList}\item 
void {\bf Write\-Eeprom\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em this function will be call when a Write\-Eeprom\-Cnf was received \item\end{CompactList}\item 
void {\bf Write\-Program\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em this function will be call when a Write\-Program\-Cnf was received \item\end{CompactList}\item 
void {\bf Write\-Ram\-Data\-Cnf} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length)
\begin{CompactList}\small\item\em this function will be call when a Write\-Ram\-Cnf was received \item\end{CompactList}\item 
void {\bf Status\-Info} (ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, const std::vector$<$ unsigned char $>$ \&auc\-Data)
\begin{CompactList}\small\item\em this function will be call when a Status\-Info was received \item\end{CompactList}\item 
void {\bf Connect\-Indication} (void)
\begin{CompactList}\small\item\em will be called if a connection was exstablished \item\end{CompactList}\item 
void {\bf Disconnect\-Indication} (void)
\begin{CompactList}\small\item\em will be called if the connection was broken \item\end{CompactList}\item 
unsigned int {\bf Get\-Max\-Retry\-Count} (void) const
\begin{CompactList}\small\item\em delivers max. \item\end{CompactList}\item 
void {\bf Set\-Max\-Retry\-Count} (const unsigned int ui\-New\-Retry\-Count)
\begin{CompactList}\small\item\em sets the max. \item\end{CompactList}\item 
unsigned int {\bf Get\-Max\-Block\-Length} (void) const
\begin{CompactList}\small\item\em get max block length transfered from/to fps \item\end{CompactList}\item 
void {\bf Set\-Max\-Block\-Length} (unsigned int ui\-New\-Max\-Block\-Length)
\begin{CompactList}\small\item\em set max block length transfered from/to fps \item\end{CompactList}\item 
void {\bf Inform\-About\-New\-Data} (const HANDLE h\-Event) const
\begin{CompactList}\small\item\em Signal received command from receive thread to waiting thread. \item\end{CompactList}\item 
bool {\bf Test\-Rcv\-Data} (RECEIVED\_\-TYPE Command, ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, std::vector$<$ unsigned char $>$ \&auc\-Tested\-Data)
\begin{CompactList}\small\item\em needed in the function Read\-Fps to test the received data \item\end{CompactList}\item 
bool {\bf Loc\_\-Get\-Rcv\-Data} (RECEIVED\_\-TYPE e\-Expected\-Rcv\-Type, ADDRESS\_\-TYPE n\-Address, unsigned int ui\-Length, std::vector$<$ unsigned char $>$ \&auc\-Buffer)
\begin{CompactList}\small\item\em adds received data to the overgiven buffer \item\end{CompactList}\item 
bool {\bf Lock\-Fps\-Req} (void)
\begin{CompactList}\small\item\em locking communication to the fps device ( from / to receive thread ) \item\end{CompactList}\item 
bool {\bf Unlock\-Fps\-Req} (void)
\begin{CompactList}\small\item\em unlocking communication to the fps device ( from / to receive thread ) \item\end{CompactList}\end{CompactItemize}
\subsection*{Private Attribute}
\begin{CompactItemize}
\item 
{\bf CRcv\-Buffer} {\bf m\_\-o\-Rcv\-Buffer}\label{classCfps_r0}

\begin{CompactList}\small\item\em handle receive buffer \item\end{CompactList}\item 
HANDLE {\bf m\_\-h\-Rcv\-Event\-Fps\-Data\-Movement}\label{classCfps_r1}

\begin{CompactList}\small\item\em Signal : we've received a command. \item\end{CompactList}\item 
HANDLE {\bf m\_\-h\-Rcv\-Event\-Connect}\label{classCfps_r2}

\begin{CompactList}\small\item\em Signal : we've established a connection. \item\end{CompactList}\item 
HANDLE {\bf m\_\-h\-Rcv\-Event\-Disconnect}\label{classCfps_r3}

\begin{CompactList}\small\item\em Signal : our connection was broken. \item\end{CompactList}\item 
DWORD {\bf m\_\-dw\-Rcv\-Time\-Out}\label{classCfps_r4}

\begin{CompactList}\small\item\em Timeout value for receiving data from the fps device. \item\end{CompactList}\item 
{\bf VERBINDUNG} {\bf m\_\-e\-Neu\-Verb}\label{classCfps_r5}

\begin{CompactList}\small\item\em current connection type \item\end{CompactList}\item 
char {\bf m\_\-s\-Call\-Number} [200]\label{classCfps_r6}

\begin{CompactList}\small\item\em current call number if MODEM is selected \item\end{CompactList}\item 
char {\bf m\_\-s\-Tcp\-Ip\-Address} [200]\label{classCfps_r7}

\begin{CompactList}\small\item\em Tcp\-Ip Address of the gateway. \item\end{CompactList}\item 
unsigned int {\bf m\_\-ui\-Tcp\-Ip\-Port}\label{classCfps_r8}

\begin{CompactList}\small\item\em Portnumber used for communication with the gateway. \item\end{CompactList}\item 
unsigned int {\bf m\_\-ui\-Base\-Port}\label{classCfps_r9}

\begin{CompactList}\small\item\em Port of TCP/IP connection for login (base port). \item\end{CompactList}\item 
unsigned int {\bf m\_\-ui\-Max\-Retry}\label{classCfps_r10}

\begin{CompactList}\small\item\em max \# of retries to send request to the fps \item\end{CompactList}\item 
unsigned int {\bf m\_\-ui\-Max\-Block\-Length}\label{classCfps_r11}

\begin{CompactList}\small\item\em max block length transfered from/to fps \item\end{CompactList}\item 
char {\bf m\_\-s\-Modem\-Init\-String} [200]\label{classCfps_r12}

\begin{CompactList}\small\item\em initstring ( used for connection with modem ) \item\end{CompactList}\item 
char {\bf m\_\-s\-Modem\-Dial\-String} [200]\label{classCfps_r13}

\begin{CompactList}\small\item\em dialstring ( used for connection with modem ) \item\end{CompactList}\item 
char {\bf m\_\-s\-Modem\-Ok\-String} [200]\label{classCfps_r14}

\begin{CompactList}\small\item\em string indicating a correct initialisation of the modem \item\end{CompactList}\item 
char {\bf m\_\-s\-Modem\-Connect\-String} [200]\label{classCfps_r15}

\begin{CompactList}\small\item\em string indicating a correct connection of the modem \item\end{CompactList}\item 
int {\bf m\_\-ui\-Modem\-Init\-Timeout}\label{classCfps_r16}

\begin{CompactList}\small\item\em init timeout for modem initializing \item\end{CompactList}\item 
int {\bf m\_\-ui\-Modem\-Dail\-Timeout}\label{classCfps_r17}

\begin{CompactList}\small\item\em dial timeout. tiemout during a try to connect with another modem \item\end{CompactList}\item 
std::vector$<$ unsigned char $>$ {\bf m\_\-auc\-Eeprom}\label{classCfps_r18}

\begin{CompactList}\small\item\em received data ( eeprom ) \item\end{CompactList}\item 
std::vector$<$ unsigned char $>$ {\bf m\_\-auc\-Program}\label{classCfps_r19}

\begin{CompactList}\small\item\em received data ( program ) \item\end{CompactList}\item 
std::vector$<$ unsigned char $>$ {\bf m\_\-auc\-Ram}\label{classCfps_r20}

\begin{CompactList}\small\item\em received data ( ram ) \item\end{CompactList}\item 
HANDLE {\bf m\_\-h\-Block\-Request}\label{classCfps_r21}

\begin{CompactList}\small\item\em Mutex : blocking mutliply request to the fps. \item\end{CompactList}\end{CompactItemize}


\subsection{Ausf\"{u}hrliche Beschreibung}
contains all functions working with the fps 

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




\subsection{Dokumentation der Aufz\"{a}hlungstypen}
\index{Cfps@{Cfps}!CONVERT_TO@{CONVERT\_\-TO}}
\index{CONVERT_TO@{CONVERT\_\-TO}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}enum {\bf Cfps::CONVERT\_\-TO}}\label{classCfps_w7}


possible working units 

\begin{Desc}
\item[Aufz\"{a}hlungswerte: ]\par
\begin{description}
\index{MV@{MV}!Cfps@{Cfps}}\index{Cfps@{Cfps}!MV@{MV}}\item[{\em 
MV\label{classCfps_w7w4}
}]use the currently used working unit \index{MM@{MM}!Cfps@{Cfps}}\index{Cfps@{Cfps}!MM@{MM}}\item[{\em 
MM\label{classCfps_w7w5}
}]use mm \end{description}
\end{Desc}

\index{Cfps@{Cfps}!VERBINDUNG@{VERBINDUNG}}
\index{VERBINDUNG@{VERBINDUNG}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}enum {\bf Cfps::VERBINDUNG}}\label{classCfps_w6}


possible types of connection 

\begin{Desc}
\item[Aufz\"{a}hlungswerte: ]\par
\begin{description}
\index{NETZWERK@{NETZWERK}!Cfps@{Cfps}}\index{Cfps@{Cfps}!NETZWERK@{NETZWERK}}\item[{\em 
NETZWERK\label{classCfps_w6w1}
}]a modem connection \index{RS232@{RS232}!Cfps@{Cfps}}\index{Cfps@{Cfps}!RS232@{RS232}}\item[{\em 
RS232\label{classCfps_w6w2}
}]a direct connection via RS232 \end{description}
\end{Desc}



\subsection{Beschreibung der Konstruktoren und Destruktoren}
\index{Cfps@{Cfps}!Cfps@{Cfps}}
\index{Cfps@{Cfps}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Cfps::Cfps ()}\label{classCfps_a0}


Create the required Events ( use for synchronization with the receive thread ). 

\begin{Desc}
\item[Autor:]Ingo Fr\"{o}hlich date 12.07.2001\end{Desc}
Copyright 2001 Analytica Gmb\-H

\begin{Desc}
\item[Log]{\bf fps.cpp}{\rm (S.\,\pageref{fps_8cpp})},v \end{Desc}
Revision 1.14 2008/02/12 16:20:16 axelschmidt neuer Verbindungstyp, default rs232

Revision 1.13 2003/07/23 09:57:55 Thomas\-Weber Zus\"{a}tzliche Methoden f\"{u}r Set und Get des Basis-Port f\"{u}r das Login hinzugef\"{u}gt Die Read und Write Methode f\"{u}r das ini-File angepasst

Revision 1.12 2003/02/06 14:16:51 Udo\-Weber\begin{itemize}
\item Funktion \"{U}ber/Untertoleranz hinzugef\"{u}gt\item Fehler beim Beenden der Anwendung (TCPIPComm::Dis\-Ind beim terminieren)\item Berechnungsfehler bei Konvertierung mm/m\-V beseitigt\end{itemize}


Revision 1.11 2002/10/17 08:30:12 Ingo\-Froehlich Letzte Modifikationen f\"{u}r Lernen Plus:\begin{itemize}
\item Speicherung der Linearisierungskurve in m\-V f\"{u}r Controller\end{itemize}


Revision 1.10 2002/02/22 16:23:08 Ingo\-Froehlich aktuelle Einheit wird nicht mehr aus dem FPS gelesen.

Revision 1.9 2001/10/22 15:07:57 Ingo\-Froehlich no message

Revision 1.8 2001/09/10 12:21:42 Ingo\-Froehlich no message

Revision 1.7 2001/09/05 15:14:39 Ingo\-Froehlich no message

Revision 1.6 2001/08/10 15:14:14 Ingo\-Froehlich no message

Revision 1.5 2001/07/23 08:29:26 Ingo\-Froehlich no message

Revision 1.4 2001/07/18 11:30:34 Ingo\-Froehlich changed wrong initial owner value for mutex

Revision 1.3 2001/07/17 15:54:12 Ingo\-Froehlich initialize without paramter possible, programm will use default portnumber and ipaddress or in case readprofilefile was called before, it will use data from this file

Revision 1.2 2001/07/17 10:30:42 Ingo\-Froehlich added : read timeout values and fps - addresses from .ini file Enhanced : readability

Revision 1.1 2001/07/13 08:02:40 Ingo\-Froehlich no message

\begin{Desc}
\item[Id]{\bf fps.cpp}{\rm (S.\,\pageref{fps_8cpp})},v 1.14 2008/02/12 16:20:16 axelschmidt Exp \end{Desc}


\subsection{Dokumentation der Elementfunktionen}
\index{Cfps@{Cfps}!ConnectIndication@{ConnectIndication}}
\index{ConnectIndication@{ConnectIndication}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Connect\-Indication (void)\hspace{0.3cm}{\tt  [private, virtual]}}\label{classCfps_d19}


will be called if a connection was exstablished 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPComm} {\rm (S.\,\pageref{classCTCPIPComm_b0})}.\index{Cfps@{Cfps}!DisconnectIndication@{DisconnectIndication}}
\index{DisconnectIndication@{DisconnectIndication}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Disconnect\-Indication (void)\hspace{0.3cm}{\tt  [private, virtual]}}\label{classCfps_d20}


will be called if the connection was broken 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPComm} {\rm (S.\,\pageref{classCTCPIPComm_b1})}.\index{Cfps@{Cfps}!FetchData@{FetchData}}
\index{FetchData@{FetchData}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Fetch\-Data (RECEIVED\_\-TYPE \& {\em Command}, ADDRESS\_\-TYPE \& {\em n\-Address}, unsigned int \& {\em ui\-Length}, std::vector$<$ unsigned char $>$ \& {\em auc\-Data})}\label{classCfps_a55}


encapsolated functions in {\bf CRcv\-Buffer}{\rm (S.\,\pageref{classCRcvBuffer})} 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em buffer}]to store rcv command, address, data block length and data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : ok \end{Desc}
\index{Cfps@{Cfps}!FetchStuetzArrayFromFps@{FetchStuetzArrayFromFps}}
\index{FetchStuetzArrayFromFps@{FetchStuetzArrayFromFps}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Fetch\-Stuetz\-Array\-From\-Fps (void)}\label{classCfps_a12}


delivers the stored stuetzstellen ( data points ) from the fps device the read in values are stored in the {\bf CFps\-Convert}{\rm (S.\,\pageref{classCFpsConvert})} class, so you can do some converting right after this 

\begin{Desc}
\item[Zu beachten:]you can store the stuetzstellen ( data points ) with {\bf Store\-Stuetz\-Array\-In\-Fps}{\rm (S.\,\pageref{classCfps_a13})}\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation was successfull, false else \end{Desc}
\index{Cfps@{Cfps}!GetBasePort@{GetBasePort}}
\index{GetBasePort@{GetBasePort}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned int Cfps::Get\-Base\-Port (void) const}\label{classCfps_a49}


Get the base port of TCP/IP connection for login. 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em base}]port for login \end{description}
\end{Desc}
\index{Cfps@{Cfps}!GetCallNumber@{GetCallNumber}}
\index{GetCallNumber@{GetCallNumber}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Get\-Call\-Number (char $\ast$ {\em pc\-Call\-Number}, unsigned int {\em ui\-Buf\-Len})}\label{classCfps_a28}


delivers the currently used call number for a modem connection 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em returned}]: buffer in which the current modem number will be stored \item[{\em length}]of the buffer ( in bytes ) \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!GetCallnumber@{GetCallnumber}}
\index{GetCallnumber@{GetCallnumber}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Get\-Callnumber (char $\ast$ {\em pc\-Callnumber}, unsigned int {\em uc\-Buf\-Len})}\label{classCfps_a4}


delivers the current number to call by a modem 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em buffer,in}]which the current number will be stored \item[{\em length}]of the buffer \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!GetCurrentConnectionType@{GetCurrentConnectionType}}
\index{GetCurrentConnectionType@{GetCurrentConnectionType}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf Cfps::VERBINDUNG} Cfps::Get\-Current\-Connection\-Type (void) const}\label{classCfps_a2}


\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]current connection type \end{Desc}
\index{Cfps@{Cfps}!GetCurrentSensorValue@{GetCurrentSensorValue}}
\index{GetCurrentSensorValue@{GetCurrentSensorValue}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Get\-Current\-Sensor\-Value (float \& {\em Cur\-Sen}, {\bf CONVERT\_\-TO} {\em e\-Convert\-To} = {\tt SPEC})}\label{classCfps_a19}


delivers the current sensor value 

the unit in which the return value will be can be specified with the second argument

SPEC =$>$ depend on what is currently used ( set / change with Set\-Measure\-Mode ) MV =$>$ returns m\-V MM =$>$ returns mm

\begin{Desc}
\item[Zu beachten:]default is SPEC\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em returned}]current sensor value, \item[{\em optional}]the unit of the return value ( see upove for details ) \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!GetCurrentTemperature@{GetCurrentTemperature}}
\index{GetCurrentTemperature@{GetCurrentTemperature}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Get\-Current\-Temperature (float \& {\em Current\-Temperature})}\label{classCfps_a21}


delivers the current temperature of the fps device ( in 176C ) 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em returned}]the current temperature \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation was successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!GetCurrentVoltage@{GetCurrentVoltage}}
\index{GetCurrentVoltage@{GetCurrentVoltage}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Get\-Current\-Voltage (float \& {\em Cur\-Operating\-Voltage})}\label{classCfps_a20}


delivers the current voltage of the fps device ( in m\-V ) 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em returned}]:the current voltage \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation was successfull, false else \end{Desc}
\index{Cfps@{Cfps}!GetMaxBlockLength@{GetMaxBlockLength}}
\index{GetMaxBlockLength@{GetMaxBlockLength}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned int Cfps::Get\-Max\-Block\-Length (void) const\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d23}


get max block length transfered from/to fps 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]the max. block length \end{Desc}
\index{Cfps@{Cfps}!GetMaxRetryCount@{GetMaxRetryCount}}
\index{GetMaxRetryCount@{GetMaxRetryCount}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned int Cfps::Get\-Max\-Retry\-Count (void) const\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d21}


delivers max. 

number of retries sending a request to the fps

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]the max. number of retries \end{Desc}
\index{Cfps@{Cfps}!GetModemConnectString@{GetModemConnectString}}
\index{GetModemConnectString@{GetModemConnectString}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Get\-Modem\-Connect\-String (char $\ast$ {\em pc\-Modem\-Connect\-String}, unsigned int {\em Buf\-Len})}\label{classCfps_a38}


the modem answers the try to connect to another modem by sending a string Use this routine to get the string which will be interpreted as a correct connection default : CONNECT 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em return}]connect string \item[{\em size}]of the buffer \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!GetModemDialString@{GetModemDialString}}
\index{GetModemDialString@{GetModemDialString}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Get\-Modem\-Dial\-String (char $\ast$ {\em pc\-Modem\-Dial\-String}, unsigned int {\em Buf\-Len})}\label{classCfps_a34}


delivers the string which will be send to modem for dialing ( at commands ) 

\begin{Desc}
\item[Zu beachten:]call number will be added, so don't set it here\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em returned}]: buffer in which the string will be stored \item[{\em size}]of the buffer ( in bytes ) \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!GetModemDialTimeout@{GetModemDialTimeout}}
\index{GetModemDialTimeout@{GetModemDialTimeout}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned int Cfps::Get\-Modem\-Dial\-Timeout (void) const}\label{classCfps_a42}


delivers the timeout value for establishing a connection with other modem ( dialing ) 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]the current timeout value \end{Desc}
\index{Cfps@{Cfps}!GetModemInitString@{GetModemInitString}}
\index{GetModemInitString@{GetModemInitString}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Get\-Modem\-Init\-String (char $\ast$ {\em pc\-Modem\-Init\-String}, unsigned int {\em Buf\-Len})}\label{classCfps_a32}


delivers the string which will be send to modem for initializing ( at commands ) 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em returned}]buffer in which the string will be stored \item[{\em size}]of the buffer ( in bytes ) \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!GetModemInitTimeout@{GetModemInitTimeout}}
\index{GetModemInitTimeout@{GetModemInitTimeout}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned int Cfps::Get\-Modem\-Init\-Timeout (void) const}\label{classCfps_a40}


delivers the timeout value for initializing the modem 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]the current timeout value \end{Desc}
\index{Cfps@{Cfps}!GetModemOkString@{GetModemOkString}}
\index{GetModemOkString@{GetModemOkString}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Get\-Modem\-Ok\-String (char $\ast$ {\em pc\-Modem\-Ok\-String}, unsigned int {\em Buf\-Len})}\label{classCfps_a36}


the modem answers the initializing by sending a string Use this routine to get the string which will be interpreted as a correct initialisation default : OK 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em return}]ok string \item[{\em size}]of the buffer \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!GetOperatingState@{GetOperatingState}}
\index{GetOperatingState@{GetOperatingState}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Get\-Operating\-State (int \& {\em Flags})}\label{classCfps_a6}


delivers the current operation flags \par
\par
 structure : \par
\par
 bit meaning \par
\par
 0 switch between operation mode ( 0 = Bereich, 1 = Schaltpunkt ) \par
 1 --- \par
 2 --- \par
 3 --- \par
 4 --- \par
 5 Update : ( set by fps device when sampling finished ) \par
 6 Record : start sampling if bit set \par
 7 Re\-Calc : transfer values from fps input buffer to fps work buffer \par
 

\begin{Desc}
\item[Zu beachten:]You can set the operating state with {\bf Set\-Operating\-State}{\rm (S.\,\pageref{classCfps_a7})}\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em returning}]flags \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation was successfull, false else \end{Desc}
\index{Cfps@{Cfps}!GetOutOfRangeFlags@{GetOutOfRangeFlags}}
\index{GetOutOfRangeFlags@{GetOutOfRangeFlags}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Get\-Out\-Of\-Range\-Flags (int \& {\em Flags})}\label{classCfps_a11}


delivers the \char`\"{}out of range\char`\"{} flags\par
 \par
 structure\par
 \par
 bit meaning ( if set )\par
 \par
 0 Unterspannung ( low voltage )\par
 1 \"{U}berspannung ( high voltage )\par
 2 Untertemperatur ( low temperature )\par
 3 \"{U}bertemperatur ( high temperature )\par
 4 ---\par
 5 ---\par
 6 ---\par
 7 ---\par
 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em read}]in flags \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation was successfull, false else \end{Desc}
\index{Cfps@{Cfps}!GetPortB@{GetPortB}}
\index{GetPortB@{GetPortB}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Get\-Port\-B (int \& {\em Flags})}\label{classCfps_a22}


delivers the current state of the fps device\par
 \par
 bit meaning\par
 0 ---\par
 1 ---\par
 2 ---\par
 3 offen ( open )\par
 4 C\par
 5 B\par
 6 A\par
 7 zu ( closed )\par
 8 ---\par
 9 ---\par
 10 ---\par
 11 ---\par
 12 ---\par
 13 ---\par
 14 ---\par
 15 ---\par
 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em returned}]flags ( see upove for details ) \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation was successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!GetPortBSamples@{GetPortBSamples}}
\index{GetPortBSamples@{GetPortBSamples}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Get\-Port\-BSamples (int {\em Port\-BSample}[640], unsigned int {\em ui\-Begin} = {\tt 0}, unsigned int {\em ui\-Length} = {\tt 640})}\label{classCfps_a18}


delivers the sample of Port\-B data from the last sampling ( see Get\-Current\-State for more details ) 

\begin{Desc}
\item[Zu beachten:]the data transfer of the whole sampling data takes a lot of time ( about 20 seconds ) You can break it down into small packages, which are more easier to handle by setting the start offset and length of the block you want to read in.\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em array}]in which the sampling data will be stored, \item[{\em optional}]: start of the block, which will be transfered, \item[{\em optional}]: length of the block, which will be transfered \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation successfull \end{Desc}
\index{Cfps@{Cfps}!GetRcvTimeOut@{GetRcvTimeOut}}
\index{GetRcvTimeOut@{GetRcvTimeOut}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}DWORD Cfps::Get\-Rcv\-Time\-Out (void) const}\label{classCfps_a51}


delivers the timeout for receiving data default 5 seconds 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]currently used timout value \end{Desc}
\index{Cfps@{Cfps}!GetSensorSamples@{GetSensorSamples}}
\index{GetSensorSamples@{GetSensorSamples}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Get\-Sensor\-Samples (float {\em Sen\-Samp}[640], unsigned int {\em ui\-Begin} = {\tt 0}, unsigned int {\em ui\-Length} = {\tt 640})}\label{classCfps_a16}


delivers the sample of sensor data from the last sampling ( see Get\-Operating\-State for more details ) 

\begin{Desc}
\item[Zu beachten:]the data transfer of the whole sampling data takes a lot of time ( about 20 seconds ) You can break it down into small packages, which are more easier to handle by setting the start offset and length of the block you want to read in.\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em array}]in which the sampling data will be stored, \item[{\em optional}]: start of the block, which will be transfered, \item[{\em optional}]: length of the block, which will be transfered \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation successfull \end{Desc}
\index{Cfps@{Cfps}!GetServiceInfo@{GetServiceInfo}}
\index{GetServiceInfo@{GetServiceInfo}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Get\-Service\-Info (int \& {\em Week}, int \& {\em Year}, int \& {\em Serialnumber})}\label{classCfps_a26}


delivers the week and year of the production of the fps device and their serialnumber 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em returned}]week \item[{\em returned}]year \item[{\em returned}]serialnumber \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation was successfull \end{Desc}
\index{Cfps@{Cfps}!GetTcpIpAddress@{GetTcpIpAddress}}
\index{GetTcpIpAddress@{GetTcpIpAddress}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Get\-Tcp\-Ip\-Address (char $\ast$ {\em pc\-Ip\-Address}, SIZE\_\-T {\em Buf\-Len})}\label{classCfps_a45}


delivers the tcpipaddress of the fps -device 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em buffer}]in which the current tcpip address will be stored in, \item[{\em length}]of the buffer \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!GetTcpIpPort@{GetTcpIpPort}}
\index{GetTcpIpPort@{GetTcpIpPort}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned int Cfps::Get\-Tcp\-Ip\-Port (void)}\label{classCfps_a47}


delivers the communication port the default port is 5000 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]the currently used port number \end{Desc}
\index{Cfps@{Cfps}!GetTolerance@{GetTolerance}}
\index{GetTolerance@{GetTolerance}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Get\-Tolerance (float \& {\em f\-Unter\-Tolerance}, float \& {\em f\-Ueber\-Tolerance})}\label{classCfps_a14}


read in the tolerance values ( this value is stored in the fps in the place of the last stuetzstelle 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em (+)}]tolerance value ( in the currently used unit ) \item[{\em (-)}]tolerance value ( in the currently used unit ) \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!GetVoltageSamples@{GetVoltageSamples}}
\index{GetVoltageSamples@{GetVoltageSamples}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Get\-Voltage\-Samples (float {\em Voltage\-Sample}[640], unsigned int {\em ui\-Begin} = {\tt 0}, unsigned int {\em ui\-Length} = {\tt 640})}\label{classCfps_a17}


delivers the sample of voltage data from the last sampling ( see Get\-Operating\-State for more details ) 

\begin{Desc}
\item[Zu beachten:]the data transfer of the whole sampling data takes a lot of time ( about 20 seconds ) You can break it down into small packages, which are more easier to handle by setting the start offset and length of the block you want to read in.\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em array}]in which the sampling data will be stored, \item[{\em optional}]: start of the block, which will be transfered, \item[{\em optional}]: length of the block, which will be transfered \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation successfull \end{Desc}
\index{Cfps@{Cfps}!InformAboutNewData@{InformAboutNewData}}
\index{InformAboutNewData@{InformAboutNewData}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Inform\-About\-New\-Data (const HANDLE {\em h\-Event}) const\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d25}


Signal received command from receive thread to waiting thread. 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em handle}]of the signal the send \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!initialize@{initialize}}
\index{initialize@{initialize}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::initialize (void)\hspace{0.3cm}{\tt  [virtual]}}\label{classCfps_a31}


init socket connection 

Set the required data with Set\-Tcp\-Ip\-Address and Set\-Tcp\-Ip\-Port

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

false else \end{Desc}
\index{Cfps@{Cfps}!InitModem@{InitModem}}
\index{InitModem@{InitModem}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Init\-Modem (void)}\label{classCfps_a30}


connect to modem 

\begin{Desc}
\item[Zu beachten:]Set the apropriate before ( using Read\-Profile\-File ) or set it by hand\end{Desc}
addtional note : you need to open a connection to the gateway before trying to connect to a modem

When set by hand\par
 \par
 Set using\par
 \par
 Callnumber Set\-Call\-Number\par
 Initstring ( at commands ) for modem Set\-Modem\-Init\-String\par
 Dialstring ( at commands ) for modem Set\-Modem\-Dial\-String\par
 string indicating a correct initialisation of the modem Set\-Modem\-Ok\-String\par
 string indicating a correct connection Set\-Modem\-Connect\-String\par


\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true connect was successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!IsSamplingDone@{IsSamplingDone}}
\index{IsSamplingDone@{IsSamplingDone}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Is\-Sampling\-Done (bool \& {\em b\-Done})}\label{classCfps_a24}


tests if the sampling is already done 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true sampling is finished 

false else \end{Desc}
\index{Cfps@{Cfps}!Loc_GetRcvData@{Loc\_\-GetRcvData}}
\index{Loc_GetRcvData@{Loc\_\-GetRcvData}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Loc\_\-Get\-Rcv\-Data (RECEIVED\_\-TYPE {\em e\-Expected\-Rcv\-Type}, ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, std::vector$<$ unsigned char $>$ \& {\em auc\-Buffer})\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d27}


adds received data to the overgiven buffer 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em expected}]command, \item[{\em expected}]address, \item[{\em expected}]length \item[{\em returned}]added received data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation was successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!LockFpsReq@{LockFpsReq}}
\index{LockFpsReq@{LockFpsReq}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Lock\-Fps\-Req (void)\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d28}


locking communication to the fps device ( from / to receive thread ) 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true lock successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!PasswordLogin@{PasswordLogin}}
\index{PasswordLogin@{PasswordLogin}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Password\-Login (char $\ast$ {\em sz\-Ip\-Address}, char $\ast$ {\em sz\-Password}, unsigned int {\em ui\-Base\-Port}, unsigned int {\em ui\-Portnumber})}\label{classCfps_a27}


handle the password login use the routine to connect to a password protected gateway 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em Tcpip}]Address of the gateway, \item[{\em password,@param}]Baseport ( used for password exchange ), \item[{\em Port}]to connect to if password is valid \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!ReadDataPointHeader@{ReadDataPointHeader}}
\index{ReadDataPointHeader@{ReadDataPointHeader}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Read\-Data\-Point\-Header (void)\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d2}


read in header information from fps 

\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{Cfps@{Cfps}!ReadDataPoints@{ReadDataPoints}}
\index{ReadDataPoints@{ReadDataPoints}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Read\-Data\-Points (void)\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d3}


read in data points from fps 

\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{Cfps@{Cfps}!ReadEepromDataCnf@{ReadEepromDataCnf}}
\index{ReadEepromDataCnf@{ReadEepromDataCnf}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::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  [private, virtual]}}\label{classCfps_d12}


this function will be call when a Read\-Eeprom\-Cnf was received 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length, read data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


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


this function will be call when a Read\-Eeprom\-Req was received It sends a signal to the working thread. 

You can catch those signals be using {\bf Wait\-For\-Data}{\rm (S.\,\pageref{classCfps_b6})}

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPConnector} {\rm (S.\,\pageref{classCTCPIPConnector_b1})}.\index{Cfps@{Cfps}!ReadFpsEeprom@{ReadFpsEeprom}}
\index{ReadFpsEeprom@{ReadFpsEeprom}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Read\-Fps\-Eeprom (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [protected]}}\label{classCfps_b0}


read in a block of data from eeprom memory from fps device the received data will be stored in m\_\-Eeprom 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]of the block to read, \item[{\em length}]of the block \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation successfull, false else \end{Desc}
\index{Cfps@{Cfps}!ReadFpsProgram@{ReadFpsProgram}}
\index{ReadFpsProgram@{ReadFpsProgram}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Read\-Fps\-Program (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [protected]}}\label{classCfps_b1}


read in a block of data from program memory from fps device the received data will be stored in m\_\-Program 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]of the block to read, \item[{\em length}]of the block \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!ReadFpsRam@{ReadFpsRam}}
\index{ReadFpsRam@{ReadFpsRam}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Read\-Fps\-Ram (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [protected]}}\label{classCfps_b2}


read in a block of data from ram memory from fps device the received data will be stored in m\_\-Ram 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]of the block to read, \item[{\em length}]of the block \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!ReadInterpolatedSensor@{ReadInterpolatedSensor}}
\index{ReadInterpolatedSensor@{ReadInterpolatedSensor}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Read\-Interpolated\-Sensor ({\bf SENSOR\_\-TYPE} \& {\em Current\-Sensor\-Values})}\label{classCfps_a10}


Read in the fps working buffer ( see Read\-Sensor for more details ). 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em read}]in values ( struct {\bf SENSOR\_\-TYPE}{\rm (S.\,\pageref{structSENSOR__TYPE})} ) \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]operation was successfull, false else \end{Desc}
\index{Cfps@{Cfps}!ReadProfileFile@{ReadProfileFile}}
\index{ReadProfileFile@{ReadProfileFile}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Read\-Profile\-File (const std::string \& {\em s\-Filename})}\label{classCfps_a52}


read address data from profile file 

read in tcpip address, portnumber, receive timeout value and internal used timeout value ( this value will be used as timeout value for communication will the separated received thread ), strings for communication with a modem \begin{Desc}
\item[Zu beachten:]Default values ( in case of an error ):\par
 \par
 tcpip address : localhost ( equals 127.0.0.1 )\par
 port number : 5000\par
 receive timeout : 5 seconds\par
 internal timeout : 5 seconds\par
 Ok string ( modem ) : OK\par
 CONNECT string ( modem ) : CONNECT\par
\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em filename}]of the profile file \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!ReadProfileFileConnectionType@{ReadProfileFileConnectionType}}
\index{ReadProfileFileConnectionType@{ReadProfileFileConnectionType}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Read\-Profile\-File\-Connection\-Type (const std::string \& {\em s\-Filename})}\label{classCfps_a53}


read connection type from profile file and set it in the class data. 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em filename}]of the profile file \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!ReadProgramDataCnf@{ReadProgramDataCnf}}
\index{ReadProgramDataCnf@{ReadProgramDataCnf}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::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  [private, virtual]}}\label{classCfps_d13}


this function will be call when a Read\-Program\-Cnf was received 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length, read data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


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


this function will be call when a Read\-Program\-Req was received It sends a signal to the working thread. 

You can catch those signals be using {\bf Wait\-For\-Data}{\rm (S.\,\pageref{classCfps_b6})}

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPConnector} {\rm (S.\,\pageref{classCTCPIPConnector_b2})}.\index{Cfps@{Cfps}!ReadRamDataCnf@{ReadRamDataCnf}}
\index{ReadRamDataCnf@{ReadRamDataCnf}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::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  [private, virtual]}}\label{classCfps_d14}


this function will be call when a Read\-Ram\-Cnf was received 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length, read data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


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


this function will be call when a Read\-Ram\-Req was received It sends a signal to the working thread. 

You can catch those signals be using {\bf Wait\-For\-Data}{\rm (S.\,\pageref{classCfps_b6})}

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPConnector} {\rm (S.\,\pageref{classCTCPIPConnector_b3})}.\index{Cfps@{Cfps}!ReadSensor@{ReadSensor}}
\index{ReadSensor@{ReadSensor}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Read\-Sensor ({\bf SENSOR\_\-TYPE} \& {\em Current\-Sensor\-Values})}\label{classCfps_a8}


Delivers the current values in the fps input buffer into the overgiven structure of type {\bf SENSOR\_\-TYPE}{\rm (S.\,\pageref{structSENSOR__TYPE})} \par
\par
 structure of {\bf SENSOR\_\-TYPE}{\rm (S.\,\pageref{structSENSOR__TYPE})} ( defined in the file {\bf fps.hpp}{\rm (S.\,\pageref{fps_8hpp})} ) \par
\par
 struct {\bf SENSOR\_\-TYPE}{\rm (S.\,\pageref{structSENSOR__TYPE})}\par
 \{\par
 int open; value which means state AUF ( open )\par
 int c; \char`\"{}     \char`\"{} \char`\"{}     \char`\"{} C\par
 int b; \char`\"{}     \char`\"{} \char`\"{}     \char`\"{} B\par
 int a; \char`\"{}     \char`\"{} \char`\"{}     \char`\"{} A\par
 int closed; \char`\"{}     \char`\"{} \char`\"{}     \char`\"{} ZU ( closed )\par
 \};. 

\begin{Desc}
\item[Zu beachten:]these values are in native format. Use the {\bf CFps\-Convert}{\rm (S.\,\pageref{classCFpsConvert})} class to convert between native and specific ( m\-V or mm )\end{Desc}
further notice : You can set fps input buffer with {\bf Write\-Sensor}{\rm (S.\,\pageref{classCfps_a9})}

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em read}]in values ( struct {\bf SENSOR\_\-TYPE}{\rm (S.\,\pageref{structSENSOR__TYPE})} ) \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation was successfull, false else \end{Desc}
\index{Cfps@{Cfps}!ResetEx@{ResetEx}}
\index{ResetEx@{ResetEx}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Reset\-Ex (void)}\label{classCfps_a25}


resets the Out\-Of\-Range\-Flags writes back the week and year of the production of the fps devise and their serial number 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation was successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!SaveTolerance@{SaveTolerance}}
\index{SaveTolerance@{SaveTolerance}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Save\-Tolerance (float {\em f\-Unter\-Tolerance}, float {\em f\-Ueber\-Tolerance})}\label{classCfps_a15}


saves the tolance value in the fps ( this value is stored in the place of the last stuetzstelle 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em (+)}]tolerance value ( in the currently used unit ) \item[{\em (-)}]tolerance value ( in the currently used unit ) \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetBasePort@{SetBasePort}}
\index{SetBasePort@{SetBasePort}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Base\-Port (const unsigned int {\em n\-Base\-Port})}\label{classCfps_a48}


Set the base port of TCP/IP connection for login. 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em n\-Base\-Port}]port for login \end{description}
\end{Desc}
\index{Cfps@{Cfps}!SetCallNumber@{SetCallNumber}}
\index{SetCallNumber@{SetCallNumber}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Call\-Number (char $\ast$ {\em pc\-New\-Call\-Number})}\label{classCfps_a29}


sets the currently used call number for a modem connection 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em the}]new call number \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetCallnumber@{SetCallnumber}}
\index{SetCallnumber@{SetCallnumber}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Callnumber (char $\ast$ {\em pc\-New\-Callnumber})}\label{classCfps_a5}


sets the current number to call by a modem 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em the}]new Callnumber \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetCurrentConnectionType@{SetCurrentConnectionType}}
\index{SetCurrentConnectionType@{SetCurrentConnectionType}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Current\-Connection\-Type (const {\bf VERBINDUNG} {\em e\-New\-Connection\-Type})}\label{classCfps_a3}


\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em new}]connection type \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetMaxBlockLength@{SetMaxBlockLength}}
\index{SetMaxBlockLength@{SetMaxBlockLength}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Max\-Block\-Length (unsigned int {\em ui\-New\-Max\-Block\-Length})\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d24}


set max block length transfered from/to fps 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em the}]new max. block length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetMaxRetryCount@{SetMaxRetryCount}}
\index{SetMaxRetryCount@{SetMaxRetryCount}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Max\-Retry\-Count (const unsigned int {\em ui\-New\-Retry\-Count})\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d22}


sets the max. 

number of retries sending a request to the fps

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em new}]retry count \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetModemConnectString@{SetModemConnectString}}
\index{SetModemConnectString@{SetModemConnectString}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Modem\-Connect\-String (char $\ast$ {\em pc\-Modem\-Connect\-String})}\label{classCfps_a39}


the modem answers the try to connect to another modem by sending a string Use this routine to set the string which will be interpreted as a correct connection default : CONNECT 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em connect}]string \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetModemDialString@{SetModemDialString}}
\index{SetModemDialString@{SetModemDialString}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Modem\-Dial\-String (char $\ast$ {\em pc\-New\-Modem\-Dial\-String})}\label{classCfps_a35}


sets the string which will be send to modem for dialing ( at commands ) 

\begin{Desc}
\item[Zu beachten:]call number will be added, so don't set it here\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em new}]dial string \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetModemDialTimeout@{SetModemDialTimeout}}
\index{SetModemDialTimeout@{SetModemDialTimeout}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Modem\-Dial\-Timeout (const unsigned int {\em ui\-New\-Timeout\-Value})}\label{classCfps_a43}


sets the timeout value for establishing a connection with other modem ( dialing ) 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em new}]timeout value \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetModemInitString@{SetModemInitString}}
\index{SetModemInitString@{SetModemInitString}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Modem\-Init\-String (char $\ast$ {\em pc\-New\-Modem\-Init\-String})}\label{classCfps_a33}


sets the string which will be send to modem for initializing ( at commands ) 

\begin{Desc}
\item[Zu beachten:]switch off echoing here\end{Desc}
\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em new}]modem init string \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetModemInitTimeout@{SetModemInitTimeout}}
\index{SetModemInitTimeout@{SetModemInitTimeout}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Modem\-Init\-Timeout (const unsigned int {\em ui\-New\-Time\-Out})}\label{classCfps_a41}


sets the timeout value for initializing the modem 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em new}]timeout value \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetModemOkString@{SetModemOkString}}
\index{SetModemOkString@{SetModemOkString}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Modem\-Ok\-String (char $\ast$ {\em pc\-Modem\-Ok\-String})}\label{classCfps_a37}


the modem answers the initializing by sending a string Use this routine to set the string which will be interpreted as a correct initialisation default : OK 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ok}]string \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetOperatingState@{SetOperatingState}}
\index{SetOperatingState@{SetOperatingState}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Set\-Operating\-State (int {\em Flags})}\label{classCfps_a7}


Sets the current operating state ( see Get\-Operation\-State for details ). 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em flags}]to set \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation was successfull, false else \end{Desc}
\index{Cfps@{Cfps}!SetRcvTimeOut@{SetRcvTimeOut}}
\index{SetRcvTimeOut@{SetRcvTimeOut}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Rcv\-Time\-Out (const DWORD {\em dw\-New\-Time\-Out})}\label{classCfps_a50}


sets timeout ( for receiving data ) 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em new}]timeout value ( in milli seconds ) \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetTcpIpAddress@{SetTcpIpAddress}}
\index{SetTcpIpAddress@{SetTcpIpAddress}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Tcp\-Ip\-Address (char const $\ast$ {\em pc\-Ip\-Address})}\label{classCfps_a44}


sets the tcpipaddress of the fps -device 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em c}]- string with the tcpip address \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!SetTcpIpPort@{SetTcpIpPort}}
\index{SetTcpIpPort@{SetTcpIpPort}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Set\-Tcp\-Ip\-Port (unsigned int {\em ui\-New\-Port})}\label{classCfps_a46}


sets the communication port 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em port}]number \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!StartSampling@{StartSampling}}
\index{StartSampling@{StartSampling}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Start\-Sampling (void)}\label{classCfps_a23}


starts the sampling of sensor, voltage and portb data a value will be measured every 30 milliseconds 640 measures will be taken at all 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation was successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!StatusInfo@{StatusInfo}}
\index{StatusInfo@{StatusInfo}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Status\-Info (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data})\hspace{0.3cm}{\tt  [private, virtual]}}\label{classCfps_d18}


this function will be call when a Status\-Info was received 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPConnector} {\rm (S.\,\pageref{classCTCPIPConnector_b13})}.\index{Cfps@{Cfps}!StoreData@{StoreData}}
\index{StoreData@{StoreData}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Store\-Data (const RECEIVED\_\-TYPE {\em Command}, const ADDRESS\_\-TYPE {\em n\-Address}, const unsigned int {\em ui\-Length}, const std::vector$<$ unsigned char $>$ \& {\em auc\-Data} = {\tt std::vector$<$unsigned\ char$>$::vector()})}\label{classCfps_a56}


encapsolated functions in {\bf CRcv\-Buffer}{\rm (S.\,\pageref{classCRcvBuffer})} 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em new}]command, new address, new data block length, new data \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : ok \end{Desc}
\index{Cfps@{Cfps}!StoreStuetzArrayInFps@{StoreStuetzArrayInFps}}
\index{StoreStuetzArrayInFps@{StoreStuetzArrayInFps}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Store\-Stuetz\-Array\-In\-Fps (void)}\label{classCfps_a13}


stores the current used stuetzstellen ( data points ) into the fps device 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation was successfull, false else \end{Desc}
\index{Cfps@{Cfps}!TestRcvData@{TestRcvData}}
\index{TestRcvData@{TestRcvData}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Test\-Rcv\-Data (RECEIVED\_\-TYPE {\em Command}, ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, std::vector$<$ unsigned char $>$ \& {\em auc\-Tested\-Data})\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d26}


needed in the function Read\-Fps to test the received data 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em expected}]command, \item[{\em expected}]address, \item[{\em expected}]length of the received command block \item[{\em returned}]the received data if valid \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true data is valid 

false else \end{Desc}
\index{Cfps@{Cfps}!UnlockFpsReq@{UnlockFpsReq}}
\index{UnlockFpsReq@{UnlockFpsReq}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Unlock\-Fps\-Req (void)\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d29}


unlocking communication to the fps device ( from / to receive thread ) 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true unlock successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!WaitForData@{WaitForData}}
\index{WaitForData@{WaitForData}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}RECEIVED\_\-TYPE Cfps::Wait\-For\-Data (void)\hspace{0.3cm}{\tt  [protected]}}\label{classCfps_b6}


wait for incoming data timeout = internal timeout 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em ---}]\end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]received command or NONE ( see {\bf fps\_\-rcvbuffer.hpp}{\rm (S.\,\pageref{fps__rcvbuffer_8hpp})} for details ) \end{Desc}
\index{Cfps@{Cfps}!WriteDataPointHeader@{WriteDataPointHeader}}
\index{WriteDataPointHeader@{WriteDataPointHeader}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Write\-Data\-Point\-Header (void)\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d4}


write header information to fps 

\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{Cfps@{Cfps}!WriteDataPoints@{WriteDataPoints}}
\index{WriteDataPoints@{WriteDataPoints}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Write\-Data\-Points (void)\hspace{0.3cm}{\tt  [private]}}\label{classCfps_d5}


write data points to fps 

\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{Cfps@{Cfps}!WriteEepromDataCnf@{WriteEepromDataCnf}}
\index{WriteEepromDataCnf@{WriteEepromDataCnf}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Write\-Eeprom\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [private, virtual]}}\label{classCfps_d15}


this function will be call when a Write\-Eeprom\-Cnf was received 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPConnector} {\rm (S.\,\pageref{classCTCPIPConnector_b10})}.\index{Cfps@{Cfps}!WriteEepromDataReq@{WriteEepromDataReq}}
\index{WriteEepromDataReq@{WriteEepromDataReq}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::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  [private, virtual]}}\label{classCfps_d9}


this function will be call when a Write\-Eeprom\-Req was received It sends a signal to the working thread. 

You can catch those signals be using {\bf Wait\-For\-Data}{\rm (S.\,\pageref{classCfps_b6})}

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length, data which should be written \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


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


write a block of data to eeprom memory in the fps device 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]of the block to write, \item[{\em length}]of the block, \item[{\em data}]to write \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!WriteFpsProgram@{WriteFpsProgram}}
\index{WriteFpsProgram@{WriteFpsProgram}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Write\-Fps\-Program (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, std::vector$<$ unsigned char $>$ {\em auc\-Data})\hspace{0.3cm}{\tt  [protected]}}\label{classCfps_b4}


write a block of data to program memory in the fps device 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]of the block to write, \item[{\em length}]of the block, \item[{\em data}]to write \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!WriteFpsRam@{WriteFpsRam}}
\index{WriteFpsRam@{WriteFpsRam}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Write\-Fps\-Ram (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length}, std::vector$<$ unsigned char $>$ {\em auc\-Data})\hspace{0.3cm}{\tt  [protected]}}\label{classCfps_b5}


write a block of data to ram memory in the fps device 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em address}]of the block to write, \item[{\em length}]of the block, \item[{\em data}]to write \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true operation successfull 

false else \end{Desc}
\index{Cfps@{Cfps}!WriteProfileFile@{WriteProfileFile}}
\index{WriteProfileFile@{WriteProfileFile}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Write\-Profile\-File (std::string {\em s\-Filename})}\label{classCfps_a54}


write address data to profile file 

write tcpip address, portnumber, receive timeout value and internal used timeout value ( this value will be used as timeout value for communication will the separated received thread ), strings for communication with a modem

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em filename}]of the profile file \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}
\index{Cfps@{Cfps}!WriteProgramDataCnf@{WriteProgramDataCnf}}
\index{WriteProgramDataCnf@{WriteProgramDataCnf}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Write\-Program\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [private, virtual]}}\label{classCfps_d16}


this function will be call when a Write\-Program\-Cnf was received 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPConnector} {\rm (S.\,\pageref{classCTCPIPConnector_b11})}.\index{Cfps@{Cfps}!WriteProgramDataReq@{WriteProgramDataReq}}
\index{WriteProgramDataReq@{WriteProgramDataReq}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::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  [private, virtual]}}\label{classCfps_d10}


this function will be call when a Write\-Program\-Req was received It sends a signal to the working thread. 

You can catch those signals be using {\bf Wait\-For\-Data}{\rm (S.\,\pageref{classCfps_b6})}

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length, data which should be written \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPConnector} {\rm (S.\,\pageref{classCTCPIPConnector_b5})}.\index{Cfps@{Cfps}!WriteRamDataCnf@{WriteRamDataCnf}}
\index{WriteRamDataCnf@{WriteRamDataCnf}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::Write\-Ram\-Data\-Cnf (ADDRESS\_\-TYPE {\em n\-Address}, unsigned int {\em ui\-Length})\hspace{0.3cm}{\tt  [private, virtual]}}\label{classCfps_d17}


this function will be call when a Write\-Ram\-Cnf was received 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPConnector} {\rm (S.\,\pageref{classCTCPIPConnector_b12})}.\index{Cfps@{Cfps}!WriteRamDataReq@{WriteRamDataReq}}
\index{WriteRamDataReq@{WriteRamDataReq}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Cfps::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  [private, virtual]}}\label{classCfps_d11}


this function will be call when a Write\-Ram\-Req was received 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em received}]address, received length, data which should be written \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]--- \end{Desc}


Implementiert {\bf CTCPIPConnector} {\rm (S.\,\pageref{classCTCPIPConnector_b6})}.\index{Cfps@{Cfps}!WriteSensor@{WriteSensor}}
\index{WriteSensor@{WriteSensor}!Cfps@{Cfps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool Cfps::Write\-Sensor ({\bf SENSOR\_\-TYPE} {\em New\-Sensor\-Values})}\label{classCfps_a9}


Writes the overgiven values into the fps input buffer ( see Read\-Sensor for details ). 

\begin{Desc}
\item[Parameter:]
\begin{description}
\item[{\em values}]to write ( struct {\bf SENSOR\_\-TYPE}{\rm (S.\,\pageref{structSENSOR__TYPE})} ) \end{description}
\end{Desc}
\begin{Desc}
\item[R\"{u}ckgabe:]true : operation was successfull, false else \end{Desc}


Die Dokumentation f\"{u}r diese Klasse wurde erzeugt aufgrund der Dateien:\begin{CompactItemize}
\item 
fps.hpp\item 
fps.cpp\item 
fps\_\-cnf\_\-msg.cpp\item 
fps\_\-const\_\-destr.cpp\item 
fps\_\-func.cpp\item 
fps\_\-getset.cpp\end{CompactItemize}
