\hypertarget{gAEM_8c}{
\section{g\-AEM.c File Reference}
\label{gAEM_8c}\index{gAEM.c@{gAEM.c}}
}
Implements command/response for the AEM.  


{\tt \#include $<$string.h$>$}\par
{\tt \#include \char`\"{}ga\_\-p.h\char`\"{}}\par
{\tt \#include \char`\"{}g\-AEM\_\-p.h\char`\"{}}\par
{\tt \#include \char`\"{}GAEM/g\-AEM.h\char`\"{}}\par
\subsection*{Functions}
\begin{CompactItemize}
\item 
void \hyperlink{gAEM_8c_a0}{set\-Cmd\-Header\-AEM} (\hyperlink{struct__gaem}{gaem\-Handle} ga, \hyperlink{union__cmdHeaderLATp}{cmd\-Header\-LATp} $\ast$ch, unsigned short type, unsigned short bcast, unsigned short inst, unsigned short ext)
\begin{CompactList}\small\item\em initializes a command header structure for a AEM \item\end{CompactList}\item 
void \hyperlink{gAEM_8c_a1}{set\-AEMlocal\-AD} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short func, unsigned short reg, \hyperlink{union__localLATpAD}{local\-LATp\-AD} $\ast$ad)
\begin{CompactList}\small\item\em initializes a local access descriptor structure for a AEM \item\end{CompactList}\item 
void \hyperlink{gAEM_8c_a2}{pack\-Payload\-AEM} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned int cmd\-Header, unsigned int local\-AD, unsigned int value, unsigned int $\ast$payload)
\begin{CompactList}\small\item\em Packs the cmd\-Header, local\-LATp\-AD and value into the 64-bit payload. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a3}{\_\-\_\-aem\-Cmd\-Load} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short func, unsigned short reg, unsigned int value)
\begin{CompactList}\small\item\em Generic routine for sending response-less commands. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a4}{g\-AEMcmd} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short opcode)
\begin{CompactList}\small\item\em Sends a dataless command to the AEM. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a5}{g\-AEMload} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short reg, unsigned int value)
\begin{CompactList}\small\item\em Loads a register with value. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a6}{\_\-\_\-aem\-Cmd\-Read} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short reg, unsigned int $\ast$val)
\begin{CompactList}\small\item\em Reads a register returing value in {\em val\/}. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a7}{g\-AEMread} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short reg, unsigned int $\ast$val)
\begin{CompactList}\small\item\em Reads a register returing value in {\em val\/}. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a8}{g\-AEMlam} (\hyperlink{struct__gaem}{gaem\-Handle} ga)
\begin{CompactList}\small\item\em Sends the \char`\"{}Look At Me\char`\"{} message to the AEM. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a9}{set\-Cmd\-Str\-Parity\-AEM} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short p)
\begin{CompactList}\small\item\em {\em p\/} determines if the AEM command string parity is inverted \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a10}{get\-Cmd\-Str\-Parity\-AEM} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short $\ast$p)
\begin{CompactList}\small\item\em Returns current AEM command string parity. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a11}{set\-Access\-Desc\-Parity\-AEM} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short p)
\begin{CompactList}\small\item\em Sets the current AEM access descriptor parity. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a12}{get\-Access\-Desc\-Parity\-AEM} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short $\ast$p)
\begin{CompactList}\small\item\em Returns current AEM access descriptor parity. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a13}{set\-Cmd\-Payload\-Parity\-AEM} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short p)
\begin{CompactList}\small\item\em {\em p\/} determines if the AEM command payload parity is inverted \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a14}{get\-Cmd\-Payload\-Parity\-AEM} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short $\ast$p)
\begin{CompactList}\small\item\em Returns the current AEM command payload parity. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a15}{g\-AEM\_\-Set\-Addr} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short aem\-Addr)
\begin{CompactList}\small\item\em Sets system wide AEM LATp address. \item\end{CompactList}\item 
int \hyperlink{gAEM_8c_a16}{g\-AEM\_\-Get\-Addr} (\hyperlink{struct__gaem}{gaem\-Handle} ga, unsigned short $\ast$aem\-Addr)
\begin{CompactList}\small\item\em Gets system wide AEM LATp address. \item\end{CompactList}\end{CompactItemize}


\subsection{Detailed Description}
Implements command/response for the AEM. 

\begin{Desc}
\item[Author:]Curt Brune -- \href{mailto:curt@slac.stanford.edu}{\tt curt@slac.stanford.edu} \end{Desc}


