One of the problems with HAM radio DX has always been the management of QSLs after a QSO has been established. Traditionally, QSLs are sent via the post office and can quickly escalate to a lot of money given very many QSOs - this holds true in particular in modern times and via WSJT-X where the time it takes for a DX spans a few minutes. Similarly, dealing with WSJT-X involves messing around with files, converting ADI(F) logs to and from online loggers and it would be much more convenient to have your own software that can handle contacts and the management of QSOs/QSLs.

The following software uses the generic node.js HTTP server created by Wizardry and Steamworks in order to offer a management web-interface, listen for WSJT-X messages (in particular, QSOs) and then automatically generate QSL cards. One quirk of the WSJT-X protocol is that the fifth message is a ragchew message that can be broadcasted without restrictions (none other than imposed by the FT8 protocol) such that one possibility is to broadcast an electronic QSL via the fifth message as a response to a DX contact.

• web-server that can expose QSL cards to the public,
• automatic and on-the-fly generation of QSL cards from WSJT-X UDP messages,
• configurable QSL card template,
• ability to be broadcasted as part of a DX call via the ragchew message 5,
• cross-platform, provided node.js is installable (Windows, Linux, BSD, etc.)

The project can be checked out from our Subversion repository:

• https://svn.grimore.org/node-wsjtx-companion

Once checked out, the following command must be run inside the created folder:

npm install

in order to install the necessary packages required by the project.

The project must then be configured, by copying config.js.dist to config.js and then editing the file config.js in order to make the appropriate changes. Even though there are many settings to play with, it is important to change ham → me and set your HAM callsign.

Finally, to start the server, issue the command:

node server.js -d www

where:

• -d tells the project to use the www directory as a web root,
• server.js is the main project file

The effect of running the command is that a web server will be launched, binding to all interfaces and, as per the default setting in config.js, listening on port 8070. You can access the web server by accessing the local host URL:

• http://localhost:8070

where you should be greeted by the logo and the various other controls.

The Node WSJT-X Companion listens to WSJT-X broadcasting messages on the local network such that WSJT-X reporting must be configured to broadcast UDP messages on the local network where they will be picked up and processed.

The following settings are important:

• the UDP server address should be set to the multicast UDP address 224.0.0.1,
• the port number 2237 must correspond to the config.js setting for the Node WSJT-X Companion,
• the outgoing interfaces should be all ticked depending on whether the Node WSJT-X Companion runs on the same machine as WSJT-X or whether the project runs on some other machine on the local network,

It is not necessary to enable the secondary UDP server for ADIF broadcasts because the Node WSJT-X Companion pulls the data from the first UDP server.

The typical operation of the Node WSJT-X Companion involves staring the Node WSJT-X Companion and WSJT-X - perhaps on the same machine, or different machines. Once a QSO is made with WSJT-X, the Node WSJT-X Companion processes an emitted ADI(F) message and automatically generates an ASCII QSL file. The ASCII QSL file is then placed under the Node WSJT-X Companion root directory followed by www and then by qsl where all generated QSLs are stored.

Similarly, the Node WSJT-X Companion exposes a web-interface, running on the port (default 8070) and listening on the address (default, any, 0.0.0.0) that can be configured by editing config.js. In order for people to be able to access your QSLs, it is recommended to expose the Node WSJT-X Companion web address to the Internet. This can be done by using a reverse-proxy or by running the Node WSJT-X Companion on a public interface.

Here is an idea, the WSJT-X 5th message, surrounded in purple in the screenshot below, is capable of ragchew meaning that it can make WSJT-X transmit any string you wish (under FT8 protocol restriction).

The ragchew message can be 13 characters long, such that one could register a short domain, perhaps, say, q.sl and then send the QSL directly after the QSO has been completed. Unfortunately, the Node WSJT-X Companion cannot do that, such that the 5th box in the message sequence must be filled in manually.

