Showroom FlyPT - 6DOF Brushless DIY Actuators

Flymen · Nov 1, 2019

pmvcda said: ↑

@Flymen ,

You can also test just the switches with this code:

Code:

SPECIAL TEST FOR SWITCHES IN FIRST ACTUATOR


// =======
// Defines
// =======
#define P 256                   // Proportional
#define I 0                     // Integral
#define D 256                   // Diferential
#define SERIAL_SPEED 115200     // Define to set up the serial speed comunication
#define CALIBRATION_SPEED 50    // Speed used to search for minimum and maximum values (0 to 255) if calibration is to fast or to slow, adjust this value
#define MAXIMUM_BIT_VALUE 32767 // Size of position values received (15 bits, above this, we use it to send other controls/requests besides position)
#define UP HIGH                 // Define to set up direction as HIGH
#define DOWN LOW                // Define to set down direction as LOW
#define PWM_RESOLUTION 8        // 0 to 255
#define PWM_FREQUENCY 1000      // The 8015A accepts up to 1 KHz
#define LIMITS_PIN 0            // Array index of pin to capture position from pot wich defines the limits
#define HALL_1_PIN 1            // Array index of pin used for hall 1 interrupt
#define HALL_2_PIN 2            // Array index of pin used for hall 2 interrupt
#define HALL_3_PIN 3            // Array index of pin used for hall 3 interrupt
#define LAST_ANGLE 4            // Array index of last angle that was detected
#define LAST_SUM 5              // Array index of last sum to know last direction it took
#define DIRECTION_PIN 6         // Array index of Pin to se direction
#define SPEED_PIN 7             // Array index of Pin to set speed with PWM
#define PWM_CHANNEL 8           // Array index of channel used to generate PWM
#define MINIMUM_POSITION 9      // Array index of minimum position
#define MAXIMUM_POSITION 10     // Array index of maximum position
#define CURRENT_POSITION 11     // Array index of current position
#define PRETENDED_POSITION 12   // Array index of pretended position
#define P_PID 13                // Array index of P from PID
#define I_PID 14                // Array index of I from PID
#define D_PID 15                // Array index of D from PID
#define INTEGRATED_ERROR 16     // Array index of sum of differences between pretended and current position
#define LAST_ERROR 17           // Array index of last difference between pretended and current position
#define SPEED 18                // Array index of speed of motor rotation
#define FOUND 19                // Array index of foud, used for in actuator calibration
#define NUMBERACTUATORS 1       // Number of actuators (for one board, please don't change, current code does not support less than 3 actuators. To use less, just disconnect them at hardware level)



static int actuator[3][20] = {
//  00  01  02  03  04  05  06  07  08  09  10  11  12  13  14  15  16  17  18  19
  {  4, 27, 26, 25,  5,  0, 32, 33,  0, -1, -1,  0,  0,  P,  I,  D,  0,  0,  0,  0 },  // Actuator 1
  { 36, 35, 34, 39,  5,  0, 18,  5,  1, -1, -1,  0,  0,  P,  I,  D,  0,  0,  0,  0 },  // Actuator 2
  { 15, 23, 22, 21,  5,  0, 19, 17,  2, -1, -1,  0,  0,  P,  I,  D,  0,  0,  0,  0 }   // Actuator 3
};


static int bufferPrevious = 0;      // To hold previous read fom serial command
static int bufferCurrent = 0;       // To hold current read fom serial command
static int bufferCount = 0;         // To hold current position in bufferCommand array
static int bufferCommand[6] = {0};  // To hold received info from serial



static int limitValue = 1023;
static int error = 0;
static int p = 0;
static int i = 0;
static int d = 0;


static int stepUp[8][8] = {
  {  0,  0,  0,  0,  0,  0,  0,  0},
  {  0,  0, -2, -1,  2,  1,  3,  0},
  {  0,  2,  0,  1, -2,  3, -1,  0},
  {  0,  1, -1,  0,  3,  2, -2,  0},
  {  0, -2,  2,  3,  0, -1,  1,  0},
  {  0, -1,  3, -2,  1,  0,  2,  0},
  {  0,  3,  1,  2, -1, -2,  0,  0},
  {  0,  0,  0,  0,  0,  0,  0,  0}
};
static int stepDown[8][8] = {
  {  0,  0,  0,  0,  0,  0,  0,  0},
  {  0,  0, -2, -1,  2,  1, -3,  0},
  {  0,  2,  0,  1, -2, -3, -1,  0},
  {  0,  1, -1,  0, -3,  2, -2,  0},
  {  0, -2,  2, -3,  0, -1,  1,  0},
  {  0, -1, -3, -2,  1,  0,  2,  0},
  {  0, -3,  1,  2, -1, -2,  0,  0},
  {  0,  0,  0,  0,  0,  0,  0,  0}
};


