Picproje Elektronik Sitesi

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "cy7c63001.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
       // Handle ermitteln
       hTreiber = CreateFile( "\\\\.\\Thermometer_0",
                    GENERIC_WRITE,
                    FILE_SHARE_WRITE,
                    NULL,
                    OPEN_EXISTING,
                    0,
                    0 );

       // Zeiger ínitialisieren
       pIn = &szIn[0];
       pOut = &szOut[0];
       lpByte = &lByte;

       // Anzeige setzen
       Label1->Caption = "---°C";

       // Fensterposition setzen
       Form1->Top = 100;
       Form1->Left = 100;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormDestroy(TObject *Sender)
{
        CloseHandle( hTreiber );
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
        Timer1->Enabled = false;
        LeseTemp();
        LeseS1();
        Timer1->Enabled = true;
}
//---------------------------------------------------------------------------
// Temperatur auslesen
void TForm1::LeseTemp( void )
{
        int nTemp;
        AnsiString sTemp;

        // 0x04 = Control-Code; Funktionsnummer
        // szOut[0] = Status; [1] = Temperatur; [2] = Vorzeichen; [3] = Schalter
        szIn[0] = 0x0b;

        DeviceIoControl( hTreiber, 0x04, pIn, sizeof(szIn), pOut,
                        sizeof(szOut), lpByte, NULL );

         // Temperatur ermitteln
         nTemp = szOut[1]/2;

        // Ausgabe zusammensetzen
        if ( szOut[2] == 0 ) sTemp += "+";
        else sTemp += "-";
        sTemp += nTemp;
        sTemp += "°C";
        Label1->Caption = sTemp;
}
//---------------------------------------------------------------------------
// Helligkeit der LED D2 einstellen
void __fastcall TForm1::TrackBar1Change(TObject *Sender)
{
        Timer1->Enabled = false;

        // Setze LED Helligkeit
        szIn[0] = 0x0e;
        szIn[1] = (char)TrackBar1->Position;

        DeviceIoControl( hTreiber, 0x04, pIn, sizeof(szIn), pOut,
                        sizeof(szOut), lpByte, NULL );

        Timer1->Enabled = true;                        
}

//---------------------------------------------------------------------------
// Lese Port 1 lesen uns S1 auskodieren
void TForm1::LeseS1( void )
{
        szIn[0] = 0x14; // Lese Port
        szIn[1] = 0x1;  // Port 1 auslesen

        DeviceIoControl( hTreiber, 0x04, pIn, sizeof(szIn), pOut,
                        sizeof(szOut), lpByte, NULL );

        // Schalter 1 offen
        if ( (szOut[1] & 0x04) == 0x4 )
        {
                Shape1->Brush->Color = clAqua;
                Label3->Caption = "S1 offen";
        }
        // Schalter 1 geschlossen
        else
        {
                Shape1->Brush->Color = clBtnFace;
                Label3->Caption = "S1 geschlossen";
        }
}

//---------------------------------------------------------------------------
#ifndef cy7c63001H
#define cy7c63001H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Buttons.hpp>
#include <ExtCtrls.hpp>
#include <ComCtrls.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
        TTimer *Timer1;
        TBitBtn *BitBtn1;
        TTrackBar *TrackBar1;
        TPanel *Panel1;
        TLabel *Label1;
        TLabel *Label2;
        TShape *Shape1;
        TLabel *Label3;
        void __fastcall FormDestroy(TObject *Sender);
        void __fastcall Timer1Timer(TObject *Sender);
        void __fastcall TrackBar1Change(TObject *Sender);
private:	// Anwenderdeklarationen
public:		// Anwenderdeklarationen
        HANDLE hTreiber;
        char szIn[4];          // 4 * 8 Bit ; = long int
        char * pIn;
        char szOut[4];          // 4 * 8 Bit ; = long int
        char *pOut;
        unsigned long int  lByte;
        unsigned long int* lpByte;
        void LeseTemp( void );
        void LeseS1( void );
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

  hTreiber = CreateFile( "\\\\.\\Thermometer_0", 
                    GENERIC_WRITE, 
                    FILE_SHARE_WRITE, 
                    NULL, 
                    OPEN_EXISTING, 
                    0, 
                    0 );

Low-cost solution for low-speed USB peripherals such as mouse, joystick, and gamepad

  hTreiber = CreateFile( "\\\\.\\Thermometer_0", 
                    GENERIC_WRITE, 
                    FILE_SHARE_WRITE, 
                    NULL, 
                    OPEN_EXISTING, 
                    0, 
                    0 );  

