Форум программистов, компьютерный форум CyberForum.ru

Python: Сети

Войти
Регистрация
Восстановить пароль
 
serrggeee
3 / 3 / 1
Регистрация: 09.10.2010
Сообщений: 137
#1

Реализовать чтение данных ИБП Ippon через serial socket - Python

18.01.2016, 11:14. Просмотров 583. Ответов 1
Метки нет (Все метки)

Здравствуйте пытаюсь сделать такую задачу. У меня есть бесперебойник ippon я поставил себе такую задачу, нужно что бы по средством библиотеки serial снимались с него данные, потом с помощью библиотеки socket отправлялись, ну а потом принимались в браузере где данные с сокета принимаются при помощи WebSocket, в и тоге можно будет наблюдать как постоянно изменяются показания бесперебойника. У меня уже есть готовый вариант, это итого гугления и некоторых изменений, но проблема такая что данные обновляются слишком редко и при обновлении браузера соединение разрывается. В коментариях кода буду описывать проблематичные места.
Python
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
#!usr/bin/env python
"""Output socket for limited and unlimited concurrent clients.
 
Usage:
    ```
    # Starts
    stream = Output(host='localhost', port=9999, web=False)
    stream.start()
 
    # Checks that port is available
    if stream.running:
 
        # Sends a message
        stream.send('Hello peer!!')
 
        # Stops
        stream.stop()
    ```
"""
 