\subsection{Function Documentation}
\hypertarget{gAEM_8c_a3}{
\index{gAEM.c@{g\-AEM.c}!__aemCmdLoad@{\_\-\_\-aemCmdLoad}}
\index{__aemCmdLoad@{\_\-\_\-aemCmdLoad}!gAEM.c@{g\-AEM.c}}
\subsubsection[\_\-\_\-aemCmdLoad]{\setlength{\rightskip}{0pt plus 5cm}int \_\-\_\-aem\-Cmd\-Load (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short {\em func}, unsigned short {\em reg}, unsigned int {\em value})}}
\label{gAEM_8c_a3}


Generic routine for sending response-less commands. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em func}]command/response function code \item[{\em reg}]register of AEM to load \item[{\em value}]32-bit value to load into AEM register \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]G\_\-OK on success\end{Desc}
Common subroutine for sending dataless commands and loading AEM on board registers. The {\em func\/} parameter indicates a \char`\"{}dataless\char`\"{} or \char`\"{}load\char`\"{} command.

For dataless commands {\em reg\/} is interpreted as the \char`\"{}opcode\char`\"{} of the dataless command and {\em value\/} is ignored.

For load commands {\em reg\/} is the AEM register to load with {\em value\/}. \hypertarget{gAEM_8c_a6}{
\index{gAEM.c@{g\-AEM.c}!__aemCmdRead@{\_\-\_\-aemCmdRead}}
\index{__aemCmdRead@{\_\-\_\-aemCmdRead}!gAEM.c@{g\-AEM.c}}
\subsubsection[\_\-\_\-aemCmdRead]{\setlength{\rightskip}{0pt plus 5cm}int \_\-\_\-aem\-Cmd\-Read (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short {\em reg}, unsigned int $\ast$ {\em val})}}
\label{gAEM_8c_a6}


Reads a register returing value in {\em val\/}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em reg}]register of AEM to read \item[{\em val}]pointer to storage to hold the response of the read command \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]G\_\-OK on success\end{Desc}
Reads the GAEM register specified by {\em reg\/}. {\em val\/} is filled on return.

The following error codes are returned when LATp errors occur:

\begin{itemize}
\item GERR\_\-LATP\_\-HEADER\_\-PARITY \item GERR\_\-LATP\_\-CELL\_\-PARITY \item GERR\_\-LATP\_\-TRUNCATE \end{itemize}
\hypertarget{gAEM_8c_a16}{
\index{gAEM.c@{g\-AEM.c}!gAEM_GetAddr@{gAEM\_\-GetAddr}}
\index{gAEM_GetAddr@{gAEM\_\-GetAddr}!gAEM.c@{g\-AEM.c}}
\subsubsection[gAEM\_\-GetAddr]{\setlength{\rightskip}{0pt plus 5cm}int g\-AEM\_\-Get\-Addr (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short $\ast$ {\em aem\-Addr})}}
\label{gAEM_8c_a16}


Gets system wide AEM LATp address. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em aem\-Addr}]pointer to hold AEM address \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]G\_\-OK on success \end{Desc}
\begin{Desc}
\item[See also:]\hyperlink{gAEM_8h_a10}{g\-AEM\_\-Set\-Addr()}\end{Desc}
Gets the system-wide AEM LATp address. \hypertarget{gAEM_8c_a15}{
\index{gAEM.c@{g\-AEM.c}!gAEM_SetAddr@{gAEM\_\-SetAddr}}
\index{gAEM_SetAddr@{gAEM\_\-SetAddr}!gAEM.c@{g\-AEM.c}}
\subsubsection[gAEM\_\-SetAddr]{\setlength{\rightskip}{0pt plus 5cm}int g\-AEM\_\-Set\-Addr (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short {\em aem\-Addr})}}
\label{gAEM_8c_a15}


Sets system wide AEM LATp address. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em aem\-Addr}]AEM address \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]G\_\-OK on success\end{Desc}
Sets the system-wide AEM LATp address. This function is intended to be called once during system initialization. It might also be useful during testing. \hypertarget{gAEM_8c_a4}{
\index{gAEM.c@{g\-AEM.c}!gAEMcmd@{gAEMcmd}}
\index{gAEMcmd@{gAEMcmd}!gAEM.c@{g\-AEM.c}}
\subsubsection[gAEMcmd]{\setlength{\rightskip}{0pt plus 5cm}int g\-AEMcmd (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short {\em opcode})}}
\label{gAEM_8c_a4}


Sends a dataless command to the AEM. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em opcode}]opcode of command to send \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]G\_\-OK on success\end{Desc}
Sends the dataless command specified by {\em opcode\/} to the AEM. \hypertarget{gAEM_8c_a8}{
\index{gAEM.c@{g\-AEM.c}!gAEMlam@{gAEMlam}}
\index{gAEMlam@{gAEMlam}!gAEM.c@{g\-AEM.c}}
\subsubsection[gAEMlam]{\setlength{\rightskip}{0pt plus 5cm}int g\-AEMlam (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga})}}
\label{gAEM_8c_a8}


