To: rsgb_lf_group@blacksheep.org
References: <340063417.10486355.1546075700695.ref@mail.yahoo.com>
 <340063417.10486355.1546075700695@mail.yahoo.com>
 <1546076873573.21670@kuleuven.be>
From: =?UTF-8?Q?Wolfgang_B=c3=bcscher?= <dl4yhf@freenet.de>
Message-ID: <005b0259-df03-2249-3996-2828834a0072@freenet.de>
Date: Sat, 29 Dec 2018 21:54:01 +0100
User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64; rv:60.0) Gecko/20100101
 Thunderbird/60.4.0
MIME-Version: 1.0
In-Reply-To: <1546076873573.21670@kuleuven.be>
Content-Language: en-US
Subject: Re: LF: JT9-5 decodes in km07ks
Content-Type: multipart/alternative;
 boundary="------------42E7BE7773076CCD3178DA12"
Sender: owner-rsgb_lf_group@blacksheep.org
Precedence: bulk
Reply-To: rsgb_lf_group@blacksheep.org

This is a multi-part message in MIME format.
--------------42E7BE7773076CCD3178DA12
Content-Type: text/plain; charset=windows-1252; format=flowed
Content-Transfer-Encoding: 8bit

Hi Rik,

 >  (maybe I should ask Wolf for advice)

You're welcome. The "image rejecting up/down converter" is written in 
plain C. It should be easily portable. Uses a 37-tap FIR filter for the 
Hilbert transformer that rejects the "unwanted" mixing product.
Not sure if the sourcecode (indentation) survives the emailing process, 
but fyi it's attached below.
If you think it's usable for your project, I can send everything 
(including the data type definitions and the filter coefficient table).

Cheers,
   Wolf .

Below: Core of the "universal frequency converter / mixer" as currently 
used in Spectrum Lab (this is the simple one, without forward and 
reverse FFT).


