n5ac/mmtty
1
0
Fork 0
mirror of https://github.com/n5ac/mmtty.git synced 2025-12-06 04:12:03 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
mmtty/Rtty.h

934 lines
19 KiB
C
Raw Normal View History

Added source file to repo as received from AA6YQ
2013-07-05 22:00:12 +02:00
//Copyright+LGPL
//-----------------------------------------------------------------------------------------------------------------------------------------------
// Copyright 2000-2013 Makoto Mori, Nobuyuki Oba
//-----------------------------------------------------------------------------------------------------------------------------------------------
// This file is part of MMTTY.
// MMTTY is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
// MMTTY is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
// You should have received a copy of the GNU Lesser General Public License along with MMTTY. If not, see
// <http://www.gnu.org/licenses/>.
//-----------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------
#ifndef RttyH
#define RttyH
//---------------------------------------------------------------------------
#include "Fir.h"
#include "CLX.h"
#define VERFFTDEM 1 // CPhaseX Version
#define VERAA6YQ 2 // CAA6YQ Version
#define BITDEBUG 0 // <20>L<EFBFBD><4C><EFBFBD><EFBFBD><EFBFBD>N<EFBFBD>^<5E><><EFBFBD>̑<EFBFBD><CC91><EFBFBD>
#define TXDDEBUG 0 // FSK<53>̃L<CC83><4C><EFBFBD><EFBFBD><EFBFBD>N<EFBFBD>^<5E><><EFBFBD>̑<EFBFBD><CC91><EFBFBD>
#define FSKDEBUG 0 // FSK<53>̃f<CC83>o<EFBFBD>b<EFBFBD>O<EFBFBD><4F><EFBFBD>[<5B>h
#ifndef SampFreq
extern double SampFreq;
#endif
//---------------------------------------------------------------------------
// Added by JE3HHT on Aug.2010
class CFAVG
{
private:
double m_Sum;
double m_Avg;
double m_Mul;
int m_Max;
int m_Cnt;
public:
__fastcall CFAVG();
void __fastcall Reset(void);
void __fastcall Reset(double d);
void __fastcall Create(int max);
double __fastcall DoZ(double d);
double __fastcall Do(double d);
inline double __fastcall GetAvg(void){return m_Avg;};
inline BOOL __fastcall IsFull(void){return m_Max == m_Cnt;};
inline BOOL __fastcall IsHalf(void){return m_Max <= (m_Cnt*2);};
inline int __fastcall GetCount(void){return m_Cnt;};
};
//--------------------------------------------------------
// CAGC<47>N<EFBFBD><4E><EFBFBD>X
// Added by JE3HHT on Aug.2010
class CAGCX
{
private:
double m_Max;
double m_Min;
double m_d;
double m_agc;
double m_fc;
double m_Gain;
CIIR m_LPF;
// CIIR m_Level;
int m_Count;
int m_TLimit;
CFAVG m_AvgOver;
public:
double m_LimitGain;
double m_MonitorFreq;
double m_CarrierFreq;
double m_SampleFreq;
public:
__fastcall CAGCX();
void __fastcall Create(void);
inline void __fastcall SetSampleFreq(double f){m_SampleFreq = f; Create();};
void __fastcall SetCarrierFreq(double f);
void __fastcall SetFC(double fc);
void __fastcall Reset(void);
double __fastcall Do(double d);
inline void __fastcall ResetOver(void){m_AvgOver.Reset(1.0);};
BOOL __fastcall GetOver(void);
};
//---------------------------------------------------------------------------
class CSinTable
{
public:
double *m_tSin;
int m_Size;
public:
__fastcall CSinTable();
__fastcall ~CSinTable();
};
//---------------------------------------------------------------------------
class CAMPCONT
{
private:
double m_Max;
double m_Cnt;
double m_ADD;
int m_S;
int m_iMax;
public:
__fastcall CAMPCONT();
void __fastcall SetMax(int max);
void __fastcall Reset(void);
double __fastcall Do(int d);
inline __fastcall IsMax(void){return m_Cnt >= m_Max;};
};
//---------------------------------------------------------------------------
class CTICK
{
public:
int *ptbl[2];
int m_wsel;
int *m_wp;
int m_wcnt;
int m_Trig;
int m_Samp;
public:
CTICK();
~CTICK();
void Init(void);
void Write(double d);
inline int GetTrig(void){return m_Trig;};
int *GetData(void);
};
class CVCO
{
private:
double m_c1; // VCO<43>̗<EFBFBD><CC97><EFBFBD>
double m_c2; // <20>t<EFBFBD><74><EFBFBD>[<5B><><EFBFBD><EFBFBD><EFBFBD>j<EFBFBD><6A><EFBFBD>O<EFBFBD><4F><EFBFBD>g<EFBFBD><67>
int m_z;
int m_TableSize;
double *pSinTbl;
double m_FreeFreq;
double m_SampleFreq;
int m_vlock;
public:
CVCO();
~CVCO();
void VirtualLock(void);
void InitPhase(void);
void SetGain(double gain);
void SetSampleFreq(double f);
void SetFreeFreq(double f);
double Do(double d);
};
//---------------------------------------------------------------------------
// Added by JE3HHT on Aug.2010
class CVCOX
{
private:
double m_c1; // VCO<43>̗<EFBFBD><CC97><EFBFBD>
double m_c2; // <20>t<EFBFBD><74><EFBFBD>[<5B><><EFBFBD><EFBFBD><EFBFBD>j<EFBFBD><6A><EFBFBD>O<EFBFBD><4F><EFBFBD>g<EFBFBD><67>
double m_z;
double m_FreeFreq;
double m_SampleFreq;
int m_TableSize;
double m_TableCOS;
public:
__fastcall CVCOX();
__fastcall ~CVCOX();
void __fastcall InitPhase(void);
void __fastcall SetGain(double gain);
void __fastcall SetSampleFreq(double f);
void __fastcall SetFreeFreq(double f);
double __fastcall Do(void);
double __fastcall Do(double d);
double __fastcall DoCos(void);
};
class CSmooz{
private:
double *bp;
int Wp;
int Max;
int Cnt;
inline void IncWp(void){
Wp++;
if( Wp >= Max ) Wp = 0;
};
inline double Avg(void){
double d = 0.0;
int i;
for( i = 0; i < Cnt; i++ ){
d += bp[i];
}
if( Cnt ){
return d/double(Cnt);
}
else {
return 0;
}
};
public:
inline CSmooz(int max = 60){
Max = max;
bp = new double[max];
Cnt = 0;
Wp = 0;
};
inline ~CSmooz(void){
delete[] bp;
};
inline void SetCount(int n){
double *np = new double[n];
Max = n;
Cnt = Wp = 0;
double *op = bp;
bp = np;
delete[] op; //JA7UDE 0428
//delete[] np; //JA7UDE 0428
};
inline double Avg(double d){
bp[Wp] = d;
IncWp();
if( Cnt < Max ){
Cnt++;
}
return Avg();
};
};
//---------------------------------------------------------------------------
// Added by JE3HHT on Aug.2010
class CFIR
{
private:
int m_Tap;
double *m_pZ;
double *m_pH;
public:
__fastcall CFIR();
__fastcall ~CFIR();
void __fastcall Create(int tap, int type, double fs, double fcl, double fch, double att, double gain);
double __fastcall Do(double d);
void __fastcall SaveCoef(LPCSTR pName);
inline double __fastcall GetHD(int n){return m_pH[n];};
inline double *__fastcall GetHP(void){return m_pH;};
inline int __fastcall GetTap(void){return m_Tap;};
};
//---------------------------------------------------------------------------
// <20>_<EFBFBD>u<EFBFBD><75><EFBFBD>o<EFBFBD>b<EFBFBD>t<EFBFBD>@<40>ɂ<EFBFBD><C982><EFBFBD>FIR<49>t<EFBFBD>B<EFBFBD><42><EFBFBD>^
// Added by JE3HHT on Aug.2010
class CFIR2
{
private:
int m_Tap;
int m_TapHalf;
double *m_pZ;
double *m_pH;
double *m_pZP;
int m_W;
double m_fs;
public:
__fastcall CFIR2();
__fastcall ~CFIR2();
void __fastcall Delete(void);
void __fastcall Clear(void);
void __fastcall Create(int tap, int type, double fs, double fcl, double fch, double att, double gain);
void __fastcall Create(int tap, double fs, double fcl, double fch);
void __fastcall CreateSamp(int tap, double fs, const double *pSmpFQ);
double __fastcall Do(double d);
double __fastcall Do(double *hp);
void __fastcall Do(CLX &z, double d);
inline double __fastcall GetHD(int n){return m_pH[n];};
inline double *__fastcall GetHP(void){return m_pH;};
inline int __fastcall GetTap(void){return m_Tap;};
inline double __fastcall GetSampleFreq(void){return m_fs;};
};
//---------------------------------------------------------------------------
// <20>_<EFBFBD>u<EFBFBD><75><EFBFBD>o<EFBFBD>b<EFBFBD>t<EFBFBD>@<40>ɂ<EFBFBD><C982><EFBFBD>FIR<49>t<EFBFBD>B<EFBFBD><42><EFBFBD>^(<28><><EFBFBD>f<EFBFBD><66><EFBFBD>p)
// Added by JE3HHT on Aug.2010
class CFIRX
{
private:
int m_Tap;
int m_TapHalf;
CLX *m_pZ;
double *m_pH;
CLX *m_pZP;
int m_W;
double m_fs;
public:
__fastcall CFIRX();
__fastcall ~CFIRX();
void __fastcall Clear(void);
void __fastcall Create(int tap, int type, double fs, double fcl, double fch, double att, double gain);
void __fastcall Do(CLX &d);
inline double __fastcall GetHD(int n){return m_pH[n];};
inline double *__fastcall GetHP(void){return m_pH;};
inline int __fastcall GetTap(void){return m_Tap;};
inline double __fastcall GetSampleFreq(void){return m_fs;};
};
//---------------------------------------------------------------------------
// <20>X<EFBFBD><58><EFBFBD>C<EFBFBD>f<EFBFBD>B<EFBFBD><42><EFBFBD>OFFT
// Added by JE3HHT on Aug.2010
class CSlideFFT
{
private:
int m_Length;
int m_Base;
int m_Tones;
CLX m_tData[16];
CLX m_tWindow[16];
CLX *m_pCur;
CLX *m_pEnd;
CLX *m_pBase;
double m_kWindow;
private:
public:
__fastcall CSlideFFT();
__fastcall ~CSlideFFT();
void __fastcall Create(int len, int base, int tones);
CLX* __fastcall Do(const CLX &zIn);
};
/*=============================================================================
CPHASE<EFBFBD>N<EFBFBD><EFBFBD><EFBFBD>X
=============================================================================*/
#define CPHASE_BASEFREQ 0.0
class CPHASE
{
private:
// CFIRX m_LPF;
CVCOX m_VCO;
CFIR2 m_Hilbert;
CAGCX m_AGC;
FILE *m_fp;
public:
CLX m_sig;
CSlideFFT m_SlideFFT;
int m_TONES;
double m_SHIFT;
double m_fftSHIFT;
int m_BASEPOINT;
double m_MixerFreq;
double m_SymbolLen;
double m_CarrierFreq;
double m_SampleFreq;
double m_dm;
double m_ds;
private:
public:
__fastcall CPHASE();
void __fastcall Create(void);
void __fastcall SetSampleFreq(double f);
void __fastcall SetCarrierFreq(double f);
inline void __fastcall AddCarrierFreq(double f){
SetCarrierFreq(m_CarrierFreq + f);
};
CLX* __fastcall Do(double d);
inline CFIR2* __fastcall GetFIR(void){return &m_Hilbert;};
void __fastcall DoFSK(double d);
void __fastcall SetShift(double f);
void __fastcall ShowPara(void);
inline void SetTones(int n){
m_TONES = n;
Create();
}
};
class CPLL
{
private:
CIIR loopLPF;
CIIR outLPF;
double m_err;
double m_out;
double m_vcoout;
double m_SampleFreq;
double m_FreeFreq;
double m_Shift;
public:
int m_loopOrder;
double m_loopFC;
int m_outOrder;
double m_outFC;
double m_vcogain;
public:
CVCO vco;
inline CPLL(){
m_err = 0;
m_out = 0;
m_vcoout = 0;
m_vcogain = 3.0;
m_SampleFreq = SampFreq * 0.5;
m_Shift = 170.0;
m_FreeFreq = (2125 + 2295)/2;
m_loopOrder = 2;
m_outOrder = 4;
m_loopFC = 250.0;
m_outFC = 200.0;
SetFreeFreq(2125, 2295);
SetSampleFreq(m_SampleFreq);
};
inline void SetVcoGain(double g){
m_vcogain = g;
vco.SetGain(-m_Shift * g);
};
inline void MakeLoopLPF(void){
loopLPF.MakeIIR(m_loopFC, m_SampleFreq, m_loopOrder, 0, 0);
}
inline void MakeOutLPF(void){
outLPF.MakeIIR(m_outFC, m_SampleFreq, m_outOrder, 0, 0);
}
inline void SetFreeFreq(double f1, double f2){
m_FreeFreq = (f1 + f2)/2.0;
m_Shift = f2 - f1;
vco.SetFreeFreq(m_FreeFreq);
vco.SetGain(-m_Shift * m_vcogain);
}
void SetSampleFreq(double f){
m_SampleFreq = f;
vco.SetSampleFreq(f);
vco.SetFreeFreq(m_FreeFreq);
SetVcoGain(3.0);
MakeLoopLPF();
MakeOutLPF();
};
double Do(double d){
d /= 32768.0;
// Loop Filter
m_out = loopLPF.Do(m_err);
// VCO
m_vcoout = vco.Do(m_out);
// <20>ʑ<EFBFBD><CA91><EFBFBD><EFBFBD>r
m_err = m_vcoout * d;
return outLPF.Do(m_out) * 32768.0;
};
inline double GetErr(void){return m_err*32768;}; // Phase Det
inline double GetOut(void){return m_out*32768;}; // Phase Det
inline double GetVco(void){return m_vcoout;};
};
#define SCOPESIZE 8192
class CScope
{
private:
int m_DataFlag;
int m_wp;
public:
int m_ScopeSize;
double *pScopeData;
public:
CScope();
~CScope();
void WriteData(double d);
void UpdateData(double d);
Fixed XY Scope bug TNX to Stu K6TU
2016-01-17 08:26:53 +01:00
inline int GetFlag(void){return m_DataFlag;}; //JA7UDE 0428, edited by JA7UDE (Jan 17, 2016)
Added source file to repo as received from AA6YQ
2013-07-05 22:00:12 +02:00
void Collect(int size);
};
#define SAMPLEPEAKMAX 16
class CSamplePeak
{
private:
double Strage[SAMPLEPEAKMAX];
double m_CurPeak;
double m_Peak;
int m_Strage;
int m_Count;
int m_ReCount;
public:
CSamplePeak();
inline int GetStrage(void){ return m_Strage + 1;};
inline void SetStrage(int n){
if( n > SAMPLEPEAKMAX ) n = SAMPLEPEAKMAX;
m_Strage = n ? (n - 1) : 0;
};
double GetPeak(void){return m_Peak;};
void SetBaudRate(double b);
void Sync(int Delay);
int Sample(double d);
};
class CAGC
{
private:
double m_MarkGain;
double m_SpaceGain;
public:
int m_Sync;
double m_StepGain;
double m_MaxGain;
double m_DeffGain;
CSamplePeak Mark;
CSamplePeak Space;
public:
CAGC();
void Sync(int Delay);
double SampleMark(double d);
double SampleSpace(double d);
};
#define ATCMAX 17
#define ATCC (8192.0)
#define ATCW (1024.0)
class CATC
{
private:
double m_Low;
double m_High;
double m_CurLow;
double m_CurHigh;
double m_LowList[ATCMAX];
double m_HighList[ATCMAX];
int m_Cnt;
CIIR m_iir;
public:
int m_Max;
public:
CATC();
double Do(double d);
};
/********************************************************
CAA6YQ class by JE3HHT on Sep.2010
*********************************************************/
class CAA6YQ { // Added by JE3HHT on Sep.2010
public:
BOOL m_fEnabled;
int m_bpfTaps;
int m_befTaps;
double m_bpfFW;
double m_befFW;
double m_afcERR;
double m_dblMark;
double m_dblSpace;
double m_dblMarkAFC;
double m_dblSpaceAFC;
CFIR2 m_BPF;
CFIR2 m_BEF;
private:
public:
__fastcall CAA6YQ(void);
void __fastcall Create(void);
void __fastcall SetMarkFreq(double f);
void __fastcall SetSpaceFreq(double f);
void __fastcall SetMarkFreqByAFC(double f);
void __fastcall SetSpaceFreqByAFC(double f);
double __fastcall Do(double d);
};
#define DEMBUFMAX 512
#define DEMBPFTAP 36
class CFSKDEM
{
private:
double HMark[TAPMAX+1];
double ZMark[TAPMAX+1];
double HSpace[TAPMAX+1];
double ZSpace[TAPMAX+1];
int Count; // <20>f<EFBFBD><66><EFBFBD>W<EFBFBD><57><EFBFBD><EFBFBD><EFBFBD>[<5B>^<5E>f<EFBFBD>B<EFBFBD>X<EFBFBD>p<EFBFBD>b<EFBFBD>`
double i2; // <20>f<EFBFBD><66><EFBFBD>W<EFBFBD><57><EFBFBD><EFBFBD><EFBFBD>[<5B>^2ndInput
CDECM2 DECM2; // <20>f<EFBFBD><66><EFBFBD>W<EFBFBD><57><EFBFBD><EFBFBD><EFBFBD>[<5B>^
int m_Smooz;
CSmooz avgMark;
CSmooz avgSpace;
double m_BaudRate;
int m_Count;
int m_ReCount;
int m_mode;
int m_inv;
int m_sq;
double m_SQLevel;
int m_Tap;
double m_FilWidth;
double m_MarkFreq;
double m_SpaceFreq;
double m_SetMarkFreq;
double m_SetSpaceFreq;
double m_AFCMarkFreq;
double m_AFCSpaceFreq;
int m_DataCount;
BYTE m_Data;
int m_BufCount;
BYTE m_Buff[DEMBUFMAX];
int m_wp;
int m_rp;
double m_dMark;
double m_dSpace;
int m_mark;
int m_space;
double m_SmoozFreq;
int m_SumParity;
CIIRTANK m_iirm;
CIIRTANK m_iirs;
int m_sqcount;
CSmooz SmoozSQ;
COVERLIMIT OverLimit;
public:
int m_type;
double m_iirfw;
int m_OverFlow;
// int m_Bit;
int m_Scope;
int m_XYScope;
int m_BitLen;
int m_StopLen;
int m_Parity;
int m_majority; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>W<EFBFBD>b<EFBFBD>N
int m_ignoreFream; // <20>t<EFBFBD><74><EFBFBD>[<5B>~<7E><><EFBFBD>O<EFBFBD>G<EFBFBD><47><EFBFBD>[<5B>̖<EFBFBD><CC96><EFBFBD>
int m_Limit;
int m_LimitAGC;
double m_LimitGain;
double m_limitMax;
double m_limitMin;
double m_d;
double m_limitagc;
double m_deff;
double m_avgdeff;
CScope m_XYScopeMark;
CScope m_XYScopeSpace;
CScope m_ScopeMark[4];
CScope m_ScopeSpace[4];
CScope m_ScopeSync;
CScope m_ScopeBit;
CPLL m_pll;
int m_lpf;
int m_lpfOrder;
double m_lpffreq;
CIIR LpfMark;
CIIR LpfSpace;
int m_LimitOverSampling;
int m_Tick;
CTICK Tick;
int m_atc;
CATC m_atcMark;
CATC m_atcSpace;
CATC m_atcPLL;
CPHASE m_Phase;
CAA6YQ m_AA6YQ;
#if BITDEBUG
int m_bitCount;
int m_bitCountA;
#endif
private:
void DoFSK(void);
public:
CFSKDEM();
void Do(double d);
inline void ClearMode(void){m_mode = 0;};
double GetFilWidth(int tap);
void SetIIR(double b);
void AFCMarkFreq(double d);
void AFCSpaceFreq(double d);
void SetMarkFreq(double d);
void SetSpaceFreq(double d);
inline double GetMarkFreq(void){return m_MarkFreq;};
inline double GetSpaceFreq(void){return m_SpaceFreq;};
inline double GetSetMarkFreq(void){return m_SetMarkFreq;};
inline double GetSetSpaceFreq(void){return m_SetSpaceFreq;};
inline double GetAFCMarkFreq(void){return m_AFCMarkFreq;};
inline double GetAFCSpaceFreq(void){return m_AFCSpaceFreq;};
inline int GetRev(void){ return m_inv; };
inline void SetRev(int inv){ m_inv = inv;};
void SetBaudRate(double b);
inline double GetBaudRate(void){return m_BaudRate;};
inline double GetSmoozFreq(void){return m_SmoozFreq;};
inline int GetSmoozCount(void){return m_Smooz;};
void SetSmoozCount(int n);
void SetSmoozFreq(double f);
void SetLPFFreq(double f);
inline int GetSQ(void){return m_sq;};
inline void SetSQ(int sq){m_sq = sq;};
inline double GetSQLevel(void){return m_SQLevel;};
inline void SetSQLevel(double lvl){m_SQLevel = lvl;};
inline int GetFilterTap(void){return m_Tap;};
void SetFilterTap(int tap);
inline int GetCount(void){return m_BufCount;};
int GetData();
inline void ClearRXBuf(void){
m_BufCount = 0;
m_rp = m_wp = 0;
m_mode = 0;
};
void WriteData(BYTE d);
};
#define MODBUFMAX 2048
class CFSKMOD
{
private:
double HBPF[TAPMAX+1];
double ZBPF[TAPMAX+1];
CSmooz avgLPF;
double m_LPFFreq;
double m_SampFreq;
CVCO vco;
BYTE m_Buff[MODBUFMAX];
int m_rp;
int m_wp;
int m_cnt;
int m_Count;
int m_out;
int m_inv;
int m_mode;
int m_DataCount;
double m_BaudRate;
double m_MarkFreq;
double m_SpaceFreq;
double m_OutputGain;
BYTE m_Data;
int m_FSKCount;
int m_SumParity;
int m_fig;
int m_figout;
int m_idle;
CFSKDEM *pDem;
private:
public:
int m_BitLen;
int m_StopLen;
int m_Parity;
int m_diddle;
int m_bpf;
int m_bpftap;
int m_lpf;
int m_DiddleWait;
int m_CharWait;
int m_CharWaitDiddle;
int m_RandomDiddle;
int m_WaitTimer;
int m_DisDiddle;
int m_CharWaitCount;
int m_WaitTimerCount;
int m_ReCount;
int m_CoutCount;
int m_AmpVal;
CAMPCONT m_Amp;
CFSKMOD();
inline int IsIdle(void){return m_idle;};
inline double GetBaudRate(void){return m_BaudRate;};
void SetBaudRate(double b);
void CalcBPF(void);
void SetMarkFreq(double d);
void SetSpaceFreq(double d);
void SetSampFreq(double f);
inline void InitPhase(void){
vco.InitPhase();
m_mode = 0;
m_CharWaitCount = 0;
m_WaitTimerCount = 4;
m_Data = 0;
memset(ZBPF, 0, (m_bpftap+1) * sizeof(double));
};
void OutTone(int sw, int bsize);
inline int GetMode(void){
return m_mode;
};
inline double GetMarkFreq(void){return m_MarkFreq;};
inline double GetSpaceFreq(void){return m_SpaceFreq;};
inline int GetRev(void){return m_inv;};
inline void SetRev(int inv){m_inv = inv;};
inline double GetOutputGain(void){return m_OutputGain;};
inline void SetOutputGain(double gain){m_OutputGain = gain;};
inline void SetBPF(int sw){m_bpf = sw;};
inline double GetLPFFreq(void){return m_LPFFreq;};
void SetLPFFreq(double f);
inline void SetCount(int count){
m_Count = count;
};
inline void ClearTXBuf(void){
m_out = -1;
m_Count = m_ReCount/2;
m_cnt = 0;
m_rp = m_wp = 0;
m_figout = 0;
m_DisDiddle = -1;
m_Data = 0;
m_FSKCount = m_SampFreq * 2;
};
inline void DeleteTXBuf(void){
m_cnt = 0;
m_rp = m_wp = 0;
m_figout = 0;
};
inline int SetDiddleTimer(int n){
m_DisDiddle = n;
return 0; //JA7UDE 0428
};
inline int GetBufCount(void){return m_cnt;};
void PutData(int d);
double Do(int echo);
inline void SetDem(CFSKDEM *p){pDem = p;};
};
#pragma option -a- // <20>p<EFBFBD>b<EFBFBD>N<EFBFBD>̎w<CC8E><77>
typedef struct {
BYTE Code;
BYTE Fig;
}BCODETBL;
#pragma option -a. // <20>p<EFBFBD>b<EFBFBD>N<EFBFBD><4E><EFBFBD><EFBFBD><EFBFBD>̎w<CC8E><77>
class CRTTY
{
private:
int m_outfig;
BCODETBL m_TBL[24*4];
public:
int m_fig;
int m_uos;
int m_txuos;
CRTTY();
char ConvAscii(int d);
int ConvRTTY(char d);
int ConvRTTY(BYTE *t, LPCSTR p);
inline int IsChar(int d){
d &= 0x000000ff;
if( !d ) return 0;
if( d == 0x000000ff ) return 0;
return 1;
};
inline void ClearTX(void){m_outfig = 3;};
inline void ClearRX(void){m_fig = 0;};
int GetShift(char d);
char InvShift(char c);
void SetCodeSet(void);
};
#define NOISEBPFTAP 12
class CNoise // M<>n<EFBFBD><6E><EFBFBD>m<EFBFBD>C<EFBFBD>Y N=22 (Tap=1)
{
private:
double H[NOISEBPFTAP+1];
double Z[NOISEBPFTAP+1];
DWORD reg;
public:
CNoise();
double GetNoise(void);
};
#endif
Reference in a new issue Copy permalink