Sends the \char`\"{}Look At Me\char`\"{} message to the AEM. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]G\_\-OK on success\end{Desc}
Sends the \char`\"{}Look At Me\char`\"{} message to the AEM. This is used to switch the command/response wire used by the AEM. If the AEM decodes the \char`\"{}Look At Me\char`\"{} message on either it's A or B command channel it will switch to that channel for future commanding. \hypertarget{gAEM_8c_a5}{
\index{gAEM.c@{g\-AEM.c}!gAEMload@{gAEMload}}
\index{gAEMload@{gAEMload}!gAEM.c@{g\-AEM.c}}
\subsubsection[gAEMload]{\setlength{\rightskip}{0pt plus 5cm}int g\-AEMload (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short {\em reg}, unsigned int {\em value})}}
\label{gAEM_8c_a5}


Loads a register with value. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em reg}]register of AEM to load \item[{\em value}]32-bit value to load into AEM register \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]G\_\-OK on success\end{Desc}
Loads the AEM register specified by {\em reg\/} with {\em value\/} \hypertarget{gAEM_8c_a7}{
\index{gAEM.c@{g\-AEM.c}!gAEMread@{gAEMread}}
\index{gAEMread@{gAEMread}!gAEM.c@{g\-AEM.c}}
\subsubsection[gAEMread]{\setlength{\rightskip}{0pt plus 5cm}int g\-AEMread (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short {\em reg}, unsigned int $\ast$ {\em val})}}
\label{gAEM_8c_a7}


Reads a register returing value in {\em val\/}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em reg}]register of AEM to read \item[{\em val}]pointer to storage to hold the response of the read command \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]G\_\-OK on success\end{Desc}
Reads the AEM register specified by {\em reg\/}. {\em val\/} is filled on return. \hypertarget{gAEM_8c_a12}{
\index{gAEM.c@{g\-AEM.c}!getAccessDescParityAEM@{getAccessDescParityAEM}}
\index{getAccessDescParityAEM@{getAccessDescParityAEM}!gAEM.c@{g\-AEM.c}}
\subsubsection[getAccessDescParityAEM]{\setlength{\rightskip}{0pt plus 5cm}int get\-Access\-Desc\-Parity\-AEM (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short $\ast$ {\em p})}}
\label{gAEM_8c_a12}


Returns current AEM access descriptor parity. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em p}]pointer to hold boolean value \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]STATUS\end{Desc}
if {\em p\/} is non-zero then all out going AEM commands will have their access descriptor parity inverted. This is used for testing parity errors. The default value is 0. \hypertarget{gAEM_8c_a14}{
\index{gAEM.c@{g\-AEM.c}!getCmdPayloadParityAEM@{getCmdPayloadParityAEM}}
\index{getCmdPayloadParityAEM@{getCmdPayloadParityAEM}!gAEM.c@{g\-AEM.c}}
\subsubsection[getCmdPayloadParityAEM]{\setlength{\rightskip}{0pt plus 5cm}int get\-Cmd\-Payload\-Parity\-AEM (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short $\ast$ {\em p})}}
\label{gAEM_8c_a14}


Returns the current AEM command payload parity. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em p}]Pointer to hold boolean value \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]STATUS\end{Desc}
if {\em p\/} is non-zero then all out going AEM commands will have their command payload parity inverted. This is used for testing parity errors. The default value is 0. \hypertarget{gAEM_8c_a10}{
\index{gAEM.c@{g\-AEM.c}!getCmdStrParityAEM@{getCmdStrParityAEM}}
\index{getCmdStrParityAEM@{getCmdStrParityAEM}!gAEM.c@{g\-AEM.c}}
\subsubsection[getCmdStrParityAEM]{\setlength{\rightskip}{0pt plus 5cm}int get\-Cmd\-Str\-Parity\-AEM (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short $\ast$ {\em p})}}
\label{gAEM_8c_a10}


Returns current AEM command string parity. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em p}]pointer to hold boolean value \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]STATUS\end{Desc}
if {\em p\/} is non-zero then all out going AEM commands will have their command string parity inverted. This is used for testing parity errors. The default value is 0. \hypertarget{gAEM_8c_a2}{
\index{gAEM.c@{g\-AEM.c}!packPayloadAEM@{packPayloadAEM}}
\index{packPayloadAEM@{packPayloadAEM}!gAEM.c@{g\-AEM.c}}
\subsubsection[packPayloadAEM]{\setlength{\rightskip}{0pt plus 5cm}void pack\-Payload\-AEM (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned int {\em cmd\-Header}, unsigned int {\em local\-AD}, unsigned int {\em value}, unsigned int $\ast$ {\em payload})}}
\label{gAEM_8c_a2}


