+++
title = 'FLEcli on OpenBSD'
aliases = '/posts/2023-09-24-flecli-on-openbsd'
summary = '''Quickly create ADIF or CSV files to import into any logging program later.
    Also creates logfiles for the SOTA program.'''
date = '2023-09-24T11:56:06+0200'
lastmod = '2024-09-28T23:48:07+0000'
categories = [ 'amateur-radio' ]
tags = [ 'linux', 'openbsd', 'freebsd', 'windows', 'macos', 'portable', 'neovim', 'zsh-shell' ]

+++

## What is <abbr title="Fast Log Entry">FLE</abbr>

Find more useful information about FLE over here:

- <https://github.com/on4kjm/FLEcli>  
   This is the tool (written in go) that we use in this article, but it interprets
  the syntax mentioned on the website below.
- <https://df3cb.com/fle/documentation/>  
   This is also the website to get a Windows binary, which is actually a logging program,
  but the link goes directly to the **documentation page**.
- <https://git.dk1mi.radio/mclemens/vim-fle-syntax>  
   This is an addon for the vim editor, that helps you with the syntax by highlighting it.
  I haven't got this working with neovim, though (not worth looking into it for now).
- <https://dk1mi.radio/vim-fle-syntax/>  
   This is a descriptive blog post by Michael DK1MI on his website about the vim-plugin.

## Get the source code and install the program

I usually keep those files in `~/git`.

```console
$ cd ~/git
$ git clone https://github.com/on4kjm/FLEcli.git
Klone nach 'FLEcli'...
remote: Enumerating objects: 1223, done.
remote: Counting objects: 100% (297/297), done.
remote: Compressing objects: 100% (187/187), done.
remote: Total 1223 (delta 162), reused 213 (delta 106), pack-reused 926
Empfange Objekte: 100% (1223/1223), 30.01 MiB | 4.88 MiB/s, fertig.
Löse Unterschiede auf: 100% (746/746), fertig.
$ cd FLEcli
$ go build
$ go install
```

Your program should now be in `$GOPATH/bin`, which is
`~/go/bin` on my computer. This is also listed in my `$PATH`.

## Create command completion for your shell

I'm using **zsh** as my primary shell so I'll create the completion file
for zsh in this article. I have my custom completion scripts in
`~/.zcomp`.

In your home directory:

```console
$ FLEcli completion zsh > ~/.zcomp/_FLEcli
$ rm .zcompdump
$ compinit
```

Hmm, your commands may differ probably, I'm using [prezto][1] since years and that
may differ a bit from other zsh setups.

[1]: https://github.com/sorin-ionescu/prezto

## Create a logfile

The log can be written very quick, for a detailed documentation see the links at the very
beginning of this article, specifically the second one.

An example logfile `log.fle` looks like this:

```fle
mycall oe7drt
mygrid jn57lb
date 2023-09-24
0826 20m ssb oe7test < comments > [ QSL message ]
7 oe7test2 < second contact >
8 oe7test3 < third, minute 8 → 08:28 >
```

See? You can create logfiles very quick.

### Have a look at the logfile

```console
$ FLEcli load log.fle
MyCall    OE7DRT
MyGrid    JN57lb

Date       Time Band Mode Call         Sent Rcvd Notes
----       ---- ---- ---- ----         ---- ---- ----
2023-09-24 0826 20m  SSB  OE7TEST      59   59   [ comments ] [ QSL message ]
2023-09-24 0827 20m  SSB  OE7TEST2     59   59   [ second contact ]
2023-09-24 0828 20m  SSB  OE7TEST3     59   59   [ third, minute 8 → 08:28 ]

Successfully parsed  7  lines.
```

## Create an ADIF file

