Current Recommend Garage Door Opener/Closer

I've tried to read through to see what everyone is using and liking - but couldn't quite get a feel for it.

What is currently recommended and what is recommended to stay away from?

yes mine is working though I would not buy one again. Had 2 but the tilt sensor fell off the door and I drove over it and you can not replace the tilt sensor so it is useless. replaced it with a mimolite and magnetic door sensor the other one is still working though. I am not home but I believe I modified Rboy's garage door DH.
For the mimotelite and magnetic door sensor I modified the following code (not my code) to work with Hubitat.

/**
 *  MIMOlite device type for garage door button, including power failure indicator.  Be sure mimolite has jumper removed before
 *  including the device to your hub, and tap Config to ensure power alarm is subscribed.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 *  in compliance with the License. You may obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
 *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
 *  for the specific language governing permissions and limitations under the License.
 *
 *  Updates:
 *  -------
 *  02-18-2016 : Initial commit
 *  03-05-2016 : Changed date format to MM-dd-yyyy h:mm a
 *  03-11-2016 : Due to ST's v2.1.0 app totally hosing up SECONDARY_CONTROL, implemented a workaround to display that info in a separate tile.
 *  08-27-2016 : Modified the device handler for my liking, primarly for looks and feel.
 *  01-08/2017 : Added code for Health Check capabilities/functions.
 *  02-11-2017 : Cleaned up code, and used secondary_control again for messages.
 *  03-11-2017 : Cleaned up code.
 *  03-24-2017 : Changed color schema to match ST's new format.
 *  04-08-2017 : Updated the updated() section to call configuration().
 *  05-19-2017 : Added additional attributeStates to match ST's DTH which should make this work with ActionTiles, and to use contact as the main tile instead of switch due to personal preference.
 *  05-20-2017 : Redefined tiles/names to be similar to the Linear-type opener DTH's, which should make this work with ActionTiles.
 *  05-23-2017 : Made the delay longer for retreiving device info (gets) after the main tile or the refresh tile is tapped.
 *  09-22-2019 : converted DH to Hubitat and added refresh before each action
 *  10-07-2019 : removed extra refresh from open/close it caused to much delay
 */
metadata {
	// Automatically generated. Make future change here.
	definition (name: "MIMOlite Garage Door Controller 10/07/2019", namespace: "Hubitat", author: "scgs350") {
        capability "Momentary"
        capability "Relay Switch"
	    capability "Polling"
        capability "Refresh"
        capability "Switch"
        capability "Sensor"
        capability "Contact Sensor"
        capability "Configuration"
	    capability "Actuator"
	    capability "Door Control"
	    capability "Garage Door Control"
        capability "Health Check"
        
	    attribute "powered", "string"
        attribute "contactState", "string"       
        
		command "on"
		command "off"
        command "open"
        command "close"
	}
}

def updated(){
	// Device-Watch simply pings if no device events received for 32min(checkInterval)
	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
    response(configure())
}

def parse(String description) {
	// log.debug "description is: ${description}"
	def result = null
    def cmd = zwave.parse(description, [0x72: 1, 0x86: 1, 0x71: 1, 0x30: 1, 0x31: 3, 0x35: 1, 0x70: 1, 0x85: 1, 0x25: 1, 0x03: 1, 0x20: 1, 0x84: 1])
    //log.debug "command value is: $cmd.CMD"
    if (cmd.CMD == "7105") {				//Mimo sent a power loss report
    	log.debug "Device lost power"
    	sendEvent(name: "powered", value: "powerOff", descriptionText: "$device.displayName lost power")
    } else {
    	sendEvent(name: "powered", value: "powerOn", descriptionText: "$device.displayName regained power")
    }
	if (cmd) {
		result = createEvent(zwaveEvent(cmd))
	}
	// log.debug "Parse returned ${result?.descriptionText}"
    def statusTextmsg = ""
    def timeString = new Date().format("MM-dd-yy h:mm a", location.timeZone)
    statusTextmsg = "Last updated: "+timeString
    sendEvent("name":"statusText", "value":statusTextmsg)
	return result
}

def sensorValueEvent(Short value) {
	if (value) {
        sendEvent(name: "contact", value: "open")
        sendEvent(name: "door", value: "open")
        sendEvent(name: "switch", value: "on")
        sendEvent(name: "contactState", value: "Door is open, close/off to close")
	} else {
        sendEvent(name: "contact", value: "closed")
        sendEvent(name: "door", value: "closed")
        sendEvent(name: "switch", value: "off")
        sendEvent(name: "contactState", value: "Door is closed, open/on to open")
	}
}

