Showroom FlyPT - 6DOF Brushless DIY Actuators

twinking · Mar 4, 2023

First you have to transform the torgue into a radial force: Nr=M/r=0.6Nm/0.008m=75N
To get the axial force you have to multiply the radial force with the gear transmission Ratio i. This is the spindle circumference divided by the pitch: i=r*2*pi/pitch=0.008m*2*pi/0.005m=10.05

Na=Nr*i=754N
Or
Na=M*r*2*pi/r*pitch=M*2*pi/pitch

Koala70 · Mar 5, 2023

twinking said: ↑

First you have to transform the torgue into a radial force: Nr=M/r=0.6Nm/0.008m=75N
To get the axial force you have to multiply the radial force with the gear transmission Ratio i. This is the spindle circumference divided by the pitch: i=r*2*pi/pitch=0.008m*2*pi/0.005m=10.05

Na=Nr*i=754N
Or
Na=M*r*2*pi/r*pitch=M*2*pi/pitch
Click to expand...

I got it.. thank you :- )

Ilyesgtsport · Apr 17, 2023

HI pmvcda ,
After your 5 years of use, what is your experience with your simulator and GruntyPig the 57BLF03 motors work without any problem, just a little slow!!

GruntyPig · Apr 17, 2023

Hi Ilyesgtsport,

The 57BLF03 motors are still working good. For the speed, the motors should run at 3000rpm and I find this is fast enough with 400mm 1605 ballscrews. The Mover software is just amazing!!!

roli · Apr 27, 2023

Hi there! I finally decided to build my first motion sim and this is the design that seems the most newbie friendly.

I managed to get my first actuator assembled and working. However... it seems slow... Too slow. I have 57BLF03 motors, and with calibration speed set to 255 the thing travels around 40cm in 4.8s. Which is roughly 80mm/s. When I was testing it first I accidentally left the controller with RV pin enabled and it seemed to slam into the mount with a lot more speed than what I am getting now. Any ideas on what could be the reason for the slow speed? Otherwise everything seems fine. When it starts it gets to the max end stop, then to the min endstop and I get this back: Minimum=-926 Maximum=926. I am using the same BLDC-8015A controller and the code from the first page (no changes).

Another side question... how much weight can this design handle? I was thinking of a pretty similar setup as the OP, but was thinking about adding an actual car dashboard (at least the drivers side and the middle console). Could this design handle something like this? If not... could I tweak it somehow?

pmvcda · Apr 28, 2023

roli said: ↑

Hi there! I finally decided to build my first motion sim and this is the design that seems the most newbie friendly.

I managed to get my first actuator assembled and working. However... it seems slow... Too slow. I have 57BLF03 motors, and with calibration speed set to 255 the thing travels around 40cm in 4.8s. Which is roughly 80mm/s. When I was testing it first I accidentally left the controller with RV pin enabled and it seemed to slam into the mount with a lot more speed than what I am getting now. Any ideas on what could be the reason for the slow speed? Otherwise everything seems fine. When it starts it gets to the max end stop, then to the min endstop and I get this back: Minimum=-926 Maximum=926. I am using the same BLDC-8015A controller and the code from the first page (no changes).

Another side question... how much weight can this design handle? I was thinking of a pretty similar setup as the OP, but was thinking about adding an actual car dashboard (at least the drivers side and the middle console). Could this design handle something like this? If not... could I tweak it somehow?
Click to expand...

Hi,

Somewhere in this topic I adjust a pot inside the 8015A to match the speed in all the actuators.
Maybe try to adjust it to reach the maximum speed without noise in the actuator.
Lacking ideas right now. (are you sure the wires are connected in the right order?)

For weight, my rig has lot's of stuff on it, a big monitor, a simcube 2, pedals and me with 80 kg.
I think it can handle the weight, but try to make it the lightest possible to have a better performance.

roli · Apr 29, 2023

Thanks. Will try the adjustment pot if I don't get it faster otherwise.

I am currently a bit suspicious of my DIY perfboard with all of the connections. I designed a PCB that will break out all of the needed stuff into screw terminals for easier and cleaner wiring. So waiting for that to arrive first before I invest too much time debugging this.

