Line data Source code
1 : // SPDX-FileCopyrightText: 2022-2025 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 7728 : MeterCommand::MeterCommand(QObject * const parent) : DeviceCommand(parent)
26 2576 : {
27 :
28 8176 : }
29 :
30 4240 : QStringList MeterCommand::requiredOptions(const QCommandLineParser &parser) const
31 2968 : {
32 18126 : return DeviceCommand::requiredOptions(parser) + QStringList{
33 2968 : u"mode"_s,
34 14151 : };
35 2968 : }
36 :
37 2080 : QStringList MeterCommand::supportedOptions(const QCommandLineParser &parser) const
38 1456 : {
39 12740 : return DeviceCommand::supportedOptions(parser) + QStringList{
40 1456 : u"interval"_s,
41 1456 : u"range"_s,
42 1456 : u"samples"_s,
43 11102 : };
44 1456 : }
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 2000 : QStringList MeterCommand::processOptions(const QCommandLineParser &parser)
53 1400 : {
54 3400 : QStringList errors = DeviceCommand::processOptions(parser);
55 3400 : if (!errors.isEmpty()) {
56 56 : return errors;
57 56 : }
58 :
59 : // Parse the (required) mode option.
60 5184 : if (const QString mode = parser.value(u"mode"_s).trimmed().toLower();
61 6216 : mode.startsWith(u"ac v"_s) || mode.startsWith(u"vac"_s)) {
62 136 : settings.mode = MultimeterService::Mode::AcVoltage;
63 136 : minRangeFunc = minVoltageRange;
64 5957 : } else if (mode.startsWith(u"dc v"_s) || mode.startsWith(u"vdc"_s)) {
65 1496 : settings.mode = MultimeterService::Mode::DcVoltage;
66 1496 : minRangeFunc = minVoltageRange;
67 3108 : } else if (mode.startsWith(u"ac c"_s) || mode.startsWith(u"aac"_s)) {
68 136 : settings.mode = MultimeterService::Mode::AcCurrent;
69 136 : minRangeFunc = minCurrentRange;
70 2849 : } else if (mode.startsWith(u"dc c"_s) || mode.startsWith(u"adc"_s)) {
71 272 : settings.mode = MultimeterService::Mode::DcCurrent;
72 272 : minRangeFunc = minCurrentRange;
73 1611 : } else if (mode.startsWith(u"res"_s)) {
74 272 : settings.mode = MultimeterService::Mode::Resistance;
75 272 : minRangeFunc = minResistanceRange;
76 1253 : } else if (mode.startsWith(u"dio"_s)) {
77 272 : settings.mode = MultimeterService::Mode::Diode;
78 272 : minRangeFunc = nullptr;
79 895 : } else if (mode.startsWith(u"cont"_s)) {
80 136 : settings.mode = MultimeterService::Mode::Continuity;
81 136 : minRangeFunc = nullptr;
82 716 : } else if (mode.startsWith(u"temp"_s)) {
83 136 : settings.mode = MultimeterService::Mode::Temperature;
84 136 : minRangeFunc = nullptr;
85 537 : } else if (mode.startsWith(u"cap"_s)) {
86 272 : settings.mode = MultimeterService::Mode::Capacitance;
87 272 : minRangeFunc = minCapacitanceRange;
88 112 : } else {
89 229 : errors.append(tr("Unknown meter mode: %1").arg(parser.value(u"mode"_s)));
90 56 : return errors;
91 944 : }
92 :
93 : // Parse the interval option.
94 4117 : if (parser.isSet(u"interval"_s)) {
95 940 : const QString value = parser.value(u"interval"_s);
96 680 : const quint32 interval = parseNumber<std::milli>(value, u"s"_s, 500);
97 680 : if (interval == 0) {
98 358 : errors.append(tr("Invalid interval value: %1").arg(value));
99 168 : } else {
100 408 : settings.updateInterval = interval;
101 168 : }
102 465 : }
103 :
104 : // Parse the range option.
105 3128 : rangeOptionValue = 0; // Default to auto.
106 4117 : if (parser.isSet(u"range"_s)) {
107 2068 : const QString value = parser.value(u"range"_s);
108 1969 : if (value.trimmed().compare(u"auto"_s, Qt::CaseInsensitive) != 0) {
109 952 : switch (settings.mode) {
110 352 : case MultimeterService::Mode::DcVoltage:
111 168 : case MultimeterService::Mode::AcVoltage:
112 408 : rangeOptionValue = parseNumber<std::milli>(value, u"V"_s, 50); // mV.
113 408 : break;
114 216 : case MultimeterService::Mode::DcCurrent:
115 112 : case MultimeterService::Mode::AcCurrent:
116 272 : rangeOptionValue = parseNumber<std::milli>(value, u"A"_s, 5); // mA.
117 272 : break;
118 0 : case MultimeterService::Mode::Resistance:
119 0 : rangeOptionValue = parseNumber<std::ratio<1>>(value, u"ohms"_s);
120 0 : break;
121 136 : case MultimeterService::Mode::Capacitance:
122 136 : rangeOptionValue = parseNumber<std::nano>(value, u"F"_s, 500); // pF.
123 136 : break;
124 136 : default:
125 288 : qCInfo(lc).noquote() << tr("Ignoring range value: %1").arg(value);
126 392 : }
127 952 : if ((minRangeFunc != nullptr) && (rangeOptionValue == 0)) {
128 179 : errors.append(tr("Invalid range value: %1").arg(value));
129 56 : }
130 392 : }
131 1023 : }
132 :
133 : // Parse the samples option.
134 4117 : if (parser.isSet(u"samples"_s)) {
135 564 : const QString value = parser.value(u"samples"_s);
136 408 : const quint32 samples = parseNumber<std::ratio<1>>(value, u"S"_s);
137 408 : if (samples == 0) {
138 358 : errors.append(tr("Invalid samples value: %1").arg(value));
139 112 : } else {
140 136 : samplesToGo = samples;
141 56 : }
142 279 : }
143 1288 : return errors;
144 1288 : }
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 6000 : void MeterCommand::outputReading(const MultimeterService::Reading &reading)
208 1800 : {
209 5025 : QString status;
210 7800 : if (reading.status == MultimeterService::MeterStatus::Error) {
211 624 : status = u"Error"_s;
212 7176 : } else switch (reading.mode) {
213 216 : case MultimeterService::Mode::Idle:
214 216 : break;
215 3024 : case MultimeterService::Mode::DcVoltage:
216 288 : case MultimeterService::Mode::AcVoltage:
217 432 : case MultimeterService::Mode::DcCurrent:
218 576 : case MultimeterService::Mode::AcCurrent:
219 720 : case MultimeterService::Mode::Resistance:
220 864 : case MultimeterService::Mode::Capacitance:
221 864 : status = (reading.status == MultimeterService::MeterStatus::AutoRangeOn)
222 5076 : ? tr("Auto Range On") : tr("Auto Range Off");
223 3744 : break;
224 1248 : case MultimeterService::Mode::Continuity:
225 288 : status = (reading.status == MultimeterService::MeterStatus::Continuity)
226 1692 : ? tr("Continuity") : tr("No continuity");
227 1248 : break;
228 1104 : case MultimeterService::Mode::Temperature:
229 144 : case MultimeterService::Mode::ExternalTemperature:
230 288 : case MultimeterService::Mode::Diode:
231 876 : status = tr("Ok");
232 1248 : break;
233 1656 : }
234 :
235 7800 : QString unit;
236 7800 : switch (reading.mode) {
237 360 : case MultimeterService::Mode::Idle: break;
238 882 : case MultimeterService::Mode::DcVoltage: unit = u"Vdc"_s; break;
239 882 : case MultimeterService::Mode::AcVoltage: unit = u"Vac"_s; break;
240 882 : case MultimeterService::Mode::DcCurrent: unit = u"Adc"_s; break;
241 882 : case MultimeterService::Mode::AcCurrent: unit = u"Aac"_s; break;
242 882 : case MultimeterService::Mode::Resistance: unit = QString::fromUtf8("Ω"); break;
243 144 : case MultimeterService::Mode::Diode: break;
244 288 : case MultimeterService::Mode::Continuity: break;
245 882 : case MultimeterService::Mode::Temperature: unit = QString::fromUtf8("°C"); break;
246 882 : case MultimeterService::Mode::Capacitance: unit = QString::fromUtf8("F"); break;
247 0 : case MultimeterService::Mode::ExternalTemperature: unit = QString::fromUtf8("°C"); break;
248 1800 : }
249 :
250 10575 : const QString range = service->toString(reading.range, reading.mode);
251 :
252 7800 : switch (format) {
253 600 : case OutputFormat::Csv:
254 4056 : for (; showCsvHeader; showCsvHeader = false) {
255 2058 : std::cout << qUtf8Printable(tr("mode,value,unit,status,range\n"));
256 336 : }
257 6500 : std::cout << qUtf8Printable(QString::fromLatin1("%1,%2,%3,%4,%5\n")
258 600 : .arg(escapeCsvField(MultimeterService::toString(reading.mode)))
259 600 : .arg(reading.value, 0, 'f').arg(unit, status, range)
260 600 : );
261 2600 : break;
262 2600 : case OutputFormat::Json: {
263 600 : QJsonObject object{
264 3300 : { u"status"_s, status },
265 3900 : { u"value"_s, qIsInf(reading.value) ?
266 2675 : QJsonValue(tr("Infinity")) : QJsonValue(reading.value) },
267 5300 : { u"mode"_s, MultimeterService::toString(reading.mode) },
268 12075 : };
269 2600 : if (!unit.isNull()) {
270 2954 : object.insert(u"unit"_s, unit);
271 336 : }
272 2600 : if (!range.isNull()) {
273 2321 : object.insert(u"range"_s, range);
274 264 : }
275 4600 : std::cout << QJsonDocument(object).toJson().toStdString();
276 2600 : } break;
277 2600 : case OutputFormat::Text:
278 5000 : std::cout << qUtf8Printable(tr("Mode: %1 (0x%2)\n").arg(MultimeterService::toString(reading.mode))
279 600 : .arg((quint8)reading.mode,2,16,'0'_L1));
280 5775 : std::cout << qUtf8Printable(tr("Value: %1 %2\n").arg(reading.value,0,'f').arg(unit));
281 4750 : std::cout << qUtf8Printable(tr("Status: %1 (0x%2)\n").arg(status)
282 600 : .arg((quint8)reading.status,2,16,'0'_L1));
283 4550 : std::cout << qUtf8Printable(tr("Range: %1 (0x%2)\n").arg(range)
284 600 : .arg((quint8)reading.range,2,16,'0'_L1));
285 2600 : break;
286 1800 : }
287 :
288 7800 : if ((samplesToGo > 0) && (--samplesToGo == 0)) {
289 0 : if (device) disconnect(); // Will exit the application once disconnected.
290 0 : }
291 13100 : }
|
