\hypertarget{CFG_8h}{
\section{CFG.h File Reference}
\label{CFG_8h}\index{CFG.h@{CFG.h}}
}
CFG structs and defines.  


{\tt \#include \char`\"{}PBI/Endianness.h\char`\"{}}\par


Include dependency graph for CFG.h:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=66pt]{CFG_8h__incl}
\end{center}
\end{figure}


This graph shows which files directly or indirectly include this file:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=53pt]{CFG_8h__dep__incl}
\end{center}
\end{figure}
\subsection*{Data Structures}
\begin{CompactItemize}
\item 
struct \hyperlink{struct__CFG__array}{\_\-CFG\_\-array}
\begin{CompactList}\small\item\em Holds an array of objects of a given type. \item\end{CompactList}\item 
union \hyperlink{union__CFG__arrayTypes}{\_\-CFG\_\-array\-Types}
\begin{CompactList}\small\item\em Union of pointer to different types. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__baf}{\_\-CFG\_\-baf}
\begin{CompactList}\small\item\em Defines the Block Address Field of the two representations of a type/id pair or an address. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__bod}{\_\-CFG\_\-bod}
\begin{CompactList}\small\item\em Beginning of Database block. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__collection}{\_\-CFG\_\-collection}
\begin{CompactList}\small\item\em Defines a collection of values. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__eod}{\_\-CFG\_\-eod}
\begin{CompactList}\small\item\em End of Database block. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__hdr}{\_\-CFG\_\-hdr}
\begin{CompactList}\small\item\em Standard CFG header. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__parameter}{\_\-CFG\_\-parameter}
\begin{CompactList}\small\item\em Simple parameter block. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__relsym}{\_\-CFG\_\-relsym}
\begin{CompactList}\small\item\em Holds one NULL-terminated string that is the name of a relocatable symbol. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__routine}{\_\-CFG\_\-routine}
\begin{CompactList}\small\item\em Describes the parameters of a routine. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__runRoutine}{\_\-CFG\_\-run\-Routine}
\begin{CompactList}\small\item\em Block to run the given routine. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__startTask}{\_\-CFG\_\-start\-Task}
\begin{CompactList}\small\item\em Block to start the given task. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__startTaskByRoutine}{\_\-CFG\_\-start\-Task\-By\-Routine}
\begin{CompactList}\small\item\em Block to run the given routine. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__string}{\_\-CFG\_\-string}
\begin{CompactList}\small\item\em Holds one NULL-terminated string. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__task}{\_\-CFG\_\-task}
\begin{CompactList}\small\item\em Describes the parameters of a task. \item\end{CompactList}\item 
union \hyperlink{union__CFG__typeId__u}{\_\-CFG\_\-type\-Id\_\-u}
\begin{CompactList}\small\item\em Defines the type and id fields as a union of the field representation and the 32-bit representation. \item\end{CompactList}\item 
struct \hyperlink{struct__CFG__typeId__us}{\_\-CFG\_\-type\-Id\_\-us}
\begin{CompactList}\small\item\em Defines a type and id of a configuration block as two separate fields. \item\end{CompactList}\end{CompactItemize}
\subsection*{Defines}
\begin{CompactItemize}
\item 
\#define \hyperlink{CFG_8h_a0}{CFG\_\-TYPE\_\-ID}(\_\-type, \_\-id)\ ((\_\-type $<$$<$ 16) $|$ (\_\-id))
\begin{CompactList}\small\item\em Macro to compose a single 32-bit type/id value from the separate fields. \item\end{CompactList}\end{CompactItemize}
\subsection*{Typedefs}
\begin{CompactItemize}
\item 
\hypertarget{CFG_8h_a1}{
typedef enum \hyperlink{CFG_8h_a47}{\_\-CFG\_\-types} \hyperlink{CFG_8h_a1}{CFG\_\-types}}
\label{CFG_8h_a1}

\begin{CompactList}\small\item\em Typedef for enum \_\-CFG\_\-type, use in CFG\_\-type. \item\end{CompactList}\item 
typedef enum \hyperlink{CFG_8h_a48}{\_\-CFG\_\-dtype} \hyperlink{CFG_8h_a2}{CFG\_\-dtype}
\begin{CompactList}\small\item\em Typedef for enum \_\-CFG\_\-dtype. \item\end{CompactList}\item 
\hypertarget{CFG_8h_a3}{
typedef unsigned short int \hyperlink{CFG_8h_a3}{CFG\_\-type}}
\label{CFG_8h_a3}

