none
Acceder a un driver para capturar datos a través del puerto paralelo RRS feed

  • Pregunta

  • Hola, estoy tratando de acceder a un driver que accede a través del puerto paralelo a una placa que contiene un sensor de imagen, para así poder capturar imágenes, y enviarlas al pc a través de dicho puerto, para poder manipularlas. El driver funciona perfectamente cuando se accede a través de un software facilitado por el fabricante de la placa. El problema es que no se como acceder a ese driver o como poder hacer que me haga interactuar con la placa, sin utilizar el software, sino creando yo el mio propio. Estoy programando con visual studio 2008 c#. ¿Alguien sabe como podría empezar?
    lunes, 12 de abril de 2010 14:17

Respuestas

Todas las respuestas

  • Tengo esto, hecho en C++ por un compañero hace años....¿se podrá implementar en C#?

     

     

     

     

     

    //---------------------------------------------------------------------------
    #include <vcl.h>
    #pragma hdrstop
    #include "Unit1.h"
    #include <Windows.h>
    #include <tlhelp32.h>
    #include <winbase.h>



    //--------------------------------------------------------------------------
    #pragma package(smart_init)
    #pragma link "HWINTERFACELib_OCX"
    #pragma resource "*.dfm"
    TForm1 *Form1;
    bool centinela;
    const Adress=0x378;
    HANDLE SNAPS;






    //---------------------------------------------------------------------------
    __fastcall TForm1::TForm1(TComponent* Owner)
            : TForm(Owner)
    {
    }
    //---------------------------------------------------------------------------
    struct registro
            {
            short base;
            short base_1;
            short base_2;
            short base_3;
            short base_4;
            short base_5;
            short base_6;
            short base_7;
            };
    struct cadena_registros
            {
            AnsiString base;
            AnsiString base_1;
            AnsiString base_2;
            AnsiString base_3;
            AnsiString base_4;
            AnsiString base_5;
            AnsiString base_6;
            AnsiString base_7;
            };
    void __fastcall TForm1::StartClick(TObject *Sender)
    {
    registro byte;
    cadena_registros cad;
    centinela=true;
    while (centinela==true)
            {
                            SuspendThread(SNAPS);
                            Application->ProcessMessages();
                            byte.base=Port->InPort(Adress);
                            byte.base_1=Port->InPort(Adress+1);
                            byte.base_2=Port->InPort(Adress+2);
                            byte.base_3=Port->InPort(Adress+3);
                            byte.base_4=Port->InPort(Adress+4);
                            byte.base_5=Port->InPort(Adress+5);
                            byte.base_6=Port->InPort(Adress+6);
                            byte.base_7=Port->InPort(Adress+7);
                            cad.base="SPP Data Port->Base: "+IntToStr(byte.base);
                            cad.base_1="SPP Status Port->Base+1: "+IntToStr(byte.base_1);
                            cad.base_2="SPP Control Port->Base+2: "+IntToStr(byte.base_2);
                            cad.base_3="EPP Adress Port->Base+3: "+IntToStr(byte.base_3);
                            cad.base_4="EPP Data PortBase+4: "+IntToStr(byte.base_4);
                            cad.base_5="Undefined->Base+5: "+IntToStr(byte.base_5);
                            cad.base_6="Undefined->Base+6: "+IntToStr(byte.base_6);
                            cad.base_7="Undefined->Base+7: "+IntToStr(byte.base_7);
                            Monitor->Items->Add(cad.base);
                            Monitor->Items->Add(cad.base_1);
                            Monitor->Items->Add(cad.base_2);
                            Monitor->Items->Add(cad.base_3);
                            Monitor->Items->Add(cad.base_4);
                            Monitor->Items->Add(cad.base_5);
                            Monitor->Items->Add(cad.base_6);
                            Monitor->Items->Add(cad.base_7);
                            Monitor->Items->Add("***************************************************");
                            ResumeThread(SNAPS);

             }
    Monitor->Items->SaveToFile("c:\\monitor.log");

    }
    //---------------------------------------------------------------------------

    void __fastcall TForm1::FormCreate(TObject *Sender)
    {
    void * h = CreateFile("\\\\.\\giveio", GENERIC_READ, 0, NULL,
                        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if(h == INVALID_HANDLE_VALUE)
            {
            Application->MessageBox("Cannot access Giveio.sys driver","Error I/O",MB_APPLMODAL);
            CloseHandle(h);
            Start->Enabled=false;
            Stop->Enabled=false;
            Borrar->Enabled=false;
            Monitor->Enabled=false;
            return;
            }
    CloseHandle(h);
    //Hasta aqui lo unico que he hecho es enlazar con el mismo driver que la aplicacion, para poder acceder al puerto paralelo sin
    //provocar un error al acceder
    HANDLE hnd = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
    if (hnd == INVALID_HANDLE_VALUE)
            {
            Application->MessageBox("Cannot get current processes list","Error",MB_APPLMODAL);
            CloseHandle(hnd);
            Start->Enabled=false;
            Stop->Enabled=false;
            Borrar->Enabled=false;
            Monitor->Enabled=false;
            return;
            }
    //Tomo un snapshot de todos los porcesos actualmente activos, para comprobar que esta ejecutándose
    PROCESSENTRY32 lppe;
    AnsiString FileName;
    lppe.dwSize = sizeof( PROCESSENTRY32 );// Indicamos el tamaño de la estructura antes de usarla
    if (!Process32First(hnd,&lppe))
            {
            Application->MessageBox("Cannot access processes","Error",MB_APPLMODAL);
            CloseHandle(hnd);
            Start->Enabled=false;
            Stop->Enabled=false;
            Borrar->Enabled=false;
            Monitor->Enabled=false;
            return;
            }
    else
            {
            FileName=ExtractFileName(AnsiString(lppe.szExeFile));
            if (FileName!="SNAPS_Eval.exe")
                    {
                    while (Process32Next(hnd,&lppe))
                            {
                            FileName=ExtractFileName(AnsiString(lppe.szExeFile));
                            if (FileName=="SNAPS_Eval.exe")
                            break;
                            }
                    }
            }
    if (FileName!="SNAPS_Eval.exe")
            {
            Application->MessageBox("SNAPS_Eval.exe must be running!","Warning",MB_APPLMODAL);
            CloseHandle(hnd);
            Start->Enabled=false;
            Stop->Enabled=false;
            Borrar->Enabled=false;
            Monitor->Enabled=false;
            return;
            }
    // A estas alturas ya tengo el identificador del proceso  y puede ver la lista de threads asociados
    CloseHandle(hnd);
    HANDLE hnd2 = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD,lppe.th32ProcessID);
    if (hnd2 == INVALID_HANDLE_VALUE)
            {
            Application->MessageBox("Cannot get SNAPS process threads list","Error",MB_APPLMODAL);
            CloseHandle(hnd2);
            Start->Enabled=false;
            Stop->Enabled=false;
            Borrar->Enabled=false;
            Monitor->Enabled=false;
            return;
            }
    THREADENTRY32 ltr;
    ltr.dwSize=sizeof(THREADENTRY32);//Asigno el tamaño antes de usar la estructura
    Thread32First(hnd2,&ltr);
    DWORD thread_id=ltr.th32ThreadID;
    CloseHandle(hnd2);
    SNAPS = OpenThread(THREAD_ALL_ACCESS,FALSE,thread_id);
    //Obtengo el handle a SNAPS_Eval.exe con todos los derechos
    if (SNAPS==INVALID_HANDLE_VALUE)
            {
            Application->MessageBox("Cannot access thread","Error",MB_APPLMODAL);
            Start->Enabled=false;
            Stop->Enabled=false;
            Borrar->Enabled=false;
            Monitor->Enabled=false;
            return;
            }
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
    {
    Action=caFree;
    CloseHandle(SNAPS);

    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::StopClick(TObject *Sender)
    {
    centinela=false;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::BorrarClick(TObject *Sender)
    {
    Monitor->Items->Clear();
    }
    //---------------------------------------------------------------------------


    jueves, 22 de abril de 2010 10:55
  • Poder se puede. Pero esta OFF TOPIC

    Un poco de ayuda FAST FOOD!

    http://code2code.net/

    De todos modos te recomiendo ver esta pagina, aqui encontraras mucho de trabajo sobre hard y soft en Visual Studio.

    http://hackaday.com/ Hace un tiempo ya habian preparado algo similar a lo que pides. Buscalo tu mismo.

    Saludos y happy convertion!


    MCTS - MCP - MST - New Technologies Evangelist
    jueves, 29 de abril de 2010 22:52