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.wled.internal.handlers;
  14
  15 import static org.openhab.binding.wled.internal.WLedBindingConstants.*;
  16
  17 import java.math.BigDecimal;
  18 import java.util.ArrayList;
  19 import java.util.List;
  20
  21 import org.eclipse.jdt.annotation.NonNullByDefault;
  22 import org.openhab.binding.wled.internal.WLedSegmentConfiguration;
  23 import org.openhab.binding.wled.internal.api.ApiException;
  24 import org.openhab.binding.wled.internal.api.WledApi;
  25 import org.openhab.core.library.types.DecimalType;
  26 import org.openhab.core.library.types.HSBType;
  27 import org.openhab.core.library.types.IncreaseDecreaseType;
  28 import org.openhab.core.library.types.OnOffType;
  29 import org.openhab.core.library.types.PercentType;
  30 import org.openhab.core.thing.Bridge;
  31 import org.openhab.core.thing.Channel;
  32 import org.openhab.core.thing.ChannelUID;
  33 import org.openhab.core.thing.Thing;
  34 import org.openhab.core.thing.ThingStatus;
  35 import org.openhab.core.thing.ThingStatusDetail;
  36 import org.openhab.core.thing.binding.BaseThingHandler;
  37 import org.openhab.core.thing.binding.builder.ThingBuilder;
  38 import org.openhab.core.types.Command;
  39 import org.openhab.core.types.RefreshType;
  40 import org.openhab.core.types.State;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43
  44 /**
  45  * The {@link WLedSegmentHandler} is responsible for handling only a single segment from a WLED device.
  46  *
  47  * @author Matthew Skinner - Initial contribution
  48  */
  49
  50 @NonNullByDefault
  51 public class WLedSegmentHandler extends BaseThingHandler {
  52     private final Logger logger = LoggerFactory.getLogger(getClass());
  53     private WLedSegmentConfiguration config = new WLedSegmentConfiguration();
  54     private BigDecimal masterBrightness255 = BigDecimal.ZERO;
  55     private HSBType primaryColor = new HSBType();
  56     private HSBType secondaryColor = new HSBType();
  57     private HSBType thirdColor = new HSBType();
  58
  59     public WLedSegmentHandler(Thing thing) {
  60         super(thing);
  61     }
  62
  63     public void update(String channelID, State state) {
  64         updateState(channelID, state);
  65     }
  66
  67     private void removeWhiteChannels() {
  68         List<Channel> removeChannels = new ArrayList<>();
  69         Channel channel = getThing().getChannel(CHANNEL_PRIMARY_WHITE);
  70         if (channel != null) {
  71             removeChannels.add(channel);
  72         }
  73         channel = getThing().getChannel(CHANNEL_SECONDARY_WHITE);
  74         if (channel != null) {
  75             removeChannels.add(channel);
  76         }
  77         channel = getThing().getChannel(CHANNEL_THIRD_WHITE);
  78         if (channel != null) {
  79             removeChannels.add(channel);
  80         }
  81         removeChannels(removeChannels);
  82     }
  83
  84     private void removeChannels(List<Channel> removeChannels) {
  85         if (!removeChannels.isEmpty()) {
  86             ThingBuilder thingBuilder = editThing();
  87             thingBuilder.withoutChannels(removeChannels);
  88             updateThing(thingBuilder.build());
  89         }
  90     }
  91
  92     @Override
  93     public void handleCommand(ChannelUID channelUID, Command command) {
  94         Bridge bridge = getBridge();
  95         if (bridge == null) {
  96             return;
  97         }
  98         WLedBridgeHandler bridgeHandler = (WLedBridgeHandler) bridge.getHandler();
  99         if (bridgeHandler == null) {
 100             return;
 101         }
 102         WledApi localApi = bridgeHandler.api;
 103         if (localApi == null) {
 104             return;
 105         }
 106         if (command instanceof RefreshType) {
 107             return;// no need to check for refresh below
 108         }
 109         logger.debug("command {} sent to {}", command, channelUID.getId());
 110         try {
 111             switch (channelUID.getId()) {
 112                 case CHANNEL_SEGMENT_BRIGHTNESS:
 113                     if (command instanceof OnOffType) {
 114                         localApi.setMasterOn(OnOffType.ON.equals(command), config.segmentIndex);
 115                     } else if (command instanceof PercentType percentCommand) {
 116                         if (PercentType.ZERO.equals(command)) {
 117                             localApi.setMasterOn(false, config.segmentIndex);
 118                             return;
 119                         }
 120                         localApi.setMasterBrightness(percentCommand, config.segmentIndex);
 121                     }
 122                     break;
 123                 case CHANNEL_MIRROR:
 124                     localApi.setMirror(OnOffType.ON.equals(command), config.segmentIndex);
 125                     break;
 126                 case CHANNEL_SPACING:
 127                     if (command instanceof DecimalType decimalCommand) {
 128                         localApi.setSpacing(decimalCommand.intValue(), config.segmentIndex);
 129                     }
 130                     break;
 131                 case CHANNEL_GROUPING:
 132                     if (command instanceof DecimalType decimalCommand) {
 133                         localApi.setGrouping(decimalCommand.intValue(), config.segmentIndex);
 134                     }
 135                     break;
 136                 case CHANNEL_REVERSE:
 137                     localApi.setReverse(OnOffType.ON.equals(command), config.segmentIndex);
 138                     break;
 139                 case CHANNEL_PRIMARY_WHITE:
 140                     if (command instanceof PercentType percentCommand) {
 141                         localApi.sendGetRequest("/win&W=" + percentCommand.toBigDecimal().multiply(BIG_DECIMAL_2_55));
 142                     }
 143                     break;
 144                 case CHANNEL_SECONDARY_WHITE:
 145                     if (command instanceof PercentType percentCommand) {
 146                         localApi.sendGetRequest("/win&W2=" + percentCommand.toBigDecimal().multiply(BIG_DECIMAL_2_55));
 147                     }
 148                     break;
 149                 case CHANNEL_MASTER_CONTROLS:
 150                     if (command instanceof OnOffType) {
 151                         if (OnOffType.ON.equals(command)) {
 152                             // global may be off, but we don't want to switch global off and affect other segments
 153                             localApi.setGlobalOn(true);
 154                         }
 155                         localApi.setMasterOn(OnOffType.ON.equals(command), config.segmentIndex);
 156                     } else if (command instanceof IncreaseDecreaseType) {
 157                         if (IncreaseDecreaseType.INCREASE.equals(command)) {
 158                             if (masterBrightness255.intValue() < 240) {
 159                                 localApi.sendGetRequest("/win&TT=1000&A=~15"); // 255 divided by 15 = 17 levels
 160                             } else {
 161                                 localApi.sendGetRequest("/win&TT=1000&A=255");
 162                             }
 163                         } else {
 164                             if (masterBrightness255.intValue() > 15) {
 165                                 localApi.sendGetRequest("/win&TT=1000&A=~-15");
 166                             } else {
 167                                 localApi.sendGetRequest("/win&TT=1000&A=0");
 168                             }
 169                         }
 170                     } else if (command instanceof HSBType hsbCommand) {
 171                         if ((hsbCommand.getBrightness()).equals(PercentType.ZERO)) {
 172                             localApi.setMasterOn(false, config.segmentIndex);
 173                             return;
 174                         }
 175                         localApi.setGlobalOn(true);
 176                         primaryColor = hsbCommand;
 177                         if (primaryColor.getSaturation().intValue() < bridgeHandler.config.saturationThreshold
 178                                 && bridgeHandler.hasWhite) {
 179                             localApi.setWhiteOnly(hsbCommand, config.segmentIndex);
 180                         } else if (primaryColor.getSaturation().intValue() == 32
 181                                 && primaryColor.getHue().intValue() == 36 && bridgeHandler.hasWhite) {
 182                             localApi.setWhiteOnly(hsbCommand, config.segmentIndex);
 183                         } else {
 184                             localApi.setMasterHSB(hsbCommand, config.segmentIndex);
 185                         }
 186                     } else if (command instanceof PercentType percentCommand) {
 187                         localApi.setMasterBrightness(percentCommand, config.segmentIndex);
 188                     }
 189                     return;
 190                 case CHANNEL_PRIMARY_COLOR:
 191                     if (command instanceof HSBType hsbCommand) {
 192                         primaryColor = hsbCommand;
 193                     } else if (command instanceof PercentType percentCommand) {
 194                         primaryColor = new HSBType(primaryColor.getHue(), primaryColor.getSaturation(), percentCommand);
 195                     }
 196                     localApi.setPrimaryColor(primaryColor, config.segmentIndex);
 197                     return;
 198                 case CHANNEL_SECONDARY_COLOR:
 199                     if (command instanceof HSBType hsbCommand) {
 200                         secondaryColor = hsbCommand;
 201                     } else if (command instanceof PercentType percentCommand) {
 202                         secondaryColor = new HSBType(secondaryColor.getHue(), secondaryColor.getSaturation(),
 203                                 percentCommand);
 204                     }
 205                     localApi.setSecondaryColor(secondaryColor, config.segmentIndex);
 206                     return;
 207                 case CHANNEL_THIRD_COLOR:
 208                     if (command instanceof HSBType hsbCommand) {
 209                         thirdColor = hsbCommand;
 210                     } else if (command instanceof PercentType percentCommand) {
 211                         thirdColor = new HSBType(thirdColor.getHue(), thirdColor.getSaturation(), percentCommand);
 212                     }
 213                     localApi.setTertiaryColor(thirdColor, config.segmentIndex);
 214                     return;
 215                 case CHANNEL_PALETTES:
 216                     localApi.setPalette(command.toString(), config.segmentIndex);
 217                     break;
 218                 case CHANNEL_FX:
 219                     localApi.setEffect(command.toString(), config.segmentIndex);
 220                     break;
 221                 case CHANNEL_SPEED:
 222                     localApi.setFxSpeed((PercentType) command, config.segmentIndex);
 223                     break;
 224                 case CHANNEL_INTENSITY:
 225                     localApi.setFxIntencity((PercentType) command, config.segmentIndex);
 226                     break;
 227             }
 228         } catch (ApiException e) {
 229             logger.debug("Exception occured:{}", e.getMessage());
 230         }
 231     }
 232
 233     @Override
 234     public void initialize() {
 235         config = getConfigAs(WLedSegmentConfiguration.class);
 236         Bridge bridge = getBridge();
 237         if (bridge == null) {
 238             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, "No bridge is selected.");
 239         } else {
 240             WLedBridgeHandler localBridgeHandler = (WLedBridgeHandler) bridge.getHandler();
 241             if (localBridgeHandler == null) {
 242                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.BRIDGE_UNINITIALIZED);
 243                 return;
 244             }
 245             WledApi localAPI = localBridgeHandler.api;
 246             if (localAPI != null) {
 247                 updateStatus(ThingStatus.ONLINE);
 248                 localBridgeHandler.stateDescriptionProvider
 249                         .setStateOptions(new ChannelUID(getThing().getUID(), CHANNEL_FX), localAPI.getUpdatedFxList());
 250                 localBridgeHandler.stateDescriptionProvider.setStateOptions(
 251                         new ChannelUID(getThing().getUID(), CHANNEL_PALETTES), localAPI.getUpdatedPaletteList());
 252                 if (!localBridgeHandler.hasWhite) {
 253                     logger.debug("WLED is not setup to use RGBW, so removing un-needed white channels");
 254                     removeWhiteChannels();
 255                 }
 256             } else {
 257                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.BRIDGE_UNINITIALIZED);
 258             }
 259         }
 260     }
 261 }