FLOAT TO VARIANT

Version imprimable

15/06/2009, 09h37
julien25

FLOAT TO VARIANT

Bonjour à tous,

J'aimerais pour une application OPC convertir un FLOAT en VARIANT, est ce possible?

Merci beaucoup.
15/06/2009, 09h52
buzzkaido

Oui, c'est possible.

ça depend de comment sont implementés tes VARIANTS.

Les VARIANTS, c'est juste une technique, différentes bibliothèques l'implémentent de différentes façons.

Il y a boost::variant dans Boost
Il y a QVariant dans Qt
Il y a ...
15/06/2009, 10h17
melleb
Salut,

OPC utilise les variables de type tagVARIANT
pour utiliser un float, il faut définir le type :
Code:

1 2 3 tagVARIANT maVariableFlottante; maVariableFlottante.vt = VT_R4;
ensuite, tu affectes la valeur dans le champ correspondant aux flottants :

Code:

maVariableFlottante.fltVal = 123.456;

Tu trouveras la définition de la structure tagVARIANT dans le fichier oaidl.h (dans les répertoires de visual studio normalement...)

Ok donc pour mon cas ca devrait donner ca ?
Ja' besoin de votre avis car je ne peux pas faire de run pour le moment, mais au build tout semble correct.

En fait non ca plante....

Merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Python return a value which is a Python Object
            // To Send in OPC, we need a VARIANT
            tagVARIANT maVariableFlottante;
            maVariableFlottante.vt = VT_R4;
 
           // je fait la conversion pointervar de typen PyObject en "f"
            PyArg_Parse(pointervar, "f",&maVariableFlottante.vt);
 
 
            // Create the group
            // By default, the name of the group is Group_Opc
            COPCGroup* MyGroupOPC = GetGroup(opc, "Group_Opc");
 
            // write to OPC the value of Python
            MyGroupOPC->addItem(NodePath, true)->writeSync(maVariableFlottante);

15/06/2009, 10h36
Goten

tagVariant c'est du microsoft pure et dur. (je connaissais pas). Donc niveau portabilité y'a mieux. (boost::variant comme cité plus haut).

D'ailleurs après recherche :

Citation:

This class supports the .NET Framework infrastructure and is not intended to be used directly from your code.

http://msdn.microsoft.com/fr-fr/library/tagvariant.aspx

ça serait pas plutôt ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Python return a value which is a Python Object
            // To Send in OPC, we need a VARIANT
            tagVARIANT maVariableFlottante;
            maVariableFlottante.vt = VT_R4;

           // je fait la conversion pointervar de typen PyObject en "f"
            PyArg_Parse(pointervar, "f",&maVariableFlottante.fltVal);
            
            
            // Create the group
            // By default, the name of the group is Group_Opc
            COPCGroup* MyGroupOPC = GetGroup(opc, "Group_Opc");

            // write to OPC the value of Python
            MyGroupOPC->addItem(NodePath, true)->writeSync(maVariableFlottante);

à moins que tu ais fait une erreur de recopie...

15/06/2009, 10h52
julien25

Oui effectivement ca serait plutôt ce que tu dis, et le plantage venait de toute façon d'ailleurs.
Je vous retiens au courant sous peu,
En attendant merci;)
Julien
15/06/2009, 12h31
Médinoc

Je recommande d'utiliser directement le typedef VARIANT plutôt que la structure tagVARIANT sous-jacente...

Bon ça à l'air de fonctionner pour un float,
J'ai aussi besoin d'effectuer le même traitement pour un Int et un String.
Je ne connais pas du tout les conversions avec ce type d'éléments.
Merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
            tagVARIANT monstring;
            monstring...=..;
 
           // je fait la conversion pointervar de typen PyObject en "f"
            PyArg_Parse(pointervar, "s",&maVariableFlottante.IVal);
 
 
            // Create the group
            // By default, the name of the group is Group_Opc
            COPCGroup* MyGroupOPC = GetGroup(opc, "Group_Opc");
 
            // write to OPC the value of Python
            MyGroupOPC->addItem(NodePath, true)->writeSync(maVariableFlottante);

16/06/2009, 08h47
Goten

Comme dis par médinoc et moi même implicitement utilise VARIANT (c'est un typedef) plutôt que tagVariant qui n'est pas fait pour être utilisé dans un code final.

Ok pour le typedef VARIANT plutôt que tagVARIANT
Mais je suis tout de même obligé de faire la conversion
Si je reprend mon code initial on a :

Pour un string et un int connaissez vous les conversions?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Python return a value which is a Python Object
            // To Send in OPC, we need a VARIANT
            VARIANT maVariableFlottante;
            maVariableFlottante.vt = VT_R4;

           // je fait la conversion pointervar de typen PyObject en "f"
            PyArg_Parse(pointervar, "f",&maVariableFlottante.fltVal);
            
            
            // Create the group
            // By default, the name of the group is Group_Opc
            COPCGroup* MyGroupOPC = GetGroup(opc, "Group_Opc");

            // write to OPC the value of Python
            MyGroupOPC->addItem(NodePath, true)->writeSync(maVariableFlottante);

16/06/2009, 09h14
Médinoc
J'ai posté ailleurs pour les strings (utiliser une BSTR).
Pour les int, c'est VT_I4 :
Code:

1 2 3 4 5 int monEntier = ... ; VARIANT var; VariantInit(&var); V_VT(&var) = VT_I4; V_IA(&var) = monEntier;
16/06/2009, 09h51
melleb

eheh,
moi aussi ça m'intéresse ;)

pour les chaines de caractères, c'est là

quelles sont les fonctions du type V_IA, V_BSTR mais pour les int, les float, les bool, les short?...
où trouve-t-on leur définition?
j'ai cherché mais trouve pas:(
16/06/2009, 10h09
Goten

http://msdn.microsoft.com/en-us/library/ms221627.aspx

En bas y'a le tableau des correspondances.
16/06/2009, 10h12
Médinoc
Ce ne sont pas des fonctions mais des macros, en fait.

C'est simple, c'est le même nom que pour les constantes VT_*, sans le "T".
- VT_I4 et V_I4 pour int (32 bits)
- VT_R4 et V_R4 pour float (32 bits)
- VT_R8 et V_R8 pour double (64 bits)
- VT_BOOL et V_BOOL pour les booléens (attention, utiliser VARIANT_TRUE et VARIANT_FALSE, pas 1 et 0)
- VT_I2 et V_I2 pour les short (16 bits)
- type + VT_BYREF pour les pointeurs, avec par exemple V_I4REF pour un pointeur sur int.
Apparemment, il n'y a pas d'aide sur les macros, mais leurs définitions sont dans <OleAuto.h>. Pour les constantes de types, tu peux les trouver dans l'aide, et leur définition est dansWTypes.h.

Juste un truc à propos des char: Pour des raisons de compatibilité, la constante de type VT_I1 désigne en vérité le type OLECHAR, qui est un wchar_t. Il n'existe plus de type char ou signed char dans les variants. Par contre, la constante VT_UI1 désigne toujours un unsigned char (ou "byte").
16/06/2009, 10h23
melleb

yeah,:ccool:
merci Médinoc :zoubi:
17/06/2009, 12h07
julien25

Merci à tous, c'est impeccable. ;)