Contents

Function Reference

Driver and Generic Functions

Physical Device Functions

Logical Device Functions

Constant and Type Reference

Driver Level

Physical Devices

Logical Devices

Header File Reference

OTX API Alphabetical References

Communication protocol between Host and Dsp (DspIoctl.h)

DSP SDK Host .. DSP Macro, Constant and Type Reference

Example

The IO Control codes used (from Host towards the DSP code) are
16 bit values layed out as follows:


 1 1 1 1 1 1
 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0

|S|C|P|         Code            |

S - SDK System IO Codes - reserved

    1 - SDK Reserved System Codes

    0 - User application code

C - Data Complete - reserved

    0 - There is more data pending for this IO Code

    1 - Data is complete for this IO Code.

P - Padded octet for Data

    0 - Even number of octets were transferred. Data length (in words)
	reflects actual number of data octets transferred (2*octets).

    1 - Odd number of octets were transferred. Data length includes one
	padded octet.

Code - is the IO Control code value

1. Retrieve (and possibly process) the data passed in the IO packet.
2. Writing return data (if any) to OTXDSP_SDK_IOCTL_DATA_ADDR and data
   length OTXDSP_SDK_IOCTL_DATA_LEN_ADDR.
3. Mark the completion of the packet by writing OTXDSP_SDK_IO_NO_COMMAND
   to the OTXDSP_SDK_IOCTL_CODE_ADDR.
4. Issue an interrupt towards the host.

1 1 1 1 1 1
5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0

|           IO Code             |  OTXDSP_SDK_IOCTL_CODE_ADDR

|  LogDevType   |  Handle       |  OTXDSP_SDK_IOCTL_HANDLE_ADDR

|           Task Ref            |  OTXDSP_SDK_IOCTL_TASKREF_ADDR

|           Data Length (n)     |  OTXDSP_SDK_IOCTL_DATA_LEN_ADDR

|           Data Word 0         |  OTXDSP_SDK_IOCTL_DATA_ADDR

|           Data Word 1         |

:                               :

|           Data Word (n-1)     |

1 1 1 1 1 1
5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0

|           Processing Addr     |       OTXDSP_SDK_EVENT_BUF_PROCESSING_ADDR

|S|C|P|     Event Code          |  >-+  OTXDSP_SDK_EVENT_BUF_ADDR (start of buffer)
|
|  LogDevType   |  Handle       |    |
|
|           TaskRef             |    |
|
|           TimeStamp bit 48-63 |    |
|
|           TimeStamp bit 32-47 |    |
|
|           TimeStamp bit 16-31 |    |
|
|           TimeStamp bit  0-15 |    |
|
|           Data Length (n=0)   |    |
|
|S|C|P|     Event Code          |    |
|
|  LogDevType   |  Handle       |    |
|
|           TaskRef             |    |
|
|           TimeStamp bit 48-63 |    |
|
|           TimeStamp bit 32-47 |    |
|
|           TimeStamp bit 16-31 |    |
|
|           TimeStamp bit  0-15 |    |
|
|           Data Length (n=2)   |    |
|
|           Data Word 0         |    |
|
|           Data Word 1         |    |
|
|  OTXDSP_SDK_EVENT_NO_COMMAND  |    |
|
:                               :    |
|
|                               |  <-+  End of Event buffer


*/ /*

Constants

DspIoctl.h

Enum Types and Constants

Functions

Generic Console Functions - OsaConsoleXXX()

OsaConsoleXXX() Function Reference

Generic stdio.h Functions - OsaStdXXX()

OsaStdXXX() Function Reference

Generic Thread and Mutex Functions - OsaThreadXXX()/OsaMutexXXX()

OsaThreadXXX()/OsaMutexXXX() Function Reference

Osa Macros

To Do

OsaCon.h

OsaDef.h

OsaStd.h

OsaThrd.h

Other Types

OTX Board Level Constants, Macros, and Types

OtxBrdXXX Macro, Constant, and Type Reference

OTX Board Level Functions - OtxBrdXXX()

OtxBrdXXX() Function Reference

OTX Device Types supported by the API (OtxDev.h)

OTX Driver Supported Device Types

OTX DMA Burst Device Management Macros, Constants, and Types

OtxBurstXXX Macro, Constant, and Type Reference

OTX Driver Level Constants

OTX Driver Level Functions - OtxDrvXXX()

OtxDrvXXX() Function Reference

OTX Driver Level Result Codes

OTX Driver Level Types

Enumerated Types

Struct Types

Other Types

OTX Driver Management Macros, Constants, and Types

OtxDrvXXX Macro, Constant, and Type Reference

OTX DSP Device Management Functions - OtxDspXXX()

OtxDspXXX() Function Reference

OTX DSP Device Management Macros, Constants, and Types

OtxDspXXX Macro, Constant, and Type Reference

OTX Generic Functions/Macros

OTX Hdlc Device Macros, Constants, and Types

OtxHdlcXXX Macro, Constant, and Type Reference

OTX Hdlc Device Macros, Constants, and Types

OtxHdlcXXX Macro, Constant, and Type Reference

OTX ISDN BRI Line Interface Device Constants, Macros, and Types

OtxBriXXX Macro, Constant, and Type Reference

OTX ISDN BRI Line Interface Device Functions - OtxBriXXX()

OtxBriXXX() Function Reference

OTX JTAG - OtxJtagXXX()

OtxJtagXXX() Function Reference

OTX Logical DMA Burst Sender/Receiver Functions - OtxBurstXXX()

OtxBurstXXX() Function Reference

OTX Logical Hdlc Sender/Receiver Functions - OtxHdlcXXX()

OtxHdlcXXX() Function Reference

OTX Logical RawData Sender/Receiver Functions - OtxRawDataXXX()

OtxRawDataXXX() Function Reference

OTX POTS Line Interface Device Constants, Macros, and Types

OtxPotsXXX Macro, Constant, and Type Reference

OTX POTS Line Interface Device Functions - OtxPotsXXX()

OtxPotsXXX() Function Reference

OTX Raw Data Device Macros, Constants, and Types

OtxRawDataXXX Macro, Constant, and Type Reference

OTX Serial Data Manipulation Device Macros, Constants, and Types

OtxDataXXX Macro, Constant, and Type Reference

OTX Serial Data Manipulation Function Prototypes - OtxDataXXX()

OtxDataXXX() Function Reference

OTX T1/E1 Line Interface Constants, Macros, and Types

OtxT1E1XXX, OtxT1XXX, and OtxE1XXX Macro, Constant, and Type Reference

OTX T1/E1 Line Interface Device Functions - OtxT1XXX(), OtxE1XXX()

OtxT1E1XXX(), OtxT1XXX(), and OtxE1XXX() Function Reference

OTX Tone Generator/Detector Functions - OtxToneXXX()

OtxToneXXX() Function Reference

OTX Tone Logical Data Filter Device Macros, Constants, and Types

OtxToneXXX Macro, Constant, and Type Reference

OtxBrd.h

OtxBrdD.h

OtxBri.h

OtxBriD.h

OtxBurst.h

OtxBurstD.h

OtxData.h

OtxDataD.h

OtxDef.h

OtxDev.h

OtxDrv.h

OtxDrvD.h

OtxDsp.h

OtxDspD.h

OtxErr.h

OtxGeneric.h

OtxHdlc.h

OtxHdlcD.h

OtxHdlcD.h

OtxJtag.h

OtxPots.h

OtxPotsD.h

OtxRaw.h

OtxRawD.h

OtxT1E1.h

OtxT1E1D.h

OtxTone.h

OtxToneD.h

OtxType.h

Struct Types

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

OTX error definitions and values

The return value of OTX APIs and methods is an OTX_RESULT. This is not a handle to anything, but is merely a 32-bit value with several fields encoded in the value. The parts of an OTX_RESULT are shown below.

The structure of OTX_RESULT is based on the Win32 HRESULT layout, but the meanings of values used in the bit fields are completely different.

Example

|3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
|1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
|-+---------------+-----------------------------+---------------+
|S|  source id    |        line number          |      Code     |
|-+---------------+-----------------------------+---------------+

S - Severity - indicates success/fail

    0 - Success
    1 - Fail

source id - source module where error occurred

line number - line number where error occurred

X - extended error flag

Code - is the OTX facility's status code

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Description

Parameters

Freq

sound frequency, in hertz

msDuration

sound duration, in milliseconds

Comments

Example

// beep 200 ms in 4000 Hz
OsaBeep(4000, 200);

Comments

Osa functions are used by the demo programs.

see example on OsaConsoleInit

See Also

Comments

Example

OTX_INT32 c;

// get a character from key board
c = OsaConsoleGetCh();

Parameters

buffer

Placeholder for input string. See gets() in stdio.h

Comments

Example

char strBuf[12];
static OTX_UINT32 nAddress = 0;

// get input "nAddress" from key board
OsaConsoleGetStr(strBuf);
if (*strBuf) {
  nAddress = strtoul(strBuf, NULL, 0);
}

Comments

Example

// first OTX function call for application if other Osa functions are used
OsaConsoleInit();
...

// this is called before application exits
OsaConsoleExit();

See Also

To indicate an 'Enter' key in the OsaConsoleGetStr function, use the '^' character in the parameter to this function.
Defined in: OsaCon.h

Comments

Example

// it is usually used at the begining of application to get input stream
// from command line
if (g_demoEnv.pszInputStr) {
  OsaConsoleInput(g_demoEnv.pszInputStr);
}

See Also

Parameters

formatStr

Format string. See printf() in stdio.h

argList

Argument list. See printf() in stdio.h

Comments

Example

// Usually it is used in function DemoLogf() in demo programs
static void DemoLogf(char *formatStr, ...)
{
  va_list argList;
  va_start(argList, formatStr);

  OsaConsolePrintF(formatStr, argList);
  if (g_pDemoLogFile)
    vfprintf(g_pDemoLogFile,   formatStr, argList);

  va_end(argList);
}

Parameters

buffer

Placeholder for input string. See puts() in stdio.h

Comments

Example

// write "Hello Odin!" on the screen
OsaConsolePutStr( "Hello Odin!");

See Also

Parameters

hOsaFile

Pointer to OSA file structure

Comments

See Also

Parameters

pFileName

Filename

mode

Type of access permitted

Comments

See Also

Parameters

buffer

Storage location for data

size

Item size in bytes

count

Maximum number of items to be read

OsaFile

Pointer to OSA file structure

Comments

See Also

Parameters

OsaFile

Pointer to OSA file structure

offset

Number of bytes from origin

origin

Initial position

Comments

See Also

Parameters

pMutex

Pointer to the mutex created by a call to OsaMutexInit

Comments

see example on OsaMutexInit

See Also

Parameters

pMutex

Pointer to the mutex created by this function call

Comments

Example

static OsaMutexS g_demoLogfCritSec;

      OsaConsoleInit();

OsaMutexInit(&g_demoLogfCritSec);

......

// delete a Mutex
OsaMutexDestroy(&g_demoLogfCritSec);

OsaConsoleExit();

See Also

Parameters

pMutex

Pointer to the mutex created by a call to OsaMutexInit

Comments

Example

OsaMutexS g_demoLogfCritSec;

static void DemoLogf(char *formatStr, ...)
{
  va_list argList;

  OsaMutexLock(&g_demoLogfCritSec);

  va_start(argList, formatStr);

  OsaConsolePrintF(formatStr, argList);
  if (g_pDemoLogFile) vfprintf(g_pDemoLogFile,   formatStr, argList);

  va_end(argList);

  OsaMutexUnlock(&g_demoLogfCritSec);

}

See Also

Parameters

pMutex

Pointer to the mutex created by a call to OsaMutexInit

Comments

see example on OsaMutexLock

See Also

Parameters

ptime

Pointer to time structure

Comments

See Also

Parameters

s

Null-terminated string to compare

t

Null-terminated string to compare

Comments

See Also

Parameters

s

Null-terminated string to compare

t

Null-terminated string to compare

s

Null-terminated string to compare

t

Null-terminated string to compare

Comments

See Also

Parameters

s

Destination string

t

Null-terminated source string

Comments

See Also

Parameters

s

Null-terminated string to get length of.

Comments

See Also

Parameters

s

Destination string

t

Source string

i

Number of characters to be copied

Comments

See Also

Parameters

s

String to be altered

c

Character setting

count

Number of characters to be set

Comments

See Also

Parameters

s

Null-terminated string to search

c

Character to be located

Comments

See Also

Parameters

nptr

String to be converted

Comments

See Also

Parameters

s

String to capitalize

s

String to capitalize

Comments

See Also

Parameters

nMilliSecs

Sleep time in milliseconds

Comments

Example

// sleep for 500 ms
OsaThreadSleep(500);

See Also

Parameters

pfnThreadFunc

Thread function to be started

Comments

Example

void  *DemoIdleFunction(
  void *lpParameter   // thread data
)
{
  OTX_RESULT result;

  while (1) {
    OtxDrvWaitForSingleEvent(
       g_hNotificationEvent,
       OTX_TIME_INFINITY);

    do {
      OtxEventDataS eventData;
      result = OtxDrvGetEventData(
		  g_hEventQueue,
		  &eventData);

      if (OTX_RESULT_CODE(result) == OTX_S_OK) {
	// We have a driver event
	// Printf the event data.
	// In a real application branch based on the data
	DemoPrintEvent(&eventData);
      }
    } while (OTX_RESULT_CODE(result) == OTX_S_OK);
  }

  return 0;
}

// start a thread
OsaThreadStart(DemoIdleFunction);

See Also

Parameters

pfnThreadFunc

Thread function to be started

lpParameter

Parameter to be passed to the thread

Comments

see example on OsaThreadStart

See Also

Parameters

c

Character to convert

Comments

See Also

Parameters

c

Character to convert

c

Character to convert

Comments

See Also

while (GetMessage(&msg, NULL, 0, 0) == TRUE) { TranslateMessage(&msg); DispatchMessage(&msg); }
Defined in: OsaCon.h

Comments

Example

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nShowCmd)
{
  // default command line parameters
  static char exename[OTX_MAX_PATH] = "";
  static char *cmdParams[] = { exename, "/TM", NULL };
  char *pc;

  GetModuleFileName(NULL, (LPTSTR) cmdParams[0], OTX_MAX_PATH);
  strcpy(g_demoEnv.cwd, cmdParams[0]);
  pc = strrchr(g_demoEnv.cwd, '\\\\');
  if (pc != NULL) {
    *++pc = '\\0';
  }

  return OsaWinCeConsoleMain(hInstance, hPrevInstance, lpCmdLine, nShowCmd,
	      cmdParams, sizeof(cmdParams) / sizeof(cmdParams[0]), main);
}

Parameters

hDevice

A handle to any type device

Parameters

hDevice

A handle to any type device

Parameters

hDevice

A handle to any type device

Parameters

hDevice

A handle to any type device

Parameters

hDevice

A handle to any type device

Parameters

hDevice

A handle to any type device

Parameters

hDevice

A handle to any type device

Parameters

StructType

The name of the type of the structure whose base address is to be returned

pBase

Base Address of the structure pointer

nByteOffset

Byte offset from Base Address that the second structure is located

*/ ((StructType *) (((OTX_UINT8 *) pBase) + nByteOffset))

