Subversion Repositories HomeAutomation

Rev

Rev 995 | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | SVN | RSS feed

Rev 995 Rev 999
1 
/***************************************************************************
 1 
/***************************************************************************
2 
 *   Copyright (C) December 10, 2008 by Mattias Runge                             *
 2 
 *   Copyright (C) December 10, 2008 by Mattias Runge                             *
3 
 *   mattias@runge.se                                                      *
 3 
 *   mattias@runge.se                                                      *
4 
 *   virtualmachine.h                                            *
 4 
 *   virtualmachine.h                                            *
5 
 *                                                                         *
 5 
 *                                                                         *
6 
 *   This program is free software; you can redistribute it and/or modify  *
 6 
 *   This program is free software; you can redistribute it and/or modify  *
7 
 *   it under the terms of the GNU General Public License as published by  *
 7 
 *   it under the terms of the GNU General Public License as published by  *
8 
 *   the Free Software Foundation; either version 2 of the License, or     *
 8 
 *   the Free Software Foundation; either version 2 of the License, or     *
9 
 *   (at your option) any later version.                                   *
 9 
 *   (at your option) any later version.                                   *
10 
 *                                                                         *
 10 
 *                                                                         *
11 
 *   This program is distributed in the hope that it will be useful,       *
 11 
 *   This program is distributed in the hope that it will be useful,       *
12 
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 12 
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
13 
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 13 
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
14 
 *   GNU General Public License for more details.                          *
 14 
 *   GNU General Public License for more details.                          *
15 
 *                                                                         *
 15 
 *                                                                         *
16 
 *   You should have received a copy of the GNU General Public License     *
 16 
 *   You should have received a copy of the GNU General Public License     *
17 
 *   along with this program; if not, write to the                         *
 17 
 *   along with this program; if not, write to the                         *
18 
 *   Free Software Foundation, Inc.,                                       *
 18 
 *   Free Software Foundation, Inc.,                                       *
19 
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 19 
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
20 
 ***************************************************************************/
 20 
 ***************************************************************************/
21 
 
 21 
 
22 
#ifndef _VIRTUALMACHINE_H
 22 
#ifndef _VIRTUALMACHINE_H
23 
#define _VIRTUALMACHINE_H
 23 
#define _VIRTUALMACHINE_H
24 
 
 24 
 
25 
using namespace std;
 25 
using namespace std;
26 
 
 26 
 
27 
#include <map>
 27 
#include <map>
28 
#include <string>
 28 
#include <string>
29 
#include <queue>
 29 
#include <queue>
30 
 
 30 
 
31 
#include "../v8/include/v8.h"
 31 
#include "../v8/include/v8.h"
32 
#include "../SyslogStream/syslogstream.h"
 32 
#include "../SyslogStream/syslogstream.h"
33 
#include "../Settings/settings.h"
 33 
#include "../Settings/settings.h"
34 
#include "../CanNet/cannetmanager.h"
 34 
#include "../CanNet/cannetmanager.h"
35 
#include "../CanNet/canmessage.h"
 35 
#include "../CanNet/canmessage.h"
36 
#include "../Threads/semaphore.h"
 36 
#include "../Threads/semaphore.h"
37 
#include "../Threads/threadsafequeue.h"
 37 
#include "../Threads/threadsafequeue.h"
38 
#include "intervalthread.h"
 38 
#include "intervalthread.h"
39 
#include "socketthread.h"
 39 
#include "socketthread.h"
- 
 
 40 
#include "commandthread.h"
- 
 
 41 
#include "expression.h"
40 
 
 42 
 
41 
using namespace v8;
 43 
using namespace v8;
42 
 
 - 
 
43 
Handle<Value> VirtualMachine_log(const Arguments& args);
 - 
 
44 
Handle<Value> VirtualMachine_sendCanMessage(const Arguments& args);
 - 
 
45 
Handle<Value> VirtualMachine_sendCanNMTMessage(const Arguments& args);
 - 
 
46 
Handle<Value> VirtualMachine_loadScript(const Arguments& args);
 - 
 
47 
Handle<Value> VirtualMachine_stopIntervalThread(const Arguments& args);
 - 
 
48 
Handle<Value> VirtualMachine_startIntervalThread(const Arguments& args);
 - 
 
49 
Handle<Value> VirtualMachine_stopSocketThread(const Arguments& args);
 - 
 
50 
Handle<Value> VirtualMachine_startSocketThread(const Arguments& args);
 - 
 
51 
Handle<Value> VirtualMachine_sendToSocketThread(const Arguments& args);
 - 
 
52 
Handle<Value> VirtualMachine_uint2hex(const Arguments& args);
 - 
 
53 
 
 44 
 
54 
class VirtualMachine : public Thread<VirtualMachine>
 45 
