API tools faq
paste
mkv

on second thought maybe this'll be slightly over the top

mkv
Mar 31st, 2013
264
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 41.46 KB | None | 0 0
raw download clone embed print report
  1. // ----------------------------------------------------------------------------
  2. // psk.cxx  --  psk modem
  3. //
  4. // Copyright (C) 2006-2010
  5. //      Dave Freese, W1HKJ
  6. // Copyright (C) 2009-2010
  7. //      John Douyere, VK2ETA
  8. //
  9. // PSK-FEC and PSK-R modes contributed by VK2ETA
  10. //
  11. // This file is part of fldigi.  Adapted from code contained in gmfsk
  12. // source code distribution.
  13. // gmfsk Copyright (C) 2001, 2002, 2003
  14. // Tomi Manninen ([email protected])
  15. //
  16. // Fldigi is free software: you can redistribute it and/or modify
  17. // it under the terms of the GNU General Public License as published by
  18. // the Free Software Foundation, either version 3 of the License, or
  19. // (at your option) any later version.
  20. //
  21. // Fldigi is distributed in the hope that it will be useful,
  22. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  23. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24. // GNU General Public License for more details.
  25. //
  26. // You should have received a copy of the GNU General Public License
  27. // along with fldigi.  If not, see <http://www.gnu.org/licenses/>.
  28. // ----------------------------------------------------------------------------
  29.  
  30.  
  31. #include <config.h>
  32.  
  33. #include <stdlib.h>
  34. #include <stdio.h>
  35. #include <iomanip>
  36.  
  37. #include "psk.h"
  38. #include "main.h"
  39. #include "fl_digi.h"
  40. #include "trx.h"
  41. #include "misc.h"
  42. #include "waterfall.h"
  43. #include "configuration.h"
  44. #include "status.h"
  45. #include "viewpsk.h"
  46. #include "pskeval.h"
  47. #include "ascii.h"
  48. #include "Viewer.h"
  49.  
  50. extern waterfall *wf;
  51.  
  52. // Change the following for DCD low pass filter adjustment
  53. #define SQLCOEFF 0.01
  54. #define SQLDECAY 50
  55.  
  56. //=====================================================================
  57.  
  58. #define K       5
  59. #define POLY1   0x17
  60. #define POLY2   0x19
  61.  
  62. // PSK + FEC + INTERLEAVE
  63. #define PSKR_K      7
  64. #define PSKR_POLY1  0x6d
  65. #define PSKR_POLY2  0x4f
  66.  
  67. #define SEPARATION  1.4 //separation between carriers expressed as a ratio to sc_bw
  68.  
  69. #define        GALILEO_K       15
  70. #define        GALILEO_POLY1   046321
  71. #define        GALILEO_POLY2   051271
  72.  
  73. char pskmsg[80];
  74. viewpsk *pskviewer = (viewpsk *)0;
  75.  
  76. void psk::tx_init(SoundBase *sc)
  77. {
  78.     scard = sc;
  79.     for (int car = 0; car < numcarriers; car++) {
  80.         phaseacc[car] = 0;
  81.         prevsymbol[car] = complex (1.0, 0.0);
  82.     }
  83.     preamble = dcdbits;
  84.     if (_pskr) {
  85.         // MFSK based varicode instead of psk
  86.         shreg = 1;
  87.         shreg2 = 1;
  88.     } else {
  89.         shreg = 0;
  90.         shreg2 = 0;
  91.     }
  92.     videoText();
  93.  
  94. // interleaver
  95.     bitshreg = 0;
  96.     startpreamble = true;
  97.  
  98. //Multiple carriers handling
  99.     accumulated_bits = 0;
  100.  
  101. }
  102.  
  103. void psk::rx_init()
  104. {
  105.     for (int car = 0; car < numcarriers; car++) {
  106.         phaseacc[car] = 0;
  107.         prevsymbol[car] = complex (1.0, 0.0);
  108.     }
  109.     quality     = complex (0.0, 0.0);
  110.     if (_pskr) {
  111.         // MFSK varicode instead of psk
  112.         shreg = 1;
  113.         shreg2 = 1;
  114.     } else {
  115.         shreg = 0;
  116.         shreg2 = 0;
  117.     }
  118.     dcdshreg = 0;
  119.     dcdshreg2 = 0;
  120.     dcd = 0;
  121.     bitclk = 0;
  122.     freqerr = 0.0;
  123.     if (mailserver && progdefaults.PSKmailSweetSpot) sigsearch = SIGSEARCH;
  124.     else sigsearch = 0;
  125.     put_MODEstatus(mode);
  126.     resetSN_IMD();
  127.     imdValid = false;
  128.     afcmetric = 0.0;
  129.     // interleaver, split incoming bit stream into two, one late by one bit
  130.     rxbitstate = 0;
  131.     fecmet = fecmet2 = 0;
  132.  
  133. }
  134.  
  135.  
  136. void psk::restart()
  137. {
  138.     if (numcarriers == 1)
  139.         pskviewer->restart(mode);
  140.     evalpsk->setbw(sc_bw);
  141. }
  142.  
  143. void psk::init()
  144. {
  145.     restart();
  146.     modem::init();
  147.     set_scope_mode(Digiscope::PHASE);
  148.     initSN_IMD();
  149.     snratio = 1.0;
  150.     imdratio = 0.001;
  151.     rx_init();
  152. }
  153.  
  154. psk::~psk()
  155. {
  156.     if (tx_shape) delete [] tx_shape;
  157.     if (enc) delete enc;
  158.     if (dec) delete dec;
  159.     // FEC 2nd Viterbi decoder
  160.     if (dec2) delete dec2;
  161.  
  162.     for (int i = 0; i < MAX_CARRIERS; i++) {
  163.         if (fir1[i]) delete fir1[i];
  164.         if (fir2[i]) delete fir2[i];
  165.     }
  166.     if (snfilt) delete snfilt;
  167.     if (imdfilt) delete imdfilt;
  168.     if (::pskviewer == pskviewer)
  169.         ::pskviewer = 0;
  170.     delete pskviewer;
  171.     delete evalpsk;
  172.  
  173.     // Interleaver
  174.     if (Rxinlv) delete Rxinlv;
  175.     if (Rxinlv2) delete Rxinlv2;
  176.     if (Txinlv) delete Txinlv;
  177.  
  178. }
  179.  
  180. psk::psk(trx_mode pskmode) : modem()
  181. {
  182.     cap |= CAP_AFC | CAP_AFC_SR;
  183.  
  184.     mode = pskmode;
  185.     int  isize = 5;
  186.     int  idepth = 5;  // 5x5x5 interleaver
  187.  
  188.     numcarriers = 1;
  189.  
  190.     switch (mode) {
  191.     case MODE_PSK31:
  192.         symbollen = 256;
  193.         _qpsk = false;
  194.         _pskr = false;
  195.         dcdbits = 32;
  196.         numcarriers = 1;
  197.         break;
  198.     case MODE_PSK63:
  199.         symbollen = 128;
  200.         _qpsk = false;
  201.         _pskr = false;
  202.         dcdbits = 64;
  203.         numcarriers = 1;
  204.         break;
  205.     case MODE_PSK125:
  206.         symbollen = 64;
  207.         _qpsk = false;
  208.         _pskr = false;
  209.         dcdbits = 128;
  210.         numcarriers = 1;
  211.         break;
  212.     case MODE_PSK250:
  213.         symbollen = 32;
  214.         _qpsk = false;
  215.         _pskr = false;
  216.         dcdbits = 256;
  217.         numcarriers = 1;
  218.         break;
  219.     case MODE_PSK500:
  220.         symbollen = 16;
  221.         _qpsk = false;
  222.         _pskr = false;
  223.         dcdbits = 512;
  224.         numcarriers = 1;
  225.         break;
  226.     case MODE_PSK1000:
  227.         symbollen = 8;
  228.         _qpsk = false;
  229.         _pskr = false;
  230.         dcdbits = 128;
  231.         numcarriers = 1;
  232.         break;
  233.  
  234.     case MODE_QPSK31:
  235.         symbollen = 256;
  236.         _qpsk = true;
  237.         _pskr = false;
  238.         dcdbits = 32;
  239.         cap |= CAP_REV;
  240.         numcarriers = 1;
  241.         break;
  242.     case MODE_QPSK63:
  243.         symbollen = 128;
  244.         _qpsk = true;
  245.         _pskr = false;
  246.         dcdbits = 64;
  247.         cap |= CAP_REV;
  248.         numcarriers = 1;
  249.         break;
  250.     case MODE_QPSK125:
  251.         symbollen = 64;
  252.         _qpsk = true;
  253.         _pskr = false;
  254.         dcdbits = 128;
  255.         cap |= CAP_REV;
  256.         numcarriers = 1;
  257.         break;
  258.     case MODE_QPSK250:
  259.         symbollen = 32;
  260.         _qpsk = true;
  261.         _pskr = false;
  262.         dcdbits = 256;
  263.         cap |= CAP_REV;
  264.         numcarriers = 1;
  265.         break;
  266.     case MODE_QPSK500:
  267.         symbollen = 16;
  268.         _qpsk = true;
  269.         _pskr = false;
  270.         dcdbits = 512;
  271.         cap |= CAP_REV;
  272.         numcarriers = 1;
  273.         break;
  274.     case MODE_PSK63F:  // As per Multipsk (BPSK63 + FEC + MFSK Varicode)
  275.         symbollen = 128;
  276.         _qpsk = false;
  277.         _pskr = true;
  278.         dcdbits = 64;
  279.         numcarriers = 1;
  280.         break;
  281.  
  282.     case MODE_PSK125R:
  283.         symbollen = 64;
  284.         _qpsk = false;
  285.         _pskr = true;
  286.         dcdbits = 128;
  287.         isize = 2;
  288.         idepth = 40;  // 2x2x40 interleaver
  289.         numcarriers = 1;
  290.         break;
  291.     case MODE_PSK250R:
  292.         symbollen = 32;
  293.         _qpsk = false;
  294.         _pskr = true;
  295.         dcdbits = 256;
  296.         isize = 2;
  297.         idepth = 80;  // 2x2x80 interleaver
  298.         numcarriers = 1;
  299.         break;
  300.     case MODE_PSK500R:
  301.         symbollen = 16;
  302.         _qpsk = false;
  303.         _pskr = true;
  304.         dcdbits = 512;
  305.         isize = 2;
  306.         idepth = 160; // 2x2x160 interleaver
  307.         numcarriers = 1;
  308.         break;
  309.     case MODE_PSK1000R:
  310.         symbollen = 8;
  311.         _qpsk = false;
  312.         _pskr = true;
  313.         dcdbits = 512;
  314.         isize = 2;
  315.         idepth = 160; // 2x2x160 interleaver
  316.         numcarriers = 1;
  317.         break;
  318.  
  319. // multi-carrier modems
  320.     case MODE_4X_PSK63R:
  321.         symbollen = 128;//PSK63
  322.         dcdbits = 128;
  323.         _qpsk = false;
  324.         _pskr = true;//PSKR
  325.         numcarriers = 4;
  326.         isize = 2;
  327.         idepth = 80; // 2x2x80 interleaver
  328.         break;
  329.     case MODE_5X_PSK63R:
  330.         symbollen = 128; //PSK63
  331.         dcdbits = 512;
  332.         _qpsk = false;
  333.         _pskr = true; //PSKR
  334.         numcarriers = 5;
  335.         isize = 2;
  336.         idepth = 260; // 2x2x160 interleaver
  337.         break;
  338.     case MODE_10X_PSK63R:
  339.         symbollen = 128; //PSK63
  340.         dcdbits = 512;
  341.         _qpsk = false;
  342.         _pskr = true; //PSKR
  343.         numcarriers = 10;
  344.         isize = 2;
  345.         idepth = 160; // 2x2x160 interleaver
  346.         break;
  347.     case MODE_20X_PSK63R:
  348.         symbollen = 128; //PSK63
  349.         dcdbits = 512;
  350.         _qpsk = false;
  351.         _pskr = true; //PSKR
  352.         numcarriers = 20;
  353.         isize = 2;
  354.         idepth = 160; // 2x2x160 interleaver
  355.         break;
  356.     case MODE_32X_PSK63R:
  357.         symbollen = 128; //PSK63
  358.         dcdbits = 512;
  359.         _qpsk = false;
  360.         _pskr = true; //PSKR
  361.         numcarriers = 32;
  362.         isize = 2;
  363.         idepth = 160; // 2x2x160 interleaver
  364.         break;
  365.  
  366.     case MODE_4X_PSK125R:
  367.         symbollen = 64;//PSK125
  368.         dcdbits = 512;
  369.         _qpsk = false;
  370.         _pskr = true;//PSKR
  371.         numcarriers = 4;
  372.         isize = 2;
  373.         idepth = 80; // 2x2x80 interleaver
  374.         break;
  375.     case MODE_5X_PSK125R:
  376.         symbollen = 64;//PSK125
  377.         dcdbits = 512;
  378.         _qpsk = false;
  379.         _pskr = true;//PSKR
  380.         numcarriers = 5;
  381.         isize = 2;
  382.         idepth = 160; // 2x2x160 interleaver
  383.         break;
  384.     case MODE_10X_PSK125R:
  385.         symbollen = 64;//PSK125
  386.         dcdbits = 512;
  387.         _qpsk = false;
  388.         _pskr = true;//PSKR
  389.         numcarriers = 10;
  390.         isize = 2;
  391.         idepth = 160; // 2x2x160 interleaver
  392.         break;
  393.  
  394.     case MODE_12X_PSK125:
  395.         symbollen = 64;//PSK125
  396.         dcdbits = 128;//512;
  397.         _qpsk = false;
  398.         _pskr = false;
  399.         numcarriers = 12;
  400.         break;
  401.     case MODE_12X_PSK125R:
  402.         symbollen = 64;//PSK125
  403.         dcdbits = 512;
  404.         _qpsk = false;
  405.         _pskr = true;//PSKR
  406.         numcarriers = 12;
  407.         isize = 2;
  408.         idepth = 160; // 2x2x160 interleaver
  409.         break;
  410.  
  411.     case MODE_16X_PSK125R:
  412.         symbollen = 64;//PSK125
  413.         dcdbits = 512;
  414.         _qpsk = false;
  415.         _pskr = true;//PSKR
  416.         numcarriers = 16;
  417.         isize = 2;
  418.         idepth = 160; // 2x2x160 interleaver
  419.         break;
  420.  
  421.     case MODE_2X_PSK250R:
  422.         symbollen = 32;//PSK250
  423.         dcdbits = 512;
  424.         _qpsk = false;
  425.         _pskr = true;//PSKR
  426.         numcarriers = 2;
  427.         isize = 2;
  428.         idepth = 160; // 2x2x160 interleaver
  429.         break;
  430.     case MODE_3X_PSK250R:
  431.         symbollen = 32;//PSK250
  432.         dcdbits = 512;
  433.         _qpsk = false;
  434.         _pskr = true;//PSKR
  435.         numcarriers = 3;
  436.         isize = 2;
  437.         idepth = 160; // 2x2x160 interleaver
  438.         break;
  439.     case MODE_5X_PSK250R:
  440.         symbollen = 32;//PSK250
  441.         _qpsk = false;
  442.         _pskr = true;//PSKR
  443.         dcdbits = 1024;
  444.         numcarriers = 5;
  445.         isize = 2;
  446.         idepth = 160; // 2x2x160 interleaver
  447.         break;
  448.     case MODE_6X_PSK250:
  449.         symbollen = 32;//PSK250
  450.         _qpsk = false;
  451.         _pskr = false;
  452.         dcdbits = 512;
  453.         numcarriers = 6;
  454.         break;
  455.     case MODE_6X_PSK250R:
  456.         symbollen = 32;//PSK250
  457.         _qpsk = false;
  458.         _pskr = true;//PSKR
  459.         dcdbits = 1024;
  460.         numcarriers = 6;
  461.         isize = 2;
  462.         idepth = 160; // 2x2x160 interleaver
  463.         break;
  464.     case MODE_7X_PSK250R:
  465.         symbollen = 32;//PSK250
  466.         _qpsk = false;
  467.         _pskr = true;//PSKR
  468.         dcdbits = 1024;
  469.         numcarriers = 7;
  470.         isize = 2;
  471.         idepth = 160; // 2x2x160 interleaver
  472.         break;
  473.  
  474.     case MODE_2X_PSK500:
  475.         symbollen = 16;
  476.         _qpsk = false;
  477.         _pskr = false;
  478.         dcdbits = 512;
  479.         numcarriers = 2;
  480.         break;
  481.     case MODE_4X_PSK500:
  482.         symbollen = 16;
  483.         _qpsk = false;
  484.         _pskr = false;
  485.         dcdbits = 512;
  486.         numcarriers = 4;
  487.         break;
  488.  
  489.     case MODE_2X_PSK500R:
  490.         symbollen = 16;
  491.         _qpsk = false;
  492.         _pskr = true;
  493.         dcdbits = 1024;
  494.         isize = 2;
  495.         idepth = 160; // 2x2x160 interleaver
  496.         numcarriers = 2;
  497.         break;
  498.     case MODE_3X_PSK500R:
  499.         symbollen = 16;
  500.         _qpsk = false;
  501.         _pskr = true;
  502.         dcdbits = 1024;
  503.         isize = 2;
  504.         idepth = 160; // 2x2x160 interleaver
  505.         numcarriers = 3;
  506.         break;
  507.     case MODE_4X_PSK500R:
  508.         symbollen = 16;
  509.         _qpsk = false;
  510.         _pskr = true;
  511.         dcdbits = 1024;
  512.         isize = 2;
  513.         idepth = 160; // 2x2x160 interleaver
  514.         numcarriers = 4;
  515.         break;
  516.  
  517.     case MODE_2X_PSK800:
  518.         symbollen = 10;
  519.         _qpsk = false;
  520.         _pskr = false;
  521.         dcdbits = 512;
  522.         numcarriers = 2;
  523.         break;
  524.     case MODE_2X_PSK800R:
  525.         symbollen = 10;
  526.         _qpsk = false;
  527.         _pskr = true;
  528.         dcdbits = 1024;
  529.         isize = 2;
  530.         idepth = 160; // 2x2x160 interleaver
  531.         numcarriers = 2;
  532.         break;
  533.  
  534.     case MODE_2X_PSK1000:
  535.         symbollen = 8;//PSK1000
  536.         _qpsk = false;
  537.         _pskr = false;
  538.         dcdbits = 1024;
  539.         numcarriers = 2;
  540.         isize = 2;
  541.         idepth = 160; // 2x2x160 interleaver
  542.         break;
  543.     case MODE_2X_PSK1000R:
  544.         symbollen = 8;//PSK1000
  545.         _qpsk = false;
  546.         _pskr = true;//PSKR
  547.         dcdbits = 1024;
  548.         numcarriers = 2;
  549.         isize = 2;
  550.         idepth = 160; // 2x2x160 interleaver
  551.         break;
  552.  
  553.     default:
  554.         mode = MODE_PSK31;
  555.         symbollen = 256;
  556.         _qpsk = false;
  557.         _pskr = false;
  558.         dcdbits = 32;
  559.         numcarriers = 1;
  560.     }
  561.  
  562. //printf("%s: symlen %d, dcdbits %d, _qpsk %d, _pskr %d, numc %f\n",
  563. //mode_info[mode].sname,
  564. //symbollen, dcdbits, _qpsk, _pskr, numcarriers);
  565.  
  566.     enc = (encoder *)0;
  567.     dec = (viterbi *)0;
  568.     // BPSK+FEC - 2nd Viterbi decoder and de-interleaver
  569.     dec2 = (viterbi *)0;
  570.     Txinlv = (interleave *)0;
  571.     Rxinlv = (interleave *)0;
  572.     Rxinlv2 = (interleave *)0;
  573.  
  574.  
  575.     // create impulse response for experimental FIR filters
  576.     double fir1c[64];
  577.     double fir2c[64];
  578.  
  579.     for (int i = 0; i < MAX_CARRIERS; i++) {
  580.         if (i < numcarriers) {
  581.             fir1[i] = new C_FIR_filter();
  582.             fir2[i] = new C_FIR_filter();
  583.         } else {
  584.             fir1[i] = (C_FIR_filter *)0;
  585.             fir2[i] = (C_FIR_filter *)0;
  586.         }
  587.     }
  588.     switch (progdefaults.PSK_filter) {
  589.         case 1:
  590.         // use the original gmfsk matched filters
  591.             for (int i = 0; i < 64; i++) {
  592.                 fir1c[i] = gmfir1c[i];
  593.                 fir2c[i] = gmfir2c[i];
  594.             }
  595.             for (int i = 0; i < numcarriers; i++) {
  596.                 fir1[i]->init(FIRLEN, symbollen > 15 ? symbollen / 16 : 1, fir1c, fir1c);
  597.                 fir2[i]->init(FIRLEN, 1, fir2c, fir2c);
  598.             }
  599.             break;
  600.         case 2:
  601.         // creates fir1c matched sin(x)/x filter w hamming
  602.             wsincfilt(fir1c, 1.0 / symbollen, false);
  603.         // creates fir2c matched sin(x)/x filter w hamming
  604.             wsincfilt(fir2c, 1.0 / 16.0, false);
  605.             for (int i = 0; i < numcarriers; i++) {
  606.                 fir1[i]->init(FIRLEN, symbollen > 15 ? symbollen / 16 : 1, fir1c, fir1c);
  607.                 fir2[i]->init(FIRLEN, 1, fir2c, fir2c);
  608.             }
  609.             break;
  610.         case 3:
  611.         // creates fir1c matched sin(x)/x filter w hamming
  612.             wsincfilt(fir1c, 1.0 / symbollen, false);
  613.         // 1/22 with Hamming window nearly identical to gmfir2c
  614.             wsincfilt(fir2c, 1.0 / 22.0, false);
  615.             for (int i = 0; i < numcarriers; i++) {
  616.                 fir1[i]->init(FIRLEN, symbollen > 15 ? symbollen / 16 : 1, fir1c, fir1c);
  617.                 fir2[i]->init(FIRLEN, 1, fir2c, fir2c);
  618.             }
  619.             break;
  620.         case 4:
  621.             wsincfilt(fir2c, 1.5 / 16.0, true);
  622.             for (int i = 0; i < numcarriers; i++) {
  623.                 fir1[i]->init_lowpass (FIRLEN, 16, 1.5 / symbollen);
  624.                 fir2[i]->init(FIRLEN, 1, fir2c, fir2c);
  625.             }
  626.         case 0:
  627.         default :
  628.         // creates fir1c matched sin(x)/x filter w blackman
  629.             wsincfilt(fir1c, 1.0 / symbollen, true);
  630.         // creates fir2c matched sin(x)/x filter w blackman
  631.             wsincfilt(fir2c, 1.0 / 16.0, true);
  632.             for (int i = 0; i < numcarriers; i++) {
  633.                 fir1[i]->init(FIRLEN, symbollen > 15 ? symbollen / 16 : 1, fir1c, fir1c);
  634.                 fir2[i]->init(FIRLEN, 1, fir2c, fir2c);
  635.             }
  636.     }
  637.  
  638.     snfilt = new Cmovavg(16);
  639.     imdfilt = new Cmovavg(16);
  640.  
  641.     if (_qpsk) {
  642.         enc = new encoder(K, POLY1, POLY2);
  643.         dec = new viterbi(K, POLY1, POLY2);
  644.     }
  645.  
  646.     if (_pskr) {
  647. // FEC for BPSK. Use a 2nd Viterbi decoder for comparison.
  648. // Set decode size to 4 since some characters can be as small
  649. // as 3 bits long. This minimises intercharacters decoding
  650. // interactions.
  651.         enc = new encoder(PSKR_K, PSKR_POLY1, PSKR_POLY2);
  652.         dec = new viterbi(PSKR_K, PSKR_POLY1, PSKR_POLY2);
  653.         dec->setchunksize(4);
  654.         dec2 = new viterbi(PSKR_K, PSKR_POLY1, PSKR_POLY2);
  655.         dec2->setchunksize(4);
  656.  
  657. // Interleaver. To maintain constant time delay between bits,
  658. // we double the number of concatenated square iterleavers for
  659. // each doubling of speed: 2x2x20 for BSK63+FEC, 2x2x40 for
  660. // BPSK125+FEC, etc..
  661.         if (_pskr && (mode != MODE_PSK63F)) {
  662. // 2x2x(20,40,80,160)
  663.             Txinlv = new interleave (isize, idepth, INTERLEAVE_FWD);//numinterleavers, INTERLEAVE_FWD);
  664. // 2x2x(20,40,80,160)
  665.             Rxinlv = new interleave (isize, idepth, INTERLEAVE_REV);//numinterleavers, INTERLEAVE_REV);
  666. // 2x2x(20,40,80,160)
  667.             Rxinlv2 = new interleave (isize, idepth, INTERLEAVE_REV);//numinterleavers, INTERLEAVE_REV);
  668.         }
  669.         bitshreg = 0;
  670.         rxbitstate = 0;
  671.         startpreamble = true;
  672.     }
  673.  
  674.     tx_shape = new double[symbollen];
  675.  
  676.     // raised cosine shape for the transmitter
  677.     for ( int i = 0; i < symbollen; i++)
  678.         tx_shape[i] = 0.5 * cos(i * M_PI / symbollen) + 0.5;
  679.  
  680.     samplerate = PskSampleRate;
  681.     fragmentsize = symbollen;
  682.     sc_bw = samplerate / symbollen;
  683.     //JD added for multiple carriers
  684.     inter_carrier = SEPARATION * sc_bw;
  685.     bandwidth = sc_bw * ( 1 + SEPARATION * (numcarriers - 1));
  686.  
  687.     snratio = s2n = imdratio = imd = 0;
  688.  
  689.     if (mailserver && progdefaults.PSKmailSweetSpot)
  690.         sigsearch = SIGSEARCH;
  691.     else
  692.         sigsearch = 0;
  693.     for (int i = 0; i < 16; i++)
  694.         syncbuf[i] = 0.0;
  695.     E1 = E2 = E3 = 0.0;
  696.     acquire = 0;
  697.  
  698.     evalpsk = new pskeval;
  699.     if (numcarriers == 1) {
  700.         ::pskviewer = pskviewer = new viewpsk(evalpsk, mode);
  701.     } else
  702.         ::pskviewer = pskviewer = 0;
  703.  
  704. }
  705.  
  706. //=============================================================================
  707. //=========================== psk31 receive routines ==========================
  708. //=============================================================================
  709.  
  710.  
  711. void psk::s2nreport(void)
  712. {
  713.     modem::s2nreport();
  714.     s2n_sum = s2n_sum2 = s2n_ncount = 0.0;
  715. }
  716.  
  717. void psk::rx_bit(int bit)
  718. {
  719.     int c;
  720.  
  721.     shreg = (shreg << 1) | !!bit;
  722.     if (_pskr) {
  723.         // MFSK varicode instead of PSK Varicode
  724.         if ((shreg & 7) == 1) {
  725.             c = varidec(shreg >> 1);
  726.             // Voting at the character level
  727.             if (fecmet >= fecmet2) {
  728.                 if ((c != -1) && (c != 0) && (dcd == true)) {
  729.                     put_rx_char(c);
  730.                     if (progdefaults.Pskmails2nreport && (mailserver || mailclient)) {
  731.                         s2n_sum += s2n_metric;
  732.                         s2n_sum2 += (s2n_metric * s2n_metric);
  733.                         s2n_ncount ++;
  734. /*                      if (c == SOH && noSOHyet) {
  735.                             s2n_sum = s2n_sum2 = 0.0;
  736.                             s2n_ncount = 1.0;
  737.                             noSOHyet = false;
  738.                         }
  739. */
  740.                         if (c == EOT)
  741.                             s2nreport();
  742.                     }
  743.                 }
  744.             }
  745.             shreg = 1;
  746.         }
  747.     } else {
  748.         if ((shreg & 3) == 0) {
  749.             c = psk_varicode_decode(shreg >> 2);
  750.             if ((c != -1) && (dcd == true)) {
  751.                 put_rx_char(c);
  752.                 if (progdefaults.Pskmails2nreport && (mailserver || mailclient)) {
  753.                     s2n_sum += s2n_metric;
  754.                     s2n_sum2 += (s2n_metric * s2n_metric);
  755.                     s2n_ncount++;
  756. /*                  if (c == SOH && noSOHyet) {
  757.                         s2n_sum = s2n_sum2 = 0.0;
  758.                         s2n_ncount = 1.0;
  759.                         noSOHyet = false;
  760.                     }
  761. */
  762.                     if (c == EOT)
  763.                         s2nreport();
  764.                 }
  765.             }
  766.             shreg = 0;
  767.         }
  768.     }
  769. }
  770.  
  771.  
  772.  
  773.  
  774. void psk::rx_bit2(int bit)
  775. {
  776.     int c;
  777.  
  778.     shreg2 = (shreg2 << 1) | !!bit;
  779.     // MFSK varicode instead of PSK Varicode
  780.     if ((shreg2 & 7) == 1) {
  781.         c = varidec(shreg2 >> 1);
  782.         // Voting at the character level
  783.         if (fecmet < fecmet2) {
  784.             if ((c != -1) && (c != 0) && (dcd == true)) {
  785.                 put_rx_char(c);
  786.                 if (progdefaults.Pskmails2nreport && (mailserver || mailclient)) {
  787.                     s2n_sum += s2n_metric;
  788.                     s2n_sum2 += (s2n_metric * s2n_metric);
  789.                     s2n_ncount++;
  790. /*                  if (c == SOH && noSOHyet) {
  791.                         s2n_sum = s2n_sum2 = 0.0;
  792.                         s2n_ncount = 1.0;
  793.                         noSOHyet = false;
  794.                     }
  795. */
  796.                     if (c == EOT)
  797.                         s2nreport();
  798.                 }
  799.             }
  800.         }
  801.         shreg2 = 1;
  802.     }
  803. }
  804.  
  805. void psk::rx_qpsk(int bits)
  806. {
  807.     unsigned char sym[2];
  808.     int c;
  809.  
  810.     if (_qpsk && !reverse)
  811.         bits = (4 - bits) & 3;
  812.  
  813.     sym[0] = (bits & 1) ? 255 : 0;
  814.     sym[1] = (bits & 2) ? 0 : 255;  // top bit is flipped
  815.  
  816.     //JD added de-interleaver
  817. //  Rxinlv->symbols(sym);
  818.  
  819.     c = dec->decode(sym, NULL);
  820.  
  821.     if (c != -1) {
  822.         rx_bit(c & 0x80);
  823.         rx_bit(c & 0x40);
  824.         rx_bit(c & 0x20);
  825.         rx_bit(c & 0x10);
  826.         rx_bit(c & 0x08);
  827.         rx_bit(c & 0x04);
  828.         rx_bit(c & 0x02);
  829.         rx_bit(c & 0x01);
  830.     }
  831. }
  832.  
  833. void psk::rx_pskr(unsigned char symbol)
  834. {
  835.     int met;
  836.     unsigned char twosym[2];
  837.     unsigned char tempc;
  838.     int c;
  839.  
  840.     //In the case of multiple carriers, if even number of carriers then we
  841.     // know the bit-order and don't need voting otherwise  
  842.     // we accumulate the soft bits for the interleaver THEN submit to Viterbi
  843.     // decoder in alternance so that each one is processed one bit later.
  844.     // Only two possibilities for sync: current bit or previous one since
  845.     // we encode with R = 1/2 and send encoded bits one after the other
  846.     // through the interleaver.
  847.  
  848.     symbolpair[1] = symbolpair[0];
  849.     symbolpair[0] = symbol;
  850.  
  851.  
  852.     if (rxbitstate == 0) {
  853.         rxbitstate++;
  854.         //Only use one decoder is using even carriers (we know the bits order)
  855. //      if (((int)numcarriers) % 2 == 0) {
  856. //          fecmet2 = -9999.0;
  857. //          return;
  858. //      }
  859.         // copy to avoid scrambling symbolpair for the next bit
  860.         twosym[0] = symbolpair[0];
  861.         twosym[1] = symbolpair[1];
  862.         // De-interleave for Robust modes only
  863.         if (mode != MODE_PSK63F) Rxinlv2->symbols(twosym);
  864.         // pass de-interleaved bits pair to the decoder, reversed
  865.         tempc = twosym[1];
  866.         twosym[1] = twosym[0];
  867.         twosym[0] = tempc;
  868.         // Then viterbi decoder
  869.         c = dec2->decode(twosym, &met);
  870.         if (c != -1) {
  871.             // FEC only take metric measurement after backtrace
  872.             // Will be used for voting between the two decoded streams
  873.             fecmet2 = decayavg(fecmet2, met, 20);
  874.             rx_bit2(c & 0x08);
  875.             rx_bit2(c & 0x04);
  876.             rx_bit2(c & 0x02);
  877.             rx_bit2(c & 0x01);
  878.         }
  879.     } else {
  880.         // Again for the same stream shifted by one bit
  881.         rxbitstate = 0;
  882.         twosym[0] = symbolpair[0];
  883.         twosym[1] = symbolpair[1];
  884.         // De-interleave
  885.         if (mode != MODE_PSK63F) Rxinlv->symbols(twosym);
  886.         tempc = twosym[1];
  887.         twosym[1] = twosym[0];
  888.         twosym[0] = tempc;
  889.         // Then viterbi decoder
  890.         c = dec->decode(twosym, &met);
  891.         if (c != -1) {
  892.             fecmet = decayavg(fecmet, met, 20);
  893.             rx_bit(c & 0x08);
  894.             rx_bit(c & 0x04);
  895.             rx_bit(c & 0x02);
  896.             rx_bit(c & 0x01);
  897.         }
  898.     }
  899. }
  900.  
  901. void psk::searchDown()
  902. {
  903.     double srchfreq = frequency - sc_bw * 2;
  904.     double minfreq = sc_bw * 2;
  905.     double spwr, npwr;
  906.     while (srchfreq > minfreq) {
  907.         spwr = wf->powerDensity(srchfreq, sc_bw);
  908.         npwr = wf->powerDensity(srchfreq + sc_bw, sc_bw/2) + 1e-10;
  909.         if (spwr / npwr > pow(10, progdefaults.ServerACQsn / 10)) {
  910.             frequency = srchfreq;
  911.             set_freq(frequency);
  912.             sigsearch = SIGSEARCH;
  913.             break;
  914.         }
  915.         srchfreq -= sc_bw;
  916.     }
  917. }
  918.  
  919. void psk::searchUp()
  920. {
  921.     double srchfreq = frequency + sc_bw * 2;
  922.     double maxfreq = IMAGE_WIDTH - sc_bw * 2;
  923.     double spwr, npwr;
  924.     while (srchfreq < maxfreq) {
  925.         spwr = wf->powerDensity(srchfreq, sc_bw/2);
  926.         npwr = wf->powerDensity(srchfreq - sc_bw, sc_bw/2) + 1e-10;
  927.         if (spwr / npwr > pow(10, progdefaults.ServerACQsn / 10)) {
  928.             frequency = srchfreq;
  929.             set_freq(frequency);
  930.             sigsearch = SIGSEARCH;
  931.             break;
  932.         }
  933.         srchfreq += sc_bw;
  934.     }
  935. }
  936.  
  937. int waitcount = 0;
  938.  
  939. void psk::findsignal()
  940. {
  941.     int ftest, f1, f2;
  942.  
  943.     if (sigsearch > 0) {
  944.         sigsearch--;
  945.         if (mailserver) { // mail server search algorithm
  946.             if (progdefaults.PSKmailSweetSpot) {
  947.                 f1 = (int)(progdefaults.ServerCarrier - progdefaults.ServerOffset);
  948.                 f2 = (int)(progdefaults.ServerCarrier + progdefaults.ServerOffset);
  949.             } else {
  950.                 f1 = (int)(frequency - progdefaults.ServerOffset);
  951.                 f2 = (int)(frequency + progdefaults.ServerOffset);
  952.             }
  953.             if (evalpsk->sigpeak(ftest, f1, f2) > pow(10, progdefaults.ServerACQsn / 10) ) {
  954.                 if (progdefaults.PSKmailSweetSpot) {
  955.                     if (fabs(ftest - progdefaults.ServerCarrier) < progdefaults.ServerOffset) {
  956.                         frequency = ftest;
  957.                         set_freq(frequency);
  958.                         freqerr = 0.0;
  959.                     } else {
  960.                         frequency = progdefaults.ServerCarrier;
  961.                         set_freq(frequency);
  962.                         freqerr = 0.0;
  963.                     }
  964.                 } else {
  965.                     frequency = ftest;
  966.                     set_freq(frequency);
  967.                     freqerr = 0.0;
  968.                 }
  969.             } else { // less than the detection threshold
  970.                 if (progdefaults.PSKmailSweetSpot) {
  971.                     frequency = progdefaults.ServerCarrier;
  972.                     set_freq(frequency);
  973.                     sigsearch = SIGSEARCH;
  974.                 }
  975.             }
  976.         } else { // normal signal search algorithm
  977.             f1 = (int)(frequency - progdefaults.SearchRange/2);
  978.             f2 = (int)(frequency + progdefaults.SearchRange/2);
  979.             if (evalpsk->sigpeak(ftest, f1, f2) > pow(10, progdefaults.ACQsn / 10.0) ) {
  980.                 frequency = ftest;
  981.                 set_freq(frequency);
  982.                 freqerr = 0.0;
  983.                 sigsearch = 0;
  984.                 acquire = dcdbits;
  985.             }
  986.         }
  987.     }
  988. }
  989.  
  990. //JD: disable for multiple carriers as we are running as modem and
  991. //    therefore use other strategies for frequency alignment like RSID
  992. void psk::phaseafc()
  993. {
  994.     double error;
  995.     if (afcmetric < 0.05 ||
  996.         mode == MODE_PSK500 ||
  997.         mode == MODE_QPSK500 ||
  998.         numcarriers > 1 ) return;
  999.  
  1000.     error = (phase - bits * M_PI / 2.0);
  1001.     if (error < -M_PI / 2.0 || error > M_PI / 2.0) return;
  1002.     error *= samplerate / (TWOPI * symbollen);
  1003.     if (fabs(error) < sc_bw ) {
  1004.         freqerr = error / dcdbits;
  1005.         frequency -= freqerr;
  1006.         if (mailserver) {
  1007.             if (frequency < progdefaults.ServerCarrier - progdefaults.ServerAFCrange)
  1008.                 frequency = progdefaults.ServerCarrier - progdefaults.ServerAFCrange;
  1009.             if (frequency > progdefaults.ServerCarrier + progdefaults.ServerAFCrange)
  1010.                 frequency = progdefaults.ServerCarrier + progdefaults.ServerAFCrange;
  1011.         }
  1012.         set_freq (frequency);
  1013.     }
  1014.     if (acquire) acquire--;
  1015. }
  1016.  
  1017. void psk::afc()
  1018. {
  1019.     if (!progStatus.afconoff)
  1020.         return;
  1021.     if (dcd == true || acquire)
  1022.         phaseafc();
  1023. }
  1024.  
  1025.  
  1026. void psk::rx_symbol(complex symbol, int car)
  1027. {
  1028.     int n;
  1029.     unsigned char softbit = 0;
  1030.     double softangle;
  1031.     double softamp;
  1032.     double sigamp = symbol.norm();
  1033.  
  1034. static double averageamp;
  1035.  
  1036.     phase = (prevsymbol[car] % symbol).arg();
  1037.     prevsymbol[car] = symbol;
  1038.  
  1039.     if (phase < 0)
  1040.         phase += TWOPI;
  1041.  
  1042.     if (_qpsk) {
  1043.         bits = ((int) (phase / M_PI_2 + 0.5)) & 3;
  1044.         n = 4;
  1045.     } else { // bpsk and pskr
  1046.         bits = (((int) (phase / M_PI + 0.5)) & 1) << 1;
  1047.         // hard decode if needed
  1048.         // softbit = (bits & 2) ? 0 : 255;  
  1049.         // reversed as we normally pass "!bits" when hard decoding
  1050.         // Soft decode section below
  1051.         averageamp = decayavg(averageamp, sigamp, SQLDECAY);
  1052.         if (sigamp > 0 && averageamp > 0) {
  1053.             softamp = clamp( averageamp / sigamp, 1.0, 1e6);
  1054.         } else {
  1055.             softamp = 1; // arbritary number (50% impact)
  1056.         }
  1057.         // Compute values between -128 and +127 for phase value only
  1058.         if (phase > M_PI) {
  1059.             softangle = (127 - (((2 * M_PI - phase) / M_PI) * (double) 255));
  1060.         } else {
  1061.             softangle = (127 - ((phase / M_PI) * (double) 255));
  1062.         }
  1063.         // Then apply impact of amplitude. Fanally, re-centre on 127-128
  1064.         // as the decoder needs values between 0-255
  1065.         softbit = (unsigned char) ((softangle / (1 + softamp)) - 127);
  1066.         n = 2;
  1067.     }
  1068.  
  1069.     // simple low pass filter for quality of signal
  1070. //  quality.re = decayavg(quality.re, cos(n*phase), _pskr ? SQLDECAY * 5 : SQLDECAY);
  1071. //  quality.im = decayavg(quality.im, sin(n*phase), _pskr ? SQLDECAY * 5 : SQLDECAY);
  1072.     quality.re = decayavg(quality.re, cos(n*phase), _pskr ? SQLDECAY * 10 : SQLDECAY);
  1073.     quality.im = decayavg(quality.im, sin(n*phase), _pskr ? SQLDECAY * 10 : SQLDECAY);
  1074.  
  1075.     metric = 100.0 * quality.norm();
  1076.  
  1077.     if (progdefaults.Pskmails2nreport && (mailserver || mailclient)) {
  1078.         //s2n reporting: rescale depending on mode, clip after scaling
  1079.         if (_pskr)
  1080.             s2n_metric = metric * 1.5 + 8;
  1081.         else
  1082.             s2n_metric = metric;
  1083.         s2n_metric = CLAMP(s2n_metric, 0.0, 100.0);
  1084.     }
  1085.  
  1086.     // FEC: adjust squelch for extra sensitivity.
  1087.     // Otherwise we miss good characters
  1088.     if (_pskr) {
  1089.         metric = metric * 4;
  1090.     }
  1091.  
  1092.     if (metric > 100)
  1093.         metric = 100;
  1094.  
  1095.     afcmetric = decayavg(afcmetric, quality.norm(), 50);
  1096.  
  1097.     dcdshreg = (dcdshreg << 2) | bits;
  1098.  
  1099.     imdValid = false;
  1100.     switch (dcdshreg) {
  1101.  
  1102.     case 0xAAAAAAAA:    // DCD on by preamble for psk modes
  1103.         if (!_pskr) {
  1104.             dcd = true;
  1105.             acquire = 0;
  1106.             quality = complex (1.0, 0.0);
  1107.             imdValid = true;
  1108.             if (progdefaults.Pskmails2nreport && (mailserver || mailclient))
  1109.                 s2n_sum = s2n_sum2 = s2n_ncount = 0.0;
  1110.         }
  1111.         break;
  1112.  
  1113.     case 0xA0A0A0A0:    // DCD on by preamble for PSKR modes ("11001100" sequence sent as preamble)
  1114.         if (_pskr) {
  1115.             dcd = true;
  1116.             acquire = 0;
  1117.             quality = complex (1.0, 0.0);
  1118.             imdValid = true;
  1119. //VK2ETA added logic to prevent resetting
  1120. //          noSOHyet = true;
  1121.             if (progdefaults.Pskmails2nreport && (mailserver || mailclient))
  1122.                 s2n_sum = s2n_sum2 = s2n_ncount = 0.0;
  1123.         }
  1124.         break;
  1125.  
  1126.     case 0:         // DCD off by postamble. Not for PSKR modes as this is not unique to postamble.
  1127.         if (!_pskr) {
  1128.             dcd = false;
  1129.             acquire = 0;
  1130.             quality = complex (0.0, 0.0);
  1131.         }
  1132.         break;
  1133.     default:
  1134.         if (metric > progStatus.sldrSquelchValue || progStatus.sqlonoff == false) {
  1135.             dcd = true;
  1136.         } else {
  1137.             dcd = false;
  1138.         }
  1139.     }
  1140.  
  1141.     if (!_pskr) {
  1142.         set_phase(phase, quality.norm(), dcd);
  1143.  
  1144.         if (dcd == true) {
  1145.             if (_qpsk )
  1146.                 rx_qpsk(bits);
  1147.             else
  1148.                 rx_bit(!bits);
  1149.         }
  1150.     } else { // pskr processing
  1151.         // FEC: moved below the rx_bit to use proper value for dcd
  1152.         rx_pskr(softbit);
  1153.         set_phase(phase, quality.norm(), dcd);
  1154.     }
  1155.  
  1156. }
  1157.  
  1158. void psk::signalquality()
  1159. {
  1160.  
  1161.     if (m_Energy[1])
  1162.         snratio = snfilt->run(m_Energy[0]/m_Energy[1]);
  1163.     else
  1164.         snratio = snfilt->run(1.0);
  1165.  
  1166.     if (m_Energy[0] && imdValid)
  1167.         imdratio = imdfilt->run(m_Energy[2]/m_Energy[0]);
  1168.     else
  1169.         imdratio = imdfilt->run(0.001);
  1170.  
  1171. }
  1172.  
  1173. void psk::update_syncscope()
  1174. {
  1175.     static char msg1[15];
  1176.     static char msg2[15];
  1177.  
  1178.     display_metric(metric);
  1179.  
  1180.     s2n = 10.0*log10( snratio );
  1181.     snprintf(msg1, sizeof(msg1), "s/n %2d dB", (int)(floor(s2n)));
  1182.  
  1183.     imd = 10.0*log10( imdratio );
  1184.     snprintf(msg2, sizeof(msg2), "imd %3d dB", (int)(floor(imd)));
  1185.  
  1186.     if (imdValid) {
  1187.         put_Status1(msg1, progdefaults.StatusTimeout, progdefaults.StatusDim ? STATUS_DIM : STATUS_CLEAR);
  1188.         put_Status2(msg2, progdefaults.StatusTimeout, progdefaults.StatusDim ? STATUS_DIM : STATUS_CLEAR);
  1189.     }
  1190. }
  1191.  
  1192. char bitstatus[100];
  1193.  
  1194. int psk::rx_process(const double *buf, int len)
  1195. {
  1196.     double delta[MAX_CARRIERS], frequencies[MAX_CARRIERS];
  1197.     complex z, z2[MAX_CARRIERS];
  1198.     bool can_rx_symbol = false;
  1199.  
  1200.     if (numcarriers == 1) {
  1201.         if (pskviewer && !bHistory &&
  1202.             (dlgViewer->visible() || progStatus.show_channels))
  1203.             pskviewer->rx_process(buf, len);
  1204.         if (evalpsk)
  1205.             evalpsk->sigdensity();
  1206.     }
  1207.  
  1208.     frequencies[0] = frequency + ((-1 * numcarriers) + 1) * inter_carrier / 2;
  1209.     delta[0] = TWOPI * frequencies[0] / samplerate;
  1210.     for (int car = 1; car < numcarriers; car++) {
  1211.             frequencies[car] = frequencies[car - 1] + inter_carrier;
  1212.             delta[car] = TWOPI * frequencies[car] / samplerate;
  1213.     }
  1214.  
  1215.     while (len-- > 0) {
  1216.  
  1217.        for (int car = 0; car < numcarriers; car++) {
  1218.  
  1219.         // Mix with the internal NCO
  1220.         z = complex ( *buf * cos(phaseacc[car]), *buf * sin(phaseacc[car]) );
  1221.  
  1222.         phaseacc[car] += delta[car];
  1223.         if (phaseacc[car] > M_PI)
  1224.             phaseacc[car] -= TWOPI;
  1225.  
  1226.         // Filter and downsample
  1227.         // by 16 (psk31, qpsk31)
  1228.         // by  8 (psk63, qpsk63)
  1229.         // by  4 (psk125, qpsk125)
  1230.         // by  2 (psk250, qpsk250)
  1231.         // by  1 (psk500, qpsk500) = no down sampling
  1232.         // first filter
  1233.         if (fir1[car]->run( z, z )) { // fir1 returns true every Nth sample
  1234.             // final filter
  1235.             fir2[car]->run( z, z2[car] ); // fir2 returns value on every sample
  1236.  
  1237.             //On last carrier processing
  1238.             if (car == numcarriers - 1) {
  1239.  
  1240.             calcSN_IMD(z); //JD OR all carriers together check logic???
  1241.  
  1242. /**
  1243. * This is the symbol timing recovery mechanism.  After the demodulated
  1244. * signal is processed by the matched filters, the signal lobes are
  1245. * expected to have been modified to a fairly symmetric shape.  The
  1246. * magnitude of the samples are taken, thus rectifying the signal to
  1247. * positive values. "bitclk" is a counter that is very close in rate to
  1248. * (samples / symbol).  Its purpose is to repeatedly "draw" one symbol
  1249. * waveform in the syncbuf array, according to its amplitude (not phase).
  1250. */                        
  1251.  
  1252.             int idx = (int) bitclk;
  1253.             double sum = 0.0;
  1254.             double ampsum = 0.0;
  1255.             for (int ii = 0; ii < numcarriers; ii++) {
  1256.                 sum += z2[ii].mag()/numcarriers;
  1257.             }
  1258. //          syncbuf[idx] = 0.8 * syncbuf[idx] + 0.2 * z2[car].mag();
  1259.             syncbuf[idx] = 0.8 * syncbuf[idx] + 0.2 * sum;
  1260.             sum = 0.0;
  1261.  
  1262.             //Handling of modes faster than PSK500/PSK500R
  1263.  
  1264. /*          for (int i = 0; i < 8; i++) {
  1265.                 sum += (syncbuf[i] - syncbuf[i+8]);
  1266.                 ampsum += (syncbuf[i] + syncbuf[i+8]);
  1267.             }
  1268. */
  1269. //          double bitsteps = (symbollen >= 16 ? 16 : 8);
  1270.             double bitsteps = (symbollen >= 16 ? 16 : symbollen);
  1271.             int symsteps = (int) (bitsteps / 2);
  1272.  
  1273. /**
  1274. * Here we sum up the difference between each sample's magnitude in the
  1275. * lower half of the array with its counterpart on the upper half of the
  1276. * array, or the other side of the waveform.  Each pair's difference is
  1277. * divided by their sum, scaling it so that the signal amplitude does not
  1278. * affect the result.  When the differences are summed, it gives an
  1279. * indication of which side is larger than the other.
  1280. */                                    
  1281.  
  1282.             for (int i = 0; i < symsteps; i++) {
  1283.                 sum += (syncbuf[i] - syncbuf[i+symsteps]);
  1284.                 ampsum += (syncbuf[i] + syncbuf[i+symsteps]);
  1285.             }
  1286.             // added correction as per PocketDigi
  1287.             sum = (ampsum == 0 ? 0 : sum / ampsum);
  1288.  
  1289. /**
  1290. * If the lower side is larger (meaning that the waveform is shifted in that
  1291. * direction), then the sum is negative, and bitclk needs to be adjusted to
  1292. * be a little faster, so that the next drawing of the waveform in syncbuf
  1293. * will be shifted right. Conversely, if the sum is positive, then it needs
  1294. * to slow down bitclk so that the waveform is shifted left.  Thus the
  1295. * error is subtracted from bitclk, rather than added.  The goal is to
  1296. * get the error as close to zero as possible, so that the receiver is
  1297. * exactly synced with the transmitter and the waveform is exactly in
  1298. * the middle of syncbuf.      
  1299. */                                                    
  1300.  
  1301. //          bitclk -= sum / 5.0;
  1302.             bitclk -= sum / (5.0 * 16 / bitsteps);
  1303.             bitclk += 1;
  1304.  
  1305. /**
  1306. * When bitclock reaches the end of the buffer, then a complete waveform
  1307. * has been received.  It is time to output the current sample and wrap
  1308. * around to the next cycle.
  1309. *        
  1310. * There is a complete symbol waveform in syncbuf, so that each
  1311. * sample[0..N/2-1] is very close in amplitude with the corresponding
  1312. * sample in [N/2..N-1].
  1313. *        
  1314. *     |            ********                       ********            |
  1315. *     |        ****        ****               ****        ****        |
  1316. *     |     ***                ***         ***                ***     |
  1317. *     |   **                      **     **                      **   |
  1318. *     |  *                          *   *                          *  |
  1319. *     | *                            * *                            * |
  1320. *     |*                              *                              *|
  1321. *     |_______________________________________________________________|
  1322. *     0                              N/2                             N-1
  1323. *    
  1324. *     === or some variation of it .... ===
  1325. *                    
  1326. *     |****                       ********                       *****|
  1327. *     |    ****               ****        ****               ****     |
  1328. *     |        ***         ***                ***         ***         |
  1329. *     |           **     **                      **     **            |
  1330. *     |             *   *                          *   *              |
  1331. *     |              * *                            * *               |
  1332. *     |               *                              *                |
  1333. *     |_______________________________________________________________|
  1334. *     0                              N/2                             N-1
  1335. *
  1336. * At the end of this cycle, bitclk is pointing at a sample which will
  1337. * have the maximum phase difference, if any, from the previous symbol's
  1338. * phase.
  1339. *
  1340. */                          
  1341.  
  1342. //          if (bitclk < 0) bitclk += 16.0;
  1343. //          if (bitclk >= 16.0) {
  1344. //              bitclk -= 16.0;
  1345.  
  1346.             if (bitclk < 0) bitclk += bitsteps;
  1347.             if (bitclk >= bitsteps) {
  1348.                 bitclk -= bitsteps;
  1349.                 can_rx_symbol = true;
  1350.                 update_syncscope();
  1351.                 afc();
  1352.             }
  1353.             }
  1354.  
  1355.         }
  1356.        }
  1357.        if (can_rx_symbol) {
  1358.         for (int car = 0; car < numcarriers; car++) {
  1359.             rx_symbol(z2[car], car);
  1360.         }
  1361.         can_rx_symbol = false;
  1362.        }
  1363.        buf++;
  1364.     }
  1365.  
  1366.     if (sigsearch)
  1367.         findsignal();
  1368.     else if (mailserver) {
  1369.         if (waitcount > 0) {
  1370.             --waitcount;
  1371.             if (waitcount == 0) {
  1372.                 if (progdefaults.PSKmailSweetSpot) {
  1373.                     frequency = progdefaults.PSKsweetspot;
  1374.                     set_freq(frequency);
  1375.                 }
  1376.                 sigsearch = SIGSEARCH;
  1377.             }
  1378.         }
  1379.         else if ( E1/ E2 <= 1.0) {
  1380.             waitcount = 8;
  1381.             sigsearch = 0;
  1382.         }
  1383.     }
  1384.     return 0;
  1385. }
  1386.  
  1387. //=====================================================================
  1388. // transmit processes
  1389. //=====================================================================
  1390.  
  1391. void psk::tx_symbol(int sym)
  1392. {
  1393.     double delta[MAX_CARRIERS];
  1394.     double  ival, qval, shapeA, shapeB;
  1395.     complex symbol;
  1396.     double  frequencies[MAX_CARRIERS];
  1397.  
  1398.     txsymbols[accumulated_bits] = sym;
  1399.  
  1400.     if (++accumulated_bits < numcarriers) {
  1401.         return;
  1402.     }
  1403.  
  1404.     //Process all carrier's symbols, then submit to sound card
  1405.     accumulated_bits = 0; //reset
  1406.     frequencies[0] = get_txfreq_woffset() + ((-1 * numcarriers) + 1) * inter_carrier / 2;
  1407.     delta[0] = TWOPI * frequencies[0] / samplerate;
  1408.     for (int car = 1; car < numcarriers; car++) {
  1409.             frequencies[car] = frequencies[car - 1] + inter_carrier;
  1410.             delta[car] = TWOPI * frequencies[car] / samplerate;
  1411.     }
  1412.  
  1413. double maxamp = 0;
  1414.     for (int car = 0; car < numcarriers; car++) {
  1415.         sym = txsymbols[car];
  1416.  
  1417.         if (_qpsk && !reverse)
  1418.             sym = (4 - sym) & 3;
  1419.  
  1420.         // differential QPSK modulation - top bit flipped
  1421.         switch (sym) {
  1422.         case 0:
  1423.             symbol = complex (-1.0, 0.0);   // 180 degrees
  1424.             break;
  1425.         case 1:
  1426.             symbol = complex (0.0, -1.0);   // 270 degrees
  1427.             break;
  1428.         case 2:
  1429.             symbol = complex (1.0, 0.0);        // 0 degrees
  1430.             break;
  1431.         case 3:
  1432.             symbol = complex (0.0, 1.0);        // 90 degrees
  1433.             break;
  1434.         }
  1435.         symbol = prevsymbol[car] * symbol;  // complex multiplication
  1436.  
  1437.         for (int i = 0; i < symbollen; i++) {
  1438.  
  1439.             shapeA = tx_shape[i];
  1440.             shapeB = (1.0 - shapeA);
  1441.  
  1442.             ival = shapeA * prevsymbol[car].real() + shapeB * symbol.real();
  1443.             qval = shapeA * prevsymbol[car].imag() + shapeB * symbol.imag();
  1444.  
  1445.             if (car != 0) {
  1446.                 outbuf[i] += (ival * cos(phaseacc[car]) + qval * sin(phaseacc[car]));// / numcarriers;
  1447.             } else {
  1448.                 outbuf[i] = (ival * cos(phaseacc[car]) + qval * sin(phaseacc[car]));// / numcarriers;
  1449.             }
  1450.             if (maxamp < fabs(outbuf[i])) {
  1451.                 maxamp = fabs(outbuf[i]);
  1452.             }
  1453.  
  1454.             phaseacc[car] += delta[car];
  1455.             if (phaseacc[car] > M_PI)
  1456.                 phaseacc[car] -= 2.0 * M_PI;
  1457.         }
  1458.  
  1459.         prevsymbol[car] = symbol;
  1460.     }
  1461.     if (maxamp)
  1462.         for (int i = 0; i < symbollen; i++) outbuf[i] /= maxamp;
  1463.  
  1464.     ModulateXmtr(outbuf, symbollen);
  1465. }
  1466.  
  1467. void psk::tx_bit(int bit)
  1468. {
  1469.     unsigned int sym;
  1470.  
  1471.     // qpsk transmission
  1472.     if (_qpsk) {
  1473.         sym = enc->encode(bit);
  1474.         //JD add interleaver
  1475. //      Txinlv->bits(&sym);
  1476.         sym = sym & 3;//JD just to make sure
  1477.         tx_symbol(sym);
  1478.     // else pskr (fec + interleaver) transmission
  1479.     } else if (_pskr) {
  1480.         // Encode into two bits
  1481.         bitshreg = enc->encode(bit);
  1482.         // pass through interleaver
  1483.         if (mode != MODE_PSK63F) Txinlv->bits(&bitshreg);
  1484.         // Send low bit first. tx_symbol expects 0 or 2 for BPSK
  1485.         sym = (bitshreg & 1) << 1;
  1486.         tx_symbol(sym);
  1487.         sym = bitshreg & 2;
  1488.         tx_symbol(sym);
  1489.     // else normal bpsk tranmission
  1490.     } else {
  1491.         sym = bit << 1;
  1492.         tx_symbol(sym);
  1493.     }
  1494. }
  1495.  
  1496.  
  1497.  
  1498. void psk::tx_char(unsigned char c)
  1499. {
  1500.     const char *code;
  1501.  
  1502.     if (_pskr) {
  1503.         // ARQ varicode instead of MFSK for PSK63FEC
  1504.         code = varienc(c);
  1505.     } else {
  1506.         code = psk_varicode_encode(c);
  1507.     }
  1508.     while (*code) {
  1509.         tx_bit((*code - '0'));
  1510.         code++;
  1511.     }
  1512.  
  1513.     if (! _pskr) {
  1514.         // MSFK varicode instead of psk varicode
  1515.         tx_bit(0);
  1516.         tx_bit(0);
  1517.     }
  1518. }
  1519.  
  1520.  
  1521. void psk::tx_flush()
  1522. {
  1523.     if (_pskr) {
  1524.         //VK2ETA replace with a more effective flushing sequence (avoids cutting the last characters in low s/n)
  1525. /*      for (int i = 0; i < dcdbits; i++)
  1526.             tx_bit(0);
  1527.         }
  1528. */
  1529.         for (int i = 0; i < dcdbits / 2; i++) {
  1530.             tx_bit(1);
  1531.             tx_bit(1);
  1532.         }
  1533.     }
  1534.     // QPSK - flush the encoder
  1535.     if (_qpsk) {
  1536.         for (int i = 0; i < dcdbits; i++)
  1537.         tx_bit(0);
  1538.     // FEC : replace unmodulated carrier by an encoded sequence of zeros
  1539.     }
  1540.     // Standard BPSK postamble
  1541.     // DCD off sequence (unmodulated carrier)
  1542.     //VK2ETA remove for pskr since it is not used for DCD and only adds delay and creates TX overlaps
  1543.     if (!_pskr) {
  1544.         for (int i = 0; i < dcdbits; i++)
  1545.             tx_symbol(2);
  1546.     }
  1547. }
  1548.  
  1549. // Necessary to clear the interleaver before we start sending
  1550. void psk::clearbits()
  1551. {
  1552.     bitshreg = enc->encode(0);
  1553.     for (int k = 0; k < 160; k++) {
  1554.         Txinlv->bits(&bitshreg);
  1555.     }
  1556. }
  1557.  
  1558.  
  1559.  
  1560. int psk::tx_process()
  1561. {
  1562.     int c;
  1563.  
  1564.     if (preamble > 0) {
  1565.         if (_pskr) {
  1566.             if (startpreamble == true) {
  1567.                 if (mode != MODE_PSK63F) clearbits();
  1568.                 startpreamble = false;
  1569.             }
  1570.             // FEC prep the encoder with one/zero sequences of bits
  1571.             preamble--;
  1572.             preamble--;
  1573.             tx_bit(1);
  1574.             tx_bit(0);
  1575.             // FEC: Mark start of first character with a double zero
  1576.             // to ensure sync at end of preamble
  1577.             if (preamble == 0)  tx_bit(0);
  1578.             return 0;
  1579.         } else {
  1580.             //JD for QPSK500R
  1581. //          if (mode == MODE_QPSK500) clearbits();
  1582.             // Standard BPSK/QPSK preamble
  1583.             preamble--;
  1584.             tx_symbol(0);   // send phase reversals
  1585.             return 0;
  1586.         }
  1587.     }
  1588.  
  1589.     c = get_tx_char();
  1590.  
  1591.     if (c == GET_TX_CHAR_ETX || stopflag) {
  1592.         tx_flush();
  1593.         stopflag = false;
  1594.         cwid();
  1595.         return -1;   // we're done
  1596.     }
  1597.  
  1598.     if (c == GET_TX_CHAR_NODATA) {
  1599.         if (_pskr) {
  1600.             // MFSK varicode instead of psk
  1601.             tx_char(0);   // <NUL>
  1602.             tx_bit(1);
  1603.             // extended zero bit stream
  1604.             for (int i = 0; i < 32; i++)
  1605.                 tx_bit(0);
  1606.         } else {
  1607.             tx_bit(0);
  1608.         }
  1609.     } else {
  1610.         tx_char(c);
  1611.         put_echo_char(c);
  1612.     }
  1613.     return 0;
  1614. }
  1615.  
  1616. //============================================================================
  1617. // psk signal evaluation
  1618. // using Goertzel IIR filter
  1619. // derived from pskcore by Moe Wheatley, AE4JY
  1620. //============================================================================
  1621.  
  1622. void psk::initSN_IMD()
  1623. {
  1624.     for(int i = 0; i < NUM_FILTERS; i++)
  1625.     {
  1626.         I1[i] = I2[i] = Q1[i] = Q2[i] = 0.0;
  1627.         m_Energy[i] = 0.0;
  1628.     }
  1629.     m_NCount = 0;
  1630.  
  1631.     COEF[0] = 2.0 * cos(TWOPI * 9 / GOERTZEL);
  1632.     COEF[1] = 2.0 * cos(TWOPI * 18 / GOERTZEL);
  1633.     COEF[2] = 2.0 * cos(TWOPI  * 27 / GOERTZEL);
  1634. }
  1635.  
  1636. void psk::resetSN_IMD()
  1637. {
  1638.     for(int i = 0; i < NUM_FILTERS; i++) {
  1639.         I1[i] = I2[i] = Q1[i] = Q2[i] = 0.0;
  1640.     }
  1641.     m_NCount = 0;
  1642. }
  1643.  
  1644. //============================================================================
  1645. //  This routine calculates the energy in the frequency bands of
  1646. //   carrier=F0(15.625), noise=F1(31.25), and
  1647. //   3rd order product=F2(46.875)
  1648. //  It is called with complex data samples at 500 Hz.
  1649. //============================================================================
  1650.  
  1651. void psk::calcSN_IMD(complex z)
  1652. {
  1653.     int i;
  1654.     complex temp;
  1655.  
  1656.     for(i = 0; i < NUM_FILTERS; i++) {
  1657.         temp.re = I1[i]; temp.im = Q1[i];
  1658.         I1[i] = I1[i] * COEF[i]- I2[i] + z.re;
  1659.         Q1[i] = Q1[i] * COEF[i]- Q2[i] + z.im;
  1660.         I2[i] = temp.re; Q2[i] = temp.im;
  1661.     }
  1662.  
  1663.     if( ++m_NCount >= GOERTZEL ) {
  1664.         m_NCount = 0;
  1665.         for(i = 0; i < NUM_FILTERS; i++) {
  1666.             m_Energy[i] =   I1[i]*I1[i] + Q1[i]*Q1[i]
  1667.                           + I2[i]*I2[i] + Q2[i]*Q2[i]
  1668.                           - I1[i]*I2[i]*COEF[i]
  1669.                           - Q1[i]*Q2[i]*COEF[i];
  1670.             I1[i] = I2[i] = Q1[i] = Q2[i] = 0.0;
  1671.         }
  1672.         signalquality();
  1673.     }
  1674. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!