LINDA — what is it?
When reviewing scenery, or an aircraft, or even simming
hardware, it is usually fairly safe to assume that the
reader is at least vaguely aware of what kind of product is
being reviewed. In the case of LINDA, however, it will be
necessary to begin by first explaining where it fits in to
the simmer’s world, and how and why it came to be, before
moving on to describe what it does — and then reviewing how
well it does it. So please understand from the outset that
this review will be slightly lengthier than would otherwise
be the case!
LINDA — who needs
it?
If you have been involved in flight simulation for as
long as I have, over the years you will have become familiar
with the Frequently Recurring Question on various simming
forums: “But what do I need FSUIPC
for”? Clearly,
there are still simmers who have never (or never knowingly,
at least) encountered the need for the facilities that
FSUIPC provides. And because LINDA is essentially a
graphical front-end for the Lua functionality made available
by the registered version of FSUIPC, it would be helpful —
and, arguably, vital — to put both FSUIPC and LINDA in some
sort of context.
A little ancient
history
When Bruce Artwick’s subLOGIC Flight Simulator franchise
was licensed by Microsoft in the early 1980s, it was used as
a demonstration of the first “Color Graphics Adapter” card
that was made available for the original IBM PC. I was
already using the subLOGIC flight simulator for the Apple
][, and so the “Microsoft Flight Simulator” was a natural
next step. (Translation: I was already hooked). But in those
early days there were no add-on controls, so you had to
control your aircraft using just the keyboard and perhaps
the mouse, which we will all agree is certainly not the best
way to do it.
So, surprisingly quickly, various hardware devices became
available for the growing interest in flight simming on home
computers. These early controls initially had to be
interfaced via a serial port, since USB hadn’t been invented
yet, and came to be categorised along with mice and
keyboards as Human Interface Devices, or HIDs. (Notice that
term, because we’ll be seeing it again, soon).
Introducing FSUIPC
The factor which made simming controls different was the
need to decode a
range of possible input values — and for elevators,
ailerons, rudders, and throttle as a minimum. These controls
were given the generic name “axes”, since each one worked by
the human operator moving a wheel or a knob or a lever round
its own axis to the required position: interfacing them
became slightly easier when USB was introduced in the
mid-to-late 1990s. As more and more different makes and
models of controls became available, Pete Dowson’s FSUIPC
became the standard way for simmers to define the
communication with the axes on these devices. And although
dealing with the axes was always FSUIPC’s main claim to
fame, it could deal with buttons, too — as long as you were
willing to edit the fsuipc.ini file in the event that you
wanted to do anything that was less than straightforward,
such as sending more than one keystroke in response to a
single button press, for example.
It was because Pete Dowson recognised that simmers’ needs
were becoming ever more complex that he fairly recently
decided to incorporate support for a programming language
called Lua into FSUIPC. This is a huge improvement: instead
of having to grub around editing ini files and calculating
hexadecimal values, it’s now possible to write code such as
the following:
-- Turn all fuel pumps off except for left fwd (for
the APU)
NGX_PUMPS1and2_off ()
NGX_PUMPSCTR_off ()
NGX_PUMP1_FWD_on ()
That, you must admit, is much easier to read, and to
work with. “But”, I hear you cry, “I’m not a programmer, I
just want to fly” — which is entirely understandable. And
being the expert programmer that he is, Pete Dowson simply
provided the interface for anyone who wanted to use it (as
long as they could read and understand his documentation)
and then let us all get on with it.
The start of LINDA
So it was that a few brave souls began using Lua to code
various useful scripts, which were posted on the FSUIPC
forum: amongst them was Günter Steiner. Günter also became
adept at searching through the developer’s code for a
specific add-on aircraft to locate somewhere to hook the Lua
code into, so as to be able to press a physical button which
flipped a cockpit switch or whatever and achieved the
desired effect. He then started working with Artem Crum:
Artem had the idea for making a graphical front end to their
growing utility, and so it was that LINDA came into being.
LINDA’s claim to
fame
The simplest possible way to describe LINDA is to say
that it does for buttons what FSUIPC does for axes: in other
words it makes them accessible and extremely easy to assign,
using a graphical interface. And that’s all that a lot of
LINDA’s users use it for — although there’s much more to it.
For
example, LINDA also provides a useful tool to enable us to
search through and find the “hooks” in the developer’s code
for a specific aircraft, using its inbuilt Tracer function.
So within 24 hours of the PMDG NGX
being released, Günter released the first LINDA module for
it, which is quite a feat, I have to say! (The current
version of the LINDA module for the PMDG NGX exposes seven
hundred and thirty-seven different functions for you to use
as and when you wish, affecting almost every aspect of the
aircraft’s controls). The business of Tracing can get a bit
technical and therefore it will never be to everyone’s
taste, but happily enough users are willing to take the time
to do it that we all are able to benefit from an impressive
support list of add-on aircraft, which you can use without
having to get involved in anything technical yourself.
It was about that time that VRinsight
introduced their “MCP Combo”, an attempt to give the simmer
a universal MCP (and EFIS and Comms) hardware unit that
could be interfaced to add-on aircraft. Unfortunately — as,
for example, in the case of PMDG aircraft — it often didn’t
cope at all well, and so LINDA was extended to also
incorporate support specifically for that piece of hardware.
When VRinsight introduced v2, LINDA
continued to support v1 whilst adding support for the new
“Boeing” version of the device, incidentally.
But for the remainder of this review I’m going to
concentrate on LINDA’s talents for interfacing buttons and
switches, since that’s what most people use it for, most of
the time.
What LINDA needs in order to be able to function
The first requirement in order to be able to run LINDA
should be pretty obvious from the foregoing — you need a
registered current version of FSUIPC v4 (i.e. for fsx),
since LINDA is built upon the support that FSUIPC provides
for Lua. Yes, that’s true even if you have no intention of
getting into Lua programming yourself. (And since Pete
Dowson only built Lua support into version 4 of FSUIPC, you
obviously need Microsoft’s fsx, too).
The second thing to say is
that
(with the exception of the VRinsight Combo, which has rotary
encoders that are supported internally by LINDA) it only
supports those
button devices which show up as HID devices to Windows.
So if you can’t see your device in [Start Orb] | Devices and
Printers, then it’s unlikely that LINDA can talk to it. (OK,
that’s not terribly usual, but it does happen — but as ever,
the VRinsight Combo is a special case, so I won’t mention it
again….).
Here,
for example, you see an extract from my own Devices and
Printers screen, and as you will notice the Thrustmaster
Warthog Control Units are recognised, along with something
that is cryptically identified as “usb pad”, which is in
fact a VRinsight TT switch panel. If I right-click its
picture and select “Game controller settings” and then click
the Properties button, I see the device as Windows sees it
(with switch 15 in the On position, in the illustration).
Two things worthy of notice are that (a) X Y and Z axes are
depicted in spite of the fact that the device has no axes at
all (!), and (b) a POV hat is shown — which strangely enough
is correct, since four of the buttons on the device are
mapped as a hat and can be used in combination to provide
any of the eight hat positions. Moral: don’t necessarily
trust what you see in Microsoft’s depiction!
But the point I’m really making is this: if, like the “usb
pad”, the buttons on your device can be seen working in this
view, then LINDA will recognise them: otherwise, it can’t
(and therefore won’t).
And please forgive me if I mention — for the last time, I
promise — that LINDA is in the
buttons business,
so that although it will recognise the switches on your
Saitek throttle, for example, (including the hidden ones for
engine reverse), it will ignore the axes completely — so use
FSUIPC for those.
The installation of LINDA could hardly be more
straightforward. You simply unzip the latest distribution
into the Modules folder of your fsx installation: if you
install the version of LINDA which also contains its modules
for a number of popular add-on aircraft, they will all be
installed at the same time. For full details, see the
official LINDA manual that comes with the distribution,
although non-techies often prefer to use the “detailed
manual” which is currently available from this link —
http://www.fs-linda.com/downloads/Introducing_LINDA_v1.01.pdf
This is probably a good moment to also mention the LINDA
forum and source for downloads, which is on Avsim, here —
http://forum.avsim.net/index.php?showforum=424
So much for the requirements: now at last we can start to
look at the goodies which LINDA brings to your simming
party.
LINDA — the good news
Let’s begin this section of the review with the news
that everyone likes to hear: you don’t have to pay for
LINDA! Its authors chose to release it as donationware, so
once you have discovered for yourself just how much LINDA
can do for you, you can donate whatever you feel is
appropriate.
After a respectful pause in honour of that decision, let’s
now consider an example of just how easy it is to use LINDA
to make your buttons do useful and interesting things for
your add-on aircraft of choice.
The first priority (assuming that you’re not starting from
scratch and setting out to Trace the code of a
recently-released aircraft) is to ensure that you have
installed the latest version of the LINDA module for the
aircraft you’re using — as well as LINDA itself, of course.
In view of its huge popularity I’ll use the PMDG NGX for
these examples, but you will find modules for many other
add-on aircraft in the Downloads section of the LINDA forum
(I’ll give you a list, soon) – and, of course, all the
default fsx aircraft are supported “out of the box”. When
you start fsx, LINDA will automatically know which aircraft
you are currently using, and load the appropriate module.
Assuming that is the case, therefore, and that you have also
been through the suggested procedure in the manual(s) to
assign and check out the functions for the default aircraft,
the rest is easy. I’ll use the same example as the one given
in the “detailed manual”, which is the common task of
assigning a three-position switch to control the lever which
raises and lowers the undercarriage (or “gear” for those on
the other side of the Pond) so as to assign to the hardware
switch an up, a down, and a central depressurised position.
I’ll work through it slowly, so you can see the relevance to
LINDA.
Without LINDA, this would be something of a nightmare with a
complex add-on aircraft, but if you look through the vast
list of functions which have been Traced for the NGX, you
will very quickly identify the fact that you somehow want
the movements of the switch to utilise the functions —
NGX GEAR up
NGX GEAR off
NGX GEAR down
— to get the effect you want. But how do you achieve
that effect in LINDA?
Once fsx is running, the LINDA screen will display the name
of the currently-loaded aircraft at the top, and a list of
the available switches running from top to bottom, down the
left-hand side. It will also display your currently-saved
button configuration for this aircraft, with three columns
for each movement of the switch or button (a button is
simply a switch that won’t hold in the on position):
On Press
Actioned when the button is pressed, or the switch is
turned On.
On Repeat
Actioned while the button is held down (or the switch
is left in the On position).
On Release
Actioned when the button is released, or the switch
is turned Off.
If
you look at the Thrustmaster diagram of the three-position
switch at the front right-hand corner of the Warthog
throttle unit you will see that in fact it comprises two
switches, electrically speaking. When the switch is up
switch 27 is on; when the switch is down switch 28 is on;
and in the middle position both 27 and 28 are both off.
Now consider the sequence of events in
the cockpit. Until takeoff, the switch (gear lever) is in
the down position (sw 28 on, 27 off). Once a positive rate
of climb is established, the switch is moved to the up
position (sw 28 off, sw 27 on), and when the flaps are
retracted the switch is returned to the centre position
(both off). On the approach, the switch is returned to the
down position (sw 28 on).
At this point you will be starting to
see where this is leading us: in LINDA terms we have the
following situation:
-
When the switch is moved from down
through the centre position to Up, we have an On Release
action from sw 28, followed by an On Press situation
from sw 27. (OK, we also have an On Repeat from sw 27,
too, but we simply ignore that).
-
When the switch is moved from Up to
the centre position, we have an On Release from switch
27.
-
When the switch is moved back to
the Down position, we have an On Press from switch 28
(with the On Repeat, which again we ignore).
So
using the On Press and On Release columns for those two
switches in LINDA, we set things up like this:
So when the switch is moved through the
mid-position to ‘up’ on leaving the runway, LINDA looks at
On Release for sw 28 (which is empty, so nothing happens)
and then On Press for sw 27, whereupon it triggers the NGX
gear up function. When the switch is moved to the centre
position, LINDA detects an On Release for sw 27, which calls
the NGX’s gear off function. And when the switch is moved to
the down position again for landing, LINDA calls the NGX’s
gear down function (On Press for sw 28). Which is what we
wanted.
It could hardly be easier — thanks to
Artem’s GUI front end for LINDA, and Günter’s excellent work
in Tracing the NGX functions for us.
You may have noticed that in the above
example I utilised NGX-specific functions, but LINDA also
provides a plethora of other functions for you to use. For
example, you have a long list of fsx standard controls
(increment and decrement flaps, throttle controls — which
may not be applicable to advanced add-on aircraft, of course
— and brakes. Furthermore, you have similar lists of
functions for A2A Map, Aivlasoft EFB, IVAO IVAP, Reality XP,
VRinsight, and Weather functions. And if that’s not enough
for you, you can also have your own User functions — scripts
that you yourself write to create your own Lua functions
which can call any of
the functions in the other lists.
At this point you are probably
beginning to glimpse the amazing amount of power that is
available to you within LINDA. Not only can you map any of
your existing buttons, but you can map them to a vast range
of hitherto-inaccessible internal functions of your aircraft
and hardware, too.
Roll your own?
The above phrase derives, of course,
from those who prefer to use cigarette paper and tobacco in
a small machine to literally roll their own cigarettes,
rather than buy the pre-made sort. The applicability to the
present discussion is that, as mentioned above, LINDA allows
you to write your own Lua functions from scratch (not for
the faint hearted, but not complex, either) — or, more
commonly, string together functions from elsewhere to
achieve the purpose you have in mind.
The
partial (this review is already lengthy) example I’ll show
here relates to the situation in a 737 when you have started
your engines and then need to do a whole list of things such
as stopping the APU and so on without (in my home cockpit,
at least) a First Officer to assist. I don’t use FS2Crew or
anything of that kind, so it’s quite difficult to flip a
whole series of switches on the overhead panel and elsewhere
whilst simultaneously negotiating a relatively narrow
taxyway and trying not to break all the little lamps along
the edge. So I wrote a simple function called BC_After_Engine_Start which I assign to a single switch:
this provides a perfect solution to the problem.
(There’s more code than is shown above,
but you get the idea). As you will also have noticed, one of
the other goodies in LINDA that I haven’t yet mentioned is a
complete, context-sensitive, colour-coded Editor, which you
can use not only to write your own Lua functions, but to
check the Lua syntax as you go along. (There are plenty of
Lua tutorials on the Internet, and it’s far from being a
hard language to learn — also, you don’t need to know much
of it to get you started).
Once you’ve strung together as many
functions as you need, you simply assign your new
all-embracing container function to your designated switch
or button: it will appear under “User functions” in LINDA’s
list of available functions, as here:
Incidentally, if you’d like a list of
the functions — 737 of them, no less — that are available in
the current NGX module (v1.9), you can find it in post #310
on this page:
http://forum.avsim.net/topic/341971-pmdg-737-ngx-module-version-19/page-13
LINDA can really
shift
You may feel that three actions for
each individual switch (press/repeat/release) is an
embarrassment of riches, but in fact LINDA goes the extra
mile and even provides you with a way of effectively
doubling the number of buttons that you have! On the page of
assignments for the buttons on your choice of aircraft and
device you will find a small checkbox labelled “Shifted”.
When checked, the column labels for On
Press and so on turn red, with an asterisk, and you have a
totally new page of assignments for each button or switch.
You can assign up to two different buttons to the shift
function: one button enables a Local shift, (i.e. the
shifted property applies to the nominated device but not to
your other devices), whilst the other enables shift Globally
(so the shifted property applies to them all).
If you are short of buttons, this is a
huge blessing, since it doubles the number (less one or two
for the Shift function itself). But although my Warthog
stick and throttle unit, combined with the VRinsight TT
panel, gives me a very generous number of switches, buttons,
and hats, I still use LINDA’s Shift function, since there I
can put the functions I would never want to trigger
accidentally by pushing the wrong button (engine cut is the
most obvious example). Since the Shift button has to be held
down whilst accessing the secondary button assignments, this
is a useful safety feature.
What if something
goes wrong?
LINDA is very stable, but clearly there
will be occasions when you (usually) have done something
wrong and need to fix it. On such occasions there are at
least two places where you can look.
The first is the obvious one — the
traditional Windows message box (which may, of course, end
up hidden behind your fsx if you are using full screen view,
but nonetheless will be awaiting your attention when you
exit fsx), whilst the other is LINDA’s Console which you can
view any time you wish by pressing F1 — unless you’ve
remapped that key — or always by clicking on the link in
LINDA’s Settings Window (obviously, you will have to
temporarily move to windowed view if you are running fsx
full-screen and want to check the Console immediately).
As you can see, the Console gives you a
pretty comprehensive log of everything that happens during
your LINDA session, should you need to know. Furthermore, if
(in spite of the LINDA Editor’s syntax checking) you should
have incorporated any syntax errors which prevent a module
loading — which tends to happen to me when I have edited the
lib-user.lua file using a different editor — you will find
helpful diagnostic information on the Console
in friendly red letters,
along with the location of the error.
(As an aside — be aware, as they say,
that the Lua language is case-sensitive: if you want to call
NGX_WHEEL_WELL_on but actually type
NGX_WHEEL_WELL_ON, that’s a syntax error! And yes, I
discovered that the hard way….).
LINDA in action
As we have seen, LINDA provides us with
an extremely powerful, and professional, interface to button
or switch programming, allowing access to cockpit functions
which have hitherto been inaccessible to simmers other than
by mouse-clicking on a switch in cockpit view. When you
choose an aircraft within fsx, LINDA notices your choice,
loads the appropriate module, and assigns your current
choice of button mappings. It’s smooth, and it works quietly
in the background without you having to worry about the
details — once you have assigned your buttons (and I should
add that you can, of course, also make your buttons send
standard fsx keystrokes, if all else fails).
As I said, basically LINDA does for
buttons what FSUIPC does for axes: it’s a professional
product at an unprofessional price.
Of course, whether LINDA will work well
in your setup depends on whether the particular add-on
aircraft you want to use today has a LINDA module already
written for it (in other words, someone else has already
done the hard work of Tracing the internal calls and mapping
them to usable function names). The official, albeit not
quite complete, list of supported aircraft, as well as one
or two other things, is currently as follows:
● A2A Accusim map controls
● A2A B17
● A2A B377 Captain of the ship
● A2A Spitfire
● Aerosoft Airbus X
● Aerosoft Catalina
● Aerosoft Katana X
● AivlaSoft EFB
● CaptainSim 757
● Carenados (all)
● DA Dornier 27
● FSX default aircraft (all)
● iFly 737
● Level-D 767
● PMDG JS41
● PMDG MD11
● PMDG NGX (with full display sync on the VRinsight Combo
unit)
● RealAir Duke Turbine
● VRS F/A-18
The extent of the support provided by
the module varies, of course, depending on your choice of
aircraft. Since all these aircraft are on the list thanks to
someone spending time with the Tracer, the number of
functions which have so far been discovered differs in each
case. For example, the initial release of the LINDA module
for the QualityWings Ultimate 146 Collection is not included
in the above list, since although many functions are already
established there are still a few MCP functions which are
proving difficult to nail down. But if you pop back to the
LINDA forum every few weeks, you may discover that there has
been an update….
And, of course, if you’re willing to
dive into the Tracer, you may be able to interface your
choice of add-on aircraft with LINDA by your own efforts. I
should, however, mention two caveats here. The first is the
obvious one: seeking out internal calls, even with the
Tracer’s help, is definitely as much of an art as it is a
science, and hence takes a certain amount of practice and
research. The second, however, is that very occasionally one
may encounter an add-on aircraft which uses methods which
seem to defy the Tracing of their internal functions —
initially, at least. But, happily for us, this is unusual.
Conclusion
Whilst brilliant in both concept and
execution, LINDA is difficult to categorise in view of the
fact that people of different skill levels will deploy it in
markedly different ways. Those with little technical
knowledge may use it only with existing aircraft profiles,
and/or for its VRinsight MCP Combo abilities. People with
some programming ability will no doubt use it to create
their own functions, which probably incorporate functions
for their aircraft which have been exposed by others. A few
will dive into the Tracer with great glee and use that
powerful tool to start interfacing new aircraft, or add to
the functions already available. Many will use it as a
delightfully straightforward way of assigning button presses
to various fsx, aircraft-specific, or other functions.
Its ease of use is impressive,
especially when you take into account its power. The
advanced functions are kept well away from the assignment
screen, so that those who wish to use it as a simple
button-assignment tool can do so without being intimidated
by the more complex stuff — indeed unless they specifically
call it up they may not even be aware that it is there.
LINDA is clearly aimed at the hard-core
simmer who has made an investment in external hardware, and
it excels at what it does. The fact that it has been
released as donationware is amazingly generous to the
simming community — although inevitably that also means that
support has to be provided via the LINDA forum, and is
therefore made available by other users, as well as the
developers, as and when they can. Therefore, one clearly
cannot anticipate anything like the same level of support as
would be put in place for a payware product emanating from a
large organisation: all I can say is that my own experience
indicates that the LINDA forum does indeed provide helpful
support in the event that it is needed — albeit not always
in as timely a fashion as one might wish, which is hardly
unreasonable given the price paid.
Scoring note
So what is the Mutley review rating for
LINDA?
It is, to say the least, unusual to
find a donationware/freeware product which offers the
usefulness, power, professionalism, and friendliness of
LINDA.
This has not been a straightforward
decision since there is no single overall score which will
be appropriate for everyone. As mentioned above, how many of
LINDA’s facilities you use will depend on your technical
skill as much as your addiction to fsx and also your
ownership of button and switch-laden hardware. But since
LINDA is clearly intended for the more advanced simmer, it
has to be evaluated on that basis, and therefore the scores
are as follows:
|
Verdict: |
|
 |
| • Ease of Use: |
10/10 |
| • Features: |
10/10 |
| • Documentation |
10/10 |
| • Performance: |
10/10 |
| • Value For Money: |
10/10 |
| |
|
Mutley's Hangar score of 10/10
- "Outstanding" |
Finally: Why is it
called LINDA?
I thought you’d never ask.
It’s
an acronym for
Lua
Integrated
Non-complex
Device
Assigning.
So now you know!
Brian Cowell
Review machine Spec: Intel i5 760 O/C 4GHz |
16GB DDR3 RAM |NVidia GTX670 FTW GFX Card |Windows 7/64
