Open Lighting Architecture: include/olad/Universe.h Source File

| Open Lighting Architecture 0.10.9

Loading...
Searching...
No Matches
Universe.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 * Universe.h
17 * Header file for the Universe class, see Universe.cpp for details.
18 * Copyright (C) 2005 Simon Newton
19 */
20
21#ifndef INCLUDE_OLAD_UNIVERSE_H_
22#define INCLUDE_OLAD_UNIVERSE_H_
23
24#include <ola/Clock.h>
25#include <ola/DmxBuffer.h>
26#include <ola/ExportMap.h>
27#include <ola/base/Macro.h>
28#include <ola/rdm/RDMCommand.h>
29#include <ola/rdm/RDMControllerInterface.h>
30#include <ola/rdm/UID.h>
31#include <ola/rdm/UIDSet.h>
32#include <ola/util/SequenceNumber.h>
33#include <olad/DmxSource.h>
34
35#include <set>
36#include <map>
37#include <vector>
38#include <string>
39
40namespace ola {
41
42class Client;
43class InputPort;
44class OutputPort;
45
46 class Universe: public ola::rdm::RDMControllerInterface {
47 public:
48 enum merge_mode {
49 MERGE_HTP,
50 MERGE_LTP
51 };
52
53 Universe(unsigned int uid, class UniverseStore *store,
54 ExportMap *export_map,
55 Clock *clock);
56 ~Universe();
57
58 // Properties for this universe
59 std::string Name() const { return m_universe_name; }
60 unsigned int UniverseId() const { return m_universe_id; }
61 merge_mode MergeMode() const { return m_merge_mode; }
62 bool IsActive() const;
63 uint8_t ActivePriority() const { return m_active_priority; }
64
70 const TimeInterval& RDMDiscoveryInterval() const {
71 return m_rdm_discovery_interval;
72 }
73
77 const TimeStamp& LastRDMDiscovery() const {
78 return m_last_discovery_time;
79 }
80
81 // Used to adjust the properties
82 void SetName(const std::string &name);
83 void SetMergeMode(merge_mode merge_mode);
84
88 void SetRDMDiscoveryInterval(const TimeInterval &discovery_interval) {
89 m_rdm_discovery_interval = discovery_interval;
90 }
91
92 // Each universe has a DMXBuffer
93 bool SetDMX(const DmxBuffer &buffer);
94 const DmxBuffer &GetDMX() const { return m_buffer; }
95
96 // These are the ports we need to notify when data changes
97 bool AddPort(InputPort *port);
98 bool AddPort(OutputPort *port);
99 bool RemovePort(InputPort *port);
100 bool RemovePort(OutputPort *port);
101 bool ContainsPort(InputPort *port) const;
102 bool ContainsPort(OutputPort *port) const;
103 unsigned int InputPortCount() const { return m_input_ports.size(); }
104 unsigned int OutputPortCount() const { return m_output_ports.size(); }
105 void InputPorts(std::vector<InputPort*> *ports) const;
106 void OutputPorts(std::vector<OutputPort*> *ports) const;
107
108 // Source clients are those that provide us with data
109 bool AddSourceClient(Client *client);
110 bool RemoveSourceClient(Client *client);
111 bool ContainsSourceClient(Client *client) const;
112 unsigned int SourceClientCount() const { return m_source_clients.size(); }
113
114 // Sink clients are those that we need to send data
115 bool AddSinkClient(Client *client);
116 bool RemoveSinkClient(Client *client);
117 bool ContainsSinkClient(Client *client) const;
118 unsigned int SinkClientCount() const { return m_sink_clients.size(); }
119
120 // These are called when new data arrives on a port/client
121 bool PortDataChanged(InputPort *port);
122 bool SourceClientDataChanged(Client *client);
123
124 // This is can be called periodically to clean stale clients
125 // stale == client that has not sent data
126 void CleanStaleSourceClients();
127
128 // RDM methods
129 void SendRDMRequest(ola::rdm::RDMRequest *request,
130 ola::rdm::RDMCallback *callback);
131 void RunRDMDiscovery(ola::rdm::RDMDiscoveryCallback *on_complete,
132 bool full = true);
133 void NewUIDList(OutputPort *port, const ola::rdm::UIDSet &uids);
134 void GetUIDs(ola::rdm::UIDSet *uids) const;
135 unsigned int UIDCount() const;
136 uint8_t GetRDMTransactionNumber();
137
138 bool operator==(const Universe &other) {
139 return m_universe_id == other.UniverseId();
140 }
141
142 static const char K_FPS_VAR[];
143 static const char K_MERGE_HTP_STR[];
144 static const char K_MERGE_LTP_STR[];
145 static const char K_UNIVERSE_INPUT_PORT_VAR[];
146 static const char K_UNIVERSE_MODE_VAR[];
147 static const char K_UNIVERSE_NAME_VAR[];
148 static const char K_UNIVERSE_OUTPUT_PORT_VAR[];
149 static const char K_UNIVERSE_RDM_REQUESTS[];
150 static const char K_UNIVERSE_SINK_CLIENTS_VAR[];
151 static const char K_UNIVERSE_SOURCE_CLIENTS_VAR[];
152 static const char K_UNIVERSE_UID_COUNT_VAR[];
153
154 private:
155 typedef struct {
156 unsigned int expected_count;
157 unsigned int current_count;
158 ola::rdm::RDMStatusCode status_code;
159 ola::rdm::RDMCallback *callback;
160 std::vector<rdm::RDMFrame> frames;
161 } broadcast_request_tracker;
162
163 typedef std::map<Client*, bool> SourceClientMap;
164
165 std::string m_universe_name;
166 unsigned int m_universe_id;
167 std::string m_universe_id_str;
168 uint8_t m_active_priority;
169 enum merge_mode m_merge_mode; // merge mode
170 std::vector<InputPort*> m_input_ports;
171 std::vector<OutputPort*> m_output_ports;
172 std::set<Client*> m_sink_clients; // clients that require updates
177 SourceClientMap m_source_clients;
178 class UniverseStore *m_universe_store;
179 DmxBuffer m_buffer;
180 ExportMap *m_export_map;
181 std::map<ola::rdm::UID, OutputPort*> m_output_uids;
182 Clock *m_clock;
183 TimeInterval m_rdm_discovery_interval;
184 TimeStamp m_last_discovery_time;
185 ola::SequenceNumber<uint8_t> m_transaction_number_sequence;
186
187 void HandleBroadcastAck(broadcast_request_tracker *tracker,
188 ola::rdm::RDMReply *reply);
189 void HandleBroadcastDiscovery(broadcast_request_tracker *tracker,
190 ola::rdm::RDMReply *reply);
191 bool UpdateDependants();
192 void UpdateName();
193 void UpdateMode();
194 void HTPMergeSources(const std::vector<DmxSource> &sources);
195 bool MergeAll(const InputPort *port, const Client *client);
196 void PortDiscoveryComplete(BaseCallback0<void> *on_complete,
197 OutputPort *output_port,
198 const ola::rdm::UIDSet &uids);
199 void DiscoveryComplete(ola::rdm::RDMDiscoveryCallback *on_complete);
200
201 void SafeIncrement(const std::string &name);
202 void SafeDecrement(const std::string &name);
203
204 template<class PortClass>
205 bool GenericAddPort(PortClass *port,
206 std::vector<PortClass*> *ports);
207
208 template<class PortClass>
209 bool GenericRemovePort(PortClass *port,
210 std::vector<PortClass*> *ports,
211 std::map<ola::rdm::UID, PortClass*> *uid_map = NULL);
212
213 template<class PortClass>
214 bool GenericContainsPort(PortClass *port,
215 const std::vector<PortClass*> &ports) const;
216
217 Universe(const Universe &) = delete;
218 const Universe &operator=(const Universe &) = delete;
219};
220} // namespace ola
221#endif // INCLUDE_OLAD_UNIVERSE_H_
DmxBuffer.h
A class used to hold a single universe of DMX data.
ExportMap.h
Export variables on the http server.
Macro.h
Helper macros.
RDMCommand.h
Classes that represent RDM commands.
RDMControllerInterface.h
Definitions and Interfaces to implement an RDMController that sends a single message at a time.
UID.h
A RDM unique identifier (UID).
UIDSet.h
A set of UIDs.
ola::Client
Represents a connected OLA client on the OLA server side.
Definition Client.h:46
ola::Clock
Used to get the current time.
Definition Clock.h:230
ola::DmxBuffer
Used to hold a single universe of DMX data.
Definition DmxBuffer.h:49
ola::ExportMap
A container for the exported variables.
Definition ExportMap.h:324
ola::InputPort
A port that receives DMX512 data.
Definition Port.h:137
ola::OutputPort
A port that sends DMX512 data.
Definition Port.h:163
ola::TimeInterval
Definition Clock.h:126
ola::TimeStamp
Definition Clock.h:179
ola::Universe::UIDCount
unsigned int UIDCount() const
Definition Universe.cpp:607
ola::Universe::CleanStaleSourceClients
void CleanStaleSourceClients()
Clean old source clients.
Definition Universe.cpp:432
ola::Universe::SetRDMDiscoveryInterval
void SetRDMDiscoveryInterval(const TimeInterval &discovery_interval)
Definition Universe.h:88
ola::Universe::LastRDMDiscovery
const TimeStamp & LastRDMDiscovery() const
Get the time of the last discovery run.
Definition Universe.h:77
ola::Universe::SendRDMRequest
void SendRDMRequest(ola::rdm::RDMRequest *request, ola::rdm::RDMCallback *callback)
Send a RDM command.
Definition Universe.cpp:456
ola::Universe::GetRDMTransactionNumber
uint8_t GetRDMTransactionNumber()
Definition Universe.cpp:614
ola::Universe::RDMDiscoveryInterval
const TimeInterval & RDMDiscoveryInterval() const
Return the time between RDM discovery operations.
Definition Universe.h:70
ola::UniverseStore
Maintains a collection of Universe objects.
Definition UniverseStore.h:39
ola::rdm::RDMControllerInterface
The interface that can send RDMRequest.
Definition RDMControllerInterface.h:73
ola::rdm::RDMStatusCode
RDMStatusCode
RDM Status Codes.
Definition RDMResponseCodes.h:45
ola::rdm::RDMCallback
ola::BaseCallback1< void, RDMReply * > RDMCallback
The callback run when a RDM request completes.
Definition RDMControllerInterface.h:52
ola::rdm::RDMDiscoveryCallback
ola::BaseCallback1< void, const ola::rdm::UIDSet & > RDMDiscoveryCallback
The callback run when a discovery operation completes.
Definition RDMControllerInterface.h:68
ola
The namespace containing all OLA symbols.
Definition Credentials.cpp:44