ioports.h

Go to the documentation of this file.

/*
  ioports.h - typedefs, API structure and functions for auxiliary I/O
 
  Part of grblHAL
 
  Copyright (c) 2021-2025 Terje Io
 
  grblHAL is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  grblHAL is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with grblHAL. If not, see <http://www.gnu.org/licenses/>.
*/
 
#pragma once
 
//#define IOPORTS_KEEP_DEPRECATED
 
#define IOPORT_UNASSIGNED 255
 
typedef enum {
    Port_Analog = 0,    
    Port_Digital = 1    
} io_port_type_t;
 
typedef enum {
    Port_Input = 0,    
    Port_Output = 1    
} io_port_direction_t;
 
typedef void (*digital_out_ptr)(uint8_t port, bool on);
 
typedef bool (*analog_out_ptr)(uint8_t port, float value);
 
typedef int32_t (*wait_on_input_ptr)(io_port_type_t type, uint8_t port, wait_mode_t wait_mode, float timeout);
 
typedef int32_t (*ll_wait_on_input_ptr)(uint8_t port, wait_mode_t wait_mode, float timeout);
 
 
typedef void (*set_pin_description_ptr)(io_port_type_t type, io_port_direction_t dir, uint8_t port, const char *s);
 
typedef void (*ll_set_pin_description_ptr)(io_port_direction_t dir, uint8_t port, const char *s);
 
typedef xbar_t *(*get_pin_info_ptr)(io_port_type_t type, io_port_direction_t dir, uint8_t port);
 
typedef xbar_t *(*ll_get_pin_info_ptr)(io_port_direction_t dir, uint8_t port);
 
typedef bool (*claim_port_ptr)(io_port_type_t type, io_port_direction_t dir, uint8_t *port, const char *description);
 
typedef bool (*ll_claim_port_ptr)(io_port_direction_t dir, uint8_t port, uint8_t user_port, const char *description);
 
 
typedef bool (*swap_pins_ptr)(io_port_type_t type, io_port_direction_t dir, uint8_t port_from, uint8_t port_to);
 
typedef void (*ioport_interrupt_callback_ptr)(uint8_t port, bool state);
 
typedef bool (*ioport_register_interrupt_handler_ptr)(uint8_t port, pin_irq_mode_t irq_mode, ioport_interrupt_callback_ptr interrupt_callback);
 
typedef bool (*ll_ioport_register_interrupt_handler_ptr)(uint8_t port, uint8_t user_port, pin_irq_mode_t irq_mode, ioport_interrupt_callback_ptr interrupt_callback);
 
typedef bool (*ioports_enumerate_callback_ptr)(xbar_t *properties, uint8_t port, void *data);
 
typedef struct {
    uint8_t num_digital_in;                         
    uint8_t num_digital_out;                        
    uint8_t num_analog_in;                          
    uint8_t num_analog_out;                         
    digital_out_ptr digital_out;                    
    analog_out_ptr analog_out;                      
    wait_on_input_ptr wait_on_input;                
    set_pin_description_ptr set_pin_description;    
    get_pin_info_ptr get_pin_info;                  
    claim_port_ptr claim;                           
    swap_pins_ptr swap_pins;                        
    ioport_register_interrupt_handler_ptr register_interrupt_handler;
} io_port_t;
 
typedef union {
    control_signals_t *control;
    coolant_state_t *coolant;
    limit_signals_t *limits;
} driver_caps_t __attribute__ ((__transparent_union__));
 
typedef union {
    uint8_t io;
    struct {
        uint8_t claim_explicit :1,
                digital_out    :1,
                analog_out     :1,
                wait_on_input  :1,
                configure      :1;
    };
} io_port_cando_t;
 
