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

   1 /**
   2  * Copyright (c) 2010-2023 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.lcn.internal;
  14
  15 import java.util.ArrayList;
  16 import java.util.Collection;
  17 import java.util.HashMap;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.NoSuchElementException;
  21 import java.util.Optional;
  22 import java.util.Set;
  23
  24 import org.eclipse.jdt.annotation.NonNullByDefault;
  25 import org.eclipse.jdt.annotation.Nullable;
  26 import org.openhab.binding.lcn.internal.common.DimmerOutputCommand;
  27 import org.openhab.binding.lcn.internal.common.LcnAddr;
  28 import org.openhab.binding.lcn.internal.common.LcnAddrMod;
  29 import org.openhab.binding.lcn.internal.common.LcnChannelGroup;
  30 import org.openhab.binding.lcn.internal.common.LcnException;
  31 import org.openhab.binding.lcn.internal.connection.Connection;
  32 import org.openhab.binding.lcn.internal.connection.ModInfo;
  33 import org.openhab.binding.lcn.internal.converter.Converter;
  34 import org.openhab.binding.lcn.internal.converter.Converters;
  35 import org.openhab.binding.lcn.internal.converter.InversionConverter;
  36 import org.openhab.binding.lcn.internal.converter.S0Converter;
  37 import org.openhab.binding.lcn.internal.subhandler.AbstractLcnModuleSubHandler;
  38 import org.openhab.binding.lcn.internal.subhandler.LcnModuleMetaAckSubHandler;
  39 import org.openhab.binding.lcn.internal.subhandler.LcnModuleMetaFirmwareSubHandler;
  40 import org.openhab.core.library.types.DecimalType;
  41 import org.openhab.core.library.types.HSBType;
  42 import org.openhab.core.library.types.OnOffType;
  43 import org.openhab.core.library.types.PercentType;
  44 import org.openhab.core.library.types.QuantityType;
  45 import org.openhab.core.library.types.StopMoveType;
  46 import org.openhab.core.library.types.StringType;
  47 import org.openhab.core.library.types.UpDownType;
  48 import org.openhab.core.thing.Bridge;
  49 import org.openhab.core.thing.Channel;
  50 import org.openhab.core.thing.ChannelUID;
  51 import org.openhab.core.thing.Thing;
  52 import org.openhab.core.thing.ThingStatus;
  53 import org.openhab.core.thing.ThingStatusDetail;
  54 import org.openhab.core.thing.binding.BaseThingHandler;
  55 import org.openhab.core.thing.binding.ThingHandlerService;
  56 import org.openhab.core.types.Command;
  57 import org.openhab.core.types.RefreshType;
  58 import org.openhab.core.types.State;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61
  62 /**
  63  * The {@link LcnModuleHandler} is responsible for handling commands, which are
  64  * sent to or received from one of the channels.
  65  *
  66  * @author Fabian Wolter - Initial contribution
  67  */
  68 @NonNullByDefault
  69 public class LcnModuleHandler extends BaseThingHandler {
  70     private final Logger logger = LoggerFactory.getLogger(LcnModuleHandler.class);
  71     private static final int FIRMWARE_VERSION_LENGTH = 6;
  72     private static final Map<String, Converter> VALUE_CONVERTERS = new HashMap<>();
  73     private static final InversionConverter INVERSION_CONVERTER = new InversionConverter();
  74     private @Nullable LcnAddrMod moduleAddress;
  75     private final Map<LcnChannelGroup, AbstractLcnModuleSubHandler> subHandlers = new HashMap<>();
  76     private final List<AbstractLcnModuleSubHandler> metadataSubHandlers = new ArrayList<>();
  77     private final Map<ChannelUID, Converter> converters = new HashMap<>();
  78
  79     static {
  80         VALUE_CONVERTERS.put("temperature", Converters.TEMPERATURE);
  81         VALUE_CONVERTERS.put("light", Converters.LIGHT);
  82         VALUE_CONVERTERS.put("co2", Converters.CO2);
  83         VALUE_CONVERTERS.put("current", Converters.CURRENT);
  84         VALUE_CONVERTERS.put("voltage", Converters.VOLTAGE);
  85         VALUE_CONVERTERS.put("angle", Converters.ANGLE);
  86         VALUE_CONVERTERS.put("windspeed", Converters.WINDSPEED);
  87     }
  88
  89     public LcnModuleHandler(Thing thing) {
  90         super(thing);
  91     }
  92
  93     @Override
  94     public void initialize() {
  95         LcnModuleConfiguration localConfig = getConfigAs(LcnModuleConfiguration.class);
  96         LcnAddrMod localModuleAddress = moduleAddress = new LcnAddrMod(localConfig.segmentId, localConfig.moduleId);
  97
  98         try {
  99             ModInfo info = getPckGatewayHandler().getModInfo(localModuleAddress);
 100             readFirmwareVersionFromProperty().ifPresent(info::setFirmwareVersion);
 101             requestFirmwareVersionAndSerialNumberIfNotSet();
 102
 103             // create sub handlers
 104             for (LcnChannelGroup type : LcnChannelGroup.values()) {
 105                 subHandlers.put(type, type.createSubHandler(this, info));
 106             }
 107
 108             // meta sub handlers, which are not assigned to a channel group
 109             metadataSubHandlers.add(new LcnModuleMetaAckSubHandler(this, info));
 110             metadataSubHandlers.add(new LcnModuleMetaFirmwareSubHandler(this, info));
 111
 112             // initialize converters
 113             for (Channel channel : thing.getChannels()) {
 114                 Object unitObject = channel.getConfiguration().get("unit");
 115                 Object parameterObject = channel.getConfiguration().get("parameter");
 116                 Object invertState = channel.getConfiguration().get("invertState");
 117                 Object invertUpDown = channel.getConfiguration().get("invertUpDown");
 118
 119                 // Initialize value converters
 120                 if (unitObject instanceof String stringValue) {
 121                     switch (stringValue) {
 122                         case "power":
 123                         case "energy":
 124                             converters.put(channel.getUID(), new S0Converter(parameterObject));
 125                             break;
 126                         default:
 127                             Converter converter = VALUE_CONVERTERS.get(unitObject);
 128                             if (converter != null) {
 129                                 converters.put(channel.getUID(), converter);
 130                             }
 131                             break;
 132                     }
 133                 }
 134
 135                 // Initialize inversion converter
 136                 if (Boolean.TRUE.equals(invertState) || Boolean.TRUE.equals(invertUpDown)) {
 137                     converters.put(channel.getUID(), INVERSION_CONVERTER);
 138                 }
 139
 140             }
 141
 142             // module is assumed as online, when the corresponding Bridge (PckGatewayHandler) is online.
 143             updateStatus(ThingStatus.ONLINE);
 144
 145             // trigger REFRESH commands for all linked Channels to start polling
 146             getThing().getChannels().forEach(channel -> {
 147                 if (isLinked(channel.getUID())) {
 148                     channelLinked(channel.getUID());
 149                 }
 150             });
 151         } catch (LcnException e) {
 152             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, e.getMessage());
 153         }
 154     }
 155
 156     /**
 157      * Triggers requesting the firmware version of the LCN module. The message also contains the serial number.
 158      *
 159      * @throws LcnException when the handler is not initialized
 160      */
 161     protected void requestFirmwareVersionAndSerialNumberIfNotSet() throws LcnException {
 162         if (readFirmwareVersionFromProperty().isEmpty()) {
 163             LcnAddrMod localModuleAddress = moduleAddress;
 164             if (localModuleAddress != null) {
 165                 getPckGatewayHandler().getModInfo(localModuleAddress).requestFirmwareVersion();
 166             }
 167         }
 168     }
 169
 170     private Optional<Integer> readFirmwareVersionFromProperty() {
 171         String prop = getThing().getProperties().get(Thing.PROPERTY_FIRMWARE_VERSION);
 172
 173         if (prop == null || prop.length() != FIRMWARE_VERSION_LENGTH) {
 174             return Optional.empty();
 175         }
 176
 177         try {
 178             return Optional.of(Integer.parseInt(prop, 16));
 179         } catch (NumberFormatException e) {
 180             logger.warn("{}: Serial number property invalid", moduleAddress);
 181             return Optional.empty();
 182         }
 183     }
 184
 185     @Override
 186     public void handleCommand(ChannelUID channelUid, Command command) {
 187         try {
 188             String groupId = channelUid.getGroupId();
 189
 190             if (!channelUid.isInGroup()) {
 191                 return;
 192             }
 193
 194             if (groupId == null) {
 195                 throw new LcnException("Group ID is null");
 196             }
 197
 198             LcnChannelGroup channelGroup = LcnChannelGroup.valueOf(groupId.toUpperCase());
 199             AbstractLcnModuleSubHandler subHandler = subHandlers.get(channelGroup);
 200
 201             if (subHandler == null) {
 202                 throw new LcnException("Sub Handler not found for: " + channelGroup);
 203             }
 204
 205             Optional<Integer> number = channelUidToChannelNumber(channelUid, channelGroup);
 206
 207             if (command instanceof RefreshType) {
 208                 number.ifPresent(n -> subHandler.handleRefresh(channelGroup, n));
 209                 subHandler.handleRefresh(channelUid.getIdWithoutGroup());
 210             } else if (command instanceof OnOffType onOffCommand) {
 211                 subHandler.handleCommandOnOff(onOffCommand, channelGroup, number.get());
 212             } else if (command instanceof DimmerOutputCommand outputCommand) {
 213                 subHandler.handleCommandDimmerOutput(outputCommand, number.get());
 214             } else if (command instanceof PercentType percentCommand && number.isPresent()) {
 215                 subHandler.handleCommandPercent(percentCommand, channelGroup, number.get());
 216             } else if (command instanceof HSBType hsbCommand) {
 217                 subHandler.handleCommandHsb(hsbCommand, channelUid.getIdWithoutGroup());
 218             } else if (command instanceof PercentType percentCommand) {
 219                 subHandler.handleCommandPercent(percentCommand, channelGroup, channelUid.getIdWithoutGroup());
 220             } else if (command instanceof StringType stringCommand) {
 221                 subHandler.handleCommandString(stringCommand, number.orElse(0));
 222             } else if (command instanceof DecimalType decimalCommand) {
 223                 DecimalType nativeValue = getConverter(channelUid).onCommandFromItem(decimalCommand.doubleValue());
 224                 subHandler.handleCommandDecimal(nativeValue, channelGroup, number.get());
 225             } else if (command instanceof QuantityType quantityCommand) {
 226                 DecimalType nativeValue = getConverter(channelUid).onCommandFromItem(quantityCommand);
 227                 subHandler.handleCommandDecimal(nativeValue, channelGroup, number.get());
 228             } else if (command instanceof UpDownType upDownCommand) {
 229                 Channel channel = thing.getChannel(channelUid);
 230                 if (channel != null) {
 231                     Object invertConfig = channel.getConfiguration().get("invertUpDown");
 232                     boolean invertUpDown = invertConfig instanceof Boolean bool && bool;
 233                     subHandler.handleCommandUpDown(upDownCommand, channelGroup, number.get(), invertUpDown);
 234                 }
 235             } else if (command instanceof StopMoveType stopMoveCommand) {
 236                 subHandler.handleCommandStopMove(stopMoveCommand, channelGroup, number.get());
 237             } else {
 238                 throw new LcnException("Unsupported command type");
 239             }
 240         } catch (IllegalArgumentException | NoSuchElementException | LcnException e) {
 241             logger.warn("{}: Failed to handle command {}: {}", channelUid, command.getClass().getSimpleName(),
 242                     e.getMessage());
 243         }
 244     }
 245
 246     @NonNullByDefault({}) // getOrDefault()
 247     private Converter getConverter(ChannelUID channelUid) {
 248         return converters.getOrDefault(channelUid, Converters.IDENTITY);
 249     }
 250
 251     /**
 252      * Invoked when a PCK messages arrives from the PCK gateway
 253      *
 254      * @param pck the message without line termination
 255      */
 256     public void handleStatusMessage(String pck) {
 257         subHandlers.values().forEach(h -> h.tryParse(pck));
 258
 259         metadataSubHandlers.forEach(h -> h.tryParse(pck));
 260     }
 261
 262     private Optional<Integer> channelUidToChannelNumber(ChannelUID channelUid, LcnChannelGroup channelGroup)
 263             throws LcnException {
 264         try {
 265             int number = Integer.parseInt(channelUid.getIdWithoutGroup()) - 1;
 266
 267             if (!channelGroup.isValidId(number)) {
 268                 throw new LcnException("Out of range: " + number);
 269             }
 270             return Optional.of(number);
 271         } catch (NumberFormatException e) {
 272             return Optional.empty();
 273         }
 274     }
 275
 276     private PckGatewayHandler getPckGatewayHandler() throws LcnException {
 277         Bridge bridge = getBridge();
 278         if (bridge == null) {
 279             throw new LcnException("No LCN-PCK gateway configured for this module");
 280         }
 281
 282         PckGatewayHandler handler = (PckGatewayHandler) bridge.getHandler();
 283         if (handler == null) {
 284             throw new LcnException("Could not get PckGatewayHandler");
 285         }
 286         return handler;
 287     }
 288
 289     /**
 290      * Queues a PCK string for sending.
 291      *
 292      * @param command without the address part
 293      * @throws LcnException when the module address is unknown
 294      */
 295     public void sendPck(String command) throws LcnException {
 296         getPckGatewayHandler().queue(getCommandAddress(), true, command);
 297     }
 298
 299     /**
 300      * Queues a PCK byte buffer for sending.
 301      *
 302      * @param command without the address part
 303      * @throws LcnException when the module address is unknown
 304      */
 305     public void sendPck(byte[] command) throws LcnException {
 306         getPckGatewayHandler().queue(getCommandAddress(), true, command);
 307     }
 308
 309     /**
 310      * Gets the address, which shall be used when sending commands into the LCN bus. This can also be a group address.
 311      *
 312      * @return the address to send to
 313      * @throws LcnException when the address is unknown
 314      */
 315     protected LcnAddr getCommandAddress() throws LcnException, LcnException {
 316         LcnAddr localAddress = moduleAddress;
 317         if (localAddress == null) {
 318             throw new LcnException("Module address not set");
 319         }
 320         return localAddress;
 321     }
 322
 323     /**
 324      * Invoked when an update for this LCN module should be fired to openHAB.
 325      *
 326      * @param channelGroup the Channel to update
 327      * @param channelId the ID within the Channel to update
 328      * @param state the new state
 329      */
 330     public void updateChannel(LcnChannelGroup channelGroup, String channelId, State state) {
 331         ChannelUID channelUid = createChannelUid(channelGroup, channelId);
 332         Converter converter = converters.get(channelUid);
 333
 334         State convertedState = state;
 335         if (converter != null) {
 336             try {
 337                 convertedState = converter.onStateUpdateFromHandler(state);
 338             } catch (LcnException e) {
 339                 logger.warn("{}: {}{}: Value conversion failed: {}", moduleAddress, channelGroup, channelId,
 340                         e.getMessage());
 341             }
 342         }
 343
 344         updateState(channelUid, convertedState);
 345     }
 346
 347     /**
 348      * Updates the LCN module's serial number property.
 349      *
 350      * @param serialNumber the new serial number
 351      */
 352     public void updateSerialNumberProperty(String serialNumber) {
 353         updateProperty(Thing.PROPERTY_SERIAL_NUMBER, serialNumber);
 354     }
 355
 356     /**
 357      * Updates the LCN module's firmware version property.
 358      *
 359      * @param firmwareVersion the new firmware version
 360      */
 361     public void updateFirmwareVersionProperty(String firmwareVersion) {
 362         updateProperty(Thing.PROPERTY_FIRMWARE_VERSION, firmwareVersion);
 363     }
 364
 365     /**
 366      * Invoked when a trigger for this LCN module should be fired to openHAB.
 367      *
 368      * @param channelGroup the Channel to update
 369      * @param channelId the ID within the Channel to update
 370      * @param event the event used to trigger
 371      */
 372     public void triggerChannel(LcnChannelGroup channelGroup, String channelId, String event) {
 373         triggerChannel(createChannelUid(channelGroup, channelId), event);
 374     }
 375
 376     private ChannelUID createChannelUid(LcnChannelGroup channelGroup, String channelId) {
 377         return new ChannelUID(thing.getUID(), channelGroup.name().toLowerCase() + "#" + channelId);
 378     }
 379
 380     /**
 381      * Checks the LCN module address against the own.
 382      *
 383      * @param physicalSegmentId which is 0 if it is the local segment
 384      * @param moduleId
 385      * @return true, if the given address matches the own address
 386      */
 387     public boolean isMyAddress(String physicalSegmentId, String moduleId) {
 388         try {
 389             return new LcnAddrMod(getPckGatewayHandler().toLogicalSegmentId(Integer.parseInt(physicalSegmentId)),
 390                     Integer.parseInt(moduleId)).equals(getStatusMessageAddress());
 391         } catch (LcnException e) {
 392             return false;
 393         }
 394     }
 395
 396     @Override
 397     public Collection<Class<? extends ThingHandlerService>> getServices() {
 398         return Set.of(LcnModuleActions.class);
 399     }
 400
 401     /**
 402      * Invoked when an Ack from this module has been received.
 403      */
 404     public void onAckRceived() {
 405         try {
 406             Connection connection = getPckGatewayHandler().getConnection();
 407             LcnAddrMod localModuleAddress = moduleAddress;
 408             if (connection != null && localModuleAddress != null) {
 409                 getPckGatewayHandler().getModInfo(localModuleAddress).onAck(LcnBindingConstants.CODE_ACK, connection,
 410                         getPckGatewayHandler().getTimeoutMs(), System.currentTimeMillis());
 411             }
 412         } catch (LcnException e) {
 413             logger.warn("Connection or module address not set");
 414         }
 415     }
 416
 417     /**
 418      * Gets the address the handler shall react to, when a status message from this address is processed.
 419      *
 420      * @return the address for status messages
 421      */
 422     public LcnAddrMod getStatusMessageAddress() {
 423         LcnAddrMod localmoduleAddress = moduleAddress;
 424         if (localmoduleAddress != null) {
 425             return localmoduleAddress;
 426         } else {
 427             return new LcnAddrMod(0, 0);
 428         }
 429     }
 430
 431     @Override
 432     public void dispose() {
 433         metadataSubHandlers.clear();
 434         subHandlers.clear();
 435         converters.clear();
 436     }
 437 }