Class: Pebble::Protocol

Inherits:
Object
  • Object
show all
Defined in:
lib/pebble/protocol.rb

Defined Under Namespace

Modules: Errors

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(port) ⇒ Protocol

Returns a new instance of Protocol.



25
26
27
28
29
30
31
32
33
 
# File 'lib/pebble/protocol.rb', line 25

def initialize(port)
  @port = port

  @connected          = false
  @send_message_mutex = Mutex.new
  @message_handlers   = Hash.new { |hash, key| hash[key] = [] }
  @messages = Queue.new
  @use_message_queue = false
end

Instance Attribute Details

#connected ⇒ Object (readonly)

Returns the value of attribute connected.



9
10
11
 
# File 'lib/pebble/protocol.rb', line 9

def connected
  @connected
end

#message_handlers ⇒ Object (readonly)

Returns the value of attribute message_handlers.



10
11
12
 
# File 'lib/pebble/protocol.rb', line 10

def message_handlers
  @message_handlers
end

#messages ⇒ Object (readonly)

Returns the value of attribute messages.



11
12
13
 
# File 'lib/pebble/protocol.rb', line 11

def messages
  @messages
end

Class Method Details

.open(port) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
 
# File 'lib/pebble/protocol.rb', line 13

def self.open(port)
  protocol = new(port)

  begin
    protocol.connect
    yield protocol
  ensure
    protocol.disconnect
  end
  nil
end

Instance Method Details

#connect ⇒ Object 



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/pebble/protocol.rb', line 35

def connect
  if @port.is_a?(String)
    require 'serialport'
    @serial_port = SerialPort.new(@port, baudrate: 115200)
  else
    @serial_port = @port
  end
  
  @connected = true
  Pebble.logger.debug "Connected to port #{@port}"
  
  @receive_messages_thread = Thread.new(&method(:receive_messages))

  true
rescue LoadError
  puts "Please 'gem install hybridgroup-serialport' for serial port support."      
end

#disconnect ⇒ Object

Raises:



53
54
55
56
57
58
59
60
61
62
 
# File 'lib/pebble/protocol.rb', line 53

def disconnect
  raise Errors::NotConnected unless @connected

  @connected = false

  @serial_port.close()
  @serial_port = nil

  true
end

#listen_for_messages(sync = true) ⇒ Object

Raises:



64
65
66
67
68
69
70
71
72
73
 
# File 'lib/pebble/protocol.rb', line 64

def listen_for_messages(sync=true)
  raise Errors::NotConnected unless @connected

  if sync
    @receive_messages_thread.join
  else
    @use_message_queue = true
    @receive_messages_thread.run
  end
end

#on_receive(endpoint = :any, &handler) ⇒ Object 



75
76
77
78
 
# File 'lib/pebble/protocol.rb', line 75

def on_receive(endpoint = :any, &handler)
  @message_handlers[endpoint] << handler
  handler
end

#send_message(endpoint, message, async_response_handler = nil, &response_parser) ⇒ Object

Raises:



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
 
# File 'lib/pebble/protocol.rb', line 87

def send_message(endpoint, message, async_response_handler = nil, &response_parser)
  raise Errors::NotConnected unless @connected

  message ||= ""

  Pebble.logger.debug "Sending #{Endpoints.for_code(endpoint) || endpoint}: #{message.inspect}"

  data = [message.size, endpoint].pack("S>S>") + message

  @send_message_mutex.synchronize do
    @serial_port.write(data)

    if response_parser
      if async_response_handler
        identifier = on_receive(endpoint) do |response_message|
          stop_receiving(endpoint, identifier)

          parsed_response = response_parser.call(response_message)

          async_response_handler.call(parsed_response)
        end

        true
      else
        received        = false
        parsed_response = nil
        identifier = on_receive(endpoint) do |response_message|
          stop_receiving(endpoint, identifier)

          parsed_response = response_parser.call(response_message)
          received        = true
        end

        sleep 0.015 until received

        parsed_response
      end
    else
      true
    end
  end
end

#stop_receiving(*params) ⇒ Object 



80
81
82
83
84
85
 
# File 'lib/pebble/protocol.rb', line 80

def stop_receiving(*params)
  handler   = params.pop
  endpoint  = params.pop || :any

  @message_handlers[endpoint].delete(handler)
end