LinuxCNC Documentation
This page is 82% translated. Untranslated text is shown in English.

1. Введение

A number of kinematics modules support the switching of kinematics calculations. These modules support a default kinematics method (type0), a second built-in method (type1), and (optionally) a user-provided kinematics method (type2). Identity kinematics are typically used for the type1 method.

The switchkins functionality can be used for machines where post-homing joint control is needed during setup or to avoid movement near singularities from G-code. Such machines use specific kinematics calculations for most operations but can be switched to identity kinematics for control of individual joints after homing.

The kinematics type is selected with G12.1 P- and G13.1, from a G-code program or by interactive MDI commands. Buttons on a virtual panel (PyVCP, GladeVCP, etc.) or on hardware controls select a kinematics type through the halui provisions for activating MDI commands.

Changing the kinematics type requires the interpreter and motion parts of LinuxCNC to be synchronized, which G12.1 and G13.1 do themselves.

A deprecated HAL pin, motion.switchkins-type, selects a kinematics type as well. It is described under Usage below, because existing configurations use it.

2. Switchable Kinematic Modules

The following kinematics modules support switchable kinematics:

  1. xyzac-trt-kins (type0:xyzac-trt-kins type1:identity)

  2. xyzbc-trt-kins (type0:xyzbc-trt-kins type1:identity)

  3. genhexkins (type0:genhexkins type1:identity)

  4. genserkins (type0:genserkins type1:identity) (puma560 example)

  5. pumakins (type0:pumakins type1:identity)

  6. three21kins (type0:three21kins type1:identity)

  7. scarakins (type0:scarakins type1:identity)

  8. 5axiskins (type0:5axiskins type1:identity) (bridgemill)

  9. millturn (type0:identity type1:turn)

  10. xyzab_tdr_kins (type0:identity type1:tcp)

  11. xyzacb_trsrn (type0:identity type1:tcp type2:tool)

  12. xyzbca_trsrn (type0:identity type1:tcp type2:tool)

Every module listed above uses its own kinematics for type0 and identity kinematics for type1. Each accepts the module string parameter sparm to swap the two, so that the machine starts in identity kinematics and the module kinematics are selected on demand:

[KINS]
KINEMATICS = xyzac-trt-kins sparm=identityfirst
# ...

Starting in identity kinematics leaves a way out of poses the module kinematics cannot solve. A module kinematics failure (near a singularity, for instance) reports an error and disables the machine; type0 is then reached without running the failing kinematics again.

Note
The sparm setting exchanges type0 and type1, so any G-code or HAL logic that selects a kinematics type by number must match.

Kinematics that solve the forward direction iteratively, genhexkins among them, need a pose to start from. While another type is running they take the estimate the caller supplies, which motion seeds from the [TRAJ]HOME world home, so they are ready to be switched to.

2.1. назначения идентифицирующей буквы

При использовании типа кинематики identity параметр модуля координаты можно использовать для назначения букв сочленениям в произвольном порядке из набора разрешенных букв координат. Примеры:

[KINS]
JOINTS = 6

# conventional identity ordering: joint0==x, joint1==y, ...
KINEMATICS = genhexkins coordinates=xyzabc

# custom identity ordering: joint0==c, joint1==b, ...
# KINEMATICS = genhexkins coordinates=cbazyx
Note
Если параметр coordinates= опущен, по умолчанию буква-сочленение присваиваемых идентификаторов будут joint0==x,joint1=y,…​

Назначения сочленений, предусмотренные для кинематики identity при использовании параметра координат, идентичны тем, которые предусмотрены для модуля trivkins. Однако дублирование букв осей для назначения нескольких сочленений букве координат обычно не применимо для последовательной или параллельной кинематики (например, genserkins, pumakins, genhexkins и т. д.), где нет простой взаимосвязи между сочленениями и координатами.

Дублирование букв координат осей поддерживается в модулях кинематики xyzac-trt-kins, xyzbc-trt-kins и 5axiskins (bridgemill). Типичным применением дублирующихся координат являются портальные станки, в которых для поперечной оси используются два двигателя (сочленения).