But I am sure that the controller-motor wiring is fine since the RV control seems to be able to move the motor with a lot more speed. So my guess is something to do with ESP-controller wiring. Though I am not sure what since things are otherwise working.

roli · May 19, 2023

Well I think I fixed the speed issue. For anyone else having the same issue - it was the pot in the controller that just needed some adjustment. I made like 10 turns with it - which slightly worries me. But it seems stable to me. If my calculations are correct then this should be around 233 mm/s.

bobo · Jun 13, 2023

pmvcda said: ↑

Software
Software used and code developed for this project

INTERNAL HALL SENSOR POSITIONING VERSION WITH ESP32 DEVKIT

Used software:
SimTools (got the DIY license)
LFS (demo version)
Sketchup to draw all the printed parts (free)
Cura to print 3D parts (free)
MSPhysics plugin for Sketchup, to test angles and dimensions of rig (free)
Arduino and needed libraries to program the ESP32 (free)

Developed PC software
To control the rig by calculating actuators positions to reach a specific pose.
I recommend using my latest software:
FlyPT Mover - https://www.xsimulator.net/community/threads/flypt-mover.13464/

There's an older software you can also use, but that's a simpler version of Mover.
FlyPT Hexapod Interface - https://www.xsimulator.net/communit...hexapod-interface-for-linear-actuators.12859/

Developed controller software (ESP32)
Installed in the ESP32, this code performs:
-Actuators calibration (calculates range and middle extension)
-Receives data (speed and/or position) from FlyPT Mover
-Sends current actuators position to FlyPT Mover
-Commands the motor controllers
-Interprets the readings from the internal hall sensors to determine the actuator position

You need to setup the Arduino IDE to program the ESP32, for that, use the following gides:

To install the ESP32 in Arduino IDE, please follow this video:

Extra info on the ESP32 - Please see the video, will help.

Changing com port to use two ESP32 simultanouslly:

Changing ID of ESP32 to have them start always in the same COM port
Thanks to @Gabor Pittner for the tip (here):

One of my biggest problem is that all ESP32 boards have the same hardware ID and COM ports are swapped sometimes in Windows.
I've been struggling with this problem for months... :confused:

Yesterday I found a solution how to change ESP32 board serial number to get a uniqe hardware ID. After it windows could reserve COM port to all uniqe ESP32 board.
You need to change serial number using with CP21xx Device Customization Software:
https://www.silabs.com/documents/public/example-code/AN721SW.zip
Device Customization Software General Overview on page 24. :
https://www.silabs.com/documents/public/application-notes/AN721.pdf
Need to change serial number only!!! :cool:

Code for ESP32 with external PID calculation
Comming soon!

Code for ESP32 with internal PID calculation, version: 11.3.is from 17-04-2020:

Code:

// ================================
// DIY 6DOF Motion Sim by FlyPT
// Version: 11.3.is from 17-04-2020
// Internal PID calculation
// ================================
// SimTools2 ESP32 code to control up to 3 actuators
// Actuators use brushless motors controlled by BLDC8015A drivers
// The BLDC8015A receives speed and direction in separated pins
// Position is obtained from internall hall sensors


// ===========================
// Serial output configuration
// ===========================
// Interface Type: Serial
// ComPort: The one used by your ESP32
// BitsPerSec: 921600 - If you want feedback on the serial monitor of the Arduino IDE, you have to change this to 500000 in the defines
// Data Bits: 8
// Parity: None
// Stop Bits: 1
// Bit Range: 15
// Type: Binary
// Interface string format: <255><255><Axis1a><Axis2a><Axis3a>
/// Output Rate: Can be down to 1 ms


// ===============
// PID calculation
// ===============
// PID calculation is performed in the ESP32
// In the PID calculation, we are calculating the speed that we want for the actuator.
// We have a pretended position and a current position of the actuator and speed is calculated depending on those values.
// Speed can be from -255 to 255, where negative speed is actuator going down and positive going up.
// Values beyond this range are cropped.
// Define each parameter PID in the defines, where:
// P is the proportional part. The amount of P depends on  the distance


