Discussion :

[julien25]

Bonjour à tous,

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

Merci beaucoup.

[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 ...

[melleb]

Salut,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
tagVARIANT maVariableFlottante;
 
maVariableFlottante.vt = VT_R4;

ensuite, tu affectes la valeur dans le champ correspondant aux flottants :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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...)

[julien25]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

[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 :

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

[melleb]

ça serait pas plutôt ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

[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

[Médinoc]

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

[julien25]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

[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.

[julien25]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

[Médinoc]

J'ai posté ailleurs pour les strings (utiliser une BSTR).
Pour les int, c'est VT_I4 :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
int monEntier = ... ;
VARIANT var;
VariantInit(&var);
V_VT(&var) = VT_I4;
V_IA(&var) = monEntier;

[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

[Goten]

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


En bas y'a le tableau des correspondances.

[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").

[melleb]

yeah,
merci Médinoc

[julien25]

Merci à tous, c'est impeccable.