// ==============
// Initialization
// ==============
void setup()
{
  // Disable watchdog in both processors
  disableCore0WDT();
  disableCore1WDT();

  // Setup serial communication
  Serial.begin(SERIAL_SPEED, SERIAL_8N1);

  // Initialize
  for (int n = 0; n < NUMBERACTUATORS; n++)
  {
    // Initialize pins
    pinMode(actuator[n][LIMITS_PIN], INPUT);
    pinMode(actuator[n][HALL_1_PIN], INPUT);
    pinMode(actuator[n][HALL_2_PIN], INPUT);
    pinMode(actuator[n][HALL_3_PIN], INPUT);
    pinMode(actuator[n][DIRECTION_PIN], OUTPUT);
    pinMode(actuator[n][SPEED_PIN], OUTPUT);

    // Setup PWM
    ledcSetup(actuator[n][PWM_CHANNEL], PWM_FREQUENCY, PWM_RESOLUTION);
    ledcAttachPin(actuator[n][SPEED_PIN], actuator[n][PWM_CHANNEL]);
    ledcWrite(actuator[n][PWM_CHANNEL], 0);
  }
}



void loop()
{
   limitValue = (analogRead(actuator[0][LIMITS_PIN]) + analogRead(actuator[0][LIMITS_PIN]) + analogRead(actuator[0][LIMITS_PIN]) + analogRead(actuator[0][LIMITS_PIN])) >> 2;
   Serial.println(limitValue );
}

It should show for the first actuator, the value we receive from the switches.
If you press the min switch you get zero
If you press the max, you get 4093
If you don't press the switches, you should get something in the middle

Click to expand...

ok thanks for testing switch with code ! Iwill try it tomorow
what I did is : on the purple wire ( return minimum microswitch ) I have : non active switch ( both) 0.723volt and maximum active : 3.3v and minimum active 0.0v and this direct to esp32 input.
After alls hall are received at the level shifter at 5.5v and other side at esp32 at 3,3 vol = ok good
after :Switch again H1 and H3 : see video

Thanks again for your help ! :thumbs

pmvcda · Nov 1, 2019

Flymen said: ↑

ok thanks for testing switch with code ! Iwill try it tomorow
what I did is : on the purple wire ( return minimum microswitch ) I have : non active switch ( both) 0.723volt and maximum active : 3.3v and minimum active 0.0v and this direct to esp32 input.
After alls hall are received at the level shifter at 5.5v and other side at esp32 at 3,3 vol = ok good
after :Switch again H1 and H3 : see video

Thanks again for your help !
Click to expand...

Is that with the last code I sent you? The one before the switches code?
It should show positions on the serial monitor.
I mean the code in this post: https://www.xsimulator.net/communit...hless-diy-actuators.10799/page-18#post-186922

Flymen · Nov 1, 2019

pmvcda said: ↑

Is that with the last code I sent you? The one before the switches code?
It should show positions on the serial monitor.
I mean the code in this post: https://www.xsimulator.net/communit...hless-diy-actuators.10799/page-18#post-186922
Click to expand...

The video was with the original code but with H1 and H3 swap only.
Must waiting for my wife leave to work and then I will continue testing today
Priority 1 - my wife 2- the machineeeeee…...

Flymen · Nov 2, 2019

pmvcda said: ↑

@Flymen ,

You can also test just the switches with this code:

Code:

SPECIAL TEST FOR SWITCHES IN FIRST ACTUATOR


// =======
// Defines
// =======
#define P 256                   // Proportional
#define I 0                     // Integral
#define D 256                   // Diferential
#define SERIAL_SPEED 115200     // Define to set up the serial speed comunication
#define CALIBRATION_SPEED 50    // Speed used to search for minimum and maximum values (0 to 255) if calibration is to fast or to slow, adjust this value
#define MAXIMUM_BIT_VALUE 32767 // Size of position values received (15 bits, above this, we use it to send other controls/requests besides position)
#define UP HIGH                 // Define to set up direction as HIGH
#define DOWN LOW                // Define to set down direction as LOW
#define PWM_RESOLUTION 8        // 0 to 255
#define PWM_FREQUENCY 1000      // The 8015A accepts up to 1 KHz
#define LIMITS_PIN 0            // Array index of pin to capture position from pot wich defines the limits
#define HALL_1_PIN 1            // Array index of pin used for hall 1 interrupt
#define HALL_2_PIN 2            // Array index of pin used for hall 2 interrupt
#define HALL_3_PIN 3            // Array index of pin used for hall 3 interrupt
#define LAST_ANGLE 4            // Array index of last angle that was detected
#define LAST_SUM 5              // Array index of last sum to know last direction it took
#define DIRECTION_PIN 6         // Array index of Pin to se direction
#define SPEED_PIN 7             // Array index of Pin to set speed with PWM
#define PWM_CHANNEL 8           // Array index of channel used to generate PWM
#define MINIMUM_POSITION 9      // Array index of minimum position
#define MAXIMUM_POSITION 10     // Array index of maximum position
#define CURRENT_POSITION 11     // Array index of current position
#define PRETENDED_POSITION 12   // Array index of pretended position
#define P_PID 13                // Array index of P from PID
#define I_PID 14                // Array index of I from PID
#define D_PID 15                // Array index of D from PID
#define INTEGRATED_ERROR 16     // Array index of sum of differences between pretended and current position
#define LAST_ERROR 17           // Array index of last difference between pretended and current position
#define SPEED 18                // Array index of speed of motor rotation
#define FOUND 19                // Array index of foud, used for in actuator calibration
#define NUMBERACTUATORS 1       // Number of actuators (for one board, please don't change, current code does not support less than 3 actuators. To use less, just disconnect them at hardware level)