Parameters

hDevice

A handle to any type device

Parameters

hCodecDevice

Handle to Codec device

eLaw

U-law or A-law

Comments

Example

// Get handles and set law for Codec devices #0 - #3
for (i = 0; i < 4; i++) {
  OtxDrvOpenPhysicalDevice(
    g_hPhysDevs.hBoardController,
    OTX_DEVICE_CODEC,
    i, i,
    g_hEventQueue,
    &g_hPhysDevs.hCodec[i]
  );

  // Use G.711 U-law (North American) companded PCM data (8 bit samples)
  // for T1 mode
  OtxBrdCodecSetLaw(
    g_hPhysDevs.hCodec[i],
    OTX_DATA_FORMAT_COMPAND8_U_LAW
  );
}

See Also

Parameters

hBrdDevice

Handle to Board device

clkMode

TSS Clock Mode (Master/Slave)

clkSource

Clock which the TSS uses to clock the highways

Comments

Basically, there are two types of clock modes, non-H.100 bus clocking (H.100 bus is disconnected or H.100 bus is not available on board) and H.100 bus clocking (H.100 bus is connected ). When H.100 bus is used, one board is set as the Clock Master, other board(s) is set to the Clock Slave.

Example

non-H.100 bus clocking
  // board is enabled before the clock source can be set
  result = OtxDrvEnable(
	     g_hPhysDevs.hBoardController,
	     OTX_TASK_SYNC,
	     5000L);

  // Set Internal Oscillator as the clock source
  result = OtxBrdSetClocks(
	     g_hPhysDevs.hBoardController,
	     OTX_CLOCK_MODE_LOCAL,
	     OTX_CLOCK_SOURCE_INTERNAL);

H.100 bus clocking
  // two boards are enabled before the clock source can be set
  result = OtxDrvEnable(
	     g_hPhysDevs.hBoardController0,
	     OTX_TASK_SYNC,
	     5000L);
  result = OtxDrvEnable(
	     g_hPhysDevs.hBoardController1,
	     OTX_TASK_SYNC,
	     5000L);

  // Set Li#0 on board0 as the H.100 Clock Master
  result = OtxBrdSetClocks(
	     g_hPhysDevs.hBoardController0,
	     OTX_CLOCK_MODE_H100,
	     OTX_CLOCK_SOURCE_LOCAL_0);

  // Set board1 as the H.100 Clock Slave (synchronize to the H.100 A-Clock
  // sourced by board0)
  result = OtxBrdSetClocks(
	     g_hPhysDevs.hBoardController1,
	     OTX_CLOCK_MODE_H100,
	     OTX_CLOCK_SOURCE_A_CLOCKS);

See Also

Parameters

hHwDevice

Handle to TSS device

nHighWayOut

highway number

nTimeSlotOut

timeslot number

nConstValue

constant value in BYTE

Example

// Get a handle to the Time-Space Switch (TSS) on the board
result = OtxDrvOpenPhysicalDevice(
	   g_hPhysDevs.hBoardController,
	   OTX_DEVICE_TSS,
	   0,
	   0,
	   g_hEventQueue,
	   &g_hPhysDevs.hTss);

// set constant value '10' on timeslot #5 of highway #2
result = OtxBrdTssConstByte(
	   g_hPhysDevs.hTss,
	   2,
	   5,
	   10);

Parameters

hBriDev

Handle to the BRI Transceiver Device

nWaitMaxMs

Time in milliseconds to wait for the layer 1 to become active

Parameters

hBriTeDev

Handle to the the Li which will listen as a TE

hBriNtDev

Handle to the the Li which will listen as a NT

Parameters

hBriDev

Handle to the BRI Transceiver Device

nWaitMaxMs

Time in milliseconds to wait for the layer 1 to become active

Comments

Parameters

hBriDev

Handle to the BRI Transceiver Device

pLineStatus

T1/E1 Physical Layer Line Status

Parameters

hBriDev

Handle to the BRI Device

eLiMode

Mode to be configured to (TE/NT)

See Also

Parameters

hBriDev

Handle to the BRI Transceiver Device

bConnectTermRes

If OTX_TRUE, connect the terminating resistor

Parameters

hBurstDevice

Handle to logical Burst Device

nHighwayNo

Highway number (0 - highway count)

psqData

buffer to receive - entire frame of 32 TS for all LIs per highway

pnDataLen

buffer size (multiple of number of TS on highway) - upon return the amount of data read

Comments

See Also

Parameters

hBurstDevice

Handle to logical Burst Device

nHighwayNo

Highway number (0 - highway count)

psqData

buffer to receive - entire frame of 32 TS for all LIs per highway

pnDataLen

buffer size (multiple of number of TS on highway) - upon return the amount of data read

pnFrameRefId

Optional - upon return, contains the Frame Reference Counter of the first frame contained in the return buffer

dtFrameRefTime

Optional - upon return, contains the time that the first frame was received

Comments

See Also

Parameters

hBurstDevice

Handle to logical Burst Device

nHighwayNo

Highway number (0 - highway count)

psqData

buffer to send - entire frame of 32 TS for all LIs per highway

nDataLen

buffer size (multiple of number of TS on highway) - upon return the amount of data buffered

Comments

See Also

Parameters

hDevice

Handle to the logical Data Converter Device

eDataFormatIn

Data format coming in. See also OtxDataFormat

eDataFormatOut

Data format coming out. See also OtxDataFormat

Comments

Example

// Create Data Converter (for cross-connection with the DSP)
result = OtxDrvCreateLogicalDevice(
	   g_hPhysDevs.hDsp0,
	   OTX_LDEVICE_DATA_CONVERTER,
	   g_hEventQueue,
	   i,
	   &g_sqDataConverter.hHandle);

// DTMF data (just an example) as the input data to Data Convertor,
// pipe creation, connection for DTMF needed to be done before this call.
result = OtxDrvConnectLogicalDevice(
	   g_sqDtmfDetector.hPipe,
	   -1,
	   g_sqDataConverter.hHandle,
	   -1);

// create a pipe for output data from Data Converter
ts = 5;
memset(sqTimeSlotMask, 0, 32 * sizeof(OTX_UINT8));
sqTimeSlotMask[ts] = 0xFF;
nCapacity = 64;

result = OtxDrvCreatePipe(
	   nCapacity,
	   &g_sqDataConverter.hPipe);

// connect pipe from DSP0 (Data Convertor) to Li0
result = OtxDrvConnectPipe(
	   g_sqDataConverter.hPipe,
	   OTX_PIPE_INPUT,
	   g_hPhysDevs.hDsp0,
	   -1,
	   sqTimeSlotMask,
	   32);

result = OtxDrvConnectPipe(
	   g_sqDataConverter.hPipe,
	   OTX_PIPE_OUTPUT,
	   g_hPhysDevs.hLi0,
	   -1,
	   sqTimeSlotMask,
	   32);

// connect Data Convertor device to the pipe
result = OtxDrvConnectLogicalDevice(
	   g_sqDataConverter.hHandle,
	   -1,
	   g_sqDataConverter.hPipe,
	   -1);

// initialize the Data Converter, convert data from U-law to 8-bit unsigned interger
result = OtxDataConverterInit(
	   g_sqDataConverter.hHandle,
	   OTX_DATA_FORMAT_COMPAND8_U_LAW,
	   OTX_DATA_FORMAT_UINT8);

// enable the Data Converter
result = OtxDrvEnable(
	   g_sqDataConverter.hHandle,
	   OTX_TASK_SYNC,
	   5000L);

See Also

Parameters

hDevice

Handle to the logical Data Mixer Device

Comments

See Also

Parameters

hDevice

Handle to the device

nTaskRef

Callers task reference, as given earlier. See OTX_TASK_REF

Comments

See Also

To Do

Parameters

hObject

Object handle to a physical/logical device, pipe or event queue

Comments

Example

// close Hdlc Receivers logical devices hosted in the physical Line Interface devices
for (i = 0; i < 2; i++) {
  if (g_hLogicDevs.hHdlcReceiver[i]) {
    result = OtxDrvClose(g_hLogicDevs.hHdlcReceiver[i]);
  }
}

See Also

Parameters

hEvent

Event handle to close. See Also OTX_EVENT

Comments

see example on OtxDrvSignalEvent

See Also

Parameters

hCtBus

Handle to a CT Bus

hBoard

Handle to a board (Nic) device which is connected to this CT bus

Comments

When two ore more boards are connected together with the appropriate CT Bus board interconnect cable it is possible to connect two devices with a pipe even if they are located on different board. Before pipes can connect over separate boards the driver must be informed about what types of board interconnects exists, and how the boards are connected. This is done by calling this function.

The CT Bus device must be opened by calling OtxDrvOpenPhysicalDevice prior to calling this function. The same applies to all the boards which are connected to the CT Bus.

The CT Bus does not have a direction like a pipe. The direction of each individual timeslot is determined at the time a pipe is connected. A Pipe Device must utilize the CT Bus to reach a different board. The direction of the pipe then determines the direction of that timeslot in the CT Bus.

The OTX driver supports a CT bus capacity of 2048 kbps which corresponds to 32 timeslots/highway.

Example

// connect to the Physical CT Buses
OTX_INT32 nCtBus;

for (nCtBus = 0; nCtBus < 1; nCtBus++) {
  // open OTX_DEVICE_CT_BUS
  result = OtxDrvOpenPhysicalDevice(
	      0,
	      OTX_DEVICE_CT_BUS,
	      nCtBus,
	      nCtBus,
	      g_hEventQueue,
	      &g_hCtBus[nCtBus]);
}

