ubitx-v5x/TeensyDSP/TS590.cpp

409 lines
9.7 KiB
C++

#include <Arduino.h>
#include "TS590.h"
#include "Debug.h"
/**********************************************************************/
/*!
* @brief Send a command to the PC via CAT. Note that the command
* should not include the trailing terminator (;). That will
* be automatically added.
* @param format
* A printf-style format string.
* @param args
* Zero or more arguments to include in the command.
*/
void ts590SendCommand(const char* format, ...) {
static char outBuf[ts590CommandMaxLength];
va_list args;
va_start(args, format);
vsprintf(outBuf, format, args);
va_end(args);
Serial.print(outBuf);
Serial.print(";");
}
/**********************************************************************/
/*!
* @brief Create a new CAT command. It should be initialized with
* a 2-character command prefix.
* @param pre
* A 2-character command prefix. If more than 2 characters
* are supplied, only the first two will be used. If less
* than two are supplied, then the command will be
* initialized with a null prefix.
*/
TS590Command::TS590Command(const char* pre) {
if (strlen(pre) >= 2) {
myPrefix[0] = pre[0];
myPrefix[1] = pre[1];
}
}
TS590Command::~TS590Command() {}
/*!
* @brief Determine whether this is a Read command or not. by
* default, if it's a 2-letter command, it's a Read.
* @return True if a Read command; false otherwise.
*/
bool TS590Command::isReadCommand(const char* cmd) const {
if (strlen(cmd) == 2) {
return true;
} else {
return false;
}
}
/*!
* @brief Process the provided command. If the command is a Set
* command, it calls handleCommand(). If Auto Information
* is eet (by the rig), sendResponse() is called at the end.
* If the command is a Read command, it also calls
* sendResponse(). Finally, if necessary, it will return
* any error codes to the PC.
* @param cmd
* The current command string received from the PC via CAT.
* It should be null-terminated, and should no longer have
* the terminator (;).
*/
void TS590Command::process(const char* cmd) {
theError = NoError;
if (isReadCommand(cmd)) {
DBGCMD( sendResponse(cmd) );
} else {
DBGCMD( handleCommand(cmd) );
switch(theError) {
case NoError:
if (theRig->isAI()) {
DBGCMD( sendResponse(cmd) );
}
break;
case SyntaxError:
DBGCMD( ts590SyntaxError() );
break;
case CommError:
DBGCMD( ts590CommError() );
break;
case ProcessError:
DBGCMD( ts590ProcessError() );
break;
}
}
}
/*!
* @brief Set the syntax error flag. This is cleared at the
* beginning of each call to process().
*/
void TS590Command::setSyntaxError() {
theError = SyntaxError;
}
/*!
* @brief Set the comms error flag. This is cleared at the
* beginning of each call to process().
*/
void TS590Command::setCommError() {
theError = CommError;
}
/*!
* @brief Set the process error flag. This is cleared at the
* beginning of each call to process().
*/
void TS590Command::setProcessError() {
theError = ProcessError;
}
/*!
* @brief Set the rig that will be used to process commands.
* @param r
* Pointer to the UBitxRig object.
*/
void TS590Command::setRig(UBitxRig* r) {
theRig = r;
}
/*!
* @brief Set the DSP that will be used to process commands.
* @param d
* Pointer to the UBitxDSP object.
*/
void TS590Command::setDSP(UBitxDSP* d) {
theDSP = d;
}
UBitxRig* TS590Command::theRig = &Rig;
UBitxDSP* TS590Command::theDSP = &DSP;
TS590Error TS590Command::theError = NoError;
/**********************************************************************/
void TS590_FR::handleCommand(const char* cmd) {
if (strlen(cmd) == 3) {
switch (cmd[2]) {
case '0':
rig()->setVFOA();
rig()->setSplitOff();
break;
case '1':
rig()->setVFOB();
rig()->setSplitOff();
break;
case '2':
// TODO: Need to add something for channel mode.
break;
default:
setSyntaxError();
}
} else {
setSyntaxError();
}
}
void TS590_FR::sendResponse(const char* cmd) {
if (rig()->isVFOA()) {
ts590SendCommand("FR0");
} else if (rig()->isVFOB()) {
ts590SendCommand("FR1");
} else {
ts590SendCommand("FR2");
}
}
/**********************************************************************/
void TS590_FT::handleCommand(const char* cmd) {
if (strlen(cmd) == 3) {
switch (cmd[2]) {
case '0':
if (rig()->isVFOA()) {
rig()->setSplitOff();
} else if (rig()->isVFOB()) {
rig()->setSplitOn();
} else {
setSyntaxError();
}
break;
case '1':
if (rig()->isVFOA()) {
rig()->setSplitOn();
} else if (rig()->isVFOB()) {
rig()->setSplitOff();
} else {
setSyntaxError();
}
break;
default:
setSyntaxError();
}
} else {
setSyntaxError();
}
}
void TS590_FT::sendResponse(const char* cmd) {
if (rig()->isVFOA()) {
ts590SendCommand(rig()->isSplit() ? "FT1" : "FT0");
} else if (rig()->isVFOB()) {
ts590SendCommand(rig()->isSplit() ? "FT0" : "FT1");
} else {
ts590SendCommand("FT2");
}
}
/**********************************************************************/
void TS590_MD::handleCommand(const char* cmd) {
if (strlen(cmd) == 3) {
switch (cmd[2]) {
case '0': // None (setting failure)
case '4': // FM - not supported
case '5': // AM - not supported
case '6': // FSK - not supported
case '8': // None (setting failure)
case '9': // FSK-R - not supported
setProcessError();
break;
case '1': // LSB
rig()->setLSB();
break;
case '2': // USB
rig()->setUSB();
break;
case '3': // CW
rig()->setCW();
break;
case '7': // CW-R
rig()->setCWR();
break;
default:
setSyntaxError();
}
} else {
setSyntaxError();
}
}
void TS590_MD::sendResponse(const char* cmd) {
if (rig()->isModeCW()) {
ts590SendCommand("MD3");
} else if (rig()->isModeCWR()) {
ts590SendCommand("MD7");
} else if (rig()->isModeUSB()) {
ts590SendCommand("MD2");
} else if (rig()->isModeLSB()) {
ts590SendCommand("MD1");
} else {
ts590SendCommand("MD0");
}
}
/**********************************************************************/
int ssbHiCut[14] = {1000, 1200, 1400, 1600, 1800, 2000, 2200, 2400, 2600, 2800, 3000, 3400, 4000, 5000};
int ssbLoCut[12] = {0, 50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};
int ssbWidth[14] = {50, 80, 100, 150, 200, 250, 300, 400, 500, 600, 1000, 1500, 2000, 2500};
int ssbCenter[14] = {1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700, 1750, 1800, 1900, 2000, 2100, 2210};
void TS590_SH::handleCommand(const char* cmd) {
if (strlen(cmd) == 4) {
index = strtoul(&cmd[2], NULL, 10);
if (index < sizeof(ssbHiCut) / sizeof(ssbHiCut[0])) {
dsp()->setRxFilterHi(ssbHiCut[index]);
} else {
setSyntaxError();
}
} else {
setSyntaxError();
}
}
void TS590_SH::sendResponse(const char* cmd) {
ts590SendCommand("SH%02u", index);
}
void TS590_SL::handleCommand(const char* cmd) {
if (strlen(cmd) == 4) {
index = strtoul(&cmd[2], NULL, 10);
if (index < sizeof(ssbLoCut) / sizeof(ssbLoCut[0])) {
dsp()->setRxFilterLo(ssbLoCut[index]);
} else {
setSyntaxError();
}
} else {
setSyntaxError();
}
}
void TS590_SL::sendResponse(const char* cmd) {
ts590SendCommand("SL%02u", index);
}
/**********************************************************************/
TS590_FA cmdFA;
TS590_FB cmdFB;
TS590_FR cmdFR;
TS590_FT cmdFT;
TS590_MD cmdMD;
TS590_SH cmdSH;
TS590_SL cmdSL;
TS590Command* catCommands[] = {
&cmdFA,
&cmdFB,
&cmdFR,
&cmdFT,
&cmdMD,
&cmdSH,
&cmdSL
};
int numCatCommands = sizeof(catCommands) / sizeof(catCommands[0]);
/**********************************************************************/
void UBitxTS590::begin() {
Serial.begin(9600); // USB is always 12 Mbit/sec
#ifdef DEBUG
delay(500);
Serial.print("DBG: Number of CAT commands: ");
Serial.println(numCommands);
for (int i = 0; i < numCommands; i++) {
Serial.print(" ");
Serial.println(commands[i]->prefix());
}
#endif
}
void UBitxTS590::update() {
char incomingChar;
while (Serial.available()) {
if (bufLen < ts590CommandMaxLength) {
incomingChar = Serial.read();
if (incomingChar == ';') {
buf[bufLen++] = '\0';
strupr(buf);
processCommand();
} else if (incomingChar == '\n' && bufLen == 0) {
;
} else {
buf[bufLen++] = incomingChar;
}
} else {
// too long... we're going to bail on this.
ts590SyntaxError();
bufLen = 0;
}
}
}
typedef class TS590Command* PCmd;
int compareCATCommands(const void* a, const void* b) {
TS590Command const *B = *(TS590Command const **)b;
int cmp = strncmp((char*)a, (char*)B->prefix(), 2);
#ifdef DEBUG
Serial.print("Comparison: ");
Serial.print((char*)a);
Serial.print(" ? ");
Serial.print((char*)B->prefix());
Serial.print(" --> ");
Serial.println(cmp);
#endif
return cmp;
}
void UBitxTS590::processCommand() {
TS590Command** cmd = (TS590Command**)bsearch(buf, commands, numCommands, sizeof(TS590Command*), compareCATCommands);
if (cmd == NULL) {
ts590SyntaxError();
} else {
(*cmd)->process(buf);
}
bufLen = 0;
}
UBitxTS590 TS590(catCommands, numCatCommands);
/**********************************************************************/