class VirtualMachine : public Thread<VirtualMachine>
55 
{
 46 
{
56 
public:
 47 
public:
57 
    static VirtualMachine& getInstance();
 48 
    static VirtualMachine& getInstance();
58 
    static void deleteInstance();
 49 
    static void deleteInstance();
59 
 
 - 
 
60 
    void queueCanMessage(CanMessage canMessage);
 - 
 
61 
    void queueExpression(string expression);
 - 
 
62 
 
 50 
 
63 
    void run();
 51 
    void run();
- 
 
 52 
 
- 
 
 53 
    void queueExpression(Expression expression);
- 
 
 54 
    void queueExpression(string script) { queueExpression(Expression(script)); };
64 
 
 55 
 
65 
    bool loadScript(string scriptName);
 56 
    bool loadScript(string scriptName);
66 
 
 57 
 
67 
    unsigned int startIntervalThread(unsigned int timeout);
 58 
    unsigned int startIntervalThread(unsigned int timeout);
68 
    bool stopIntervalThread(unsigned int id);
 59 
    bool stopIntervalThread(unsigned int id);
69 
 
 60 
 
70 
    unsigned int startSocketThread(string address, int port, unsigned int reconnectTimeout);
 61 
    unsigned int startSocketThread(string address, int port, unsigned int reconnectTimeout);
71 
    bool stopSocketThread(unsigned int id);
 62 
    bool stopSocketThread(unsigned int id);
72 
    void sendToSocketThread(unsigned int id, string data);
 63 
    void sendToSocketThread(unsigned int id, string data);
- 
 
 64 
 
- 
 
 65 
    void sendToCommandClient(unsigned int id, string data);
- 
 
 66 
    void disconnectCommandClient(unsigned int id);
- 
 
 67 
 
- 
 
 68 
    void print(unsigned int id, string data);
- 
 
 69 
 
- 
 
 70 
    static Handle<Value> _quit(const Arguments& args);
- 
 
 71 
    static Handle<Value> _print(const Arguments& args);
- 
 
 72 
    static Handle<Value> _log(const Arguments& args);
- 
 
 73 
    static Handle<Value> _sendCanMessage(const Arguments& args);
- 
 
 74 
    static Handle<Value> _sendCanNMTMessage(const Arguments& args);
- 
 
 75 
    static Handle<Value> _loadScript(const Arguments& args);
- 
 
 76 
    static Handle<Value> _stopIntervalThread(const Arguments& args);
- 
 
 77 
    static Handle<Value> _startIntervalThread(const Arguments& args);
- 
 
 78 
    static Handle<Value> _stopSocketThread(const Arguments& args);
- 
 
 79 
    static Handle<Value> _startSocketThread(const Arguments& args);
- 
 
 80 
    static Handle<Value> _sendToSocketThread(const Arguments& args);
- 
 
 81 
    static Handle<Value> _uint2hex(const Arguments& args);
73 
 
 82 
 
74 
private:
 83 
private:
75 
    void callHandleNMTMessage(CanMessage canMessage);
 - 
 
76 
    void callHandleMessage(CanMessage canMessage);
 - 
 
77 
    bool runExpression(string expression);
 84 
    bool runExpression(Expression expression);
78 
    void printException(TryCatch* tryCatch);
 85 
    string formatException(TryCatch* tryCatch);
79 
 
 86 
 
80 
    VirtualMachine();
 87 
    VirtualMachine();
81 
    ~VirtualMachine();
 88 
    ~VirtualMachine();
82 
    static VirtualMachine* myInstance;
 89 
    static VirtualMachine* myInstance;
83 
 
 90 
 
84 
    Handle<Function> myFunctionHandleNMTMessage;
 - 
 
85 
    Handle<Function> myFunctionOfflineCheck;
 - 
 
86 
    Handle<Function> myFunctionHandleMessage;
 - 
 
87 
    Handle<Function> myFunctionStartup;
 91 
    Handle<Function> myFunctionStartup;
88 
 
 92 
 
89 
    Handle<ObjectTemplate> myGlobal;
 93 
    Handle<ObjectTemplate> myGlobal;
90 
    HandleScope myHandleScope;
 94 
    HandleScope myHandleScope;
91 
    Handle<Context> myContext;
 95 
    Handle<Context> myContext;
92 
 
 96 
 
93 
    Semaphore mySemaphore;
 97 
    Semaphore mySemaphore;
94 
 
 98 
 
95 
    ThreadSafeQueue<string> myExpressions;
 99 
    ThreadSafeQueue<Expression> myExpressions;
96 
    ThreadSafeQueue<CanMessage> myCanMessages;
 - 
 
97 
 
 100 
 
98 
    map<int, IntervalThread> myIntervalThreads;
 101 
    map<int, IntervalThread*> myIntervalThreads;
99 
    map<int, SocketThread*> mySocketThreads;
 102 
    map<int, SocketThread*> mySocketThreads;
- 
 
 103 
 
- 
 
 104 
    CommandThread myCommandThread;
100 
};
 105 
};
101 
 
 106 
 
102 
#endif  /* _VIRTUALMACHINE_H */
 107 
#endif  /* _VIRTUALMACHINE_H */
103 
 
 108 
 
104 
 
 109