WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom/VM/virtualmachine.cpp

     myGlobal = ObjectTemplate::New();
     //associates "print" on script to the Print function
     myGlobal->Set(String::New("log"), FunctionTemplate::New(VirtualMachine_log));
     myGlobal->Set(String::New("sendCanMessage"), FunctionTemplate::New(VirtualMachine_sendCanMessage));
+    myGlobal->Set(String::New("sendCanNMTMessage"), FunctionTemplate::New(VirtualMachine_sendCanNMTMessage));
     myGlobal->Set(String::New("loadScript"), FunctionTemplate::New(VirtualMachine_loadScript));
     myGlobal->Set(String::New("startIntervalThread"), FunctionTemplate::New(VirtualMachine_startIntervalThread));
     myGlobal->Set(String::New("stopIntervalThread"), FunctionTemplate::New(VirtualMachine_stopIntervalThread));
     myGlobal->Set(String::New("startSocketThread"), FunctionTemplate::New(VirtualMachine_startSocketThread));
     myGlobal->Set(String::New("stopSocketThread"), FunctionTemplate::New(VirtualMachine_stopSocketThread));
             if (file_exists(basePath + "Autostart.js"))
+            {
                 loadScript("Autostart.js");
+            }
-            myFunctionHandleHeartbeat = Handle<Function>::Cast(myContext->Global()->Get(String::New("handleHeartbeat")));
+            myFunctionHandleNMTMessage = Handle<Function>::Cast(myContext->Global()->Get(String::New("handleNMTMessage")));
             myFunctionOfflineCheck = Handle<Function>::Cast(myContext->Global()->Get(String::New("offlineCheck")));
             myFunctionHandleMessage = Handle<Function>::Cast(myContext->Global()->Get(String::New("handleMessage")));
             myFunctionStartup = Handle<Function>::Cast(myContext->Global()->Get(String::New("startup")));
+        }
+    }
         while (myCanMessages.size() > 0)
+        {
             canMessage = myCanMessages.pop();
-            if (canMessage.isHeartbeat())
+            if (canMessage.getClassName() == "nmt")
+            {
-                callHandleHeartbeat(stoi(canMessage.getData()["HardwareId"].getValue()));
+                callHandleNMTMessage(canMessage);
+            }
             else
+            {
                 callHandleMessage(canMessage);
+            }
+    }
     return true;
+}
-void VirtualMachine::callHandleHeartbeat(int hardwareId)
+void VirtualMachine::callHandleNMTMessage(CanMessage canMessage)
+{
-    const int argc = 1;
+    const int argc = 3;
-    Handle<Value> argv[argc] = { Integer::New(hardwareId) };
+    string jsonData = canMessage.getJSONData();
+    Handle<Value> argv[argc] = {String::New(canMessage.getClassName().c_str()),
+                                String::New(canMessage.getCommandName().c_str()),
+                                String::New(jsonData.c_str()) };
-    Handle<Value> result = myFunctionHandleHeartbeat->Call(myFunctionHandleHeartbeat, argc, argv); // argc and argv are your standard arguments to a function
+    Handle<Value> result = myFunctionHandleNMTMessage->Call(myFunctionHandleNMTMessage, argc, argv); // argc and argv are your standard arguments to a function
+}
 void VirtualMachine::callHandleMessage(CanMessage canMessage)
+{
     const int argc = 6;
 bool VirtualMachine::stopIntervalThread(unsigned int id)
+{
     if (myIntervalThreads.find(id) != myIntervalThreads.end())
+    {
         myIntervalThreads.erase(id);
         return true;
     }
     return false;
+}
 unsigned int VirtualMachine::startSocketThread(string address, int port, unsigned int reconnectTimeout)
+{
     SocketThread *socketThread = new SocketThread(address, port, reconnectTimeout);
         mySocketThreads[id]->send(data);
+    }
+}
 bool VirtualMachine::runExpression(string expression)
 {
     SyslogStream &slog = SyslogStream::getInstance();
     string scriptName = "runExpression";
     Handle<String> source =  String::New(expression.c_str(), expression.length());
     //compile script to binary code - JIT
     Handle<Script> script = Script::Compile(source, name);
     //check if we got problems on compilation
     if (script.IsEmpty())
     {
         // Print errors that happened during compilation.
         String::AsciiValue error(try_catch.Exception());
         string sError = *error;
         slog << "runExpression: Failed to compile script: " + sError + "\n";
         slog << expression << "\n\n";
     slog << *str;
     return Undefined();
+}
 Handle<Value> VirtualMachine_sendCanMessage(const Arguments& args)
+{
+    //SyslogStream &slog = SyslogStream::getInstance();
+    CanNetManager &canMan = CanNetManager::getInstance();
+    CanMessage canMessage;
+    String::AsciiValue className(args[0]);
+    canMessage.setClassName(*className);
+    String::AsciiValue directionFlag(args[1]);
+    canMessage.setDirectionFlag(*directionFlag);
+    String::AsciiValue moduleName(args[2]);
+    canMessage.setModuleName(*moduleName);
+    canMessage.setModuleId(args[3]->Uint32Value());
+    String::AsciiValue commandName(args[4]);
+    canMessage.setCommandName(*commandName);
+    String::AsciiValue dataString(args[5]);
+    vector<string> parts = explode(",", trim(*dataString, ','));
+    map<string, CanVariable> data;
+    for (int n = 0; n < parts.size(); n++)
+    {
+        vector<string> keyAndValue = explode(":", parts[n]);
+        //string key = trim(keyAndValue[0], ' ');
+        //string value = trim(keyAndValue[1], ' ');
+        data[keyAndValue[0]] = CanVariable(keyAndValue[0], keyAndValue[1]);
+    }
+    canMessage.setData(data);
+    canMan.sendMessage(canMessage);
+    return Undefined();
+}
+Handle<Value> VirtualMachine_sendCanNMTMessage(const Arguments& args)
+{
     //SyslogStream &slog = SyslogStream::getInstance();
     CanNetManager &canMan = CanNetManager::getInstance();
     CanMessage canMessage;
     String::AsciiValue className(args[0]);
     canMessage.setClassName(*className);
-    String::AsciiValue directionFlag(args[1]);
-    canMessage.setDirectionFlag(*directionFlag);
-    String::AsciiValue moduleName(args[2]);
-    canMessage.setModuleName(*moduleName);
-    canMessage.setModuleId(args[3]->Uint32Value());
-    String::AsciiValue commandName(args[4]);
+    String::AsciiValue commandName(args[1]);
     canMessage.setCommandName(*commandName);
-    String::AsciiValue dataString(args[5]);
+    String::AsciiValue dataString(args[2]);
     vector<string> parts = explode(",", trim(*dataString, ','));
     map<string, CanVariable> data;
     for (int n = 0; n < parts.size(); n++)

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/VM/virtualmachine.cpp @ 994 – Rev 983 → 986