static int actuator[3][20] = {
//  00  01  02  03  04  05  06  07  08  09  10  11  12  13  14  15  16  17  18  19
  {  4, 27, 26, 25,  5,  0, 32, 33,  0, -1, -1,  0,  0,  P,  I,  D,  0,  0,  0,  0 },  // Actuator 1
  { 36, 35, 34, 39,  5,  0, 18,  5,  1, -1, -1,  0,  0,  P,  I,  D,  0,  0,  0,  0 },  // Actuator 2
  { 15, 23, 22, 21,  5,  0, 19, 17,  2, -1, -1,  0,  0,  P,  I,  D,  0,  0,  0,  0 }   // Actuator 3
};


static int bufferPrevious = 0;      // To hold previous read fom serial command
static int bufferCurrent = 0;       // To hold current read fom serial command
static int bufferCount = 0;         // To hold current position in bufferCommand array
static int bufferCommand[6] = {0};  // To hold received info from serial



static int limitValue = 1023;
static int error = 0;
static int p = 0;
static int i = 0;
static int d = 0;


static int stepUp[8][8] = {
  {  0,  0,  0,  0,  0,  0,  0,  0},
  {  0,  0, -2, -1,  2,  1,  3,  0},
  {  0,  2,  0,  1, -2,  3, -1,  0},
  {  0,  1, -1,  0,  3,  2, -2,  0},
  {  0, -2,  2,  3,  0, -1,  1,  0},
  {  0, -1,  3, -2,  1,  0,  2,  0},
  {  0,  3,  1,  2, -1, -2,  0,  0},
  {  0,  0,  0,  0,  0,  0,  0,  0}
};
static int stepDown[8][8] = {
  {  0,  0,  0,  0,  0,  0,  0,  0},
  {  0,  0, -2, -1,  2,  1, -3,  0},
  {  0,  2,  0,  1, -2, -3, -1,  0},
  {  0,  1, -1,  0, -3,  2, -2,  0},
  {  0, -2,  2, -3,  0, -1,  1,  0},
  {  0, -1, -3, -2,  1,  0,  2,  0},
  {  0, -3,  1,  2, -1, -2,  0,  0},
  {  0,  0,  0,  0,  0,  0,  0,  0}
};


// ==============
// Initialization
// ==============
void setup()
{
  // Disable watchdog in both processors
  disableCore0WDT();
  disableCore1WDT();

  // Setup serial communication
  Serial.begin(SERIAL_SPEED, SERIAL_8N1);

  // Initialize
  for (int n = 0; n < NUMBERACTUATORS; n++)
  {
    // Initialize pins
    pinMode(actuator[n][LIMITS_PIN], INPUT);
    pinMode(actuator[n][HALL_1_PIN], INPUT);
    pinMode(actuator[n][HALL_2_PIN], INPUT);
    pinMode(actuator[n][HALL_3_PIN], INPUT);
    pinMode(actuator[n][DIRECTION_PIN], OUTPUT);
    pinMode(actuator[n][SPEED_PIN], OUTPUT);

    // Setup PWM
    ledcSetup(actuator[n][PWM_CHANNEL], PWM_FREQUENCY, PWM_RESOLUTION);
    ledcAttachPin(actuator[n][SPEED_PIN], actuator[n][PWM_CHANNEL]);
    ledcWrite(actuator[n][PWM_CHANNEL], 0);
  }
}



void loop()
{
   limitValue = (analogRead(actuator[0][LIMITS_PIN]) + analogRead(actuator[0][LIMITS_PIN]) + analogRead(actuator[0][LIMITS_PIN]) + analogRead(actuator[0][LIMITS_PIN])) >> 2;
   Serial.println(limitValue );
}

It should show for the first actuator, the value we receive from the switches.
If you press the min switch you get zero
If you press the max, you get 4093
If you don't press the switches, you should get something in the middle

Click to expand...

If you press the min switch you get zero = sorry, but nothing , it moves between 54 and 56
If you press the max, you get 4093 = it moves between 54 and 56
If you don't press the switches, you should get something in the middle[/QUOTE] = it moves between 54 and 56

Could it be on the limit switches? check 3 time = ok
Are you sure they are correctly connected? yes

On the EsP32 at Pin D15 , do you have this set up ?
If you press the min switch you get : 0.0 volt
If you press the max, you get : 3.3 volt
If you don't press the switches : 0.723 volt

pmvcda · Nov 2, 2019

Flymen said: ↑

If you press the min switch you get zero = sorry, but nothing , it moves between 54 and 56
If you press the max, you get 4093 = it moves between 54 and 56
If you don't press the switches, you should get something in the middle= it moves between 54 and 56

Could it be on the limit switches? check 3 time = ok
Are you sure they are correctly connected? yes

On the EsP32 at Pin D15 , do you have this set up ?
If you press the min switch you get : 0.0 volt
If you press the max, you get : 3.3 volt
If you don't press the switches : 0.723 volt

Click to expand...

Hi, D15 is for actuator 3, that's why you dont get readings, I changed the code to use only actuator 1.
And that is pin 4

Connect the actuator on another port, the one that uses pin 4

Flymen · Nov 2, 2019

pmvcda said: ↑

Hi, D15 is for actuator 3, that's why you dont get readings, I changed the code to use only actuator 1.
And that is pin 4