\begin{CompactList}\small\item\em Defines datasize of item type, use enums from CFG\_\-types. \item\end{CompactList}\item 
\hypertarget{CFG_8h_a4}{
typedef unsigned short int \hyperlink{CFG_8h_a4}{CFG\_\-id}}
\label{CFG_8h_a4}

\begin{CompactList}\small\item\em Defines datasize of item id. \item\end{CompactList}\item 
\hypertarget{CFG_8h_a5}{
typedef unsigned int \hyperlink{CFG_8h_a5}{CFG\_\-type\-Id}}
\label{CFG_8h_a5}

\begin{CompactList}\small\item\em Defines datasize of item type\-Id. \item\end{CompactList}\item 
\hypertarget{CFG_8h_a6}{
typedef \hyperlink{struct__CFG__typeId__us}{\_\-CFG\_\-type\-Id\_\-us} \hyperlink{CFG_8h_a6}{CFG\_\-type\-Id\_\-us}}
\label{CFG_8h_a6}

\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__typeId__us}{\_\-CFG\_\-type\-Id\_\-us}. \item\end{CompactList}\item 
\hypertarget{CFG_8h_a7}{
typedef \hyperlink{union__CFG__typeId__u}{\_\-CFG\_\-type\-Id\_\-u} \hyperlink{CFG_8h_a7}{CFG\_\-type\-Id\_\-u}}
\label{CFG_8h_a7}

\begin{CompactList}\small\item\em Typedef for struct \hyperlink{union__CFG__typeId__u}{\_\-CFG\_\-type\-Id\_\-u}. \item\end{CompactList}\item 
typedef \hyperlink{struct__CFG__baf}{\_\-CFG\_\-baf} \hyperlink{CFG_8h_a8}{CFG\_\-baf}
\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__baf}{\_\-CFG\_\-baf}. \item\end{CompactList}\item 
\hypertarget{CFG_8h_a9}{
typedef \hyperlink{struct__CFG__hdr}{\_\-CFG\_\-hdr} \hyperlink{CFG_8h_a9}{CFG\_\-hdr}}
\label{CFG_8h_a9}

\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__hdr}{\_\-CFG\_\-hdr}. \item\end{CompactList}\item 
typedef \hyperlink{struct__CFG__hdr}{CFG\_\-hdr} \hyperlink{CFG_8h_a10}{CFG\_\-db}
\begin{CompactList}\small\item\em Points to start of db. \item\end{CompactList}\item 
typedef \hyperlink{struct__CFG__bod}{\_\-CFG\_\-bod} \hyperlink{CFG_8h_a11}{CFG\_\-bod}
\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__bod}{\_\-CFG\_\-bod}. \item\end{CompactList}\item 
typedef \hyperlink{struct__CFG__eod}{\_\-CFG\_\-eod} \hyperlink{CFG_8h_a12}{CFG\_\-eod}
\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__eod}{\_\-CFG\_\-eod}. \item\end{CompactList}\item 
typedef \hyperlink{struct__CFG__parameter}{\_\-CFG\_\-parameter} \hyperlink{CFG_8h_a13}{CFG\_\-parameter}
\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__parameter}{\_\-CFG\_\-parameter}. \item\end{CompactList}\item 
\hypertarget{CFG_8h_a14}{
typedef \hyperlink{union__CFG__arrayTypes}{\_\-CFG\_\-array\-Types} \hyperlink{CFG_8h_a14}{CFG\_\-array\-Types}}
\label{CFG_8h_a14}

\begin{CompactList}\small\item\em Typedef for union \hyperlink{union__CFG__arrayTypes}{\_\-CFG\_\-array\-Types}. \item\end{CompactList}\item 
\hypertarget{CFG_8h_a15}{
typedef \hyperlink{struct__CFG__array}{\_\-CFG\_\-array} \hyperlink{CFG_8h_a15}{CFG\_\-array}}
\label{CFG_8h_a15}

\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__array}{\_\-CFG\_\-array}. \item\end{CompactList}\item 
typedef \hyperlink{struct__CFG__collection}{\_\-CFG\_\-collection} \hyperlink{CFG_8h_a16}{CFG\_\-collection}
\begin{CompactList}\small\item\em Typedef for CFG\_\-collection. \item\end{CompactList}\item 
\hypertarget{CFG_8h_a17}{
typedef \hyperlink{struct__CFG__string}{\_\-CFG\_\-string} \hyperlink{CFG_8h_a17}{CFG\_\-string}}
\label{CFG_8h_a17}

