[C || C++ @ Windows] Aprire porta USB per trasmettere segnali

[oregon]

Originariamente inviato da alde90
Mi spieghi meglio cosa intendi? A quanto dicono, loro suppliscono un driver che fa vedere questo adattatore come una porta seriale normale, quindi penso si possa usare i comandi Windows per aprirla e scriverci sopra, compreso impostare il baud rate o no???

Scusa per l'incessante sfilza di domande, ma sono cose che si fanno fatica a trovare da soli

Sì ... tutto giusto. Ma dopo che imposti il baud rate e la apri, come invii i dati secondo lo standard DMX? Sai come farlo?

[alde90]

Bè, cercando in giro ho trovato questo

In breve, a quel che ho capito CreateFile, dentro la quale definisco la porta (esempio, la porta "COM1") e scrivo i byte usando la WriteFile.
Questa è l'idea di base, devo rifinire bene i passaggi per adattarmi allo standard DMX e fare le prove del caso, nel caso riesca posto subito la soluzione, visto quanto mi ha fatto diventare matto (mi è venuto in mente ora che ci sarebbe la possibilità di usare direttamente USB-> DMX, ma visto che direi costa troppo un convertitore, penso vada bene questa strada )

PS: nel primo link c'è in fondo un esempio molto chiaro di come aprire device in Windows, un po' di esempi non guastano mai

[oregon]

Sì ... aprire e scrivere su seriale non mi pare un problema (CreateFile, SetCommState, WriteFile ...), però, ad esempio, i baud rate possibili sono

CBR_128000
CBR_256000

e quindi non capisco come tu possa generare i tuoi 250 kbit ...

[alde90]

Infatti è giusto una domanda che mi stavo facendo cinque minuti fa, e sembra non ci sia soluzione porco cavolo, speravo di poter impostare direttamente il baud rate che mi pareva, ma a quanto pare all'hardware non piace questa soluzione...quindi penso che per forza di cose bisogna prendere un adattatore USB->DMX, non c'è altro modo, altrimenti mi sfasano troppo i canali...

Peccato, stava venendo fuori qualcosa di interessante

Grazie del tuo aiuto oregon, almeno questo è servito per capire un qualcosa di più sulle comunicazioni da pc all'esterno
casomai aprirò un altro thread per connettersi direttamente al dispositivo USB->DMX, ma penso che userò i programmi già fatti :P

comunque, posto come usare una "classe" (meglio file, visto che si parla di C) di collegamento seriale (almeno sento di aver fatto qualcosa di utile dopo tutto questo casino )

comport.h

#ifndef _COMPORT_H
#define _COMPORT_H

#include <windows.h>
#include <string.h>

BOOL  openComPort  (const char* port);

void  closeComPort (void);

DWORD sendData     (char* data, DWORD size);

DWORD receiveData  (char* data, DWORD size);

#endif /* _COMPORT_H */

comport.c

#include "comport.h"

static HANDLE _hCom;


BOOL openComPort (const char* port)
{
    char buildStr[50];
    DCB dcb;
    COMMTIMEOUTS timeouts = {0};


    _hCom = CreateFile(port,
                       GENERIC_READ,
                       0,
                       0,
                       OPEN_EXISTING,
                       0,
                       0);

    if (_hCom == INVALID_HANDLE_VALUE)
    {
        _hCom = NULL;
        return FALSE;
    }

    /* set timeouts */
    timeouts.ReadTotalTimeoutConstant    = 100;
    timeouts.ReadTotalTimeoutMultiplier  = 0;
    timeouts.WriteTotalTimeoutMultiplier = 0;
    timeouts.WriteTotalTimeoutConstant   = 0;
    if (SetCommTimeouts(_hCom, &timeouts) == FALSE)
        return FALSE;

    dcb.DCBlength = sizeof(DCB);
    if (GetCommState(_hCom, &dcb) == FALSE)
        return FALSE;

    dcb.BaudRate = CBR_128000;
    dcb.Parity = FALSE;
    dcb.StopBits = TWOSTOPBITS;
    dcb.ByteSize = 8;
    dcb.fOutX = FALSE;
    dcb.fInX = FALSE;
    dcb.fErrorChar = FALSE;
    dcb.fBinary = TRUE;
    dcb.fRtsControl = FALSE;
    dcb.fAbortOnError = FALSE;

    return SetCommState(_hCom, &dcb);
}


void closeComPort(void)
{
    CloseHandle(_hCom);
}


DWORD sendData (char* data, DWORD size)
{
    DWORD numberOfBytesWritten;

    WriteFile(_hCom,
              data,
              size,
              &numberOfBytesWritten,
              0);

    return numberOfBytesWritten;
}


DWORD receiveData (char* data, DWORD size)
{
    DWORD numberOfBytesRead;

    ReadFile(_hCom,
             data,
             size,
             &numberOfBytesRead,
             0);

    return numberOfBytesRead;
}