```console
$ FLEcli adif log.fle
No output provided, defaulting to "log.adi"
MyCall    OE7DRT
MyGrid    JN57lb

Date       Time Band Mode Call         Sent Rcvd Notes
----       ---- ---- ---- ----         ---- ---- ----
2023-09-24 0826 20m  SSB  OE7TEST      59   59   [ comments ] [ QSL message ]
2023-09-24 0827 20m  SSB  OE7TEST2     59   59   [ second contact ]
2023-09-24 0828 20m  SSB  OE7TEST3     59   59   [ third, minute 8 → 08:28 ]

Successfully parsed  7  lines.

Successfully wrote 7 lines to file "log.adi"
```

Which looks like this then:

```adif
ADIF Export for Fast Log Entry by DF3CB
<PROGRAMID:3>FLE
<ADIF_VER:5>3.1.0
<EOH>
<STATION_CALLSIGN:6>OE7DRT <CALL:7>OE7TEST <QSO_DATE:8>20230924 <TIME_ON:4>0826 <BAND:3>20m <MODE:3>SSB <RST_SENT:2>59 <RST_RCVD:2>59 <COMMENT:10> comments  <QSLMSG:13> QSL message  <MY_GRIDSQUARE:6>JN57lb <EOR>
<STATION_CALLSIGN:6>OE7DRT <CALL:8>OE7TEST2 <QSO_DATE:8>20230924 <TIME_ON:4>0827 <BAND:3>20m <MODE:3>SSB <RST_SENT:2>59 <RST_RCVD:2>59 <COMMENT:16> second contact  <MY_GRIDSQUARE:6>JN57lb <EOR>
<STATION_CALLSIGN:6>OE7DRT <CALL:8>OE7TEST3 <QSO_DATE:8>20230924 <TIME_ON:4>0828 <BAND:3>20m <MODE:3>SSB <RST_SENT:2>59 <RST_RCVD:2>59 <COMMENT:27> third, minute 8 → 08:28  <MY_GRIDSQUARE:6>JN57lb <EOR>
```

## Create a SOTA log

I've never activated or hunted a SOTA station, but this is the theoretical
way to produce a valid logfile to submit to the sota website.

First, the dummy logfile:

```fle
mycall oe7drt
mygrid jn57lb
mysota oe/ti-674

date 2023-09-24
1015 80m ssb oe0t1 46 58 [no qsl; only LOTW]
20 oe0t2 33 32 < very quiet mic >
22 oe0t3 59 59 < must be very near>
4 oe0t4 34 57 sota oe/ti-559 < nice s2s contact >
```

We create the CSV file:

```console
$ FLEcli csv log.fle
No output provided, defaulting to "log.csv"
MyCall    OE7DRT
MySOTA    OE/TI-674
MyGrid    JN57lb

Date       Time Band Mode Call         Sent Rcvd Notes
----       ---- ---- ---- ----         ---- ---- ----
2023-09-24 1015 80m  SSB  OE0T1        46   58   [no qsl; only LOTW]
2023-09-24 1020 80m  SSB  OE0T2        33   32   [ very quiet mic ]
2023-09-24 1022 80m  SSB  OE0T3        59   59   [ must be very near]
2023-09-24 1024 80m  SSB  OE0T4        34   57   [ nice s2s contact ] OE/TI-559

Successfully parsed  10  lines.

Successfully wrote 4 lines to file "log.csv"
```

Which results in a CVS file ready for uploading to the SOTA website (untested!):

```csv
V2,OE7DRT,OE/TI-674,24/09/23,1015,3.5MHz,SSB,OE0T1
V2,OE7DRT,OE/TI-674,24/09/23,1020,3.5MHz,SSB,OE0T2,, very quiet mic
V2,OE7DRT,OE/TI-674,24/09/23,1022,3.5MHz,SSB,OE0T3,, must be very near
V2,OE7DRT,OE/TI-674,24/09/23,1024,3.5MHz,SSB,OE0T4,OE/TI-559, nice s2s contact
```

## Final words

I guess this is an excellent way to create a **quick offline log** on your computer,
if you have one with you. Otherwise this is a quick way to create a properly formatted
ADIF or CSV file to **import later** into your regular logging program because you really
only type in the needed information like time changes or band changes and the callsigns
with their reports of course. All entered information keeps there for the following QSOs.