\begin{CompactList}\small\item\em Typedef for CFG\_\-string. \item\end{CompactList}\item 
\hypertarget{CFG_8h_a18}{
typedef \hyperlink{struct__CFG__relsym}{\_\-CFG\_\-relsym} \hyperlink{CFG_8h_a18}{CFG\_\-relsym}}
\label{CFG_8h_a18}

\begin{CompactList}\small\item\em Typedef for CFG\_\-relsym. \item\end{CompactList}\item 
typedef \hyperlink{struct__CFG__task}{\_\-CFG\_\-task} \hyperlink{CFG_8h_a19}{CFG\_\-task}
\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__task}{\_\-CFG\_\-task}. \item\end{CompactList}\item 
typedef \hyperlink{struct__CFG__startTask}{\_\-CFG\_\-start\-Task} \hyperlink{CFG_8h_a20}{CFG\_\-start\-Task}
\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__startTask}{\_\-CFG\_\-start\-Task}. \item\end{CompactList}\item 
typedef \hyperlink{struct__CFG__startTaskByRoutine}{\_\-CFG\_\-start\-Task\-By\-Routine} \hyperlink{CFG_8h_a21}{CFG\_\-start\-Task\-By\-Routine}
\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__startTaskByRoutine}{\_\-CFG\_\-start\-Task\-By\-Routine}. \item\end{CompactList}\item 
typedef \hyperlink{struct__CFG__routine}{\_\-CFG\_\-routine} \hyperlink{CFG_8h_a22}{CFG\_\-routine}
\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__routine}{\_\-CFG\_\-routine}. \item\end{CompactList}\item 
typedef \hyperlink{struct__CFG__runRoutine}{\_\-CFG\_\-run\-Routine} \hyperlink{CFG_8h_a23}{CFG\_\-run\-Routine}
\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__CFG__runRoutine}{\_\-CFG\_\-run\-Routine}. \item\end{CompactList}\end{CompactItemize}
\subsection*{Enumerations}
\begin{CompactItemize}
\item 
enum \hyperlink{CFG_8h_a47}{\_\-CFG\_\-types} \{ \par
\hyperlink{CFG_8h_a47a24}{CFG\_\-TYPE\_\-K\_\-BOD} =  0xbbb0, 
\par
\hyperlink{CFG_8h_a47a25}{CFG\_\-TYPE\_\-K\_\-EOD} =  0xeee0, 
\par
\hyperlink{CFG_8h_a47a26}{CFG\_\-TYPE\_\-K\_\-STRING} =  1, 
\par
\hyperlink{CFG_8h_a47a27}{CFG\_\-TYPE\_\-K\_\-PARAMETER} =  2, 
\par
\hyperlink{CFG_8h_a47a28}{CFG\_\-TYPE\_\-K\_\-ARRAY} =  3, 
\par
\hyperlink{CFG_8h_a47a29}{CFG\_\-TYPE\_\-K\_\-COLLECTION} =  4, 
\par
\hyperlink{CFG_8h_a47a30}{CFG\_\-TYPE\_\-K\_\-RELSYM} =  5, 
\par
\hyperlink{CFG_8h_a47a31}{CFG\_\-TYPE\_\-K\_\-DESC\_\-TASK} =  6, 
\par
\hyperlink{CFG_8h_a47a32}{CFG\_\-TYPE\_\-K\_\-DESC\_\-ROUTINE} =  7, 
\par
\hyperlink{CFG_8h_a47a33}{CFG\_\-TYPE\_\-K\_\-START\_\-TASK} =  0x10, 
\par
\hyperlink{CFG_8h_a47a34}{CFG\_\-TYPE\_\-K\_\-RUN\_\-ROUTINE} =  0x11, 
\par
\hyperlink{CFG_8h_a47a35}{CFG\_\-TYPE\_\-K\_\-START\_\-TASK\_\-RTN} =  0x12
 \}