for (iBrd = 0; iBrd < 2; iBrd++) {

  // Connect (get handles) to the physical devices on two boards
  DemoOpenPhysicalDevices(iBrd);
}

// inform the driver that our two  boards are connected to one CT Bus
for (iBrd = 0; iBrd < 2; iBrd++) {
  result = OtxDrvConnectBoard(
	      g_hCtBus[iBrd/2],
	      g_hPhysDevs[iBrd].hThorController);
}

See Also

Comments

Its complement is OtxDrvReleaseLib which closes the communication channel and is the last function to be called.

Example

// start of OTX applicaton
result = OtxDrvConnectLib();
......
......
// end of OTX application
result = OtxDrvReleaseLib();

See Also

Parameters

hFromDevice

Logical Device or Pipe whose output is to be connected

iFromConnectPoint

Output connection point to connect, -1 = don't care

hToDevice

Logical Device or Pipe whose input is to be connected

iToConnectPoint

Connection point on the second device to connect to, -1 = don't care

Comments

The connection point index is only needed for devices that have more than one inputs of outputs, e.g. a mixer or a conference bridge, and even in that case it can be left as -1 if the connection points are 100% symmetrical, e.g. a symmetrically mixed conference bridge.

see example on OtxDrvConnectPipe

Developer Notes

See Also

Parameters

hPipe

Pipe to be connected to a Physical Device.

ePipeEnd

End of the pipe (input vs. output) to be connected. See Also OtxPipeEndE

hDevice

Physical Device to be connected to

nHighway

Physical Highway to be used. -1 = don't care

sqConnectMask[]

Connection mask for mapping the Pipe Bits to time-slots and bits on the PCM highway connected to the physical device Can be NULL if don't care and coMaskSize = 0 Each octet in the mask represents a timeslot on the highway A connection mask is needed for pipes connected on OTX PCMCIA card and also for pipes with a capacity < 64 kpbs. Please note that the capacity specified in the connection mask must match the capacity used when the pipe was created with OtxDrvCreatePipe.

coMaskSize

Size of connection mask for the highway connection (in octets). 0 = don't care.

Comments

Multiple logical devices (implemented within a physical device) can be connected within a physical device to use data from a pipe output. To connect logical devices to each other and to a pipe, use function OtxDrvConnectLogicalDevice.

To specify which timeslot (or timeslots) the pipe will be connected to, a connection mask can be used. Each bit in the connection mask corresponds to 8 kpbs capacity. A 64 kpbs pipe corresponds to 8 bits (1 octet) in the connection mask.

The connection mask is only needed for devices where an exact mapping of the pipe onto a physical interface (i.e. specific time-slots) is needed, e.g. in the case of a multichannel line interface where a specific timeslot is used for signalling. It is important that the mapping matches the capacity of the pipe exactly. If the time-slots to be used do not matter, or if they cannot be changed by the user, specify coMaskSize = 0 and sqConnectMask = NULL.

The connection mask is also needed for pipes of a capacity < 64 kpbs. E.g. if a 56kpbs pipe is specified for an HDLC device, the timeslot mask for that pipe must be specified to 0xFE. Please see example below:

Example

OTX_UINT8 sqTimeSlotMask[32];
memset(sqTimeSlotMask, 0, 32 * sizeof(OTX_UINT8));
sqTimeSlotMask[1] = 0xFE;  // TS1 is a 56kpbs pipe

OTX_UINT8 sqTimeSlotMask[32];
memset(sqTimeSlotMask, 0, 32 * sizeof(OTX_UINT8));
sqTimeSlotMask[16] = 0xFF;  // TS16 is a 64kpbs pipe

OTX_UINT8 sqTimeSlotMask[32];
memset(sqTimeSlotMask, 0, 32 * sizeof(OTX_UINT8));
sqTimeSlotMask[5] = 0xFF;
sqTimeSlotMask[7] = 0xFF;

//connect the Logical Device in the Line Interface (one for each direction)

for (i = 0; i < 2; i++) {
  ts = 5;
  memset(sqTimeSlotMask, 0, 32 * sizeof(OTX_UINT8));
  sqTimeSlotMask[ts] = 0xFF;
  nCapacity = 64;

  // Create an incoming and outgoing Pipe representing the external T1/E1
  result = OtxDrvCreatePipe(
	     nCapacity,
	     &g_sqLiHdlcReceiver[i].hPipe);
  result = OtxDrvCreatePipe(
	     nCapacity,
	     &g_sqLiHdlcSender[i].hPipe);

  // connect external T1/E1 pipes. Only connect ONE end of each pipe.
  // External Interface is LI Highway Number 1
  result = OtxDrvConnectPipe(
	     g_sqLiHdlcReceiver[i].hPipe,
	     OTX_PIPE_OUTPUT,
	     g_hPhysDevs.hLi[i],
	     1,
	     sqTimeSlotMask,
	     32);
  result = OtxDrvConnectPipe(
	     g_sqLiHdlcSender[i].hPipe,
	     OTX_PIPE_INPUT,
	     g_hPhysDevs.hLi[i],
	     1,
	     sqTimeSlotMask,
	     32);

  // connect the logical devices within the Li
  result = OtxDrvConnectLogicalDevice(
	     g_sqLiHdlcSender[i].hHandle,
	     -1,
	     g_sqLiHdlcSender[i].hPipe,
	     -1);
  result = OtxDrvConnectLogicalDevice(
	     g_sqLiHdlcReceiver[i].hPipe,
	     -1,
	     g_sqLiHdlcReceiver[i].hHandle,
	     -1);
}

//connect the Logical Device in DSP, connect BOTH ends of each pipe

for (i = 0; i < 2; i++) {

  // Receiving direction
  {
    ts = 1;
    memset(sqTimeSlotMask, 0, 32 * sizeof(OTX_UINT8));
    sqTimeSlotMask[ts] = 0xFF;
    nCapacity = 64;

    result = OtxDrvCreatePipe(
	       nCapacity,
	       &g_sqDspHdlcReceiver[i].hPipe);

    result = OtxDrvConnectPipe(
	       g_sqDspHdlcReceiver[i].hPipe,
	       OTX_PIPE_OUTPUT,
	       g_hPhysDevs.hDsp[i],
	       -1,
	       sqTimeSlotMask,
	       32);
    result = OtxDrvConnectPipe(
	       g_sqDspHdlcReceiver[i].hPipe,
	       OTX_PIPE_INPUT,
	       g_hPhysDevs.hLi[i],
	       -1,
	       sqTimeSlotMask,
	       32);

    result = OtxDrvConnectLogicalDevice(
	       g_sqDspHdlcReceiver[i].hPipe,
	       -1,
	       g_sqDspHdlcReceiver[i].hHandle,
	       -1);
  }

  // Sending direction
  {
    ts = 1;
    memset(sqTimeSlotMask, 0, 32 * sizeof(OTX_UINT8));
    sqTimeSlotMask[ts] = 0xFF;
    nCapacity = 64;

    result = OtxDrvCreatePipe(
	       nCapacity,
	       &g_sqDspHdlcSender[i].hPipe);

    result = OtxDrvConnectPipe(
	       g_sqDspHdlcSender[i].hPipe,
	       OTX_PIPE_INPUT,
	       g_hPhysDevs.hDsp[i],
	       -1,
	       sqTimeSlotMask,
	       32);
    result = OtxDrvConnectPipe(
	       g_sqDspHdlcSender[i].hPipe,
	       OTX_PIPE_OUTPUT,
	       g_hPhysDevs.hLi[i],
	       -1,
	       sqTimeSlotMask,
	       32);

    result = OtxDrvConnectLogicalDevice(
	       g_sqDspHdlcSender[i].hHandle,
	       -1,
	       g_sqDspHdlcSender[i].hPipe,
	       -1);
  }
}

Developer Notes

See Also

Parameters

phEvent

Event handle, ready for use. See Also OTX_EVENT

Comments

OTX_RESULT result;

Example

// create the event queue to be used by the driver to inform the
// application about events

// create a notification Event
result = OtxDrvCreateEvent(&g_hNotificationEvent);

// create Event Queue for driver notifications
result = OtxDrvCreateEventQueue(
	    2048,
	    g_hNotificationEvent,
	    &g_hEventQueue);

// enable Event Queue
result = OtxDrvEnable(
	    g_hEventQueue,
	    OTX_TASK_SYNC,
	    5000L);

See Also

Parameters

nSize

Size of the queue to be created in # of messages

hEvent

Event which a Win32 app can Wait for events to occur, NULL if no notification needed (or if not a Win32 application).

phEventQueue

Event Queue handle

Comments

see example on OtxDrvCreateEvent

See Also

Parameters

hHostDevice

Parent (typically a physical device) who owns the logical device we are connecting to

eDevType

Class of device we are looking for, as known by the module in question. See also OtxLogicalDeviceTypeE

hEventQueue

Handle to separate event queue (0 creates device specific event queue)

nEventSourceId

User specified ID to be used by this device as the Source ID for the events generated by the device

phLogicDevice

Handle to the new logical device (if result code OTX_S_OK)

Comments

The following Logical Devices are supported by the OTX Driver:

Tone Devices : Logical devices for tone generation and reception (See OtxTone.h) Data Devices : Devices for sending, receiving, and manipulation of Raw data (See OtxData.h) HDLC Devices : Logical devices implementing HDLC Sender and Receiver Devices (See OtxHdlc.h) CAS Devices : Devices implementin Channel Associated Signalling (CAS) functions (See OtxCas1.h) Modem Devices : Devices implementing Modem emulation Fax Devices : Devices implementin Fax emulation Voice Devices : Devices implementing Voice Codecs, echo cancellation, silence supression, etc.

Example

// create Hdlc Senders and Receivers logical devices hosted in the physical Line Interface devices
for (i = 0; i < 2; i++) {
  result = OtxDrvCreateLogicalDevice(
	      g_hPhysDevs.hLi[i],
	      OTX_LDEVICE_HDLC_SENDER,
	      g_hEventQueue,
	      i,
	      &g_hLogicDevs.hHdlcSender[i]);
  result = OtxDrvCreateLogicalDevice(
	      g_hPhysDevs.hLi[i],
	      OTX_LDEVICE_HDLC_RECEIVER,
	      g_hEventQueue,
	      i,
	      &g_hLogicDevs.hHdlcReceiver[i]);
}

See Also

Parameters

nCapacity

Capacity in kbps (only 8kbps increments allowed)

phPipe

Handle to the new pipe device (if result code OTX_S_OK)

Comments

A pipe can be created for a data rate between 8 kbit/s and 2.048Mbit/s (2.048 Mbit/s max is standard. Highways can be operated at up to 8.192Mbits/s). A pipe is a configured entity and it is overlaid on internal highways. A pipe can constitute a single time-slot on a Highway or it can be a superchannel of any number of time slots. The pipe is mapped on the physical highways when it is connected to a device with function OtxDrvConnectPipe

see example on OtxDrvConnectPipe

See Also

Parameters

hDevice

Handle to device

nCommandCode

Code indicating requested operation

pInBuffer

Input parameters in serial format

cbInBuffer

Byte count of input parameters

pOutBuffer

Buffer to receive output parameters in serial format

cbOutBuffer

Size in bytes of output buffer. Must be large enough for the given command

cbReturned

Actual number of bytes returned (may differ from cbOutBuffer).

nTaskRef

See OTX_TASK_REF

nWaitMaxMs

See OTX_TIME

Comments

See Also

To Do

Parameters

hObject

Any OTX_HANDLE

nTaskRef

See OTX_TASK_REF

nWaitMaxMs

See OTX_TIME

Example

// disable board interrupts
OtxDrvDisable(
   g_hPhysDevs.hBoardController,
   1L,
   OTX_TIME_INFINITY);

See Also

To Do

Parameters

hFromDevice

Logical Device or Pipe whose output is to be disconnected

iFromConnectPoint

Output connection point to be disconnected, -1 = disconnect all

hToDevice

Logical Device or Pipe whose input is to be disconnected

iToConnectPoint

Connection point on the second device to be disconnect to, -1 = disconnect all

Comments

The connection point index must be the same connection point used when OtxDrvConnectLogicalDevice was called.

Example

// break Cross-Connect

// disable the logical devices
result = OtxDrvDisable(
	    hDataConverter[0],
	    OTX_TASK_SYNC,
	    5000L);
result = OtxDrvDisable(
	    hDataConverter[1],
	    OTX_TASK_SYNC,
	    5000L);

