Using this module clients can simulate a device with an input channel and
an output channel.
Generator channels are used to generate sequences of constants, sine waves,
random noise, or other streams of data defined by a user function.
When a channel is opened, the user gets to specify a function to simulate
the input channel and a function to simulate the output channel
characteristics.
The Generator module can be configured to process the io just like
a real driver, where a
submit call will return pending and
io will be completed in the context of an isr. This mode is called
returnPending.
However the user has to call
simulateIsrFxn in an isr, Swi or a
Task to support this mode. In simulateIsr, one pending IO Packet for both
channel for all Generator instances is processed.
const Generator.NUMCHANS |
 |
Number of channels per generator device
XDCscript usage |
meta-domain |
const Generator.NUMCHANS = 2;
#define Generator_NUMCHANS (Int)2
DETAILS
one input and one output channel
typedef Generator.GenFunc |
 |
typedef for user specified I/O generators
typedef Void (*Generator_GenFunc)(Ptr,SizeT,UArg);
DETAILS
Functions of this type get passed the buffer, buffer size and a
function specific argument
metaonly struct Generator.BasicView |
 |
XDCscript usage |
meta-domain |
var obj = new Generator.BasicView;
obj.label = String ...
struct Generator.ChanParams |
 |
Channel parameters used along with open
XDCscript usage |
meta-domain |
var obj = new Generator.ChanParams;
obj.userFxn = Void(*)(Ptr,SizeT,UArg) ...
obj.userArg = UArg ...
obj.returnPending = Bool ...
typedef struct Generator_ChanParams {
UArg userArg;
Bool returnPending;
} Generator_ChanParams;
metaonly struct Generator.GeneratorView |
 |
XDCscript usage |
meta-domain |
var obj = new Generator.GeneratorView;
obj.mode = String ...
obj.inUse = Bool ...
obj.returnPending = Bool ...
obj.callbackFxn = String[] ...
obj.callbackArg = UArg ...
obj.userFxn = String[] ...
obj.userArg = UArg ...
metaonly config Generator.common$ // module-wide |
 |
Common module configuration parameters
XDCscript usage |
meta-domain |
DETAILS
All modules have this configuration parameter. Its name
contains the '$' character to ensure it does not conflict with
configuration parameters declared by the module. This allows
new configuration parameters to be added in the future without
any chance of breaking existing modules.
metaonly config Generator.rovViewInfo // module-wide |
 |
XDCscript usage |
meta-domain |
Generator.simulateIsr( ) // module-wide |
 |
This function is used to give energy to the Generator
driver to process its IO packets. It simulates real ISR
Void Generator_simulateIsr( UArg arg );
DETAILS
The application needs to call this function within a hwi, swi or
task thread if any channels are opened in
returnPending
mode.
The Generator module will process all channels with returnPending set
to true within this function. One packet per channel for all
generator instances gets processed during a single call to this
function.
module-wide built-ins |
 |
// Get this module's unique id
Bool Generator_Module_startupDone( );
// Test if this module has completed startup
// The heap from which this module allocates memory
Bool Generator_Module_hasMask( );
// Test whether this module has a diagnostics mask
Bits16 Generator_Module_getMask( );
// Returns the diagnostics mask for this module
Void Generator_Module_setMask( Bits16 mask );
// Set the diagnostics mask for this module
per-instance object types |
 |
typedef struct Generator_Object Generator_Object;
// Opaque internal representation of an instance object
// Client reference to an instance object
typedef struct Generator_Struct Generator_Struct;
// Opaque client structure large enough to hold an instance object
// Convert this instance structure pointer into an instance handle
// Convert this instance handle into an instance structure pointer
per-instance config parameters |
 |
XDCscript usage |
meta-domain |
var params = new Generator.Params;
// Instance config-params object
typedef struct Generator_Params {
// Instance config-params structure
// Common per-instance configs
} Generator_Params;
// Initialize this config-params structure with supplier-specified defaults before instance creation
Generator.close( ) // per-instance |
 |
Close a channel. Raises an error upon failure
ARGUMENTS
handle
handle of a previously-created Generator instance object
chanHandle
opaque channel handle
eb
error block
DETAILS
For example, trying to close a channel which is NOT in use could raise
an error. The error could be driver specific or generic errors defined
by
ti.sdo.io.DriverTypes
Generator.control( ) // per-instance |
 |
Send driver specific command to channel or associated device
ARGUMENTS
handle
handle of a previously-created Generator instance object
chanHandle
opaque channel handle
cmd
control command
cmdArgs
command argument
eb
error block
Generator.open( ) // per-instance |
 |
Open a channel
ARGUMENTS
handle
handle of a previously-created Generator instance object
name
name string
mode
open mode for channel
chanParams
driver specific channel parameters
cbFxn
callback function
cbArg
callback function arg
eb
error block
RETURNS
opaque channel handle
DETAILS
Use this function to open a channel. The name parameter allows for
driver specific configuration. e.g when a channel id is required. The
name will be null for most drivers. The mode is either
ti.sdo.io.DriverTypes.INPUT or
ti.sdo.io.DriverTypes.OUTPUT.
chanParams are driver specific. When chanparams is null driver will use
default params which were statically configured. The callback function
and arg are used to indicate completion of IO after an async
submit call. The driver will raise an error when open fails and
the error block will contain a driver specific error or a generic error
defined by
ti.sdo.io.DriverTypes.
open returns a driver specific opaque channel handle.
Note that open() can be called at Startup time and the driver
has to ensure that open() returns the channel pointer even though the
driver startup has not been called.
Generator.submit( ) // per-instance |
 |
Submit io packet to a channel. This may result in a callback
ARGUMENTS
handle
handle of a previously-created Generator instance object
chanHandle
opaque channel handle
packet
io packet
eb
error block
RETURNS
status (DriverTypes_COMPLETED/PENDING/ERROR)
DETAILS
The driver may be able to complete the IO immediately and will return
ti.sdo.io.DriverTypes.COMPLETED status. If the driver requires an async
callback then, it will return
ti.sdo.io.DriverTypes.PENDING. When the
driver raises an error, it will return
ti.sdo.io.DriverTypes.ERROR and the
caller need to check the error block.
In case the return value is
ti.sdo.io.DriverTypes.PENDING, the driver will
call the function specified during
open with the IO packet.
per-instance convertors |
 |
// unconditionally move one level up the inheritance hierarchy
// conditionally move one level down the inheritance hierarchy; NULL upon failure
per-instance built-ins |
 |
Int Generator_Object_count( );
// The number of statically-created instance objects
// The handle of the i-th statically-created instance object (array == NULL)
// The handle of the first dynamically-created instance object, or NULL
// The handle of the next dynamically-created instance object, or NULL
// The heap used to allocate dynamically-created instance objects
// The label associated with this instance object
// The name of this instance object