\begin{CompactList}\small\item\em Enumerate the supported configuration block types. \item\end{CompactList}\item 
enum \hyperlink{CFG_8h_a48}{\_\-CFG\_\-dtype} \{ \par
\hyperlink{CFG_8h_a48a36}{CFG\_\-K\_\-DTYPE\_\-UNDEF} =  -1, 
\par
\hyperlink{CFG_8h_a48a37}{CFG\_\-K\_\-DTYPE\_\-BU} =  0, 
\par
\hyperlink{CFG_8h_a48a38}{CFG\_\-K\_\-DTYPE\_\-BS} =  1, 
\par
\hyperlink{CFG_8h_a48a39}{CFG\_\-K\_\-DTYPE\_\-SU} =  2, 
\par
\hyperlink{CFG_8h_a48a40}{CFG\_\-K\_\-DTYPE\_\-SS} =  3, 
\par
\hyperlink{CFG_8h_a48a41}{CFG\_\-K\_\-DTYPE\_\-IU} =  4, 
\par
\hyperlink{CFG_8h_a48a42}{CFG\_\-K\_\-DTYPE\_\-IS} =  5, 
\par
\hyperlink{CFG_8h_a48a43}{CFG\_\-K\_\-DTYPE\_\-LLU} =  6, 
\par
\hyperlink{CFG_8h_a48a44}{CFG\_\-K\_\-DTYPE\_\-LLS} =  7, 
\par
\hyperlink{CFG_8h_a48a45}{CFG\_\-K\_\-DTYPE\_\-F} =  8, 
\par
\hyperlink{CFG_8h_a48a46}{CFG\_\-K\_\-DTYPE\_\-D} =  9
 \}
\begin{CompactList}\small\item\em Enumerates the support data types. \item\end{CompactList}\end{CompactItemize}


\subsection{Detailed Description}
CFG structs and defines. 

\begin{Desc}
\item[Author:]Ed Bacho -- \href{mailto:ebacho@slac.stanford.edu}{\tt ebacho@slac.stanford.edu} \end{Desc}
These are the structs and defines needed by both the write and read sides of the CFG system.

\subsection{Define Documentation}
\hypertarget{CFG_8h_a0}{
\index{CFG.h@{CFG.h}!CFG_TYPE_ID@{CFG\_\-TYPE\_\-ID}}
\index{CFG_TYPE_ID@{CFG\_\-TYPE\_\-ID}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-TYPE\_\-ID]{\setlength{\rightskip}{0pt plus 5cm}\#define CFG\_\-TYPE\_\-ID(\_\-type, \_\-id)\ ((\_\-type $<$$<$ 16) $|$ (\_\-id))}}
\label{CFG_8h_a0}


Macro to compose a single 32-bit type/id value from the separate fields. 

((\_\-type $<$$<$ 16) $|$ (\_\-id)) 

\begin{Desc}
\item[Returns:]A single 32-bit value representing the type and id\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-type}]The block type \item[{\em \_\-id}]The block id \end{description}
\end{Desc}


\subsection{Typedef Documentation}
\hypertarget{CFG_8h_a8}{
\index{CFG.h@{CFG.h}!CFG_baf@{CFG\_\-baf}}
\index{CFG_baf@{CFG\_\-baf}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-baf]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{struct__CFG__baf}{CFG\_\-baf}}}
\label{CFG_8h_a8}


Typedef for struct \hyperlink{struct__CFG__baf}{\_\-CFG\_\-baf}. 

\begin{Desc}
\item[]All known CFG blocks with type/ids used to reference other blocks have their type/ids replaced with the block address. This would apply to relocable symbols, but not collections where one does not know a priori which are which.... \end{Desc}
\hypertarget{CFG_8h_a11}{
\index{CFG.h@{CFG.h}!CFG_bod@{CFG\_\-bod}}
\index{CFG_bod@{CFG\_\-bod}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-bod]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{struct__CFG__bod}{CFG\_\-bod}}}
\label{CFG_8h_a11}


Typedef for struct \hyperlink{struct__CFG__bod}{\_\-CFG\_\-bod}. 

\begin{Desc}
\item[]Every CFG data base object must start with this mandatory block \end{Desc}
\hypertarget{CFG_8h_a16}{
\index{CFG.h@{CFG.h}!CFG_collection@{CFG\_\-collection}}
\index{CFG_collection@{CFG\_\-collection}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-collection]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{struct__CFG__collection}{CFG\_\-collection}}}
\label{CFG_8h_a16}


Typedef for CFG\_\-collection. 

\begin{Desc}
\item[]A collection block consists of a counted array of 32-bit objects. These objects may be simple 32-bit values or they may be 32-bit type + id pairs that reference another block. The fixup stage resolves the type/id pairs to addresses. In order to do this, the fixup stage must know which are values, {\em i.e\/}. hands off and which are type/ids. It does this by consulting a bit array contained in the 32-bit words immediately following the data. Each bit indicates\end{Desc}
\begin{itemize}
\item 0, corresponding entry is a value\item 1, corresponding entry is a type/id pair\end{itemize}


