diff --git a/OpenAudio_ArduinoLibrary.h b/OpenAudio_ArduinoLibrary.h
index a2c772d..5498a1d 100644
--- a/OpenAudio_ArduinoLibrary.h
+++ b/OpenAudio_ArduinoLibrary.h
@@ -57,6 +57,7 @@
 #include "AudioFilterFIRGeneral_F32.h"
 #include "RadioFMDetector_F32.h"
 #include "radioBFSKmodulator_F32.h"
+#include "radioFT8Modulator_F32.h"
 #include "RadioFMDiscriminator_F32.h"
 #include "radioNoiseBlanker_F32.h"
 #include "synth_sin_cos_f32.h"
diff --git a/docs/index.html b/docs/index.html
index 55bd2f5..e02a4d5 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -421,6 +421,8 @@ span.mainfunction {color: #993300; font-weight: bolder}
         {"type":"UART_F32","data":{"defaults":{"name":{"value":"new"}},"shortName":"UART","inputs":"1","output":"0","category":"radio-function","color":"#E6E0F8","icon":"arrow-in.png","outputs":"0"}},
 
 
+        {"type":"radioFT8Modulator_F32","data":{"defaults":{"name":{"value":"new"}},"shortName":"FT8Mod","inputs":"0","output":"0","category":"radio-function","color":"#E6E0F8","icon":"arrow-in.png","outputs":"1"}},
+
 
 
         {"type":"RadioIQMixer_F32","data":{"defaults":{"name":{"value":"new"}},"shortName":"I-QMixer","inputs":"2","output":"0","category":"radio-function","color":"#E6E0F8","icon":"arrow-in.png","outputs":"2"}},
@@ -3363,7 +3365,7 @@ The actual packets are taken
     <p class=desc>Empties the FIFO transmit buffer.</p>
 
     <p class=func><span class=keyword>clearBuffer</span>();</p>
-    <p class=desc>Returns a bool value true if another data word can be sent. </p>
+    <p class=desc>Clears the send buffer. Does not stop a character being sent. No return value.</p>
 
     <p class=func><span class=keyword>amplitude</span>(<strong>float32_t</strong> a);</p>
     <p class=desc>Sets a,  the zero-to-peak amplitude of the transmit signal.
@@ -3405,6 +3407,102 @@ The actual packets are taken
 
 
 
+<script type="text/x-red" data-help-name="radioFT8Modulator_F32">
+	<!-- ============   radioFT8Modulator_F32    ========= -->
+    <h3>Summary</h3>
+    <div class=tooltipinfo>
+    <p>Generates and transmits the eight-tone frequency shift keyed waveform
+    for the WSJT mode called FT8.
+    The data is provided by an ASCII string.  A subset of possible FT8
+    messages is supported.  All elements of the FT8 waveform are provided
+    including spectral confinement.
+     </p>
+    </div>
+
+    <h3>Audio Connections</h3>
+    <table class=doc align=center cellpadding=3>
+        <tr class=top><th>Port</th><th>Purpose</th></tr>
+        <tr class=odd><td align=center>Out 0</td><td>FT8 transmit audio or I-F</td></tr>
+    </table>
+
+    <h3>Functions</h3>
+
+    <p class=func><span class=keyword>setSampleRate_Hz</span>
+    (<strong>const float32_t</strong> &fs_Hz);</p>
+    <p class=desc>The two values are 48000.0 and 96000.0. </p>
+
+    <p class=func><span class=keyword>ft8Initialize</span>();</p>
+    <p class=desc>This computes several filters that are needed.
+    IMPORTANT: Before calling this initialize function, set the audio sampling rate.</p>
+
+    <p class=func><span class=keyword>FT8TransmitBusy</span>();</p>
+    <p class=desc>Returns <strong>bool</strong> true if transmission is still active (a 12.96 second period).
+    Returns false if new data can be loaded.</p>
+
+    <p class=func><span class=keyword>sendData</span>
+    (<strong>char*</strong> data, <strong>int16_t</strong> i3, <strong>int16_t</strong> n3,
+     <strong>int16_t</strong> specialCase);</p>
+    <p class=desc>  This defines the data to be sent and also triggers the starting time.
+    The parameter data takes a string, such as
+    "K1ABC W9XYZ RR73".  The descriptors, i3 and n3 are needed to define all possible FT8 messages.
+    Because of the current message capability (standard QSO and free text)
+    the i3 and n3 are not needed. The specialCase are:
+    specialCase==0 is not special at all. It converts the message to
+    tones and transmits the 81 tones in FT8 format.
+    specialCase==1 allows running of the message-to-tone conversion without
+    starting the transmission of tones.  Results are in tones[].
+    specialCase==2 starts the transmission of tones[]
+    without doing a message-to-tone conversion as part of the function call. </p>
+
+    <p class=func><span class=keyword>amplitude</span>(<strong>float32_t</strong> a);</p>
+    <p class=desc>Sets a,  the zero-to-peak amplitude of the transmit signal.
+    No return value.</p>
+
+    <p class=func><span class=keyword>frequency</span>(<strong>float32_t</strong> f);</p>
+    <p class=desc>Sets f, the base, lowest, frequency of the FT8 waveform.
+    The occupied bandwidth is a few Hz below f and about 50 Hz above f.
+    No return value.</p>
+
+    <p class=func><span class=keyword>cancelTransmit</span>();</p>
+    <p class=desc>Cancels the current transmission, following the current 128 sample period,
+    if active.  This, of course, does not control PTT.  No return value.</p>
+
+
+    <p class=func><span class=keyword>setSampleRate_Hz</span>(<strong>float32_t</strong> sampleRate_Hz)</p>
+    <p class=desc>Enter sample rate, as float32_t.
+    It applies to this class only.
+    </p>
+
+    <p class=func><span class=keyword>getPayload</span>()</p>
+    <p class=desc>Returns pointer to an array of 10 uint8_t holding the 77 bit payload.
+    </p>
+
+    <p class=func><span class=keyword>getTones</span>()</p>
+    <p class=desc>Returns pointer to an array of 81 uint8_t holding the
+    tones to be transmitted (0, 7).
+    </p>
+
+    <h3>Examples</h3>
+    <p class=exam>File &gt; Examples &gt; OpenAudio_ArduinoLibrary &gt; FT8Transmit
+    </p>
+
+    <h3>Notes</h3>
+    <p>See the library file radioFT8Modulator.h for much more information,
+    references, sample data, and most importantly, credits to the many contributors
+    upon which these FT8 library classes are based.</p>
+
+    <p> This class does not provide true (absolute) clock timing. The sendData() function
+    should be called when it is time for a new 15-sec period transmission.
+    Audio output will start at the next 128 audio sample period. This
+    class does not control push-to-talk (PTT).</p>
+
+</script>
+<script type="text/x-red" data-template-name="radioFT8Modulator_F32">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+</script>
 
 <div>
 <script type="text/x-red" data-help-name="radioModulatedGenerator_F32">
diff --git a/examples/FT8Transmit/FT8Transmit.ino b/examples/FT8Transmit/FT8Transmit.ino
new file mode 100644
index 0000000..2b44a71
--- /dev/null
+++ b/examples/FT8Transmit/FT8Transmit.ino
@@ -0,0 +1,385 @@
+/*
+ *  New FT8Transmit.ino    RSL 29 Aug 2022
+ *
+ * Generates a subset of possible FT8 messages.
+ * S/N is controlled accurately.  Uses Teensy Floating Point
+ * OpenAudio_TeensyLibrary.
+ * See radioFT8Modulator_F32 for information on the implementation.
+ * This INO is in the public domain.
+ */
+
+#include "Arduino.h"
+#include "OpenAudio_ArduinoLibrary.h"
+#include "AudioStream_F32.h"
+#include <Audio.h>
+
+// Only 48 and 96 kHz audio sample rates are currently supported.
+const float sample_rate_Hz = 48000.0f;
+const int   audio_block_samples = 128;
+AudioSettings_F32 audio_settings(sample_rate_Hz, audio_block_samples);
+
+AudioSynthGaussian_F32       GaussianWhiteNoise1(audio_settings); //xy=101,148
+RadioFT8Modulator_F32        FT8Mod1;                             //xy=117,277
+AudioMixer4_F32              mixer4_1;                            //xy=282,218
+AudioFilterFIRGeneral_F32    filterFIRgeneral1(audio_settings);   //xy=452,181
+AudioOutputI2S_F32           audioOutI2S1(audio_settings);        //xy=532,243
+AudioAnalyzeRMS_F32          rms1;                                //xy=625,180
+AudioConnection_F32          patchCord1(GaussianWhiteNoise1, 0, mixer4_1, 0);
+AudioConnection_F32          patchCord2(FT8Mod1, 0, mixer4_1, 1);
+AudioConnection_F32          patchCord5(mixer4_1, filterFIRgeneral1);
+AudioConnection_F32          patchCord3(filterFIRgeneral1, 0, audioOutI2S1, 0);
+AudioConnection_F32          patchCord4(filterFIRgeneral1, 0, audioOutI2S1, 1);
+AudioConnection_F32          patchCord6(filterFIRgeneral1, rms1);
+AudioControlSGTL5000         sgtl5000_1;                          //xy=357,318
+
+/* FIR filter to measure noise power in a 2500 Hz BW
+ * Designed with http://t-filter.appspot.com
+ * Sampling frequency: 48000 Hz
+ * 0 Hz to 100 Hz and 3000 Hz to 24000 Hz  Attenuation = 60.031 dB
+ * 330 Hz to 2770 Hz   Ripple = 0.073 dB
+ */
+static float32_t filter2500BP[597] = {
+-0.0005125820f,-0.0000202947f, 0.0000003593f, 0.0000329934f, 0.0000736751f, 0.0001169578f,
+ 0.0001564562f, 0.0001855962f, 0.0001984728f, 0.0001906737f, 0.0001599822f, 0.0001068279f,
+ 0.0000344273f,-0.0000514436f,-0.0001430419f,-0.0002315220f,-0.0003080131f,-0.0003647587f,
+-0.0003961436f,-0.0003995218f,-0.0003756478f,-0.0003287024f,-0.0002658396f,-0.0001963221f,
+-0.0001303695f,-0.0000777464f,-0.0000465332f,-0.0000418429f,-0.0000651581f,-0.0001139975f,
+-0.0001821358f,-0.0002604090f,-0.0003379262f,-0.0004035583f,-0.0004475075f,-0.0004627523f,
+-0.0004461496f,-0.0003990178f,-0.0003271062f,-0.0002399160f,-0.0001495029f,-0.0000688527f,
+-0.0000100068f, 0.0000176282f, 0.0000087805f,-0.0000368277f,-0.0001142343f,-0.0002137524f,
+-0.0003221742f,-0.0004245023f,-0.0005060412f,-0.0005544731f,-0.0005617283f,-0.0005252710f,
+-0.0004486501f,-0.0003412138f,-0.0002169625f,-0.0000927250f, 0.0000141208f, 0.0000880971f,
+ 0.0001179086f, 0.0000982361f, 0.0000307076f,-0.0000761311f,-0.0002078708f,-0.0003460213f,
+-0.0004701224f,-0.0005615004f,-0.0006049803f,-0.0005918278f,-0.0005209351f,-0.0003992998f,
+-0.0002412975f,-0.0000668730f, 0.0001011003f, 0.0002399869f, 0.0003306072f, 0.0003600909f,
+ 0.0003239133f, 0.0002268029f, 0.0000823809f,-0.0000884979f,-0.0002604794f,-0.0004071616f,
+-0.0005048299f,-0.0005359033f,-0.0004916409f,-0.0003736551f,-0.0001940102f, 0.0000261329f,
+ 0.0002593430f, 0.0004753909f, 0.0006458134f, 0.0007476677f, 0.0007671322f, 0.0007017674f,
+ 0.0005611468f, 0.0003658605f, 0.0001449418f,-0.0000679871f,-0.0002393698f,-0.0003405009f,
+-0.0003517550f,-0.0002656412f,-0.0000882146f, 0.0001613566f, 0.0004531208f, 0.0007502948f,
+ 0.0010142494f, 0.0012099822f, 0.0013111621f, 0.0013041379f, 0.0011902347f, 0.0009859932f,
+ 0.0007212731f, 0.0004353657f, 0.0001717278f,-0.0000281207f,-0.0001305200f,-0.0001146943f,
+ 0.0000239082f, 0.0002725259f, 0.0006024022f, 0.0009724061f, 0.0013345069f, 0.0016403901f,
+ 0.0018483209f, 0.0019292574f, 0.0018713163f, 0.0016819017f, 0.0013872308f, 0.0010291844f,
+ 0.0006595979f, 0.0003334254f, 0.0001008215f,-0.0000000058f, 0.0000514030f, 0.0002543686f,
+ 0.0005865884f, 0.0010066897f, 0.0014595849f, 0.0018838923f, 0.0022204845f, 0.0024209305f,
+ 0.0024546503f, 0.0023137474f, 0.0020147314f, 0.0015968377f, 0.0011170820f, 0.0006426406f,
+ 0.0002415985f,-0.0000267023f,-0.0001203145f,-0.0000211214f, 0.0002619020f, 0.0006935370f,
+ 0.0012155342f, 0.0017563231f, 0.0022384277f, 0.0025907218f, 0.0027584970f, 0.0027114957f,
+ 0.0024488224f, 0.0019998882f, 0.0014211081f, 0.0007886354f, 0.0001880784f,-0.0002974170f,
+-0.0005990413f,-0.0006724584f,-0.0005047619f,-0.0001171406f, 0.0004372104f, 0.0010797374f,
+ 0.0017169949f, 0.0022534601f, 0.0026050371f, 0.0027112878f, 0.0025446519f, 0.0021152693f,
+ 0.0014705327f, 0.0006894468f,-0.0001277897f,-0.0008733366f,-0.0014468246f,-0.0017698095f,
+-0.0017974750f,-0.0015259241f,-0.0009938711f,-0.0002783418f, 0.0005151815f, 0.0012669280f,
+ 0.0018594224f, 0.0021942034f, 0.0022063046f, 0.0018744400f, 0.0012252608f, 0.0003308740f,
+-0.0006999772f,-0.0017363651f,-0.0026430272f,-0.0032994372f,-0.0036172996f,-0.0035539945f,
+-0.0031199655f,-0.0023787848f,-0.0014397352f,-0.0004436511f, 0.0004561031f, 0.0011150128f,
+ 0.0014181900f, 0.0012975421f, 0.0007428372f,-0.0001950981f,-0.0014097317f,-0.0027521917f,
+-0.0040510049f,-0.0051355902f,-0.0058603728f,-0.0061261746f,-0.0058958745f,-0.0052041918f,
+-0.0041474660f,-0.0028816782f,-0.0015956931f,-0.0004880525f, 0.0002612250f, 0.0005167695f,
+ 0.0002085432f,-0.0006559859f,-0.0019902208f,-0.0036379161f,-0.0053928385f,-0.0070261631f,
+-0.0083180284f,-0.0090889780f,-0.0092268159f,-0.0087049647f,-0.0075894402f,-0.0060330006f,
+-0.0042568860f,-0.0025221767f,-0.0010944561f,-0.0002064388f,-0.0000237284f,-0.0006187163f,
+-0.0019563607f,-0.0038947756f,-0.0062005014f,-0.0085775775f,-0.0107065383f,-0.0122883661f,
+-0.0130875874f,-0.0129684039f,-0.0119185125f,-0.0100567406f,-0.0076227165f,-0.0049491711f,
+-0.0024198814f,-0.0004183923f, 0.0007258785f, 0.0007867696f,-0.0003212561f,-0.0025231429f,
+-0.0055845169f,-0.0091349479f,-0.0127114002f,-0.0158169578f,-0.0179877599f,-0.0188595572f,
+-0.0182248418f,-0.0160724049f,-0.0126028433f,-0.0082166040f,-0.0034743283f, 0.0009670264f,
+ 0.0044354922f, 0.0063335060f, 0.0062244751f, 0.0039053136f,-0.0005450570f,-0.0067487839f,
+-0.0140477185f,-0.0215575093f,-0.0282527468f,-0.0330748862f,-0.0350513372f,-0.0334119094f,
+-0.0276905793f,-0.0177980957f,-0.0040578279f, 0.0128017918f, 0.0316985253f, 0.0512872217f,
+ 0.0700815899f, 0.0865943871f, 0.0994813474f, 0.1076734313f, 0.1104831570f, 0.1076734313f,
+ 0.0994813474f, 0.0865943871f, 0.0700815899f, 0.0512872217f, 0.0316985253f, 0.0128017918f,
+-0.0040578279f,-0.0177980957f,-0.0276905793f,-0.0334119094f,-0.0350513372f,-0.0330748862f,
+-0.0282527468f,-0.0215575093f,-0.0140477185f,-0.0067487839f,-0.0005450570f, 0.0039053136f,
+ 0.0062244751f, 0.0063335060f, 0.0044354922f, 0.0009670264f,-0.0034743283f,-0.0082166040f,
+-0.0126028433f,-0.0160724049f,-0.0182248418f,-0.0188595572f,-0.0179877599f,-0.0158169578f,
+-0.0127114002f,-0.0091349479f,-0.0055845169f,-0.0025231429f,-0.0003212561f, 0.0007867696f,
+ 0.0007258785f,-0.0004183923f,-0.0024198814f,-0.0049491711f,-0.0076227165f,-0.0100567406f,
+-0.0119185125f,-0.0129684039f,-0.0130875874f,-0.0122883661f,-0.0107065383f,-0.0085775775f,
+-0.0062005014f,-0.0038947756f,-0.0019563607f,-0.0006187163f,-0.0000237284f,-0.0002064388f,
+-0.0010944561f,-0.0025221767f,-0.0042568860f,-0.0060330006f,-0.0075894402f,-0.0087049647f,
+-0.0092268159f,-0.0090889780f,-0.0083180284f,-0.0070261631f,-0.0053928385f,-0.0036379161f,
+-0.0019902208f,-0.0006559859f, 0.0002085432f, 0.0005167695f, 0.0002612250f,-0.0004880525f,
+-0.0015956931f,-0.0028816782f,-0.0041474660f,-0.0052041918f,-0.0058958745f,-0.0061261746f,
+-0.0058603728f,-0.0051355902f,-0.0040510049f,-0.0027521917f,-0.0014097317f,-0.0001950981f,
+ 0.0007428372f, 0.0012975421f, 0.0014181900f, 0.0011150128f, 0.0004561031f,-0.0004436511f,
+-0.0014397352f,-0.0023787848f,-0.0031199655f,-0.0035539945f,-0.0036172996f,-0.0032994372f,
+-0.0026430272f,-0.0017363651f,-0.0006999772f, 0.0003308740f, 0.0012252608f, 0.0018744400f,
+ 0.0022063046f, 0.0021942034f, 0.0018594224f, 0.0012669280f, 0.0005151815f,-0.0002783418f,
+-0.0009938711f,-0.0015259241f,-0.0017974750f,-0.0017698095f,-0.0014468246f,-0.0008733366f,
+-0.0001277897f, 0.0006894468f, 0.0014705327f, 0.0021152693f, 0.0025446519f, 0.0027112878f,
+ 0.0026050371f, 0.0022534601f, 0.0017169949f, 0.0010797374f, 0.0004372104f,-0.0001171406f,
+-0.0005047619f,-0.0006724584f,-0.0005990413f,-0.0002974170f, 0.0001880784f, 0.0007886354f,
+ 0.0014211081f, 0.0019998882f, 0.0024488224f, 0.0027114957f, 0.0027584970f, 0.0025907218f,
+ 0.0022384277f, 0.0017563231f, 0.0012155342f, 0.0006935370f, 0.0002619020f,-0.0000211214f,
+-0.0001203145f,-0.0000267023f, 0.0002415985f, 0.0006426406f, 0.0011170820f, 0.0015968377f,
+ 0.0020147314f, 0.0023137474f, 0.0024546503f, 0.0024209305f, 0.0022204845f, 0.0018838923f,
+ 0.0014595849f, 0.0010066897f, 0.0005865884f, 0.0002543686f, 0.0000514030f,-0.0000000058f,
+ 0.0001008215f, 0.0003334254f, 0.0006595979f, 0.0010291844f, 0.0013872308f, 0.0016819017f,
+ 0.0018713163f, 0.0019292574f, 0.0018483209f, 0.0016403901f, 0.0013345069f, 0.0009724061f,
+ 0.0006024022f, 0.0002725259f, 0.0000239082f,-0.0001146943f,-0.0001305200f,-0.0000281207f,
+ 0.0001717278f, 0.0004353657f, 0.0007212731f, 0.0009859932f, 0.0011902347f, 0.0013041379f,
+ 0.0013111621f, 0.0012099822f, 0.0010142494f, 0.0007502948f, 0.0004531208f, 0.0001613566f,
+-0.0000882146f,-0.0002656412f,-0.0003517550f,-0.0003405009f,-0.0002393698f,-0.0000679871f,
+ 0.0001449418f, 0.0003658605f, 0.0005611468f, 0.0007017674f, 0.0007671322f, 0.0007476677f,
+ 0.0006458134f, 0.0004753909f, 0.0002593430f, 0.0000261329f,-0.0001940102f,-0.0003736551f,
+-0.0004916409f,-0.0005359033f,-0.0005048299f,-0.0004071616f,-0.0002604794f,-0.0000884979f,
+ 0.0000823809f, 0.0002268029f, 0.0003239133f, 0.0003600909f, 0.0003306072f, 0.0002399869f,
+ 0.0001011003f,-0.0000668730f,-0.0002412975f,-0.0003992998f,-0.0005209351f,-0.0005918278f,
+-0.0006049803f,-0.0005615004f,-0.0004701224f,-0.0003460213f,-0.0002078708f,-0.0000761311f,
+ 0.0000307076f, 0.0000982361f, 0.0001179086f, 0.0000880971f, 0.0000141208f,-0.0000927250f,
+-0.0002169625f,-0.0003412138f,-0.0004486501f,-0.0005252710f,-0.0005617283f,-0.0005544731f,
+-0.0005060412f,-0.0004245023f,-0.0003221742f,-0.0002137524f,-0.0001142343f,-0.0000368277f,
+ 0.0000087805f, 0.0000176282f,-0.0000100068f,-0.0000688527f,-0.0001495029f,-0.0002399160f,
+-0.0003271062f,-0.0003990178f,-0.0004461496f,-0.0004627523f,-0.0004475075f,-0.0004035583f,
+-0.0003379262f,-0.0002604090f,-0.0001821358f,-0.0001139975f,-0.0000651581f,-0.0000418429f,
+-0.0000465332f,-0.0000777464f,-0.0001303695f,-0.0001963221f,-0.0002658396f,-0.0003287024f,
+-0.0003756478f,-0.0003995218f,-0.0003961436f,-0.0003647587f,-0.0003080131f,-0.0002315220f,
+-0.0001430419f,-0.0000514436f, 0.0000344273f, 0.0001068279f, 0.0001599822f, 0.0001906737f,
+ 0.0001984728f, 0.0001855962f, 0.0001564562f, 0.0001169578f, 0.0000736751f, 0.0000329934f,
+ 0.0000003593f,-0.0000202947f,-0.0005125820f};
+
+// Messages 0 to 7
+const char* inputString[] = {
+        "CQ LL3JG",
+        "CQ LL3JG KO26",
+        "L0UAA LL3JG KO26",
+        "L0UAA LL3JG +02",
+        "L0UAA LL3JG RRR",
+        "K1ABC W9XYZ RR73",
+        "TNX BOB 73 GL",
+        "ABCDEFG123456"};
+int32_t sendNext = -1;
+float32_t pStateArray[1322];  // 2*597+128
+float32_t  t60, t60Last;
+uint32_t t60Base;
+bool displayClock = false;
+bool displayPower = false;
+bool sendEvery15Sec = true;
+bool doing15SecSend = false;
+float32_t snrDB = 0.0f;
+
+void setup(void) {
+   Serial.begin(9600);    delay(500);
+   Serial.println("FT8Transmit.ino  Ver 0.1  29 Aug 2022 W7PUA");
+   Serial.println("Use '?' to list commands and '=' to zero FT8 clock.");
+   Serial.println("Use 0 to 7 to set message.");
+
+   AudioMemory_F32(20, audio_settings);
+
+   FT8Mod1.setSampleRate_Hz(48000.0f);
+   FT8Mod1.ft8Initialize();
+   FT8Mod1.frequency(700.0f);
+   // Calibration note: For the following = 0.1 and the GWN amplitude at 0.1,
+   // the power S/N at the output of the FIR filter is 6.617 dB or
+   // 4.589 as a power ratio. The filter is very close to a 2500 Hz BW
+   // so this is close to the WSJT defined S/N.  Show on WSJT-X as -1.8 dB S/N.
+   // (Power as used here means the RMS object output squared.)
+   FT8Mod1.amplitude(0.04668);   // for 0 dB S/N.
+   filterFIRgeneral1.LoadCoeffs(597, filter2500BP, pStateArray);
+
+   GaussianWhiteNoise1.amplitude(0.1f);  // Do not change unless breaking the cal is wanted.
+
+   sgtl5000_1.enable();
+
+   delay(5);
+   t60 = 0.000f;
+   t60Last = t60;
+   t60Base = millis();
+   }
+
+void loop()  {
+   int16_t inCmd;
+   if( Serial.available() )
+      {
+      inCmd = Serial.read();
+      if(inCmd=='0')
+         {
+         sendNext = 0;
+         Serial.print("Next FT8:");
+         Serial.println((char*) inputString[0]);
+         }
+      else if(inCmd=='1')
+         {
+         sendNext = 1;
+         Serial.print("Next FT8:");
+         Serial.println((char*) inputString[1]);
+         }
+      else if(inCmd=='2')
+         {
+         sendNext = 2;
+         Serial.print("Next FT8:");
+         Serial.println((char*) inputString[2]);
+         }
+      else if(inCmd=='3')
+         {
+         sendNext = 3;
+         Serial.print("Next FT8:");
+         Serial.println((char*) inputString[3]);
+         }
+      else if(inCmd=='4')
+         {
+         sendNext = 4;
+         Serial.print("Next FT8:");
+         Serial.println((char*) inputString[4]);
+         }
+      else if(inCmd=='5')
+         {
+         sendNext = 5;
+         Serial.print("Next FT8:");
+         Serial.println((char*) inputString[5]);
+         }
+      else if(inCmd=='6')
+         {
+         sendNext = 6;
+         Serial.print("Next FT8:");
+         Serial.println((char*) inputString[6]);
+         }
+      else if(inCmd=='7')
+         {
+         sendNext = 7;
+         Serial.print("Next FT8:");
+         Serial.println((char*) inputString[7]);
+         }
+      else if(inCmd=='w' || inCmd=='W')  // S/N Up 1 dB
+         {
+         snrDB += 1.0f;
+         FT8Mod1.amplitude(powf(10.0f, 0.05f*(snrDB-26.617)));   //0.04668 is amplitude for 0dB S/N
+         Serial.print("SNR Up 1 dB to "); Serial.println(snrDB, 3);
+         if(snrDB>23.5f)
+            Serial.println("WARNING: S/N > 23 dB may cause DAC overload.");
+         }
+
+      else if(inCmd=='a' || inCmd=='A')  // S/N Down 1 dB
+         {
+         snrDB -= 1.0f;
+         FT8Mod1.amplitude(powf(10.0f, 0.05f*(snrDB-26.617)));   //0.04668 is amplitude for 0dB S/N
+         Serial.print("SNR Down 1 dB to "); Serial.println(snrDB, 3);
+         }
+
+      else if(inCmd=='t' || inCmd=='T')  // Toggle Continuous and Trigger
+         {
+         sendEvery15Sec = !sendEvery15Sec;
+         if(sendEvery15Sec)
+            Serial.println("Send every 15 sec");
+         else
+            Serial.println("Send triggered on Number");
+         }
+      else if(inCmd=='d' || inCmd=='D')  // Toggle dB Power
+         {
+         displayPower = !displayPower;
+         if(displayPower)
+            Serial.println("Display dB Power every sec");
+         else
+            Serial.println("No Display Power");
+         }
+      else if(inCmd=='=')  //Set minute clock to zero
+         {
+         t60 = 0;
+         t60Base = millis();
+         t60Last = t60;
+         Serial.println("Clock Zero'd");
+         }
+      else if(inCmd=='p' || inCmd=='P')  // Increase clock 0.1 sec
+         {
+         t60 += 0.100;
+         t60Base -= 100;
+         Serial.println("Increase clock 0.1 sec");
+         }
+      else if(inCmd=='l' || inCmd=='L')  // Decrease clock 0.1 sec
+         {
+         t60 -= 0.100;
+         t60Base += 100;
+         Serial.println("Decrease clock 0.1 sec");
+         }
+      else if(inCmd=='-')  // Increase clock 1 sec
+         {
+         t60 += 1.000;
+         t60Last = t60;
+         t60Base -= 1000;
+         Serial.println("Increase clock 1 sec");
+         }
+      else if(inCmd==',')  // Decrease clock 1 sec
+         {
+         t60 -= 1.000;
+         t60Last = t60;
+         t60Base -= 1000;
+         Serial.println("Decrease clock 1 sec");
+         }
+      else if(inCmd=='c' || inCmd=='C')  // Toggle clock display
+         {
+         displayClock = !displayClock;
+         }
+      else if(inCmd=='?')
+         {
+         Serial.println("0, 1,...7  Select message 0 to 7");
+         Serial.println("w, W       Increase S/N by 1 dB");
+         Serial.println("a, A       Decrease S/N by 1 dB");
+         Serial.println("t, T       Toggle Repeat every 15 sec or Trigger on msg entry");
+         Serial.println("d, D       Toggle dB total power display, On or Off");
+         Serial.println("=          Set local FT-8 clock to 0 (60 sec range).");
+         Serial.println("p, P       Increase local FT8 clock by 0.1 sec");
+         Serial.println("l, L       Decrease local FT8 clock by 0.1 sec");
+         Serial.println("-          Increase local FT8 clock by 1 sec");
+         Serial.println(",          Decrease local FT8 clock by 1 sec");
+         Serial.println("c, C       Toggle Clock Display On or Off.");
+         Serial.println("?          Help Display (this message)");
+         }
+      else if(inCmd>35)   // Ignore anything below '#'
+         Serial.println("Cmd ???");
+      }   //  End, if Serial Available
+
+      // Update clock
+      t60 = 0.001f*(float32_t)(millis() - t60Base);
+      if(t60 >= 60.000f)
+         {
+         t60 -= 60.000f;     // Seconds
+         t60Base += 60000;   // milliSeconds
+         t60Last = t60;
+         if(displayClock)
+            {
+            Serial.print("Seconds: "); Serial.println(t60, 3);
+            }
+         }
+      if(t60-t60Last >= 1.000f)
+         {
+         if(displayClock)
+            {
+            Serial.print("Seconds: "); Serial.println(t60, 3);
+            }
+         if( rms1.available() && displayPower )
+            {
+            Serial.print("Power, dB = ");
+            Serial.println(20.0*rms1.read(), 2);
+            }
+         t60Last += 1.000f;
+         }
+
+      // Look for immediate triggered send
+      if(sendNext>=0 && !sendEvery15Sec)
+         {
+         FT8Mod1.cancelTransmit();
+         FT8Mod1.sendData((char*) inputString[sendNext], 1, 0, 0);
+         sendNext = -1;
+         Serial.println("Immediate Triggered Send");
+         }
+
+      // Look for send every 15 sec
+      if(!FT8Mod1.FT8TransmitBusy() && timing15() && sendNext>=0 && sendEvery15Sec)
+         {
+         FT8Mod1.cancelTransmit();
+         FT8Mod1.sendData((char*) inputString[sendNext], 1, 0, 0);
+         Serial.println("Send every 15 sec");
+         doing15SecSend = true;
+         }
+   }      // End. loop
+
+// Return true if time for new transmission
+bool timing15(void)  {
+   if(t60>=0.0f  && t60<1.0f)   return true;
+   if(t60>=15.0f && t60<16.0f)  return true;
+   if(t60>=30.0f && t60<31.0f)  return true;
+   if(t60>=45.0f && t60<46.0f)  return true;
+   return false;
+   }
diff --git a/examples/FT8Transmit/FT8Transmit1.gnumeric b/examples/FT8Transmit/FT8Transmit1.gnumeric
new file mode 100644
index 0000000..49c7f6f
Binary files /dev/null and b/examples/FT8Transmit/FT8Transmit1.gnumeric differ
diff --git a/gui/DesignTool_F32.zip b/gui/DesignTool_F32.zip
index 8b1e359..0da8465 100644
Binary files a/gui/DesignTool_F32.zip and b/gui/DesignTool_F32.zip differ
diff --git a/radioFT8Modulator_F32.cpp b/radioFT8Modulator_F32.cpp
new file mode 100644
index 0000000..df10a70
--- /dev/null
+++ b/radioFT8Modulator_F32.cpp
@@ -0,0 +1,133 @@
+/*
+ * radioFT8modulator_F32
+ *
+ * Created: Bob Larkin 17 July 2022
+ *
+ * License: MIT License. Use at your own risk. See radioFT8Modulator.h file.
+ *
+ */
+
+#include "radioFT8Modulator_F32.h"
+// 513 values of the sine wave in a float array:
+#include "sinTable512_f32.h"
+
+void RadioFT8Modulator_F32::update(void) {
+   audio_block_f32_t *blockOut;
+   uint16_t index;
+   float32_t a, b;
+   float32_t mag = 1.0f;
+
+   // uint32_t tu = micros();
+
+   if(ft8Transmit==false)
+      return;
+   // Sending tones.  Sort out actions
+   blockOut = AudioStream_F32::allocate_f32();   // Get the output block
+   if (!blockOut)
+      return;
+
+   /* NOTE - ALL FT8 values shown in comments below are for a 48 kHz sample rate
+    * tone81SendCount     0 to 80 (81 tones)
+    * audioSampleCount    0 to 7679 for 48kHz sample rate
+    * sampleSent          0 to 622079 for 48kHz, 12.96 seconds, 81 tones
+    */
+   // Send 128 audio samples of FSK sine waves
+   for(int kk=0; kk<128; kk++)
+      {
+      audioSampleCount = sampleSent % toneLength;  // audioSampleCount is always derived from sampleSent
+      mag = magnitude;    // Use down below
+      dphi = phaseIncrement;
+      if(tone81SendCount>0 && tone81SendCount<80)  // Exclude end tones as special cases
+         {
+         if(audioSampleCount<pulseSegActive)   //  First part of tone with pulse shaping
+            {
+            // Overlap from previous tone with pulse falling 0.499608070 to 0.0 audioSampleCount 0 to 2815
+            dphi += (pulse[pulseSegActive - audioSampleCount - 1])*tones[tone81SendCount-1]*dphi_peak;
+            // plus current tone with pulse rising 0.500391960 to 1.0, audioSampleCount 0 to 2815
+            dphi += (1.0f - pulse[pulseSegActive - audioSampleCount - 1])*tones[tone81SendCount]*dphi_peak;
+            }
+         else if(audioSampleCount>=pulseSegActive && audioSampleCount<(toneLength - pulseSegActive))  // Center region, no pulses involved
+            {
+            // Center of tone with pulse level at 1.0, main tone, 2816 to 4863
+            dphi += tones[tone81SendCount]*dphi_peak;
+            }
+         else  //if((audioSampleCount - 1)>(toneLength - pulseSegActive))   //  Last part of tone with pulse shaping
+            {
+            // Current tone with pulse falling 1.0 to 0.500391960, audioSampleCount 4864 to 7679
+            dphi += (1.0f - pulse[audioSampleCount - (toneLength - pulseSegActive)])*tones[tone81SendCount]*dphi_peak;
+            // plus overlap from next tone with pulse rising 0.0 to 0.499608070, audioSampleCount 4864 to 7679
+            dphi += (pulse[audioSampleCount - (toneLength - pulseSegActive)])*tones[tone81SendCount + 1]*dphi_peak;
+            }
+         }   // End of middle 79 tones
+      else if(tone81SendCount==0)      // Key click pulse with no tone ahead
+         {
+         if((audioSampleCount)<(toneLength - pulseSegActive))  // audioSampleCount 0 to 4863 incl or 4864 points
+            {
+            // Pulse level at 1.0, main tone
+            dphi += tones[0]*dphi_peak;
+            }
+         else   //  Last part of tone with pulse shaping
+            {
+            // Current tone with pulse falling 1.0 to 0.50039196, audioSampleCount 4864 to 7679 or 2816 pts
+            dphi += (1.0f - pulse[audioSampleCount -(toneLength - pulseSegActive)])*tones[0]*dphi_peak;
+            // plus overlap from next tone with pulse rising 0.00000003 to 0.49960807 on 4864 to 7679
+            dphi += (pulse[audioSampleCount - (toneLength - pulseSegActive)])*tones[1]*dphi_peak;
+            }
+         if(audioSampleCount<cosineRampActive)
+            mag = magnitude*ramp[audioSampleCount];
+         else
+            mag = magnitude;
+         }   // End of first tone
+
+      else if(tone81SendCount==80)      // Key click pulse with no tone after
+         {
+         if(audioSampleCount<pulseSegActive)   //  First part of tone with pulse shaping
+            {
+            // Overlap from previous tone with pulse falling 0.499608070 to 0,00000
+            // over audioSampleCount 0 to 2815
+            dphi += (pulse[pulseSegActive - audioSampleCount - 1])*tones[79]*dphi_peak;
+            // plus current tone with pulse rising 0.50039196 to 1.0000000  0 to 2815
+            dphi += (1.0f - pulse[pulseSegActive - audioSampleCount - 1])*tones[80]*dphi_peak;
+            }
+         else //(audioSampleCount>=pulseSegActive)  // Rest of region, no pulses involved
+            {
+            // Rest of tone with pulse level at 1.0, main tone, audioSampleCount 2816 to 7679
+            dphi += tones[80]*dphi_peak;
+            }
+         if(audioSampleCount>(toneLength - cosineRampActive))
+            {
+            mag = magnitude*ramp[toneLength - audioSampleCount];
+            }
+         else
+            mag = magnitude;
+         }  // End of last tone
+      currentPhase += dphi;
+      while(currentPhase > 512.0f)
+         currentPhase -= 512.0f;
+      while(currentPhase < 0.0f)
+         currentPhase += 512.0f;
+      index = (uint16_t) currentPhase;
+      float32_t deltaPhase = currentPhase - (float32_t)index;
+      // Read two nearest values of input value from the sin table
+      a = sinTable512_f32[index];
+      b = sinTable512_f32[index+1];
+
+      blockOut->data[kk] = mag*(a+(b-a)*deltaPhase); // Linear interpolation
+      sampleSent++;
+      audioSampleCount = sampleSent % toneLength;
+      if(audioSampleCount == 0)  // End of a tone send
+         {
+         if(++tone81SendCount == 81)    // End of the 12.96 second period
+            {
+            tone81SendCount = 0;
+            ft8Transmit = false;
+            // Serial.println("End Transmission");
+            }
+         }
+      }  // End, over all  128 audio output points
+   AudioStream_F32::transmit(blockOut);
+   AudioStream_F32::release (blockOut);
+   // Serial.println(micros() - tu);
+   }
+
+
diff --git a/radioFT8Modulator_F32.h b/radioFT8Modulator_F32.h
new file mode 100644
index 0000000..5acf95b
--- /dev/null
+++ b/radioFT8Modulator_F32.h
@@ -0,0 +1,1032 @@
+/*
+ * radioFT8modulator_F32.h
+ *
+ * FT-8 Modulator including Gaussian frequency change filtering
+ * and raised cosine amplitude control to limit spectral width.
+ * By Bob Larkin  W7PUA   16 July 2022
+ *
+ * Thanks to PJRC and Pau Stoffregen for the Teensy processor, Teensyduino
+ * and Teensy Audio.  Thanks to Chip Audette for the F32 extension
+ * work.  All of that makes this possible.  Bob
+ *
+ * Copyright (c) 2022 Bob Larkin
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice, development funding notice, and this permission
+ * notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * *** CREDITS ***
+ * There have been many contributors to this FT8 project.  I will not
+ * catch them all, but a try is neeeded.  I picked from
+ * multiple sources in making the transmission process consistent with the
+ * 128-block Teensy Audio Library.  But, everything I did was a translation
+ * of existing software.  The "specification" for FT8 is the paper, "The FT4
+ * and FT8 Communications Protocols," by Steve Franke, K9AN, Bill Somerville,
+ * G4WJS and Joe Taylor, K1JT, QEX July/August 2020, pp7-17.  I was guided
+ * in the right direction for this implementation by Farhan, VU2ESE
+ * and Charlie, W5BAA. This led to a pair of excellent Raspberry Pi sources,
+ * https://github.com/kgoba/ft8_lib and
+ * https://github.com/WB2CBA/W5BAA-FT8-POCKET-TERMINAL
+ * An FT8 derivative of the first web site, using the Raspberry Pi,
+ * is Farhan's sBitx:
+ * https://github.com/afarhan/sbitx
+ * For those not familiar with FT8, it is a widely used amateur radio
+ * communications format.  A search of FT8 will lead to much information.
+ *
+ *Notes:
+ * 1 - Sampling rate -  The output of this class is a sampled sine wave,
+ * shifted in frequency according to the FT-8 specification. At this point,
+ *  only 48 and 96 kHz sample rates are supported.
+ */
+
+/* 2 - Bit timing is simple for sample rate of 48 kHz where we start a new bit
+ * every 60 128-sample period blocks, or 96 kHz where it is every 120
+ * 128-sample period blocks.
+ */
+
+/* 3 - This class does not provide true (absolute) clock timing. The sendData() function
+ * should be called when it is time for a new 15-sec period transmission.
+ * This class will start that at the next 128 audio sample period.  Worst
+ * case error is 128/sampleRate seconds, which is 2.667 milliseconds for
+ * a 48 kHz sample rate.  Starting means producing audio output, as this
+ * class does not control PTT.
+ */
+
+/* 4 - The bits are transmitted by 1 of 8 tones that change every 0.16 seconds.
+ * To restrict the occupied spectrum, the frequency control signal is
+ * filtered by a Gaussian LPF (see Franke, Somerville, Taylor QEX
+ * July/Aug 2020).  There are 58 symbols carrying the data payload, CRC check,
+ * and error correcting bits.  These are grouped into two 29 symbol words
+ * MA and MB. There are 3 synchronization words, S, of 7 symbols
+ * and two end amplitude ramp symbols, R1=3 and R2=2, that are only for
+ * stopping key clicks.  All together there are 81 symbol periods of
+ * 0.16 sec used as R1 S MA S MB S R2.  Transmission time is 81*0.16=12.96 sec.
+ */
+
+/* 5 - As explained in the QEX article, the control signal is not filtered
+ * directly to get the Gaussian transitions.  Instead, to save computation,
+ * Gaussian LP filtering is applied to a unit pulse 0.16 secon in time.
+ * This resulting "pulse" can then be multiplied by the frequency
+ * offset.  Linearity enables this simple sum.  This can be thought of as
+ * having a base frequency.  Each pulse moves the frequency to its needed
+ * value and then returns, after 0.16 sec, to the base frequency.  Without
+ * delay the next pulse moves the frequency to some other value.  Instead of
+ * ever going from 5 to 3, we go from 5 to 0 followed immediately by
+ * going from 0 to 3.
+ */
+
+/* 6 - Time requirements - The update function works on 128 samples as a group.
+ * Measured on a T4.0, that function required 19 microseconds, or less.  This
+ * is about 0.7% of the available time at 48 kHz and 1.4% at 96 kHz, i.e.,
+ * it is very small.
+ */
+
+/* MESSAGE FORMATS: The following table shows examples of message formats
+supported by FT8 protocol.  Parameters i3 and n3
+(shown in the first column) are used in the software to define major
+and minor 77-bit message types.
+* TODO: Mark the formats that are currently supported.
+*
+i3.n3  Example Messages       Comments
+————————————————————————————————————————————————————-
+0.0 TNX BOB 73 GL           Free text
+0.1 K1ABC RR73; W9XYZ <KH1/KH7Z> -08   DXpedition Mode
+0.2 PA9XYZ 590003 IO91NP    EU VHF Contest
+0.2 G4ABC/P R 570007 JO22DB EU VHF Contest
+0.3 K1ABC W9XYZ 6A WI       ARRL Field Day
+0.3 W9XYZ K1ABC R 2B EMA    ARRL Field Day
+0.5 123456789ABCDEF012      Telemetry (71 bits, 18 hex digits)
+1. CQ FD K1ABC FN42         ARRL Field Day
+1. CQ RU K1ABC FN42         ARRL RTTY Roundup
+1. CQ K1ABC FN42
+1. CQ TEST K1ABC FN42       NA VHF Contest
+1. CQ TEST K1ABC/R FN42     NA VHF Contest
+1. K1ABC W9XYZ EN37
+1. K1ABC W9XYZ -09
+1. K1ABC W9XYZ R-17
+1. K1ABC W9XYZ RRR
+1. K1ABC W9XYZ 73
+1. K1ABC W9XYZ RR73
+1. K1ABC/R W9XYZ EN37       NA VHF Contest
+1. K1ABC W9XYZ/R RR73       NA VHF Contest
+1. K1ABC/R W9XYZ/R RR73     NA VHF Contest
+1. <PJ4/K1ABC> W9XYZ        Compound call
+1. W9XYZ <PJ4/K1ABC> 73     Compound call
+1. W9XYZ <YW18FIFA> -13     Nonstandard call
+1. <YW18FIFA> W9XYZ R+02    Nonstandard call
+1. W9XYZ <YW18FIFA> RRR     Nonstandard call
+1. <YW18FIFA> W9XYZ RR73    Nonstandard call
+2. CQ G4ABC/P IO91          EU VHF contest
+2. G4ABC/P PA9XYZ JO22      EU VHF contest
+2. PA9XYZ G4ABC/P RR73      EU VHF contest
+3. K1ABC KA0DEF 559 MO      ARRL RTTY Roundup
+3. K1ABC W9XYZ 579 WI       ARRL RTTY Roundup
+3. KA1ABC G3AAA 529 0013    ARRL RTTY Roundup
+3. TU; KA0DEF K1ABC R 569 MA   ARRL RTTY Roundup
+3. TU; K1ABC G3AAA R 559 0194  ARRL RTTY Roundup
+3. W9XYZ K1ABC R 589 MA     ARRL RTTY Roundup
+4. CQ PJ4/K1ABC
+4. CQ YW18FIFA              Nonstandard call
+4. <KA1ABC> YW18FIFA RR73   Nonstandard call
+4. <W9XYZ> PJ4/K1ABC RRR    Nonstandard call
+4. <W9XYZ> YW18FIFA         Nonstandard call
+4. <W9XYZ> YW18FIFA 73      Nonstandard call
+4. PJ4/K1ABC <W9XYZ>        Nonstandard call
+4. PJ4/K1ABC <W9XYZ> 73     Nonstandard call
+4. YW18FIFA <W9XYZ> RRR     Nonstandard call
+———————————————————————————-
+
+In the above list, callsigns enclosed in angle brackets (e.g.,
+<PJ4/K1ABC>, <YW18FIFA>) are transmitted as hash codes. They will be
+displayed correctly by receiving stations that have copied the full
+callsign without brackets in a previous transmissiion. Otherwise the
+receiving software will display <…>. Hash collisions are possible
+but should be rare, and extremely rare within a particular QSO.
+*/
+
+#ifndef _radioFT8modulator_f32_h
+#define _radioFT8modulator_f32_h
+
+#include "Arduino.h"
+#include "AudioStream_F32.h"
+#include "OpenAudio_ArduinoLibrary.h"
+#include <math.h>
+
+#define GFSK_CONST_K 5.336446f // pi*sqrt(2 / log(2))
+#define FT8_SYMBOL_BT 2.0f // symbol smoothing filter bandwidth factor (BT)
+// #define FT4_SYMBOL_BT 1.0f    No FT4 here
+
+class RadioFT8Modulator_F32 : public AudioStream_F32 {
+//GUI: inputs:0, outputs:1  //this line used for automatic generation of GUI node
+//GUI: shortName: FT8modulator
+public:
+   // Option of AudioSettings_F32 change to block size or sample rate:
+   RadioFT8Modulator_F32(void) :  AudioStream_F32(0, NULL) {
+       // Defaults
+      }
+/*   RadioFT8Modulator_F32(const AudioSettings_F32 &settings) : AudioStream_F32(0, NULL) {
+      setSampleRate_Hz(settings.sampleRateHz);
+      block_size = settings.audio_block_samples;
+      }
+ */
+
+   void ft8Initialize(void)  {
+      /* The Gaussian smoothing "pulse" is computed at setup for the current
+       * transmit tone and one before and after.  This optimizes speed.  It is
+       * reasonable to compute the time shifted segments at update() time and
+       * save about 2*toneLength float storage.  It can be continued further by
+       * noting that about half of the values are either 0.0 or 1.0.
+       * So we produce values from  only the rising values over the last 37%.
+       * The rest can be derived simply enough.
+       * toneLength = 7680 audio samples from 0.16 sec at 48 kHz.
+       * pulseSegActive is the length for which float32_t is meaningful.
+       * pulseSegActive = 5632 and 2816 in length.
+       * The subscripts are offset by  toneLength - pulseSegActive
+       *                                    15360 - 5632 = 9728 for 96 kHz
+       *                                     7680 - 2816 = 4864 for 48 kHz
+       */
+      for (int i=toneLength-pulseSegActive; i<toneLength; i++)
+         {
+         // If an odd number of pulse samples:
+         // float t = (((float32_t)i)/(float32_t)toneLength) - 1.5f;
+         // If an even number of pulse samples:
+         float t = ((0.5f + (float32_t)i)/(float32_t)toneLength) - 1.5f;
+         float arg1 = GFSK_CONST_K * FT8_SYMBOL_BT * (t + 0.5f);
+         float arg2 = GFSK_CONST_K * FT8_SYMBOL_BT * (t - 0.5f);
+         pulse[i - toneLength + pulseSegActive] = 0.5f*(erff(arg1) - erff(arg2));
+         }
+         // Print the pulse segment
+         //for (int i=0; i<pulseSegActive; i++)
+         //   {
+	      //   Serial.print(i);
+         //   Serial.print(",");
+         //   Serial.println(pulse[i], 8);
+         //   }
+         // 0,   0.00000003   (Results)
+         //     ...
+         // 2813,0.49803999
+         // 2814,0.49882385
+         // 2815,0.49960807
+
+      // Raised cosine ramp to start and end the transmission
+      // (key click elimination).  Ranges (0, 0.000000) to (959, 0.999997)
+      // for 48 kHz sample rate
+      for(int ii=0; ii<cosineRampActive; ii++)
+         {
+         ramp[ii] = 0.5*(1.0f - cosf(PI*(float32_t)ii/cosineRampActive));
+         // Serial.println(ramp[ii], 6);
+         }
+   }
+
+   // Is transmission active?
+   bool FT8TransmitBusy(void)  {
+      return ft8Transmit;
+      }
+
+   // As viewed from the INO, put ASCII into _data array to be sent.
+   // Returns true if successful.
+   // *Special Cases*
+   // _specialCase==0:
+   //    Not special at all.  Converts the message to tones and transmits
+   //    the 81 tones in FT8 format.
+   // _specialCase = 1:
+   //    This allows running of the message-to-tone conversion without
+   //    starting the transmission of tones.  Results are in tones[].
+   //    To keep things simple, this *cannot* be done when tones are
+   //    being transmitted.  See cancelTransmit() below, if needed.
+   // _specialCase==2:
+   //    This starts the transmission of tones[]
+   //    without doing a message-to-tone as part of the function call.
+   //    Again, only when not transmitting.  See getTones() below for pointer
+   //    to the array that can be filled.
+   bool sendData(char* _data, int16_t _i3, int16_t _n3, int16_t _specialCase) {
+      if( ft8Transmit ) {  // Busy transmitting
+         return false;
+         }
+      dataFT8 = _data;
+      i3 = _i3;        // Todo - These are not implemented
+      n3 = _n3;
+      if(_specialCase!=2)
+         {
+         pack77(dataFT8, packedPayload);  // Build the FT8 payload bit array
+         genft8(packedPayload, &tones[1]);  // Shift one to allow for 2 key-click tones
+         // Add key click suppression tones, with slow 20 mSec transitions
+         tones[0] = tones[1];   // Make same freq as [1]
+         tones[80] = tones[79];
+         tone81SendCount = 0;
+         }
+      if(_specialCase!=1)
+         {
+         ft8Transmit = true;    // Start new 81 tone, 12.96 second transmit
+         tone81SendCount = 0;
+         }
+      return true;
+      }
+
+   // Sets base frequency for FT-8 modulation transmission.  Tones 0 to 7
+   // raise the frequency by 0 to 7 times 6.25 Hz.
+   void frequency(float32_t _f0) {
+      freqFT8 = _f0;
+      phaseIncrement = kp*freqFT8;
+      }
+
+   // The amplitude, a, is the peak, as in zero-to-peak.  This produces outputs
+   // ranging from -a to +a.
+   void amplitude(float32_t a) {
+      if (a < 0.0f)  a = 0.0f;
+      magnitude = a;
+      }
+
+   // Following reflects that there are only 2 supported sample rates.
+   // IMPORTANT: This changes constants for FT8 Transmit, only.  It does not
+   // change system-wide audio sample rate.  Use AudioSettings_F32.
+   void setSampleRate_Hz(const float32_t &fs_Hz) {
+      sampleRateHz = fs_Hz;
+      if(sampleRateHz>47900.0f && sampleRateHz<48100.0f)
+         {
+         sampleRateHz = 48000.0f;
+         }
+      else if(sampleRateHz>95900.0f && sampleRateHz<96100.0f)
+         {
+         sampleRateHz = 96000.0f;
+         }
+      else
+         {
+         Serial.println("Unsupported sample rate, FT-8 will not transmit.");
+         }
+      kp = 512.0f/sampleRateHz;
+      toneLength = (int32_t)(0.5f + 0.16f*sampleRateHz);
+      pulseSegActive = (int32_t)(0.5f + 0.3666667f*toneLength);
+      phaseIncrement = kp*freqFT8;
+      dphi_peak = 512.0f*6.25f/sampleRateHz;
+      cosineRampActive = (int32_t)(0.5f + 0.020f*sampleRateHz);
+      }
+
+   void cancelTransmit(void)  {
+      ft8Transmit = false;
+      }
+
+   // Returns pointer to array of 10 bytes holding 77 bit payload
+   uint8_t* getPayload(void) {
+      return packedPayload;
+      }
+
+   // Returns pointer to 81 bytes holding the tones to be transmitted (0, 7)
+   uint8_t* getTones(void) {
+      return tones;
+      }
+
+   // Diagnostic function.  Caution, this may be removed in the future.
+   void printFT8TransmitInfo(void)  {
+      if(ft8Transmit)
+         Serial.println("FT8 in Transmission");
+      else
+         Serial.println("FT8 Transmit Idle");
+      Serial.print("Sample Rate, Hz      = "); Serial.println(sampleRateHz);
+      Serial.print("kp, 512 per SR       = "); Serial.println(kp, 8);
+      Serial.print("Tone Length, samples = "); Serial.println(toneLength);
+      Serial.print("Pulse Segment Active = "); Serial.println(pulseSegActive);
+      Serial.print("Cosine Ramp Active   = "); Serial.println(cosineRampActive);
+      Serial.print("FT8 Base Frequency   = "); Serial.println(freqFT8);
+      Serial.print("FT8 Frequency        = "); Serial.println(dphi/kp);
+      Serial.print("Current Tone Number  = "); Serial.println(tone81SendCount);
+      Serial.print("Current Tone         = "); Serial.println(tones[tone81SendCount]);
+      Serial.print("Sample being Sent    = "); Serial.println(sampleSent);
+      Serial.println("");
+      }
+
+   virtual void update(void);
+
+private:
+   float32_t sampleRateHz = AUDIO_SAMPLE_RATE_EXACT;
+   // Only 2 sample rates are supported
+   // block_size other than 128 is not supported:
+   uint16_t  blockSize = 128;
+   int32_t   toneLength = (int32_t)(0.5f + 0.16f*sampleRateHz);
+   int32_t   pulseSegActive = (int32_t)(0.5f + 0.3666667f*toneLength);
+   int32_t   cosineRampActive = (int32_t)(0.5f + 0.020f*sampleRateHz);
+   float32_t freqFT8 = 1000.0f;
+   float32_t kp = 512.0f/sampleRateHz;
+   float32_t phaseIncrement = kp*freqFT8;
+   float32_t currentPhase = 0.0f;
+   float32_t dphi = 0.0f;
+   float32_t dphi_peak = 512.0f*6.25f/sampleRateHz;
+   float32_t magnitude = 1.0f;
+   int32_t  tone81SendCount = 0;
+   int32_t  audioSampleCount = 0;
+   int32_t  sampleSent = 0;
+   float32_t ramp[1920];    // Raised cosine ramp 20mSec at 96 kHz sample rate
+   float32_t pulse[5632];   // Non zero, non-one part of pulse rising 0.0 to 0.5
+   bool ft8Transmit = false;
+   char* dataFT8 = NULL;
+   uint16_t i3 = 0;
+   uint16_t n3 = 0;
+
+   const int ND = 58;      // Data symbols
+   const int NS = 21;      // Sync symbols (3 @ Costas 7x7)
+   const int NN = 79;   // Total channel symbols (79)
+   // Define the LDPC sizes
+   const int N = 174;      // Number of bits in the encoded message
+   const int K = 91;       // Number of payload bits
+   const int M = 83;
+   const int K_BYTES = 12;
+   // Define CRC parameters
+   uint16_t CRC_POLYNOMIAL = 0x2757;  // CRC-14 polynomial without the leading (MSB) 1
+   const int CRC_WIDTH = 14;
+   uint8_t packedPayload[10];
+   uint8_t tones[81];            // 79 + 2 for key click reduction
+ //  const int rampSize[4] = {0, 8, 9, 16}; // For none plus the 3 sample rates allowed
+
+// -----------------------------------------------------------------------
+// The remainder of this was brazenly borrowed from Karlis Goba's
+// https://github.com/kgoba/ft8_lib/blob/master/ft8/
+// and retains his "todo's," etc.  Thanks to the whole chain of authors.
+
+// Costas 7x7 tone pattern
+const uint8_t kCostas_map[7] = { 3,1,4,0,6,5,2 };
+
+// Gray code map
+const uint8_t kGray_map[8] = { 0,1,3,2,5,6,4,7 };
+
+// Parity generator matrix for (174,91) LDPC code, stored in bitpacked format (MSB first)
+const uint8_t kGenerator[83][12] = {
+   { 0x83, 0x29, 0xce, 0x11, 0xbf, 0x31, 0xea, 0xf5, 0x09, 0xf2, 0x7f, 0xc0 },
+   { 0x76, 0x1c, 0x26, 0x4e, 0x25, 0xc2, 0x59, 0x33, 0x54, 0x93, 0x13, 0x20 },
+   { 0xdc, 0x26, 0x59, 0x02, 0xfb, 0x27, 0x7c, 0x64, 0x10, 0xa1, 0xbd, 0xc0 },
+   { 0x1b, 0x3f, 0x41, 0x78, 0x58, 0xcd, 0x2d, 0xd3, 0x3e, 0xc7, 0xf6, 0x20 },
+   { 0x09, 0xfd, 0xa4, 0xfe, 0xe0, 0x41, 0x95, 0xfd, 0x03, 0x47, 0x83, 0xa0 },
+   { 0x07, 0x7c, 0xcc, 0xc1, 0x1b, 0x88, 0x73, 0xed, 0x5c, 0x3d, 0x48, 0xa0 },
+   { 0x29, 0xb6, 0x2a, 0xfe, 0x3c, 0xa0, 0x36, 0xf4, 0xfe, 0x1a, 0x9d, 0xa0 },
+   { 0x60, 0x54, 0xfa, 0xf5, 0xf3, 0x5d, 0x96, 0xd3, 0xb0, 0xc8, 0xc3, 0xe0 },
+   { 0xe2, 0x07, 0x98, 0xe4, 0x31, 0x0e, 0xed, 0x27, 0x88, 0x4a, 0xe9, 0x00 },
+   { 0x77, 0x5c, 0x9c, 0x08, 0xe8, 0x0e, 0x26, 0xdd, 0xae, 0x56, 0x31, 0x80 },
+   { 0xb0, 0xb8, 0x11, 0x02, 0x8c, 0x2b, 0xf9, 0x97, 0x21, 0x34, 0x87, 0xc0 },
+   { 0x18, 0xa0, 0xc9, 0x23, 0x1f, 0xc6, 0x0a, 0xdf, 0x5c, 0x5e, 0xa3, 0x20 },
+   { 0x76, 0x47, 0x1e, 0x83, 0x02, 0xa0, 0x72, 0x1e, 0x01, 0xb1, 0x2b, 0x80 },
+   { 0xff, 0xbc, 0xcb, 0x80, 0xca, 0x83, 0x41, 0xfa, 0xfb, 0x47, 0xb2, 0xe0 },
+   { 0x66, 0xa7, 0x2a, 0x15, 0x8f, 0x93, 0x25, 0xa2, 0xbf, 0x67, 0x17, 0x00 },
+   { 0xc4, 0x24, 0x36, 0x89, 0xfe, 0x85, 0xb1, 0xc5, 0x13, 0x63, 0xa1, 0x80 },
+   { 0x0d, 0xff, 0x73, 0x94, 0x14, 0xd1, 0xa1, 0xb3, 0x4b, 0x1c, 0x27, 0x00 },
+   { 0x15, 0xb4, 0x88, 0x30, 0x63, 0x6c, 0x8b, 0x99, 0x89, 0x49, 0x72, 0xe0 },
+   { 0x29, 0xa8, 0x9c, 0x0d, 0x3d, 0xe8, 0x1d, 0x66, 0x54, 0x89, 0xb0, 0xe0 },
+   { 0x4f, 0x12, 0x6f, 0x37, 0xfa, 0x51, 0xcb, 0xe6, 0x1b, 0xd6, 0xb9, 0x40 },
+   { 0x99, 0xc4, 0x72, 0x39, 0xd0, 0xd9, 0x7d, 0x3c, 0x84, 0xe0, 0x94, 0x00 },
+   { 0x19, 0x19, 0xb7, 0x51, 0x19, 0x76, 0x56, 0x21, 0xbb, 0x4f, 0x1e, 0x80 },
+   { 0x09, 0xdb, 0x12, 0xd7, 0x31, 0xfa, 0xee, 0x0b, 0x86, 0xdf, 0x6b, 0x80 },
+   { 0x48, 0x8f, 0xc3, 0x3d, 0xf4, 0x3f, 0xbd, 0xee, 0xa4, 0xea, 0xfb, 0x40 },
+   { 0x82, 0x74, 0x23, 0xee, 0x40, 0xb6, 0x75, 0xf7, 0x56, 0xeb, 0x5f, 0xe0 },
+   { 0xab, 0xe1, 0x97, 0xc4, 0x84, 0xcb, 0x74, 0x75, 0x71, 0x44, 0xa9, 0xa0 },
+   { 0x2b, 0x50, 0x0e, 0x4b, 0xc0, 0xec, 0x5a, 0x6d, 0x2b, 0xdb, 0xdd, 0x00 },
+   { 0xc4, 0x74, 0xaa, 0x53, 0xd7, 0x02, 0x18, 0x76, 0x16, 0x69, 0x36, 0x00 },
+   { 0x8e, 0xba, 0x1a, 0x13, 0xdb, 0x33, 0x90, 0xbd, 0x67, 0x18, 0xce, 0xc0 },
+   { 0x75, 0x38, 0x44, 0x67, 0x3a, 0x27, 0x78, 0x2c, 0xc4, 0x20, 0x12, 0xe0 },
+   { 0x06, 0xff, 0x83, 0xa1, 0x45, 0xc3, 0x70, 0x35, 0xa5, 0xc1, 0x26, 0x80 },
+   { 0x3b, 0x37, 0x41, 0x78, 0x58, 0xcc, 0x2d, 0xd3, 0x3e, 0xc3, 0xf6, 0x20 },
+   { 0x9a, 0x4a, 0x5a, 0x28, 0xee, 0x17, 0xca, 0x9c, 0x32, 0x48, 0x42, 0xc0 },
+   { 0xbc, 0x29, 0xf4, 0x65, 0x30, 0x9c, 0x97, 0x7e, 0x89, 0x61, 0x0a, 0x40 },
+   { 0x26, 0x63, 0xae, 0x6d, 0xdf, 0x8b, 0x5c, 0xe2, 0xbb, 0x29, 0x48, 0x80 },
+   { 0x46, 0xf2, 0x31, 0xef, 0xe4, 0x57, 0x03, 0x4c, 0x18, 0x14, 0x41, 0x80 },
+   { 0x3f, 0xb2, 0xce, 0x85, 0xab, 0xe9, 0xb0, 0xc7, 0x2e, 0x06, 0xfb, 0xe0 },
+   { 0xde, 0x87, 0x48, 0x1f, 0x28, 0x2c, 0x15, 0x39, 0x71, 0xa0, 0xa2, 0xe0 },
+   { 0xfc, 0xd7, 0xcc, 0xf2, 0x3c, 0x69, 0xfa, 0x99, 0xbb, 0xa1, 0x41, 0x20 },
+   { 0xf0, 0x26, 0x14, 0x47, 0xe9, 0x49, 0x0c, 0xa8, 0xe4, 0x74, 0xce, 0xc0 },
+   { 0x44, 0x10, 0x11, 0x58, 0x18, 0x19, 0x6f, 0x95, 0xcd, 0xd7, 0x01, 0x20 },
+   { 0x08, 0x8f, 0xc3, 0x1d, 0xf4, 0xbf, 0xbd, 0xe2, 0xa4, 0xea, 0xfb, 0x40 },
+   { 0xb8, 0xfe, 0xf1, 0xb6, 0x30, 0x77, 0x29, 0xfb, 0x0a, 0x07, 0x8c, 0x00 },
+   { 0x5a, 0xfe, 0xa7, 0xac, 0xcc, 0xb7, 0x7b, 0xbc, 0x9d, 0x99, 0xa9, 0x00 },
+   { 0x49, 0xa7, 0x01, 0x6a, 0xc6, 0x53, 0xf6, 0x5e, 0xcd, 0xc9, 0x07, 0x60 },
+   { 0x19, 0x44, 0xd0, 0x85, 0xbe, 0x4e, 0x7d, 0xa8, 0xd6, 0xcc, 0x7d, 0x00 },
+   { 0x25, 0x1f, 0x62, 0xad, 0xc4, 0x03, 0x2f, 0x0e, 0xe7, 0x14, 0x00, 0x20 },
+   { 0x56, 0x47, 0x1f, 0x87, 0x02, 0xa0, 0x72, 0x1e, 0x00, 0xb1, 0x2b, 0x80 },
+   { 0x2b, 0x8e, 0x49, 0x23, 0xf2, 0xdd, 0x51, 0xe2, 0xd5, 0x37, 0xfa, 0x00 },
+   { 0x6b, 0x55, 0x0a, 0x40, 0xa6, 0x6f, 0x47, 0x55, 0xde, 0x95, 0xc2, 0x60 },
+   { 0xa1, 0x8a, 0xd2, 0x8d, 0x4e, 0x27, 0xfe, 0x92, 0xa4, 0xf6, 0xc8, 0x40 },
+   { 0x10, 0xc2, 0xe5, 0x86, 0x38, 0x8c, 0xb8, 0x2a, 0x3d, 0x80, 0x75, 0x80 },
+   { 0xef, 0x34, 0xa4, 0x18, 0x17, 0xee, 0x02, 0x13, 0x3d, 0xb2, 0xeb, 0x00 },
+   { 0x7e, 0x9c, 0x0c, 0x54, 0x32, 0x5a, 0x9c, 0x15, 0x83, 0x6e, 0x00, 0x00 },
+   { 0x36, 0x93, 0xe5, 0x72, 0xd1, 0xfd, 0xe4, 0xcd, 0xf0, 0x79, 0xe8, 0x60 },
+   { 0xbf, 0xb2, 0xce, 0xc5, 0xab, 0xe1, 0xb0, 0xc7, 0x2e, 0x07, 0xfb, 0xe0 },
+   { 0x7e, 0xe1, 0x82, 0x30, 0xc5, 0x83, 0xcc, 0xcc, 0x57, 0xd4, 0xb0, 0x80 },
+   { 0xa0, 0x66, 0xcb, 0x2f, 0xed, 0xaf, 0xc9, 0xf5, 0x26, 0x64, 0x12, 0x60 },
+   { 0xbb, 0x23, 0x72, 0x5a, 0xbc, 0x47, 0xcc, 0x5f, 0x4c, 0xc4, 0xcd, 0x20 },
+   { 0xde, 0xd9, 0xdb, 0xa3, 0xbe, 0xe4, 0x0c, 0x59, 0xb5, 0x60, 0x9b, 0x40 },
+   { 0xd9, 0xa7, 0x01, 0x6a, 0xc6, 0x53, 0xe6, 0xde, 0xcd, 0xc9, 0x03, 0x60 },
+   { 0x9a, 0xd4, 0x6a, 0xed, 0x5f, 0x70, 0x7f, 0x28, 0x0a, 0xb5, 0xfc, 0x40 },
+   { 0xe5, 0x92, 0x1c, 0x77, 0x82, 0x25, 0x87, 0x31, 0x6d, 0x7d, 0x3c, 0x20 },
+   { 0x4f, 0x14, 0xda, 0x82, 0x42, 0xa8, 0xb8, 0x6d, 0xca, 0x73, 0x35, 0x20 },
+   { 0x8b, 0x8b, 0x50, 0x7a, 0xd4, 0x67, 0xd4, 0x44, 0x1d, 0xf7, 0x70, 0xe0 },
+   { 0x22, 0x83, 0x1c, 0x9c, 0xf1, 0x16, 0x94, 0x67, 0xad, 0x04, 0xb6, 0x80 },
+   { 0x21, 0x3b, 0x83, 0x8f, 0xe2, 0xae, 0x54, 0xc3, 0x8e, 0xe7, 0x18, 0x00 },
+   { 0x5d, 0x92, 0x6b, 0x6d, 0xd7, 0x1f, 0x08, 0x51, 0x81, 0xa4, 0xe1, 0x20 },
+   { 0x66, 0xab, 0x79, 0xd4, 0xb2, 0x9e, 0xe6, 0xe6, 0x95, 0x09, 0xe5, 0x60 },
+   { 0x95, 0x81, 0x48, 0x68, 0x2d, 0x74, 0x8a, 0x38, 0xdd, 0x68, 0xba, 0xa0 },
+   { 0xb8, 0xce, 0x02, 0x0c, 0xf0, 0x69, 0xc3, 0x2a, 0x72, 0x3a, 0xb1, 0x40 },
+   { 0xf4, 0x33, 0x1d, 0x6d, 0x46, 0x16, 0x07, 0xe9, 0x57, 0x52, 0x74, 0x60 },
+   { 0x6d, 0xa2, 0x3b, 0xa4, 0x24, 0xb9, 0x59, 0x61, 0x33, 0xcf, 0x9c, 0x80 },
+   { 0xa6, 0x36, 0xbc, 0xbc, 0x7b, 0x30, 0xc5, 0xfb, 0xea, 0xe6, 0x7f, 0xe0 },
+   { 0x5c, 0xb0, 0xd8, 0x6a, 0x07, 0xdf, 0x65, 0x4a, 0x90, 0x89, 0xa2, 0x00 },
+   { 0xf1, 0x1f, 0x10, 0x68, 0x48, 0x78, 0x0f, 0xc9, 0xec, 0xdd, 0x80, 0xa0 },
+   { 0x1f, 0xbb, 0x53, 0x64, 0xfb, 0x8d, 0x2c, 0x9d, 0x73, 0x0d, 0x5b, 0xa0 },
+   { 0xfc, 0xb8, 0x6b, 0xc7, 0x0a, 0x50, 0xc9, 0xd0, 0x2a, 0x5d, 0x03, 0x40 },
+   { 0xa5, 0x34, 0x43, 0x30, 0x29, 0xea, 0xc1, 0x5f, 0x32, 0x2e, 0x34, 0xc0 },
+   { 0xc9, 0x89, 0xd9, 0xc7, 0xc3, 0xd3, 0xb8, 0xc5, 0x5d, 0x75, 0x13, 0x00 },
+   { 0x7b, 0xb3, 0x8b, 0x2f, 0x01, 0x86, 0xd4, 0x66, 0x43, 0xae, 0x96, 0x20 },
+   { 0x26, 0x44, 0xeb, 0xad, 0xeb, 0x44, 0xb9, 0x46, 0x7d, 0x1f, 0x42, 0xc0 },
+   { 0x60, 0x8c, 0xc8, 0x57, 0x59, 0x4b, 0xfb, 0xb5, 0x5d, 0x69, 0x60, 0x00 }
+};
+
+// TODO: This is wasteful, should figure out something more elegant
+   const char A0s[43] = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ+-./?";
+   const char A1s[38] = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+   const char A2s[37] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+   const char A3s[11] = "0123456789";
+   const char A4s[28] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+   // Pack a special token, a 22-bit hash code, or a valid base call
+   // into a 28-bit integer.
+   int32_t pack28(const char *callsign) {
+      int32_t NTOKENS = 2063592L;
+      int32_t MAX22   = 4194304L;
+
+      // Check for special tokens first
+      if (starts_with(callsign, "DE "))   return 0;
+      if (starts_with(callsign, "QRZ "))  return 1;
+      if (starts_with(callsign, "CQ "))   return 2;
+
+      if (starts_with(callsign, "CQ_"))
+         {
+         //int nnum = 0, nlet = 0;
+         // TODO:
+         // if(nnum.eq.3 .and. nlet.eq.0) then n28=3+nqsy
+         // if(nlet.ge.1 .and. nlet.le.4 .and. nnum.eq.0) then n28=3+1000+m
+         }
+
+      // TODO: Check for <...> callsign
+      // if(text(1:1).eq.'<')then
+      //   call save_hash_call(text,n10,n12,n22)   !Save callsign in hash table
+      //   n28=NTOKENS + n22
+      char c6[6] = {' ', ' ', ' ', ' ', ' ', ' '};
+
+      int length = 0; // strlen(callsign);  // We will need it later
+      while (callsign[length] != ' ' && callsign[length] != 0)
+         {
+         length++;
+         }
+      // Copy callsign to 6 character buffer
+      if (starts_with(callsign, "3DA0") && length <= 7)
+         {
+         // Work-around for Swaziland prefix: 3DA0XYZ -> 3D0XYZ
+         memcpy(c6, "3D0", 3);
+         memcpy(c6 + 3, callsign + 4, length - 4);
+         }
+      else if (starts_with(callsign, "3X") && is_letter(callsign[2]) && length <= 7)
+         {
+         // Work-around for Guinea prefixes: 3XA0XYZ -> QA0XYZ
+         memcpy(c6, "Q", 1);
+         memcpy(c6 + 1, callsign + 2, length - 2);
+         }
+      else
+         {
+         if (is_digit(callsign[2]) && length <= 6)
+            {
+            // AB0XYZ
+            memcpy(c6, callsign, length);
+            }
+         else if (is_digit(callsign[1]) && length <= 5)
+            {
+            // A0XYZ -> " A0XYZ"
+            memcpy(c6 + 1, callsign, length);
+            }
+         }
+      // Check for standard callsign
+      int i0, i1, i2, i3, i4, i5;
+      if((i0 = char_index(A1s, c6[0])) >= 0 && (i1 = char_index(A2s, c6[1])) >= 0 &&
+         (i2 = char_index(A3s, c6[2])) >= 0 && (i3 = char_index(A4s, c6[3])) >= 0 &&
+         (i4 = char_index(A4s, c6[4])) >= 0 && (i5 = char_index(A4s, c6[5])) >= 0)
+         {
+         //printf("Pack28: idx=[%d, %d, %d, %d, %d, %d]\n", i0, i1, i2, i3, i4, i5);
+         // This is a standard callsign
+         int32_t n28 = i0;
+         n28 = n28 * 36 + i1;
+         n28 = n28 * 10 + i2;
+         n28 = n28 * 27 + i3;
+         n28 = n28 * 27 + i4;
+         n28 = n28 * 27 + i5;
+         //printf("Pack28: n28=%d (%04xh)\n", n28, n28);
+         return NTOKENS + MAX22 + n28;
+         }
+      //char text[13];
+      //if (length > 13) return -1;
+
+      // TODO:
+      // Treat this as a nonstandard callsign: compute its 22-bit hash
+      // call save_hash_call(text,n10,n12,n22)   !Save callsign in hash table
+      // n28=NTOKENS + n22
+      // n28=iand(n28,ishft(1,28)-1)
+      return -1;
+   }      // End pack28()
+
+// Check if a string could be a valid standard callsign or a valid
+// compound callsign.
+// Return base call "bc" and a logical "cok" indicator.
+bool chkcall(const char *call, char *bc) {
+   int length = strlen(call);   // n1=len_trim(w)
+   if (length > 11) return false;
+   if (0 != strchr(call, '.')) return false;
+   if (0 != strchr(call, '+')) return false;
+   if (0 != strchr(call, '-')) return false;
+   if (0 != strchr(call, '?')) return false;
+   if (length > 6 && 0 != strchr(call, '/')) return false;
+
+   // TODO: implement suffix parsing (or rework?)
+   //bc=w(1:6)
+   //i0=char_index(w,'/')
+   //if(max(i0-1,n1-i0).gt.6) go to 100      !Base call must be < 7 characters
+   //if(i0.ge.2 .and. i0.le.n1-1) then       !Extract base call from compound call
+   //   if(i0-1.le.n1-i0) bc=w(i0+1:n1)//'   '
+   //   if(i0-1.gt.n1-i0) bc=w(1:i0-1)//'   '
+
+    return true;
+   }
+
+uint16_t packgrid(const char *grid4) {
+    //constexpr uint16_t MAXGRID4 = 32400;
+    uint16_t MAXGRID4 = 32400;
+
+    if (grid4 == 0) {
+        // Two callsigns only, no report/grid
+        return MAXGRID4 + 1;
+    }
+
+    // Take care of special cases
+    if (equals(grid4, "RRR")) return MAXGRID4 + 2;
+    if (equals(grid4, "RR73")) return MAXGRID4 + 3;
+    if (equals(grid4, "73")) return MAXGRID4 + 4;
+
+    // Check for standard 4 letter grid
+    if (in_range(grid4[0], 'A', 'R') &&
+        in_range(grid4[1], 'A', 'R') &&
+        is_digit(grid4[2]) && is_digit(grid4[3]))
+    {
+        //if (w(3).eq.'R ') ir=1
+        uint16_t igrid4 = (grid4[0] - 'A');
+        igrid4 = igrid4 * 18 + (grid4[1] - 'A');
+        igrid4 = igrid4 * 10 + (grid4[2] - '0');
+        igrid4 = igrid4 * 10 + (grid4[3] - '0');
+        return igrid4;
+    }
+
+    // Parse report: +dd / -dd / R+dd / R-dd
+    // TODO: check the range of dd
+    if (grid4[0] == 'R') {
+        int dd = dd_to_int(grid4 + 1, 3);
+        uint16_t irpt = 35 + dd;
+        return (MAXGRID4 + irpt) | 0x8000;  // ir = 1
+    }
+    else {
+        int dd = dd_to_int(grid4, 3);
+        uint16_t irpt = 35 + dd;
+        return (MAXGRID4 + irpt);           // ir = 0
+    }
+
+    return MAXGRID4 + 1;
+   }
+
+// Pack Type 1 (Standard 77-bit message) and Type 2 (ditto, with a "/P" call)
+int pack77_1(const char *msg, uint8_t *b77) {
+    // Locate the first delimiter
+    const char *s1 = strchr(msg, ' ');
+    if (s1 == 0) return -1;
+
+    const char *call1 = msg;        // 1st call
+    const char *call2 = s1 + 1;     // 2nd call
+
+    int32_t n28a = pack28(call1);
+    int32_t n28b = pack28(call2);
+
+    if (n28a < 0 || n28b < 0) return -1;
+
+    uint16_t igrid4;
+
+    // Locate the second delimiter
+    const char *s2 = strchr(s1 + 1, ' ');
+    if (s2 != 0) {
+        igrid4 = packgrid(s2 + 1);
+    }
+    else {
+        // Two callsigns, no grid/report
+        igrid4 = packgrid(0);
+    }
+
+    uint8_t i3 = 1; // No suffix or /R
+
+    // TODO: check for suffixes
+    // if(char_index(w(1),'/P').ge.4 .or. char_index(w(2),'/P').ge.4) i3=2  !Type 2, with "/P"
+    // if(char_index(w(1),'/P').ge.4 .or. char_index(w(1),'/R').ge.4) ipa=1
+    // if(char_index(w(2),'/P').ge.4 .or. char_index(w(2),'/R').ge.4) ipb=1
+
+    // Shift in ipa and ipb bits into n28a and n28b
+    n28a <<= 1; // ipa = 0
+    n28b <<= 1; // ipb = 0
+
+    // Pack into (28 + 1) + (28 + 1) + (1 + 15) + 3 bits
+    // write(c77,1000) n28a,ipa,n28b,ipb,ir,igrid4,i3
+    // 1000 format(2(b28.28,b1),b1,b15.15,b3.3)
+
+    b77[0] = (n28a >> 21);
+    b77[1] = (n28a >> 13);
+    b77[2] = (n28a >> 5);
+    b77[3] = (uint8_t)(n28a << 3) | (uint8_t)(n28b >> 26);
+    b77[4] = (n28b >> 18);
+    b77[5] = (n28b >> 10);
+    b77[6] = (n28b >> 2);
+    b77[7] = (uint8_t)(n28b << 6) | (uint8_t)(igrid4 >> 10);
+    b77[8] = (igrid4 >> 2);
+    b77[9] = (uint8_t)(igrid4 << 6) | (uint8_t)(i3 << 3);
+
+    return 0;
+   }
+
+void packtext77(const char *text, uint8_t *b77) {
+    int length = strlen(text);
+
+    // Skip leading and trailing spaces
+    while (*text == ' ' && *text != 0) {
+        ++text;
+        --length;
+    }
+    while (length > 0 && text[length - 1] == ' ') {
+        --length;
+    }
+
+    // Clear the first 72 bits representing a long number
+    for (int i = 0; i < 9; ++i) {
+        b77[i] = 0;
+    }
+
+    // Now express the text as base-42 number stored
+    // in the first 72 bits of b77
+    for (int j = 0; j < 13; ++j) {
+        // Multiply the long integer in b77 by 42
+        uint16_t x = 0;
+        for (int i = 8; i >= 0; --i) {
+            x += b77[i] * (uint16_t)42;
+            b77[i] = (x & 0xFF);
+            x >>= 8;
+        }
+
+        // Get the index of the current char
+        if (j < length) {
+            int q = char_index(A0s, text[j]);
+            x = (q > 0) ? q : 0;
+        }
+        else {
+            x = 0;
+        }
+        // Here we double each added number in order to have the result multiplied
+        // by two as well, so that it's a 71 bit number left-aligned in 72 bits (9 bytes)
+        x <<= 1;
+
+        // Now add the number to our long number
+        for (int i = 8; i >= 0; --i) {
+            if (x == 0) break;
+            x += b77[i];
+            b77[i] = (x & 0xFF);
+            x >>= 8;
+        }
+    }
+
+    // Set n3=0 (bits 71..73) and i3=0 (bits 74..76)
+    b77[8] &= 0xFE;
+    b77[9] &= 0x00;
+   }
+
+// pack77()
+// [IN] msg - 10 byte array consisting of 77 bit payload (MSB first)
+// [OUT] payload - 10 byte array consisting of 77 bit payload (MSB first)
+int pack77(const char *msg, uint8_t *c77) {
+    // Check Type 1 (Standard 77-bit message) or Type 2, with optional "/P"
+    if (0 == pack77_1(msg, c77))
+        {
+        return 0;
+        }
+
+    // TODO:
+    // Check 0.5 (telemetry)
+    // i3=0 n3=5 write(c77,1006) ntel,n3,i3 1006 format(b23.23,2b24.24,2b3.3)
+
+    // Check Type 4 (One nonstandard call and one hashed call)
+    // pack77_4(nwords,w,i3,n3,c77)
+
+    // Default to free text
+    // i3=0 n3=0
+    packtext77(msg, c77);
+    return 0;
+   }
+
+bool starts_with(const char *string, const char *prefix) {
+    return 0 == memcmp(string, prefix, strlen(prefix));
+   }
+
+char to_upper(char c) {
+    return (c >= 'a' && c <= 'z') ? (c - 'a' + 'A') : c;
+   }
+
+bool is_digit(char c) {
+    return (c >= '0') && (c <= '9');
+   }
+
+bool is_letter(char c) {
+    return ((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z'));
+   }
+
+bool is_space(char c) {
+    return (c == ' ');
+   }
+
+bool in_range(char c, char min, char max) {
+    return (c >= min) && (c <= max);
+   }
+
+bool equals(const char *string1, const char *string2) {
+    return 0 == strcmp(string1, string2);
+   }
+
+int char_index(const char *string, char c) {
+    for (int i = 0; *string; ++i, ++string) {
+        if (c == *string) {
+            return i;
+        }
+    }
+    return -1;  // Not found
+   }
+
+// Parse a 2 digit integer from string
+int dd_to_int(const char *str, int length) {
+    int result = 0;
+    bool negative;
+    int i;
+    if (str[0] == '-') {
+        negative = true;
+        i = 1;                          // Consume the - sign
+    }
+    else {
+        negative = false;
+        i = (str[0] == '+') ? 1 : 0;    // Consume a + sign if found
+    }
+    while (i < length) {
+        if (str[i] == 0) break;
+        if (!is_digit(str[i])) break;
+        result *= 10;
+        result += (str[i] - '0');
+        ++i;
+    }
+    return negative ? -result : result;
+}
+
+// Convert a 2 digit integer to string
+void int_to_dd(char *str, int value, int width, bool full_sign) {
+    if (value < 0) {
+        *str = '-';
+        ++str;
+        value = -value;
+    }
+    else if (full_sign) {
+        *str = '+';
+        ++str;
+    }
+    int divisor = 1;
+    for (int i = 0; i < width - 1; ++i) {
+        divisor *= 10;
+    }
+    while (divisor >= 1) {
+        int digit = value / divisor;
+        *str = '0' + digit;
+        ++str;
+        value -= digit * divisor;
+        divisor /= 10;
+    }
+    *str = 0;   // Add zero terminator
+   }
+
+// Returns 1 if an odd number of bits are set in x, zero otherwise
+uint8_t parity8(uint8_t x) {
+    x ^= x >> 4;    // a b c d ae bf cg dh
+    x ^= x >> 2;    // a b ac bd cae dbf aecg bfdh
+    x ^= x >> 1;    // a ab bac acbd bdcae caedbf aecgbfdh
+    return (x) & 1;
+   }
+
+// Encode a 91-bit message and return a 174-bit codeword.
+// The generator matrix has dimensions (87,87).
+// The code is a (174,91) regular ldpc code with column weight 3.
+// The code was generated using the PEG algorithm.
+// Arguments:
+// [IN] message   - array of 91 bits stored as 12 bytes (MSB first)
+// [OUT] codeword - array of 174 bits stored as 22 bytes (MSB first)
+void encode174(const uint8_t *message, uint8_t *codeword) {
+    // Here we don't generate the generator bit matrix as in WSJT-X implementation
+    // Instead we access the generator bits straight from the binary representation in kGenerator
+
+    // For reference:
+    // codeword(1:K)=message
+    // codeword(K+1:N)=pchecks
+
+    // printf("Encode ");
+    // for (int i = 0; i < K_BYTES; ++i) {
+    //     printf("%02x ", message[i]);
+    // }
+    // printf("\n");
+
+    // Fill the codeword with message and zeros, as we will only update binary ones later
+    for (int j = 0; j < (7 + N) / 8; ++j) {
+        codeword[j] = (j < K_BYTES) ? message[j] : 0;
+    }
+
+    uint8_t col_mask = (0x80 >> (K % 8));   // bitmask of current byte
+    uint8_t col_idx = K_BYTES - 1;          // index into byte array
+
+    // Compute the first part of itmp (1:M) and store the result in codeword
+    for (int i = 0; i < M; ++i) { // do i=1,M
+        // Fast implementation of bitwise multiplication and parity checking
+        // Normally nsum would contain the result of dot product between message and kGenerator[i],
+        // but we only compute the sum modulo 2.
+        uint8_t nsum = 0;
+        for (int j = 0; j < K_BYTES; ++j) {
+            uint8_t bits = message[j] & kGenerator[i][j];    // bitwise AND (bitwise multiplication)
+            nsum ^= parity8(bits);                  // bitwise XOR (addition modulo 2)
+        }
+        // Check if we need to set a bit in codeword
+        if (nsum % 2) { // pchecks(i)=mod(nsum,2)
+            codeword[col_idx] |= col_mask;
+        }
+
+        col_mask >>= 1;
+        if (col_mask == 0) {
+            col_mask = 0x80;
+            ++col_idx;
+        }
+    }
+
+    // printf("Result ");
+    // for (int i = 0; i < (N + 7) / 8; ++i) {
+    //     printf("%02x ", codeword[i]);
+    // }
+    // printf("\n");
+   }
+
+// Compute 14-bit CRC for a sequence of given number of bits
+// [IN] message  - byte sequence (MSB first)
+// [IN] num_bits - number of bits in the sequence
+uint16_t crc(uint8_t *message, int num_bits) {
+    // Adapted from https://barrgroup.com/Embedded-Systems/How-To/CRC-Calculation-C-Code
+    //constexpr uint16_t  TOPBIT = (1 << (CRC_WIDTH - 1));
+    uint16_t  TOPBIT = (1 << (CRC_WIDTH - 1));
+    // printf("CRC, %d bits: ", num_bits);
+    // for (int i = 0; i < (num_bits + 7) / 8; ++i) {
+    //     printf("%02x ", message[i]);
+    // }
+    // printf("\n");
+
+    uint16_t remainder = 0;
+    int idx_byte = 0;
+
+    // Perform modulo-2 division, a bit at a time.
+    for (int idx_bit = 0; idx_bit < num_bits; ++idx_bit) {
+        if (idx_bit % 8 == 0) {
+            // Bring the next byte into the remainder.
+            remainder ^= (message[idx_byte] << (CRC_WIDTH - 8));
+            ++idx_byte;
+        }
+
+        // Try to divide the current data bit.
+        if (remainder & TOPBIT) {
+            remainder = (remainder << 1) ^ CRC_POLYNOMIAL;
+        }
+        else {
+            remainder = (remainder << 1);
+        }
+    }
+    // printf("CRC = %04xh\n", remainder & ((1 << CRC_WIDTH) - 1));
+    return remainder & ((1 << CRC_WIDTH) - 1);
+   }
+
+// Generate FT8 tone sequence from payload data
+// [IN] payload - 10 byte array consisting of 77 bit payload (MSB first)
+// [OUT] itone  - array of NN (79) bytes to store the generated tones (encoded as 0..7)
+// This generates 79 tones by historical convention.  Right after calling
+// the two key-click tones are added to make 81 total
+void genft8(const uint8_t *payload, uint8_t *itone) {
+    uint8_t a91[12];    // Store 77 bits of payload + 14 bits CRC
+
+    // Copy 77 bits of payload data
+    for (int i = 0; i < 10; i++)
+        a91[i] = payload[i];
+
+    // Clear 3 bits after the payload to make 80 bits
+    a91[9] &= 0xF8;
+    a91[10] = 0;
+    a91[11] = 0;
+
+    // Calculate CRC of 12 bytes = 96 bits, see WSJT-X code
+    uint16_t checksum = crc(a91, 96 - 14);
+
+    // Store the CRC at the end of 77 bit message
+    a91[9] |= (uint8_t)(checksum >> 11);
+    a91[10] = (uint8_t)(checksum >> 3);
+    a91[11] = (uint8_t)(checksum << 5);
+
+    // a91 contains 77 bits of payload + 14 bits of CRC
+    uint8_t codeword[22];
+    encode174(a91, codeword);  // Add in 174-91 = 83 bits for FEC
+
+    // itone[] array structure: S7 D29 S7 D29 S7  (79 symbols total)
+    // (split 58 codeword symbols into 2 groups of 29)
+    for (int i = 0; i < 7; ++i) {
+        itone[i]      = kCostas_map[i];
+        itone[36 + i] = kCostas_map[i];
+        itone[72 + i] = kCostas_map[i];
+    }
+
+    int k = 7;          // Skip over the first set of Costas symbols
+
+    uint8_t mask = 0x80;
+    int i_byte = 0;
+    for (int j=0; j<ND; ++j) {
+        if (j == 29) {
+            k += 7;     // Skip over the second set of Costas symbols
+        }
+
+        // Extract 3 bits from codeword at i-th position
+        uint8_t bits3 = 0;
+
+        if (codeword[i_byte] & mask) bits3 |= 4;
+        if (0 == (mask >>= 1)) { mask = 0x80; i_byte++; }
+        if (codeword[i_byte] & mask) bits3 |= 2;
+        if (0 == (mask >>= 1)) { mask = 0x80; i_byte++; }
+        if (codeword[i_byte] & mask) bits3 |= 1;
+        if (0 == (mask >>= 1)) { mask = 0x80; i_byte++; }
+
+        itone[k] = kGray_map[bits3];
+        ++k;
+    }
+    // Done, now have 79 8-tone symbols decribed by itone[]
+    // Raised cosine begin and end is included by first and last Costas tone.
+   }
+
+};
+#endif