Connect the actuator on another port, the one that uses pin 4
Click to expand...

ok , sorry for the confusion!!
If you press the min switch you get zero = stay at zero
If you press the max, you get 4093 =4095
If you don't press the switches, you should get something in the middle = still at zero , don't move

pmvcda · Nov 2, 2019

Flymen said: ↑

ok , sorry for the confusion!!
If you press the min switch you get zero = stay at zero
If you press the max, you get 4093 =4095
If you don't press the switches, you should get something in the middle = still at zero , don't move
Click to expand...

No switch pressed gives you zero?
There's something wrong there.

What resistances are you using?

Please measure that pin in the 3 situations

Flymen · Nov 2, 2019

pmvcda said: ↑

No switch pressed gives you zero?
There's something wrong there.

What resistances are you using? 10k like you

Please measure that pin in the 3 situations
Click to expand...

On the EsP32 at Pin D4 ,I have this set up ?
If you press the min switch you get : 0.0 volt
If you press the max, you get : 3.3 volt
If you don't press the switches :0.0 volt ( yes, here … something wrong )

Flymen · Nov 2, 2019

Flymen said: ↑

On the EsP32 at Pin D4 ,I have this set up ?
If you press the min switch you get : 0.0 volt
If you press the max, you get : 3.3 volt
If you don't press the switches :0.0 volt ( yes, here … something wrong )
Click to expand...

I use 10 k like you !
I had swapping Esp32 with new one and is the same thing !

pmvcda · Nov 2, 2019

Flymen said: ↑

On the EsP32 at Pin D4 ,I have this set up ?
If you press the min switch you get : 0.0 volt
If you press the max, you get : 3.3 volt
If you don't press the switches :0.0 volt ( yes, here … something wrong )
Click to expand...

That was bad luck. Right on the first actuator.
Maybe better to test the #2, that's pin 36

Happened to me on the second board, I mixed halls pins with limits pins. In the middle of the spaghetti, it's easy to make an error.

pmvcda · Nov 2, 2019

From what you say, the pin 15 works.
So if you mount the same actuator to the port of that pin, it works.
This means there's no connection problem in the switches or in the actuator.

Problem might be on a bad or swapped soldering.

Flymen · Nov 2, 2019

pmvcda said: ↑

That was bad luck. Right on the first actuator.
Maybe better to test the #2, that's pin 36

Happened to me on the second board, I mixed halls pins with limits pins. In the middle of the spaghetti, it's easy to make an error.
Click to expand...

On the EsP32 at Pin D36 or ( UP) ,I have this set up
If you press the min switch I get : 0.0 volt
If you press the max, I get : 3.3 volt
If I don't press the switches :0.0 volt
and I can't see nothing on monitor ( it moves between 54 and 56)

pmvcda · Nov 2, 2019

Flymen said: ↑

On the EsP32 at Pin D36 or ( UP) ,I have this set up ?
If you press the min switch you get : 0.0 volt
If you press the max, I get : 3.3 volt
If you don't press the switches :0.0 volt
and I can't see nothing on monitor ( it moves between 54 and 56)
Click to expand...

You have to see all the connections... really sorry. Something is mixed somewhere.
You have to follow wire by wire and see where they go. It's easy to jump pins and put them in the wrong place.

Flymen · Nov 2, 2019

pmvcda said: ↑

You have to see all the connections... really sorry. Something is mixed somewhere.
You have to follow wire by wire and see where they go. It's easy to jump pins and put them in the wrong place.
Click to expand...

Ok thanks a lot !
I will do a check ( revision) of this !

Flymen · Nov 2, 2019

pmvcda said: ↑

The sequence is the same, but one is CW and the other CCW (they are always the same)
This is my sequence compared to yours:
66570
Maybe try swapping H1 and H3 again.
But even exchanged they should show something.
That's what I find strange. I don't see any problem on the code.
Could it be on the limit switches?
Are you sure they are correctly connected?

Please test this code:

Code:

SPECIAL TEST VERSION FOR 1 ACTUATOR (THE FIRST ONE) !!!


// =======
// Defines
// =======
#define P 256                   // Proportional
#define I 0                     // Integral
#define D 256                   // Diferential
#define SERIAL_SPEED 115200     // Define to set up the serial speed comunication
#define CALIBRATION_SPEED 50    // Speed used to search for minimum and maximum values (0 to 255) if calibration is to fast or to slow, adjust this value
#define MAXIMUM_BIT_VALUE 32767 // Size of position values received (15 bits, above this, we use it to send other controls/requests besides position)
#define UP HIGH                 // Define to set up direction as HIGH
#define DOWN LOW                // Define to set down direction as LOW
#define PWM_RESOLUTION 8        // 0 to 255
#define PWM_FREQUENCY 1000      // The 8015A accepts up to 1 KHz
#define LIMITS_PIN 0            // Array index of pin to capture position from pot wich defines the limits
#define HALL_1_PIN 1            // Array index of pin used for hall 1 interrupt
#define HALL_2_PIN 2            // Array index of pin used for hall 2 interrupt
#define HALL_3_PIN 3            // Array index of pin used for hall 3 interrupt
#define LAST_ANGLE 4            // Array index of last angle that was detected
#define LAST_SUM 5              // Array index of last sum to know last direction it took
#define DIRECTION_PIN 6         // Array index of Pin to se direction
#define SPEED_PIN 7             // Array index of Pin to set speed with PWM
#define PWM_CHANNEL 8           // Array index of channel used to generate PWM
#define MINIMUM_POSITION 9      // Array index of minimum position
#define MAXIMUM_POSITION 10     // Array index of maximum position
#define CURRENT_POSITION 11     // Array index of current position
#define PRETENDED_POSITION 12   // Array index of pretended position
#define P_PID 13                // Array index of P from PID
#define I_PID 14                // Array index of I from PID
#define D_PID 15                // Array index of D from PID
#define INTEGRATED_ERROR 16     // Array index of sum of differences between pretended and current position
#define LAST_ERROR 17           // Array index of last difference between pretended and current position
#define SPEED 18                // Array index of speed of motor rotation
#define FOUND 19                // Array index of foud, used for in actuator calibration
#define NUMBERACTUATORS 1       // Number of actuators (for one board, please don't change, current code does not support less than 3 actuators. To use less, just disconnect them at hardware level)


