
CPI-UD048 WindowsXP/Vista/7 32bit OS Ή API dl

CPI Technologies, Inc.
========================================================================

ڎ

1.  Tv
2.  
3.  vO\
4.  API t@X
4.1.   API
4.1.1.  D048GetVersion
4.1.2.  D048Create
4.1.3.  D048Close
4.1.4.  D048GetDevInfo
4.1.5.  D048GetUnitType
4.1.6.  D048GetSwitchValue
4.2.  I/O API
4.2.1.  D048GetDirections
4.2.2.  D048SetDirections
4.2.3.  D048InPort
4.2.4.  D048OutPort
4.2.5.  D048SetWdt
4.2.6.  D048ResetWdt
4.2.7.  D048SetDefaultOutput
4.2.8.  D048GetWdtStatus
4.2.9.  D048SetTrgCond
4.2.10. D048SetFilter
4.3.  ̑ API
4.3.1.  D048GetLastError
5.  bZ[W
6.  萔
6.1.  G[R[h
6.2.  _|[gԍ萔
6.3.  o͕wrbg}bv萔
6.4.  ̑̒萔

========================================================================

1.  Tv

    { CPI-UD048 p[UJ API _Ci~bNNCu
     (ȉuDLLv) xŒ`܂B
    foCXhCȍڍׂɂĂ͐GĂ܂B
    ȂAP DLL  CPI-UD048 𐧌䂵܂B

========================================================================

2.  

    {Œ` API  Windows(R) XP/Vista/7  32bit OSōő
    16 ܂ł CPI-UD048 (ȉufoCXv) 𐧌䂵܂B

========================================================================

3.  vO\

    {Œ` API cpiud048.sys(foCXhCo)
    сAcpiud048.dll (DLL) ɂ܂B

========================================================================

4.  API t@X

    API ͈ȉ̂悤ɑʂ܂B

        1.   API
        2.  I/O API
        3.  ̑ API

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

4.1.   API

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

4.1.1.  D048GetVersion

@\
    o[Wԍ擾

`
    Visual C++
      BOOL D048GetVersion(PDWORD pdwDllVersion, PDWORD pdwDriverVersion);

    Visual Basic
      Function D048GetVersion(ByRef pdwDllVersion As Long, ByRef pdwDriverVersion As Long) As Long

    Delphi
      function D048GetVersion(var pdwDllVersion: DWord; var pdwDriverVersion: DWord): Boolean;


    pdwDllVersion
        DLL ̃o[Wԍi[̈ւ̃|C^B
        NULL B
    pdwDriverVersion
        foCXhCõo[Wԍi[̈ւ̃|C^B
        NULL B

o
    *pdwDllVersion
        DLL ̃o[WԍB

    *pdwDriverVersion
        foCXhCõo[WԍB

߂l
    APIsꍇFALSEԂ܂B


    DLL  foCXhCõo[Wԍ擾܂B
        16BitW[o[W
        16Bit}Ci[o[W

G[
    D048_ERR_SYSTEM
        VXeG[łBWindows  GetLastError() R[
        B
        ̃tH_ɃhCo̗RŃfoCX
        hCogݍ܂ĂȂ\܂B


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

4.1.2.  D048Create

@\
    foCX̎gp錾

`
    Visual C++
      BOOL D048Create(PWORD pwLogDevice, HWND hwnd, UINT uWMCode);

    Visual Basic
      Function D048Create(ByRef pwLogDevice As Integer, ByVal hwnd As Long, ByVal uWMCode As Integer) As Long

    Delphi
      function D048Create(var pwLogDevice: Word; hwnd: THandle; uWMCode: Word): Boolean;


    pwLogDevice
        gpfoCX̘_foCXԍw肵܂B
        _foCXԍ͂On܂܂B
        D048_DEVICE_AUTOw肵ꍇAgp\ȃfoCXT܂B
        _foCXԍO猟A_ł̔ԍԂ܂B
        łɃAvP[VɂgpĂfoCX̓XLbv܂B
        ȌAAvP[V͂̒lŃfoCXʂ܂BNULLsB
    hwnd
        |[gĎ@\gpꍇɃhCoo郁bZ[W󂯎
        EBhẼnhw肵܂B
        bZ[WgpȂꍇ NULL w肵܂B
    uWMCode
        |[gĎ@\gpꍇɑo郁bZ[W ID ̒lw肵܂B
        ʏ WM_USER (0x400) ȏ̒lw肵܂B
        bZ[WgpȂꍇ NULL w肵܂B

o
    *pwLogDevice
        gp\ȃfoCXꍇ́A̘_foCXԍ
        i[܂B
        ȂꍇA̒l͖`łB

߂l
    APIsꍇFALSEԂ܂B


    foCXAvP[Vgp邱ƂhCoɒʒm܂B
    foCX݂ĂȂꍇ́AG[ƂȂ܂B
    łɑ̃AvP[VŎgpĂꍇG[ƂȂ܂B
    ɂAP̃foCX͒P̃AvP[VrIɎgp
    ܂B
    APIĂяoOɕKAPIĂяoĂB
    APIsꍇAD048GetLastError()iDevɂ
    D048_DEVICE_AUTOw肵ĂB


    ׂẴ|[g͓͕ɏ܂B
    荞݂͋֎~ԂɂȂ܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_NO_DEVICE
        gp\ȃfoCX܂B
    D048_ERR_IN_USE
        w̃foCX͎gpł
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_ARGUMENT
        Ȉw肳܂B


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

4.1.3.  D048Close

@\
    gp̃foCX

`
    Visual C++
      BOOL D048Close(WORD wLogDevice);

    Visual Basic
      Function D048Close(ByVal wLogDevice As Integer) As Long

    Delphi
      function D048Close(wLogDevice: Word): Boolean;



    wLogDevice
        foCX̘_foCXԍw肵܂B

߂l
    APIsꍇFALSEԂ܂B


    AvP[VfoCX̎gpIAfoCX𑼂
    AvP[VɊJ邱ƂfoCXhCoɒʒm܂B
    AvP[VIOɕKAPIĂяoĂB

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_ARGUMENT
        Ȉw肳܂B


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

4.1.4.  D048GetDevInfo

@\
    foCX擾

`
    VisualC++
      #define D048_CCH_VEN         8
      #define D048_CCH_DEV         16
      #define D048_CCH_VER         4

      typedef struct  SD048DI {
          unsigned short  wCdb;       /* bytes of command descriptor */
          unsigned short  wSdb;       /* bytes of status descriptor */
          unsigned long   dwBuff;     /* bytes of internal buffer */
          char sVen[ D048_CCH_VEN ];  /* vendor name */
          char sDev[ D048_CCH_DEV ];  /* device name */
          char sVer[ D048_CCH_VER ];  /* firmware version */
      } TD048DI, * PD048DI;

      BOOL WINAPI D048GetDevInfo(WORD wLogDevice, PD048DI pDevInfo);

    Visual Basic
      Global Const D048_CCH_VEN = 8
      Global Const D048_CCH_DEV = 16
      Global Const D048_CCH_VER = 4

      Type SD048DI
          wCdb As Integer                     ' bytes of command descriptor
          wSdb As Integer                     ' bytes of status descriptor
          dwBuff As Long                      ' bytes of internal buffer
          sVen(1 To D048_CCH_VEN) As Byte     ' vendor name
          sDev(1 To D048_CCH_DEV) As Byte     ' device name
          sVer(1 To D048_CCH_VER) As Byte     ' firmware version
      End Type

      Function D048GetDevInfo(ByVal wLogDevice As Integer, ByRef pDevInfo As SD048DI) As Long

    Delphi
      const
        D048_CCH_VEN = 8;
        D048_CCH_DEV = 16;
        D048_CCH_VER = 4;

      type
        SD048DI = record
          wCdb:   Word;                                   // bytes of command descriptor
          wSdb:   Word;                                   // bytes of status descriptor
          dwBuff: DWord;                                  // bytes of internal buffer
          sVen:   array [0 .. D048_CCH_VEN - 1] of Byte;  // vendor name
          sDev:   array [0 .. D048_CCH_DEV - 1] of Byte;  // device name
          sVer:   array [0 .. D048_CCH_VER - 1] of Byte;  // firmware version
        end;
     PD048DI = ^SD048DI;

     function D048GetDevInfo(wLogDevice: Word; pDevInfo: PD048DI): Boolean;


    wLogDevice
        _foCXԍw肵܂B
    pDevInfo
        foCXi[̈ւ̃|C^w肵܂B

o
    *pDevInfo
        wCdb
            R}h fBXNv^̃oCgi[܂B
        wSdb
            Xe[^X fBXNv^̃oCgi[܂B
        dwBuff
            foCXobt@̃oCgi[܂B
        sVen
            x_ʕ񂪊i[܂B
        sDev
            v_Ngʕ񂪊i[܂B
        sVer
            t@[EFÃo[W񂪊i[܂B

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̏擾܂B
    NULI[ł͂܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_ARGUMENT
        Ȉw肳܂B


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

4.1.5. D048GetUnitType

@\
    jbg^CviTTL/CMOSj擾

`
    Visual C++
      #define D048_TYPE_TTL    0
      #define D048_TYPE_CMOS   1

      BOOL D048GetUnitType(WORD wLogDevice, PDWORD pdwType);

    Visual Basic
      Global Const D048_TYPE_TTL = 0
      Global Const D048_TYPE_CMOS = 1

      Function D048GetUnitType(ByVal wLogDevice As Integer, ByRef pdwType As Long) As Long

    Delphi
      D048_TYPE_TTL  = 0;
      D048_TYPE_CMOS = 1;

      function D048GetUnitType(wLogDevice: Word; var pdwType: Dword): Boolean;


    wLogDevice
        _foCXԍw肵܂B
    pdwType
        ^Cvli[̈ւ̃|C^B
        NULL͕sB

o
    *pdwType
        ^CvlB

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̃^CviTTL/CMOSj擾܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_ARGUMENT
        pdwTypeNULLłB

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

4.1.6. D048GetSwitchValue

@\
    jbgZNgXCb`̒l擾

`
    Visual C++
      BOOL D048GetSwitchValue(WORD wLogDevice, PDWORD pdwSwitchValue);

    Visual Basic
      Function D048GetSwitchValue(ByVal wLogDevice As Integer, ByRef pdwSwitchValue As Long) As Long

    Delphi
      function D048GetSwitchValue(wLogDevice: Word; var pdwSwitchValue: DWord): Boolean;


    wLogDevice
        _foCXԍw肵܂B
    pdwSwitchValue
        jbgZNgXCb`̒li[̈ւ̃|C^B
        NULL͕sB

o
    *pdwSwitchValue
        jbgZNgXCb`̒lB

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̃jbgZNgXCb`̒l擾܂B

G[

    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_ARGUMENT
        pdwSwitchValueNULLłB

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

4.2.  I/O API

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

4.2.1. D048GetDirections

@\
    擾

`
    Visual C++
      BOOL D048GetDirections(WORD wLogDevice, PDWORD pdwDirections);

    Visual Basic
      Function D048GetDirections(ByVal wLogDevice As Integer, ByRef pdwDirections As Long) As Long

    Delphi
      function D048GetDirections(wLogDevice: Word; var pdwDirections: Dword): Boolean;


    wLogDevice
        _foCXԍw肵܂B
    pdwDirections
        i[̈ւ̃|C^B
        NULL͕sB

o
    *pdwDirections
        擾B
        ̒l͊e|[gɑΉrbg}bvɂȂĂ܂B
            
             rbg  |[g 
            
               O      `   
               P      a   
               Q      b   
               R      c   
               S      d   
               T      e   
            
        erbg͂OŏóAPœ͕ɐݒ肳Ă܂B

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̕擾܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_ARGUMENT
        pdwDirectionsNULLłB

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

4.2.2. D048SetDirections

@\
    ݒ

`
    Visual C++
      BOOL D048SetDirections(WORD wLogDevice, DWORD dwDirections);

    Visual Basic
      Function D048SetDirections(ByVal wLogDevice As Integer, ByVal dwDirections As Long) As Long

    Delphi
      function D048SetDirections(wLogDevice: Word; dwDirections: Dword): Boolean;


    wLogDevicev
        _foCXԍw肵܂B
    dwDirections
        e|[gɑΉrbg}bvŎw肵܂B
            
             rbg  |[g 
            
               O      `   
               P      a   
               Q      b   
               R      c   
               S      d   
               T      e   
            
        erbg͂OŏóAPœ͕ɐݒ肳܂B

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̃fBNVݒ肵܂B


    Lȃ|[gȏ̃rbg͖܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB

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

4.2.3. D048InPort

@\
    Cӂ̃|[gf[^

`
    Visual C++
      BOOL D048InPort(WORD wLogDevice, DWORD dwLogPort, PBYTE pbInValue);

    Visual Basic
      Function D048InPort(ByVal wLogDevice As Integer, ByVal dwLogPort As Long, ByRef pbInValue As Byte) As Long

    Delphi
      function D048InPort(wLogDevice: Word; dwLogPort: DWord; var pbInValue: Byte): Boolean;


    wLogDevice
        _foCXԍw肵܂B
    dwLogPort
        ̘_|[gԍ̓͂s܂B
    pbInValue
        ̓f[^i[̈ւ̃|C^B
        NULL͕sB

o
    *pbInValue
        Y|[g(dwLogPortl)̓|[gɐݒ肳Ăꍇ
            ̓f[^lɑ΂D048SetFilterŐݒ肳ꂽtB^ꂽ
            lǂݏo܂B

        Y|[g(dwLogPortl)o̓|[gɐݒ肳Ăꍇ
            D048OutPortŏo͂ꂽo̓f[^l[hobN܂B

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̎w_|[g͂܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_ARGUMENT
        pbInValueNULLłB
    D048_ERR_INVALID_PORT
        Ș_|[gԍłB

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

4.2.4. D048OutPort

@\
    Cӂ̃|[gւ̃f[^o

`
    Visual C++
      BOOL D048OutPort(WORD wLogDevice, DWORD dwLogPort, BYTE bOutValue);

    Visual Basic
      Function D048OutPort(ByVal wLogDevice As Integer, ByVal dwLogPort As Long, ByVal bOutValue As Byte) As Long

    Delphi
      function D048OutPort(wLogDevice: Word; dwLogPort: DWord; bOutValue: Byte): Boolean;


    wLogDevice
        _foCXԍw肵܂B
    dwLogPort
        ̘_|[gԍւ̏o͂s܂B
    bOutValue
        o̓f[^B

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̎w_|[gɏo͂܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_PORT
        Ș_|[gԍłB
    D048_ERR_BAD_DIRECTION
        sȕłB

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

4.2.5. D048SetWdt

@\
    EHb`hbO^CAEgԂ̐ݒ
    уEHb`hbO@\̊JnA~

`
    Visual C++
      bWdtValueɐݒ肷l
        #define D048_WDT_INTERVAL_STOP        0
        #define D048_WDT_INTERVAL_126         1
        #define D048_WDT_INTERVAL_252         2
        #define D048_WDT_INTERVAL_504         3
        #define D048_WDT_INTERVAL_1008        4
        #define D048_WDT_INTERVAL_2016        5

      BOOL D048SetWdt(WORD wLogDevice, BYTE bWdtValue);

    Visual Basic
      bWdtValueɐݒ肷l
        Global Const D048_WDT_INTERVAL_STOP = 0
        Global Const D048_WDT_INTERVAL_126 = 1
        Global Const D048_WDT_INTERVAL_252 = 2
        Global Const D048_WDT_INTERVAL_504 = 3
        Global Const D048_WDT_INTERVAL_1008 = 4
        Global Const D048_WDT_INTERVAL_2016 = 5

     Function D048SetWdt(ByVal wLogDevice As Integer, ByVal bWdtValue As Byte) As Long

    Delphi
      bWdtValueɐݒ肷l
        D048_WDT_INTERVAL_STOP = 0;
        D048_WDT_INTERVAL_126  = 1;
        D048_WDT_INTERVAL_252  = 2;
        D048_WDT_INTERVAL_504  = 3;
        D048_WDT_INTERVAL_1008 = 4;
        D048_WDT_INTERVAL_2016 = 5;

     function D048SetWdt(wLogDevice: Word; bWdtValue: Byte): Boolean;


    wLogDevicev
        _foCXԍw肵܂B
    bWdtValue
        EHb`hbO^CAEgԂΉlŎw肵܂B

            
                    l                            
            
            O(ftHgl)  EHb`hbO@\~  
            P                            PQUr  
            Q                            QTQr  
            R                            TOSr  
            S                          POOWr  
            T                          QOPUr  
            

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̃EHb`hbO^CAEgԂݒ肵܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_ARGUMENT
        bWdtValueȒlłB

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

4.2.6.  D048ResetWdt

@\
    EHb`hbO^CAEgԂlɂB

`
    Visual C++
      BOOL D048ResetWdt(WORD wLogDevice);

    Visual Basic
      Function D048ResetWdt(ByVal wLogDevice As Integer) As Long

    Delphi
      function UD048ResetWdt(wLogDevice: Word): Boolean;


    wLogDevice
        _foCXԍw肵܂B

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̃^C}܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB

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

4.2.7. D048SetDefaultOutput

@\
    EHb`hbO^CAEgɏo͂|[gђl̐ݒ

`
    Visual C++
      BOOL D048SetDefaultOutput(WORD wLogDevice, DWORD dwLogPort, BYTE bDefaultValue);

    Visual Basic
      Function D048SetDefaultOutput(ByVal wLogDevice As Integer, ByVal dwLogPort As Long, ByVal bDefaultValue As Byte) As Long

    Delphi
      function D048SetDefaultOutput(wLogDevice: Word; dwLogPort: DWord; bDefaultValue: Byte): Boolean;


    wLogDevice
        _foCXԍw肵܂B
    dwLogPort
        ̘_|[gԍւ̏o͂s܂B
    bDefaultValue
        o̓f[^B
        ftHgl0x00

߂l
    APIsꍇFALSEԂ܂B


    EHb`hbO^CAEgɏo͂l
    wfoCX̎w_|[gɐݒ肵܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_PORT
        Ș_|[gԍłB
    D048_ERR_BAD_DIRECTION
        sȕłB

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

4.2.8. D048GetWdtStatus

@\
    EHb`hbOJE^̏Ԃ擾

`
    Visual C++
      #define D048_WDT_FLAG_OFF    0
      #define D048_WDT_FLAG_ON     1

      BOOL D048GetWdtStatus(WORD wLogDevice, PBYTE pbWdtStatus);

    Visual Basic
      Global Const D048_WDT_FLAG_OFF = 0
      Global Const D048_WDT_FLAG_ON = 1

      Function D048GetWdtStatus(ByVal wLogDevice As Integer, ByRef pbWdtStatus As Byte) As Long

    Delphi
      D048_WDT_FLAG_OFF = 0;
      D048_WDT_FLAG_ON  = 1;

      function D048GetWdtStatus(wLogDevice: Word; var pbWdtStatus: Byte): Boolean;


    wLogDevice
        _foCXԍw肵܂B
    pbWdtStatus
        EHb`hbOJE^̏Ԃi[̈ւ̃|C^B
        NULL͕sB

o
    *pbWdtStatus
        EHb`hbOJE^̏ԁB

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̃EHb`hbOJE^̏Ԃ擾܂B
    D048_WDT_FLAG_OFF 0: EHb`hbO܂́A^CAEgO
    D048_WDT_FLAG_ON  1: EHb`hbO^CAEg

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_ARGUMENT
        pbWdtStatusNULLłB

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

4.2.9.  D048SetTrgCond

@\
    |[gĎ̐ݒ

`
    VisualC++
      TD048PTRGCOND.bModeɐݒ肷l
        #define D048_MON_NONE          0
        #define D048_MON_ALT           1
        #define D048_MON_AND           2
        #define D048_MON_OR            3

      typedef struct SD048PTRGCOND {
          BYTE bMode;
          BYTE bMask;
          BYTE bData;
      } TD048PTRGCOND, *PD048PTRGCOND;

      BOOL WINAPI D048SetTrgCond(WORD wLogDevice, DWORD dwLogPort, PD048PTRGCOND pTrgCond);

    Visual Basic
      TD048PTRGCOND.bModeɐݒ肷l
        Global Const D048_MON_NODE = 0
        Global Const D048_MON_ALT = 1
        Global Const D048_MON_AND = 2
        Global Const D048_MON_OR = 3

      Type SD048PTRGCOND
          bMode As Byte
          bMask As Byte
          bData As Byte
      End Type

      Function D048SetTrgCond(ByVal wLogDevice As Integer, ByVal dwLogPort As Long, ByRef pTrgCond As SD048PTRGCOND) As Long

    Delphi
      TD048PTRGCOND.bModeɐݒ肷l
        D048_MON_NODE = 0;
        D048_MON_ALT  = 1;
        D048_MON_AND  = 2;
        D048_MON_OR   = 3;

      type
        SD048PTRGCOND = record
          bMode:  Byte;
          bMask:  Byte;
          bData:  Byte;
        end;
      PD048PTRGCOND = ^SD048PTRGCOND;

     function D048SetTrgCond(wLogDevice: Word; dwLogPort: DWord; pTrgCond: PD048PTRGCOND): Boolean;


    wLogDevice
        _foCXԍw肵܂B
    dwLogPort
        Ď|[g̘_ԍw肵܂B
    pTrgCond
        |[gĎli[̈ւ̃|C^B
        NULL͕sB

       EbModeɐݒ肷l
            
               l                   `          |[gĎ       ֌Wv   
            
             O(ftHgl)  D048_MON_NONE                              
             P                D048_MON_ALT    Ώۃrbgɕω  bMask        
             Q                D048_MON_AND    ΏۃrbgSv      bMask,bData  
             R                D048_MON_OR     Ώۃrbgv    bMask,bData  
            

       EbMaskɐݒ肷l
            0x00`0xFFCӂŐݒ
            ftHgl0x00

       EbDataɐݒ肷l
            0x00`0xFFCӂŐݒ
            ftHgl0x00

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̃|[gĎݒ肵܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_ARGUMENT
        Ȉw肳܂B

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

4.2.10. D048SetFilter

@\
    tB^̃TCNAv񐔂̐ݒ

`
    Visual C++
      bIntervalɐݒ肷l
        #define D048_FILTER_INTERVAL_STOP        0
        #define D048_FILTER_INTERVAL_1260        1
        #define D048_FILTER_INTERVAL_2520        2
        #define D048_FILTER_INTERVAL_5040        3
        #define D048_FILTER_INTERVAL_10080       4
        #define D048_FILTER_INTERVAL_20160       5

      BOOL D048SetFilter(WORD wLogDevice, BYTE bInterval, BYTE bCount);

    Visual Basic
      bIntervalɐݒ肷l
        Global Const D048_FILTER_INTERVAL_STOP = 0
        Global Const D048_FILTER_INTERVAL_1260 = 1
        Global Const D048_FILTER_INTERVAL_2520 = 2
        Global Const D048_FILTER_INTERVAL_5040 = 3
        Global Const D048_FILTER_INTERVAL_10080 = 4
        Global Const D048_FILTER_INTERVAL_20160 = 5

     Function D048SetFilter(ByVal wLogDevice As Integer, ByVal bInterval As Byte, ByVal bCount As Byte) As Long

    Delphi
      bIntervalɐݒ肷l
        D048_FILTER_INTERVAL_STOP  = 0;
        D048_FILTER_INTERVAL_1260  = 1;
        D048_FILTER_INTERVAL_2520  = 2;
        D048_FILTER_INTERVAL_5040  = 3;
        D048_FILTER_INTERVAL_10080 = 4;
        D048_FILTER_INTERVAL_20160 = 5;

     function D048SetFilter(wLogDevice: Word; bInterval: Byte; bCount: Byte): Boolean;


    wLogDevicev
        _foCXԍw肵܂B
    bWdtValue
        tB^̃TCNif[^擾ԁjΉlŎw肵܂B
            
                    l                   `                       
            
            O(ftHgl)  D048_FILTER_INTERVAL_STOP         rsno
            P                D048_FILTER_INTERVAL_1260     PQUOr
            Q                D048_FILTER_INTERVAL_2520     QTQOr
            R                D048_FILTER_INTERVAL_5040     TOSOr
            S                D048_FILTER_INTERVAL_10080  POOWOr
            T                D048_FILTER_INTERVAL_20160  QOPUOr
            
    bCount
        v񐔂w肵܂B0x00`0xFFŔCӒl
        ftHgl0x00

߂l
    APIsꍇFALSEԂ܂B


    wfoCX̃tB^TCNсAv񐔂ݒ肵܂B

G[
    D048_ERR_SYSTEM
        VXeG[łB
    D048_ERR_INVALID_DEVICENO
        Ș_foCXԍłB
    D048_ERR_INVALID_ARGUMENT
        bIntervaȒlłB


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

4.3.  ̑ API

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

4.3.1.  D048GetLastError

@\
    G[R[h擾

`
    Visual C++
      DWORD D048GetLastError(WORD wLogSlot);

    Visual Basic
      Function D048GetLastError(ByVal wLogDevice As Integer) As Long

    Delphi
      function D048GetLastError(wLogDevice: Word): DWord;


    wLogSlot
        foCX̘_XbgԍwB

߂l
    G[R[hB


    ƂŋߋNG[̃R[h擾܂B

========================================================================

5.  bZ[W

    uWMCode ɂ̓foCXŗL ID ܂B

    WM_CHECK_TRG F |[gĎ@\gpꍇɐݒ肵
                    hCobZ[W𑗏o܂B


`
    VisualC++
      #define WM_CHECK_TRG     0x2000      /* bZ[WID */

      BOOL D048Create(PWORD pwLogDevice, HWND hwnd, UINT uWMCode);

    Visual Basic
      Global Const WM_CHECK_TRG = &H2000   ' bZ[WID

      Function D048Create(ByRef pwLogDevice As Integer, ByVal hwnd As Long, ByVal uWMCode As Integer) As Long

    Delphi
      WM_CHECK_TRG                  = $2000;  // bZ[WID

      function D048Create(var pwLogDevice: Word; hwnd: THandle; uWMCode: Word): Boolean;


    EbZ[Wnh̐ݒiu4.1.2.  D048CreatevQƁj

========================================================================

6.  萔

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

6.1.  G[R[h

#define D048_SUCCESS                 0        /* I*/
#define D048_ERR_SYSTEM              1        /* GetLastError R[ */
#define D048_ERR_NO_DEVICE           2        /* gp\ȃfoCXȂ */
#define D048_ERR_IN_USE              3        /* wfoCX͎gpł */
#define D048_ERR_INVALID_DEVICENO    4        /* Ș_foCXԍ */
#define D048_ERR_INVALID_ARGUMENT    5        /* Ȉ */
#define D048_ERR_INVALID_PORT        6        /* Ș_|[g */
#define D048_ERR_BAD_DIRECTION       7        /* sȕ */
#define	D048_ERR_TRG_DATA_INVALID    8        /* |[gĎvf[^Ȃ */
#define D048_ERR_DLL                 ( ~0UL ) /* DLL [hs */



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

6.2. _|[gԍ萔

#define D048_PORT_A          0
#define D048_PORT_B          1
#define D048_PORT_C          2
#define D048_PORT_D          3
#define D048_PORT_E          4
#define D048_PORT_F          5

6.3. o͕wrbg}bv萔

#define D048_DIR_A_OUTPUT    ( 0 << D048_PORT_A )
#define D048_DIR_A_INPUT     ( 1 << D048_PORT_A )
#define D048_DIR_B_OUTPUT    ( 0 << D048_PORT_B )
#define D048_DIR_B_INPUT     ( 1 << D048_PORT_B )
#define D048_DIR_C_OUTPUT    ( 0 << D048_PORT_C )
#define D048_DIR_C_INPUT     ( 1 << D048_PORT_C )
#define D048_DIR_D_OUTPUT    ( 0 << D048_PORT_D )
#define D048_DIR_D_INPUT     ( 1 << D048_PORT_D )
#define D048_DIR_E_OUTPUT    ( 0 << D048_PORT_E )
#define D048_DIR_E_INPUT     ( 1 << D048_PORT_E )
#define D048_DIR_F_OUTPUT    ( 0 << D048_PORT_F )
#define D048_DIR_F_INPUT     ( 1 << D048_PORT_F )

#define D048_DIR_ALL_OUTPUT  ( D048_DIR_A_OUTPUT    \
                                | D048_DIR_B_OUTPUT \
                                | D048_DIR_C_OUTPUT \
                                | D048_DIR_D_OUTPUT \
                                | D048_DIR_E_OUTPUT \
                                | D048_DIR_F_OUTPUT \
                                )
#define D048_DIR_ALL_INPUT   ( D048_DIR_A_INPUT     \
                                | D048_DIR_B_INPUT  \
                                | D048_DIR_C_INPUT  \
                                | D048_DIR_D_INPUT  \
                                | D048_DIR_E_INPUT  \
                                | D048_DIR_F_INPUT  \
                                )

6.4. ̑̒萔

#define D048_MAX_DEVICES     16              /* őfoCX */
#define D048_MAX_PORTS       6               /* |[g */
#define D048_DEVICE_AUTO     ( ( WORD )~0 )

========================================================================

7. 

1.00    2010/03/23  

