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