ioControl.cc new pin iocontrol.0.tool-from-pocket

tldr: pocket number for nonrandom toolchangers does not
have to be fixed (unchangeable).

For configs using [EMCIO]RANDOM_TOOLCHANGER=0 (default), an
external application (or a [EMCIO]DB_PROGRAM) can alter the
pocket number for a tool while LinuxnCNC is running.
LinuxCNC can read such updated tooldata using
python:linuxcnc.command().load_tool_table() from a gui or
with G10L0 gcode.   The pin iocontrol.0.tool-from-pocket can
be used to return a tool to the appropriate pocket when such
updates are employed.

update linuxcnc.stat, docs, runtests

Author: dngarrett

docs/src/config/python-interface.adoc

@@ -371,6 +371,9 @@ machine angular units per deg, reflects [TRAJ]ANGULAR_UNITS INI value.
 *tool_in_spindle*:: '(returns integer)' -
   current tool number.
 
+*tool_from_pocket*:: '(returns integer)' -
+  pocket number for the currently loaded tool (0 if no tool loaded).
+
 *tool_offset*:: '(returns tuple of floats)' -
   offset values of the current tool.
 

docs/src/gcode/tool-compensation.adoc

@@ -204,29 +204,40 @@ The io program provides HAL output pins to facilitate toolchanger management:
 . *iocontrol.0.tool-prep-number*
 . *iocontrol.0.tool-prep-index*
 . *iocontrol.0.tool-prep-pocket*
+. *iocontrol.0.tool-from-pocket*
 
 ==== IO for non-random toolchanger
 
 . Tool number n==0 indicates no tool
-. The pocket number for a tool is fixed when tooldata is loaded
+. The pocket number for a tool is set when tooldata is loaded/reloaded
+from its data source ([EMCIO]TOOL_TABLE or [EMCIO]DB_PROGRAM).
 . At G-code *Tn* (n != 0) command:
 .. *iocontrol.0.tool-prep-index*  = idx (index based on tooldata load sequence)
 .. *iocontrol.0.tool-prep-number* = n
-.. *iocontrol.0.tool-prep-pocket* = the fixed pocketno for n
+.. *iocontrol.0.tool-prep-pocket* = the pocketno for n
 . At G-code *T0* (n == 0 remove) command:
 .. *iocontrol.0.tool-prep-index*  = 0
 .. *iocontrol.0.tool-prep-number* = 0
 .. *iocontrol.0.tool-prep-pocket* = 0
+. At M-code *M6* (following iocontrol.0.tool-changed pin 0-->1):
+.. *iocontrol.0.tool-from-pocket* = pocket number used to retrieve tool
 
 ==== IO for random toolchanger
 
 . Tool number n==0 is *not special*.
 . Pocket number 0 is *special* as it indicates the *spindle*.
 . The *current* pocket number for tool N is the tooldata index (idx) for tool n.
 . At G-code command *Tn*:
-.. *iocontrol.0.tool-prep-index*  = pocket number for tool n
+.. *iocontrol.0.tool-prep-index*  = tooldata index (idx) for tool n
 .. *iocontrol.0.tool-prep-number* = n
 .. *iocontrol.0.tool-prep-pocket* = pocket number for tool n
+. At M-code *M6* (following iocontrol.0.tool-changed pin 0-->1):
+.. *iocontrol.0.tool-from-pocket* = pocket number used to retrieve tool
+
+[NOTE]
+At startup, *iocontrol.0.tool-from-pocket* = 0.
+An M61Qn (n!=0) command does not change the *iocontrol.0.tool-from-pocket*.
+An M61Qn (n==0) command sets *iocontrol.0.tool-from-pocket* to 0.
 
 [[sub:tool-changers]]
 === Tool Changers(((Tool Changers)))
@@ -248,21 +259,33 @@ with INI statements:
 HALFILE = axis_manualtoolchange.hal
 ----
 
-.Fixed Location Tool Changers
+.Fixed Location Tool Changers 
 Fixed location tool changers always return the tools to a
 fixed position in the tool changer. This would also include
 designs like lathe turrets. When LinuxCNC is configured for a fixed
 location tool changer the 'P' number is not used internally (but read, preserved
 and rewritten) by LinuxCNC, so you can use P for any bookkeeping number you
 want.
 
+[NOTE]
+When using [EMCIO]RANDOM_TOOLCHANGER = 0 (the default), the 'P'
+pocket number is a parameter of the tooldata that is retrieved from
+the tooldata source ([EMCIO]TOOL_TABLE or [EMCIO]DB_PROGRAM).  In many
+applications it is fixed but it may be changed by edits to the
+[EMCIO]TOOL_TABLE or programatically when the [EMCIO]DB_PROGRAM is
+used.  LinuxCNC pushes updates to the data source ([EMCIO]TOOL_TABLE
+or [EMCIO]DB_PROGRAM) for gcodes G10L1,G10L10,G10L11,M61.  LinuxCNC
+can pull tooldata updates from the data source by UI (user-interface)
+commands (python example: linuxcnc.command().load_tool_table()) or by
+the gcode: G10L0.
+
 .Random Location Tool Changers
-Random location tool changers swap the tool in the spindle with the
-one in the changer. With this type of tool changer the tool will
-always be in a different pocket after a tool change. When a tool is
-changed LinuxCNC rewrites the pocket number to keep track of where the tools
-are. T can be any number but P must be a number that makes sense for
-the machine.
+Random location tool changers ([EMCIO]RANDOM_TOOLCHANGER = 1) swap the
+tool in the spindle with the one in the changer. With this type of
+tool changer the tool will always be in a different pocket after a
+tool change. When a tool is changed LinuxCNC rewrites the pocket
+number to keep track of where the tools are. T can be any number but P
+must be a number that makes sense for the machine.
 
 
 == Tool Length Compensation(((Tool Length Compensation)))

src/emc/iotask/ioControl.cc

@@ -102,6 +102,7 @@ struct iocontrol_str {
     hal_bit_t *tool_prepare;        /* output, pin that notifies HAL it needs to prepare a tool */
     hal_s32_t *tool_prep_pocket;/* output, pin that holds the pocketno for the tool table entry matching the tool to be prepared,
                                    only valid when tool-prepare=TRUE */
+    hal_s32_t *tool_from_pocket;/* output, pin indicating pocket current load tool retrieved from*/
     hal_s32_t *tool_prep_index; /* output, pin for internal index (idx) of prepped tool above */
     hal_s32_t *tool_prep_number;/* output, pin that holds the tool number to be prepared, only valid when tool-prepare=TRUE */
     hal_s32_t *tool_number;     /* output, pin that holds the tool number currently in the spindle */
@@ -407,6 +408,16 @@ static int iocontrol_hal_init(void)
         hal_exit(comp_id);
         return -1;
     }
+    // tool-from-pocket
+    retval = hal_pin_s32_newf(HAL_OUT, &(iocontrol_data->tool_from_pocket), comp_id,
+                              "iocontrol.%d.tool-from-pocket", n);
+    if (retval < 0) {
+        rtapi_print_msg(RTAPI_MSG_ERR,
+                        "IOCONTROL: ERROR: iocontrol %d pin tool-from-pocket export failed with err=%i\n",
+                        n, retval);
+        hal_exit(comp_id);
+        return -1;
+    }
     // tool-prepared
     retval = hal_pin_bit_newf(HAL_IN, &(iocontrol_data->tool_prepared), comp_id,
                               "iocontrol.%d.tool-prepared", n);
@@ -483,6 +494,7 @@ static void hal_init_pins(void)
     *(iocontrol_data->tool_prepare)=0;       /* output, pin that notifies HAL it needs to prepare a tool */
     *(iocontrol_data->tool_prep_number)=0;   /* output, pin that holds the tool number to be prepared, only valid when tool-prepare=TRUE */
     *(iocontrol_data->tool_prep_pocket)=0;   /* output, pin that holds the pocketno for the tool to be prepared, only valid when tool-prepare=TRUE */
+    *(iocontrol_data->tool_from_pocket)=0;   /* output, always 0 at startup */
     *iocontrol_data->tool_prep_index=0;      /* output, pin that holds the internal index (idx) of the tool to be prepared, for debug */
     *(iocontrol_data->tool_change)=0;        /* output, notifies a tool-change should happen (emc should be in the tool-change position) */
 }
@@ -623,13 +635,18 @@ static int read_tool_inputs(void)
     if (*iocontrol_data->tool_change && *iocontrol_data->tool_changed) {
         if(!random_toolchanger && emcioStatus.tool.pocketPrepped == 0) {
             emcioStatus.tool.toolInSpindle = 0;
+            emcioStatus.tool.toolFromPocket  =  *(iocontrol_data->tool_from_pocket) = 0;
         } else {
             // the tool now in the spindle is the one that was prepared
             CANON_TOOL_TABLE tdata;
             if (tooldata_get(&tdata,emcioStatus.tool.pocketPrepped) != IDX_OK) {
                 UNEXPECTED_MSG; return -1;
             }
             emcioStatus.tool.toolInSpindle = tdata.toolno;
+            emcioStatus.tool.toolFromPocket = *(iocontrol_data->tool_from_pocket) = tdata.pocketno;
+        }
+        if (emcioStatus.tool.toolInSpindle == 0) {
+             emcioStatus.tool.toolFromPocket =  *(iocontrol_data->tool_from_pocket) = 0;
         }
         *(iocontrol_data->tool_number) = emcioStatus.tool.toolInSpindle; //likewise in HAL
         load_tool(emcioStatus.tool.pocketPrepped);
@@ -1030,6 +1047,9 @@ int main(int argc, char *argv[])
                      , emcioStatus.tool.toolInSpindle, idx, tdata.toolno);
                 //likewise in HAL
                 *(iocontrol_data->tool_number) = emcioStatus.tool.toolInSpindle;
+                if (emcioStatus.tool.toolInSpindle == 0) {
+                    emcioStatus.tool.toolFromPocket =  *(iocontrol_data->tool_from_pocket) = 0; // no tool in spindle
+                }
             }
             break;
 

src/emc/nml_intf/emc.cc

@@ -901,6 +901,7 @@ void EMC_TOOL_STAT::update(CMS * cms)
     EMC_TOOL_STAT_MSG::update(cms);
     cms->update(pocketPrepped); // idx
     cms->update(toolInSpindle);
+    cms->update(toolFromPocket);
 #ifdef TOOL_NML //{
     for (int i_toolTable = 0; i_toolTable < CANON_POCKETS_MAX; i_toolTable++)
 	CANON_TOOL_TABLE_update(cms, &(toolTable[i_toolTable]));

src/emc/nml_intf/emc_nml.hh

@@ -1666,6 +1666,7 @@ class EMC_TOOL_STAT:public EMC_TOOL_STAT_MSG {
 
     int pocketPrepped;		// idx ready for loading from
     int toolInSpindle;		// tool loaded, 0 is no tool
+    int toolFromPocket;     // tool was loaded from this pocket
 #ifdef TOOL_NML //{
     CANON_TOOL_TABLE toolTable[CANON_POCKETS_MAX];
 #else //}{

src/emc/nml_intf/emcops.cc

@@ -157,6 +157,7 @@ EMC_TOOL_STAT_MSG(EMC_TOOL_STAT_TYPE, sizeof(EMC_TOOL_STAT))
 {
     pocketPrepped = 0; // idx
     toolInSpindle = 0; // toolno
+    toolFromPocket = 0; // tool_from_pocket
 #ifdef TOOL_NML //{
     int idx;
     for (idx = 0; idx < CANON_POCKETS_MAX; idx++) {
@@ -206,6 +207,7 @@ EMC_TOOL_STAT EMC_TOOL_STAT::operator =(EMC_TOOL_STAT s)
 {
     pocketPrepped = s.pocketPrepped; // idx
     toolInSpindle = s.toolInSpindle; // toolno
+    toolFromPocket = s.toolFromPocket; // tool_from_pocket
 
 #ifdef TOOL_NML //{
     int idx;

src/emc/usr_intf/axis/extensions/emcmodule.cc

@@ -400,6 +400,10 @@ static PyMemberDef Stat_members[] = {
     {(char*)"tool_in_spindle", T_INT, O(io.tool.toolInSpindle), READONLY,
         (char*)"The tool number of the currently loaded tool, or 0 if no tool is loaded."
     },
+    {(char*)"tool_from_pocket", T_INT, O(io.tool.toolFromPocket), READONLY,
+        (char*)"The pocket number that the currently loaded tool was retrieved from,\n"
+        "or 0 if no tool is loaded."
+    },
 
 // EMC_COOLANT_STAT io.cooland
     {(char*)"mist", T_INT, O(io.coolant.mist), READONLY},

tests/toolchanger/m61/mod_core_sim.hal

@@ -57,4 +57,5 @@ net tool-changed => iocontrol.0.tool-changed
 net tool-number <= iocontrol.0.tool-number
 net tool-prep-number <= iocontrol.0.tool-prep-number
 net tool-prep-pocket <= iocontrol.0.tool-prep-pocket
+net tool-from-pocket <= iocontrol.0.tool-from-pocket
 

tests/toolchanger/m61/postgui.hal

@@ -8,4 +8,5 @@ net tool-changed <= python-ui.tool-changed
 net tool-number => python-ui.tool-number
 net tool-prep-number => python-ui.tool-prep-number
 net tool-prep-pocket => python-ui.tool-prep-pocket
+net tool-from-pocket => python-ui.tool-from-pocket
 

tests/toolchanger/m61/test-ui.py

@@ -128,6 +128,7 @@ def do_tool_change_handshake(tool_number, pocket_number):
 h.newpin("tool-number", hal.HAL_S32, hal.HAL_IN)
 h.newpin("tool-prep-number", hal.HAL_S32, hal.HAL_IN)
 h.newpin("tool-prep-pocket", hal.HAL_S32, hal.HAL_IN)
+h.newpin("tool-from-pocket", hal.HAL_S32, hal.HAL_IN)
 
 h.newpin("tool-prepare", hal.HAL_BIT, hal.HAL_IN)
 h.newpin("tool-prepared", hal.HAL_BIT, hal.HAL_OUT)
@@ -230,7 +231,8 @@ def do_tool_change_handshake(tool_number, pocket_number):
         'tool-change': 0,
         'tool-prep-number': 0,
         'tool-prep-pocket': 0,
-        'tool-prepare': 0
+        'tool-prepare': 0,
+        'tool-from-pocket': 1
     },
     duration=1
 )