def zwaveEvent(hubitat.zwave.commands.basicv1.BasicReport cmd) {
	[name: "switch", value: cmd.value ? "on" : "off", type: "physical"]
}

def zwaveEvent(hubitat.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd) {
	def doorState = device.currentValue('switch')
    if (doorState == "off")
    	[name: "contactState", value: cmd.value ? "close" : "closing", type: "digital"]
}    
    
def zwaveEvent(hubitat.zwave.commands.basicv1.BasicSet cmd)
{
	sensorValueEvent(cmd.value)
}

def zwaveEvent(hubitat.zwave.commands.sensorbinaryv1.SensorBinaryReport cmd)
{
	sensorValueEvent(cmd.sensorValue)
}

def zwaveEvent(hubitat.zwave.commands.alarmv1.AlarmReport cmd)
{
    log.debug "We lost power" //we caught this up in the parse method. This method not used.
}

def zwaveEvent(hubitat.zwave.Command cmd) {
	// Handles all Z-Wave commands we aren't interested in
	[:]
}

def on() {
    log.debug "Sending on event to open door"
	open()
}

def off() {
    log.debug "Sending off event to close door"  
	close()
}

def open() {
	if (device.currentValue("door") != "closed") {
		log.debug "not opening door is already open"
	}
	else {
        log.debug "Sending open event to open door"
		push()
	}
}

def close() {
	if (device.currentValue("door") != "open") {
        log.debug "Not closing door since it is already closed"
	}
	else {
		log.debug "Sending close event to close door"
		push()
    }
}

def push() {
	log.debug "Executing push for garage door"
	delayBetween([
        zwave.basicV1.basicGet().format(),
        zwave.basicV1.basicSet(value: 0xFF).format(),
	],1000)
}

def poll() {
	refresh()
}

// PING is used by Device-Watch in attempt to reach the Device
def ping() {
	refresh()
}

def refresh() {
	log.debug "Refreshing"
	delayBetween([
		zwave.switchBinaryV1.switchBinaryGet().format(),
		zwave.sensorBinaryV1.sensorBinaryGet().format(),
        zwave.basicV1.basicGet().format(),
//		zwave.alarmV1.alarmGet(alarmType: 0x08).format()
	],1000)
}

def configure() {
	log.debug "Configuring...." //setting up to monitor power alarm and actuator duration
	delayBetween([
		zwave.associationV1.associationSet(groupingIdentifier:3, nodeId:[zwaveHubNodeId]).format(),
        zwave.configurationV1.configurationSet(parameterNumber: 11, configurationValue: [25], size: 1).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 11).format()
	],100)
}
1 Like

Nortek builds a device that is sold under: Linear, GoControl and Iris brands. (anything GD00Z- will be the same device.)

It's great but took at least a week for me to understand why it wasn't working first time.

It's a Perimeter device and therefore demands Secure Inclusion.

It uses the same two wires that feed the wall button BUT if that wall button is "smart" (has a display) it won't work. Swap the button for a completely dumb button and it worked, 4 seconds later.

I got the dumb button from the same vendor as my door opener motor and I actually like it better than the smart one. Bigger button for one.

Keep in mind none of the z-wave controllers (to the best of my knowledge) will work correctly with the latest Chamberlain/Lift-Mastere Secure 2.0 garage door openers.

Another interesting newcomer is https://gotailwind.com/

It seems to offer some pretty cool automation, easy installation, and compatibliity with the latest openers. It also features IFTTT integration which should allow HE integration.

1 Like

Using Garadget with my ST currently and read a bit that someone got it working here. From a usability standpoint I love the Garadget device and how it works.

https://community.garadget.com/t/hubitat-support/3953

It is cloud, but they recently updated it to do local LAN via a local MQTT server.

@NoWon Do you have any issues with your Mimolite not reporting back to Hubitat when the garage door opens and closes? I am using the same device driver for my setup and when I open the garage door, the device status in HE never refreshes on its own unlike other zwave devices. The same goes when I close the door. I am even using Hubi-poll to refresh the device every 45 seconds and it still wont report back the proper status until I go into the device and click the refresh button.

Linear GD00Z-4 for sure.

Side note, I broke a tilt sensor too.. Contacted them and they sent me a new unit (sensor and main unit) no questions asked for free.

@sdonaghe the actual open/closed state always report correctly but I do get opening/closing transition sometimes but the state never changes from the correct open/closed. I assumed the magnetic might be to far apart.
But I have not looked into what was causing transition mode
If I selected poll instead of refresh it cleared the transition mode

