Line data Source code
1 : // SPDX-FileCopyrightText: 2022-2026 Paul Colby <git@colby.id.au>
2 : // SPDX-License-Identifier: LGPL-3.0-or-later
3 :
4 : #include "metercommand.h"
5 : #include "../stringliterals_p.h"
6 :
7 : #include <qtpokit/pokitdevice.h>
8 :
9 : #include <QJsonDocument>
10 : #include <QJsonObject>
11 :
12 : #include <iostream>
13 :
14 : DOKIT_USE_STRINGLITERALS
15 :
16 : /*!
17 : * \class MeterCommand
18 : *
19 : * The MeterCommand class implements the `meter` CLI command.
20 : */
21 :
22 : /*!
23 : * Construct a new MeterCommand object with \a parent.
24 : */
25 8624 : MeterCommand::MeterCommand(QObject * const parent) : DeviceCommand(parent)
26 4200 : {
27 :
28 9100 : }
29 :
30 3710 : QStringList MeterCommand::requiredOptions(const QCommandLineParser &parser) const
31 5883 : {
32 19398 : return DeviceCommand::requiredOptions(parser) + QStringList{
33 5883 : u"mode"_s,
34 15211 : };
35 5883 : }
36 :
37 1820 : QStringList MeterCommand::supportedOptions(const QCommandLineParser &parser) const
38 2886 : {
39 13052 : return DeviceCommand::supportedOptions(parser) + QStringList{
40 2886 : u"interval"_s,
41 2886 : u"range"_s,
42 2886 : u"samples"_s,
43 11102 : };
44 2886 : }
45 :
46 : /*!
47 : * \copybrief DeviceCommand::processOptions
48 : *
49 : * This implementation extends DeviceCommand::processOptions to process additional CLI options
50 : * supported (or required) by this command.
51 : */
52 1750 : QStringList MeterCommand::processOptions(const QCommandLineParser &parser)
53 2775 : {
54 4525 : QStringList errors = DeviceCommand::processOptions(parser);
55 4525 : if (!errors.isEmpty()) {
56 111 : return errors;
57 111 : }
58 :
59 : // Parse the (required) mode option.
60 6024 : if (const QString mode = parser.value(u"mode"_s).trimmed().toLower();
61 7128 : mode.startsWith(u"ac v"_s) || mode.startsWith(u"vac"_s)) {
62 181 : settings.mode = MultimeterService::Mode::AcVoltage;
63 181 : minRangeFunc = minVoltageRange;
64 6831 : } else if (mode.startsWith(u"dc v"_s) || mode.startsWith(u"vdc"_s)) {
65 1991 : settings.mode = MultimeterService::Mode::DcVoltage;
66 1991 : minRangeFunc = minVoltageRange;
67 3564 : } else if (mode.startsWith(u"ac c"_s) || mode.startsWith(u"aac"_s)) {
68 181 : settings.mode = MultimeterService::Mode::AcCurrent;
69 181 : minRangeFunc = minCurrentRange;
70 3267 : } else if (mode.startsWith(u"dc c"_s) || mode.startsWith(u"adc"_s)) {
71 362 : settings.mode = MultimeterService::Mode::DcCurrent;
72 362 : minRangeFunc = minCurrentRange;
73 2043 : } else if (mode.startsWith(u"res"_s)) {
74 362 : settings.mode = MultimeterService::Mode::Resistance;
75 362 : minRangeFunc = minResistanceRange;
76 1589 : } else if (mode.startsWith(u"dio"_s)) {
77 362 : settings.mode = MultimeterService::Mode::Diode;
78 362 : minRangeFunc = nullptr;
79 1135 : } else if (mode.startsWith(u"cont"_s)) {
80 181 : settings.mode = MultimeterService::Mode::Continuity;
81 181 : minRangeFunc = nullptr;
82 908 : } else if (mode.startsWith(u"temp"_s)) {
83 181 : settings.mode = MultimeterService::Mode::Temperature;
84 181 : minRangeFunc = nullptr;
85 681 : } else if (mode.startsWith(u"cap"_s)) {
86 362 : settings.mode = MultimeterService::Mode::Capacitance;
87 362 : minRangeFunc = minCapacitanceRange;
88 222 : } else {
89 269 : errors.append(tr("Unknown meter mode: %1").arg(parser.value(u"mode"_s)));
90 111 : return errors;
91 687 : }
92 :
93 : // Parse the interval option.
94 5221 : if (parser.isSet(u"interval"_s)) {
95 1180 : const QString value = parser.value(u"interval"_s);
96 905 : const quint32 interval = parseNumber<std::milli>(value, u"s"_s, 500);
97 905 : if (interval == 0) {
98 454 : errors.append(tr("Invalid interval value: %1").arg(value));
99 333 : } else {
100 543 : settings.updateInterval = interval;
101 333 : }
102 675 : }
103 :
104 : // Parse the range option.
105 4163 : rangeOptionValue = 0; // Default to auto.
106 5221 : if (parser.isSet(u"range"_s)) {
107 2596 : const QString value = parser.value(u"range"_s);
108 2497 : if (value.trimmed().compare(u"auto"_s, Qt::CaseInsensitive) != 0) {
109 1267 : switch (settings.mode) {
110 432 : case MultimeterService::Mode::DcVoltage:
111 333 : case MultimeterService::Mode::AcVoltage:
112 543 : rangeOptionValue = parseNumber<std::milli>(value, u"V"_s, 50); // mV.
113 543 : break;
114 251 : case MultimeterService::Mode::DcCurrent:
115 222 : case MultimeterService::Mode::AcCurrent:
116 362 : rangeOptionValue = parseNumber<std::milli>(value, u"A"_s, 5); // mA.
117 362 : break;
118 0 : case MultimeterService::Mode::Resistance:
119 0 : rangeOptionValue = parseNumber<std::ratio<1>>(value, u"ohms"_s);
120 0 : break;
121 181 : case MultimeterService::Mode::Capacitance:
122 181 : rangeOptionValue = parseNumber<std::nano>(value, u"F"_s, 500); // pF.
123 181 : break;
124 181 : default:
125 331 : qCInfo(lc).noquote() << tr("Ignoring range value: %1").arg(value);
126 777 : }
127 1267 : if ((minRangeFunc != nullptr) && (rangeOptionValue == 0)) {
128 227 : errors.append(tr("Invalid range value: %1").arg(value));
129 111 : }
130 777 : }
131 1485 : }
132 :
133 : // Parse the samples option.
134 5221 : if (parser.isSet(u"samples"_s)) {
135 708 : const QString value = parser.value(u"samples"_s);
136 543 : const quint32 samples = parseNumber<std::ratio<1>>(value, u"S"_s);
137 543 : if (samples == 0) {
138 454 : errors.append(tr("Invalid samples value: %1").arg(value));
139 222 : } else {
140 181 : samplesToGo = samples;
141 111 : }
142 405 : }
143 2553 : return errors;
144 2553 : }
145 :
146 : /*!
147 : * \copybrief DeviceCommand::getService
148 : *
149 : * This override returns a pointer to a MultimeterService object.
150 : */
151 0 : AbstractPokitService * MeterCommand::getService()
152 0 : {
153 0 : Q_ASSERT(device);
154 0 : if (!service) {
155 0 : service = device->multimeter();
156 0 : Q_ASSERT(service);
157 0 : connect(service, &MultimeterService::settingsWritten,
158 0 : this, &MeterCommand::settingsWritten);
159 0 : }
160 0 : return service;
161 0 : }
162 :
163 : /*!
164 : * \copybrief DeviceCommand::serviceDetailsDiscovered
165 : *
166 : * This override fetches the current device's status, and outputs it in the selected format.
167 : */
168 0 : void MeterCommand::serviceDetailsDiscovered()
169 0 : {
170 0 : DeviceCommand::serviceDetailsDiscovered(); // Just logs consistently.
171 0 : settings.range = (minRangeFunc == nullptr) ? 0 : minRangeFunc(*service->pokitProduct(), rangeOptionValue);
172 0 : const QString range = service->toString(settings.range, settings.mode);
173 0 : qCInfo(lc).noquote() << tr("Measuring %1, with range %2, every %L3ms.").arg(
174 0 : MultimeterService::toString(settings.mode),
175 0 : (range.isNull()) ? QString::fromLatin1("N/A") : range).arg(settings.updateInterval);
176 0 : service->setSettings(settings);
177 0 : }
178 :
179 : /*!
180 : * \var MeterCommand::minRangeFunc
181 : *
182 : * Pointer to function for converting #rangeOptionValue to a Pokit device's range enumerator. This function pointer
183 : * is assigned during the command line parsing, but is not invoked until after the device's services are discovered,
184 : * because prior to that discovery, we don't know which product (Meter vs Pro vs Clamp, etc) we're talking to and thus
185 : * which enumerator list to be using.
186 : *
187 : * If the current mode does not support ranges (eg diode, and continuity modes), then this member will be \c nullptr.
188 : *
189 : * \see processOptions
190 : * \see serviceDetailsDiscovered
191 : */
192 :
193 : /*!
194 : * Invoked when the multimeter settings have been written, to begin reading the meter values.
195 : */
196 0 : void MeterCommand::settingsWritten()
197 0 : {
198 0 : qCDebug(lc).noquote() << tr("Settings written; starting meter readings...");
199 0 : connect(service, &MultimeterService::readingRead,
200 0 : this, &MeterCommand::outputReading);
201 0 : service->enableReadingNotifications();
202 0 : }
203 :
204 : /*!
205 : * Outputs meter \a reading in the selected output format.
206 : */
207 5250 : void MeterCommand::outputReading(const MultimeterService::Reading &reading)
208 1950 : {
209 5400 : QString status;
210 7200 : if (reading.status == MultimeterService::MeterStatus::Error) {
211 576 : status = u"Error"_s;
212 6624 : } else switch (reading.mode) {
213 234 : case MultimeterService::Mode::Idle:
214 234 : break;
215 2676 : case MultimeterService::Mode::DcVoltage:
216 312 : case MultimeterService::Mode::AcVoltage:
217 468 : case MultimeterService::Mode::DcCurrent:
218 624 : case MultimeterService::Mode::AcCurrent:
219 780 : case MultimeterService::Mode::Resistance:
220 936 : case MultimeterService::Mode::Capacitance:
221 936 : status = (reading.status == MultimeterService::MeterStatus::AutoRangeOn)
222 4320 : ? tr("Auto Range On") : tr("Auto Range Off");
223 3456 : break;
224 1152 : case MultimeterService::Mode::Continuity:
225 312 : status = (reading.status == MultimeterService::MeterStatus::Continuity)
226 1440 : ? tr("Continuity") : tr("No continuity");
227 1152 : break;
228 996 : case MultimeterService::Mode::Temperature:
229 156 : case MultimeterService::Mode::ExternalTemperature:
230 312 : case MultimeterService::Mode::Diode:
231 756 : status = tr("Ok");
232 1152 : break;
233 1794 : }
234 :
235 7200 : QString unit;
236 7200 : switch (reading.mode) {
237 390 : case MultimeterService::Mode::Idle: break;
238 852 : case MultimeterService::Mode::DcVoltage: unit = u"Vdc"_s; break;
239 852 : case MultimeterService::Mode::AcVoltage: unit = u"Vac"_s; break;
240 852 : case MultimeterService::Mode::DcCurrent: unit = u"Adc"_s; break;
241 852 : case MultimeterService::Mode::AcCurrent: unit = u"Aac"_s; break;
242 852 : case MultimeterService::Mode::Resistance: unit = QString::fromUtf8("Ω"); break;
243 156 : case MultimeterService::Mode::Diode: break;
244 312 : case MultimeterService::Mode::Continuity: break;
245 852 : case MultimeterService::Mode::Temperature: unit = QString::fromUtf8("°C"); break;
246 852 : case MultimeterService::Mode::Capacitance: unit = QString::fromUtf8("F"); break;
247 0 : case MultimeterService::Mode::ExternalTemperature: unit = QString::fromUtf8("°C"); break;
248 1950 : }
249 :
250 9000 : const QString range = service->toString(reading.range, reading.mode);
251 :
252 7200 : switch (format) {
253 650 : case OutputFormat::Csv:
254 3744 : for (; showCsvHeader; showCsvHeader = false) {
255 1988 : std::cout << qUtf8Printable(tr("mode,value,unit,status,range\n"));
256 364 : }
257 6200 : std::cout << qUtf8Printable(QString::fromLatin1("%1,%2,%3,%4,%5\n")
258 650 : .arg(escapeCsvField(MultimeterService::toString(reading.mode)))
259 650 : .arg(reading.value, 0, 'f').arg(unit, status, range)
260 650 : );
261 2400 : break;
262 2400 : case OutputFormat::Json: {
263 650 : QJsonObject object{
264 2775 : { u"status"_s, status },
265 3775 : { u"value"_s, qIsInf(reading.value) ?
266 2450 : QJsonValue(tr("Infinity")) : QJsonValue(reading.value) },
267 4525 : { u"mode"_s, MultimeterService::toString(reading.mode) },
268 10575 : };
269 2400 : if (!unit.isNull()) {
270 2716 : object.insert(u"unit"_s, unit);
271 364 : }
272 2400 : if (!range.isNull()) {
273 2134 : object.insert(u"range"_s, range);
274 286 : }
275 4150 : std::cout << QJsonDocument(object).toJson().toStdString();
276 2400 : } break;
277 2400 : case OutputFormat::Text:
278 5075 : std::cout << qUtf8Printable(tr("Mode: %1 (0x%2)\n").arg(MultimeterService::toString(reading.mode))
279 650 : .arg((quint8)reading.mode,2,16,'0'_L1));
280 5500 : std::cout << qUtf8Printable(tr("Value: %1 %2\n").arg(reading.value,0,'f').arg(unit));
281 4700 : std::cout << qUtf8Printable(tr("Status: %1 (0x%2)\n").arg(status)
282 650 : .arg((quint8)reading.status,2,16,'0'_L1));
283 4400 : std::cout << qUtf8Printable(tr("Range: %1 (0x%2)\n").arg(range)
284 650 : .arg((quint8)reading.range,2,16,'0'_L1));
285 2400 : break;
286 1950 : }
287 :
288 7200 : if ((samplesToGo > 0) && (--samplesToGo == 0)) {
289 0 : if (device) disconnect(); // Will exit the application once disconnected.
290 0 : }
291 10950 : }
|