2.2. Обратная совместимость

Переключаемая кинематика инициализируется с помощью motion.switchkins-type==0, реализующего одноименный метод кинематики. Если контакт типа motion.switchkins не подключен (как в устаревших конфигурациях), доступен только тип кинематики по умолчанию.

3. HAL Контакты

Переключение кинематики контролируется входным контактом HAL модуля движения motion.switchkins-type. Значение вывода с плавающей запятой усекается до целого числа и используется для выбора одного из предоставленных типов кинематики. Нулевое значение запуска выбирает тип кинематики по умолчанию type0.

Note
Входной контакт типа motion.switchkins имеет тип числа с плавающей запятой, чтобы облегчить подключение к выходным контактам модуля движения, таким как motion.analog-out-0n, которые управляются стандартными M-кодами (обычно M68EnL0).

Выходные контакты HAL предназначены для информирования ГИП о текущем типе кинематики. Эти контакты также можно подключить к цифровым входам, которые считываются программами G-кода для включения или отключения поведения программы в соответствии с активным типом кинематики.

3.1. Сводная информация о контактах HAL

  1. motion.switchkins-type Input (real)

  2. motion.kins-type Output (real)

  3. kinstype.is-0 Output (bool)

  4. kinstype.is-1 Output (bool)

  5. kinstype.is-2 Output (bool)

A module providing more than three kinematics types has one kinstype.is-N pin per type.

4. Использование

4.1. HAL Connections

G12.1 and G13.1 ask motion for a kinstype directly and need no HAL connection at all.

A kinstype can also be selected by writing the pin motion.switchkins-type, which is sourced from an analog output pin like motion.analog-out-03 so that it can be set by M68 commands:

net :kinstype-select <= motion.analog-out-03
net :kinstype-select => motion.switchkins-type
Warning
Selecting the kinstype from HAL is deprecated and motion says so, once, the first time the pin is used to change it. The interpreter does not see the pin, so a program is read, its limits checked and its path looked ahead in whatever kinematics the interpreter last knew about, which is not necessarily the one that will run it. Use G12.1 and G13.1. The pin is in a grace period: it keeps working for now, but is meant to be removed in the future.

4.2. G-code commands

G12.1 P- selects a kinstype and G13.1 cancels back to identity kinematics. Which kinstype that is, the module declares (see Code Notes), not fixed to a number; on a module whose slides do not line up with its frame it is the machine frame type the module declares instead:

...
G12.1 P1  ;select kinstype 1
...
...       ;user G-code
...
G13.1     ;back to identity kinematics
...

These codes ask motion for the kinstype directly and synchronize task and motion themselves, so no HAL connection and no separate sync command are needed. The G-code words and the motion.switchkins-type pin are both acted on when they change, so whichever asked most recently is the one in force. motion.kins-type reports what is currently selected.

The pin is deprecated, see the warning under HAL Connections.

The kinstype in force is readable in G-code as #<_kins_type>, which lets a subroutine restore whatever its caller had selected:

#<saved> = #<_kins_type>
G12.1 P2
( ... )
G12.1 P#<saved>

Selection is not cancelled by the end of a program or by an abort, so that the kinstype continues to match the position readout. A program that should leave the machine in identity kinematics ends with G13.1.

A module that declares no identity or machine frame kinstype refuses G13.1 with an error and can still be driven by number with G12.1; see Code Notes for how a module declares its types.

For tool length work there are spellings that name the kinematics by what it is rather than by number: G43.4 applies the tool length offset and switches to the kinstype the module declares its working transform, and the G49 that cancels it switches back to identity. See the G-code documentation for G43.4 and G49, and for G12.1 and G13.1, for the full description.

4.3. M-code commands

Warning
This is the deprecated route described under HAL Connections above. It is documented because existing configurations use it. New ones should use G12.1 and G13.1.

Writing motion.switchkins-type through an analog output pin needs the HAL connection shown above. Kinstype selection is then managed using G-code sequences like:

...
M68 E3 Q1 ;update analog-out-03 to select kinstype 1
M66 E0 L0 ;sync interp-motion
...
...       ;user G-code
...
M68 E3 Q0 ;update analog-out-03 to select kinstype 0
M66 E0 L0 ;sync interp-motion
...
Note
Команда M66 wait-on-input обновляет переменную #5399. Если текущее значение этой переменной необходимо для последующих целей, его следует скопировать в дополнительную переменную перед вызовом M66.

Эти последовательности команд G-кода обычно реализуются в подпрограммах G-кода как переназначенные M-коды или с помощью обычных сценариев M-кода.

Предлагаемые коды (используемые в конфигурациях sim):

Обычные пользовательские M-коды:

  1. M128 Выбор kinstype 0 (кинематика по умолчанию при запуске)

  2. M129 Выбирает kinstype 1 (обычно идентичная кинематика)

  3. M130 Выбирает kinstype 2 (кинематика, предоставляемая пользователем)

Переназначенные М-коды:

  1. M428 Выбор kinstype 0 (кинематика по умолчанию при запуске)

  2. M429 Выберите kinstype 1 (обычно идентичная кинематика)

  3. M430 Выбор kinstype 2 (кинематика, предоставляемая пользователем)

Note
Обычные пользовательские М-коды (в диапазоне от M100 до M199) находятся в модальной группе 10. Переназначенные M-коды (в диапазоне от M200 до M999) могут указывать модальную группу. Дополнительную информацию см. в документации по переназначению.

4.4. Настройки ограничений INI-файла

При планировании траектории LinuxCNC используются ограничения на положение (мин, максимум), скорость и ускорение для каждой применимой буквы координат, указанной в INI-файле конфигурации. Пример буквы L (в наборе XYZABCUVW):

[AXIS_L]
MIN_LIMIT =
MAX_LIMIT =
MAX_VELOCITY =
MIN_ACCELERATION =

Указанные ограничения файла INI применяются к типу кинематики по умолчанию типа 0, который активируется при запуске. Эти ограничения могут не применяться при переключении на альтернативную кинематику. Однако, поскольку при переключении кинематики требуется синхронизация движения интерпретатора, контакты INI-HAL можно использовать для установки пределов для ожидающего типа кинематики.

Note
Контакты INI-HAL обычно не распознаются во время работы программы G-кода, если не выдана команда синхронизации (queue-buster). Дополнительную информацию см. на странице руководства milltask ($ man milltask).

Соответствующие контакты INI-HAL для номера сочленения (N):

ini.N.min_limit
ini.N.max_limit
ini.N.max_acceleration
ini.N.max_velocity

Соответствующие контакты INI-HAL для координаты оси (L):

ini.L.min_limit
ini.L.max_limit
ini.L.max_velocity
ini.L.max_acceleration
Note
В общем, не существует фиксированных сопоставлений между номерами сочленений и буквами координат осей. Для некоторых модулей кинематики могут существовать специальные сопоставления, особенно для тех, которые реализуют идентичную кинематику (trivkins). Дополнительную информацию смотрите на странице руководства kins ($ man kins).

Предоставленный пользователем M-код может изменить любые или все пределы координат оси перед изменением контакта типа motion.switchkins и синхронизацией интерпретатора и движущихся частей LinuxCNC. Например, скрипт bash, вызывающий halcmd, может быть hardcoded для установки любого количества контактов HAL:

#!/bin/bash
halcmd -f <<EOF
setp ini.x.min_limit -100
setp ini.x.max_limit  100
# ... repeat for other limit parameters
EOF

Подобные скрипты могут быть вызваны как пользовательский M-код и использованы перед M-кодом переключения kins, который обновляет контакт HAL типа motion.switchkins-type и вызывает принудительную синхронизацию interp-motion. Обычно для каждого kinstype (0,1,2) используются отдельные скрипты.

Когда identity kinematics предоставляется в качестве средства управления отдельными сочленениями, может быть удобно устанавливать или восстанавливать пределы, указанные в системном INI-файле. Например, робот стартует со сложной (non-identity) кинематикой (type0) после возврата в исходное положение. Система настроена так, что ее можно переключить на identity kinematics (type1) для манипулирования отдельными сочленениями с помощью обычных букв из набора XYZABCUVW. Настройки INI-файла ([AXIS_L]) не применимы при работе с identity (type1) kinematics. Для решения этого варианта использования пользовательские скрипты M-кода могут быть разработаны следующим образом:

M129 (Switch to identity type1)

  1. прочитать и разобрать INI-файл

  2. HAL: setp ограничительные контакты INI-HAL для каждой буквы оси ([AXIS_L]) в соответствии с настройкой ([JOINT_N]) identity-referenced номера сочленения INI файла

  3. HAL: setp motion.switchkins-type 1

  4. MDI: выполните синхронизирующий G-код (M66E0L0)

M128 (restore robot default kinematics type 0)

  1. прочитать и разобрать INI-файл

  2. HAL: setp ограничительные контакты INI-HAL для каждой буквы оси ([AXIS_L]) в соответствии с соответствующей настройкой INI-файла ([AXIS_L])

  3. HAL: setp motion.switchkins-type 0

  4. MDI: выполните синхронизирующий G-код (M66E0L0)

Note
Конфигурации моделирования vismach для робота Puma демонстрируют сценарии M-кода (M128, M129, M130) для этого примера использования.

4.5. Соображения смещения системы координат

Как и настройки предельных значений INI-файла, смещения системы координат (G92, G10L2, G10L20, G43 и т. д.) обычно применимы только для type 0 типа kinematics при запуске по умолчанию. При переключении типов кинематики может быть важно либо сбросить все смещения перед переключением, либо обновить смещения в соответствии с требованиями конкретной системы.

4.6. Внешние соображения смещения

External offsets (set to an axis (L) via axis.L.eoffset-request) are preserved during kinematics switches. When an offset is active on an axis before the switch (visible in axis.L.eoffset), the trajectory planner maintains that same offset after the switch, similar to how it maintains the commanded position from a G-code. This ensures consistent machine behavior regardless of the active kinematics.

If maintaining the offset will be an issue due to axis limit changes or other concerns, be sure to clear and possibly disable the eoffset before making a kinematics switch.

5. Конфигурации моделирования

Конфигурации моделирования (не требующие аппаратного обеспечения) снабжены иллюстративными дисплеями vismach в подкаталогах configs/sim/axis/vismach/ .

  1. 5axis/table-rotary-tilting/xyzac-trt.ini (xyzac-trt-kins)

  2. 5axis/table-rotary-tilting/xyzbc-trt.ini (xyzac-trt-kins)

  3. 5axis/bridgemill/5axis.ini (5axiskins)

  4. scara/scara.ini (scarakins)

  5. puma/puma560.ini (genserkins)

  6. puma/puma.ini (pumakins)

  7. hexapod-sim/hexapod.ini (genhexkins)

  8. millturn/millturn.ini (millturn)

  9. 5axis/table-dual-rotary/xyzab-tdr.ini (xyzab_tdr_kins)

  10. 5axis/table-rotary_spindle-rotary-nutating/xyzacb-trsrn_twp/xyzacb-trsrn.ini (xyzacb_trsrn)

  11. 5axis/table-rotary_spindle-rotary-nutating/xyzbca-trsrn_twp/xyzbca-trsrn.ini (xyzbca_trsrn)

6. Условия пользовательской кинематики

There are two ways to supply custom kinematics. Adding a kinstype to a module that is already in the tree is the smaller job; building a module of your own gives you every kinstype it provides.

6.1. Adding a kinstype to an in-tree module

Custom kinematics can be coded and tested on Run-In-Place (RIP) builds. A template file src/emc/kinematics/userkfuncs.c is provided in the distribution. This file can be copied/renamed to a user directory and edited to supply custom kinematics with kinstype==2: the in-tree modules register its USERK_OPS as that kinstype, so the forward and inverse in the copy are what runs.

Пользовательский файл кинематики можно скомпилировать из исходных расположений вне дерева для реализаций rt-preempt или путем замены файла шаблона в дереве (src/emc/kinematics/userkfuncs.c) для систем rtai.

Preempt-rt make пример:

$ userkfuncs=/home/myname/kins/mykins.c make && sudo make setuid

6.2. Building a switchkins module of your own

A complete kinematics module can be built out-of-tree with halcompile using the same switchkins implementation the in-tree modules use, so it gets the kinematics switching, the kinstype.is-N pins, the coordinates= identity mapping and the G-code and HAL controls without reimplementing any of them.

The implementation is the switchkins_core module. It provides no kinstypes of its own; it exports switchkinsInit() and the rest of the switchkins.h interface, and the identity kinematics and helpers kins_module.h declares. A module of your own includes switchkins.h, supplies switchkinsSetup() and a kinsDescribe() that replays it through switchkinsDescribeWith(), and calls switchkinsRunSetupWith() and switchkinsInit() from EXTRA_SETUP(), which halcompile runs after hal_init() and before hal_ready(). See Code Notes for the calls.

The template is src/hal/components/switchkinscomp.comp. Copy and rename it (both the file and the component name) and replace the example kinstype with the real kinematics. Start from the template, not from an in-tree component such as millturn.comp: those link the switchkins objects into the module through hal/components/Submakefile, which a halcompile build outside the tree does not do.

$ halcompile --install user_switchkins.comp
[KINS]
KINEMATICS = user_switchkins
JOINTS = 3

The HAL file loads switchkins_core ahead of the module:

loadrt switchkins_core
loadrt [KINS]KINEMATICS

A module loaded without switchkins_core ahead of it fails to load, and the error names the first switchkins or kinematics function it could not find:

user_switchkins: dlopen: .../rtlib/user_switchkins.so: undefined symbol: ...

7. Предупреждения

Неожиданное поведение может возникнуть, если программа G-кода случайно запускается с несовместимым типом кинематики. Нежелательное поведение можно обойти в программах G-кода следующим образом:

  1. Подключение соответствующих контактов HAL kinstype.is.N к контактам цифрового входа (например, motion.digital-in-0m).

  2. Чтение контакта цифрового входа (M66 E0 Pm) в начале программы G-кода

  3. Прерывание (M2) программы G-кода с сообщением (DEBUG, problem_message), если kinstype не подходит.

При интерактивном использовании возможностей медленной подачи или команд MDI оператору требуется соблюдать осторожность. В ГИП должны быть индикаторы для отображения текущего типа кинематики.

Note
Переключаемая кинематика может привести к существенным эксплуатационным изменениям, требующим тщательного проектирования, тестирования и подготовки к развертыванию. Управление смещениями координат, компенсацией инструмента и ограничениями файлов INI может потребовать сложных и нестандартных рабочих протоколов.

8. Примечания к коду

Kinematic modules providing switchkins functionality are linked to the switchkins.o object (switchkins.c). It provides kinematicsForward(), kinematicsInverse(), kinematicsSwitch() and the rest of the kinematics interface, dispatching each call to the kinstype currently selected, and it creates the HAL pins common to all switchkins modules. It does not provide the module main program, so a module can get that from wherever suits it.

A kinstype is supplied by calling switchkinsRegisterOps(), once per kinstype, with the maths of that type written as functions of the parameter block (see the Kinematics Conventions chapter):

int switchkinsRegisterOps(int ktype, const kins_ops *ops);

The geometry of the whole module is one table, named in the kparms fields params and nparams; every kinstype reads it from the block. The older form, switchkinsRegister() with a setup, forward and inverse routine per kinstype that read pins of their own, is still accepted:

int switchkinsRegister(int ktype, KS kset, KF kfwd, KI kinv);

ktype runs from 0 to SWITCHKINS_MAX_TYPES-1 (defined in kinematics.h). Registering a kinstype twice, by either route, is an error, and so is leaving a gap below the highest kinstype provided. Either mistake fails the module load and says which kinstype is at fault.

Each kinstype gets its own kinstype.is-N pin, so a module providing the usual three keeps the pin names it always had.

A module also declares what each kinstype IS, with flags from kinematics.h:

  1. KINSTYPE_IDENTITY no transform: the joints are the world

  2. KINSTYPE_PRIMARY the module’s working transform

  3. KINSTYPE_MACHINE the machine frame: the pivot in machine coordinates, the rotaries as joints

A kinstype registered with switchkinsRegisterOps() carries its flag in the ops table itself, as the identity, primary or machine field; a kinstype registered the older way gets it from a call, again from within switchkinsSetup():

int switchkinsDeclare(int ktype, int flags);

G-code reads these declarations: G13.1 and G49 cancel to the kinstype declared KINSTYPE_MACHINE, and G43.4 switches to the kinstype declared KINSTYPE_PRIMARY, whatever their numbers, so a module whose kinematics are not in the conventional order still gets working spellings. The machine frame type is the machine with the orientation left out, XYZ the pivot in machine coordinates and the rotary letters the rotary joints; on a machine whose slides line up with its frame that is the identity type, so a module that declares no machine frame kinstype has its identity kinstype stand in, and every shipped module is of that kind. A module whose carriage does not line up, a slanted slide or a composite Y on a mill-turn, declares its machine frame kinstype separately and keeps KINSTYPE_IDENTITY for a kinstype whose joints really are the axes, since motion and the planner skip the maths on that flag alone. At most one kinstype may be declared identity, at most one primary and at most one machine frame, and declaring a kinstype the module does not provide fails the module load. A module that declares nothing keeps working exactly as before for G12.1 P- and G49, but G13.1 and G43.4 are an error, since the numbers of the identity and primary kinematics are then a guess.

A module that implements kinematicsTypeFlags() itself, without switchkins.c, returns the flags of every kinstype it can switch to, 0 when neither applies, and -1 for any other: G12.1 P- refuses a kinstype that returns -1.

When every kinstype is registered, the module calls:

int switchkinsInit(const int comp_id, kparms* kp, const char* coordinates);

which checks the supplied parameters, creates the HAL pins, the table’s among them, selects kinstype 0, and then invokes the setup routine of each kinstype registered the older way. The caller owns the HAL component: it does hal_init() before switchkinsInit() and hal_ready() after it.

A module built this way also exports kinsDescribe(), through which a copy of it loaded outside realtime learns its table and the maths of each kinstype; the non-realtime loader and kinslimits use it. It exports kinematicsSetTool() as well, through which motion hands it the tool offset in effect whenever that changes. A table entry flagged as the tool is overwritten with it, and the entry’s pin only matters until motion has sent anything, so a config need not net motion.tooloffset.z to the module. A kinstype registered the older way reads its own pins and is not affected.

8.1. Module main program

A module written as a plain C file links switchkins_main.o (switchkins_main.c) for its rtapi_app_main(). That main program reads the (optional) module command-line parameters (coordinates, sparm) and passes them to the module-provided function switchkinsSetup():

int switchkinsSetup(kparms* kp,
                    KS* kset0, KS* kset1, KS* kset2,
                    KF* kfwd0, KF* kfwd1, KF* kfwd2,
                    KI* kinv0, KI* kinv1, KI* kinv2);

which sets the configuration settings, names the geometry table and registers the kinstypes with switchkinsRegisterOps(). The pointer arguments are the older route for kinstypes 0,1,2; a module using them leaves the rest alone. switchkinsRunSetup() in switchkins_setup.c is what runs switchkinsSetup() and registers what it returned, for the main program and for kinsDescribe() alike.

A module written as a halcompile component gets rtapi_app_main() from halcompile instead. It supplies the same switchkinsSetup() and a kinsDescribe() that replays it, and from its EXTRA_SETUP() routine, which halcompile runs after hal_init() and before hal_ready(), runs switchkinsSetup() and then switchkinsInit():

int kinsDescribe(const char *coords, const char *sparm,
                 kins_module_info *info)
{
    return switchkinsDescribeWith(switchkinsSetup, coords, sparm, info);
}

EXPORT_SYMBOL(kinsDescribe);

EXTRA_SETUP() {
    kparms kp;
    (void)__comp_inst; (void)prefix; (void)extra_arg;

    if (switchkinsRunSetupWith(switchkinsSetup, &kp, NULL)) { return -1; }
    return switchkinsInit(comp_id, &kp, coordinates);
}

switchkinsRunSetupWith() and switchkinsDescribeWith() take the module’s switchkinsSetup() as an argument, so they work from switchkins_core. switchkinsRunSetup() and the kinsDescribe() in switchkins_setup.c call the switchkinsSetup() they were linked with, and only a module built in tree links them.

Where the switchkins code comes from depends on where the component is built. Out of tree, the switchkins_core module provides it, loaded ahead of the component (see Building a switchkins module of your own). In tree, the component links the objects into itself instead, named in hal/components/Submakefile:

millturn-extra-objs := emc/kinematics/switchkins.o emc/kinematics/switchkins_setup.o emc/kinematics/kins_util.o

8.2. Outline

A switchkinsSetup() with the kinematics itself left out: the table, the ops table of the machine’s own kinstype, and the shared identity and userk ops for the other two:

static const kins_param_desc my_params[] = {
    { "pivot-length", KINS_PARAM_FLOAT, KINS_IN, 0, 100.0 },
    { "tool-offset",  KINS_PARAM_FLOAT, KINS_IN, 1, 0.0 },   // the tool length
};
enum { P_PIVOT_LENGTH, P_TOOL_OFFSET };

static int my_forward(const kins_params *p, kins_scratch *s,
                      const double *joint, EmcPose *pos,
                      const KINEMATICS_FORWARD_FLAGS *fflags,
                      KINEMATICS_INVERSE_FLAGS *iflags)
{
    double pivot = p->geometry[P_PIVOT_LENGTH];   // where a pin was read
    double tool  = p->tool.tran.z;                // the tool, from wherever the caller has it
    // ...
}

static int my_inverse(const kins_params *p, kins_scratch *s,
                      const EmcPose *pos, double *joint,
                      const KINEMATICS_INVERSE_FLAGS *iflags,
                      KINEMATICS_FORWARD_FLAGS *fflags);

static const kins_ops my_ops = {
    .forward = my_forward,
    .inverse = my_inverse,
    // .work, .tool, .native and .jacobian are optional, see kins_module.h
};

int switchkinsSetup(kparms* kp,
                    KS* kset0, KS* kset1, KS* kset2,
                    KF* kfwd0, KF* kfwd1, KF* kfwd2,
                    KI* kinv0, KI* kinv1, KI* kinv2
                   )
{
    kp->kinsname             = "mykins"; // must agree with the filename
    kp->halprefix            = "mykins"; // hal pin names
    kp->required_coordinates = "xyzab";
    kp->max_joints           = strlen(kp->required_coordinates);
    kp->params               = my_params;
    kp->nparams              = sizeof(my_params)/sizeof(my_params[0]);
    // remaining kparms fields

    switchkinsRegisterOps(0, &my_ops);              // kinstype 0 is the startup default
    switchkinsRegisterOps(1, &KINS_IDENTITY_OPS);
    switchkinsRegisterOps(2, &USERK_OPS);

    // any further kinstype is registered the same way, and the
    // numbering carries on with no gaps
    return 0;
} // switchkinsSetup()

For the surrounding shape, the in-tree switchkinsSetup() routines are in src/emc/kinematics: 5axiskins.c, xyzac-trt-kins.c, genserkins.c, scarakins.c and the others listed at the top of this document. None of them registers a fourth kinstype yet, so a call for one has no in-tree example to copy.