// hDataConverter[0])
result = OtxDrvDisconnectLogicalDevice(
	    hLiDspPipe[0],
	    -1,
	    hDataConverter[0],
	    -1);
result = OtxDrvDisconnectLogicalDevice(
	    hDataConverter[0],
	    -1,
	    hDspLiPipe[1],
	    -1);

// hDataConverter[1]
result = OtxDrvDisconnectLogicalDevice(
	    hLiDspPipe[1],
	    -1,
	    hDataConverter[1],
	    -1);
result = OtxDrvDisconnectLogicalDevice(
	    hDataConverter[1],
	    -1,
	    hDspLiPipe[0],
	    -1);

Developer Notes

See Also

Parameters

hPipe

Pipe to be disconnected

ePipeEnd

End of the pipe to be disconnected. See Also OtxPipeEndE

Comments

Example

OTX_INT32 ts;
OTX_UINT8 sqTimeSlotMask[32];

// disonnect pipe
result = OtxDrvDisconnectPipe(
	    g_sqDtmfDialer[1].hPipe,
	    OTX_PIPE_INPUT);
result = OtxDrvDisconnectPipe(
	    g_sqDtmfDialer[2].hPipe,
	    OTX_PIPE_INPUT);

// reconnect pipes, arbitrary timeslot on the DSP highway
result = OtxDrvConnectPipe(
	    g_sqDtmfDialer[2].hPipe,
	    OTX_PIPE_INPUT,
	    g_hPhysDevs.hDsp[0],
	    -1,
	    NULL,
	    0);
result = OtxDrvConnectPipe(
	    g_sqDtmfDialer[1].hPipe,
	    OTX_PIPE_INPUT,
	    g_hPhysDevs.hDsp[0],
	    -1,
	    NULL,
	    0);

// reconnect logical devices
result = OtxDrvConnectLogicalDevice(
	    g_sqDtmfDialer[1].hHandle,
	    -1,
	    g_sqDtmfDialer[1].hPipe,
	    -1);
result = OtxDrvConnectLogicalDevice(
	    g_sqDtmfDialer[2].hHandle,
	    -1,
	    g_sqDtmfDialer[2].hPipe,
	    -1);

See Also

Parameters

hObject

Any OTX_HANDLE

nTaskRef

See OTX_TASK_REF

nWaitMaxMs

See OTX_TIME

Example

// open mother board and enable it
result = OtxDrvOpenPhysicalDevice(
	    0,                      // '0' for mother board
	    OTX_DEVICE_THOR_PCI,
	    nboardNo,
	    nboardNo,
	    g_hEventQueue,
	    &g_hPhysDevs.hBoardController);

result = OtxDrvEnable(
	    g_hPhysDevs.hBoardController,
	    OTX_TASK_SYNC,
	    5000L);

See Also

Parameters

hDevice

Handle to the physical parent device

eDeviceType

Physical or logical device type. See OtxPhysicalDeviceTypeE and OtxLogicalDeviceTypeE

pItr

Enumeration start position. See OTX_ITERATOR

phChildDevice

Handle to device referenced by iterator. This handle can be always be used to query the device, but the device must have been opened for most other operations to succeed

Comments

After the call, the iterator has been incremented to reference the next item in the sequence. It can be used in a subsequent call to the same function to fetch data for the next element in the same sequence. Repeated calls to the same function with the same iterator eventually fetches data for all items in this sequence. Note that it is not possible to increment the iterator in any other way.

The iterator must already be initialized with a call to OtxDrvIteratorBegin before the first call to this function.

It is important that the iterator is used on the same sequence of items between each call to OtxDrvIteratorBegin, i.e. the same function must be called with the same handle value (hDevice) and the same iterator (pItr).

However, it is possible for multiple iterators to be used on the same sequence independently, at the same time, even in separate threads.

Example

{
  OTX_UINT32   eDevType;
  OTX_ITERATOR itrChildTypes;
  OTX_ITERATOR itrChildrenOfSameType;
  OTX_HANDLE hParentDevice = 0;

  // Initialize the opaque iterator for the hosted types
  OtxDrvIteratorBegin(&itrChildTypes);

  while (OTX_SUCCESS(OtxDrvEnumDeviceType(hParentDevice, &itrChildTypes, (OTX_INT32 *)&eDevType))) {   // Note that we must use a zero handle to get the children of the root level

    OTX_HANDLE hChildDevice;
    // Initialize the opaque iterator for the devices within the same type
    OtxDrvIteratorBegin(&itrChildrenOfSameType);

    while (OTX_SUCCESS(OtxDrvEnumDevice(hParentDevice, eDevType, &itrChildrenOfSameType, &hChildDevice))) {
      if (hChildDevice != OTX_INVALID_HANDLE_VALUE) {
	OTX_UINT32 eDevType2;
	OTX_HANDLE hParentDevice2;

				// Here we have a handle for a child device, get the attributes
	DemoLogf("%s_%d (%s, handle = %#x)\\n",
	DemoGetDeviceTypeString(hChildDevice),
	DemoGetDeviceNo(hChildDevice),
	(eDevType >= 0) ? (eDevType == 0 ? "UnKnown" : "Physical") : "Logical", hChildDevice);

	// Print device specific attributes
	switch (eDevType) {
	  case OTX_DEVICE_THOR_PCI:
	  case OTX_DEVICE_THOR_8_PCI:
	  {
		   OTX_RESULT      result;

	    // Read serial number from the board
	    ReadSerialNum( hParentDevice, hChildDevice, eDevType );

	    if (eDevType) {
	      DemoLogf("Opening board# %d using OtxDrvOpenPhysicalDeviceEx()\\n", DemoGetDeviceNo(hChildDevice));

	      result = OtxDrvOpenPhysicalDeviceEx(
			  hChildDevice,
			  DemoGetDeviceNo(hChildDevice),
			  OTX_INVALID_HANDLE_VALUE);
	    }
	  }
	  break;
	}

	// Now do the same thing for all children of this device (recursion)
	ms_nIndentLevel += 1;
	EnumerateDevices(hChildDevice);
	ms_nIndentLevel -= 1;
      }
    } // while loop
  } // while loop
}

See Also

Parameters

hDevice

Handle to the physical parent device

pItr

Enumeration start position. See OTX_ITERATOR

peDeviceType

Physical or logical device type. See OtxPhysicalDeviceTypeE and OtxLogicalDeviceTypeE

Comments

The iterator is incremented to reference the next item in the sequence. It can be used in a subsequent call to the same function to fetch data for the next element in the same sequence. Repeated calls to the same function with the same iterator eventually fetches data for all items in this sequence.

The iterator must already be initialized with a call to OtxDrvIteratorBegin before the first call to this function.

It is important that the iterator is used on the same sequence of items between each call to OtxDrvIteratorBegin, i.e. the same function must be called with the same handle and the same iterator.

However, it is possible for multiple iterators to be used on the same sequence independently, at the same time, even in separate threads.

see example on OtxDrvEnumDevice

See Also

Parameters

hDevice

Handle to the device who generated the event

nEventCode

Event Cause Code to be translated. See also OtxEventDataS

nBufLen

Length of the User supplied String Buffer

szStrBuf[]

User supplied String buffer

Comments

see example on OtxHdlcReadData

Parameters

hDevice

Handle to the device being queried

nAttribId

ID of attribute

peAttribType

Type of the attribute, if attribute exists

pcbAttribValue

Size in bytes of attribute value (Get value with OtxDrvGetAttributeValue)

pbReadOnly

Is attribute writable or read-only

Comments

Example

// Read Serial Number from the board
OtxAttribTypeE  eAttribType;
OTX_UINT32      cbAttribValue;
OTX_BOOL        bReadOnly;
char *pszSerialNumber;

result = OtxDrvGetAttributeType(
	    g_hPhysDevs.hBoardController,
	    OTX_ATTR_BRD_SERIAL_NUMBER,
	    &eAttribType,
	    &cbAttribValue,
	    &bReadOnly);

assert(eAttribType == OTX_ATTRIB_SZ);
assert(bReadOnly == OTX_TRUE);

pszSerialNumber = (char *) malloc(cbAttribValue * sizeof(char));

result = OtxDrvGetAttributeValueSz(
	    g_hPhysDevs.hBoardController,
	    OTX_ATTR_BRD_SERIAL_NUMBER,
	    pszSerialNumber,
	    cbAttribValue);

// display
DemoLogf("Board Serial Number: %s\\n", pszSerialNumber);

free(pszSerialNumber);

See Also

Parameters

hDevice

Handle to the device being queried

nAttribId

ID of attribute

pAttribValueBuf

Buffer to hold the value of the attribute

cbAttribValueBuf

Size of the attribValueBuf in bytes

pcbAttribValue

Bytes actually used in attribValueBuf

Comments

Example

// get driver version
OtxVersionInfo sVersionInfo;
char szVersionInfo[255];

OtxDrvGetAttributeValueSz(
   0,
   OTX_ATTR_DRV_REV_STR,
   szVersionInfo,
   255);
OtxDrvGetAttributeValue(
   0,
   OTX_ATTR_DRV_REV_NUM,
   &sVersionInfo,
   sizeof(OtxVersionInfo),
   NULL);

// display
DemoLogf("Driver version string     %s\\n", szVersionInfo);
DemoLogf("Driver major version      %d\\n", sVersionInfo.nMjRev);
DemoLogf("Driver minor version      %d\\n", sVersionInfo.nMnRev);
DemoLogf("Driver status             %s\\n", sVersionInfo.bRelStatus ? "Released" : "Preliminary");
DemoLogf("Driver preliminary level  %d\\n", sVersionInfo.nPrelLevel);

See Also

Parameters

hDevice

Handle to the device being queried

nAttribId

ID of attribute

pAttribValue

Buffer to hold the value of the attribute

Example

// Query Library revision
char szVersionInfo[255];
OTX_BOOL bIsStaticLinkedLibrary;
char szLibFileName[64];
result = OtxDrvGetAttributeValueSz(
	    OTX_LIB_HANDLE,
	    OTX_ATTR_LIB_REV_STR,
	    szVersionInfo,
	    255);

result = OtxDrvGetAttributeValueBool(
	    OTX_LIB_HANDLE,
	    OTX_ATTR_LIB_TYPE_STATIC,
	    &bIsStaticLinkedLibrary);

result = OtxDrvGetAttributeValueSz(
	    OTX_LIB_HANDLE,
	    OTX_ATTR_LIB_FILE_NAME,
	    szLibFileName,
	    64);

// display
DemoLogf("Library version %s (filename %s, %s linked)\\n", szVersionInfo, szLibFileName, bIsStaticLinkedLibrary ? "static":"dynamic");

See Also

Parameters

hDevice

Handle to the device being queried

nAttribId

ID of attribute

pAttribValueBuf

Buffer to hold the value of the attribute

cbAttribValueBuf

Size of the attribValueBuf in bytes

Comments

See Also

Parameters

hDevice

Handle to the device being queried

nAttribId

ID of attribute

pAttribValue

Buffer to hold the value of the attribute

Example

// get board Device ID and SubSystem ID
OTX_UINT32 nDeviceId;
OTX_UINT32 nSubsystemId;

result = OtxDrvGetAttributeValueUint32(
	    g_hPhysDevs.hBoardController,
	    OTX_ATTR_BRD_DEVICE_ID,
	    &nDeviceId);

result = OtxDrvGetAttributeValueUint32(
	    g_hPhysDevs.hBoardController,
	    OTX_ATTR_BRD_SUBSYSTEM_ID,
	    &nSubsystemId);

// display
DemoLogf("Board Device ID: %d, SubsystemId: 0x%.4X\\n", nDeviceId, nSubsystemId);

See Also

Parameters

pnTimeStamp

Current time of the host

Example

result = OtxDrvGetCurrentTime(&nTimeStamp);

See Also

Parameters

hDevice

Handle to the device being queried

nDeviceType

Device type, either OtxPhysicalDeviceTypeE or OtxLogicalDeviceTypeE

nDevice

Sequence number of device within it's class

phDevice

Buffer to hold returned device handle

Comments

Example

// Get a handle to the ASM Daughter Board
result = OtxDrvGetDeviceHandle(
	    g_hPhysDevs.hThorController,
	    OTX_DEVICE_VIDAR_5x_ASM,
	    0,
	    &g_hPhysDevs.hVidarAsmController);

See Also

Parameters

hEventQueue

Event queue to read event from