This is what i plan to do very soon

2 Likes

I have had absolutely zero issues with the Go-Control Linear device. Works flawlessly every time.

GoControl/Linear GD00Z-4 Z-Wave Garage Door Opener Remote Controller, Small, Black https://www.amazon.com/dp/B00M75TEIU/ref=cm_sw_r_cp_api_i_LDa4CbF0ESTJS

Same here. I know there were some issues on units a couple of years ago where failure of the warning led caused the units to no longer open/close. I haven't been affected by that and my unit has been rock solid. I'd definitely buy again if I needed another.

Hi there

Did you get to try this, did it work?

Did anyone tried Aeotec Z-Wave Plus garage door controller, is there any issues using it with Hubitat?

Hi @sruty9
I did try it. I bought the peanut plug and it connected to hubitat while in my kitchen for testing. It took some time to do the rest. When i did the rest of the setup and moved peanut plug to the garage since i think was 40 feet away from the hubitat hub something happened and peanut plug got disconnected from the hub. In general peanut plugs were designed to work with Almond router. But they can connect directly too to hubitat. While i think the setup would still work the temporary setback in my setup is not fixed up yet since i need to find the time to troibleshoot it.

For anyone trying this my only suggestion is to get better smart outlet plug than peanut plug which is better supported in hubitat.

During my first attempt to set this up it did actually work as i controlled the garage door by setting the state of the device to on or off. But then i think the distance to the hub messed it up

1 Like

I know this post is a bit old, but I've set this up and have had zero issues. My only real issue is setting this up on the Dashboard. I'd like to have one button that actuates and utilizes the state of the garage door.

Setup:

  • Smart outlet with relay to garage door opener (I used the same instructions in the video posted by iskren.p.petkov except a smart outlet in lieu of peanut).
  • Cheap z-wave window sensor for state of garage door (open/closed)

Does anyone have a solution for the Dashboard? I'd like to use the "Garage Door (control)" template on the Dashboard, but I'd like to use the sensors to update the state of the template/button (green when closed, red when opened).

Hubitat Devices:

  • Garage Door Control Outlet (smart outlet)
  • Garage Door Sensor (window sensor)
  • Virtual Garage Door (virtual switch)

So far, I have the following rules:

  • Close Garage Door
    • When switched to "on", if Garage Door Sensor is "open", turn on Garage Door Control Outlet.
  • Garage Door Outlet Auto-off
    • This simply turns off the smart outlet (which actuates the garage door opener) after 1 second.
  • Make Sure Garage Door Closes
    • Since I do not know if the actuation is closing or opening the garage door, this basically just waits 15 seconds, checks the garage door sensor to make sure it's closed and, if not, actuates the garage door again (by turning on the smart outlet again).

Unfortunately, I have two buttons on my dashboard. I have one that shows the state (open/closed using the Garage Door template), and the other is the Virtual Garage Door to actuate the Garage Door Control Outlet using the switch template.

Any ideas on how I could combine these two?

There's a Garage Door Hybrid driver that you can perhaps use via RM to combine the disparate devices into one virtual device.

1 Like

Thank you! I'll give this a shot. Appreciate it!

I am considering changing my traditional panel rollup door to a door that rolls up like a window roller shade. https://www.smartgarage.ca/

It seems that the garadget's laser method would work fine with this type of door too. It gets around the problem that tilt sensors can't be used on a door that rolls up on itself. Am I right about that?

Anybody aware of a z wave laser sensor? I'm thinking I could possibly make my own with a 1-sided beam break sensor and a z wave dry contact module. (I say "possibly" not from experience, just having read a few posts.). Am I on the right track? Any advice?

I rolled my own for less than the price of a beer.

a) Sonoff relay, etch-cut and soldered to make it a dry-contact relay, loaded with Tasmota.
b) A magnetic-reed door/window sensor mounted on the door, with the magnet attached to an old hinge mounted directly above the sensor. When the door is open, the hinge hangs "open" (straight down), and the magnet is out of range for the sensor, which detects "open". When closed, the hinge is "closed" and the magnet is near the sensor, which reads "closed".

The SonOff must be toggled momentarily for a half-second or so, as it is wired in parallel with the garage wall pushbutton. The SonOff is mounted next to the garage pushbutton, so only a few inches of wire was needed.

The "programming" required was minimal. Event Engine or Rule Machine is all one needs.

This approach works with any garage door opener, of course.

Excellent, thanks. This has given me some ideas. Any chance you could post a pic of how you mounted the hinge and sensor?

Download the Hubitat app