1. pc-vitc.zip Driver
2. DLL_INFO.TXT File Contents

DLL_INFO.TXT Driver File Contents (pc-vitc.zip)

Adrienne Electronics Corporation - Copyright (C)1995 AEC - Page 1 of 7

March 24, 1995

This document describes how to use the functions which are included
in our "AECPC-TC.DLL" dynamic link library file.

Use of these functions makes it easier to interface your Windows
application software to our PC-LTC, PC-VITC, and PC-VLTC boards. 

You are authorized to use our dynamic link library file only
in conjunction with our PC-LTC, PC-VITC, and PC-VLTC boards.
ANY other use of our DLL file or modifications thereof is
strictly prohibited under international copyright laws.


Please send suggestions for bug fixes or other improvements to:
                 Bruce Waggoner, President
              Adrienne Electronics Corporation
                    2196 E. Ford Avenue
                Las Vegas, NV 89123 * U.S.A.
         tel: 1-702-896-1858   fax: 1-702-896-3034


NOTE - To print this text file, from DOS,
       simply enter "COPY DLL_INFO.TXT PRN:".



                        (continued)
Adrienne Electronics Corporation - Copyright (C)1995 AEC - Page 2 of 7


COMMON CHARACTERISTICS OF ALL "AECPC-TC" DLL FUNCTIONS:

1) This DLL can handle any combination of up to 16
   of our PC-LTC/VITC/VLTC boards simultaneously.
   Three classes of our time code boards are supported:
   a) PC-LTC/IOR I/O Mapped Simple LTC Reader ("IOR"),
   b) PC-LTC/MMR Memory Mapped Simple LTC Reader ("MMR"), and
   c) All PC-VITC, all PC-VLTC, and the PC-LTC/RDR, GEN, and RG1 boards,
      sometimes called "OTHER" boards for lack of a better name.

2) Each function returns a completion code, a returned string length,
   or other information in AX (see each function for details).
   If any errors are detected, AX will hold one of these error codes:
     E001h  =>  Invalid board address detected.
     E002h  =>  DLL's board address table is full (16 boards maximum).
     E003h  =>  Board address OFFSET is too big for this board type.
     E004h  =>  Board address OFFSET is inappropriate for this function.
     E005h  =>  Data from board is unstable (glitchy).
     E006h  =>  Invalid command for this board type.

3) All registers are saved (except AX).

4) All I/O (other than the AX return code) is done via FAR
   (32-bit double word) pointers pushed onto the stack
   (all arguments are passed by FAR reference).
   For example, in Assembly language, you would push the
   16-bit SEGMENT/SELECTOR address onto the stack first,
   followed by the 16-bit OFFSET address,
   which together point to the first byte of an I/O data structure.

5) The "Board_Address_Ptr" pointer in the argument lists below
   should point to a 16-bit word which contains the
   PC-LTC/VITC/VLTC board's base address, which is normally
   02A0h for a PC-LTC/IOR board, and CC00h for ALL other boards.

6) All function arguments are popped off of the stack by
   each DLL function before it returns to your program.

7) Unless specifically noted otherwise, all functions return
   almost immediately (in a matter of microseconds),
   without waiting for a new time code frame or anything else.

8) All 4-byte (doubleword) time bits fields are arranged as follows:
   Offset 3  =  Packed BCD hours byte (normally 00h - 23h).
   Offset 2  =  Packed BCD minutes byte (normally 00h - 59h).
   Offset 1  =  Packed BCD seconds byte (normally 00h - 59h).
   Offset 0  =  Packed BCD frames byte (normally 00h - 29h for NTSC/SMPTE,
                                             and 00h - 24h for PAL/EBU).



                        (continued)
Adrienne Electronics Corporation - Copyright (C)1995 AEC - Page 3 of 7


DEBUGGING SUGGESTIONS:

1) We assume that you already know how to make standard Windows API calls
   using the compiler/assembler which you have chosen for your project.
   If you don't, please contact your compiler/assembler vendor, not us,
   because we cannot possibly keep up with the HUNDREDS of compiler
   and assembler versions which continually reach the marketplace.

2) From DOS (not the Windows DOS emulator),
   use our test and demo program (that came on the diskette
   which accompanied the board) to verify that our time code
   board is installed properly, and that your time code
   sources are working and properly connected to our board.

3) Get your Windows application running to the point where it can
   display on-screen a dummy time bits display (like 01:23:45:67)
   before attempting to access our board.  This verifies your
   main Windows application program, your Windows display routines,
   and your ability to call Windows API functions, whose calling
   conventions we use for all of our DLL functions.

4) Call the AEC_PCTC_ECHO_ADDR function (see description on page 7)
   to test your ability to properly pass the Board_Address_Ptr argument,
   and to receive and process (display?) the return code in AX,
   which should be identical to the board address variable you pointed to.

