Utilisation de librairie en C

Version imprimable

09/02/2015, 14h57
Anonyme5571

Utilisation de librairie en C

Bonjour;
J'aimerais savoir si quelqu’un c'est comment utiliser des librairies qui sont écrites en C pour les utiliser avec node.js car je ne trouve pas beaucoup d'exemples sur internet...en gros j'ai un fichier .h qui contient des fonctions que j'aimerais pouvoir utiliser avec node, j'ai aussi un fichier .dll que s’utilisait pour faire fonctionner mes fonctions en VB.
Merci d'avance pour vos réponses.
10/02/2015, 18h22
p3ga5e

Salut !

Pour utiliser une lib c tu devras passer par l’écriture d’un addons C/C++ te permettant l’interopérabilité entre ta lib C et le javascript.
Donc première étape : recompile les addons C/C++ du ce TUTO, tu devras installer Visual Studio Express, peut-être python et bidouiller tes variables d’environnements.
Ensuite tu pourras ajouter des librairies externes a ton addon grace au fichier binding.gyp .

La partie la plus difficile étant l'utilisation de la libUV qui permet d'exposer une fonction C synchrone en une fonction JavaScript Asynchrone
11/02/2015, 09h05
Anonyme5571
Merci pour ta réponse, tu n'aurais pas un exemple en C car dans le tuto que tu ma donner c'est en C++ et je ne connais pas du tout le C++ donc je n'arrive pas à faire ce que je veut...
Voilà la librairie que je veut me servir AnaGate CAN API Library für Windows (32/64 bit) dans ce fichier j'ai trois .h, .dll et .lib donc si j'ai bien comprit j'ajoute dans mon code en C les #include pour utiliser mes librairie dans mon code en C? c'est tout ce qu'il faut faire? Car j'ai des erreurs donc je pense que je doit faire quelque chose avec mon .dll et .lib.
Par contre ce que j'ai pas comprit c'est comment ajouter des librairies externes a mon addon grâce au fichier binding.gyp? Si tu aurait un exemple rapide a me montrée car moi dans mon binding.gyp j'ai que:
Code:

1 2 3 4 5 6 7 8 9 10 { 'targets': [ { 'target_name': 'hello', 'sources': [ 'hello.c', ], }, ], }
Donc je n'interviens pas directement sur ma librairie, quand tu dis "Ensuite tu pourras ajouter des librairies externes à ton addon grace au fichier binding.gyp" c'est que je pourrais utiliser directement mes fonctions de ma librairie avec node sans appeler les fonctions de ma librairie dans un fichier .c?
Merci d'avance pour ta réponse
11/02/2015, 11h53
p3ga5e

Ne brule pas les étapes
Tous d’abord assure toi que tu disposes des outils nécessaire pour écrire et compilé un addon C++

L’exécution de la commande node-gyp rebuild dans le répertoire de l’exemple hello_world se termine t’elle bien par gyp info ok ?
Le fichier hello.node dans le sous-repertoire build\Release est-il bien créer ?

D'accord
Oui j'ai effectuer c'est étape sa fonctionne bien, j'ai même réussi a effectuer se programme et a avoir mon résultat " world" sur node :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include <node.h> using namespace v8; void Method(const FunctionCallbackInfo<Value>& args) { Isolate* isolate = Isolate::GetCurrent(); HandleScope scope(isolate); args.GetReturnValue().Set(String::NewFromUtf8(isolate, "world")); } void init(Handle<Object> exports) { NODE_SET_METHOD(exports, "hello", Method); } NODE_MODULE(addon, init)
C'est quand je veut utiliser ma librairie que je bloque...

11/02/2015, 12h48
p3ga5e

Ok quel fonction,de ta lib C soit-tu exposer ?
quel est sa signature ?
11/02/2015, 13h56
Anonyme5571
Je veut pouvoir utiliser 4 fonction dans un premier temps:
-CANOpenDevice
Code:

1 2 CANOpenDevice(int *pHandle, BOOL bSendDataConfirm, BOOL bSendDataInd, int nCANPort, const char * pcIPAddress, int nTimeout );
-CANCloseDevice

Code:

CANCloseDevice(int hHandle);

-CANWrite
Code:

1 2 CANWrite(int hHandle, int nIdentifier, const char * pcBuffer, int nBufferLen, int nFlags);
-CANSetCallback

Code:

CANSetCallback(int hHandle, CAN_PF_CALLBACK pCallbackFunction);

Tu trouvera tout les information nécessaire ici.
Vraiment merci pour ton aide.

Rien qu’en regardant les signatures, je remarque que tes fonctions manipule une référence (Handle) c’est donc bien une API objet en C !

Ton addon node va devoir exposer un fonction constructeur te permettant d’instancier un Object Device que tu vas devoir dériver de node::ObjectWrap
Dans la branche node 0.10, sa définition serait la suivante (Device.h) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #ifndef DEVICE_H #define DEVICE_H #include <node.h> #include <node.h> class Device : public node::ObjectWrap { public: static void Init(v8::Handle<v8::Object> target); private: Device(); ~Device(); static v8::Handle<v8::Value> New(const v8::Arguments& args); static v8::Handle<v8::Value> Write(const v8::Arguments& args); static v8::Handle<v8::Value> SetCallback(const v8::Arguments& args); static v8::Handle<v8::Value> Close(const v8::Arguments& args); int m_handle; }; #endif
Base-toi sur l’exemple 6_object_wrap

11/02/2015, 15h07
Anonyme5571

Merci pour ta réponse mais j'avoue que je suis complètement perdu...
Tu pourrais me décrire les étapes que je dois effectuer? car je n'ai pas compris où je viens mettre mon Device.h....
J'ai commencé le node il n'y a pas longtemps donc j'ai un peu de mal...