pEventData

Pointer to place-holder for event data See also OtxEventDataS

Comments

Each event is time stamped.

Win32 applications can wait efficiently for events to occur by setting up a Win32 Event with the driver, see OtxWaitForSingleEvent

see example on OtxDrvWaitForSingleEvent

See Also

Parameters

hEventQueue

Event queue to read event from

psqEventData

Pointer to place-holder array for event data (OtxEventDataS)

coEventData

Capacity of psqEventData (in number of OtxEventDataS elements), i.e. maximum number of events which the driver can entry in psqEventData.

pcoEventsReturned

Number of events returned by this function (number of elements which the driver entered in psqEventData).

Example

void  *DemoIdleFunction(
  void *lpParameter   // thread data
)
{
  OTX_RESULT result;

  while (1) {
    OtxDrvWaitForSingleEvent(
       g_hNotificationEvent,
       OTX_TIME_INFINITY);

    do {
      // Multiple reads of events
      OtxEventDataS sqEventData[DEMO_EVENT_DATA_BUF_SIZE];
      OTX_INT32 coEventsFetched;
      OTX_INT32 i;

      result = OtxDrvGetEventDataEx(
		  g_hEventQueue,
		  sqEventData,
		  10,
		  &coEventsFetched);

      if (OTX_RESULT_CODE(result) == OTX_S_OK) {
	// We have a driver event (one at least)
	//DemoLogf("OtxDrvGetEventDataEx() fetched %d events\\n", coEventsFetched);

	assert(coEventsFetched <= coEventsFetched);

	for (i = 0; i < coEventsFetched; i++) {
	  // Print the event data.
	  // In a real application branch based on the data
	  DemoPrintEvent(&sqEventData[i]);
	}

      }
    } while (OTX_RESULT_CODE(result) == OTX_S_OK);

  }

  return 0;

}

See Also

Parameters

hObject

Handle to a driver object to get state info about

peDevState

State of the device. See also OtxDeviceStateE

Comments

Example

// toggle OTX_DEVICE_WORKING on device
OTX_RESULT result;
OtxDeviceStateE  eDevState;
OTX_HANDLE hHandle = g_hLogicDevs.hDtmfDialler[nCurrentLi];

result = OtxDrvGetState(
	    hHandle,
	    &eDevState);

if (eDevState == OTX_DEVICE_WORKING) {
  // disable sending device on current Li
  result = OtxDrvDisable(
	      hHandle,
	      OTX_TASK_SYNC,
	      5000L);
} else {
  // enable sending device on current Li
  result = OtxDrvEnable(
	      hHandle,
	      OTX_TASK_SYNC,
	      5000L);
}

See Also

Parameters

pItr

pointer to iterator to check. See OTX_ITERATOR

See Also

To Do

Parameters

pItr

pointer to iterator to initialize. See OTX_ITERATOR

Comments

See Also

Parameters

hHostDevice

Parent (typically Board Device) who owns the device we are connecting to Specify NULL when opening a board device

eDevType

Class of device we are looking for. See OtxPhysicalDeviceTypeE

nDevice

Sequence number of device within it's class

nEventSourceId

User specified ID to be used by this device as the Source ID for the events generated by the device

hEventQueue

Handle to separate event queue (specify OTX_INVALID_HANDLE_VALUE to create device specific event queue)

phPhysDevice

Handle to the new physical device (if result code OTX_S_OK)

Comments

The physical devices can be classified in 2 categories:

BOARD Devices: A board device represents one OTX Network Interface card or a Daughter Board Module. The board device is the placeholder and controller of other physical devices on the board.

CHIP Devices: A chip device represents a physical integrated circuit on the board performing one or several functions. A logical device can be created to represent each of the functions implemented by a chip device. For example, a Digital Signal Processor is a physical "chip" device. However, the DSP software may implement several functions which then can be represented by a multiple of logical devices.

The chip devices can be further categorized as follows:

Line Interface Devices: A hardware device that interfaces with the external network and converts/maps the non-TTL level external data interface to the internal serial data highways. Typically an actual line interface transceiver chip on a board. Examples of Line Interface Devices include T1/E1, BRI, POTS, T3/E3 Li’s.

Processor Devices: A processor (general purpose micro processor or Digital Signal Processor) is an integrated circuit that implements certain functionality (logical devices) under software control.

Switch Device: A device connecting and disconnecting data-paths.

Other miscellaneous chips.

Example

// open mother board
result = OtxDrvOpenPhysicalDevice(
	    0,                      // '0' for mother board
	    OTX_DEVICE_THOR_PCI,
	    nboardNo,
	    nboardNo,
	    g_hEventQueue,
	    &g_hPhysDevs.hBoardController);


// open daughter board or chip devices

// open two T1/E1 Line Interfaces
for (i = 0; i < 2; i++) {
  result = OtxDrvOpenPhysicalDevice(
	      g_hPhysDevs.hBoardController,
	      OTX_DEVICE_LI_T1E1,
	      i,
	      i,
	      g_hEventQueue,
	      &g_hPhysDevs.hLi[i]);
}

See Also

Parameters

hPhysDevice

Handle to the physical device

nEventSourceId

User specified ID to be used by this device as the Source ID for the events generated by the device

hEventQueue

Handle to separate event queue (specify OTX_INVALID_HANDLE_VALUE to create device specific event queue)

Comments

See Also

Parameters

hDevice

Handle to device

Comments

Example

OtxEventDataS eventData;
OTX_RESULT result;

OtxDrvPollEvents(g_hPhysDevs.hThorController0);

result = OtxDrvGetEventData(g_hEventQueue, &eventData);

if (OTX_RESULT_CODE(result) == OTX_S_OK) {
  // We have a driver event
  // Printf the event data.
  // In a real application branch based on the data
  DemoPrintEvent(&eventData);
}

Parameters

hDevice

Handle to the device to read from

nAddress

Register address within the device

pnValue

16-bit value read from the device

Example

OTX_UINT32 readVal;
char strBuf[12];
static OTX_UINT32 nAddress = 0;

// read from a 16-bit register in board device
DemoLogf("Which Address (0x%X): ", nAddress);
OsaConsoleGetStr(strBuf);
if (*strBuf) {
  nAddress = strtoul(strBuf, NULL, 0);
}

result = OtxDrvReadReg16(
	    g_hPhysDevs.hBoardController,
	    nAddress,
	    &readVal);

// display
DemoLogf("Brd Address 0x%X = %.4X\\n", nAddress, (OTX_UINT16)readVal);

Parameters

hDevice

Handle to the device to read from

nAddress

Register address within the device

pnValue

32-bit value read from the device

To Do

Parameters

hDevice

Handle to the device to read from

nAddress

Register address within the device

pnValue

8-bit value read from the device

Example

OTX_UINT32 readVal;
char strBuf[12];
static OTX_UINT32 nAddress = 0;

// read from an 8-bit register in current Li
DemoLogf("Which Address (0x%X): ", nAddress);

OsaConsoleGetStr(strBuf);
if (*strBuf) {
  nAddress = strtoul(strBuf, NULL, 0);
}

result = OtxDrvReadReg8(
	    g_hPhysDevs.hLi[nCurrentLi],
	    nAddress,
	    &readVal);

// display
DemoLogf("Li%d Address 0x%X = %.2X\\n", nCurrentLi, nAddress, (OTX_UINT8)readVal);

Comments

see example on

Example

See Also

Events in the event queue for the particular object are removed by this command.
Defined in: OtxDrv.h

Parameters

hObject

Handle to a object to reset

Example

// reset HdlcReceiver on current Li
result = OtxDrvReset(g_hLogicDevs.hHdlcReceiver[nCurrentLi]);

See Also

Parameters

hDevice

Handle to the device who generated the result code

nResultCode

Result Code to be translated. See also OTX_RESULT

nBufLen

Length of the User supplied String Buffer

szStrBuf[]

User supplied String buffer

Comments

Usaully it is used in DemoCheckRc() on demo programs

Example

static void DemoCheckRc(IN OTX_HANDLE hDevice, IN OTX_RESULT result)
{
  if ( OTX_FAILURE(result) ) {

    if (hDevice == OTX_INVALID_HANDLE_VALUE) {
      DemoLogf("ERROR(%#lX) \\n", result);
    } else {
      OTX_RESULT otxRc;
      char msgStr[256];
      OtxAttribTypeE  eAttribType;
      OTX_UINT32      cbAttribValue;
      OTX_BOOL        bReadOnly;
      OTX_UINT32      eDeviceType = 999;
      OTX_UINT32      nDeviceNumber = 999;

      // Get the Device Type for hHandle
      otxRc = OtxDrvGetAttributeType(
		 hDevice,
		 OTX_ATTR_DEVICE_TYPE,
		 &eAttribType,
		 &cbAttribValue,
		 &bReadOnly);

      if (OTX_SUCCESS(otxRc)) {
	assert(eAttribType == OTX_ATTRIB_UINT32);
	assert(cbAttribValue == sizeof(OTX_UINT32));
	OtxDrvGetAttributeValueUint32(
		 hDevice,
		 OTX_ATTR_DEVICE_TYPE,
		 &eDeviceType);
      }

      // Get the Device Number for hHandle
      otxRc = OtxDrvGetAttributeType(
		 hDevice,
		 OTX_ATTR_DEVICE_NO,
		 &eAttribType,
		 &cbAttribValue,
		 &bReadOnly);

      if (OTX_SUCCESS(otxRc)) {
	assert(eAttribType == OTX_ATTRIB_UINT32);
	assert(cbAttribValue == sizeof(OTX_UINT32));
	OtxDrvGetAttributeValueUint32(hDevice, OTX_ATTR_DEVICE_NO, &nDeviceNumber);
      }

      // Convert the result code to a more descriptive string
      otxRc = OtxDrvResultCode2String(
		 hDevice,
		 result,
		 256,
		 &msgStr[0]);

      if (OTX_FAILURE(otxRc)) {
	strcpy(msgStr, "Cannot translate this result code.");
      }
      DemoLogf("ERROR(%#lX [%d.%d]) Dev(%X,%d,%d): %s \\n", OTX_RESULT_CODE(result), OTX_RESULT_SOURCE_ID(result), OTX_RESULT_LINE_NUM(result), hDevice, (int) eDeviceType, (int)nDeviceNumber, msgStr);
    }

    DemoExitQuestion();
  }
}

Parameters

hDevice

Handle to the device being queried

nAttribId

ID of attribute

attribValueBuf[]

Value of the attribute, if attribute exists

cbAttribValueBuf

Size in bytes of the buffer for the value

Comments

See Also

To Do

Parameters

hDevice

Handle to the device being queried

nAttribId

ID of attribute

attribValue

Value of the attribute, if attribute exists

Example

// toggle OTX_ATTR_T1E1_AUTOMATIC_RESET attribute
OTX_BOOL bAutomaticResetMode;

result = OtxDrvGetAttributeValueBool(
	    g_hPhysDevs.hLi[nCurrentLi],
	    OTX_ATTR_T1E1_AUTOMATIC_RESET,
	    &bAutomaticResetMode);

bAutomaticResetMode = !bAutomaticResetMode;

result = OtxDrvSetAttributeValueBool(
	    g_hPhysDevs.hLi[nCurrentLi],
	    OTX_ATTR_T1E1_AUTOMATIC_RESET,
	    bAutomaticResetMode);

See Also

Parameters

hDevice

Handle to the device being queried

nAttribId

ID of attribute

pAttribValue

Value of the attribute, if attribute exists

Example

// configuring Thor-2-PCMCIA series board for dongle type
result = OtxDrvSetAttributeValueSz(
	    g_hPhysDevs.hBoardController,
	    OTX_ATTR_BRD_PCMCIA_DONGLE_TYPE,
	    "HMA-1079-2-1.0");

See Also

Parameters

hDevice

Handle to the device being queried

nAttribId

ID of attribute

attribValue

Value of the attribute, if attribute exists

Example

// set Receive Input Threshold for current Li
char strBuf[12];
OTX_UINT32 nThresholdInMilliVolts;

result = OtxDrvGetAttributeValueUint32(
	    g_hPhysDevs.hLi[nCurrentLi],
	    OTX_ATTR_T1E1_RX_INPUT_THRESHOLD,
	    &nThresholdInMilliVolts);

// display
DemoLogf("Threshold (%d mV): ", nThresholdInMilliVolts);

nThresholdInMilliVolts = 100;