Packs the cmd\-Header, local\-LATp\-AD and value into the 64-bit payload. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em cmd\-Header}]32-bit command header word \item[{\em local\-AD}]32-bit local access descriptor word \item[{\em value}]32-bit value to load into AEM register \item[{\em payload}]pointer to 64-bits of pre-allocated storage \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]void\end{Desc}
Packs the bits of {\em cmd\-Header\/}, {\em local\-AD\/} and {\em value\/} into the 64-bits pointed to by {\em payload\/}. The packing is specific to local \char`\"{}on board\char`\"{} registers for the AEM Common Controller. \hypertarget{gAEM_8c_a11}{
\index{gAEM.c@{g\-AEM.c}!setAccessDescParityAEM@{setAccessDescParityAEM}}
\index{setAccessDescParityAEM@{setAccessDescParityAEM}!gAEM.c@{g\-AEM.c}}
\subsubsection[setAccessDescParityAEM]{\setlength{\rightskip}{0pt plus 5cm}int set\-Access\-Desc\-Parity\-AEM (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short {\em p})}}
\label{gAEM_8c_a11}


Sets the current AEM access descriptor parity. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em p}]boolean value \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]STATUS\end{Desc}
if {\em p\/} is non-zero then all out going AEM commands will have their access descriptor parity inverted. This is used for testing parity errors. The default value is 0. \hypertarget{gAEM_8c_a1}{
\index{gAEM.c@{g\-AEM.c}!setAEMlocalAD@{setAEMlocalAD}}
\index{setAEMlocalAD@{setAEMlocalAD}!gAEM.c@{g\-AEM.c}}
\subsubsection[setAEMlocalAD]{\setlength{\rightskip}{0pt plus 5cm}void set\-AEMlocal\-AD (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short {\em func}, unsigned short {\em reg}, \hyperlink{union__localLATpAD}{local\-LATp\-AD} $\ast$ {\em ad})}}
\label{gAEM_8c_a1}


initializes a local access descriptor structure for a AEM 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em func}]AEM fucntion code \item[{\em reg}]register of AEM \item[{\em ad}]pointer to local access descriptor structure \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]void \end{Desc}
\hypertarget{gAEM_8c_a0}{
\index{gAEM.c@{g\-AEM.c}!setCmdHeaderAEM@{setCmdHeaderAEM}}
\index{setCmdHeaderAEM@{setCmdHeaderAEM}!gAEM.c@{g\-AEM.c}}
\subsubsection[setCmdHeaderAEM]{\setlength{\rightskip}{0pt plus 5cm}void set\-Cmd\-Header\-AEM (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, \hyperlink{union__cmdHeaderLATp}{cmd\-Header\-LATp} $\ast$ {\em ch}, unsigned short {\em type}, unsigned short {\em bcast}, unsigned short {\em inst}, unsigned short {\em ext})}}
\label{gAEM_8c_a0}


initializes a command header structure for a AEM 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em ch}]pointer to command header structure \item[{\em type}]type of on board AEM object \item[{\em bcast}]set for broadcast commands \item[{\em inst}]instance (address) of ACD object \item[{\em ext}]set for \char`\"{}off board\char`\"{} commands, i.e. GARC and GAFE commands \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]G\_\-OK on void \end{Desc}
\hypertarget{gAEM_8c_a13}{
\index{gAEM.c@{g\-AEM.c}!setCmdPayloadParityAEM@{setCmdPayloadParityAEM}}
\index{setCmdPayloadParityAEM@{setCmdPayloadParityAEM}!gAEM.c@{g\-AEM.c}}
\subsubsection[setCmdPayloadParityAEM]{\setlength{\rightskip}{0pt plus 5cm}int set\-Cmd\-Payload\-Parity\-AEM (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short {\em p})}}
\label{gAEM_8c_a13}


{\em p\/} determines if the AEM command payload parity is inverted 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em p}]boolean value \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]STATUS\end{Desc}
if {\em p\/} is non-zero then all out going AEM commands will have their command payload parity inverted. This is used for testing parity errors. The default value is 0. \hypertarget{gAEM_8c_a9}{
\index{gAEM.c@{g\-AEM.c}!setCmdStrParityAEM@{setCmdStrParityAEM}}
\index{setCmdStrParityAEM@{setCmdStrParityAEM}!gAEM.c@{g\-AEM.c}}
\subsubsection[setCmdStrParityAEM]{\setlength{\rightskip}{0pt plus 5cm}int set\-Cmd\-Str\-Parity\-AEM (\hyperlink{struct__gaem}{gaem\-Handle} {\em ga}, unsigned short {\em p})}}
\label{gAEM_8c_a9}


{\em p\/} determines if the AEM command string parity is inverted 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ga}]gaem\-Handle for AEM \item[{\em p}]boolean value \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]STATUS\end{Desc}
if {\em p\/} is non-zero then all out going AEM commands will have their command string parity inverted. This is used for testing parity errors. The default value is 0.