// ======================
// Actuators information:
// ======================
// 0  - LIMITS_PIN          - Pin to capture position from pot
// 1  - HALL_1_PIN          - Pin used for hall 1 interrupt
// 2  - HALL_2_PIN          - Pin used for hall 2 interrupt
// 3  - HALL_3_PIN          - Pin used for hall 3 interrupt
// 4  - LAST_ANGLE          - Last angle that was detected
// 5  - LAST_SUM            - Last sum to know last direction it took
// 6  - DIRECTION_PIN       - Pin to se direction
// 7  - SPEED_PIN           - Pin to set speed with PWM
// 8  - PWM_CHANNEL         - Channel used to generate PWM
// 9  - MINIMUM_POSITION    - Minimum position
// 10 - MAXIMUM_POSITION    - Maximum position
// 11 - CURRENT_POSITION    - Current position
// 12 - PRETENDED_POSITION  - Pretended position
// 13 - P_PID               - P from PID
// 14 - I_PID               - I from PID
// 15 - D_PID               - D from PID
// 16 - INTEGRATED_ERROR    - Sum of differences between pretended and current position
// 17 - LAST_ERROR          - Last difference between pretended and current position
// 18 - SPEED               - Speed of motor rotation
// 19 - FOUND               - Used as help for calibraion
static int actuator[3][20] = {
//  00  01  02  03  04  05  06  07  08  09  10  11  12  13  14  15  16  17  18  19
  {  4, 27, 26, 25,  5,  0, 32, 33,  0, -1, -1,  0,  0,  P,  I,  D,  0,  0,  0,  0 },  // Actuator 1
  { 36, 35, 34, 39,  5,  0, 18,  5,  1, -1, -1,  0,  0,  P,  I,  D,  0,  0,  0,  0 },  // Actuator 2
  { 15, 23, 22, 21,  5,  0, 19, 17,  2, -1, -1,  0,  0,  P,  I,  D,  0,  0,  0,  0 }   // Actuator 3
};


// =======================================
// Variables for info received from serial
// =======================================
static int bufferPrevious = 0;      // To hold previous read fom serial command
static int bufferCurrent = 0;       // To hold current read fom serial command
static int bufferCount = 0;         // To hold current position in bufferCommand array
static int bufferCommand[6] = {0};  // To hold received info from serial


// ===========================================================================
// Variables used in PID calculation to avoid repeated definitions in the loop
// ===========================================================================
static int limitValue = 1023;
static int error = 0;
static int p = 0;
static int i = 0;
static int d = 0;


// ========================================================
// Array used to calculate motor position from hall sensors
// ========================================================
// Maps to get increment off position from comparing previous hall sensor state with current state
// In the table, vertical is the new value, horizontal is the old one
// Stores for 0 and 7, althought they should not ocurr, digital read might get them. They are ignored with zero change.
// State sequence going up
// 5=101
// 1=001
// 3=011
// 2=010
// 6=110
// 4=100
// First index for new state, second for old state ([new][old])
static int stepUp[8][8] = {
  {  0,  0,  0,  0,  0,  0,  0,  0},
  {  0,  0, -2, -1,  2,  1,  3,  0},
  {  0,  2,  0,  1, -2,  3, -1,  0},
  {  0,  1, -1,  0,  3,  2, -2,  0},
  {  0, -2,  2,  3,  0, -1,  1,  0},
  {  0, -1,  3, -2,  1,  0,  2,  0},
  {  0,  3,  1,  2, -1, -2,  0,  0},
  {  0,  0,  0,  0,  0,  0,  0,  0}
};
static int stepDown[8][8] = {
  {  0,  0,  0,  0,  0,  0,  0,  0},
  {  0,  0, -2, -1,  2,  1, -3,  0},
  {  0,  2,  0,  1, -2, -3, -1,  0},
  {  0,  1, -1,  0, -3,  2, -2,  0},
  {  0, -2,  2, -3,  0, -1,  1,  0},
  {  0, -1, -3, -2,  1,  0,  2,  0},
  {  0, -3,  1,  2, -1, -2,  0,  0},
  {  0,  0,  0,  0,  0,  0,  0,  0}
};


