6-Axis configuration with CORE-BC kinematics

[alexmnr]

Hello all,
I am using uCNC to control a 6-axis robot arm and so far had a lot of success controlling all the motors and homing X,Y,Z and A axis. The problem is, that B and C axis are controlled using two motors that have to work together. So if both motor spin in the same direction, the B axis turns and when they spin in opposite directions, only C axis turns. The rest of the robot arm uses a normal 1 Motor 1 Axis configuration.
So here is my question: Is there any way to merge a cartesion kinematic system and a adapted COREXY for the b and c axis? I probably have to create my own kinematics file, is there any documentation or help on how to do this?

Every help or small hint on where I should start would be appreciated!

[Paciente8159]

That sounds awesome.
Creating a new kinematic is fairly trivial. The only really hard part is the math.

To create a new kinematic you just need to implement some of the functions declared in uCNC/src/hal/kinematics/kinematic.h.

The main ones are:

         /**
	 * @brief Implements kinematic initialization if needed. Can be an empty function.
	 * */
        void kinematics_init(void);

        /**
	 * @brief Converts from machine absolute coordinates to step position.
	 * This is done after computing position relative to the active coordinate system
	 *
	 * @param axis Position in world coordinates
	 * @param steps Position in steps
	 */

	void kinematics_apply_inverse(float *axis, int32_t *steps);

	/**
	 * @brief Converts from step position to machine absolute coordinates.
	 * This is done after computing position relative to the active coordinate system
	 *
	 * @param steps Position in steps
	 * @param axis Position in world coordinates
	 */
	void kinematics_apply_forward(int32_t *steps, float *axis);

	/**
	 * @brief Executes the homing motion for the machine.
	 * The homing motion for each axis is defined in the motion control.
	 * In the kinematics home function the axis order of the homing motion and other custom motions can be defined
	 *
	 * @return uint8_t Error status
	 */
	uint8_t kinematics_home(void);

        /**
	 * @brief Checks if the desired target is inside software boundaries
	 *
	 * @param axis Target in absolute coordinates
	 * @return true If inside boundaries
	 * @return false If outside boundaries
	 */
	bool kinematics_check_boundaries(float *axis);

These 5 functions contain all the kinematic operations needed to allow the core to control the machine mechanical movement and these tell µCNC how to:

• convert absolute axis coordinates to steps and vice versa
• in which order do the axis home (and if the home individually or in groups)
• and how can the machine calculate the virtual limits of it's own motion (used only if software limits setting is enabled)

After that is just a matter of adding the definitions and kinematic header calls to kinematicdefs.h and kinematics.h.

You can look at the cartesian an coreXY implementations to have a rough idea of how to do it.

Other stuff is optional like:

        /**
	 * @brief Aplies a transformation to the position sent to planner.
	 * This is aplied only on normal and jog moves. Homing motions go directly to planner.
	 *
	 * @param axis Target in absolute coordinates
	 */
	void kinematics_apply_transform(float *axis);

	/**
	 * @brief Aplies a reverse transformation to the position returned from the planner.
	 * This is aplied only on normal and jog moves. Homing motions go directly to planner.
	 *
	 * @param axis Target in absolute coordinates
	 */
	void kinematics_apply_reverse_transform(float *axis);

These functions can be implemented to apply special transformations to correct geometric deformations, machine mechanical problems or other edge cases, but can simply be ignored.

[alexmnr]

Thank you for the quick answer, I actually figured out the way, I just had to copy four lines from the corexy script and it worked!
Thank you so much, I love this project!