Segway Navimow

With the help of CrownSeven's fork of het Navimow integration I was able to create an automation to have the mower pause in front of an closed and locked gate as it finishes mowing the first zone. After manual opening of the gate I press the resume buttons on the mower and it continues mowing the other zone where also the docking station is located.

alias: Start Navimow mowing job
description: >-
  Starts mowing on button press; pauses once at gate zone; ends automation once
  mowing resumes after pause

triggers:
  # Watches mowing zone and GPS coordinates to detect when mower approaches gate
  - trigger: state
    entity_id:
      - sensor.navimow_i206_awd_mowing_zone
      - sensor.navimow_i206_awd_position_x
      - sensor.navimow_i206_awd_position_y
    id: zone_check

  # Detects when mower transitions to mowing state — used to end run after gate pause
  - trigger: state
    entity_id: lawn_mower.navimow_i206_awd
    to: mowing
    id: mowing

  # Physical MQTT button (single press) to manually start a mowing session
  - trigger: device
    domain: mqtt
    device_id: c3ca9c67be73f5e422f65a127a839d8f
    type: action
    subtype: single
    id: start

actions:
  - choose:

      # Guard: notify if button pressed while mower is already running
      - conditions:
          - condition: trigger
            id: start
          - condition: state
            entity_id: lawn_mower.navimow_i206_awd
            state: mowing
        sequence:
          - action: notify.whatsapp_me
            data:
              title: Navimow
              message: Maaier maait al

      # Main start sequence: reset pause flag, reload integration to sync state,
      # wait for integration to come back up, then issue start command
      - conditions:
          - condition: trigger
            id: start
        sequence:
          - action: input_boolean.turn_off
            target:
              entity_id: input_boolean.grasmaaier_paused
          # Reload forces a fresh connection — workaround for stale integration state
          - action: homeassistant.reload_config_entry
            target:
              entity_id: lawn_mower.navimow_i206_awd
          # Allow integration time to reconnect before issuing the start command
          - delay:
              seconds: 10
          - action: lawn_mower.start_mowing
            target:
              entity_id: lawn_mower.navimow_i206_awd

      # Gate resume detection: mower returned to mowing after a gate pause.
      # Stop ends this automation run only — automation stays enabled for next session.
      - conditions:
          - condition: trigger
            id: mowing
          - condition: state
            entity_id: input_boolean.grasmaaier_paused
            state: "on"
        sequence:
          - stop: Mower resumed after gate pause — ending automation run

      # Gate pause: triggers when mower is in zone >1 and within the gate coordinate
      # window (x: 2–3, y: 19–20). Pauses mower, sets flag to prevent re-triggering,
      # and notifies to open the gate. mode: single ensures this fires only once.
      - conditions:
          - condition: trigger
            id: zone_check
          # Flag prevents this block from firing again during the same session
          - condition: state
            entity_id: input_boolean.grasmaaier_paused
            state: "off"
          - condition: state
            entity_id: lawn_mower.navimow_i206_awd
            state: mowing
          # Only pause when transitioning out of zone 1 (i.e. heading to back garden)
          - condition: numeric_state
            entity_id: sensor.navimow_i206_awd_mowing_zone
            above: 1
          # Narrow GPS window marking the gate crossing point — widen if missed
          - condition: numeric_state
            entity_id: sensor.navimow_i206_awd_position_x
            above: 2
            below: 3
          - condition: numeric_state
            entity_id: sensor.navimow_i206_awd_position_y
            above: 19
            below: 20
        sequence:
          - action: lawn_mower.pause
            target:
              entity_id: lawn_mower.navimow_i206_awd
          - action: input_boolean.turn_on
            target:
              entity_id: input_boolean.grasmaaier_paused
          - action: notify.whatsapp_me
            data:
              title: Navimow
              message: De grasmaaier staat voor de tuinpoort

# Single mode prevents gate-pause logic from re-triggering while handling the gate
mode: single

@CrownSeven thanks for your work!

I tried the map with an overlay but the mower's path does not survive page reloads. It draws fine as long as I stay on the page and even when switching to a different view and returning to the map.
But as soon as I reload the page, the path is gone.
I have no special recorder configuration so it should default to recording. History view of the position entities are also fine.

Any idea what might go wrong?

Thank you for @CrownSeven for maintaining this fork. Even at this early stage, it already performs better than the original branch.

I would like to report issues related to mower state synchronization:

Battery entity:
The reported battery level appears to be out of sync. It frequently jumps between values, for example from 80% to 56% or from 15% directly to 55% (see attached graph).