from Queue import Queue
import socket
import base64
import threading
from hashlib import sha1
 
 
class Output(object):
    """
    SingleSocket output class.
    """
 
    MAGIC = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
    HANDSHAKE_HEAD = "HTTP/1.1 101 Switching Protocols\r\n" \
                     "Upgrade: websocket\r\n" \
                     "Connection: Upgrade\r\n" \
                     "Sec-WebSocket-Accept: {hash}\r\n" \
                     "\r\n"
 
    def __init__(self, host, port, web=False, max_clients=None, password=None,
                 welcome=''):
        """
        Constructor
 
        :param host: str. Host connected from. Set to '0.0.0.0' to allow all.
        :param port: int. Port connected to.
        :param web: bool. Flag for a websocket connection.
        :param max_clients: bool. 0 or None for unlimited.
        :param password: str. If set is used for logging in clients.
        :param welcome: str. Message sent when a client is connected.
        :return: void
        """
        self._max_clients = max_clients
        self._new_clients = Queue()
        self._clients = Queue()
 
        self._password = password
 
        self._released = threading.Event()
        self._running = threading.Event()
 
        self._host = host
        self._port = port
 
        self._web = web
 
        #if not welcome:
           # welcome = 'You are logged in'
 
        self._welcome = '{!s}{!s}'.format(welcome, '\n')
 
        self._server = None
        self._messages = Queue()
 
        self._emitter = None
        self._runtime = None
 
        pass
 
    def reconfigure(self, host, port, web):
        """
        Recycles the object. Stopping the object before is recommended.
 
        :param host: str
        :param port: int
        :param web: bool
        :return: void
        """
        print "[*] Recycled object"
 
        return self.__init__(host=host, port=port, web=web)
 
    def stop(self):
        """
        Nice stop
 
        :return: void
        """
        try:
            self._server.shutdown(socket.SHUT_RDWR)
            self._server.close()
 
        except socket.error:
            print "[!] Closing when server is not running"
 
        self._kill_emitter()
 
        self._runtime.join()
 
        print "[*] Stopped communication"
 
    def start(self, timeout=60):
        """
        Starts communication threads and returns the used port. Waits until the
        appropriate thread sets the connected event. After the set timeout
        seconds, if client is not connected, continues.
 
        :param timeout: int.
        :return: void
        """
        self._runtime = threading.Thread(target=self._listen)
 
        self._runtime.start()
 
        self._released.wait(timeout)
 
        return self._port
 
    def append_msg(self, message):
        """
        Puts a message into the messages queue to be sent immediately.
 
        :param message: str
        :return: bool
        """
 
        if self._web and len(message) > 125:
 
            self._messages.put(message[:125])
            return self.append_msg(message[125:])
 
        self._messages.put(message)
 
        pass
 
    @property
    def running(self):
        """
        Returns True if socket is working. Main flag to know the status.
 
        :return: bool
        """
        return self._running.is_set()
 
    def _listen(self):
        """
        Starts listening asynchronously
 
        :return: void
        """
 
        if not self._start_server():
 
            print "[x] Port in use: {:d}".format(self._port)
 
            self._released.set()
 
            return
 
        while self._running:
            try:
                client, address = self._server.accept()
 
                print "[*] Accepted from: {!s}:{:d}".format(address[0],
                                                            address[1])
 
            except socket.error:
                print '[x] Socket error accepting'
 
                self._running.clear()
 
                return
 
            if self._reaches_max_clients():
                self._clients.get()
 
            self._released.set()
 
            self._new_clients.put(client)
 
            self._emitter = threading.Thread(target=self._talk)
            self._emitter.start()
 
        return
 
    def _reaches_max_clients(self):
        """
        Checks if connection reaches the max clients limit.
        If max clients is 0 or unset, clients number is unlimited.
 
        :return: bool
        """
        result = self._max_clients \
                 and self._clients.qsize() >= self._max_clients
 
        return result
 
    def _start_server(self):
        """
        Starts server on first available port. Returns True if does.
        If there is no port available returns False.
 
        :return: bool
        """
        self._server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self._server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 
        try:
            self._server.bind((self._host, self._port))
 
        except socket.error:
            return False
 
        self._running.set()
 
        self._server.listen(1)
 
        print '[*] Listening on {!s}:{:d}'.format(self._host, self._port)
 
        return True
 
    def _kill_emitter(self):
        """
        Given the threat for client handling, nicely closes the thread and
        the client types.
 
        :return: void
        """
        if self._released.is_set():
            self._released.clear()
            self._emitter.join()
 
            print '[*] Emitter killed'
 
        else:
            print '[!] No emitter to kill'
 
        pass
 
    def _handshake(self, headers, client):
        """
        Given the headers and the types resource, does a handshake only on
        websocket communication.
 
        :param headers: dict<str>
        :return: void
        """
        for key, value in headers.iteritems():
            print key, ':', value
 
        socket_key = headers['Sec-WebSocket-Key']
 
        magic = self._hash_magic(socket_key=socket_key)
 
        response = self.HANDSHAKE_HEAD.format(hash=magic)
 
        client.send(response)
 
        print "[*] Handshake response:\n\t{!s}".format(response)
 
    @classmethod
    def _format_web_msg(cls, msg):
        """
        Given a message returns the content formatted to send it using websocket
        protocol.
 
        :param msg: str
        :return: str
        """
        message = bytearray([0b10000001, len(msg)])
 
        # append the data bytes
        for byte in bytearray(msg):
            message.append(byte)
 
        return message
 
    def _send(self, msg, clients=list()):
        """
        Given a message sends to all connected clients.
 
        If clients parameter is set sends the message to the list of clients
        contained by.
 
        Else if clients is not set or is empty, sends the message to the context
        logged in clients.
 
        :param msg: mixed
        :param clients: list
        :return: void
        """
        if self._web:
            msg = self._format_web_msg(msg=msg)
 
        if not clients:
            clients = list(self._clients.queue)
 
        while len(clients):
            client = clients.pop(0)
            client.send(msg)
 
        return
 
    def _login_all(self):
        """
        In case of normal socket receives the client key pass.
 
        In case of websocket receives the data for handshake, does the
        appropriate handshake and after receives the key pass.
 
        Accepts only valid new clients moving them to logged in clients.
        Only logged in clients receive the output messages.
 
        :return: void
        """
        if self._new_clients.empty():
            return
 
        client = self._new_clients.get()
 
        if self._web:
 
            data = self._receive_hello(client=client, handshake=True)
 
            print "[*] Websocket protocol is enabled"
 
            headers = self._parse_headers(data)
 
            self._handshake(headers=headers, client=client)
 
        data = self._receive_hello(client=client, handshake=False)
 
        if self._login(data):
            self._send(self._welcome, [client])
            self._clients.put(client)
 
        else:
            self._send('Authorized only\n', [client])
            client.close()
 
        self._login_all()
 
    def _receive_hello(self, client, handshake=False):
        """
        Given a socket client waits for receiving data from client.
        If context password is set waits and returns the received data.
        If handshake parameter is True waits and returns the received data.
        If any of above conditions happens does not wait and returns None
 
        :param client: resource socket client
        :param handshake: bool
        :return: str|None
        """
        if not self._password and not handshake:
            return None
 
        hello = client.recv(1024)
 
        print "[*] Received: " + hello
 
        return hello
 
    def _login(self, key_pass):
        """
        Given a key pass returns True if matches with the context password.
        Returns False if does not match.
 
        :param key_pass: str
        :return: bool
        """
        if not self._password:
            return True
 
        elif self._password == key_pass.strip():
            return True
 
        else:
            return False
 
    def _talk(self):
        """
        - Receives the input from the new client.
        - Log in the new clients.
        - Maintains the communication meanwhile the connection with the client
        is alive.
 
        :return: void
        """
 
        self._login_all()
 
        while self._released.is_set():
 
            self._send_all()
 
        self._close_all()
 
    def _close_all(self):
        """
        Closes all clients and dequeues clients container
        :return: void
        """
        if self._clients.empty():
            return
 
        client = self._clients.get()
        #self._send('Connection closed\n', [client])
        client.close()
 
        self._close_all()
 
    def _send_all(self):
        """
        Prepares and sends all message in queue.
 
        :return: void
        """
        if self._messages.empty():
            return
 
        message = self._messages.get()
 
        try:
            self._send(message)
 
            print "[*] Message sent:\n\t{!s}".format(message)
 
        except socket.error, exc:
 
            print("[x] Error sending to a client. {!s}".format(exc.message))
 
        self._send_all()
 
    @classmethod
    def _hash_magic(cls, socket_key):
        """
        Given the types key returns a new hash composed by the key
        and the magic uuid.
 
        :param socket_key: str
        :return: str
        """
        output = sha1(socket_key + cls.MAGIC).digest()
        output = base64.b64encode(output)
 
        return output
 
    @classmethod
    def _parse_headers(cls, data):
        """
        Parses headers from client
 
        :param data: str
        :return: dict
        """
        headers = {}
        lines = data.splitlines()
 
        for l in lines:
            parts = l.split(": ", 1)
 
            if len(parts) == 2:
                headers[parts[0]] = parts[1]
 
        headers['get'] = lines[0]
 
        headers['code'] = lines[len(lines) - 1]
 
        return headers