For instance, assume that you have completed a QSO with a station with the callsign 811SDD then Node WSJT-X would have already generated a QSL for you, such that you will fill in the 5th box as:

• q.sl/811SDD

and then send the message.

If 811SDD access the website:

• http://q.sl/11SDD

then they will be able to access the generate QSL card, download it or print it as they see fit.

The Node WSJT-X Companion project uses a template that is provided with the project, named qsl.txt and placed at the root of the project with the following contents:

 /------------------------------------------------------------------------\
 |o                                                                      o|
 |                .---.   .--- ...           ....   ....        /         |
 |               /  _  | |---/ | |          / .. \ / .. \      |/         |
 |               | | | | |--\  | |   .---.  \\  // \\  //      |/         |
 |    -(--).     | "-/ |  \--\ | \    ---    //\\   //\\   Ooo |          |
 |   /  (-) \    / .   | --- | |  -..       //..\\ //..\\     o| , .      |
 |   \--   -/     /---/  \---/  \---/       \..../ \..../     -- (o)      |
 |                          \                   /             || ^|^      |
 |       /(..)\              +:[ XXXXXXXXXXX ]:+              ..  |/      |
 |      \ (-) /  c(..)o                               "   \  /..\/.       |
 |       \   /    ----    =====)------------------     -----......        |
 |                \  /                           .      /    \../         |
 |   ...                                         o            --          |
 |   \|/                        | .................. ..................   |
 |    |                         |.                  .                  .  |
 |    |    ."-._.-""--.-"-../   |. Confirm QSO      = AAAAAAAAAAAAAAAA .  |
 |    |-._/                /    |\                  .                  .  |
 |    |  '      .-""-.     \    | .-----------------+-----------------/   |
 |    |  \  ** . _  _ . **  )   |.                  .                  .  |
 |  .---. )  \\|(_)(_)|//   \   |. Date & Time      = DDDDDDDDDDDDDDDD .  |
 |  .---. \    (_ /\ _)      )  |\                  .                  .  |
 |  .---.  )  //|wwww|\\    /   | .-----------------+-----------------/   |
 |    |    . ** '-..-' **   )   |.                  .                  .  |
 |    |   .'                \   |. f / Mode / Band  = FFFFFFFFFFFFFFFF .  |
 |    |.../"-.__.-""-.__.-"-.)  |\                  .                  .  |
 |    |                         | .-----------------+-----------------/   |
 |    |                         |.                  .                  .  |
 |    |                         |. Signal TX/RX     = SSSSSSSSSSSSSSSS .  |
 |    |          )    )          \                  .                  .  |
 |  /////          |\__/,|   (`\   ................/+................./   |
 |o              _.|o o  |_   ) )                                        o|
 \--------------(((---(((-------------------------------------------------/
                                                                            

The template uses the following markers in order to dynamically perform substituons when generating the QSL card:

• XXXXXXXXXXX this will be substituted by your own callsign,
• AAAAAAAAAAAAAAAA this string will be substituted by the callsign of the DX station,
• DDDDDDDDDDDDDDDD this string will be substituted by the date and time when the QSO has been made,
• FFFFFFFFFFFFFFFF this string will be substituted by a compound of the frequency, mode and band that the QSO took place over,
• SSSSSSSSSSSSSSSS this string will be substituted by a tuple consisting of the TX signal in and the RX signal in

Although the provided template is artsy, it is completely feasible to recreate the template just by editing the qsl.txt file. The file can be made or changed as you desire, and, as an extra bonus, if you provide any of the strings mentioned above, the Node WSJT-X Companion will substitute the strings for you when it generates a QSL card.

Whether you access the QSL of a station via the main webpage, by entering the callsign and clicking the Get button, or whether the QSL is accessed by browsing to the URL corresponding to the station for which the QSL is to be retrieved, the browser print button will work and will only display the QSL card without the form.

It is up to you whether you would like to print the QSL cards yourself, or deliver them via ragchew to your DX partners.