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/Comm.cpp

633 lines
15 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/>.
//-----------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Comm.h"
#include "ComLib.h"
#define WAITSTAT 0
#define DEFFSOUND 3
COMMPARA COMM;
void InitCOMMPara(void)
{
COMM.change = 1;
}
__fastcall CComm::CComm(bool CreateSuspended)
: TThread(CreateSuspended)
{
m_CreateON = FALSE; // <20>N<EFBFBD><4E><EFBFBD>G<EFBFBD>C<EFBFBD>g<EFBFBD>t<EFBFBD><74><EFBFBD>O
m_Command = 0;
m_fHnd = NULL; // <20>t<EFBFBD>@<40>C<EFBFBD><43><EFBFBD>n<EFBFBD><6E><EFBFBD>h<EFBFBD><68>
m_inv = 0;
m_Execute = 0;
m_txwp = m_txrp = m_txcnt = 0;
m_TxEnb = 0;
m_figout = 0;
m_idle = 0;
m_WaitTimerCount = 0;
m_nextcount = 0;
pMod = NULL;
m_pEXT = NULL;
}
void __fastcall CComm::WaitTXD(int w)
{
if( w ){
#if 0
ULONG tim = ::GetTickCount();
ULONG w = ((pMod->m_ReCount*(pMod->m_BitLen + 1.5) ) + (w * pMod->m_ReCount/3)) * 1000 / SampFreq;
tim += w;
if( w > 10 )::Sleep(w - 10);
while(tim >= ::GetTickCount()) ::Sleep(0);
#else
::Sleep(((pMod->m_ReCount*(pMod->m_BitLen + 1.5) ) + (w * pMod->m_ReCount/3)) * 1000 / SampFreq);
#endif
}
}
void __fastcall CComm::NextBuf(void)
{
m_txrp++;
if( m_txrp >= COMM_TXBUFSIZE ){
m_txrp = 0;
}
m_txcnt--;
FSKCount1++;
FSKCount--;
}
void __fastcall CComm::EnbTX(int sw)
{
m_TxEnb = 0;
if( !sw ){
FSKCount1 = 1000;
FSKCount2 = 0;
}
else {
m_WaitTimerCount = 4;
m_FirstGaurd = TRUE;
FSKCount1 = 0;
FSKCount2 = 0;
FSKDeff = 0;
}
m_txwp = m_txrp = m_txcnt = 0;
FSKCount = 0;
m_figout = 0;
m_idle = 0;
m_TxEnb = sw;
}
void __fastcall CComm::Timer(void)
{
if( m_CreateON ){
if( sys.m_TxPort ){
if( m_fHnd == NULL ) return;
if( !m_TxEnb ) return;
if( m_DisDiddle != pMod->m_DisDiddle ){
m_DisDiddle = pMod->m_DisDiddle;
}
}
}
}
//-----------------------------------------------------------------
// DTR<54>ŕ<EFBFBD><C595><EFBFBD><EFBFBD><EFBFBD><EFBFBD>M<EFBFBD>p
void __fastcall CComm::OutData(BYTE d)
{
const BYTE tbl[]={
0x00, 0x10, 0x08, 0x18, // 00000 10000 01000 11000
0x04, 0x14, 0x0c, 0x1c, // 00100 10100 01100 11100
0x02, 0x12, 0x0a, 0x1a, // 00010 10010 01010 11010
0x06, 0x16, 0x0e, 0x1e, // 00110 10110 01110 11110
0x01, 0x11, 0x09, 0x19, // 00001 10001 01001 11001
0x05, 0x15, 0x0d, 0x1d, // 00101 10101 01101 11101
0x03, 0x13, 0x0b, 0x1b, // 00011 10011 01011 11011
0x07, 0x17, 0x0f, 0x1f, // 00111 10111 01111 11111
};
if( m_CreateON == FALSE ) return;
if( pMod->m_BitLen <= 6 ){
d = tbl[d & 0x001f];
}
if( sys.m_TxdJob >= 2 ){
if( m_nextcount ){
while( m_nextcount >= ::GetTickCount() ){
if( m_Command == COMM_CLOSE ) return;
::Sleep(1);
}
}
m_nextcount = ::GetTickCount() + m_addcount;
}
if( m_pEXT != NULL ){
m_pEXT->PutChar(d);
}
else {
TransmitCommChar(m_fHnd, d);
}
#if BITDEBUG
m_bitCountA = GetTickCount() - m_bitCount;
m_bitCount = GetTickCount();
#endif
}
//---------------------------------------------------------------------------
void __fastcall CComm::Execute()
{
m_Execute = 1;
int BitLen = pMod->m_BitLen;
//---- <20>X<EFBFBD><58><EFBFBD>b<EFBFBD>h<EFBFBD>̃R<CC83>[<5B>h<EFBFBD><68><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɋL<C98B>q ----
// Priority = tpLower;
while(1){
_try:;
if( Terminated == TRUE ){
return;
}
if( m_Command == COMM_CLOSE ){
m_Command = 0;
return;
}
if( m_CreateON == TRUE ){
if( !m_TxEnb ){
::Sleep(10);
}
else if( !TxBusy() ){
if( m_FirstGaurd ){ // <20>ŏ<EFBFBD><C58F>̃K<CC83>[<5B>h<EFBFBD><68><EFBFBD>Ԃ̊m<CC8A><6D>
m_FirstGaurd = 0;
::Sleep(250);
if( m_DisDiddle == -1 ) m_DisDiddle = 0;
}
else if( m_txcnt && (FSKDeff <= DEFFSOUND) ){ // <20><><EFBFBD>M<EFBFBD>f<EFBFBD>[<5B>^<5E><><EFBFBD><EFBFBD>
m_DisDiddle = pMod->m_DisDiddle;
m_Data = m_txbuf[m_txrp];
if( m_figout && (m_fig == 0x1b) && (m_Data != 0x1f) ){
m_Data = 0x1b;
}
else {
switch(m_Data){
case 0xff: // Mark
::Sleep((pMod->m_ReCount * 3 * 1000) / SampFreq);
NextBuf();
goto _try;
case 0xfe: // <20>L<EFBFBD><4C><EFBFBD><EFBFBD><EFBFBD>A<EFBFBD>f<EFBFBD><66>
NextBuf();
goto _try;
case 0xfd: // disable diddle
m_DisDiddle = 0;
NextBuf();
goto _try;
case 0xfc: // enable diddle
m_DisDiddle = 1;
NextBuf();
goto _try;
case 0x1b:
case 0x1f:
m_fig = m_Data;
break;
}
NextBuf();
}
m_figout = 0;
if( !pMod->m_CharWaitDiddle ){
WaitTXD(pMod->m_CharWait);
}
m_WaitTimerCount = 4;
OutData(m_Data);
}
else if( (BitLen < 6) && ((FSKDeff > DEFFSOUND) || (pMod->m_diddle && !m_DisDiddle)) ){
if( FSKDeff > DEFFSOUND ){
WaitTXD(pMod->m_CharWait);
}
else if( (sys.m_LWait == 2) || !pMod->m_WaitTimer || m_WaitTimerCount ){
if( !pMod->m_CharWaitDiddle ){
if( sys.m_LWait == 2 ){
WaitTXD(pMod->m_CharWait);
}
else if( pMod->m_DiddleWait ){
WaitTXD(pMod->m_DiddleWait);
}
}
}
m_idle = 1;
switch(pMod->m_diddle){
case 1: // BLK
if( pMod->m_RandomDiddle && !(rand() & 3) ){
m_Data = 0x1f;
if( pMod->m_BitLen <= 6 ) m_figout = 1;
}
else {
m_Data = 0x00;
}
break;
default: // LTR
if( pMod->m_RandomDiddle && !(rand() & 3) ){
m_Data = 0x00;
}
else {
m_Data = 0x1f;
if( pMod->m_BitLen <= 6 ) m_figout = 1;
}
break;
}
if( m_WaitTimerCount ) m_WaitTimerCount--;
OutData(m_Data);
}
else {
if( !m_idle ){
::Sleep((pMod->m_ReCount * pMod->m_BitLen)*1000/SampFreq);
}
m_idle = 1;
}
::Sleep(10);
}
else {
::Sleep(1);
}
}
else {
::Sleep(10);
}
}
}
/*#$%
==============================================================
<EFBFBD>ʐM<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>N<EFBFBD><EFBFBD><EFBFBD>[<EFBFBD>Y<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
--------------------------------------------------------------
--------------------------------------------------------------
--------------------------------------------------------------
==============================================================
*/
void __fastcall CComm::Close(void)
{
if( m_CreateON == TRUE ){
if( m_Execute ){
m_TxEnb = 0;
m_Command = COMM_CLOSE; // <20>X<EFBFBD><58><EFBFBD>b<EFBFBD>h<EFBFBD>I<EFBFBD><49><EFBFBD>R<EFBFBD>}<7D><><EFBFBD>h
Priority = tpNormal; //<2F>X<EFBFBD><58><EFBFBD>b<EFBFBD>h<EFBFBD>͒ʏ<CD92><CA8F>̗D<CC97><44><EFBFBD>x<EFBFBD>ł<EFBFBD><C582><EFBFBD>
#if 0
DWORD tim = GetTickCount();
while( m_Command && (GetTickCount() < (tim + 3000)) ){ // <20>X<EFBFBD><58><EFBFBD>b<EFBFBD>h<EFBFBD>I<EFBFBD><49><EFBFBD>҂<EFBFBD>
::Sleep(1);
}
#else
WaitFor();
#endif
FSKCount1+=1000;
}
if( m_pEXT != NULL ){
delete m_pEXT;
m_pEXT = NULL;
}
else {
::CloseHandle(m_fHnd);
}
m_CreateON = FALSE;
}
}
void __fastcall CComm::ReqClose(void)
{
if( m_CreateON == TRUE ){
if( m_Execute ){
m_TxEnb = 0;
m_Command = COMM_CLOSE; // <20>X<EFBFBD><58><EFBFBD>b<EFBFBD>h<EFBFBD>I<EFBFBD><49><EFBFBD>R<EFBFBD>}<7D><><EFBFBD>h
Priority = tpNormal; //<2F>X<EFBFBD><58><EFBFBD>b<EFBFBD>h<EFBFBD>͒ʏ<CD92><CA8F>̗D<CC97><44><EFBFBD>x<EFBFBD>ł<EFBFBD><C582><EFBFBD>
FSKCount1+=1000;
}
}
}
void __fastcall CComm::WaitClose(void)
{
if( m_CreateON == TRUE ){
if( m_Execute && m_Command ){
#if 0
DWORD tim = GetTickCount();
while( GetTickCount() < (tim + 3000) ){ // 1[s]<5D>̃E<CC83>G<EFBFBD>C<EFBFBD>g
if( !m_Command ) break;
::Sleep(1);
}
#else
WaitFor();
#endif
}
if( m_pEXT != NULL ){
delete m_pEXT;
m_pEXT = NULL;
}
else {
::CloseHandle(m_fHnd);
}
m_CreateON = FALSE;
}
}
/*#$%
==============================================================
<EFBFBD>ʐM<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>I<EFBFBD>[<EFBFBD>v<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
--------------------------------------------------------------
PortName : <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̖<EFBFBD><EFBFBD>O
pCP : COMMPARA<EFBFBD>̃|<EFBFBD>C<EFBFBD><EFBFBD><EFBFBD>^<EFBFBD>i<EFBFBD>k<EFBFBD><EFBFBD><EFBFBD>̎<EFBFBD><EFBFBD>̓f<EFBFBD>t<EFBFBD>H<EFBFBD><EFBFBD><EFBFBD>g<EFBFBD>ŏ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>j
RBufSize : <EFBFBD><EFBFBD><EFBFBD>M<EFBFBD>o<EFBFBD>b<EFBFBD>t<EFBFBD>@<EFBFBD>̃T<EFBFBD>C<EFBFBD>Y(default=2048)
TBufSize : <EFBFBD><EFBFBD><EFBFBD>M<EFBFBD>o<EFBFBD>b<EFBFBD>t<EFBFBD>@<EFBFBD>̃T<EFBFBD>C<EFBFBD>Y(default=2048)
--------------------------------------------------------------
TRUE/FALSE
--------------------------------------------------------------
==============================================================
*/
BOOL __fastcall CComm::Open(LPCTSTR PortName, int inv, COMMPARA *cp)
{
if( m_CreateON == TRUE ) Close();
m_Execute = 0;
m_fHnd = ::CreateFile( PortName, GENERIC_READ | GENERIC_WRITE,
0, NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if( m_fHnd == INVALID_HANDLE_VALUE ){
m_pEXT = new CEXTFSK(PortName);
if( m_pEXT->IsLib() ){
LONG para;
if( cp != NULL ){
para = (cp->Baud << 16);
para |= cp->Stop;
para |= (cp->BitLen << 2);
}
else {
para = (45 << 16);
}
m_pEXT->Open(para);
m_CreateON = TRUE;
return TRUE;
}
else {
delete m_pEXT;
m_pEXT = NULL;
}
return FALSE;
}
m_inv = inv;
// setup device buffers
if( ::SetupComm( m_fHnd, DWORD(1024), DWORD(2) ) == FALSE ){
::CloseHandle(m_fHnd);
return FALSE;
}
// purge any information in the buffer
::PurgeComm( m_fHnd, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );
// set up for overlapped I/O
COMMTIMEOUTS TimeOut;
TimeOut.ReadIntervalTimeout = 0xffffffff;
TimeOut.ReadTotalTimeoutMultiplier = 0;
TimeOut.ReadTotalTimeoutConstant = 0;
TimeOut.WriteTotalTimeoutMultiplier = 0;
TimeOut.WriteTotalTimeoutConstant = 20000;
// TimeOut.WriteTotalTimeoutConstant = 1;
if( !::SetCommTimeouts( m_fHnd, &TimeOut ) ){
::CloseHandle( m_fHnd );
return FALSE;
}
::GetCommState( m_fHnd, &m_dcb );
m_dcb.BaudRate = (cp != NULL) ? cp->Baud : 9600;
m_dcb.fBinary = TRUE;
m_dcb.ByteSize = BYTE((cp != NULL) ? cp->BitLen : 8);
m_dcb.Parity = BYTE((cp != NULL) ? cp->Parity : NOPARITY);
m_dcb.StopBits = BYTE((cp != NULL ) ? cp->Stop : ONESTOPBIT);
// Application->MainForm->Caption = int(cp ? cp->Stop == TWOSTOPBITS : FALSE);
m_dcb.XonChar = 0x11; // XON
m_dcb.XoffChar = 0x13; // XOFF
m_dcb.fParity = 0;
m_dcb.fOutxCtsFlow = FALSE;
m_dcb.fInX = m_dcb.fOutX = FALSE;
m_dcb.fOutxDsrFlow = FALSE;
m_dcb.EvtChar = 0x0d;
m_dcb.fRtsControl = m_inv ? RTS_CONTROL_ENABLE : RTS_CONTROL_DISABLE; // <20><><EFBFBD>M<EFBFBD>֎~
m_dcb.fDtrControl = m_inv ? DTR_CONTROL_ENABLE : DTR_CONTROL_DISABLE; // <20><><EFBFBD>M<EFBFBD>֎~
// m_dcb.fTXContinueOnXoff = TRUE;
m_dcb.XonLim = USHORT(1024/4); // 1/4 of RBufSize
m_dcb.XoffLim = USHORT(1024*3/4); // 3/4 of RBufSize
m_dcb.DCBlength = sizeof( DCB );
if( m_dcb.StopBits != ONESTOPBIT ){
m_addcount = DWORD((1000.0/double(m_dcb.BaudRate)) * double(m_dcb.ByteSize + 2.7));
}
else {
m_addcount = DWORD((1000.0/double(m_dcb.BaudRate)) * double(m_dcb.ByteSize + 2.2));
}
#if 0 // debug
m_dcb.BaudRate = 9600;
m_dcb.ByteSize = 8;
#endif
if( !::SetCommState( m_fHnd, &m_dcb ) ){
::CloseHandle( m_fHnd );
return FALSE;
}
// get any early notifications
if( !::SetCommMask( m_fHnd, EV_RXFLAG ) ){
::CloseHandle(m_fHnd);
return FALSE;
}
m_CreateON = TRUE;
return TRUE;
}
//-----------------------------------------------------------------
// PTT<54>؂<EFBFBD><D882>ւ<EFBFBD><D682>p
void __fastcall CComm::SetTXRX(int sw)
{
if( m_CreateON == FALSE ) return;
if( m_inv ) sw = sw ? 0 : 1;
if( m_pEXT != NULL ){
m_pEXT->SetPTT(sw);
}
else if( sw ){
::EscapeCommFunction(m_fHnd, SETRTS);
::EscapeCommFunction(m_fHnd, SETDTR);
}
else {
::EscapeCommFunction(m_fHnd, CLRRTS);
::EscapeCommFunction(m_fHnd, CLRDTR);
}
}
#if 0
//-----------------------------------------------------------------
// DTR<54>ŕ<EFBFBD><C595><EFBFBD><EFBFBD><EFBFBD><EFBFBD>M<EFBFBD>p
void __fastcall CComm::SetDTR(int sw)
{
if( m_CreateON == FALSE ) return;
if( sw ){
::EscapeCommFunction(m_fHnd, SETDTR);
}
else {
::EscapeCommFunction(m_fHnd, CLRDTR);
}
}
#endif
//-----------------------------------------------------------------
// <20><><EFBFBD>M<EFBFBD>r<EFBFBD>W<EFBFBD>[<5B><><EFBFBD>ǂ<EFBFBD><C782><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ׂ<EFBFBD> TRUE : <20><><EFBFBD>M<EFBFBD>r<EFBFBD>W<EFBFBD>[<5B><><EFBFBD><EFBFBD>
int __fastcall CComm::TxBusy(void)
{
if( m_CreateON == FALSE ) return 0;
if( m_pEXT != NULL ){
return m_pEXT->IsTxBusy();
}
else {
COMSTAT ComStat;
DWORD dwErrorFlags;
ClearCommError( m_fHnd, &dwErrorFlags, &ComStat );
return ComStat.fTxim;
}
}
/*#$%
==============================================================
<EFBFBD>ʐM<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƀf<EFBFBD>[<EFBFBD>^<EFBFBD>𑗐M<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
--------------------------------------------------------------
--------------------------------------------------------------
--------------------------------------------------------------
==============================================================
*/
void __fastcall CComm::PutChar(BYTE c)
{
if( (m_CreateON == TRUE) && m_Execute ){
if( m_txcnt < COMM_TXBUFSIZE ){
m_txbuf[m_txwp] = c;
m_txwp++;
if( m_txwp >= COMM_TXBUFSIZE ) m_txwp = 0;
m_txcnt++;
m_idle = 0;
FSKCount++;
}
}
}
#if 0
/*#$%
==============================================================
<EFBFBD><EFBFBD><EFBFBD>M<EFBFBD>o<EFBFBD>b<EFBFBD>t<EFBFBD>@<EFBFBD><EFBFBD><EFBFBD>̊i<EFBFBD>[<EFBFBD>f<EFBFBD>[<EFBFBD>^<EFBFBD><EFBFBD><EFBFBD>𓾂<EFBFBD>
--------------------------------------------------------------
--------------------------------------------------------------
<EFBFBD>f<EFBFBD>[<EFBFBD>^<EFBFBD>̒<EFBFBD><EFBFBD><EFBFBD>
--------------------------------------------------------------
==============================================================
*/
DWORD CComm::RecvLen(void)
{
if( m_pEXT != NULL ){
return m_pEXT->IsEmpty(0) ? 0 : 1;
}
else {
COMSTAT ComStat;
DWORD dwErrorFlags;
::ClearCommError( m_fHnd, &dwErrorFlags, &ComStat );
return ComStat.cbInQue;
}
}
#endif
/*******************************************************************
EXTFSK.DLL
*******************************************************************/
__fastcall CEXTFSK::CEXTFSK(LPCSTR pName)
{
char Name[128];
sprintf(Name, "%s.%s", pName, strcmpi(pName, "EXTFSK") ? "fsk" : "dll");
fextfskOpen = NULL;
fextfskClose = NULL;
fextfskIsTxBusy = NULL;
fextfskPutChar = NULL;
fextfskSetPTT = NULL;
m_hLib = ::LoadLibrary(Name);
if( m_hLib != NULL ){
fextfskOpen = (extfskOpen)GetProc("_extfskOpen");
fextfskClose = (extfskClose)GetProc("_extfskClose");
fextfskIsTxBusy = (extfskIsTxBusy)GetProc("_extfskIsTxBusy");
fextfskPutChar = (extfskPutChar)GetProc("_extfskPutChar");
fextfskSetPTT = (extfskSetPTT)GetProc("_extfskSetPTT");
}
}
//---------------------------------------------------------------------
__fastcall CEXTFSK::~CEXTFSK()
{
if( m_hLib != NULL ){
Close();
::FreeLibrary(m_hLib);
m_hLib = NULL;
}
}
//---------------------------------------------------------------------
FARPROC CEXTFSK::GetProc(LPCSTR pName)
{
FARPROC fn = ::GetProcAddress(m_hLib, pName+1);
if( fn == NULL ){
fn = ::GetProcAddress(m_hLib, pName);
}
return fn;
}
long __fastcall CEXTFSK::Open(long para)
{
if( !m_hLib || !fextfskOpen ) return FALSE;
return fextfskOpen(para);
}
void __fastcall CEXTFSK::Close(void)
{
if( !m_hLib || !fextfskClose ) return;
fextfskClose();
}
long __fastcall CEXTFSK::IsTxBusy(void)
{
if( !m_hLib || !fextfskIsTxBusy ) return FALSE;
return fextfskIsTxBusy();
}
void __fastcall CEXTFSK::PutChar(BYTE c)
{
if( !m_hLib || !fextfskPutChar ) return;
fextfskPutChar(c);
}
void __fastcall CEXTFSK::SetPTT(long tx)
{
if( !m_hLib || !fextfskSetPTT ) return;
fextfskSetPTT(tx);
}
Reference in a new issue Copy permalink