Mowing progress and other entities:
State reporting seems correct from the start of mowing, but only until the mower goes to recharge. After recharging to 80% → mowing resumes; however, the mower state remains "docked" and other related entities are not updated. These entities begin reporting correctly again approximately 30 minutes after mowing resumes. The same issue repeats after each recharge cycle (see attached graph).

Based on this behavior, it seems that when the mower resumes mowing after recharging, the integration does not detect this transition. As a result, Home Assistant continues to treat the mower as docked instead of actively mowing.

I tinkered a bit with @CrownSeven's fork and have reached the point where HA displays the following sensors:

The battery status was also updating very infrequently, so I set it to refresh every 2 minutes. Shortly after 12 o'clock, I uploaded the new code.

I modified the map card slightly to display the paths from the previous five runs in gray and the active mowing path in blue. Previously, it used to erase the old track after every charging cycle.

State attributes looks like this at the moment.

It is displaying the two zone sensors correctly so I can use them to set up gate-opening automation.
I have the H215 and X390, and everything seems to be working fine on them at the moment.
I haven't figured out how to send commands from HA to the mower to mow a specific zone, or how to toggle perimeter mowing on and off. How do you do that?
I also haven't figured out what "mowStartType" is.

P.S. I am by no means a software developer or coder; this is simply the work of AI. If you have any questions, I can send the contents of my .py files as a .txt file if that would be helpful. @CrownSeven did the heavy lifting to get us to where we are today. Thanks!

Great job @toomasv.
When / where can we test your changes please ?

To be honest, I don't know how to set it up as a GitHub repo. :face_holding_back_tears: Personally, I installed @CrownSeven's fork and modified the files using the HA File Editor. I can email the files in .txt format if anyone is interested.

Hi, I think a lot of users would be happy if you could somehow get this published on GitHub. It would be great to have a working integration.

Best regards

Ask claude to help it'll do it all for you...

NavimowHA Fork - Gate Channels, Map Improvements & Extra Sensors

Hi everyone,

Over the last few weeks I've been working on my own fork of the Navimow Home Assistant integration.

GitHub:
GitHub - vahesoo/NavimowHA: Segway Navimow Official Integration for Home Assistant with some tweaking · GitHub

I haven't had time to test everything thoroughly yet, but I wanted to share it in case someone finds it useful.

Gate automation

For a long time I thought reliable gate automation would require detecting mower zones.

Yesterday I ended up with a completely different solution.

Instead of relying on zones, the integration can now use the mower's RTK Position X/Y coordinates to create configurable Channel areas.

A Channel is simply a rectangular area defined by four coordinates.

When the mower enters that area, a binary sensor is created and changes to ON, which can be used as a trigger for Home Assistant automations.

To configure a channel:

Settings → Devices & Services → Navimow → Configure

Enter the four corner coordinates (X min, X max, Y min, Y max).

The integration will automatically create a binary sensor such as:

binary_sensor.my_front_gate_channel

Example gate automation

I've included my own automation in:

examples/gate-automation/

I tested it yesterday and it works well for my installation.

The logic is:

  1. The mower enters the configured Channel.
  2. The mower is paused.
  3. The gate is opened.
  4. The automation waits until the gate is open.
  5. The mower resumes:
  • Start Mowing if it was mowing.
  • Dock if it was returning to the charging station.

This prevents the mower from waiting in front of the gate while VisionFence/LiDAR tries to figure out what's blocking the path.

Map card improvements

The examples folder also contains:

navimow-map-card.jsNavimow_top_low.svg

I copied these to my Home Assistant:

/config/www/navimow/

and added the JavaScript file as a Lovelace resource.

I also modified the map slightly.

Instead of showing every previous path with the same opacity:

  • the newest path is fully visible
  • older paths are displayed using transparent grey
  • each older session becomes progressively more transparent

The number of historical mowing sessions displayed can be configured directly in the card YAML.

A complete example dashboard configuration is included.

Extra sensors

I also added several sensors that were missing from the original integration, including:

  • Zone progress
  • Overall mowing progress
  • Current job area
  • Weekly mowing area
  • Active task
  • Additional mower state information

Disclaimer

I'm not a software developer or a Python programmer.

This fork exists because I wanted a few extra features for my own Home Assistant setup.

I don't plan to actively maintain or develop it long-term, but I'm happy if someone finds it useful or wants to build on top of it.

If you find bugs or have ideas for improvements, feel free to open an issue or submit a pull request.

