diff --git a/src/compatibility/5.1/android-5.1-cdd.html b/src/compatibility/5.1/android-5.1-cdd.html
index 3c29a81..3a4283f 100644
--- a/src/compatibility/5.1/android-5.1-cdd.html
+++ b/src/compatibility/5.1/android-5.1-cdd.html
@@ -3071,8 +3071,10 @@
 
 <ul>
   <li>MUST implement and report TYPE_ACCELEROMETER sensor [<a href="http://developer.android.com/reference/android/hardware/Sensor.html#TYPE_ACCELEROMETER">Resources, 78</a>].</li>
-  <li>MUST be able to report events up to a frequency of at least 100 Hz and SHOULD
-report events up to at least 200 Hz.</li>
+  <li>MUST be able to report events up to a frequency of at least 50 Hz for
+  Android Watch devices as such devices have a stricter power constraint and
+  100 Hz for all other device types.</li>
+  <li>SHOULD report events up to at least 200 Hz.</li>
   <li>MUST comply with the Android sensor coordinate system as detailed in the
 Android APIs [<a href="http://developer.android.com/reference/android/hardware/SensorEvent.html">Resources, 74</a>].</li>
   <li>MUST be capable of measuring from freefall up to four times the gravity (4g) or
@@ -3155,8 +3157,10 @@
 TYPE_GYROSCOPE_UNCALIBRATED sensor. Existing and new Android devices are
 strongly encouraged to implement the SENSOR_TYPE_GYROSCOPE_UNCALIBRATED sensor.</li>
   <li>MUST be capable of measuring orientation changes up to 1,000 degrees per second.</li>
-  <li>MUST be able to report events up to a frequency of at least 100 Hz and SHOULD
-report events up to at least 200 Hz.</li>
+  <li>MUST be able to report events up to a frequency of at least 50 Hz for
+  Android Watch devices as such devices have a stricter power constraint and 
+  100 Hz for all other device types.</li>
+  <li>SHOULD report events up to at least 200 Hz.</li>
   <li>MUST have a resolution of 12-bits or more and SHOULD have a resolution of
 16-bits or more.</li>
   <li>MUST be temperature compensated.</li>