// set attribute
result = OtxDrvSetAttributeValueUint32(
	    g_hPhysDevs.hLi[nCurrentLi],
	    OTX_ATTR_T1E1_RX_INPUT_THRESHOLD,
	    nThresholdInMilliVolts);

// get attribute
result = OtxDrvGetAttributeValueUint32(
	    g_hPhysDevs.hLi[nCurrentLi],
	    OTX_ATTR_T1E1_RX_INPUT_THRESHOLD,
	    &nThresholdInMilliVolts);

// display
DemoLogf("Receive Input Threshold is changed to %d mV.\\n", nThresholdInMilliVolts);

See Also

Parameters

hEventQueue

Event queue to be used

eDeviceType

Device Type with which the event is associated

nSourceId

Device Id of the device that the event is associated with (supplied by the user when the device for opened/created)

hDevice

Handle to the Device with which the event is associated

nCode

Device specific cause code indicating what happened. Each device types has it own set of event cause codes

nRequestId

If the message is for a previous user request this member holds the user assigned request ID

nParam

Optional parameter with user defined meaning

Comments

The driver will time stamp the event.

Example

// set an event in the event queue
OtxDrvSetEventData(
   g_hEventQueue,
   OTX_DEVICE_LI_T1E1,
   0,
   g_hPhysDevs.hLi[nCurrentLi],
   OTX_T1E1_EC_AIS,
   0,
   9);

See Also

Parameters

hEventQueue

Event queue to be used

eDeviceType

Device Type with which the event is associated

nSourceId

Device Id of the device that the event is associated with (supplied by the user when the device for opened/created)

hDevice

Handle to the Device with which the event is associated

nCode

Device specific cause code indicating what happened. Each device types has it own set of event cause codes

nRequestId

If the message is for a previous user request this member holds the user assigned request ID

nParam

Optional parameter with user defined meaning

nTimeStamp

Timestamp to mark the event with

Comments

The driver will time stamp the event.

Example

// set an event in the event queue
OtxDrvSetEventDataEx(
   g_hEventQueue,
   OTX_DEVICE_LI_T1E1,
   0,
   g_hPhysDevs.hLi[nCurrentLi],
   OTX_T1E1_EC_AIS,
   0,
   9,
   nTimeStamp);

See Also

Parameters

hEvent

Handle to an Event to be set into signalled state. See Also OTX_EVENT

Comments

Example

// just a demostration of usage of OtxDrvSignalEvent() and OtxDrvCloseEvent()
OTX_EVENT g_hEvent;

void *DemoTestThreadFunc(
  void *lpParameter   // thread data
)
{
  int i, j, x;
  // Thread Running, waiting for event
  OtxDrvWaitForSingleEvent(g_hEvent, OTX_TIME_INFINITY);

  // just spend some time
  for (i=0; i<20; i++) {
    for (j=0;j<1000; j++) {
      x = 3 * i + 4 * j;
    }
  }
  DemoLogf("Thread exiting\\n");

  return 0;
}


if (OTX_SUCCESS(OtxDrvCreateEvent(&g_hEvent))) {
  // starting Thread
  OsaThreadStart(DemoTestThreadFunc);

  OsaThreadSleep(0);
  DemoLogf("Hit return to signaling event\\n");
  getch();
  OtxDrvSignalEvent(g_hEvent);
  OsaThreadSleep(0);

  DemoLogf("Hit return to close event and exit\\n");
  getch();
  OtxDrvCloseEvent(g_hEvent);

} else {
  DemoLogf("Failed to create event\\n");
  getch();
}

See Also

Parameters

coEventHandles

Event handle count

sqhEvents[]

Array of event handles. See Also OTX_EVENT

nWaitMaxMs

Max time to wait in millisconds

bWaitAll

Specifies the wait type. If OTX_TRUE, the function returns when the state all objects in the lpHandles array is signaled. If OTX_FALSE, the function returns when the state of any one of the objects set to is signaled. In the latter case, the return value indicates the object whose state caused the function to return. See also OTX_BOOL

pnEventFired

index to event in array that fired

Comments

Specify nMilliseconds = OTX_TIME_INFINITY to wait forever.

See Also

To Do

Return Value

OTX_E_HANDLE

Handle invalid

OTX_S_TIMEOUT

Wait timed out

OTX_S_OK

Event occured

OTX_E_FAIL

Non-specified failure

Parameters

hEvent

Event handle, initilized with OtxDrvCreateEvent

nWaitMaxMs

Max time to wait in millisconds

Comments

Specify nMilliseconds = OTX_TIME_INFINITY to wait forever.

Example

// check for Events from the OTX Driver
while (1) {
  OtxDrvWaitForSingleEvent(
     g_hNotificationEvent,
     OTX_TIME_INFINITY);
  do {
    result = OtxDrvGetEventData(
		g_hEventQueue,
		&eventData);

    if (OTX_RESULT_CODE(result) == OTX_S_OK) {
      // We have a driver event
      // Print the event data.
      // In a real application branch based on the data
      DemoPrintEvent(&eventData);
  }
} while (OTX_RESULT_CODE(result) == OTX_S_OK);

See Also

Parameters

hDevice

Handle to the device to write to

nAddress

Register address within the device

nValue

16-bit value to be written to the device

Example

char strBuf[12];
static OTX_UINT32 nAddress = 0;
static OTX_UINT32 nValue = 0;

// write to a 16-bit register in board device
DemoLogf("Which Address (0x%X): ", nAddress);
OsaConsoleGetStr(strBuf);
if (*strBuf) {
  nAddress = strtoul(strBuf, NULL, 0);
}
DemoLogf("Which Value (0x%X): ", nValue);
OsaConsoleGetStr(strBuf);
if (*strBuf) {
  nValue = strtoul(strBuf, NULL, 0);
}

result = OtxDrvWriteReg16(
	    g_hPhysDevs.hBoardController,
	    nAddress,
	    nValue);

DemoLogf("Wrote %.4X to Brd Address 0x%X\\n", (OTX_UINT16)nValue, nAddress);

Parameters

hDevice

Handle to the device to write to

nAddress

Register address within the device

nValue

32-bit value to be written to the device

To Do

Parameters

hDevice

Handle to the device to write to

nAddress

Register address within the device

nValue

8-bit value to be written to the device

Example

char strBuf[12];
static OTX_UINT32 nAddress = 0;
static OTX_UINT32 nValue = 0;

// write to an 8-bit register in current Li
DemoLogf("Which Address (0x%X): ", nAddress);
OsaConsoleGetStr(strBuf);
if (*strBuf) {
  nAddress = strtoul(strBuf, NULL, 0);
}
DemoLogf("Which Value (0x%X): ", nValue);
OsaConsoleGetStr(strBuf);
if (*strBuf) {
  nValue = strtoul(strBuf, NULL, 0);
}

result = OtxDrvWriteReg8(
	    g_hPhysDevs.hLi[nCurrentLi],
	    nAddress,
	    nValue);

DemoLogf("Wrote %.2X to Li%d Address 0x%X\\n", (OTX_UINT8)nValue, nCurrentLi, nAddress);

Parameters

szProgfile

Application file to be converted to an image

szEntryPoint

Label for the entry point of the application. Usually "_c_int00" for a C-compiled application.

coProgImageMax

Count of objects (size) of psqProgImage (in elements) provided by the user

psqProgImage

Image Buffer provided by the user

coProgImage

Number of image elements returned in psqProgImage

nEntryAddr

Program Entry address

Example

OTX_UINT16 *psqProgImage;
OTX_UINT16 coProgImage;
OTX_INT32  nEntryAddr;
const OTX_UINT16 DEMO_DSP_IMAGE_BUF_SIZE = 60000;

psqProgImage = (OTX_UINT16 *)malloc(DEMO_DSP_IMAGE_BUF_SIZE*sizeof(OTX_UINT16));

// convert "OtxSpm1.out" to DSP image format
result = OtxDspCreateProgramImage(
	    "OtxSpm1.out",
	    "_c_int00",
	    DEMO_DSP_IMAGE_BUF_SIZE,
	    psqProgImage,
	    &coProgImage,
	    &nEntryAddr);

// load DSP program with image format
for (nDsp = 0; nDsp < 2; nDsp++) {
  result = OtxDspRunImage(
	      g_hPhysDevs.hDsp[nDsp],
	      psqProgImage,
	      coProgImage,
	      nEntryAddr);
}

free(psqProgImage);

See Also

Parameters

szProgfile

Application file to be converted to an image

szEntryPoint

Label for the entry point of the application. Usually "_c_int00" for a C-compiled application.

coProgImageMax

Count of objects (size) of psqProgImage (in elements) provided by the user

psqProgImage

Image Buffer provided by the user

coProgImage

Number of image elements returned in psqProgImage

nEntryAddr

Program Entry address

Example

#define IMAGE_BUF_SIZE 128000
static OTX_UINT16 g_psqProgImage[IMAGE_BUF_SIZE];

// convert "OtxSpm5.out" to DSP Extended Image format
result = OtxDspCreateProgramImageEx(
	    "OtxSpm5.out",
	    "_c_int00",
	    IMAGE_BUF_SIZE,
	    g_psqProgImage,
	    &coProgImage,
	    &nEntryAddr);

// load DSP program with image format
for (nDsp = 0; nDsp < 2; nDsp++) {
  result = OtxDspRunImage(
	      g_hPhysDevs.hDsp[nDsp],
	      psqProgImage,
	      coProgImage,
	      nEntryAddr);
}

free(psqProgImage);

See Also

Parameters

hDspDevice

Handle to the physical DSP device

nIoControlCode

I/O Control Code to be passed

pInBuf

Pointer to the user allocated input buffer

nInBufSize

Size of the input buffer

pOutBuf

Pointer to the user allocated output buffer

nOutBufSize

Size of the output buffer

pnBytesReturned

Number of Bytes returned

nTaskRef

See OTX_TASK_REF

nWaitMaxMs

See OTX_TIME

Example

Demo1IoInSetBlinkFreqS sIn;
OTX_UINT32 nBytesReturned;
OTX_UINT16 nDemo1Rc;

sIn.nBlinkCountFactor = DEMO_FAST_BLINK_COUNT_FACTOR;
sIn.nDummyData = 6;

// sending Blink Count factor DEMO_FAST_BLINK_COUNT_FACTOR to User App
result = OtxDspIoControl(
	    g_hLogicDevs.hUserApp,
	    DEMO1_IOCTL_SET_BLINK_FREQ,
	    &sIn,
	    sizeof(sIn),
	    &nDemo1Rc,
	    sizeof(nDemo1Rc),
	    &nBytesReturned,
	    OTX_TASK_SYNC,
	    OTX_TIME_INFINITY);

Return Value

OTX_S_OK

Data was fetched

OTX_S_FALSE

No Data available at this moment

OTX_E_BUFFER_TO_SMALL

The supplied user data buffer is too small to fit the received data

Parameters

hDspDevice

Handle to the physical DSP device

nTaskRef

See OTX_TASK_REF

pOutBuf

Pointer to the user allocated output buffer

nOutBufSize

Size of the output buffer

pnBytesReturned

Number of Bytes returned

pnIoControlCode

I/O Control Code the returned data is associated with

Comments

Example

// Note: function DemoLogf() is used to display message in our demo programs

case OTX_LDEVICE_USER_APPLICATION:
  if (pEventData->m_nCode == OTX_USER_APPLICATION_EC_READ_DATA) {
    OTX_UINT8  buf[8192];
    OTX_UINT32 nBytesReturned;
    OTX_UINT32 nIoControlCode;

    otxRc = OtxDspReadData(
	       pEventData->m_hDevice,
	       OTX_TASK_SYNC,
	       buf,
	       8192,
	       &nBytesReturned,
	       &nIoControlCode);

    if (OTX_RESULT_CODE(otxRc) == OTX_S_OK) {
      switch(nIoControlCode) {
	case DEMO1_NOTIFY_DEBUG_DATA:
	{
	  Demo1NotifyGetDebugDataS *pDataS = (Demo1NotifyGetDebugDataS *)buf;
	  if (nBytesReturned != sizeof(Demo1NotifyGetDebugDataS)) {
	    DemoLogf("Unexpected data length for this IoControlCode (nIoControlCode = %d, nBytesReturned=%d)\\n", nIoControlCode, nBytesReturned);
	  } else {
	    DemoLogf("DEMO1_NOTIFY_DEBUG_DATA (nRequestId=%d, nBytes=%d)\\n", pEventData->m_nRequestId, nBytesReturned);
	    DemoLogf("nData0 = %.4X\\n", pDataS->nData0);
	    DemoLogf("nData1 = %.4X\\n", pDataS->nData1);
	    DemoLogf("nData2 = %.4X\\n", pDataS->nData2);

	    DemoLogf("sqBuf[299] = %.4X\\n", pDataS->sqBuf[299]);
	  }
	}
	break;

	default:
	  DemoLogf("Unknown IoControlCode received in OtsDspReadData (nIoControlCode = %d, nBytesReturned=%d, nRequestId=%d)\\n", nIoControlCode, nBytesReturned, pEventData->m_nRequestId);
	break;
      }

    } else {

      OTX_RESULT errorCode = otxRc;
      otxRc = OtxDrvResultCode2String(
		 pEventData->m_hDevice,
		 errorCode,
		 256,
		 &msgStr[0]);

      if (OTX_SUCCESS(otxRc)) {
	DemoLogf("User App[%d] Error: %s \\n", pEventData->m_nSourceId, msgStr);
      } else {
	DemoLogf("User App[%d] Invalid Error Code: %ld\\n", pEventData->m_nSourceId, errorCode);
      }
    }

  } else {

    otxRc = OtxDrvEventCode2String(
	       pEventData->m_hDevice,
	       pEventData->m_nCode,
	       256,
	       &msgStr[0]);

    if (OTX_SUCCESS(otxRc)) {
      DemoLogf("User App[%d] Event: %s (nRequestId=%d)\\n", pEventData->m_nSourceId, msgStr, pEventData->m_nRequestId);
    } else {
      DemoLogf("User App[%d] Invalid Event: %ld (nRequestId=%d)\\n", pEventData->m_nSourceId, pEventData->m_nCode, pEventData->m_nRequestId);
    }
  }
break;  // end of OTX_LDEVICE_USER_APPLICATION

See Also

Parameters

hDspDevice

Handle to the physical DSP device

nHpiAddress

HPI Address to start to read from

coWordsToRead

Number of OTX_UINT16s (Words) to read from the HPI

pReadBuf

Pointer to the user allocated output buffer (Words)

Comments

API OtxDspWriteHpi can be used to write the data

Example

OTX_UINT32 i;
OTX_UINT16 sqReadBuf[0x800];

// dump the entire HPI memory for the current DSP
result = OtxDspReadHpi(
	    g_hPhysDevs.hDsp,
	    0x1000,
	    0x800,
	    sqReadBuf);

// display the data
for (i = 0; i < 0x800; i++) {
    if (i && ((i % 8) == 0))
    DemoLogf("\\n %.4X ", sqReadBuf[i]);
  }
}

