412 lines
15 KiB
C++
412 lines
15 KiB
C++
#include "SimulatorTransport.h"
|
|
|
|
#include <QStringList>
|
|
#include <QTimer>
|
|
|
|
using namespace Concept1;
|
|
|
|
SimulatorTransport::SimulatorTransport(QObject *parent)
|
|
: ITransport(parent)
|
|
{
|
|
}
|
|
|
|
bool SimulatorTransport::open()
|
|
{
|
|
m_open = true;
|
|
m_inBuf.clear();
|
|
emit openedChanged(true);
|
|
return true;
|
|
}
|
|
|
|
void SimulatorTransport::close()
|
|
{
|
|
if (m_open) {
|
|
m_open = false;
|
|
emit openedChanged(false);
|
|
}
|
|
}
|
|
|
|
bool SimulatorTransport::isOpen() const
|
|
{
|
|
return m_open;
|
|
}
|
|
|
|
QString SimulatorTransport::endpointName() const
|
|
{
|
|
return QStringLiteral("Simulator");
|
|
}
|
|
|
|
void SimulatorTransport::write(const QByteArray &data)
|
|
{
|
|
if (!m_open)
|
|
return;
|
|
m_inBuf.append(data);
|
|
// Split on CR; ignore LF entirely.
|
|
int idx;
|
|
while ((idx = m_inBuf.indexOf('\r')) >= 0) {
|
|
QByteArray lineBytes = m_inBuf.left(idx);
|
|
m_inBuf.remove(0, idx + 1);
|
|
QString line = QString::fromLatin1(lineBytes);
|
|
line.remove(QLatin1Char('\n'));
|
|
line = line.trimmed();
|
|
if (line.startsWith(QLatin1Char('>')))
|
|
line = line.mid(1).trimmed();
|
|
if (m_state.echo) {
|
|
// Echo back the received instruction (without re-framing header).
|
|
QString e = line;
|
|
e += QLatin1Char(kCr);
|
|
if (m_state.lineFeed) e += QLatin1Char(kLf);
|
|
const QByteArray bytes = e.toLatin1();
|
|
QTimer::singleShot(0, this, [this, bytes]() {
|
|
if (m_open) emit bytesReceived(bytes);
|
|
});
|
|
}
|
|
if (!line.isEmpty())
|
|
processInstruction(line);
|
|
}
|
|
emitQueued();
|
|
}
|
|
|
|
QString SimulatorTransport::frame(const QString &line) const
|
|
{
|
|
QString s;
|
|
if (m_state.header && !m_state.echo)
|
|
s += QLatin1Char('>');
|
|
s += line;
|
|
s += QLatin1Char(kCr);
|
|
if (m_state.lineFeed)
|
|
s += QLatin1Char(kLf);
|
|
return s;
|
|
}
|
|
|
|
void SimulatorTransport::reply(const QString &line)
|
|
{
|
|
m_outLines << line;
|
|
}
|
|
|
|
void SimulatorTransport::emitQueued()
|
|
{
|
|
if (m_outLines.isEmpty())
|
|
return;
|
|
QString out;
|
|
for (const QString &l : m_outLines)
|
|
out += frame(l);
|
|
m_outLines.clear();
|
|
const QByteArray bytes = out.toLatin1();
|
|
// Slight async delay mimics serial timing.
|
|
QTimer::singleShot(5, this, [this, bytes]() {
|
|
if (m_open)
|
|
emit bytesReceived(bytes);
|
|
});
|
|
}
|
|
|
|
QString SimulatorTransport::valueString(Attribute attr, Zone zone) const
|
|
{
|
|
const int zi = DeviceState::zoneIndex(zone);
|
|
switch (attr) {
|
|
case Attribute::MultiZone: return m_state.multiZone ? "ON" : "OFF";
|
|
case Attribute::ZoneLink: return m_state.zoneLink ? "ON" : "OFF";
|
|
case Attribute::MusicLevel: return levelToken(m_state.musicLevel[zi]);
|
|
case Attribute::MicLevel: return levelToken(m_state.micLevel[zi]);
|
|
case Attribute::MaxMusicLevel: return levelToken(m_state.maxMusicLevel[zi]);
|
|
case Attribute::MaxMicLevel: return levelToken(m_state.maxMicLevel[zi]);
|
|
case Attribute::Select: return sourceToken(m_state.select);
|
|
case Attribute::EqBass: return QString::number(m_state.eqBass);
|
|
case Attribute::EqTreble: return QString::number(m_state.eqTreble);
|
|
case Attribute::Standby: return m_state.standby ? "ON" : "OFF";
|
|
case Attribute::AutoLoudness: return m_state.autoLoudness ? "ON" : "OFF";
|
|
case Attribute::PagingActive: return m_state.pagingActive[zi] ? "ON" : "OFF";
|
|
case Attribute::Echo: return m_state.echo ? "ON" : "OFF";
|
|
case Attribute::LineFeed: return m_state.lineFeed ? "ON" : "OFF";
|
|
case Attribute::BackSpace: return m_state.backSpace ? "ON" : "OFF";
|
|
case Attribute::Header: return m_state.header ? "ON" : "OFF";
|
|
case Attribute::ValueFeedback: return m_state.valueFeedback ? "ON" : "OFF";
|
|
default: return QString();
|
|
}
|
|
}
|
|
|
|
void SimulatorTransport::sendValueFeedback(Attribute attr, Zone zone)
|
|
{
|
|
if (!m_state.valueFeedback)
|
|
return;
|
|
QString line = attributeToken(attr);
|
|
if (zone != Zone::None)
|
|
line += QLatin1Char(' ') + zoneToken(zone);
|
|
line += QLatin1Char(' ') + valueString(attr, zone);
|
|
reply(line);
|
|
}
|
|
|
|
void SimulatorTransport::sendInfoDump()
|
|
{
|
|
// Mirrors the real GET INFO dump. Zone-qualified when in 2-zone mode.
|
|
reply(QStringLiteral("PAGING OFF"));
|
|
reply(QStringLiteral("MULTIZONE ") + (m_state.multiZone ? "ON" : "OFF"));
|
|
reply(QStringLiteral("ZONELINK ") + (m_state.zoneLink ? "ON" : "OFF"));
|
|
if (m_state.multiZone) {
|
|
reply(QStringLiteral("PAGACT ZONE1 ") + (m_state.pagingActive[0] ? "ON" : "OFF"));
|
|
reply(QStringLiteral("PAGACT ZONE2 ") + (m_state.pagingActive[1] ? "ON" : "OFF"));
|
|
} else {
|
|
reply(QStringLiteral("PAGACT ") + (m_state.pagingActive[0] ? "ON" : "OFF"));
|
|
}
|
|
reply(QStringLiteral("AUTOLD ") + (m_state.autoLoudness ? "ON" : "OFF"));
|
|
reply(QStringLiteral("SELECT ") + sourceToken(m_state.select));
|
|
|
|
const bool mscZone = m_state.musicNeedsZone();
|
|
const bool micZone = m_state.micNeedsZone();
|
|
if (mscZone) {
|
|
reply("MSCLVL ZONE1 " + levelToken(m_state.musicLevel[0]));
|
|
reply("MSCLVL ZONE2 " + levelToken(m_state.musicLevel[1]));
|
|
} else {
|
|
reply("MSCLVL " + levelToken(m_state.musicLevel[0]));
|
|
}
|
|
if (micZone) {
|
|
reply("MICLVL ZONE1 " + levelToken(m_state.micLevel[0]));
|
|
reply("MICLVL ZONE2 " + levelToken(m_state.micLevel[1]));
|
|
} else {
|
|
reply("MICLVL " + levelToken(m_state.micLevel[0]));
|
|
}
|
|
if (mscZone) {
|
|
reply("MAXMSCLVL ZONE1 " + levelToken(m_state.maxMusicLevel[0]));
|
|
reply("MAXMSCLVL ZONE2 " + levelToken(m_state.maxMusicLevel[1]));
|
|
} else {
|
|
reply("MAXMSCLVL " + levelToken(m_state.maxMusicLevel[0]));
|
|
}
|
|
if (micZone) {
|
|
reply("MAXMICLVL ZONE1 " + levelToken(m_state.maxMicLevel[0]));
|
|
reply("MAXMICLVL ZONE2 " + levelToken(m_state.maxMicLevel[1]));
|
|
} else {
|
|
reply("MAXMICLVL " + levelToken(m_state.maxMicLevel[0]));
|
|
}
|
|
reply("EQBASS " + QString::number(m_state.eqBass));
|
|
reply("EQTREB " + QString::number(m_state.eqTreble));
|
|
}
|
|
|
|
// Parse "OFF"/number into a level; returns false if not parseable.
|
|
static bool parseLevel(const QString &tok, int *out)
|
|
{
|
|
const QString t = tok.trimmed().toUpper();
|
|
if (t == QLatin1String("OFF")) { *out = kLevelOff; return true; }
|
|
bool ok = false;
|
|
const int v = t.toInt(&ok);
|
|
if (ok) { *out = v; return true; }
|
|
return false;
|
|
}
|
|
|
|
void SimulatorTransport::processInstruction(const QString &instruction)
|
|
{
|
|
const QStringList parts = instruction.split(QLatin1Char(' '), Qt::SkipEmptyParts);
|
|
if (parts.isEmpty())
|
|
return;
|
|
|
|
const QString cmdTok = parts.first().toUpper();
|
|
Command cmd;
|
|
if (cmdTok == QLatin1String("SET")) cmd = Command::Set;
|
|
else if (cmdTok == QLatin1String("GET")) cmd = Command::Get;
|
|
else if (cmdTok == QLatin1String("INC")) cmd = Command::Inc;
|
|
else if (cmdTok == QLatin1String("DEC")) cmd = Command::Dec;
|
|
else { reply("ERROR: Command Unknown!"); return; }
|
|
|
|
if (parts.size() < 2) { reply("ERROR: Unknown Attribute!"); return; }
|
|
|
|
const Attribute attr = attributeFromToken(parts.at(1));
|
|
if (attr == Attribute::Unknown) { reply("ERROR: Unknown Attribute!"); return; }
|
|
|
|
QStringList rest = parts.mid(2);
|
|
|
|
// Optional source (for IPGAIN/SOURCENAME) comes right after attribute.
|
|
std::optional<Source> source;
|
|
if ((attr == Attribute::InputGain || attr == Attribute::SourceName) &&
|
|
!rest.isEmpty()) {
|
|
if (auto s = sourceFromToken(rest.first())) {
|
|
source = *s;
|
|
rest.removeFirst();
|
|
}
|
|
}
|
|
// Optional zone.
|
|
Zone zone = Zone::None;
|
|
if (!rest.isEmpty()) {
|
|
if (auto z = zoneFromToken(rest.first())) {
|
|
zone = *z;
|
|
rest.removeFirst();
|
|
}
|
|
}
|
|
const QString valueStr = rest.join(QLatin1Char(' '));
|
|
const int zi = DeviceState::zoneIndex(zone);
|
|
|
|
auto stepValue = [&]() -> int {
|
|
bool ok = false;
|
|
int s = valueStr.trimmed().toInt(&ok);
|
|
if (!ok) s = 1;
|
|
return clampStep(s);
|
|
};
|
|
|
|
switch (cmd) {
|
|
case Command::Get:
|
|
switch (attr) {
|
|
case Attribute::Info:
|
|
sendInfoDump();
|
|
return;
|
|
case Attribute::InputGain:
|
|
if (!source) { reply("ERROR: Value Invalid!"); return; }
|
|
reply("IPGAIN " + sourceToken(*source) + " " +
|
|
QString::number(m_state.inputGain[DeviceState::sourceIndex(*source)]));
|
|
return;
|
|
case Attribute::SourceName:
|
|
if (!source) { reply("ERROR: Value Invalid!"); return; }
|
|
// Real device returns the bare name string.
|
|
reply(m_state.sourceName[DeviceState::sourceIndex(*source)]);
|
|
return;
|
|
case Attribute::Serial:
|
|
reply(m_state.serial.isEmpty() ? QStringLiteral("1A2B") : m_state.serial);
|
|
return;
|
|
case Attribute::HwVersion:
|
|
reply(m_state.hwVersion.isEmpty() ? QStringLiteral("ACPT 1V05") : m_state.hwVersion);
|
|
return;
|
|
case Attribute::SwVersion:
|
|
reply(m_state.swVersion.isEmpty() ? QStringLiteral("SW 1V12") : m_state.swVersion);
|
|
return;
|
|
default: {
|
|
QString line = attributeToken(attr);
|
|
if (zone != Zone::None)
|
|
line += QLatin1Char(' ') + zoneToken(zone);
|
|
line += QLatin1Char(' ') + valueString(attr, zone);
|
|
reply(line);
|
|
return;
|
|
}
|
|
}
|
|
|
|
case Command::Set:
|
|
switch (attr) {
|
|
case Attribute::MultiZone:
|
|
m_state.multiZone = (valueStr.toUpper() == "ON" || valueStr == "1");
|
|
sendValueFeedback(attr);
|
|
return;
|
|
case Attribute::ZoneLink:
|
|
m_state.zoneLink = (valueStr.toUpper() == "ON" || valueStr == "1");
|
|
sendValueFeedback(attr);
|
|
return;
|
|
case Attribute::MusicLevel: {
|
|
int lvl; if (!parseLevel(valueStr, &lvl)) { reply("ERROR: Value Invalid!"); return; }
|
|
m_state.musicLevel[zi] = clampLevel(lvl);
|
|
sendValueFeedback(attr, zone);
|
|
return;
|
|
}
|
|
case Attribute::MicLevel: {
|
|
int lvl; if (!parseLevel(valueStr, &lvl)) { reply("ERROR: Value Invalid!"); return; }
|
|
m_state.micLevel[zi] = clampLevel(lvl);
|
|
sendValueFeedback(attr, zone);
|
|
return;
|
|
}
|
|
case Attribute::MaxMusicLevel: {
|
|
int lvl; if (!parseLevel(valueStr, &lvl)) { reply("ERROR: Value Invalid!"); return; }
|
|
m_state.maxMusicLevel[zi] = clampLevel(lvl);
|
|
sendValueFeedback(attr, zone);
|
|
return;
|
|
}
|
|
case Attribute::MaxMicLevel: {
|
|
int lvl; if (!parseLevel(valueStr, &lvl)) { reply("ERROR: Value Invalid!"); return; }
|
|
m_state.maxMicLevel[zi] = clampLevel(lvl);
|
|
sendValueFeedback(attr, zone);
|
|
return;
|
|
}
|
|
case Attribute::Select: {
|
|
auto s = sourceFromToken(valueStr);
|
|
if (!s) { reply("ERROR: Value Invalid!"); return; }
|
|
m_state.select = *s;
|
|
sendValueFeedback(attr);
|
|
return;
|
|
}
|
|
case Attribute::EqBass: {
|
|
bool ok=false; int v=valueStr.toInt(&ok);
|
|
if (!ok) { reply("ERROR: Value Invalid!"); return; }
|
|
m_state.eqBass = normalizeEq(v);
|
|
sendValueFeedback(attr);
|
|
return;
|
|
}
|
|
case Attribute::EqTreble: {
|
|
bool ok=false; int v=valueStr.toInt(&ok);
|
|
if (!ok) { reply("ERROR: Value Invalid!"); return; }
|
|
m_state.eqTreble = normalizeEq(v);
|
|
sendValueFeedback(attr);
|
|
return;
|
|
}
|
|
case Attribute::Standby:
|
|
m_state.standby = (valueStr.toUpper() == "ON" || valueStr == "1");
|
|
sendValueFeedback(attr);
|
|
return;
|
|
case Attribute::AutoLoudness:
|
|
m_state.autoLoudness = (valueStr.toUpper() == "ON" || valueStr == "1");
|
|
sendValueFeedback(attr);
|
|
return;
|
|
case Attribute::PagingActive:
|
|
m_state.pagingActive[zi] = (valueStr.toUpper() == "ON" || valueStr == "1");
|
|
sendValueFeedback(attr, zone);
|
|
return;
|
|
case Attribute::InputGain: {
|
|
if (!source) { reply("ERROR: Value Invalid!"); return; }
|
|
bool ok=false; int v=valueStr.toInt(&ok);
|
|
if (!ok) { reply("ERROR: Value Invalid!"); return; }
|
|
m_state.inputGain[DeviceState::sourceIndex(*source)] = normalizeGain(v);
|
|
reply("Command Executed!"); // IPGAIN is not auto-fed back
|
|
return;
|
|
}
|
|
case Attribute::Echo:
|
|
m_state.echo = (valueStr.toUpper() == "ON" || valueStr == "1");
|
|
sendValueFeedback(attr);
|
|
return;
|
|
case Attribute::LineFeed:
|
|
m_state.lineFeed = (valueStr.toUpper() == "ON" || valueStr == "1");
|
|
sendValueFeedback(attr);
|
|
return;
|
|
case Attribute::BackSpace:
|
|
m_state.backSpace = (valueStr.toUpper() == "ON" || valueStr == "1");
|
|
sendValueFeedback(attr);
|
|
return;
|
|
case Attribute::Header:
|
|
m_state.header = (valueStr.toUpper() == "ON" || valueStr == "1");
|
|
sendValueFeedback(attr);
|
|
return;
|
|
case Attribute::ValueFeedback:
|
|
m_state.valueFeedback = (valueStr.toUpper() == "ON" || valueStr == "1");
|
|
// Always acknowledge the change itself.
|
|
sendValueFeedback(attr);
|
|
return;
|
|
case Attribute::SourceName: {
|
|
if (!source) { reply("ERROR: Value Invalid!"); return; }
|
|
m_state.sourceName[DeviceState::sourceIndex(*source)] = valueStr;
|
|
reply("Command Executed!");
|
|
return;
|
|
}
|
|
case Attribute::Restore:
|
|
if (valueStr.toUpper() == "ON" || valueStr == "1") {
|
|
m_state = DeviceState{}; // factory defaults
|
|
reply("Please Cycle Power!");
|
|
} else {
|
|
reply("ERROR: Value Invalid!");
|
|
}
|
|
return;
|
|
default:
|
|
reply("ERROR: Unknown Instruction!");
|
|
return;
|
|
}
|
|
|
|
case Command::Inc:
|
|
case Command::Dec: {
|
|
const int delta = (cmd == Command::Inc ? 1 : -1) * stepValue();
|
|
int *target = nullptr;
|
|
switch (attr) {
|
|
case Attribute::MusicLevel: target = &m_state.musicLevel[zi]; break;
|
|
case Attribute::MicLevel: target = &m_state.micLevel[zi]; break;
|
|
case Attribute::MaxMusicLevel: target = &m_state.maxMusicLevel[zi]; break;
|
|
case Attribute::MaxMicLevel: target = &m_state.maxMicLevel[zi]; break;
|
|
default: reply("ERROR: Unknown Instruction!"); return;
|
|
}
|
|
int base = *target;
|
|
if (base <= kLevelOff) base = kLevelOff; // OFF acts as -80 for stepping
|
|
int next = base + delta;
|
|
*target = clampLevel(next);
|
|
sendValueFeedback(attr, zone);
|
|
return;
|
|
}
|
|
}
|
|
}
|