Pour l'instant j'ai un fichier hello.c

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <AnaGateDllcan.h>
 
int main(void)
{
	int hHandle;
    int nRC = CANOpenDevice(&hHandle, 1, 1, 0, "192.168.0.254", 5000);
    printf("Hello, world!\n");
    return 0;
}

Et mon binding.gyp

Code:

1
2
3
4
5
6
7
8
9
10
{
    'targets': [
        {
            'target_name': 'hello',
                'sources': [
                    'hello.c',
                ],
        },
    ],
}

Ce qui est pas bon je sais mais j'ai pas trop comprit le device.h

J'ai pas mal cherché et j'ai commencé à écrire la devise.cc comme cela mais je bloque sur la fin...si quelqu'un sait comment il faut l'écrire je suis preneur.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include "device.h"
using namespace v8;
Persistent<Function> Device::constructor;
 
Device::~Device() {
}
 
void Device::Init() {
  Isolate* isolate = Isolate::GetCurrent();
  // Prepare constructor template
  Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
  tpl->SetClassName(String::NewFromUtf8(isolate, "Device"));
  tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
  // Prototype
  NODE_SET_PROTOTYPE_METHOD(tpl, "Write", Write);
 
  constructor.Reset(isolate, tpl->GetFunction());
}
 
 
void Device::New(const FunctionCallbackInfo<Value>& args) {
  Isolate* isolate = Isolate::GetCurrent();
  HandleScope scope(isolate);
 
  if (args.IsConstructCall()) {
    // Invoked as constructor: `new Device(...)`
    double value = args[0]->IsUndefined() ? 0 : args[0]->NumberValue();
    Device* obj = new Device(value);
    obj->Wrap(args.This());
    args.GetReturnValue().Set(args.This());
  } else {
    // Invoked as plain function `Device(...)`, turn into construct call.
    const int argc = 1;
    Local<Value> argv[argc] = { args[0] };
    Local<Function> cons = Local<Function>::New(isolate, constructor);
    args.GetReturnValue().Set(cons->NewInstance(argc, argv));
  }
}
void Device::Write(const FunctionCallbackInfo<Value>& args) {
	  Isolate* isolate = Isolate::GetCurrent();
	  HandleScope scope(isolate);
	  Device* obj = ObjectWrap::Unwrap<Device>(args.Holder());

Comme tu sembles perdu ! Reprenons de début :

Que souhaites-tu obtenir comme API JavaScript par ton addon ? Quel est, en gros, ton cahier des charges ?

Comme ton CAN API semble interfacer un ou plusieurs périphériques IP distant, je t’ai suggérer une API JavaScript objet qui s’utiliserai de la sorte :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 var CAN = require('./build/Release/CAN'); var device = new CAN.Device(); if( device.open(1, 1, 0, "192.168.0.254", 5000) { device.setCallBack( function () { console.log(arguments); }) device.write(0,"data",0); setTimeout(function() { device.close(); process.exit(0); },20000); }
Cela te convient-il ?
Car si tu as juste besoin de faire en javascript ceci :
Code:

1 2 3 4 CAN.doSomething("192.168.0.254", 5000, function() { console.log("work done!"); })
Alors tu peux te passer d’un addon node …

En gros je souhaite pouvoir me connecter à mon système AnaGate ou a plusieurs système avec la fonction CANOpenDevice et après quand je suis connecté à mon AnaGate pouvoir lui envoyer des informations avec CANWrite et recevoir des c'est information avec la fonction CANSetCallback et pour finir pouvoir me déconnecter avec la fonction CANCloseDevice.
Donc oui quelque chose comme cela me convient:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 var CAN = require('./build/Release/CAN'); var device = new CAN.Device(); if( device.open(1, 1, 0, "192.168.0.254", 5000) { device.setCallBack( function () { console.log(arguments); }) device.write(0,"data",0); setTimeout(function() { device.close(); process.exit(0); },20000); }

Mais du coup pour faire une API JavaScript objet il faut bien que je créer un devise.cc non?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//devise.cc
#include "device.h"
using namespace v8;
Persistent<Function> Device::constructor;
 
Device::~Device() {
}
 
void Device::Init() {
  Isolate* isolate = Isolate::GetCurrent();
  // Prepare constructor template
  Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
  tpl->SetClassName(String::NewFromUtf8(isolate, "Device"));
  tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
  // Prototype
  NODE_SET_PROTOTYPE_METHOD(tpl, "Write", Write);
 
  constructor.Reset(isolate, tpl->GetFunction());
}
 
 
void Device::New(const FunctionCallbackInfo<Value>& args) {
  Isolate* isolate = Isolate::GetCurrent();
  HandleScope scope(isolate);
 
  if (args.IsConstructCall()) {
    // Invoked as constructor: `new Device(...)`
    double value = args[0]->IsUndefined() ? 0 : args[0]->NumberValue();
    Device* obj = new Device(value);
    obj->Wrap(args.This());
    args.GetReturnValue().Set(args.This());
  } else {
    // Invoked as plain function `Device(...)`, turn into construct call.
    const int argc = 1;
    Local<Value> argv[argc] = { args[0] };
    Local<Function> cons = Local<Function>::New(isolate, constructor);
    args.GetReturnValue().Set(cons->NewInstance(argc, argv));
  }
}
void Device::Write(const FunctionCallbackInfo<Value>& args) {
	  Isolate* isolate = Isolate::GetCurrent();
	  HandleScope scope(isolate);
	  Device* obj = ObjectWrap::Unwrap<Device>(args.Holder());

En plus de ton Device.h et après mon addon.cc?

17/02/2015, 16h44
Anonyme5571

Personne ne sais comment faire...?