Hi everyone,
I've made a few more improvements to my fork.
The biggest addition is interactive map calibration. Instead of manually finding pixel coordinates, you can now enable Calibration Mode, drive the mower to a known location, click the same point on the map image, then repeat the process for a second point. The card will display the calibration values that can be copied into your YAML configuration. The original manual calibration method is still fully supported. The calibration helper makes it much easier to align satellite images or site plans without having to manually measure image pixel coordinates.
I've also added support for displaying channel areas directly on the map. These use the channel coordinates configured in the integration (via Configure), so you can visually verify where your automation trigger zones are located.
Other improvements include:
Interactive two-point map calibration
Channel area visualization
Pinch-to-zoom (mobile)
Mouse wheel zoom and panning (desktop)
Configurable trail appearance (colors, width, opacity and fade mode)
Configurable robot and dock scaling
Customizable dock icon (MDI)
Appearance options moved to YAML configuration
Improved historical trail rendering
The gate automation example from my previous post still works and now integrates nicely with the channel visualization on the map.

To answer my own question: I accidentially omitted the status_entity: config of the the map card. Once added, everything is fine.

I’ve made some more progress with the Navimow map card and decided to start moving it into a separate repository.

Until now, the map card has been included inside my NavimowHA fork, but updating it that way is not very convenient. A separate repository should make updates easier, especially through HACS, and it also makes the map card easier to maintain as its own project.

The first pre-release is now available here:

My NavimowHA fork is still here:

The map card has grown quite a bit from the first version. Current features include:

  • Visual editor support
  • Live mower position on a map
  • Live heading / mower rotation
  • Dock position
  • Historical trail rendering
  • Multi-day history view
  • Mowing session legend
  • Session filtering
  • Interactive two-point map calibration
  • Background image / aerial map support
  • Channel area visualization
  • Pinch-to-zoom on mobile
  • Mouse wheel zoom and panning on desktop
  • Configurable trail colors, width, opacity and fade
  • Configurable robot scaling
  • Custom robot SVG model support
  • Default robot icon loaded from dist/icons/h2.svg
  • Optional custom robot icon or MDI icon support
  • Customizable dock icon using MDI icons
  • Configurable dock scaling
  • Zone names
  • Automatic entity detection from the mower entity
  • Legacy overlay_image support, with the new preferred option being background_image

One of the main reasons I added the channel visualization was gate control. In my setup, I had trouble getting zones to work reliably enough for controlling a gate. Instead, I now use a configurable “channel” area based on the mower’s live position. When the mower enters that channel, Home Assistant can use it in automations, for example to open the gate.

The map card can now show these channel areas directly on the map, so it is much easier to see and verify where the automation trigger area actually is.

The project is still evolving, but separating the card into its own repository should make it easier to install, update and improve.

Let’s see what else will be possible from here :slightly_smiling_face:

Hey @toomasv
Really great work, I like it!
Short question: I have exactly every hour an interruption. Any idea or already saw this behavior?

Hi, i have been trying to figure it out or filter it out, yet no luck, it comes from tokens refresh so the connection will go down for few seconds. I did filter it out form map card.
Cheers!

Maybe a stupid question regarding vehicle state: when robot docks, state changes to „docked“. After „a while“ it changes to „idle“. Why and when changes it to idle? For what do you need this state?

Ah, I see you have also updated to 2026.7…

Sorry for not replying earlier. I’ve been on holiday for the past 3 weeks, and have 3 more to go. I’ll try to get back to those who have asked any questions soon. I am happy to see that overs have started contributing nice work everyone!

Navimow integration v1.2.0 released

Version v1.2.0 is now available Here

This release focuses mainly on zone tracking, state stability and dock position handling.

New zone sensors include:

  • Zone X last area
  • Zone X last completed
  • Zone X last mowed
  • Zone X progress
  • Zone X session count

The integration now also tries to keep entity states stable during the hourly OAuth token refresh. Previously, entities could briefly become unavailable after every token refresh even though the mower itself was still online. The integration now filters these temporary refresh-related state changes where possible, so the logs stay cleaner and the last valid state is preserved. Live position entities such as heading, X and Y are excluded from this protection, because they are expected to update only when fresh position data is received.

Dock coordinates can occasionally be overwritten by incorrect cloud data. To prevent this, v1.2.0 adds dock learning and dock lock functionality. Once the correct dock position has been learned and locked, temporary incorrect values from the cloud should no longer replace it.

The integration-level channels can also be used for purposes other than mowing zones. For example, they can represent areas such as front yard, back yard, house front or house rear, depending on how the map is divided.

After updating through HACS, restart Home Assistant.

It works bit better now, tokens refresh still happens every hour but integration filters it out.