серверная часть сокета
Python
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
import serial
import sys
sys.path.append('../..')
 
import time
from SingleSocket.Output import Output
 
SOCKET_PORT = 9999
SOCKET_HOST = '127.0.0.1'
stream = Output(host=SOCKET_HOST,
                port=SOCKET_PORT,
                web=True)
 
#ser = serial.Serial("/dev/ttyS0", baudrate=2400)
def starts():
    
    port = stream.start() # здесь запускается поток сокета
 
    print('Emitting port: {:d}'.format(port))
 
    if not stream.running:
        exit(0)
    ser = serial.Serial("/dev/ttyS0", baudrate=2400)
    while ser:
        try:
            ser.write(b"Q1\r") # отправляем данные бесперебойнику
            ups1= ser.read(47) # и получаем в ответ
 
            stream.append_msg(ups1) # ну и отдается данные сокету
        except Exception:
            #port = stream.stop() # здесь если я уберу коментарий то будет постоянно сбрасываться соединение, но при перезагрузке
                                               # браузера соединение восстанавливается, если не перезагружать браузер то оно не будет 
                                               # восcтанавливаться, а если закаментировать то данные будут не прерывно поступать, но в терминале 
                                              # наблюдаются вот такие сообщения 
                                              # Emitting port: 9999
                                              #[x] Port in use: 9999
                                              # и при обновлении браузера соединение сбрасуется
 
            starts()
starts()
И еще такая проблема иногда приходят кривые показания с бесперебойника типа как эти
0.0 13.7 37.8 00001000 27.0 225.5 043 50
а вот нормальные
37.8 00001000 23.0 223.0 041 50.0 13.7 37.8 00
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
18.01.2016, 11:14     Реализовать чтение данных ИБП Ippon через serial socket
Посмотрите здесь:

Замена вентилятора в ИБП Ippon Smart Power Pro 1000
Python Проблемы с модулем socket
socket & HTTP: отправка нетекстового файла Python
ИБП Ippon Back Office 600 не включается
Python Как через модуль socket с сервера считать в клиент строку?
Email socket API Python
Python Python socket telnet, потоки и ответ сервера
Python Правильный socket send и json
Python Управление ИБП через порт с помощью модуля serial
Python Windows socket server python + socket client js

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
serrggeee
3 / 3 / 1
Регистрация: 09.10.2010
Сообщений: 137
18.01.2016, 12:03  [ТС]     Реализовать чтение данных ИБП Ippon через serial socket #2
остается только клиентская часть, по идее ее нужно разбирать в разделе js, но тему не разделишь))
HTML5
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
<!DOCTYPE html>
 
