You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
375 lines
8.6 KiB
375 lines
8.6 KiB
/*
|
|
* Copyright (C) 2011-2014 by Jonathan Naylor G4KLX
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#include "GMSKController.h"
|
|
#if defined(__WINDOWS__)
|
|
#include "GMSKModemWinUSB.h"
|
|
#endif
|
|
#include "GMSKModemLibUsb.h"
|
|
#include "Timer.h"
|
|
|
|
const unsigned char DVRPTR_HEADER_LENGTH = 5U;
|
|
|
|
const unsigned int BUFFER_LENGTH = 200U;
|
|
|
|
const unsigned int CYCLE_TIME = 15U;
|
|
|
|
CGMSKController::CGMSKController(USB_INTERFACE iface, unsigned int address, bool duplex) :
|
|
CModem(),
|
|
m_modem(NULL),
|
|
m_duplex(duplex),
|
|
m_buffer(NULL),
|
|
m_txData(1000U)
|
|
{
|
|
wxASSERT(address > 0U);
|
|
|
|
m_buffer = new unsigned char[BUFFER_LENGTH];
|
|
|
|
#if defined(__WINDOWS__)
|
|
switch (iface) {
|
|
case UI_LIBUSB:
|
|
m_modem = new CGMSKModemLibUsb(address);
|
|
break;
|
|
case UI_WINUSB:
|
|
m_modem = new CGMSKModemWinUSB(address);
|
|
break;
|
|
default:
|
|
wxLogError(wxT("Unknown GMSM modem driver type - %d"), int(iface));
|
|
break;
|
|
}
|
|
#else
|
|
m_modem = new CGMSKModemLibUsb(address);
|
|
#endif
|
|
}
|
|
|
|
CGMSKController::~CGMSKController()
|
|
{
|
|
delete[] m_buffer;
|
|
}
|
|
|
|
bool CGMSKController::start()
|
|
{
|
|
if (m_modem == NULL)
|
|
return false;
|
|
|
|
bool ret = m_modem->open();
|
|
if (!ret) {
|
|
delete m_modem;
|
|
return false;
|
|
}
|
|
|
|
Create();
|
|
SetPriority(100U);
|
|
Run();
|
|
|
|
return true;
|
|
}
|
|
|
|
void* CGMSKController::Entry()
|
|
{
|
|
wxLogMessage(wxT("Starting GMSK Modem Controller thread"));
|
|
|
|
CTimer hdrTimer(1000U, 0U, 100U);
|
|
hdrTimer.start();
|
|
|
|
CTimer dataTimer(1000U, 0U, 100U);
|
|
|
|
bool rx = false;
|
|
|
|
DSMT_TYPE writeType = DSMTT_HEADER;
|
|
unsigned char writeLength = 0U;
|
|
unsigned char* writeBuffer = new unsigned char[BUFFER_LENGTH];
|
|
|
|
unsigned char readLength = 0U;
|
|
unsigned char* readBuffer = new unsigned char[DV_FRAME_LENGTH_BYTES];
|
|
|
|
wxStopWatch stopWatch;
|
|
|
|
while (!m_stopped) {
|
|
stopWatch.Start();
|
|
|
|
// Only receive when not transmitting or when in duplex mode
|
|
if (!m_tx || m_duplex) {
|
|
if (rx) {
|
|
unsigned char buffer[GMSK_MODEM_DATA_LENGTH];
|
|
bool end;
|
|
int ret = m_modem->readData(buffer, GMSK_MODEM_DATA_LENGTH, end);
|
|
if (ret >= 0) {
|
|
// CUtils::dump(wxT("Read Data"), buffer, ret);
|
|
|
|
if (end) {
|
|
wxMutexLocker locker(m_mutex);
|
|
|
|
unsigned char data[2U];
|
|
data[0U] = DSMTT_EOT;
|
|
data[1U] = 0U;
|
|
m_rxData.addData(data, 2U);
|
|
|
|
hdrTimer.start();
|
|
readLength = 0U;
|
|
rx = false;
|
|
} else {
|
|
for (int i = 0; i < ret; i++) {
|
|
readBuffer[readLength] = buffer[i];
|
|
|
|
readLength++;
|
|
if (readLength >= DV_FRAME_LENGTH_BYTES) {
|
|
wxMutexLocker locker(m_mutex);
|
|
|
|
unsigned char data[2U];
|
|
data[0U] = DSMTT_DATA;
|
|
data[1U] = DV_FRAME_LENGTH_BYTES;
|
|
m_rxData.addData(data, 2U);
|
|
|
|
m_rxData.addData(readBuffer, DV_FRAME_LENGTH_BYTES);
|
|
readLength = 0U;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
ret = reopenModem();
|
|
if (!ret)
|
|
break;
|
|
}
|
|
} else {
|
|
// Check for a header every 100ms or so
|
|
if (hdrTimer.isRunning() && hdrTimer.hasExpired()) {
|
|
unsigned char buffer[90U];
|
|
bool ret = m_modem->readHeader(buffer, 90U);
|
|
if (ret) {
|
|
// CUtils::dump(wxT("Read Header"), buffer, RADIO_HEADER_LENGTH_BYTES);
|
|
|
|
wxMutexLocker locker(m_mutex);
|
|
|
|
unsigned char data[2U];
|
|
data[0U] = DSMTT_HEADER;
|
|
data[1U] = RADIO_HEADER_LENGTH_BYTES - 2U;
|
|
m_rxData.addData(data, 2U);
|
|
|
|
m_rxData.addData(buffer, RADIO_HEADER_LENGTH_BYTES - 2U);
|
|
|
|
hdrTimer.stop();
|
|
readLength = 0U;
|
|
rx = true;
|
|
} else {
|
|
hdrTimer.start();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Only transmit when not receiving or when in duplex mode
|
|
if (!rx || m_duplex) {
|
|
if (writeLength == 0U && m_txData.hasData()) {
|
|
wxMutexLocker locker(m_mutex);
|
|
|
|
unsigned char type = DSMTT_NONE;
|
|
m_txData.getData(&type, 1U);
|
|
writeType = DSMT_TYPE(type);
|
|
|
|
m_txData.getData(&writeLength, 1U);
|
|
m_txData.getData(writeBuffer, writeLength);
|
|
}
|
|
|
|
if (writeLength > 0U) {
|
|
if (writeType == DSMTT_HEADER) {
|
|
TRISTATE tx = m_modem->getPTT();
|
|
|
|
// Check that the modem isn't still transmitting before sending the new header
|
|
if (tx == STATE_FALSE) {
|
|
// CUtils::dump(wxT("Write Header"), writeBuffer, writeLength);
|
|
m_modem->writeHeader(writeBuffer, writeLength);
|
|
m_modem->setPTT(true);
|
|
dataTimer.start();
|
|
writeLength = 0U;
|
|
m_tx = true;
|
|
} else if (tx == STATE_UNKNOWN) {
|
|
bool ret = reopenModem();
|
|
if (!ret)
|
|
break;
|
|
}
|
|
} else {
|
|
// Don't start sending data until the header has been gone for 100ms or so
|
|
if (!dataTimer.isRunning() || dataTimer.hasExpired()) {
|
|
dataTimer.stop();
|
|
|
|
TRISTATE ret = m_modem->hasSpace();
|
|
|
|
// Check that there is space in the modem buffer
|
|
if (ret == STATE_TRUE) {
|
|
// CUtils::dump(wxT("Write Data"), writeBuffer, writeLength);
|
|
int ret = m_modem->writeData(writeBuffer, writeLength);
|
|
if (ret > 0) {
|
|
writeLength -= ret;
|
|
|
|
if (writeType == DSMTT_EOT) {
|
|
m_modem->setPTT(false);
|
|
m_tx = false;
|
|
}
|
|
} else if (ret < 0) {
|
|
ret = reopenModem();
|
|
if (!ret)
|
|
break;
|
|
}
|
|
} else if (ret == STATE_UNKNOWN) {
|
|
bool ret = reopenModem();
|
|
if (!ret)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
unsigned long ms = stopWatch.Time();
|
|
|
|
// Don't sleep when reading from the modem
|
|
if (!rx) {
|
|
if (ms < CYCLE_TIME)
|
|
Sleep(CYCLE_TIME - ms);
|
|
|
|
ms = stopWatch.Time();
|
|
}
|
|
|
|
// Catch up with the clock
|
|
dataTimer.clock(ms);
|
|
hdrTimer.clock(ms);
|
|
}
|
|
|
|
wxLogMessage(wxT("Stopping GMSK Modem Controller thread"));
|
|
|
|
if (m_modem != NULL) {
|
|
m_modem->close();
|
|
delete m_modem;
|
|
}
|
|
|
|
delete[] writeBuffer;
|
|
delete[] readBuffer;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool CGMSKController::writeHeader(const CHeaderData& header)
|
|
{
|
|
bool ret = m_txData.hasSpace(RADIO_HEADER_LENGTH_BYTES);
|
|
if (!ret) {
|
|
wxLogWarning(wxT("No space to write the header"));
|
|
return false;
|
|
}
|
|
|
|
unsigned char buffer[50U];
|
|
|
|
::memset(buffer, ' ', RADIO_HEADER_LENGTH_BYTES - 2U);
|
|
|
|
buffer[0U] = header.getFlag1();
|
|
buffer[1U] = header.getFlag2();
|
|
buffer[2U] = header.getFlag3();
|
|
|
|
wxString rpt2 = header.getRptCall2();
|
|
for (unsigned int i = 0U; i < rpt2.Len() && i < LONG_CALLSIGN_LENGTH; i++)
|
|
buffer[i + 3U] = rpt2.GetChar(i);
|
|
|
|
wxString rpt1 = header.getRptCall1();
|
|
for (unsigned int i = 0U; i < rpt1.Len() && i < LONG_CALLSIGN_LENGTH; i++)
|
|
buffer[i + 11U] = rpt1.GetChar(i);
|
|
|
|
wxString your = header.getYourCall();
|
|
for (unsigned int i = 0U; i < your.Len() && i < LONG_CALLSIGN_LENGTH; i++)
|
|
buffer[i + 19U] = your.GetChar(i);
|
|
|
|
wxString my1 = header.getMyCall1();
|
|
for (unsigned int i = 0U; i < my1.Len() && i < LONG_CALLSIGN_LENGTH; i++)
|
|
buffer[i + 27U] = my1.GetChar(i);
|
|
|
|
wxString my2 = header.getMyCall2();
|
|
for (unsigned int i = 0U; i < my2.Len() && i < SHORT_CALLSIGN_LENGTH; i++)
|
|
buffer[i + 35U] = my2.GetChar(i);
|
|
|
|
wxMutexLocker locker(m_mutex);
|
|
|
|
unsigned char data[2U];
|
|
data[0U] = DSMTT_HEADER;
|
|
data[1U] = RADIO_HEADER_LENGTH_BYTES - 2U;
|
|
m_txData.addData(data, 2U);
|
|
|
|
m_txData.addData(buffer, RADIO_HEADER_LENGTH_BYTES - 2U);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CGMSKController::writeData(const unsigned char* data, unsigned int, bool end)
|
|
{
|
|
bool ret = m_txData.hasSpace(DV_FRAME_LENGTH_BYTES + 2U);
|
|
if (!ret) {
|
|
wxLogWarning(wxT("No space to write data"));
|
|
return false;
|
|
}
|
|
|
|
wxMutexLocker locker(m_mutex);
|
|
|
|
unsigned char buffer[2U];
|
|
buffer[0U] = end ? DSMTT_EOT : DSMTT_DATA;
|
|
buffer[1U] = DV_FRAME_LENGTH_BYTES;
|
|
m_txData.addData(buffer, 2U);
|
|
|
|
m_txData.addData(data, DV_FRAME_LENGTH_BYTES);
|
|
|
|
return true;
|
|
}
|
|
|
|
unsigned int CGMSKController::getSpace()
|
|
{
|
|
return m_txData.freeSpace() / (DV_FRAME_LENGTH_BYTES + 2U);
|
|
}
|
|
|
|
bool CGMSKController::isTXReady()
|
|
{
|
|
if (m_tx)
|
|
return false;
|
|
|
|
return m_txData.isEmpty();
|
|
}
|
|
|
|
bool CGMSKController::reopenModem()
|
|
{
|
|
wxLogMessage(wxT("Connection to the GMSK modem has been lost"));
|
|
|
|
m_modem->close();
|
|
|
|
while (!m_stopped) {
|
|
bool ret = m_modem->open();
|
|
if (ret)
|
|
return true;
|
|
|
|
// Reset the drivers state
|
|
m_mutex.Lock();
|
|
m_txData.clear();
|
|
m_mutex.Unlock();
|
|
|
|
m_tx = false;
|
|
|
|
Sleep(1000UL);
|
|
}
|
|
|
|
delete m_modem;
|
|
m_modem = NULL;
|
|
|
|
return false;
|
|
|
|
}
|