// ==============
// Initialization
// ==============
void setup()
{
  // Disable watchdog in both processors
  disableCore0WDT();
  disableCore1WDT();

  // Setup serial communication
  Serial.begin(SERIAL_SPEED, SERIAL_8N1);

  // Initialize
  for (int n = 0; n < NUMBERACTUATORS; n++)
  {
    // Initialize pins
    pinMode(actuator[n][LIMITS_PIN], INPUT);
    pinMode(actuator[n][HALL_1_PIN], INPUT);
    pinMode(actuator[n][HALL_2_PIN], INPUT);
    pinMode(actuator[n][HALL_3_PIN], INPUT);
    pinMode(actuator[n][DIRECTION_PIN], OUTPUT);
    pinMode(actuator[n][SPEED_PIN], OUTPUT);

    // Setup PWM
    ledcSetup(actuator[n][PWM_CHANNEL], PWM_FREQUENCY, PWM_RESOLUTION);
    ledcAttachPin(actuator[n][SPEED_PIN], actuator[n][PWM_CHANNEL]);
    ledcWrite(actuator[n][PWM_CHANNEL], 0);
  }

  // Create thread that gets position from hall sensors to run in the core 0
  // It will run in paralell with the main loop that uses core 1 by default
  xTaskCreatePinnedToCore(
    TaskUpdatePositions,  // Task function
    "UpdatePositions",    // Name
    10000,                // Stack size
    NULL,                 // Task input parameter
    1,                    // Priority of the task
    NULL,                 // Task handle
    0);                   // Core

  // Initialize pin to light up onboard led and blink for 5 seconds before starting calibration
  pinMode(2, OUTPUT);
  for (byte n = 5; n > 0; n--)
  {
    delay(500);
    digitalWrite(2, HIGH);
    delay(500);
    digitalWrite(2, LOW);
  }
  digitalWrite(2, LOW);
 
  // Calibrate actuators, searching for minimums and maximums
  calibrate();
 
  // Put actuators in the minimum after calibration (for easy access to the rig)
  for (int n = 0; n < NUMBERACTUATORS; n++) actuator[n][PRETENDED_POSITION] = actuator[n][MINIMUM_POSITION];
}