\begin{Desc}
\item[]The bits are packed big-endian style so that the entry corresponds with bit 0, the most significant bit, of the first word following the data words.\end{Desc}
\begin{Desc}
\item[Example]Suppose one has a collection given by\end{Desc}
Define\_\-Parameter\-Id(Z, 10, 20); Define\_\-Collection\-Id(A, 11, Val(1), Val(2), Type\-Id(Z), Val(3));

\begin{Desc}
\item[]The block would look like\end{Desc}


\footnotesize\begin{verbatim}             length in bytes:                            32
                                 CFG_TYPE_K_COLLECTION | 11
             number of dat's                              4
                      dat[0]                              1
                      dat[1]                              2
                      dat[2]      CFG_TYPE_K_PARAMETER | 10
                      dat[3]                              3
                      dat[4]                     0x20000000
\end{verbatim}\normalsize


\begin{Desc}
\item[]The number of data objects is 4, accounting for dat\mbox{[}0-3\mbox{]}. One needs 1 more word to hold the bit mask of object types. Since only object \#2 (using zero based counting) is a type/id pair, only bit 3 is set. \end{Desc}
\hypertarget{CFG_8h_a10}{
\index{CFG.h@{CFG.h}!CFG_db@{CFG\_\-db}}
\index{CFG_db@{CFG\_\-db}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-db]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{struct__CFG__hdr}{CFG\_\-db}}}
\label{CFG_8h_a10}


Points to start of db. 

\begin{Desc}
\item[]Every CFG data object must start with this identifying header \end{Desc}
\hypertarget{CFG_8h_a2}{
\index{CFG.h@{CFG.h}!CFG_dtype@{CFG\_\-dtype}}
\index{CFG_dtype@{CFG\_\-dtype}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-dtype]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{CFG_8h_a2}{CFG\_\-dtype}}}
\label{CFG_8h_a2}


Typedef for enum \_\-CFG\_\-dtype. 

\begin{Desc}
\item[]This mainly used in connection with array types, but eventually could find uses elsewhere. \end{Desc}
\hypertarget{CFG_8h_a12}{
\index{CFG.h@{CFG.h}!CFG_eod@{CFG\_\-eod}}
\index{CFG_eod@{CFG\_\-eod}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-eod]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{struct__CFG__eod}{CFG\_\-eod}}}
\label{CFG_8h_a12}


Typedef for struct \hyperlink{struct__CFG__eod}{\_\-CFG\_\-eod}. 

\begin{Desc}
\item[]Every CFG data base object must end with this mandatory block \end{Desc}
\hypertarget{CFG_8h_a13}{
\index{CFG.h@{CFG.h}!CFG_parameter@{CFG\_\-parameter}}
\index{CFG_parameter@{CFG\_\-parameter}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-parameter]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{struct__CFG__parameter}{CFG\_\-parameter}}}
\label{CFG_8h_a13}


Typedef for struct \hyperlink{struct__CFG__parameter}{\_\-CFG\_\-parameter}. 

\begin{Desc}
\item[]A parameter block carries the standard identifying header and one 32 value. It is the simplest block in the system \end{Desc}
\hypertarget{CFG_8h_a22}{
\index{CFG.h@{CFG.h}!CFG_routine@{CFG\_\-routine}}
\index{CFG_routine@{CFG\_\-routine}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-routine]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{struct__CFG__routine}{CFG\_\-routine}}}
\label{CFG_8h_a22}


Typedef for struct \hyperlink{struct__CFG__routine}{\_\-CFG\_\-routine}. 

\begin{Desc}
\item[]This block describes the parameters associated with a routine. It does not start a task, that is the job of Run\_\-Routine macro \end{Desc}
\hypertarget{CFG_8h_a23}{
\index{CFG.h@{CFG.h}!CFG_runRoutine@{CFG\_\-runRoutine}}
\index{CFG_runRoutine@{CFG\_\-runRoutine}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-runRoutine]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{struct__CFG__runRoutine}{CFG\_\-run\-Routine}}}
\label{CFG_8h_a23}


Typedef for struct \hyperlink{struct__CFG__runRoutine}{\_\-CFG\_\-run\-Routine}. 

