Unified IO - C++ interface for industrial IO cards

  1. Windows NT

Download distribution package from www.bbdsoft.com

Unzip it to any directory on your hard disk.

For Windows NT only - use loaddrv.exe utility to install and load Unified IO hardware access driver. You can install and load this driver using following command line:

Loaddrv uniio <full path to your driver >\uniio.sys

To verify installation of the driver open Windows NT Control Panel item "Devices", find device uniio. Status should be "Started", Startup should be "Manual". In the future this driver will load automatically when you use Unified IO first time after restart. If you wish to load this driver automatically during Windows NT startup select push button "Startup…" and select Startup type – "Automatic". Then press "OK" button.

  • Building package
    1. Microsoft Visual C++ 5.0 and up

    You can build release version of entire Unified IO package by executing br.cmd batch file. Debug version can be built by bd.cmd batch file. Already built release version for Microsoft Visual C++ of uniio.dll and uniio.lib are included in the package.

    Size of Unified IO package can be reduced if you software does not have to support all IO cards supported by Unified IO.

    .cpp file

    Required if

    osiface.cpp

    iotrack.cpp

    iocard.cpp

    always

    physmem.cpp

    fwfbuff.cpp

    ab1784card.cpp

    1784dpram.cpp

    AB1784KTx card supported

    ioport.cpp

    any card other than AB1784KTx supported

    ac5card.cpp

    OPTO22 AC5 card supported

    pc7166card.cpp

    US Digital PC7166 card supported

    ac28card.cpp

    OPTO22 AC28 card supported

    dummycard.cpp

    testing without actual IO cards is supported

    pcibus.cpp

    pcidev.cpp

    pcicfg1.cpp

    pcicfg2.cpp

    pcicfgdr.cpp

    pcicfgsl.cpp

    pcicfg.cpp

    pci72xxcard.cpp

    Arbor Technologies PCI-7248 or PCI-7296 card supported

  • Overview
    1. Architecture

    Unified IO is designed to be platform independent C== class library for hardware control. Basic structure is in the figure bellow:

    Figure 1 Unified IO Architecture

    Therefore only small portion of Unified IO is platform dependent. This part varies depending on operating system. But basically this code should provide ability to perform port IO and direct memory access. Specific IO card wrappers are using only interface of platform dependent classes. As a result support for n cards under m platforms would require only n+m code modules. Traditional approach would require n*m device drivers. End user is using only platform independent Standard C++ code and therefore code is fully portable.

  • Using Unified IO
    1. Overview

    Unified IO is based on concept of IO Tracks. IO Track is a logical group of consecutive IO point controlled by the same IO interface card. There are 6 types of IO points:

    Object of class inherited from abstract class IOCard is created for each IO card in the system. Then IO tracks have to be associated with IO cards. Then program control loop:

        1. IOTrack and IOCard creation and configuration

          2. Here is a sample code of IO Track and IOCard creation:

          // create digital IO card object
