Abstract:
This invention relates to an apparatus and method for use in conjunction with cameras which are used to monitor motor vehicle traffic flow on highways, bridges and the like. The camera are mounted using servomotors which have made the cameras&#39; direction to be varied by a remote operator. The invention permits cameras whose direction is driven by signals in different protocols for languages to be used in the same camera array.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS  
       [0001]    This application claims the benefit of U.S. Provisional Patent Application No. 60/373,118 filed Apr. 17, 2002 entitled Universal Protocol Converter (UPC). 
     
    
     
       FIELD OF THE INVENTION  
         [0002]    This invention in general relates to translating electronic protocols from one “language” to another and in particular data streams used to control mechanical objects such as remote sensors, motors or data.  
         SUMMARY OF THE INVENTION  
         [0003]    The invention is a computer-based system which controls the remote operation of cameras used in monitoring motor vehicle traffic on highways, bridges and the like, where cameras using different protocols for driving the motors which drive the cameras to be directed in a particular direction are used.  
           [0004]    In the past, these problems have been solved by having a database where the first protocol or language is translated directly into the second language. This requires that the first language must be translated directly into a multiplicity of second languages.  
         DESCRIPTION OF THE PRIOR ART  
         [0005]    U.S. Pat. No. 6,271,752 to Chistof and Vaios describes a network of cameras and operators including method of translation. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0006]    The accompanying drawings, which are incorporated in and form a part of the specification, illustrate the embodiments of the present invention and, together with the description, serve to explain the principles of the invention. The drawings and their descriptions are set forth in the Description of the Invention.  
     
    
     DESCRIPTION OF THE INVENTION  
       [0007]    In describing an embodiment of the invention, specific terminology will be selected for the sake of clarity. However, the invention is not intended to be limited to the specific terms so selected, and it is to be understood that each specific term includes all technical equivalents that operate in a similar manner to accomplish a similar purpose.  
         [0008]    The invention is a system which controls a mechanical device may transmit instructions to that device in a first language. However, the device which is being controlled may only respond to a second language. The particular device may be made by a variety of manufacturers, each of which uses a different language. The operator of the system desires to have the ability to use any one of a number of different manufacturers&#39; devices and be able to use them interchangeably. This requires that the system be capable of automatically being able to translate the first language input signals into any one of a variety of different second languages (to A to B to C, etc.) which are being used by the particular device.  
         [0009]    The recipient of the signal in the first language does not necessarily have to be a mechanical device. It may, as indicated above, be a data stream where the input data in the first language must be translated into a second language.  
         [0010]    In the past, these problems have been solved by having a database where the first protocol or language is translated directly into the second language. This requires that the first language must be translated directly into a multiplicity of second languages.  
         [0011]    The Universal Protocol Converter (UPC) is intended to resolve communication shortcomings and limitations between two heterogeneous devices. This is accomplished by converting an “input” protocol to an “output” protocol and inversely converting the “output” protocol to the “input” protocol. By using a Single Board Computer (SBC) that is loaded with a version of software that accepts an “input” protocol, via RS-232 or Ethernet communication, translating the “input” protocol to a generalizing “generic” protocol. It then translates the “generic” protocol to the “output” protocol and delivers it via RS-232, RS-422/RS-485, or Ethernet connection. The process is the same for converting from “input” to “output” protocols as well as converting “output” to “input” protocols.  
         [0012]    Explanation:  
         [0013]    The software is modular by design. This is necessary to accommodate the ease of programming for one distinct device to another distinct device.  
         [0014]    The main modules consist of the following:  
         [0015]    Input Module: This module is for accepting communications, via RS-232, from the input device, and translating to the “generic” protocol.  
         [0016]    Output Module: This module is for accepting communications, via RS-232 or RS-422/RS-485, from the output device, and translating to the “generic” protocol.  
         [0017]    Network Module: This module is for accepting and sending communications via Ethernet connection.  
         [0018]    Utility Module: This module allows for various functionality that is necessary for the software program to perform correctly and interact with the hardware on the SBC.  
         [0019]    The Input and Output modules are interchangeable and allow for the construction of various software versions based on the devices and protocols that will be used by the UPC.  
         [0020]    Implementation:  
         [0021]    The main procedure is outlined in the FIG. 1 (main loop). The program first initializes hardware devices via the relevant module functions. It then enters a main (infinite) loop, which continually checks for messages from the “input” and “output” device, signaling Light Emitting Diodes (LEDs) and signaling a “watchdog” timer.  
         [0022]    Utility Module:  
         [0023]    The utility module contains the functionality for the software program to interact with the hardware devices located on the SBC. An example of the functions it contains follows:  
         [0024]    InitPIO  
         [0025]    GetId  
         [0026]    ToggleLeds  
         [0027]    SetLeds  
         [0028]    SetCom1Leds  
         [0029]    SetCom2Leds  
         [0030]    SetEthLeds  
         [0031]    InitWD  
         [0032]    StobeWD  
         [0033]    IntTimer  
         [0034]    Network Module:  
         [0035]    The network module contains the functionality for the program to interact with the network capabilities of the SBC. An example of the functions it contains follows:  
         [0036]    InitNet  
         [0037]    GetNetMessage  
         [0038]    SendNetMessage  
         [0039]    Input/Output Module:  
         [0040]    The input/output modules contain the functionality for the program to translate protocols from one protocol to the “generic” protocol, translate the “generic” protocol to its native protocol, and to deiliver the communcations to the hardware device. Examples of the typical functions that they contain follow:  
                                                   Input   Output                           _GetCommand   _GetCommand           _SendCommand   _InitCommPort           _InitCommPort   _SendCommand           _ExpiredCommand   _CalcCRC           _GetNextValidCommand   _AccumByteCRC           _CheckCommandExpiration   _AccumulateCRC           _CompareCommands   _ConvertCommand           _ShiftStructRight   _TranslateCommand           _SendString   _TranslateText           _TranslateCommand   _TranslateRequest           _CopyCommands   _SendString           _ShiftExpiredCommands                      
 
         [0041]    Due to the complexity of individual protocols, some functionality may be needed in one module that is not necessary in another module. Cyclic Redundancy Checks (CRC), for example, may be needed by one particular protocol, but not used for another.  
         [0042]    The Execution:  
         [0043]    Program execution begins immediately after power is supplied to the SBC and follows the outline from the main loop figure. A more detailed explanation follows:  
         [0044]    A. Program Initialization as set forth in FIG. 2.  
         [0045]    1. Command Line Arguments are stored.  
         [0046]    2. Command Line Arguments are verified.  
         [0047]    If Command Line Arguments are invalid display error message and end program.  
         [0048]    3. Initialize Parallel Input/Output lines.  
         [0049]    Parallel I/O lines are used for LEDs and unit addressing.  
         [0050]    Get current address setting from parallel I/O lines.  
         [0051]    4. Initialize Input and Output Module corn port.  
         [0052]    Use command line arguments to initialize the corn port settings.  
         [0053]    Toggle LEDs to indicate initialization.  
         [0054]    If initialization fails, display error message and end program.  
         [0055]    5. Initialize Network Port.  
         [0056]    Use command line arguments to initialize the corn port settings.  
         [0057]    Toggle LEDs to indicate initialization.  
         [0058]    If initialization fails, display error message and end program.  
         [0059]    6. Initialize Watchdog Timer.  
         [0060]    Initialize port settings on the SBC.  
         [0061]    Re-vector interrupt 1C to an empty interrupt handler.  
         [0062]    7. Enter Main Loop.  
         [0063]    B. Main Loop: Input Message Retrieval as set forth in FIG. 3.  
         [0064]    1. Check for input message.  
         [0065]    Examine the contents of the serial port receive buffer.  
         [0066]     If the buffer has enough stored bytes to process as a message, retrieve the bytes from the buffer. Otherwise, return to main loop.  
         [0067]     In some cases, it may be necessary to complete other utilitarian functionality based on the nature of the protocol, such as removing expired commands, validating commands or synchronizing consecutive commands. For a more detailed description, see examples discussed later on.  
         [0068]    2. Retrieve bytes from corn port receive buffer.  
         [0069]    3. Set the appropriate LED flags.  
         [0070]    The LED flags are used in the main loop by the utility  
         [0071]     module to toggle the LEDs  
         [0072]     on and off.  
         [0073]    4. Translate bytes to “generic” string.  
         [0074]    Each protocol uses various formats. Some use ASCII text  
         [0075]     while others use  
         [0076]     hexadecimal numbers to represent operations or messages. The  
         [0077]     translation  
         [0078]     process converts the input protocol to a generalizing “generic” protocol.  
         [0079]    For  
         [0080]     a more detailed description, see the examples that are discussed further on.  
         [0081]    5. Return “generic” string to the Main Loop.  
         [0082]    C. Main Loop: Input Message Handling as set forth in FIG. 4A.  
         [0083]    If the return flag from the previous function call indicates that there is a Command to process, then send the command to the output module. Otherwise, continue on in the main loop.  
         [0084]    1. Translate “generic” protocol to native protocol.  
         [0085]    2. Put bytes into corn port TX buffer.  
         [0086]    3. Set appropriate LED flags.  
         [0087]    4. Return to main loop.  
         [0088]    D. Main Loop: Output Module Message Retrieval and Handling as set forth in FIG. 4B.  
         [0089]    The output module message routine mimics the input module message routine. For brevity, its description has been excluded. For a detailed description,  
         [0090]     refer to the input module message description.  
         [0091]    E. Main Loop: Network Message Retrieval as set forth FIG. 5.  
         [0092]    1. Check the Ethernet RX buffer for bytes.  
         [0093]    If there are no bytes in the RX buffer, then return to the main loop.  
         [0094]    If there are bytes in the RX Buffer, continue with function call.  
         [0095]    2. Get bytes from the RX buffer.  
         [0096]    3. Return bytes to main loop.  
         [0097]    F. Main Loop: Network Message Handling as set forth in FIG. 6.  
         [0098]    If the return flag from the previous function call indicates that there are no network messages to handle, then continue with main loop, otherwise complete the following steps.  
         [0099]    1. Translate the network message into “generic” protocol  
         [0100]    This is a function call to the input module.  
         [0101]    2. Sent the resulting “generic” protocol the output module.  
         [0102]    This function call will deliver the translated network message to the output device via the appropriate method (RS-232, RS-422/485, or Ethernet).  
         [0103]    3. Continue with main loop.  
         [0104]    G. Main Loop: Hardware Interaction as set forth in FIG. 7.  
         [0105]    1. Toggle LEDs.  
         [0106]    By setting the LED flag appropriately, the LEDs can be turned on  
         [0107]     or off by writing to the parallel input/output lines.  
         [0108]    2. Strobe Watchdog Timer.  
         [0109]    By writing to a particular port on the SBC, the Watchdog timer is flashed. If the watchdog timer is not flashed approximately every 1.6 seconds, the program terminates and restarts.  
         [0110]    3. Continue with main loop by repeating procedures B-G.  
         [0111]    Examples of Protocol Translation.  
         [0112]    The following illustrates the typical dataflow used when converting from native protocol to the “generic Protocol.  
         [0113]    [0113]FIG. 8 shows how a particular routine is used to retrieve a communication from the serial corn ports. A brief explanation follows:  
         [0114]    1. Check the receive buffer for available bytes.  
         [0115]    If there are no bytes waiting in the receive buffer, proceed to step 7.  
         [0116]    2. Determine the number of bytes available in the receive buffer and temporarily store that number.  
         [0117]    3. Fetch the number of bytes indicated, from the previous step, from the serial device.  
         [0118]    4. Store the bytes from the previous step in a temporary buffer.  
         [0119]    The temporary buffer is a static memory allocation that remains unchanged from invocation to invocation of this particular function call.  
         [0120]    5. Set the appropriate flags in the LEDflags structure via function call in Utility Module.  
         [0121]    6. Call the ToggleLEDs function in the Utility Module.  
         [0122]    This will toggle on, or off, the appropriate LEDs.  
         [0123]    7. Check if there are enough bytes in the temporary buffer to determine Message Size.  
         [0124]    This is protocol specific. The Message Size indicates the number of bytes that constitutes a valid command from the input/output device. The Message Size is a static memory allocation that is initialized on the very first invocation of the function call. If there are not enough bytes in the temporary buffer to determine the Message Size, return from this function call by indicating there are no messages to process. Otherwise, continue on to the next step.  
         [0125]    8. Copy the first three bytes of the message to temporary storage.  
         [0126]    9. Check if the first byte=3 and the second byte=0.  
         [0127]    This is protocol specific. In this particular case, this indicates the beginning of a valid command from the input/output device, which in turn indicates that the fourth byte will determine the Message Size. If this test fails continue on to step 11  
         [0128]    10. Check the value of the fourth byte that is stored in the temporary buffer.  
         [0129]    This is protocol specific. This byte determines the valid Message Size.  
         [0130]    Set the Message Size as indicated by the fourth byte.  
         [0131]    11. Check if the number of bytes in the temporary buffer is equal to the Message Size.  
         [0132]    If this test fails, return to the main loop indicating that there is no message to process, otherwise continue on to step 12.  
         [0133]    12. Temporarily copy the number of bytes indicated by the Message Size out of the temporary buffer.  
         [0134]    13. Calculate Cyclic Redundancy Check (CRC) on the temporary message via function call.  
         [0135]    This is protocol specific.  
         [0136]    14. Check if CRC is correct.  
         [0137]    If CRC fails, return to main loop indicating there are no messages to process. Otherwise continue to the next step.  
         [0138]    15. Remove this message from the temporary buffer.  
         [0139]    16. Check if the device id in the message is equal to this device id.  
         [0140]    If the ids do not match, then return to main loop indicating there are no messages to process. Otherwise continue to the next step  
         [0141]    17. Convert message to the “generic” protocol via a function call to ConvertCommand.  
         [0142]    Convert Command Function Call as Set Forth in FIG. 9.  
         [0143]    1. Compare the device ID with the message ID.  
         [0144]    If the device Ids do not match, return to previous function call.  
         [0145]    2. Determine value of 5 th  byte of the message.  
         [0146]    This is protocol specific.  
         [0147]     If the value of the 5 th  byte is equal to 1, make a “Request” message function call.  
         [0148]    This indicates a request of information from the attached device.  
         [0149]     It the value of the 5 th  byte is equal to 3, make a “text” message function call.  
         [0150]    This indicates a text message needs to be translated.  
         [0151]     It the value of the 5 th  is equal to 7, make a command message function call.  
         [0152]    This indicates a command is issued to control the attached device.  
         [0153]    3. Return to previous function call.  
         [0154]    Translate a “Command” Message Function Call as Set Forth in FIG. 10.  
         [0155]    1. Get the device ID.  
         [0156]    2. Add the device to the translated “generic” command.  
         [0157]    3. Is the 9 th  byte of the input command &gt;128.  
         [0158]    This is protocol specific. The 9 th  byte is a bitmapped  
         [0159]     byte that indicates, among other aspects, if the command is a “test” message or “command” message.  
         [0160]    In this case, the Most Significant Bit (MSB), the 8 th  bit indicates the above condition. If the MSB is set, then the message is a “command” message, otherwise it is a  
         [0161]     “test” message.  
         [0162]    YES condition. The message is a “command” message, and “command” is appended to the translated command.  
         [0163]    NO condition. The message is a “request” message, and “request” is appended to the translated command.  
         [0164]    4. Remove the Most Significant Bit from the 9 th  byte.  
         [0165]    Once removed, the 9 th  byte serves as an index into a look up table that hold the translated command.  
         [0166]    5. Use the 9 th  byte and look up table to translate message.  
         [0167]    6. Is the result from the look up table empty (NULL)? 
         [0168]    YES condition. Return to previous function call.  
         [0169]    NO condition. Continue.  
         [0170]    7. Determine value of the 10 th  byte.  
         [0171]    This is protocol specific.  
         [0172]    Value is equal to 8. Continue to step 8.  
         [0173]    Value is equal to 11. Continue to step 10.  
         [0174]    8. Is there another parameter (11 tth  byte)? 
         [0175]    This is protocol specific.  
         [0176]    YES condition. Continue to step  9   
         [0177]    NO condition. Return to previous function call.  
         [0178]    9. Append additional parameter to translated command.  
         [0179]    Return to previous function call.  
         [0180]    10. Is there another parameter (11 tth  byte)? 
         [0181]    This is protocol specific.  
         [0182]    Set the value of the additional parameter as indicated in FIG. 10 based on the value (1-7) as indicated in FIG. 10.  
         [0183]    11. Append the resulting parameter value to the translated command  
         [0184]    12. Return to the previous function call.  
         [0185]    Translate “Text” Message as Set Forth in FIG. 11.  
         [0186]    1. Get device Id and append to translated command  
         [0187]    2. Extract text message from “native” protocol.  
         [0188]    This is protocol specific.  
         [0189]    The text message consists of 3 text lines, each 21 characters long with the first  
         [0190]     character of the first line beginning at byte  9 .  
         [0191]    3. Append resulting text to translated message.  
         [0192]    4. Return to previous function call.  
         [0193]    Translate Request Command as Set Forth in FIG. 12.  
         [0194]    1. Get device ID and append to the translated command.  
         [0195]    2. Append “request” to translated command.  
         [0196]    This is protocol specific. In some instances, multiple commands may need to be  
         [0197]     sent in order to fulfill the request command.  
         [0198]    3. Return to previous function call.  
         [0199]    Send Command To Input/Output Module as Set Forth in FIG. 13.  
         [0200]    1. Validate command.  
         [0201]    If the command is empty (NULL), return to previous function call indicating no commands to translate.  
         [0202]    2. Call ConvertCommand function call.  
         [0203]    This function call converts the “generic” protocol to “native” protocol.  
         [0204]    3. Was translation successful? 
         [0205]    If above function call indicates an unsuccessful translation, return to previous function call indicating no command was translated.  
         [0206]    4. Calculate checksum via function call.  
         [0207]    This is protocol specific. This is a simple checksum calculation, the value of all the  
         [0208]     bytes of the current “native” protocol are Exclusively Or-ed, and the Least Significant  
         [0209]     byte is used.  
         [0210]    5. Set corn port LEDs via function call.  
         [0211]    6. Send translated command out appropriate corn port.  
         [0212]    7. Return to previous function call.  
         [0213]    Convert Command Function Call as Set Forth in FIG. 14.  
         [0214]    1. Parse “generic” command into individual parts.  
         [0215]    The “generic” protocol is and ASCII based Pipe, “|”,  
         [0216]     delineated string. See following examples for detailed explanation.  
         [0217]    2. Is device ID equal to device ID in message? 
         [0218]    YES condition. Continue.  
         [0219]    NO condition. Return to previous function call.  
         [0220]    3. Convert ASCII string to uppercase.  
         [0221]    4. Set all known “native” bytes.  
         [0222]    This is protocol specific.  
         [0223]    5. Is this a “PAN” command? 
         [0224]    YES condition. Make a PAN_Convertion function call.  
         [0225]    NO condition. Continue until correct command is found.  
         [0226]    6. Is this a “TILT” command? 
         [0227]    YES condition. Make a TILT_Convertion function call.  
         [0228]    NO condition. Continue until correct command is found.  
         [0229]    7. Is this a “Focus Command? 
         [0230]    YES condition. Make a FOCUS_Convertion function call.  
         [0231]    NO condition. Continue until correct command is found.  
         [0232]    8 . . . check for all possible commands.  
         [0233]    If suitable command is found call appropriate function call, otherwise continue to next step.  
         [0234]    9. Return to previous function.  
         [0235]    Pan Command Conversion Function Call as Set Forth in FIG. 15.  
         [0236]    1. Set the next byte in the native.  
         [0237]    2. If “generic” command=“STOP”.  
         [0238]    YES condition. Continue to next step  
         [0239]    No condition. Continue to step 4  
         [0240]    3. Set next byte in “native” command=“S”.  
         [0241]    Set byte and return to previous function call.  
         [0242]    4. If “generic” command=“RIGHT”.  
         [0243]    YES condition. Continue to next step  
         [0244]    No condition. Continue to step 4  
         [0245]    5. Set next byte in “native” command=“R”.  
         [0246]    Set byte and return to previous function call.  
         [0247]    6. If “generic” command=“LEFT”.  
         [0248]    YES condition. Continue to next step  
         [0249]    No condition. Continue to step 4  
         [0250]    7. Set next byte in “native” command=“L”.  
         [0251]    Set byte and return to previous function call.  
         [0252]    8. Return to previous function call.  
         [0253]    Tilt Command Conversion Function Call, And Subsequent Conversion Function Calls.  
         [0254]    All of the individual Conversion function calls closely mimic the previous Pan_Conversion function call. The only significant distinction is the individual characters that are used by the specific protocol. Therefore, the detailed explanation and flow chart diagrams are omitted for brevity.  
         [0255]    Protocol Definitions.  
         [0256]    The previous explanation, FIGS.  8 - 15 , use the following protocols as example protocols.  
         [0257]    Input protocol.  
         [0258]    Input device—Pan/Tilt/Zoom Camera Controller.  
         [0259]    Protocol Definition:  
         [0260]    This protocol uses binary data to interpret which command is to be issued and is compromised or 15 bytes.  
                                                                 Byte   Definition                                        0   Controller Address           1   Functional Device Type           2   Functional Device ID (high order byte)           3   Function Device ID (low Order byte)           4   Test | Circuit Flag | Com - Res p |               Message = 7           5   Sequence Number           6   EOF|    Reserved           7   Byte Count = 15 (high order byte)           8   Byte Count (low order byte)           9   Command request|  Command code           10   Command Parameter 1 Value           11   Command Parameter 2 Value           12   Reserved           13   CRC (high order byte)           14   CRC (low order byte)                      
 
         [0261]    The most relevant information required to complete the protocol conversion to or from the “generic” protocol is contained in bytes  9  through  11 . The following excerpt shows the typical information stored in these bytes:  
         [0262]    Command Code 1=TILT Motion Command  
         [0263]    Parameter 1 Values:  
         [0264]    0=Stop Tilt  
         [0265]    1=Tilt Up, Normal Speed  
         [0266]    2=Tilt Up, Fast Speed  
         [0267]    3=Tilt Down, Normal Speed  
         [0268]    4=Tilt Down, Fast Speed  
         [0269]    Parameter 2 Values:  
         [0270]    Not Used  
         [0271]    Command Code 2=PAN motion command  
         [0272]    Parameter 1 Values:  
         [0273]    0=Stop Pan  
         [0274]    1=Pan Left, Normal Speed  
         [0275]    2=Pan Left, Fast Speed  
         [0276]    3=Pan Right, Normal Speed  
         [0277]    4=Pan Right, Fast Speed  
         [0278]    Parameter 2 Values:  
         [0279]    Not Used  
         [0280]    Other Command Code Values Omitted for Brevity  
         [0281]    Command Code 12=SHUTTER SPEED command  
         [0282]    Parameter 1 Values:  
         [0283]    0=Continue Current Setting  
         [0284]    1=Automatic  
         [0285]    2=Manual  
         [0286]    Parameter 2 Values:  
         [0287]    0=Not Used  
         [0288]    1=1/60  
         [0289]    2=1/100  
         [0290]    3=1/250  
         [0291]    4=1/500  
         [0292]    5=1/1000  
         [0293]    6=1/2000  
         [0294]    7=1/10000  
         [0295]    Output protocol.  
         [0296]    Input device—Pan/Tilt/Zoom Camera.  
         [0297]    Protocol Definition:  
         [0298]    This protocol used several bytes of mixed modes, binary and ASCII data, to control the device. The format is specified as follows:  
                                       Byte   Data   Description                   0   F8 (hex)   Start Of Message       1   Address   01 - DF (hex)       2   ‘c’   Message Type       3 to n + 3   Command Data   Control Command       n + 4   Checksum   End Of Message, LS nibble of all bytes               XORd                  
 
         [0299]    The following is an excerpt of the Command Data from the output protocol:  
                                                       ‘PR’   Pan Right           ‘PL’   Pan Left           ‘PS’   Pan Stop           ‘TU’   Tilt Up           ‘TD’   Tilt Down           ‘TS’   Tilt Stop           ‘ZI’   Zoom In           ‘ZO’   Zoom Out           ‘ZS’   Zoom Stop           ‘IO’   Iris Open           ‘IC’   Iris Close           ‘IS’   Iris Stop           ‘S’ #   Shutter Speed               # indicates:               = 30 (hex) (1/4)               = 31 (hex) (1/8)               = 32 (hex) (1/15)               = 33 (hex) (1/30)               = 34 (hex) (Auto)               = 35 (hex) (1/60)               = 36 (hex) (1/100)               = 37 (hex) (1/250)               = 38 (hex) (1/500)               = 39 (hex) (1/1000)               = 3A (hex) (1/2000)               = 3B (hex) (1/4000)               = 3C (hex) (1/10000)                      
 
         [0300]    Generalizing “Generic” Protocol  
         [0301]    In both “native” to “generic” and “generic” to “native” protocol, the following protocol is used.  
         [0302]    Protocol definition.  
         [0303]    This protocol uses pipe (‘|’) delineated ASCII strings to translate “native” protocol to this generalizing protocol. The ASCII text is outlined as follows”.  
         [0304]    Device ID|Type|OpCode|Command|Parameter 1|[|Parameter 2][| . . . ][|Parameter n] 
         [0305]    Explanation:  
         [0306]    Device ID This is the unit ID/device ID.  
         [0307]    Type This is the type of command that will follow. ‘Command’ or ‘Request’.  
         [0308]    OpCode This is the type of command that will follow. ‘pan’, ‘tilt’, ‘zoom’, ‘iris’.  
         [0309]    Command This is dependant on the OpCode. ‘right’, ‘left’, ‘up’, ‘down’, ‘in’, ‘out’, ‘save’, “go”.  
         [0310]    Parameter 1 This is an additional parameter that is dependant on the OpCode and Command. ‘1’, ‘2’, ‘3’, . . . ‘8’,  
         [0311]    Parameter 2 This is an additional parameter that is dependant on the OpCode, Command, and Parameter 1.  
         [0312]    An example of the translations follows:  
         [0313]    ‘Input’ protocol to ‘generic’ protocol.  
         [0314]    Command: Device ID 1, Pan Left Normal Speed.  
         [0315]    Input: 01 03 00 01 07 05 00 00 0F 82 01 00 00 f1 56  
         [0316]    Output: 1|command|pan|left|45 (speed is indicated as degrees per second)  
         [0317]    Command: Device ID 12, Shutter Speed 1/500  
         [0318]    Input: 0C 03 00 01 07 0A 00 00 0F 8C 02 04 00 11 AD  
         [0319]    Output: 12|command|shutter|maual|500 (speed is indicated as inverse of true speed.  
         E.g. 1/500=500 and 1/60=60)  
         [0320]    ‘Generic’ protocol to ‘Output’ protocol.  
         [0321]    Command: Device ID 1, Pan Left Normal Speed.  
         [0322]    Input: 1|command|pan|left|45 (speed is indicated as degrees per second)  
         [0323]    Output: F8 01 ‘P’ ‘R’ 83  
         [0324]    Command: Device ID 12, Shutter Speed 1/500  
         [0325]    Input: 12|command|shutter|maual|500  
         [0326]    Output: F8 0C ‘c’ ‘S’ 38 84  
         [0327]    The invention described above is, of course, susceptible to many variations, modifications and changes, all of which are within the skill of the art. It should be understood that all such variations, modifications, and changes are within the spirit and scope of the invention and of the appended claims. Similarly, it will be understood that it is intended to cover all changes, modifications and variations of the example of the invention herein disclosed for the purpose of illustration which do not constitute departures from the spirit and scope of the present invention. The present invention is intended to be protected broadly within the spirit and scope of the appended claims.