OpenCPN Partial API docs
Loading...
Searching...
No Matches
plugin_api.cpp
Go to the documentation of this file.
1/**************************************************************************
2 * Copyright (C) 2022 by David Register *
3 * Copyright (C) 2022 Alec Leamas *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
19 **************************************************************************/
20
26#include <memory>
27#include <sstream>
28#include <vector>
29
30#include <wx/event.h>
31#include <wx/fileconf.h>
32#include <wx/jsonval.h>
33#include <wx/jsonreader.h>
34#include <wx/tokenzr.h>
35
36#include "model/base_platform.h"
37#include "model/comm_appmsg.h"
38#include "model/comm_drv_loopback.h"
41#include "model/comm_drv_n2k.h"
45#include "ocpn_plugin.h"
47#include "model/comm_drv_n2k_net.h"
48#include "model/comm_drv_n2k_serial.h"
49using namespace std;
50
51vector<uint8_t> GetN2000Payload(NMEA2000Id id, ObservedEvt ev) {
52 auto msg = UnpackEvtPointer<Nmea2000Msg>(ev);
53 return msg->payload;
54}
55
57 auto msg = UnpackEvtPointer<Nmea2000Msg>(ev);
58 return msg->source->to_string();
59}
60
62 auto msg = UnpackEvtPointer<Nmea0183Msg>(ev);
63 return msg->payload;
64}
65
67 auto msg = UnpackEvtPointer<PluginMsg>(ev);
68 return msg->message;
69}
70
71std::shared_ptr<void> GetSignalkPayload(ObservedEvt ev) {
72 auto msg = UnpackEvtPointer<SignalkMsg>(ev);
73 wxJSONReader reader;
74 wxJSONValue data;
75 reader.Parse(wxString(msg->raw_message), &data);
76
77 wxJSONValue root(wxJSONTYPE_OBJECT);
78 root["Data"] = data;
79 root["ErrorCount"] = reader.GetErrorCount();
80 root["WarningCount"] = reader.GetWarningCount();
81
82 root["Errors"] = wxJSONValue(wxJSONTYPE_ARRAY);
83 for (size_t i = 0; i < reader.GetErrors().GetCount(); i++)
84 root["Errors"].Append(reader.GetErrors().Item(i));
85
86 root["Warnings"] = wxJSONValue(wxJSONTYPE_ARRAY);
87 for (size_t i = 0; i < reader.GetWarnings().GetCount(); i++)
88 root["Warnings"].Append(reader.GetWarnings().Item(i));
89
90 root["Context"] = msg->context;
91 root["ContextSelf"] = msg->context_self;
92
93 return static_pointer_cast<void>(std::make_shared<wxJSONValue>(root));
94}
95
96std::shared_ptr<PI_Notification> GetNotificationMsgPayload(NotificationMsgId id,
97 ObservedEvt ev) {
98 auto msg = UnpackEvtPointer<NotificationMsg>(ev);
99 auto note = msg->notification;
100 auto rv = std::make_shared<PI_Notification>(
101 (PI_NotificationSeverity)note->GetSeverity(), note->GetMessage(),
102 note->GetTimeoutStart(), note->GetTimeoutLeft(), note->GetGuid());
103 rv->action_verb = msg->action_verb;
104 return rv;
105}
106
107shared_ptr<ObservableListener> GetListener(NMEA2000Id id, wxEventType et,
108 wxEvtHandler* eh) {
109 return make_shared<ObservableListener>(Nmea2000Msg(id.id), eh, et);
110}
111
112std::shared_ptr<ObservableListener> GetListener(NMEA0183Id id, wxEventType et,
113 wxEvtHandler* eh) {
114 return make_shared<ObservableListener>(Nmea0183Msg(id.id), eh, et);
115}
116
117shared_ptr<ObservableListener> GetListener(SignalkId id, wxEventType et,
118 wxEvtHandler* eh) {
119 return make_shared<ObservableListener>(SignalkMsg(), eh, et);
120}
121
122shared_ptr<ObservableListener> GetListener(NavDataId id, wxEventType et,
123 wxEvtHandler* eh) {
124 return make_shared<ObservableListener>(BasicNavDataMsg(), eh, et);
125}
126
127std::shared_ptr<ObservableListener> GetListener(PluginMsgId id, wxEventType et,
128 wxEvtHandler* eh) {
129 return make_shared<ObservableListener>(PluginMsg(id.id, ""), eh, et);
130}
131
132std::shared_ptr<ObservableListener> GetListener(NotificationMsgId id,
133 wxEventType et,
134 wxEvtHandler* eh) {
135 return make_shared<ObservableListener>(NotificationMsg(), eh, et);
136}
137
139 auto msg = UnpackEvtPointer<BasicNavDataMsg>(ev);
140 PluginNavdata data;
141
142 data.lat = msg->pos.lat;
143 data.lon = msg->pos.lon;
144 data.sog = msg->sog;
145 data.cog = msg->cog;
146 data.var = msg->var;
147 data.hdt = msg->hdt;
148 data.time = msg->time;
149 return data;
150}
151
154std::vector<DriverHandle> GetActiveDrivers() {
155 std::vector<DriverHandle> result;
156
157 auto& registry = CommDriverRegistry::GetInstance();
158 const std::vector<DriverPtr>& drivers = registry.GetDrivers();
159
160 for (auto& driver : drivers) result.push_back(driver->Key());
161
162 return result;
163}
164
165const std::unordered_map<std::string, std::string> GetAttributes(
166 DriverHandle handle) {
167 auto& registry = CommDriverRegistry::GetInstance();
168 auto& drivers = registry.GetDrivers();
169 auto func = [handle](const DriverPtr d) { return d->Key() == handle; };
170 AbstractCommDriver* found = nullptr;
171 for (auto& d : drivers)
172 if (d->Key() == handle) found = d.get();
173 if (found)
174 return found->GetAttributes();
175 else
176 return {};
177}
178
180 DriverHandle handle, const std::shared_ptr<std::vector<uint8_t>>& payload) {
181 // Find the driver from the handle
182 auto& registry = CommDriverRegistry::GetInstance();
183 auto& drivers = registry.GetDrivers();
184 AbstractCommDriver* found = nullptr;
185 for (auto& d : drivers)
186 if (d->Key() == handle) found = d.get();
187 if (!found) {
189 }
190
191 // Determine protocol
192 std::unordered_map<std::string, std::string> attributes =
193 GetAttributes(handle);
194 auto protocol_it = attributes.find("protocol");
195 if (protocol_it == attributes.end()) return RESULT_COMM_INVALID_PARMS;
196 std::string protocol = protocol_it->second;
197
198 // This whole thing is a design collapse. If things were as they should,
199 // all drivers should have the same interface and there should be no
200 // need to handle different protocols separately. Part of the problem
201 // is that there is no "internal" driver.
202 if (protocol == "nmea0183") {
203 auto d0183 = dynamic_cast<CommDriverN0183*>(found); // FIXME (leamas)
204
205 std::string msg(payload->begin(), payload->end());
206 std::string id = msg.substr(1, 5);
207 auto address = std::make_shared<NavAddr>();
208 auto msg_out = std::make_shared<Nmea0183Msg>(id, msg, address);
209 bool xmit_ok = d0183->SendMessage(msg_out, address);
211 } else if (protocol == "internal") {
212 std::string msg(payload->begin(), payload->end());
213 size_t space_pos = msg.find(" ");
214 if (space_pos == std::string::npos) return RESULT_COMM_INVALID_PARMS;
215 auto plugin_msg = std::make_shared<PluginMsg>(msg.substr(0, space_pos),
216 msg.substr(space_pos + 1));
217 NavMsgBus::GetInstance().Notify(static_pointer_cast<NavMsg>(plugin_msg));
219 } else if (protocol == "loopback") {
220 std::string msg(payload->begin(), payload->end());
221 auto navmsg = LoopbackDriver::ParsePluginMessage(msg);
222 bool send_ok = found->SendMessage(navmsg, nullptr);
224 } else {
226 }
227}
228
230 DriverHandle handle, int PGN, int destinationCANAddress, int priority,
231 const std::shared_ptr<std::vector<uint8_t>>& payload) {
232 uint64_t _PGN;
233 _PGN = PGN;
234
235 // Find the driver from the handle
236 auto& registry = CommDriverRegistry::GetInstance();
237 auto& drivers = registry.GetDrivers();
238
239 AbstractCommDriver* found(nullptr);
240 for (auto& d : drivers)
241 if (d->Key() == handle) found = d.get();
242 if (!found) {
244 }
245 auto dest_addr =
246 std::make_shared<const NavAddr2000>(found->iface, destinationCANAddress);
247 auto msg =
248 std::make_shared<const Nmea2000Msg>(_PGN, *payload, dest_addr, priority);
249 bool result = found->SendMessage(msg, dest_addr);
250
252}
253
255 std::vector<int>& pgn_list) {
256 if (!pgn_list.size()) return RESULT_COMM_INVALID_PARMS;
257
258 // Find the driver from the handle
259 auto& registry = CommDriverRegistry::GetInstance();
260 auto& drivers = registry.GetDrivers();
261 AbstractCommDriver* found(nullptr);
262 for (auto& d : drivers)
263 if (d->Key() == handle) found = d.get();
264
265 if (!found) {
267 }
268 auto dn2k = dynamic_cast<CommDriverN2K*>(found);
269
270 int nloop = 0;
271 for (size_t i = 0; i < pgn_list.size(); i++) {
272 int nTry = 5;
273 int iresult = -1;
274 nloop = 0;
275 while (nTry && iresult < 0) {
276 iresult = dn2k->SetTXPGN(pgn_list[i]);
277 nTry--;
278 nloop++;
279 }
280 if (iresult < 0) {
282 }
283 }
285}
286
288 return g_BasePlatform->GetPrivateDataDirPtr();
289}
290
291void ReloadConfigConnections() {
292 // Close and delete all active comm drivers
293 auto& registry = CommDriverRegistry::GetInstance();
294 registry.CloseAllDrivers();
295
296 // Reload config file connections parameters.
297 wxFileConfig* pConf = GetOCPNConfigObject();
298 if (pConf) {
299 TheConnectionParams().clear();
300 pConf->SetPath(_T ( "/Settings/NMEADataSource" ));
301
302 wxString connectionconfigs;
303 pConf->Read(_T( "DataConnections" ), &connectionconfigs);
304 if (!connectionconfigs.IsEmpty()) {
305 wxArrayString confs = wxStringTokenize(connectionconfigs, _T("|"));
306 for (size_t i = 0; i < confs.Count(); i++) {
307 ConnectionParams* prm = new ConnectionParams(confs[i]);
308 if (!prm->Valid) continue;
309 TheConnectionParams().push_back(prm);
310 }
311 }
312 }
313
314 // Reconnect enabled connections
315 for (auto* cp : TheConnectionParams()) {
316 if (cp->bEnabled) {
317 MakeCommDriver(cp);
318 cp->b_IsSetup = TRUE;
319 }
320 }
321}
322
328 const std::string& _message,
329 int _timeout_start, int _timeout_left,
330 std::string _guid) {
331 severity = _severity;
332 message = _message;
333 auto_timeout_start = _timeout_start;
334 auto_timeout_left = _timeout_left;
335 guid = _guid;
336}
337
338int GetActiveNotificationCount() {
339 auto& noteman = NotificationManager::GetInstance();
340 return noteman.GetNotificationCount();
341}
342
343PI_NotificationSeverity GetMaxActiveNotificationLevel() {
344 auto& noteman = NotificationManager::GetInstance();
345 if (noteman.GetNotificationCount())
346 return (PI_NotificationSeverity)noteman.GetMaxSeverity();
347 else
348 return (PI_NotificationSeverity)-1;
349}
350
351std::string RaiseNotification(const PI_NotificationSeverity _severity,
352 const std::string& _message, int timeout_secs) {
353 auto& noteman = NotificationManager::GetInstance();
354 auto notification = std::make_shared<Notification>(
355 (NotificationSeverity)_severity, _message, timeout_secs);
356 return noteman.AddNotification(notification);
357}
358
359bool AcknowledgeNotification(const std::string& guid) {
360 auto& noteman = NotificationManager::GetInstance();
361 return noteman.AcknowledgeNotification(guid);
362}
363
364std::vector<std::shared_ptr<PI_Notification>> GetActiveNotifications() {
365 auto& noteman = NotificationManager::GetInstance();
366 std::vector<std::shared_ptr<PI_Notification>> pi_notes;
367 for (auto note : noteman.GetNotifications()) {
368 auto pi_note = std::make_shared<PI_Notification>(
369 (PI_NotificationSeverity)note->GetSeverity(), note->GetMessage(),
370 note->GetTimeoutStart(), note->GetTimeoutLeft(), note->GetGuid());
371 pi_notes.push_back(pi_note);
372 }
373
374 return pi_notes;
375}
376
380PI_Comm_Status GetConnState(const std::string& iface, PI_Conn_Bus _bus) {
381 // Translate API bus to internal NavAddr::Bus
382 NavAddr::Bus ibus = NavAddr::Bus::Undef;
383 switch (_bus) {
384 case PI_Conn_Bus::N0183:
385 ibus = NavAddr::Bus::N0183;
386 break;
387
388 case PI_Conn_Bus::Signalk:
389 ibus = NavAddr::Bus::Signalk;
390 break;
391
392 case PI_Conn_Bus::N2000:
393 ibus = NavAddr::Bus::N2000;
394 break;
395
396 default:
397 break;
398 }
399
400 DriverStats stats;
401 if (ibus != NavAddr::Bus::Undef) {
402 auto& registry = CommDriverRegistry::GetInstance();
403 auto& drivers = registry.GetDrivers();
404 auto& found_driver = FindDriver(drivers, iface, ibus);
405 if (found_driver) {
406 auto stats_provider =
407 dynamic_cast<DriverStatsProvider*>(found_driver.get());
408 if (stats_provider) {
409 stats = stats_provider->GetDriverStats();
410 }
411 }
412 }
413
415 if (stats.available) {
416 if (stats.rx_count)
417 rv.state = PI_Comm_State::Ok;
418 else
419 rv.state = PI_Comm_State::NoData;
420 } else
421 rv.state = PI_Comm_State::Unavailable;
422
423 rv.rx_count = stats.rx_count;
424 rv.tx_count = stats.tx_count;
425 rv.error_count = stats.error_count;
426
427 return rv;
428}
Common interface for all drivers.
Definition comm_driver.h:67
const std::string iface
Physical device for 0183, else a unique string.
Definition comm_driver.h:97
wxString * GetPrivateDataDirPtr()
Legacy compatibility syntactic sugar for GetPrivateDataDir().
NMEA0183 basic parsing common parts:
Driver interface providing driver statistics.
static std::shared_ptr< const NavMsg > ParsePluginMessage(const std::string &msg)
Parse a string as provided by plugin and convert to a navmsg.
void Notify(std::shared_ptr< const NavMsg > message)
Accept message received by driver, make it available for upper layers.
A regular Nmea0183 message.
See: https://github.com/OpenCPN/OpenCPN/issues/2729#issuecomment-1179506343.
Custom event class for OpenCPN's notification system.
unsigned error_count
Number of detected errors since program start.
unsigned tx_count
Number of bytes sent since program start.
unsigned rx_count
Number of bytes received since program start.
PI_Notification(PI_NotificationSeverity _severity, const std::string &_message, int _timeout_start, int _timeout_left, std::string _guid)
Plugin Notification Framework support.
A plugin to plugin json message over the REST interface.
A parsed SignalK message over ipv4.
The JSON parser.
Definition jsonreader.h:50
const wxArrayString & GetWarnings() const
Return a reference to the warning message's array.
const wxArrayString & GetErrors() const
Return a reference to the error message's array.
int GetErrorCount() const
Return the size of the error message's array.
int GetWarningCount() const
Return the size of the warning message's array.
int Parse(const wxString &doc, wxJSONValue *val)
Parse the JSON document.
The JSON value class implementation.
Definition jsonval.h:84
void MakeCommDriver(const ConnectionParams *params)
Create and register a driver for given connection.
Communication drivers factory and support.
NMEA0183 over IP driver.
NMEA0183 serial driver.
DriverPtr & FindDriver(const std::vector< DriverPtr > &drivers, const std::string &iface, const NavAddr::Bus _bus)
Search list of drivers for a driver with given interface string.
Driver registration container, a singleton.
Raw messages layer, supports sending and recieving navmsg messages.
Class NotificationManager.
PlugIn Object Definition/API.
CommDriverResult
Error return values
@ RESULT_COMM_INVALID_PARMS
Invalid parameters provided to operation.
@ RESULT_COMM_TX_ERROR
Error occurred during transmission.
@ RESULT_COMM_REGISTER_PGN_ERROR
Failed to register PGN parameters.
@ RESULT_COMM_NO_ERROR
Operation completed successfully.
@ RESULT_COMM_INVALID_HANDLE
Invalid or unknown driver handle specified.
PI_NotificationSeverity
Plugin Notification Framework support.
std::string DriverHandle
Plugin API supporting direct access to comm drivers for output purposes.
wxFileConfig * GetOCPNConfigObject(void)
Gets OpenCPN's configuration object.
PI_Comm_Status GetConnState(const std::string &iface, PI_Conn_Bus _bus)
Plugin polled Comm Status support.
std::string GetPluginMsgPayload(PluginMsgId id, ObservedEvt ev)
Retrieve the string in a plugin message, internal or received on the REST insterface.
std::string GetN0183Payload(NMEA0183Id id, ObservedEvt ev)
Return payload in a received n0183 message of type id in ev.
PluginNavdata GetEventNavdata(ObservedEvt ev)
Return BasicNavDataMsg decoded data available in ev.
std::shared_ptr< PI_Notification > GetNotificationMsgPayload(NotificationMsgId id, ObservedEvt ev)
Retrieve the Notification Event in a Notification message.
CommDriverResult WriteCommDriverN2K(DriverHandle handle, int PGN, int destinationCANAddress, int priority, const std::shared_ptr< std::vector< uint8_t > > &payload)
Send a PGN message to an NMEA2000 address.
shared_ptr< ObservableListener > GetListener(NMEA2000Id id, wxEventType et, wxEvtHandler *eh)
Gets listener for NMEA 2000 messages.
std::vector< DriverHandle > GetActiveDrivers()
Comm port plugin TX support methods
const std::unordered_map< std::string, std::string > GetAttributes(DriverHandle handle)
Query a specific driver for attributes.
std::string GetN2000Source(NMEA2000Id id, ObservedEvt ev)
Return source identifier (iface) of a received n2000 message of type id in ev.
vector< uint8_t > GetN2000Payload(NMEA2000Id id, ObservedEvt ev)
Return N2K payload for a received n2000 message of type id in ev.
std::shared_ptr< void > GetSignalkPayload(ObservedEvt ev)
Get SignalK status payload after receiving a message.
wxString * GetpPrivateApplicationDataLocation(void)
Gets private application data directory.
CommDriverResult WriteCommDriver(DriverHandle handle, const std::shared_ptr< std::vector< uint8_t > > &payload)
Send a non-NMEA2000 message.
CommDriverResult RegisterTXPGNs(DriverHandle handle, std::vector< int > &pgn_list)
Register PGNs that this application intends to transmit for some NMEA 2000 adapters like Actisense NG...
Driver statistics report.
unsigned tx_count
Number of bytes sent since program start.
unsigned rx_count
Number of bytes received since program start.
unsigned error_count
Number of detected errors since program start.
Identifier for NMEA 0183 sentence types.
Identifier for NMEA 2000 message types.
Navigation data message identifier.
Facade for NotificationMsg.
Facade for NavAddrPluginMsg.
Basic navigation data structure.
double lat
Latitude in decimal degrees.
Identifier for Signal K paths.