See Also

This function is only meant to be called if a DSP Debugger is being used.
Defined in: OtxDsp.h

Parameters

hDspDevice

Handle to DSP device

Example

1. First the OtxDspRunImage(), OtxDspRunSpm(), or OtxDspRunProgram() is called.
2. Immediately thereafter the host application must be stopped.
3. While the host application is stopped the DSP program is loaded and started
   from the DSP Debugger.
4. Once the DSP program is running again, OtxDspRunProgram() should be called
   to bring the DSP program back to the state it was right after step 1 was
   executed.

// load DSP program
for (nDsp = 0; nDsp < 2; nDsp++) {
  result = OtxDspRunSpm(
	      g_hPhysDevs.hDsp[nDsp],
	      OTX_DSP_SPM_OTXSPM1);
}

// load and run DSP program to all of the DSPs in the DSP Debugger

// restart program on DSPs
for (i = 0; i < 2; i++) {
    result = OtxDspRestartProgram(g_hPhysDevs.hDsp[i]);
}

See Also

Parameters

hDspDevice

Handle to DSP device

psqProgImage

Program image

coProgImage

Number of elements in psqProgImage

nEntryAddr

Program Entry Address

Example

see example on

See Also

Parameters

hDspDevice

Handle to DSP device

szPrgfile

Application file to be loaded

szEntryPoint

Label for the entry point of the application

Example

// open physical device of DSP
for (i = 0; i < 2; i++) {
  result = OtxDrvOpenPhysicalDevice(
	      g_hPhysDevs.hBoardController, // Vidar series or Thor-2-PCMCIA series
	      OTX_DEVICE_DSP,
	      i,
	      i,
	      g_hEventQueue,
	      &g_hPhysDevs.hDsp[i]);
}

// load DSP program from file OtxSpm1.out
for (nDsp = 0; nDsp < 2; nDsp++) {
  result = OtxDspRunProgram(
	      g_hPhysDevs.hDsp[nDsp],
	      "OtxSpm1.out",
	      "_c_int00");
}

See Also

Parameters

hDspDevice

Handle to DSP device

eProgramModule

Standard Program Module to be loaded in the DSP (from the Lib)

Example

// open physical device of DSP
for (i = 0; i < 2; i++) {
  result = OtxDrvOpenPhysicalDevice(
	      g_hPhysDevs.hBoardController, // Vidar series or Thor-2-PCMCIA series
	      OTX_DEVICE_DSP,
	      i,
	      i,
	      g_hEventQueue,
	      &g_hPhysDevs.hDsp[i]);
}


// load DSP Program OTX_DSP_SPM_OTXSPM1
for (i = 0; i < 2; i++) {
  result = OtxDspRunSpm(
	      g_hPhysDevs.hDsp[i],
	      OTX_DSP_SPM_OTXSPM1);
}

See Also

Parameters

hDspDevice

Handle to the physical DSP device

nHpiAddress

HPI Address to start to write to

coWordsToWrite

Number of OTX_UINT16s (Words) to write to the HPI

pWriteBuf

Pointer to the user allocated input buffer (Words)

Comments

API OtxDspReadHpi can be used to check the data written

Example

static OTX_UINT16 writeVal = 0x5A5A;
OTX_UINT16 sqWriteBuf[1];

sqWriteBuf[0] = writeVal;

// write a value to the last address in the HPI memory for the current DSP
result = OtxDspWriteHpi(
	    g_hPhysDevs.hDsp,
	    0x17FF,
	    1,
	    sqWriteBuf);

See Also

Parameters

hLogicDevice

Handle to the E1 ABCD-Bit Access Logical Device

pABCDBitData

ABCD CAS signalling data received. See also OtxE1ABCDBitDataS

Comments

Example

OTX_INT32 i;
OTX_INT32 nCurrentLi = 0;
OtxE1ABCDBitDataS  rxABCDBitData;

for (i = 0; i < 2; i++) {
  // create CAS logical devices hosted in the physical Line Interface devices
  result = OtxDrvCreateLogicalDevice(
	      g_hPhysDevs.hLi[i],
	      OTX_LDEVICE_E1_ABCD_BIT_ACCESS,
	      g_hEventQueue,
	      i,
	      &g_hLogicDevs.hT1E1Cas[i]);

  // enable Logical T1/E1 Cas Devices
  result = OtxDrvEnable(
	      g_hLogicDevs.hT1E1Cas[i],
	      OTX_TASK_SYNC, 5000L);

}

// get ABCD bit data from current Line
result = OtxE1GetABCDBit(
	    g_hLogicDevs.hT1E1Cas[nCurrentLi],
	    &rxABCDBitData);

// display the data
printf("A = %.6X, B = %.6X, C = %.6X, D = %.6X\\n", rxABCDBitData.chA, rxABCDBitData.chB, rxABCDBitData.chC, rxABCDBitData.chD);
printf("\\n");
printf("            ABCD              ABCD\\n");
printf("            ====              ====\\n");
for (i = 1; i <= 30; i++) {
  char *pszValue;
  pszValue[0] = '\\0';

  printf("Channel %.2d: ", i);

  sprintf(pszValue + strlen(pszValue), "%d",  (pABCDBitData->chA >> (nCasCh - 1)) & 0x01 ? 1 : 0);
  sprintf(pszValue + strlen(pszValue), "%d",  (pABCDBitData->chB >> (nCasCh - 1)) & 0x01 ? 1 : 0);
  sprintf(pszValue + strlen(pszValue), "%d",  (pABCDBitData->chC >> (nCasCh - 1)) & 0x01 ? 1 : 0);
  sprintf(pszValue + strlen(pszValue), "%d",  (pABCDBitData->chD >> (nCasCh - 1)) & 0x01 ? 1 : 0);

  if (!(i % 2)) {
    printf("\\n");
  }
}
printf("\\n");

Developer Notes

See Also

Parameters

hLogicDevice

Handle to the E1 ABCD-Bit Access Logical Device

nChannel

CAS Channel (1 - 30)

pnABCDBits

The ABCD bits for this channel are returned in the lower nibble of this parameter (A=bit3,B=bit2,C=bit1,D=bit0)

Example

OTX_INT32 i;
OTX_UINT8 nABCDBits;
OTX_INT32 nCurrentLi = 0;

for (i = 0; i < 2; i++) {
  //set Channelized ABCD bit access on Line Interface
  result = OtxDrvSetAttributeValueBool(
	      g_hPhysDevs.hLi[i],
	      OTX_ATTR_T1E1_CHANNELIZED_ABCD_BIT_ACCESS,
	      OTX_TRUE);

  // create CAS logical devices hosted in the physical Line Interface devices
  result = OtxDrvCreateLogicalDevice(
	      g_hPhysDevs.hLi[i],
	      OTX_LDEVICE_E1_ABCD_BIT_ACCESS,
	      g_hEventQueue,
	      i,
	      &g_hLogicDevs.hT1E1Cas[i]);

  // enable Logical T1/E1 Cas Devices
  result = OtxDrvEnable(
	      g_hLogicDevs.hT1E1Cas[i],
	      OTX_TASK_SYNC, 5000L);

}

for (i = 1; i <= 30; i++) {
  result = OtxE1GetChannelizedABCDBit(
	      g_hLogicDevs.hT1E1Cas[nCurrentLi],
	      i,
	      &nABCDBits);

  // display the data
  printf("   Channel %.2d: 0x%X", i, nABCDBits);
  if (!(i % 2)) {
    printf("\\n");
  }
}

Developer Notes

See Also

Parameters

hLineDevice

Handle to the T1/E1 Transceiver Device

pE1ConfigOptions

E1 Configuration Data

Example

OtxE1ConfigOptionsS m_sE1CfgData[2];

for (i = 0; i < 2; i++) {

  // get handle of Line Interface
  result = OtxDrvOpenPhysicalDevice(
	    g_hPhysDevs.hBoardController,
	    OTX_DEVICE_LI_T1E1,
	    i,
	    i,
	    g_hEventQueue,
	    &g_hPhysDevs.hLi[i]);

  result = OtxE1GetConfiguration(
	    g_hPhysDevs.hLi[i],
	    &(m_sE1CfgData[i]));
}

See Also

Parameters

hLogicDevice

Handle to the E1 S-Bit Access Logical Device

eSaBit

Sa bit to retrieve. See also OtxE1SaBitE

pSaVal

Last 8 received Sa-bits

Comments

Example

for (i = 0; i < 2; i++) {
  // create CAS logical devices hosted in the physical Line Interface devices
  result = OtxDrvCreateLogicalDevice(
	      g_hPhysDevs.hLi[i],
	      OTX_LDEVICE_E1_S_BIT_ACCESS,
	      g_hEventQueue,
	      i,
	      &g_hLogicDevs.hT1E1Cas[i]);

  // enable Logical T1/E1 Cas Devices
  result = OtxDrvEnable(
	      g_hLogicDevs.hT1E1Cas[i],
	      OTX_TASK_SYNC,
	      5000L);
}

// read service word data (Sa and Si bits) from all Lis
for (nLi = 0; nLi < 2; nLi++) {
  OTX_UINT16 nSaPos;
  OTX_UINT8 nSaVal;

  for (nSaPos = 4; nSaPos <= 8; nSaPos++) {
    result =  OtxE1GetSaBit(
		 g_hLogicDevs.hT1E1Cas[nLi],
		 (OtxE1SaBitE)(OTX_E1_SA4 + (nSaPos - 4)),
		 &nSaVal);

    // display them
    printf("  SA%d=%.2X \\n", nSaPos, nSaVal);
  }
}

Developer Notes

See Also

Parameters

hLogicDevice

Handle to the E1 S-Bit Access Logical Device

pSi1Val

Value of the FAS Si-bit in doubleframe format or Si (E) bit in frame 13 in CRC-multiframe format

