//steppermotorA4988withclass_singleDEMO.ino
// A4988ステッピングモータードライバーモジュール

#include "StepperMotorESP32.h"

StepperMotorESP32 stepper;

uint32_t MinPulsePeriod = 200; //[microsec]
uint32_t ControlFrequency = 100; //[Hz]
const uint8_t PinDIR  = D0;
const uint8_t PinSTEP = D1;
const uint8_t PinEnable = D6; // モータドライブEnable（府論理）に使用する PIN番号

int MaxControlValue;

void setup() {
  Serial.begin(115200);
  delay(100);
  Serial.println("Hello");

  stepper.setPins(PinDIR, PinSTEP, PinEnable);
  stepper.setDirModifier(1);
  MaxControlValue = stepper.getMaxControlValue(ControlFrequency, MinPulsePeriod);
  Serial.print("MaxControlValue = ");
  Serial.println(MaxControlValue);
  stepper.enableDriver();
}

void loop() {
  static int control = 0;
  static int dcontrol = 1;
  static int n=0;
  int res;
  double fcontrol = (double)control/50.;
  res = stepper.drive(fcontrol);

  n++;
  if (n == 100) {
    if (control == 5 || control == -5) {
      dcontrol *= -1;
    }
    control += dcontrol;
    n=0;
    Serial.print("control, res = ");
    Serial.print(fcontrol);
    Serial.print(", ");
    Serial.println(res);
  }
  delay(1000/ControlFrequency); //[msec]
}

//StepperMotorESP32.h

//The class StepperMotorESP32 drives a stepper motor using the A4988 driver module.

#ifndef StepperMotorESP32_h
#define StepperMotorESP32_h

class StepperMotorESP32 {
  public:
    void setPins(uint8_t DirPin, uint8_t StepPin, uint8_t EnablePin);
    int getMaxControlValue(uint32_t ControlFrequency, uint32_t MinPulsePeriod);//Hz, microsec
    void setDirModifier(int Modifier); // 1 or -1
    int drive(double ControlValue); // -1.0 <= ControlValue <= 1.0: return with number of palses
    void enableDriver();
    void disableDriver();
  private:
    uint8_t dirpin, steppin, enablepin;
    uint32_t controlfrequency;
    int MaxControlValue;
    int modifier = 1;;
    double limitfrequency;
    int duty;
    const uint32_t orgfrequency = 500;
    const int nBits_forPWM = 12;
};
#endif

//StepperMotorESP32.cpp

#include <Arduino.h>

#include "StepperMotorESP32.h"

void StepperMotorESP32::setPins(uint8_t DirPin, uint8_t StepPin, uint8_t EnablePin) {
  dirpin = DirPin;
  steppin = StepPin;
  enablepin = EnablePin;
  pinMode(dirpin, OUTPUT);
  pinMode(steppin, OUTPUT);
  pinMode(enablepin, OUTPUT);
  digitalWrite(enablepin, HIGH); //HIGH:disable; LOW:enable
  ledcAttach(steppin, orgfrequency, nBits_forPWM);
  digitalWrite(dirpin, LOW);
  digitalWrite(steppin, LOW);
  int nShifts = nBits_forPWM - 4;
  if (nShifts < 0) nShifts = 1; 
  duty = 1 << (nShifts);  //duty cycle
  /*
  Serial.print("duty = ");
  Serial.println(duty);
  */
}

/*If the motor shaft does not rotate forward when a positive value is entered using the method drive, 
then giving -1 to this method will cause the motor shaft to rotate forward 
when a positive value is entered using the method drive.
*/
void StepperMotorESP32::setDirModifier(int Modifier) { // 1 or -1
  modifier = Modifier;
}

/*
Returns the maximum value that can be given to the motor within this class.
This maximum value is given by dividing the startup cycle of the method drive by the minimum motor drive pulse length.
This value is only used for checking and is not used in the program.
The argument “ControlFrequency” gives the frequency [Hz] at which the method drive is invoked.
The argument “MinPulsePeriod” gives the minimum pulse length (pulse period) [microsecond] that may be given to the stepping motor.
*/
int StepperMotorESP32::getMaxControlValue(uint32_t ControlFrequency, uint32_t MinPulsePeriod) {//Hz, microsec
  MaxControlValue = 1000000 / ControlFrequency / MinPulsePeriod;
  controlfrequency = ControlFrequency;
  limitfrequency = 1000000 / MinPulsePeriod;
  return MaxControlValue;
}

/*
Drives the motor.
The argument “ControlValue” gives the command value to the motor. (-1 <= ControlValue <= 1) 
A positive value means forward rotation and a negative value means reverse rotation.
Returns with number of palses.
*/
int StepperMotorESP32::drive(double ControlValue) {// -1 <= ControlValue <= 1: returns with number of palses
  uint32_t outfrequency;
  int nSteps;
  int sign = 1;
  uint32_t res = 99999;
  if (ControlValue < 0.) sign = -1;
  ControlValue *= modifier;
  if (0 < ControlValue) {
    digitalWrite(dirpin, HIGH);
  } if (ControlValue < 0.) {
    digitalWrite(dirpin, LOW);
    ControlValue = -ControlValue;
  }
  outfrequency = (uint32_t)(controlfrequency * ControlValue * MaxControlValue);
  if (limitfrequency < outfrequency) outfrequency = limitfrequency;
  nSteps = sign * (int)(outfrequency / controlfrequency);
  if (outfrequency == 0) {
    ledcWrite(steppin, 0);
    nSteps = 0;
  } else {
    res = ledcChangeFrequency(steppin, outfrequency, nBits_forPWM);
    ledcWrite(steppin, duty);
  }
  
  /*
  Serial.print("res, outfrequency= ");
  Serial.print(res);
  Serial.print(", ");
  Serial.println(outfrequency);
  */
  
  return nSteps;
}

void StepperMotorESP32::enableDriver()
{
  digitalWrite(enablepin, LOW);
}

void StepperMotorESP32::disableDriver()
{
  digitalWrite(enablepin, HIGH);
}

control, res = 0.00, 0
control, res = 0.02, 1
control, res = 0.04, 2
control, res = 0.06, 3
control, res = 0.08, 4
control, res = 0.10, 5
control, res = 0.08, 4
control, res = 0.06, 3
control, res = 0.04, 2
control, res = 0.02, 1
control, res = 0.00, 0
control, res = -0.02, -1
control, res = -0.04, -2
control, res = -0.06, -3
control, res = -0.08, -4
control, res = -0.10, -5
control, res = -0.08, -4
control, res = -0.06, -3
control, res = -0.04, -2
control, res = -0.02, -1