diff --git a/drivers/servo/servo.cpp b/drivers/servo/servo.cpp
index 40354b24..bf737a17 100644
--- a/drivers/servo/servo.cpp
+++ b/drivers/servo/servo.cpp
@@ -4,15 +4,15 @@
 
 namespace servo {
   Servo::Servo(uint pin, CalibrationType type, float freq)
-    : pin(pin), state(type), pwm_frequency(freq) {
+    : servo_pin(pin), state(type), pwm_frequency(freq) {
   }
 
   Servo::Servo(uint pin, const Calibration& calibration, float freq)
-    : pin(pin), state(calibration), pwm_frequency(freq) {
+    : servo_pin(pin), state(calibration), pwm_frequency(freq) {
   }
 
   Servo::~Servo() {
-    gpio_set_function(pin, GPIO_FUNC_NULL);
+    gpio_set_function(servo_pin, GPIO_FUNC_NULL);
   }
 
   bool Servo::init() {
@@ -30,18 +30,18 @@ namespace servo {
       // Apply the divider
       pwm_config_set_clkdiv(&pwm_cfg, (float)div16 / 16.0f); // There's no 'pwm_config_set_clkdiv_int_frac' for some reason...
 
-      pwm_init(pwm_gpio_to_slice_num(pin), &pwm_cfg, true);
-      gpio_set_function(pin, GPIO_FUNC_PWM);
+      pwm_init(pwm_gpio_to_slice_num(servo_pin), &pwm_cfg, true);
+      gpio_set_function(servo_pin, GPIO_FUNC_PWM);
 
-      pwm_set_gpio_level(pin, 0);
+      pwm_set_gpio_level(servo_pin, 0);
 
       success = true;
     }
     return success;
   }
 
-  uint Servo::get_pin() const {
-    return pin;
+  uint Servo::pin() const {
+    return servo_pin;
   }
 
   void Servo::enable() {
@@ -56,27 +56,27 @@ namespace servo {
     return state.is_enabled();
   }
 
-  float Servo::get_pulse() const {
+  float Servo::pulse() const {
     return state.get_pulse();
   }
 
-  void Servo::set_pulse(float pulse) {
-    apply_pulse(state.set_pulse(pulse));
+  void Servo::pulse(float pulse) {
+    apply_pulse(state.set_pulse_with_return(pulse));
   }
 
-  float Servo::get_value() const {
+  float Servo::value() const {
     return state.get_value();
   }
 
-  void Servo::set_value(float value) {
-    apply_pulse(state.set_value(value));
+  void Servo::value(float value) {
+    apply_pulse(state.set_value_with_return(value));
   }
 
-  float Servo::get_frequency() const {
+  float Servo::frequency() const {
     return pwm_frequency;
   }
 
-  bool Servo::set_frequency(float freq) {
+  bool Servo::frequency(float freq) {
     bool success = false;
 
     if((freq >= ServoState::MIN_FREQUENCY) && (freq <= ServoState::MAX_FREQUENCY)) {
@@ -92,7 +92,7 @@ namespace servo {
         pwm_period = period;
         pwm_frequency = freq;
 
-        uint pin_num = pwm_gpio_to_slice_num(pin);
+        uint pin_num = pwm_gpio_to_slice_num(servo_pin);
 
         // Apply the new divider
         uint8_t div = div16 >> 4;
@@ -118,36 +118,36 @@ namespace servo {
     return success;
   }
 
-  float Servo::get_min_value() const {
+  float Servo::min_value() const {
     return state.get_min_value();
   }
 
-  float Servo::get_mid_value() const {
+  float Servo::mid_value() const {
     return state.get_mid_value();
   }
 
-  float Servo::get_max_value() const {
+  float Servo::max_value() const {
     return state.get_max_value();
   }
 
   void Servo::to_min() {
-    apply_pulse(state.to_min());
+    apply_pulse(state.to_min_with_return());
   }
 
   void Servo::to_mid() {
-    apply_pulse(state.to_mid());
+    apply_pulse(state.to_mid_with_return());
   }
 
   void Servo::to_max() {
-    apply_pulse(state.to_max());
+    apply_pulse(state.to_max_with_return());
   }
 
   void Servo::to_percent(float in, float in_min, float in_max) {
-    apply_pulse(state.to_percent(in, in_min, in_max));
+    apply_pulse(state.to_percent_with_return(in, in_min, in_max));
   }
 
   void Servo::to_percent(float in, float in_min, float in_max, float value_min, float value_max) {
-    apply_pulse(state.to_percent(in, in_min, in_max, value_min, value_max));
+    apply_pulse(state.to_percent_with_return(in, in_min, in_max, value_min, value_max));
   }
 
   Calibration& Servo::calibration() {
@@ -159,6 +159,6 @@ namespace servo {
   }
 
   void Servo::apply_pulse(float pulse) {
-    pwm_set_gpio_level(pin, (uint16_t)ServoState::pulse_to_level(pulse, pwm_period, pwm_frequency));
+    pwm_set_gpio_level(servo_pin, (uint16_t)ServoState::pulse_to_level(pulse, pwm_period, pwm_frequency));
   }
 };
\ No newline at end of file
diff --git a/drivers/servo/servo.hpp b/drivers/servo/servo.hpp
index 197962e0..e6968f3e 100644
--- a/drivers/servo/servo.hpp
+++ b/drivers/servo/servo.hpp
@@ -11,7 +11,7 @@ namespace servo {
     // Variables
     //--------------------------------------------------
   private:
-    uint pin;
+    uint servo_pin;
     ServoState state;
     pwm_config pwm_cfg;
     uint16_t pwm_period;
@@ -33,25 +33,25 @@ namespace servo {
     bool init();
 
     // For print access in micropython
-    uint get_pin() const;
+    uint pin() const;
 
     void enable();
     void disable();
     bool is_enabled() const;
 
-    float get_pulse() const;
-    void set_pulse(float pulse);
+    float pulse() const;
+    void pulse(float pulse);
 
-    float get_value() const;
-    void set_value(float value);
+    float value() const;
+    void value(float value);
 
-    float get_frequency() const;
-    bool set_frequency(float freq);
+    float frequency() const;
+    bool frequency(float freq);
 
     //--------------------------------------------------
-    float get_min_value() const;
-    float get_mid_value() const;
-    float get_max_value() const;
+    float min_value() const;
+    float mid_value() const;
+    float max_value() const;
 
     void to_min();
     void to_mid();
diff --git a/drivers/servo/servo_cluster.cpp b/drivers/servo/servo_cluster.cpp
index 0eccdcf1..699e018c 100644
--- a/drivers/servo/servo_cluster.cpp
+++ b/drivers/servo/servo_cluster.cpp
@@ -80,11 +80,11 @@ namespace servo {
     return success;
   }
 
-  uint8_t ServoCluster::get_count() const {
+  uint8_t ServoCluster::count() const {
     return pwms.get_chan_count();
   }
 
-  uint8_t ServoCluster::get_pin(uint8_t servo) const {
+  uint8_t ServoCluster::pin(uint8_t servo) const {
     return pwms.get_chan_pin(servo);
   }
 
@@ -157,122 +157,122 @@ namespace servo {
     return states[servo].is_enabled();
   }
 
-  float ServoCluster::get_pulse(uint servo) const {
+  float ServoCluster::pulse(uint servo) const {
     assert(servo < pwms.get_chan_count());
     return states[servo].get_pulse();
   }
 
-  void ServoCluster::set_pulse(uint servo, float pulse, bool load) {
+  void ServoCluster::pulse(uint servo, float pulse, bool load) {
     assert(servo < pwms.get_chan_count());
-    float new_pulse = states[servo].set_pulse(pulse);
+    float new_pulse = states[servo].set_pulse_with_return(pulse);
     apply_pulse(servo, new_pulse, load);
   }
 
-  void ServoCluster::set_pulse(const uint8_t *servos, uint8_t length, float pulse, bool load) {
+  void ServoCluster::pulse(const uint8_t *servos, uint8_t length, float pulse, bool load) {
     assert(servos != nullptr);
     for(uint8_t i = 0; i < length; i++) {
-      set_pulse(servos[i], pulse, false);
+      this->pulse(servos[i], pulse, false);
     }
     if(load)
       pwms.load_pwm();
   }
 
-  void ServoCluster::set_pulse(std::initializer_list<uint8_t> servos, float pulse, bool load) {
+  void ServoCluster::pulse(std::initializer_list<uint8_t> servos, float pulse, bool load) {
     for(auto servo : servos) {
-      set_pulse(servo, pulse, false);
+      this->pulse(servo, pulse, false);
     }
     if(load)
       pwms.load_pwm();
   }
 
-  void ServoCluster::set_all_pulses(float pulse, bool load) {
+  void ServoCluster::all_to_pulse(float pulse, bool load) {
     uint8_t servo_count = pwms.get_chan_count();
     for(uint8_t servo = 0; servo < servo_count; servo++) {
-      set_pulse(servo, pulse, false);
+      this->pulse(servo, pulse, false);
     }
     if(load)
       pwms.load_pwm();
   }
 
-  float ServoCluster::get_value(uint servo) const {
+  float ServoCluster::value(uint servo) const {
     assert(servo < pwms.get_chan_count());
     return states[servo].get_value();
   }
 
-  void ServoCluster::set_value(uint servo, float value, bool load) {
+  void ServoCluster::value(uint servo, float value, bool load) {
     assert(servo < pwms.get_chan_count());
-    float new_pulse = states[servo].set_value(value);
+    float new_pulse = states[servo].set_value_with_return(value);
     apply_pulse(servo, new_pulse, load);
   }
 
-  void ServoCluster::set_value(const uint8_t *servos, uint8_t length, float value, bool load) {
+  void ServoCluster::value(const uint8_t *servos, uint8_t length, float value, bool load) {
     assert(servos != nullptr);
     for(uint8_t i = 0; i < length; i++) {
-      set_value(servos[i], value, false);
+      this->value(servos[i], value, false);
     }
     if(load)
       pwms.load_pwm();
   }
 
-  void ServoCluster::set_value(std::initializer_list<uint8_t> servos, float value, bool load) {
+  void ServoCluster::value(std::initializer_list<uint8_t> servos, float value, bool load) {
     for(auto servo : servos) {
-      set_value(servo, value, false);
+      this->value(servo, value, false);
     }
     if(load)
       pwms.load_pwm();
   }
 
-  void ServoCluster::set_all_values(float value, bool load) {
+  void ServoCluster::all_to_value(float value, bool load) {
     uint8_t servo_count = pwms.get_chan_count();
     for(uint8_t servo = 0; servo < servo_count; servo++) {
-      set_value(servo, value, false);
+      this->value(servo, value, false);
     }
     if(load)
       pwms.load_pwm();
   }
 
-  float ServoCluster::get_phase(uint servo) const {
+  float ServoCluster::phase(uint servo) const {
     assert(servo < pwms.get_chan_count());
     return servo_phases[servo];
   }
 
-  void ServoCluster::set_phase(uint servo, float phase, bool load) {
+  void ServoCluster::phase(uint servo, float phase, bool load) {
     assert(servo < pwms.get_chan_count());
     servo_phases[servo] = MIN(MAX(phase, 0.0f), 1.0f);
     pwms.set_chan_offset(servo, (uint32_t)(servo_phases[servo] * (float)pwms.get_wrap()), load);
   }
 
-  void ServoCluster::set_phase(const uint8_t *servos, uint8_t length, float phase, bool load) {
+  void ServoCluster::phase(const uint8_t *servos, uint8_t length, float phase, bool load) {
     assert(servos != nullptr);
     for(uint8_t i = 0; i < length; i++) {
-      set_phase(servos[i], phase, false);
+      this->phase(servos[i], phase, false);
     }
     if(load)
       pwms.load_pwm();
   }
 
-  void ServoCluster::set_phase(std::initializer_list<uint8_t> servos, float phase, bool load) {
+  void ServoCluster::phase(std::initializer_list<uint8_t> servos, float phase, bool load) {
     for(auto servo : servos) {
-      set_phase(servo, phase, false);
+      this->phase(servo, phase, false);
     }
     if(load)
       pwms.load_pwm();
   }
 
-  void ServoCluster::set_all_phases(float phase, bool load) {
+  void ServoCluster::all_to_phase(float phase, bool load) {
     uint8_t servo_count = pwms.get_chan_count();
     for(uint8_t servo = 0; servo < servo_count; servo++) {
-      set_phase(servo, phase, false);
+      this->phase(servo, phase, false);
     }
     if(load)
       pwms.load_pwm();
   }
 
-  float ServoCluster::get_frequency() const {
+  float ServoCluster::frequency() const {
     return pwm_frequency;
   }
 
-  bool ServoCluster::set_frequency(float freq) {
+  bool ServoCluster::frequency(float freq) {
     bool success = false;
 
     if((freq >= ServoState::MIN_FREQUENCY) && (freq <= ServoState::MAX_FREQUENCY)) {
@@ -306,24 +306,24 @@ namespace servo {
     return success;
   }
 
-  float ServoCluster::get_min_value(uint servo) const {
+  float ServoCluster::min_value(uint servo) const {
     assert(is_assigned(servo));
     return states[servo].get_min_value();
   }
 
-  float ServoCluster::get_mid_value(uint servo) const {
+  float ServoCluster::mid_value(uint servo) const {
     assert(is_assigned(servo));
     return states[servo].get_mid_value();
   }
 
-  float ServoCluster::get_max_value(uint servo) const {
+  float ServoCluster::max_value(uint servo) const {
     assert(is_assigned(servo));
     return states[servo].get_max_value();
   }
 
   void ServoCluster::to_min(uint servo, bool load) {
     assert(is_assigned(servo));
-    float new_pulse = states[servo].to_min();
+    float new_pulse = states[servo].to_min_with_return();
     apply_pulse(servo, new_pulse, load);
   }
 
@@ -355,7 +355,7 @@ namespace servo {
 
   void ServoCluster::to_mid(uint servo, bool load) {
     assert(is_assigned(servo));
-    float new_pulse = states[servo].to_mid();
+    float new_pulse = states[servo].to_mid_with_return();
     apply_pulse(servo, new_pulse, load);
   }
 
@@ -387,7 +387,7 @@ namespace servo {
 
   void ServoCluster::to_max(uint servo, bool load) {
     assert(is_assigned(servo));
-    float new_pulse = states[servo].to_max();
+    float new_pulse = states[servo].to_max_with_return();
     apply_pulse(servo, new_pulse, load);
   }
 
@@ -419,7 +419,7 @@ namespace servo {
 
   void ServoCluster::to_percent(uint servo, float in, float in_min, float in_max, bool load) {
     assert(is_assigned(servo));
-    float new_pulse = states[servo].to_percent(in, in_min, in_max);
+    float new_pulse = states[servo].to_percent_with_return(in, in_min, in_max);
     apply_pulse(servo, new_pulse, load);
   }
 
@@ -451,7 +451,7 @@ namespace servo {
 
   void ServoCluster::to_percent(uint servo, float in, float in_min, float in_max, float value_min, float value_max, bool load) {
     assert(is_assigned(servo));
-    float new_pulse = states[servo].to_percent(in, in_min, in_max, value_min, value_max);
+    float new_pulse = states[servo].to_percent_with_return(in, in_min, in_max, value_min, value_max);
     apply_pulse(servo, new_pulse, load);
   }
 
diff --git a/drivers/servo/servo_cluster.hpp b/drivers/servo/servo_cluster.hpp
index 1fb415e2..3633aa67 100644
--- a/drivers/servo/servo_cluster.hpp
+++ b/drivers/servo/servo_cluster.hpp
@@ -42,8 +42,8 @@ namespace servo {
   public:
     bool init();
 
-    uint8_t get_count() const;
-    uint8_t get_pin(uint8_t servo) const;
+    uint8_t count() const;
+    uint8_t pin(uint8_t servo) const;
 
     void enable(uint servo, bool load = true);
     void enable(const uint8_t *servos, uint8_t length, bool load = true);
@@ -57,31 +57,31 @@ namespace servo {
 
     bool is_enabled(uint servo) const;
 
-    float get_pulse(uint servo) const;
-    void set_pulse(uint servo, float pulse, bool load = true);
-    void set_pulse(const uint8_t *servos, uint8_t length, float pulse, bool load = true);
-    void set_pulse(std::initializer_list<uint8_t> servos, float pulse, bool load = true);
-    void set_all_pulses(float pulse, bool load = true);
+    float pulse(uint servo) const;
+    void pulse(uint servo, float pulse, bool load = true);
+    void pulse(const uint8_t *servos, uint8_t length, float pulse, bool load = true);
+    void pulse(std::initializer_list<uint8_t> servos, float pulse, bool load = true);
+    void all_to_pulse(float pulse, bool load = true);
 
-    float get_value(uint servo) const;
-    void set_value(uint servo, float value, bool load = true);
-    void set_value(const uint8_t *servos, uint8_t length, float value, bool load = true);
-    void set_value(std::initializer_list<uint8_t> servos, float value, bool load = true);
-    void set_all_values(float value, bool load = true);
+    float value(uint servo) const;
+    void value(uint servo, float value, bool load = true);
+    void value(const uint8_t *servos, uint8_t length, float value, bool load = true);
+    void value(std::initializer_list<uint8_t> servos, float value, bool load = true);
+    void all_to_value(float value, bool load = true);
 
-    float get_phase(uint servo) const;
-    void set_phase(uint servo, float phase, bool load = true);
-    void set_phase(const uint8_t *servos, uint8_t length, float phase, bool load = true);
-    void set_phase(std::initializer_list<uint8_t> servos, float phase, bool load = true);
-    void set_all_phases(float phase, bool load = true);
+    float phase(uint servo) const;
+    void phase(uint servo, float phase, bool load = true);
+    void phase(const uint8_t *servos, uint8_t length, float phase, bool load = true);
+    void phase(std::initializer_list<uint8_t> servos, float phase, bool load = true);
+    void all_to_phase(float phase, bool load = true);
 
-    float get_frequency() const;
-    bool set_frequency(float freq);
+    float frequency() const;
+    bool frequency(float freq);
 
     //--------------------------------------------------
-    float get_min_value(uint servo) const;
-    float get_mid_value(uint servo) const;
-    float get_max_value(uint servo) const;
+    float min_value(uint servo) const;
+    float mid_value(uint servo) const;
+    float max_value(uint servo) const;
 
     void to_min(uint servo, bool load = true);
     void to_min(const uint8_t *servos, uint8_t length, bool load = true);
diff --git a/drivers/servo/servo_state.cpp b/drivers/servo/servo_state.cpp
index 7a08c69d..85cea537 100644
--- a/drivers/servo/servo_state.cpp
+++ b/drivers/servo/servo_state.cpp
@@ -16,7 +16,7 @@ namespace servo {
     // Has the servo not had a pulse value set before being enabled?
     if(last_enabled_pulse < MIN_VALID_PULSE) {
       // Set the servo to its middle
-      return to_mid();
+      return to_mid_with_return();
     }
     return _enable();
   }
@@ -39,7 +39,7 @@ namespace servo {
     return last_enabled_pulse;
   }
 
-  float ServoState::set_pulse(float pulse) {
+  float ServoState::set_pulse_with_return(float pulse) {
     if(pulse >= MIN_VALID_PULSE) {
       float value_out, pulse_out;
       if(calib.pulse_to_value(pulse, value_out, pulse_out)) {
@@ -55,7 +55,7 @@ namespace servo {
     return servo_value;
   }
 
-  float ServoState::set_value(float value) {
+  float ServoState::set_value_with_return(float value) {
     float pulse_out, value_out;
     if(calib.value_to_pulse(value, pulse_out, value_out)) {
       last_enabled_pulse = pulse_out;
@@ -91,26 +91,26 @@ namespace servo {
     return value;
   }
 
-  float ServoState::to_min() {
-    return set_value(get_min_value());
+  float ServoState::to_min_with_return() {
+    return set_value_with_return(get_min_value());
   }
 
-  float ServoState::to_mid() {
-    return set_value(get_mid_value());
+  float ServoState::to_mid_with_return() {
+    return set_value_with_return(get_mid_value());
   }
 
-  float ServoState::to_max() {
-    return set_value(get_max_value());
+  float ServoState::to_max_with_return() {
+    return set_value_with_return(get_max_value());
   }
 
-  float ServoState::to_percent(float in, float in_min, float in_max) {
+  float ServoState::to_percent_with_return(float in, float in_min, float in_max) {
     float value = Calibration::map_float(in, in_min, in_max, get_min_value(), get_max_value());
-    return set_value(value);
+    return set_value_with_return(value);
   }
 
-  float ServoState::to_percent(float in, float in_min, float in_max, float value_min, float value_max) {
+  float ServoState::to_percent_with_return(float in, float in_min, float in_max, float value_min, float value_max) {
     float value = Calibration::map_float(in, in_min, in_max, value_min, value_max);
-    return set_value(value);
+    return set_value_with_return(value);
   }
 
   Calibration& ServoState::calibration() {
diff --git a/drivers/servo/servo_state.hpp b/drivers/servo/servo_state.hpp
index 3246091a..9d74f443 100644
--- a/drivers/servo/servo_state.hpp
+++ b/drivers/servo/servo_state.hpp
@@ -51,21 +51,21 @@ namespace servo {
     float _enable(); // Internal version of enable without convenient initialisation to the middle
   public:
     float get_pulse() const;
-    float set_pulse(float pulse);
+    float set_pulse_with_return(float pulse);
 
     float get_value() const;
-    float set_value(float value);
+    float set_value_with_return(float value);
 
   public:
     float get_min_value() const;
     float get_mid_value() const;
     float get_max_value() const;
 
-    float to_min();
-    float to_mid();
-    float to_max();
-    float to_percent(float in, float in_min = ZERO_PERCENT, float in_max = ONEHUNDRED_PERCENT);
-    float to_percent(float in, float in_min, float in_max, float value_min, float value_max);
+    float to_min_with_return();
+    float to_mid_with_return();
+    float to_max_with_return();
+    float to_percent_with_return(float in, float in_min = ZERO_PERCENT, float in_max = ONEHUNDRED_PERCENT);
+    float to_percent_with_return(float in, float in_min, float in_max, float value_min, float value_max);
 
     Calibration& calibration();
     const Calibration& calibration() const;
diff --git a/examples/servo2040/servo2040_multiple_servos.cpp b/examples/servo2040/servo2040_multiple_servos.cpp
index ee07cd75..52de5685 100644
--- a/examples/servo2040/servo2040_multiple_servos.cpp
+++ b/examples/servo2040/servo2040_multiple_servos.cpp
@@ -65,7 +65,7 @@ int main() {
     for(auto i = 0u; i < 360; i++) {
       float value = sin(((float)i * (float)M_PI) / 180.0f) * SWEEP_EXTENT;
       for(auto s = 0u; s < NUM_SERVOS; s++) {
-        servos[s]->set_value(value);
+        servos[s]->value(value);
       }
       sleep_ms(20);
     }
diff --git a/examples/servo2040/servo2040_servo_cluster.cpp b/examples/servo2040/servo2040_servo_cluster.cpp
index ae4a6542..8ac77a0d 100644
--- a/examples/servo2040/servo2040_servo_cluster.cpp
+++ b/examples/servo2040/servo2040_servo_cluster.cpp
@@ -52,7 +52,7 @@ int main() {
   // Do a sine sweep
   for(auto j = 0u; j < SWEEPS; j++) {
     for(auto i = 0u; i < 360; i++) {
-      servos.set_all_values(sin(((float)i * (float)M_PI) / 180.0f) * SWEEP_EXTENT);
+      servos.all_to_value(sin(((float)i * (float)M_PI) / 180.0f) * SWEEP_EXTENT);
       sleep_ms(20);
     }
   }
diff --git a/examples/servo2040/servo2040_servo_wave.cpp b/examples/servo2040/servo2040_servo_wave.cpp
index d15c8e7e..1788de0f 100644
--- a/examples/servo2040/servo2040_servo_wave.cpp
+++ b/examples/servo2040/servo2040_servo_wave.cpp
@@ -60,9 +60,9 @@ int main() {
     }
 
     // Update all the Servos
-    for(auto i = 0u; i < servos.get_count(); i++) {
-        float angle = (((float)i / (float)servos.get_count()) + offset) * (float)M_TWOPI;
-        servos.set_value(i, sin(angle) * SERVO_EXTENT, false);
+    for(auto i = 0u; i < servos.count(); i++) {
+        float angle = (((float)i / (float)servos.count()) + offset) * (float)M_TWOPI;
+        servos.value(i, sin(angle) * SERVO_EXTENT, false);
     }
     // We have now set all the servo values, so load them
     servos.load();
diff --git a/examples/servo2040/servo2040_simple_easing.cpp b/examples/servo2040/servo2040_simple_easing.cpp
index 9119102e..4eacb11d 100644
--- a/examples/servo2040/servo2040_simple_easing.cpp
+++ b/examples/servo2040/servo2040_simple_easing.cpp
@@ -40,7 +40,7 @@ int main() {
   s.init();
 
   // Get the initial value and create a random end value between the extents
-  float start_value = s.get_mid_value();
+  float start_value = s.mid_value();
   float end_value = (((float)rand() / (float)RAND_MAX) * (SERVO_EXTENT * 2.0f)) - SERVO_EXTENT;
 
   uint update = 0;
@@ -61,7 +61,7 @@ int main() {
     }
 
     // Print out the value the servo is now at
-    printf("Value = %f\n", s.get_value());
+    printf("Value = %f\n", s.value());
 
     // Move along in time
     update++;
diff --git a/examples/servo2040/servo2040_single_servo.cpp b/examples/servo2040/servo2040_single_servo.cpp
index 04f5ee1b..baa596a1 100644
--- a/examples/servo2040/servo2040_single_servo.cpp
+++ b/examples/servo2040/servo2040_single_servo.cpp
@@ -50,7 +50,7 @@ int main() {
   // Do a sine sweep
   for(auto j = 0u; j < SWEEPS; j++) {
     for(auto i = 0u; i < 360; i++) {
-      s.set_value(sin(((float)i * (float)M_PI) / 180.0f) * SWEEP_EXTENT);
+      s.value(sin(((float)i * (float)M_PI) / 180.0f) * SWEEP_EXTENT);
       sleep_ms(20);
     }
   }
diff --git a/micropython/modules/servo/servo.cpp b/micropython/modules/servo/servo.cpp
index 8bcbb62b..47a07dbb 100644
--- a/micropython/modules/servo/servo.cpp
+++ b/micropython/modules/servo/servo.cpp
@@ -837,15 +837,15 @@ void Servo_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind
     mp_print_str(print, "Servo(");
 
     mp_print_str(print, "pin = ");
-    mp_obj_print_helper(print, mp_obj_new_int(self->servo->get_pin()), PRINT_REPR);
+    mp_obj_print_helper(print, mp_obj_new_int(self->servo->pin()), PRINT_REPR);
     mp_print_str(print, ", enabled = ");
     mp_obj_print_helper(print, self->servo->is_enabled() ? mp_const_true : mp_const_false, PRINT_REPR);
     mp_print_str(print, ", pulse = ");
-    mp_obj_print_helper(print, mp_obj_new_float(self->servo->get_pulse()), PRINT_REPR);
+    mp_obj_print_helper(print, mp_obj_new_float(self->servo->pulse()), PRINT_REPR);
     mp_print_str(print, ", value = ");
-    mp_obj_print_helper(print, mp_obj_new_float(self->servo->get_value()), PRINT_REPR);
+    mp_obj_print_helper(print, mp_obj_new_float(self->servo->value()), PRINT_REPR);
     mp_print_str(print, ", freq = ");
-    mp_obj_print_helper(print, mp_obj_new_float(self->servo->get_frequency()), PRINT_REPR);
+    mp_obj_print_helper(print, mp_obj_new_float(self->servo->frequency()), PRINT_REPR);
 
     mp_print_str(print, ")");
 }
@@ -916,7 +916,7 @@ mp_obj_t Servo___del__(mp_obj_t self_in) {
 /***** Methods *****/
 extern mp_obj_t Servo_pin(mp_obj_t self_in) {
     _Servo_obj_t *self = MP_OBJ_TO_PTR2(self_in, _Servo_obj_t);
-    return mp_obj_new_int(self->servo->get_pin());
+    return mp_obj_new_int(self->servo->pin());
 }
 
 extern mp_obj_t Servo_enable(mp_obj_t self_in) {
@@ -949,7 +949,7 @@ extern mp_obj_t Servo_pulse(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
 
         _Servo_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _Servo_obj_t);
 
-        return mp_obj_new_float(self->servo->get_pulse());
+        return mp_obj_new_float(self->servo->pulse());
     }
     else {
         enum { ARG_self, ARG_pulse };
@@ -966,7 +966,7 @@ extern mp_obj_t Servo_pulse(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
 
         float pulse = mp_obj_get_float(args[ARG_pulse].u_obj);
 
-        self->servo->set_pulse(pulse);
+        self->servo->pulse(pulse);
         return mp_const_none;
     }
 }
@@ -984,7 +984,7 @@ extern mp_obj_t Servo_value(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
 
         _Servo_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _Servo_obj_t);
 
-        return mp_obj_new_float(self->servo->get_value());
+        return mp_obj_new_float(self->servo->value());
     }
     else {
         enum { ARG_self, ARG_value };
@@ -1001,7 +1001,7 @@ extern mp_obj_t Servo_value(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
 
         float value = mp_obj_get_float(args[ARG_value].u_obj);
 
-        self->servo->set_value(value);
+        self->servo->value(value);
         return mp_const_none;
     }
 }
@@ -1019,7 +1019,7 @@ extern mp_obj_t Servo_frequency(size_t n_args, const mp_obj_t *pos_args, mp_map_
 
         _Servo_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _Servo_obj_t);
 
-        return mp_obj_new_float(self->servo->get_frequency());
+        return mp_obj_new_float(self->servo->frequency());
     }
     else {
         enum { ARG_self, ARG_freq };
@@ -1036,7 +1036,7 @@ extern mp_obj_t Servo_frequency(size_t n_args, const mp_obj_t *pos_args, mp_map_
 
         float freq = mp_obj_get_float(args[ARG_freq].u_obj);
 
-        if(!self->servo->set_frequency(freq)) {
+        if(!self->servo->frequency(freq)) {
             mp_raise_ValueError("freq out of range. Expected 10Hz to 350Hz");
         }
         return mp_const_none;
@@ -1045,17 +1045,17 @@ extern mp_obj_t Servo_frequency(size_t n_args, const mp_obj_t *pos_args, mp_map_
 
 extern mp_obj_t Servo_min_value(mp_obj_t self_in) {
     _Servo_obj_t *self = MP_OBJ_TO_PTR2(self_in, _Servo_obj_t);
-    return mp_obj_new_float(self->servo->get_min_value());
+    return mp_obj_new_float(self->servo->min_value());
 }
 
 extern mp_obj_t Servo_mid_value(mp_obj_t self_in) {
     _Servo_obj_t *self = MP_OBJ_TO_PTR2(self_in, _Servo_obj_t);
-    return mp_obj_new_float(self->servo->get_mid_value());
+    return mp_obj_new_float(self->servo->mid_value());
 }
 
 extern mp_obj_t Servo_max_value(mp_obj_t self_in) {
     _Servo_obj_t *self = MP_OBJ_TO_PTR2(self_in, _Servo_obj_t);
-    return mp_obj_new_float(self->servo->get_max_value());
+    return mp_obj_new_float(self->servo->max_value());
 }
 
 extern mp_obj_t Servo_to_min(mp_obj_t self_in) {
@@ -1212,18 +1212,18 @@ void ServoCluster_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind
 
     mp_print_str(print, "servos = {");
 
-    uint8_t servo_count = self->cluster->get_count();
+    uint8_t servo_count = self->cluster->count();
     for(uint8_t servo = 0; servo < servo_count; servo++) {
         mp_print_str(print, "\n\t{pin = ");
-        mp_obj_print_helper(print, mp_obj_new_int(self->cluster->get_pin(servo)), PRINT_REPR);
+        mp_obj_print_helper(print, mp_obj_new_int(self->cluster->pin(servo)), PRINT_REPR);
         mp_print_str(print, ", enabled = ");
         mp_obj_print_helper(print, self->cluster->is_enabled(servo) ? mp_const_true : mp_const_false, PRINT_REPR);
         mp_print_str(print, ", pulse = ");
-        mp_obj_print_helper(print, mp_obj_new_float(self->cluster->get_pulse(servo)), PRINT_REPR);
+        mp_obj_print_helper(print, mp_obj_new_float(self->cluster->pulse(servo)), PRINT_REPR);
         mp_print_str(print, ", value = ");
-        mp_obj_print_helper(print, mp_obj_new_float(self->cluster->get_value(servo)), PRINT_REPR);
+        mp_obj_print_helper(print, mp_obj_new_float(self->cluster->value(servo)), PRINT_REPR);
         mp_print_str(print, ", phase = ");
-        mp_obj_print_helper(print, mp_obj_new_float(self->cluster->get_phase(servo)), PRINT_REPR);
+        mp_obj_print_helper(print, mp_obj_new_float(self->cluster->phase(servo)), PRINT_REPR);
         mp_print_str(print, "}");
         if(servo < servo_count - 1)
             mp_print_str(print, ", ");
@@ -1232,7 +1232,7 @@ void ServoCluster_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind
         mp_print_str(print, "\n");
     }
     mp_print_str(print, "}, freq = ");
-    mp_obj_print_helper(print, mp_obj_new_float(self->cluster->get_frequency()), PRINT_REPR);
+    mp_obj_print_helper(print, mp_obj_new_float(self->cluster->frequency()), PRINT_REPR);
 
     mp_print_str(print, ")");
 }
@@ -1377,7 +1377,7 @@ mp_obj_t ServoCluster___del__(mp_obj_t self_in) {
 /***** Methods *****/
 extern mp_obj_t ServoCluster_count(mp_obj_t self_in) {
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(self_in, _ServoCluster_obj_t);
-    return mp_obj_new_int(self->cluster->get_count());
+    return mp_obj_new_int(self->cluster->count());
 }
 
 extern mp_obj_t ServoCluster_pin(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
@@ -1394,13 +1394,13 @@ extern mp_obj_t ServoCluster_pin(size_t n_args, const mp_obj_t *pos_args, mp_map
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
     int servo = args[ARG_servo].u_int;
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else if(servo < 0 || servo >= servo_count)
         mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("servo out of range. Expected 0 to %d"), servo_count - 1);
     else
-        return mp_obj_new_int(self->cluster->get_pin((uint)servo));
+        return mp_obj_new_int(self->cluster->pin((uint)servo));
 
     return mp_const_none;
 }
@@ -1419,7 +1419,7 @@ extern mp_obj_t ServoCluster_enable(size_t n_args, const mp_obj_t *pos_args, mp_
 
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else {
@@ -1503,7 +1503,7 @@ extern mp_obj_t ServoCluster_disable(size_t n_args, const mp_obj_t *pos_args, mp
 
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else {
@@ -1587,7 +1587,7 @@ extern mp_obj_t ServoCluster_is_enabled(size_t n_args, const mp_obj_t *pos_args,
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
     int servo = args[ARG_servo].u_int;
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else if(servo < 0 || servo >= servo_count)
@@ -1613,13 +1613,13 @@ extern mp_obj_t ServoCluster_pulse(size_t n_args, const mp_obj_t *pos_args, mp_m
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
         int servo = args[ARG_servo].u_int;
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else if(servo < 0 || servo >= servo_count)
             mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("servo out of range. Expected 0 to %d"), servo_count - 1);
         else
-            return mp_obj_new_float(self->cluster->get_pulse((uint)servo));
+            return mp_obj_new_float(self->cluster->pulse((uint)servo));
     }
     else {
         enum { ARG_self, ARG_servos, ARG_pulse, ARG_load };
@@ -1636,7 +1636,7 @@ extern mp_obj_t ServoCluster_pulse(size_t n_args, const mp_obj_t *pos_args, mp_m
 
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else {
@@ -1648,7 +1648,7 @@ extern mp_obj_t ServoCluster_pulse(size_t n_args, const mp_obj_t *pos_args, mp_m
                     mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("servo out of range. Expected 0 to %d"), servo_count - 1);
                 else {
                     float pulse = mp_obj_get_float(args[ARG_pulse].u_obj);
-                    self->cluster->set_pulse((uint)servo, pulse, args[ARG_load].u_bool);
+                    self->cluster->pulse((uint)servo, pulse, args[ARG_load].u_bool);
                 }
             }
             else {
@@ -1683,7 +1683,7 @@ extern mp_obj_t ServoCluster_pulse(size_t n_args, const mp_obj_t *pos_args, mp_m
                         }
                     }
                     float pulse = mp_obj_get_float(args[ARG_pulse].u_obj);
-                    self->cluster->set_pulse(servos, length, pulse, args[ARG_load].u_bool);
+                    self->cluster->pulse(servos, length, pulse, args[ARG_load].u_bool);
                     delete[] servos;
                 }
             }
@@ -1693,30 +1693,6 @@ extern mp_obj_t ServoCluster_pulse(size_t n_args, const mp_obj_t *pos_args, mp_m
 }
 
 extern mp_obj_t ServoCluster_all_to_pulse(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    /*if(n_args <= 1) {
-        enum { ARG_self };
-        static const mp_arg_t allowed_args[] = {
-            { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
-        };
-
-        // Parse args.
-        mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
-        mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-
-        _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
-
-        uint servo_count = self->cluster->get_count();
-        if(servo_count == 0)
-            mp_raise_ValueError("this cluster does not have any servos");
-        else {
-            mp_obj_tuple_t *tuple = MP_OBJ_TO_PTR2(mp_obj_new_tuple(servo_count, NULL), mp_obj_tuple_t);
-            for(uint servo = 0; servo < servo_count; servo++) {
-                tuple->items[servo] = mp_obj_new_float(self->cluster->get_pulse(servo));
-            }
-            return MP_OBJ_FROM_PTR(tuple);
-        }
-    }
-    else {*/
     enum { ARG_self, ARG_pulse, ARG_load };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
@@ -1730,14 +1706,13 @@ extern mp_obj_t ServoCluster_all_to_pulse(size_t n_args, const mp_obj_t *pos_arg
 
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else {
         float pulse = mp_obj_get_float(args[ARG_pulse].u_obj);
-        self->cluster->set_all_pulses(pulse, args[ARG_load].u_bool);
+        self->cluster->all_to_pulse(pulse, args[ARG_load].u_bool);
     }
-    //}
     return mp_const_none;
 }
 
@@ -1756,13 +1731,13 @@ extern mp_obj_t ServoCluster_value(size_t n_args, const mp_obj_t *pos_args, mp_m
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
         int servo = args[ARG_servo].u_int;
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else if(servo < 0 || servo >= servo_count)
             mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("servo out of range. Expected 0 to %d"), servo_count - 1);
         else
-            return mp_obj_new_float(self->cluster->get_value((uint)servo));
+            return mp_obj_new_float(self->cluster->value((uint)servo));
     }
     else {
         enum { ARG_self, ARG_servos, ARG_value, ARG_load };
@@ -1779,7 +1754,7 @@ extern mp_obj_t ServoCluster_value(size_t n_args, const mp_obj_t *pos_args, mp_m
 
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else {
@@ -1791,7 +1766,7 @@ extern mp_obj_t ServoCluster_value(size_t n_args, const mp_obj_t *pos_args, mp_m
                     mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("servo out of range. Expected 0 to %d"), servo_count - 1);
                 else {
                     float value = mp_obj_get_float(args[ARG_value].u_obj);
-                    self->cluster->set_value((uint)servo, value, args[ARG_load].u_bool);
+                    self->cluster->value((uint)servo, value, args[ARG_load].u_bool);
                 }
             }
             else {
@@ -1826,7 +1801,7 @@ extern mp_obj_t ServoCluster_value(size_t n_args, const mp_obj_t *pos_args, mp_m
                         }
                     }
                     float value = mp_obj_get_float(args[ARG_value].u_obj);
-                    self->cluster->set_value(servos, length, value, args[ARG_load].u_bool);
+                    self->cluster->value(servos, length, value, args[ARG_load].u_bool);
                     delete[] servos;
                 }
             }
@@ -1836,30 +1811,6 @@ extern mp_obj_t ServoCluster_value(size_t n_args, const mp_obj_t *pos_args, mp_m
 }
 
 extern mp_obj_t ServoCluster_all_to_value(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    /*if(n_args <= 1) {
-        enum { ARG_self, ARG_servo };
-        static const mp_arg_t allowed_args[] = {
-            { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
-        };
-
-        // Parse args.
-        mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
-        mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-
-        _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
-
-        uint servo_count = self->cluster->get_count();
-        if(servo_count == 0)
-            mp_raise_ValueError("this cluster does not have any servos");
-        else {
-            mp_obj_tuple_t *tuple = MP_OBJ_TO_PTR2(mp_obj_new_tuple(servo_count, NULL), mp_obj_tuple_t);
-            for(uint servo = 0; servo < servo_count; servo++) {
-                tuple->items[servo] = mp_obj_new_float(self->cluster->get_value(servo));
-            }
-            return MP_OBJ_FROM_PTR(tuple);
-        }
-    }
-    else {*/
     enum { ARG_self, ARG_value, ARG_load };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
@@ -1873,14 +1824,13 @@ extern mp_obj_t ServoCluster_all_to_value(size_t n_args, const mp_obj_t *pos_arg
 
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else {
         float value = mp_obj_get_float(args[ARG_value].u_obj);
-        self->cluster->set_all_values(value, args[ARG_load].u_bool);
+        self->cluster->all_to_value(value, args[ARG_load].u_bool);
     }
-    //}
     return mp_const_none;
 }
 
@@ -1899,13 +1849,13 @@ extern mp_obj_t ServoCluster_phase(size_t n_args, const mp_obj_t *pos_args, mp_m
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
         int servo = args[ARG_servo].u_int;
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else if(servo < 0 || servo >= servo_count)
             mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("servo out of range. Expected 0 to %d"), servo_count - 1);
         else
-            return mp_obj_new_float(self->cluster->get_phase((uint)servo));
+            return mp_obj_new_float(self->cluster->phase((uint)servo));
     }
     else {
         enum { ARG_self, ARG_servos, ARG_phase, ARG_load };
@@ -1922,7 +1872,7 @@ extern mp_obj_t ServoCluster_phase(size_t n_args, const mp_obj_t *pos_args, mp_m
 
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else {
@@ -1934,7 +1884,7 @@ extern mp_obj_t ServoCluster_phase(size_t n_args, const mp_obj_t *pos_args, mp_m
                     mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("servo out of range. Expected 0 to %d"), servo_count - 1);
                 else {
                     float phase = mp_obj_get_float(args[ARG_phase].u_obj);
-                    self->cluster->set_phase((uint)servo, phase, args[ARG_load].u_bool);
+                    self->cluster->phase((uint)servo, phase, args[ARG_load].u_bool);
                 }
             }
             else {
@@ -1969,7 +1919,7 @@ extern mp_obj_t ServoCluster_phase(size_t n_args, const mp_obj_t *pos_args, mp_m
                         }
                     }
                     float phase = mp_obj_get_float(args[ARG_phase].u_obj);
-                    self->cluster->set_phase(servos, length, phase, args[ARG_load].u_bool);
+                    self->cluster->phase(servos, length, phase, args[ARG_load].u_bool);
                     delete[] servos;
                 }
             }
@@ -1979,30 +1929,6 @@ extern mp_obj_t ServoCluster_phase(size_t n_args, const mp_obj_t *pos_args, mp_m
 }
 
 extern mp_obj_t ServoCluster_all_to_phase(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    /*if(n_args <= 1) {
-        enum { ARG_self };
-        static const mp_arg_t allowed_args[] = {
-            { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
-        };
-
-        // Parse args.
-        mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
-        mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-
-        _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
-
-        uint servo_count = self->cluster->get_count();
-        if(servo_count == 0)
-            mp_raise_ValueError("this cluster does not have any servos");
-        else {
-            mp_obj_tuple_t *tuple = MP_OBJ_TO_PTR2(mp_obj_new_tuple(servo_count, NULL), mp_obj_tuple_t);
-            for(uint servo = 0; servo < servo_count; servo++) {
-                tuple->items[servo] = mp_obj_new_float(self->cluster->get_phase(servo));
-            }
-            return MP_OBJ_FROM_PTR(tuple);
-        }
-    }
-    else {*/
     enum { ARG_self, ARG_phase, ARG_load };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
@@ -2016,14 +1942,13 @@ extern mp_obj_t ServoCluster_all_to_phase(size_t n_args, const mp_obj_t *pos_arg
 
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else {
         float phase = mp_obj_get_float(args[ARG_phase].u_obj);
-        self->cluster->set_all_phases(phase, args[ARG_load].u_bool);
+        self->cluster->all_to_phase(phase, args[ARG_load].u_bool);
     }
-    //}
     return mp_const_none;
 }
 
@@ -2040,7 +1965,7 @@ extern mp_obj_t ServoCluster_frequency(size_t n_args, const mp_obj_t *pos_args,
 
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-        return mp_obj_new_float(self->cluster->get_frequency());
+        return mp_obj_new_float(self->cluster->frequency());
     }
     else {
         enum { ARG_self, ARG_freq };
@@ -2057,7 +1982,7 @@ extern mp_obj_t ServoCluster_frequency(size_t n_args, const mp_obj_t *pos_args,
 
         float freq = mp_obj_get_float(args[ARG_freq].u_obj);
 
-        if(!self->cluster->set_frequency(freq))
+        if(!self->cluster->frequency(freq))
             mp_raise_ValueError("freq out of range. Expected 10Hz to 350Hz");
         else
             return mp_const_none;
@@ -2078,13 +2003,13 @@ extern mp_obj_t ServoCluster_min_value(size_t n_args, const mp_obj_t *pos_args,
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
     int servo = args[ARG_servo].u_int;
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else if(servo < 0 || servo >= servo_count)
         mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("servo out of range. Expected 0 to %d"), servo_count - 1);
     else
-        return mp_obj_new_float(self->cluster->get_min_value((uint)servo));
+        return mp_obj_new_float(self->cluster->min_value((uint)servo));
 
     return mp_const_none;
 }
@@ -2103,13 +2028,13 @@ extern mp_obj_t ServoCluster_mid_value(size_t n_args, const mp_obj_t *pos_args,
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
     int servo = args[ARG_servo].u_int;
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else if(servo < 0 || servo >= servo_count)
         mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("servo out of range. Expected 0 to %d"), servo_count - 1);
     else
-        return mp_obj_new_float(self->cluster->get_mid_value((uint)servo));
+        return mp_obj_new_float(self->cluster->mid_value((uint)servo));
 
     return mp_const_none;
 }
@@ -2128,13 +2053,13 @@ extern mp_obj_t ServoCluster_max_value(size_t n_args, const mp_obj_t *pos_args,
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
     int servo = args[ARG_servo].u_int;
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else if(servo < 0 || servo >= servo_count)
         mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("servo out of range. Expected 0 to %d"), servo_count - 1);
     else
-        return mp_obj_new_float(self->cluster->get_max_value((uint)servo));
+        return mp_obj_new_float(self->cluster->max_value((uint)servo));
 
     return mp_const_none;
 }
@@ -2153,7 +2078,7 @@ extern mp_obj_t ServoCluster_to_min(size_t n_args, const mp_obj_t *pos_args, mp_
 
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else {
@@ -2218,7 +2143,7 @@ extern mp_obj_t ServoCluster_all_to_min(size_t n_args, const mp_obj_t *pos_args,
 
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else {
@@ -2241,7 +2166,7 @@ extern mp_obj_t ServoCluster_to_mid(size_t n_args, const mp_obj_t *pos_args, mp_
 
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else {
@@ -2306,7 +2231,7 @@ extern mp_obj_t ServoCluster_all_to_mid(size_t n_args, const mp_obj_t *pos_args,
 
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else {
@@ -2329,7 +2254,7 @@ extern mp_obj_t ServoCluster_to_max(size_t n_args, const mp_obj_t *pos_args, mp_
 
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else {
@@ -2394,7 +2319,7 @@ extern mp_obj_t ServoCluster_all_to_max(size_t n_args, const mp_obj_t *pos_args,
 
     _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-    int servo_count = (int)self->cluster->get_count();
+    int servo_count = (int)self->cluster->count();
     if(servo_count == 0)
         mp_raise_ValueError("this cluster does not have any servos");
     else {
@@ -2419,7 +2344,7 @@ extern mp_obj_t ServoCluster_to_percent(size_t n_args, const mp_obj_t *pos_args,
 
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else {
@@ -2489,7 +2414,7 @@ extern mp_obj_t ServoCluster_to_percent(size_t n_args, const mp_obj_t *pos_args,
 
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else {
@@ -2565,7 +2490,7 @@ extern mp_obj_t ServoCluster_to_percent(size_t n_args, const mp_obj_t *pos_args,
 
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else {
@@ -2644,7 +2569,7 @@ extern mp_obj_t ServoCluster_all_to_percent(size_t n_args, const mp_obj_t *pos_a
 
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else {
@@ -2668,7 +2593,7 @@ extern mp_obj_t ServoCluster_all_to_percent(size_t n_args, const mp_obj_t *pos_a
 
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else {
@@ -2696,7 +2621,7 @@ extern mp_obj_t ServoCluster_all_to_percent(size_t n_args, const mp_obj_t *pos_a
 
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else {
@@ -2726,7 +2651,7 @@ extern mp_obj_t ServoCluster_calibration(size_t n_args, const mp_obj_t *pos_args
         _ServoCluster_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, _ServoCluster_obj_t);
 
         int servo = args[ARG_servo].u_int;
-        int servo_count = (int)self->cluster->get_count();
+        int servo_count = (int)self->cluster->count();
         if(servo_count == 0)
             mp_raise_ValueError("this cluster does not have any servos");
         else if(servo < 0 || servo >= servo_count)