698 lines
26 KiB
Text
698 lines
26 KiB
Text
#---------------------------------------------------------------------------
|
|
#
|
|
# Title : EMESARY inter-object communication
|
|
#
|
|
# File Type : Implementation File
|
|
#
|
|
# Description : Provides generic inter-object communication. For an object to receive a message it
|
|
# : must first register with an instance of a Transmitter, and provide a Receive method
|
|
#
|
|
# : To send a message use a Transmitter with an object. That's all there is to it.
|
|
#
|
|
# References : http://chateau-logic.com/content/emesary-nasal-implementation-flightgear
|
|
# : http://www.chateau-logic.com/content/class-based-inter-object-communication
|
|
# : http://chateau-logic.com/content/emesary-efficient-inter-object-communication-using-interfaces-and-inheritance
|
|
# : http://chateau-logic.com/content/c-wpf-application-plumbing-using-emesary
|
|
#
|
|
# Author : Richard Harrison (richard@zaretto.com)
|
|
#
|
|
# Creation Date : 29 January 2016
|
|
#
|
|
# Version : 4.8
|
|
#
|
|
# Copyright © 2016 Richard Harrison Released under GPL V2
|
|
#
|
|
#---------------------------------------------------------------------------
|
|
# Classes in this file:
|
|
# Transmitter
|
|
# Notification
|
|
# Recipient
|
|
#---------------------------------------------------------------------------*/
|
|
|
|
var __emesaryUniqueId = 14; # 0-15 are reserved, this way the global transmitter will be 15.
|
|
|
|
# add registry so we can find a transmitter by name in genericEmesaryGlobalTransmitterTransmit
|
|
var _transmitters = std.Hash.new({}, "transmitters");
|
|
|
|
var _registerTransmitter = func (key, t) {
|
|
_transmitters.set(key, t);
|
|
}
|
|
var getTransmitter = func (key) {
|
|
return _transmitters.get(key);
|
|
}
|
|
|
|
# Transmitters send notifications to all recipients that are registered.
|
|
var Transmitter =
|
|
{
|
|
ReceiptStatus_OK : 0, # Processing completed successfully
|
|
ReceiptStatus_Fail : 1, # Processing resulted in at least one failure
|
|
ReceiptStatus_Abort : 2, # Fatal error, stop processing any further recipients of this message. Implicitly failed.
|
|
ReceiptStatus_Finished : 3, # Definitive completion - do not send message to any further recipients
|
|
ReceiptStatus_NotProcessed : 4,# Return value when method doesn't process a message.
|
|
ReceiptStatus_Pending : 5, # Message sent with indeterminate return status as processing underway
|
|
ReceiptStatus_PendingFinished : 6,# Message definitively handled, status indeterminate. The message will not be sent any further
|
|
|
|
# create a new transmitter. shouldn't need many of these
|
|
# _ident: string; name of the transmitter, used in debug messages
|
|
new: func(_ident)
|
|
{
|
|
if (!isscalar(_ident)) {
|
|
logprint(LOG_ALERT, "Transmitter.new: argument must be a scalar!")
|
|
}
|
|
__emesaryUniqueId += 1;
|
|
var new_class = {
|
|
parents : [Transmitter],
|
|
Recipients : [],
|
|
Ident : _ident,
|
|
Timestamp : nil,
|
|
MaxMilliseconds : 1,
|
|
UniqueId: __emesaryUniqueId,
|
|
};
|
|
_registerTransmitter(_ident, new_class);
|
|
return new_class;
|
|
},
|
|
|
|
OverrunDetection: func(max_ms=0){
|
|
if (isnum(max_ms) and max_ms) {
|
|
if (me.Timestamp == nil)
|
|
me.Timestamp = maketimestamp();
|
|
me.MaxMilliseconds = max_ms;
|
|
logprint(LOG_INFO, "Set overrun detection ",me.Ident, " to ", me.MaxMilliseconds);
|
|
return 1;
|
|
} else {
|
|
# me.Timestamp = nil;
|
|
me.MaxMilliseconds = 0;
|
|
logprint(LOG_INFO, "Disable overrun detection ",me.Ident);
|
|
return 0;
|
|
}
|
|
},
|
|
|
|
# Add a recipient to receive notifications from this transmitter
|
|
Register: func (recipient)
|
|
{
|
|
# not inheriting from Recipient is maybe strange but will not crash
|
|
if (!isa(recipient, Recipient))
|
|
{
|
|
logprint(LOG_INFO, "Transmitter.Register: argument is not a Recipient object");
|
|
}
|
|
#not having a Receive function is an error
|
|
if (!isfunc(recipient["Receive"]))
|
|
{
|
|
logprint(DEV_ALERT, "Transmitter.Register: Error, argument has no Receive method!");
|
|
return 0;
|
|
}
|
|
foreach (var r; me.Recipients)
|
|
{
|
|
if (r == recipient) {
|
|
logprint(DEV_ALERT, "Transmitter.Register: Recipient already registered!");
|
|
return 1;
|
|
}
|
|
}
|
|
append(me.Recipients, recipient);
|
|
return 1;
|
|
},
|
|
|
|
DeleteAllRecipients: func
|
|
{
|
|
me.Recipients = [];
|
|
},
|
|
|
|
# Stops a recipient from receiving notifications from this transmitter.
|
|
DeRegister: func(todelete_recipient)
|
|
{
|
|
var out_idx = 0;
|
|
var element_deleted = 0;
|
|
|
|
for (var idx = 0; idx < size(me.Recipients); idx += 1)
|
|
{
|
|
if (me.Recipients[idx] != todelete_recipient)
|
|
{
|
|
me.Recipients[out_idx] = me.Recipients[idx];
|
|
out_idx = out_idx + 1;
|
|
}
|
|
else
|
|
element_deleted = 1;
|
|
}
|
|
|
|
if (element_deleted)
|
|
pop(me.Recipients);
|
|
},
|
|
|
|
RecipientCount: func
|
|
{
|
|
return size(me.Recipients);
|
|
},
|
|
|
|
PrintRecipients: func
|
|
{
|
|
print("Emesary: Recipient list for ",me.Ident,"(",me.UniqueId,")");
|
|
for (var idx = 0; idx < size(me.Recipients); idx += 1)
|
|
print("Emesary: Recipient[",idx,"] ",me.Recipients[idx].Ident," (",me.Recipients[idx].UniqueId,")");
|
|
},
|
|
|
|
# Notify all registered recipients. Stop when receipt status of abort or finished are received.
|
|
# The receipt status from this method will be
|
|
# - OK > message handled
|
|
# - Fail > message not handled. A status of Abort from a recipient will result in our status
|
|
# being fail as Abort means that the message was not and cannot be handled, and
|
|
# allows for usages such as access controls.
|
|
# message: hash; Notification passed to the Receive() method of registered recipients
|
|
NotifyAll: func(message)
|
|
{
|
|
if (!isa(message, Notification))
|
|
{
|
|
logprint(DEV_ALERT, "Transmitter.NotifyAll: argument must be a Notification!");
|
|
return Transmitter.ReceiptStatus_NotProcessed;
|
|
}
|
|
me._return_status = Transmitter.ReceiptStatus_NotProcessed;
|
|
me.TimeTaken = 0;
|
|
foreach (var recipient; me.Recipients)
|
|
{
|
|
if (recipient.RecipientActive)
|
|
{
|
|
me._rstat = nil;
|
|
if (me.MaxMilliseconds > 0 and me.Timestamp != nil)
|
|
me.Timestamp.stamp();
|
|
|
|
message.Timestamp = me.Timestamp;
|
|
call(func {me._rstat = recipient.Receive(message);},nil,nil,nil,var err = []);
|
|
|
|
if (size(err)){
|
|
foreach(var line; err) {
|
|
print(line);
|
|
}
|
|
logprint(LOG_ALERT, "Recipient ",recipient.Ident,
|
|
" has been removed from transmitter (", me.Ident,
|
|
") because of the above error");
|
|
me.DeRegister(recipient);
|
|
#need to break the foreach due to having modified what its iterating over.
|
|
return Transmitter.ReceiptStatus_Abort;
|
|
}
|
|
if (me.Timestamp != nil) {
|
|
recipient.TimeTaken = me.Timestamp.elapsedUSec()/1000.0;
|
|
me.TimeTaken += recipient.TimeTaken;
|
|
}
|
|
|
|
if(me._rstat == Transmitter.ReceiptStatus_Fail)
|
|
{
|
|
me._return_status = Transmitter.ReceiptStatus_Fail;
|
|
}
|
|
elsif(me._rstat == Transmitter.ReceiptStatus_Pending)
|
|
{
|
|
me._return_status = Transmitter.ReceiptStatus_Pending;
|
|
}
|
|
elsif(me._rstat == Transmitter.ReceiptStatus_PendingFinished)
|
|
{
|
|
return me._rstat;
|
|
}
|
|
# elsif(rstat == Transmitter.ReceiptStatus_NotProcessed)
|
|
# {
|
|
# ;
|
|
# }
|
|
elsif(me._rstat == Transmitter.ReceiptStatus_OK)
|
|
{
|
|
if (me._return_status == Transmitter.ReceiptStatus_NotProcessed)
|
|
me._return_status = me._rstat;
|
|
}
|
|
elsif(me._rstat == Transmitter.ReceiptStatus_Abort)
|
|
{
|
|
# this is a final results, e.g. no more recipients will be
|
|
# notified but the result is returned as NotifyAll result.
|
|
return Transmitter.ReceiptStatus_Abort;
|
|
}
|
|
elsif(me._rstat == Transmitter.ReceiptStatus_Finished)
|
|
{
|
|
# this is a final results, e.g. no more recipients will be
|
|
# notified but the result is returned as NotifyAll result.
|
|
return Transmitter.ReceiptStatus_OK;
|
|
}
|
|
}
|
|
}
|
|
if (me.MaxMilliseconds and me.TimeTaken > me.MaxMilliseconds) {
|
|
logprint(LOG_WARN, sprintf("Overrun: %s ['%s'] %1.2fms max (%d)",
|
|
me.Ident, message.NotificationType, me.TimeTaken, me.MaxMilliseconds));
|
|
foreach (var recipient; me.Recipients) {
|
|
if (recipient.TimeTaken) {
|
|
logprint(LOG_WARN, sprintf(" -- Recipient %25s %7.2f ms",
|
|
recipient.Ident, recipient.TimeTaken));
|
|
}
|
|
}
|
|
}
|
|
return me._return_status;
|
|
},
|
|
|
|
# Returns true if a return value from NotifyAll is to be considered a failure.
|
|
IsFailed: func(receiptStatus)
|
|
{
|
|
# Failed is either Fail or Abort.
|
|
# NotProcessed isn't a failure because it hasn't been processed.
|
|
if (receiptStatus == Transmitter.ReceiptStatus_Fail or receiptStatus == Transmitter.ReceiptStatus_Abort)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
var QueuedTransmitter =
|
|
{
|
|
new: func(_ident){
|
|
var new_class = { parents:[QueuedTransmitter], base:emesary.Transmitter};
|
|
new_class = emesary.Transmitter.new(_ident);
|
|
new_class.baseNotifyAll = new_class.NotifyAll;
|
|
new_class.Q = [];
|
|
|
|
new_class.NotifyAll = func(message){
|
|
append(me.Q, message);
|
|
return emesary.Transmitter.ReceiptStatus_Pending;
|
|
};
|
|
|
|
new_class.Process = func {
|
|
foreach (var m ; me.Q)
|
|
me.baseNotifyAll(m);
|
|
me.Q = [];
|
|
return emesary.Transmitter.ReceiptStatus_PendingFinished;
|
|
};
|
|
new_class.size = func {
|
|
return size(me.Q);
|
|
}
|
|
return new_class;
|
|
}
|
|
};
|
|
|
|
|
|
#---------------------------------------------------------------------------
|
|
# Notification - base class
|
|
# By convention a Notification has a type and a value. Derived classes can add
|
|
# extra properties or methods.
|
|
#
|
|
# NotificationType: Notification Type
|
|
# Ident: Can be an ident, or for simple messages a value that needs transmitting.
|
|
# IsDistinct: non zero if this message supercedes previous messages of this type.
|
|
# Distinct messages are usually sent often and self contained
|
|
# (i.e. no relative state changes such as toggle value)
|
|
# Messages that indicate an event (such as after a pilot action)
|
|
# will usually be non-distinct. So an example would be gear/up down
|
|
# or ATC acknowledgements that all need to be transmitted
|
|
# The IsDistinct is important for any messages that are bridged over MP as
|
|
# only the most recently sent distinct message will be transmitted over MP.
|
|
# Example:
|
|
# position update, where only current position is relevant -> IsDistinct=1;
|
|
# 0 = queue all messages for MP bridging
|
|
# 1 = queue only latest message (replace any old message of same type+ident)
|
|
#
|
|
var TypeIdUnspecified = 1;
|
|
var NotificationAutoTypeId = 1;
|
|
var Notification =
|
|
{
|
|
new: func(_type, _ident, _typeid=0)
|
|
{
|
|
if (!isscalar(_type)) {
|
|
logprint(DEV_ALERT, "Notification.new: _type must be a scalar!");
|
|
return nil;
|
|
}
|
|
if (!isscalar(_ident)) {
|
|
logprint(DEV_ALERT, "Notification.new: _ident is not scalar but ", typeof(_ident));
|
|
return nil;
|
|
}
|
|
|
|
if (_typeid == 0) {
|
|
NotificationAutoTypeId += 1;
|
|
# IDs >= 16 are reserved; see http://wiki.flightgear.org/Emesary_Notifications
|
|
if (NotificationAutoTypeId == 16) {
|
|
logprint(LOG_ALERT, "Notification: AutoTypeID limit exceeded: "~NotificationAutoTypeId);
|
|
return nil;
|
|
}
|
|
_typeid = NotificationAutoTypeId;
|
|
}
|
|
|
|
var new_class = {
|
|
parents: [Notification],
|
|
NotificationType: _type,
|
|
Ident: _ident,
|
|
IsDistinct: 1, #1: MP bridge only latest notification
|
|
FromIncomingBridge: 0,
|
|
Callsign: nil,
|
|
TypeId: _typeid, # used in MP bridged
|
|
};
|
|
return new_class;
|
|
},
|
|
|
|
setType: func(_type) {
|
|
if (!isscalar(_type)) {
|
|
logprint(DEV_ALERT, "Notification.new: _type must be a scalar!");
|
|
return nil;
|
|
}
|
|
me.NotificationType = _type;
|
|
return me;
|
|
},
|
|
|
|
setIdent: func(_ident) {
|
|
if (!isscalar(_ident)) {
|
|
logprint(DEV_ALERT, "Notification.new: _ident is not scalar but ", typeof(_ident));
|
|
return nil;
|
|
}
|
|
me.Ident = _ident;
|
|
return me;
|
|
},
|
|
|
|
GetBridgeMessageNotificationTypeKey: func {
|
|
return me.NotificationType~"."~me.Ident;
|
|
},
|
|
};
|
|
|
|
#---------------------------------------------------------------------------
|
|
# Recipient - base class for receiving notifications.
|
|
#
|
|
# You have to implement the Receive method
|
|
# The Receive method must return a sensible ReceiptStatus_* code
|
|
var Recipient =
|
|
{
|
|
new: func(_ident)
|
|
{
|
|
if (_ident == nil or _ident == "")
|
|
{
|
|
_ident = id(new_class);
|
|
logprint(LOG_WARN, "Emesary Error: Ident required when creating a recipient, defaulting to ", _ident);
|
|
}
|
|
__emesaryUniqueId += 1;
|
|
var new_class = {
|
|
parents: [Recipient],
|
|
Ident: _ident,
|
|
RecipientActive: 1,
|
|
UniqueId: __emesaryUniqueId,
|
|
};
|
|
return new_class;
|
|
},
|
|
|
|
Receive: func(notification)
|
|
{
|
|
logprint(DEV_ALERT, "Emesary Error: Receive function not implemented in recipient ", me.Ident);
|
|
return Transmitter.ReceiptStatus_NotProcessed;
|
|
},
|
|
|
|
setReceive: func(f)
|
|
{
|
|
if (isfunc(f)) { me.Receive = f; }
|
|
else { logprint(DEV_ALERT, "Recipient.addReceive: argument must be a function!"); }
|
|
return me;
|
|
},
|
|
};
|
|
|
|
#
|
|
# Instantiate a Global Transmitter, this is a convenience and a known starting point.
|
|
# Generally most classes will use this transmitters, however other transmitters
|
|
# can be created and merely use the global transmitter to discover each other.
|
|
var GlobalTransmitter = Transmitter.new("GlobalTransmitter");
|
|
|
|
#
|
|
# Base method of transferring all numeric based values.
|
|
# Using the same techinque as base64 - except this is base248 because we can use a much wider range of characters.
|
|
#
|
|
var BinaryAsciiTransfer =
|
|
{
|
|
#excluded chars 32 (<space>), 33 (!), 35 (#), 36($), 126 (~), 127 (<del>)
|
|
alphabet :
|
|
chr(1) ~chr(2) ~chr(3) ~chr(4) ~chr(5) ~chr(6) ~chr(7) ~chr(8) ~chr(9)
|
|
~chr(10)~chr(11)~chr(12)~chr(13)~chr(14)~chr(15)~chr(16)~chr(17)~chr(18)~chr(19)
|
|
~chr(20)~chr(21)~chr(22)~chr(23)~chr(24)~chr(25)~chr(26)~chr(27)~chr(28)~chr(29)
|
|
~chr(30)~chr(31) ~chr(34)
|
|
~"%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}"
|
|
~chr(128)~chr(129)
|
|
~chr(130)~chr(131)~chr(132)~chr(133)~chr(134)~chr(135)~chr(136)~chr(137)~chr(138)~chr(139)
|
|
~chr(140)~chr(141)~chr(142)~chr(143)~chr(144)~chr(145)~chr(146)~chr(147)~chr(148)~chr(149)
|
|
~chr(150)~chr(151)~chr(152)~chr(153)~chr(154)~chr(155)~chr(156)~chr(157)~chr(158)~chr(159)
|
|
~chr(160)~chr(161)~chr(162)~chr(163)~chr(164)~chr(165)~chr(166)~chr(167)~chr(168)~chr(169)
|
|
~chr(170)~chr(171)~chr(172)~chr(173)~chr(174)~chr(175)~chr(176)~chr(177)~chr(178)~chr(179)
|
|
~chr(180)~chr(181)~chr(182)~chr(183)~chr(184)~chr(185)~chr(186)~chr(187)~chr(188)~chr(189)
|
|
~chr(190)~chr(191)~chr(192)~chr(193)~chr(194)~chr(195)~chr(196)~chr(197)~chr(198)~chr(199)
|
|
~chr(200)~chr(201)~chr(202)~chr(203)~chr(204)~chr(205)~chr(206)~chr(207)~chr(208)~chr(209)
|
|
~chr(210)~chr(211)~chr(212)~chr(213)~chr(214)~chr(215)~chr(216)~chr(217)~chr(218)~chr(219)
|
|
~chr(220)~chr(221)~chr(222)~chr(223)~chr(224)~chr(225)~chr(226)~chr(227)~chr(228)~chr(229)
|
|
~chr(230)~chr(231)~chr(232)~chr(233)~chr(234)~chr(235)~chr(236)~chr(237)~chr(238)~chr(239)
|
|
~chr(240)~chr(241)~chr(242)~chr(243)~chr(244)~chr(245)~chr(246)~chr(247)~chr(248)~chr(249)
|
|
~chr(250)~chr(251)~chr(252)~chr(253)~chr(254)~chr(255),
|
|
# base248: powers of 2 (i.e. po2(x) = f(248 ^ x);
|
|
# 0 based list so the first item is really[1]; i.e. 124 which is 248/2 as po2 is the magnitude excluding sign
|
|
po2: [1, 124, 30752, 7626496, 1891371008, 469060009984, 116326882476032, 28849066854055936],
|
|
|
|
_base: 248,
|
|
spaces: " ",
|
|
empty_encoding: chr(1)~chr(1)~chr(1)~chr(1)~chr(1)~chr(1)~chr(1)~chr(1)~chr(1)~chr(1)~chr(1),
|
|
encodeNumeric : func(_num,length,factor)
|
|
{
|
|
#print(BinaryAsciiTransfer.po2[1]);
|
|
var irange = int(BinaryAsciiTransfer.po2[length] / factor);
|
|
var scale = int(irange / factor);
|
|
#print("EC ",irange, " sc=",scale);
|
|
var num = int(_num / factor);
|
|
if (num < -scale) num = -scale;
|
|
else if (num > scale) num = scale;
|
|
|
|
num = int(num + irange);
|
|
|
|
if (num == 0)
|
|
return substr(BinaryAsciiTransfer.empty_encoding,0,length);
|
|
var arr="";
|
|
|
|
while (num > 0 and length > 0) {
|
|
var num0 = num;
|
|
num = int(num / BinaryAsciiTransfer._base);
|
|
rem = num0-(num*BinaryAsciiTransfer._base);
|
|
arr =substr(BinaryAsciiTransfer.alphabet, rem,1) ~ arr;
|
|
length -= 1;
|
|
}
|
|
if (length>0)
|
|
arr = substr(BinaryAsciiTransfer.spaces,0,length)~arr;
|
|
return arr;
|
|
},
|
|
retval : {value:0, pos:0},
|
|
decodeNumeric : func(str, length, factor, pos)
|
|
{
|
|
var irange = int(BinaryAsciiTransfer.po2[length]/factor);
|
|
var power = length-1;
|
|
BinaryAsciiTransfer.retval.value = 0;
|
|
BinaryAsciiTransfer.retval.pos = pos;
|
|
|
|
while (length > 0 and power > 0) {
|
|
var c = substr(str,BinaryAsciiTransfer.retval.pos,1);
|
|
if (c != " ") break;
|
|
power = power -1;
|
|
length = length-1;
|
|
BinaryAsciiTransfer.retval.pos = BinaryAsciiTransfer.retval.pos + 1;
|
|
}
|
|
while (length >= 0 and power >= 0) {
|
|
var c = substr(str,BinaryAsciiTransfer.retval.pos,1);
|
|
# spaces are used as padding so ignore them.
|
|
if (c != " ") {
|
|
var cc = find(c,BinaryAsciiTransfer.alphabet);
|
|
if (cc < 0)
|
|
{
|
|
print("Emesary: BinaryAsciiTransfer.decodeNumeric: Bad encoding ");
|
|
return BinaryAsciiTransfer.retval;
|
|
}
|
|
BinaryAsciiTransfer.retval.value += int(cc * math.exp(math.ln(BinaryAsciiTransfer._base) * power));
|
|
power = power - 1;
|
|
}
|
|
length = length-1;
|
|
BinaryAsciiTransfer.retval.pos = BinaryAsciiTransfer.retval.pos + 1;
|
|
}
|
|
BinaryAsciiTransfer.retval.value -= irange;
|
|
BinaryAsciiTransfer.retval.value = BinaryAsciiTransfer.retval.value * factor;
|
|
return BinaryAsciiTransfer.retval;
|
|
},
|
|
encodeInt : func(num,length){
|
|
return me.encodeNumeric(num, length, 1.0);
|
|
},
|
|
decodeInt : func(str, length, pos){
|
|
return me.decodeNumeric(str, length, 1.0, pos);
|
|
}
|
|
};
|
|
|
|
var TransferString =
|
|
{
|
|
MaxLength:16,
|
|
#
|
|
# just to pack a valid range and keep the lower and very upper control codes for seperators
|
|
# that way we don't need to do anything special to encode the string.
|
|
getalphanumericchar : func(v)
|
|
{
|
|
if (find(v,BinaryAsciiTransfer.alphabet) > 0)#"-./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz") > 0)
|
|
return v;
|
|
return nil;
|
|
},
|
|
encode : func(v)
|
|
{
|
|
if (v==nil)
|
|
return "0";
|
|
var l = size(v);
|
|
if (l > TransferString.MaxLength)
|
|
l = TransferString.MaxLength;
|
|
var rv = "";
|
|
var actual_len = 0;
|
|
for(var ii = 0; ii < l; ii = ii + 1)
|
|
{
|
|
ev = TransferString.getalphanumericchar(substr(v,ii,1));
|
|
if (ev != nil) {
|
|
rv = rv ~ ev;
|
|
actual_len = actual_len + 1;
|
|
}
|
|
}
|
|
|
|
rv = BinaryAsciiTransfer.encodeNumeric(l,1,1.0) ~ rv;
|
|
return rv;
|
|
},
|
|
decode : func(v,pos)
|
|
{
|
|
var dv = BinaryAsciiTransfer.decodeNumeric(v,1,1.0,pos);
|
|
var length = dv.value;
|
|
if (length == 0){
|
|
dv.value = "";
|
|
return dv;
|
|
}
|
|
var rv = substr(v,dv.pos,length);
|
|
dv.pos = dv.pos + length;
|
|
dv.value = rv;
|
|
return dv;
|
|
}
|
|
};
|
|
|
|
#
|
|
# encode an int into a specified number of characters.
|
|
var TransferInt =
|
|
{
|
|
encode : func(v, length)
|
|
{
|
|
return BinaryAsciiTransfer.encodeNumeric(v,length, 1.0);
|
|
},
|
|
decode : func(v, length, pos)
|
|
{
|
|
return BinaryAsciiTransfer.decodeNumeric(v,length, 1.0, pos);
|
|
}
|
|
};
|
|
|
|
var TransferFixedDouble =
|
|
{
|
|
encode : func(v, length, factor)
|
|
{
|
|
return BinaryAsciiTransfer.encodeNumeric(int(v), length, factor);
|
|
},
|
|
decode : func(v, length, factor, pos)
|
|
{
|
|
return BinaryAsciiTransfer.decodeNumeric(v, length, pos, factor);
|
|
}
|
|
};
|
|
|
|
var TransferNorm =
|
|
{
|
|
powers: [1,10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0, 100000000000.0],
|
|
|
|
encode : func(v, length)
|
|
{
|
|
return BinaryAsciiTransfer.encodeNumeric(int(v * BinaryAsciiTransfer.po2[length]),length, 1.0);
|
|
},
|
|
decode : func(v, length, pos)
|
|
{
|
|
dv = BinaryAsciiTransfer.decodeNumeric(v, length, 1.0, pos);
|
|
dv.value = (dv.value/BinaryAsciiTransfer.po2[length]);
|
|
return dv;
|
|
}
|
|
};
|
|
|
|
var TransferByte =
|
|
{
|
|
encode : func(v)
|
|
{
|
|
return BinaryAsciiTransfer.encodeNumeric(v,1, 1.0);
|
|
},
|
|
decode : func(v, pos)
|
|
{
|
|
return BinaryAsciiTransfer.decodeNumeric(v, 1, 1.0, pos);
|
|
}
|
|
};
|
|
|
|
var TransferCoord =
|
|
{
|
|
# 28 bits = 268435456 (268 435 456)
|
|
# to transfer lat lon (360 degree range) 268435456/360=745654
|
|
# we could use different factors for lat lon due to the differing range, however
|
|
# this will be fine.
|
|
# 1 degree = 110574 meters;
|
|
encode : func(v)
|
|
{
|
|
return BinaryAsciiTransfer.encodeNumeric((v.lat()+90)*745654,5, 1.0)
|
|
~ BinaryAsciiTransfer.encodeNumeric((v.lon()+180)*745654,5, 1.0)
|
|
~ TransferNumeric.encode(v.alt(), 3, 1.0);
|
|
},
|
|
decode : func(v,pos)
|
|
{
|
|
var dv = BinaryAsciiTransfer.decodeNumeric(v,5, 1.0 ,pos);
|
|
var lat = (dv.value / 745654)-90;
|
|
dv = BinaryAsciiTransfer.decodeNumeric(v,5, 1.0 ,dv.pos);
|
|
var lon = (dv.value / 745654)-180;
|
|
dv = TransferNumeric.decode(v, 3, 1.0 ,dv.pos);
|
|
var alt =dv.value;
|
|
|
|
dv.value = geo.Coord.new().set_latlon(lat, lon).set_alt(alt);
|
|
return dv;
|
|
}
|
|
};
|
|
|
|
# genericEmesaryGlobalTransmitterTransmit allowes to use the emesary.GlobalTransmitter via fgcommand
|
|
# which in turn allows using it in XML bindings, e.g.
|
|
# <binding>
|
|
# <command>emesary-transmit</command>
|
|
# <type>cockpit-switch</type>
|
|
# <ident>eicas-page-select</ident>
|
|
# <page>hydraulic</page>
|
|
# </binding>
|
|
#
|
|
var genericEmesaryGlobalTransmitterTransmit = func(node)
|
|
{
|
|
var transmitter = emesary.GlobalTransmitter;
|
|
var t = node.getNode("transmitter",1).getValue();
|
|
if (t != nil) {
|
|
transmitter = emesary.getTransmitter(t);
|
|
if (transmitter == nil) {
|
|
logprint(LOG_WARN, "Invalid transmitter "~t);
|
|
return;
|
|
}
|
|
}
|
|
var type = node.getNode("type").getValue();
|
|
if (type == nil) {
|
|
logprint(LOG_WARN, "emesary-transmit requires a type");
|
|
return;
|
|
}
|
|
var ident = node.getNode("ident").getValue();
|
|
if (ident == nil) {
|
|
logprint(LOG_WARN, "emesary-transmit requires an ident");
|
|
return;
|
|
}
|
|
var typeid = node.getNode("typeid",1).getValue() or 0;
|
|
if (typeid == 0) {
|
|
typeid = TypeIdUnspecified;
|
|
logprint(LOG_WARN, "emesary-transmit using generic typeid ", typeid);
|
|
}
|
|
|
|
var message = emesary.Notification.new(type, ident, typeid);
|
|
node.removeChild("type");
|
|
node.removeChild("id");
|
|
node.removeChild("typeid");
|
|
|
|
# add remaining nodes to the message hash
|
|
var children = node.getValues();
|
|
if (children != nil) {
|
|
foreach (var key; keys(children)) {
|
|
message[key] = children[key];
|
|
}
|
|
}
|
|
transmitter.NotifyAll(message);
|
|
};
|
|
|
|
removecommand("emesary-transmit"); #in case of reload
|
|
addcommand("emesary-transmit", genericEmesaryGlobalTransmitterTransmit);
|
|
|
|
#setprop("/sim/startup/terminal-ansi-colors",0);
|
|
#for(i=-1;i<=1;i+=0.1)
|
|
#print ("i ",i, " --> ", (TransferNorm.decode(TransferNorm.encode(i,2), 2,0)).value);
|
|
#debug.dump(TransferNorm.decode(TransferNorm.encode(-1,2), 2,0));
|
|
#debug.dump(TransferNorm.decode(TransferNorm.encode(0,2), 2,0));
|
|
#debug.dump(TransferNorm.decode(TransferNorm.encode(1,2), 2,0));
|