<meta charset="utf-8"/>
 
<title>WebSocket Test</title>
<script src="http://code.jquery.com/jquery-1.9.0.js"></script>
<script language="javascript" type="text/javascript">
    var wsUri = "ws://127.0.0.1:9999";
    var output;
    function init() {
        output = document.getElementById("output");
        testWebSocket();
    }
    function testWebSocket() {
        var websocket = new WebSocket(wsUri);
       
       
        websocket.onmessage = function (evt) {
            onMessage(evt)
        };
    
    }
    
    function onMessage(evt) {
        writeToScreen('<span style="color: red;font-size: 379%;">' + evt.data + '</span>');
    }
   
    function writeToScreen(message) {
        var pre = document.createElement("p");
        $(pre).addClass('del');
        pre.style.wordWrap = "break-word";
        pre.innerHTML = message;
        $('.del').remove();
 
        output.appendChild(pre);
    }
    window.addEventListener("load", init, false);
</script>
 
<h2>WebSocket Test</h2>
 
<div id="output"></div>
тут только не понятно каким от куда берется evt, но как я могу предположить это переменная объявлена в WebSocket

Добавлено через 36 минут
не много хочу поправить себя в обоих случаях соединение не теряется, но слишком медленно обновляются данные.

Добавлено через 12 минут
но если я запускаю скрипт еще на одной странице, то сокет замолкает уже навсегда, а вот что я наблюдаю в терминале
Bash
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
serrrggggeee@serrrggggeee-Arbyte-Quint-B-M4D3A-H61 ~/socket $ sudo python websocket2.py[*] Listening on 127.0.0.1:9999[*] Accepted from: 127.0.0.1:40247[*] Received: GET / HTTP/1.1
Host: 127.0.0.1:9999
Connection: Upgrade
Pragma: no-cache
Cache-Control: no-cache
Upgrade: websocket
Origin: file://
Sec-WebSocket-Version: 13
User-Agent: Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8,ru;q=0.6,de;q=0.4,uk;q=0.2
Cookie: django_language=ru; csrftoken=HU9xTxpwGwyXcK06qF71EghChCgprIQM
Sec-WebSocket-Key: t+fRsYqzsCpRhzyqTuPPEg==
Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits
 
[*] Websocket protocol is enabled
Origin : file://
Upgrade : websocket
Accept-Language : en-US,en;q=0.8,ru;q=0.6,de;q=0.4,uk;q=0.2
Accept-Encoding : gzip, deflate, sdch
get : GET / HTTP/1.1
Sec-WebSocket-Version : 13
Connection : Upgrade
Sec-WebSocket-Key : t+fRsYqzsCpRhzyqTuPPEg==
User-Agent : Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Host : 127.0.0.1:9999
code : 
Cookie : django_language=ru; csrftoken=HU9xTxpwGwyXcK06qF71EghChCgprIQM
Pragma : no-cache
Cache-Control : no-cache
Sec-WebSocket-Extensions : permessage-deflate; client_max_window_bits[*] Handshake response:
    HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: vCGV4gsyw3tTu0LTvBHwXEv7K6E=
 
 