5) Call the AEC_PCTC_CHECK_BOARD function (see description on page 4),
   using both real and fictitious board addresses,
   to test your ability to properly pass the Board_Address_Ptr argument,
   to receive and process (display?) the return code in AX,
   and to verify proper access to our time code board under Windows.

6) Call the AEC_PCTC_GET_DLL_INFO function (see description on page 7)
   to test your ability to receive and display a string variable
   returned by our DLL.

7) If you get this far, CONGRATULATIONS, you are ready for prime time.

8) If your application just needs to read time bits,
   all you really need to do is:
  a) Call AEC_PCTC_CHECK_BOARD to make sure a board is present.
  b) Call AEC_PCTC_READ_TB to read the time bits into a doubleword, or
     call AEC_PCTC_READ_ASC_TB to read the time bits into an ASCII string.
  c) Call AEC_PCTC_UNINSTALL_BOARD when exiting your application.
  d) Ignore all of the other DLL functions.

9) If your application is more complicated (sorry),
   you should spend a few hours reading the straightforward
   yet comprehensive manual which came with your time code board.



                        (continued)
Adrienne Electronics Corporation - Copyright (C)1995 AEC - Page 4 of 7


THE DLL FUNCTIONS ARE NOW LISTED INDIVIDUALLY BY NAME...


AEC_PCTC_CHECK_BOARD(Board_Address_Ptr)
:
Checks to see if one of our time code boards is installed and working,
 using the FAR pointer you have placed onto the stack to indicate
 where the 16-bit base address for the board is located.
This function allows your application to "search for" a board
 at one of several possible addresses, or can be used to verify
 that the proper type of board is present before launching your application.
Returns a board type code in AX:
 0000h  =>  No board found.
 0001h  =>  An IOR board was found.
 0002h  =>  An MMR board was found.
 0003h  =>  An "OTHER" type PC-LTC, PC-VITC, or PC-VLTC board was found.


AEC_PCTC_READ_TB(Return_Bytes_Ptr,Board_Address_Ptr)
:
Reads the current selected time bits (with no embedded bits)
 into a four-byte string or doubleword variable,
 whose lowest FAR address you have placed onto the stack.
Returns a completion code (0001h if OK) in AX.


AEC_PCTC_READ_TBE(Return_Bytes_Ptr,Board_Address_Ptr)
:
Reads the current selected time bits (including embedded bits)
 into a four-byte string or doubleword variable,
 whose lowest FAR address you have placed onto the stack.
Returns a completion code (0001h if OK) in AX.


AEC_PCTC_READ_UB(Return_Bytes_Ptr,Board_Address_Ptr)
:
Reads the current selected user bits
 into a four-byte string or doubleword variable,
 whose lowest FAR address you have placed onto the stack.
Returns a completion code (0001h if OK) in AX.


AEC_PCTC_READ_ASC_TB(Return_String_Ptr,Board_Address_Ptr)
:
Reads the current selected time bits (with no embedded bits)
 into an ASCII-Z string variable (normally 11 bytes long),
 whose lowest FAR address you have placed onto the stack.
The string has a standard "HH:MM:SS:FF" format,
 and ends with a 00h string terminator character.
Returns the new string length in AX.



                        (continued)
Adrienne Electronics Corporation - Copyright (C)1995 AEC - Page 5 of 7


AEC_PCTC_READ_ASC_UB(Return_String_Ptr,Board_Address_Ptr)
:
Reads the current selected user bits
 into an ASCII-Z string variable (normally 11 bytes long),
 whose lowest FAR address you have placed onto the stack.
The string has a standard "HH:MM:SS:FF" format,
 and ends with a 00h string terminator character.
Returns the new string length in AX.


AEC_PCTC_READ_1BYTE(Return_Byte_Ptr,Offset_Ptr,Board_Address_Ptr)
:
Reads one byte from the board, using the 16-bit offset
 whose FAR address you have placed onto the stack,
 into the desired 8-bit data byte,
 whose FAR address you have also placed onto the stack.
Returns a completion code (0001h if OK) in AX.


AEC_PCTC_READ_4BYTES(Return_Bytes_Ptr,Offset_Ptr,Board_Address_Ptr)
:
Reads four bytes from the board, starting at the 16-bit offset
 whose FAR address you have placed onto the stack,
 into the desired four destination bytes,
 whose lowest FAR address you have also placed onto the stack.
Returns a completion code (0001h if OK) in AX.


AEC_PCTC_WRITE_1BYTE(Data_Byte_Ptr,Offset_Ptr,Board_Address_Ptr)
:
Writes the desired 8-bit data byte,
 whose FAR address you have placed onto the stack,
 to the selected board, using the 16-bit offset
 whose FAR address you have also placed onto the stack.