void SOUND_RunThroughMixer(
       T_SOUND_FREQ_CONVERTER *pcnv,  // contains all parameters for a 
converter
       T_Float *input_samples,  T_Float *input_samples_q,
       T_Float *output_samples, T_Float *output_samples_q,
       int    number_of_samples )
  /* Frequency mixer. May transform the frequency for some kind of RX.
   * Can optionally cancel one sideband using a Hilbert transformer,
   * I/Q-mixer etc.
   */
{
  int    sample_i, j;
  T_Float d, y, dbl_i, dbl_q;
  const T_Float* coeff_ptr;
  T_Float* queue_ptr;
  T_Float* input_queue_end;
  double  dblPhzInc;
  int     iCosTableIndex, iSineTableOffset = 0;
  T_Float dblNcoI, dblNcoQ;
  double  dblNcoPhase = pcnv->dblNcoPhase;  // use local var for speed


   // Prepare the NCO for the "mixer" frequency ...
   // Note: SoundTab_fltCosTable[SOUND_COS_TABLE_LEN] contains exactly 
ONE PERIOD.
   //       "Negative" frequencies are possible by inverting the Q-channel .
   if(pcnv->dblFSample!=0)
       dblPhzInc = (double)SOUND_COS_TABLE_LEN * pcnv->dblOscillatorFreq 
/ pcnv->dblFSample;
     else
       dblPhzInc = 0;   // mixer frequency is ZERO, so noo phase increment

   if(dblPhzInc > 0)
    { // array index offset to read a SINE WAVE from a COSINE TABLE :
      iSineTableOffset = (int) (0.499 + 3.0 * 
(T_Float)SOUND_COS_TABLE_LEN / 4.0);
    }
   else   // phase increment negative, "negative" mixer frequency ....
    {
      dblPhzInc = -dblPhzInc; // Make sure the table reading index 
INCREMENTS,
                              // because the wrap test will not look for 
negative indices.
      // Get array index offset to read a NEGATIVE SINE WAVE from a 
COSINE TABLE :
      iSineTableOffset = (int)(0.499 + (T_Float)SOUND_COS_TABLE_LEN / 4.0);
    } // end if <produce NEGATIVE frequencies ... possible only with I/Q 
mult. >
   if(dblNcoPhase<0) dblNcoPhase = 0;


   if(pcnv->fDcReject)
    { // Accumulate & remove a bit DC offset from the new chunk:
      for(sample_i=0; sample_i<number_of_samples; ++sample_i)
        {
          pcnv->dblMixerDcOffset =
                      pcnv->dblMixerDcOffset  * 0.9999
                    + input_samples[sample_i] * 0.0001;
          // bad style to modifying the INPUT samples
          //  but this won't hurt anyone :>
          input_samples[sample_i] -= pcnv->dblMixerDcOffset;
        }
    }

   if(pcnv->iMixerScheme==CFG_FREQ_MIX_DSB)
    { // No sideband rejection:
      //   This is a simple and very fast mixer without sideband-rejection.
      //   No complicated broadband 90° phase shifter required.
     for(sample_i=0; sample_i<number_of_samples; ++sample_i)
      {
       // Run the NCO (numerical controlled oscillator)
       dblNcoPhase += dblPhzInc;
       while(dblNcoPhase >=(T_Float)SOUND_COS_TABLE_LEN) // "while", not 
"if" !!
             dblNcoPhase -=(T_Float)SOUND_COS_TABLE_LEN; // table index wrap
       d = SoundTab_fltCosTable[(int)dblNcoPhase];

       // DSB mixer: simply multiply the input signal with the NCO output :
       *output_samples++ = (*input_samples++) * d;
      }
    }  // end if <frequency converter WITHOUT sideband rejection>
   else
   if(pcnv->iMixerScheme==CFG_FREQ_MIX_COMPLEX)
    { // Complex multiplication of complex input :
      //   (a + j*b ) * ( c + j*d )  =  a*c - b*d + j * ( a*d + b*c )
      // To do this, SOUND_RunThroughMixer() must be called with
      //   TWO source-  and TWO destination blocks.
      //  (real and imaginary parts are in sepearate blocks)
      if(  (input_samples!=NULL) && (input_samples_q!=NULL)
         &&(output_samples!=NULL) && (output_samples_q!=NULL) )
       {
         T_Float inp_i, inp_q, outp_i, outp_q;
         for(sample_i=0; sample_i<number_of_samples; ++sample_i)
          {
           // Run the NCO (numerical controlled oscillator; here with 
quadrature output)
           dblNcoPhase += dblPhzInc;
           while(dblNcoPhase >=(T_Float)SOUND_COS_TABLE_LEN) // "while", 
not "if" !!
                 dblNcoPhase -=(T_Float)SOUND_COS_TABLE_LEN; // table 
index wrap
           iCosTableIndex = (int)dblNcoPhase;
           dblNcoI = SoundTab_fltCosTable[iCosTableIndex];
           dblNcoQ = 
SoundTab_fltCosTable[(iCosTableIndex+iSineTableOffset) % 
SOUND_COS_TABLE_LEN];

           // Get complex input sample, multiply with complex 
oscillator, and put into output buffers:
           inp_i = *(input_samples++);
           inp_q = *(input_samples_q++);
           outp_i = inp_i * dblNcoI - inp_q * dblNcoQ;
           outp_q = inp_i * dblNcoQ + inp_q * dblNcoI;
           *output_samples++   = outp_i;
           *output_samples_q++ = outp_q;
          }
      }
    }  // end if <frequency converter WITHOUT sideband rejection>
   else
   if(   (pcnv->iMixerScheme == CFG_FREQ_MIX_LSB_DOWNCONVERTER )
      || (pcnv->iMixerScheme == CFG_FREQ_MIX_USB_DOWNCONVERTER ) )
    {   // Optimized mixer for "downconversion".
        // Based on a schematic diagram from the ARRL handbook 1996,
        // page 17.73:   "The R2: An image-rejecting D-C Receiver"
        // Principle: Splitter, TWO Mixers (with I and Q output),
        //            audio phase shift network, summer, filter.
        // Note: 90° phase shifting is done AFTER mixing (in contrast to the
        //           schemes  CFG_FREQ_MIX_LSB_UP  and CFG_FREQ_MIX_USB_UP.
     for(sample_i=0; sample_i<number_of_samples; ++sample_i)
      {
       // Let the NCO (numerical controlled oscillator) produce 
quadrature-phase signals :
       dblNcoPhase += dblPhzInc;
       while(dblNcoPhase >=(T_Float)SOUND_COS_TABLE_LEN)  // "while", 
not "if" !!
             dblNcoPhase -=(T_Float)SOUND_COS_TABLE_LEN; // table index wrap
       iCosTableIndex = (int)dblNcoPhase;
       dblNcoI = SoundTab_fltCosTable[iCosTableIndex];
       dblNcoQ = SoundTab_fltCosTable[(iCosTableIndex+iSineTableOffset) 
% SOUND_COS_TABLE_LEN];

       // Now mix the incoming (higher-frequency) signal ..input_samples[]..
       //         with a sine and a cosine signal from the NCO ("LO").
       dbl_i = input_samples[sample_i];   // this is the INPUT signal

       if(pcnv->iMixerScheme == CFG_FREQ_MIX_LSB_DOWNCONVERTER)
        {
         dbl_q =  dbl_i * dblNcoI;   // LSB (below NCO freq) moved DOWN
         dbl_i =  dbl_i * dblNcoQ;
        }
       else  // the "other" sideband with reversed oscillator phases:
        {
         dbl_q =  dbl_i * dblNcoQ;   // USB (above NCO freq) moved DOWN
         dbl_i =  dbl_i * dblNcoI;
        }
       // arrived here: dbl_i is the output of the "I"-mixer,
       //               dbl_q is the output of the "Q"-mixer.


       // Let the I-channel run through a delay line [ length (N-1)/2 ]
       //  to compensate the delay from the hilbert trafo (see below).
       if(  (pcnv->iDelayQIndex < 0)
          ||(pcnv->iDelayQIndex >= ((SOUND_Hilbert_filter_length-1)/2)) )
             pcnv->iDelayQIndex = 0;
       y = pcnv->dblDelayQueue[pcnv->iDelayQIndex];
       pcnv->dblDelayQueue[pcnv->iDelayQIndex++] = dbl_i;
       dbl_i = y;

       // Let the Q-channel run through a broadband 90° phase shifter
       // (hilbert transformer, implemented as FIR filter here).
       //    keep the circular buffer pointer 'valid' all the time :
       input_queue_end = 
&pcnv->dblHilbertQueue[SOUND_Hilbert_filter_length-1];
       if(  (pcnv->pdblHilbertQPointer < &pcnv->dblHilbertQueue[0])
          ||(pcnv->pdblHilbertQPointer > input_queue_end) )
             pcnv->pdblHilbertQPointer = &pcnv->dblHilbertQueue[0];
       if( --pcnv->pdblHilbertQPointer < &pcnv->dblHilbertQueue[0] )
             pcnv->pdblHilbertQPointer = input_queue_end; // deal with 
wraparound
       *pcnv->pdblHilbertQPointer = dbl_q;     // hilbert trafo input
       queue_ptr = pcnv->pdblHilbertQPointer;  // pointer to read from 
input queue
       coeff_ptr = &SOUND_HilbertCoeffs[0]; // pointer to read from 
coeff table
       y = 0.0;                  // clear the 'global adder'
       j = (SOUND_Hilbert_filter_length+1)/2 -1;  // j=12 for 25th-order 
filter
       while( j-- )              // do the MAC's (with every 2nd coeff ZERO)
         {
          // coeffs[0], [2], [4].. are (almost) zero and are not calculated
          //                       so just skip the 'queue' pointer
          ++queue_ptr;  ++coeff_ptr;
          if( queue_ptr > input_queue_end ) // deal with wraparound
              queue_ptr = &pcnv->dblHilbertQueue[0];
          // odd coefficients, non-zero, do a MAC-operation :
          y += ( (*queue_ptr++) * (*coeff_ptr++) );
          if( queue_ptr > input_queue_end ) // deal with wraparound
              queue_ptr = &pcnv->dblHilbertQueue[0];
         }
       dbl_q = y;    // filter output = sum from all 'taps'

       // finally add the output of the "audio phase-shift network"...
       output_samples[sample_i] = dbl_i + dbl_q;

      } // end for (sample_i ... )
    } // end if <..mixer_scheme == CFG_FREQ_MIX_USB_DOWNCONVERTER >
   else // neither "double side band" nor "USB DOWNCONVERTER"....
    {
     for(sample_i=0; sample_i<number_of_samples; ++sample_i)
      {
       // Let the I-value run through a delay line [ length (N-1)/2 ]
       //  to compensate the delay from the hilbert trafo (see below).
       if(  (pcnv->iDelayQIndex < 0)
          ||(pcnv->iDelayQIndex >= ((SOUND_Hilbert_filter_length-1)/2)) )
             pcnv->iDelayQIndex = 0;
       dbl_i = pcnv->dblDelayQueue[pcnv->iDelayQIndex];
       pcnv->dblDelayQueue[pcnv->iDelayQIndex++]
             = input_samples[sample_i];

       // Generate the Q-value by passing the real input through a
       // hilbert transformer (which is implemented as an FIR filter here).
       //    keep the circular buffer pointer 'valid' all the time :
       input_queue_end = 
&pcnv->dblHilbertQueue[SOUND_Hilbert_filter_length-1];
       if(  (pcnv->pdblHilbertQPointer < &pcnv->dblHilbertQueue[0])
          ||(pcnv->pdblHilbertQPointer > input_queue_end) )
             pcnv->pdblHilbertQPointer = &pcnv->dblHilbertQueue[0];
       if( --pcnv->pdblHilbertQPointer < &pcnv->dblHilbertQueue[0] )
             pcnv->pdblHilbertQPointer = input_queue_end; // deal with 
wraparound
       *pcnv->pdblHilbertQPointer = input_samples[sample_i];  // filter 
input = "X"
       queue_ptr = pcnv->pdblHilbertQPointer;  // pointer to read from 
input queue
       coeff_ptr = &SOUND_HilbertCoeffs[0]; // pointer to read from 
coeff table
       y = 0.0;                  // clear the 'global adder'
       j = (SOUND_Hilbert_filter_length+1)/2 -1;  // j=12 for 25th-order 
filter
       while( j-- )              // do the MAC's (with every 2nd coeff ZERO)
         {
          // coeffs[0], [2], [4].. are (almost) zero and are not calculated
          //                       so just skip the 'queue' pointer
#if(0)   // not optimized:
          y += ( (*queue_ptr++) * (*coeff_ptr++) );  // here's the MAC
#else    // optimized:
          ++queue_ptr;  ++coeff_ptr;
#endif
          if( queue_ptr > input_queue_end ) // deal with wraparound
              queue_ptr = &pcnv->dblHilbertQueue[0];
          // odd coefficients, non-zero, do a MAC-operation :
          y += ( (*queue_ptr++) * (*coeff_ptr++) );
          if( queue_ptr > input_queue_end ) // deal with wraparound
              queue_ptr = &pcnv->dblHilbertQueue[0];
         }
       dbl_q = y;    // filter output = sum from all 'taps'

       // Let the NCO (numerical controlled oscillator) produce 
quadrature-phase signals :
       dblNcoPhase += dblPhzInc;
       while(dblNcoPhase >=(T_Float)SOUND_COS_TABLE_LEN) // "while", not 
"if" !!
             dblNcoPhase -=(T_Float)SOUND_COS_TABLE_LEN; // table index wrap
       iCosTableIndex = (int)dblNcoPhase;
       dblNcoI = SoundTab_fltCosTable[iCosTableIndex];
       dblNcoQ = SoundTab_fltCosTable[(iCosTableIndex + 
iSineTableOffset) % SOUND_COS_TABLE_LEN];

       if(pcnv->iMixerScheme==CFG_FREQ_MIX_LSB_UP)
        {
         // multiply the I- and Q- samples with the sin- and cos- output
         //     of the local oscillator.
         output_samples[sample_i] =
               dbl_q * dblNcoI  // multiply with "cosine"
             - dbl_i * dblNcoQ; // multiply with "sine"
        }
       else // not LSB but USB:
        {
         output_samples[sample_i] =
               dbl_i * dblNcoI  // multiply with "cosine"
             - dbl_q * dblNcoQ; // multiply with "sine"
        }
      } // end for (sample_i ... )
    } // end if <frequency UP converter with sideband rejection>

   pcnv->dblNcoPhase = dblNcoPhase;  // save the NCO phase for next block

} // end SOUND_RunThroughMixer()