\begin{Desc}
\item[]This block runs the routine described in CFG\_\-routine \end{Desc}
\hypertarget{CFG_8h_a20}{
\index{CFG.h@{CFG.h}!CFG_startTask@{CFG\_\-startTask}}
\index{CFG_startTask@{CFG\_\-startTask}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-startTask]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{struct__CFG__startTask}{CFG\_\-start\-Task}}}
\label{CFG_8h_a20}


Typedef for struct \hyperlink{struct__CFG__startTask}{\_\-CFG\_\-start\-Task}. 

\begin{Desc}
\item[]This block starts the task described in CFG\_\-task \end{Desc}
\hypertarget{CFG_8h_a21}{
\index{CFG.h@{CFG.h}!CFG_startTaskByRoutine@{CFG\_\-startTaskByRoutine}}
\index{CFG_startTaskByRoutine@{CFG\_\-startTaskByRoutine}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-startTaskByRoutine]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{struct__CFG__startTaskByRoutine}{CFG\_\-start\-Task\-By\-Routine}}}
\label{CFG_8h_a21}


Typedef for struct \hyperlink{struct__CFG__startTaskByRoutine}{\_\-CFG\_\-start\-Task\-By\-Routine}. 

\begin{Desc}
\item[]This block runs the start routine described in CFG\_\-task \end{Desc}
\hypertarget{CFG_8h_a19}{
\index{CFG.h@{CFG.h}!CFG_task@{CFG\_\-task}}
\index{CFG_task@{CFG\_\-task}!CFG.h@{CFG.h}}
\subsubsection[CFG\_\-task]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{struct__CFG__task}{CFG\_\-task}}}
\label{CFG_8h_a19}


Typedef for struct \hyperlink{struct__CFG__task}{\_\-CFG\_\-task}. 

\begin{Desc}
\item[]This block describes the parameters associated with a task. It does not start a task, that is the job of Start\_\-Task macro \end{Desc}


\subsection{Enumeration Type Documentation}
\hypertarget{CFG_8h_a48}{
\index{CFG.h@{CFG.h}!_CFG_dtype@{\_\-CFG\_\-dtype}}
\index{_CFG_dtype@{\_\-CFG\_\-dtype}!CFG.h@{CFG.h}}
\subsubsection[\_\-CFG\_\-dtype]{\setlength{\rightskip}{0pt plus 5cm}enum \hyperlink{CFG_8h_a48}{\_\-CFG\_\-dtype}}}
\label{CFG_8h_a48}


Enumerates the support data types. 

