333 lines
8.2 KiB
C++
333 lines
8.2 KiB
C++
//======================================================================
|
|
// rig.h
|
|
//======================================================================
|
|
|
|
#ifndef __rig_h__
|
|
#define __rig_h__
|
|
|
|
#include <iopcomm.h>
|
|
#include "audio.h"
|
|
#include "RigMode.h"
|
|
//#include "menu.h"
|
|
|
|
//======================================================================
|
|
// Rig class
|
|
//======================================================================
|
|
|
|
const char * const modeID[] = {"s", "S", "c", "C", "d", "D", "t", "T"};
|
|
|
|
class Rig {
|
|
public:
|
|
|
|
//--------------------------------------------------------------------
|
|
// Constructor/destructor.
|
|
//--------------------------------------------------------------------
|
|
|
|
Rig(RigConfig& c, RigAudio& a): _config(c), _audio(a), _filter(RX_FILTER_WIDE)
|
|
{
|
|
_modes = new IMode*[c.numModes];
|
|
_modesLen = c.numModes;
|
|
_modesIndex = c.startMode;
|
|
/* _modes[RIG_MODE_LSB] = new SSBMode(c.lsb, a);
|
|
_modes[RIG_MODE_USB] = new SSBMode(c.usb, a);
|
|
_modes[RIG_MODE_CWL] = new CWMode(c.cwl, a);
|
|
_modes[RIG_MODE_CWU] = new CWMode(c.cwu, a);
|
|
_modes[RIG_MODE_DGL] = new DGTMode(c.dgl, a);
|
|
_modes[RIG_MODE_DGU] = new DGTMode(c.dgu, a);
|
|
_modes[RIG_MODE_TTL] = new TTMode(c.ttl, a);
|
|
_modes[RIG_MODE_TTU] = new TTMode(c.ttu, a);*/
|
|
/*
|
|
_rxFilters = new (IFilter*)[NUM_RX_FILTERS];
|
|
_rxFiltersLen = NUM_RX_FILTERS;
|
|
_rxFiltersIndex = 0; // need to get default filter from current mode...
|
|
_rxFilters[RX_FILTER_WIDE] = mode()->filterWide();
|
|
_rxFilters[RX_FILTER_MEDIUM] = mode()->filterMedium();
|
|
_rxFilters[RX_FILTER_NARROW] = mode()->filterNarrow();
|
|
*/
|
|
}
|
|
|
|
~Rig()
|
|
{
|
|
for (unsigned i = 0; i < _modesLen; i++) {
|
|
delete _modes[i];
|
|
}
|
|
delete _modes;
|
|
}
|
|
|
|
void init() {
|
|
switchRxFilter(_filter);
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// Mode control.
|
|
//--------------------------------------------------------------------
|
|
|
|
const char* modeText() {
|
|
strcpy(&_modeText[0], modeID[_modesIndex]);
|
|
strcpy(&_modeText[3], mode()->rxInfo());
|
|
strcpy(&_modeText[10], mode()->txInfo());
|
|
return _modeText;
|
|
}
|
|
|
|
inline bool isSSBMode() const { return (_modesIndex == RIG_MODE_USB || _modesIndex == RIG_MODE_LSB); }
|
|
inline bool isUSBMode() const { return (_modesIndex == RIG_MODE_USB); }
|
|
inline bool isLSBMode() const { return (_modesIndex == RIG_MODE_LSB); }
|
|
inline bool isDGTMode() const { return (_modesIndex == RIG_MODE_DGU || _modesIndex == RIG_MODE_DGL); }
|
|
inline bool isDGUMode() const { return (_modesIndex == RIG_MODE_DGU); }
|
|
inline bool isDGLMode() const { return (_modesIndex == RIG_MODE_DGL); }
|
|
inline bool isCWMode() const { return (_modesIndex == RIG_MODE_CWU || _modesIndex == RIG_MODE_CWL); }
|
|
inline bool isCWUMode() const { return (_modesIndex == RIG_MODE_CWU); }
|
|
inline bool isCWLMode() const { return (_modesIndex == RIG_MODE_CWL); }
|
|
inline bool isTTMode() const { return (_modesIndex == RIG_MODE_TTU || _modesIndex == RIG_MODE_TTL); }
|
|
inline bool isTTUMode() const { return (_modesIndex == RIG_MODE_TTU); }
|
|
inline bool isTTLMode() const { return (_modesIndex == RIG_MODE_TTL); }
|
|
|
|
// Assign a pointer to a mode object. Returns true if successful, false otherwise.
|
|
bool addNewMode(RigMode i, IMode* mode) {
|
|
if (i > _modesLen) {
|
|
return false;
|
|
} else {
|
|
_modes[i] = mode;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Returns a pointer to the current mode.
|
|
inline IMode* mode() const {
|
|
return _modes[_modesIndex];
|
|
}
|
|
|
|
// Returns the array index of the current mode.
|
|
inline RigMode modeNum() const {
|
|
return _modesIndex;
|
|
}
|
|
|
|
/* // Returns a pointer to the specified mode.
|
|
inline IMode* mode(RigMode m) const {
|
|
return _modes[m];
|
|
}*/
|
|
|
|
// Switch to the mode specified by the provided index. Returns a
|
|
// pointer to the new mode.
|
|
IMode* switchMode(RigMode i) {
|
|
// exit the previous mode
|
|
mode()->exit(); // NOTE: This could currently occur during TX, which is NOT desirable.
|
|
|
|
// select the new mode
|
|
_modesIndex = RigMode(i % _modesLen);
|
|
|
|
//enter the new mode
|
|
mode()->enter();
|
|
|
|
// return a pointer to the new mode
|
|
return mode();
|
|
}
|
|
|
|
// Advance to the next (or previous) mode. Returns a pointer to the
|
|
// new mode.
|
|
IMode* switchMode(bool prev=false) {
|
|
|
|
// exit the previous mode
|
|
mode()->exit();
|
|
|
|
// select the new mode
|
|
if (prev) {
|
|
_modesIndex = RigMode((_modesIndex > 0 ? _modesIndex - 1 : _modesLen - 1));
|
|
} else {
|
|
_modesIndex = RigMode((_modesIndex + 1) % _modesLen);
|
|
}
|
|
|
|
// enter the new mode
|
|
mode()->enter();
|
|
|
|
// return a pointer to the new mode
|
|
return mode();
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// Transmit/Receive (T/R) control.
|
|
//--------------------------------------------------------------------
|
|
|
|
inline bool isTx() const { return mode()->isTx(); }
|
|
inline bool isRx() const { return mode()->isRx(); }
|
|
|
|
// Enter the transmit state. This is delegated to the mode.
|
|
inline void tx() { mode()->tx(); }
|
|
|
|
// Enter the receive state. This is delegated to the mode.
|
|
inline void rx() { mode()->rx(); }
|
|
|
|
//--------------------------------------------------------------------
|
|
// Transmit processor control.
|
|
//--------------------------------------------------------------------
|
|
|
|
void switchProcessor(bool prev=false) {
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// RX filter control.
|
|
//--------------------------------------------------------------------
|
|
|
|
inline void setWideRxFilter() {
|
|
_filter = RX_FILTER_WIDE;
|
|
mode()->setWideRxFilter();
|
|
}
|
|
|
|
inline void setMediumRxFilter() {
|
|
_filter = RX_FILTER_MEDIUM;
|
|
mode()->setMediumRxFilter();
|
|
}
|
|
|
|
inline void setNarrowRxFilter() {
|
|
_filter = RX_FILTER_NARROW;
|
|
mode()->setNarrowRxFilter();
|
|
}
|
|
|
|
void switchRxFilter(RxFilter i) {
|
|
switch(i) {
|
|
case RX_FILTER_WIDE:
|
|
setWideRxFilter();
|
|
break;
|
|
|
|
case RX_FILTER_MEDIUM:
|
|
setMediumRxFilter();
|
|
break;
|
|
|
|
case RX_FILTER_NARROW:
|
|
setNarrowRxFilter();
|
|
break;
|
|
}
|
|
}
|
|
|
|
void switchRxFilter(bool prev=false) {
|
|
if (prev) {
|
|
_filter = RxFilter((_filter - 1) % NUM_RX_FILTERS);
|
|
} else {
|
|
_filter = RxFilter((_filter + 1) % NUM_RX_FILTERS);
|
|
}
|
|
}
|
|
|
|
/*
|
|
// Returns a pointer to the current RX filter.
|
|
IFilter* rxFilter() {
|
|
return _rxFilters[_rxFiltersIndex];
|
|
}
|
|
|
|
IFilter* switchRxFilter(bool prev=false) {
|
|
if (prev) {
|
|
_rxFiltersIndex--;
|
|
} else {
|
|
_rxFiltersIndex++;
|
|
}
|
|
_rxFiltersIndex %= _rxFiltersLen;
|
|
return _rxFiltersList[_rxFiltersIndex];
|
|
}
|
|
|
|
IFilter* switchRxFilterWide() {
|
|
}
|
|
|
|
IFilter* switchFilterMedium() {
|
|
|
|
}
|
|
|
|
IFilter* switchFilterNarrow() {
|
|
|
|
}
|
|
*/
|
|
// Audio output control.
|
|
|
|
inline void muteSpkrOut() const {
|
|
_audio.muteSpkrOut();
|
|
}
|
|
|
|
inline void unmuteSpkrOut() const {
|
|
_audio.unmuteSpkrOut();
|
|
}
|
|
|
|
inline void muteLineOut() const {
|
|
_audio.muteLineOut();
|
|
}
|
|
|
|
inline void unmuteLineOut() const {
|
|
_audio.unmuteLineOut();
|
|
}
|
|
|
|
inline void muteUSBOut() const {
|
|
_audio.muteUSBOut();
|
|
}
|
|
|
|
inline void unmuteUSBOut() const {
|
|
_audio.unmuteUSBOut();
|
|
}
|
|
|
|
// Audio input control.
|
|
|
|
inline void muteAllTx() const {
|
|
_audio.muteAllTx();
|
|
}
|
|
|
|
inline void muteMicIn() const {
|
|
_audio.muteMicIn();
|
|
}
|
|
|
|
inline void unmuteMicIn() const {
|
|
_audio.unmuteMicIn();
|
|
}
|
|
|
|
inline void muteLineIn() const {
|
|
_audio.muteLineIn();
|
|
}
|
|
|
|
inline void unmuteLineIn() const {
|
|
_audio.unmuteLineIn();
|
|
}
|
|
|
|
inline void muteUSBIn() const {
|
|
_audio.muteUSBIn();
|
|
}
|
|
|
|
inline void unmuteUSBIn() const {
|
|
_audio.unmuteUSBOut();
|
|
}
|
|
|
|
inline void muteTTIn() const {
|
|
_audio.muteTTIn();
|
|
}
|
|
|
|
inline void unmuteTTIn() const {
|
|
_audio.unmuteTTIn();
|
|
}
|
|
|
|
// Update the rig state. This should be called once each time through
|
|
// the main loop.
|
|
void update()
|
|
{
|
|
}
|
|
|
|
private:
|
|
|
|
RigConfig& _config;
|
|
RigAudio& _audio;
|
|
|
|
IMode** _modes;
|
|
RigMode _modesLen;
|
|
RigMode _modesIndex;
|
|
|
|
RxFilter _filter;
|
|
|
|
char _modeText[17];
|
|
|
|
/*
|
|
IFilter** _rxFilters;
|
|
uint8_t _rxFiltersLen;
|
|
uint8_t _rxFiltersIndex;
|
|
*/
|
|
};
|
|
|
|
#endif
|
|
|
|
//======================================================================
|
|
// EOF
|
|
//======================================================================
|