pSi2Val

Value of the service word Si bit in DoubleFrame format or Si (E) bit in frame 15 in CRC-multiframe format

Comments

In CRC-Multiframe format, the Si bit are the first bits of frames 13 and 15. In CRC-Multiframe format these bits are also known as the E-bits.

Example

OTX_UINT8 nSi1Val;
OTX_UINT8 nSi2Val;

for (i = 0; i < 2; i++) {
  // create CAS logical devices hosted in the physical Line Interface devices
  result = OtxDrvCreateLogicalDevice(
	      g_hPhysDevs.hLi[i],
	      OTX_LDEVICE_E1_S_BIT_ACCESS,
	      g_hEventQueue,
	      i,
	      &g_hLogicDevs.hT1E1Cas[i]);

  // enable Logical T1/E1 Cas Devices
  result = OtxDrvEnable(
	      g_hLogicDevs.hT1E1Cas[i],
	      OTX_TASK_SYNC,
	      5000L);
}

for (nLi = 0; nLi < 2; nLi++) {
  result =  OtxE1GetSiBit(
	       g_hLogicDevs.hT1E1Cas[nLi],
	       &nSi1Val,
	       &nSi2Val);
  // display
  printf("  Si1=%.1X", nSi1Val);
  printf("  Si2=%.1X \\n", nSi2Val);
}

Developer Notes

See Also

Parameters

hLogicDevice

Handle to the E1 ABCD-Bit Access Logical Device

pABCDBitData

ABCD CAS signalling data to be transmitted. See also OtxE1ABCDBitDataS

Comments

Example

OTX_INT32 nCurrentLi = 0;
OtxE1ABCDBitDataS  g_sqSendABCDBitData[2];

for (i = 0; i < 2; i++) {
  // create CAS logical devices hosted in the physical Line Interface devices
  result = OtxDrvCreateLogicalDevice(
	      g_hPhysDevs.hLi[i],
	      OTX_LDEVICE_E1_ABCD_BIT_ACCESS,
	      g_hEventQueue,
	      i,
	      &g_hLogicDevs.hT1E1Cas[i]);

  // enable Logical T1/E1 Cas Devices
  result = OtxDrvEnable(
	      g_hLogicDevs.hT1E1Cas[i],
	      OTX_TASK_SYNC, 5000L);

}

// set ABCD-bits to ABCD = 0101 on all CAS channels on current Li
g_sqSendABCDBitData[nCurrentLi].chA = 0x00000000;
g_sqSendABCDBitData[nCurrentLi].chB = 0xffffffff;
g_sqSendABCDBitData[nCurrentLi].chC = 0x00000000;
g_sqSendABCDBitData[nCurrentLi].chD = 0xffffffff;

result = OtxE1SetABCDBit(
	    g_hLogicDevs.hT1E1Cas[nCurrentLi],
	    &g_sqSendABCDBitData[nCurrentLi]);

Developer Notes

See Also

Parameters

hLogicDevice

Handle to the E1 ABCD-Bit Access Logical Device

nChannel

CAS Channel (1 - 30)

nABCDBits

The ABCD bits for this channel to be transmitted (A=bit3,B=bit2,C=bit1,D=bit0)

Comments

Example

OTX_INT32 nCurrentLi = 0;

for (i = 0; i < 2; i++) {
  //set Channelized ABCD bit access on Line Interface
  result = OtxDrvSetAttributeValueBool(
	      g_hPhysDevs.hLi[i],
	      OTX_ATTR_T1E1_CHANNELIZED_ABCD_BIT_ACCESS,
	      OTX_TRUE);

  // create CAS logical devices hosted in the physical Line Interface devices
  result = OtxDrvCreateLogicalDevice(
	      g_hPhysDevs.hLi[i],
	      OTX_LDEVICE_E1_ABCD_BIT_ACCESS,
	      g_hEventQueue,
	      i,
	      &g_hLogicDevs.hT1E1Cas[i]);

  // enable Logical T1/E1 Cas Devices
  result = OtxDrvEnable(
	      g_hLogicDevs.hT1E1Cas[i],
	      OTX_TASK_SYNC, 5000L);

}

// set transmitted ABCD bit data (for all channels) to 0101 (0x05) on current Li
for (i = 1; i <= 30; i++) {
  result = OtxE1SetChannelizedABCDBit(
	      g_hLogicDevs.hT1E1Cas[nCurrentLi],
	      i,
	      0x05);
}

Developer Notes

See Also

Parameters

hLineDevice

Handle to the T1/E1 Transceiver Device

pE1ConfigOptions

E1 Configuration Data

Example

// see example on

See Also

Parameters

hLogicDevice

Handle to the E1 S-Bit Access Logical Device

eSaBit

Sa bit to set. See also OtxE1SaBitE

nSaVal

Byte (8 bits) to be sent. LSB will be sent first.

Comments

In Doubleframe format one bit of the saVal word is sent in the every other frame starting from the least significant bit.

Start signalling by calling function OtxDrvEnable and end it with function OtxDrvDisable

Example

OTX_INT32 nCurrentLi = 0;
OTX_UINT8 nSaVal;
char wValStr[12];

for (i = 0; i < 2; i++) {
  // create CAS logical devices hosted in the physical Line Interface devices
  result = OtxDrvCreateLogicalDevice(
	      g_hPhysDevs.hLi[i],
	      OTX_LDEVICE_E1_S_BIT_ACCESS,
	      g_hEventQueue,
	      i,
	      &g_hLogicDevs.hT1E1Cas[i]);

  // enable Logical T1/E1 Cas Devices
  result = OtxDrvEnable(
	      g_hLogicDevs.hT1E1Cas[i],
	      OTX_TASK_SYNC,
	      5000L);
}

// set Sa4 values 0x04 on current Line
result = OtxE1SetSaBit(
	    g_hLogicDevs.hT1E1Cas[nCurrentLi],
	    OTX_E1_SA4,
	    0x04);

Developer Notes

See Also

Parameters

hLogicDevice

Handle to the E1 S-Bit Access Logical Device

nSi1Val

Value of the FAS Si-bit in doubleframe format or Si (E) bit in frame 13 in CRC-multiframe format

nSi2Val

Value of the service word Si bit in DoubleFrame format or Si (E) bit in frame 15 in CRC-multiframe format

Comments

In CRC-Multiframe format, the Si bit are the first bits of frames 13 and 15. In CRC-Multiframe format these bits are also known as the E-bits.

Example

OTX_INT32 nCurrentLi = 0;

for (i = 0; i < 2; i++) {
  // create CAS logical devices hosted in the physical Line Interface devices
  result = OtxDrvCreateLogicalDevice(
	      g_hPhysDevs.hLi[i],
	      OTX_LDEVICE_E1_S_BIT_ACCESS,
	      g_hEventQueue,
	      i,
	      &g_hLogicDevs.hT1E1Cas[i]);

  // enable Logical T1/E1 Cas Devices
  result = OtxDrvEnable(
	      g_hLogicDevs.hT1E1Cas[i],
	      OTX_TASK_SYNC,
	      5000L);
}

// set Si-bit values (both 0 on Si1 and Si2) on current Li
result = OtxE1SetSiBit(
	    g_hLogicDevs.hT1E1Cas[nCurrentLi],
	    0,
	    0);

Developer Notes

See Also

Comments

See Also

Return Value

OTX_S_OK

Hdlc Data was fetched

OTX_S_FALSE

No Hdlc Data available at this moment

OTX_E_BUFFER_TO_SMALL

The supplied user data buffer is too small to fit the received HDLC frame

Parameters

hHdlcDevice

Handle to the HDLC Receiver Device

pDataBuf

Data buffer for the received data

nBufLen

Length of the user data buffer

pnFrameLen

Length of the received HDLC frame

pnFrameSeq

Sequence number of the received HDLC frame (matches the number in the event queue)

pnFrameEndCode

Frame Status Code

pnTimeStamp

Timestamp of the last received octet of the frame

Comments

Example

// Note: function DemoLogf() is used to display message in our demo programs

case OTX_LDEVICE_HDLC_RECEIVER:
  otxRc = OtxDrvEventCode2String(
	     pEventData->m_hDevice,
	     pEventData->m_nCode,
	     256,
	     &msgStr[0]);

  if (OTX_SUCCESS(otxRc)) {
    // Event from HLDC Receiver
    if (pEventData->m_nCode == OTX_HDLC_RECEIVER_EC_COMPLETE_FRAME) {

      otxRc = OtxHdlcReadData(
		 pEventData->m_hDevice,
		 buf,
		 1024,
		 &nFrameLen,
		 &nFrameSeq,
		 &nFrameEndCode,
		 &nTimeStamp);

      while (OTX_RESULT_CODE(otxRc) == OTX_S_OK) {

	if (pEventData->m_nSourceId < 256) {
	  g_coHdlcRxFrames[pEventData->m_nSourceId]++;
	}

	if (g_bHdlcVerbose) {
	  DemoLogf("HDLC Frame Received, Sequence Number = %d\\n", pEventData->m_nParam);

	  DemoLogf("HdlcReceiver[%d] Len=%d, Fe=0x%.2X, Sq=%d: ", pEventData->m_nSourceId, nFrameLen, nFrameEndCode, nFrameSeq);
	  for (i = 0; i < nFrameLen && i < 1024; i++) {
	    DemoLogf("%.2X ", buf[i]);
	  }
	  DemoLogf("\\n");
	} else {
	  if (nFrameEndCode) {

	    g_coHdlcBadRxFrames[pEventData->m_nSourceId]++;

	    DemoLogf("FrameEndCode Error HdlcReceiver[%d] Len=%d, Fe=0x%.2X, Sq=%d: ", pEventData->m_nSourceId, nFrameLen, nFrameEndCode, nFrameSeq);
	    for (i = 0; i < nFrameLen && i < 256; i++) {
	      DemoLogf("%.2X ", buf[i]);
	    }
	    DemoLogf("\\n");

	    if (g_coHdlcBadRxFrames[pEventData->m_nSourceId] > 100) {
	      DemoLogf("Too many bad frames from HdlcReceiver[%d]. Disabling device\\n", pEventData->m_nSourceId);
	      otxRc = OtxDrvDisable(
			pEventData->m_hDevice,
			OTX_TASK_SYNC,
		𗌘L);
	    }

	  } else {
	    if ((nFrameLen != (OTX_UINT32)g_cbHdlcFrame) && (nFrameLen != 3)) {
	      g_coHdlcBadRxFrames[pEventData->m_nSourceId]++;

	      DemoLogf("LENGTH Error HdlcReceiver[%d] Len=%d, Fe=0x%.2X, Sq=%d: ", pEventData->m_nSourceId, nFrameLen, nFrameEndCode, nFrameSeq);
	      for (i = 0; i < nFrameLen && i < 256; i++) {
		DemoLogf("%.2X ", buf[i]);
	      }
	      DemoLogf("\\n");

	    } else if (memcmp(buf+3, g_sqHdlcFrame+3, g_cbHdlcFrame-3)) {
	      g_coHdlcBadRxFrames[pEventData->m_nSourceId]++;

	      DemoLogf("memcmp Error HdlcReceiver[%d] Len=%d, Fe=0x%.2X, Sq=%d: ", pEventData->m_nSourceId, nFrameLen, nFrameEndCode, nFrameSeq);
	      for (i = 0; i < nFrameLen && i < 256; i++) {
		DemoLogf("%.2X ", buf[i]);
	      }
	      DemoLogf("\\n");
	    }
	  }
	}
	otxRc = OtxHdlcReadData(
		   pEventData->m_hDevice,
		   buf,
		   1024,
		   &nFrameLen,
		   &nFrameSeq,
		   &nFrameEndCode,
		   &nTimeStamp);
      }
      if (OTX_RESULT_CODE(otxRc) != OTX_S_FALSE) {
	DemoLogf("HdlcReceiver[%d] OtxHdlcReadData() was unsuccessful (rc = %X).\\n", pEventData->m_nSourceId, otxRc);
      }

    } else {
      // Unexpected event from this device
      DemoLogf("HdlcReceiver[%d] Event: %s \\n", pEventData->m_nSourceId, msgStr);
    }
  } else {
    DemoLogf("HdlcReceiver[%d] Invalid Event: %ld \\n", pEventData->m_nSourceId, pEventData->m_nCode);
  }
  break;  // end of OTX_LDEVICE_HDLC_RECEIVER

See Also