DIY autotuning servo driver

[Zoidberg]

Anyone up for a collaboration project? The best open source servo driver ever!

Let's talk specifications:
Written in C/C++.
Based on Amtel AVR ATmega48, 88, 168 (differ only in memory sizes).
Easily portable to other models by using port/pin defines.
Minimalistic board design.
Programmed on board with ISP.

Inputs/outputs:
Enable input.
Step/dir or quadrature input.
Encoder input 1x, 2x or 4x.
Current sensing with A/D converter.
Fault output.
Auto tuning button.
Reset button.

Control:
2 PID loops, torque loop controls output PWM, position loop controls torque.
Autotuning with Ziegler Nichols method.

Settings:
Max current limit (over the limit = fault).
Max continuous current limit (over the limit for 1? second = fault).
Max error limit (over the limit = fault).
Max PWM output.
Step multiplier 1-10.

Safety:
Missing encoder check (Max? PWM output for x loops without any encoder interrupt = fault).



Because the driver is open source and built for a specific use by each user, the settings is set at compile time by defines, and therefore you would not need any RS232, only 1 button to initialize the autotuning and 1 button for reset! It would reduce the size and cost of the driver a bit, as you don't need DB9 connector, the MAX232 ic and the supporting components! It also reduces the memory requirement for the µC as you don't need a communication protocol.

Comments?

[Zoidberg]

I have written the encoder input earlier!

It works by setting interrupts for the 2 encoder input pins:
Rising edge on pin A, nothing on pin B = 1X
Logical change on pin A, nothing on pin B = 2X
Logical change on pin A, logical change on pin B = 4X

ISR(INT0_vect)
{
  if(bit_is_set(PIND, PD2))
  {
    if(bit_is_set(PIND, PD3))
    {
      ProcessVariable--;
    } else {
      ProcessVariable++;
    }
  } else {
    if(bit_is_set(PIND, PD3))
    {
      ProcessVariable++;
    } else {
      ProcessVariable--;
    }
  }
}

ISR(INT1_vect)
{
  if(bit_is_set(PIND, PD3))
  {
    if(bit_is_set(PIND, PD2))
    {
      ProcessVariable++;
    } else {
      ProcessVariable--;
    }
  } else {
    if(bit_is_set(PIND, PD2))
    {
      ProcessVariable--;
    } else {
      ProcessVariable++;
    }
  }
}

[Zoidberg]

I have done some coding now. I dropped the quadrature input, enable input and PORT/PIN defines.

Implemented:
Save and Load PID parameters from eeprom.
Step/Dir input with step multiplier.
Encoder input, 1X, 2X and quadrature.

I have only used notepad so i don't know if it will compile!

#define F_CPU 20000000U //20 MHz External Oscillator

#include 
#include 
#include 

#define sbi(port, bit) (port |=  (1 << bit))
#define cbi(port, bit) (port &= ~(1 << bit))

//////////////
// SETTINGS //
//////////////

#define MaxCurrent 255
#define MaxContinuousCurrent 127
#define MaxContinuousCurrentTime 1000

#define MaxError 1000

#define MaxPWM 255

#define StepMultiplier 1

//#define EncoderMode1
//#define EncoderMode2
#define EncoderModeQuadrature

//////////////////
// DECLARATIONS //
//////////////////

typedef struct
{
  short int PTorque;
  short int ITorque;
  short int DTorque; 

  short int PPosition;
  short int IPosition;
  short int DPosition;
} pss //PID Setting Structure

pss EEMEM EEPROM_Data;
pss PidSettings = {0,0,0,0,0,0};

long int SetPoint = 0;
long int ProcessVariable = 0;

void Initialization();

void AutoTune();
void TorqueLoop();
void PositionLoop();

void LoadSettings();
void SaveSettings();

//////////
// MAIN //
//////////

int main(void)
{
  LoadSettings();
  Initialization();
}

///////////////
// FUNCTIONS //
///////////////

void Initialization()
{
  cbi(DDRC, DDC0); //Enable Step input - Pin 23
  cbi(DDRC, DDC1); //Enable Dir input - Pin 24

  sbi(PCICR, PCIE1); //Enable pin change interrupt
  sbi(PCMSK1, PCINT8); //Enable PCINT8 - Step input

  cbi(DDRD, DDD2); //Enable encoder A input - Pin 4
  cbi(DDRD, DDD3); //Enable encoder B input - Pin 5

  cbi(EIMSK, INT0); //Clear registers
  cbi(EIMSK, INT1);
  cbi(EICRA, ISC00);
  cbi(EICRA, ISC01);
  cbi(EICRA, ISC10);

#ifdef EncoderMode1
  sbi(EIMSK, INT0); //Enable interrupt A
  sbi(EICRA, ISC01); //Set rising edge A
#endif

#ifdef EncoderMode2
  sbi(EIMSK, INT0); //Enable interrupt A
  sbi(EICRA, ISC00); //Set logical change A
#endif

#ifdef EncoderModeQuadrature
  sbi(EIMSK, INT0); //Enable interrupt A
  sbi(EICRA, ISC00); //Set logical change A
  sbi(EIMSK, INT1); //Enable interrupt B
  sbi(EICRA, ISC10); //Set logical change B
#endif
}

void AutoTune()
{ 
}

void TorqueLoop()
{
}

void PositionLoop()
{
}

void LoadSettings()
{
  eeprom_read_block((void*)&PidSettings, (const void*)&EEPROM_Data, sizeof(pss));
}

void SaveSettings()
{
  eeprom_write_block((const void*)&PidSettings, (void*)&EEPROM_Data, sizeof(pss));
}

////////////////
// INTERRUPTS //
////////////////

ISR(PCINT1_vect) //Step Dir input
{
  if(bit_is_set(PINC, PC0))
  {
    if(bit_is_set(PINC, PC1))
    {
      SetPoint -= StepMultiplier;
    } else {
      SetPoint += StepMultiplier;
    }
  }
}

ISR(INT0_vect) //Encoder input A
{
  if(bit_is_set(PIND, PD2))
  {
    if(bit_is_set(PIND, PD3))
    {
      ProcessVariable--;
    } else {
      ProcessVariable++;
    }
  } else {
    if(bit_is_set(PIND, PD3))
    {
      ProcessVariable++;
    } else {
      ProcessVariable--;
    }
  }
}

#ifdef EncoderModeQuadrature
ISR(INT1_vect) //Encoder input B
{
  if(bit_is_set(PIND, PD3))
  {
    if(bit_is_set(PIND, PD2))
    {
      ProcessVariable++;
    } else {
      ProcessVariable--;
    }
  } else {
    if(bit_is_set(PIND, PD2))
    {
      ProcessVariable--;
    } else {
      ProcessVariable++;
    }
  }
}
#endif

[samco]

I think you may want to look at a different autotuning method than ZN. I have used ZN manually and within emc there is a PID with ZN tuning built in. It gets you sort of close - but in the end a bit of manual tuining is required.

(I don't know what is out there)

Good luck
sam