\begin{Desc}
\item[Enumeration values: ]\par
\begin{description}
\index{CFG_K_DTYPE_UNDEF@{CFG\_\-K\_\-DTYPE\_\-UNDEF}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_K_DTYPE_UNDEF@{CFG\_\-K\_\-DTYPE\_\-UNDEF}}\item[{\em 
\hypertarget{CFG_8h_a48a36}{
{\em CFG\_\-K\_\-DTYPE\_\-UNDEF}}
\label{CFG_8h_a48a36}
}]unspecified \index{CFG_K_DTYPE_BU@{CFG\_\-K\_\-DTYPE\_\-BU}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_K_DTYPE_BU@{CFG\_\-K\_\-DTYPE\_\-BU}}\item[{\em 
\hypertarget{CFG_8h_a48a37}{
{\em CFG\_\-K\_\-DTYPE\_\-BU}}
\label{CFG_8h_a48a37}
}]byte (unsigned) \index{CFG_K_DTYPE_BS@{CFG\_\-K\_\-DTYPE\_\-BS}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_K_DTYPE_BS@{CFG\_\-K\_\-DTYPE\_\-BS}}\item[{\em 
\hypertarget{CFG_8h_a48a38}{
{\em CFG\_\-K\_\-DTYPE\_\-BS}}
\label{CFG_8h_a48a38}
}]byte ( signed) \index{CFG_K_DTYPE_SU@{CFG\_\-K\_\-DTYPE\_\-SU}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_K_DTYPE_SU@{CFG\_\-K\_\-DTYPE\_\-SU}}\item[{\em 
\hypertarget{CFG_8h_a48a39}{
{\em CFG\_\-K\_\-DTYPE\_\-SU}}
\label{CFG_8h_a48a39}
}]short (unsigned) \index{CFG_K_DTYPE_SS@{CFG\_\-K\_\-DTYPE\_\-SS}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_K_DTYPE_SS@{CFG\_\-K\_\-DTYPE\_\-SS}}\item[{\em 
\hypertarget{CFG_8h_a48a40}{
{\em CFG\_\-K\_\-DTYPE\_\-SS}}
\label{CFG_8h_a48a40}
}]short ( signed) \index{CFG_K_DTYPE_IU@{CFG\_\-K\_\-DTYPE\_\-IU}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_K_DTYPE_IU@{CFG\_\-K\_\-DTYPE\_\-IU}}\item[{\em 
\hypertarget{CFG_8h_a48a41}{
{\em CFG\_\-K\_\-DTYPE\_\-IU}}
\label{CFG_8h_a48a41}
}]integer (unsigned) \index{CFG_K_DTYPE_IS@{CFG\_\-K\_\-DTYPE\_\-IS}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_K_DTYPE_IS@{CFG\_\-K\_\-DTYPE\_\-IS}}\item[{\em 
\hypertarget{CFG_8h_a48a42}{
{\em CFG\_\-K\_\-DTYPE\_\-IS}}
\label{CFG_8h_a48a42}
}]integer ( signed) \index{CFG_K_DTYPE_LLU@{CFG\_\-K\_\-DTYPE\_\-LLU}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_K_DTYPE_LLU@{CFG\_\-K\_\-DTYPE\_\-LLU}}\item[{\em 
\hypertarget{CFG_8h_a48a43}{
{\em CFG\_\-K\_\-DTYPE\_\-LLU}}
\label{CFG_8h_a48a43}
}]long long (unsigned) \index{CFG_K_DTYPE_LLS@{CFG\_\-K\_\-DTYPE\_\-LLS}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_K_DTYPE_LLS@{CFG\_\-K\_\-DTYPE\_\-LLS}}\item[{\em 
\hypertarget{CFG_8h_a48a44}{
{\em CFG\_\-K\_\-DTYPE\_\-LLS}}
\label{CFG_8h_a48a44}
}]long long ( signed) \index{CFG_K_DTYPE_F@{CFG\_\-K\_\-DTYPE\_\-F}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_K_DTYPE_F@{CFG\_\-K\_\-DTYPE\_\-F}}\item[{\em 
\hypertarget{CFG_8h_a48a45}{
{\em CFG\_\-K\_\-DTYPE\_\-F}}
\label{CFG_8h_a48a45}
}]Single precision float \index{CFG_K_DTYPE_D@{CFG\_\-K\_\-DTYPE\_\-D}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_K_DTYPE_D@{CFG\_\-K\_\-DTYPE\_\-D}}\item[{\em 
\hypertarget{CFG_8h_a48a46}{
{\em CFG\_\-K\_\-DTYPE\_\-D}}
\label{CFG_8h_a48a46}
}]Double precision float \end{description}
\end{Desc}

\hypertarget{CFG_8h_a47}{
\index{CFG.h@{CFG.h}!_CFG_types@{\_\-CFG\_\-types}}
\index{_CFG_types@{\_\-CFG\_\-types}!CFG.h@{CFG.h}}
\subsubsection[\_\-CFG\_\-types]{\setlength{\rightskip}{0pt plus 5cm}enum \hyperlink{CFG_8h_a47}{\_\-CFG\_\-types}}}
\label{CFG_8h_a47}


Enumerate the supported configuration block types. 