uint8_t ioports_available (io_port_type_t type, io_port_direction_t dir);
uint8_t ioports_unclaimed (io_port_type_t type, io_port_direction_t dir);
xbar_t *ioport_get_info (io_port_type_t type, io_port_direction_t dir, uint8_t port);
xbar_t *ioport_claim (io_port_type_t type, io_port_direction_t dir, uint8_t *port, const char *description);
io_port_cando_t ioports_can_do (void);
uint8_t ioport_find_free (io_port_type_t type, io_port_direction_t dir, pin_cap_t filter, const char *description);
bool ioports_enumerate (io_port_type_t type, io_port_direction_t dir, pin_cap_t filter, ioports_enumerate_callback_ptr callback, void *data);
bool ioport_set_description (io_port_type_t type, io_port_direction_t dir, uint8_t port, const char *description);
bool ioport_set_function (xbar_t *pin, pin_function_t function, driver_caps_t caps);
bool ioport_analog_out (uint8_t port, float value);
bool ioport_digital_out (uint8_t port, uint32_t value);
int32_t ioport_wait_on_input (io_port_type_t type, uint8_t port, wait_mode_t wait_mode, float timeout);
bool ioport_analog_out_config (uint8_t port, pwm_config_t *config);
bool ioport_digital_pwm_config (uint8_t port, pwm_config_t *config);
bool ioport_digital_in_config (uint8_t port, gpio_in_config_t *config);
bool ioport_enable_irq (uint8_t port, pin_irq_mode_t irq_mode, ioport_interrupt_callback_ptr handler);
bool ioport_digital_out_config (uint8_t port, gpio_out_config_t *config);
 
struct io_ports_data;
 
typedef struct {
    uint8_t n_ports;
    uint8_t n_start;
    uint8_t idx_last;
#ifdef IOPORTS_KEEP_DEPRECATED
    uint8_t *map;               
#endif
} io_ports_detail_t;
 
typedef struct io_ports_data {
    union {
        io_ports_detail_t cfg[2];
        struct {
            io_ports_detail_t in;
            io_ports_detail_t out;
        };
    };
#ifdef IOPORTS_KEEP_DEPRECATED
    const char *pnum;                                                  
    const char *(*get_pnum)(struct io_ports_data *data, uint8_t port); 
#endif
} io_ports_data_t;
 
typedef struct {
    io_ports_data_t *ports;
    analog_out_ptr analog_out;                         
    ll_wait_on_input_ptr wait_on_input;                
    ll_set_pin_description_ptr set_pin_description;    
    ll_get_pin_info_ptr get_pin_info;                  
} io_analog_t;
 
typedef struct {
    io_ports_data_t *ports;
    digital_out_ptr digital_out;                       
    ll_ioport_register_interrupt_handler_ptr register_interrupt_handler;
    ll_wait_on_input_ptr wait_on_input;                
    ll_set_pin_description_ptr set_pin_description;    
    ll_get_pin_info_ptr get_pin_info;                  
} io_digital_t;
 
typedef struct {
    uint32_t f_clock;
    uint_fast16_t period;
    uint_fast16_t off_value;    
    uint_fast16_t min_value;
    uint_fast16_t max_value;
    float min;                  
    float pwm_gradient;
    bool invert_pwm;            
    bool always_on;
} ioports_pwm_t;
 
bool ioports_add_analog (io_analog_t *ports);
bool ioports_add_digital (io_digital_t *ports);
void ioports_add_settings (driver_settings_load_ptr settings_loaded, setting_changed_ptr setting_changed);
void ioport_save_input_settings (xbar_t *xbar, gpio_in_config_t *config);
void ioport_save_output_settings (xbar_t *xbar, gpio_out_config_t *config);
void ioport_setting_changed (setting_id_t id);
uint8_t ioports_map_reverse (io_ports_detail_t *type, uint8_t port);
bool ioports_precompute_pwm_values (pwm_config_t *config, ioports_pwm_t *pwm_data, uint32_t clock_hz);
uint_fast16_t ioports_compute_pwm_value (ioports_pwm_t *pwm_data, float value);
#ifdef IOPORTS_KEEP_DEPRECATED
#define iports_get_pnum(type, port) type.get_pnum(&type, port)
#define ioports_map(type, port) ( type.map ? type.map[port] : port )
#endif
 
//
bool ioports_add (io_ports_data_t *ports, io_port_type_t type, uint8_t n_in, uint8_t n_out); 
bool ioport_can_claim_explicit (void);                                                       
void ioport_assign_function (aux_ctrl_t *aux_ctrl, pin_function_t *function);                
void ioport_assign_out_function (aux_ctrl_out_t *aux_ctrl, pin_function_t *function);        
//
 
/*EOF*/