Motor.h

//
// Motor.h
//
// Copyright (c) 2025 Embedded Technology Software Design Robot Contest
//
 
#ifndef SPIKE_CPP_API_MOTOR_H_ 
#define SPIKE_CPP_API_MOTOR_H_
 
#include <stdint.h>
extern "C" {
#include <pup/motor.h>
}
 
#include "Port.h"
 
namespace spikeapi {
class Motor
{
public:
 
  enum class EDirection {
    CLOCKWISE = PUP_DIRECTION_CLOCKWISE,
    COUNTERCLOCKWISE = PUP_DIRECTION_COUNTERCLOCKWISE,
  };
   
  Motor(EPort port,EDirection direction = EDirection::CLOCKWISE, bool reset_count = true) : mHasError(false) { 
    mMotor = pup_motor_get_device(static_cast<pbio_port_id_t>(port));
    if ( !mMotor ) {
      mHasError = true;
      return;
    }
    pbio_error_t ret = pup_motor_setup(mMotor, static_cast<pup_direction_t>(direction), reset_count);
    if ( ret != PBIO_SUCCESS ) {
      mHasError = true;
    }
  }
     
  void resetCount() const { 
    pup_motor_reset_count(mMotor); 
  } 
     
  int32_t getCount() const { 
    return pup_motor_get_count(mMotor); 
  } 
     
  int32_t getSpeed() const { 
    return pup_motor_get_speed(mMotor);
  } 
     
  void setSpeed(int speed) const { 
    pup_motor_set_speed(mMotor, speed); 
  } 
     
  int32_t getPower() const { 
    return pup_motor_get_power(mMotor); 
  } 
     
  void setPower(int power) const { 
    pup_motor_set_power(mMotor, power); 
  } 
     
  void stop() const { 
    pup_motor_stop(mMotor); 
  } 
     
  void brake() const { 
    pup_motor_brake(mMotor); 
  } 
     
  void hold() const { 
    pup_motor_hold(mMotor); 
  } 
     
  bool isStalled() const { 
    return pup_motor_is_stalled(mMotor); 
  } 
     
  int32_t setDutyLimit(int duty_limit) const { 
    return pup_motor_set_duty_limit(mMotor, duty_limit); 
  } 
     
  void restoreDutyLimit(int old_value) const { 
    pup_motor_restore_duty_limit(mMotor, old_value); 
  }

  bool hasError() { return mHasError; }
  
  
private: 
  pup_motor_t *mMotor;
  bool mHasError;
  
}; // class Motor
}  // namespace spikeapi
 
#endif // !SPIKE_CPP_API_MOTOR_H_