Returns a completion code in AX:
 0001h  =>  OK.
 E006h  =>  Invalid command for IOR and MMR boards.


AEC_PCTC_WRITE_4BYTES(Data_Bytes_Ptr,Offset_Ptr,Board_Address_Ptr)
:
Writes the desired four data bytes,
 whose lowest FAR address you have placed onto the stack,
 to the selected board, starting with the 16-bit offset
 whose FAR address you have also placed onto the stack.
Returns a completion code in AX:
 0001h  =>  OK.
 E006h  =>  Invalid command for IOR and MMR boards.



                        (continued)
Adrienne Electronics Corporation - Copyright (C)1995 AEC - Page 6 of 7


AEC_PCTC_SEND_COMMAND(Command_Byte_Ptr,Return_Byte_Ptr,Board_Address_Ptr)
:
Writes the desired 8-bit command byte,
 whose FAR address you have placed onto the stack,
 to DPRAM register 3FFh (the "command" code byte),
 then waits up to 50ms for a proper acknowledgement.
Returns the acknowledgement code (or the last code found)
 (or 00h if nothing found) in another 8-bit data byte,
 whose FAR address you have also placed onto the stack.
Returns a completion code in AX:
 0000h  =>  No acknowledgement found.
 0001h  =>  Received a proper command acknowledgement.
 E006h  =>  Invalid command for IOR and MMR boards.


AEC_PCTC_GET_INTCODE(Command_Byte_Ptr,Return_Byte_Ptr,Board_Address_Ptr)
:
Reads DPRAM register 3FEh (the "interrupt" code byte)
 into the desired 8-bit data byte,
 whose FAR address you have placed onto the stack.
The 8-bit command byte,
 whose FAR address you have placed onto the stack,
 determines how long to wait for a valid interrupt code:
    0d  =>  No wait, return immediately.
   50d  =>  Wait up to 50ms for the first valid interrupt code.
If NO interrupt is pending, returns a 00h byte.
If an interrupt IS pending, reads it, clears the interrupt,
 and returns the interrupt code byte that was found.
Returns a completion code in AX:
 0000h  =>  No interrupt code found.
 0001h  =>  Found a valid interrupt code.
 E006h  =>  Invalid command for IOR and MMR boards.


AEC_PCTC_GET_DLL_INFO(Return_String_Ptr)
:
Writes various DLL information to an ASCII-Z string variable,
 whose FAR address you have placed onto the stack.
The string ends with a 00h string terminator character.
At present, the following DLL information string bytes are defined:
  Offset 0  =>  DLL software revision letter (major revision) ("A"-"Z").
  Offset 1  =>  DLL software revision number (minor revision) ("1"-"9").
Returns the new string length in AX.



                        (continued)
Adrienne Electronics Corporation - Copyright (C)1995 AEC - Page 7 of 7


AEC_PCTC_GET_SELECTOR(Return_Word_Ptr,Board_Address_Ptr)
:
Writes the 16-bit selector for this PC-LTC/VITC/VLTC board
 over a two-byte word variable,
 whose FAR address you have placed onto the stack.
Returns a completion code in AX:
 0001h  =>  Selector is OK (MMR or OTHER type board).
 E006h  =>  Invalid command for IOR boards.


AEC_PCTC_UNINSTALL_BOARD(Board_Address_Ptr)
:
Removes this board from the DLL's list of active boards,
 freeing up the associated selector in the process.
This frees up one space in the operating system's selector tables. 
Returns a completion code in AX:
 0001h  =>  Board has been uninstalled (MMR or OTHER type board).
 E006h  =>  Invalid command for IOR boards.


AEC_PCTC_ECHO_ADDR(Board_Address_Ptr)
:
Returns (in AX) the board address
 whose FAR pointer you have placed onto the stack.
Useful for verifying/debugging your application source code.


AEC_PCTC_DWORD_TO_STR(Command_Byte_Ptr,Source_Bytes_Ptr,Return_String_Ptr)
:
Reads any four-byte packed BCD time or user bits doubleword,
 whose lowest FAR address you have placed onto the stack,
 and converts it into an ASCII-Z string variable (normally 11-bytes long),
 whose FAR address you have also placed onto the stack.
The output string has a standard "HH:MM:SS:FF" format,
 and ends with a 00h string terminator character.
Note that the source bytes pointer should point to the frames byte,
 whose address is the lowest of the four source bytes.
The 8-bit command byte, whose FAR address you have placed onto the stack,
 determines how the returned string will be formatted:
   00h  =>  Time bits display (strip out embedded bits).
   01h  =>  User bits display (print "A"-"F" if found).
Returns the new string length in AX.


THAT'S ALL!