diff --git a/y2015/control_loops/claw/claw.cc b/y2015/control_loops/claw/claw.cc
index c1a734e..e487024 100644
--- a/y2015/control_loops/claw/claw.cc
+++ b/y2015/control_loops/claw/claw.cc
@@ -291,12 +291,12 @@
   status->goal_velocity = claw_goal_velocity;
 
   if (output) {
-    status->rollers_open =
-        !output->rollers_closed &&
-        (Time::Now() - last_piston_edge_ >= values.claw.piston_switch_time);
-    status->rollers_closed =
-        output->rollers_closed &&
-        (Time::Now() - last_piston_edge_ >= values.claw.piston_switch_time);
+    status->rollers_open = !output->rollers_closed &&
+                           ((Time::Now() - last_piston_edge_).ToSeconds() >=
+                            values.claw.piston_switch_time);
+    status->rollers_closed = output->rollers_closed &&
+                             ((Time::Now() - last_piston_edge_).ToSeconds() >=
+                              values.claw.piston_switch_time);
   } else {
     status->rollers_open = false;
     status->rollers_closed = false;
