Open Lighting Architecture  0.9.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DmxTriWidget.h
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License as published by
4  * the Free Software Foundation; either version 2 of the License, or
5  * (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10  * GNU Library General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software
14  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
15  *
16  * DmxTriWidget.h
17  * The Jese DMX-TRI/RDM-TRI widget.
18  * Copyright (C) 2010 Simon Newton
19  */
20 
21 #ifndef PLUGINS_USBPRO_DMXTRIWIDGET_H_
22 #define PLUGINS_USBPRO_DMXTRIWIDGET_H_
23 
24 #include <map>
25 #include <string>
26 #include <queue>
27 #include "ola/Callback.h"
28 #include "ola/DmxBuffer.h"
31 #include "ola/rdm/UIDSet.h"
32 #include "ola/thread/SchedulerInterface.h"
33 #include "plugins/usbpro/BaseUsbProWidget.h"
34 
35 namespace ola {
36 namespace plugin {
37 namespace usbpro {
38 
39 /*
40  * A DMX TRI Widget implementation. We separate the Widget from the
41  * implementation so we can leverage the QueueingRDMController.
42  */
45  public:
47  ola::io::ConnectedDescriptor *descriptor,
48  bool use_raw_rdm);
50 
51  void UseRawRDM(bool use_raw_rdm) { m_use_raw_rdm = use_raw_rdm; }
52 
53  void Stop();
54 
55  bool SendDMX(const DmxBuffer &buffer);
56  void SendRDMRequest(const ola::rdm::RDMRequest *request,
57  ola::rdm::RDMCallback *on_complete);
60 
61  private:
62  typedef enum {
63  SINGLE_TX_COMMAND_ID = 0x21,
64  DISCOVER_AUTO_COMMAND_ID = 0x33,
65  DISCOVER_STATUS_COMMAND_ID = 0x34,
66  REMOTE_UID_COMMAND_ID = 0x35,
67  RAW_RDM_COMMAND_ID = 0x37,
68  REMOTE_GET_COMMAND_ID = 0x38,
69  REMOTE_SET_COMMAND_ID = 0x39,
70  QUEUED_GET_COMMAND_ID = 0x3a,
71  SET_FILTER_COMMAND_ID = 0x3d,
72 
73  RESERVED_COMMAND_ID = 0xff,
74  } TriCommandId;
75 
76  typedef enum {
77  NO_DISCOVERY_ACTION,
78  DISCOVER_AUTO_REQUIRED,
79  DISCOVER_STATUS_REQUIRED,
80  FETCH_UID_REQUIRED,
81  } TriDiscoveryState;
82 
83  typedef std::map<ola::rdm::UID, uint8_t> UIDToIndexMap;
84 
86  UIDToIndexMap m_uid_index_map;
87  uint8_t m_uid_count;
88  uint16_t m_last_esta_id;
89  bool m_use_raw_rdm;
90 
91  // State for sending DMX
92  DmxBuffer m_outgoing_dmx;
93 
94  // State for handling RDM discovery
95  ola::thread::timeout_id m_disc_stat_timeout_id;
96  ola::rdm::RDMDiscoveryCallback *m_discovery_callback;
97  TriDiscoveryState m_discovery_state;
98 
99  // State for sending RDM Gets/Sets
100  // This holds pointers to the RDMRequest and Callback that is queued or in
101  // flight.
102  ola::rdm::RDMCallback *m_rdm_request_callback;
103  const ola::rdm::RDMRequest *m_pending_rdm_request;
104  uint8_t m_transaction_number;
105  // The command id that we expect to see in the response.
106  uint8_t m_last_command, m_expected_command;
107 
108  void SendDMXBuffer();
109  void SendQueuedRDMCommand();
110  void RunDiscoveryCallback(ola::rdm::RDMDiscoveryCallback *callback);
111  bool CheckDiscoveryStatus();
112  void HandleMessage(uint8_t label,
113  const uint8_t *data,
114  unsigned int length);
115  void SendDiscoveryAuto();
116  void SendDiscoveryStat();
117  void FetchNextUID();
118  bool IsDUBRequest(const ola::rdm::RDMRequest *request);
119  void SendRawRDMRequest();
120  void DispatchRequest();
121  void DispatchQueuedGet();
122  void StopDiscovery();
123 
124  void HandleSingleTXResponse(uint8_t return_code);
125  void HandleDiscoveryAutoResponse(uint8_t return_code,
126  const uint8_t *data,
127  unsigned int length);
128  void HandleDiscoverStatResponse(uint8_t return_code,
129  const uint8_t *data,
130  unsigned int length);
131  void HandleRemoteUIDResponse(uint8_t return_code,
132  const uint8_t *data,
133  unsigned int length);
134  void HandleRawRDMResponse(uint8_t return_code,
135  const uint8_t *data,
136  unsigned int length);
137  void HandleRemoteRDMResponse(uint8_t return_code,
138  const uint8_t *data,
139  unsigned int length);
140  void HandleQueuedGetResponse(uint8_t return_code,
141  const uint8_t *data,
142  unsigned int length);
143  void HandleGenericRDMResponse(uint8_t return_code,
144  uint16_t pid,
145  const uint8_t *data,
146  unsigned int length);
147  void HandleSetFilterResponse(uint8_t return_code,
148  const uint8_t *data,
149  unsigned int length);
150  bool PendingTransaction() const;
151  void MaybeSendNextRequest();
152  void HandleRDMError(ola::rdm::rdm_response_code error_code);
153  bool SendCommandToTRI(uint8_t label, const uint8_t *data,
154  unsigned int length);
155  bool TriToOlaReturnCode(uint8_t return_code,
156  ola::rdm::rdm_response_code *code);
157  bool ReturnCodeToNackReason(uint8_t return_code,
158  ola::rdm::rdm_nack_reason *reason);
159 
160  typedef enum {
161  EC_NO_ERROR = 0,
162  EC_CONSTRAINT = 1,
163  EC_UNKNOWN_COMMAND = 2,
164  EC_INVALID_OPTION = 3,
165  EC_FRAME_FORMAT = 4,
166  EC_DATA_TOO_LONG = 5,
167  EC_DATA_MISSING = 6,
168  EC_SYSTEM_MODE = 7,
169  EC_SYSTEM_BUSY = 8,
170  EC_DATA_CHECKSUM = 0x0a,
171  EC_INCOMPATIBLE = 0x0b,
172  EC_RESPONSE_TIME = 0x10,
173  EC_RESPONSE_WAIT = 0x11,
174  EC_RESPONSE_MORE = 0x12,
175  EC_RESPONSE_TRANSACTION = 0x13,
176  EC_RESPONSE_SUB_DEVICE = 0x14,
177  EC_RESPONSE_FORMAT = 0x15,
178  EC_RESPONSE_CHECKSUM = 0x16,
179  EC_RESPONSE_NONE = 0x18,
180  EC_RESPONSE_IDENTITY = 0x1a,
181  EC_RESPONSE_MUTE = 0x1b,
182  EC_RESPONSE_DISCOVERY = 0x1c,
183  EC_RESPONSE_UNEXPECTED = 0x1d,
184  EC_UNKNOWN_PID = 0x20,
185  EC_FORMAT_ERROR = 0x21,
186  EC_HARDWARE_FAULT = 0x22,
187  EC_PROXY_REJECT = 0x23,
188  EC_WRITE_PROTECT = 0x24,
189  EC_UNSUPPORTED_COMMAND_CLASS = 0x25,
190  EC_OUT_OF_RANGE = 0x26,
191  EC_BUFFER_FULL = 0x27,
192  EC_FRAME_OVERFLOW = 0x28,
193  EC_SUBDEVICE_UNKNOWN = 0x29,
194  EC_PROXY_BUFFER_FULL = 0x2a, // this isn't included in the docs
195  } dmx_tri_error_codes;
196 
197  static const unsigned int DATA_OFFSET = 2; // first two bytes are CI & RC
198  static const uint8_t EXTENDED_COMMAND_LABEL = 88; // 'X'
199 
200  // The ms delay between checking on the RDM discovery process
201  static const unsigned int RDM_STATUS_INTERVAL_MS = 100;
202 };
203 
204 
205 /*
206  * A DMX TRI Widget
207  */
210  public:
212  ola::io::ConnectedDescriptor *descriptor,
213  unsigned int queue_size = 20,
214  bool use_raw_rdm = false);
215  ~DmxTriWidget();
216  void UseRawRDM(bool use_raw_rdm) { m_impl->UseRawRDM(use_raw_rdm); }
217 
218  void Stop() { m_impl->Stop(); }
219 
220  bool SendDMX(const DmxBuffer &buffer) const {
221  return m_impl->SendDMX(buffer);
222  }
223 
225  ola::rdm::RDMCallback *on_complete) {
226  m_controller->SendRDMRequest(request, on_complete);
227  }
228 
230  m_controller->RunFullDiscovery(callback);
231  }
232 
233  void RunIncrementalDiscovery(ola::rdm::RDMDiscoveryCallback *callback) {
234  m_controller->RunIncrementalDiscovery(callback);
235  }
236 
237  ola::io::ConnectedDescriptor *GetDescriptor() const {
238  return m_impl->GetDescriptor();
239  }
240 
241  private:
242  // we need to control the order of construction & destruction here so these
243  // are pointers.
244  DmxTriWidgetImpl *m_impl;
246 
247  void ResumeRDMCommands() {
248  m_controller->Resume();
249  }
250 };
251 } // namespace usbpro
252 } // namespace plugin
253 } // namespace ola
254 #endif // PLUGINS_USBPRO_DMXTRIWIDGET_H_