On 29.12.2018 10:47, Rik Strobbe wrote:
>
> Hello Markus,
>
>
> nice copy on N1BUG, this might be a new distance record for Paul.
>
>
> Thanks for your help with the JT9-2 and JT9-5 resampling.
>
> Lifting the frequency restriction on TX is "peanuts", but on RX I 
> would need to implement frequency conversion in SpecLab style.
>
> I will have a look to that (maybe I should ask Wolf for advice).
>
>
> 73, Rik  ON7YD - OR7T
>
>
>
> ------------------------------------------------------------------------
> *Van:* owner-rsgb_lf_group@blacksheep.org 
> <owner-rsgb_lf_group@blacksheep.org> namens Markus Vester 
> <markusvester@aol.com>
> *Verzonden:* zaterdag 29 december 2018 10:28
> *Aan:* rsgb_lf_group@blacksheep.org
> *Onderwerp:* Re: LF: JT9-5 decodes in km07ks
> Thanks to Rik for the software, and to Spiros and Dionysios for their 
> reports. This is what I picked up using JT9-2
>
> 18-12-28 21:38 2038 -25  0.1  648 2  CQ SV8CS KM07
> 18-12-28 21:40 2040 -25  0.1 1200 2  LA3EQ JO28XJ
> 18-12-28 21:42 2042 -26  0.1  648 2  CQ SV8CS KM07
> 18-12-28 21:44 2044 -26  0.2 1200 2  LA3EQ JO28XJ
> 18-12-28 21:48 2048 -25  0.1 1250 2  LA3EQ JO28XJ
> 18-12-28 21:52 2052 -25  0.2 1250 2  LA3EQ JO28XJ
> 18-12-28 21:56 2056 -25  0.2 1250 2  LA3EQ JO28XJ
> 18-12-28 22:00 2100 -28  0.3 1250 2  LA3EQ JO28XJ
>
> and later JT9-5:
>
> 18-12-29 02:30 0130 -34 -0.7  615 5  VVV N1BUG 5
> 18-12-29 02:40 0140 -34 -0.6  615 5  VVV N1BUG 5
> 18-12-29 03:30 0230 -35 -0.6  615 5  VVV N1BUG 5
>
> As my LF transceiver needs to be parked on 135.5 kHz I am always 
> struggling with audio frequency restrictions in WSJT, WSPR and JT-9 
> software. My workaround are frequency conversions in two separate 
> SpecLab instances for RX and TX, connected to the left and right 
> channels of a single VB-Audio virtual cable instance. However there is 
> a noticable latency in this process.
>
> Best 73,
> Markus (DF6NM)
>
>
> -----Ursprüngliche Mitteilung-----
> Von: Dionysios Vlachiotis <sv8rv@otenet.gr>
> An: rsgb_lf_group <rsgb_lf_group@blacksheep.org>; rsgb_lf_group 
> <rsgb_lf_group@yahoogroups.co.uk>
> Verschickt: Sa, 29. Dez 2018 8:39
> Betreff: LF: JT9-5 decodes in km07ks
>
> 245 -28 -0.4  650 5  CQ DF6NM JN59
> 2255 -27 -0.4  650 5  CQ DF6NM JN59
> 2315 -27 -0.5  650 5  CQ DF6NM JN59
> 2325 -24 -0.3  650 5  CQ DF6NM JN59
> 0035 -23 -0.2  650 5  CQ DF6NM JN59
> 0045 -21 -0.3  650 5  CQ DF6NM JN59
> 73 de SV8RV
> Zakynthos isl. GREECE (km07ks)
>
> -----Ursprüngliche Mitteilung-----
> Von: SV8CS-Spiros Chimarios <zante@otenet.gr>
> An: rsgb_lf_group <rsgb_lf_group@blacksheep.org>
> Verschickt: Sa, 29. Dez 2018 5:56
> Betreff: LF: SV8CS SlowJT9
>
> Good morning.
> Decoded only DF6NM during the night (JT9-5) – 136 KHz.
> 2245 -30 -0.4  650 5  CQ DF6NM JN59
> 2255 -29 -0.4  650 5  CQ DF6NM JN59
> 2315 -27 -0.4  650 5  CQ DF6NM JN59
> 2325 -26 -0.4  650 5  CQ DF6NM JN59
> 0035 -21 -0.6  650 5  CQ DF6NM JN59
> 0045 -20 -0.4  650 5  CQ DF6NM JN59
> 73, Spiros/SV8CS


