Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 19
  1. #1
    Utente di HTML.it
    Registrato dal
    Jun 2010
    Messaggi
    20

    [VB6] Passaggio parametri a dll C

    Ciao a tutti, è la prima volta che scrivo quindi spero di aver postato nella sezione giusta.

    Avrei un problema con VB6.
    Devo creare una'applicazione che si interfaccia con una DLL scritta in C.

    La dll è già pronta, testata e le funzioni vengono esportate correttamente.

    In questa dll ho definito un tipo:

    codice:
    typedef struct Cuscinetto
    {
    
    int F2L_avg_counter;
    double F2L_X_SUM[CAMPIONI_DESIDERATI], F2L_Y_SUM[CAMPIONI_DESIDERATI], F2L_Z_SUM[CAMPIONI_DESIDERATI];
    double F2_Golden_X[CAMPIONI_DESIDERATI], F2_Golden_Y[CAMPIONI_DESIDERATI], F2_Golden_Z[CAMPIONI_DESIDERATI];
    
    
    int F2_SM_curr_x, F2_SM_next_x;
    int F2_SM_curr_y, F2_SM_next_y;
    int F2_SM_curr_z, F2_SM_next_z;
    
    
    int F2_counter_x;
    int F2_counter_y;
    int F2_counter_z;
    
    
    int F2_SM_curr, F2_SM_next;
    
    
    int F2_OK_counter, F2_WRN_counter, F2_DMG_counter;
    
    
    
    int F3L_avg_counter; // Contatore per la media della fase 1->3
    
    double F3L_X_SUM[FFNUMBER], F3L_Y_SUM[FFNUMBER], F3L_Z_SUM[FFNUMBER];
    double F3_Golden_X[FFNUMBER], F3_Golden_Y[FFNUMBER], F3_Golden_Z[FFNUMBER];
    
    
    
    double F3_AVG_BUFFER_X [F3_AVG_BUFFER_LENGTH][FFNUMBER];
    
    int F3_Buffer_Idx_X;
    
    double F3_AVG_BUFFER_Y [F3_AVG_BUFFER_LENGTH][FFNUMBER];
    
    int F3_Buffer_Idx_Y;
    
    double F3_AVG_BUFFER_Z [F3_AVG_BUFFER_LENGTH][FFNUMBER];
    
    int F3_Buffer_Idx_Z;
    
    double sum_x[FFNUMBER];
    double sum_y[FFNUMBER];
    double sum_z[FFNUMBER];
    
    
    int F3_SM_curr_x_C, F3_SM_next_x_C;
    int F3_SM_curr_x_OR, F3_SM_next_x_OR;
    int F3_SM_curr_x_IR, F3_SM_next_x_IR;
    int F3_SM_curr_x_B, F3_SM_next_x_B;
    int F3_counter_x_C;
    int F3_counter_x_OR;
    int F3_counter_x_IR;
    int F3_counter_x_B;
    int F3_SM_curr_y_C, F3_SM_next_y_C;
    int F3_SM_curr_y_OR, F3_SM_next_y_OR;
    int F3_SM_curr_y_IR, F3_SM_next_y_IR;
    int F3_SM_curr_y_B, F3_SM_next_y_B;
    int F3_counter_y_C;
    int F3_counter_y_OR;
    int F3_counter_y_IR;
    int F3_counter_y_B;
    int F3_SM_curr_z_C, F3_SM_next_z_C;
    int F3_SM_curr_z_OR, F3_SM_next_z_OR;
    int F3_SM_curr_z_IR, F3_SM_next_z_IR;
    int F3_SM_curr_z_B, F3_SM_next_z_B;
    int MAIN_SM_curr;
    int MAIN_SM_next;
    int F3_counter_z_C;
    int F3_counter_z_OR;
    int F3_counter_z_IR;
    int F3_counter_z_B;
    int F3_SM_curr_C, F3_SM_next_C;
    int F3_SM_curr_OR, F3_SM_next_OR;
    int F3_SM_curr_IR, F3_SM_next_IR;
    int F3_SM_curr_B, F3_SM_next_B;
    int F3_counter_C_OK;
    int F3_counter_OR_OK;
    int F3_counter_IR_OK;
    int F3_counter_B_OK;
    int F3_counter_C_WRN;
    int F3_counter_OR_WRN;
    int F3_counter_IR_WRN;
    int F3_counter_B_WRN;
    int F3_counter_C_DMG;
    int F3_counter_OR_DMG;
    int F3_counter_IR_DMG;
    int F3_counter_B_DMG;
    int MAIN_SM_pkt_counter;
    int MAIN_SM_window_counter;
    int MAIN_SM_last_ret;
    
    char packet[DATIPACCH];
    double MAIN_x[CAMPIONI_DESIDERATI];
    double MAIN_y[CAMPIONI_DESIDERATI];
    double MAIN_z[CAMPIONI_DESIDERATI];
    
    
    double statFirValues_X[FIR_TAP_NUMBER], statFirValues_Y[FIR_TAP_NUMBER], statFirValues_Z[FIR_TAP_NUMBER];
    
    double F2L_X_TH;
    double F2L_Y_TH;
    double F2L_Z_TH;
    
    
    double C_THRESHOLD;
    double OR_THRESHOLD;
    double IR_THRESHOLD;
    double B_THRESHOLD;
    
    double DB;
    double DP;
    double NB;
    
    double TETA;
    
    double temperature[CAMPIONI_DESIDERATI];
    unsigned int temperature_cnt;
    
    }bearing;
    Ora, lavorando su VB6 mi son trovato a dover replicare la struttura e l'ho fatta così:


    codice:
    Public Type Bearing
    F2L_avg_counter As Long
    F2L_X_SUM(CAMPIONI_DESIDERATI) As Double
    F2L_Y_SUM(CAMPIONI_DESIDERATI) As Double
    F2L_Z_SUM(CAMPIONI_DESIDERATI) As Double
    F2_Golden_X(CAMPIONI_DESIDERATI) As Double
    F2_Golden_Y(CAMPIONI_DESIDERATI) As Double
    F2_Golden_Z(CAMPIONI_DESIDERATI) As Double
    
    F2_SM_curr_x As Long
    F2_SM_next_x As Long
    F2_SM_curr_y As Long
    F2_SM_next_y As Long
    F2_SM_curr_z As Long
    F2_SM_next_z As Long
    
    F2_counter_x As Long
    F2_counter_y As Long
    F2_counter_z As Long
    F2_SM_curr As Long
    F2_SM_next As Long
    
    F2_OK_counter As Long
    F2_WRN_counter As Long
    F2_DMG_counter As Long
    
    F3L_avg_counter As Long
    F3L_X_SUM(FFNUMBER) As Double
    F3L_Y_SUM(FFNUMBER) As Double
    F3L_Z_SUM(FFNUMBER) As Double
    F3_Golden_X(FFNUMBER) As Double
    F3_Golden_Y(FFNUMBER) As Double
    F3_Golden_Z(FFNUMBER) As Double
    
    F3_AVG_BUFFER_X(F3_AVG_BUFFER_LENGTH, FFNUMBER) As Double
    F3_Buffer_Idx_X As Long
    F3_AVG_BUFFER_Y(F3_AVG_BUFFER_LENGTH, FFNUMBER) As Double
    F3_Buffer_Idx_Y As Long
    F3_AVG_BUFFER_Z(F3_AVG_BUFFER_LENGTH, FFNUMBER) As Double
    F3_Buffer_Idx_Z As Long
    
    sum_x(FFNUMBER) As Double 'Somma dei picchi x fare le medie
    sum_y(FFNUMBER) As Double 'Somma dei picchi x fare le medie
    sum_z(FFNUMBER) As Double 'Somma dei picchi x fare le medie
    
    F3_SM_curr_x_C As Long
    F3_SM_next_x_C As Long
    F3_SM_curr_x_OR As Long
    F3_SM_next_x_OR As Long
    F3_SM_curr_x_IR As Long
    F3_SM_next_x_IR As Long
    F3_SM_curr_x_B As Long
    F3_SM_next_x_B As Long
    F3_counter_x_C As Long
    F3_counter_x_OR As Long
    F3_counter_x_IR As Long
    F3_counter_x_B As Long
    F3_SM_curr_y_C As Long
    F3_SM_next_y_C As Long
    F3_SM_curr_y_OR As Long
    F3_SM_next_y_OR As Long
    F3_SM_curr_y_IR As Long
    F3_SM_next_y_IR As Long
    F3_SM_curr_y_B As Long
    F3_SM_next_y_B As Long
    F3_counter_y_C As Long
    F3_counter_y_OR As Long
    F3_counter_y_IR As Long
    F3_counter_y_B As Long
    F3_SM_curr_z_C As Long
    F3_SM_next_z_C As Long
    F3_SM_curr_z_OR As Long
    F3_SM_next_z_OR As Long
    F3_SM_curr_z_IR As Long
    F3_SM_next_z_IR As Long
    F3_SM_curr_z_B As Long
    F3_SM_next_z_B As Long
    MAIN_SM_curr As Long
    MAIN_SM_next As Long
    F3_counter_z_C As Long
    F3_counter_z_OR As Long
    F3_counter_z_IR As Long
    F3_counter_z_B As Long
    F3_SM_curr_C As Long
    F3_SM_next_C As Long
    F3_SM_curr_OR As Long
    F3_SM_next_OR As Long
    F3_SM_curr_IR As Long
    F3_SM_next_IR As Long
    F3_SM_curr_B As Long
    F3_SM_next_B As Long
    F3_counter_C_OK As Long
    F3_counter_OR_OK As Long
    F3_counter_IR_OK As Long
    F3_counter_B_OK As Long
    F3_counter_C_WRN As Long
    F3_counter_OR_WRN As Long
    F3_counter_IR_WRN As Long
    F3_counter_B_WRN As Long
    F3_counter_C_DMG As Long
    F3_counter_OR_DMG As Long
    F3_counter_IR_DMG As Long
    F3_counter_B_DMG As Long
    MAIN_SM_pkt_counter As Long
    MAIN_SM_window_counter As Long
    MAIN_SM_last_ret As Long
    
    packet(DATIPACCH) As Long
    MAIN_x(CAMPIONI_DESIDERATI) As Double
    MAIN_y(CAMPIONI_DESIDERATI) As Double
    MAIN_z(CAMPIONI_DESIDERATI) As Double
    statFirValues_X(FIR_TAP_NUMBER) As Double
    statFirValues_Y(FIR_TAP_NUMBER) As Double
    statFirValues_Z(FIR_TAP_NUMBER) As Double
    
    F2L_X_TH As Double
    F2L_Y_TH As Double
    F2L_Z_TH As Double
    
    
    C_THRESHOLD As Double
    OR_THRESHOLD As Double
    IR_THRESHOLD As Double
    B_THRESHOLD As Double
    
    
    DB As Double
    DP As Double
    NB As Double
    TETA As Double
    
    temperature(CAMPIONI_DESIDERATI) As Double
    temperature_cnt As Long
    
    
    End Type
    In VB creo un array di bearing e fin qui nessun problema.
    Sto creando l'interfaccia grafica che sfrutterà la dll per la parte di calcolo e alcune funzioni funzionano correttamente, per esempio ho una funzione in C così definita:

    codice:
    int _stdcall Param_Load(bearing *curr_bearing, double F2L_X_TH, double F2L_Y_TH, double F2L_Z_TH, double C_THRESHOLD, double OR_THRESHOLD,double IR_THRESHOLD,double B_THRESHOLD, double DB, double DP, double NB, double TETA);
    che copia semplicemente i valori passati come parametro nelle rispettive variabili di currbearing, da VB passo l'oggetto di tipo bearing per riferimento e funziona perfettamente.

    Questa è la dichiarazione della funzione:

    codice:
    Public Declare Function Param_Load Lib "C:\Documents and Settings\Ale\Desktop\GUI\SKF_Multi.dll" (ByRef curr_bearing As Bearing, ByVal F2L_X_TH As Double, ByVal F2L_Y_TH As Double, ByVal F2L_Z_TH As Double, ByVal C_THRESHOLD As Double, ByVal OR_THRESHOLD As Double, ByVal IR_THRESHOLD As Double, ByVal B_THRESHOLD As Double, ByVal DB As Double, ByVal DP As Double, ByVal NB As Double, ByVal TETA As Double) As Integer

    E questa è la chiamata:


    codice:
    Call Param_Load(tmpbear, F2L_X_TH, F2L_Y_TH, F2L_Z_TH, C_THRESHOLD, OR_THRESHOLD, IR_THRESHOLD, B_THRESHOLD, DB, DP, NB, TETA)
    dove tmpbear è una variabile temporanea, che una volta inizializzata con Param_load viene copiata in un vettore.



    A questo punto mi trovo a dover usare un'altra funzione, ecco il prototipo in C:

    codice:
    int _stdcall F2_SetGolden(double *g_x, double *g_y, double *g_z, bearing *curr_bearing);
    ciò che deve fare è semplicemente prendere i valori dei vettori g_x, g_y e g_z e copiarli nei vettori curr_bearing->F2_Golden_X, curr_bearing->F2_Golden_Y e curr_bearing->F2_Golden_Z
    è quindi una funzione molto stupida con un semplice iclo for all'interno.

    In VB l'ho importata così:

    codice:
    Public Declare Function F2_SetGolden Lib "C:\Documents and Settings\Ale\Desktop\GUI\SKF_Multi.dll" (ByRef g_x As Double, ByRef g_y As Double, ByRef g_z As Double, ByRef curr_bearing As Bearing) As Integer
    e la richiamo così:
    codice:
    Call F2_SetGolden(g_x(0), g_y(0), g_z(0), CONF_BEARINGS(0))
    CONF_BEARINGS è il vettore di bearing di cui parlavo prima. In questo caso mi interessa il primo elemento, in altri passerò altri elementi.

    Il problema che è è che la copia non funziona, per provare ho inizializzato g_X con i valori 1 2 3 4 5 ecc
    ma dopo l'esecuzione della funzione CONF_BEARINGS(0).F2_Golden_X ha valori insensati come 5.0134563457451-34

    Ho pensato che il problema potessero essere i vettori g_x, g_y e g_z visto che nella funzione Param_Load il passaggio di un oggetto di tipo bearing funzionava.
    Per togliermi il dubbio ho modificato la funzione nella dll facendo in modo che copiasse il contenuto di g_x in g_y e questa ha funzionato perfettamente. Credo il problema stia quindi nel tipo bearing.
    Qualcuno sa darmi una dritta per risolvere questo problema?


    Scusate se ho scritto un poema inserendo magari cose inutili, ma vi ho scritto praticamente tutto ciò che ho fatto per evitare di vedermi consigliare strade già provate.

    Grazie mille in anticipo


    Apo

  2. #2
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,480
    E' possibile che sia un problema di allineamento delle strutture. Prova a ricompilare la DLL, inserendo all'inizio

    #pragma pack(4)
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  3. #3
    Utente di HTML.it
    Registrato dal
    Jun 2010
    Messaggi
    20
    No cioè...io ti adoro!!! Effettivamente la funzione ora funziona come si deve!!!

    Però mi salta fuori un altro problema....

    Non funziona più la funzione Param_Load, nel senso che scrive i valor che passo come parametri in variabili sbagliate. Ora provo a capire il perchè.

    Scusa l'ignoranza... ma potresti spiegarmi a che serve

    #pragma pack(4)

    giusto per sapere che cosa ho fatto e magari la prossima volta ci arrivo subito!

    Grazie!

  4. #4
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,480
    Il compilatore C/C++, per default, allinea i membri delle strutture in memoria utilizzando 8 byte, il VB6 usa il default di 4 byte.

    In certi casi, a secondo di come è fatta la struttura, si potrebbero manifestare i problemi che hai avuto.

    Se indichi al compilatore C/C++ di utilizzare l'allineamento a 4 byte (come fa VB6) tutto va a posto.

    Per l'altro problema, mi sembra che la Param_Load restituisca un int mentre quella in VB6 restituisce un Integer (dovrebbe essere un Long).
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  5. #5
    Utente di HTML.it
    Registrato dal
    Jun 2010
    Messaggi
    20
    Ok, succede una cosa davvero strana!

    questa è la mia funzione in C
    codice:
    int _stdcall Param_Load(bearing *curr_bearing, double F2L_X_TH, double F2L_Y_TH, double F2L_Z_TH, double C_THRESHOLD, double OR_THRESHOLD,double IR_THRESHOLD,double B_THRESHOLD, double DB, double DP, double NB, double TETA)
    {
    	curr_bearing->F2L_X_TH = F2L_X_TH;
    	curr_bearing->F2L_Y_TH = F2L_Y_TH;
    	curr_bearing->F2L_Z_TH = F2L_Z_TH;
    
    	curr_bearing->C_THRESHOLD = C_THRESHOLD;
    	curr_bearing->OR_THRESHOLD = OR_THRESHOLD;
    	curr_bearing->IR_THRESHOLD = IR_THRESHOLD;
    	curr_bearing->B_THRESHOLD = B_THRESHOLD;
    
    	curr_bearing->DB = DB;
    	curr_bearing->DP = DP;
    	curr_bearing->NB = NB;
    	
    	// Passare il parametro in GRADI!!!!!!!!!!!
    	curr_bearing->TETA = TETA * 3.141592654 /180;
    
    	return 0;
    }
    è una funzione molto semplice quindi trovo strano si comporti in maniera così strana.

    In VB la importo così:
    codice:
    Public Declare Function Param_Load Lib "C:\Documents and Settings\Ale\Desktop\GUI\SKF_Multi.dll" (ByRef curr_bearing As Bearing, ByVal F2L_X_TH As Double, ByVal F2L_Y_TH As Double, ByVal F2L_Z_TH As Double, ByVal C_THRESHOLD As Double, ByVal OR_THRESHOLD As Double, ByVal IR_THRESHOLD As Double, ByVal B_THRESHOLD As Double, ByVal DB As Double, ByVal DP As Double, ByVal NB As Double, ByVal TETA As Double) As Long
    La chiamo così:
    codice:
    Call Gvar.Param_Load(tmpbear, F2L_X_TH, F2L_Y_TH, F2L_Z_TH, C_THRESHOLD, OR_THRESHOLD, IR_THRESHOLD, B_THRESHOLD, DB, DP, NB, TETA)
    i valori dei vari parametri sono:
    F2L_X_TH = 25
    F2L_Y_TH = 35
    F2L_Z_TH = 30
    C_THRESHOLD = 6
    OR_THRESHOLD = 16
    IR_THRESHOLD = 12
    B_THRESHOLD = 8
    DB = 9.525
    DP = 90
    NB = 25
    TETA = 15

    Quando devo chiamarla leggo da file i valori dei vari parametri, ho controllato ed effettivamente vengono letti in maniera corretta.
    Dopo l'esecuzione della funzione ottengo questo:
    F2L_X_TH = 30
    F2L_Y_TH = 6
    F2L_Z_TH = 16
    C_THRESHOLD = 12
    OR_THRESHOLD = 8
    IR_THRESHOLD = 9.525
    B_THRESHOLD = 90
    DB = 25
    DP = 0.2167 (la conversione di TETA in radianti)
    NB = 0 rimane a 0 perchè all'inizio inizializzo tutto a 0)
    TETA = 0 (sempre per l'inizializzazione)


    I valori Scritti son quelli corretti ( a parte che scompaiono il valore di F2L_Y_TH e uno dei due parametri che valgono 25 cioè F2L_X_TH o NB), ma sembra che la dll non capisca in quali campi debba andare a scrivere i valori. Così a naso mi semmbra possa essere un problema analogo al precedente...

    Quando cercavo su internet come tradurre la mia struttura C in VB sul sito della microsoft (http://support.microsoft.com/kb/106553/it) avevo letto che i corrispettivi in VB degli int del C sono gli integer, io ho usato i Long perchè su un altro sito (http://www.visual-basic.it/articoli/agVB_VC.htm) dice di usare i Long.
    Per sfizio ho provato a trasformare tutti i Long in Integer pensando che magari se i campi della struttura hanno lunghezza diverse il C non riesce a riconoscere correttamente nemmeno gli altri (ovvero i double della mia funzione)... il risultato è stato che con gli Integer Param_Load non fa assolutamente nulla (i parametri rimangono tutti a 0).... FAIL!

    Per inciso la F2_SetGolden ora funziona da Dio in entrambi i casi...per la serie "almeno di qualcosa possiamo gioire"

  6. #6
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,480
    Originariamente inviato da Apoman
    Quando cercavo su internet come tradurre la mia struttura C in VB sul sito della microsoft (http://support.microsoft.com/kb/106553/it) avevo letto che i corrispettivi in VB degli int del C sono gli integer
    Ma non hai letto ...

    Le informazioni in questo articolo si applicano a:
    Microsoft Visual Basic 3.0 Professional Edition

    io ho usato i Long perchè su un altro sito (http://www.visual-basic.it/articoli/agVB_VC.htm) dice di usare i Long.
    E hai fatto bene ... il mio articolo è corretto ...


    Purtroppo hai usato i tag <CODE> e non quelli corretti con le parentesi quadre [ ] ...
    Puoi correggere in modo che si legga bene il codice?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  7. #7
    Utente di HTML.it
    Registrato dal
    Jun 2010
    Messaggi
    20
    ...che scemo! Abituato all'html ho messo i <>... ora ho corretto.

    E così l'articolo era tuo... beh allora ti devo un altro paio di grazie per l'aiuto involontario che mi ha dato quell'articolo!

    E comunque il

    Le informazioni in questo articolo si applicano a:
    Microsoft Visual Basic 3.0 Professional Edition

    non l'avevo letto... che scemo!

  8. #8
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,480
    Per darti un aiuto concreto, evitando continue domande/risposte per debuggare "a distanza", ti sarebbe possibile farmi scaricare i sorgenti dei progetti per fare una prova dal vivo?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  9. #9
    Utente di HTML.it
    Registrato dal
    Jun 2010
    Messaggi
    20
    Si, come faccio però? E' possibile allegare solo immagini al messaggio? se mi dai una mail te li spedisco

  10. #10
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,480
    Mettili su un sito (tipo rapidshare) e inviami il link per PM. Ti posterò una risposta (positiva o negativa) nel forum ...
    No MP tecnici (non rispondo nemmeno!), usa il forum.

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.