Updates to RigState.
This commit is contained in:
Rob French
parent
f3887e7950
commit
1bca18c3e1
@ -18,7 +18,7 @@ const PROGMEM uint8_t meters_bitmap[] = {
|
||||
};
|
||||
*/
|
||||
|
||||
#include "RigState.h"
|
||||
//#include "RigState.h"
|
||||
|
||||
//SWR GRAPH, DrawMeter and drawingMeter Logic function by VK2ETA
|
||||
|
||||
|
||||
@ -5,6 +5,8 @@
|
||||
|
||||
#ifndef TEENSYDUINO
|
||||
|
||||
#include "ubitx_eemap.h"
|
||||
|
||||
extern unsigned long frequency;
|
||||
extern unsigned long vfoA;
|
||||
extern unsigned long vfoB;
|
||||
@ -15,123 +17,46 @@ extern char ritOn;
|
||||
extern char splitOn;
|
||||
void setFrequency(unsigned long);
|
||||
|
||||
#endif
|
||||
|
||||
/**********************************************************************/
|
||||
// Raduino functors - used to read/write from Raduino state
|
||||
|
||||
#ifndef TEENSYDUINO
|
||||
|
||||
struct readNone {
|
||||
bool operator()(uint32_t* d) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
struct writeNone {
|
||||
void operator()(uint32_t d) {
|
||||
}
|
||||
}
|
||||
|
||||
struct readVFOA {
|
||||
bool operator()(uint32_t* d) {
|
||||
unsigned freq = (vfoActive == VFO_A) ? frequency : vfoA;
|
||||
if (*d == freq) {
|
||||
return false;
|
||||
} else {
|
||||
*d = freq;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct writeVFOA {
|
||||
void operator()(uint32_t d) {
|
||||
/*!
|
||||
* @brief Write dirty fields from the provided rig state, out to the
|
||||
* Raduino variables.
|
||||
* @param r
|
||||
* Reference to a RigState object that will be used to update
|
||||
* the Raduino variables.
|
||||
*/
|
||||
void writeDirty(const RigState& r) {
|
||||
// VFO A frequency
|
||||
if (r.isDirty(VFOA_WORD)) {
|
||||
if (vfoActive == VFO_A) {
|
||||
setFrequency(d);
|
||||
setFrequency(r.getFreqA());
|
||||
} else {
|
||||
vfoA = frequency;
|
||||
vfoA = r.getFreqA();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct readVFOB {
|
||||
bool operator()(uint32_t* d) {
|
||||
unsigned freq = (vfoActive == VFO_B) ? frequency : vfoB;
|
||||
if (*d == freq) {
|
||||
return false
|
||||
} else {
|
||||
*d = freq;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct writeVFOB {
|
||||
void operator()(uint32_t d) {
|
||||
// VFO B frequency
|
||||
if (r.isDirty(VFOB_WORD)) {
|
||||
if (vfoActive == VFO_B) {
|
||||
setFrequency(d);
|
||||
setFrequency(r.getFreqB());
|
||||
} else {
|
||||
vfoB = frequency;
|
||||
vfoB = r.getFreqB();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct readRIT {
|
||||
bool operator()(uint32_t* d) {
|
||||
int freq = ritRxFrequency - frequency;
|
||||
if (*d == (uint32_t)freq) {
|
||||
return false;
|
||||
} else {
|
||||
*d = (uint32_t)freq;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct writeRIT {
|
||||
void operator()(uint32_t d) {
|
||||
ritRxFrequency = (int)d + ritTxFrequency;
|
||||
// RIT and XIT frequencies
|
||||
if (r.isDirty(OFFSETS_WORD)) {
|
||||
// RIT
|
||||
ritRxFrequency = r.getRIT() + ritTxFrequency;
|
||||
if ((ritOn == 1) && (inTx == 0)) {
|
||||
setFrequency(ritRxFrequency);
|
||||
}
|
||||
// XIT - TODO
|
||||
}
|
||||
};
|
||||
|
||||
struct readXIT {
|
||||
bool operator()(uint32_t* d) {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
struct writeXIT {
|
||||
void operator()(uint32_t d) {
|
||||
}
|
||||
};
|
||||
|
||||
struct readFlags {
|
||||
bool operator()(uint32_t* d) {
|
||||
uint32_t flags = 0
|
||||
flags = 0;
|
||||
flags |= (vfoActive == VFO_B ? UBITX_VFOB_FLAG : 0);
|
||||
flags |= (cwMode != 0 ? UBITX_CW_FLAG : 0);
|
||||
flags |= (isUSB != 0 ? UBITX_USB_FLAG : 0);
|
||||
flags |= (splitOn != 0 ? UBITX_SPLIT_FLAG : 0);
|
||||
flags |= (ritOn != 0 ? UBITX_RIT_FLAG : 0);
|
||||
//flags |= (xitOn != 0 ? UBITX_XIT_FLAG : 0);
|
||||
if (*d == flags) {
|
||||
return false;
|
||||
} else {
|
||||
*d = flags;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct writeFlags {
|
||||
void operator()(uint32_t d) {
|
||||
// VFO A/B selection
|
||||
if (r.isDirty(FLAGS_WORD)) {
|
||||
char prev = vfoActive;
|
||||
vfoActive = (d & UBITX_VFOB_FLAG ? VFO_B : VFO_A);
|
||||
vfoActive = r.isVFOA() ? VFO_A : VFO_B;
|
||||
if (vfoActive != prev) {
|
||||
if (vfoActive == VFO_A) {
|
||||
if (vfoA != frequency) {
|
||||
@ -144,28 +69,128 @@ struct writeFlags {
|
||||
}
|
||||
}
|
||||
|
||||
splitOn = d & UBITX_SPLIT_FLAG ? 1 : 0;
|
||||
// Split on/off
|
||||
splitOn = r.isSplit() ? 1 : 0;
|
||||
|
||||
// RIT on/off
|
||||
prev = ritOn;
|
||||
ritOn = d & UBITX_RIT_FLAG ? 1 : 0;
|
||||
ritOn = r.isRIT() ? 1 : 0;
|
||||
if (ritOn != prev) {
|
||||
if ((ritOn == 1) && (inTx == 0)) {
|
||||
setFrequency(ritRxFrequency);
|
||||
}
|
||||
}
|
||||
|
||||
char prev = (cwMode << 1) | isUSB;
|
||||
isUSB = d.flags & UBITX_USB_FLAG ? 1 : 0;
|
||||
if (d.flags & UBITX_CW_FLAG) {
|
||||
cwMode = isUSB ? 2 : 1; // 2 = cwu / 1 = cwl
|
||||
// XIT on/off
|
||||
// TODO
|
||||
|
||||
// Mode
|
||||
prev = (cwMode << 1) | isUSB;
|
||||
isUSB = r.isUSB() ? 1 : 0;
|
||||
if (r.isCW()) {
|
||||
cwMode = 2; // 2 = cwu
|
||||
} else if (r.isCWR()) {
|
||||
cwMode = 1; // 1 = cwl
|
||||
} else {
|
||||
cwMode = 0;
|
||||
cwMode = 0; // 0 = no cw
|
||||
}
|
||||
if ((cwMode << 1) | isUSB != prev) {
|
||||
setFrequency(frequency);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief Read current Raduino variables into the provided RigState
|
||||
* (if they are dirty) and set the appropriate dirty flags.
|
||||
* @param r
|
||||
* RigState reference to put the values into.
|
||||
*/
|
||||
void readDirty(RigState& r) {
|
||||
unsigned freq;
|
||||
short offset;
|
||||
|
||||
// VFO A frequency
|
||||
freq = (vfoActive == VFO_A) ? frequency : vfoA;
|
||||
if (r.getFreqA() != freq) {
|
||||
r.setFreqA(freq);
|
||||
r.setDirty(VFOA_WORD);
|
||||
}
|
||||
|
||||
// VFO B frequency
|
||||
freq = (vfoActive == VFO_B) ? frequency : vfoB;
|
||||
if (r.getFreqB() != freq) {
|
||||
r.setFreqB(freq);
|
||||
r.setDirty(VFOB_WORD);
|
||||
}
|
||||
|
||||
// RIT frequency
|
||||
offset = ritRxFrequency - frequency;
|
||||
if (r.getRIT() != offset) {
|
||||
r.setRIT(offset);
|
||||
r.setDirty(OFFSETS_WORD);
|
||||
}
|
||||
|
||||
// XIT frequency
|
||||
offset = 0; // xitRxFrequency - frequency;
|
||||
if (r.getXIT() != offset) {
|
||||
r.setXIT(offset);
|
||||
r.setDirty(OFFSETS_WORD);
|
||||
}
|
||||
|
||||
bool dirty = false;
|
||||
|
||||
// VFO A/B selection
|
||||
if (r.isVFOA() && vfoActive == VFO_B) {
|
||||
r.setVFOB();
|
||||
dirty = true;
|
||||
} else if (r.isVFOB() && vfoActive == VFO_A) {
|
||||
r.setVFOA();
|
||||
dirty = true;
|
||||
}
|
||||
|
||||
// Split selection
|
||||
if (r.isSplit() && splitOn == 0) {
|
||||
r.setSplitOff();
|
||||
dirty = true;
|
||||
} else if (!r.isSplit() && splitOn != 0) {
|
||||
r.setSplitOn();
|
||||
dirty = true;
|
||||
}
|
||||
|
||||
// RIT selection
|
||||
if (r.isRIT() && ritOn == 0) {
|
||||
r.setRITOff();
|
||||
dirty = true;
|
||||
} else if (!r.isRIT() && ritOn != 0) {
|
||||
r.setRITOn();
|
||||
dirty = true;
|
||||
}
|
||||
|
||||
// XIT selection
|
||||
r.setXITOff();
|
||||
// TODO
|
||||
|
||||
// Mode
|
||||
char prev = (r.isCW() ? 4 : 0) | (r.isCWR() ? 2 : 0) | (r.isUSB() ? 1 : 0);
|
||||
char curr = (cwMode << 1) | isUSB;
|
||||
if (curr != prev) {
|
||||
if (cwMode == 2) {
|
||||
r.setCW();
|
||||
} else if (cwMode == 1) {
|
||||
r.setCWR();
|
||||
} else {
|
||||
if (isUSB) {
|
||||
r.setUSB();
|
||||
} else {
|
||||
r.setLSB();
|
||||
}
|
||||
}
|
||||
dirty = true;
|
||||
}
|
||||
|
||||
if (dirty) r.setDirty(FLAGS_WORD);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -197,29 +222,17 @@ void RigState::begin() {
|
||||
}
|
||||
}
|
||||
|
||||
void RigState::update() {
|
||||
// First we need to determine which fields have changed (and are
|
||||
// thus dirty and need to be sent to the TeensyDSP).
|
||||
for (byte i = 0; i < numFields; i++) {
|
||||
if (read(i)) {
|
||||
makeDirty(i);
|
||||
}
|
||||
}
|
||||
|
||||
// Next we need to send the current (changed) Raduino information
|
||||
// to the TeensyDSP.
|
||||
void updateRaduinoState(RigState& r) {
|
||||
writeDirty(r);
|
||||
Wire.beginTransmission(I2CMETER_ADDR);
|
||||
Wire.write(I2CMETER_RIGINF);
|
||||
for (byte i = 0; i < numFields; i++) {
|
||||
if (isDirty(i)) { // Write each field that is dirty to the bus.
|
||||
Wire.write(i); // - write the field number/ID
|
||||
Wire.write(data(i), dataSize(i)); // - write the field data
|
||||
makeClean(i);
|
||||
}
|
||||
for (RigStateWord i = 0; i < NUM_WORDS; i++) {
|
||||
Wire.write((byte*)&r.data, sizeof(r.data)); // - write the field data
|
||||
r.setClean(i);
|
||||
}
|
||||
Wire.endTransmission();
|
||||
|
||||
delay(1); // some delay required between ending transmission and requesting?
|
||||
delay(1); // 1ms - some delay required between ending transmission and requesting?
|
||||
|
||||
// Retrieve all of the deltas. Mark any received field as dirty.
|
||||
Wire.requestFrom(I2CMETER_ADDR, numBytes);
|
||||
|
||||
@ -3,12 +3,6 @@
|
||||
|
||||
#include <Arduino.h>
|
||||
|
||||
#define UBITX_VFOA_UPDATE 0x00000001
|
||||
#define UBITX_VFOB_UPDATE 0x00000002
|
||||
#define UBITX_RIT_UPDATE 0x00000004
|
||||
#define UBITX_XIT_UPDATE 0x00000008
|
||||
#define UBITX_FLAGS_UPDATE 0x00000010
|
||||
|
||||
#define UBITX_VFOB_FLAG 0x00000001
|
||||
#define UBITX_SPLIT_FLAG 0x00000002
|
||||
#define UBITX_RIT_FLAG 0x00000004
|
||||
@ -17,14 +11,68 @@
|
||||
#define UBITX_USB_FLAG 0x00000020
|
||||
#define UBITX_TX_FLAG 0x00000040
|
||||
|
||||
struct UBitxRigState {
|
||||
uint32_t header = 0;
|
||||
uint32_t vfo[2];
|
||||
int32_t rit;
|
||||
int32_t xit;
|
||||
uint32_t flags = 0;
|
||||
enum RigStateWord {
|
||||
DIRTY_WORD = 0,
|
||||
VFOA_WORD,
|
||||
VFOB_WORD,
|
||||
OFFSETS_WORD,
|
||||
FLAGS_WORD,
|
||||
NUM_WORDS
|
||||
};
|
||||
|
||||
struct UBitxRigState {
|
||||
uint32_t data[RigStateWord.NUM_WORDS] = {0};
|
||||
|
||||
/*!
|
||||
* @brief Set the dirty bit for for the specified word.
|
||||
*/
|
||||
inline void setDirty(RigStateWord w) {
|
||||
data[i] |= w < NUM_WORDS ? 1 << w : 0;
|
||||
}
|
||||
|
||||
inline void setClean(RigStateWord w) {
|
||||
data[i] &= ~(w < NUM_WORDS ? 1 << w : 0);
|
||||
}
|
||||
|
||||
inline bool isDirty(RigStateWord w) {
|
||||
return (1 << w) & data[DIRTY_WORD] > 0 ? true : false;
|
||||
}
|
||||
|
||||
inline void setFreqA(uint32_t freq) { data[VFOA_WORD] = freq; }
|
||||
inline uint32_t getFreqA() const { return data[VFOA_WORD]; }
|
||||
inline void getFreqB(uint32_r freq) { data[VFOB_WORD] = freq; }
|
||||
inline uint32_t getFreqB() const { return data[VFOB_WORD]; }
|
||||
inline void setRIT(int16_t offset) { data[OFFSETS_WORD] = (offset << 16) | (0x0000FFFF & data[OFFSETS_WORD]); }
|
||||
inline int16_t getRIT() const { return data[OFFSETS_WORD] >> 16; }
|
||||
inline void setXIT(int16_t offset) { data[OFFSETS_WORD] = (0xFFFF0000 & data[OFFSETS_WORD]) | offset;
|
||||
inline int16_t getXIT() const { return 0x0000FFFF & data[OFFSETS_WORD]; }
|
||||
inline void setVFOA() { data[FLAGS_WORD] &= ~UBITX_VFOB_FLAG; }
|
||||
inline void setVFOB() { data[FLAGS_WORD] |= UBITX_VFOB_FLAG; }
|
||||
inline bool isVFOA() const { return data[FLAGS_WORD] & UBITX_VFOB_FLAG ? false : true; }
|
||||
inline bool isVFOB() const { return data[FLAGS_WORD] & UBITX_VFOB_FLAG ? true : false; }
|
||||
inline void setSplitOn() { data[FLAGS_WORD] |= UBITX_SPLIT_FLAG; }
|
||||
inline void setSplitOff() { data[FLAGS_WORD] &= ~UBITX_SPLIT_FLAG; }
|
||||
inline bool isSplit() const { data[FLAGS_WORD] & UBITX_SPLIT_FLAG ? true : false; }
|
||||
inline void setRITOn() { data[FLAGS_WORD] |= UBITX_RIT_FLAG; }
|
||||
inline void setRITOff() { data[FLAGS_WORD] &= ~UBITX_RIT_FLAG; }
|
||||
inline bool isRIT() const { data[FLAGS_WORD] & UBITX_RIT_FLAG ? true : false; }
|
||||
inline void setXITOn() { data[FLAGS_WORD] |= UBITX_XIT_FLAG; }
|
||||
inline void setXITOff() { data[FLAGS_WORD] &= ~UBITX_XIT_FLAG; }
|
||||
inline bool isXIT() const { data[FLAGS_WORD] & UBITX_XIT_FLAG ? true : false; }
|
||||
inline void setUSB() { data[FLAGS_WORD] |= UBITX_USB_FLAG; data[FLAGS_WORD] &= ~UBITX_CW_FLAG; }
|
||||
inline void setLSB() { data[FLAGS_WORD] &= ~UBITX_USB_FLAG; data[FLAGS_WORD] &= ~UBITX_CW_FLAG; }
|
||||
inline void setCW() { data[FLAGS_WORD] |= UBITX_USB_FLAG; data[FLAGS_WORD] |= UBITX_CW_FLAG; }
|
||||
inline void setCWR() { data[FLAGS_WORD] &= ~UBITX_USB_FLAG; data[FLAGS_WORD] |= UBITX_CW_FLAG; }
|
||||
inline bool isUSB() { return (data[FLAGS_WORD] & UBITX_USB_FLAG > 0) && (data[FLAGS_WORD] & UBITX_CW_FLAG == 0); }
|
||||
inline bool isLSB() { return (data[FLAGS_WORD] & UBITX_USB_FLAG == 0) && (data[FLAGS_WORD] & UBITX_CW_FLAG == 0); }
|
||||
inline bool isCW() { return (data[FLAGS_WORD] & UBITX_USB_FLAG > 0) && (data[FLAGS_WORD] & UBITX_CW_FLAG > 0); }
|
||||
inline bool isCWR() { return (data[FLAGS_WORD] & UBITX_USB_FLAG == 0) && (data[FLAGS_WORD] & UBITX_CW_FLAG > 0); }
|
||||
};
|
||||
|
||||
#ifndef TEENSYDUINO
|
||||
void mergeDirty(const RigState& r);
|
||||
#endif
|
||||
|
||||
/**********************************************************************/
|
||||
// NEW IMPLEMENTATION
|
||||
|
||||
@ -58,7 +106,6 @@ struct Field : public BaseField {
|
||||
virtual void write() const { W(data); }
|
||||
};
|
||||
|
||||
#define WIREBUS_NULL 0 // an empty field
|
||||
#define WIREBUS_VFO_A 1
|
||||
#define WIREBUS_VFO_B 2
|
||||
#define WIREBUS_RIT_OFS 3
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user