--------------42E7BE7773076CCD3178DA12
Content-Type: text/html; charset=windows-1252
Content-Transfer-Encoding: 8bit

<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html;
      charset=windows-1252">
  </head>
  <body text="#000000" bgcolor="#FFFFFF">
    Hi Rik,<br>
    <br>
    &gt;  (maybe I should ask Wolf for advice)<br>
    <br>
    You're welcome. The "image rejecting up/down converter" is written
    in plain C. It should be easily portable. Uses a 37-tap FIR filter
    for the Hilbert transformer that rejects the "unwanted" mixing
    product.<br>
    Not sure if the sourcecode (indentation) survives the emailing
    process, but fyi it's attached below.<br>
    If you think it's usable for your project, I can send everything
    (including the data type definitions and the filter coefficient
    table).<br>
    <br>
    Cheers,<br>
      Wolf .<br>
    <br>
    Below: Core of the "universal frequency converter / mixer" as
    currently used in Spectrum Lab (this is the simple one, without
    forward and reverse FFT).<br>
    <br>
    <br>
    void SOUND_RunThroughMixer(<br>
          T_SOUND_FREQ_CONVERTER *pcnv,  // contains all parameters for
    a converter<br>
          T_Float *input_samples,  T_Float *input_samples_q,<br>
          T_Float *output_samples, T_Float *output_samples_q,<br>
          int    number_of_samples )<br>
     /* Frequency mixer. May transform the frequency for some kind of
    RX.<br>
      * Can optionally cancel one sideband using a Hilbert transformer,<br>
      * I/Q-mixer etc.<br>
      */<br>
    {<br>
     int    sample_i, j;<br>
     T_Float d, y, dbl_i, dbl_q;<br>
     const T_Float* coeff_ptr;<br>
     T_Float* queue_ptr;<br>
     T_Float* input_queue_end;<br>
     double  dblPhzInc;<br>
     int     iCosTableIndex, iSineTableOffset = 0;<br>
     T_Float dblNcoI, dblNcoQ;<br>
     double  dblNcoPhase = pcnv-&gt;dblNcoPhase;  // use local var for
    speed<br>
    <br>
    <br>
      // Prepare the NCO for the "mixer" frequency ...<br>
      // Note: SoundTab_fltCosTable[SOUND_COS_TABLE_LEN] contains
    exactly ONE PERIOD.<br>
      //       "Negative" frequencies are possible by inverting the
    Q-channel .<br>
      if(pcnv-&gt;dblFSample!=0)<br>
          dblPhzInc = (double)SOUND_COS_TABLE_LEN *
    pcnv-&gt;dblOscillatorFreq / pcnv-&gt;dblFSample;<br>
        else<br>
          dblPhzInc = 0;   // mixer frequency is ZERO, so noo phase
    increment<br>
    <br>
      if(dblPhzInc &gt; 0)<br>
       { // array index offset to read a SINE WAVE from a COSINE TABLE :<br>
         iSineTableOffset = (int) (0.499 + 3.0 *
    (T_Float)SOUND_COS_TABLE_LEN / 4.0);<br>
       }<br>
      else   // phase increment negative, "negative" mixer frequency
    ....<br>
       {<br>
         dblPhzInc = -dblPhzInc; // Make sure the table reading index
    INCREMENTS,<br>
                                 // because the wrap test will not look
    for negative indices.<br>
         // Get array index offset to read a NEGATIVE SINE WAVE from a
    COSINE TABLE :<br>
         iSineTableOffset = (int)(0.499 + (T_Float)SOUND_COS_TABLE_LEN /
    4.0);<br>
       } // end if &lt;produce NEGATIVE frequencies ... possible only
    with I/Q mult. &gt;<br>
      if(dblNcoPhase&lt;0) dblNcoPhase = 0;<br>
    <br>
    <br>
      if(pcnv-&gt;fDcReject)<br>
       { // Accumulate &amp; remove a bit DC offset from the new chunk:<br>
         for(sample_i=0; sample_i&lt;number_of_samples; ++sample_i)<br>
           {<br>
             pcnv-&gt;dblMixerDcOffset =<br>
                         pcnv-&gt;dblMixerDcOffset  * 0.9999<br>
                       + input_samples[sample_i] * 0.0001;<br>
             // bad style to modifying the INPUT samples<br>
             //  but this won't hurt anyone :&gt;<br>
             input_samples[sample_i] -= pcnv-&gt;dblMixerDcOffset;<br>
           }<br>
       }<br>
    <br>
      if(pcnv-&gt;iMixerScheme==CFG_FREQ_MIX_DSB)<br>
       { // No sideband rejection:<br>
         //   This is a simple and very fast mixer without
    sideband-rejection.<br>
         //   No complicated broadband 90° phase shifter required.<br>
        for(sample_i=0; sample_i&lt;number_of_samples; ++sample_i)<br>
         {<br>
          // Run the NCO (numerical controlled oscillator)<br>
          dblNcoPhase += dblPhzInc;<br>
          while(dblNcoPhase &gt;=(T_Float)SOUND_COS_TABLE_LEN) //
    "while", not "if" !!<br>
                dblNcoPhase -=(T_Float)SOUND_COS_TABLE_LEN; // table
    index wrap<br>
          d = SoundTab_fltCosTable[(int)dblNcoPhase];<br>
    <br>
          // DSB mixer: simply multiply the input signal with the NCO
    output :<br>
          *output_samples++ = (*input_samples++) * d;<br>
         }<br>
       }  // end if &lt;frequency converter WITHOUT sideband
    rejection&gt;<br>
      else<br>
      if(pcnv-&gt;iMixerScheme==CFG_FREQ_MIX_COMPLEX)<br>
       { // Complex multiplication of complex input :<br>
         //   (a + j*b ) * ( c + j*d )  =  a*c - b*d + j * ( a*d + b*c )<br>
         // To do this, SOUND_RunThroughMixer() must be called with<br>
         //   TWO source-  and TWO destination blocks.<br>
         //  (real and imaginary parts are in sepearate blocks)<br>
         if(  (input_samples!=NULL) &amp;&amp; (input_samples_q!=NULL)<br>
            &amp;&amp;(output_samples!=NULL) &amp;&amp;
    (output_samples_q!=NULL) )<br>
          {<br>
            T_Float inp_i, inp_q, outp_i, outp_q;<br>
            for(sample_i=0; sample_i&lt;number_of_samples; ++sample_i)<br>
             {<br>
              // Run the NCO (numerical controlled oscillator; here with
    quadrature output)<br>
              dblNcoPhase += dblPhzInc;<br>
              while(dblNcoPhase &gt;=(T_Float)SOUND_COS_TABLE_LEN) //
    "while", not "if" !!<br>
                    dblNcoPhase -=(T_Float)SOUND_COS_TABLE_LEN; // table
    index wrap<br>
              iCosTableIndex = (int)dblNcoPhase;<br>
              dblNcoI = SoundTab_fltCosTable[iCosTableIndex];<br>
              dblNcoQ =
    SoundTab_fltCosTable[(iCosTableIndex+iSineTableOffset) %
    SOUND_COS_TABLE_LEN];<br>
    <br>
              // Get complex input sample, multiply with complex
    oscillator, and put into output buffers:<br>
              inp_i = *(input_samples++);<br>
              inp_q = *(input_samples_q++);<br>
              outp_i = inp_i * dblNcoI - inp_q * dblNcoQ;<br>
              outp_q = inp_i * dblNcoQ + inp_q * dblNcoI;<br>
              *output_samples++   = outp_i;<br>
              *output_samples_q++ = outp_q;<br>
             }<br>
         }<br>
       }  // end if &lt;frequency converter WITHOUT sideband
    rejection&gt;<br>
      else<br>
      if(   (pcnv-&gt;iMixerScheme == CFG_FREQ_MIX_LSB_DOWNCONVERTER )<br>
         || (pcnv-&gt;iMixerScheme == CFG_FREQ_MIX_USB_DOWNCONVERTER ) )<br>
       {   // Optimized mixer for "downconversion".<br>
           // Based on a schematic diagram from the ARRL handbook 1996,<br>
           // page 17.73:   "The R2: An image-rejecting D-C Receiver"<br>
           // Principle: Splitter, TWO Mixers (with I and Q output),<br>
           //            audio phase shift network, summer, filter.<br>
           // Note: 90° phase shifting is done AFTER mixing (in contrast
    to the<br>
           //           schemes  CFG_FREQ_MIX_LSB_UP  and 
    CFG_FREQ_MIX_USB_UP.<br>
        for(sample_i=0; sample_i&lt;number_of_samples; ++sample_i)<br>
         {<br>
          // Let the NCO (numerical controlled oscillator) produce
    quadrature-phase signals :<br>
          dblNcoPhase += dblPhzInc;<br>
          while(dblNcoPhase &gt;=(T_Float)SOUND_COS_TABLE_LEN)  //
    "while", not "if" !!<br>
                dblNcoPhase -=(T_Float)SOUND_COS_TABLE_LEN; // table
    index wrap<br>
          iCosTableIndex = (int)dblNcoPhase;<br>
          dblNcoI = SoundTab_fltCosTable[iCosTableIndex];<br>
          dblNcoQ =
    SoundTab_fltCosTable[(iCosTableIndex+iSineTableOffset) %
    SOUND_COS_TABLE_LEN];<br>
    <br>
          // Now mix the incoming (higher-frequency) signal
    ..input_samples[]..<br>
          //         with a sine and a cosine signal from the NCO
    ("LO").<br>
          dbl_i = input_samples[sample_i];   // this is the INPUT signal<br>
    <br>
          if(pcnv-&gt;iMixerScheme == CFG_FREQ_MIX_LSB_DOWNCONVERTER)<br>
           {<br>
            dbl_q =  dbl_i * dblNcoI;   // LSB (below NCO freq) moved
    DOWN<br>
            dbl_i =  dbl_i * dblNcoQ;<br>
           }<br>
          else  // the "other" sideband with reversed oscillator phases:<br>
           {<br>
            dbl_q =  dbl_i * dblNcoQ;   // USB (above NCO freq) moved
    DOWN<br>
            dbl_i =  dbl_i * dblNcoI;<br>
           }<br>
          // arrived here: dbl_i is the output of the "I"-mixer,<br>
          //               dbl_q is the output of the "Q"-mixer.<br>
    <br>
    <br>
          // Let the I-channel run through a delay line [ length (N-1)/2
    ]<br>
          //  to compensate the delay from the hilbert trafo (see
    below).<br>
          if(  (pcnv-&gt;iDelayQIndex &lt; 0)<br>
             ||(pcnv-&gt;iDelayQIndex &gt;=
    ((SOUND_Hilbert_filter_length-1)/2)) )<br>
                pcnv-&gt;iDelayQIndex = 0;<br>
          y = pcnv-&gt;dblDelayQueue[pcnv-&gt;iDelayQIndex];<br>
          pcnv-&gt;dblDelayQueue[pcnv-&gt;iDelayQIndex++] = dbl_i;<br>
          dbl_i = y;<br>
    <br>
          // Let the Q-channel run through a broadband 90° phase shifter<br>
          // (hilbert transformer, implemented as FIR filter here).<br>
          //    keep the circular buffer pointer 'valid' all the time :<br>
          input_queue_end =
    &amp;pcnv-&gt;dblHilbertQueue[SOUND_Hilbert_filter_length-1];<br>
          if(  (pcnv-&gt;pdblHilbertQPointer &lt;
    &amp;pcnv-&gt;dblHilbertQueue[0])<br>
             ||(pcnv-&gt;pdblHilbertQPointer &gt; input_queue_end) )<br>
                pcnv-&gt;pdblHilbertQPointer =
    &amp;pcnv-&gt;dblHilbertQueue[0];<br>
          if( --pcnv-&gt;pdblHilbertQPointer &lt;
    &amp;pcnv-&gt;dblHilbertQueue[0] )<br>
                pcnv-&gt;pdblHilbertQPointer = input_queue_end; // deal
    with wraparound<br>
          *pcnv-&gt;pdblHilbertQPointer = dbl_q;     // hilbert trafo
    input<br>
          queue_ptr = pcnv-&gt;pdblHilbertQPointer;  // pointer to read
    from input queue<br>
          coeff_ptr = &amp;SOUND_HilbertCoeffs[0]; // pointer to read
    from coeff table<br>
          y = 0.0;                  // clear the 'global adder'<br>
          j = (SOUND_Hilbert_filter_length+1)/2 -1;  // j=12 for
    25th-order filter<br>
          while( j-- )              // do the MAC's (with every 2nd
    coeff ZERO)<br>
            {<br>
             // coeffs[0], [2], [4].. are (almost) zero and are not
    calculated<br>
             //                       so just skip the 'queue' pointer<br>
             ++queue_ptr;  ++coeff_ptr;<br>
             if( queue_ptr &gt; input_queue_end ) // deal with
    wraparound<br>
                 queue_ptr = &amp;pcnv-&gt;dblHilbertQueue[0];<br>
             // odd coefficients, non-zero, do a MAC-operation :<br>
             y += ( (*queue_ptr++) * (*coeff_ptr++) );<br>
             if( queue_ptr &gt; input_queue_end ) // deal with
    wraparound<br>
                 queue_ptr = &amp;pcnv-&gt;dblHilbertQueue[0];<br>
            }<br>
          dbl_q = y;    // filter output = sum from all 'taps'<br>
    <br>
          // finally add the output of the "audio phase-shift
    network"...<br>
          output_samples[sample_i] = dbl_i + dbl_q;<br>
    <br>
         } // end for (sample_i ... )<br>
       } // end if &lt;..mixer_scheme == CFG_FREQ_MIX_USB_DOWNCONVERTER
    &gt;<br>
      else // neither "double side band" nor "USB DOWNCONVERTER"....<br>
       {<br>
        for(sample_i=0; sample_i&lt;number_of_samples; ++sample_i)<br>
         {<br>
          // Let the I-value run through a delay line [ length (N-1)/2 ]<br>
          //  to compensate the delay from the hilbert trafo (see
    below).<br>
          if(  (pcnv-&gt;iDelayQIndex &lt; 0)<br>
             ||(pcnv-&gt;iDelayQIndex &gt;=
    ((SOUND_Hilbert_filter_length-1)/2)) )<br>
                pcnv-&gt;iDelayQIndex = 0;<br>
          dbl_i = pcnv-&gt;dblDelayQueue[pcnv-&gt;iDelayQIndex];<br>
          pcnv-&gt;dblDelayQueue[pcnv-&gt;iDelayQIndex++]<br>
                = input_samples[sample_i];<br>
    <br>
          // Generate the Q-value by passing the real input through a<br>
          // hilbert transformer (which is implemented as an FIR filter
    here).<br>
          //    keep the circular buffer pointer 'valid' all the time :<br>
          input_queue_end =
    &amp;pcnv-&gt;dblHilbertQueue[SOUND_Hilbert_filter_length-1];<br>
          if(  (pcnv-&gt;pdblHilbertQPointer &lt;
    &amp;pcnv-&gt;dblHilbertQueue[0])<br>
             ||(pcnv-&gt;pdblHilbertQPointer &gt; input_queue_end) )<br>
                pcnv-&gt;pdblHilbertQPointer =
    &amp;pcnv-&gt;dblHilbertQueue[0];<br>
          if( --pcnv-&gt;pdblHilbertQPointer &lt;
    &amp;pcnv-&gt;dblHilbertQueue[0] )<br>
                pcnv-&gt;pdblHilbertQPointer = input_queue_end; // deal
    with wraparound<br>
          *pcnv-&gt;pdblHilbertQPointer = input_samples[sample_i];  //
    filter input = "X"<br>
          queue_ptr = pcnv-&gt;pdblHilbertQPointer;  // pointer to read
    from input queue<br>
          coeff_ptr = &amp;SOUND_HilbertCoeffs[0]; // pointer to read
    from coeff table<br>
          y = 0.0;                  // clear the 'global adder'<br>
          j = (SOUND_Hilbert_filter_length+1)/2 -1;  // j=12 for
    25th-order filter<br>
          while( j-- )              // do the MAC's (with every 2nd
    coeff ZERO)<br>
            {<br>
             // coeffs[0], [2], [4].. are (almost) zero and are not
    calculated<br>
             //                       so just skip the 'queue' pointer<br>
    #if(0)   // not optimized:<br>
             y += ( (*queue_ptr++) * (*coeff_ptr++) );  // here's the
    MAC<br>
    #else    // optimized:<br>
             ++queue_ptr;  ++coeff_ptr;<br>
    #endif<br>
             if( queue_ptr &gt; input_queue_end ) // deal with
    wraparound<br>
                 queue_ptr = &amp;pcnv-&gt;dblHilbertQueue[0];<br>
             // odd coefficients, non-zero, do a MAC-operation :<br>
             y += ( (*queue_ptr++) * (*coeff_ptr++) );<br>
             if( queue_ptr &gt; input_queue_end ) // deal with
    wraparound<br>
                 queue_ptr = &amp;pcnv-&gt;dblHilbertQueue[0];<br>
            }<br>
          dbl_q = y;    // filter output = sum from all 'taps'<br>
    <br>
          // Let the NCO (numerical controlled oscillator) produce
    quadrature-phase signals :<br>
          dblNcoPhase += dblPhzInc;<br>
          while(dblNcoPhase &gt;=(T_Float)SOUND_COS_TABLE_LEN) //
    "while", not "if" !!<br>
                dblNcoPhase -=(T_Float)SOUND_COS_TABLE_LEN; // table
    index wrap<br>
          iCosTableIndex = (int)dblNcoPhase;<br>
          dblNcoI = SoundTab_fltCosTable[iCosTableIndex];<br>
          dblNcoQ = SoundTab_fltCosTable[(iCosTableIndex +
    iSineTableOffset) % SOUND_COS_TABLE_LEN];<br>
    <br>
          if(pcnv-&gt;iMixerScheme==CFG_FREQ_MIX_LSB_UP)<br>
           {<br>
            // multiply the I- and Q- samples with the sin- and cos-
    output<br>
            //     of the local oscillator.<br>
            output_samples[sample_i] =<br>
                  dbl_q * dblNcoI  // multiply with "cosine"<br>
                - dbl_i * dblNcoQ; // multiply with "sine"<br>
           }<br>
          else // not LSB but USB:<br>
           {<br>
            output_samples[sample_i] =<br>
                  dbl_i * dblNcoI  // multiply with "cosine"<br>
                - dbl_q * dblNcoQ; // multiply with "sine"<br>
           }<br>
         } // end for (sample_i ... )<br>
       } // end if &lt;frequency UP converter with sideband
    rejection&gt;<br>
    <br>
      pcnv-&gt;dblNcoPhase = dblNcoPhase;  // save the NCO phase for
    next block<br>
    <br>
    } // end SOUND_RunThroughMixer()<br>
    <br>
    <br>
    <br>
    <br>
    <div class="moz-cite-prefix">On 29.12.2018 10:47, Rik Strobbe wrote:<br>
    </div>
    <blockquote type="cite" cite="mid:1546076873573.21670@kuleuven.be">
      <meta http-equiv="Content-Type" content="text/html;
        charset=windows-1252">
      <style type="text/css" style="display:none"><!-- p { margin-top: 0px; margin-bottom: 0px; } #yiv0044036530 #yiv0044036530 -- p { margin-top: 0px; margin-bottom: 0px; } #yiv0044036530 body { margin: 0.7em; } #yiv0044036530 body.yiv0044036530OECFntDef, #yiv0044036530 body.yiv0044036530OECFntDef div { font-family: Arial, Tahoma, Verdana, Helvetica, sans-serif; font-size: 10pt; }--></style>
      <p>Hello Markus,<br>
      </p>
      <p><br>
      </p>
      <p>nice copy on N1BUG, this might be a new distance record for
        Paul.<br>
      </p>
      <p><br>
      </p>
      <p>Thanks for your help with the JT9-2 and JT9-5 resampling.<br>
      </p>
      <p>Lifting the frequency restriction on TX is "peanuts", but on RX
        I would need to implement frequency conversion in SpecLab style.<br>
      </p>
      <p>I will have a look to that (maybe I should ask Wolf for
        advice).<br>
      </p>
      <p><br>
      </p>
      <p>73, Rik  ON7YD - OR7T<br>
      </p>
      <p><br>
      </p>
      <p><br>
      </p>
      <div style="color: rgb(33, 33, 33);">
        <hr tabindex="-1" style="display:inline-block; width:98%">
        <div id="divRplyFwdMsg" dir="ltr"><font style="font-size:11pt"
            face="Calibri, sans-serif" color="#000000"><b>Van:</b>
            <a class="moz-txt-link-abbreviated" href="mailto:owner-rsgb_lf_group@blacksheep.org">owner-rsgb_lf_group@blacksheep.org</a>
            <a class="moz-txt-link-rfc2396E" href="mailto:owner-rsgb_lf_group@blacksheep.org">&lt;owner-rsgb_lf_group@blacksheep.org&gt;</a> namens Markus
            Vester <a class="moz-txt-link-rfc2396E" href="mailto:markusvester@aol.com">&lt;markusvester@aol.com&gt;</a><br>
            <b>Verzonden:</b> zaterdag 29 december 2018 10:28<br>
            <b>Aan:</b> <a class="moz-txt-link-abbreviated" href="mailto:rsgb_lf_group@blacksheep.org">rsgb_lf_group@blacksheep.org</a><br>
            <b>Onderwerp:</b> Re: LF: JT9-5 decodes in km07ks</font>
          <div> </div>
        </div>
        <div>
          <div style="font-size:10pt;
            font-family:arial,helvetica,sans-serif; color:black">
            <div style="color:black;
              font-family:arial,helvetica,sans-serif; font-size:10pt">
              Thanks to Rik for the software, and to Spiros and
              Dionysios for their reports. This is what I picked
              up using JT9-2<br>
              <br>
              18-12-28 21:38 2038 -25  0.1  648 2  CQ SV8CS KM07        
              <br>
              18-12-28 21:40 2040 -25  0.1 1200 2  LA3EQ JO28XJ         
              <br>
              18-12-28 21:42 2042 -26  0.1  648 2  CQ SV8CS KM07        
              <br>
              18-12-28 21:44 2044 -26  0.2 1200 2  LA3EQ JO28XJ         
              <br>
              18-12-28 21:48 2048 -25  0.1 1250 2  LA3EQ JO28XJ         
              <br>
              18-12-28 21:52 2052 -25  0.2 1250 2  LA3EQ JO28XJ         
              <br>
              18-12-28 21:56 2056 -25  0.2 1250 2  LA3EQ JO28XJ         
              <br>
              18-12-28 22:00 2100 -28  0.3 1250 2  LA3EQ JO28XJ         
              <br>
              <br>
              and later JT9-5:<br>
              <br>
              18-12-29 02:30 0130 -34 -0.7  615 5  VVV N1BUG 5          
              <br>
              18-12-29 02:40 0140 -34 -0.6  615 5  VVV N1BUG 5          
              <br>
              18-12-29 03:30 0230 -35 -0.6  615 5  VVV N1BUG 5          
              <br>
              <br>
              As my LF transceiver needs to be parked on 135.5 kHz I am
              always struggling with audio frequency restrictions in
              WSJT, WSPR and JT-9 software. My workaround are frequency
              conversions in two separate SpecLab instances for RX and
              TX, connected to the left and right channels of a
              single VB-Audio virtual cable instance. However there is a
              noticable latency in this process.<br>
              <br>
              Best 73,<br>
              Markus (DF6NM)<br>
              <br>
              <br>
              -----Ursprüngliche Mitteilung-----<br>
              Von: Dionysios Vlachiotis <a class="moz-txt-link-rfc2396E" href="mailto:sv8rv@otenet.gr">&lt;sv8rv@otenet.gr&gt;</a><br>
              An: rsgb_lf_group <a class="moz-txt-link-rfc2396E" href="mailto:rsgb_lf_group@blacksheep.org">&lt;rsgb_lf_group@blacksheep.org&gt;</a>;
              rsgb_lf_group <a class="moz-txt-link-rfc2396E" href="mailto:rsgb_lf_group@yahoogroups.co.uk">&lt;rsgb_lf_group@yahoogroups.co.uk&gt;</a><br>
              Verschickt: Sa, 29. Dez 2018 8:39<br>
              Betreff: LF: JT9-5 decodes in km07ks<br>
              <br>
            </div>
            <div id="yiv9276798064">
              <div dir="ltr">
                <div dir="ltr">
                  <div style="color:rgb(0,0,0);
                    font-family:&quot;Calibri&quot;; font-size:12pt">
                    <div>245 -28 -0.4  650 5  CQ DF6NM JN59         </div>
                    <div>2255 -27 -0.4  650 5  CQ DF6NM JN59         </div>
                    <div>2315 -27 -0.5  650 5  CQ DF6NM JN59         </div>
                    <div>2325 -24 -0.3  650 5  CQ DF6NM JN59         </div>
                    <div>0035 -23 -0.2  650 5  CQ DF6NM JN59         </div>
                    <div>0045 -21 -0.3  650 5  CQ DF6NM JN59      </div>
                    <div> </div>
                    <div>73 de SV8RV</div>
                    <div>Zakynthos isl. GREECE (km07ks)<br>
                      <br>
                      -----Ursprüngliche Mitteilung-----<br>
                      Von: SV8CS-Spiros Chimarios
                      <a class="moz-txt-link-rfc2396E" href="mailto:zante@otenet.gr">&lt;zante@otenet.gr&gt;</a><br>
                      An: rsgb_lf_group
                      <a class="moz-txt-link-rfc2396E" href="mailto:rsgb_lf_group@blacksheep.org">&lt;rsgb_lf_group@blacksheep.org&gt;</a><br>
                      Verschickt: Sa, 29. Dez 2018 5:56<br>
                      Betreff: LF: SV8CS SlowJT9<br>
                      <br>
                      <div id="yiv0044036530">
                        <style type="text/css">