// =========
// Calibrate
// =========
void calibrate()
{
  // Move all actuators to maximum
  // =============================
  for (int n = 0; n < NUMBERACTUATORS; n++)
  {
    digitalWrite (actuator[n][DIRECTION_PIN], UP);
    ledcWrite(actuator[n][PWM_CHANNEL], CALIBRATION_SPEED);
    actuator[n][FOUND] = false;
  }
  int found = 0;
  while (found < NUMBERACTUATORS)
  {
    for (int n = 0; n < NUMBERACTUATORS; n++)
    {

        Serial.print("n);
        Serial.print(" SEARCH MAX! Current position= ");
        Serial.println(actuator[n][CURRENT_POSITION]

      // Read limit switch position (we are looking for big value 4095)
      // We read more than one time to be sure (4 times in this case)
      if (!actuator[n][FOUND] && (analogRead(actuator[n][LIMITS_PIN]) + analogRead(actuator[n][LIMITS_PIN]) + analogRead(actuator[n][LIMITS_PIN]) + analogRead(actuator[n][LIMITS_PIN])) / 4 >= 4095)
      {
        ledcWrite(actuator[n][PWM_CHANNEL], 0);
        actuator[n][CURRENT_POSITION] = 0;
        actuator[n][FOUND] = true;
        found++;
      }
    }
  }
  // Move all actuators to minimum
  // =============================
  for (int n = 0; n < NUMBERACTUATORS; n++)
  {
    digitalWrite (actuator[n][DIRECTION_PIN], DOWN);
    ledcWrite(actuator[n][PWM_CHANNEL], CALIBRATION_SPEED);
    actuator[n][FOUND] = false;
  }
  found = 0;
  while (found < NUMBERACTUATORS)
  {
    for (int n = 0; n < NUMBERACTUATORS; n++)
    { 

        Serial.print("n);
        Serial.print(" SEARCH MIN! Current position= ");
        Serial.println(actuator[n][CURRENT_POSITION]

      // Read limit switch position (we are looking for zero)
      if (!actuator[n][FOUND] && (analogRead(actuator[n][LIMITS_PIN]) + analogRead(actuator[n][LIMITS_PIN]) + analogRead(actuator[n][LIMITS_PIN]) + analogRead(actuator[n][LIMITS_PIN])) <= 0)
      {
        ledcWrite(actuator[n][PWM_CHANNEL], 0);
        actuator[n][MAXIMUM_POSITION] = -actuator[n][CURRENT_POSITION] / 2;
        actuator[n][MINIMUM_POSITION] = -actuator[n][MAXIMUM_POSITION];
        actuator[n][CURRENT_POSITION] = actuator[n][MINIMUM_POSITION];
        actuator[n][FOUND] = true;
        found++;

        // Send info to serial monitor for debug (use 500000 in serial speed to work with the Arduino IDE)
        Serial.println();
        Serial.print("Actuator ");
        Serial.print(n);
        Serial.print(":  Minimum=");
        Serial.print(actuator[n][MINIMUM_POSITION]);
        Serial.print("  Maximum=");
        Serial.println(actuator[n][MAXIMUM_POSITION]);
      }
    }
  }
}


// ======================
// Update actuator action
// ======================
// Here we calculate the PID depending of desired vs current position and send respective signal to motor controller
void updateActuatorSpeed(byte n)
{
  // Calculate PID
  // =============
  error = actuator[n][PRETENDED_POSITION] - actuator[n][CURRENT_POSITION];
  actuator[n][INTEGRATED_ERROR] += error;
  p = actuator[n][P_PID] * error;
  i = actuator[n][I_PID] * constrain(actuator[n][INTEGRATED_ERROR], -255, 255);
  d = actuator[n][D_PID] * (error - actuator[n][LAST_ERROR]);
  actuator[n][LAST_ERROR] = error;
  actuator[n][SPEED] = FlyPT_Constrain((p + i + d) >> 8, -255, 255); // 2 4 8 16 32 64 128 256 Divide by 256
 
  // Apply changes to motor controller
  // =================================
  if (actuator[n][SPEED] > 0)
  {
    ledcWrite(actuator[n][PWM_CHANNEL], actuator[n][SPEED]);
    digitalWrite (actuator[n][DIRECTION_PIN], UP);
  }
  else
  {
    ledcWrite(actuator[n][PWM_CHANNEL], -actuator[n][SPEED]);
    digitalWrite (actuator[n][DIRECTION_PIN], DOWN);
  }
 
  // Check limits
  // ============
  // Adjust position if minimum or maximum switch is activated in case of a drift in position calculation
  limitValue = (analogRead(actuator[n][LIMITS_PIN]) + analogRead(actuator[n][LIMITS_PIN]) + analogRead(actuator[n][LIMITS_PIN]) + analogRead(actuator[n][LIMITS_PIN])) >> 2;
  // If they are actuated, recalibrate position
  if (limitValue >= 4095) actuator[n][CURRENT_POSITION] = actuator[n][MAXIMUM_POSITION]; // We are at maximum position
  else if (limitValue <= 0) actuator[n][CURRENT_POSITION] = actuator[n][MINIMUM_POSITION]; // We are at minimum position
}


// ======================================================
// Replacement for constrain function (seems to be buggy)
// ======================================================
int FlyPT_Constrain(int value, int low, int high)
{
  return (value < low) ? low : (value > high) ? high : value;
}


// ====================================
// Update current position of actuators
// ====================================
void updateCurrentPosition(byte n)
{
  int angle = digitalRead(actuator[n][HALL_1_PIN]) * 4 + digitalRead(actuator[n][HALL_2_PIN]) * 2 + digitalRead(actuator[n][HALL_3_PIN]);
  if (actuator[n][LAST_SUM] > 0) actuator[n][LAST_SUM] = stepUp[angle][actuator[n][LAST_ANGLE]];
  else actuator[n][LAST_SUM] = stepDown[angle][actuator[n][LAST_ANGLE]];
  actuator[n][LAST_ANGLE] = angle;
  actuator[n][CURRENT_POSITION] += actuator[n][LAST_SUM];
}


// ===========================
// Main loop running on core 1
// ===========================
// Here we get the simtools commands and make the actuator move
void loop()
{
  if (Serial.available())
  {
    bufferPrevious = bufferCurrent; // Store previous byte
    bufferCurrent = Serial.read(); // Get the new byte
    bufferCommand[bufferCount] = bufferCurrent; // Put the new byte in the array
    bufferCount++; // Change to next position in the array
    if(bufferCurrent==255 && bufferPrevious==255) bufferCount = 0; // Two 255 in sequence are the start of the position info
    if(bufferCount==6) // Having 6 bytes means we have the 3 positions and that we can update the pretended position
    {
      actuator[0][PRETENDED_POSITION] = map((bufferCommand[0] * 256) + bufferCommand[1], 0, MAXIMUM_BIT_VALUE, actuator[0][MINIMUM_POSITION], actuator[0][MAXIMUM_POSITION]);
      //actuator[1][PRETENDED_POSITION] = map((bufferCommand[2] * 256) + bufferCommand[3], 0, MAXIMUM_BIT_VALUE, actuator[1][MINIMUM_POSITION], actuator[1][MAXIMUM_POSITION]);
      //actuator[2][PRETENDED_POSITION] = map((bufferCommand[4] * 256) + bufferCommand[5], 0, MAXIMUM_BIT_VALUE, actuator[2][MINIMUM_POSITION], actuator[2][MAXIMUM_POSITION]);
      bufferCount=0;
    }
  }

  // Update orders sent to motor driver
  updateActuatorSpeed(0);
  //updateActuatorSpeed(1);
  //updateActuatorSpeed(2);
}


// ==============================================
// Update positions thread loop running in core 0
// ==============================================
void TaskUpdatePositions(void * parameter)
{
  while (true)
  {
      updateCurrentPosition(0);
      //updateCurrentPosition(1);
      //updateCurrentPosition(2);
  }
}

And show me the output of the serial monitor.
It's already for 1 actuator at 115200
It should show the position while it searches for her.

Do you have a separated motor to try it without switches?

Depending on result, it's the next step.

Click to expand...

Hi ,
Missing something !!

Flymen · Nov 2, 2019

pmvcda said: ↑

Electronics
Schematics used for this project

INTERNALL HALL SENSOR POSITIONING VERSION WITH ESP32 DEVKIT
Still using a similar solution to the pot positioning to detect minimum and maximum switches.
The pot was replace by two resistances (10k):

56509
(For full resolution: https://c2.staticflickr.com/2/1966/43113342910_bbfc75294e_o.png)

So if minimum is pressed we get 0 in the ESP32.
If maximum is pressed we get 4095 on the ESP32.
None pressed we get around 2047.
Now positioning is calculated from reading the hall sensors state.
Lower resolution than the pot, but I think it's enough.

For 6 actuators we need two ESP32 boards. They are connected the same way.
Here's the current schematic in use:

56510
(For full resolution: https://www.flickr.com/photos/128465277@N06/30098511787/sizes/o/)

And the board I made with the ESP32 DevKit, plugs and level shifters:
54992

Mounted in the controllers "box":
56511
54993

POT POSITIONING VERSION WITH ARDUINO UNO
I moved to the internal hall positioning solution, so this is no longer updated, but here for reference.

Pot and controller connection for one actuator:

(For full resolution: https://c1.staticflickr.com/5/4389/36059736774_07d10f6b53_o.png)

The idea is to control all the actuators with one Arduino Uno.
I get position feedback with pots and two limit switches.
When the maximum switch is pressed, the pot value is immediately 1023 on the Arduino.
The same for the minimum, we get 0 when the switch is enabled
While no limit switch is activated, we get the value from the pot.
The motor controller needs speed and direction information.
Speed is fed with PWM and direction is on/off.
So with this config I can fit everything in one Arduino Uno:

(For full resolution: https://c1.staticflickr.com/5/4362/36059748064_4c644dc11d_o.jpg)
Click to expand...

Hi ,
On your electronic plan , I can see two diferences : Electronics for 1 /Electronics for 3
Elec ..for 1 : input D-35 ( com /minimum travel switch).
Elec.. for 3 : input are D-4 , D-36 and D-15 ( com /minimum travel switch) .
My question is :
If I want build just one exemple , I must take Electronics for 3 Plan (actuator 1) like D4 and not D-35 ?

Thanks !

pmvcda · Nov 2, 2019

Flymen said: ↑

Hi ,
On your electronic plan , I can see two diferences : Electronics for 1 /Electronics for 3
Elec ..for 1 : input D-35 ( com /minimum travel switch).
Elec.. for 3 : input are D-4 , D-36 and D-15 ( com /minimum travel switch) .
My question is :
If I want build just one exemple , I must take Electronics for 3 Plan (actuator 1) like D4 and not D-35 ?

Thanks !
Click to expand...

Use the 3 actuators version!

Flymen · Nov 5, 2019

pmvcda said: ↑

No switch pressed gives you zero?
There's something wrong there.

What resistances are you using?

Please measure that pin in the 3 situations
Click to expand...

Hi . It me again !!!
what you told me :
It should show for the first actuator, the value we receive from the switches.
If you press the min switch you get zero
If you press the max, you get 4093
If you don't press the switches, you should get something in the middle

Can you check this ? Maybe I'm lost but … Shema( see pic ) : Left side with correction and Right side the old one .
Test :

pmvcda · Nov 5, 2019

Flymen said: ↑

Hi . It me again !!!
what you told me :
It should show for the first actuator, the value we receive from the switches.
If you press the min switch you get zero
If you press the max, you get 4093
If you don't press the switches, you should get something in the middle

Can you check this ? Maybe I'm lost but … Shema( see pic ) : Left side with correction and Right side the old one .
Test :

Click to expand...

That's OK in the video. Use it that way.
I might have an error in the schematic, I will take a look. Maybe tomorrow, because...

Yesterday, I had stupid inspectors in my business, looking at stupid things from some stupid laws just to make money to my stupid government.
That way they can say the stupid economy is recovering in my country.
Today I'm spending money buying new equipment to comply with the laws, that exige the equipment to be mounted by someone that might not have studies, but that paid for a paper saying is special an he can mount a surveillance system that is HD, because I don't know what is HD.....
The most comical one is I did not have a paper at the entry saying if I allow dogs or not in the pharmacy... IDIOTS! Just that it's 600€.
Sorry... needed to put it out...

Trip Rodriguez · Nov 5, 2019

pmvcda said: ↑

Sorry... needed to put it out...
Click to expand...

I understand that 100% Unbelievable government BS.

Log in or Sign up

Showroom FlyPT - 6DOF Brushless DIY Actuators

Flymen Flymen Gold Contributor

pmvcda aka FlyPT

Flymen Flymen Gold Contributor

Flymen Flymen Gold Contributor

pmvcda aka FlyPT

Flymen Flymen Gold Contributor

pmvcda aka FlyPT

Flymen Flymen Gold Contributor

Flymen Flymen Gold Contributor

pmvcda aka FlyPT

pmvcda aka FlyPT

Flymen Flymen Gold Contributor

pmvcda aka FlyPT

Flymen Flymen Gold Contributor

Flymen Flymen Gold Contributor

Flymen Flymen Gold Contributor

pmvcda aka FlyPT

Flymen Flymen Gold Contributor

Attached Files:

FlyPT switch test new one and old shema.png

pmvcda aka FlyPT

Trip Rodriguez VR Pilot