\\\\.\\com10

m_hCommPort = CreateFile(m_strPort,GENERIC_READ | GENERIC_WRITE,
0, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED |
FILE_FLAG_NO_BUFFERING,NULL);
if (m_hCommPort == INVALID_HANDLE_VALUE) return FALSE;

m_hPort = CreateFile (\\\\.\\com10,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL);

#include "usb.h"
#include <setupapi.h>
#include <hidsdi.h>

HANDLE connectToIthUSBHIDDevice (DWORD deviceIndex)
{
    GUID hidGUID;
    HDEVINFO hardwareDeviceInfoSet;
    SP_DEVICE_INTERFACE_DATA deviceInterfaceData;
    PSP_INTERFACE_DEVICE_DETAIL_DATA deviceDetail;
    ULONG requiredSize;
    HANDLE deviceHandle = INVALID_HANDLE_VALUE;
    DWORD result;

    //Get the HID GUID value - used as mask to get list of devices
    HidD_GetHidGuid (&hidGUID);

    //Get a list of devices matching the criteria (hid interface, present)
    hardwareDeviceInfoSet = SetupDiGetClassDevs (&hidGUID,
                                                 NULL, // Define no enumerator (global)
                                                 NULL, // Define no
                                                 (DIGCF_PRESENT | // Only Devices present
                                                 DIGCF_DEVICEINTERFACE)); // Function class devices.

    deviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);

    //Go through the list and get the interface data
    result = SetupDiEnumDeviceInterfaces (hardwareDeviceInfoSet,
                                          NULL, //infoData,
                                          &hidGUID, //interfaceClassGuid,
                                          deviceIndex, 
                                          &deviceInterfaceData);

    /* Failed to get a device - possibly the index is larger than the number of devices */
    if (result == FALSE)
    {
        SetupDiDestroyDeviceInfoList (hardwareDeviceInfoSet);
        return INVALID_HANDLE_VALUE;
    }

    //Get the details with null values to get the required size of the buffer
    SetupDiGetDeviceInterfaceDetail (hardwareDeviceInfoSet,
                                     &deviceInterfaceData,
                                     NULL, //interfaceDetail,
                                     0, //interfaceDetailSize,
                                     &requiredSize,
                                     0); //infoData))

    //Allocate the buffer
    deviceDetail = (PSP_INTERFACE_DEVICE_DETAIL_DATA)malloc(requiredSize);
    deviceDetail->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);

    //Fill the buffer with the device details
    if (!SetupDiGetDeviceInterfaceDetail (hardwareDeviceInfoSet,
                                          &deviceInterfaceData,
                                          deviceDetail,
                                          requiredSize,
                                          &requiredSize,
                                          NULL)) 
    {
        SetupDiDestroyDeviceInfoList (hardwareDeviceInfoSet);
        free (deviceDetail);
        return INVALID_HANDLE_VALUE;
    }

    //Open file on the device
    deviceHandle = CreateFile (deviceDetail->DevicePath,
                               GENERIC_READ,
                               FILE_SHARE_READ | FILE_SHARE_WRITE,
                               NULL,        // no SECURITY_ATTRIBUTES structure
                               OPEN_EXISTING, // No special create flags
                               0, 
                               NULL);       // No template file

    SetupDiDestroyDeviceInfoList (hardwareDeviceInfoSet);
    free (deviceDetail);
    return deviceHandle;
}

HANDLE connectToUSBHIDDevice (DWORD *vendorID, DWORD *productID, DWORD *versionNumber)
{
    HANDLE deviceHandle = INVALID_HANDLE_VALUE;
    DWORD index = 0;
    HIDD_ATTRIBUTES deviceAttributes;
    BOOL matched = FALSE;

    while (!matched && (deviceHandle = connectToIthUSBHIDDevice (index)) != INVALID_HANDLE_VALUE)
    {
        if (!HidD_GetAttributes (deviceHandle, &deviceAttributes))
            return INVALID_HANDLE_VALUE;

        if ((vendorID == 0 || deviceAttributes.VendorID == *vendorID) &&
            (productID == 0 || deviceAttributes.ProductID == *productID) &&
            (versionNumber == 0 || deviceAttributes.VersionNumber == *versionNumber))
            return deviceHandle; /* matched */
        
        CloseHandle (deviceHandle); /* not a match - close and try again */

        index++;
    }

    return INVALID_HANDLE_VALUE;
}