<!--
#yiv0044036530 #yiv0044036530 -- p
	{margin-top:0px;
	margin-bottom:0px}
#yiv0044036530 body
	{margin:0.7em}
#yiv0044036530 body.yiv0044036530OECFntDef, #yiv0044036530 body.yiv0044036530OECFntDef div
	{font-family:Arial,Tahoma,Verdana,Helvetica,sans-serif;
	font-size:10pt}
-->
</style>
                        <div dir="ltr">
                          <div dir="ltr">
                            <div style="color:rgb(0,0,0);
                              font-family:&quot;Calibri&quot;;
                              font-size:12pt">
                              <div>Good morning.</div>
                              <div>Decoded only DF6NM during the night
                                (JT9-5) – 136 KHz.</div>
                              <div> </div>
                              <div>2245 -30 -0.4  650 5  CQ DF6NM
                                JN59         </div>
                              <div>2255 -29 -0.4  650 5  CQ DF6NM
                                JN59         </div>
                              <div>2315 -27 -0.4  650 5  CQ DF6NM
                                JN59         </div>
                              <div>2325 -26 -0.4  650 5  CQ DF6NM
                                JN59         </div>
                              <div>0035 -21 -0.6  650 5  CQ DF6NM
                                JN59         </div>
                              <div>0045 -20 -0.4  650 5  CQ DF6NM JN59 
                              </div>
                              <div> </div>
                              <div>73, Spiros/SV8CS<br>
                              </div>
                            </div>
                          </div>
                        </div>
                      </div>
                    </div>
                  </div>
                </div>
              </div>
            </div>
          </div>
        </div>
      </div>
    </blockquote>
    <br>
  </body>
</html>

--------------42E7BE7773076CCD3178DA12--