\begin{Desc}
\item[Enumeration values: ]\par
\begin{description}
\index{CFG_TYPE_K_BOD@{CFG\_\-TYPE\_\-K\_\-BOD}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_BOD@{CFG\_\-TYPE\_\-K\_\-BOD}}\item[{\em 
\hypertarget{CFG_8h_a47a24}{
{\em CFG\_\-TYPE\_\-K\_\-BOD}}
\label{CFG_8h_a47a24}
}]Beginning of Data Base \index{CFG_TYPE_K_EOD@{CFG\_\-TYPE\_\-K\_\-EOD}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_EOD@{CFG\_\-TYPE\_\-K\_\-EOD}}\item[{\em 
\hypertarget{CFG_8h_a47a25}{
{\em CFG\_\-TYPE\_\-K\_\-EOD}}
\label{CFG_8h_a47a25}
}]End of Data Base \index{CFG_TYPE_K_STRING@{CFG\_\-TYPE\_\-K\_\-STRING}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_STRING@{CFG\_\-TYPE\_\-K\_\-STRING}}\item[{\em 
\hypertarget{CFG_8h_a47a26}{
{\em CFG\_\-TYPE\_\-K\_\-STRING}}
\label{CFG_8h_a47a26}
}]Holds one string block \index{CFG_TYPE_K_PARAMETER@{CFG\_\-TYPE\_\-K\_\-PARAMETER}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_PARAMETER@{CFG\_\-TYPE\_\-K\_\-PARAMETER}}\item[{\em 
\hypertarget{CFG_8h_a47a27}{
{\em CFG\_\-TYPE\_\-K\_\-PARAMETER}}
\label{CFG_8h_a47a27}
}]Holds one parameter, of type {\em dtype\/} \index{CFG_TYPE_K_ARRAY@{CFG\_\-TYPE\_\-K\_\-ARRAY}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_ARRAY@{CFG\_\-TYPE\_\-K\_\-ARRAY}}\item[{\em 
\hypertarget{CFG_8h_a47a28}{
{\em CFG\_\-TYPE\_\-K\_\-ARRAY}}
\label{CFG_8h_a47a28}
}]Holds an array of type {\em dtype\/} \index{CFG_TYPE_K_COLLECTION@{CFG\_\-TYPE\_\-K\_\-COLLECTION}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_COLLECTION@{CFG\_\-TYPE\_\-K\_\-COLLECTION}}\item[{\em 
\hypertarget{CFG_8h_a47a29}{
{\em CFG\_\-TYPE\_\-K\_\-COLLECTION}}
\label{CFG_8h_a47a29}
}]Holds a collection of N integers or type $|$ id pairs \index{CFG_TYPE_K_RELSYM@{CFG\_\-TYPE\_\-K\_\-RELSYM}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_RELSYM@{CFG\_\-TYPE\_\-K\_\-RELSYM}}\item[{\em 
\hypertarget{CFG_8h_a47a30}{
{\em CFG\_\-TYPE\_\-K\_\-RELSYM}}
\label{CFG_8h_a47a30}
}]Holds the name of one relocatably symbol \index{CFG_TYPE_K_DESC_TASK@{CFG\_\-TYPE\_\-K\_\-DESC\_\-TASK}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_DESC_TASK@{CFG\_\-TYPE\_\-K\_\-DESC\_\-TASK}}\item[{\em 
\hypertarget{CFG_8h_a47a31}{
{\em CFG\_\-TYPE\_\-K\_\-DESC\_\-TASK}}
\label{CFG_8h_a47a31}
}]Holds the description of a task \index{CFG_TYPE_K_DESC_ROUTINE@{CFG\_\-TYPE\_\-K\_\-DESC\_\-ROUTINE}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_DESC_ROUTINE@{CFG\_\-TYPE\_\-K\_\-DESC\_\-ROUTINE}}\item[{\em 
\hypertarget{CFG_8h_a47a32}{
{\em CFG\_\-TYPE\_\-K\_\-DESC\_\-ROUTINE}}
\label{CFG_8h_a47a32}
}]Holds the description of a routine \index{CFG_TYPE_K_START_TASK@{CFG\_\-TYPE\_\-K\_\-START\_\-TASK}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_START_TASK@{CFG\_\-TYPE\_\-K\_\-START\_\-TASK}}\item[{\em 
\hypertarget{CFG_8h_a47a33}{
{\em CFG\_\-TYPE\_\-K\_\-START\_\-TASK}}
\label{CFG_8h_a47a33}
}]Holds a Start/Task order \index{CFG_TYPE_K_RUN_ROUTINE@{CFG\_\-TYPE\_\-K\_\-RUN\_\-ROUTINE}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_RUN_ROUTINE@{CFG\_\-TYPE\_\-K\_\-RUN\_\-ROUTINE}}\item[{\em 
\hypertarget{CFG_8h_a47a34}{
{\em CFG\_\-TYPE\_\-K\_\-RUN\_\-ROUTINE}}
\label{CFG_8h_a47a34}
}]Holds a Run/Routine order \index{CFG_TYPE_K_START_TASK_RTN@{CFG\_\-TYPE\_\-K\_\-START\_\-TASK\_\-RTN}!CFG.h@{CFG.h}}\index{CFG.h@{CFG.h}!CFG_TYPE_K_START_TASK_RTN@{CFG\_\-TYPE\_\-K\_\-START\_\-TASK\_\-RTN}}\item[{\em 
\hypertarget{CFG_8h_a47a35}{
{\em CFG\_\-TYPE\_\-K\_\-START\_\-TASK\_\-RTN}}
\label{CFG_8h_a47a35}
}]Holds a Start Task by Start\-Routine order \end{description}
\end{Desc}