AC5Card aDigitalCard (0x220);
// create 2 tracks consisting of digital IO
// and associate tracks with the card
IOTrack track ( aDigitalCard // IO card reference
              , 0 // starting point
              , "IIIIIIIIIIIIOOOO" // track of 12 inputs and 4 outputs
              );

          Specific IOCard instance is created. You should consult specific IOCard class description for constructor parameters description. In our case OPTO 22 AC5 card is created and it’s base address is passed in the constructor.

          IO Track is created by providing a reference to a specific IOCard object to which this track belongs. Since IOTrack is an abstraction of physical group of inputs, outputs and other elements, multiple IOTracks can belong to the same IOCard. For this purpose starting point parameter is used. First IOTrack for any IOCard should have starting point 0. Other IOTracks in the same IOCard should have starting point more than 0. Usually this number is incremented by the number of points of previous track. In our example starting point for a next track on the same IOCard would be 16. Third parameter of IOTrack constructor is used to specify IO mask of the IOTrack. This can be any combination of the following characters (assuming specific IOCard supports them):

          ‘N’ Not Used
          ‘I’ Digital Input
          ‘O’ Digital Output
          ‘A’ Analog Input
          ‘U’ Analog Output
          ‘C’ Counter
          ‘R’ Reverse Counter

          If specified point type is not supported by a specific card an exception is thrown.

          User is responsible for correct destruction of objects of classes IOCard and IOTrack.

        2. Reading and writing to IO

    Class IOTrack provides all necessary interface to read from and write to IO points. By calling function IOTrack::updateInputs() IOTrack reads all inputs belonging to this track from IOCard and places values to an internal image.

    Later you can access this image by using IOTrack::operator [].

    All modifications to outputs are performed in this internal image and are written to IOCard by calling function IOTrack::updateOutputs().

    Usually all IO control is performed within an loop. In the beginning of the loop reading inputs from all tracks, then performing control logic and writing outputs to all tracks at the end.

    Here is a simple example of reading and writing to IO points:

    while (1)
{
   // read current state of all inputs
   track.updateInputs ();
   // do control logic
   if ( track[5] && track[1] )
   {
      track[14] = 0;
   } // endif

   // activate/deactivate outputs
   track.updateOutputs ();
   // sleep for 10 milliseconds = 10000 microseconds
   OSInterface::sleep (10000);
} // endwhile
    1. Class Diagrams
      1. System Interface classes

      2. IO Card Interface classes

    2. Unified IO Reference
        1. AB1784Card

          2. Class for accesing Allen-Bradley 1784 KTx series of cards by Remote IO protocol

           

          1. Derived from IOCard

            2.  

          2. Public Operations:
            1. AB1784Card AB1784Card (const unsigned int inBaseMemoryAddress, const char* const inFirmwarePath, const unsigned int inLinkSpeed)
            2. void ~AB1784Card ()
            3. unsigned int baseMemoryAddress ()

              4. returns dual port RAM address provided while constructing AB1784Card

            4. unsigned int linkSpeed ()

              5. Returns Remote IO link speed

            5. const char* const firmwarePath ()

              6. returns full path to directory where AB1784KTx firmware files are stored.

           

        2. IOCard

          3. An abstract class for representation of IO interface card.

          1. Public Operations:
            1. IOCard IOCard (const char* inType)
            2. IOCard& reset ()

              3. default implemetation of reset operation does nothing.

            3. void ~IOCard ()
            4. const char* const type ()

              5. Returns name of IO card

           

        3. PhysicalMemory

          4. provides access to physical memory block from user process.

          1. Public Operations:
            1. PhysicalMemory PhysicalMemory (const unsigned long inPhysicalAddress, const unsigned long inSize, bool fWriteAccess = true)

              2. Retrives pointer to the specified block of physical memory.

            2. PhysicalMemory& writeMemoryBlock (const void* const inDataToWrite, const unsigned long inBlockSize, const unsigned long inStartOffset = 0)

              3. modifies physical memory block

            3. void ~PhysicalMemory ()
            4. PhysicalMemory& readMemoryBlock (void* inBuffer, const unsigned long inBlockSize, const unsigned long inStartOffset = 0)

              5. reads block of data from physical memory

            5. unsigned long size ()

              6. returns size of a physical memory region

           

        4. AC28Card

          5. OPTO 22 ISA AC28 Pamux bus card wrapper

          1. Derived from IOCard

            2.  

          2. Public Operations:
            1. AC28Card AC28Card (const unsigned int inBaseIOPort, const unsigned int inResetPort, const bool inResetLevel)
            2. unsigned int baseIOPort ()

              3. Returns base IO port address

            3. void ~AC28Card ()
            4. unsigned int resetPort ()

              5. returns reset port address

            5. bool resetLevel ()

              6. returns reset level. true - HIGH, false - LOW

           

        5. AC5Card

          6. OPTO 22 ISA AC5 direct digital card wrapper.

          1. Derived from IOCard

            2.  

          2. Public Operations:
            1. AC5Card AC5Card (const unsigned int inBaseIOPort)
            2. unsigned int baseIOPort ()

              3. returns base IO port number - parameter provided while constructing AC5Card

            3. void ~AC5Card ()

           

        6. DummyCard

          7. Default implementation of IOCard, could be used to test functionality of software without actual IO cards.

          1. Derived from IOCard

            2.  

          2. Public Operations:
            1. void ~DummyCard ()
            2. DummyCard DummyCard ()

           

        7. FirmwareFileBuffer

          8. Class for implementing file buffer for loading firmware files

          1. Public Operations:
            1. FirmwareFileBuffer FirmwareFileBuffer (const char* const inFileName)
            2. unsigned long size ()

              3. Returns the size of an firmware file

            3. void ~FirmwareFileBuffer ()
            4. char* operator char* ()

              5. Returns pointer to a firmaware file buffer read from disk

           

        8. IOPort

          9. Represent class wrapper for reading and writing from PC IO ports

          1. Public Operations:
            1. IOPort IOPort (const unsigned int inPortNumber, bool fWriteAccess = true)

              2. represents IO port. Constructor enables access to a port.

            2. IOPort& write (const unsigned char inValue)

              3. writes 1 byte of data to the port.

            3. IOPort& write (const unsigned short inValue)

              4. writes 2 bytes of data

            4. IOPort& write (const unsigned long inValue)

              5. writes 4 bytes of data

            5. void ~IOPort ()

              6. -

            6. unsigned char readChar ()

              7. reads 1 byte of data

            7. unsigned short readShort ()

              8. reads 2 bytes of data

            8. unsigned long readLong ()

              9. reads 4 bytes of data

           

        9. IOTrack

          10. Basic abstraction level of physical IO track. Track must be asociated with an specific IO card.All input/output operations are performed through IOTrack.

          1. Public Operations:
            1. IOTrack IOTrack (IOCard& inCard, const unsigned int inStartingPoint, const char* const inIOMask)

              2. -----------------------------------------------------------------------------

            2. void ~IOTrack ()
            3. enum IOTrack::PointTypes pointType (const unsigned int inPointNumber)

              4. return type of specified IO point.

            4. bool hasPointOfType (const char inPointType)

              5. returns if there are any points of specified type.

            5. unsigned int startingPoint ()

              6. meaning of starting point value is IO card specific.

            6. unsigned int numberOfPoints ()

              7. Returns number of points per track

               

            7. IOCard& card ()

              8. Returns a reference to IOCard which this trac belongs to.

            8. long trackState ()

              9. returns track state code. 0 always means OK, other state codes are

              IO card specific

            9. const long& operator [] (const unsigned int inPointNumber)

              10. returns state of individual IO point

            10. long& operator [] (const unsigned int inPointNumber)

              11. changes state of individual IO point

            11. IOTrack& updateInputs ()

              12. reads current state of all input points from IO card. Should be called periodically.

            12. IOTrack& updateOutputs ()

              13. modified physical state of all output points. Should be called periodically or after output state modification.

           

        10. OSInterface

          11. Singleton class for accessing operating system services. Windows NT implementatin loads and opens uniio.sys driver that is used to enable port IO from user process and retrive pointer to physical memory block. All communication with device driver is performed through OSInterface class.

          1. Public Operations:
            1. OSInterface& osinterface ()
            2. void sleep (const unsigned long inMicroseconds)

              3. suspends execution of the current thred for specified number of microseconds

            3. void ~OSInterface ()

           

        11. PC7166Card

          12. Class for accessing USDigital PC7166 Encoder counter card. This card accepts tracks only with 'C' or 'R' types

          1. Derived from IOCard

            2.  

          2. Public Operations:
            1. PC7166Card PC7166Card (const unsigned int inBaseIOPort)
            2. unsigned int baseIOPort ()

              3. Returns base IO Port of this card

            3. void ~PC7166Card ()
            4. IOCard& reset ()

              5. Reset encoder counters to 0

           

        12. PCI72xxCard

          13. Class for interfacing Arbor Technologies PCI-7248 and PCI7296 direct digital IO cards

          1. Derived from IOCard

            2.  

          2. Public Operations:
            1. PCI72xxCard PCI72xxCard (const unsigned int inCardId = 0)
            2. void ~PCI72xxCard ()

           

        13. PCIBus

          14. Singleton class representing computer PCI bus.

          1. Public Operations:
            1. PCIBus& pciBus ()
            2. bool exists ()

              3. Tests if PCI bus exists on the system

            3. void ~PCIBus ()
            4. const PCIDeviceInfo* getDeviceInfo (const unsigned short inVendorId, const unsigned short inDeviceId, const unsigned int inCardNumber = 0)

              5. returns pointer to Device Information structure or NULL or device with specified ID is not present in the system

           

        14. PCIDeviceInfo

          15. Clas for representing PCI device information retrieved from PCI Bus.

          1. Public Operations:
            1. unsigned short vendorId ()
            2. void ~PCIDeviceInfo ()
            3. unsigned short deviceId ()
            4. unsigned short status ()
            5. unsigned char revisionId ()
            6. unsigned char progIf ()
            7. unsigned char subClass ()
            8. unsigned char baseClass ()
            9. unsigned char cacheLineSize ()
            10. unsigned char latencyTimer ()
            11. unsigned char headerType ()
            12. unsigned char BIST ()

              13. base addresses are from 0 to 5

            13. unsigned long baseAddress (const unsigned char i)
            14. unsigned long CIS ()
            15. unsigned short subVendorId ()
            16. unsigned short subSystemId ()
            17. unsigned long ROMBaseAddress ()
            18. unsigned char capabilityList ()
            19. unsigned char interruptLine ()
            20. unsigned char interruptPin ()
            21. unsigned char minimumGrant ()
            22. unsigned char maximumLatency ()

           

        15. PCIConfig

          16. Abstract class representing method of retrieving PCI device information.

          1. Public Operations:
            1. bool exists ()

              2. returns if this PCI configuration retrieval method is available in the computer.

            2. void ~PCIConfig ()
            3. void scanBus ()

              4. Function which scans PCI bus on first use and stores retrieved information in the PCIBus class

           

        16. PCIConfig1

          17. Class for direct PCI access using "Type 1"

          1. Derived from PCIConfigDirect

            2.  

          2. Public Operations:
            1. PCIConfig1 PCIConfig1 ()

              2. Command word for Config1 access

              -----------------------------------------------------------------------------

            2. bool exists ()

              3. end destructor

              -----------------------------------------------------------------------------

            3. void ~PCIConfig1 ()

              4. end constructor

              -----------------------------------------------------------------------------

           

        17. PCIConfigDirect

          18. Abstract class for retrieving PCI device information using direct port IO.

          1. Derived from PCIConfig
          2. Public Operations:
            1. PCIConfigDirect PCIConfigDirect ()
            2. void scanBus ()
            3. void ~PCIConfigDirect ()

           

        18. PCIConfig2

          19. Class for Direct PCI access using "Type 2"

          1. Derived from PCIConfigDirect

            2.  

          2. Public Operations:
            1. PCIConfig2 PCIConfig2 ()
            2. bool exists ()

              3. end destructor

              -----------------------------------------------------------------------------

            3. void ~PCIConfig2 ()

              4. end constructor

              -----------------------------------------------------------------------------

           

        19. PCIConfigSelector

          20. Class which selects what PCI acces type should we use on a specific platform. Platform specific. On a Windows NT PC systems tries PCIConfig1 and if this one fails uses PCIConfig2.

          1. Public Operations:
            1. PCIConfig* createPCIConfig ()

              2. determines which PCI bus configuration retrieval options are available and creates appropriate PCIConfig object.


    Copyright © 2000 UAB "BBD SOFT"
    All Rights Reserved.
    Comments to bbdsoft@bbdsoft.com

    All brand names and products names are trademarks or registered trademarks of their respective companies.