Discussion :

[Anonyme5571]

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.

[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

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

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

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

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

[Anonyme5571]

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 :

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

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

[p3ga5e]

Ok quel fonction,de ta lib C soit-tu exposer ?
quel est sa signature ?

[Anonyme5571]

Je veut pouvoir utiliser 4 fonction dans un premier temps:
-CANOpenDevice

Code :

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

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

-CANCloseDevice

Code :

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

CANCloseDevice(int hHandle);

-CANWrite

Code :

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

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

-CANSetCallback

Code :

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

CANSetCallback(int hHandle, CAN_PF_CALLBACK pCallbackFunction);

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

[p3ga5e]

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 :

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

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

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

[Anonyme5571]

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

Code :

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

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 :

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

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

[Anonyme5571]

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 :

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

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

[p3ga5e]

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 :

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

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 :

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

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 …

[Anonyme5571]

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 :

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

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

[Anonyme5571]

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

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

[Anonyme5571]

Personne ne sais comment faire...?