git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2020 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.epsonprojector.internal;
  14
  15 import java.time.Duration;
  16 import java.util.concurrent.ScheduledExecutorService;
  17 import java.util.concurrent.ScheduledFuture;
  18 import java.util.concurrent.TimeUnit;
  19
  20 import org.eclipse.jdt.annotation.NonNullByDefault;
  21 import org.eclipse.jdt.annotation.Nullable;
  22 import org.openhab.binding.epsonprojector.internal.configuration.EpsonProjectorConfiguration;
  23 import org.openhab.binding.epsonprojector.internal.connector.EpsonProjectorConnector;
  24 import org.openhab.binding.epsonprojector.internal.connector.EpsonProjectorSerialConnector;
  25 import org.openhab.binding.epsonprojector.internal.connector.EpsonProjectorTcpConnector;
  26 import org.openhab.binding.epsonprojector.internal.enums.AspectRatio;
  27 import org.openhab.binding.epsonprojector.internal.enums.Background;
  28 import org.openhab.binding.epsonprojector.internal.enums.ColorMode;
  29 import org.openhab.binding.epsonprojector.internal.enums.ErrorMessage;
  30 import org.openhab.binding.epsonprojector.internal.enums.Gamma;
  31 import org.openhab.binding.epsonprojector.internal.enums.Luminance;
  32 import org.openhab.binding.epsonprojector.internal.enums.PowerStatus;
  33 import org.openhab.binding.epsonprojector.internal.enums.Switch;
  34 import org.openhab.core.cache.ExpiringCache;
  35 import org.openhab.core.io.transport.serial.SerialPortManager;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 /**
  40  * Provide high level interface to Epson projector.
  41  *
  42  * @author Pauli Anttila - Initial contribution
  43  * @author Yannick Schaus - Refactoring
  44  * @author Michael Lobstein - Improvements for OH3
  45  */
  46 @NonNullByDefault
  47 public class EpsonProjectorDevice {
  48     private static final int[] MAP64 = new int[] { 0, 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63, 66,
  49             70, 74, 78, 82, 86, 90, 94, 98, 102, 106, 110, 114, 118, 122, 126, 129, 133, 137, 141, 145, 149, 153, 157,
  50             161, 165, 169, 173, 177, 181, 185, 189, 192, 196, 200, 204, 208, 212, 216, 220, 224, 228, 232, 236, 240,
  51             244, 248, 252 };
  52
  53     private static final int[] MAP60 = new int[] { 0, 4, 8, 12, 16, 20, 25, 29, 33, 37, 41, 46, 50, 54, 58, 62, 67, 71,
  54             75, 79, 83, 88, 92, 96, 100, 104, 109, 113, 117, 121, 125, 130, 134, 138, 142, 146, 151, 155, 159, 163, 167,
  55             172, 176, 180, 184, 188, 193, 197, 201, 205, 209, 214, 218, 222, 226, 230, 235, 239, 243, 247, 251 };
  56
  57     private static final int[] MAP49 = new int[] { 0, 5, 10, 15, 20, 25, 30, 35, 40, 46, 51, 56, 61, 66, 71, 76, 81, 87,
  58             92, 97, 102, 107, 112, 117, 122, 128, 133, 138, 143, 148, 153, 158, 163, 168, 174, 179, 184, 189, 194, 199,
  59             204, 209, 215, 220, 225, 230, 235, 240, 245, 250 };
  60
  61     private static final int[] MAP48 = new int[] { 0, 5, 10, 15, 20, 26, 31, 36, 41, 47, 52, 57, 62, 67, 73, 78, 83, 88,
  62             94, 99, 104, 109, 114, 120, 125, 130, 135, 141, 146, 151, 156, 161, 167, 172, 177, 182, 188, 193, 198, 203,
  63             208, 214, 219, 224, 229, 235, 240, 245, 250 };
  64
  65     private static final int[] MAP20 = new int[] { 0, 12, 24, 36, 48, 60, 73, 85, 97, 109, 121, 134, 146, 158, 170, 182,
  66             195, 207, 219, 231, 243 };
  67
  68     private static final int[] MAP18 = new int[] { 0, 13, 26, 40, 53, 67, 80, 94, 107, 121, 134, 148, 161, 175, 188,
  69             202, 215, 229, 242 };
  70
  71     private static final int[] MAP_COLOR_TEMP = new int[] { 0, 25, 51, 76, 102, 128, 153, 179, 204, 230 };
  72     private static final int[] MAP_FLESH_COLOR = new int[] { 0, 36, 73, 109, 146, 182, 219 };
  73
  74     private static final int DEFAULT_TIMEOUT = 5 * 1000;
  75     private static final int POWER_ON_TIMEOUT = 100 * 1000;
  76     private static final int POWER_OFF_TIMEOUT = 130 * 1000;
  77     private static final int LAMP_REFRESH_WAIT_MINUTES = 5;
  78
  79     private static final String ON = "ON";
  80     private static final String ERR = "ERR";
  81
  82     private final Logger logger = LoggerFactory.getLogger(EpsonProjectorDevice.class);
  83
  84     private @Nullable ScheduledExecutorService scheduler = null;
  85     private @Nullable ScheduledFuture<?> timeoutJob;
  86
  87     private EpsonProjectorConnector connection;
  88     private ExpiringCache<Integer> cachedLampHours = new ExpiringCache<>(Duration.ofMinutes(LAMP_REFRESH_WAIT_MINUTES),
  89             this::queryLamp);
  90     private boolean connected = false;
  91     private boolean ready = true;
  92
  93     public EpsonProjectorDevice(SerialPortManager serialPortManager, EpsonProjectorConfiguration config) {
  94         connection = new EpsonProjectorSerialConnector(serialPortManager, config.serialPort);
  95     }
  96
  97     public EpsonProjectorDevice(EpsonProjectorConfiguration config) {
  98         connection = new EpsonProjectorTcpConnector(config.host, config.port);
  99     }
 100
 101     public boolean isReady() {
 102         return ready;
 103     }
 104
 105     public void setScheduler(ScheduledExecutorService scheduler) {
 106         this.scheduler = scheduler;
 107     }
 108
 109     private synchronized @Nullable String sendQuery(String query, int timeout)
 110             throws EpsonProjectorCommandException, EpsonProjectorException {
 111         logger.debug("Query: '{}'", query);
 112         String response = connection.sendMessage(query, timeout);
 113
 114         if (response.length() == 0) {
 115             throw new EpsonProjectorException("No response received");
 116         }
 117
 118         response = response.replace("\r:", "");
 119         logger.debug("Response: '{}'", response);
 120
 121         if (ERR.equals(response)) {
 122             throw new EpsonProjectorCommandException("Error response received for command: " + query);
 123         }
 124
 125         if ("PWR OFF".equals(query) && ":".equals(response)) {
 126             // When PWR OFF command is sent, next command can be sent 10 seconds after the colon is received
 127             logger.debug("Refusing further commands for 10 seconds to power OFF completion");
 128             ready = false;
 129             ScheduledExecutorService scheduler = this.scheduler;
 130             if (scheduler != null) {
 131                 timeoutJob = scheduler.schedule(() -> {
 132                     ready = true;
 133                 }, 10, TimeUnit.SECONDS);
 134             }
 135         }
 136
 137         return response;
 138     }
 139
 140     private String splitResponse(@Nullable String response)
 141             throws EpsonProjectorCommandException, EpsonProjectorException {
 142         if (response != null && !"".equals(response)) {
 143             String[] pieces = response.split("=");
 144
 145             if (pieces.length < 2) {
 146                 throw new EpsonProjectorCommandException("Invalid response from projector: " + response);
 147             }
 148
 149             return pieces[1].trim();
 150         } else {
 151             throw new EpsonProjectorException("No response received");
 152         }
 153     }
 154
 155     protected void sendCommand(String command, int timeout)
 156             throws EpsonProjectorCommandException, EpsonProjectorException {
 157         sendQuery(command, timeout);
 158     }
 159
 160     protected void sendCommand(String command) throws EpsonProjectorCommandException, EpsonProjectorException {
 161         sendCommand(command, DEFAULT_TIMEOUT);
 162     }
 163
 164     protected int queryInt(String query, int timeout, int radix)
 165             throws EpsonProjectorCommandException, EpsonProjectorException {
 166         String response = sendQuery(query, timeout);
 167
 168         String str = splitResponse(response);
 169
 170         // if the response has two number groups, get the first one (Aspect Ratio does this)
 171         if (str.contains(" ")) {
 172             String[] subStr = str.split(" ");
 173             str = subStr[0];
 174         }
 175
 176         return Integer.parseInt(str, radix);
 177     }
 178
 179     protected int queryInt(String query, int timeout) throws EpsonProjectorCommandException, EpsonProjectorException {
 180         return queryInt(query, timeout, 10);
 181     }
 182
 183     protected int queryInt(String query) throws EpsonProjectorCommandException, EpsonProjectorException {
 184         return queryInt(query, DEFAULT_TIMEOUT, 10);
 185     }
 186
 187     protected int queryHexInt(String query, int timeout)
 188             throws EpsonProjectorCommandException, EpsonProjectorException {
 189         return queryInt(query, timeout, 16);
 190     }
 191
 192     protected int queryHexInt(String query) throws EpsonProjectorCommandException, EpsonProjectorException {
 193         return queryInt(query, DEFAULT_TIMEOUT, 16);
 194     }
 195
 196     protected String queryString(String query) throws EpsonProjectorCommandException, EpsonProjectorException {
 197         String response = sendQuery(query, DEFAULT_TIMEOUT);
 198         return splitResponse(response);
 199     }
 200
 201     public void connect() throws EpsonProjectorException {
 202         connection.connect();
 203         connected = true;
 204     }
 205
 206     public void disconnect() throws EpsonProjectorException {
 207         connection.disconnect();
 208         connected = false;
 209         ScheduledFuture<?> timeoutJob = this.timeoutJob;
 210         if (timeoutJob != null) {
 211             timeoutJob.cancel(true);
 212             this.timeoutJob = null;
 213         }
 214     }
 215
 216     public boolean isConnected() {
 217         return connected;
 218     }
 219
 220     /*
 221      * Power
 222      */
 223     public PowerStatus getPowerStatus() throws EpsonProjectorCommandException, EpsonProjectorException {
 224         int val = queryInt("PWR?");
 225         return PowerStatus.forValue(val);
 226     }
 227
 228     public void setPower(Switch value) throws EpsonProjectorCommandException, EpsonProjectorException {
 229         sendCommand(String.format("PWR %s", value.name()), value == Switch.ON ? POWER_ON_TIMEOUT : POWER_OFF_TIMEOUT);
 230     }
 231
 232     /*
 233      * Key code
 234      */
 235     public void sendKeyCode(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 236         sendCommand(String.format("KEY %02X", value));
 237     }
 238
 239     /*
 240      * Vertical Keystone
 241      */
 242     public int getVerticalKeystone() throws EpsonProjectorCommandException, EpsonProjectorException {
 243         int vkey = queryInt("VKEYSTONE?");
 244         for (int i = 0; i < MAP60.length; i++) {
 245             if (vkey == MAP60[i]) {
 246                 return i - 30;
 247             }
 248         }
 249         return 0;
 250     }
 251
 252     public void setVerticalKeystone(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 253         value = value + 30;
 254         if (value >= 0 && value <= 60) {
 255             sendCommand(String.format("VKEYSTONE %d", MAP60[value]));
 256         }
 257     }
 258
 259     /*
 260      * Horizontal Keystone
 261      */
 262     public int getHorizontalKeystone() throws EpsonProjectorCommandException, EpsonProjectorException {
 263         int hkey = queryInt("HKEYSTONE?");
 264         for (int i = 0; i < MAP60.length; i++) {
 265             if (hkey == MAP60[i]) {
 266                 return i - 30;
 267             }
 268         }
 269         return 0;
 270     }
 271
 272     public void setHorizontalKeystone(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 273         value = value + 30;
 274         if (value >= 0 && value <= 60) {
 275             sendCommand(String.format("HKEYSTONE %d", MAP60[value]));
 276         }
 277     }
 278
 279     /*
 280      * Auto Keystone
 281      */
 282
 283     public Switch getAutoKeystone() throws EpsonProjectorCommandException, EpsonProjectorException {
 284         String val = queryString("AUTOKEYSTONE?");
 285         return val.equals(ON) ? Switch.ON : Switch.OFF;
 286     }
 287
 288     public void setAutoKeystone(Switch value) throws EpsonProjectorCommandException, EpsonProjectorException {
 289         sendCommand(String.format("AUTOKEYSTONE %s", value.name()), DEFAULT_TIMEOUT);
 290     }
 291
 292     /*
 293      * Freeze
 294      */
 295     public Switch getFreeze() throws EpsonProjectorCommandException, EpsonProjectorException {
 296         String val = queryString("FREEZE?");
 297         return val.equals(ON) ? Switch.ON : Switch.OFF;
 298     }
 299
 300     public void setFreeze(Switch value) throws EpsonProjectorCommandException, EpsonProjectorException {
 301         sendCommand(String.format("FREEZE %s", value.name()), DEFAULT_TIMEOUT);
 302     }
 303
 304     /*
 305      * Aspect Ratio
 306      */
 307     public AspectRatio getAspectRatio() throws EpsonProjectorCommandException, EpsonProjectorException {
 308         int val = queryHexInt("ASPECT?");
 309         return AspectRatio.forValue(val);
 310     }
 311
 312     public void setAspectRatio(AspectRatio value) throws EpsonProjectorCommandException, EpsonProjectorException {
 313         sendCommand(String.format("ASPECT %02X", value.toInt()));
 314     }
 315
 316     /*
 317      * Luminance
 318      */
 319     public Luminance getLuminance() throws EpsonProjectorCommandException, EpsonProjectorException {
 320         int val = queryHexInt("LUMINANCE?");
 321         return Luminance.forValue(val);
 322     }
 323
 324     public void setLuminance(Luminance value) throws EpsonProjectorCommandException, EpsonProjectorException {
 325         sendCommand(String.format("LUMINANCE %02X", value.toInt()));
 326     }
 327
 328     /*
 329      * Source
 330      */
 331     public String getSource() throws EpsonProjectorCommandException, EpsonProjectorException {
 332         return queryString("SOURCE?");
 333     }
 334
 335     public void setSource(String value) throws EpsonProjectorCommandException, EpsonProjectorException {
 336         sendCommand(String.format("SOURCE %s", value));
 337     }
 338
 339     /*
 340      * Brightness
 341      */
 342     public int getBrightness() throws EpsonProjectorCommandException, EpsonProjectorException {
 343         int brt = queryInt("BRIGHT?");
 344         for (int i = 0; i < MAP48.length; i++) {
 345             if (brt == MAP48[i]) {
 346                 return i - 24;
 347             }
 348         }
 349         return 0;
 350     }
 351
 352     public void setBrightness(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 353         value = value + 24;
 354         if (value >= 0 && value <= 48) {
 355             sendCommand(String.format("BRIGHT %d", MAP48[value]));
 356         }
 357     }
 358
 359     /*
 360      * Contrast
 361      */
 362     public int getContrast() throws EpsonProjectorCommandException, EpsonProjectorException {
 363         int con = queryInt("CONTRAST?");
 364         for (int i = 0; i < MAP48.length; i++) {
 365             if (con == MAP48[i]) {
 366                 return i - 24;
 367             }
 368         }
 369         return 0;
 370     }
 371
 372     public void setContrast(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 373         value = value + 24;
 374         if (value >= 0 && value <= 48) {
 375             sendCommand(String.format("CONTRAST %d", MAP48[value]));
 376         }
 377     }
 378
 379     /*
 380      * Density
 381      */
 382     public int getDensity() throws EpsonProjectorCommandException, EpsonProjectorException {
 383         int den = queryInt("DENSITY?");
 384         for (int i = 0; i < MAP64.length; i++) {
 385             if (den == MAP64[i]) {
 386                 return i - 32;
 387             }
 388         }
 389         return 0;
 390     }
 391
 392     public void setDensity(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 393         value = value + 32;
 394         if (value >= 0 && value <= 64) {
 395             sendCommand(String.format("DENSITY %d", MAP64[value]));
 396         }
 397     }
 398
 399     /*
 400      * Tint
 401      */
 402     public int getTint() throws EpsonProjectorCommandException, EpsonProjectorException {
 403         int tint = queryInt("TINT?");
 404         for (int i = 0; i < MAP64.length; i++) {
 405             if (tint == MAP64[i]) {
 406                 return i - 32;
 407             }
 408         }
 409         return 0;
 410     }
 411
 412     public void setTint(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 413         value = value + 32;
 414         if (value >= 0 && value <= 64) {
 415             sendCommand(String.format("TINT %d", MAP64[value]));
 416         }
 417     }
 418
 419     /*
 420      * Color Temperature
 421      */
 422     public int getColorTemperature() throws EpsonProjectorCommandException, EpsonProjectorException {
 423         int ctemp = queryInt("CTEMP?");
 424         for (int i = 0; i < MAP_COLOR_TEMP.length; i++) {
 425             if (ctemp == MAP_COLOR_TEMP[i]) {
 426                 return i;
 427             }
 428         }
 429         return 0;
 430     }
 431
 432     public void setColorTemperature(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 433         if (value >= 0 && value <= 9) {
 434             sendCommand(String.format("CTEMP %d", MAP_COLOR_TEMP[value]));
 435         }
 436     }
 437
 438     /*
 439      * Flesh Color
 440      */
 441     public int getFleshColor() throws EpsonProjectorCommandException, EpsonProjectorException {
 442         int fclr = queryInt("FCOLOR?");
 443         for (int i = 0; i < MAP_FLESH_COLOR.length; i++) {
 444             if (fclr == MAP_FLESH_COLOR[i]) {
 445                 return i;
 446             }
 447         }
 448         return 0;
 449     }
 450
 451     public void setFleshColor(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 452         if (value >= 0 && value <= 6) {
 453             sendCommand(String.format("FCOLOR %d", MAP_FLESH_COLOR[value]));
 454         }
 455     }
 456
 457     /*
 458      * Color Mode
 459      */
 460     public ColorMode getColorMode() throws EpsonProjectorCommandException, EpsonProjectorException {
 461         int val = queryHexInt("CMODE?");
 462         return ColorMode.forValue(val);
 463     }
 464
 465     public void setColorMode(ColorMode value) throws EpsonProjectorCommandException, EpsonProjectorException {
 466         sendCommand(String.format("CMODE %02X", value.toInt()));
 467     }
 468
 469     /*
 470      * Horizontal Position
 471      */
 472     public int getHorizontalPosition() throws EpsonProjectorCommandException, EpsonProjectorException {
 473         int hpos = queryInt("HPOS?");
 474         for (int i = 0; i < MAP49.length; i++) {
 475             if (hpos == MAP49[i]) {
 476                 return i - 23;
 477             }
 478         }
 479         return 0;
 480     }
 481
 482     public void setHorizontalPosition(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 483         value = value + 23;
 484         if (value >= 0 && value <= 49) {
 485             sendCommand(String.format("HPOS %d", MAP49[value]));
 486         }
 487     }
 488
 489     /*
 490      * Vertical Position
 491      */
 492     public int getVerticalPosition() throws EpsonProjectorCommandException, EpsonProjectorException {
 493         int vpos = queryInt("VPOS?");
 494         for (int i = 0; i < MAP18.length; i++) {
 495             if (vpos == MAP18[i]) {
 496                 return i - 8;
 497             }
 498         }
 499         return 0;
 500     }
 501
 502     public void setVerticalPosition(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 503         value = value + 8;
 504         if (value >= 0 && value <= 18) {
 505             sendCommand(String.format("VPOS %d", MAP18[value]));
 506         }
 507     }
 508
 509     /*
 510      * Gamma
 511      */
 512     public Gamma getGamma() throws EpsonProjectorCommandException, EpsonProjectorException {
 513         int val = queryHexInt("GAMMA?");
 514         return Gamma.forValue(val);
 515     }
 516
 517     public void setGamma(Gamma value) throws EpsonProjectorCommandException, EpsonProjectorException {
 518         sendCommand(String.format("GAMMA %02X", value.toInt()));
 519     }
 520
 521     /*
 522      * Volume
 523      */
 524     public int getVolume() throws EpsonProjectorCommandException, EpsonProjectorException {
 525         int vol = queryInt("VOL?");
 526         for (int i = 0; i < MAP20.length; i++) {
 527             if (vol == MAP20[i]) {
 528                 return i;
 529             }
 530         }
 531         return 0;
 532     }
 533
 534     public void setVolume(int value) throws EpsonProjectorCommandException, EpsonProjectorException {
 535         if (value >= 0 && value <= 20) {
 536             sendCommand(String.format("VOL %d", MAP20[value]));
 537         }
 538     }
 539
 540     /*
 541      * AV Mute
 542      */
 543     public Switch getMute() throws EpsonProjectorCommandException, EpsonProjectorException {
 544         String val = queryString("MUTE?");
 545         return val.equals(ON) ? Switch.ON : Switch.OFF;
 546     }
 547
 548     public void setMute(Switch value) throws EpsonProjectorCommandException, EpsonProjectorException {
 549         sendCommand(String.format("MUTE %s", value.name()));
 550     }
 551
 552     /*
 553      * Horizontal Reverse
 554      */
 555     public Switch getHorizontalReverse() throws EpsonProjectorCommandException, EpsonProjectorException {
 556         String val = queryString("HREVERSE?");
 557         return val.equals(ON) ? Switch.ON : Switch.OFF;
 558     }
 559
 560     public void setHorizontalReverse(Switch value) throws EpsonProjectorCommandException, EpsonProjectorException {
 561         sendCommand(String.format("HREVERSE %s", value.name()));
 562     }
 563
 564     /*
 565      * Vertical Reverse
 566      */
 567     public Switch getVerticalReverse() throws EpsonProjectorCommandException, EpsonProjectorException {
 568         String val = queryString("VREVERSE?");
 569         return val.equals(ON) ? Switch.ON : Switch.OFF;
 570     }
 571
 572     public void setVerticalReverse(Switch value) throws EpsonProjectorCommandException, EpsonProjectorException {
 573         sendCommand(String.format("VREVERSE %s", value.name()));
 574     }
 575
 576     /*
 577      * Background Select for AV Mute
 578      */
 579     public Background getBackground() throws EpsonProjectorCommandException, EpsonProjectorException {
 580         int val = queryHexInt("MSEL?");
 581         return Background.forValue(val);
 582     }
 583
 584     public void setBackground(Background value) throws EpsonProjectorCommandException, EpsonProjectorException {
 585         sendCommand(String.format("MSEL %02X", value.toInt()));
 586     }
 587
 588     /*
 589      * Lamp Time (hours) - get from cache
 590      */
 591     public int getLampTime() throws EpsonProjectorCommandException, EpsonProjectorException {
 592         Integer lampHours = cachedLampHours.getValue();
 593
 594         if (lampHours != null) {
 595             return lampHours.intValue();
 596         } else {
 597             throw new EpsonProjectorCommandException("cachedLampHours returned null");
 598         }
 599     }
 600
 601     /*
 602      * Get Lamp Time
 603      */
 604     private @Nullable Integer queryLamp() {
 605         try {
 606             return Integer.valueOf(queryInt("LAMP?"));
 607         } catch (EpsonProjectorCommandException | EpsonProjectorException e) {
 608             logger.debug("Error executing command LAMP?", e);
 609             return null;
 610         }
 611     }
 612
 613     /*
 614      * Error Code
 615      */
 616     public int getError() throws EpsonProjectorCommandException, EpsonProjectorException {
 617         return queryHexInt("ERR?");
 618     }
 619
 620     /*
 621      * Error Code Description
 622      */
 623     public String getErrorString() throws EpsonProjectorCommandException, EpsonProjectorException {
 624         int err = queryInt("ERR?");
 625         return ErrorMessage.forCode(err);
 626     }
 627 }