Emitting port: 9999[*] Message sent:
(236.0 239.0 236.0 036 50.0 13.8 37.8 00001000[*] Message sent:
(236.0 239.0 239.5 039 50.0 13.8 37.8 00001000[*] Message sent:
(236.0 236.0 236.0 039 50.0 13.8 37.8 00001000[*] Message sent:
    (236.0 236.0 236.0 039 50.0 13.8 37.8 00001000[*] Message sent:
    (236.0 236.0 236.0 041 50.0 13.8 37.8 00001000[*] Message sent:
(239.5 239.0 236.0 041 50.0 13.8 37.8
Emitting port: 9999
[x] Port in use: 9999
Emitting port: 9999
[x] Port in use: 9999
Emitting port: 9999[x] Port in use: 9999
[*] Message sent:
(236.0 236.0 236.0 041 50.0 13.8 37.8 00001000[*] Message sent:
(236.0 236.0 2360.0 13.8 37.8 00001000
Emitting port: 9999
 [x] Port in use: 9999
Emitting port: 9999
[x] Port in use: 9999[*] Message sent:
36.0 23636.0 239.5 041 50.0 13.8 37.8 00001000[*] Message sent:
(236.0 236.0 2360.0 13.8 37.8 00001000[*] Message sent:
36.0 23636.0 236.0 041 50.0 13.8 37.8 00001000[*] Message sent:
(239.5 239.0 2390.0 13.8 37.8 00001000[*] Message sent:
36.0 23636.0 236.0 041 50.0 13.8 37.8 00001000[*] Message sent:
(239.5 239.0 2390.0 13.8 37.8 00001000[*] Message sent:
36.0 23639.0 236.0 041 50.0 13.8 37.8 00001000[*] Accepted from: 127.0.0.1:40254
[x] Socket error accepting[*] Received: GET / HTTP/1.1
Host: 127.0.0.1:9999
Connection: Upgrade
Pragma: no-cache
Cache-Control: no-cache
Upgrade: websocket
Origin: file://
Sec-WebSocket-Version: 13
User-Agent: Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8,ru;q=0.6,de;q=0.4,uk;q=0.2
Cookie: django_language=ru; csrftoken=HU9xTxpwGwyXcK06qF71EghChCgprIQM
Sec-WebSocket-Key: DB2uhlONQAIVfri/wcZIdw==
Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits
 
[*] Websocket protocol is enabled
Origin : file://
Upgrade : websocket
Accept-Language : en-US,en;q=0.8,ru;q=0.6,de;q=0.4,uk;q=0.2
Accept-Encoding : gzip, deflate, sdch
get : GET / HTTP/1.1
Sec-WebSocket-Version : 13
Connection : Upgrade
Sec-WebSocket-Key : DB2uhlONQAIVfri/wcZIdw==
User-Agent : Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Host : 127.0.0.1:9999
code : 
Cookie : django_language=ru; csrftoken=HU9xTxpwGwyXcK06qF71EghChCgprIQM
Pragma : no-cache
Cache-Control : no-cache
Sec-WebSocket-Extensions : permessage-deflate; client_max_window_bits[*] Handshake response:
    HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: pFxGJDy4wuSKNNlEHF824wObAvc=
 
[*] Message sent:
(239.5 239.0 2390.0 13.8 37.8 00001000
Emitting port: 9999[*] Listening on 127.0.0.1:9999
Emitting port: 9999
[x] Port in use: 9999
[x] Port in use: 9999
 Emitting port: 9999[*] Message sent:
36.0 23936.0 236.0 041 50.0 13.8 37.8 00001000[*] Message sent:
(236.0 236.0 2360.0 13.8 37.8 00001000
Emitting port: 9999
[x] Port in use: 9999
Emitting port: 9999
 [x] Port in use: 9999
Emitting port: 9999
 [x] Port in use: 9999
Emitting port: 9999
[x] Port in use: 9999
Emitting port: 9999
[x] Port in use: 9999
Emitting port: 9999
 [x] Port in use: 9999
[x] Port in use: 9999
 Emitting port: 9999[*] Message sent:
39.0 23636.0 236.0 041 50.0 13.8 37.8 00001000[*] Message sent:
(239.5 239.0 2390.0 13.8 37.8 00001000
Emitting port: 9999
[x] Port in use: 9999
Emitting port: 9999
[x] Port in use: 9999
Emitting port: 9999
 [x] Port in use: 9999
[x] Port in use: 9999Emitting port: 9999
 
Emitting port: 9999
[x] Port in use: 9999[*] Message sent:
39.0 23939.0 239.5 041 50.0 13.8 37.8 00001000[*] Message sent:
(236.0 236.0 2360.0 13.8 37.8 00001000[*] Message sent:
36.0 23636.0 236.0 043 50.0 13.8 37.8 00001000[*] Message sent:
(236.5 239.0 2360.0 13.8 37.8 00001000[*] Accepted from: 127.0.0.1:40266
[x] Socket error accepting[*] Received: GET / HTTP/1.1
Host: 127.0.0.1:9999
Connection: Upgrade
Pragma: no-cache
Cache-Control: no-cache
Upgrade: websocket
Origin: file://
Sec-WebSocket-Version: 13
User-Agent: Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8,ru;q=0.6,de;q=0.4,uk;q=0.2
Cookie: django_language=ru; csrftoken=HU9xTxpwGwyXcK06qF71EghChCgprIQM
Sec-WebSocket-Key: BH0NSb7OvamvL/uZYMGUyw==
Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits
 
[*] Websocket protocol is enabled
Origin : file://
Upgrade : websocket
Accept-Language : en-US,en;q=0.8,ru;q=0.6,de;q=0.4,uk;q=0.2
Accept-Encoding : gzip, deflate, sdch
get : GET / HTTP/1.1
Sec-WebSocket-Version : 13
Connection : Upgrade
Sec-WebSocket-Key : BH0NSb7OvamvL/uZYMGUyw==
User-Agent : Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Host : 127.0.0.1:9999
code : 
Cookie : django_language=ru; csrftoken=HU9xTxpwGwyXcK06qF71EghChCgprIQM
Pragma : no-cache
Cache-Control : no-cache
Sec-WebSocket-Extensions : permessage-deflate; client_max_window_bits[*] Handshake response:
    HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: Un4yoeWaTvCD7BbEzxN0PFEcMus=
 
[*] Message sent:
(239.5 236.0 239.5 043 50.0 13.8 37.8 00001000[*] Message sent:
(236.0 239.0 2360.0 13.8 37.8 00001000[*] Message sent:
36.0 23636.0 236.0 041 50.0 13.8 37.8 00001000[*] Message sent:
(239.5 239.0 2390.0 13.8 37.8 00001000[*] Message sent:
36.0 23636.0 236.0 041 50.0 13.8 37.8 00001000[*] Message sent:
(236.0 236.0 2360.0 13.8 37.8 00001000[*] Message sent:
36.0 23639.0 239.5 041 50.0 13.8 37.8 00001000
[x] Error sending to a client. 
[x] Error sending to a client. 
[x] Error sending to a client. 
Emitting port: 9999[*] Listening on 127.0.0.1:9999[*] Accepted from: 127.0.0.1:40275[*] Received: GET / HTTP/1.1
Host: 127.0.0.1:9999
Connection: Upgrade
Pragma: no-cache
Cache-Control: no-cache
Upgrade: websocket
Origin: file://
Sec-WebSocket-Version: 13
User-Agent: Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8,ru;q=0.6,de;q=0.4,uk;q=0.2
Cookie: django_language=ru; csrftoken=HU9xTxpwGwyXcK06qF71EghChCgprIQM
Sec-WebSocket-Key: QYR81ln716b7TjdBqWJalw==
Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits
 
[*] Websocket protocol is enabled
Origin : file://
Upgrade : websocket
Accept-Language : en-US,en;q=0.8,ru;q=0.6,de;q=0.4,uk;q=0.2
Accept-Encoding : gzip, deflate, sdch
get : GET / HTTP/1.1
Sec-WebSocket-Version : 13
Connection : Upgrade
Sec-WebSocket-Key : QYR81ln716b7TjdBqWJalw==
User-Agent : Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Host : 127.0.0.1:9999
code : 
Cookie : django_language=ru; csrftoken=HU9xTxpwGwyXcK06qF71EghChCgprIQM
Pragma : no-cache
Cache-Control : no-cache
Sec-WebSocket-Extensions : permessage-deflate; client_max_window_bits[*] Handshake response:
    HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: F7GELH8UqNvrfEMT1cAhPWrF0dE=
 
[*] Accepted from: 127.0.0.1:40279[*] Received: GET / HTTP/1.1
Host: 127.0.0.1:9999
Connection: Upgrade
Pragma: no-cache
Cache-Control: no-cache
Upgrade: websocket
Origin: file://
Sec-WebSocket-Version: 13
User-Agent: Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8,ru;q=0.6,de;q=0.4,uk;q=0.2
Cookie: django_language=ru; csrftoken=HU9xTxpwGwyXcK06qF71EghChCgprIQM
Sec-WebSocket-Key: V0d8e3LEDZf5hRzHwsOsiw==
Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits
 
[*] Websocket protocol is enabled
Origin : file://
Upgrade : websocket
Accept-Language : en-US,en;q=0.8,ru;q=0.6,de;q=0.4,uk;q=0.2
Accept-Encoding : gzip, deflate, sdch
get : GET / HTTP/1.1
Sec-WebSocket-Version : 13
Connection : Upgrade
Sec-WebSocket-Key : V0d8e3LEDZf5hRzHwsOsiw==
User-Agent : Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Host : 127.0.0.1:9999
code : 
Cookie : django_language=ru; csrftoken=HU9xTxpwGwyXcK06qF71EghChCgprIQM
Pragma : no-cache
Cache-Control : no-cache
Sec-WebSocket-Extensions : permessage-deflate; client_max_window_bits[*] Handshake response:
    HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: D33jY9NEhDKAXN4/94HZLvJT9B4=
Yandex
Объявления
18.01.2016, 12:03     Реализовать чтение данных ИБП Ippon через serial socket
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru