MODBUS IO plugin

[risototh]

Hi, I'm currently developing a "generic" MODBUS I/O plugin. My intention is to be able to connect virtually any MODBUS I/O board to expand the I/Os. For now, I want to use it for controlling solenoids for my ATC (hope that I will use it with the ATC macros...). I have some early implementation at https://github.com/risototh/grblHAL-modbus-io and I want to ask, what M-code should I use? I reviewed the Marlin G/M-code list, and there is nothing similar... Any idea @terjeio ?

[terjeio]

M62-M68
Ideally hook your code into the ioPorts HAL - this way M62-M68 wil be available and all plugins requiring aux I/O will have low level access.
Currently you have to redirect the ioPorts function pointers if the board map alreday provides for aux I/O. Longer term my plan is to allow more than one simultaneous implementation by means of registering with the core.

[risototh]

I have seen these, but that will require a looooot more work, and I'm pretty sure, that I'm not that skilled to do this. At least for now...
Now I only need some two free M-codes and I need to know, how to make a pull request to the core to put there the init code, one error code and the m codes. I forked the core repo and made some of the changes, but currently all is bound to UserMCode_Generic1 and UserMCode_Generic2.

[terjeio]

Here is a skeleton where you can integrate your code, the port_data array is used for both inputs and outputs (for testing), replace writing/reading with your own code.

#include "grbl/hal.h"

#include <string.h>

#define N_PORTS 2

bool port_data[N_PORTS];
static char *pn[] = { "P0", "P1", "P2", "P3", "P5", "P6", "P7", "P8", "P9", "P10", "P11", "P12" };

io_port_t ioport;

static enumerate_pins_ptr on_enumerate_pins;

// Adds to $pins output
static void enumerate_pins (bool low_level, pin_info_ptr pin_info, void *data)
{
    on_enumerate_pins(low_level, pin_info, data);

    static xbar_t pin = {0};

    uint8_t i, id = 0;

    pin.mode.input = On;

    for(i = 0; i < N_PORTS; i++) {
        pin.id = id++;
        pin.pin = i;
        pin.function = (pin_function_t)(Input_Aux0 + ioport.num_digital_in + i);
        pin.group = PinGroup_AuxInput;
        pin.port =  low_level ? NULL : (void *)"My input";
        pin.description = pn[i + hal.port.num_digital_in - N_PORTS - 1];
        pin_info(&pin, data);
    };

    pin.mode.input = Off;
    pin.mode.output = On;

    for(i = 0; i < N_PORTS; i++) {
        pin.id = id++;
        pin.pin = i;
        pin.function = (pin_function_t)(Output_Aux0 + ioport.num_digital_out + i);
        pin.group = PinGroup_AuxOutput;
        pin.port = low_level ? NULL : (void *)"My output";
        pin.description =  pn[i + hal.port.num_digital_out - N_PORTS - 1];
        pin_info(&pin, data);
    };
}


static void digital_out (uint8_t port, bool on)
{
    if(port >= hal.port.num_digital_out - N_PORTS)
        port_data[port - (hal.port.num_digital_out - N_PORTS)] = on;
    else
        ioport.digital_out(port, on);
}

static int32_t wait_on_input (io_port_type_t type, uint8_t port, wait_mode_t wait_mode, float timeout)
{
    int32_t value = -1;

    if(type == Port_Digital && port >= hal.port.num_digital_in - N_PORTS)
        value = port_data[port - (hal.port.num_digital_in - N_PORTS)];
    else
        value = ioport.wait_on_input(type, port, wait_mode, timeout);

    return value;
}

static xbar_t *get_pin_info (io_port_type_t type, io_port_direction_t dir, uint8_t port)
{
    static xbar_t pin;

    xbar_t *info = NULL;

    if(type == Port_Digital) {

        if(dir == Port_Input) {
            if(port >= ioport.num_digital_in) {
                pin.id = port;
                pin.cap.input = On;
                pin.cap.claimable = Off;
                pin.function = (pin_function_t)(Input_Aux0 + port);
                pin.group = PinGroup_AuxInput;
                pin.description = pn[(port - ioport.num_digital_in) + hal.port.num_digital_in - N_PORTS - 1];
                info = &pin;
            } else
                info = ioport.get_pin_info(type, dir, port);
        }

        if(dir == Port_Output) {
            if(port >= ioport.num_digital_out) {
                pin.id = port;
                pin.cap.output = On;
                pin.cap.claimable = Off;
                pin.function = (pin_function_t)(Output_Aux0 + port);
                pin.group = PinGroup_AuxOutput;
                pin.description =  pn[(port - ioport.num_digital_out) + hal.port.num_digital_out - N_PORTS - 1];
                info = &pin;
            } else
                info = ioport.get_pin_info(type, dir, port);
        }
    } else
        info = ioport.get_pin_info(type, dir, port);

    return info;
}

void my_plugin_init (void)
{
    memcpy(&ioport, &hal.port, sizeof(io_port_t));

    hal.port.num_digital_in += N_PORTS;
    hal.port.num_digital_out += N_PORTS;

    hal.port.digital_out = digital_out;
    hal.port.wait_on_input = wait_on_input;
    hal.port.get_pin_info = get_pin_info;

    ioport.num_digital_in = ioports_available(Port_Digital, Port_Input) - N_PORTS;
    ioport.num_digital_out = ioports_available(Port_Digital, Port_Output) - N_PORTS;

    on_enumerate_pins = hal.enumerate_pins;
    hal.enumerate_pins = enumerate_pins;
}

If you still want new M-codes pick from the user defined ones or just add some in your code and cast them as I am not going to allocate new M-codes for generic I/O in the core.

[risototh]

Thank you for the mockup, but for now I preffer my approach, which does not require recompilation and reflashing with each new I/O port/device/pin... I think, that this approach is much more flexible, at least for me.