// =======
// Defines
// =======
#define P 256                   // Proportional
#define I 0                     // Integral
#define D 256                   // Diferential
#define SERIAL_SPEED 921600     // 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, 19, 17,  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, 32, 33,  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++)
    {
      // 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++)
    {
      // 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==NUMBERACTUATORS*2) // Having 6 bytes means we have the 3 positions and that we can update the pretended position
    {
      for (int n = 0; n < NUMBERACTUATORS; n++)
      {
        actuator[n][PRETENDED_POSITION] = map((bufferCommand[n*2] * 256) + bufferCommand[n*2+1], 0, MAXIMUM_BIT_VALUE, actuator[n][MINIMUM_POSITION], actuator[n][MAXIMUM_POSITION]);
      }
      bufferCount=0;
    }
  }

  // Update orders sent to motor driver
  for (int n = 0; n < NUMBERACTUATORS; n++) updateActuatorSpeed(n);
}


// ==============================================
// Update positions thread loop running in core 0
// ==============================================
void TaskUpdatePositions(void * parameter)
{
  while (true)
  {
    for (int n = 0; n < NUMBERACTUATORS; n++) updateCurrentPosition(n);
  }
}

Click to expand...

Hello, is this program the final version? I have many questions that I would like to ask you.
Question 1:
I used two 10K resistors for the limit switch, following the exact same method as you described. However, in practice, one of the switches is not being detected.
Question 2:
Why is the PWM resolution only 8 bits with a maximum value of 255? The data sent by your PC appears to have 15 bits (32768), which seems to have a very low precision for the resolution.
Question 3:
After powering on, I first create a hall thread and then perform a calibration function. After the calibration is complete, should the motor be positioned and held in the middle of its travel range? This is because our BLDC motor does not have a braking mechanism.
Question 4:
Is the information sent from the PC in the form of 16 hexadecimal values (e.g., FF FF 12 34 12 34 12 34)? And does the actual speed information of axis 1 correspond to 12 * 256 + 34, map ranging from -255 to 255?
Question 5:
The current behavior I'm experiencing is that when I power on the system, the computer does not send any information. Then, after performing the calibration in the program (I changed the limit switches to separate channels and they are working correctly), once the calibration is complete, the motor starts spinning rapidly, reaching a speed of 255 and it doesn't change. After that, if I manually press the limit switch, the motor immediately reverses but still at a speed of 255. What could be the reason for this? Is it related to the PID controller? I'm using your default values of 255, 0, 255.

Basic Information:

My motor has 4 pole pairs and 8 poles. When I manually rotate it, there are a total of 24 steps for one complete revolution. It uses Hall sensors for position detection. In my case, the motor should not rotate when there are no commands from the PC. However, it is spinning rapidly. What should I do?
Thank you.

profetadelmus · Oct 27, 2023

I not have enough space to build a 6dof... but i think that i have space to build a 3dof with 3 or 4 motors (more easy 3 motors because the esp32 position controller) but with minor actuator travel (10-15cm max)... can be possible? what about max weight supported?

Walter Flores · Nov 3, 2023

Hi all, I just joined today and I am glad I found this forum, have been thinking about building one of these rigs for a while now but had not found the proper motivation to get started, one of the reason was that I could not find enough information on how to get started, until a few days a go I came across this forum and boy am I fired up to get started .

First off I'd like to thank @pmvcda for this helpful post, you really provide very good detailed information specially for a newbie like myself, I have experience in Electronic Engineering and some software background, so I really hope I can come up with my own simulator very soon

The most important thing for me at the moment is acquiring the materials, i.e. motors, motor drivers and all the other materials to start mocking up the set up, I wanted to ask aside from the brands of motors you used, are there any other brands similar in spec to the ones you are using, hopefully some that are a bit cheaper, I've been doing some digging in Amazon and came across a few but not sure if I should trust them as they seem way less expensive than all the other ones I've seen other people use.

Anyhow, thank you so much @pmvcda for providing all these helpful information, I will be downloading your software as soon as I have my motors.

Cheers all

Walter

Log in or Sign up

Showroom FlyPT - 6DOF Brushless DIY Actuators

twinking New Member

Koala70 New Member

Ilyesgtsport New Member

GruntyPig New Member Gold Contributor

roli New Member

pmvcda aka FlyPT

roli New Member

roli New Member

bobo Member

Attached Files:

mycode.txt

profetadelmus New Member

Walter Flores New Member